Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/dill/__pycache__/session.cpython-39.pyc
Ðазад
a h�h�[ � @ s� d Z g d�ZddlZddlZddlZddlZddlZddlZe�e� � �Z ddl m Z m Z ddlmZmZmZ ddlmZmZmZmZmZmZmZmZmZmZm Z m Z dd � Z eeeeefZ d ev r�e ed f7 Z d Z e!d d � e D ��Z dd� Z"dd� Z#dd� Z$d)e e%ej&f e e ee%f e'dd�dd�Z(d*dd�Z)e(j e)_ G dd� d�Z*d d � Z+d+d d �Z,d,e e%ej&f e e ee%f e e d �d!d"�Z-d-d#d$�Z.e-j e._ d.e e%ej&f e'e/d%�d&d'�Z0d(D ]Z1e2ee1e3� e1 � �q�[1dS )/z, Pickle and restore the intepreter session. )� dump_module� load_module�load_module_asdict� dump_session� load_session� N)�Optional�Union)�_dill�Pickler� Unpickler� ) �BuiltinMethodType� FunctionType� MethodType� ModuleType�TypeType�_import_module�_is_builtin_module�_is_imported_module� _main_module�_reverse_typemap� __builtin__�UnpicklingErrorc C s� ddl m} ddlm} || t�| t�i d�}tj�� D ]t\}}|dv s8t|t �sTq8d|vrj||j t |�< |j �� D ]6\}}|j | �||f� |jt |� �|||f� qtq8|S )zget map of imported modulesr )� defaultdict)�SimpleNamespace)�by_name�by_id� top_level)�__main__� __mp_main__�.)� collectionsr �typesr �list�sys�modules�items� isinstancer r �id�__dict__r �appendr )r r �modmap�modname�module�objname�modobj� r0 �|/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/dill/session.py� _module_map% s � r2 Z PyCapsuleType)�ctypes�typing� subprocess� threadingzconcurrent\.futures(\.\w+)?zmultiprocessing(\.\w+)?c c s | ]}t �|�V qd S �N)�re�compile)�.0�xr0 r0 r1 � <genexpr>= � r< c s� | j | D ]*\}}||u r tj| |ur ||f S q t|dd�� t|t�sj� dur�t� fdd�tD ��r�| jt |� D ]$\}}}tj| |urx||f S qxdS )z.lookup name or id of obj if module is imported� __module__Nc 3 s | ]}|� � �V qd S r7 )� fullmatch)r: �regex�r> r0 r1 r< F r= z!_lookup_module.<locals>.<genexpr>)NN) r r$ r% �getattrr' �IMPORTED_AS_TYPES�any�IMPORTED_AS_MODULESr r( )r+ �name�obj� main_moduler/ r, r. r0 rA r1 �_lookup_module? s �rI c sl t � }t| j�}g }g }g }i }| j�� D ]�\}� � | u rD|||< q*� | ju rZ|j||< q*t� fdd�dD ��s�t� t�r�t� �r�� ||< q*t||� | �\}} |d ur�| |kr�|� ||f� n|� || |f� q*z |� |j t � � |f� W q* t �y � ||< Y q*0 q*t |�t | j�k �rd|j�|� ||_||_||_t|dd �d u �r`t| ��r`d|_|S | S d S )Nc 3 s | ]}� |u V qd S r7 r0 )r: Z singleton�rG r0 r1 r< Z r= z!_stash_modules.<locals>.<genexpr>)NFT� __loader__T)r2 r �__name__r) r& rD r' r rI r* r r( �KeyError�len�update�__dill_imported�__dill_imported_as�__dill_imported_top_levelrB r rK ) rH r+ �newmodZimportedZ imported_asZimported_top_level�originalrF Z source_moduler. r0 rJ r1 �_stash_modulesL sF �� rU c C s� zz|j �d�D ]\}}| �||�|j |< q|j �d�D ] \}}}| �||�|j |< q6|j �d�D ]\}}t|�|j |< q`W n ty� Y n0 d S )NrP rQ rR )r) �pop� find_class� __import__rM )� unpicklerrH r, rF r. r0 r0 r1 �_restore_modulesv s rZ F)�filenamer- � refimported�returnc K sz dD ]V\}}||v rd||f }|dkr0|d7 }t �|d t� t� | rtd||f ��q|�d|�}|�d|�}dd lm} |d }|} | d u r�t} nt| t �r�t | �} t| t �s�td | ��t | d �r�| } n | d u r�t t d �} t| d�} zpt| |fi |��} | | _|�rt| �} | | _d| _d| _d| _d| _| | ju| _| �| � W | | u�rv| �� n| | u�rt| �� 0 d S )a� Pickle the current state of :py:mod:`__main__` or another module to a file. Save the contents of :py:mod:`__main__` (e.g. from an interactive interpreter session), an imported module, or a module-type object (e.g. built with :py:class:`~types.ModuleType`), to a file. The pickled module can then be restored with the function :py:func:`load_module`. Args: filename: a path-like object or a writable stream. If `None` (the default), write to a named file in a temporary directory. module: a module object or the name of an importable module. If `None` (the default), :py:mod:`__main__` is saved. refimported: if `True`, all objects identified as having been imported into the module's namespace are saved by reference. *Note:* this is similar but independent from ``dill.settings[`byref`]``, as ``refimported`` refers to virtually all imported objects, while ``byref`` only affects select objects. **kwds: extra keyword arguments passed to :py:class:`Pickler()`. Raises: :py:exc:`PicklingError`: if pickling fails. Examples: - Save current interpreter session state: >>> 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- )�byrefr\ z#The argument %r has been renamed %rr_ z. to distinguish it from dill.settings['byref']r z"both %r and %r arguments were usedr^ r )�settings�protocolN�%r is not a module�write� session.pkl�wbFT)�warnings�warn�PendingDeprecationWarning�locals� TypeErrorrV r` r r' �strr r �hasattr�TEMPDIR�openr Z_original_mainrU �_mainZ_byrefZ_recurse�_sessionZ _first_passZ_main_modified�dump�close) r[ r- r\ �kwdsZold_parZpar�messager` ra r^ �fileZpicklerr0 r0 r1 r � sR Z � r c K s& t �dt� t| f||d�|�� d S )Nz-dump_session() has been renamed dump_module())r- r\ )rf rg rh r )r[ r^ r_ rs r0 r0 r1 r s r c @ s@ e Zd ZdZdd� Zdd� Zdd� Zdd � Zd d � Zd d � Z dS )�_PeekableReaderz1lightweight stream wrapper that implements peek()c C s || _ d S r7 )�stream)�selfrw r0 r0 r1 �__init__ s z_PeekableReader.__init__c C s | j �|�S r7 )rw �read)rx �nr0 r0 r1 rz s z_PeekableReader.readc C s | j �� S r7 )rw �readline�rx r0 r0 r1 r| s z_PeekableReader.readlinec C s | j �� S r7 )rw �tellr} r0 r0 r1 r~ s z_PeekableReader.tellc C s | j �� S r7 )rw rr r} r0 r0 r1 rr s z_PeekableReader.closec C sl | j }z>t|d�r|�� |�� }|�|� |�|�}|�|� |W S ttfyf td|�d �Y n0 d S )N�flushzstream is not peekable: %r) rw rl r r~ �seekrz �AttributeError�OSError�NotImplementedError)rx r{ rw �position�chunkr0 r0 r1 �peek s z_PeekableReader.peekN) rL r> � __qualname__�__doc__ry rz r| r~ rr r� r0 r0 r0 r1 rv s rv c C sR ddl }t| d�r| S t| d�r*t| d�sJz |�| �W S tyH Y n0 t| �S )z/return stream as an object with a peek() methodr Nr� r~ r� )�iorl �BufferedReader� Exceptionrv )rw r� r0 r0 r1 �_make_peekable% s r� c C s� ddl m} h d�}d}zX|| �d��D ]<\}}}|sP|jdv rd|�d�rdd}q(|j|v r(| W S q(td ��W nR ttfy� } z6t|t�r�|d ur�W Y d }~d S td �|�W Y d }~n d }~0 0 d S ) zDidentify the name of the module stored in the given file-type objectr )�genops> �SHORT_BINUNICODE� BINUNICODE�UNICODEF� )�GLOBALr� r Tz(reached STOP without finding main moduleNz unable to identify main module) Z pickletoolsr� r� rF �endswithr r� � ValueErrorr' ) ru r^ r� r� Z found_import�opcode�arg�pos�errorr0 r0 r1 �_identify_module1 s" � r� )r[ r- r] c K s� d|v r.t �dt� |dur$td��|�d�}|}t| d�rB| }n | du rVttd �} t| d�}�z�t |�}t |fi |��}d|_ t ||�}|du r�|dur�|}t |t�r�|�d �r�t|�d �d �}nt|�}|dur�t |t�s�td | ��||_n|j}t|�}|du�r�|�d �}|�r,|�d �d }d } |�rZ|�rZt| �dddd�|j|f ��|�s�|�s�t| �dddd�||jf ��|j|k�r�t| �dddd�|j|f ��|�s�d|j } |tj| < |�� } W t| d��s�|�� z tj| = W n tt f�y Y n0 n<t| d��s"|�� z tj| = W n tt f�yF Y n0 0 | |u �sXJ �t ||� |t u �sv||u �rzdS |S dS )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. r^ z.The argument 'main' has been renamed 'module'.Nz,both 'module' and 'main' arguments were usedrz rd �rbTz __runtime__.r ���rb z@can't update{} module{} %r with the saved state of{} module{} %rz imported� z -type objectz__runtime__.%s) rf rg rh rj rV rl rk rm rn r� r rp r� r' � startswithr � partitionr ro r r� �formatrL r$ r% �loadrr rM � NameErrorrZ r ) r[ r- rs r^ ru rY Z pickle_mainZis_main_importedZis_runtime_mod� error_msgZ runtime_mainZloadedr0 r0 r1 r H s� f� �� �� � r c K s$ t �dt� t| fd|i|�� d S )Nz.load_session() has been renamed load_module().r- )rf rg rh r )r[ r^ rs r0 r0 r1 r � s r )r[ rO r] c K sP d|v rt d��t| d�r | }n | du r4ttd �} t| d�}z�t|�}t|�}tj� |�}t |�}|r�|du rxt |�}|j � |j � nt|_|tj|< t|fi |�� W t| d�s�|�� z |du r�tj|= n |tj|< W n ty� Y n0 nNt| d��s|�� z"|du �r tj|= n |tj|< W n t�y< Y n0 0 t| �|_|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()rz Nrd r� )rj rl rk rm rn r� r� r$ r% �getr r r) rO r � __builtins__r rr r� Z __session__)r[ rO rs ru � main_nameZold_mainr^ r0 r0 r1 r sJ 8 � r )rI r2 rZ rU r r )NNF)NNF)N)NN)NN)NF)4r� �__all__r8 �osr$ rf �pathlib�tempfile�PurePath� gettempdirrm r4 r r Zdillr r r r r r r r r r r r r r r r2 rC rE �tuplerI rU rZ rk �PathLike�boolr r rv r� r� r r �dictr rF �setattr�globalsr0 r0 r0 r1 �<module> sn 8 * � � � � 6 � � ]
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка