Sindbad~EG File Manager

Current Path : /usr/src/Python-3.12.7/Python/
Upload File :
Current File : //usr/src/Python-3.12.7/Python/frozen.o

ELF>��@@_frozen_importlibimportlib._bootstrap_frozen_importlib_externalimportlib._bootstrap_externalos.pathposixpath__hello_alias____hello____phello_alias____phello_alias__.spam__phello__.__init__<__phello____phello__.ham.__init__<__phello__.ham__hello_only____phello____phello__.ham__phello__.ham.eggs__phello__.spamabccodecsio_collections_abc_sitebuiltinsgenericpathntpathossitestatimportlib.utilimportlib.machineryrunpyzipimportHHHHJJhhmO�J��ٲhh�D�D+��nG�-�7��,�;^���dZed�y)TzHello world!N)�initialized�print���<frozen frozen_only>�<module>rs�����n�r��(�dZd�Zedk(re�yy)Tc��td�y)NzHello world!)�print���<frozen __phello__.spam>�mainrs
��	�.�r�__main__N)�initializedr�__name__rrr�<module>rs#������z���F�r���y)N�r��<frozen __phello__.ham.eggs>�<module>rs�r���y)N�r��<frozen __phello__.ham>�<module>rs�r��(�dZd�Zedk(re�yy)Tc��td�y)NzHello world!)�print���<frozen __phello__>�mainrs
��	�.�r�__main__N)�initializedr�__name__rrr�<module>rs#������z���F�r��d�dZGd�d�ZGd�d�ZGd�d�Zd�Zedk(re�y	y	)
Tc��eZdZdZy)�TestFrozenUtf8_1�¶N��__name__�
__module__�__qualname__�__doc__���<frozen __hello__>rr���rrc��eZdZdZy)�TestFrozenUtf8_2uπNrr
rrrrr
rrc��eZdZdZy)�TestFrozenUtf8_4u😀Nrr
rrrr	s��rrc��td�y)NzHello world!)�printr
rr�mainrs
��	�.�r�__main__N)�initializedrrrrrr
rr�<module>rsA������������z���F�r���dZddlZddlZddlZddlZddlZddgZee�Z	Gd�de
�ZGd�de
�Z			dd	�Z
			dd
�Zefd�ZGd�d
e�Zdd�Z		dd�Zefd�Zd�Zdd�Zedk(rMeej4�dkredej8��yej4d=eej4d�yy)aZrunpy.py - locating and running Python code using the module namespace

Provides support for locating and running Python scripts using the Python
module namespace instead of the native filesystem.

This allows Python code to play nicely with non-filesystem based PEP 302
importers when locating support scripts as well as when importing modules.
�N�
run_module�run_pathc�"�eZdZdZd�Zd�Zd�Zy)�_TempModulezCTemporarily replace a module in sys.modules with an empty namespacec�@�||_t|�|_g|_y�N)�mod_name�
ModuleType�module�
_saved_module��selfr	s  �<frozen runpy>�__init__z_TempModule.__init__s�� ��
� ��*������c���|j}	|jjtj|�|jtj|<|S#t
$rY�*wxYwr)r	r�append�sys�modules�KeyErrorrr
s  r�	__enter__z_TempModule.__enter__!sZ���=�=��	����%�%�c�k�k�(�&;�<�!%������H������	��	�s�,A�	A%�$A%c���|jr2|jdtj|j<g|_ytj|j=g|_y�Nr)rrrr	�r�argss  r�__exit__z_TempModule.__exit__*sL�����)-�);�);�A�)>�C�K�K��
�
�&� ������D�M�M�*���rN)�__name__�
__module__�__qualname__�__doc__rrr�rrrrs��M� �
� rrc��eZdZd�Zd�Zd�Zy)�_ModifiedArgv0c�>�||_t�x|_|_yr)�value�object�_saved_value�	_sentinel)rr%s  rrz_ModifiedArgv0.__init__2s����
�-3�X�5���D�Nrc��|j|jurtd��tjd|_|j
tjd<y)NzAlready preserving saved valuer)r'r(�RuntimeErrorr�argvr%)rs rrz_ModifiedArgv0.__enter__6sA�����D�N�N�2��?�@�@��H�H�Q�K����j�j�����rc�`�|j|_|jtjd<yr)r(r%r'rr+rs  rrz_ModifiedArgv0.__exit__<s ���^�^��
��'�'�����rN)rrrrrrr!rrr#r#1s��6�!�(rr#c	���|�|j|�|�d}|}d}	n2|j}|j}|j}	|�|j}|j|||	d|||��t||�|S)z)Helper to run code in nominated namespaceN)r�__file__�
__cached__r �
__loader__�__package__�__spec__)�update�loader�origin�cached�parent�exec)
�code�run_globals�init_globalsr	�mod_spec�pkg_name�script_namer4�fnamer6s
          r�	_run_coder@As��������<�(��������������������������H����(�"'�$*�!%�$*�%-�"*�
�,�	��{���rc�.�|�|n|j}t|�5}t|�5|jj}t|||||||�ddd�ddd�j
�S#1swY�!xYw#1swYj
�SxYw)z5Helper to run code in new namespace with sys modifiedN)r5rr#r�__dict__r@�copy)	r9r;r	r<r=r>r?�temp_module�mod_globalss	         r�_run_module_coderF[s���$�+�K����E�	�X�	�+�~�e�/D�!�(�(�1�1���$��\��H�h��	=�0E�	������
0E�/D��	������s"�A<�(A0�A<�0A9	�5A<�<Bc	��|jd�r|d��|jd�\}}}|rc	t|�t
jj|�}|�6t|d�s*ddl	m
}dj||��}|t|��	tjj|�}|�|d|z��|j,�0|dk(s|j'd�r|d��	|dz}
t/|
|�S|j0}|�|d|z��	|j3|�}|�|d|z��|||fS#t$rE}|j�-|j|k7r|j|jdz�s�Yd}~��Fd}~wwxYw#tt t"t$f$rT}	d}|j'd	�r|d
|dd�d|�d
�z
}||j|t)|	�j*|	��|	�d}	~	wwxYw#|$r&}|t
jvr�||�d|�d���d}~wwxYw#t$r}|t|��|�d}~wwxYw)N�.z#Relative module names not supported�__path__r)�warnz�{mod_name!r} found in sys.modules after import of package {pkg_name!r}, but prior to execution of {mod_name!r}; this may result in unpredictable behaviour)r	r=z:Error while finding module specification for {!r} ({}: {})z.pyz
. Try using '���z' instead of 'z' as the module name.zNo module named %s�__main__z	.__main__z%Cannot use package as __main__ modulez; z- is a package and cannot be directly executedz0%r is a namespace package and cannot be executedzNo code object available for %s)�
startswith�
rpartition�
__import__�ImportError�namerr�get�hasattr�warningsrJ�format�RuntimeWarning�	importlib�util�	find_spec�AttributeError�	TypeError�
ValueError�endswith�typer�submodule_search_locations�_get_module_detailsr4�get_code)
r	�errorr=�_�e�existingrJ�msg�spec�ex�
pkg_main_namer4r9s
             rr`r`is������3���9�:�:��(�(��-�N�H�a���	��x� ��;�;�?�?�8�,������*�(E�%��#�F�H�x�F�H�
�
���$�%�
I��~�~�'�'��1���|��(�8�3�4�4��&�&�2��z�!�X�%6�%6�{�%C��?�@�@�	G�$�{�2�M�&�}�e�<�<��[�[�F�
�~��F�CK�L�M�	M�&����x�(���|��5��@�A�A��T�4����g�	��v�v�~�!�&�&�H�"4� �+�+�A�F�F�S�L�9����
	��&
���J�?�I�K�����U�#��m�H�S�b�M�?�3� �z�!6�8�
9�C��C�J�J�x��b��):�):�B�?�@�b�H��I��"�	G��s�{�{�*���9:�H�F�G�
G��	G���&��F�1�I��A�%��&�s`�D:�F�,G;�H)�:	F�:F�F�G8�$AG3�3G8�;H&�!H!�!H&�)	I	�2I�I	c��eZdZdZy)�_ErrorzBError that _run_module_as_main() should report without a tracebackN)rrrr r!rrrkrk�s��Lrrkc�x�	|s|dk7rt|t�\}}}ntt�\}}}tjdj}|rjtjd<t|dd�S#t$r4}tj�d|��}tj
|�Yd}~��d}~wwxYw)a�Runs the designated module in the __main__ namespace

       Note that the executed module will have full access to the
       __main__ namespace. If this is not desirable, the run_module()
       function should be used to run the module code in a fresh namespace.

       At the very least, these variables in __main__ will be overwritten:
           __name__
           __file__
           __cached__
           __loader__
           __package__
    rLz: Nr)r`rk�_get_main_module_detailsr�
executable�exitrrBr5r+r@)r	�
alter_argvr<r9�excrf�main_globalss       r�_run_module_as_mainrs�s������Z�/�':�8�V�'L�$�H�h��'?��'G�$�H�h���;�;�z�*�3�3�L���o�o�������T�<����+�+��
���.�.�#�.������
�
���s�/A<�<	B9�*B4�4B9c�f�t|�\}}}|�|}|rt||||�St|i|||�S)u"Execute a module's code without importing it.

       mod_name -- an absolute module name or package name.

       Optional arguments:
       init_globals -- dictionary used to pre-populate the module’s
       globals dictionary before the code is executed.

       run_name -- if not None, this will be used for setting __name__;
       otherwise, __name__ will be set to mod_name + '__main__' if the
       named module is a package and to just mod_name otherwise.

       alter_sys -- if True, sys.argv[0] is updated with the value of
       __file__ and sys.modules[__name__] is updated with a temporary
       module object for the module being executed. Both are
       restored to their original values before the function returns.

       Returns the resulting module globals dictionary.
    )r`rFr@)r	r;�run_name�	alter_sysr<r9s      rrr�sI��* 3�8�<��H�h���������l�H�h�G�G���r�<��8�D�Drc�:�d}tj|}tj|=	t|�|tj|<S#t$r3}|t	|�vr |d|�dtj
d���|��d}~wwxYw#|tj|<wxYw)NrLzcan't find z module in r)rrr`rP�str�path)rb�	main_name�
saved_mainrqs    rrmrm�s���
�I����Y�'�J����I��,�"�9�-�",����I���
����C�� ��(�#�(�(�1�+�7�8�=@�
A�
��	��",����I��s#�
A�	B�.A=�=B�B�Bc�H�ddlm}tjj	|�}tj|�5}||�}ddd��;tj|�5}t|j�|d�}ddd�|S|S#1swY�HxYw#1swY|SxYw)Nr)�	read_coder8)	�pkgutilr}�osry�abspath�io�	open_code�compile�read)r?r}�	code_path�fr9s     r�_get_code_from_filer��s|��!�������&�I�	���i�	 �A���|��
!��|�
�\�\�)�
$���1�6�6�8�U�F�3�D�%��K�4�K�

!�	 ��%��K�s�	B�#B�B�B!c
�\�|�d}|jd�d}ddlm}||�}tj|�}t|t
d��rt|�}t|||||��Stjjd|�	t�\}}}t|�5}	t|�5|	jj }
t#||
||||�j%�cddd�cddd�	tjj'|�S#t($rYSwxYw#1swYnxYw	ddd�n#1swYnxYw	tjj'|�y#t($rYywxYw#	tjj'|�w#t($rYwwxYwxYw)uExecute code located at the specified filesystem location.

       path_name -- filesystem location of a Python script, zipfile,
       or directory containing a top level __main__.py script.

       Optional arguments:
       init_globals -- dictionary used to pre-populate the module’s
       globals dictionary before the code is executed.

       run_name -- if not None, this will be used to set __name__;
       otherwise, '<run_path>' will be used for __name__.

       Returns the resulting module globals dictionary.
    Nz
<run_path>rHr)�get_importer)r=r>)rNr~r�r�fsdecode�
isinstancer^r�rFrry�insertrmrr#rrBr@rC�remover\)�	path_namer;rur=r��importerr9r	r<rDrEs           rrrs{�������"�"�3�'��*�H�$��I�&�H����I�&�I��(�D��J�'�#�9�-����l�H�)1�y�J�	J�
	������9�%�	�(@�'A�$�H�h���X�&�+��	�*�)�0�0�9�9�� ��{�L�$,�h��B�BF�$�&�+�*�'�&�
������	�*���
��
��+�*��*�'�&�&��
������	�*���
��
��
������	�*���
��
�s��
E:�&D>�24D(�&	D>�/	E:�9D�	D%�$D%�(D1	�-D>�5	E:�>E�E:�E+�+	E7�6E7�:F+�<F�F+�	F(�%F+�'F(�(F+rL�z!No module specified for execution)�file)NNNNN)T)NNF)NN)r r�importlib.machineryrW�importlib.utilr�r�__all__r^r
r&rr#r@rFrPr`�	Exceptionrkrsrrmr�rr�lenr+�print�stderrr!rr�<module>r�s�������	�	��*���
�#�Y�
� �&� �.
(�V�
(� /3�&*�)-��4)-�,0�/3��)4�; �zM�Y�M�+�8'+�(-�E�<$/�,�&
�0�f�z��
�3�8�8�}�q��
�1��
�
�C��H�H�Q�K��C�H�H�Q�K�(�
r���dZddlmZddlmZddlmZddlmZmZmZm	Z	m
Z
ddlmZddlmZddlm
Z
dd	lmZdd
lmZddlmZddlmZd
�Zy)z9The machinery of importlib: finders, loaders, hooks, etc.�)�
ModuleSpec)�BuiltinImporter)�FrozenImporter)�SOURCE_SUFFIXES�DEBUG_BYTECODE_SUFFIXES�OPTIMIZED_BYTECODE_SUFFIXES�BYTECODE_SUFFIXES�EXTENSION_SUFFIXES)�WindowsRegistryFinder)�
PathFinder)�
FileFinder)�SourceFileLoader)�SourcelessFileLoader)�ExtensionFileLoader)�NamespaceLoaderc�*�ttztzS)zAReturns a list of all recognized module suffixes for this process)rr	r
���<frozen importlib.machinery>�all_suffixesrs���.�.�1C�C�CrN)�__doc__�
_bootstraprrr�_bootstrap_externalrrrr	r
rrr
rrrrrrrr�<module>rs8��?�"�'�&�)�)�7�+�+�1�5�4�0�Dr���dZddlmZddlmZddlmZddlmZddlmZddlm	Z	ddlm
Z
dd	lmZdd
lmZddlm
Z
ddlmZd
dlZd
dlZd
dlZd�Zd�Zdd�Zdd�ZGd�d�ZGd�dej.�ZGd�de�Zy)z-Utility code for constructing importers, etc.�)�Loader)�module_from_spec)�
_resolve_name)�spec_from_loader)�
_find_spec)�MAGIC_NUMBER)�_RAW_MAGIC_NUMBER)�cache_from_source)�
decode_source)�source_from_cache)�spec_from_file_location�Nc�6�tjt|�S)zBReturn the hash of *source_bytes* as used in hash-based pyc files.)�_imp�source_hashr	)�source_bytess �<frozen importlib.util>rrs�����-�|�<�<�c��|jd�s|S|stdt|��d���d}|D]}|dk7rn|dz
}�t||d||�S)z2Resolve a relative module name to an absolute one.�.zno package specified for z% (required for relative module names)rrN)�
startswith�ImportError�reprr)�name�package�level�	characters    r�resolve_namersw���?�?�3����
��5�d�4�j�\�BA�A�B�	B�
�E��	�����
��
�����e�f��w��6�6rc���|tjvrt||�Stj|}|�y	|j}|�t	|�d���|S#t
$rt	|�d��d�wxYw)a�Return the spec for the specified module.

    First, sys.modules is checked to see if the module was already imported. If
    so, then sys.modules[name].__spec__ is returned. If that happens to be
    set to None, then ValueError is raised. If the module is not in
    sys.modules, then sys.meta_path is searched for a suitable spec with the
    value of 'path' given to the finders. None is returned if no spec could
    be found.

    Dotted names do not have their parent packages implicitly imported. You will
    most likely need to explicitly import all parent packages in the proper
    order for a submodule to get the correct spec.

    N�.__spec__ is None�.__spec__ is not set)�sys�modulesr�__spec__�
ValueError�AttributeError)r�path�module�specs    r�_find_spec_from_pathr*'s����3�;�;���$��%�%����T�"���>��	��?�?�D��|� �D�6�):�!;�<�<��K���	F���v�%9�:�;��E�	F�s�A�A-c���|jd�rt||�n|}|tjvr@|j	d�d}|rt|dg��}	|j}nd}t||�Stj|}|�y	|j}|�t|�d	���|S#t$r}td|�d|��|��|�d}~wwxYw#t$rt|�d
��d�wxYw)a�Return the spec for the specified module.

    First, sys.modules is checked to see if the module was already imported. If
    so, then sys.modules[name].__spec__ is returned. If that happens to be
    set to None, then ValueError is raised. If the module is not in
    sys.modules, then sys.meta_path is searched for a suitable spec with the
    value of 'path' given to the finders. None is returned if no spec could
    be found.

    If the name is for submodule (contains a dot), the parent module is
    automatically imported.

    The name and package arguments work the same as importlib.import_module().
    In other words, relative module names (with leading dots) work.

    rr�__path__)�fromlistz __path__ attribute not found on z while trying to find )rNr r!)rrr"r#�
rpartition�
__import__r,r&�ModuleNotFoundErrorrr$r%)	rr�fullname�parent_name�parent�parent_path�er(r)s	         r�	find_specr6Fs��"/3�o�o�c�.B�|�D�'�*��H��s�{�{�"��)�)�#�.�q�1�����z�l�C�F�
P�$�o�o���K��(�K�0�0����X�&���>��	��?�?�D��|� �D�6�):�!;�<�<��K��%"�
P�)�6�{�o�F,�,4�<�9�?G�I�NO�P��
P���	F���v�%9�:�;��E�	F�s$�B'�	C�'	C	�0C�C	�C%c�2�eZdZdZd�Zd�Zd�Zed��Zy)�+_incompatible_extension_module_restrictionsagA context manager that can temporarily skip the compatibility check.

    NOTE: This function is meant to accommodate an unusual case; one
    which is likely to eventually go away.  There's is a pretty good
    chance this is not what you were looking for.

    WARNING: Using this function to disable the check can lead to
    unexpected behavior and even crashes.  It should only be used during
    extension module development.

    If "disable_check" is True then the compatibility check will not
    happen while the context manager is active.  Otherwise the check
    *will* happen.

    Normally, extensions that do not support multiple interpreters
    may not be imported in a subinterpreter.  That implies modules
    that do not implement multi-phase init or that explicitly of out.

    Likewise for modules import in a subinterpeter with its own GIL
    when the extension does not support a per-interpreter GIL.  This
    implies the module does not have a Py_mod_multiple_interpreters slot
    set to Py_MOD_PER_INTERPRETER_GIL_SUPPORTED.

    In both cases, this context manager may be used to temporarily
    disable the check for compatible extension modules.

    You can get the same effect as this function by implementing the
    basic interface of multi-phase init (PEP 489) and lying about
    support for multiple interpreters (or per-interpreter GIL).
    c�$�t|�|_y�N)�bool�
disable_check)�selfr<s  r�__init__z4_incompatible_extension_module_restrictions.__init__�s��!�-�0��rc�N�tj|j�|_|Sr:)r�'_override_multi_interp_extensions_check�override�old�r=s r�	__enter__z5_incompatible_extension_module_restrictions.__enter__�s���?�?��
�
�N����rc�J�|j}|`tj|�yr:)rBrr@)r=�argsrBs   r�__exit__z4_incompatible_extension_module_restrictions.__exit__�s���h�h���H��4�4�S�9rc�"�|jrdSdS)N���r)r<rCs rrAz4_incompatible_extension_module_restrictions.override�s���'�'�r�.�Q�.rN)	�__name__�
__module__�__qualname__�__doc__r>rDrG�propertyrA�rrr8r8ws*���>1��:�
�/��/rr8c��eZdZdZd�Zd�Zy)�_LazyModulezKA subclass of the module type which triggers loading upon attribute access.c��tj|d�}|j}|d5tj|d�tu�r#|drtj||�cddd�Sd|d<tj|d�}|j}|d}|}i}|j�D]2\}	}
|	|vr|
||	<�t
||	�t
||	�k7s�.|
||	<�4|jj|�|tjvr7t
|�t
tj|�k7rtd|�d	���|j|�tj|_ddd�t!||�S#1swY�xYw)
z8Trigger the load of the module and return the attribute.r$�lock�	__class__�
is_loadingNT�__dict__zmodule object for z. substituted in sys.modules during a lazy load)�object�__getattribute__�loader_staterQr�items�id�loader�exec_moduler"r#r%�update�types�
ModuleTyperT�getattr)r=�attrr$rYrV�
original_name�
attrs_then�	attrs_now�
attrs_updated�key�values           rrXz_LazyModule.__getattribute__�s����*�*�4��<���,�,��
�&�
!��&�&�t�[�9�[�H�
 ��-�!�2�2�4��>�"�
!�.2��\�*�!�2�2�4��D��!)�
�
�
�*�*�5�
�$�	� "�
�"+�/�/�"3�J�C���*�,�-2�
�c�*��I�c�N�+�r�*�S�/�/B�B�-2�
�c�*�
#4����+�+�D�1�!�C�K�K�/��$�x�2�c�k�k�-�&@�#A�A�(�+=�m�=N�O1�*1�2�2�
���
�.�!&�!1�!1���W"�Z�t�T�"�"�["�
!�s�8E=�*A-E=�BE=�=Fc�>�|j|�t||�y)z/Trigger the load and then perform the deletion.N)rX�delattr)r=rbs  r�__delattr__z_LazyModule.__delattr__�s��	
���d�#���d�rN)rJrKrLrMrXrkrOrrrQrQ�s��U�1#�frrQc�B�eZdZdZed��Zed��Zd�Zd�Z	d�Z
y)�
LazyLoaderzKA loader that creates a module which defers loading until attribute access.c�2�t|d�std��y)Nr]z loader must define exec_module())�hasattr�	TypeError)r\s r�__check_eager_loaderzLazyLoader.__check_eager_loader�s���v�}�-��>�?�?�.rc�4����j����fd�S)z>Construct a callable which returns the eager loader made lazy.c� ����|i|���Sr:rO)rF�kwargs�clsr\s  ��r�<lambda>z$LazyLoader.factory.<locals>.<lambda>�s���s�6�4�+B�6�+B�'Cr)�_LazyLoader__check_eager_loader)rur\s``r�factoryzLazyLoader.factory�s���	� � ��(�C�Crc�4�|j|�||_yr:)rwr\)r=r\s  rr>zLazyLoader.__init__�s���!�!�&�)���rc�8�|jj|�Sr:)r\�
create_module)r=r)s  rr{zLazyLoader.create_module�s���{�{�(�(��.�.rc�(�ddl}|j|j_|j|_i}|jj�|d<|j|d<|j�|d<d|d<||j_t|_y)zMake the module load lazily.rNrVrTrSFrU)
�	threadingr\r$�
__loader__rV�copyrT�RLockrYrQ)r=r(r}rYs    rr]zLazyLoader.exec_module�s���	�!%������� �K�K���
��#)�?�?�#7�#7�#9��Z� �$*�$4�$4��[�!�(���0��V��%*��\�"�'3����$�&��rN)rJrKrLrM�staticmethodrw�classmethodrxr>r{r]rOrrrmrm�s>��U��@��@��D��D�
�/�'rrmr:)rM�_abcr�
_bootstraprrrr�_bootstrap_externalrr	r
rrr
rr"r_rrr*r6r8r`rQrmrOrr�<module>r�sq��3��(�%�(�"�-�2�2�.�2�8��
��=�
7��>*�b./�./�b<�%�"�"�<�~''��''r�
�6�dZdZdZdZdZdZdZdZdZd	Z	d
Z
d�Zd�Zd
Z
dZdZdZdZdZdZdZdZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z dZ!dZ"e"Z#d Z$d!Z%d"Z&d#Z'd$Z(d!Z)d"Z*d#Z+d%Z,d&Z-d'Z.d	Z/dZ0dZ1dZ2dZ3dZ4dZ5dZ6d	Z7d'Z8d&Z9dZ:d(Z;d)Z<d*Z=d+Z>d,Z?ed-fed.fed/fed0fe
d1fed2fed3ffe)d4ffe*d5ffe+e!zd.fe!d6fe+d7ffe-d4ffe.d5ffe/e"zd.fe"d6fe/d7ffe1d4ffe2d5ffe3e$zd8fe$d9fe3d7fff
Z@d:�ZAd&ZBdZCd#ZDd'ZEd
ZFdZGdZHd"ZIdZJd)ZKdZLdZMdZNd ZOdZPd!ZQd(ZR	dd;lS�y<#eT$rYy<wxYw)=zoConstants/functions for interpreting results of os.stat() and os.lstat().

Suggested usage: from stat import *
����������	c��|dzS)zMReturn the portion of the file's mode that can be set by
    os.chmod().
    i����modes �
<frozen stat>�S_IMODErs���&�=��c��|dzS)zLReturn the portion of the file's mode that describes the
    file type.
    i�r
rs r�S_IFMTrs���(�?�ri@i i`i�ii�i�c�&�t|�tk(S)z(Return True if mode is from a directory.)r�S_IFDIRrs r�S_ISDIRr2����$�<�7�"�"rc�&�t|�tk(S)z<Return True if mode is from a character special device file.)r�S_IFCHRrs r�S_ISCHRr6rrc�&�t|�tk(S)z8Return True if mode is from a block special device file.)r�S_IFBLKrs r�S_ISBLKr:rrc�&�t|�tk(S)z+Return True if mode is from a regular file.)r�S_IFREGrs r�S_ISREGr!>rrc�&�t|�tk(S)z0Return True if mode is from a FIFO (named pipe).)r�S_IFIFOrs r�S_ISFIFOr$Brrc�&�t|�tk(S)z,Return True if mode is from a symbolic link.)r�S_IFLNKrs r�S_ISLNKr'Frrc�&�t|�tk(S)z%Return True if mode is from a socket.)r�S_IFSOCKrs r�S_ISSOCKr*Js���$�<�8�#�#rc��y)z#Return True if mode is from a door.Fr
rs r�S_ISDOORr,N���rc��y)z*Return True if mode is from an event port.Fr
rs r�S_ISPORTr/Rr-rc��y)z'Return True if mode is from a whiteout.Fr
rs r�S_ISWHTr1Vr-riii���@i��8� �iiiii �l�s�-�b�d�c�p�r�w�S�x�t�Tc��g}tD]8}|D] \}}||z|k(s�|j|��'|jd��:dj|�S)z;Convert a file's mode to a string of the form '-rwxrwxrwx'.r:�)�_filemode_table�append�join)r�perm�table�bit�chars     r�filemoderN�sX��
�D� ���I�C���c�z�S� ����D�!���

�K�K���
!��7�7�4�=�r)�*N)U�__doc__�ST_MODE�ST_INO�ST_DEV�ST_NLINK�ST_UID�ST_GID�ST_SIZE�ST_ATIME�ST_MTIME�ST_CTIMErrrrrr r#r&r)�S_IFDOOR�S_IFPORT�S_IFWHTrrrr!r$r'r*r,r/r1�S_ISUID�S_ISGID�S_ENFMT�S_ISVTX�S_IREAD�S_IWRITE�S_IEXEC�S_IRWXU�S_IRUSR�S_IWUSR�S_IXUSR�S_IRWXG�S_IRGRP�S_IWGRP�S_IXGRP�S_IRWXO�S_IROTH�S_IWOTH�S_IXOTH�	UF_NODUMP�UF_IMMUTABLE�	UF_APPEND�	UF_OPAQUE�UF_NOUNLINK�
UF_COMPRESSED�	UF_HIDDEN�SF_ARCHIVED�SF_IMMUTABLE�	SF_APPEND�SF_NOUNLINK�SF_SNAPSHOTrGrN�FILE_ATTRIBUTE_ARCHIVE�FILE_ATTRIBUTE_COMPRESSED�FILE_ATTRIBUTE_DEVICE�FILE_ATTRIBUTE_DIRECTORY�FILE_ATTRIBUTE_ENCRYPTED�FILE_ATTRIBUTE_HIDDEN�FILE_ATTRIBUTE_INTEGRITY_STREAM�FILE_ATTRIBUTE_NORMAL�"FILE_ATTRIBUTE_NOT_CONTENT_INDEXED�FILE_ATTRIBUTE_NO_SCRUB_DATA�FILE_ATTRIBUTE_OFFLINE�FILE_ATTRIBUTE_READONLY�FILE_ATTRIBUTE_REPARSE_POINT�FILE_ATTRIBUTE_SPARSE_FILE�FILE_ATTRIBUTE_SYSTEM�FILE_ATTRIBUTE_TEMPORARY�FILE_ATTRIBUTE_VIRTUAL�_stat�ImportErrorr
rr�<module>r�s����
����������������������������������������
��#�#�#�#�#�#�$������
��
��
��
����
��
��
��
��
��
��
��
��
��
��
��
��
���	����	��	����
��	������	������s���s��
�s��
�s��
�s��
�s��
�s��
��s���
�s���
�g�o�s��
�s��
�s����s���
�s���
�g�o�s��
�s��
�s����s���
�s���
�g�o�s��
�s��
�s���/��8
� �� ������ ����"'����%)�"�%������#�� ��������	����	��	�s�
D�D�D��^�dZddlZddlZddlZddlZddlZddlZejejga	da
dadad�Z
d�Zd�Zd�Zd�Zd�Zdd	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zdd�Zdd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#ejHjJse#�d�Z&e'dk(re&�yy)a�Append module search paths for third-party packages to sys.path.

****************************************************************
* This module is automatically imported during initialization. *
****************************************************************

This will append site-specific paths to the module search path.  On
Unix (including Mac OSX), it starts with sys.prefix and
sys.exec_prefix (if different) and appends
lib/python<version>/site-packages.
On other platforms (such as Windows), it tries each of the
prefixes directly, as well as with lib/site-packages appended.  The
resulting directories, if they exist, are appended to sys.path, and
also inspected for path configuration files.

If a file named "pyvenv.cfg" exists one directory above sys.executable,
sys.prefix and sys.exec_prefix are set to that directory and
it is also checked for site-packages (sys.base_prefix and
sys.base_exec_prefix will always be the "real" prefixes of the Python
installation). If "pyvenv.cfg" (a bootstrap configuration file) contains
the key "include-system-site-packages" set to anything other than "false"
(case-insensitive), the system-level prefixes will still also be
searched for site-packages; otherwise they won't.

All of the resulting site-specific directories, if they exist, are
appended to sys.path, and also inspected for path configuration
files.

A path configuration file is a file whose name has the form
<package>.pth; its contents are additional directories (one per line)
to be added to sys.path.  Non-existing directories (or
non-directories) are never added to sys.path; no directory is added to
sys.path more than once.  Blank lines and lines beginning with
'#' are skipped. Lines starting with 'import' are executed.

For example, suppose sys.prefix and sys.exec_prefix are set to
/usr/local and there is a directory /usr/local/lib/python2.5/site-packages
with three subdirectories, foo, bar and spam, and two path
configuration files, foo.pth and bar.pth.  Assume foo.pth contains the
following:

  # foo package configuration
  foo
  bar
  bletch

and bar.pth contains:

  # bar package configuration
  bar

Then the following directories are added to sys.path, in this order:

  /usr/local/lib/python2.5/site-packages/bar
  /usr/local/lib/python2.5/site-packages/foo

Note that bletch is omitted because it doesn't exist; bar precedes foo
because bar.pth comes alphabetically before foo.pth; and spam is
omitted because it is not mentioned in either path configuration file.

The readline module is also automatically configured to enable
completion for systems that support it.  This can be overridden in
sitecustomize, usercustomize or PYTHONSTARTUP.  Starting Python in
isolated mode (-I) disables automatic readline configuration.

After these operations, an attempt is made to import a module
named sitecustomize, which can perform arbitrary additional
site-specific customizations.  If this import fails with an
ImportError exception, it is silently ignored.
�Nc�p�tjjrt|tj��yy)N��file)�sys�flags�verbose�print�stderr)�messages �
<frozen site>�_tracer
\s"��
�y�y���
�g�C�J�J�'��c���tjj|�}	tjj|�}|tjj|�fS#t$rY�,wxYw�N)�os�path�join�abspath�OSError�normcase)�paths�dirs  r�makepathras[��
�'�'�,�,��
�C�
��g�g�o�o�c�"������ � ��%�%�%���
��
�s�A�	A*�)A*c�<�ttjj��D]~}d}	|jj
}|dvr�!	tjj|j�|_	tjj|j�|_��y#t$r4	|jjj
}n#t$rYnwxYwY��wxYw#tttf$rY��wxYw#tttf$rY��wxYw)zESet all module __file__ and __cached__ attributes to an absolute pathN>�_frozen_importlib�_frozen_importlib_external)�setr�modules�values�
__loader__�
__module__�AttributeError�__spec__�loaderrrr�__file__r�	TypeError�
__cached__)�m�
loader_modules  r�	abs_pathsr*js���
����#�#�%�
&���
�	��L�L�3�3�M�� S�S��	���������4�A�J�	��7�7�?�?�1�<�<�8�A�L�!'���	�
� !�
�
� 1� 1� <� <�
��!�
��
��	�����3�	��	�����3�	��	�sY�B*�
.C*�9.D�*	C'�4 C�C'�	C!�C'� C!�!C'�&C'�*D�D�D�Dc���g}t�}tjD]7}t|�\}}||vs�|j	|�|j|��9|tjdd|S)zK Remove duplicate entries from sys.path along with making them
    absoluteN)rrrr�append�add)�L�known_pathsr�dircases    r�removeduppathsr1�sa��
	�A��%�K��x�x�� ��}���W��+�%�
�H�H�S�M��O�O�G�$���C�H�H�Q�K��rc���t�}tjD]A}	tjj	|�rt|�\}}|j
|��C|S#t$rY�QwxYw)zEReturn a set containing all existing file system items from sys.path.)rrrr�existsrr-r&)�d�item�_�itemcases    r�_init_pathinfor8�s`����A�����	��w�w�~�~�d�#�&�t�n���8����h���	�
�H���	��	�s�>A!�!	A-�,A-c	��|�
t�}d}nd}tjj||�}	tj|�}t
|dd�tjzst
|dd�tjzrtd|���ytd|���	tj|�5}|j�}ddd�	jd	�}t%|j'�d�D]�\}	}
|
j)d
�r�|
j+�dk(r�,	|
j)d�rt-|
��J|
j/�}
t1||
�\}}||vrOtjj3|�r0t4jj7|�|j9|���|rd}|S#t
$rYywxYw#1swY��	xYw#t
$rYywxYw#t$rFddl}j|j#��}td
|�d|j#����Y��WwxYw#t:$r�}
t=d|	d�d|�d�t4j>��ddl }|jC|
�D]5}|j'�D] }
t=d|
zt4j>���"�7t=dt4j>��Yd}
~
��d}
~
wwxYw)z�Process a .pth file within the site-packages directory:
       For each line in the file, either combine it with sitedir to a path
       and add that to known_paths, or execute it if it starts with 'import '.
    NTF�st_flagsr�st_file_attributeszSkipping hidden .pth file: zProcessing .pth file: z	utf-8-sigzCannot read z# as UTF-8. Using fallback encoding ��#�)zimport zimport	zError processing line r4z of z:
rz  z
Remainder of file ignored)"r8rrr�lstatr�getattr�stat�	UF_HIDDEN�FILE_ATTRIBUTE_HIDDENr
�io�	open_code�read�decode�UnicodeDecodeError�locale�getencoding�	enumerate�
splitlines�
startswith�strip�exec�rstriprr3rr,r-�	Exceptionr	r
�	traceback�format_exception)�sitedir�namer/�reset�fullname�st�f�pth_contentrI�n�linerr0�excrR�records                r�
addpackager_�s���
��$�&�������w�w�|�|�G�T�*�H��
�X�X�h�
��
��Z��	#�d�n�n�	4�	��)�1�	-��0J�0J�	J��,�X�L�9�:��
�
#�H�<�0�1��
�\�\�(�
#�q��&�&�(�K�$�

D�"�(�(��5���[�3�3�5�q�9���4��?�?�3����:�:�<�2���	����6�7��T�
���;�;�=�D�#�G�T�2�L�C���k�)�b�g�g�n�n�S�.A�������$�����(��:�.
������e�����$�
#��������D�	�!�(�(��);�);�)=�>����h�\�**�*0�*<�*<�*>�)A�C�	D�D��,�	��*�1�Q�%�t�H�:�S�A��z�z�
#��#�4�4�S�9��"�-�-�/�D��$�t�)�#�*�*�5�0�:�
�/�c�j�j�A���	�sn�G�"G�7G�G�G+�)H=�A2H=�	G�G�G�G�	G(�'G(�+AH:�9H:�=	K�BK�Kc��td|���|�
t�}d}nd}t|�\}}||vr0tjj|�|j
|�	tj|�}|D�cgc]&}|jd�r|jd�s|��(}}t|�D]}t|||��|rd}|S#t$rYywxYwcc}w)zTAdd 'sitedir' argument to sys.path if missing and handle .pth files in
    'sitedir'zAdding directory: NTFz.pth�.)r
r8rrrr,r-r�listdirr�endswithrM�sortedr_)rTr/rV�sitedircase�namesrUs      r�
addsitedirrg�s����
��{�+�,���$�&������#�G�,��G�[��+�%������� �����$���
�
�7�#��$�
D�e�d��
�
�f�%�d�o�o�c�.B��e�E�
D��u�
���7�D�+�.�������������
Ds�#C�<+C�	C�Cc�b�tjjryttd�r:ttd�r*t	j
�t	j�k7ryttd�r:ttd�r*t	j�t	j�k7ryy)a,Check if user site directory is safe for inclusion

    The function tests for the command line flag (including environment var),
    process uid/gid equal to effective uid/gid.

    None: Disabled for security reasons
    False: Disabled by user (command line option)
    True: Safe and enabled
    F�getuid�geteuidN�getgid�getegidT)	rr�no_user_site�hasattrrrjrirlrk�rr�check_enableusersiterp�sk���y�y�����r�8����Y�!7�
�:�:�<�2�9�9�;�&���r�8����Y�!7�
�:�:�<�2�9�9�;�&��rc	��tjjdd�}|r|Stjdvryd�}tj
dk(r,tjjd�xsd}||d�Stjdk(r=tjr-|dd	tjd
tjddz�S|dd�S)
N�PYTHONUSERBASE>�wasi�vxworks�
emscriptenc�t�tjjtjj|��Sr)rr�
expanduserr)�argss r�joinuserz_getuserbase.<locals>.joinuser&s$���w�w�!�!�"�'�'�,�,��"5�6�6r�nt�APPDATA�~�Python�darwin�Libraryz%d.%d�z.local)r�environ�getr�platformrU�
_framework�version_info)�env_basery�bases   r�_getuserbaser�s����z�z�~�~�.��5�H�����|�|�8�8��7�
�w�w�$���z�z�~�~�i�(�/�C����h�'�'�
�|�|�x��C�N�N���Y�����#�"2�"2�2�A�"6�6�8�	8��C��"�"rc�
�tj}tjdk(r(tjjdd�}|�d|�d�Stjdk(rtjr|�d�S|�d|d	�d|d
�d�S)Nrzrar>z\Pythonz\site-packagesr~z/lib/python/site-packagesz/lib/pythonrr<z/site-packages)rr�rrU�winver�replacer�r�)�userbase�version�	ver_nodots   r�	_get_pathr�5s������G�	�w�w�$���J�J�&�&�s�B�/�	���8�I�;�o�>�>�
�|�|�x��C�N�N���4�5�5��Z�{�7�1�:�,�a���
�|�>�J�Jrc�.�t�
t�atS)z�Returns the `user base` directory path.

    The `user base` directory can be used to store data. If the global
    variable ``USER_BASE`` is not initialized yet, this function will also set
    it.
    )�	USER_BASEr�rorr�getuserbaser�Bs���� �N�	��rc�X�t�}t�|�datSt|�atS)z�Returns the user-specific site-packages directory path.

    If the global variable ``USER_SITE`` is not initialized yet, this
    function will also set it.
    F)r��	USER_SITE�ENABLE_USER_SITEr�)r�s r�getusersitepackagesr�Os7���}�H�����$����"�(�+�I��rc��td�t�}tr+tjj|�rt
||�|S)z�Add a per user site-package to sys.path

    Each user has its own python directory with site-packages in the
    home directory.
    zProcessing user site-packages)r
r�r�rr�isdirrg)r/�	user_sites  r�addusersitepackagesr�`s7���*�+�#�%�I��B�G�G�M�M�)�4��9�k�*��rc
��g}t�}|�t}|D]�}|r||vr�
|j|�tjdk(r�t
jg}t
jdk7r|jd�|D]I}tjj||dt
jddzd�}|j|��K��|j|�|jtjj|dd����|S)aReturns a list containing all global site-packages directories.

    For each directory present in ``prefixes`` (or the global ``PREFIXES``),
    this function will find its `site-packages` subdirectory depending on the
    system environment, and will return a list of full paths.
    N�/�libzpython%d.%dr�z
site-packages�Lib)r�PREFIXESr-r�sepr�
platlibdirr,rrr�)�prefixes�sitepackages�seen�prefix�libdirs�libdirrs       r�getsitepackagesr�os����L��5�D���������4��������
�6�6�S�=��~�~�&�G��~�~��&����u�%�!���w�w�|�|�F�F�$1�C�4D�4D�R�a�4H�$H�$3�5���#�#�D�)�	"�
����'���������V�U�O� L�M�#�$�rc��td�t|�D].}tjj	|�s�#t||��0|S)zAdd site-packages to sys.pathzProcessing global site-packages)r
r�rrr�rg)r/r�rTs   r�addsitepackagesr��s<��
�,�-�"�8�,��
�7�7�=�=��!��w��,�-��rc��tjdk(rd}nd}tjd|�t_tjd|�t_y)z�Define new builtins 'quit' and 'exit'.

    These are objects which make the interpreter exit when called.
    The repr of each object contains a hint at how it works.

    �\zCtrl-Z plus ReturnzCtrl-D (i.e. EOF)�quit�exitN)rr��
_sitebuiltins�Quitter�builtinsr�r�)�eofs r�setquitr��sA��
�v�v��~�"��!��!�)�)�&�#�6�H�M�!�)�)�&�#�6�H�Mrc�L�tjdtj�t_tjdd�t_gg}}t
tdd�}|s=ttd�r-tjjtj�}|ra|jddg�|jtjj|tj�|tjg�tjd	d
||�t_y)z)Set 'copyright' and 'credits' in builtins�	copyright�creditsz�    Thanks to CWI, CNRI, BeOpen.com, Zope Corporation and a cast of thousands
    for supporting Python development.  See www.python.org for more information.�_stdlib_dirNr%zLICENSE.txt�LICENSE�licensez'See https://www.python.org/psf/license/)r��_Printerrr�r�r�r@rnrr�dirnamer%�extendr�pardir�curdirr�)�files�dirs�heres   r�setcopyrightr��s���&�/�/��S�]�]�K�H��$�-�-�i�:T�U�H���b�4�E��3�
�t�,�D��G�B�
�+��w�w���r�{�{�+���
���m�Y�/�0����R�W�W�\�\�$��	�	�2�D�"�)�)�D�E�$�-�-��1�
�t��H�rc�>�tj�t_yr)r��_Helperr��helprorr�	sethelperr��s��!�)�)�+�H�Mrc� �d�}|t_y)ajEnable default readline configuration on interactive prompts, by
    registering a sys.__interactivehook__.

    If the readline module can be imported, the hook will set the Tab key
    as completion key and register ~/.python_history as history file.
    This can be overridden in the sitecustomize or usercustomize module,
    or in a PYTHONSTARTUP file.
    c����ddl}	ddl�ddl}t	�dd�}|�d|vr�jd�n�jd�	�j
��j�dk(rgtjjtjjd�d��	�j����fd	�}|j|�yy#t$rYywxYw#t$rY��wxYw#t$rY�BwxYw)
Nr�__doc__r>�libeditzbind ^I rl_completez
tab: completer|z.python_historyc�H��	�j��y#t$rYywxYwr)�write_history_filer)�history�readlines��r�
write_historyzCenablerlcompleter.<locals>.register_readline.<locals>.write_history�s*�����/�/��8������s��	!�!)�atexitr��rlcompleter�ImportErrorr@�parse_and_bind�read_init_filer�get_current_history_lengthrrrrw�read_history_file�register)r�r��readline_docr�r�r�s    @@r�register_readlinez,enablerlcompleter.<locals>.register_readline�s�����	����x��B�7���#�	�\�(A��#�#�$9�:��#�#�O�4�	��#�#�%��.�.�0�A�5��g�g�l�l�2�7�7�#5�#5�c�#:�#4�6�G�
��*�*�7�3�
�
�O�O�M�*�+6��)�	��	���	�

�	��"�
��
�s5�C�C!�(C0�	C�C�!	C-�,C-�0	C<�;C<N)r�__interactivehook__)r�s r�enablerlcompleterr��s��.+�`0�C�rc�B�tj}tjdk(r#d|vrtjdx}t_ntj
}tjjtjj|��}tjj|�}dt_	d}td�tjj||�tjj||�fD�d�}|�r|}d}t|d��5}	|	D]q}
d|
vs�|
jd�\}}}
|j�j�}|
j�}
|d	k(r|
j�}�a|d
k(s�g|
t_	�s	ddd�|xt_t_t%|tj g�|dk(r&t&j)dtj �|Stj gada|S#1swY�zxYw)
Nr~�__PYVENV_LAUNCHER__z
pyvenv.cfgc3�^K�|]%}tjj|�r|���'y�wr)rr�isfile)�.0�conffiles  r�	<genexpr>zvenv.<locals>.<genexpr>	s.����	
�&���w�w�~�~�h�'�	
�&�s�+-�truezutf-8)�encoding�=zinclude-system-site-packages�homerF)rr�rr��_base_executable�
executablerr�r�_home�nextr�open�	partitionrN�lowerr��exec_prefixr�r��insertr�)r/�envr��exe_dir�site_prefix�
conf_basename�candidate_conf�virtual_conf�system_siterYr\�keyr6�values              r�venvr��s���
�*�*�C�
�|�|�x��$9�S�$@�,.�J�J�7L�,M�M�
�S�)��^�^�
��g�g�o�o�b�g�g�o�o�j�9�:�G��'�'�/�/�'�*�K��C�I� �M��	
������W�m�4������[�-�8�&�	
�	
�	�N��%�����,��
1�Q����$�;�$(�N�N�3�$7�M�C��E��)�)�+�+�+�-�C�!�K�K�M�E��<�<�&+�k�k�m�����$)��	��2�(3�2��
�S�_�	��c�j�j�\�2��&� ��O�O�A�s�z�z�*�
���
�
�|�H�$����12�
1�s�$
H�/AH�
H�Hc��		ddl}y#t$r}|jdk(rn�Yd}~yd}~wwxYw#t$r�}tj
jr%t	jt	j��n?tjjd|jj�d|�d��Yd}~yYd}~yd}~wwxYw)z,Run custom site specific code, if available.rN�
sitecustomizez9Error in sitecustomize; set PYTHONVERBOSE for traceback:
�: �
)
r�r�rUrQrrr�
excepthook�exc_infor
�write�	__class__�__name__)r�r]�errs   r�execsitecustomizer3���/�	� ���	��x�x�?�*�����	��
�/��9�9����N�N�C�L�L�N�+��J�J������'�'��.�
/�
/�
,��/��)��	,�'�/�,�/�	C�A9B;�;Cc��		ddl}y#t$r}|jdk(rn�Yd}~yd}~wwxYw#t$r�}tj
jr%t	jt	j��n?tjjd|jj�d|�d��Yd}~yYd}~yd}~wwxYw)z,Run custom user specific code, if available.rN�
usercustomizez9Error in usercustomize; set PYTHONVERBOSE for traceback:
r�r�)
rr�rUrQrrrr�r�r
rrr)rr]rs   r�execusercustomizer	Grrc��tjdd}t�}|tjk7r
t�t	|�}t
�
t
�at|�}t|�}t�t�t�tjjs
t�t�t
rt!�yy)z�Add standard site-specific directories to the module search path.

    This function is called automatically when this module is imported,
    unless the python interpreter was started with the -S flag.
    N)rrr1r*r�r�rpr�r�r�r�r�r�isolatedr�rr	)�	orig_pathr/s  r�mainr
[s��������I� �"�K��C�H�H��	���{�#�K���/�1��%�k�2�K�!�+�.�K��I��N�
�K��9�9����������rc���d}tjdd}|s�t�}t�}t	d�tj
D]}t	d|�d���t	d�d�}t	d|�d	||��d
��t	d|�d	||��d
��t	dt���tjd
�g}d|vr|jt�d|vr|jt�|r�t	tjj|��trtjd
�ytdurtjd�yt�tjd�ytjd�yd
dl}t	|j|tjd
tjfz��tjd�y)Na�    %s [--user-base] [--user-site]

    Without arguments print some useful information
    With arguments print the value of USER_BASE and/or USER_SITE separated
    by '%s'.

    Exit codes with --user-base or --user-site:
      0 - user site directory is enabled
      1 - user site directory is disabled by user
      2 - user site directory is disabled by super user
          or for security reasons
     >2 - unknown error
    r<zsys.path = [z    �,�]c�H�|� tjj|�ryy)Nr3z
doesn't exist)rrr�)rs rr3z_script.<locals>.exists�s����B�G�G�M�M�$�$7��&rzUSER_BASE: z (�)zUSER_SITE: zENABLE_USER_SITE: rz--user-basez--user-siteFr���
)r�argvr�r�r	rr�r�r,r�r�r�pathsepr�textwrap�dedent)r�rx�	user_baser�rr3�bufferrs        r�_scriptr}si��
�D��8�8�A�B�<�D���M�	�'�)�	�
�n���8�8�C��s�$�%��
�c�
�	'�
	��I�=��6�)�+<�*=�Q�?�@�
��I�=��6�)�+<�*=�Q�?�@�
�"�#3�"6�7�8������
�F�����
�
�i� �����
�
�i� �
�
�b�j�j�o�o�f�%�&���H�H�Q�K�
��
&��H�H�Q�K�
�
%��H�H�Q�K��H�H�Q�K��
�h�o�o�d�c�h�h�q�k�2�:�:�%>�>�?�@�����r�__main__r)(r�rrr�r�rDrAr�r�r�r�r�r�r
rr*r1r8r_rgrpr�r�r�r�r�r�r�r�r�r�r�r�rr	r
r�no_siterrrorr�<module>rs���E�N�	���	��
�J�J����(����

�	��	�(�
&��.�&

�?�D�4�@#�0
K�
��"
��B�
7� �*,�90�v4�n/�(/�(�>�y�y����F�4�l�z���I�r��
�dZddlZddlZddlZddlmZeee	�Z
ejZgd�Z
d�Zd�ZdevrIdZdZdd	l�	dd
lmZe
j)d�ddlZ	ddlmZddlZe
j3ee��[nUd
evrId
ZdZdd	l�	dd
lmZe
j)d�ddlZddlZe
j3ee��[	ddlmZned��eej8d<ddlmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%[ed��r�e&�Z'd�Z(e)�Z*e(dd�e(dd�e(dd�e(dd�e(dd�e(dd�e(d d!�e(d"d#�e(d$d%�e(d&d'�e(d(d)�e(d*d+�e(d,d-�e(d.d/�e(d.d0�e(d1d�e*Z+e)�Z*e(dd�e*Z,e)�Z*e(d2d3�e(d4d�e(d5d�e(d6d7�e(d6d8�e(d9d:�e*j[e�e(d;d<�e(d=d�e(d>d�e(d?d@�edA�redB�r	e(dCdA�e*Z.e)�Z*e(dd�e(dd�e(dd�e(dDdE�e(dFd�edG�r	e(dHd�e(dd�e(dId�e(dJd�e(dd�e(d1d�e(dKd�e*Z/[*[['[(dZ0dLZ1dMZ2d�dO�Z3dP�Z4dQ�Z5e
j3gdR��e6�Z7d�dS�Z8e
j)dT�e9ehe+kr)e:ehe.kr"d�dNddU�dV�Z;dZ<dLZ=dMZ>dW�Z?e
j)dX�dY�Z@dZ�ZAd[�ZBd\�ZCd]�ZDd^�ZEe
j3gd_��d�d`�ZFd�da�ZGddblmHZHmIZIGdc�ddeH�ZJde�ZKeK�ZL[Kd�df�ZMed
k7ZNe
j3dg�eNr/dh�ZOeJeLj�eOeQeOeQ�ZR[Od�di�ZSe
j3dj�dk�ZTeT�\ZUZV[Tedl�rKedm�sCedn�r;dZWdLxZXZYe
j3gdo��dp�ZZdq�Z[dr�Z\ds�Z]dt�Z^e
j3gdu��edm�rdv�Z_dw�Z`e
j3dxdyg�edz�rd{�Zad|�Zbe
j3d}d~g�ej�dk7rd�d��ZdGd��d��Zee
j)d��d�d��Zfd��Zged��s	egZhd�eh_iGd��d�ej��Zked
k(rGd��d��Zld��Zmyy#e$rY���wxYw#e$rY���wxYw#e$rY��WwxYw#e$rY��3wxYw)�aNOS routines for NT or Posix depending on what system we're on.

This exports:
  - all functions from posix or nt, e.g. unlink, stat, etc.
  - os.path is either posixpath or ntpath
  - os.name is either 'posix' or 'nt'
  - os.curdir is a string representing the current directory (always '.')
  - os.pardir is a string representing the parent directory (always '..')
  - os.sep is the (or a most common) pathname separator ('/' or '\\')
  - os.extsep is the extension separator (always '.')
  - os.altsep is the alternate pathname separator (None or '/')
  - os.pathsep is the component separator used in $PATH etc
  - os.linesep is the line separator in text files ('\r' or '\n' or '\r\n')
  - os.defpath is the default search path for executables
  - os.devnull is the file path of the null device ('/dev/null', etc.)

Programs that import and use 'os' stand a better chance of being
portable between different platforms.  Of course, they must then
only use functions that are defined by all platforms (e.g., unlink
and opendir), and leave all pathname manipulation to os.path
(e.g., split and join).
�N)�_check_methods)�altsep�curdir�pardir�sep�pathsep�linesep�defpath�name�path�devnull�SEEK_SET�SEEK_CUR�SEEK_END�fsencode�fsdecode�
get_exec_path�fdopen�extsepc��|t�vS�N)�globals)rs �<frozen os>�_existsr)s���7�9���c��	t|j�S#t$r+t|�D�cgc]
}|ddk7s�|��ncc}wc}cYSwxYw)Nr�_)�list�__all__�AttributeError�dir)�module�ns  r�_get_exports_listr$,sH��7��F�N�N�#�#���7��v�;�6�;�a�!�A�$�#�+��;��6�6�7�s��A�
A�A�	A�
A�posix�
)�*)�_exitr()�_have_functions�ntz
zno os specific module foundzos.path)rrrrr
rrr
r)c�`�|tvr&|tvrtjt|�yyyr)�_globalsr)�_set�add)�str�fns  r�_addr1hs'���(�N���!7��H�H�X�b�\�"�"8�Nr�HAVE_FACCESSAT�access�
HAVE_FCHMODAT�chmod�
HAVE_FCHOWNAT�chown�HAVE_FSTATAT�stat�HAVE_FUTIMESAT�utime�HAVE_LINKAT�link�HAVE_MKDIRAT�mkdir�
HAVE_MKFIFOAT�mkfifo�HAVE_MKNODAT�mknod�HAVE_OPENAT�open�HAVE_READLINKAT�readlink�
HAVE_RENAMEAT�rename�HAVE_SYMLINKAT�symlink�
HAVE_UNLINKAT�unlink�rmdir�HAVE_UTIMENSAT�HAVE_FCHDIR�chdir�HAVE_FCHMOD�HAVE_FCHOWN�HAVE_FDOPENDIR�listdir�scandir�HAVE_FEXECVE�execve�HAVE_FTRUNCATE�truncate�
HAVE_FUTIMENS�HAVE_FUTIMES�HAVE_FPATHCONF�pathconf�statvfs�fstatvfs�
HAVE_FSTATVFS�
HAVE_LCHFLAGS�chflags�HAVE_LCHMOD�lchown�HAVE_LCHOWN�HAVE_LUTIMES�
HAVE_LSTAT�
MS_WINDOWS��Fc��tj|�\}}|stj|�\}}|rQ|rOtj|�s:	t||��t
}t
|t�rtt
d�}||k(ry	t||�y#t$rY�EwxYw#t$r|rtj|�s�YywxYw)a�makedirs(name [, mode=0o777][, exist_ok=False])

    Super-mkdir; create a leaf directory and all intermediate ones.  Works like
    mkdir, except that any intermediate path segment (not just the rightmost)
    will be created if it does not exist. If the target directory already
    exists, raise an OSError if exist_ok is False. Otherwise no exception is
    raised.  This is recursive.

    )�exist_ok�ASCIIN)r�split�exists�makedirs�FileExistsErrorr�
isinstance�bytesr?�OSError�isdir)r�moderm�head�tail�cdirs      rrqrq�s������D�!�J�D�$���Z�Z��%�
��d���T�[�[��.�	��T�H�-����d�E�"����)�D��4�<���
�d�D����	��	�����t�z�z�$�/�� 0��s$�

B�B#�	B �B �#!C�Cc��t|�tj|�\}}|stj|�\}}|r.|r+	t|�tj|�\}}|r|r�)yyyy#t$rYywxYw)a�removedirs(name)

    Super-rmdir; remove a leaf directory and all empty intermediate
    ones.  Works like rmdir except that, if the leaf directory is
    successfully removed, directories corresponding to rightmost path
    segments will be pruned away until either the whole path is
    consumed or an error occurs.  Errors during this latter phase are
    ignored -- they generally mean that a directory was not empty.

    N)rNrroru)rrxrys   r�
removedirsr|�sx��
�$�K����D�!�J�D�$���Z�Z��%�
��d�
�4�	��$�K��Z�Z��%�
��d��4�$�4�$���	��	�s�A/�/	A;�:A;c��tj|�\}}|r"|r tj|�st|�t	||�tj|�\}}|r|r
	t|�yyy#t$rYywxYw)a<renames(old, new)

    Super-rename; create directories as necessary and delete any left
    empty.  Works like rename, except creation of any intermediate
    directories needed to make the new pathname good is attempted
    first.  After the rename, directories corresponding to rightmost
    path segments of the old name will be pruned until either the
    whole path is consumed or a nonempty directory is found.

    Note: this function can fail with the new directory structure made
    if you lack permissions needed to unlink the leaf directory or
    file.

    N)rrorprqrIr|ru)�old�newrxrys    r�renamesr��st�����C��J�D�$���T�[�[��.����
�3������C��J�D�$���	��t���t���	��	�s�&A4�4	B�?B)rqr|r�c#�K�tjd||||�t|�g}tjtj
}}|r�|j
�}t|t�r|���'g}g}g}		t|�}
d}|
5			t|
�}
		|tur&|
jd��xr|
j�}n|
j�}|r|j!|
j"�n|j!|
j"�|s8|r6|rd}n	|
j%�}|}|r|	j!|
j���yy#t$r}|�||�Yd}~��d}~wwxYw#t$rYnHwxYw#t$r}|�||�d}Yd}~n*d}~wwxYw#t$rd}Y��wxYw#t$rd}Y��wxYwddd�n#1swYnxYw|r���|r=|||f��t'|�D]'}|||�}|s	||�r�|j!|��)n5|j!|||f�t'|	�D]}|j!|��|r����	�w)a&Directory tree generator.

    For each directory in the directory tree rooted at top (including top
    itself, but excluding '.' and '..'), yields a 3-tuple

        dirpath, dirnames, filenames

    dirpath is a string, the path to the directory.  dirnames is a list of
    the names of the subdirectories in dirpath (including symlinks to directories,
    and excluding '.' and '..').
    filenames is a list of the names of the non-directory files in dirpath.
    Note that the names in the lists are just names, with no path components.
    To get a full path (which begins with top) to a file or directory in
    dirpath, do os.path.join(dirpath, name).

    If optional arg 'topdown' is true or not specified, the triple for a
    directory is generated before the triples for any of its subdirectories
    (directories are generated top down).  If topdown is false, the triple
    for a directory is generated after the triples for all of its
    subdirectories (directories are generated bottom up).

    When topdown is true, the caller can modify the dirnames list in-place
    (e.g., via del or slice assignment), and walk will only recurse into the
    subdirectories whose names remain in dirnames; this can be used to prune the
    search, or to impose a specific order of visiting.  Modifying dirnames when
    topdown is false has no effect on the behavior of os.walk(), since the
    directories in dirnames have already been generated by the time dirnames
    itself is generated. No matter the value of topdown, the list of
    subdirectories is retrieved before the tuples for the directory and its
    subdirectories are generated.

    By default errors from the os.scandir() call are ignored.  If
    optional arg 'onerror' is specified, it should be a function; it
    will be called with one argument, an OSError instance.  It can
    report the error to continue with the walk, or raise the exception
    to abort the walk.  Note that the filename is available as the
    filename attribute of the exception object.

    By default, os.walk does not follow symbolic links to subdirectories on
    systems that support them.  In order to get this functionality, set the
    optional argument 'followlinks' to true.

    Caution:  if you pass a relative pathname for top, don't change the
    current working directory between resumptions of walk.  walk never
    changes the current directory, and assumes that the client doesn't
    either.

    Example:

    import os
    from os.path import join, getsize
    for root, dirs, files in os.walk('python/Lib/email'):
        print(root, "consumes ")
        print(sum(getsize(join(root, name)) for name in files), end=" ")
        print("bytes in", len(files), "non-directory files")
        if 'CVS' in dirs:
            dirs.remove('CVS')  # don't visit CVS directories

    zos.walkNFT��follow_symlinks)�sys�audit�fspathr�islink�join�poprs�tuplerVru�next�
StopIteration�_walk_symlinks_as_files�is_dir�is_junction�appendr�
is_symlink�reversed)�top�topdown�onerror�followlinks�stackr�r��dirs�nondirs�	walk_dirs�
scandir_it�error�cont�entryr��	walk_intor��dirname�new_paths                   r�walkr�sU����x�I�I�i��g�w��<�
�C�[�M�E��;�;��	�	�D�F�
��i�i�k���c�5�!��I�������	�	� ���J���
��	�� $�Z� 0��#�"�&=�=�!&���e��!D�!`�U�M^�M^�M`�I`��!&�������K�K��
�
�+��N�N�5�:�:�.��6�#�$(�	�/�).�)9�)9�);�J�)3�N�	� �!�(�(����4�W��1��"�	��"������	��)��������*�����D���	���#�#�F�#��$ '�/�*/�J�	/��I�Z�Z��Z����t�W�$�$�#�D�>����W�-��
�f�X�&6��L�L��*�*�
�L�L�#�t�W�-�.�$�Y�/�����X�&�0�o�s��A3I�6E
�I�G�	E+�G�>F�AG�F-�'!G�I�
	E(�
E#�I�#E(�(I�+	E7�4E:�5G�6E7�7E:�:	F�F�G�F�G�F*�'G�)F*�*G�-F;�8G�:F;�;G�>	I�G�5I�AIr��r��dir_fdc#�K�tjd|||||�t|�}td|||dffg}t	|t
�}	|rt
|||||�Ed{���|r�|r+|j�\}}|tk(rt|�|r�*yy7�5#|r+|j�\}}|tk(rt|�|r�*wwxYw�w)aDirectory tree generator.

        This behaves exactly like walk(), except that it yields a 4-tuple

            dirpath, dirnames, filenames, dirfd

        `dirpath`, `dirnames` and `filenames` are identical to walk() output,
        and `dirfd` is a file descriptor referring to the directory `dirpath`.

        The advantage of fwalk() over walk() is that it's safe against symlink
        races (when follow_symlinks is False).

        If dir_fd is not None, it should be a file descriptor open to a directory,
          and top should be relative; top will then be relative to that directory.
          (dir_fd is always supported for fwalk.)

        Caution:
        Since fwalk() yields file descriptors, those are only valid until the
        next iteration step, so you should dup() them if you want to keep them
        for a longer period.

        Example:

        import os
        for root, dirs, files, rootfd in os.fwalk('python/Lib/email'):
            print(root, "consumes", end="")
            print(sum(os.stat(name, dir_fd=rootfd).st_size for name in files),
                  end="")
            print("bytes in", len(files), "non-directory files")
            if 'CVS' in dirs:
                dirs.remove('CVS')  # don't visit CVS directories
        zos.fwalkTN)
r�r�r��_fwalk_walkrsrt�_fwalkr��_fwalk_close�close)	r�r�r�r�r�r��isbytes�action�values	         r�fwalkr��s�����B	�	�	�*�c�7�G�_�f�M��S�k����f�c�3��=�>�?���S�%�(��	!��!�%��'�7�O�T�T�T��� %�	�	��
����\�)��%�L��U��� %�	�	��
����\�)��%�L��s<�AC�B�B�B�#+C�C�B�,C�C�Cc
#����K�|j�\}}|tk(rt|�y|tk(r|��y|tk(sJ�|\}}�}	}
	|s#|
�t|	d|��}n|
jd��}t
|	ttz|���|jt�f�|sB|r tjj�sytjt���syt!��}
g}g}|s|rdng}|
D]b}
|
j"}|rt%|�}	|
j'�r%|j|�|�#|j|
�n|j|��d|r	�||�f��n|jt�||�ff�tj*��dd��|�"|j-��fd�|ddd�D��y|j-��fd�t/|ddd�|ddd��D��y#t$r}|r�|�||�Yd}~yd}~wwxYw#t$r6	|
j)�r|j|�n#t$rYnwxYwY��[wxYw�w)	NFr�r�)r�rc3�>�K�|]}td��|z|dff���y�w�FN�r�)�.0r�topfd�toppaths  ��r�	<genexpr>z_fwalk.<locals>.<genexpr>2s-�����(�&�D��u�e�W�t�^�T�4�H�I�&�s����c3�D�K�|]\}}td��|z||ff���y�wr�r�)r�rr�r�r�s   ��rr�z_fwalk.<locals>.<genexpr>6s2�����C�#A�K�D�%��u�e�W�t�^�T�5�I�J�#A�s� )r�r�r��_fwalk_yieldr�r9rE�O_RDONLY�
O_NONBLOCKrur��st�S_ISDIR�st_moder�samestatrVrrr�r�r��extend�zip)r�r�r�r�r�r�r��isroot�dirfd�topnamer��orig_st�errr�r�r��entriesrr�r�s                  @@rr�r��sT�����
�	�	��
����\�!��%�L��
�|�
#��K����$�$�$�16�.���w���	�"��=�"�7�E�%�P�G�#�j�j��j�?�G���(�Z�"7��F�E�	���l�E�*�+���b�j�j����9���=�=��$�u�+�6���U�^�
�����!�_�$�"���E��:�:�D����~��

��<�<�>��K�K��%��*����u�-��N�N�4�(�� �&��4��%�/�/��L�L�,��$���(G�H�I��)�)�G�W�R�a�[�1���?��L�L�(� ��2��J�(�
(�
�L�L�C�#&�t�D�b�D�z�7�4�R�4�=�#A�C�
C��_�	����"������	��8�
���'�'�)����t�,�������
�s{�A
I �>G;�
BI �AH�$BI �;	H�
H�I �H�I �	I�(!I
�	I�
	I�I�I�I�I �I�I r�c��t||�y)zpexecl(file, *args)

    Execute the executable file with argument list args, replacing the
    current process. N)�execv��file�argss  r�execlr�<s��

�$��rc�.�|d}t||dd|�y)z�execle(file, *args, env)

    Execute the executable file with argument list args and
    environment env, replacing the current process. r�N)rX�r�r��envs   r�execler�Cs��
�r�(�C�
�4��c�r��C� rc��t||�y)z�execlp(file, *args)

    Execute the executable file (which is searched for along $PATH)
    with argument list args, replacing the current process. N)�execvpr�s  r�execlpr�Ks��
�4��rc�.�|d}t||dd|�y)z�execlpe(file, *args, env)

    Execute the executable file (which is searched for along $PATH)
    with argument list args and environment env, replacing the current
    process. r�N)�execvper�s   r�execlper�Rs���r�(�C��D�$�s��)�S�!rc��t||�y)z�execvp(file, args)

    Execute the executable file (which is searched for along $PATH)
    with argument list args, replacing the current process.
    args may be a list or tuple of strings. N��_execvper�s  rr�r�[s��
�T�4�rc��t|||�y)z�execvpe(file, args, env)

    Execute the executable file (which is searched for along $PATH)
    with argument list args and environment env, replacing the
    current process.
    args may be a list or tuple of strings. Nr�r�s   rr�r�cs��
�T�4��r)r�r�r�r�r�r�c��|�t}||f}nt}|f}t}tj|�r
||g|���yd}t|�}tdk7rt|�}tt|�}|D]"}tj||�}	||g|����$|�|�
�#ttf$r}	|	}
Yd}	~	�Ad}	~	wt$r}	|	}
|�|	}Yd}	~	�Xd}	~	wwxYw)Nr*)
rXr��environrr�rrr�mapr��FileNotFoundError�NotADirectoryErrorru)r�r�r��	exec_func�argrest�	saved_exc�	path_listr!�fullname�e�last_excs           rr�r�ns���
���	���+���	��'�����|�|�D���$�!��!���I��c�"�I��t�|���~����)�,�	����9�9�S�$�'��	��h�)��)������
�N��"�#5�6�	��H���	��H�� ��	���	�s$�		B�C�)B0�0C�<C�Cc��ddl}|�t}|j�5|jdt�	|jd�}tr2	|d}|�td��|}|�t|t�rt|�}ddd��t}|jt�S#t$rd}Y�jwxYw#ttf$rY�dwxYw#1swY�LxYw)z�Returns the sequence of directories that will be searched for the
    named executable (similar to a shell) when launching a process.

    *env* must be an environment variable dict or None.  If *env* is None,
    os.environ will be used.
    rN�ignore�PATHsPATHz*env cannot contain 'PATH' and b'PATH' keys)�warningsr��catch_warnings�simplefilter�BytesWarning�get�	TypeError�supports_bytes_environ�
ValueError�KeyErrorrsrtrr
ror)r�r�r��
path_listbs    rrr�s����
�{���
�	 �	 �	"����h��5�	������I�"�
'� ��\�
��(�$�D�F�F�&�	��$��I�u�)E�$�Y�/�	�)
#�,���	��?�?�7�#�#��'�	��I�	���i�(�
��
��
#�	"�sR�C	�B#�C	�
B4�,C	�#B1�.C	�0B1�1C	�4C�C	�C�C	�	C)�MutableMapping�Mappingc�T�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zy
)�_Environc�J�||_||_||_||_||_yr)�	encodekey�	decodekey�encodevalue�decodevalue�_data)�self�datar�r�r�r�s      r�__init__z_Environ.__init__�s'��"���"���&���&�����
rc��	|j|j|�}|j|�S#t$r
t|�d�wxYwr)r�r�r�r��r��keyr�s   r�__getitem__z_Environ.__getitem__�sN��	*��J�J�t�~�~�c�2�3�E�����&�&���	*��3�-�T�)�	*�s	�1�Ac�~�|j|�}|j|�}t||�||j|<yr)r�r��putenvr�rs   r�__setitem__z_Environ.__setitem__�s7���n�n�S�!��� � ��'���s�E����
�
�3�rc��|j|�}t|�	|j|=y#t$r
t|�d�wxYwr)r��unsetenvr�r�)r�r�
encodedkeys   r�__delitem__z_Environ.__delitem__�sD���^�^�C�(�
����	*��
�
�:�&���	*��3�-�T�)�	*�s	�
,�Ac#�jK�t|j�}|D]}|j|����y�wr)rr�r�)r��keysrs   r�__iter__z_Environ.__iter__�s-�����D�J�J����C��.�.��%�%��s�13c�,�t|j�Sr)�lenr��r�s r�__len__z_Environ.__len__�s���4�:�:��rc�t��dj�fd��jj�D��}d|�d�S)Nz, c3�n�K�|],\}}�j|��d�j|������.y�w)z: N)r�r�)r�rr�r�s   �rr�z$_Environ.__repr__.<locals>.<genexpr>�s>�����$
�0�
��U��~�~�c�"�%�R��(8�(8��(?�'B�C�0�s�25z	environ({z}))r�r��items)r��formatted_itemss` r�__repr__z_Environ.__repr__�s=����)�)�$
�"�j�j�.�.�0�$
�
���O�,�C�0�0rc��t|�Sr)�dictrs r�copyz
_Environ.copy�s���D�z�rc��||vr|||<||Sr�rs   r�
setdefaultz_Environ.setdefault�s���d�?��D��I��C�y�rc�(�|j|�|Sr)�update)r��others  r�__ior__z_Environ.__ior__�s�����E���rc�j�t|t�stSt|�}|j	|�|Sr�rsr��NotImplementedrr�r�r rs   r�__or__z_Environ.__or__�s,���%��)�!�!��4�j���
�
�5���
rc�j�t|t�stSt|�}|j	|�|Srr#r%s   r�__ror__z_Environ.__ror__�s,���%��)�!�!��5�k���
�
�4���
rN)�__name__�
__module__�__qualname__rrrrrrrrrr!r&r(rrrr�r��s>���'� �*�&��1���
��rr�c����tdk(r:d�}|�t}�fd�}i}tj�D]\}}||||�<�n&t	j
���fd���fd�}�}t}t
|||�|�S)Nr*c�h�t|t�s!tdt|�jz��|S)N�str expected, not %s)rsr/r��typer)�r�s r�	check_strz!_createenviron.<locals>.check_str	s,���e�S�)�� 6��e��9M�9M� M�N�N��Lrc�0���|�j�Sr)�upper)r�encodes �rr�z!_createenviron.<locals>.encodekeys����#�;�$�$�&�&rc���t|t�s!tdt|�jz��|j�d�S)Nr.�surrogateescape)rsr/r�r/r)r4�r��encodings �rr4z_createenviron.<locals>.encodes:����e�S�)�� 6��e��9M�9M� M�N�N��<�<��*;�<�<rc�(��|j�d�S)Nr6)�decoder7s �rr:z_createenviron.<locals>.decodes����<�<��*;�<�<r)rr/r�rr��getfilesystemencodingr�)r1r:r�r�rr�r4r8s      @@r�_createenvironr<s�����t�|�	�����	'���!�-�-�/�J�C��#(�D��3�� �*��,�,�.��	=�	=��	����D��6����rc�.�tj||�S)z�Get an environment variable, return None if it doesn't exist.
    The optional second argument can specify an alternate default.
    key, default and the result are str.)r�r��r�defaults  r�getenvr@(s���;�;�s�G�$�$r)r@r�c�h�t|t�s!tdt|�jz��|S)Nzbytes expected, not %s)rsrtr�r/r)r0s r�_check_bytesrB2s,���%��'��4�t�E�{�7K�7K�K�L�L��rc�.�tj||�S)z�Get an environment variable, return None if it doesn't exist.
        The optional second argument can specify an alternate default.
        key, default and the result are bytes.)�environbr�r>s  r�getenvbrE=s���|�|�C��)�)r)rDrEc�v���tj��tj����fd�}��fd�}||fS)Nc�b��t|�}t|t�r|j���S|S)aEncode filename (an os.PathLike, bytes, or str) to the filesystem
        encoding with 'surrogateescape' error handler, return bytes unchanged.
        On Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).
        )r�rsr/r4��filenamer8�errorss ��rrz_fscodec.<locals>.fsencodeIs/����(�#���h��$��?�?�8�V�4�4��Orc�b��t|�}t|t�r|j���S|S)aDecode filename (an os.PathLike, bytes, or str) from the filesystem
        encoding with 'surrogateescape' error handler, return str unchanged. On
        Windows, use 'strict' error handler if the file system encoding is
        'mbcs' (which is the default encoding).
        )r�rsrtr:rHs ��rrz_fscodec.<locals>.fsdecodeUs/����(�#���h��&��?�?�8�V�4�4��Or)r�r;�getfilesystemencodeerrors)rrr8rJs  @@r�_fscodecrMEs6����(�(�*�H�
�
*�
*�
,�F�
�
��X��r�fork�spawnvr�)�P_WAIT�P_NOWAIT�	P_NOWAITOc�:�t|ttf�std��|r|dst	d��t�}|s	|�
|||�n||||�yy|tk(r|S	t|d�\}}t|�r�t|�S#t
d�YyxYw)Nzargv must be a tuple or a listrz"argv first element cannot be empty�)rsr�rr�r�rNr(rQ�waitpid�
WIFSTOPPED�waitstatus_to_exitcode)rwr�r�r��func�pid�wpid�stss        r�	_spawnvefr\rs����$���
�.��<�=�=��4��7��A�B�B��f���
��;���t�$���t�S�)�%��x���
��#�C��O�	��c��c�?��-�c�2�2��
��c�
�s�B�
Bc�(�t|||dt�S)aspawnv(mode, file, args) -> integer

Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. N)r\r��rwr�r�s   rrOrO�s����t�T�4��7�7rc�(�t||||t�S)a:spawnve(mode, file, args, env) -> integer

Execute file with arguments from args in a subprocess with the
specified environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. )r\rX�rwr�r�r�s    r�spawnvera�s����t�T�3��7�7rc�(�t|||dt�S)a8spawnvp(mode, file, args) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. N)r\r�r^s   r�spawnvprc�s����t�T�4��8�8rc�(�t||||t�S)a\spawnvpe(mode, file, args, env) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. )r\r�r`s    r�spawnvpere�s����t�T�3��8�8r)rOrarcrec��t|||�S)aspawnl(mode, file, *args) -> integer

Execute file with arguments from args in a subprocess.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. )rOr^s   r�spawnlrg�s���d�D�$�'�'rc�.�|d}t|||dd|�S)a:spawnle(mode, file, *args, env) -> integer

Execute file with arguments from args in a subprocess with the
supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. r�N)rar`s    r�spawnleri�s$���2�h���t�T�4���9�c�2�2rrgrircc��t|||�S)aWspawnlp(mode, file, *args) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. )rcr^s   r�spawnlprk�s���t�T�4�(�(rc�.�|d}t|||dd|�S)a]spawnlpe(mode, file, *args, env) -> integer

Execute file (which is looked for along $PATH) with arguments from
args in a subprocess with the supplied environment.
If mode == P_NOWAIT return the pid of the process.
If mode == P_WAIT return the process's exit code if it exits normally;
otherwise return -SIG, where SIG is the signal that killed it. r�N)rer`s    r�spawnlperm�s$���2�h����d�D��"�I�s�3�3rrkrm�vxworksc��t|t�stdt|�z��|dvrt	d|z��|dk(s|�t	d��ddl}|dk(r6|j
|dd|j|��}t|j|�S|j
|dd|j|�	�}t|j|�S)
Nz&invalid cmd type (%s, expected string))�r�wzinvalid mode %rrz+popen() does not support unbuffered streamsrpT)�shell�text�stdout�bufsize)rrrs�stdinru)rsr/r�r/r��
subprocess�Popen�PIPE�_wrap_closertrv)�cmdrw�	bufferingrw�procs     r�popenr~�s����#�s�#��D�t�C�y�P�Q�Q��z�!��.��5�6�6���>�Y�.��J�K�K���3�;��#�#�C�*.�T�+5�?�?�,5�$�7�D��t�{�{�D�1�1��#�#�C�*.�T�*4�/�/�,5�$�7�D��t�z�z�4�0�0rc�0�eZdZd�Zd�Zd�Zd�Zd�Zd�Zy)rzc� �||_||_yr)�_stream�_proc)r��streamr}s   rrz_wrap_close.__init__s��!�D�L��D�Jrc��|jj�|jj�}|dk(rytdk(r|S|dzS)Nrr*�)r�r�r��waitr)r��
returncodes  rr�z_wrap_close.closesC���L�L��� ������*�J��Q����t�|�!�!�!�Q��&rc��|Srrrs r�	__enter__z_wrap_close.__enter__����Krc�$�|j�yr�r��r�r�s  r�__exit__z_wrap_close.__exit__����J�J�Lrc�.�t|j|�Sr)�getattrr�)r�rs  r�__getattr__z_wrap_close.__getattr__s���4�<�<��.�.rc�,�t|j�Sr)�iterr�rs rrz_wrap_close.__iter__s������%�%rN)	r)r*r+rr�r�r�r�rrrrrzrzs ��	�	'�	�	�	/�	&rrzr~c��t|t�stdt|�z��ddl}d|vr|j|�}|j||||g|��i|��S)Nz&invalid fd type (%s, expected integer)r�b)rs�intr�r/�io�
text_encodingrE)�fdrwr|r8r��kwargsr�s       rrr$s\���b�#���@�4��8�K�L�L�
�
�$���#�#�H�-���2�7�7�2�t�Y��B�4�B�6�B�Brc�p�t|ttf�r|St|�}	|j	|�}t|ttf�r|Stdj|jt|�j���#t
$r&t
|d�r�td|jz��wxYw)aaReturn the path representation of a path-like object.

    If str or bytes is passed in, it is returned unchanged. Otherwise the
    os.PathLike interface is used to get the path representation. If the
    path representation is not str or bytes, TypeError is raised. If the
    provided path is not str, bytes, or os.PathLike, TypeError is raised.
    �
__fspath__z/expected str, bytes or os.PathLike object, not z7expected {}.__fspath__() to return str or bytes, not {})
rsr/rtr/r�r �hasattrr�r)�format)r�	path_type�	path_reprs   r�_fspathr�/s����$��e��%����T�
�I�9��(�(��.�	��)�c�5�\�*����!�!'��	�(:�(:�(,�Y��(@�(@�"B�C�	C���9��9�l�+���#�%.�%7�%7�8�9�
9�	9�s�B�/B5r�c�T�eZdZdZej
d��Zed��Zee	�Z
y)�PathLikezCAbstract base class for implementing the file system path protocol.c��t�)z9Return the file system path representation of the object.)�NotImplementedErrorrs rr�zPathLike.__fspath__Ws
��"�!rc�6�|turt|d�StS)Nr�)r�rr$)�cls�subclasss  r�__subclasshook__zPathLike.__subclasshook__\s���(�?�!�(�L�9�9��rN)r)r*r+�__doc__�abc�abstractmethodr��classmethodr��GenericAlias�__class_getitem__rrrr�r�Ss>��M����"��"�����
$�L�1�rr�c�*�eZdZd�Zd�Zd�Zd�Zd�Zy)�_AddedDllDirectoryc�.�||_||_||_yr)r�_cookie�_remove_dll_directory)r�r�cookie�remove_dll_directorys    rrz_AddedDllDirectory.__init__gs���D�I�!�D�L�)=�D�&rc�H�|j|j�d|_yr)r�r�rrs rr�z_AddedDllDirectory.closeks���&�&�t�|�|�4��D�Irc��|Srrrs rr�z_AddedDllDirectory.__enter__nr�rc�$�|j�yrr�r�s  rr�z_AddedDllDirectory.__exit__pr�rc�R�|jrdj|j�Sy)Nz<AddedDllDirectory({!r})>z<AddedDllDirectory()>)rr�rs rrz_AddedDllDirectory.__repr__rs!���y�y�2�9�9�$�)�)�D�D�*rN)r)r*r+rr�r�r�rrrrr�r�fs��	>�	�	�	�	+rr�c�\�ddl}|j|�}t|||j�S)aOAdd a path to the DLL search path.

        This search path is used when resolving dependencies for imported
        extension modules (the module itself is resolved through sys.path),
        and also by ctypes.

        Remove the directory by calling close() on the returned object or
        using it in a with statement.
        rN)r*�_add_dll_directoryr�r�)rr*r�s   r�add_dll_directoryr�ws5��	�&��&�&�t�,��!����$�$�
�	
r)i�F)TNF)�.TNr)rpr�)rpr�N)nr�r�r�r9r��_collections_abcrr/rr�r��builtin_module_names�_namesrrr$rr	r%r(r��ImportError�	posixpathrr)r�r*�ntpath�modules�os.pathrrrrr
rrr
rr,r1�setr-�supports_dir_fd�supports_effective_idsr.�supports_fd�supports_follow_symlinksrrrrqr|r��objectr�r�rErVr�r�r�r�r�r�r�r�r�r�r�r�rr�r�r�r<r�r@r�rBr�rtrDrErMrrrPrQrRr\rOrarcrergrirkrm�platformr~rzrr�r�r)�ABCr�r�r�rrr�<module>r�s���0�
��+��D��I���	�	!�	!����
�7��f���D��G��
�����w���
�)���N�N�$�U�+�,�
�	�V�^��D��G��
�����w���
��N�N�$�R�(�)�
�
�&�
�3�
4�4�����I��
�
�
������y�H�#��5�D��	�H�%���G�$���G�$���F�#��	�G�$���F�#���G�$���H�%���G�$���F�#��	�J�'���H�%��	�I�&���H�%���G�$��	�G�$��O��5�D��	�H�%�!���5�D���G�$���G�$���G�$��	�I�&��	�I�&���H�%��H�H�T�N��	�J�'���G�$���G�$��	�J�'��y��g�j�1��_�i�(��K��5�D��	�H�%�,	��G�$���F�#���I�&���G�$��x���]�G�$���F�#���G�$���F�#���F�#��	�G�$���F�#�#������
������
�@&�,�4���4�5�!�(��X'�t���v���$�<�?�"����+�'E�-!�e�TX�-!�`�K��L��L�HC�T�N�N�7���!��"������G�H��@)$�Z5�G�~�G�R�<�
���%��$�,�����3�4�����
�
��e��e��H�	�*��N�N�*�+��<�Z���(���6�?�7�8�,���1A�
�F���H�y��N�N�6�7�3�68�8�9�9��N�N�?�@��8��(�	3��N�N�H�i�(�)��9��)�	4��N�N�I�z�*�+��<�<�9��1�,&�&�,�N�N�7��C�C�>�x��
�F��F�O�2�s�w�w�2�$�4�<�+�+�"
�%��U!�
��
���
��
���
��
���
��
�sH�S� S+�S7�	T�S(�'S(�+S4�3S4�7T�?T�T�T��`�dZdZdZdZdZdZdZdZdZddl	Z	ddl
Z
ddlZddlZdd	l�gd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zej(je_d�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zdadad�Z	ddl m!Z"d�Z$dd�d�Z%d �Z&e
jNd!k(Z(d$d"�Z)d#�Z*y#e#$rd�Z"Y�-wxYw)%a�Common operations on Posix pathnames.

Instead of importing this module directly, import os and refer to
this module as os.path.  The "os.path" name is an alias for this
module on Posix systems; on other systems (e.g. Windows),
os.path provides the same operations in a manner specific to that
platform, and is an alias to another module (e.g. ntpath).

Some of this can actually be useful on non-Posix systems too, e.g.
for manipulation of the pathname component of URLs.
�.�..�/�:z
/bin:/usr/binNz	/dev/null�)�*)(�normcase�isabs�join�
splitdrive�	splitroot�split�splitext�basename�dirname�commonprefix�getsize�getmtime�getatime�getctime�islink�exists�lexists�isdir�isfile�ismount�
expanduser�
expandvars�normpath�abspath�samefile�sameopenfile�samestat�curdir�pardir�sep�pathsep�defpath�altsep�extsep�devnull�realpath�supports_unicode_filenames�relpath�
commonpath�
isjunctionc�&�t|t�ryy)N�/r)�
isinstance�bytes��paths �<frozen posixpath>�_get_sepr7)s���$�����c�,�tj|�S)z6Normalize case of pathname.  Has no effect under Posix��os�fspath)�ss r6rr4s��
�9�9�Q�<�r8c�d�tj|�}t|�}|j|�S)zTest whether a path is absolute)r;r<r7�
startswith)r=r%s  r6r	r	<s'��
�	�	�!��A�
�1�+�C��<�<���r8c�j�tj|�}t|�}|}	|s|dd|zttj|�D]7}|j	|�r|}�|r|j|�r||z
}�0|||zz
}�9	|S#tttf$rtjd|g|����wxYw)z�Join two or more pathname components, inserting '/' as needed.
    If any component is an absolute path, all previous path components
    will be discarded.  An empty last part will result in a path that
    ends with a separator.Nrr
)r;r<r7�mapr?�endswith�	TypeError�AttributeError�BytesWarning�genericpath�_check_arg_types)�a�pr%r5�bs     r6r
r
Gs���
	�	�	�!��A�
�1�+�C��D�����!�H�s�N��R�Y�Y��"�A��|�|�C� ����T�]�]�3�/���	����a����
#��K��
�~�|�4���$�$�V�Q�3��3�
��s�AB�-B2c���tj|�}t|�}|j|�dz}|d|||d}}|r"||t	|�zk7r|j|�}||fS)z�Split a pathname.  Returns tuple "(head, tail)" where "tail" is
    everything after the final slash.  Either part may be empty.�N�r;r<r7�rfind�len�rstrip)rIr%�i�head�tails     r6r
r
dsk��	�	�	�!��A�
�1�+�C�	�����q��A��2�A���!�"��$�D����C��I�
�%��{�{�3�����:�r8c��tj|�}t|t�rd}d}nd}d}t	j
||d|�S)Nr1�.rr)r;r<r2r3rF�	_splitext)rIr%r)s   r6rrusD��
�	�	�!��A��!�U����������� � ��C��v�6�6r8c�:�tj|�}|dd|fS)zJSplit a pathname into drive and path. On Posix, drive is always
    empty.Nrr:)rIs r6rr�s ��	�	�	�!��A��R�a�5�!�8�Or8c��tj|�}t|t�rd}d}nd}d}|dd|k7r|||fS|dd|k7s|dd|k(r|||ddfS||dd|ddfS)	a�Split a pathname into drive, root and tail. On Posix, drive is always
    empty; the root may be empty, a single slash, or two slashes. The tail
    contains anything after the root. For example:

        splitroot('foo/bar') == ('', '', 'foo/bar')
        splitroot('/foo/bar') == ('', '/', 'foo/bar')
        splitroot('//foo/bar') == ('', '//', 'foo/bar')
        splitroot('///foo/bar') == ('', '/', '//foo/bar')
    r1r8r�NrL��)r;r<r2r3)rIr%�emptys   r6rr�s���	�	�	�!��A��!�U������������!�u��|��e�Q���	
�1�Q��3��!�A�a�&�C�-��c�1�Q�R�5� � ��a���e�Q�q�r�U�"�"r8c�t�tj|�}t|�}|j|�dz}||dS)z)Returns the final component of a pathnamerLN)r;r<r7rN)rIr%rQs   r6rr�s5��
�	�	�!��A�
�1�+�C�	�����q��A��Q�R�5�Lr8c��tj|�}t|�}|j|�dz}|d|}|r"||t	|�zk7r|j|�}|S)z-Returns the directory component of a pathnamerLNrM)rIr%rQrRs    r6rr�sZ��
�	�	�!��A�
�1�+�C�	�����q��A��R�a�5�D����C��I�
�%��{�{�3����Kr8c�.�tj|�y)zQTest whether a path is a junction
    Junctions are not a part of posix semanticsFr:r4s r6r/r/�s���I�I�d�O�r8c�Z�	tj|�y#ttf$rYywxYw)zCTest whether a path exists.  Returns True for broken symbolic linksFT)r;�lstat�OSError�
ValueErrorr4s r6rr�s0���
�������
�Z� ����s��*�*c��	tj|�}tj|j�rytj|�}t|t�r
t|d�}nt|d�}t|�}	tj|�}|j}|j}||k7ry|j}|j}||k(ryy#t
tf$rYywxYw#t
tf$rYywxYw)z$Test whether a path is a mount pointF�..rT)r;ra�stat�S_ISLNK�st_moderbrcr<r2r3r
r+�st_dev�st_ino)r5�s1�parent�s2�dev1�dev2�ino1�ino2s        r6rr�s����
�X�X�d�^���<�<��
�
�#��
�9�9�T�?�D��$����d�E�"���d�D�!��
�f�
�F��
�X�X�f�
���9�9�D�
�9�9�D��t�|��
�9�9�D�
�9�9�D��t�|����7
�Z� ����� 
�Z� ����s#�C�C(�C%�$C%�(C:�9C:c�r�tj|�}t|t�rd}nd}|j	|�s|St|�}|j
|d�}|dkrt|�}|dk(rZdtjvr4	ddl	}	|jtj��j}natjd}nM	ddl	}|d|}t|t�rtj|�}	|j!|�}|j}|�t"j$dk(r|St|t�rtj&|�}d}nd	}|j)|�}|||dzxs|S#t$r|cYSwxYw#t$r|cYSwxYw#t$r|cYSwxYw#t$r|cYSwxYw)
zOExpand ~ and ~user constructions.  If user or $HOME is unknown,
    do nothing.�~�~rLr�HOMEN�vxworksr1r)r;r<r2r3r?r7�findrO�environ�pwd�ImportError�getpwuid�getuid�pw_dir�KeyError�fsdecode�getpwnam�sys�platform�fsencoderP)	r5�tilder%rQry�userhome�name�pwent�roots	         r6rrs����9�9�T�?�D��$��������?�?�5�!���
�4�.�C��	�	�#�q��A��1�u���I���A�v�����#�
��
��<�<��	�	��4�;�;���z�z�&�)�H�	���A�a�y���d�E�"��;�;�t�$�D�	��L�L��&�E�
�<�<����C�L�L�I�5����$����;�;�x�(���������t�$�H��t�A�B�x��(�D�(��I�
���
��
�
���
���	��K�	���	��K�	�sH�E5�-F�F�:F(�5F�F�F�F�F%�$F%�(F6�5F6c�,�tj|�}t|t�rRd|vr|Sts ddl}|j
d|j�atj}d}d}ttdd�}nPd|vr|Sts ddl}|j
d	|j�a
tj}d
}d}tj}d}	|||�}|s	|S|jd�\}}|jd�}	|	j|�r|	j|�r|	dd
}		|�:tj tjtj"|	��}
n||	}
||d}|d||
z}t%|�}||z
}��#t&$r|}Y�wxYw)zZExpand shell variables of form $var and ${var}.  Unknown variables
    are left unchanged.�$rNs\$(\w+|\{[^}]*\})�{�}�environb�$z\$(\w+|\{[^}]*\})�{�}rL���)r;r<r2r3�	_varprogb�re�compile�ASCII�search�getattr�_varprogrx�span�groupr?rBr�rrOr~)r5r�r��start�endrxrQ�m�jr��valuerSs            r6rr@s����9�9�T�?�D��$����t���K����
�
�#8�"�(�(�C�I��!�!�������"�j�$�/���d�?��K����z�z�"6����A�H����������*�*��	�A�
��4��O����"�K�!�v�v�a�y���1��w�w�q�z���?�?�5�!�d�m�m�C�&8���"�:�D�	������B�J�J�r�{�{�4�/@�$A�B����
�����8�D����8�e�#�D��D�	�A��D�L�D�'���	��A�	�s�&AF�F�F)�_path_normpathc��tj|�}t|t�r	d}d}d}d}nd}d}d}d}||k(r|St	|�\}}}|j|�}g}|D]A}	|	||fvr�
|	|k7s|s|r
|r|d	|k(r|j
|	��/|s�2|j��C|}||j|�z}|xs|S)
z0Normalize path, eliminating double slashes, etc.r1r8rUrerrYrrr�)	r;r<r2r3rr
�append�popr
)
r5r%r\�dot�dotdot�_�initial_slashes�comps�	new_comps�comps
          r6rrys����y�y�����d�E�"��C��E��C��F��C��E��C��F��5�=��J�#,�T�?� ��?�D��
�
�3����	��D���s�|�#������y��	�"�
�� 7�� � ��&���
�
���������%��0���{�s�r8c���tj|�}t|�sEt|t�rtj
�}ntj�}t||�}t|�S)zReturn an absolute path.)	r;r<r	r2r3�getcwdb�getcwdr
r)r5�cwds  r6rr�sK��
�9�9�T�?�D���;��d�E�"��*�*�,�C��)�)�+�C��C�����D�>�r8F)�strictc�j�tj|�}t|dd||i�\}}t|�S)zlReturn the canonical path of the specified filename, eliminating any
symbolic links encountered in the path.Nr)r;r<�
_joinrealpathr)�filenamer�r5�oks    r6r+r+�s6���y�y��"�H��X�b�q�\�8�V�R�@�H�D�"��4�=�r8c��t|t�rd}d}d}nd}d}d}t|�r|dd}|}|�r|j|�\}}}|r||k(r� ||k(r&|r!t	|�\}}||k(rt|||�}n|}�Kt||�}		t
j|	�}
tj|
j�}|s|	}��|	|vr.||	}|���|rt
j|	�nt|	|�dfSd||	<t|t
j|	�||�\}}|st||�dfS|||	<|r��|d	fS#t$r|r�d}Y��wxYw)
Nr1rUrerrrrLFT)r2r3r	�	partitionr
r
r;rarfrgrhrbr��readlink)
r5�restr��seenr%r#r$r�r��newpath�st�is_linkr�s
             r6r�r��s����$����������������T�{��A�B�x����
����s�+�
��a���t�v�~���6�>��"�4�[�
��d��6�>���f�f�5�D�����t�T�"��	/����'�"�B��l�l�2�:�:�.�G���D���d�?���=�D��������� ��G�T�*�E�1�1���W�
� ��r�{�{�7�';�V�T�J���b����d�#�U�*�*���W�
�Y�\��:���;�	����G�	�s�D9�9E
�	E
�darwinc�P�|std��tj|�}t|t�rd}d}d}nd}d}d}|�|}ntj|�}	t|�j
|�D�cgc]}|s�|��	}}t|�j
|�D�cgc]}|s�|��	}}tt||g��}|gt|�|z
z||dz}	|	s|St|	�Scc}wcc}w#ttttf$rtjd	||��wxYw)
z#Return a relative version of a pathzno path specifiedrUr1rerrrNr-)rcr;r<r2r3rr
rOrr
rCrDrE�DeprecationWarningrFrG)
r5r�r#r%r$�x�
start_list�	path_listrQ�rel_lists
          r6r-r-�s2����,�-�-�
�9�9�T�?�D��$����������������}����	�	�%� ���!(���!5�!5�c�!:�@�!:�A�a�a�!:�
�@� '��
� 3� 3�C� 8�>� 8�1�A�Q� 8�	�>���j�)�4�5�6���8�s�:��q�0�1�I�a�b�M�A����M��X����A��>��
�~�|�5G�H���$�$�Y��e�<�
��s<�C3�7C)�?C)�C3�!C.�)C.�-3C3�!C3�)
C3�32D%c	���|std��tttj|��}t|dt�rd�d}nd�d}	|D�cgc]}|j����}}	t�fd�|D��\}|D��cgc]}|D�cgc]
}|s�||k7s�|��c}��}}}t|�}t|�}|}	t|�D]\}
}|||
k7s�|d	|
}	n|r�n�d	d}|�j|	�zScc}w#t$r
td�d	�wxYwcc}wcc}}w#ttf$rtj d
g|����wxYw)zDGiven a sequence of path names, returns the longest common sub-path.z%commonpath() arg is an empty sequencerr1rUrrc3�.�K�|]}|dd�k(���y�w)NrL�)�.0rIr%s  �r6�	<genexpr>zcommonpath.<locals>.<genexpr>,s�����5�u�!��2�A��#��u�s�z%Can't mix absolute and relative pathsNr.)rc�tuplerAr;r<r2r3r
�set�min�max�	enumerater
rCrDrFrG)
�pathsr#r5�split_pathsr	r=�crkrm�commonrQ�prefixr%s
            @r6r.r.su�����@�A�A��#�b�i�i��'�(�E��%��(�E�"����������38�9�5�4�t�z�z�#��5��9�	P��5�u�5�5�F�E�EP�P�K�q�1�:�1�a��a�6�k��1�:�K��P�
��
��
��
�����b�M�D�A�q��B�q�E�z��B�Q����"�
��3�r��7�������(�(�(��#:���	P��D�E�4�O�	P��;��P��
�~�&���$�$�\�:�E�:�
��sl�D,�D�+D,�.D�D,�		D&�D!�D!� D!�$D&�)4D,�$D,�D,�D�D,�!D&�&D,�,'E)N)+�__doc__r#r$r)r%r&r'r(r*r;r�rfrF�__all__r7rr	r
r
rrVrrrrr/rrrr�r�r�posixr�rrzrr+r�r�r,r-r.r�r8r6�<module>r�s��
�

��	
��	��	��

��
��	
��
��	�
����'������:	�"7��(�(�0�0���
�#�>�����V6)�z���	�.�j �0�D	�"'��<�~"�l�l�h�6��!�R#��E����s�9B"�"B-�,B-���dZdZdZdZdZdZdZdZdZdd	l	Z	dd	l
Z
dd	lZdd	lZdd
l�gd�Z
d�Z	dd
lmZmZmZd�Zd�Zd�Zd�Zd�Zd�Zd�Zej<je_d�Zd�Z e!e	jDd�rd�Z#nd�Z#d�Z$	ddl%m&Z&d�Z'd�Z(d�Z)	dd l%m*Z+d"�Z,	dd#l%m-Z-d$�Z.	dd%l%m/Z/m0Z1d&�Z2d'�Z3d(d)�d*�Z4d+Z5d5d,�Z6d-�Z7	dd.l%m8Z9dd/l%m:Z;dd0l%m<Z=dd1l%m>Z?	dd2l%m@Z@d3�ZAy	#e$rd�ZY��wxYw#e$rd	Z&Y�vwxYw#e$rd!�Z+Y�twxYw#e$re,Z.Y�twxYw#e$re.Z4Y�lwxYw#e$rY�UwxYw#e$rd4�ZAYy	wxYw)6z�Common pathname manipulations, WindowsNT/95 version.

Instead of importing this module directly, import os and refer to this
module as os.path.
�.�..�\�;�/z.;C:\bin�nul�N)�*)(�normcase�isabs�join�
splitdrive�	splitroot�split�splitext�basename�dirname�commonprefix�getsize�getmtime�getatime�getctime�islink�exists�lexists�isdir�isfile�ismount�
expanduser�
expandvars�normpath�abspath�curdir�pardir�sep�pathsep�defpath�altsep�extsep�devnull�realpath�supports_unicode_filenames�relpath�samefile�sameopenfile�samestat�
commonpath�
isjunctionc�&�t|t�ryy)N�\/�\/)�
isinstance�bytes��paths �<frozen ntpath>�
_get_bothsepsr:#s���$�����)�
LCMapStringEx�LOCALE_NAME_INVARIANT�LCMAP_LOWERCASEc�X�tj|�}|s|St|t�r]t	j
�}|j
|d�jdd�}ttt|�}|j|d�Sttt|jdd��S)�nNormalize case of pathname.

        Makes all characters lowercase and all slashes into backslashes.
        �surrogateescaperr)�os�fspathr5r6�sys�getfilesystemencoding�decode�replace�_LCMapStringEx�_LOCALE_NAME_INVARIANT�_LCMAP_LOWERCASE�encode)�s�encodings  r9r
r
3s���

�I�I�a�L����H��a����0�0�2�H�����#4�5�=�=�c�4�H�A��5�/��4�A��8�8�H�&7�8�8�!�"8�"2�"#�)�)�C��"6�8�
8r;c��tj|�}t|t�rFtjtj
|�j
dd�j��S|j
dd�j�S)r@rr)rBrCr5r6�fsencode�fsdecoderG�lower)rLs r9r
r
Fsb��

�I�I�a�L���a����;�;�r�{�{�1�~�5�5�c�4�@�F�F�H�I�I��y�y��d�#�)�)�+�+r;c���tj|�}t|t�rd}d}d}nd}d}d}|ddj	||�}|j|�s|j|d	�ry
y)zTest whether a path is absolute�\�/s:\rrz:\N��TF)rBrCr5r6rG�
startswith)rLr$r'�	colon_seps    r9rrWsn��
�	�	�!��A��!�U�������	������	�	�"�1��
�
�f�c�"�A�	�|�|�C��A�L�L��A�6��r;c�8�tj|�}t|t�rd}d}d}nd}d}d}	|s|dd|zt	|�\}}}ttj|�D]b}t	|�\}	}
}|
r|	s|s|	}|
}|}�|	r/|	|k7r*|	j
�|j
�k7r|	}|
}|}�N|	}|r|d|vr||z}||z}�d|r|s|r|dd||zvr||z|zS||z|zS#tttf$rtjd	|g|����wxYw)
NrSr3�:rr4�:r���r)rBrCr5r6r�maprQ�	TypeError�AttributeError�BytesWarning�genericpath�_check_arg_types)r8�pathsr$�seps�colon�result_drive�result_root�result_path�p�p_drive�p_root�p_paths            r9rrks_��
�9�9�T�?�D��$���������������!����!�H�s�N�1:�4��.��k�;��R�Y�Y��&�A�&/��l�#�G�V�V���,�#*�L�$��$����W��4��=�=�?�l�&8�&8�&:�:�#*�L�"(�K�"(�K��&���{�2��d�:�)�C�/��%��.�K�+'�.
���\�"�#�.�e�d�l�B��#�%��3�3��k�)�K�7�7���~�|�4���$�$�V�T�:�E�:�
��s�B/C,�$C,�,-Dc�.�t|�\}}}|||zfS)a�Split a pathname into drive/UNC sharepoint and relative path specifiers.
    Returns a 2-tuple (drive_or_unc, path); either part may be empty.

    If you assign
        result = splitdrive(p)
    It is always true that:
        result[0] + result[1] == p

    If the path contained a drive letter, drive_or_unc will contain everything
    up to and including the colon.  e.g. splitdrive("c:/dir") returns ("c:", "/dir")

    If the path contained a UNC path, the drive_or_unc will contain the host name
    and share up to but not including the fourth directory separator character.
    e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")

    Paths cannot contain both a drive letter and a UNC path.

    )r)ri�drive�root�tails    r9r
r
�s#��&"�!���E�4���$��+��r;c��tj|�}t|t�rd}d}d}d}d}n
d}d}d}d	}d
}|j	||�}|dd|k(r||dd
|k(ri|ddj�|k(rdnd
}|j
||�}|dk(r|||fS|j
||dz�}	|	dk(r|||fS|d|	||	|	dz||	dzdfS||dd|ddfS|dd
|k(r!|d
d|k(r|dd
|d
d|ddfS|dd
||d
dfS|||fS)a�Split a pathname into drive, root and tail. The drive is defined
    exactly as in splitdrive(). On Windows, the root may be a single path
    separator or an empty string. The tail contains anything after the root.
    For example:

        splitroot('//server/share/') == ('//server/share', '/', '')
        splitroot('C:/Users/Barney') == ('C:', '/', 'Users/Barney')
        splitroot('C:///spam///ham') == ('C:', '/', '//spam///ham')
        splitroot('Windows/notepad') == ('', '', 'Windows/notepad')
    rSrTrZ�\\?\UNC\r;rrr[�\\?\UNC\�NrV��r\rU)rBrCr5r6rG�upper�find)
rir$r're�
unc_prefix�empty�normp�start�index�index2s
          r9rr�s���	�	�	�!��A��!�U��������$�
���������#�
���
�I�I�f�c�"�E��R�a�y�C����1�:����r�����*�j�8�A�a�E��J�J�s�E�*�E���{��%���&��Z�Z��U�Q�Y�/�F���|��%���&��W�f�:�q����
�3�Q�v��z�{�^�C�C��!�B�Q�%��1�2��&�&�	�q���u�	���1�:����R�a�5�!�A�a�&�!�A�B�%�'�'��R�a�5�%��1�2��&�&��e�Q��r;c��tj|�}t|�}t|�\}}}t	|�}|r||dz
|vr|dz}|r||dz
|vr�|d|||d}}||z|j|�z|fS)z~Split a pathname.

    Return tuple (head, tail) where tail is everything after the final slash.
    Either part may be empty.rVN)rBrCr:r�len�rstrip)rird�d�r�i�headrps       r9rr�s���
	�	�	�!��A����D���l�G�A�q�!��A��A�
��!�A�#��d�"�	�Q�����!�A�#��d�"��2�A���!�"��$�D��q�5�4�;�;�t�$�$�d�*�*r;c��tj|�}t|t�rt	j
|ddd�St	j
|ddd�S)NrSrT�.rrr)rBrCr5r6ra�	_splitext�ris r9rrsG��
�	�	�!��A��!�U���$�$�Q��t�T�:�:��$�$�Q��c�3�7�7r;c��t|�dS)z)Returns the final component of a pathnamerV�rr�s r9rr�����8�A�;�r;c��t|�dS)z-Returns the directory component of a pathnamerr�r�s r9rrr�r;�st_reparse_tagc��	tj|�}t|jtjk(�S#tttf$rYywxYw�z!Test whether a path is a junctionF)	rB�lstat�OSError�
ValueErrorr_�boolr��stat�IO_REPARSE_TAG_MOUNT_POINT�r8�sts  r9r1r1sM��	����$��B��B�%�%��)H�)H�H�I�I����^�4�	��	�s�=�A�Ac�.�tj|�yr�)rBrCr7s r9r1r1#s��
�	�	�$��r;c�Z�	tj|�}y#ttf$rYywxYw)zCTest whether a path exists.  Returns True for broken symbolic linksFT)rBr�r�r�r�s  r9rr+s2���
�X�X�d�^����
�Z� ����s��*�*)�_getvolumepathnamec�>�tj|�}t|�}t|�}t	|�\}}}|r
|d|vr|S|r|syt
rL|j
|�}t|�j
|�}|j�|j�k(Sy)zaTest whether a path is a mount point (a drive root, the root of a
    share, or a mounted volume)rTF)rBrCr:r!rr�r��casefold)r8rdrnro�rest�x�ys       r9rrAs����9�9�T�?�D����D��4�=�D�!�$���E�4����q��T�!��x���D����K�K�����d�#�*�*�4�0���z�z�|�q�z�z�|�+�+�r;c�8�tj|�}t|t�rd}nd}|j	|�s|Sdt|�}}||kr+||t
|�vr|dz
}||kr||t
|�vr�dtjvrtjd}nEdtjvr|S	tjd}t|tjd�}|dk7rs|d|}t|t�rtj|�}tjjd�}||k7r%|t|�k7r|Stt|�|�}t|t�rtj|�}|||d	zS#t$rd}Y��wxYw)
zLExpand ~ and ~user constructs.

    If user or $HOME is unknown, do nothing.�~�~rV�USERPROFILE�HOMEPATH�	HOMEDRIVErt�USERNAMEN)rBrCr5r6rWr�r:�environ�KeyErrorrrP�getrrrO)r8�tilder��n�userhomern�target_user�current_users        r9rr^s{���9�9�T�?�D��$��������?�?�5�!����c�$�i�q�A�
�a�%�D��G�=��#6�6�	�Q����a�%�D��G�=��#6�6���
�
�"��:�:�m�,��
�2�:�:�
%���	��J�J�{�+�E���r�z�z�*�5�6���A�v��1�Q�i���k�5�)��+�+�k�2�K��z�z�~�~�j�1���,�&��x��1�1����G�H�-�{�;�H��$����;�;�x�(���d�1�2�h����/�	��E�	�s�6F�F�Fc���tj|�}t|t�rPd|vrd|vr|Sddl}t|j
|jzdzd�}d}d}d}d	}d}ttd
d�}nDd|vrd|vr|Sddl}|j
|jzdz}d
}d}d}d}d}tj}|dd}	d}
t|�}|
|k�r||
|
dz}||k(r5||
dzd}t|�}	|j|�}
|	||d|
dzzz
}	�n�||k(r�||
dz|
dz|k(r|	|z
}	|
dz
}
�n�||
dzd}t|�}	|j|�}
|d|
}
	|�:tjtjtj|
��}n||
}|	|z
}	�n%||k(�r||
dz|
dz|k(r|	|z
}	|
dz
}
�n||
dz|
dz|k(rr||
dzd}t|�}	|j|�}
|d|
}
	|�:tjtjtj|
��}n||
}|	|z
}	n�|dd}
|
dz
}
||
|
dz}|r||vr|
|z
}
|
dz
}
||
|
dz}|r||vr�	|�:tjtjtj|
��}n||
}|	|z
}	|r|
dz}
n|	|z
}	|
dz
}
|
|kr��|	S#t$r|	||zz
}	|dz
}
Y�&wxYw#t$r||
z|z}Y��jwxYw#t$r|	||zz
}	|dz
}
Y�ZwxYw#t$r||z|
z|z}Y��wxYw#t$r|	||z|zz
}	|dz
}
Y��wxYw#t$r||
z}Y��wxYw)zfExpand shell variables of the forms $var, ${var} and %var%.

    Unknown variables are left unchanged.�$�%rNz_-�ascii�'�{�}�environb�$�%�'�{�}rVru)rBrCr5r6�string�
ascii_letters�digits�getattrr�r�r}r�rOrPr�)r8r��varchars�quote�percent�brace�rbrace�dollarr��resr}�pathlen�c�var�values               r9rr�sH���9�9�T�?�D��$����t���D� 0��K����-�-��
�
�=��D�g�N�������������"�j�$�/���d�?�s�$���K���'�'�&�-�-�7�$�>�������������*�*��
�r��(�C�
�E��$�i�G�
�'�/���u�Q�w�����:����	�
�#�D��$�i�G�
$��
�
�1�
���q�4�
����+�+�+���'�\��E�A�I�e�a�i�(�G�3��q�����
���E�!�G�H�~���d�)��!� �J�J�w�/�E�
�v��,�C�8�"�?�$&�K�K��
�
�2�;�;�s�;K�0L�$M�E�$+�C�L�E��5�L�C�
�&�[��E�A�I�e�a�i�(�F�2��q�����
���e�a�i���	�*�e�3��E�!�G�H�~���d�)��!� �J�J�v�.�E�
�v��,�C�>�"�?�$&�K�K��
�
�2�;�;�s�;K�0L�$M�E�$+�C�L�E��5�L�C��2�A�h����
����u�q�y�)���A��M��1�H�C��Q�J�E��U�5�1�9�-�A��A��M�)��� "���B�J�J�r�{�{�3�7G�,H� I�� '�����u�����Q�J�E��1�H�C�
��
��W�'�/�X�J��I�
$��q�4�x����!���
$��,$�8� '�#�
�� 7��8��"�(��7�T�>�)�C�#�a�K�E�(��@$�>� &���� 4�v� =��>��"�(��6�E�>�D�0�0�C�#�a�K�E�(��4 �)�"�S�L�E�)�so�3K�L
�AK5�(M�?AL)�8AM"�K2�1K2�5L
�	L
�
L&�%L&�)M�?M�M�M�"M3�2M3)�_path_normpathc��tj|�}t|t�r	d}d}d}d}nd}d}d}d}|j	||�}t|�\}}}||z}|j
|�}d	}	|	t|�kr_||	r||	|k(r||	=n?||	|k(r2|	d	kDr||	d
z
|k7r||	d
z
|	d
z�=|	d
z}	n|	d	k(r|r||	=n|	d
z
}	n|	d
z
}	|	t|�kr�_|s|s|j|�||j|�zS)z0Normalize path, eliminating double slashes, etc.rSrTr��..rrrrrrV)
rBrCr5r6rGrrr��appendr)
r8r$r'r"r#rnro�prefix�compsr�s
          r9r r s3���y�y�����d�E�"��C��F��F��F��C��F��F��F��|�|�F�C�(��%�d�O���t�T������
�
�3���
���#�e�*�n���8�u�Q�x�6�1��!�H��q��V�#��q�5�U�1�Q�3�Z�6�1��a��c�!�A�#�g����F�A��!�V���a����F�A��Q����#�e�*�n��e��L�L�� �������'�'r;c���tj|�}t|�sEt|t�rtj
�}ntj�}t||�}t|�S)z�Return the absolute version of a path as a fallback function in case
    `nt._getfullpathname` is not available or raises OSError. See bpo-31047 for
    more.

    )	rBrCrr5r6�getcwdb�getcwdrr )r8�cwds  r9�_abspath_fallbackr�4sM���9�9�T�?�D���;��d�E�"��*�*�,�C��)�)�+�C��C�����D�>�r;)�_getfullpathnamec�l�	tt|��S#ttf$rt	|�cYSwxYw)z&Return the absolute version of a path.)r�r r�r�r�r7s r9r!r!Ls5��	+�#�H�T�N�3�3����$�	+�$�T�*�*�	+�s��3�3)�_getfinalpathname�readlinkc�x�d}t�}t|�|vro|jt|��	|}t|�}t	|�s.t|�s|}	|St
tt|�|��}t|�|vr�o|S#t$r}|j|vrYd}~|S�d}~wt$rY|SwxYw)N)rVrurU��� �2�C�Wi&i(i))�setr
�add�_nt_readlinkrrr rrr��winerrorr�)r8�allowed_winerror�seen�old_path�exs     r9�_readlink_deepr�Ys���L���u���t�n�D�(��H�H�X�d�^�$�
���#�D�)���T�{�"�(�+�'�����$�D���):�D�$A�B�D��t�n�D�(�,����
��;�;�"2�2��
��	���
����
�s)�%B�B�	B9�B)�(B)�)B9�8B9c�f�d}|dd}|r	t|�}|rt||�S|S|S#t$r{}|j|vr�	t	|�}||k7r|rt||�n|cYd}~Sn#t$rYnwxYwt|�\}}|r|s
||zcYd}~S|rt||�n|}Yd}~nd}~wwxYw|r����)N)rVrurUr�r�r�r��5�Ar�r��{�i�i�r)r�rr�r�r�r)r8r�rpr��new_path�names      r9�_getfinalpathname_nonstrictr��s���$X���B�Q�x���
:�(��.��+/�t�D�$�'�9�T�9�*���)�
:��;�;�&6�6��	� .�d�3�H��4�'�7;�t�H�d�3��I�(�������#�4�[�
��d����$�;�&�+/�t�D�$�'�T���'
:��	�sN�(�(�	B,�B'�A'� B,�&B'�'	A3�0B'�2A3�3B'�B,�B'�'B,F)�strictc��t|�}t|t�rId}d}d}tj�}t|�ttjt��k(r7yd}d}d}tj�}t|�tt�k(ry|j|�}|st|�st||�}	t|�}d	}|sU|j|�rD|j|�r||t%|�dz}	n|t%|�d}		t|	�|k(r|	}|S|S#t$r,}|rtt|��d�t|�}Yd}~��d}~wt$r$}|r�|j }t#|�}Yd}~��d}~wwxYw#t$r}Yd}~|Sd}~wt$r}|j k(r|	}Yd}~|Sd}~wwxYw)
Ns\\?\rrs\\s\\.\NULz\\?\rsz\\z\\.\NULr)r r5r6rBr�r
rOr)r�rWrrr�r�r��strr�r�r�)
r8r�r�ry�new_unc_prefixr��
had_prefix�initial_winerrorr��spaths
          r9r*r*�s�����~���d�E�"��F�(�J�$�N��*�*�,�C���~��"�+�+�g�*>�!?�?�$��F�'�J�#�N��)�)�+�C���~��'�!2�2�#��_�_�V�,�
��%��+���T�?�D�	5�$�T�*�D� ��"�d�o�o�f�5����z�*�&��c�*�o�.>�)?�?���S��[�\�*��
!�$�U�+�t�3� �D���t���I�	"�
��c�"�g�&�D�0��D�>�D���	5���!�{�{��.�t�4�D��		5��&�
������
!��;�;�"2�2� �D�����
!�sB�
D,�F�,	F�5"E�F�(F�F�	G�G�*G�GTc�L�tj|�}t|t�rd}d}d}nd}d}d}|�|}|st	d��tj|�}	tt
|��}tt
|��}t|�\}}}	t|�\}
}}t|�t|
�k7rt	d	|
�d
|����|	j|�D�cgc]}|s�|��	}
}|j|�D�cgc]}|s�|��	}}d}t|
|�D]#\}}t|�t|�k7rn|dz
}�%|gt|
�|z
z||dz}|s|St|�Scc}wcc}w#ttttt f$rt#j$d
||��wxYw)z#Return a relative version of a pathrSr�r�rrrNzno path specifiedzpath is on mount z, start on mount rrVr,)rBrCr5r6r�r!r rr
r�zipr�rr^r_r`�DeprecationWarningrarb)r8r|r$r"r#�	start_abs�path_abs�start_drive�_�
start_rest�
path_drive�	path_restr��
start_list�	path_listr��e1�e2�rel_lists                   r9r,r,�s���
�9�9�T�?�D��$����������������}�����,�-�-��I�I�e��E���H�U�O�,�	��8�D�>�*��%.�y�%9�"��Q�
�#,�X�#6� �
�A�y��K� �H�Z�$8�8���K�)�*�
*�",�!1�!1�#�!6�<�!6�A�!�a�!6�
�<� )���� 4�:� 4�1��Q� 4�	�:�
���*�i�0�F�B����|�x��|�+��
��F�A�1�
�8�s�:��q�0�1�I�a�b�M�A����M��X����=��:��
�z�>�<�AS�T���$�$�Y��e�<�
��s>�BE,�E"�#E"�'E,�<E'�E'�AE,�E,�"
E,�,7F#c
�`�|std��tttj|��}t|dt�rd}d}d}nd}d}d}	|D�cgc]+}t|j||�j����-}}|D���cgc]\}}}|j|���}}}}t|D���chc]\}}}|��
c}}}�d	k7rtd
��t|D���chc]\}}}|��
c}}}�d	k7rtd��t|dj||��\}	}
}|j|�}|D�
cgc]
}
|
s�|
|k7s�|
��}}
|D��
cgc]}|D�
cgc]
}
|
s�|
|k7s�|
��c}
��}}}
t|�}t|�}t|�D]\}}
|
||k7s�|d|}n|dt|�}|	|
z|j|�zScc}wcc}}}wcc}}}wcc}}}wcc}
wcc}
wcc}
}w#t t"f$rt%j&d
g|����wxYw)zDGiven a sequence of path names, returns the longest common sub-path.z%commonpath() arg is an empty sequencerrSrTr�rrrrVz%Can't mix absolute and relative pathszPaths don't have the same driveNr0)r��tupler]rBrCr5r6rrGrQrr��min�max�	enumeraterr^r_rarb)rcr$r'r"ri�drivesplitsr�r��split_pathsrnror8�commonr�rL�s1�s2r�s                  r9r0r0.s-����@�A�A��#�b�i�i��'�(�E��%��(�E�"��������������JO�P�%�Q�y����6�3�!7�!=�!=�!?�@�%��P�3>�?�;���1�a�q�w�w�s�|�;��?���-��g�a��A���-�.�!�3��D�E�E�
��-��g�a��A���-�.�!�3��>�?�?�%�e�A�h�&6�&6�v�s�&C�D���t�T����C���#�9�V��q�Q�&�[�!�V��9�DO�P�K�q�1�:�1�a��a�6�k��1�:�K��P�
��
��
��
���b�M�D�A�q��B�q�E�z�������"�
�H�S��W�%�F��t�|�c�h�h�v�.�.�.��5Q��?��-��.��
:��:��P��
�~�&���$�$�\�:�E�:�
��s��H�0G�H�G!�*H�9
G(�"H�(
G/�5AH�G6�G6�G6�H�	H�%G;�-G;�3G;�7H�<2H�/,H�H�;H�H�'H-)�_path_isdir)�_path_isfile)�_path_islink)�_path_exists)�_path_isdevdrivec�J�	tt|��S#t$rYywxYw�z@Determines whether the specified path is on a Windows Dev Drive.F)rr!r�r7s r9�
isdevdriverts(��	�#�G�D�M�2�2���	��	�s��	"�"c��yr�r7s r9rros��r;)N)B�__doc__r"r#r(r$r%r'r&r)rBrDr�ra�__all__r:�_winapir<rHr=rIr>rJr
�ImportErrorrrr
rrrr�rr�hasattr�stat_resultr1r�ntr�rrrr�r r�r�r!r�r�r�r�r�r*r+r,r0rrrrrrrrrrrr;r9�<module>r$s����

��	
��	��
��

��	��
��
��	�
����O���!,�-�-�
8�H�(+�b�.1�r
+�*8��(�(�0�0���
���2�>�>�+�,�J���$�%��:-�zj�`&(�-�P�"+�#�+�]�>�
(�T/�b"'�<�@"��+�p.�b
	�(�)�)�)�
�#���_�	,�,�	,��t������^�#(�"(�#(��t� ��G� �����H���d�	��	������s}�
C3�D�D�(D�2D)�D6�)E�3C>�=C>�D�
D�D�D�D&�%D&�)D3�2D3�6D>�=D>�E�E��t�dZddlZddlZgd�Zd�Zd�Zd�Zd�Zd�Zd	�Z	d
�Z
d�Zd�Zd
�Z
d�Zd�Zd�Zd�Zy)z�
Path operations common to more than one OS
Do not use directly.  The OS specific modules import the appropriate
functions from this module themselves.
�N)�commonprefix�exists�getatime�getctime�getmtime�getsize�isdir�isfile�islink�samefile�sameopenfile�samestatc�Z�	tj|�y#ttf$rYywxYw)zDTest whether a path exists.  Returns False for broken symbolic linksFT)�os�stat�OSError�
ValueError)�paths �<frozen genericpath>rrs0���
����
���
�Z� ����s��*�*c��	tj|�}tj|j
�S#ttf$rYywxYw)z%Test whether a path is a regular fileF)rrrr�S_ISREG�st_mode�r�sts  rr
r
sB���
�W�W�T�]���<�<��
�
�#�#��
�Z� ������6�A�Ac��	tj|�}tj|j
�S#ttf$rYywxYw)z<Return true if the pathname refers to an existing directory.F)rrrr�S_ISDIRr)�srs  rr	r	'sB���
�W�W�Q�Z���<�<��
�
�#�#��
�Z� ����rc��	tj|�}tj|j�S#tttf$rYywxYw)z&Test whether a path is a symbolic linkF)r�lstatrr�AttributeErrorr�S_ISLNKrrs  rrr3sD���
�X�X�d�^���<�<��
�
�#�#��
�Z��0����s�6�A
�A
c�@�tj|�jS)z1Return the size of a file, reported by os.stat().)rr�st_size��filenames rrr<s��
�7�7�8��$�$�$�c�@�tj|�jS)zCReturn the last modification time of a file, reported by os.stat().)rr�st_mtimer%s rrrA���
�7�7�8��%�%�%r'c�@�tj|�jS)z=Return the last access time of a file, reported by os.stat().)rr�st_atimer%s rrrFr*r'c�@�tj|�jS)zAReturn the metadata change time of a file, reported by os.stat().)rr�st_ctimer%s rrrKr*r'c���|syt|dttf�s#tttj
|��}t
|�}t|�}t|�D]\}}|||k7s�|d|cS|S)zGGiven a list of pathnames, returns the longest common leading component�rN)	�
isinstance�list�tuple�mapr�fspath�min�max�	enumerate)�m�s1�s2�i�cs     rrrQsq���R�
�a��d�T�5�M�*��#�b�i�i��#�$��	�Q��B�	�Q��B��"�
���1���1��:��b�q�6�M���Ir'c�j�|j|jk(xr|j|jk(S)z5Test whether two stat buffers reference the same file)�st_ino�st_dev)r:r;s  rrrcs,���I�I����"�
#��I�I����"�$r'c�n�tj|�}tj|�}t||�S)z�Test whether two pathnames reference the same actual file or directory

    This is determined by the device number and i-node number and
    raises an exception if an os.stat() call on either pathname fails.
    )rrr)�f1�f2r:r;s    rrrjs+��
�����B�	�����B��B���r'c�n�tj|�}tj|�}t||�S)z:Test whether two open file objects reference the same file)r�fstatr)�fp1�fp2r:r;s    rr
r
ws)��	���#��B�	���#��B��B���r'c���|j|�}|r|j|�}t||�}|j|�}||kDr*|dz}||kr |||dz|k7r
|d|||dfS|dz
}||kr� ||ddfS)z�Split the extension from a pathname.

    Extension is everything from the last dot to the end, ignoring
    leading dots.  Returns "(root, ext)"; ext may be empty.�Nr)�rfindr7)�p�sep�altsep�extsep�sepIndex�altsepIndex�dotIndex�
filenameIndexs        r�	_splitextrS�s����w�w�s�|�H�
��g�g�f�o���x��-���w�w�v��H��(�� �1��
��h�&���}�Q��/�6�9���(�|�Q�x�y�\�1�1��Q��M��h�&�

�a���e�8�Or'c���dx}}|D]L}t|t�rd}�t|t�rd}�)t|�d|jj
���d�|r|rtd�d�yy)NFTz;() argument must be str, bytes, or os.PathLike object, not z.Can't mix strings and bytes in path components)r1�str�bytes�	TypeError�	__class__�__name__)�funcname�args�hasstr�hasbytesrs     r�_check_arg_typesr^�s�����F�X�
���a����F�
��5�
!��H��x�j�)7�78�{�{�7K�7K�6N�P�Q�VZ�
[�
��(��H�I�t�S��vr')�__doc__rr�__all__rr
r	rrrrrrrrr
rSr^�r'r�<module>rbs`���

�����$�$�$�%�
&�
&�
&��$$����.Tr'��R�dZddlZGd�de�ZGd�de�ZGd�de�Zy)	z=
The objects used by the site module to add custom builtins.
�Nc� �eZdZd�Zd�Zdd�Zy)�Quitterc� �||_||_y�N��name�eof)�selfrr	s   �<frozen _sitebuiltins>�__init__zQuitter.__init__s����	����c�<�d|j�d|j�d�S)NzUse z() or z to exitr�r
s r�__repr__zQuitter.__repr__s��+/�9�9�d�h�h�?�?r
Nc�x�	tjj�t|��#Yt|��xYwr)�sys�stdin�close�
SystemExit)r
�codes  r�__call__zQuitter.__call__s7��	��I�I�O�O�������	������s�+�9r)�__name__�
__module__�__qualname__rrr�r
rrr
s���@�r
rc�.�eZdZdZdZdd�Zd�Zd�Zd�Zy)	�_Printerzninteractive prompt objects for printing the license text, a list of
    contributors and the copyright notice.�c	��ddl}||_||_d|_|D��cgc]%}|D]}|jj||��� �'c}}|_ycc}}w�Nr)�os�_Printer__name�_Printer__data�_Printer__lines�path�join�_Printer__filenames)r
r�data�files�dirsr!�dir�filenames        rrz_Printer.__init__#s[������������'+�3�'+��,1���G�G�L�L��h�7�,1�8�'+�3����3s�*Ac�F�|jryd}|jD]*}	t|d��5}|j�}ddd�n|s|j
}|j
d�|_t|j�|_y#1swY�KxYw#t$rY��wxYw)Nzutf-8)�encoding�
)	r$r'�open�read�OSErrorr#�split�len�_Printer__linecnt)r
r(r,�fps    r�__setupz_Printer.__setup,s����<�<�����(�(�H�
��(�W�5���7�7�9�D�6��	)���;�;�D��z�z�$�'����T�\�\�*���6�5���
��
�s'�
B�B�B�B	�
B�	B �B c���|j�t|j�|jkrdj	|j�Sd|j
fdzzS)Nr/z!Type %s() to see the full %s text�)�_Printer__setupr4r$�MAXLINESr&r"rs rrz_Printer.__repr__<sI�������t�|�|���
�
�-��9�9�T�\�\�*�*�6�4�;�;�.��:J�K�Kr
c��|j�d}d}		t|||jz�D]}t|j|��	||jz
}d}|�t|�}|dvrd}|��|dk(ry�f#t$rYywxYw)Nz0Hit Return for more, or q (and Return) to quit: r)��qr>)r:�ranger;�printr$�input�
IndexError)r
�prompt�lineno�i�keys     rrz_Printer.__call__Cs�������C�����

��v�v��
�
�'=�>�A��$�,�,�q�/�*�?�
�$�-�-�'�����k���-�C��)�+�"���k��#�:�����
��
�s�6A<�<	B�BN)rr)	rrr�__doc__r;rr:rrrr
rrrs#��.��H�3�+� L�r
rc��eZdZdZd�Zd�Zy)�_Helpera3Define the builtin 'help'.

    This is a wrapper around pydoc.help that provides a helpful message
    when 'help' is typed at the Python interactive prompt.

    Calling help() at the Python prompt starts an interactive help session.
    Calling help(thing) prints help for the python object 'thing'.
    c��y)NzHType help() for interactive help, or help(object) for help about object.rrs rrz_Helper.__repr__bs��8r
c�.�ddl}|j|i|��Sr )�pydoc�help)r
�args�kwdsrLs    rrz_Helper.__call__es����u�z�z�4�(�4�(�(r
N)rrrrGrrrr
rrIrIXs���8�)r
rI)rGr�objectrrrIrr
r�<module>rQs4����
�f�
� 8�v�8�v)�f�)r
��Z
�dZddlmZmZddlZeee�Zed�Z	d�Z
ee
�Z[
gd�ZdZ
eed��Zeee���Zeeij%���Zeeij)���Zeeij-���Zeeg��Zeeeg���Zeeed���Zeeed	d
z���Zeee���Zeed��Z eed��Z!eee"���Z#eij%��Z$eij)��Z%eij-��Z&eejN�Z(ed
���Z)d�Z*e*�Z*ee*�Z+e*jY�[*d�Z-e-�Z-ee-�Z.[-d�Z/Gd�de��Z0Gd�de��Z1Gd�de1�Z2e2jge+�Gd�de��Z4Gd�de4�Z5Gd�de5�Z6e6jge.�Gd�de��Z7Gd �d!e7�Z8e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge�e8jge �e8jge!�e8jge#�Gd"�d#e7�Z9Gd$�d%e8�Z:e:jge)�Gd&�d'e��Z;Gd(�d)e��Z<Gd*�d+e;e7e<�Z=Gd,�d-e��Z>Gd.�d/e�Z?d0�Z@d1�ZAGd2�d3e��ZBGd4�d5e=�ZCeCjgeD�Gd6�d7eC�ZEeEjge�Gd8�d9e=�ZFeFjge(�Gd:�d;e;�ZGGd<�d=eGeC�ZHeHjge$�Gd>�d?eGeC�ZIeIjge&�Gd@�dAeGe=�ZJeJjge%�GdB�dCeF�ZKeKjgeL�GdD�dEe9e=�ZMeMjgeN�eMjgeO�eMjge�eMjgeP�GdF�dGe�ZQGdH�dIeMeQ��ZReRjgeS�eRjge�GdJ�dKeM�ZTeTjge�eTjge�y)LzjAbstract Base Classes (ABCs) for collections, according to PEP 3119.

Unit tests are in test_collections.
�)�ABCMeta�abstractmethodN.c��y�N�r��<frozen _collections_abc>�_fr
(s��$r)�	Awaitable�	Coroutine�
AsyncIterable�
AsyncIterator�AsyncGenerator�Hashable�Iterable�Iterator�	Generator�
Reversible�Sized�	Container�Callable�
Collection�Set�
MutableSet�Mapping�MutableMapping�MappingView�KeysView�	ItemsView�
ValuesView�Sequence�MutableSequence�
ByteString�Bufferzcollections.abcr�i��rc#�K�d��Srrrrr	�<lambda>r(Xs����5rc��K�y�wrrrrr	�_coror*Zs����4���c�K�d���y�wrrrrr	�_agr-`s�������	c��|j}|D]9}|D]+}||jvs�|j|�
tccS�2tcSy)NT)�__mro__�__dict__�NotImplemented)�C�methods�mro�method�Bs     r	�_check_methodsr8hsP��
�)�)�C����A�����#��:�:�f�%�-�)�)��	�"�!��rc�0�eZdZdZed��Zed��Zy)rrc��y�Nrr��selfs r	�__hash__zHashable.__hash__x���rc�6�|turt|d�StS)Nr>)rr8r2��clsr3s  r	�__subclasshook__zHashable.__subclasshook__|����(�?�!�!�Z�0�0��rN)�__name__�
__module__�__qualname__�	__slots__rr>�classmethodrCrrr	rrt�-���I��������rr)�	metaclassc�@�eZdZdZed��Zed��Zee�Z	y)rrc#�K�d��y�wrrr<s r	�	__await__zAwaitable.__await__�s	����
�s�c�6�|turt|d�StS)NrN)rr8r2rAs  r	rCzAwaitable.__subclasshook__�s���)��!�!�[�1�1��rN)
rErFrGrHrrNrIrC�GenericAlias�__class_getitem__rrr	rr�s:���I���������
$�L�1�rrc�H�eZdZdZed��Zedd��Zd�Zed��Z	y)rrc��t�)zcSend a value into the coroutine.
        Return next yielded value or raise StopIteration.
        ��
StopIteration�r=�values  r	�sendzCoroutine.send��
��
�rNc�F�|�|�|�|�}|�|j|�}|�)zgRaise an exception in the coroutine.
        Return next yielded value or raise StopIteration.
        ��with_traceback�r=�typ�val�tbs    r	�throwzCoroutine.throw��4��
�;��z��	��%�C�
�>��$�$�R�(�C��	rc�n�	|jt�td��#ttf$rYywxYw)�.Raise GeneratorExit inside coroutine.
        zcoroutine ignored GeneratorExitN�ra�
GeneratorExit�RuntimeErrorrUr<s r	�closezCoroutine.close��;��	B��J�J�}�%��@�A�A���}�-�	��	���"�4�4c�<�|turt|dddd�StS)NrNrXrarh)rr8r2rAs  r	rCzCoroutine.__subclasshook__�s#���)��!�!�[�&�'�7�K�K��r�NN)
rErFrGrHrrXrarhrIrCrrr	rr�sG���I������
��
�B����rrc�@�eZdZdZed��Zed��Zee�Z	y)r
rc��t�Sr)rr<s r	�	__aiter__zAsyncIterable.__aiter__�s
����rc�6�|turt|d�StS)Nro)r
r8r2rAs  r	rCzAsyncIterable.__subclasshook__�s���-��!�!�[�1�1��rN)
rErFrGrHrrorIrCrPrQrrr	r
r
�s:���I���������
$�L�1�rr
c�6�eZdZdZed��Zd�Zed��Zy)rrc��K�t��w)z@Return the next item or raise StopAsyncIteration when exhausted.��StopAsyncIterationr<s r	�	__anext__zAsyncIterator.__anext__�s����!� �r.c��|Srrr<s r	rozAsyncIterator.__aiter__�����rc�8�|tur
t|dd�StS)Nruro)rr8r2rAs  r	rCzAsyncIterator.__subclasshook__�s���-��!�!�[�+�>�>��rN)	rErFrGrHrrurorIrCrrr	rr�s2���I��!��!�����rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze	d��Z
y)	rrc��@K�|jd��d{���S7��w)zpReturn the next item from the asynchronous generator.
        When exhausted, raise StopAsyncIteration.
        N)�asendr<s r	ruzAsyncGenerator.__anext__�s�����Z�Z��%�%�%�%�s���c��K�t��w)zuSend a value into the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        rsrVs  r	r{zAsyncGenerator.asend�s����
!� �r.Nc��NK�|�|�|�|�}|�|j|�}|��w)zyRaise an exception in the asynchronous generator.
        Return next yielded value or raise StopAsyncIteration.
        r[r]s    r	�athrowzAsyncGenerator.athrow�s8����
�;��z��	��%�C�
�>��$�$�R�(�C��	�s�#%c��K�	|jt��d{���td��7�#ttf$rYywxYw�w)rdNz,asynchronous generator ignored GeneratorExit)r~rfrgrtr<s r	�aclosezAsyncGenerator.aclosesH����	O��+�+�m�,�,�,��M�N�N�	
-���1�2�	��	�s/�A�.�,�.�A�.�A�A�A�Ac�>�|turt|ddddd�StS)Nrorur{r~r�)rr8r2rAs  r	rCzAsyncGenerator.__subclasshook__s*���.� �!�!�[�+�")�8�X�?�
?��rrl)rErFrGrHrurr{r~r�rIrCrrr	rr�sN���I�&��!��!��
��
�O����rrc�@�eZdZdZed��Zed��Zee�Z	y)rrc#�K�y�wrrr<s r	�__iter__zIterable.__iter__�	�����r+c�6�|turt|d�StS)Nr�)rr8r2rAs  r	rCzIterable.__subclasshook__ rDrN)
rErFrGrHrr�rIrCrPrQrrr	rrs:���I���������
$�L�1�rrc�6�eZdZdZed��Zd�Zed��Zy)rrc��t�)zKReturn the next item from the iterator. When exhausted, raise StopIterationrTr<s r	�__next__zIterator.__next__-s
���rc��|Srrr<s r	r�zIterator.__iter__2rwrc�8�|tur
t|dd�StS)Nr�r�)rr8r2rAs  r	rCzIterator.__subclasshook__5s���(�?�!�!�Z��<�<��rN)	rErFrGrHrr�r�rIrCrrr	rr)s2���I���������rrc�0�eZdZdZed��Zed��Zy)rrc#�K�y�wrrr<s r	�__reversed__zReversible.__reversed__Pr�r+c�8�|tur
t|dd�StS)Nr�r�)rr8r2rAs  r	rCzReversible.__subclasshook__Us���*��!�!�^�Z�@�@��rN)rErFrGrHrr�rIrCrrr	rrLs-���I��������rrc�N�eZdZdZd�Zed��Zedd��Zd�Ze	d��Z
y)	rrc�$�|jd�S)z^Return the next item from the generator.
        When exhausted, raise StopIteration.
        N)rXr<s r	r�zGenerator.__next__`s���y�y���rc��t�)zcSend a value into the generator.
        Return next yielded value or raise StopIteration.
        rTrVs  r	rXzGenerator.sendfrYrNc�F�|�|�|�|�}|�|j|�}|�)zgRaise an exception in the generator.
        Return next yielded value or raise StopIteration.
        r[r]s    r	razGenerator.throwmrbrc�n�	|jt�td��#ttf$rYywxYw)z.Raise GeneratorExit inside generator.
        zgenerator ignored GeneratorExitNrer<s r	rhzGenerator.closezrirjc�>�|turt|ddddd�StS)Nr�r�rXrarh)rr8r2rAs  r	rCzGenerator.__subclasshook__�s*���)��!�!�Z��"(�'�7�<�
<��rrl)rErFrGrHr�rrXrarhrIrCrrr	rr\sN���I�������
��
�B����rrc�0�eZdZdZed��Zed��Zy)rrc��yr;rr<s r	�__len__z
Sized.__len__�r?rc�6�|turt|d�StS)Nr�)rr8r2rAs  r	rCzSized.__subclasshook__�s���%�<�!�!�Y�/�/��rN)rErFrGrHrr�rIrCrrr	rr�rJrrc�@�eZdZdZed��Zed��Zee�Z	y)rrc��y�NFr)r=�xs  r	�__contains__zContainer.__contains__����rc�6�|turt|d�StS)Nr�)rr8r2rAs  r	rCzContainer.__subclasshook__�s���)��!�!�^�4�4��rN)
rErFrGrHrr�rIrCrPrQrrr	rr�s:���I���������
$�L�1�rrc� �eZdZdZed��Zy)rrc�:�|turt|ddd�StS)Nr�r�r�)rr8r2rAs  r	rCzCollection.__subclasshook__�s!���*��!�!�i��^�L�L��rN)rErFrGrHrIrCrrr	rr�s���I����rrc�:�eZdZdZededefd��Zed��Z	y)r$r�flags�returnc��t�r��NotImplementedError)r=r�s  r	�
__buffer__zBuffer.__buffer__�s��!�!rc�6�|turt|d�StS)Nr�)r$r8r2rAs  r	rCzBuffer.__subclasshook__�s���&�=�!�!�\�2�2��rN)
rErFrGrHr�int�
memoryviewr�rIrCrrr	r$r$�s;���I��"��"�:�"��"����rr$c�@��eZdZdZdZ�fd�Z�fd�Zd�Z�fd�Z�xZ	S)�_CallableGenericAliasz� Represent `Callable[argtypes, resulttype]`.

    This sets ``__args__`` to a tuple containing the flattened ``argtypes``
    followed by ``resulttype``.

    Example: ``Callable[[int, str], float]`` sets ``__args__`` to
    ``(int, str, float)``.
    rc����t|t�rt|�dk(std��|\}}t|ttf�rg|�|��}nt|�std|����t�|�|||�S)N�z6Callable must be used as Callable[[arg, ...], result].zFExpected a list of types, an ellipsis, ParamSpec, or Concatenate. Got )�
isinstance�tuple�len�	TypeError�list�_is_param_expr�super�__new__)rB�origin�args�t_args�t_result�	__class__s     �r	r�z_CallableGenericAlias.__new__�s�����4��'�C��I��N��H�J�
J������f�u�d�m�,�&�V�&�X�&�D���'��>�>D�X�G�H�
H��w��s�F�D�1�1rc	�.��t|j�dk(r&t|jd�rt�|��Sddj|jddD�cgc]
}t
|���c}��dt
|jd��d�Scc}w)Nr�rzcollections.abc.Callable[[z, ���z], �])r��__args__r�r��__repr__�join�
_type_repr)r=�ar�s  �r	r�z_CallableGenericAlias.__repr__�s�����t�}�}���"�~�d�m�m�A�6F�'G��7�#�%�%���Y�Y�t�}�}�S�b�7I�J�7I�!�
�1�
�7I�J�K�L�C��d�m�m�B�/�0�1��4�	5��Js�B
c��|j}t|�dk(rt|d�st|dd�|df}tt
|ffS)Nr�rr�)r�r�r�r�r�r)r=r�s  r	�
__reduce__z _CallableGenericAlias.__reduce__�sI���}�}���D�	�Q��>�$�q�'�#:���S�b�	�?�D��H�,�D�$�x��&6�6�6rc����t|t�s|f}t�|�
|�j}t|dtt
f�s|d}|dd}||f}t
tt|��S)Nrr�)r�r�r��__getitem__r�r�r�r)r=�item�new_argsr�r�r�s     �r	r�z!_CallableGenericAlias.__getitem__�sn���
�$��&��7�D��7�&�t�,�5�5���(�1�+��t�}�5���|�H��c�r�]�F���)�H�$�X�u�X��?�?r)
rErFrG�__doc__rHr�r�r�r��
__classcell__�r�s@r	r�r��s*�����I�
2�5�7�@�@rr�c����turyt�t�ryt���d}�jdk(xrt�fd�|D��S)z|Checks if obj matches either a list of types, ``...``, ``ParamSpec`` or
    ``_ConcatenateGenericAlias`` from typing.py
    T)�	ParamSpec�_ConcatenateGenericAlias�typingc3�<�K�|]}�j|k(���y�wr)rE)�.0�name�objs  �r	�	<genexpr>z!_is_param_expr.<locals>.<genexpr>	s�����-U�u�t�c�l�l�d�.B�u�s�)�Ellipsisr�r��typerF�any)r��namess` r	r�r��sI����h����#�t���
�s�)�C�5�E��>�>�X�%�U�#�-U�u�-U�*U�Urc���t|t�r6|jdk(r|jS|j�d|j��S|turyt|t
�r|jSt|�S)z�Return the repr() of an object, special-casing types (internal helper).

    Copied from :mod:`typing` since collections.abc
    shouldn't depend on that module.
    (Keep this roughly in sync with the typing version.)
    �builtins�.z...)r�r�rFrGr��FunctionTyperE�repr)r�s r	r�r�sk���#�t���>�>�Z�'��#�#�#��.�.�!��3�#3�#3�"4�5�5�
�h����#�|�$��|�|����9�rc�@�eZdZdZed��Zed��Zee�Z	y)rrc��yr�r)r=r��kwdss   r	�__call__zCallable.__call__!r�rc�6�|turt|d�StS)Nr�)rr8r2rAs  r	rCzCallable.__subclasshook__%rDrN)
rErFrGrHrr�rIrCr�rQrrr	rrs;���I���������
$�$9�:�rrc�x�eZdZdZdZd�Zd�Zd�Zd�Zd�Z	e
d��Zd	�ZeZ
d
�Zd�ZeZd�Zd
�Zd�ZeZd�Zy)raZA set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__ and __len__.

    To override the comparisons (presumably for speed, as the
    semantics are fixed), redefine __le__ and __ge__,
    then the other operations will automatically follow suit.
    rc�z�t|t�stSt|�t|�kDry|D]}||vs�yy�NFT�r�rr2r��r=�other�elems   r	�__le__z
Set.__le__>s?���%��%�!�!��t�9�s�5�z�!���D��5� ���rc��t|t�stSt|�t|�kxr|j	|�Sr�r�rr2r�r��r=r�s  r	�__lt__z
Set.__lt__H�3���%��%�!�!��4�y�3�u�:�%�<�$�+�+�e�*<�<rc��t|t�stSt|�t|�kDxr|j	|�Sr)r�rr2r��__ge__r�s  r	�__gt__z
Set.__gt__Mr�rc�z�t|t�stSt|�t|�kry|D]}||vs�yyr�r�r�s   r	r�z
Set.__ge__Rs?���%��%�!�!��t�9�s�5�z�!���D��4����rc��t|t�stSt|�t|�k(xr|j	|�Srr�r�s  r	�__eq__z
Set.__eq__\s3���%��%�!�!��4�y�C��J�&�=�4�;�;�u�+=�=rc��||�S)z�Construct an instance of the class from any iterable input.

        Must override this method if the class constructor signature
        does not accept an iterable for an input.
        r�rB�its  r	�_from_iterablezSet._from_iterableas
���2�w�rc�d��t|t�stS�j�fd�|D��S)Nc3�,�K�|]}|�vs�|���
y�wrr�r�rWr=s  �r	r�zSet.__and__.<locals>.<genexpr>ms�����"M�e�U�u��}�5�e�s�	��r�rr2r�r�s` r	�__and__zSet.__and__js*����%��*�!�!��"�"�"M�e�"M�M�Mrc��|D]}||vs�yy)z1Return True if two sets have a null intersection.FTr)r=r�rWs   r	�
isdisjointzSet.isdisjointqs���E���}���rc�f�t|t�stSd�||fD�}|j|�S)Nc3�.K�|]
}|D]}|����y�wrr)r��s�es   r	r�zSet.__or__.<locals>.<genexpr>{s����5�M�q�1�a��1��M�s�r)r=r��chains   r	�__or__z
Set.__or__xs1���%��*�!�!�5�T�5�M�5���"�"�5�)�)rc���t�t�s't�t�stS|j	���|j	�fd�|D��S)Nc3�*�K�|]
}|�vr|���y�wrr)r�rWr�s  �r	r�zSet.__sub__.<locals>.<genexpr>�s�����#:�d�U�&+�5�&8�$)�d����r�rrr2r�r�s `r	�__sub__zSet.__sub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#:�d�#:�:�	:rc���t|t�s't|t�stS�j	|�}�j	�fd�|D��S)Nc3�*�K�|]
}|�vr|���y�wrrr�s  �r	r�zSet.__rsub__.<locals>.<genexpr>�s�����#9�e�U�&+�4�&7�$)�e�rr
r�s` r	�__rsub__zSet.__rsub__�sL����%��%��e�X�.�%�%��'�'��.�E��"�"�#9�e�#9�9�	9rc��t|t�s't|t�stS|j	|�}||z
||z
zSrr
r�s  r	�__xor__zSet.__xor__�s?���%��%��e�X�.�%�%��'�'��.�E��u�����.�.rc��tj}d|zdz}t|�}d|dzz}||z}|D]#}t|�}|||dzzdzdzz}||z}�%||dz	|dz	zz}|d	zd
z}||z}||kDr||dzz}|dk(rd}|S)
a+Compute the hash value of a set.

        Note that we don't define __hash__: not all sets are hashable.
        But if you define a hashable set type, its __hash__ should
        call this function.

        This must be compatible __eq__.

        All sets ought to compare equal if they contain the same
        elements, regardless of how they are implemented, and
        regardless of the order of the elements; so there's not much
        freedom for __eq__ or __hash__.  We match the algorithm used
        by the built-in frozenset type.
        r�r%iM��r�i�M[l�4~2��i�
i��6r�i��8#)�sys�maxsizer��hash)r=�MAX�MASK�n�hr��hxs       r	�_hashz	Set._hash�s����k�k���3�w��{����I���!�a�%� ��	�T�	���A��a��B�
�"��b��/�H�,��;�;�A�
��I�A��	
�a�2�g�!�r�'�
"�"��
��I�	�!��	�T�	���s�7�
����M�A���7��A��rN)rErFrGr�rHr�r�r�r�r�rIr�r�__rand__rr	�__ror__rrr�__rxor__r rrr	rr1st����I��=�
=�
�>�
����N�
�H��*��G�:�9�/��H�rrc�^�eZdZdZdZed��Zed��Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zy)
ra�A mutable set is a finite, iterable container.

    This class provides concrete generic implementations of all
    methods except for __contains__, __iter__, __len__,
    add(), and discard().

    To override the comparisons (presumably for speed, as the
    semantics are fixed), all you have to do is redefine __le__ and
    then the other operations will automatically follow suit.
    rc��t�)zAdd an element.r�rVs  r	�addzMutableSet.add��
��"�!rc��t�)z8Remove an element.  Do not raise an exception if absent.r�rVs  r	�discardzMutableSet.discard�r'rc�D�||vrt|��|j|�y)z5Remove an element. If not a member, raise a KeyError.N)�KeyErrorr)rVs  r	�removezMutableSet.remove�s ������5�/�!����U�rc�~�t|�}	t|�}|j	|�|S#t$rtd�wxYw)z2Return the popped value.  Raise KeyError if empty.N)�iter�nextrUr+r)�r=r�rWs   r	�popzMutableSet.pop�sE��
�$�Z��	%���H�E�	
���U������	%���$�	%�s�+�<c�F�		|j��#t$rYywxYw)z6This is slow (creates N new iterators!) but effective.N)r1r+r<s r	�clearzMutableSet.clear�s*��	�����
����	��	����	 � c�6�|D]}|j|��|Sr)r&r0s   r	�__ior__zMutableSet.__ior__�s���E��H�H�U�O���rc�<�||z
D]}|j|��|Sr)r)r0s   r	�__iand__zMutableSet.__iand__�s!���R�i�E��L�L��� ��rc���||ur|j�|St|t�s|j|�}|D])}||vr|j	|��|j|��+|Sr)r3r�rr�r)r&r0s   r	�__ixor__zMutableSet.__ixor__�sd��
��:��J�J�L����b�#�&��(�(��,�����D�=��L�L��'��H�H�U�O�	�
�rc�b�||ur|j�|S|D]}|j|��|Sr)r3r)r0s   r	�__isub__zMutableSet.__isub__s6��
��:��J�J�L��������U�#���rN)rErFrGr�rHrr&r)r,r1r3r6r8r:r<rrr	rr�sW��	��I��"��"��"��"�����
�
�rrc�R�eZdZdZdZdZed��Zdd�Zd�Z	d�Z
d	�Zd
�Zd�Z
dZy)
rz�A Mapping is a generic container for associating key/value
    pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __iter__, and __len__.
    r�@c��t�r�r+�r=�keys  r	r�zMapping.__getitem__ ����rNc�0�	||S#t$r|cYSwxYw)z<D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.r@�r=rB�defaults   r	�getzMapping.get$s%��	���9����	��N�	�s���c�.�	||y#t$rYywxYw�NTFr@rAs  r	r�zMapping.__contains__+s'��	���I����	��	�s��	�c��t|�S)z:D.keys() -> a set-like object providing a view on D's keys)rr<s r	�keyszMapping.keys3s����~�rc��t|�S)z<D.items() -> a set-like object providing a view on D's items)rr<s r	�itemsz
Mapping.items7s�����rc��t|�S)z6D.values() -> an object providing a view on D's values)r r<s r	�valueszMapping.values;s
���$��rc��t|t�stSt|j	��t|j	��k(Sr)r�rr2�dictrMr�s  r	r�zMapping.__eq__?s3���%��)�!�!��D�J�J�L�!�T�%�+�+�-�%8�8�8rr)rErFrGr�rH�__abc_tpflags__rr�rGr�rKrMrOr�r�rrr	rrsL����I��O��������� �9�
�Lrrc�2�eZdZdZd�Zd�Zd�Zee�Z	y)r��_mappingc��||_yrrT)r=�mappings  r	�__init__zMappingView.__init__Ms	����
rc�,�t|j�Sr)r�rUr<s r	r�zMappingView.__len__Ps���4�=�=�!�!rc�$�dj|�S)Nz&{0.__class__.__name__}({0._mapping!r}))�formatr<s r	r�zMappingView.__repr__Ss��7�>�>�t�D�DrN)
rErFrGrHrXr�r�rIrPrQrrr	rrIs$���I� �"�E�$�L�1�rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Sr��setr�s  r	r�zKeysView._from_iterable]����2�w�rc��||jvSrrTrAs  r	r�zKeysView.__contains__as���d�m�m�#�#rc#�8K�|jEd{���y7��wrrTr<s r	r�zKeysView.__iter__ds�����=�=� � �s���N�rErFrGrHrIr�r�r�rrr	rrYs#���I�����$�!rrc�,�eZdZdZed��Zd�Zd�Zy)rrc��t|�Srr^r�s  r	r�zItemsView._from_iterableor`rc�`�|\}}	|j|}||uxs||k(S#t$rYywxYwr�)rUr+)r=r�rBrW�vs     r	r�zItemsView.__contains__ssG���
��U�	,��
�
�c�"�A���:�+��e��+���	��	�s�!�	-�-c#�TK�|jD]}||j|f���y�wrrTrAs  r	r�zItemsView.__iter__|s(�����=�=�C���
�
�c�*�+�+�!�s�&(Nrcrrr	rrks#���I�����,�,rrc��eZdZdZd�Zd�Zy)r rc�Z�|jD]}|j|}||us||k(s�yyrIrT)r=rWrBrgs    r	r�zValuesView.__contains__�s3���=�=�C��
�
�c�"�A��E�z�Q�%�Z��!�rc#�PK�|jD]}|j|���y�wrrTrAs  r	r�zValuesView.__iter__�s#�����=�=�C��-�-��$�$�!�s�$&N)rErFrGrHr�r�rrr	r r �s���I��%rr c�h�eZdZdZdZed��Zed��Ze�Z	e	fd�Z
d�Zd�Zdd�Z
dd
�Zy	)
rz�A MutableMapping is a generic container for associating
    key/value pairs.

    This class provides concrete generic implementations of all
    methods except for __getitem__, __setitem__, __delitem__,
    __iter__, and __len__.
    rc��t�rr@�r=rBrWs   r	�__setitem__zMutableMapping.__setitem__�rCrc��t�rr@rAs  r	�__delitem__zMutableMapping.__delitem__�rCrc�X�	||}||=|S#t$r||jur�|cYSwxYw)z�D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
          If key is not found, d is returned if given, otherwise KeyError is raised.
        )r+�_MutableMapping__marker)r=rBrFrWs    r	r1zMutableMapping.pop�sC��	���I�E��S�	��L��
�	��$�-�-�'���N�	�s��)�)c�l�	tt|��}||}||=||fS#t$rtd�wxYw)z�D.popitem() -> (k, v), remove and return some (key, value) pair
           as a 2-tuple; but raise KeyError if D is empty.
        N)r/r.rUr+rns   r	�popitemzMutableMapping.popitem�sJ��	%��t�D�z�"�C��S�	����I��E�z���	�	%���$�	%�s�"�3c�F�		|j��#t$rYywxYw)z,D.clear() -> None.  Remove all items from D.N)rur+r<s r	r3zMutableMapping.clear�s*��	���������	��	�r4c���t|t�r|D]
}||||<�n9t|d�r|j�D]
}||||<�n|D]
\}}|||<�|j	�D]
\}}|||<�y)aK D.update([E, ]**F) -> None.  Update D from mapping/iterable E and F.
            If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
            If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
            In either case, this is followed by: for k, v in F.items(): D[k] = v
        rKN)r�r�hasattrrKrM)r=r�r�rBrWs     r	�updatezMutableMapping.update�s����e�W�%���!�#�J��S�	��
�U�F�
#��z�z�|��!�#�J��S�	�$�$�
��U�!��S�	�$��*�*�,�J�C���D��I�'rNc�8�	||S#t$r	|||<Y|SwxYw)z@D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in Dr@rEs   r	�
setdefaultzMutableMapping.setdefault�s.��	 ���9����	 ��D��I���	 �s���)rr)rErFrGr�rHrrorq�objectrsr1rur3ryr{rrr	rr�sY����I����������x�H�'��
���$rrc�H�eZdZdZdZdZed��Zd�Zd�Z	d�Z
dd	�Zd
�Zy)r!z�All the operations on a read-only sequence.

    Concrete subclasses must override __new__ or __init__,
    __getitem__, and __len__.
    r� c��t�r��
IndexError�r=�indexs  r	r�zSequence.__getitem__�����rc#�NK�d}		||}|��|dz
}�#t$rYywxYw�w)Nrr%r�)r=�irgs   r	r�zSequence.__iter__�sB����
��	����G�����Q������	��	�s�%��	"�%�"�%c�(�|D]
}||us||k(s�
yyrIr)r=rWrgs   r	r�zSequence.__contains__s!���A��E�z�Q�%�Z���rc#�^K�ttt|���D]	}||���y�wr)�reversed�ranger�)r=r�s  r	r�zSequence.__reversed__s'�����%��D�	�*�+�A��q�'�M�,�s�+-Nc���|�|dkrtt|�|zd�}|�|dkr|t|�z
}|}|�||kr	||}||us||k(r|S|dz
}|��||kr�t�#t$rYt�wxYw)z�S.index(value, [start, [stop]]) -> integer -- return first index of value.
           Raises ValueError if the value is not present.

           Supporting start and stop arguments is optional, but
           recommended.
        rr%)�maxr�r��
ValueError)r=rW�start�stopr�rgs      r	r�zSequence.indexs����������D�	�E�)�1�-�E����q���C��I��D����l�a�$�h�
���G���E�z�Q�%�Z���
��F�A��l�a�$�h�����
����
�s�A#�#	A4�3A4c�,��t�fd�|D��S)zBS.count(value) -> integer -- return number of occurrences of valuec3�6�K�|]}|�us|�k(s�
d���y�w)r%Nr)r�rgrWs  �r	r�z!Sequence.count.<locals>.<genexpr>+s�����?�d��a�5�j�A��J�1�d�s��)�sumrVs `r	�countzSequence.count)s����?�d�?�?�?r)rN)
rErFrGr�rHrRrr�r�r�r�r�r�rrr	r!r!�sA����I��O���������.@rr!c�(��eZdZ�fd�Z�fd�Z�xZS)�_DeprecateByteStringMetac�b��|dk7rddl}|jdd��t�|�||||fi|��S)Nr#r�collections.abc.ByteString����r,)�warnings�_deprecatedr�r�)rBr��bases�	namespace�kwargsr�r�s      �r	r�z _DeprecateByteStringMeta.__new__3sC����<���� � �,��
!�
��w��s�D�%��E�f�E�Erc�P��ddl}|jdd��t�|�
|�S)Nrr�r�r�)r�r�r��__instancecheck__)rB�instancer�r�s   �r	r�z*_DeprecateByteStringMeta.__instancecheck__=s1�������(��	�	
��w�(��2�2r)rErFrGr�r�r�r�s@r	r�r�2s���F�3�3rr�c��eZdZdZdZy)r#zMThis unifies bytes and bytearray.

    XXX Should add all their methods.
    rN)rErFrGr�rHrrr	r#r#Fs���
�Irr#c�p�eZdZdZdZed��Zed��Zed��Zd�Z	d�Z
d�Zd	�Zdd
�Z
d�Zd�Zy
)r"z�All the operations on a read-write sequence.

    Concrete subclasses must provide __new__ or __init__,
    __getitem__, __setitem__, __delitem__, __len__, and insert().
    rc��t�rr��r=r�rWs   r	rozMutableSequence.__setitem__[r�rc��t�rr�r�s  r	rqzMutableSequence.__delitem___r�rc��t�)z3S.insert(index, value) -- insert value before indexr�r�s   r	�insertzMutableSequence.insertcs
���rc�:�|jt|�|�y)z:S.append(value) -- append value to the end of the sequenceN)r�r�rVs  r	�appendzMutableSequence.appendhs�����C��I�u�%rc�F�		|j��#t$rYywxYw)z,S.clear() -> None -- remove all items from SN)r1r�r<s r	r3zMutableSequence.clearls*��	�����
����	��	�r4c�z�t|�}t|dz�D]}|||z
dz
||c||<|||z
dz
<�!y)z!S.reverse() -- reverse *IN PLACE*r�r%N)r�r�)r=rr�s   r	�reversezMutableSequence.reversetsI����I���q�!�t��A�#'��!��A��;��Q�� �D��G�T�!�A�#�a�%�[�rc�R�||urt|�}|D]}|j|��y)zMS.extend(iterable) -- extend sequence by appending elements from the iterableN)r�r�)r=rOrgs   r	�extendzMutableSequence.extendzs'���T�>��&�\�F��A��K�K��N�rc��||}||=|S)z�S.pop([index]) -> item -- remove and return item at index (default last).
           Raise IndexError if list is empty or index is out of range.
        r)r=r�rgs   r	r1zMutableSequence.pop�s��
��K����K��rc�(�||j|�=y)zvS.remove(value) -- remove first occurrence of value.
           Raise ValueError if the value is not present.
        N)r�rVs  r	r,zMutableSequence.remove�s��
����E�"�#rc�(�|j|�|Sr)r�)r=rOs  r	�__iadd__zMutableSequence.__iadd__�s�����F���rN)r�)rErFrGr�rHrrorqr�r�r3r�r�r1r,r�rrr	r"r"Rsk����I�������������&��8���$�rr")Ur��abcrrrr�r�r�rP�EllipsisTyper
r��__all__rEr.�bytes_iterator�	bytearray�bytearray_iteratorrK�dict_keyiteratorrO�dict_valueiteratorrM�dict_itemiterator�
list_iteratorr��list_reverseiteratorr��range_iterator�longrange_iteratorr_�set_iterator�str_iterator�tuple_iterator�zip�zip_iterator�	dict_keys�dict_values�
dict_itemsr1�mappingproxy�	generatorr*�	coroutinerhr-�async_generatorr8rrr�registerr
rrrrrrrrrr$r�r�r�rr�	frozensetrrrrrr rrQr!r��strr�r�r#�bytesr"rrr	�<module>r�s���>(�
��D��I����C�y����B�x���	
�����d�3�i����$�y�{�+�,����R�W�W�Y��(���$�r�y�y�{�+�,����b�h�h�j�)�*���T�"�X��
��D��"��.�/���d�5��8�n�%���$�u�Q�$�Y�/�0�1���D���K� ���D��H�~���d�2�h����D���K� �������O�	��2�9�9�;���
�"�(�(�*�
�
��D�M�M�"���/�$�%�	��
�����K�	����
�	��	�e���s�)���

����2�'�2�"&�	�&�R
���9��2�g�2�"�M��&-�]�-�`����(�2��2�$�x��&	���.�!����$�%����"�#����$�%����#�$����-� ����&�'����.�!����$�%����,�����,�����.�!����,��
��
� -��-�`
���9���g��2�'�2�"���)���w��4@�L�4@�l
V��$;��;�(G�*�G�T���Y��M��M�`���C��
1�j�1�f�����
2�%�
2� !�{�C�!�	���)��,��S�,�,
���:��
%��j�
%� ���K� �O�W�O�d�����
=@�z�:�=@�~	���%�����#�����%�����*��3�w�3�(��%=�����E��
���I��?�h�?�D���������#r�� �dZdZgd�ZddlZddlZddlmZmZmZmZm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZde_dZdZdZGd	�d
ej0ej2��ZGd�d
ej6e�ZGd�dej:e�ZGd�dej>e�Z ejCe
�ee
eeefD]Z"ejCe"��eefD]Z"e jCe"��["	ddlm#Z#ejCe#�y#e$$rYywxYw)a�The io module provides the Python interfaces to stream handling. The
builtin open function is defined in this module.

At the top of the I/O hierarchy is the abstract base class IOBase. It
defines the basic interface to a stream. Note, however, that there is no
separation between reading and writing to streams; implementations are
allowed to raise an OSError if they do not support a given operation.

Extending IOBase is RawIOBase which deals simply with the reading and
writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
an interface to OS files.

BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
streams that are readable, writable, and both respectively.
BufferedRandom provides a buffered interface to random access
streams. BytesIO is a simple stream of in-memory bytes.

Another IOBase subclass, TextIOBase, deals with the encoding and decoding
of streams into text. TextIOWrapper, which extends it, is a buffered text
interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
is an in-memory stream for text.

Argument names are not part of the specification, and only the arguments
of open() are intended to be used as keyword arguments.

data:

DEFAULT_BUFFER_SIZE

   An int containing the default buffer size used by the module's buffered
   I/O classes. open() uses the file's blksize (as obtained by os.stat) if
   possible.
z�Guido van Rossum <guido@python.org>, Mike Verdone <mike.verdone@gmail.com>, Mark Russell <mark.russell@zen.co.uk>, Antoine Pitrou <solipsis@pitrou.net>, Amaury Forgeot d'Arc <amauryfa@gmail.com>, Benjamin Peterson <benjamin@python.org>)�BlockingIOError�open�	open_code�IOBase�	RawIOBase�FileIO�BytesIO�StringIO�BufferedIOBase�BufferedReader�BufferedWriter�BufferedRWPair�BufferedRandom�
TextIOBase�
TextIOWrapper�UnsupportedOperation�SEEK_SET�SEEK_CUR�SEEK_END�DEFAULT_BUFFER_SIZE�
text_encoding�IncrementalNewlineDecoder�N)rrrrrrrr	rrr
rrrr�io��c�8�eZdZejj
Zy)rN)�__name__�
__module__�__qualname__�_io�_IOBase�__doc__���<frozen io>rrHs���k�k�!�!�Gr$r)�	metaclassc�8�eZdZejj
Zy)rN)rrrr �
_RawIOBaser"r#r$r%rrKs���n�n�$�$�Gr$rc�8�eZdZejj
Zy)r
N)rrrr �_BufferedIOBaser"r#r$r%r
r
Ns���!�!�)�)�Gr$r
c�8�eZdZejj
Zy)rN)rrrr �_TextIOBaser"r#r$r%rrQs���o�o�%�%�Gr$r)�_WindowsConsoleIO)%r"�
__author__�__all__r �abcrrrrrrrr	rrr
rrrrrrrrr!�ABCMetarr(rr*r
r,r�register�klassr-�ImportErrorr#r$r%�<module>r5s/��!�H8�
�P���
�J�J�J�J�J�#'���
������
"�S�[�[�C�K�K�"�%�����%�*�S�(�(�&�*�&����&�&�
���6���~�~�~���E����E�"���
�
&�E������'�	�*�%����(�)���	��	�s�-D�D
�D
���dZddlZddlZ	ddl�gd�ZdZdxZ	Z
dxZZd	Z
d
Zejdk(re
xZZe
ZnexZZeZe
ZeZe
ZeZGd�d
e�ZGd�d�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�Z Gd�d�Z!Gd�d�Z"d2d!�Z#d3d"�Z$d#�Z%d$�Z&d%�Z'd&�Z(d'�Z)d(�Z*d4d)�Z+d4d*�Z,d+�Z-d,�Z.	e/d �Z0e/d-�Z1e/d.�Z2e/d/�Z3e/d0�Z4e/d1�Z5dZ7e7rddl8Z8yy#e$rZedez��dZ[wwxYw#e6$rdZ0dZ1dZ2dZ3dZ4dZ5Y�5wxYw)5z� codecs -- Python Codec Registry, API and helpers.


Written by Marc-Andre Lemburg (mal@lemburg.com).

(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.

�N)�*z%Failed to load the builtin codecs: %s),�register�lookup�open�EncodedFile�BOM�BOM_BE�BOM_LE�BOM32_BE�BOM32_LE�BOM64_BE�BOM64_LE�BOM_UTF8�	BOM_UTF16�BOM_UTF16_LE�BOM_UTF16_BE�	BOM_UTF32�BOM_UTF32_LE�BOM_UTF32_BE�	CodecInfo�Codec�IncrementalEncoder�IncrementalDecoder�StreamReader�StreamWriter�StreamReaderWriter�
StreamRecoder�
getencoder�
getdecoder�getincrementalencoder�getincrementaldecoder�	getreader�	getwriter�encode�decode�
iterencode�
iterdecode�
strict_errors�
ignore_errors�replace_errors�xmlcharrefreplace_errors�backslashreplace_errors�namereplace_errors�register_error�lookup_errorss��s��s��s���littlec�,�eZdZdZdZ		ddd�d�Zd�Zy)rz0Codec details when looking up the codec registryTN)�_is_text_encodingc��tj|||||f�}	||	_||	_||	_||	_||	_||	_||	_|�||	_	|	S�N)
�tuple�__new__�namer$r%�incrementalencoder�incrementaldecoder�streamwriter�streamreaderr2)
�clsr$r%r;r:r8r9r7r2�selfs
          �<frozen codecs>r6zCodecInfo.__new__^se���}�}�S�6�6�<��"N�O����	�������"4���"4���(���(����(�%6�D�"���c��d|jj|jj|jt	|�fzS)Nz%<%s.%s object for encoding %s at %#x>)�	__class__�
__module__�__qualname__r7�id�r=s r>�__repr__zCodecInfo.__repr__ms:��6����*�*�D�N�N�,G�,G����B�t�H�&�&�	&r?)NNNNN)�__name__rBrC�__doc__r2r6rF�r?r>rrSs%��:���EI�?C�
�!�
�&r?rc� �eZdZdZdd�Zdd�Zy)ra9 Defines the interface for stateless encoders/decoders.

        The .encode()/.decode() methods may use different error
        handling schemes by providing the errors argument. These
        string values are predefined:

         'strict' - raise a ValueError error (or a subclass)
         'ignore' - ignore the character and continue with the next
         'replace' - replace with a suitable replacement character;
                    Python will use the official U+FFFD REPLACEMENT
                    CHARACTER for the builtin Unicode codecs on
                    decoding and '?' on encoding.
         'surrogateescape' - replace with private code points U+DCnn.
         'xmlcharrefreplace' - Replace with the appropriate XML
                               character reference (only for encoding).
         'backslashreplace'  - Replace with backslashed escape sequences.
         'namereplace'       - Replace with \N{...} escape sequences
                               (only for encoding).

        The set of allowed values can be extended via register_error.

    c��t�)a# Encodes the object input and returns a tuple (output
            object, length consumed).

            errors defines the error handling to apply. It defaults to
            'strict' handling.

            The method may not store state in the Codec instance. Use
            StreamWriter for codecs which have to keep state in order to
            make encoding efficient.

            The encoder must be able to handle zero length input and
            return an empty object of the output object type in this
            situation.

        ��NotImplementedError�r=�input�errorss   r>r$zCodec.encode�s
��""�!r?c��t�)a� Decodes the object input and returns a tuple (output
            object, length consumed).

            input must be an object which provides the bf_getreadbuf
            buffer slot. Python strings, buffer objects and memory
            mapped files are examples of objects providing this slot.

            errors defines the error handling to apply. It defaults to
            'strict' handling.

            The method may not store state in the Codec instance. Use
            StreamReader for codecs which have to keep state in order to
            make decoding efficient.

            The decoder must be able to handle zero length input and
            return an empty object of the output object type in this
            situation.

        rLrNs   r>r%zCodec.decode�s
��*"�!r?N��strict)rGrBrCrHr$r%rIr?r>rrrs���,"�&"r?rc�2�eZdZdZdd�Zd	d�Zd�Zd�Zd�Zy)
rz�
    An IncrementalEncoder encodes an input in multiple steps. The input can
    be passed piece by piece to the encode() method. The IncrementalEncoder
    remembers the state of the encoding process between calls to encode().
    c� �||_d|_y)z�
        Creates an IncrementalEncoder instance.

        The IncrementalEncoder may use different error handling schemes by
        providing the errors keyword argument. See the module docstring
        for a list of possible values.
        �N)rP�buffer�r=rPs  r>�__init__zIncrementalEncoder.__init__�s�������r?c��t�)zA
        Encodes input and returns the resulting object.
        rL�r=rO�finals   r>r$zIncrementalEncoder.encode��
��"�!r?c��y)z:
        Resets the encoder to the initial state.
        NrIrEs r>�resetzIncrementalEncoder.reset���r?c��y)z:
        Return the current state of the encoder.
        rrIrEs r>�getstatezIncrementalEncoder.getstate�s��r?c��y)zl
        Set the current state of the encoder. state must have been
        returned by getstate().
        NrI�r=�states  r>�setstatezIncrementalEncoder.setstate�r`r?NrR�F)	rGrBrCrHrYr$r_rbrfrIr?r>rr�s ���
	�"��
�r?rc�8�eZdZdZd	d�Zd�Zd
d�Zd�Zd�Zd�Z	y)�BufferedIncrementalEncoderz�
    This subclass of IncrementalEncoder can be used as the baseclass for an
    incremental encoder if the encoder must keep some of the output in a
    buffer between calls to encode().
    c�>�tj||�d|_y�NrV)rrYrWrXs  r>rYz#BufferedIncrementalEncoder.__init__�s���#�#�D�&�1���r?c��t�r4rL�r=rOrPr\s    r>�_buffer_encodez)BufferedIncrementalEncoder._buffer_encode��
��"�!r?c�x�|j|z}|j||j|�\}}||d|_|Sr4)rWrnrP�r=rOr\�data�result�consumeds      r>r$z!BufferedIncrementalEncoder.encode��?���{�{�U�"��!�0�0��t�{�{�E�J�����8�9�o����
r?c�<�tj|�d|_yrk)rr_rWrEs r>r_z BufferedIncrementalEncoder.reset�s��� � ��&���r?c�"�|jxsdS�Nr�rWrEs r>rbz#BufferedIncrementalEncoder.getstate�s���{�{��a�r?c��|xsd|_yrkryrds  r>rfz#BufferedIncrementalEncoder.setstate�s
���k�r��r?NrRrg)
rGrBrCrHrYrnr$r_rbrfrIr?r>riri�s%���
�
"�
�� �"r?ric�2�eZdZdZdd�Zd	d�Zd�Zd�Zd�Zy)
rz�
    An IncrementalDecoder decodes an input in multiple steps. The input can
    be passed piece by piece to the decode() method. The IncrementalDecoder
    remembers the state of the decoding process between calls to decode().
    c��||_y)z�
        Create an IncrementalDecoder instance.

        The IncrementalDecoder may use different error handling schemes by
        providing the errors keyword argument. See the module docstring
        for a list of possible values.
        N)rPrXs  r>rYzIncrementalDecoder.__init__s����r?c��t�)z@
        Decode input and returns the resulting object.
        rLr[s   r>r%zIncrementalDecoder.decoder]r?c��y)z9
        Reset the decoder to the initial state.
        NrIrEs r>r_zIncrementalDecoder.resetr`r?c��y)a	
        Return the current state of the decoder.

        This must be a (buffered_input, additional_state_info) tuple.
        buffered_input must be a bytes object containing bytes that
        were passed to decode() that have not yet been converted.
        additional_state_info must be a non-negative integer
        representing the state of the decoder WITHOUT yet having
        processed the contents of buffered_input.  In the initial state
        and after reset(), getstate() must return (b"", 0).
        )r?rrIrEs r>rbzIncrementalDecoder.getstates��r?c��y)z�
        Set the current state of the decoder.

        state must have been returned by getstate().  The effect of
        setstate((b"", 0)) must be equivalent to reset().
        NrIrds  r>rfzIncrementalDecoder.setstate'r`r?NrRrg)	rGrBrCrHrYr%r_rbrfrIr?r>rr�s ���
�"��
�r?rc�8�eZdZdZd	d�Zd�Zd
d�Zd�Zd�Zd�Z	y)�BufferedIncrementalDecoderz�
    This subclass of IncrementalDecoder can be used as the baseclass for an
    incremental decoder if the decoder must be able to handle incomplete
    byte sequences.
    c�>�tj||�d|_y�Nr?)rrYrWrXs  r>rYz#BufferedIncrementalDecoder.__init__5s���#�#�D�&�1���r?c��t�r4rLrms    r>�_buffer_decodez)BufferedIncrementalDecoder._buffer_decode:ror?c�x�|j|z}|j||j|�\}}||d|_|Sr4)rWr�rPrqs      r>r%z!BufferedIncrementalDecoder.decode?rur?c�<�tj|�d|_yr�)rr_rWrEs r>r_z BufferedIncrementalDecoder.resetGs��� � ��&���r?c��|jdfSrxryrEs r>rbz#BufferedIncrementalDecoder.getstateKs�����Q��r?c��|d|_yrxryrds  r>rfz#BufferedIncrementalDecoder.setstateOs
���A�h��r?NrRrg)
rGrBrCrHrYr�r%r_rbrfrIr?r>r�r�/s%���
�
"�
�� �r?r�c�J�eZdZdd�Zd�Zd�Zd�Zdd�Zefd�Z	d�Z
d�Zd	�Zy
)
rc� �||_||_y)aw Creates a StreamWriter instance.

            stream must be a file-like object open for writing.

            The StreamWriter may use different error handling
            schemes by providing the errors keyword argument. These
            parameters are predefined:

             'strict' - raise a ValueError (or a subclass)
             'ignore' - ignore the character and continue with the next
             'replace'- replace with a suitable replacement character
             'xmlcharrefreplace' - Replace with the appropriate XML
                                   character reference.
             'backslashreplace'  - Replace with backslashed escape
                                   sequences.
             'namereplace'       - Replace with \N{...} escape sequences.

            The set of allowed parameter values can be extended via
            register_error.
        N)�streamrP�r=r�rPs   r>rYzStreamWriter.__init__\s��,�����r?c�x�|j||j�\}}|jj|�y)z> Writes the object's contents encoded to self.stream.
        N)r$rPr��write)r=�objectrrrts    r>r�zStreamWriter.writeus.�����V�T�[�[�9���h������$�r?c�D�|jdj|��y)z[ Writes the concatenated list of strings to the stream
            using .write().
        rVN)r��join�r=�lists  r>�
writelineszStreamWriter.writelines|s��
	
�
�
�2�7�7�4�=�!r?c��y)a2 Resets the codec buffers used for keeping internal state.

            Calling this method should ensure that the data on the
            output is put into a clean state, that allows appending
            of new fresh data without having to rescan the whole
            stream to recover state.

        NrIrEs r>r_zStreamWriter.reset�s��	
r?c�t�|jj||�|dk(r|dk(r|j�yyyrx�r��seekr_�r=�offset�whences   r>r�zStreamWriter.seek�s3���������(��Q�;�6�Q�;��J�J�L�'�;r?c�(�||j|�S�z? Inherit all other methods from the underlying stream.
        �r��r=r7�getattrs   r>�__getattr__zStreamWriter.__getattr__����
�t�{�{�D�)�)r?c��|Sr4rIrEs r>�	__enter__zStreamWriter.__enter__�����r?c�8�|jj�yr4�r��close�r=�type�value�tbs    r>�__exit__zStreamWriter.__exit__���������r?c�F�td|jjz���Nzcan't serialize %s��	TypeErrorrArG�r=�protos  r>�
__reduce_ex__zStreamWriter.__reduce_ex__�����,�t�~�~�/F�/F�F�G�Gr?NrR�r)
rGrBrCrYr�r�r_r�r�r�r�r�r�rIr?r>rrZs5���2 �"�

��$�*���Hr?rc�n�eZdZeZdd�Zdd�Zdd�Zdd�Zdd�Z	d�Z
dd�Zd	�Zd
�Z
efd�Zd�Zd
�Zd�Zy)rc��||_||_d|_|j�|_|j|_d|_y)a� Creates a StreamReader instance.

            stream must be a file-like object open for reading.

            The StreamReader may use different error handling
            schemes by providing the errors keyword argument. These
            parameters are predefined:

             'strict' - raise a ValueError (or a subclass)
             'ignore' - ignore the character and continue with the next
             'replace'- replace with a suitable replacement character
             'backslashreplace' - Replace with backslashed escape sequences;

            The set of allowed parameter values can be extended via
            register_error.
        r?N)r�rP�
bytebuffer�charbuffertype�_empty_charbuffer�
charbuffer�
linebufferr�s   r>rYzStreamReader.__init__�s>��$���������!%�!4�!4�!6����0�0�����r?c��t�r4rLrNs   r>r%zStreamReader.decode�s��!�!r?c�F�|jr1|jj|j�|_d|_|dkr|}	|dk\rt	|j�|k\rn�|dkr|j
j
�}n|j
j
|�}|j|z}|snC	|j||j�\}}||d|_|xj|z
c_|sn��|dkr|j}
|j|_|
S|jd|}
|j|d|_|
S#t$rZ}|rM|j|d|j|j�\}}|jd��}	t	|	�dkr��Yd}~��d}~wwxYw)a� Decodes data from the stream self.stream and returns the
            resulting object.

            chars indicates the number of decoded code points or bytes to
            return. read() will never return more data than requested,
            but it might return less, if there is not enough available.

            size indicates the approximate maximum number of decoded
            bytes or code points to read for decoding. The decoder
            can modify this setting as appropriate. The default value
            -1 indicates to read and decode as much as possible.  size
            is intended to prevent having to decode huge files in one
            step.

            If firstline is true, and a UnicodeDecodeError happens
            after the first line terminator in the input only the first line
            will be returned, the rest of the input will be kept until the
            next call to read().

            The method should use a greedy read strategy, meaning that
            it should read as much data as is allowed within the
            definition of the encoding and the given size, e.g.  if
            optional encoding endings or state markers are available
            on the stream, these should be read too.
        NrT��keepends�)
r�r�r�r��lenr��readr�r%rP�UnicodeDecodeError�start�
splitlines)r=�size�chars�	firstline�newdatarr�newchars�decodedbytes�exc�linesrss           r>r�zStreamReader.read�s���8�?�?�"�4�4�9�9�$�/�/�J�D�O�"�D�O��1�9��E����z��t���'�5�0���a�x��+�+�*�*�,���+�+�*�*�4�0���?�?�W�,�D���

�)-���T�4�;�;�)G�&��,�#�<�=�1�D�O��O�O�x�'�O���?�@�1�9��_�_�F�"�4�4�D�O�
�
��_�_�V�e�,�F�"�o�o�e�f�5�D�O��
��1&�
�����D��#�)�)�$4�d�k�k�B�+�H�l�$�/�/��/�>�E��5�z�1�}���%��
�s�2D=�=	F �AF�F Nc�&�|jrh|jd}|jd=t|j�dk(r|jd|_d|_|s|jd��d}|S|xsd}|j}	|j|d��}|rXt
|t�r|jd	�s!t
|t�r'|jd
�r||jdd��z
}||z
}|jd��}|r�t|�dkDrm|d}|d=t|�dkDr&|dxx|jz
cc<||_d|_n|d|jz|_|s|jd��d}	|S|d}|djd��d}||k7r<|jj|dd�|jz|_|r|}	|S|}	|S|r|�|r|s|jd��d}	|S|d
kr|dz}���)z� Read one line from the input stream and return the
            decoded data.

            size, if given, is passed as size argument to the
            read() method.

        rr�NFr��HT)r��
�
)r�r����i@�)r�r�r�r�r�r��
isinstance�str�endswith�bytesr�)	r=r�r��line�readsizerrr��line0withend�line0withoutends	         r>�readlinezStreamReader.readlines;���?�?��?�?�1�%�D�����"��4�?�?�#�q�(�#'�/�/�!�"4���"&���������6�q�9���K��:�2���%�%����9�9�X��9�6�D���t�S�)�d�m�m�D�.A��t�U�+��
�
�e�0D��D�I�I�1�A�I�6�6�D��D�L�D��O�O�T�O�2�E���u�:��>�!��8�D��a���5�z�A�~��b�	�T�_�_�4�	�*/���*.���+0��(�T�_�_�*D���#�#�����>�q�A���&��% %�Q�x��"'��(�"5�"5�u�"5�"E�a�"H���?�2�&*�&<�&<�&A�&A�%���)�&L�&*�o�o�'6�D�O��+����� /�����
�4�+����?�?�E�?�:�1�=�D�����$���A�
��]r?c�D�|j�}|j|�S)aS Read all lines available on the input stream
            and return them as a list.

            Line breaks are implemented using the codec's decoder
            method and are included in the list entries.

            sizehint, if given, is ignored since there is no efficient
            way to finding the true end-of-line.

        )r�r�)r=�sizehintr�rrs    r>�	readlineszStreamReader.readlinesas���y�y�{�����x�(�(r?c�B�d|_|j|_d|_y)z� Resets the codec buffers used for keeping internal state.

            Note that no stream repositioning should take place.
            This method is primarily intended to be able to recover
            from decoding errors.

        r?N)r�r�r�r�rEs r>r_zStreamReader.resetps������0�0�����r?c�\�|jj||�|j�y)zp Set the input stream's current position.

            Resets the codec buffers used for keeping state.
        Nr�r�s   r>r�zStreamReader.seek}s!��
	
�������(��
�
�r?c�6�|j�}|r|St��z4 Return the next decoded line from the input stream.)r��
StopIteration)r=r�s  r>�__next__zStreamReader.__next__�s���}�}�����K��r?c��|Sr4rIrEs r>�__iter__zStreamReader.__iter__�r�r?c�(�||j|�Sr�r�r�s   r>r�zStreamReader.__getattr__�r�r?c��|Sr4rIrEs r>r�zStreamReader.__enter__�r�r?c�8�|jj�yr4r�r�s    r>r�zStreamReader.__exit__�r�r?c�F�td|jjz��r�r�r�s  r>r�zStreamReader.__reduce_ex__�r�r?rR)r�r�F)NTr�)rGrBrCr�r�rYr%r�r�r�r_r�r�r�r�r�r�r�r�rIr?r>rr�sR���N��2"�N�`I�V
)�����$�*���Hr?rc�v�eZdZdZdZdd�Zdd�Zdd�Zdd�Zd�Z	d	�Z
d
�Zd�Zd�Z
dd
�Zefd�Zd�Zd�Zd�Zy)ra StreamReaderWriter instances allow wrapping streams which
        work in both read and write modes.

        The design is such that one can use the factory functions
        returned by the codec.lookup() function to construct the
        instance.

    �unknownc�X�||_|||�|_|||�|_||_y)aR Creates a StreamReaderWriter instance.

            stream must be a Stream-like object.

            Reader, Writer must be factory functions or classes
            providing the StreamReader, StreamWriter interface resp.

            Error handling is done in the same way as defined for the
            StreamWriter/Readers.

        N)r��reader�writerrP)r=r��Reader�WriterrPs     r>rYzStreamReaderWriter.__init__�s.������V�V�,����V�V�,�����r?c�8�|jj|�Sr4)r�r��r=r�s  r>r�zStreamReaderWriter.read�s���{�{����%�%r?Nc�8�|jj|�Sr4)r�r�r�s  r>r�zStreamReaderWriter.readline�s���{�{�#�#�D�)�)r?c�8�|jj|�Sr4)r�r�)r=r�s  r>r�zStreamReaderWriter.readlines�s���{�{�$�$�X�.�.r?c�,�t|j�Sr�)�nextr�rEs r>r�zStreamReaderWriter.__next__�s���D�K�K� � r?c��|Sr4rIrEs r>r�zStreamReaderWriter.__iter__�r�r?c�8�|jj|�Sr4)r�r�)r=rrs  r>r�zStreamReaderWriter.write�s���{�{� � ��&�&r?c�8�|jj|�Sr4)r�r�r�s  r>r�zStreamReaderWriter.writelines�s���{�{�%�%�d�+�+r?c�l�|jj�|jj�yr4�r�r_r�rEs r>r_zStreamReaderWriter.reset��"�������������r?c��|jj||�|jj�|dk(r!|dk(r|jj�yyyrx)r�r�r�r_r�r�s   r>r�zStreamReaderWriter.seek�sJ���������(��������Q�;�6�Q�;��K�K����'�;r?c�(�||j|�Sr�r�r�s   r>r�zStreamReaderWriter.__getattr__�r�r?c��|Sr4rIrEs r>r�zStreamReaderWriter.__enter__�r�r?c�8�|jj�yr4r�r�s    r>r�zStreamReaderWriter.__exit__�r�r?c�F�td|jjz��r�r�r�s  r>r�z StreamReaderWriter.__reduce_ex__�r�r?rR�r�r4r�)rGrBrCrH�encodingrYr�r�r�r�r�r�r�r_r�r�r�r�r�r�rIr?r>rr�sZ����H��$&�*�/�!�
�'�,��
 �$�*���Hr?rc�|�eZdZdZdZdZ	dd�Zdd�Zdd�Zdd�Z	d�Z
d	�Zd
�Zd�Z
d�Zdd
�Zefd�Zd�Zd�Zd�Zy)raB StreamRecoder instances translate data from one encoding to another.

        They use the complete set of APIs returned by the
        codecs.lookup() function to implement their task.

        Data written to the StreamRecoder is first decoded into an
        intermediate format (depending on the "decode" codec) and then
        written to the underlying stream using an instance of the provided
        Writer class.

        In the other direction, data is read from the underlying stream using
        a Reader instance and then encoded and returned to the caller.

    r�c�t�||_||_||_|||�|_|||�|_||_y)a� Creates a StreamRecoder instance which implements a two-way
            conversion: encode and decode work on the frontend (the
            data visible to .read() and .write()) while Reader and Writer
            work on the backend (the data in stream).

            You can use these objects to do transparent
            transcodings from e.g. latin-1 to utf-8 and back.

            stream must be a file-like object.

            encode and decode must adhere to the Codec interface; Reader and
            Writer must be factory functions or classes providing the
            StreamReader and StreamWriter interfaces resp.

            Error handling is done in the same way as defined for the
            StreamWriter/Readers.

        N)r�r$r%r�r�rP)r=r�r$r%r�r�rPs       r>rYzStreamRecoder.__init__s<��*����������V�V�,����V�V�,�����r?c�z�|jj|�}|j||j�\}}|Sr4)r�r�r$rP�r=r�rr�bytesencodeds    r>r�zStreamRecoder.read,s4���{�{����%��!�[�[��t�{�{�;���l��r?Nc��|�|jj�}n|jj|�}|j||j�\}}|Sr4)r�r�r$rPrs    r>r�zStreamRecoder.readline2sK���<��;�;�'�'�)�D��;�;�'�'��-�D�!�[�[��t�{�{�;���l��r?c��|jj�}|j||j�\}}|j	d��S)NTr�)r�r�r$rPr�)r=r�rrrs    r>r�zStreamRecoder.readlines;s>���{�{���!��!�[�[��t�{�{�;���l������-�-r?c�n�t|j�}|j||j�\}}|Sr�)r�r�r$rP)r=rrrs   r>r�zStreamRecoder.__next__As0���D�K�K� ��!�[�[��t�{�{�;���l��r?c��|Sr4rIrEs r>r�zStreamRecoder.__iter__Hr�r?c�v�|j||j�\}}|jj|�Sr4)r%rPr�r�)r=rr�bytesdecodeds   r>r�zStreamRecoder.writeKs0��!�[�[��t�{�{�;���l��{�{� � ��&�&r?c��dj|�}|j||j�\}}|jj	|�Sr�)r�r%rPr�r�)r=r�rrrs    r>r�zStreamRecoder.writelinesPs=���x�x��~��!�[�[��t�{�{�;���l��{�{� � ��&�&r?c�l�|jj�|jj�yr4rrEs r>r_zStreamRecoder.resetVrr?c�t�|jj||�|jj||�yr4)r�r�r�r�s   r>r�zStreamRecoder.seek[s,��	
�������(��������(r?c�(�||j|�Sr�r�r�s   r>r�zStreamRecoder.__getattr__ar�r?c��|Sr4rIrEs r>r�zStreamRecoder.__enter__hr�r?c�8�|jj�yr4r�r�s    r>r�zStreamRecoder.__exit__kr�r?c�F�td|jjz��r�r�r�s  r>r�zStreamRecoder.__reduce_ex__nr�r?rRr	r4r�)rGrBrCrH�
data_encoding�
file_encodingrYr�r�r�r�r�r�r�r_r�r�r�r�r�r�rIr?r>rr�sd��
��M��M�!��8��.���'�
'��
)�$�*���Hr?rrSc���|�	d|vr|dz}tj|||�}|�|S	t|�}t||j|j
|�}||_|S#|j��xYw)a� Open an encoded file using the given mode and return
        a wrapped version providing transparent encoding/decoding.

        Note: The wrapped version will only accept the object format
        defined by the codecs, i.e. Unicode objects for most builtin
        codecs. Output is also codec dependent and will usually be
        Unicode as well.

        If encoding is not None, then the
        underlying encoded files are always opened in binary mode.
        The default file mode is 'r', meaning to open the file in read mode.

        encoding specifies the encoding which is to be used for the
        file.

        errors may be given to define the error handling. It defaults
        to 'strict' which causes ValueErrors to be raised in case an
        encoding error occurs.

        buffering has the same meaning as for the builtin open() API.
        It defaults to -1 which means that the default buffer size will
        be used.

        The returned wrapped file object provides an extra attribute
        .encoding which allows querying the used encoding. This
        attribute is only available if an encoding was specified as
        parameter.

    �b)�builtinsrrrr;r:r
r�)�filename�moder
rP�	buffering�file�info�srws        r>rrss���>��
�$���c�z���=�=��4��3�D�������h��� ��t�'8�'8�$�:K�:K�V�T������
����
�
��
�s�5A�A1c���|�|}t|�}t|�}t||j|j|j|j
|�}||_||_|S)a� Return a wrapped version of file which provides transparent
        encoding translation.

        Data written to the wrapped file is decoded according
        to the given data_encoding and then encoded to the underlying
        file using file_encoding. The intermediate data type
        will usually be Unicode but depends on the specified codecs.

        Bytes read from the file are decoded using file_encoding and then
        passed back to the caller encoded using data_encoding.

        If file_encoding is not given, it defaults to data_encoding.

        errors may be given to define the error handling. It defaults
        to 'strict' which causes ValueErrors to be raised in case an
        encoding error occurs.

        The returned wrapped file object provides two extra attributes
        .data_encoding and .file_encoding which reflect the given
        parameters of the same name. The attributes can be used for
        introspection by Python programs.

    )rrr$r%r;r:rr)r%rrrP�	data_info�	file_info�srs       r>rr�sj��2��%�
��}�%�I��}�%�I�	�t�Y�-�-�y�/?�/?� �-�-�y�/E�/E�v�
O�B�%�B��$�B��
�Ir?c�,�t|�jS)z� Lookup up the codec for the given encoding and return
        its encoder function.

        Raises a LookupError in case the encoding cannot be found.

    )rr$�r
s r>rr�����(��"�"�"r?c�,�t|�jS)z� Lookup up the codec for the given encoding and return
        its decoder function.

        Raises a LookupError in case the encoding cannot be found.

    )rr%r-s r>rr�r.r?c�J�t|�j}|�t|��|S)z� Lookup up the codec for the given encoding and return
        its IncrementalEncoder class or factory function.

        Raises a LookupError in case the encoding cannot be found
        or the codecs doesn't provide an incremental encoder.

    )rr8�LookupError)r
�encoders  r>r r ��)���X��1�1�G����(�#�#��Nr?c�J�t|�j}|�t|��|S)z� Lookup up the codec for the given encoding and return
        its IncrementalDecoder class or factory function.

        Raises a LookupError in case the encoding cannot be found
        or the codecs doesn't provide an incremental decoder.

    )rr9r1)r
�decoders  r>r!r!�r3r?c�,�t|�jS)z� Lookup up the codec for the given encoding and return
        its StreamReader class or factory function.

        Raises a LookupError in case the encoding cannot be found.

    )rr;r-s r>r"r"�����(��(�(�(r?c�,�t|�jS)z� Lookup up the codec for the given encoding and return
        its StreamWriter class or factory function.

        Raises a LookupError in case the encoding cannot be found.

    )rr:r-s r>r#r#r7r?c+�K�t|�|fi|��}|D]}|j|�}|s�|���|jdd�}|r|��yy�w)z�
    Encoding iterator.

    Encodes the input strings from the iterator using an IncrementalEncoder.

    errors and kwargs are passed through to the IncrementalEncoder
    constructor.
    rVTN)r r$)�iteratorr
rP�kwargsr2rO�outputs       r>r&r&s^����.�#�H�-�f�?��?�G�������&����L���^�^�B��
%�F�
�����
�+A� Ac+�K�t|�|fi|��}|D]}|j|�}|s�|���|jdd�}|r|��yy�w)z�
    Decoding iterator.

    Decodes the input strings from the iterator using an IncrementalDecoder.

    errors and kwargs are passed through to the IncrementalDecoder
    constructor.
    r?TN)r!r%)r:r
rPr;r5rOr<s       r>r'r' s^����.�#�H�-�f�?��?�G�������&����L���^�^�C��
&�F�
����r=c�.�|D�cic]}||��c}Scc}w)z� make_identity_dict(rng) -> dict

        Return a dictionary where elements of the rng sequence are
        mapped to themselves.

    rI)�rng�is  r>�make_identity_dictrB4s �����A�A�a�C�����s�
c�X�i}|j�D]\}}||vr|||<�d||<�|S)a� Creates an encoding map from a decoding map.

        If a target mapping in the decoding map occurs multiple
        times, then that target is mapped to None (undefined mapping),
        causing an exception when encountered by the charmap codec
        during translation.

        One example where this happens is cp875.py which decodes
        multiple character to \u001a.

    N)�items)�decoding_map�m�k�vs    r>�make_encoding_maprI>s@��	�A��!�!�#���!��A�v��A�a�D��A�a�D�	$�

�Hr?�ignore�replace�xmlcharrefreplace�backslashreplace�namereplace)�rNrSr�)NrSrR)9rHr!�sys�_codecs�ImportError�why�SystemError�__all__rr
rr	rrr�	byteorderrrrrrrr
r5rrr�rrirr�rrrrrrrrr r!r"r#r&r'rBrIr/r(r)r*r+r,r-r1�_false�	encodingsrIr?r>�<module>rYs����
�E��
-��0��$�#���$�#���#��#���=�=�H��#�"�C�)��I�
#�"�C�)��I���������
&��&�>@"�@"�D&��&�P "�!3� "�D/��/�b"�!3�"�VHH�5�HH�XxH�5�xH�xVH�VH�tsH�sH�n/�b"�L#�#���)�)��$�(�
�.� ��*�M� ��*�M�!�)�,�N�+�,?�@��*�+=�>��%�m�4��
��	��
��o"�E�
�=��C�
D�D��E��V"���M��M��N�#��"�����s)�D�0D-�D*�D%�%D*�-E�E����dZd�ZGd�de�ZGd�de�ZGd�de�Z	dd	lm	Z	m
Z
mZmZm
Z
mZmZmZGd
�de�Zd�ZGd�de��Zy#e$rddlmZm	Z	d
e_Y�&wxYw)z3Abstract Base Classes (ABCs) according to PEP 3119.c��d|_|S)aIA decorator indicating abstract methods.

    Requires that the metaclass is ABCMeta or derived from it.  A
    class that has a metaclass derived from ABCMeta cannot be
    instantiated unless all of its abstract methods are overridden.
    The abstract methods can be called using any of the normal
    'super' call mechanisms.  abstractmethod() may be used to declare
    abstract methods for properties and descriptors.

    Usage:

        class C(metaclass=ABCMeta):
            @abstractmethod
            def my_abstract_method(self, arg1, arg2, argN):
                ...
    T)�__isabstractmethod__)�funcobjs �<frozen abc>�abstractmethodrs��"$(�G� ��N�c�&��eZdZdZdZ�fd�Z�xZS)�abstractclassmethodaA decorator indicating abstract classmethods.

    Deprecated, use 'classmethod' with 'abstractmethod' instead:

        class C(ABC):
            @classmethod
            @abstractmethod
            def my_abstract_classmethod(cls, ...):
                ...

    Tc�2��d|_t�|�	|�y�NT�r�super�__init__��self�callable�	__class__s  �rrzabstractclassmethod.__init__+����(,��%�
����"r��__name__�
__module__�__qualname__�__doc__rr�
__classcell__�rs@rr	r	����
� ��#�#rr	c�&��eZdZdZdZ�fd�Z�xZS)�abstractstaticmethodaA decorator indicating abstract staticmethods.

    Deprecated, use 'staticmethod' with 'abstractmethod' instead:

        class C(ABC):
            @staticmethod
            @abstractmethod
            def my_abstract_staticmethod(...):
                ...

    Tc�2��d|_t�|�	|�yrrrs  �rrzabstractstaticmethod.__init__?rrrrs@rrr0rrrc��eZdZdZdZy)�abstractpropertyz�A decorator indicating abstract properties.

    Deprecated, use 'property' with 'abstractmethod' instead:

        class C(ABC):
            @property
            @abstractmethod
            def my_abstract_property(self):
                ...

    TN)rrrrr�rrr r Ds��
� �rr �)�get_cache_token�	_abc_init�
_abc_register�_abc_instancecheck�_abc_subclasscheck�	_get_dump�_reset_registry�
_reset_cachesc�H��eZdZdZ�fd�Zd�Zd�Zd�Zd	d�Zd�Z	d�Z
�xZS)
�ABCMetaa�Metaclass for defining Abstract Base Classes (ABCs).

        Use this metaclass to create an ABC.  An ABC can be subclassed
        directly, and then acts as a mix-in class.  You can also register
        unrelated concrete classes (even built-in classes) and unrelated
        ABCs as 'virtual subclasses' -- these and their descendants will
        be considered subclasses of the registering ABC by the built-in
        issubclass() function, but the registering ABC won't show up in
        their MRO (Method Resolution Order) nor will method
        implementations defined by the registering ABC be callable (not
        even via super()).
        c�D��t�|�||||fi|��}t|�|S�N)r
�__new__r$)�mcls�name�bases�	namespace�kwargs�clsrs      �rr/zABCMeta.__new__is(����'�/�$��e�Y�I�&�I�C��c�N��Jrc��t||�S)z{Register a virtual subclass of an ABC.

            Returns the subclass, to allow usage as a class decorator.
            )r%�r5�subclasss  r�registerzABCMeta.registerns��
!��h�/�/rc��t||�S)z'Override for isinstance(instance, cls).)r&)r5�instances  r�__instancecheck__zABCMeta.__instancecheck__u���%�c�8�4�4rc��t||�S)z'Override for issubclass(subclass, cls).)r'r7s  r�__subclasscheck__zABCMeta.__subclasscheck__yr=rc�"�td|j�d|j��|��tdt���|��t	|�\}}}}td|��|��td|��|��td|��|��td|��|��y	)
z'Debug helper to print the ABC registry.zClass: �.)�filezInv. counter: z_abc_registry: z_abc_cache: z_abc_negative_cache: z_abc_negative_cache_version: N)�printrrr#r()r5rB�
_abc_registry�
_abc_cache�_abc_negative_cache�_abc_negative_cache_versions      r�_dump_registryzABCMeta._dump_registry}s����G�C�N�N�+�1�S�-=�-=�,>�?�d�K��N�?�#4�"5�6�T�B�,5�c�N�
*�]�J�(;�
(��O�M�#4�5�D�A��L���/�d�;��)�*=�)@�A��M��1�2M�1P�Q��
rc��t|�y)z.Clear the registry (for debugging or testing).N)r)�r5s r�_abc_registry_clearzABCMeta._abc_registry_clear�s
���C� rc��t|�y)z,Clear the caches (for debugging or testing).N)r*rJs r�_abc_caches_clearzABCMeta._abc_caches_clear�s
���#�rr.)rrrrr/r9r<r?rHrKrMrrs@rr,r,\s+���	�	�
	0�	5�	5�
	�	!�	rr,)r,r#�abcc�v�t|d�s|St�}|jD]@}t|dd�D].}t||d�}t|dd�s�|j	|��0�B|j
j
�D]$\}}t|dd�s�|j	|��&t|�|_|S)a�Recalculate the set of abstract methods of an abstract class.

    If a class has had one of its abstract methods implemented after the
    class was created, the method will not be considered implemented until
    this function is called. Alternatively, if a new abstract method has been
    added to the class, it will only be considered an abstract method of the
    class after this function is called.

    This function should be called before any use is made of the class,
    usually in class decorators that add methods to the subject class.

    Returns cls, to allow usage as a class decorator.

    If cls is not an instance of ABCMeta, does nothing.
    �__abstractmethods__r!NrF)	�hasattr�set�	__bases__�getattr�add�__dict__�items�	frozensetrP)r5�	abstracts�sclsr1�values     r�update_abstractmethodsr\�s��� �3�-�.��
���I��
�
���D�"7��<�D��C��t�,�E��u�4�e�<��
�
�d�#�=���|�|�)�)�+���e��5�0�%�8��M�M�$��,�(�	�2�C���Jrc��eZdZdZdZy)�ABCzVHelper class that provides a standard way to create an ABC using
    inheritance.
    r!N)rrrr�	__slots__r!rrr^r^�s����Irr^)�	metaclassN)rr�classmethodr	�staticmethodr�propertyr �_abcr#r$r%r&r'r(r)r*�typer,�ImportError�_py_abcrr\r^r!rr�<module>rhs���:��*#�+�#�(#�<�#�(
 �x�
 � ;�6�6�6�3�$�3�l#�L�G���A��0��G���s�A�A.�-A.c��dZddlZddlmZmZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddgZ
ejZejddZGd�de�ZiZee
�ZdZd	Zd
ZGd�dej2�Zedzd
d
fedzdd
fddfZd�Zd�Zd�Zd�ZdZ da!d�Z"d�Z#d�Z$d�Z%ee%jL�Z'd�Z(d�Z)d�Z*d�Z+d�Z,d �Z-y)!aPzipimport provides support for importing Python modules from Zip archives.

This module exports three objects:
- zipimporter: a class; its constructor takes a path to a Zip archive.
- ZipImportError: exception raised by zipimporter objects. It's a
  subclass of ImportError, so it can be caught as ImportError, too.
- _zip_directory_cache: a dict, mapping archive paths to zip directory
  info dicts, as used in zipimporter._files.

It is usually not needed to use the zipimport module explicitly; it is
used by the builtin import mechanism for sys.path items that are paths
to Zip archives.
�N)�_unpack_uint16�_unpack_uint32�ZipImportError�zipimporter�c��eZdZy)rN)�__name__�
__module__�__qualname__���<frozen zipimport>rr"s��r�sPKi��c�T�eZdZdZd�Zdd�Zd�Zd�Zd�Zd�Z	d	�Z
d
�Zd�Zd�Z
d
�Zy)ra�zipimporter(archivepath) -> zipimporter object

    Create a new zipimporter instance. 'archivepath' must be a path to
    a zipfile, or to a specific path inside a zipfile. For example, it can be
    '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a
    valid directory inside the archive.

    'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip
    archive.

    The 'archive' attribute of zipimporter objects contains the name of the
    zipfile targeted.
    c���t|t�stdt|�����|s
t	d|���t
r|j
t
t�}g}		tj|�}|jdzdk7r
t	d|���		t|}||_||_tj(|ddd��|_|j*r|xj*tz
c_yy#ttf$r@tj|�\}}||k(r
t	d|���|}|j|�YnwxYw��#t $rt#|�}|t|<Y��wxYw)Nzexpected str, not zarchive path is empty��pathi�i�znot a Zip file���)�
isinstance�str�	TypeError�typer�alt_path_sep�replace�path_sep�_bootstrap_external�
_path_stat�st_mode�OSError�
ValueError�_path_split�append�_zip_directory_cache�KeyError�_read_directory�_files�archive�
_path_join�prefix)�selfrr(�st�dirname�basename�filess       r
�__init__zzipimporter.__init__@sY���$��$��0��d���?�@�@�� �!8�t�D�D���<�<��h�7�D����
�(�3�3�D�9���J�J��)�h�6�(�)9��E�E��	/�(��.�E�������)�4�4�f�T�r�T�l�C����;�;��K�K�8�#�K���1�Z�(�
(�%8�$C�$C�D�$I�!����d�?�(�)9��E�E����
�
�h�'�
(����(�	/�#�D�)�E�).� ��&�	/�s%�C,�	D?�,AD;�:D;�?E�ENc��t||�}|�tj|||��St||�}t	||�rK|j
�t�|��}tj|dd��}|jj|�|Sy)zkCreate a ModuleSpec for the specified module.

        Returns None if the module cannot be found.
        N)�
is_packageT)�name�loaderr0)
�_get_module_info�
_bootstrap�spec_from_loader�_get_module_path�_is_dirr&r�
ModuleSpec�submodule_search_locationsr!)r)�fullname�target�module_info�modpathr�specs       r
�	find_speczzipimporter.find_spechs���
'�t�X�6���"��.�.�x��+�V�V�'�t�X�6�G��t�W�%��,�,���z�'��;��!�,�,�(�4�8<�>���/�/�6�6�t�<���rc�&�t||�\}}}|S)z�get_code(fullname) -> code object.

        Return the code object for the specified module. Raise ZipImportError
        if the module couldn't be imported.
        ��_get_module_code�r)r:�code�	ispackager=s     r
�get_codezzipimporter.get_code�s��$4�D�(�#C� ��i���rc�H�tr|jtt�}|}|j|jtz�r|t|jtz�d}	|j|}t|j|�S#t$rtdd|��wxYw)z�get_data(pathname) -> string with file data.

        Return the data associated with 'pathname'. Raise OSError if
        the file wasn't found.
        Nr�)
rrr�
startswithr&�lenr%r#r�	_get_data)r)�pathname�key�	toc_entrys    r
�get_datazzipimporter.get_data�s�����'�'��h�?�H������t�|�|�h�6�7��3�t�|�|�h�6�7�8�9�C�	&����C�(�I�����y�1�1���	&��!�R��%�%�	&�s�%B
�
B!c�&�t||�\}}}|S)z�get_filename(fullname) -> filename string.

        Return the filename for the specified module or raise ZipImportError
        if it couldn't be imported.
        rArCs     r
�get_filenamezzipimporter.get_filename�s��$4�D�(�#C� ��i���rc��t||�}|�td|��|���t||�}|rtj|d�}n|�d�}	|j
|}t|j|�j�S#t$rYywxYw)z�get_source(fullname) -> source string.

        Return the source code for the specified module. Raise ZipImportError
        if the module couldn't be found, return None if the archive does
        contain the module, but has no source for it.
        N�can't find module �r1�__init__.py�.py)
r3rr6rr'r%r#rKr&�decode)r)r:�mir�fullpathrNs      r
�
get_sourcezzipimporter.get_source�s����d�H�
-��
�:� �#5�h�\�!B��R�R���h�/��
�*�5�5�d�M�J�H���s�|�H�	����H�-�I�����y�1�8�8�:�:���	��	�s�
A=�=	B	�B	c�B�t||�}|�td|��|���|S)z�is_package(fullname) -> bool.

        Return True if the module specified by fullname is a package.
        Raise ZipImportError if the module couldn't be found.
        rSrT)r3r)r)r:rXs   r
r0zzipimporter.is_package�s/���d�H�
-��
�:� �#5�h�\�!B��R�R��	rc���d}tj|t�t||�\}}}tj
j
|�}|�t|t�st|�}|tj
|<||_		|r4t||�}tj|j|�}|g|_t|d�st |_tj"|j$||�t'||j$�	tj
|}t-j.d||�|S#tj
|=�xYw#t($rt+d|�d���wxYw)a@load_module(fullname) -> module.

        Load the module specified by 'fullname'. 'fullname' must be the
        fully qualified (dotted) module name. It returns the imported
        module, or raises ZipImportError if it could not be imported.

        Deprecated since Python 3.10. Use exec_module() instead.
        zrzipimport.zipimporter.load_module() is deprecated and slated for removal in Python 3.12; use exec_module() instead�__builtins__zLoaded module z not found in sys.moduleszimport {} # loaded from Zip {})�	_warnings�warn�DeprecationWarningrB�sys�modules�getr�_module_type�
__loader__r6rr'r&�__path__�hasattrr]�_fix_up_module�__dict__�execr#�ImportErrorr4�_verbose_message)	r)r:�msgrDrEr=�modrrYs	         r
�load_modulezzipimporter.load_module�sB��C�����s�.�/�#3�D�(�#C� ��i���k�k�o�o�h�'���;�j��l�;��x�(�C�$'�C�K�K��!����	��(��h�7��.�9�9�$�,�,��M�� (�z����3��/�#/�� ��.�.�s�|�|�X�w�O���s�|�|�$�
	V��+�+�h�'�C�	�#�#�$D�h�PW�X��
��	����H�%����	V���x�l�:S�T�U�U�	V�s�BD5�	E�5E	�E%c� �ddlm}|||�S)z5Return the ResourceReader for a module in a zip file.r)�	ZipReader)�importlib.readersrq)r)r:rqs   r
�get_resource_readerzzipimporter.get_resource_readers��/���x�(�(rc���	t|j�|_|jt|j<y#t$r*tj|jd�i|_YywxYw)z)Reload the file data of the archive path.N)r$r&r%r"r�pop�r)s r
�invalidate_cacheszzipimporter.invalidate_cachessT��	�)�$�,�,�7�D�K�15��� ����.���	� �$�$�T�\�\�4�8��D�K�	�s�7:�0A-�,A-c�F�d|j�t�|j�d�S)Nz<zipimporter object "z">)r&rr(rvs r
�__repr__zzipimporter.__repr__s!��&�t�|�|�n�X�J�t�{�{�m�2�N�Nr�N)rr	r
�__doc__r.r?rFrOrQrZr0rorsrwryrrr
rr.sA���"%$�P�6�2�*	�;�4	�(�V)��Orz__init__.pycTrUF)z.pycTF)rVFFc�D�|j|jd�dzS)N�.�)r(�
rpartition)r)r:s  r
r6r6#s!���;�;��,�,�S�1�!�4�4�4rc�0�|tz}||jvSrz)rr%)r)r�dirpaths   r
r7r7's���X�o�G��d�k�k�!�!rc�h�t||�}tD]\}}}||z}||jvs�|cSyrz)r6�_zip_searchorderr%)r)r:r�suffix�
isbytecoderErYs       r
r3r30s?���D�(�+�D�)9�%��
�I��&�=���t�{�{�"���*:�rc	�
�	tj|�}|5|j	�}		|jtd�|j	�}|jt�}t|�tk7rtd|��|���|ddtk7r�	|jdd�|j	�}t|tz
tz
d�}	|j|�|j�}|jt�}|dkrtd|��|���|||tz}t|�tk7rtd|��|���|t|�z
|z}t|d	d
�}	t|d
d�}
||	krtd|��|���||
krtd
|��|���||	z}||
z
}|dkrtd|��|���i}d}
	|j|�	|jd�}t|�dkrtd��|dddk7r�n�t|�dk7rtd��t|dd�}t|dd	�}t|d	d�}t|dd
�}t|d
d�}t|dd�}t|dd�}t|dd�}t|dd�}t|dd�}t|dd�}||z|z}	||
kDrtd|��|���||z
}	|j|�}t|�|k7rtd|��|���	t|j|	|z
��|	|z
k7rtd|��|���	|dzr|j!�}n	|j!d�}|j)dt*�}t-j.||�}||||||||f}|||<|
d z
}
���	|j|�	ddd�t1j2d!
|�S#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t$rtd|��|���wxYw#t"$r(|j!d�j%t&�}Y��qwxYw#|j|�wxYw#1swY��8xYw)"Nzcan't open Zip file: rr~�can't read Zip file: �rznot a Zip file: zcorrupt Zip file: ���zbad central directory size: zbad central directory offset: z&bad central directory size or offset: �.�EOF read where not expectedsPK��
����� �"�*zbad local header offset: i�ascii�latin1�/rz!zipimport: found {} names in {!r})�_io�	open_coderr�tell�seek�END_CENTRAL_DIR_SIZE�readrJ�STRING_END_ARCHIVE�max�MAX_COMMENT_LEN�rfindr�EOFErrorrrW�UnicodeDecodeError�	translate�cp437_tablerrrr'r4rl)r&�fp�start_offset�header_position�buffer�	file_size�max_comment_start�data�pos�header_size�
header_offset�
arc_offsetr-�count�flags�compress�time�date�crc�	data_size�	name_size�
extra_size�comment_size�file_offsetr1r�ts                           r
r$r$Os���P�
�]�]�7�
#��
��w�w�y��n	"�
X����-�-�q�1�"$�'�'�)�����!5�6���6�{�2�2�$�'<�W�K�%H�w�W�W��b�q�z�/�/�7��G�G�A�q�M� "���	�I�%(�	�O�(C�(<�)=�>?�%A�!�7��G�G�-�.��7�7�9�D��j�j�!3�4����7�(�+;�G�;�)G�.5�7�7��c�#�&:�":�;���v�;�"6�6�(�+=�g�[�)I�.5�7�7�"+�c�$�i�"7�#�"=��(���2��7�K�*�6�"�R�=�9�M���,�$�'C�G�;�%O�V]�^�^���.�$�'E�g�[�%Q�X_�`�`��{�*�O�(�=�8�J��A�~�$�'M�g�[�%Y�`g�h�h��E��E�
X�����(���������v�;��?�"�#@�A�A��"�1�:��.���v�;�"�$�"�#@�A�A�&�v�a��|�4��)�&��B�-�8��%�f�R��m�4��%�f�R��m�4��$�V�B�r�]�3��*�6�"�R�=�9�	�*�6�"�R�=�9�	�*�6�"�R�=�9�	�+�F�2�b�M�:�
�-�f�R��m�<��,�V�B�r�]�;��'�*�4�|�C����.�(�+D�W�K�)P�W^�_�_��z�)��\��7�7�9�-�D��t�9�	�)�(�+@���)L�SZ�[�[�\��2�7�7�;��#:�;�<��i�@W�W�,�/D�W�K�-P�W^�_�_�X�
�5�=��;�;�=�D�L�#�{�{�7�3���|�|�C��2��*�5�5�g�t�D���8�Y�	�;��d�TW�X����d����
��m��d
�G�G�L�!�g
�h��� C�U�G�T��L��q�P��4�W�K�@�w�O�O�P���
X�$�'<�W�K�%H�w�W�W�
X���7�(�+@���)L�.5�7�7�7���7�(�+@���)L�.5�7�7�7��:�
X�$�'<�W�K�%H�w�W�W�
X��:�\�(�+@���)L�SZ�[�[�\���\�(�+@���)L�SZ�[�[�\��.�L�#�{�{�8�4�>�>�{�K��L��
�G�G�L�!��g
��s��O&�S;�<P�(.S%�"P �9S%�!P=�5CS%�Q�D
S%�$Q7�5S%�3R�S%�R1�0AS%�3S;�&P�P�S%� P:�:S%�=Q�S%�Q4�4S%�7R�S%�R.�.S%�1-S"�S%�!S"�"S%�%S8�8S;�;Tu�	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ c��tr tjd�td��da	ddlm}	datjd�|S#t$r!tjd�td��wxYw#dawxYw)Nzzipimport: zlib UNAVAILABLE�)can't decompress data; zlib not availableTr��
decompressFzzipimport: zlib available)�_importing_zlibr4rlr�zlibr��	Exceptionr�s r
�_get_decompress_funcr��s����	�#�#�$A�B��H�I�I��O� �#�
 ����� ;�<�����J��#�#�$A�B��H�I�I�J�� ��s�A
�
*A4�4A7�7A;c���|\}}}}}}}}	|dkrtd��tj|�5}
	|
j|�|
jd�}t
|�dk7rtd��|dddk7rtd	|��|���t|d
d�}t|dd�}
d|z|
z}||z
}	|
j|�|
j|�}t
|�|k7rt	d��	ddd�|dk(rS	t�}|d�S#t$rtd|��|���wxYw#t$rtd|��|���wxYw#1swY�^xYw#t$rtd
��wxYw)Nrznegative data sizer�rr�r�r�sPKzbad local file header: �r�zzipimport: can't read datar�i�)rr�r�r�rr�rJr�rr�r�)r&rN�datapathr�r�r�r�r�r�r�r�r�r�r�r��raw_datar�s                 r
rKrK	s���MV�J�H�h�	�9�k�4��s��1�}��1�2�2�	���w�	�2�	T��G�G�K� ��������v�;�"���8�9�9��"�1�:��&� �#:�7�+�!F�W�U�U�"�6�"�R�=�1�	�#�F�2�b�M�2�
��9�n�z�1���{�"��	T��G�G�K� ��7�7�9�%���x�=�I�%��6�7�7�&�/
 �4�1�}���J�)�+�
��h��$�$��?�	T� �#8���!D�7�S�S�	T�� �	T� �#8���!D�7�S�S�	T��)
 �	��B�J��H�I�I�J�sG�E	�D�A+E	�0D,�*E	�<
E�D)�)E	�,E�E	�	E�E*c�$�t||z
�dkS)Nr)�abs)�t1�t2s  r
�	_eq_mtimer�7s���r�B�w�<�1��rc�\�||d�}tj|||�}|dzdk7}|r{|dzdk7}tjdk7r�|stjdk(r�t	||�}	|	��tj
tj|	�}
tj||
||�nSt||�\}}|rBtt|dd�|�rt|dd	�|k7rtjd
|���ytj|d	d�}
t|
t �st#d|�d���|
S)
N)r1rrrr~�never�alwaysr�r�r�zbytecode is stale for zcompiled module z is not a code object)r�
_classify_pyc�_imp�check_hash_based_pycs�_get_pyc_source�source_hash�_RAW_MAGIC_NUMBER�_validate_hash_pyc�_get_mtime_and_size_of_sourcer�rr4rl�marshal�loadsr�
_code_typer)r)rLrYr:r��exc_detailsr��
hash_based�check_source�source_bytesr��source_mtime�source_sizerDs              r
�_unmarshal_coder�?sA�����K�

 �-�-�d�H�k�J�E�����!�J���t�|�q�(���&�&�'�1���!;�!;�x�!G�*�4��:�L��'�"�.�.�'�9�9� ���
$�6�6��+�x��>�
*�$��9�	"��k���n�T�!�B�Z�8�,�G�"�4��2�;�/�;�>��+�+�,�X�L�9�;���=�=��b�c��#�D��d�J�'��*�8�,�6K�L�M�M��Krc�N�|jdd�}|jdd�}|S)Ns
�
�
)r)�sources r
�_normalize_line_endingsr�ls'��
�^�^�G�U�
+�F�
�^�^�E�5�
)�F��Mrc�6�t|�}t||dd��S)NrjT)�dont_inherit)r��compile)rLr�s  r
�_compile_sourcer�ss��
$�V�
,�F��6�8�V�$�?�?rc�z�tj|dz	dz|dz	dz|dz|dz	|dz	dz|dzdzd	d	d	f	�S)
N�	i������?r~r)r��mktime)�dr�s  r
�_parse_dostimer�ysY���;�;�	
�a��4��	
�a��3��	�D��	�R��	
�a��4��	
�T��Q��
�B����rc��	|dddvsJ�|dd}|j|}|d}|d}|d}t||�|fS#tttf$rYywxYw)Nr��c�or���)rr)r%r�r#�
IndexErrorr)r)rrNr�r��uncompressed_sizes      r
r�r��s~����B�C�y�J�&�&�&��C�R�y���K�K��%�	���|����|��%�a�L���d�D�)�+<�<�<���j�)�,����s�9<�A�Ac��|dddvsJ�|dd}	|j|}t|j|�S#t$rYywxYw)Nrr�)r%rKr&r#)r)rrNs   r
r�r��s[�����9�
�"�"�"����9�D�2��K�K��%�	�����y�1�1������s�5�	A�Ac���t||�}d}tD]�\}}}||z}tjd|jt
|d��	|j|}|d}	t|j|�}
d}|r	t||	|||
�}nt|	|
�}|���|d}	|||	fcS|rd|��}
t|
|��|�td|��|���#t$r}|}Yd}~�Ed}~wwxYw#t$rY��wxYw)Nz
trying {}{}{}r~)�	verbosityrzmodule load failed: rTrS)
r6r�r4rlr&rr%rKr�rkr�r#r)r)r:r�import_errorr�r�rErYrNr=r�rD�excrms              r
rBrB�s"���D�(�+�D��L�)9�%��
�I��&�=���#�#�O�T�\�\�8�X�ab�c�	,����H�-�I� ��l�G��T�\�\�9�5�D��D��'�*�4��(�H�d�S�D�'�w��5���|����l�G���G�+�+�/*:�2�(���7�C� ��8�4�,�F� �#5�h�\�!B��R�R��#�'�#&�L��'���	��	�s*�
C"�9C
�
	C�C�C�"	C.�-C.).r{�_frozen_importlib_externalrrr�_frozen_importlibr4r�r�r�rar�r^�__all__r�path_separatorsrrkrr"rrdr�r�r��
_LoaderBasicsrr�r6r7r3r$r�r�r�rKr�r��__code__r�r�r�r�r�r�rBrrr
�<module>rs3��� 9�E�&��
��
����]�
+���'�'��"�2�2�1�2�6��	�[�	����C�y����"����dO�%�3�3�dO�Z����d�+�
�
��u�d�+���	��5�"��>{�J/��:��
�*(%�\�&�P�/�*�*�
+�
�
�@��
�&
2� Src��dZdaddlZddlZddlZddlZddlZejdk(Zer	ddl	Z
ddlZnddlZ
erddgZ
ndgZ
ed�e
D��sJ�e
dZee
�Zdj%e
�Z
e
D�chc]}d|����	c}Zd	Zd
ZeezZd�Ze�Zd�Zd
�Zd�Zerd�Znd�Zd�Zd�Zd�Zd�Z d�Z!erd�Z"nd�Z"d�Z#dNd�Z$e%e$jL�Z'djQdd�dzZ)e*jWe)d�Z,dZ-dZ.d gZ/ere/jad!�ejb�Z2d"gZ3e3xZ4Z5dOdd#�d$�Z6d%�Z7d&�Z8d'�Z9d(�Z:d)�Z;d*�Z<d+�Z=d,�Z>dPd-�Z?dQd.�Z@dRd/�ZAd0�ZBeC�ZDdOdeDd1�d2�ZEd3�ZFGd4�d5�ZGGd6�d7�ZHGd8�d9eH�ZIGd:�d;�ZJGd<�d=eJeI�ZKGd>�d?eJeH�ZLGd@�dAeJeH�ZMGdB�dC�ZNGdD�dE�ZOeOZPGdF�dG�ZQGdH�dI�ZRdOdJ�ZSdK�ZTdL�ZUdM�ZVycc}w)Sa^Core implementation of path-based import.

This module is NOT meant to be directly imported! It has been designed such
that it can be bootstrapped into Python as the implementation of import. As
such it requires the injection of specific modules and attributes in order to
work. One should use importlib as the public-facing version of this module.

N��win32�\�/c#�8K�|]}t|�dk(���y�w)�N)�len)�.0�seps  �&<frozen importlib._bootstrap_external>�	<genexpr>r.s����
4�O�S�3�s�8�q�=�O�s���:)�win)�cygwin�darwinc���tjjt�r/tjjt�rd�nd��fd�}|Sd�}|S)N�PYTHONCASEOKsPYTHONCASEOKc�b��tjjxr�tjvS)z^True if filenames must be checked case-insensitively and ignore environment flags are not set.)�sys�flags�ignore_environment�_os�environ��keys�r
�_relax_casez%_make_relax_case.<locals>._relax_caseCs$����y�y�3�3�3�J��s�{�{�8J�J�c��y)z5True if filenames must be checked case-insensitively.F�rrr
rz%_make_relax_case.<locals>._relax_caseGs��r)r�platform�
startswith�_CASE_INSENSITIVE_PLATFORMS�#_CASE_INSENSITIVE_PLATFORMS_STR_KEY)rrs @r
�_make_relax_caser#<sN���
�|�|���:�;��<�<�"�"�#F�G� �C�!�C�	K���	��rc�>�t|�dzjdd�S)z*Convert a 32-bit integer to little-endian.�����little)�int�to_bytes)�xs r
�_pack_uint32r+Os����F�Z��)�)�!�X�6�6rc�N�t|�dk(sJ�tj|d�S)z/Convert 4 bytes in little-endian to an integer.r&r'�rr(�
from_bytes��datas r
�_unpack_uint32r1T�#���t�9��>��>��>�>�$��)�)rc�N�t|�dk(sJ�tj|d�S)z/Convert 2 bytes in little-endian to an integer.�r'r-r/s r
�_unpack_uint16r5Yr2rc��|syt|�dk(r|dSd}g}ttj|�D]�\}}|j	t
�s|j
t
�r$|jt�xs|}t|zg}�T|j
d�r9|j�|j�k7r|}|g}��|j|���|xs|}|j|���|D�cgc]}|s�|jt���}}t|�dk(r|ds	|tzS|tj|�zScc}w)�Replacement for os.path.join().rrrr
)
r�mapr�_path_splitrootr �path_sep_tuple�endswith�rstrip�path_separators�path_sep�casefold�append�join)�
path_parts�root�path�new_root�tail�ps      r
�
_path_joinrH`s(�����z�?�a���a�=� �����!�#�"5�"5�z�B�N�H�d��"�"�>�2�h�6G�6G��6W�����7�?�4�� �4��(���"�"�3�'��=�=�?�h�&7�&7�&9�9�$�D� �6�D��K�K��%��'�4�����D�!�C�48�=�4�a�1�����)�4��=��t�9��>�$�q�'��(�?�"��h�m�m�D�)�)�)��	>s�0E�8Ec�|�tj|D�cgc]}|r|jt���c}�Scc}w)r7)r>rAr<r=)rB�parts  r
rHrH~s>���}�}�*4�>�*4�$��#�k�k�/�:�*4�>�?�	?��>s�9c�`��t�fd�tD��}|dkrd�fS�d|�|dzdfS)z Replacement for os.path.split().c3�@�K�|]}�j|����y�w�N)�rfind)rrGrDs  �r
rz_path_split.<locals>.<genexpr>�s�����3�?�a�D�J�J�q�M�?�s�rrNr)�maxr=)rD�is` r
�_path_splitrQ�s>����3�?�3�3�A��1�u��4�x�����8�T�!�a�%�&�\�!�!rc�,�tj|�S)z~Stat the path.

    Made a separate function to make it easier to override in experiments
    (e.g. cache stat results).

    )r�stat�rDs r
�
_path_statrU�s���8�8�D�>�rc�\�	t|�}|jdz|k(S#t$rYywxYw)z1Test whether the path is the specified mode type.Fi�)rU�OSError�st_mode)rD�mode�	stat_infos   r
�_path_is_mode_typer[�s=����t�$�	�
����(�T�1�1������s��	+�+c��t|d�S)zReplacement for os.path.isfile.i�)r[rTs r
�_path_isfiler]�s���d�H�-�-rc�F�|stj�}t|d�S)zReplacement for os.path.isdir.i@)r�getcwdr[rTs r
�_path_isdirr`�s����z�z�|���d�H�-�-rc��|sytj|�djdd�}t|�dkDxr$|j	d�xs|jd�S)�Replacement for os.path.isabs.Frrrrz\\)rr9�replacerr r;)rDrCs  r
�_path_isabsrd�sT�����"�"�4�(��+�3�3�C��>���4�y�1�}�Q�$�/�/�&�"9�"P�T�]�]�4�=P�Qrc�,�|jt�S)rb)r r=rTs r
rdrd�s������/�/rc��t|�s=tD]}|jd|���}�tt	j
�|�S|S)z Replacement for os.path.abspath.�.)rdr=�removeprefixrHrr_)rDr	s  r
�
_path_abspathri�sB���t��"�C��$�$�q���Y�/�D�#��#�*�*�,��-�-��rc���|�dt|���}tj|tjtjztj
z|dz�}	t
j|d�5}|j|�ddd�tj||�y#1swY� xYw#t$r'	tj|��#t$rY�wxYwwxYw)z�Best-effort function to write data to a path atomically.
    Be prepared to handle a FileExistsError if concurrent writing of the
    temporary file is attempted.rg��wbN)�idr�open�O_EXCL�O_CREAT�O_WRONLY�_io�FileIO�writercrW�unlink)rDr0rY�path_tmp�fd�files      r
�
_write_atomicry�s���
��q��D��
�#�H�	���(��*�*�s�{�{�*�S�\�\�9�4�%�<�
I�B���Z�Z��D�
!�T��J�J�t��"����H�d�#�"�
!����	��J�J�x� �	���	��
�	���sH�B/�2B#�B/�#B,�(B/�/	C�9C�C�	C�C�C�Ci�
r4r's
�__pycache__zopt-z.pyz.pywz.pyc)�optimizationc�<�|�/tjdt�|�
d}t|��|rdnd}t	j
|�}t
|�\}}|jd�\}}}tjj}	|	�td��dj|r|n|||	g�}
|�:tjjdk(rd}ntjj}t|�}|dk7r+|j!�st#|�d	���|
�dt$�|��}
|
t&dz}tj(�Qt+|�}|dd
k(r|dt,vr|dd}t/tj(|j1t,�|�St/|t2|�S)a�Given the path to a .py file, return the path to its .pyc file.

    The .py file does not need to exist; this simply returns the path to the
    .pyc file calculated as if the .py file were imported.

    The 'optimization' parameter controls the presumed optimization level of
    the bytecode file. If 'optimization' is not None, the string representation
    of the argument is taken and verified to be alphanumeric (else ValueError
    is raised).

    The debug_override parameter is deprecated. If debug_override is not None,
    a True value is the same as setting 'optimization' to the empty string
    while a False value is equivalent to setting 'optimization' to '1'.

    If sys.implementation.cache_tag is None then NotImplementedError is raised.

    NzFthe debug_override parameter is deprecated; use 'optimization' insteadz2debug_override or optimization must be set to Nonerrrg�$sys.implementation.cache_tag is Nonerz is not alphanumericr
r4)�	_warnings�warn�DeprecationWarning�	TypeErrorr�fspathrQ�
rpartitionr�implementation�	cache_tag�NotImplementedErrorrAr�optimize�str�isalnum�
ValueError�_OPT�BYTECODE_SUFFIXES�pycache_prefixrir=rH�lstrip�_PYCACHE)rD�debug_overrider{�message�headrF�baser	�rest�tag�almost_filename�filenames            r
�cache_from_sourcer��s���$�!����0�1C�	E��#�J�G��G�$�$�+�r����:�:�d��D��T�"�J�D�$��o�o�c�*�O�D�#�t�

�
�
�
&�
&�C�
�{�!�"H�I�I��g�g���$��c�B�C�O����9�9����"��L��9�9�-�-�L��|�$�L��r���#�#�%���/�/C�D�E�E�,�-�Q�t�f�\�N�C���!2�1�!5�5�H�
���%��T�"��
��7�c�>�d�1�g�_�<����8�D������K�K��(��
�	
�
�d�H�h�/�/rc�$�tjj�td��t	j
|�}t
|�\}}d}tj�Ktjjt�}|j|tz�r|t|�d}d}|s+t
|�\}}|tk7rtt�d|����|jd�}|dvrtd|����|d	k(rm|j!dd
�d}|jt"�stdt"����|tt"�d}|j%�std
|�d���|j'd�d}	t)||	t*dz�S)anGiven the path to a .pyc. file, return the path to its .py file.

    The .pyc file does not need to exist; this simply returns the path to
    the .py file calculated to correspond to the .pyc file.  If path does
    not conform to PEP 3147/488 format, ValueError will be raised. If
    sys.implementation.cache_tag is None then NotImplementedError is raised.

    Nr}FTz not bottom-level directory in rg>r4�zexpected only 2 or 3 dots in r�r4���z5optimization portion of filename does not start with zoptimization level z is not an alphanumeric valuer)rr�r�r�rr�rQr�r<r=r r>rr�r��count�rsplitr�r��	partitionrH�SOURCE_SUFFIXES)
rDr��pycache_filename�found_in_pycache_prefix�
stripped_path�pycache�	dot_countr{�	opt_level�
base_filenames
          r
�source_from_cacher�(s������#�#�+�!�"H�I�I��:�:�d��D�(��.��D�
�#��
���%��*�*�1�1�/�B�
��?�?�=�8�3�4���M�*�+�,�D�&*�#�"�#�D�)�
��g��h����z�)H� $�x�)�*�
*� �&�&�s�+�I�����8�9I�8L�M�N�N�	�a��'�.�.�s�A�6�r�:���&�&�t�,��%�%)�H�.�/�
/� ��T���,�	�� � �"��2�<�2B�C2�2�3�
3�$�.�.�s�3�A�6�M��d�M�O�A�,>�>�?�?rc���t|�dk(ry|jd�\}}}|r|j�dddk7r|S	t|�}t
|�r|S|S#tt
f$r|dd}Y�%wxYw)z�Convert a bytecode file path to a source path (if possible).

    This function exists purely for backwards-compatibility for
    PyImport_ExecCodeModuleWithFilenames() in the C API.

    rNrg�������py)rr��lowerr�r�r�r])�
bytecode_pathr��_�	extension�source_paths     r
�_get_sourcefiler�Ps����=��Q���&�1�1�#�6��D�!�Y��9�?�?�$�R��+�t�3���)�'�
�6��'�{�3�;�F��F��
 ��,�)�#�C�R�(��)�s�A�A1�0A1c��|jtt��r	t|�S|jtt
��r|Sy#t$rYywxYwrM)r;�tupler�r�r�r�)r�s r
�_get_cachedr�csW�������/�0�	�$�X�.�.�
�	�	�5�!2�3�	4�����#�	��	�s�
A�	A�Ac�^�	t|�j}|dz}|S#t$rd}Y�wxYw)z3Calculate the mode permissions for a bytecode file.rk�)rUrXrW)rDrYs  r
�
_calc_moder�os=����$��'�'��
	�E�M�D��K�������s��,�,c�Z��d�fd�	}t�tj}nd�}||��|S)z�Decorator to verify that the module being requested matches the one the
    loader can handle.

    The first argument (self) must define _name which the second argument is
    compared against. If the comparison fails then ImportError is raised.

    c���|�
|j}n,|j|k7rtd|j�d|��|����||g|��i|��S)Nzloader for z cannot handle ��name)r��ImportError)�selfr��args�kwargs�methods    �r
�_check_name_wrapperz(_check_name.<locals>._check_name_wrapper�sR����<��9�9�D�
�Y�Y�$�
��!%���D�2�8<�>�
>��d�D�2�4�2�6�2�2rc	��dD]&}t||�s�t||t||���(|jj	|j�y)N)�
__module__�__name__�__qualname__�__doc__)�hasattr�setattr�getattr�__dict__�update)�new�oldrcs   r
�_wrapz_check_name.<locals>._wrap�sB��P���3��(��C��'�#�w�*?�@�Q�
�L�L������-rrM)�
_bootstrapr�)r�r�r�s`  r
�_check_namer�{s3���3���� � ��	.�
�
�v�&��rc�,�|dd}|tk7r*d|�d|��}tjd|�t|fi|���t	|�dkr&d|��}tjd|�t|��t
|dd�}|d	zrd
|�d|��}t|fi|���|S)aTPerform basic validity checking of a pyc header and return the flags field,
    which determines how the pyc should be further validated against the source.

    *data* is the contents of the pyc file. (Only the first 16 bytes are
    required, though.)

    *name* is the name of the module being imported. It is used for logging.

    *exc_details* is a dictionary passed to ImportError if it raised for
    improved debugging.

    ImportError is raised when the magic number is incorrect or when the flags
    field is invalid. EOFError is raised when the data is found to be truncated.

    Nr&zbad magic number in z: �{}�z(reached EOF while reading pyc header of ����zinvalid flags z in )�MAGIC_NUMBERr��_verbose_messager�r�EOFErrorr1)r0r��exc_details�magicr�rs      r
�
_classify_pycr��s��� 
��!�H�E����(����5�)�<���#�#�D�'�2��'�1�[�1�1�
�4�y�2�~�<�T�H�E���#�#�D�'�2��w����4��!�9�%�E��u�}�"�5�)�4��x�8���'�1�[�1�1��Lrc���t|dd�|dzk7r'd|��}tjd|�t|fi|���|�$t|dd�|dzk7rtd|��fi|���yy)aValidate a pyc against the source last-modified time.

    *data* is the contents of the pyc file. (Only the first 16 bytes are
    required.)

    *source_mtime* is the last modified timestamp of the source file.

    *source_size* is None or the size of the source file in bytes.

    *name* is the name of the module being imported. It is used for logging.

    *exc_details* is a dictionary passed to ImportError if it raised for
    improved debugging.

    An ImportError is raised if the bytecode is stale.

    r��r%zbytecode is stale for r�Nr�)r1r�r�r�)r0�source_mtime�source_sizer�r�r�s      r
�_validate_timestamp_pycr��s���&�d�1�R�j�!�l�Z�&?�@�*�4�(�3���#�#�D�'�2��'�1�[�1�1����t�B�r�{�#��j�(@�A��2�4�(�;�K�{�K�K�	B�	 rc�2�|dd|k7rtd|��fi|���y)a�Validate a hash-based pyc by checking the real source hash against the one in
    the pyc header.

    *data* is the contents of the pyc file. (Only the first 16 bytes are
    required.)

    *source_hash* is the importlib.util.source_hash() of the source file.

    *name* is the name of the module being imported. It is used for logging.

    *exc_details* is a dictionary passed to ImportError if it raised for
    improved debugging.

    An ImportError is raised if the bytecode is stale.

    r�r�z.hash in bytecode doesn't match hash of source N)r�)r0�source_hashr�r�s    r
�_validate_hash_pycr��s6��"�A�b�z�[� ��=�d�X�F�
��
�	
�!rc���tj|�}t|t�r0tjd|�|�t
j||�|Std|��||���)z#Compile bytecode as found in a pyc.zcode object from {!r}zNon-code object in �r�rD)	�marshal�loads�
isinstance�
_code_typer�r��_imp�_fix_co_filenamer�)r0r�r�r��codes     r
�_compile_bytecoder��sc���=�=���D��$�
�#��#�#�$;�]�K��"��!�!�$��4����/�
�/@�A�#�-�9�	9rc��tt�}|jtd��|jt|��|jt|��|jt	j
|��|S)z+Produce the data for a timestamp-based pyc.r)�	bytearrayr��extendr+r��dumps)r��mtimer�r0s    r
�_code_to_timestamp_pycr��sX���\�"�D��K�K��Q�� ��K�K��U�#�$��K�K��[�)�*��K�K��
�
�d�#�$��Krc���tt�}d|dzz}|jt|��t	|�dk(sJ�|j|�|jtj|��|S)z&Produce the data for a hash-based pyc.rr�)r�r�r�r+rr�r�)r�r��checkedr0rs     r
�_code_to_hash_pycr�sd���\�"�D��'�Q�,��E��K�K��U�#�$��{��q� � � ��K�K����K�K��
�
�d�#�$��Krc���ddl}tj|�j}|j	|�}tj
dd�}|j
|j
|d��S)zyDecode bytes representing source code and return the string.

    Universal newline support is used in the decoding.
    rNT)�tokenizerr�BytesIO�readline�detect_encoding�IncrementalNewlineDecoder�decode)�source_bytesr��source_bytes_readline�encoding�newline_decoders     r
�
decode_sourcers_��
��K�K��5�>�>���'�'�(=�>�H��3�3�D�$�?�O��!�!�,�"5�"5�h�q�k�"B�C�Cr��loader�submodule_search_locationsc��|�!d}t|d�r4	|j|�}n!tj|�}	t|�}tj|||��}d|_	|�?t�D]1\}}|jt|��s�!|||�}||_
ny|tur(t|d�r#	|j|�}|rg|_n||_|j gk(r+|r)t#|�d}|j j%|�|S#t$rY��wxYw#t$rY��wxYw#t$rY�ewxYw)a=Return a module spec based on a file location.

    To indicate that the module is a package, set
    submodule_search_locations to a list of directory paths.  An
    empty list is sufficient, though its not otherwise useful to the
    import system.

    The loader must take a spec as its only __init__() arg.

    Nz	<unknown>�get_filename��originT�
is_packager)r�rr�rr�rirWr��
ModuleSpec�
_set_fileattr�_get_supported_file_loadersr;r�r�	_POPULATEr
rrQr@)	r��locationrr�spec�loader_class�suffixesr
�dirnames	         r
�spec_from_file_locationr"si�������6�>�*�
�!�.�.�t�4���:�:�h�'��	�$�X�.�H�� � ��v�h� �?�D��D���~�&A�&C�"�L�(�� � ��x��1�%�d�H�5��$����	'D��"�Y�.��6�<�(�
9�#�.�.�t�4�
��68�D�3�*D��'��&�&�"�,��!�(�+�A�.�G��+�+�2�2�7�;��K��]�
��
���	��	��8�
��
�s4�D�D'�:D6�	D$�#D$�'	D3�2D3�6	E�Ec��t|t�syt�}|jdd�}|jd|�}|�||ury|�t	d��t|d|�}||dfvr6|�||urtnt}|d��tjdt�|}|�J�|�!||k7rtjdt�|S|S)zCHelper function for _warnings.c

    See GH#97850 for details.
    N�
__loader__�__spec__z+Module globals is missing a __spec__.loaderrz-Module globals; __loader__ != __spec__.loader)
r��dict�object�getr�r��AttributeErrorr~rr�)�module_globals�missingrr�spec_loader�excs      r
�_bless_my_loaderr hs����n�d�+���h�G�
�
�
��d�
3�F����j�'�2�D�
�~��7�?��
�\��J�K�K��$��'�2�K��w��o�%��>�$/�7�$:�.�
�C��C�D�D����9��	 ����"�"�"�
��f��3����;��	 ��
��rc�Z�eZdZdZdZdZexrdevZe	d��Z
ed��Zed	d��Z
y)
�WindowsRegistryFinderz>Meta path finder for modules declared in the Windows registry.z;Software\Python\PythonCore\{sys_version}\Modules\{fullname}zASoftware\Python\PythonCore\{sys_version}\Modules\{fullname}\Debugz_d.pydc��	tjtj|�S#t$r'tjtj|�cYSwxYwrM)�winreg�OpenKey�HKEY_CURRENT_USERrW�HKEY_LOCAL_MACHINErs r
�_open_registryz$WindowsRegistryFinder._open_registry�sG��	B��>�>�&�":�":�C�@�@���	B��>�>�&�";�";�S�A�A�	B�s�#&�-A�Ac�8�|jr
|j}n|j}|j|dtj
ddz��}	|j
|�5}tj|d�}ddd�|S#1swYSxYw#t$rYywxYw)Nz%d.%dr4)�fullname�sys_versionr)
�DEBUG_BUILD�REGISTRY_KEY_DEBUG�REGISTRY_KEY�formatr�version_infor(r$�
QueryValuerW)�clsr*�registry_keyr�hkey�filepaths      r
�_search_registryz&WindowsRegistryFinder._search_registry�s����?�?��1�1�L��+�+�L��!�!�8�.5��8H�8H��!�8L�.L�"�N��	��#�#�C�(�D�!�,�,�T�2�6��)���	)�����	��	�s0�B
�B�6B
�B
�B
�
B
�
	B�BNc��|j|�}|�y	t|�t�D]B\}}|j	t|��s�!tj||||�|��}|cSy#t$rYywxYw)Nr)r6rUrWr
r;r�r��spec_from_loader)r2r*rD�targetr5rrrs        r
�	find_speczWindowsRegistryFinder.find_spec�s����'�'��1�����	��x� �!<� =��F�H�� � ��x��1�!�2�2�8�39�(�H�3M�:B�3�D����!>���	��	�s�A1�1	A=�<A=�NN)r�r�r�r�r.r-�_MS_WINDOWS�EXTENSION_SUFFIXESr,�staticmethodr(�classmethodr6r:rrr
r"r"�sg��H�	 ��	'���A�8�/A�#A�K��B��B������
��
rr"c�(�eZdZdZd�Zd�Zd�Zd�Zy)�
_LoaderBasicszSBase class of common code needed by both SourceLoader and
    SourcelessFileLoader.c��t|j|��d}|jdd�d}|jd�d}|dk(xr|dk7S)z�Concrete implementation of InspectLoader.is_package by checking if
        the path returned by get_filename has a filename of '__init__.py'.rrgrr4�__init__)rQrr�r�)r�r*r��
filename_base�	tail_names     r
r
z_LoaderBasics.is_package�s]���t�0�0��:�;�A�>�� ����Q�/��2�
��'�'��,�Q�/�	��
�*�F�y�J�/F�Frc��y�z*Use default semantics for module creation.Nr�r�rs  r
�
create_modulez_LoaderBasics.create_module���rc��|j|j�}|�td|j�d���tj	t
||j�y)zExecute the module.Nzcannot load module z when get_code() returns None)�get_coder�r�r��_call_with_frames_removed�execr�)r��moduler�s   r
�exec_modulez_LoaderBasics.exec_module�sS���}�}�V�_�_�-���<�� 3�F�O�O�3F�G8�8�9�
9��,�,�T�4����Irc�.�tj||�S)zThis method is deprecated.)r��_load_module_shim�r�r*s  r
�load_modulez_LoaderBasics.load_module�s���+�+�D�(�;�;rN)r�r�r�r�r
rIrPrTrrr
rArA�s���G�9�J�<rrAc�<�eZdZd�Zd�Zd�Zd�Zd�Zdd�d�Zd	�Z	y
)�SourceLoaderc��t�)z�Optional method that returns the modification time (an int) for the
        specified path (a str).

        Raises OSError when the path cannot be handled.
        )rW�r�rDs  r
�
path_mtimezSourceLoader.path_mtime�s	���
rc�(�d|j|�iS)a�Optional method returning a metadata dict for the specified
        path (a str).

        Possible keys:
        - 'mtime' (mandatory) is the numeric timestamp of last source
          code modification;
        - 'size' (optional) is the size in bytes of the source code.

        Implementing this method allows the loader to read bytecode files.
        Raises OSError when the path cannot be handled.
        r�)rYrXs  r
�
path_statszSourceLoader.path_stats�s�������.�/�/rc�&�|j||�S)z�Optional method which writes data (bytes) to a file path (a str).

        Implementing this method allows for the writing of bytecode files.

        The source path is needed in order to correctly transfer permissions
        )�set_data)r�r��
cache_pathr0s    r
�_cache_bytecodezSourceLoader._cache_bytecodes���}�}�Z��.�.rc��y)z�Optional method which writes data (bytes) to a file path (a str).

        Implementing this method allows for the writing of bytecode files.
        Nr)r�rDr0s   r
r]zSourceLoader.set_data
rJrc��|j|�}	|j|�}t	|�S#t$r}td|��|�d}~wwxYw)z4Concrete implementation of InspectLoader.get_source.z'source not available through get_data()r�N)r�get_datarWr�r)r�r*rDr�rs     r
�
get_sourcezSourceLoader.get_sourcesZ��� � ��*��	6��=�=��.�L��\�*�*���	6��G�#+�-�25�
6��	6�s�/�	A�A�Ar�)�	_optimizec�@�tjt||dd|��S)z�Return the code object compiled from source.

        The 'data' argument can be any object type that compile() supports.
        rNT)�dont_inheritr�)r�rM�compile)r�r0rDrds    r
�source_to_codezSourceLoader.source_to_codes+��
�3�3�G�T�4��59�I�4�O�	Orc�H�|j|�}d}d}d}d}d}	t|�}	|j|�}	t|	d�}	|j	|�}
||d�}	t|
||�}t
|
�dd}
|dzdk7}|rj|d	zdk7}tjd
k7ra|stjdk(rL|j	|�}tjt|�}t|
|||�nt|
||	d||�tjd
||�t|
|||��S#t t"f$rYn3wxYw#t$$rYn$wxYw#t$$rYnwxYw#t&$rd}YnwxYw|�|j	|�}|j)||�}tjd|�t*j,sl|�j|�h|r*|�tjt|�}t/|||�}
nt1||t3|��}
	|j5|||
�|S#t&$rY|SwxYw|S)z�Concrete implementation of InspectLoader.get_code.

        Reading of bytecode requires path_stats to be implemented. To write
        bytecode, set_data must also be implemented.

        NFTr�r�r�rrr4�never�always�sizez
{} matches {})r�r�r�zcode object from {})rr�r[r(rbr��
memoryviewr��check_hash_based_pycsr��_RAW_MAGIC_NUMBERr�r�r�r�r�r�r�rWr�rhr�dont_write_bytecoder�r�rr_)r�r*r�r�r�r��
hash_based�check_sourcer��str0r�r�
bytes_data�code_objects               r
rLzSourceLoader.get_code&s����'�'��1���������
���3	J�-�k�:�M�.
J��_�_�[�1�� #�2�g�;�/��(J��=�=��7�D�
!)� -�#�K�J� -�d�H�k� J��%/��%5�b�c�%:�
�%*�S�[�A�%5�
�%�+0�4�<�1�+<�L� $� :� :�g� E�!-�!%�!;�!;�x�!G�/3�}�}�[�/I��.2�.>�.>�$5�$0�/"��!3�4��h�3>�!@�4� $� ,� "�6�
� (� +��#�3�3�O�]�4?�A�0��(�?L�=H� J�J��(��2�����?�����
�
��
��#�	!� �M�	!��d���=�=��5�L��)�)�,��D���#�#�$9�;�G��'�'�M�,E��(���&�"&�"2�"2�3D�3?�#A�K�(��k�<�P��-�k�<�.1�,�.?�A��
��$�$�[�-��F����'�
����
���sY�E�E�	D<� B!D'�'D9�8D9�<	E�E�	E�E�E(�'E(�=H�	H�HN)
r�r�r�rYr[r_r]rcrhrLrrr
rVrV�s,���0�/��+�79�O�SrrVc�d��eZdZdZd�Zd�Zd�Ze�fd��Zed��Z	d�Z
ed��Z�xZS)	�
FileLoaderzgBase file loader class which implements the loader protocol methods that
    require file system usage.c� �||_||_y)zKCache the module name and the path to the file found by the
        finder.Nr�)r�r*rDs   r
rCzFileLoader.__init__�s����	���	rc�j�|j|jk(xr|j|jk(SrM��	__class__r��r��others  r
�__eq__zFileLoader.__eq__��,�����%�/�/�1�0��
�
����/�	1rc�X�t|j�t|j�zSrM��hashr�rD�r�s r
�__hash__zFileLoader.__hash__�����D�I�I���d�i�i��0�0rc�*��tt|�|�S)zdLoad a module from a file.

        This method is deprecated.  Use exec_module() instead.

        )�superrwrT)r�r*r{s  �r
rTzFileLoader.load_module�s����Z��2�8�<�<rc��|jS�z:Return the path to the source file as found by the finder.rTrSs  r
rzFileLoader.get_filename�����y�y�rc�.�t|ttf�r8tjt|��5}|j
�cddd�Stj|d�5}|j
�cddd�S#1swYyxYw#1swYyxYw)z'Return the data from path as raw bytes.N�r)r�rV�ExtensionFileLoaderrr�	open_coder��readrs)r�rDrxs   r
rbzFileLoader.get_data�sj���d�\�+>�?�@����s�4�y�)�T��y�y�{�*�)����D�#�&�$��y�y�{�'�&�*�)��'�&�s�A?�%B�?B�Bc��ddlm}||�S)Nr)�
FileReader)�importlib.readersr�)r�rOr�s   r
�get_resource_readerzFileLoader.get_resource_reader�s��0��$��r)
r�r�r�r�rCr~r�r�rTrrbr��
__classcell__)r{s@r
rwrw|sX���"��1�1��	=��	=�����#�� �� rrwc�(�eZdZdZd�Zd�Zdd�d�Zy)�SourceFileLoaderz>Concrete implementation of SourceLoader using the file system.c�J�t|�}|j|jd�S)z!Return the metadata for the path.)r�rl)rU�st_mtime�st_size)r�rDrss   r
r[zSourceFileLoader.path_stats�s��
��
�����b�j�j�9�9rc�@�t|�}|j|||��S)N��_mode)r�r])r�r�r�r0rYs     r
r_z SourceFileLoader._cache_bytecode�s!���+�&���}�}�]�D��}�=�=rrkr�c��t|�\}}g}|r8t|�s-t|�\}}|j|�|rt|�s�-t|�D]$}t	||�}	tj|��&	t|||�tjd|�y#t$rY�Wt$r"}tjd||�Yd}~yd}~wwxYw#t$r!}tjd||�Yd}~yd}~wwxYw)zWrite bytes data to a file.zcould not create {!r}: {!r}Nzcreated {!r})rQr`r@�reversedrHr�mkdir�FileExistsErrorrWr�r�ry)	r�rDr0r��parentr�rBrJrs	         r
r]zSourceFileLoader.set_data�s���&�t�,�����
��[��0�&�v�.�L�F�D����d�#��[��0��Z�(�D����-�F�

��	�	�&�!�)�	-��$��e�,��'�'���=��#�
���
��+�+�,I�,2�C�9���
���	-��'�'�(E�t�(+�
-�
-��	-�s6�&B"�>#C�"	C�-C�5C�C�	D�#C?�?DN)r�r�r�r�r[r_r]rrr
r�r��s��H�:�
>�
-2�-rr�c��eZdZdZd�Zd�Zy)�SourcelessFileLoaderz-Loader which handles sourceless file imports.c��|j|�}|j|�}||d�}t|||�tt	|�dd||��S)Nr�r�)r�r�)rrbr�r�rm)r�r*rDr0r�s     r
rLzSourcelessFileLoader.get_code�s_��� � ��*���}�}�T�"����
��	�d�H�k�2� ��t��R�S�!���
�	
rc��y)z'Return None as there is no source code.NrrSs  r
rczSourcelessFileLoader.get_source����rN)r�r�r�r�rLrcrrr
r�r��s��7�
� rr�c�P�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zed
��Z
y)r�z]Loader for extension modules.

    The constructor is designed to work with FileFinder.

    c� �||_||_yrMr�)r�r�rDs   r
rCzExtensionFileLoader.__init__�s����	���	rc�j�|j|jk(xr|j|jk(SrMrzr|s  r
r~zExtensionFileLoader.__eq__rrc�X�t|j�t|j�zSrMr�r�s r
r�zExtensionFileLoader.__hash__r�rc��tjtj|�}tj	d|j
|j�|S)z(Create an uninitialized extension modulez&extension module {!r} loaded from {!r})r�rMr��create_dynamicr�r�rD)r�rrOs   r
rIz!ExtensionFileLoader.create_modules@���5�5�����'���#�#�$L����D�I�I�	/��
rc��tjtj|�tj	d|j
|j�y)zInitialize an extension modulez(extension module {!r} executed from {!r}N)r�rMr��exec_dynamicr�r�rD�r�rOs  r
rPzExtensionFileLoader.exec_modules6���,�,�T�->�->��G��#�#�$N����D�I�I�	/rc�d��t|j�d�t�fd�tD��S)z1Return True if the extension module is a package.rc3�.�K�|]}�d|zk(���y�w)rCNr)r�suffix�	file_names  �r
rz1ExtensionFileLoader.is_package.<locals>.<genexpr>s#�����5�!3�v��
�V� 3�3�!3�s�)rQrD�anyr=)r�r*r�s  @r
r
zExtensionFileLoader.is_packages0�����	�	�*�1�-�	��5�!3�5�5�	5rc��y)z?Return None as an extension module cannot create a code object.NrrSs  r
rLzExtensionFileLoader.get_coder�rc��y)z5Return None as extension modules have no source code.NrrSs  r
rczExtensionFileLoader.get_sourcer�rc��|jSr�rTrSs  r
rz ExtensionFileLoader.get_filename#r�rN)r�r�r�r�rCr~r�rIrPr
rLrcr�rrrr
r�r��sC����1�1��/�5������rr�c�V�eZdZdZdZd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zy)�_NamespacePatha&Represents a namespace package's path.  It uses the module name
    to find its parent module, and from there it looks up the parent's
    __path__.  When this changes, the module's own path is recomputed,
    using path_finder.  For top-level modules, the parent module's path
    is sys.path.rc��||_||_t|j��|_|j
|_||_yrM)�_name�_pathr��_get_parent_path�_last_parent_path�_epoch�_last_epoch�_path_finder�r�r�rD�path_finders    r
rCz_NamespacePath.__init__4s:����
���
�!&�t�'<�'<�'>�!?����;�;���'��rc�T�|jjd�\}}}|dk(ry|dfS)z>Returns a tuple of (parent-module-name, parent-path-attr-name)rgr)rrD�__path__)r�r�)r�r��dot�mes    r
�_find_parent_path_namesz&_NamespacePath._find_parent_path_names;s3���*�*�/�/��4����R��"�9� ��z�!�!rc�b�|j�\}}ttj||�SrM)r�r�r�modules)r��parent_module_name�path_attr_names   r
r�z_NamespacePath._get_parent_pathEs-��-1�-I�-I�-K�*��N��s�{�{�#5�6��G�Grc�Z�t|j��}||jk7s|j|jk7r_|j|j|�}|�)|j�|jr|j|_	||_|j|_|jSrM)
r�r�r�r�r�r�r�rrr�)r��parent_pathrs   r
�_recalculatez_NamespacePath._recalculateIs����D�1�1�3�4���$�0�0�0�D�K�K�4�CS�CS�4S��$�$�T�Z�Z��=�D���D�K�K�$7��2�2�!%�!@�!@�D�J�%0�D�"�#�{�{�D���z�z�rc�4�t|j��SrM)�iterr�r�s r
�__iter__z_NamespacePath.__iter__Ws���D�%�%�'�(�(rc�(�|j�|SrM�r�)r��indexs  r
�__getitem__z_NamespacePath.__getitem__Zs��� � �"�5�)�)rc�"�||j|<yrM�r�)r�r�rDs   r
�__setitem__z_NamespacePath.__setitem__]s�� ��
�
�5�rc�4�t|j��SrM)rr�r�s r
�__len__z_NamespacePath.__len__`s���4�$�$�&�'�'rc�"�d|j�d�S)Nz_NamespacePath(�)r�r�s r
�__repr__z_NamespacePath.__repr__cs�� �����a�0�0rc�&�||j�vSrMr��r��items  r
�__contains__z_NamespacePath.__contains__fs���t�(�(�*�*�*rc�:�|jj|�yrM)r�r@r�s  r
r@z_NamespacePath.appendis���
�
���$�rN)r�r�r�r�r�rCr�r�r�r�r�r�r�r�r�r@rrr
r�r�)sF����F�(�"�H��)�*�!�(�1�+� rr�c�<�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�NamespaceLoaderc�(�t|||�|_yrM)r�r�r�s    r
rCzNamespaceLoader.__init__qs��#�D�$��<��
rc��y)NTrrSs  r
r
zNamespaceLoader.is_packagets��rc��y)NrrrSs  r
rczNamespaceLoader.get_sourcews��rc� �tdddd��S)Nrz<string>rNT)rf)rgrSs  r
rLzNamespaceLoader.get_codezs���r�:�v�D�A�Arc��yrGrrHs  r
rIzNamespaceLoader.create_module}rJrc��yrMrr�s  r
rPzNamespaceLoader.exec_module�s��rc�n�tjd|j�tj||�S)zbLoad a namespace module.

        This method is deprecated.  Use exec_module() instead.

        z&namespace module loaded with path {!r})r�r�r�rRrSs  r
rTzNamespaceLoader.load_module�s1��	�#�#�$L�$(�J�J�	0��+�+�D�(�;�;rc�2�ddlm}||j�S)Nr)�NamespaceReader)r�r�r�)r�rOr�s   r
r�z#NamespaceLoader.get_resource_reader�s��5��t�z�z�*�*rN)r�r�r�rCr
rcrLrIrPrTr�rrr
r�r�ps+��=���B�9�
�
<�+rr�c�t�eZdZdZed��Zed��Zed��Zed	d��Z	ed
d��Z
ed��Zy)�
PathFinderz>Meta path finder for sys.path and package __path__ attributes.c�8�ttjj��D]A\}}|�t	|�stj|=�%t|d�s�2|j
��Ctxjdz
c_ddl	m
}|j
�y)z}Call the invalidate_caches() method on all path entry finders
        stored in sys.path_importer_caches (where implemented).N�invalidate_cachesrr��MetadataPathFinder)�listr�path_importer_cache�itemsrdr�r�r�r��importlib.metadatar�)r��finderr�s   r
r�zPathFinder.invalidate_caches�s|��!��!8�!8�!>�!>�!@�A�L�D�&��~�[��%6��+�+�D�1���!4�5��(�(�*�
B�	����"��9��,�,�.rc���tj�*tjstjdt�tjD]}	||�cSy#t
$rY�wxYw)z.Search sys.path_hooks for a finder for 'path'.Nzsys.path_hooks is empty)r�
path_hooksr~r�
ImportWarningr�)rD�hooks  r
�_path_hookszPathFinder._path_hooks�sY���>�>�%�c�n�n��N�N�4�m�D��N�N�D�
��D�z�!�#����
��
�s�A�	A'�&A'c���|dk(r	tj�}	tj|}|S#t$rYywxYw#t
$r(|j
|�}|tj|<Y|SwxYw)z�Get the finder for the path entry from sys.path_importer_cache.

        If the path entry is not in the cache, find the appropriate finder
        and cache it. If no finder is available, store None.

        rN)rr_�FileNotFoundErrorrr��KeyErrorr�)r2rDr�s   r
�_path_importer_cachezPathFinder._path_importer_cache�s����2�:�
��z�z�|��
	3��,�,�T�2�F��
��%�
��
���	3��_�_�T�*�F�,2�C�#�#�D�)��
�	3�s�1�A�	=�=�-A1�0A1Nc�:�g}|D]v}t|t�s�|j|�}|��(|j||�}|��=|j�|cS|j
}|�t
d��|j|��xtj|d�}||_|S)z?Find the loader or namespace_path for this module/package name.Nzspec missing loader)
r�r�rr:rrr�r�r�r)	r2r*rDr9�namespace_path�entryr�r�portionss	         r
�	_get_speczPathFinder._get_spec�s���
���E��e�S�)���-�-�e�4�F��!��'�'��&�9���<���;�;�*��K��:�:���#�%�&;�<�<�
�%�%�h�/�#�&�(�(��4�8�D�.<�D�+��Krc���|�tj}|j|||�}|�y|j�4|j}|r%d|_t
|||j�|_|Sy|S)z�Try to find a spec for 'fullname' on sys.path or 'path'.

        The search is based on sys.path_hooks and sys.path_importer_cache.
        N)rrDrrrr	r�)r2r*rDr9rrs      r
r:zPathFinder.find_spec�sr���<��8�8�D��}�}�X�t�V�4���<��
�[�[�
 �!�<�<�N��#���2@��>�[^�[h�[h�2i��/�����Krc�2�ddlm}|j|i|��S)a 
        Find distributions.

        Return an iterable of all Distribution instances capable of
        loading the metadata for packages matching ``context.name``
        (or all names if ``None`` indicated) along the paths in the list
        of directories ``context.path``.
        rr�)r�r��find_distributions)r�r�r�s   r
r
zPathFinder.find_distributionss ��	:�4�!�4�4�d�E�f�E�ErrMr;)r�r�r�r�r>r�r�r?rrr:r
rrr
r�r��s}��H��/��/�"�
��
�����*����8����.�
F��
Frr�c�F�eZdZdZd�Zd�Zd�Zd
d�Zd�Ze	d��Z
d	�Zy)�
FileFinderz�File-based finder.

    Interactions with the file system are cached for performance, being
    refreshed when the directory the finder is handling has been modified.

    c���g}|D]\�}|j�fd�|D���!||_|r|dk(rtj�|_nt|�|_d|_t�|_t�|_	y)z�Initialize with the path to search on and a variable number of
        2-tuples containing the loader and the file suffixes the loader
        recognizes.c3�&�K�|]}|�f���
y�wrMr)rr�rs  �r
rz&FileFinder.__init__.<locals>.<genexpr>%s�����C�(��F�F�+�(�s�rgr�N)
r��_loadersrr_rDri�_path_mtime�set�_path_cache�_relaxed_path_cache)r�rD�loader_details�loadersrrs     @r
rCzFileFinder.__init__sp����� .��F�H��N�N�C�(�C�C�!/���
��t�s�{��
�
��D�I�%�d�+�D�I�����5���#&�5�� rc��d|_y)zInvalidate the directory mtime.r�N)rr�s r
r�zFileFinder.invalidate_caches0s
����rc�2�|||�}t||||��S)Nr)r)r�rr*rD�smslr9rs       r
rzFileFinder._get_spec4s&���h��-��&�x��f�BF�H�	HrNc��d}|jd�d}	t|jxstj��j
}||jk7r|j�||_t�r|j}|j�}n|j}|}||vrit|j|�}|jD]9\}	}
d|	z}t||�}t|�s�#|j!|
|||g|�cSt#|�}|jD]a\}	}
	t|j||	z�}t&j)d|d��||	z|vs�@t|�s�L|j!|
||d|�cS|r6t&j)d	�t&j+|d�}
|g|
_|
Sy#t$rd}Y��wxYw#t$$rYywxYw)
zoTry to find a spec for the specified module.

        Returns the matching spec, or None if not found.
        Frgr4r�rCNz	trying {})�	verbosityzpossible namespace for {})r�rUrDrr_r�rWr�_fill_cacherrr�rrHrr]rr`r�r�r�rr)r�r*r9�is_namespace�tail_moduler��cache�cache_module�	base_pathr�r�
init_filename�	full_pathrs              r
r:zFileFinder.find_spec9s���
���)�)�#�.�q�1��	��t�y�y�8�C�J�J�L�9�B�B�E��D�$�$�$�����$�D���=��,�,�E�&�,�,�.�L��$�$�E�&�L��5� �"�4�9�9�k�:�I�(,�
�
�$��� *�V� 3�
�&�y�-�@�	��	�*��>�>�,��)�i�[�Z`�a�a�	)6� +�9�5��$(�M�M� �F�L�
�&�t�y�y�+��2F�G�	�
�'�'��Y�!�'�L��f�$��-��	�*��>�>�,��)�*.��8�8�%2���'�'�(C�Y�O��(�(��4�8�D�/8�k�D�+��K���Q�	��E�	��8�
��
�s#�5F>�(G�>G
�G
�	G�Gc�T�|j}	tj|xstj��}tjjd�st|�|_nXt�}|D]B}|jd�\}}}|r|�d|j���}n|}|j|��D||_tjjt�r$|D�	chc]}	|	j���c}	|_yy#tt
tf$rg}Y��wxYwcc}	w)zDFill the cache of potential modules and packages for this directory.rrgN)rDr�listdirr_r�PermissionError�NotADirectoryErrorrrr rrr�r��addr!r)
r�rD�contents�lower_suffix_contentsr�r�r�r��new_name�fns
          r
rzFileFinder._fill_cachels���y�y��	��{�{�4�#7�3�:�:�<�8�H��|�|�&�&�u�-�"�8�}�D��%(�E�!� ��$(�N�N�3�$7�!��c�6��"&��q�����(8�9�H�#�H�%�)�)�(�3�
!� 5�D���<�<�"�"�#>�?�=E�'F�X�r����
�X�'F�D�$�@��/"�?�4F�G�	��H�	��0(Gs�+D	�(D%�	D"�!D"c������fd�}|S)aA class method which returns a closure to use on sys.path_hook
        which will return an instance using the specified loaders and the path
        called on the closure.

        If the path called on the closure is not a directory, ImportError is
        raised.

        c�F��t|�s
td|����|g����S)z-Path hook for importlib.machinery.FileFinder.zonly directories are supportedrT)r`r�)rDr2rs ��r
�path_hook_for_FileFinderz6FileFinder.path_hook.<locals>.path_hook_for_FileFinder�s)����t�$�!�"B��N�N��t�-�n�-�-rr)r2rr.s`` r
�	path_hookzFileFinder.path_hook�s���	.�(�'rc�"�d|j�d�S)NzFileFinder(r�rTr�s r
r�zFileFinder.__repr__�s���T�Y�Y�M��+�+rrM)r�r�r�r�rCr�rr:rr?r/r�rrr
rrs<���)�"�H�
1�fG�>�(��(�",rrc�2�|jd�}|jd�}|s-|r
|j}n||k(r
t||�}nt||�}|s t	|||��}|rt|�|_	||d<||d<||d<||d<y#t$rYywxYw)Nrr)r�__file__�
__cached__)rrr�r�rri�cached�	Exception)�nsr��pathname�	cpathnamerrs      r
�_fix_up_moduler9�s���
�V�V�L�
!�F�
�6�6�*��D����[�[�F�
��
"�)�$��9�F�%�d�H�5�F��&�t�X�f�E���'�	�2�D�K�
���:��!��<��!��:��$��<����
��
�s�5B
�
	B�Bc�p�ttj�f}ttf}t
tf}|||gS)z_Returns a list of file-based module loaders.

    Each item is a tuple (loader, suffixes).
    )r�r��extension_suffixesr�r�r�r�)�
extensions�source�bytecodes   r
r
r
�s9��
%�d�&=�&=�&?�?�J�
��
.�F�#�%6�6�H����)�)rc��|ayrM)r�)�_bootstrap_modules r
�_set_bootstrap_modulerA�s��"�Jrc���t|�t�}tjj	tj|�g�tjjt�y)z)Install the path-based import components.N)
rAr
rr�r�rr/�	meta_pathr@r�)r@�supported_loaderss  r
�_installrE�sG���+�,�3�5���N�N���:�/�/�1B�C�D�E��M�M����$r)rkrM)NNN)rr)T)Wr�r�r�rrrr~r�rr<�ntrr$�posixr=�allr>r�r:rA�_pathseps_with_colonr"�%_CASE_INSENSITIVE_PLATFORMS_BYTES_KEYr!r#rr+r1r5rHrQrUr[r]r`rdriry�type�__code__r�r)r�r(r.ror�r�r�r@r;r=r��DEBUG_BYTECODE_SUFFIXES�OPTIMIZED_BYTECODE_SUFFIXESr�r�r�r�r�r�r�r�r�r�r�r�rrrrr r"rArVrwr�r�r�r�r��_NamespaceLoaderr�rr9r
rArE)�ss0r
�<module>rQs����,�
��
�
����|�|�w�&��������S�k�O��e�O�
�
4�O�
4�4�4�4��1�����'���'�'�/�*��)8�9��A�!�A�3���9��'-�#�(:�%� E�"E�!F��� � ��7�
*�
*��*�<?�"��2�.�
.��R�0�
��,�-�(�(�
)�
�p���q�(�+�g�5���N�N�<��:����
���'������6�"�,�T�,�,�.���H��8I�I��5�C0��C0�L%@�PG�&	�	��>�BL�8
�0
9���	D�
�H�	�C�4�7@�C�L-�d0�0�f<�<�<N�=�N�b/ �/ �d*-�z�<�*-�Z�:�}��22�*�m�2�jA �A �N!+�!+�J#��
yF�yF�xH,�H,�Z
�2*�#�
%��u4:s�4G7c�
�dZd�ZdZdZdZdad�Zd�ZGd�de�Z	Gd�d�Z
iZdaGd	�d
�Z
Gd�de�Zd
�ZGd�d�ZGd�d�ZGd�d�Zd�Zd�Zd�Zdd�d�Zd�Zd�Zd�Zd�ZGd�d�Zddd �d!�ZdBd"�Zd#d$�d%�Zd&�Z d'�Z!d(�Z"d)�Z#d*�Z$d+�Z%Gd,�d-�Z&Gd.�d/�Z'Gd0�d1�Z(d2�Z)dCd3�Z*d4�Z+d5Z,e,d6zZ-d7�Z.e/�Z0d8�Z1dDd9�Z2d#d:�d;�Z3d<�Z4dEd=�Z5d>�Z6d?�Z7d@�Z8dA�Z9y)FaSCore implementation of import.

This module is NOT meant to be directly imported! It has been designed such
that it can be bootstrapped into Python as the implementation of import. As
such it requires the injection of specific modules and attributes in order to
work. One should use importlib as the public-facing version of this module.

c�d�	|jS#t$rt|�jcYSwxYw�N)�__qualname__�AttributeError�type)�objs �<frozen importlib._bootstrap>�_object_namers2��&�������&��C�y�%�%�%�&�s��/�/Nc	��dD]&}t||�s�t||t||���(|jj	|j�y)z/Simple substitute for functools.update_wrapper.)�
__module__�__name__r�__doc__N)�hasattr�setattr�getattr�__dict__�update)�new�old�replaces   r�_wrapr(sB��H���3�� ��C��'�#�w�"7�8�I��L�L������%�c�,�tt�|�Sr)r�sys��names r�_new_moduler0s���4��9�T�?�rc��eZdZy)�_ListN�rr
r�rrrr7���rrc�.�eZdZd�Zd�Zd�Zdd�Zdd�Zy)�_WeakValueDictionaryc���tj|��G�fd�dtj�}||_|j�y)Nc�B���eZdZdZ�fd�Z�fd�Ze�fd��Z�xZS)�/_WeakValueDictionary.__init__.<locals>.KeyedRef)�keyc�L��t�|�|||j�}||_|Sr)�super�__new__�remover&)r�obr&�self�	__class__s    �rr)z7_WeakValueDictionary.__init__.<locals>.KeyedRef.__new__Js%����w��t�R����=������rc�:��t�|�||j�yr)r(�__init__r*)r,r+r&r-s   �rr/z8_WeakValueDictionary.__init__.<locals>.KeyedRef.__init__Os����� ��T�[�[�1rc������}|�]|jr&|jj|j�ytj|j|j�yyr)�
_iterating�_pending_removals�appendr&�_weakref�_remove_dead_weakref�data)�wrr,�self_weakrefs  �rr*z6_WeakValueDictionary.__init__.<locals>.KeyedRef.removeRsN���$�~���#�����.�.�5�5�b�f�f�=� �5�5�d�i�i����H�	$r)	rr
r�	__slots__r)r/�staticmethodr*�
__classcell__)r-r8s@�r�KeyedRefr%Fs(����I�
�

2��
I��
Irr<)r4�ref�	_KeyedRef�clear)r,r<r8s  @rr/z_WeakValueDictionary.__init__@s5����|�|�D�)��
	I�x�|�|�	I�."����
�
�rc�>�g|_t�|_i|_yr)r2�setr1r6�r,s rr?z_WeakValueDictionary.clear`s��!#����%�����	rc��|jj}|j}		|�}tj||��#t$rYywxYwr)r2�popr6�
IndexErrorr4r5)r,rD�dr&s    r�_commit_removalsz%_WeakValueDictionary._commit_removalsesV���$�$�(�(���I�I���
��e��
�)�)�!�S�1����
��
�s�A�	A�ANc��|jr|j�	|j|}|�x}�|S|S#t$r|cYSwxYwr)r2rGr6�KeyError)r,r&�defaultr7�os     r�getz_WeakValueDictionary.getosW���!�!��!�!�#�	����3��B��T�	��"������
�	��N�	�s�:�A�Ac���	|j|�}|�=|jr|j�|j	||�|j|<|S|S#t$rd}Y�NwxYwr)r6rIr2rGr>)r,r&rJrKs    r�
setdefaultz_WeakValueDictionary.setdefault|sm��	���	�	�#�� �A�
�9��%�%��%�%�'�!�^�^�G�S�9�D�I�I�c�N��N��H���	��A�	�s�A�A%�$A%r)rr
rr/r?rGrLrNrrrr"r">s���@�
2��rr"c�"�eZdZdZd�Zd�Zd�Zy)�_BlockingOnManagerz;A context manager responsible to updating ``_blocking_on``.c� �||_||_yr)�	thread_id�lock)r,rRrSs   rr/z_BlockingOnManager.__init__�s��"�����	rc��tj|jt��|_|jj|j�y)zCMark the running thread as waiting for self.lock. via _blocking_on.N)�_blocking_onrNrRr�
blocked_onr3rSrBs r�	__enter__z_BlockingOnManager.__enter__�s4��'�1�1�$�.�.�%�'�J��������t�y�y�)rc�N�|jj|j�y)z6Remove self.lock from this thread's _blocking_on list.N)rVr*rS�r,�args�kwargss   r�__exit__z_BlockingOnManager.__exit__�s�������t�y�y�)rN)rr
rrr/rWr\rrrrPrP�s��E��	*�*rrPc��eZdZy)�_DeadlockErrorNrrrrr^r^�r rr^c���||vry|D]W}|j|�x}s�||vry|j|�|D�cgc]}|j��}}t||||��s�Wyycc}w)a�Check if 'target_id' is holding the same lock as another thread(s).

    The search within 'blocking_on' starts with the threads listed in
    'candidate_ids'.  'seen_ids' contains any threads that are considered
    already traversed in the search.

    Keyword arguments:
    target_id     -- The thread id to try to reach.
    seen_ids      -- A set of threads that have already been visited.
    candidate_ids -- The thread ids from which to begin.
    blocking_on   -- A dict representing the thread/blocking-on graph.  This may
                     be the same object as the global '_blocking_on' but it is
                     a parameter to reduce the impact that global mutable
                     state has on the result of this function.
    TF)�seen_ids�
candidate_ids�blocking_on)rL�add�owner�_has_deadlocked)�	target_idr`rarb�tid�candidate_blocking_onrS�edgess        rrere�s��� �M�!����)4����)=�=�%�=��
�H�_�
����S��)>�>�(=�����(=��>��9�x�u�'�)��!�$��?s�A#c�.�eZdZdZd�Zd�Zd�Zd�Zd�Zy)�_ModuleLockz�A recursive lock implementation which is able to detect deadlocks
    (e.g. thread 1 trying to take locks A then B, and thread 2 trying to
    take locks B then A).
    c��tj�|_tj�|_||_d|_g|_g|_yr)	�_thread�RLockrS�
allocate_lock�wakeuprrd�count�waiters�r,rs  rr/z_ModuleLock.__init__�sE��*�M�M�O��	��+�+�-�����	���
���
���rc�r�ttj�t�|jgt
��S)N)rfr`rarb)rerm�	get_identrArdrUrBs r�has_deadlockz_ModuleLock.has_deadlock s0��
��'�'�)��U� �:�:�,�$�	
�		
rc�V�tj�}t||�5	|j5|jgk(s|j
|k(r4||_|jj
d�	ddd�ddd�y|j�rtd|����|jjd�r|jj
d�ddd�|jj�|jj���#1swY�>xYw#1swYyxYw)z�
        Acquire the module lock.  If a potential deadlock is detected,
        a _DeadlockError is raised.
        Otherwise, the lock is always acquired and True is returned.
        TNzdeadlock detected by F)
rmrurPrSrqrdr3rvr^rp�acquirerr�release�r,rgs  rrxz_ModuleLock.acquire0s������!��
��T�
*���Y�Y��z�z�R�'�4�:�:��+<�&)��
��
�
�)�)�$�/�#��+�
*�D�(�(�*�,�/D�T�H�-M�N�N��{�{�*�*�5�1����+�+�D�1�Y�b���#�#�%�
���#�#�%�u��Y��+�
*�s0�D�AD�1D�AD�=D�D	�D�D(c���tj�}|j5|j|k7rt	d��t|j�dkDsJ�|jj�t|j�sSd|_t|j�dkDr4|jj�|jj�ddd�y#1swYyxYw)N�cannot release un-acquired lock�)rmrurSrd�RuntimeError�lenrqrDrrrpryrzs  rryz_ModuleLock.releasets������!��
�Y�Y��z�z�S� �"�#D�E�E��t�z�z�?�Q�&�&�&��J�J�N�N���t�z�z�?�!��
��t�|�|�$�q�(��L�L�$�$�&��K�K�'�'�)��Y�Y�s�B7C!�!C*c�8�d|j�dt|���S)Nz_ModuleLock(�) at �r�idrBs r�__repr__z_ModuleLock.__repr__�s���d�i�i�]�%��4��z�:�:rN)	rr
rrr/rvrxryr�rrrrkrk�s#���
6�p
� B&�H*�;rrkc�(�eZdZdZd�Zd�Zd�Zd�Zy)�_DummyModuleLockzVA simple _ModuleLock equivalent for Python builds without
    multi-threading support.c� �||_d|_y�Nr})rrqrss  rr/z_DummyModuleLock.__init__�s����	���
rc�.�|xjdz
c_y)N�T)rqrBs rrxz_DummyModuleLock.acquire�s���
�
�a��
�rc�b�|jdk(rtd��|xjdzc_y)Nr}r|r�)rqr~rBs rryz_DummyModuleLock.release�s&���:�:��?��@�A�A��
�
�a��
rc�8�d|j�dt|���S)Nz_DummyModuleLock(r�r�rBs rr�z_DummyModuleLock.__repr__�s��"�4�9�9�-�u�R��X�J�?�?rN)rr
rrr/rxryr�rrrr�r��s�� ����
@rr�c��eZdZd�Zd�Zd�Zy)�_ModuleLockManagerc� �||_d|_yr)�_name�_lockrss  rr/z_ModuleLockManager.__init__�s����
���
rc�l�t|j�|_|jj�yr)�_get_module_lockr�r�rxrBs rrWz_ModuleLockManager.__enter__�s"��%�d�j�j�1��
��
�
���rc�8�|jj�yr)r�ryrYs   rr\z_ModuleLockManager.__exit__�s���
�
���rN)rr
rr/rWr\rrrr�r��s����rr�c�J�tj�		t|�}|�?t�t|�}nt
|�}|fd�}tj||�t|<tj�|S#t$rd}Y�dwxYw#tj�wxYw)z�Get or create the module lock for a given module name.

    Acquire/release internally the global import lock to protect
    _module_locks.Nc���tj�	tj|�|urt|=tj	�y#tj	�wxYwr)�_imp�acquire_lock�
_module_locksrL�release_lock)r=rs  r�cbz_get_module_lock.<locals>.cb�sI���!�!�#�(�%�(�(��.�#�5�)�$�/��%�%�'��D�%�%�'�s�A	�	A)
r�r�r�rIrmr�rkr4r=r�)rrSr�s   rr�r��s���	�����	� ��&�(�D��<���'��-��"�4�(��!�	
(�#+�,�,�t�R�"8�M�$�������K��1�	��D�	��,	
����s)�
A;�AB�;B	�B�B	�	B�B"c�z�t|�}	|j�|j�y#t$rYywxYw)z�Acquires then releases the module lock for a given module name.

    This is used to ensure a module is completely initialized, in the
    event it is being imported by another thread.
    N)r�rxryr^)rrSs  r�_lock_unlock_moduler��s=���D�!�D������	
������
�	
�
�s�.�	:�:c��||i|��S)a.remove_importlib_frames in import.c will always remove sequences
    of importlib frames that end with a call to this function

    Use it instead of a normal call in places where including the importlib
    frames introduces unwanted noise into the traceback (e.g. when executing
    module code)
    r)�frZ�kwdss   r�_call_with_frames_removedr��s��
�d��d��rr�)�	verbosityc��tjj|k\r?|jd�sd|z}t	|j
|�tj��yy)z=Print the message to stderr if -v/PYTHONVERBOSE is turned on.)�#zimport z# )�fileN)r�flags�verbose�
startswith�print�format�stderr)�messager�rZs   r�_verbose_messager��sJ��
�y�y���I�%��!�!�"2�3��W�n�G�
�n�g�n�n�d�#�#�*�*�5�&rc�*���fd�}t|��|S)z1Decorator to verify the named module is built-in.c�Z��|tjvrt|�d�|����||�S)N� is not a built-in moduler)r�builtin_module_names�ImportError�r,�fullname�fxns  �r�_requires_builtin_wrapperz4_requires_builtin.<locals>._requires_builtin_wrapper�s8����3�3�3�3����,E�F�#+�-�
-��4��"�"r�r)r�r�s` r�_requires_builtinr��s���#�

�
#�S�)�$�$rc�*���fd�}t|��|S)z/Decorator to verify the named module is frozen.c�`��tj|�st|�d�|����||�S)Nz is not a frozen moduler)r��	is_frozenr�r�s  �r�_requires_frozen_wrapperz2_requires_frozen.<locals>._requires_frozen_wrappers6����~�~�h�'����,C�D�#+�-�
-��4��"�"rr�)r�r�s` r�_requires_frozenr��s���#�

�
"�C�(�#�#rc���d}tj|t�t||�}|tj
vr2tj
|}t
||�tj
|St|�S)z�Load the specified module into sys.modules and return it.

    This method is deprecated.  Use loader.exec_module() instead.

    zgthe load_module() method is deprecated and slated for removal in Python 3.12; use exec_module() instead)�	_warnings�warn�DeprecationWarning�spec_from_loaderr�modules�_exec�_load)r,r��msg�spec�modules     r�_load_module_shimr�
sa��3�C�
�N�N�3�*�+��H�d�+�D��3�;�;�����X�&��
�d�F���{�{�8�$�$��T�{�rc��t|dd�}t|dd�x}rt|�S	|j}	|j}d|�d|�d�S#t$rd}Y�#wxYw#t$r|�d|�d�cYSd|�d|�d	�cYSwxYw)
z,The implementation of ModuleType.__repr__().�
__loader__N�__spec__�?�<module � from �>� (�)>)r�_module_repr_from_specrr�__file__)r��loaderr�r�filenames     r�_module_reprr�s���
�V�\�4�
0�F��v�z�4�0�0�t�0�%�d�+�+������6��?�?���$����|�1�5�5���������5��>��d�X�Q�'�'��d�X�R��z��4�4�	5�s(�A�A�A�A�A;�/	A;�:A;c��eZdZdZdddd�d�Zd�Zd�Zed��Zejd��Zed	��Z
ed
��Zejd��Zy)�
ModuleSpeca�The specification for a module, used for loading.

    A module's spec is the source for information about the module.  For
    data associated with the module, including source, use the spec's
    loader.

    `name` is the absolute name of the module.  `loader` is the loader
    to use when loading the module.  `parent` is the name of the
    package the module is in.  The parent is derived from the name.

    `is_package` determines if the module is considered a package or
    not.  On modules this is reflected by the `__path__` attribute.

    `origin` is the specific location used by the loader from which to
    load the module, if that information is available.  When filename is
    set, origin will match.

    `has_location` indicates that a spec's "origin" reflects a location.
    When this is True, `__file__` attribute of the module is set.

    `cached` is the location of the cached bytecode file, if any.  It
    corresponds to the `__cached__` attribute.

    `submodule_search_locations` is the sequence of path entries to
    search when importing submodules.  If set, is_package should be
    True--and False otherwise.

    Packages are simply modules that (may) have submodules.  If a spec
    has a non-None value in `submodule_search_locations`, the import
    system will consider modules loaded from the spec as packages.

    Only finders (see importlib.abc.MetaPathFinder and
    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.

    N)�origin�loader_state�
is_packagec�|�||_||_||_||_|rgnd|_g|_d|_d|_y�NF)rr�r�r��submodule_search_locations�_uninitialized_submodules�
_set_fileattr�_cached)r,rr�r�r�r�s      rr/zModuleSpec.__init__WsD����	�������(���0:�"���'�)+��&�#�����rc�<�d|j��d|j��g}|j�|jd|j���|j�|jd|j���|j
j�ddj|��d�S)Nzname=zloader=zorigin=zsubmodule_search_locations=�(z, �))rr�r�r3r�r-r�join)r,rZs  rr�zModuleSpec.__repr__ds�����	�	�}�%������'@�A���;�;�"��K�K�'�$�+�+��1�2��*�*�6��K�K�5�d�6U�6U�5V�W�X��.�.�)�)�*�!�D�I�I�d�O�+<�A�>�>rc�r�|j}	|j|jk(xr{|j|jk(xr`|j|jk(xrE||jk(xr4|j|jk(xr|j
|j
k(S#t$r	tcYSwxYwr)r�rr�r��cached�has_locationr�NotImplemented)r,�other�smsls   r�__eq__zModuleSpec.__eq__ls����.�.��	"��I�I����+�<��K�K�5�<�<�/�<��K�K�5�<�<�/�<��E�<�<�<�<��K�K�5�<�<�/�	<�
�%�%��);�);�;�
=���	"�!�!�	"�s�BB$�$B6�5B6c���|j�H|j�<|jr0t�t�tj|j�|_|jSr)r�r�r��_bootstrap_external�NotImplementedError�_get_cachedrBs rr�zModuleSpec.cachedxsJ���<�<���{�{�&�4�+=�+=�&�.�-�-�2�>�>�t�{�{�K����|�|�rc��||_yr)r�)r,r�s  rr�zModuleSpec.cached�s	����rc�n�|j�|jjd�dS|jS)z The name of the module's parent.�.r})r�r�
rpartitionrBs r�parentzModuleSpec.parent�s4���*�*�2��9�9�'�'��,�Q�/�/��9�9�rc��|jSr)r�rBs rr�zModuleSpec.has_location�s���!�!�!rc�$�t|�|_yr)�boolr�)r,�values  rr�zModuleSpec.has_location�s��!�%�[��r)rr
rrr/r�r��propertyr��setterr�r�rrrr�r�2s���"�H04�$� ��?�
"������]�]���������"��"����)��)rr��r�r�c�4�|�
t|dd�}|sEt|d�r9t�t�tj}|�
|||��S|rgnd}||||��S|�!t|d�r	|j|�}nd}t||||��S#t$rd}Y�wxYw)	z5Return a module spec based on various loader methods.N�_ORIGIN�get_filename)r�)r�r�r�Fr�)rr
r�r��spec_from_file_locationr�r�r�)rr�r�r�r�searchs      rr�r��s���
�~����D�1���g�f�n�5��&�%�%�"5�"M�"M����*�4��?�?�!��t��&�t�F�BH�J�	J����6�<�(�
"�#�.�.�t�4�
�
�J��d�F�6�j�I�I��
�
"�!�
�
"�s�&B	�	B�Bc���	|j}|�|S|j}|�
	|j}	|j}|�|�
t|dd�}|s|�|}	|j}	t|j�}t|||��}|�dn||k(|_
||_||_|S#t$rY��wxYw#t$rY��wxYw#t$rd}Y��wxYw#t$rd}Y�~wxYw#t$rd}Y�ywxYw)Nr��r�F)
r�rrr�r�r�
__cached__�list�__path__r�r�r�r�)r�r�r�r�r�locationr�r�s        r�_spec_from_moduler	�s5����������K��?�?�D�
�~�	��&�&�F���?�?���~����V�Y��5�F��(�.��F���"�"��*�%)�&�/�/�%:�"��d�F�6�2�D�"*�"2���8�9K�D���D�K�&@�D�#��K��G�
��
���	��	��
�������������*�%)�"�*�sW�B �B/�B>�C�C � 	B,�+B,�/	B;�:B;�>C�C�C�C� C.�-C.F��overridec�|�|s
t|dd��	|j|_|s
t|dd��n|j}|�X|j
�Lt�t�tj}|j|�}|j
|_
||_d|_	||_|s
t|dd��	|j|_	||_|s
t|dd��|j
�	|j
|_|j"rP|s
t|dd��	|j$|_|s
t|dd�� |j&�	|j&|_|S|S#t$rY��=wxYw#t$rY��wxYw#t$rY��wxYw#t$rY��wxYw#t$rY��wxYw#t$rY��wxYw#t$rY|SwxYw)Nrr��__package__rr�r)rrrrr�r�r�r��NamespaceLoaderr)�_pathr�r�r�r
r�rr�r�r�r)r�r�rr�rs     r�_init_module_attrsr�s���	�G�F�J��5�=�	�"�i�i�F�O��7�6�<��6�>������>��.�.�:�&�.�-�-�"5�"E�"E��(�0�0��A��#�>�>���$���#'���	� &�F���7�6�=�$�7�?�	�!%���F��
�����7�6�:�t�4�<��*�*�6�
�"&�"A�"A�������w�v�z�4�8�@�
�"&�+�+����w�v�|�T�:�B��{�{�&��(,���F�%��M�6�M���	��	��8�	��	���	��	��
�
��
��"�
��
��"�
��
��&����M��s}�E�E#�/E2�F�$F�F�>F.�	E �E �#	E/�.E/�2	E>�=E>�	F
�F
�	F�F�	F+�*F+�.	F;�:F;c��d}t|jd�r|jj|�}n!t|jd�rtd��|�t	|j
�}t
||�|S)z+Create a module based on the provided spec.N�
create_module�exec_modulezBloaders that define exec_module() must also define create_module())r
r�rr�rrr�r�r�s  r�module_from_specr&so���F��t�{�{�O�,����*�*�4�0��	����m�	,��=�>�	>�
�~��T�Y�Y�'���t�V�$��Mrc�x�|j�dn|j}|j�Y|j}|�d|�d�St�6t	|tj
�rd|�dt
|j��d�Sd|�d|�d�S|jrd|�d|j�d�Sd|j�d|j�d�S)z&Return the repr to use for the module.r�r�r�z (namespace) from r�r�r�)	rr�r�r��
isinstancerrrr�)r�rr�s   rr�r�7s����)�)�#�3����D��{�{�������>��d�X�Q�'�'��+��6�#6�#F�#F�G��d�X�%7��V�\�\�8J�7K�1�M�M��d�X�R��z��4�4�����d�X�V�D�K�K�?�!�<�<��d�i�i�]�"�T�[�[�M��<�<rc��|j}t|�5tjj	|�|urd|�d�}t||���	|j�2|j�td|j���t||d��n�t||d��t|jd�sNt|j��d	�}tj|t�|jj|�n|jj|�tjj!|j�}|tj|j<	ddd�|S#tjj!|j�}|tj|j<wxYw#1swY|SxYw)
zFExecute the spec's specified module in an existing module's namespace.zmodule z not in sys.modulesrN�missing loaderTr
r�7.exec_module() not found; falling back to load_module())rr�rr�rLr�r�r�rr
rr�r��
ImportWarning�load_modulerrD)r�r�rr�s    rr�r�MsS���9�9�D�	�D�	!��;�;�?�?�4� ��.��D�8�#6�7�C��c��-�-�	,��{�{�"��2�2�:�%�&6�T�Y�Y�G�G�"�4��$�?�"�4��$�?��t�{�{�M�:�*�4�;�;�7�8�9;�;�C��N�N�3�
�6��K�K�+�+�D�1��K�K�+�+�F�3��[�[�_�_�T�Y�Y�/�F�%+�C�K�K��	�	�"�/
"�0�M���[�[�_�_�T�Y�Y�/�F�%+�C�K�K��	�	�"��/
"�0�M�s&�5F5�CE*�AF5�*AF2�2F5�5F?c��	|jj|j�tjj|j�}|tj|j<t
|dd��	|j|_t
|dd��A	|j|_
t|d�s#|jjd�d|_
t
|dd��
	||_
|S|S#|jtjvrFtjj|j�}|tj|j<�xYw#t$rY��wxYw#t$rY��wxYw#t$rY|SwxYw)Nr�r
rr�r}r�)r�rrrr�rDrr�rrr
r
r�r�rs  r�_load_backward_compatiblerksY���������	�	�*��[�[�_�_�T�Y�Y�
'�F�#�C�K�K��	�	���v�|�T�*�2�	� $���F���v�}�d�+�3�	�"(���F���6�:�.�%)�Y�Y�%9�%9�#�%>�q�%A��"��v�z�4�(�0�	�"�F�O��M�6�M��;��9�9����#��[�[�_�_�T�Y�Y�/�F�%+�C�K�K��	�	�"�
���	��	���	��	��
�	���M�	�sC�%C3�;E�AE*�(E9�3A%E�	E'�&E'�*	E6�5E6�9	F�Fc��|j�St|jd�s=t|j��d�}tj	|t
�t
|�St|�}d|_	|tj|j<	|j�#|j�2td|j���|jj|�tjj!|j�}|tj|j<t#d|j|j�d|_|S#	tj|j=�#t$rY�wxYwxYw#d|_wxYw)NrrTrrzimport {!r} # {!r}F)r�r
rr�r�rrr�
_initializingrr�rr�r�rrIrDr�)r�r�r�s   r�_load_unlockedr!�sH���{�{���t�{�{�M�2�"�4�;�;�/�0�14�4�C��N�N�3�
�.�,�T�2�2�
�d�
#�F�
�D��#�!'����D�I�I��	��{�{�"��2�2�:�%�&6�T�Y�Y�G�G����'�'��/���������+��!'����D�I�I���-�t�y�y�$�+�+�F�"����M��!	�
��K�K��	�	�*�
���
���
��#���sJ�3E<�A
E�A'E<�E9�E*�)E9�*	E6�3E9�5E6�6E9�9E<�<	Fc�n�t|j�5t|�cddd�S#1swYyxYw)z�Return a new module object, loaded by the spec's loader.

    The module is not added to its parent.

    If a module is already in sys.modules, that existing module gets
    clobbered.

    N)r�rr!�r�s rr�r��s$��
�D�I�I�	&��d�#�
'�	&�	&�s�+�4c��eZdZdZdZed
d��Zed��Zed��Z	ee
d���Zee
d���Zee
d	���Z
ee�Zy)�BuiltinImporterz�Meta path import for built-in modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

    zbuilt-inNc�^�tj|�rt|||j��Sy)Nr)r��
is_builtinr�r�)�clsr��path�targets    r�	find_speczBuiltinImporter.find_spec�s$���?�?�8�$�#�H�c�#�+�+�F�F�rc��|jtjvr$t|j�d�|j���t	t
j|�S)zCreate a built-in moduler�r)rrr�r�r�r��create_builtinr#s rrzBuiltinImporter.create_module�sK���9�9�C�4�4�4�����
�-F�G�#'�9�9�.�
.�(��)<�)<�d�C�Crc�8�ttj|�y)zExec a built-in moduleN)r�r��exec_builtin)r�s rrzBuiltinImporter.exec_module�s��	"�$�"3�"3�V�<rc��y)z9Return None as built-in modules do not have code objects.Nr�r(r�s  r�get_codezBuiltinImporter.get_code����rc��y)z8Return None as built-in modules do not have source code.Nrr1s  r�
get_sourcezBuiltinImporter.get_source�r3rc��y)z4Return False as built-in modules are never packages.Frr1s  rr�zBuiltinImporter.is_package�s��r�NN)rr
rrr��classmethodr+r:rrr�r2r5r�r�rrrrr%r%�s�����G������D��D��=��=��������������������/�0�Krr%c���eZdZdZdZed��Zed
d��Zedd��Ze	d��Z
e	d��Zed	��Zee
d
���Zee
d���Zee
d���Zy)�FrozenImporterz�Meta path import for frozen modules.

    All methods are either class or static methods to avoid the need to
    instantiate the class.

    �frozenc��|j}|j}|��Xt|�jdd�}|sJd��t	|d�}t
j
|j�|k(sJ|��|j||j|�\}}ttj�||��|_|j}|r+|gk(sJ|��|r&|jjd|�n	|�J|��t	|d�rJ|j��|r	||_|�r�|j"|k7�r�|j"gk(sJ|j"��|j"j%|��nv|j}|du}t't|��ddgk(sJ|��|j(rm|j|j(|j|�\}	}|j*|	k(sJ|j*|	f��|r||gk(sHJ||f��||rgndk(s6J|��d}	|j*�J|j*��||rgndk(sJ|��|	r0t	|d�sJ�|j|	k(s0J|j|	f��t	|d�rJ|j��|r0t	|d�sJ�|j"|k(s0J|j"|f��t	|d�rJ|j"��|j,rJ�y#t $rY���wxYw)	N�__origname__z'see PyImport_ImportFrozenModuleObject()r�r��orignamer}r�r�r?)r�r��varsrDr
r��is_frozen_packager�_resolve_filenamerrr�implementationr��insertr�rr�extend�sortedr?r�r�)
r(r�r��stater?�ispkgr��pkgdirrr�s
          r�_fix_up_modulezFrozenImporter._fix_up_module
s�������!�!���=��F�|�'�'���=�H��F�F�F�8��F�J�/�E��)�)�&�/�/�:�e�C�J�U�J�C�"�4�4�X�t�y�y�%�P��H�f� 8��S�%7�%7� 8�!�!�!�D���6�6�H���2�~�/�x�/�~���3�3�:�:�1�f�E��'�1��1�'��v�z�2�C�F�O�O�C�2���&.�F�O���?�?�h�.�!�?�?�b�0�A�&�/�/�A�0��O�O�*�*�8�4��6�6�H��D�(�E��$�u�+�&�:�z�*B�B�I�E�I�B��~�~��*�*�5�>�>�4�9�9�e�L���6��~�~��1�M�E�N�N�H�3M�M�1��#��x�/�C�(�F�1C�C�/�#�e���>�H��H�>����~�~�-�=�u�~�~�=�-��%�B�T�:�D�H�D�:���v�z�2�2�2����(�2�O�V�_�_�h�4O�O�2�"�6�:�6�G����G�6���v�z�2�2�2����(�2�O�V�_�_�h�4O�O�2�"�6�:�6�G����G�6��$�$�$�$�$��K&����s�K9�9	L�LNc��|rttdd�sy	|j}||k7r |jd�r
|dd}|s|�d�}nd	}|j
d
|�}|r!tj�|�|��}|�|�d�}||fSd}tj�|�|�d�}||fS#t$r!tjdk(rdndx}|_Y��wxYw)
N�_stdlib_dirr7�win32�\�/�<r�z	.__init__Fr�z__init__.pyz.py)rr�_SEPr�platformr�rrL)r(r��aliasrH�sep�relfilerIr�s        rrBz FrozenImporter._resolve_filenameOs����w�s�M�4�@��	F��(�(�C��u���"�"�3�'�#�A�B�<���"*��9�5�H����"�"�3��,������(���g�Y�7�F� ��#��k�2�H������F��/�/�*�3�%��y��<�H������#�	F�%(�\�\�W�%<�T�#�E�C�#�(�	F�s�B�'C�Cc�2�ttj|�}|�y|\}}}t|||j|��}|j|||�\}	}
t
tj�|	|��|_	|
r|jjd|
�|S)Nr�r>r})r�r��find_frozenr�r�rBrrrCr�r�rD)r(r�r)r*�info�_rHr?r�r�rIs           rr+zFrozenImporter.find_spechs���(��)9�)9�8�D���<��"���5�(���#�'*�{�{�+0�2���0�0��8�U�K���&�4�D��!3�!3�4���
�����+�+�2�2�1�f�=��rc��t|j�}	|jj}|r||_|S#t
$rY|SwxYw)zSet __file__, if able.)rrr�r�r�r)r�r�r�s   rrzFrozenImporter.create_module�sT���T�Y�Y�'��	+��(�(�1�1�H��"*����
���	���
�	�s�8�	A�Ac��|j}|j}ttj|�}t||j�yr)r�rr�r��get_frozen_object�execr)r�r�r�codes    rrzFrozenImporter.exec_module�s4�������y�y��(��)?�)?��F���T�6�?�?�#rc���t||�}tj|�}|�J�|\}}}||_t	|�jdd�|rg|_|j|�|S)z_Load a frozen module.

        This method is deprecated.  Use exec_module() instead.

        Nr�)r�r�rWr=r@rDrrJ)r(r�r�rXrYrHr?s       rrzFrozenImporter.load_module�sq��#�3��1������)������!���5�(�&����V�����T�*�� �F�O����6�"��
rc�,�tj|�S)z-Return the code object for the frozen module.)r�r\r1s  rr2zFrozenImporter.get_code�����%�%�h�/�/rc��y)z6Return None as frozen modules do not have source code.Nrr1s  rr5zFrozenImporter.get_source�r3rc�,�tj|�S)z.Return True if the frozen module is a package.)r�rAr1s  rr�zFrozenImporter.is_package�rarr�r7)rr
rrr�r8rJrBr+r:rrrr�r2r5r�rrrr:r:�s�����G��B%��B%�H� �� �0����:�
��
��$��$�����$��0���0���������0���0rr:c��eZdZdZd�Zd�Zy)�_ImportLockContextz$Context manager for the import lock.c�,�tj�y)zAcquire the import lock.N)r�r�rBs rrWz_ImportLockContext.__enter__�������rc�,�tj�y)z<Release the import lock regardless of any raised exceptions.N)r�r�)r,�exc_type�	exc_value�
exc_tracebacks    rr\z_ImportLockContext.__exit__�rgrN)rr
rrrWr\rrrrere�s��.��rrec�~�|jd|dz
�}t|�|krtd��|d}|r|�d|��S|S)z2Resolve a relative module name to an absolute one.r�r�z2attempted relative import beyond top-level packager})�rsplitrr�)r�package�level�bits�bases     r�
_resolve_namerr�sO���>�>�#�u�q�y�)�D�
�4�y�5���N�O�O���7�D�#�d�V�1�T�F��-��-rc���tj}|�td��|stj	dt
�|tjv}|D]q}t�5	|j}||||�}	ddd���1|s<|tjvr*tj|}	|j}	|	�|cS|	cS|cSy#t$rYddd���wxYw#1swY�gxYw#t$r|cYcSwxYw)zFind a module's spec.Nz5sys.meta_path is None, Python is likely shutting downzsys.meta_path is empty)r�	meta_pathr�r�r�rr�rer+rr�)
rr)r*rt�	is_reload�finderr+r�r�r�s
          r�
_find_specrw�s���
�
�I����*�+�	+�����/��?�
����#�I���
�
!�
5�"�,�,�	�!��t�V�4��
"��������!4����T�*��(�%���H� �'�#��'����3�6��/"�
��	"�
!�
��"�
!��&� � �K�	 �sB�C�C�)
C�'C&�	C�C�C�C�C#	�&C6�5C6c���t|t�stdt|�����|dkrt	d��|dkDr(t|t�std��|std��|s|dk(rt	d��yy)zVerify arguments are "sane".zmodule name must be str, not r}zlevel must be >= 0z__package__ not set to a stringz6attempted relative import with no known parent packagezEmpty module nameN)r�str�	TypeErrorr�
ValueErrorr��rrnros   r�
_sanity_checkr}s����d�C� ��7��T�
�|�D�E�E��q�y��-�.�.��q�y��'�3�'��=�>�>���(�)�
)��E�Q�J��,�-�-��4rzNo module named z{!r}c�V�d}|jd�d}d}|r�|tjvrt||�|tjvrtj|Stj|}	|j}|j}|jd�d}t||�}|�tt�|��|���|r|jj�	t|�}	|r|jj�	|r#tj|}	t||	�|	S|	S#t
$rt�|�d|�d�}t||��d�wxYw#|r|jj�wwxYw#t
$r&d|�d��}tj!|t"�Y|	SwxYw)	Nr�r}z; z is not a packager�zCannot set an attribute on z for child module )r�rr�r�rr�_ERR_MSG_PREFIX�ModuleNotFoundErrorr�rwr�r3r!rDrr�r�r)
r�import_r)r��parent_spec�
parent_moduler��childr�r�s
          r�_find_and_load_unlockedr�s����D�
�_�_�S�
!�!�
$�F��K�
�����$�%�g�v�6��3�;�;���;�;�t�$�$����F�+�
�	@� �)�)�D�$�,�,������$�Q�'���d�D�!�D��|�!�_�$5�d�X�">�T�J�J��
�1�1�8�8��?�	<�#�D�)�F���5�5�9�9�;�
����F�+�
�	/��M�5�&�1��M�6�M��5�	@�$�%�d�X�R��z�9J�K�C�%�c��5�4�?�	@�� ��5�5�9�9�;����	/�/��z�9K�E�9�U�C��N�N�3�
�.��M�	/�s*�2D.�E�
E9�.&E�E6�9+F(�'F(c��tjj|t�}|tust	t	|dd�dd�rat|�5tjj|t�}|turt
||�cddd�S	ddd�t|�|�d|�d�}t||���|S#1swY�+xYw)zFind and load the module.r�Nr Fz
import of z halted; None in sys.modulesr)	rr�rL�_NEEDS_LOADINGrr�r�r�r�)rr�r�r�s    r�_find_and_loadr�Es���
�[�[�_�_�T�>�
2�F��.� ����
�D�1�?�E�J�
��
%��[�[�_�_�T�>�:�F���'�.�t�W�=�&�
%�'�&�	�D�!�
�~��t�f�$@�A��!�'��5�5��M�&�
%�s�8B=�=Cc�`�t|||�|dkDr
t|||�}t|t�S)a2Import and return the module based on its name, the package the call is
    being made from, and the level adjustment.

    This function represents the greatest common denominator of functionality
    between import_module and __import__. This includes setting __package__ if
    the loader did not.

    r})r}rrr��_gcd_importr|s   rr�r�_s2���$���'��q�y��T�7�E�2���$��,�,r��	recursivec	���|D]�}t|t�s8|r|jdz}nd}td|�dt	|�j����|dk(r*|r�St|d�s�`t
||j|d���zt||�r��|j�d	|��}	t||���|S#t$r>}|j|k(r)tjj|t��Yd
}~��d
}~wwxYw)z�Figure out what __import__ should return.

    The import_ parameter is a callable which takes the name of module to
    import. It is required to decouple the function from assuming importlib's
    import implementation is desired.

    z.__all__z
``from list''zItem in z must be str, not �*�__all__Tr�r�N)rryrrzrr
�_handle_fromlistr�r�r�rrr�rLr�)r��fromlistr�r��x�where�	from_name�excs        rr�r�ns������!�S�!�����*�4��'���h�u�g�.#�#'��7�#3�#3�"4�6�7�
7�
�#�X�����!;� ������+/�1����#�!�?�?�+�1�Q�C�0�I�	
�)�'�9�=��0�M��'�
��H�H�	�)��K�K�O�O�I�~�>�J����
�s�B,�,	C3�53C.�-C.�.C3c�\�|jd�}|jd�}|�@|�<||jk7r-tjd|�d|j�d�td��|S|�|jStjdt
d��|d	}d
|vr|j
d�d}|S)
z�Calculate what __package__ should be.

    __package__ is not guaranteed to be defined or could be set to None
    to represent that its proper value is unknown.

    r
r�z __package__ != __spec__.parent (z != r��)�
stacklevelzYcan't resolve package from __spec__ or __package__, falling back on __name__ and __path__rrr�r})rLr�r�r�r�rr�)�globalsrnr�s   r�_calc___package__r��s����k�k�-�(�G��;�;�z�"�D������4�;�;� 6��N�N��&�k��d�k�k�_�A�?�-�!�
�
=���	
�	��{�{�����?�$��	�	4��*�%���W�$��(�(��-�a�0�G��Nrc��|dk(rt|�}n|�|ni}t|�}t|||�}|s�|dk(rt|jd�d�S|s|St|�t|jd�d�z
}tj
|jdt|j�|z
St|d�rt||t�S|S)a�Import a module.

    The 'globals' argument is used to infer where the import is occurring from
    to handle relative imports. The 'locals' argument is ignored. The
    'fromlist' argument specifies what should exist as attributes on the module
    being imported (e.g. ``from module import <fromlist>``).  The 'level'
    argument represents the package location to import from in a relative
    import (e.g. ``from ..pkg import mod`` would have a 'level' of 2).

    r}Nr�r)	r�r��	partitionrrr�rr
r�)	rr��localsr�ror��globals_rn�cut_offs	         r�
__import__r��s���
��z��T�"��%�1�7�r��#�H�-���T�7�E�2����A�:��t�~�~�c�2�1�5�6�6���M��$�i�#�d�n�n�S�&9�!�&<�"=�=�G��;�;�v���/L��F�O�O�0D�W�0L�M�N�N�	���	$����+�>�>��
rc�b�tj|�}|�td|z��t|�S)Nzno built-in module named )r%r+r�r!)rr�s  r�_builtin_from_namer��s3���$�$�T�*�D��|��5��<�=�=��$��rc�,�|a|att�}tjj	�D]z\}}t||�s�|tjvrt}ntj|�rt}n�It||�}t||�|tus�j|j|��|tjt}dD]@}|tjvrt|�}	ntj|}	t|||	��Bt!�ay)z�Setup importlib by importing needed built-in modules and injecting them
    into the global namespace.

    As sys is needed for sys.modules access and _imp is needed to load built-in
    modules, those two modules must be explicitly passed in.

    )rmr�r4N)r�rrr��itemsrr�r%r�r:r	rrJrr�rr"rU)
�
sys_module�_imp_module�module_typerr�r�r��self_module�builtin_name�builtin_modules
          r�_setupr��s����D�
�C��s�)�K����)�)�+���f��f�k�*��s�/�/�/�(������%�'���$�V�V�4�D��t�V�,���'��%�%�f�-�,��+�+�h�'�K�<���s�{�{�*�/��=�N� �[�[��6�N���\�>�:�=�(�)�Lrc��t||�tjjt�tjjt
�y)z0Install importers for builtin and frozen modulesN)r�rrtr3r%r:)r�r�s  r�_installr�s0��
�:�{�#��M�M����)��M�M����(rc�\�ddl}|a|jtjt
�y)z9Install importers that require external filesystem accessr}N)�_frozen_importlib_externalr�r�rr�r)r�s r�_install_external_importersr�
s$��&�4���'�'����H�(=�>rr7rr�)NNrr}):rrrmr�r4r�rrrrr"r�rUrPr~r^rerkr�r�r�r�r�r�r�r�r�r�r�r�r	rrr�r�rr!r�r%r:rerrrwr}r��_ERR_MSGr��objectr�r�r�r�r�r�r�r�r�r�rrr�<module>r�s����,&����	�����&��	�D�	�I�I�\�
���*�*�,	�\�	�
(�V`;�`;�F@�@�*�� "�J�"�01�6�%�$��&6�*a)�a)�H.2�d�J�:'�T27�F�R�"=�,�<"�H)�Z
$�11�11�h~0�~0�F
�
�.�*�Z
.� %���V�#��'�T����4-�>C�"�J�6"�J �%*�P)�?r�&�))intcQ\ht)t,)�<�<�<\l��1l	35	6	�	7	�	8	�	9	� 	:	�(	;	�0	<	�8	=	�@	@	�H	A	�P	B	�X	D�`	F�h	H5p	I5t	J�x	MJ�	N��	O��	Q��	Y
��	[��	\��	]��	^	��	_
�	`5�	b���
+��\�
)x��\�
)��l����5W5-�.�	\�	!\
$�
25
75
;5��Z)
��
��54	6	5	7	5��9
)�)�5�<�)�5�<5� 6�	7Q	8]	95	;Q�(7	Qget
setdocQ	� C()�	*Q	+	5	,�	-	5doc.Q ����	��� W�	X�	Y�����	�#	�Q	�� 	��(	�0	��8	�5@	�iH	��P	��X	��`	��h	��p	��x	���	���	�\�	���	���	�)�	�Q�	��
�	�
��	���	���	���	�
�	���	���	������W��$�� �1(�j0�
>8��
@�
�H�WP�WX�W`��h�Wp�x�t�������h���_ts s�
	v	w	x	��	�	5	�	5 	�	5$	�	5(	�	5,	�	50	�8	�D@	�DH	�WP	�WX	�W`	�!h	�Wp	�	5x	�W�	�)�	�)�	�]�	��	���	�	5�	�W�	�W�	�W�	���id���	�'�	�'�	�'������
_isP	Wbuf�objWlen�	�		5 		5$	�(	b0	b8	b@	 �H�W�!�
#��5�W�5h$���W���������
)��	#	��	��������0TZWiW1v|W�WW2��W�WWW3��5�W4���
W5


W'
W�74
:
5S
W�W9`
f
5
WWW;�
�
5�
WW<�
�
5�
W�=�
�
5�
W�
�@�A$*5WBBHW\W�CvDv|5�W�WE`
FTG����WH��W�WW5ITJTK�L`
M`
NKQWj�WWOw}W���R��W�W�W]������J�X�5h+ ! l	" ;		@i	Ai	Bi	Ci	Di 	E�(	FG0	GG8	HG@	I
�H	JGP	KiX	Li`	Mih	Nip	Oix	PG�	Q��	RG�	Ti�	Ui�	Vi�	Wi�	X��	Yi�	Zi�	[i�	\i�	]i�	_i�	`i�	ai�bidGfigih8Pj	�	k
�	li	m
	n
	o� 	p'
(	q�0	r
8	ti@	u
Hv'x	�	y
�	zi	{S
|�~+'WW'W �	k	�G	�G	�G	���-�	�	�t	���wk����7�����5���;-	<�	=�@Ok0A�k1B�Es	Fs	G�h�
)I�	Js	K�7	�#uc9�#fnv>	C-HOL�h�
)M�N�%5	%5
%5%5%5
%5%5%5%5%5%5%5%5%5%5��\����o�p�o2'�!21PV5tWt5W�C�	O!�	P��zQzS�	aW	c��e� g;	h;	itopj	kA�WQ
)l�n�	o	5	pWz$t$�t$�t$�t$�t$�t$�t$�t��
��Q NW OW PW RW TW UW VW WW YW ZW [W \W ]W ^W _W aW cW dW eW fW gW hW iW kW mW nW oW pW qW rW sW tW uW vW wW xW yW zW {W ~W W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W �W+�R�	S�	T�]�
)Ui!�!�"�#�$�$�$�%	�&�'�'�(�(�(�)�)B�)C�)D�)O�)P�)Q�)S�)T�)U�*�*�*�*�*�+
�+�,	�,
�,�-EW�v. �/
�/)�%W�0A�0��0��1�11�2.Q2.Q2%52%53�W*W�4�5��6�7
�8	�8�8�9�:�:	�:�;$�;8�;9�;F�;G�;H�;I�	 59WW��������<<�=	�>�>�>
�? W@
�A�QB�B�B�%5C"  Dx�M ��QDyY 4 EB!0F� 	FQ	F�F� k  F � 	F!Q	F"� 	F#	5	F$	5	F%�� oF+$!� G�G�G	�{E!
)�5!H E!of!
)�V!H!f!H!f!I��!	I�Q	I�Q�!I�$!I�$!I�$!I�%�!�!o�!&)���!'J�!	o#"&)+�"'K#"	oO"&):^>"'LO"	o{"&)Ij"'M{"	o�"&)���"'N�"	o�"&)�"'O�"	o�"&)ز�"'P�"	o+#&)g#'Q+#	oW#&)F#'RW#	o�#&)hr#'S�#	o�#&)�D�#'T�#	o�#&)*��#'U�#	o$&)�n�#'V$	o3$&)F"$'W3$	o_$&)�-N$'X_$	o�$&)z$'Y�$	o�$&)�7�$'Z�$	o�$&)G�$'[�$	o%&)I�$'\%	o:%
)g*%']:%	oe%
)lU%'^e%	o�%&)N�%'_�%	o�%
)��%'`�%	� �%
)�%(aa�%	� &
)&(ag&	� =&
)-&(a~=&	)�!a�	)�!a�	)�!a�	�!�&
)	�&(a�#�&	)�!a�	)� a�	%:;9I$>&I$>I:;9	
:;9I8
:;9<I
!I/4:;9I?<!4:;9I?<7I
:;9I8
I8:;9
:;9I8:;9<:;9'II':;9
:;9I:;9I>I:;9 (!(
":;9#
:;9I$
:;9I
8%'I&!I/'4:;9I?(4:;9I)4G:;9���
/usr/lib/gcc/x86_64-redhat-linux/8/include/usr/include/bits/usr/include/sys/usr/include/bits/types/usr/include./Include./Include/cpython./Include/internalPython/frozen_modulesPythonstddef.htypes.htypes.hstruct_FILE.hFILE.hstdio.hsys_errlist.herrno.hunistd.hgetopt_core.hstdint-uintn.hstdint.hpyport.hmath.htime.htime.hpytypedefs.hmethodobject.hdescrobject.hobject.hlongintrepr.hobject.hpystate.hpybuffer.hpyhash.hpydebug.hbytearrayobject.hbytearrayobject.hbytesobject.hunicodeobject.hunicodeobject.hpyerrors.hboolobject.hfloatobject.hcomplexobject.hrangeobject.hmemoryobject.hmemoryobject.htupleobject.hlistobject.hdictobject.hodictobject.henumobject.hsetobject.hsetobject.hmethodobject.hmoduleobject.hfuncobject.hclassobject.hfileobject.hfileobject.hpycapsule.hcode.hpyframe.htraceback.hsliceobject.hcellobject.hiterobject.hgenobject.hdescrobject.hgenericaliasobject.hweakrefobject.hstructseq.hpicklebufobject.hcodecs.hcontext.hpythonrun.hpythonrun.hpylifecycle.himport.hbltinmodule.hpyctype.hpycore_import.himportlib._bootstrap.h	importlib._bootstrap_external.h	zipimport.h	abc.h	codecs.h	io.h	_collections_abc.h	_sitebuiltins.h	genericpath.h	ntpath.h	posixpath.h	os.h	site.h	stat.h	importlib.util.h	importlib.machinery.h	runpy.h	__hello__.h	__phello__.h	__phello__.ham.h	__phello__.ham.eggs.h	__phello__.spam.h	frozen_only.h	frozen.c
hashsaltPyGen_TypePy_tracefunc_sys_errlist_unused2py_recursion_remaining_filenolenfuncPyExc_ModuleNotFoundErrorPyExc_KeyErrortp_getattrsq_itemnb_addPyGetSetDescr_TypePyExc_FileNotFoundErrorob_refcntPyTuple_Typesq_ass_itemPyBaseObject_TypePyExc_AssertionErrortracingsq_inplace_repeattp_as_async_PyAsyncGenWrappedValue_Typenb_matrix_multiplynb_lshift_PyImport_FrozenStdlibsq_inplace_concattp_is_gc_shortbufnb_poweram_anext_Py_M__abcPyCell_TypePyExc_IndentationErrorsq_repeat__environ_framesiphashPyExc_SyntaxWarningsq_concattp_itemsizePyExc_EOFErrorinitprocPyOS_ReadlineFunctionPointer_flagsPyOS_InputHooknextPyExc_IOErrorPyGetSetDef_Py_M__ostp_bases__off_tPyExc_TabError_PyStackChunkPyMethodDescr_Type_Py_M___collections_abcPy_OptimizeFlag_PyWeakref_ProxyType_lockPyFloat_Typecontext_versetattrofunctp_deallocexc_value_PyByteArray_empty_string_typeobjectnb_floor_dividenb_inplace_lshiftinternal_Py_M__frozen_onlydataPyExc_ConnectionRefusedErrorlv_tag_Py_M__runpyPyExc_ConnectionAbortedErrorPyExc_OSErroris_packagePy_NoUserSiteDirectory_PyImport_FrozenBootstrapaliasesPyLongObjectPyExc_ConnectionErrorPyExc_BrokenPipeErrorunboundnb_indextp_richcomparePyExc_StopIterationPyExc_ChildProcessError_IO_write_endPyThreadStatenb_remaindervisitprocPyMethod_Type_Py_TrueStructnb_inplace_multiply_inittabPy_VerboseFlag_frozenwas_sq_slice__tznamePyExc_EncodingWarningPyMemberDefPyImport_Inittabinterpob_typePyExc_PendingDeprecationWarningtp_freePyExc_RuntimeWarningPyMemoryView_TypePy_GenericAliasTypedatastack_topPyVarObjectbound_gilstate_PyManagedBuffer_Typenb_andPyExc_BlockingIOErroroptarg_err_stackitemPyExc_ProcessLookupErrortp_callasync_exc_Py_NoneStruct_PyNone_Typegilstate_counterclearedtype_Py_M__ntpathsys_errlisttp_strPyExc_Warningwas_sq_ass_slicePyExc_RuntimeErrordaylightternaryfuncPyExc_ArithmeticErrorob_basePyTypeObjectPyTraceBack_Typedelete_laterPyPickleBuffer_TypePyExc_BufferErrorPy_InspectFlag_PyInterpreterFramesq_containspadding_Py_M__site_chainboundtp_setattrPyCode_Typepy_recursion_limitrichcmpfuncunsigned charPyModuleDef_Typedjbx33aPyProperty_Typemp_ass_subscriptPyExc_IsADirectoryErrorPyDictRevIterItem_Typeinitialized_IO_lock_tPyExc_UnboundLocalErrorfloattp_dictoffsetPyExc_GeneratorExitPyNumberMethodsPyMethodDeftp_finalizetp_watchedPyClassMethodDescr_TypePyFrozenSet_Typemp_subscripttp_clearPy_QuietFlag_PyMethodWrapper_TypePyDictIterKey_Type_statusuint64_tPyExc_SystemExitPy_FileSystemDefaultEncodingPyList_Typedictfinalizingnb_boolprevious_PySet_DummyPyCapsule_Typetp_initobjobjargprocob_size_Py_M__zipimport_Py_M__genericpathtp_dict_IO_write_ptrtp_as_mappingsetattrfunc_py_trashcanPySlice_TypePyExc_NotImplementedErrorbinaryfuncPyMemberDescr_Type/usr/src/Python-3.12.7sizeFILEbf_getbuffervectorcallfuncgetiterfunc_PyCoroWrapper_Type_Py_ctype_tolowerssizeargfuncPyCMethod_Typeexc_statesize_tgetdate_errPy_UnbufferedStdioFlagdescrsetfuncPyWrapperDescr_Typedescrgetfunc_Py_HashSecret_tnb_inplace_addnb_reserved_Py_M__codecson_delete_IO_save_basePyExc_TimeoutErrorPYGEN_NEXTPy_Versiondatastack_chunkPyUnicode_TypeenvironreprfuncPyExc_UnicodeTranslateErrorPy_DebugFlagcode_wide_dataPyExc_BaseExceptionGroupPyFilter_TypePyStructSequence_UnnamedFieldPyExc_NameErrorsigngamPyDict_TypePy_hash_t__uint64_tPyObjectnb_xorPyExc_ResourceWarningcframenb_negativePyStdPrinter_TypePyImport_FrozenModules_PyAsyncGenASend_Type__ssize_t_longobjectam_sendPyDictIterItem_TypePyODictItems_TypePyODict_TypePyODictIter_Type__timezonePyDictProxy_TypePyCallIter_TypePyExc_TypeErrorPyBufferProcsml_flagstp_newPyClassMethod_Type_Py_M__importlib__bootstrapnb_inplace_true_divide_PyErr_StackItemdestructorPyCFunctionPyLongRangeIter_Typestderr_PyImport_FrozenAliasesPySet_Typename_Py_ascii_whitespaceprogram_invocation_short_nameget_codePyExc_UserWarning_IO_save_endPyContextVar_Typetp_delPyRange_TypePyInstanceMethod_TypePyEllipsis_Typestdouttp_nameoptoptclosureinitfuncPy_NoSiteFlagc_profilefunctp_as_sequencelong_valuetp_as_bufferitemsizenb_inplace_andrecursion_headroomdigitshort unsigned intsigned charasync_gen_firstiterwhat_eventPyModule_TypePyEnum_Typetp_allocsuboffsetsPYGEN_ERRORc_recursion_remaining__off64_torigPyCoro_Type_IO_read_basePyZip_Type_offsetfinalizedPyTupleIter_Type_IO_buf_enddelete_nesting_Py_M____phello__tp_getattroallocfunc_PyNotImplemented_Typec_traceobjopterr_modePyReversed_Typetp_methods_IO_write_basetp_mroPyExc_MemoryErrortz_dsttimePyExc_BaseException_Py_SwappedOpnative_thread_idPyExc_ImportErrorPyContext_TypePyContextToken_TypePyExc_FloatingPointErrorPyListIter_Type_Py_M__posixpathlong intnb_orformatunaryfunc_IO_markerPyByteArray_Type_Py_ctype_table_Py_M___sitebuiltinsnb_floatPyExc_SystemErrorPyDictValues_TypePyExc_ValueErrorPYGEN_RETURNtraverseproccontexttp_vectorcall_offsetinquiryuint32_tnb_invertGNU C11 8.5.0 20210514 (Red Hat 8.5.0-22) -mtune=generic -march=x86-64 -g -O3 -std=c11 -fno-strict-overflow -fno-semantic-interposition -fvisibility=hidden -fprofile-use -fprofile-correctionml_doc_IO_codecvtml_namePyExc_IndexErroruintptr_tPySeqIter_TypePyDictKeys_TypePyExc_Exceptiontp_as_numberPySendResultPyStaticMethod_TypePy_BytesWarningFlagPyAsyncMethodstp_weaklistoffsetlong unsigned intcurrent_framePyFrameObjectml_methreadonlytp_docgetattrofunc_PyCFramePyDictRevIterKey_TypePyListRevIter_TypecharPySequenceMethodsstdinon_delete_datatp_weaklist_IO_buf_basenewfuncPython/frozen.chashfuncgetattrfunc_IO_read_endPyExc_ReferenceError_IO_FILE_IO_wide_dataPyExc_NotADirectoryErrorstdlib_modulesPyExc_DeprecationWarningtznameshapetp_hash_Py_M__importlib_util_Py_M____phello___ham_eggsPyByteArrayIter_TypesuffixPyExc_UnicodeWarningndimssizeobjargprocPyMap_Typetp_vectorcallPyExc_RecursionErrortp_version_tagc_tracefunc__pad5getbufferprocroot_cframe_PyAnextAwaitable_TypePy_IsolatedFlag_markerssetterprevious_itemam_awaitPyExc_EnvironmentErrorsendfunc_codecvttp_memberstp_traversemp_lengthdouble_PyImport_FrozenTestam_aiternb_inplace_xorssize_ttp_subclassesnb_inplace_power_Py_HashSecrettp_setattroPyBool_Typefreefunc__uint32_tnb_multiply__daylightnb_true_dividePyComplex_Typetp_getsetPyLong_Typetp_iternextPyExc_BytesWarningPySetIter_Typesq_length_PyAsyncGenAThrow_Typeob_refcnt_splittp_descr_getPy_FrozenFlagtp_iternb_inplace_floor_divideprogram_invocation_name_Py_M__importlib__bootstrap_externalPyBytes_TypestridesPyExc_OverflowErrorexpatPyDictRevIterValue_TypePyDictItems_Typetp_basenb_rshiftdatastack_limit_freeres_bufexc_infoPy_hexdigitsbf_releasebufferPyExc_UnicodeErrorasync_gen_finalizerlong long unsigned intoffset_cur_columnreleasebufferprocPyDictIterValue_TypePyExc_ImportWarning_PyWeakref_CallableProxyTypetest_modulesnb_inplace_remainderthread_id_objectPy_HashRandomizationFlagnb_absolutePyExc_KeyboardInterrupt_IO_backup_base_IO_read_ptrcoroutine_origin_tracking_depthcurrent_exception_freeres_list_PyLongValuePy_FileSystemDefaultEncodeErrorsPy_DontWriteBytecodeFlagnb_inplace_or_sys_nerrtimezonetp_reprPyExc_AttributeErrortp_cachePyExc_LookupErrorPy_ssize_tPyBytesIter_TypePy_UTF8Mode_old_offsetnb_inplace_rshiftPy_HasFileSystemDefaultEncodingPyODictValues_TypePyUnicodeIter_Typec_profileobj_Py_NotImplementedStructoptindnb_positivePyFunction_Typelong long intPyExc_UnicodeDecodeErrortrash_flags2PyMappingMethods_PyWeakref_RefTypeprefixPyExc_SyntaxError_PyOS_ReadlineTStatePySuper_TypePyCFunction_Typetp_flagsPyExc_ZeroDivisionErrorPy_InteractiveFlag_Py_M____phello___ham_Py_M____hello__sys_nerrob_digitPyODictKeys_Typenb_subtractPyType_TypePyFrame_TypePyExc_ConnectionResetErrorPyExc_FileExistsError_Py_M____phello___spam_module_aliasPyExc_InterruptedError_Py_EllipsisObjectPyExc_StopAsyncIterationPyRangeIter_TypeiternextfuncPyExc_PermissionError_stack_chunkunsigned intgetterPyExc_UnicodeEncodeErrornb_int_Py_ctype_touppertp_descr_set_Py_M__ioPy_bufferactivePy_IgnoreEnvironmentFlagshort intPyExc_FutureWarningbootstrap_modulesprev_vtable_offsetnb_inplace_matrix_multiplytp_basicsizenb_inplace_subtract_Py_FalseStruct_Py_M__stat_Py_M__importlib_machinerynb_divmodflagstz_minuteswestobjobjprocPyAsyncGen_TypePyInterpreterStateGCC: (GNU) 8.5.0 20210514 (Red Hat 8.5.0-22)�
��� . �

@Wo��� 	H���J�@h%E�m`�`O�������J�
B��3�1=Qٲi��lh��`T��@�h����D&A@�+�K_���nk�@vG��`H�-��@D���7&=�T��Y�d,���`;^�frozen.caliasestest_modulesstdlib_modulesbootstrap_modulesPyImport_FrozenModules_PyImport_FrozenAliases_PyImport_FrozenTest_PyImport_FrozenStdlib_PyImport_FrozenBootstrap_Py_M____hello___Py_get___hello___toplevel_Py_M____phello___Py_get___phello___toplevel_Py_M____phello___ham_Py_get___phello___ham_toplevel_Py_M____phello___ham_eggs_Py_get___phello___ham_eggs_toplevel_Py_M____phello___spam_Py_get___phello___spam_toplevel_Py_M__frozen_only_Py_get_frozen_only_toplevel_Py_M__abc_Py_get_abc_toplevel_Py_M__codecs_Py_get_codecs_toplevel_Py_M__io_Py_get_io_toplevel_Py_M___collections_abc_Py_get__collections_abc_toplevel_Py_M___sitebuiltins_Py_get__sitebuiltins_toplevel_Py_M__genericpath_Py_get_genericpath_toplevel_Py_M__ntpath_Py_get_ntpath_toplevel_Py_M__posixpath_Py_get_posixpath_toplevel_Py_M__os_Py_get_os_toplevel_Py_M__site_Py_get_site_toplevel_Py_M__stat_Py_get_stat_toplevel_Py_M__importlib_util_Py_get_importlib_util_toplevel_Py_M__importlib_machinery_Py_get_importlib_machinery_toplevel_Py_M__runpy_Py_get_runpy_toplevel_Py_M__importlib__bootstrap_Py_get_importlib__bootstrap_toplevel_Py_M__importlib__bootstrap_external_Py_get_importlib__bootstrap_external_toplevel_Py_M__zipimport_Py_get_zipimport_toplevel�  'B `(h0r8�@�H�P�X�`�h�p�x��������r������� 
(8@�HX`hx�����$���8�� ���!�" H(#8$@LH%X&`Sh'x(�V�)�*�g�+�,�u�-�.���/�0h12 `(182@�H3X4`�h5x6���7�8���9�:���;�<���=�> (?8@@'HAXB`�hCxD

�
>
5

�,
k?
�F
�M
�_
�k
sw
��
��
f �
��
y
�
��
:�
�
�
��
��
��
t
�

c
U'
4
�
A
N
)[
�h
fu
��
��
��
0�
N�
��
�
�
� �
��
1
n
A
�+
:8
�E
�R
�_
.m
Qy
��
�
��
��
�
�
;�
�
$ 
�,
!8
�D
P
�c
�p
�|
��
��
 �
��
�	�
��
��
o
�
	�
k�
[
�
�
-!
F:
�F

R
^^
�j
iv
��
��
Q	�
Q	�
��
��
��
��
��
��
e*
'8
�D
�Q
e^
k
x
'!�
�
�
��
��
{�
�
��
c�
�
�
�
(
� 5
3B
]O
�\
�i
=v
0�
��
�
T�
�
�
��
��
0�
��
��
n
b
�
U,
�	9
�F
YS
�`
Lm
z
J�
6�
{�
�
�
��
% �
	�
q
�
�
�
�
� 
�.
-<
�J
�X
f
�t
��
]	�
t�
i	�
��
�
�
� �
��
��
�		
7	
T&	
$3	
�@	
M	
�Z	
�
g	
Ft	
��	
t�	
��	
(�	
��	
4
�	
��	
��	
��	
s�	
�

\



*

�7

�D

�Q

Dj

�w

?�

��

��

��

W!�

{�

�	
T
#
�0
0=

J
�i
< u
��
"�
��
�	
�
�
$
M0
@<
�H
	j
�
r�
��
V

�(

YT

y
�

<!�

)�

��

�
6
W]
�j
�
�
P�
��
N�
g�
r
�
%
�2
N?
6k
��
c�
��
��
D�
��
�
�
%
�,
C
�P
�]
j
w
!�
��
�
�
��
��
D
�
��
l�
��
~�
�

�
  
B-
T:
3G
� T
Pa
�n
�{
��
�
��
��
��
��
�
��
��
��
Y

� 
A	1
z>
)K
�X
�e
�r
�
E�
�
��
�
��
a�
�	�
��
��
87
D
�Q
�^
l
J�
V�
��
��
��
��
e
 
8Y
f
8�
�
�

�
��
L�
"	
�
�!
m-
�	9
�E
�Q
]
8i
6u
��
M �
v�
B�
��
��
��
�
#�
r�
#
�
�
a8
jE
{
��
}�
L
�
��
��
��
h�

�
��
�
L

L.
�R
�^
�
k
�x
��
��
7�
��
Y�
F �
9
�
	�
v.
Q:
�F

R
�^
�j
-	v
~�
��
�
��
��
?�
��
)�
��
^�
��
x
�
4
K
*
86
VB
�N
�
Z
f
�r
�~
p�
]�
�	�
��
	�
��
��
��
��
��
k
�
�
�&
�2
>
�J
V
 b
�n
[z
��
��
��
��
t�
!�
��
7�
��
��
��



p "
I.
?:
XF
�R
�
^
�j
Hw
��
��
H�
� �
A�
7�
'�
��
��
&

h
�&
�2
(
>
�J
�V
c
b
�n
oz
j�
�	�
4�
�
��
��
R�
@�
M�
��
.�
N

�
"
Z.
�	:
kF
U
R
Q^
j
�v
��
��
��
��
"�
3�
��

�
U�
.�

�
+
b
7
HC
�O
�[
rg
�
s

��
��
z�
��
	�
I�
~�
G!�
�
�
<�
�
�
:
t	F
�R
"^
�j
v
i�
��
�	�
+�
�
�
]�
-
�
��
��
��
� 
� 
{) 
/N 
W` 
�l 
dy 
e� 
/� 
�� 
|� 
e� 
�� 
L� 
7� 
�!
�
!

!
i*!
cK!
/l!
�x!
 �!
M�!
e�!
D�!
Y�!
v�!
r�!
B�!
�
"?)"
�6"AU"
�
b"C�"
��"#�"
N�"%�"
2 �"'#
�#)1#
?>#+]#
�
j#-�#
�#/�#
��#1�#
��#3
$
$$59$
� F$7e$
�r$9�$
!�$;�$
��$=�$
��$%
�"%@%
�M%k%
x%�%
6�%�%
��%!�%
� �% &
�%& C&
zP&�b&t&�&�&
s�&�&�&
.symtab.strtab.shstrtab.text.rela.data.bss.rodata.str1.1.rela.rodata.rela.debug_info.debug_abbrev.rela.debug_aranges.debug_line.debug_str.comment.note.GNU-stack@&@ !@��`,`12`�E@�. @@ ��	R�0�&M@�(;^�Wq�Y l@���Y��0�`j!�0�.�C�H�x	��� ��

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists