{ K | ]}t j | V d S N)recompile).0xs r1 r? > s* GGaBJqMMGGGGGGr3 c p | j | D ]#\ }}||u rt j | |ur||fc S $t |dd t |t
s"[t
fdt D r;| j t | D ] \ }}}t j | |ur||fc S !dS )z.lookup name or id of obj if module is imported
__module__Nc 3 B K | ]}| V d S r: ) fullmatch)r= regexrA s r1 r? z!_lookup_module..G s/ QQEEOOJ//QQQQQQr3 NN)
r r% r& getattrr( IMPORTED_AS_TYPESanyIMPORTED_AS_MODULESr r) )r, nameobj main_moduler0 r- r/ rA s @r1 _lookup_modulerM @ s !>$/ ! ! S==S[ 1 D DD= lD11J#()) (j.DQQQQ=PQQQQQ /E(. RWW(= ( ( $FGW{7#;66 '''' 7 :r3 c
t }t | j }g }g }g }i }| j D ]\ }
| u r|||<
| j u r |j ||< #t
fddD s$t
t rt
r
||< ht ||
| \ }} |7| |k r| ||f | || |f | |j
t
|f # t $ r
||< Y w xY wt | t | j k rX|j | ||_ ||_ ||_ t% |dd t' | rd|_ |S | S )Nc 3 K | ]}|u V d S r: )r= singletonrK s r1 r? z!_stash_modules..[ s( GGi !GGGGGGr3 )NFT
__loader__T)r2 r __name__r* r' rH r( r rM r+ r r) KeyErrorlenupdate__dill_imported__dill_imported_as__dill_imported_top_levelrF r rR ) rL r, newmodimported imported_asimported_top_leveloriginalrJ
source_moduler/ rK s @r1 _stash_modulesr` M s
]]F
,
-
-FHKH )//11 ) ) c + #HTNN
K(
(
( #_HTNN
GGGG3FGGG
G
G ) c:.. )3Ec3J3J ) HTNN%3FD#{%S%S "M7 (d?? OO]D$9:::: &&
w'EFFFF)&--v/?3/H$.OPPPP ) ) )%(HTNNN) 8}}s;/0000 x(((!) $/!+=( 6< . . 6;N{;[;[ 6 $F
s =D>c |j d D ]#\ }}| || |j |< $|j d D ]$\ }}}| || |j |< %|j d D ] \ }}t | |j |< d S # t $ r Y d S w xY w)NrW rX rY )r* pop
find_class
__import__rT ) unpicklerrL r- rJ r/ s r1 _restore_modulesrf w s
( 1 5 56G H H M MMGT)2)=)=gt)L)LK & &&1&:&>&>?S&T&T P P "GWd)2)=)=gw)O)OK & & ( 1 5 56Q R R = =MGT)3G)<)>> import dill
>>> squared = lambda x: x*x
>>> dill.dump_module() # save state of __main__ to /tmp/session.pkl
- Save the state of an imported/importable module:
>>> import dill
>>> import pox
>>> pox.plus_one = lambda x: x+1
>>> dill.dump_module('pox_session.pkl', module=pox)
- Save the state of a non-importable, module-type object:
>>> import dill
>>> from types import ModuleType
>>> foo = ModuleType('foo')
>>> foo.values = [1,2,3]
>>> import math
>>> foo.sin = math.sin
>>> dill.dump_module('foo_session.pkl', module=foo, refimported=True)
- Restore the state of the saved modules:
>>> import dill
>>> dill.load_module()
>>> squared(2)
4
>>> pox = dill.load_module('pox_session.pkl')
>>> pox.plus_one(1)
2
>>> foo = dill.load_module('foo_session.pkl')
>>> [foo.sin(x) for x in foo.values]
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672]
- Use `refimported` to save imported objects by reference:
>>> import dill
>>> from html.entities import html5
>>> type(html5), len(html5)
(dict, 2231)
>>> import io
>>> buf = io.BytesIO()
>>> dill.dump_module(buf) # saves __main__, with html5 saved by value
>>> len(buf.getvalue()) # pickle size in bytes
71665
>>> buf = io.BytesIO()
>>> dill.dump_module(buf, refimported=True) # html5 saved by reference
>>> len(buf.getvalue())
438
*Changed in version 0.3.6:* Function ``dump_session()`` was renamed to
``dump_module()``. Parameters ``main`` and ``byref`` were renamed to
``module`` and ``refimported``, respectively.
Note:
Currently, ``dill.settings['byref']`` and ``dill.settings['recurse']``
don't apply to this function.
))mainr. )byrefrh z
The argument z has been renamed rl z. to distinguish it from dill.settings['byref']r! zboth z and z arguments were usedrk r )settingsprotocolN%r is not a modulewrite session.pklwbFT)warningswarnPendingDeprecationWarninglocals TypeErrorrb rm r r( strr r hasattrTEMPDIRopenr _original_mainr` _main_byref_recurse_session _first_pass_main_modifieddumpclose) rg r. rh kwdsold_parparmessagerm rn rk filepicklers r1 r r s. t G W W d????FwwLG'!!KK M'C-)B C C Cxx}
W iWWW UVVV((7K00K
XXff
%
%F""""""
#H D | D# $ d## dJ ' ' 5,t3444x!! $ 7=011HHd##$11D11!% (!$''D
"!%W-C!C T x JJLLL x JJLLLL
Fs
5A,F: :Gc Z t j dt t | f||d| d S )Nz-dump_session() has been renamed dump_module())r. rh )rs rt ru r )rg rk rl r s r1 r r s9 MAC\]]]A5AADAAAAAr3 c 6 e Zd ZdZd Zd Zd Zd Zd Zd Z dS ) _PeekableReaderz1lightweight stream wrapper that implements peek()c || _ d S r: )stream)selfr s r1 __init__z_PeekableReader.__init__ s
r3 c 6 | j | S r: )r read)r ns r1 r z_PeekableReader.read s { """r3 c 4 | j S r: )r readliner s r1 r z_PeekableReader.readline s {##%%%r3 c 4 | j S r: )r tellr s r1 r z_PeekableReader.tell s { !!!r3 c 4 | j S r: )r r r s r1 r z_PeekableReader.close s { """r3 c P | j } t |d r| | }| | | | }| | |S # t t f$ r t d| d w xY w)Nflushzstream is not peekable: %r) r ry r r seekr AttributeErrorOSErrorNotImplementedError)r r r positionchunks r1 peekz_PeekableReader.peek s Vvw'' 7 {{}}H KK ! ! !KKNNE KK ! ! !L ( V V V%&BFKKQU U Vs A8B #B%N)
rS rA __qualname____doc__r r r r r r rP r3 r1 r r sy ;; # # #& & &" " "# # #
V
V
V
V
Vr3 r c ddl }t | d r| S t | d rt | d s& | | S # t $ r Y nw xY wt | S )z/return stream as an object with a peek() methodr Nr r r )iory BufferedReader Exceptionr )r r s r1 _make_peekabler & s
IIIvv
FF # # (?(? $$V,, , D 6 " ""s A
AAc p ddl m} h d}d} || d D ]6\ }}}|s!|j dv r| d rd})|j |v r|c S 7t d # t t f$ r2}t |t r|Y d
}~d
S t d |d
}~ww xY w) zDidentify the name of the module stored in the given file-type objectr )genops> UNICODE
BINUNICODESHORT_BINUNICODEF )GLOBALr r Tz(reached STOP without finding main moduleNz unable to identify main module) pickletoolsr r rJ endswithUnpicklingErrorr
ValueErrorr( ) r rk r r found_importopcodeargposerrors r1 _identify_moduler 2 s """""";;;GLK &tyy~~ 6 6 N N FC
;"@@@ %566 A#'L;')) JJJ * ""LMM M , K K K e 0 1 1 d6F44444 >??UJ Ks$ AA2 "A2 2B5B0 B00B5c T d|v r@t j dt |t d | d }|}t | d r| }n)| t
t dz } t | d } t | }t |fi |}d|_ t || }|||}t |t rM| d r)t | d
d }nt# | }|/t |t st d |z ||_ n|j }t' | }|| d }|r| d
d }d
} |r1|r/t) | dddd |j |fz |s1|s/t) | dddd ||j fz |j |k r/t) | dddd |j |fz |sd|j z }
|t. j |
< | } t | d s| t. j |
= ne# t6 t8 f$ r Y nRw xY w# t | d s| t. j |
= w # t6 t8 f$ r Y w w xY wxY w| |u sJ t; || |t< u s||u rdS |S )ag Update the selected module (default is :py:mod:`__main__`) with
the state saved at ``filename``.
Restore a module to the state saved with :py:func:`dump_module`. The
saved module can be :py:mod:`__main__` (e.g. an interpreter session),
an imported module, or a module-type object (e.g. created with
:py:class:`~types.ModuleType`).
When restoring the state of a non-importable module-type object, the
current instance of this module may be passed as the argument ``main``.
Otherwise, a new instance is created with :py:class:`~types.ModuleType`
and returned.
Args:
filename: a path-like object or a readable stream. If `None`
(the default), read from a named file in a temporary directory.
module: a module object or the name of an importable module;
the module name and kind (i.e. imported or non-imported) must
match the name and kind of the module stored at ``filename``.
**kwds: extra keyword arguments passed to :py:class:`Unpickler()`.
Raises:
:py:exc:`UnpicklingError`: if unpickling fails.
:py:exc:`ValueError`: if the argument ``main`` and module saved
at ``filename`` are incompatible.
Returns:
A module object, if the saved module is not :py:mod:`__main__` or
a module instance wasn't provided with the argument ``main``.
Examples:
- Save the state of some modules:
>>> import dill
>>> squared = lambda x: x*x
>>> dill.dump_module() # save state of __main__ to /tmp/session.pkl
>>>
>>> import pox # an imported module
>>> pox.plus_one = lambda x: x+1
>>> dill.dump_module('pox_session.pkl', module=pox)
>>>
>>> from types import ModuleType
>>> foo = ModuleType('foo') # a module-type object
>>> foo.values = [1,2,3]
>>> import math
>>> foo.sin = math.sin
>>> dill.dump_module('foo_session.pkl', module=foo, refimported=True)
- Restore the state of the interpreter:
>>> import dill
>>> dill.load_module() # updates __main__ from /tmp/session.pkl
>>> squared(2)
4
- Load the saved state of an importable module:
>>> import dill
>>> pox = dill.load_module('pox_session.pkl')
>>> pox.plus_one(1)
2
>>> import sys
>>> pox in sys.modules.values()
True
- Load the saved state of a non-importable module-type object:
>>> import dill
>>> foo = dill.load_module('foo_session.pkl')
>>> [foo.sin(x) for x in foo.values]
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672]
>>> import math
>>> foo.sin is math.sin # foo.sin was saved by reference
True
>>> import sys
>>> foo in sys.modules.values()
False
- Update the state of a non-importable module-type object:
>>> import dill
>>> from types import ModuleType
>>> foo = ModuleType('foo')
>>> foo.values = ['a','b']
>>> foo.sin = lambda x: x*x
>>> dill.load_module('foo_session.pkl', module=foo)
>>> [foo.sin(x) for x in foo.values]
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672]
*Changed in version 0.3.6:* Function ``load_session()`` was renamed to
``load_module()``. Parameter ``main`` was renamed to ``module``.
See also:
:py:func:`load_module_asdict` to load the contents of module saved
with :py:func:`dump_module` into a dictionary.
rk z.The argument 'main' has been renamed 'module'.Nz,both 'module' and 'main' arguments were usedr rq rbTz __runtime__.r! ro z@can't update{} module{} %r with the saved state of{} module{} %rz imported z -type objectz__runtime__.%s) rs rt ru rw rb ry rx rz r{ r r
r r r(
startswithr partitionr r} r r formatrS r% r& loadr rT NameErrorrf r ) rg r. r rk r re pickle_mainis_main_importedis_runtime_mod error_msg runtime_mainloadeds r1 r r I s L ~~
< %
JKK K&!! Dx $ 7=011HHd##7 d## d++d++ ! 'tT22 >>>Y%%% |tv~~t sC G'J5
J J21J25%L
K)(L )K=:L <K==L c X t j dt t | fd|i| d S )Nz.load_session() has been renamed load_module().r. )rs rt ru r )rg rk r s r1 r r s7 MBD]^^^........r3 rV c d|v rt d t | d r| }n)| t t dz } t | d } t | }t
| }t j | }t | }|r1|t | }|j
|j n t |_ |t j |< t! |fi | t | d s| |t j |= n|t j |< ni# t$ $ r Y n]w xY w# t | d s| |t j |= w |t j |< w # t$ $ r Y w w xY wxY wt | |_ |j S )ay
Load the contents of a saved module into a dictionary.
``load_module_asdict()`` is the near-equivalent of::
lambda filename: vars(dill.load_module(filename)).copy()
however, does not alter the original module. Also, the path of
the loaded module is stored in the ``__session__`` attribute.
Args:
filename: a path-like object or a readable stream. If `None`
(the default), read from a named file in a temporary directory.
update: if `True`, initialize the dictionary with the current state
of the module prior to loading the state stored at filename.
**kwds: extra keyword arguments passed to :py:class:`Unpickler()`
Raises:
:py:exc:`UnpicklingError`: if unpickling fails
Returns:
A copy of the restored module's dictionary.
Note:
If ``update`` is True, the corresponding module may first be imported
into the current namespace before the saved state is loaded from
filename to the dictionary. Note that any module that is imported into
the current namespace as a side-effect of using ``update`` will not be
modified by loading the saved module in filename to a dictionary.
Example:
>>> import dill
>>> alist = [1, 2, 3]
>>> anum = 42
>>> dill.dump_module()
>>> anum = 0
>>> new_var = 'spam'
>>> main = dill.load_module_asdict()
>>> main['__name__'], main['__session__']
('__main__', '/tmp/session.pkl')
>>> main is globals() # loaded objects don't reference globals
False
>>> main['alist'] == alist
True
>>> main['alist'] is alist # was saved by value
False
>>> main['anum'] == anum # changed after the session was saved
False
>>> new_var in main # would be True if the option 'update' was set
False
r. z@'module' is an invalid keyword argument for load_module_asdict()r Nrq r )rw ry rx rz r{ r r r% r& getr r r* rV r __builtins__r r r __session__)rg rV r r main_nameold_mainrk s r1 r r s p 4Z[[[x $ 7=011HHd## d##$T** ;??9--)$$ , ))44 M !2 3 3 3 3 +D !% I D!!D!!!x(( JJLLL K **)1 I& D x(( JJLLL K **)1 I&& D 8}}D =sO B'E
D= =
E
E
%F#3FF#FF#
F F# F F#)rM r2 rf r` r r )NNFr: rE )NF)3r __all__r; osr% rs dillr r r
r r
r r r r r r r r r r6 r r pathlibtempfilePurePath
gettempdirrz r2 rG rI tuplerM r` rf rx PathLikeboolr r r r r r r dictr rJ setattrglobalsrP r3 r1 r s
* * * * * * * * * * # " " " " " " "
'
.8.00
1
1 & <EVW &&&*?;==[ eGG3FGGGGG ( ( (T
)-/3 C C C$%C U:s?+ ,C C
C C C C LB B B B #* V V V V V V V V0
#
#
#K K K K0 )-/3r rC$%r U:s?+ ,r j r r r rj/ / / / #* )-X XC$%X X
X X X Xz
* *D GE44 ))))DDr3