403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/traitlets/config/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/traitlets/config/__pycache__/loader.cpython-311.pyc
�

�Uc{���r�dZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
mZmZm
Z
mZmZmZddlmZmZGd�de��ZGd�d	e��ZGd
�de��ZGd�d
e��ZGd�d��Ze��ZGd�dej��Zd�ZGd�de��Zd�ZGd�de��Z Gd�d��Z!Gd�de"e!��Z#Gd�de$e!��Z%Gd�d��Z&Gd �d!e&��Z'Gd"�d#e'��Z(Gd$�d%e'��Z)Gd&�d'e&��Z*ej+d(��Z,d)Z-d*Z.Gd+�d,ej/��Z0Gd-�d.e��Z1Gd/�d0ej��Z2Gd1�d2e*��Z3Gd3�d4ej/��Z4Gd5�d6e3��Z5Gd7�d8e5��Z6d9�Z7dS):zA simple configuration system.�N)�Any�	Container�Dict�	HasTraits�List�	Undefined�)�cast_unicode�filefindc��eZdZdS)�ConfigErrorN��__name__�
__module__�__qualname__���9/usr/lib/python3/dist-packages/traitlets/config/loader.pyr
r
��������Drr
c��eZdZdS)�ConfigLoaderErrorNrrrrrrrrrc��eZdZdS)�ConfigFileNotFoundNrrrrrr rrrc��eZdZdS)�
ArgumentErrorNrrrrrr$rrrc��eZdZd�Zd�ZdS)�	_Sentinelc��dS)Nz<Sentinel deprecated>r��selfs r�__repr__z_Sentinel.__repr__4s��&�&rc��dS)Nz<deprecated>rrs r�__str__z_Sentinel.__str__7s���~rN)rrrr!r#rrrrr3s2������'�'�'�����rrc�P��eZdZdZd�fd�	Zejjje_�xZS)�ArgumentParserz?Simple argparse subclass that prints help to stdout by default.Nc�b��|�tj}t���|��S�N)�sys�stdout�super�
print_help)r �file�	__class__s  �rr+zArgumentParser.print_helpAs'����<��:�D��w�w�!�!�$�'�'�'rr')rrr�__doc__r+�argparser%�
__classcell__�r-s@rr%r%>sN�������I�I�(�(�(�(�(�(�
"�0�;�C�J�����rr%c��t|d��5}tt|���|d��||��ddd��dS#1swxYwYdS)N�rb�exec)�openr4�compile�read)�fname�glob�fs   r�execfiler;Ns���	
�e�T�	�	�;�a��W�Q�V�V�X�X�u�f�
-�
-�t�T�:�:�:�;�;�;�;�;�;�;�;�;�;�;�;����;�;�;�;�;�;s�3A�A�Ac��eZdZdZdZe��Ze��Ze��Zd�Z	d�Z
d�Zd�Zd�Z
e��Zd�Zd	�Zd
�Zd�Zd�ZdS)
�LazyConfigValueaProxy object for exposing methods on configurable containers

    These methods allow appending/extending/updating
    to add to non-empty defaults instead of clobbering them.

    Exposes:

    - append, extend, insert on lists
    - update on dicts
    - update, add on sets
    Nc�:�|j�|��dS)zAppend an item to a ListN)�_extend�append�r �objs  rr@zLazyConfigValue.appendgs������C� � � � � rc�:�|j�|��dS)z
Extend a listN)r?�extend�r �others  rrDzLazyConfigValue.extendks������E�"�"�"�"�"rc��||jdd�<dS)z#like list.extend, but for the frontNr)�_prependrEs  r�prependzLazyConfigValue.prependos��!��
�b�q�b���rc��t|t��r�|j�|j��|j|_|j�|j��|j�|j��|j|_|jr&|�|j��|j|_|S|�|��S)a�
        Merge with another earlier LazyConfigValue or an earlier container.
        This is useful when having global system-wide configuration files.

        Self is expected to have higher precedence.

        Parameters
        ----------
        other : LazyConfigValue or container

        Returns
        -------
        LazyConfigValue
            if ``other`` is also lazy, a reified container otherwise.
        )	�
isinstancer=r?rDrH�_inserts�_update�update�	get_valuerEs  r�
merge_intozLazyConfigValue.merge_intoss��� �e�_�-�-�	)��M� � ���.�.�.� �=�D�L��M� � ���0�0�0��N�!�!�$�-�0�0�0�!�N�D�M��|�
-����T�\�*�*�*�$�}����K��>�>�%�(�(�(rc��t|t��std���|j�||f��dS)NzAn integer is required)rK�int�	TypeErrorrLr@)r �indexrFs   r�insertzLazyConfigValue.insert�sC���%��%�%�	6��4�5�5�5��
���e�U�^�,�,�,�,�,rc��|j�0t|t��ri|_nt��|_|j�|��dS)zUpdate either a set or dictN)rMrK�dict�setrNrEs  rrNzLazyConfigValue.update�sL���<���%��&�&�
%�!����"�u�u�������E�"�"�"�"�"rc�2�|�|h��dS)zAdd an item to a setN)rNrAs  r�addzLazyConfigValue.add�s�����S�E�����rc���|j�|jStj|��}t|t��rJ|jD]\}}|�||���|j|dd�<|�|j	��nmt|t��r"|jr|�|j��n6t|t��r!|jr|�|j��||_|S)znconstruct the value from the initial one

        after applying any insert / extend / update changes
        Nr)�_value�copy�deepcopyrK�listrLrUrHrDr?rWrMrNrX)r �initial�value�idxrBs     rrOzLazyConfigValue.get_value�s���
�;�"��;���
�g�&�&���e�T�"�"�	+� �M�
'�
'���S����S�#�&�&�&�&��
�E�"�1�"�I��L�L���&�&�&�&�
��t�
$�
$�	+��|�
+����T�\�*�*�*��
��s�
#�
#�	+��|�
+����T�\�*�*�*�����rc��i}|jr
|j|d<|jr
|j|d<|jr|j|d<n|jr
|j|d<|S)z�return JSONable dict form of my data

        Currently update as dict or set, extend, prepend as lists, and inserts as list of tuples.
        rNrDrI�inserts)rMr?rHrL)r �ds  r�to_dictzLazyConfigValue.to_dict�sd��

���<�	'��,�A�h�K��<�	'��,�A�h�K��=�	)��=�A�i�L�L�
�]�	)��=�A�i�L��rc��|j�d|jj�d|j�d�Sd|jj�d|����d�S)N�<z value=�>� )r\r-rrfrs rr!zLazyConfigValue.__repr__�sP���;�"�G�t�~�.�G�G�t�{�G�G�G�G�D�t�~�.�D�D������D�D�D�Dr)rrrr.r\rr?rHrLr@rDrIrPrUrrMrNrZrOrfr!rrrr=r=Ss�������
�
��F��d�f�f�G��t�v�v�H��t�v�v�H�!�!�!�#�#�#�"�"�"�)�)�)�B-�-�-��c�e�e�G�#�#�#�������.��� E�E�E�E�Err=c��|r;|d���|dkr|�d��sdSdS)z>Is a Config key a section name (does it start with a capital)?r�_TF)�upper�
startswith)�keys r�_is_section_keyrp�s?��
��s�1�v�|�|�~�~��Q��'�'����s�0C�0C�'��t��urc���eZdZdZd�Zd�Zd�Zd�Zdddej	e
ejffd�Z�fd	�Z
e
Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Z�xZS)�Configa�An attribute-based dict that can do smart merges.

    Accessing a field on a config object for the first time populates the key
    with either a nested Config object for keys starting with capitals
    or :class:`.LazyConfigValue` for lowercase keys,
    allowing quick assignments such as::

        c = Config()
        c.Class.int_trait = 5
        c.Class.list_trait.append("x")

    c�X�tj|g|�Ri|��|���dSr')rW�__init__�_ensure_subconfig)r �args�kwdss   rrtzConfig.__init__�s:���
�d�*�T�*�*�*�T�*�*�*���� � � � � rc���|D]a}||}t|��rHt|t��r3t|t��st	||t|�����bdS)z�ensure that sub-dicts that should be Config objects are

        casts dicts that are under section keys to Config objects,
        which is necessary for constructing Config objects from dict literals.
        N)rprKrWrr�setattr)r rorBs   rruzConfig._ensure_subconfig�ss���	0�	0�C��s�)�C��s�#�#�
0�
�3��(=�(=�
0�j�QT�V\�F]�F]�
0���c�6�#�;�;�/�/�/��	0�	0rc�0�|�|��dS)z$deprecated alias, use Config.merge()N)�mergerEs  r�_mergez
Config._merge�s���
�
�5�����rc��i}|���D]�\}}||vr|||<�t|t��r7t||t��r||�|���[t|t��r|�||��||<��|||<��|�|��dS)z)merge another config object into this oneN)�itemsrKrrr{r=rPrN)r rF�	to_update�k�vs     rr{zConfig.merges����	��K�K�M�M�	%�	%�D�A�q���}�}� �	�!����a��(�(�%�Z��Q���-H�-H�%���G�M�M�!�$�$�$�$���?�3�3�%��l�l�4��7�3�3�D��G�G�$%�I�a�L�L����I�����rrF�returnc���i}|D]d}||vr�||}||}|D]J}||vrD||||kr2|�|i��||�d||��|||<�K�e|S)z�Check for collisions between two config objects.

        Returns a dict of the form {"Class": {"trait": "collision message"}}`,
        indicating which values have been ignored.

        An empty dict indicates no collisions.
        z ignored, using )�
setdefault)r rF�
collisions�section�mine�theirsros       rr�zConfig.collisionss���*,�
��	_�	_�G��e�#�#����=�D��7�^�F��
_�
_���&�=�=�T�#�Y�&��+�%=�%=��)�)�'�2�6�6�6�26�s�)�/^�/^�v�VY�{�/^�/^�J�w�'��,��
_��rc���d|vr)|�dd��\}}||vrdS|||vSt���|��S)N�.�F)�splitr*�__contains__)r ro�first�	remainderr-s    �rr�zConfig.__contains__(s[����#�:�:�"�y�y��a�0�0��E�9��D� � ��u���U��+�+��w�w�#�#�C�(�(�(rc�(�t|��o||vSr')rp�r ros  r�_has_sectionzConfig._has_section5s���s�#�#�3��t��3rc�b�t|��t�|����Sr')�typerWr]rs rr]zConfig.copy8s"���t�D�z�z�$�)�)�D�/�/�*�*�*rc�*�|���Sr')r]rs r�__copy__zConfig.__copy__;s���y�y�{�{�rc�P�t|����}|���D]y\}}t|ttf��rtj||��}n=t|��tttthvrtj|��}|||<�z|Sr')r�r~rKrrr=r]r^rWr_rX�tuple)r �memo�
new_configroras     r�__deepcopy__zConfig.__deepcopy__>s����T�$�Z�Z�\�\�
��*�*�,�,�	$�	$�J�C���%�&�/�!:�;�;�
)��
�e�T�2�2����e����t�S�%� 8�8�8��	�%�(�(��#�J�s�O�O��rc�d�	t�||��S#t$r�t|��r.t	��}t�|||��|cYS|�d��s.t��}t�|||��|cYSt�wxYw)Nrl)rW�__getitem__�KeyErrorrprr�__setitem__rnr=)r ro�cr�s    rr�zConfig.__getitem__Js���
	��#�#�D�#�.�.�.���	�	�	��s�#�#�

��H�H��� � ��s�A�.�.�.������^�^�C�(�(�
�#�%�%��� � ��s�A�.�.�.�������	���s��AB/�$AB/�'B/c��t|��r*t|t��std|�d|�����t�|||��dS)NzIvalues whose keys begin with an uppercase char must be Config instances: �, )rprKrr�
ValueErrorrWr�)r roras   rr�zConfig.__setitem__Zsi���3���	��e�V�,�,�
� �j�?B�s�s�E�E�K����	
����s�E�*�*�*�*�*rc���|�d��rt�||��S	|�|��S#t$r}t|���d}~wwxYw�N�__)rnrW�__getattr__r�r��AttributeError�r ro�es   rr�zConfig.__getattr__csr���>�>�$���	/��#�#�D�#�.�.�.�	$��#�#�C�(�(�(���	$�	$�	$� ��#�#�#�����	$���s�A�
A%�A � A%c���|�d��rt�|||��S	|�||��dS#t$r}t|���d}~wwxYwr�)rnrW�__setattr__r�r�r�)r rorar�s    rr�zConfig.__setattr__ks|���>�>�$���	6��#�#�D�#�u�5�5�5�	$����S�%�(�(�(�(�(���	$�	$�	$� ��#�#�#�����	$���s�A�
A)�A$�$A)c���|�d��rt�||��S	t�||��dS#t$r}t|���d}~wwxYwr�)rnrW�__delattr__�__delitem__r�r�r�s   rr�zConfig.__delattr__ssz���>�>�$���	/��#�#�D�#�.�.�.�	$����T�3�'�'�'�'�'���	$�	$�	$� ��#�#�#�����	$���s�A�
A-�A(�(A-)rrrr.rtrur|r{�tr�strrr�r��has_keyr�r]r�r�r�r�r�r�r�r0r1s@rrrrr�s;���������!�!�!�	0�	0�	0�������$���Q�V�C���J�-?�����()�)�)�)�)��G�4�4�4�+�+�+����
�
�
���� +�+�+�$�$�$�$�$�$�$�$�$�$�$�$�$rrrc�*��eZdZdZ	d�Z�fd�Z�xZS)�DeferredConfigz0Class for deferred-evaluation of config from CLIc� �td���)NzImplement in subclasses��NotImplementedError)r �traits  rrOzDeferredConfig.get_value�s��!�";�<�<�<rc�R��t|j|�����Sr')r*r-r!)r r-s �r�_super_reprzDeferredConfig._super_repr�s!����T�^�T�*�*�3�3�5�5�5r)rrrr.rOr�r0r1s@rr�r�|sP�������:�:��=�=�=�6�6�6�6�6�6�6�6�6rr�c��eZdZdZd�Zd�ZdS)�DeferredConfigStringa�Config value for loading config from a string

    Interpretation is deferred until it is loaded into the trait.

    Subclass of str for backward compatibility.

    This class is only used for values that are not listed
    in the configurable classes.

    When config is loaded, `trait.from_string` will be used.

    If an error is raised in `.from_string`,
    the original string is returned.

    .. versionadded:: 5.0
    c�p�t|��}	|�|��S#t$r|cYSwxYw)�#Get the value stored in this string)r��from_string�	Exception)r r��ss   rrOzDeferredConfigString.get_value�sL����I�I��	��$�$�Q�'�'�'���	�	�	��H�H�H�		���s�&�5�5c�J�|jj�d|����d�S�N�(�)�r-rr�rs rr!zDeferredConfigString.__repr__��*���.�)�A�A�D�,<�,<�,>�,>�A�A�A�ArN�rrrr.rOr!rrrr�r��sA��������"	�	�	�B�B�B�B�Brr�c��eZdZdZd�Zd�ZdS)�DeferredConfigLista�Config value for loading config from a list of strings

    Interpretation is deferred until it is loaded into the trait.

    This class is only used for values that are not listed
    in the configurable classes.

    When config is loaded, `trait.from_string_list` will be used.

    If an error is raised in `.from_string_list`,
    the original string list is returned.

    .. versionadded:: 5.0
    c	�<�t|d��rt|��}|j}nXt|��dkr6t	|j�dt|���dt|�������|d}|j}	||��S#t$r|cYSwxYw)r��from_string_listr�z only accepts one value, got z: r)�hasattrr_r��lenr��namer�r�)r r��src�casts    rrOzDeferredConfigList.get_value�s����5�,�-�-�
	%��t�*�*�C��)�D�D��4�y�y�1�}�}� ��z�Y�Y��D�	�	�Y�Y�T�RV�Z�Z�Y�Y�����q�'�C��$�D�	��4��9�9����	�	�	��J�J�J�		���s�
B�B�Bc�J�|jj�d|����d�Sr�r�rs rr!zDeferredConfigList.__repr__�r�rNr�rrrr�r��sA������
�
����,B�B�B�B�Brr�c�,�eZdZdZd�Zdd�Zd�Zd�ZdS)�ConfigLoadera1A object for loading configurations from just about anywhere.

    The resulting configuration is packaged as a :class:`Config`.

    Notes
    -----
    A :class:`ConfigLoader` does one thing: load a config from a source
    (file, command line arguments) and returns the data as a :class:`Config` object.
    There are lots of things that :class:`ConfigLoader` does not do.  It does
    not implement complex logic for finding config files.  It does not handle
    default values or merge multiple configs.  These things need to be
    handled elsewhere.
    c�"�ddlm}|��S)Nr)�
get_logger)�
traitlets.logr�)r r�s  r�_log_defaultzConfigLoader._log_default�s ��,�,�,�,�,�,��z�|�|�rNc��|���|�5|���|_|j�d��dS||_dS)aeA base class for config loaders.

        log : instance of :class:`logging.Logger` to use.
              By default logger of :meth:`traitlets.config.application.Application.instance()`
              will be used

        Examples
        --------
        >>> cl = ConfigLoader()
        >>> config = cl.load_config()
        >>> config
        {}
        NzUsing default logger)�clearr��log�debug)r r�s  rrtzConfigLoader.__init__�sO��	
�
�
�����;��(�(�*�*�D�H��H�N�N�1�2�2�2�2�2��D�H�H�Hrc�,�t��|_dSr')rr�configrs rr�zConfigLoader.clears���h�h����rc�8�|���|jS)aLoad a config from somewhere, return a :class:`Config` instance.

        Usually, this will cause self.config to be set and then returned.
        However, in most cases, :meth:`ConfigLoader.clear` should be called
        to erase any previous state.
        )r�r�rs r�load_configzConfigLoader.load_configs��	
�
�
�����{�rr')rrrr.r�rtr�r�rrrr�r��s_�����������
����*�������rr�c�*��eZdZdZd�fd�	Zd�Z�xZS)�FileConfigLoaderz�A base class for file based configurations.

    As we add more file based config loaders, the common logic should go
    here.
    Nc�d��t��jdi|��||_||_d|_dS)a.Build a config loader for a filename and path.

        Parameters
        ----------
        filename : str
            The file name of the config file.
        path : str, list, tuple
            The path to search for the config file on, or a sequence of
            paths to try in order.
        �Nr)r*rt�filename�path�
full_filename)r r�r��kwr-s    �rrtzFileConfigLoader.__init__s>���	�������2���� ��
���	�����rc�D�t|j|j��|_dS)z,Try to find the file by searching the paths.N)rr�r�r�rs r�
_find_filezFileConfigLoader._find_file's��%�d�m�T�Y�?�?����rr')rrrr.rtr�r0r1s@rr�r�s]��������� � � � � � � @�@�@�@�@�@�@rr�c�0�eZdZdZd�Zd�Zd�Zd�Zd�ZdS)�JSONFileConfigLoaderaA JSON file loader for config

    Can also act as a context manager that rewrite the configuration file to disk on exit.

    Example::

        with JSONFileConfigLoader('myapp.json','/home/jupyter/configurations/') as c:
            c.MyNewConfigurable.new_value = 'Updated'

    c��|���	|���n.#t$r!}tt	|�����d}~wwxYw|���}|�|��|_|jS�z=Load the config from a file and return it as a Config object.N)r�r��OSErrorrr��_read_file_as_dict�_convert_to_configr�)r r��dcts   rr�z JSONFileConfigLoader.load_config8s����
�
����	-��O�O�������	-�	-�	-�$�S��V�V�,�,�,�����	-�����%�%�'�'���-�-�c�2�2����{���+�
A�A�Ac��t|j��5}tj|��cddd��S#1swxYwYdSr')r5r��json�load)r r:s  rr�z'JSONFileConfigLoader._read_file_as_dictCs��
�$�$�
%�
%�	 ���9�Q�<�<�	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 �	 ����	 �	 �	 �	 �	 �	 s�6�:�:c��d|vr|�d��}nd}|dkrt|��Std|�����)N�versionr�z%Unknown version of JSON config file: )�poprrr�)r �
dictionaryr�s   rr�z'JSONFileConfigLoader._convert_to_configGsS���
�"�"� �n�n�Y�/�/�G�G��G��a�<�<��*�%�%�%��N�W�N�N�O�O�Orc�8�|���|jSr')r�r�rs r�	__enter__zJSONFileConfigLoader.__enter__Rs���������{�rc���d|j_tj|jd���}t	|jd��5}|�|��ddd��dS#1swxYwYdS)z�
        Exit the context manager but do not handle any errors.

        In case of any error, we do not want to write the potentially broken
        configuration to disk.
        r�r	)�indent�wN)r�r�r��dumpsr5r��write)r �exc_type�	exc_value�	traceback�json_configr:s      r�__exit__zJSONFileConfigLoader.__exit__Vs��� �����j���Q�7�7�7��
�$�$�c�
*�
*�	!�a�
�G�G�K� � � �	!�	!�	!�	!�	!�	!�	!�	!�	!�	!�	!�	!����	!�	!�	!�	!�	!�	!s�A � A$�'A$N)	rrrr.r�r�r�r�rrrrr�r�,sl������	�	�	�	�	� � � �	P�	P�	P����
!�
!�
!�
!�
!rr�c�&�eZdZdZd�Zdd�Zd�ZdS)�PyFileConfigLoaderz�A config loader for pure python files.

    This is responsible for locating a Python config file by filename and
    path, then executing it to construct a Config object.
    c���|���	|���n.#t$r!}tt	|�����d}~wwxYw|���|jSr�)r�r�r�rr�r�r�)r r�s  rr�zPyFileConfigLoader.load_configjst���
�
����	-��O�O�������	-�	-�	-�$�S��V�V�,�,�,�����	-�������!�!�!��{�r�Nc���|�|j}|�||��}	|���}|j�|��dS#t
$rYdSwxYw)z5Injected into config file namespace as load_subconfigN)r�r-r�r�r{r)r r8r��loader�
sub_configs     r�load_subconfigz!PyFileConfigLoader.load_subconfigts{���<��9�D�����t�,�,��	*��+�+�-�-�J�
�K���j�)�)�)�)�)��"�	�	�	�
�D�D�	���s�A�
A�Ac����fd�}t�j�j|�j���}�j}t	|d��5}tt
|���|d��||��ddd��dS#1swxYwYdS)z>Load the config file into self.config, with recursive loading.c����jS)zKUnnecessary now, but a deprecation warning is more trouble than it's worth.�r�rs�r�
get_configz9PyFileConfigLoader._read_file_as_dict.<locals>.get_config�s����;�r)r�r
r�__file__r3r4N)rWr�r
r�r5r4r6r7)r r�	namespace�
conf_filenamer:s`    rr�z%PyFileConfigLoader._read_file_as_dict�s����	�	�	�	�	���k��.�!��'�	
�
�
�	��*�
�
�-��
&�
&�	Q�!��������=�&�9�9�9�i�P�P�P�	Q�	Q�	Q�	Q�	Q�	Q�	Q�	Q�	Q�	Q�	Q�	Q����	Q�	Q�	Q�	Q�	Q�	Qs�3B�B�Br')rrrr.r�r
r�rrrrrcsU�����������
*�
*�
*�
*�Q�Q�Q�Q�Qrrc� �eZdZdZdd�Zd�ZdS)�CommandLineConfigLoaderz�A config loader for command line arguments.

    As we add more command line based loaders, the common logic should go
    here.
    Nc���|}t|t��rs|r|�|��}n�t|t��rEt	|��dkr2ttj�|d����}n'|r|�	|��}nt|��}|�
d���^}}|j}|D]
}||}�|||<dS)z�execute self.config.<lhs> = <rhs>

        * expands ~ with expanduser
        * interprets value with trait if available
        r�rr�N)rKr�rOr�r�r��osr��
expanduserr�r�r�)	r �lhs�rhsr�rar�ror��parts	         r�_exec_config_strz(CommandLineConfigLoader._exec_config_str�s������e�^�,�,�	4��
I�����.�.����C�!3�4�4�
I��S���Q���,�R�W�-?�-?��A��-G�-G�H�H����
4��)�)�%�0�0���,�U�3�3���Y�Y�s�^�^�
��s��+���	$�	$�D��d�m�G�G������rc���t|ttf��r<|���D]%\}}|j|�|���&dSt
d|z���)z=update self.config from a flag, which can be a dict or ConfigzInvalid flag: %rN)rKrWrrr~r�rNrS)r �cfg�secr�s    r�
_load_flagz"CommandLineConfigLoader._load_flag�ss���c�D�&�>�*�*�	6��)�)�+�+�
+�
+���Q���C� �'�'��*�*�*�*�
+�
+��.��4�5�5�5rr')rrrr.rr!rrrrr�sA������������66�6�6�6�6rrz^\-?\-[A-Za-z][\w]*(\.[\w]+)*$�__DOT__�__DASH__c��eZdZdZdd�ZdS)�	_KVActionzDCustom argparse action for handling --Class.trait=x

    Always
    Nc��t|t��r|g}d�|D��}t||jd��}|�t	��}nt	|��}|�|��t
||j|��dS)Nc�(�g|]}|turdn|��S��-��_DASH_REPLACEMENT)�.0r�s  r�
<listcomp>z&_KVAction.__call__.<locals>.<listcomp>�s'��G�G�G�1��/�/�/�#�#�Q�G�G�Gr)rKr��getattr�destr�rDry)r �parserr�values�
option_stringr~s      r�__call__z_KVAction.__call__�s����f�c�"�"�	��X�F�G�G��G�G�G���	�4�9�d�3�3���=�&�(�(�E�E�&�u�-�-�E�
���V�����	�4�9�e�,�,�,�,�,rr')rrrr.r3rrrr%r%�s2��������

-�
-�
-�
-�
-�
-rr%c�:��eZdZdZd�Z�fd�Z�fd�Zdd�Z�xZS)�_DefaultOptionDictz_Like the default options dict

    but acts as if all --Class.trait options are predefined
    c��t|g|�d���dt��|�d�����||<dS)Nr)r�)�option_stringsr/�metavar)r%�lstrip�replace�_DOT_REPLACEMENTr�s  r�_add_kv_actionz!_DefaultOptionDict._add_kv_action�sN����5����C���(�(��.>�?�?��J�J�s�O�O�	
�
�
��S�	�	�	rc����d|vrdSt���|��rdS|�d��r1t�|��r|�|��dSdS)N�=FTr))r*r�rn�class_trait_opt_pattern�matchr<�r ror-s  �rr�z_DefaultOptionDict.__contains__�sx����#�:�:��5��7�7����$�$�	��4��>�>�#���	�#:�#@�#@��#E�#E�	�����$�$�$��4��urc�l��||vr!t���|��St|���r')r*r�r�rAs  �rr�z_DefaultOptionDict.__getitem__�s0����$�;�;��7�7�&�&�s�+�+�+��3�-�-�rNc�8�	||S#t$r|cYSwxYwr')r�)r ro�defaults   r�getz_DefaultOptionDict.gets5��	���9����	�	�	��N�N�N�	���s�
��r')	rrrr.r<r�r�rEr0r1s@rr5r5�s~���������

�
�
�	�	�	�	�	� � � � � ��������rr5c�$��eZdZdZd�fd�	Z�xZS)�_KVArgParserzOsubclass of ArgumentParser where any --Class.trait option is implicitly definedNc���||jfD]}t|j��|_�t���||��Sr')�
_optionalsr5�_option_string_actionsr*�parse_known_args)r rvr�	containerr-s    �rrKz_KVArgParser.parse_known_args
sM������0�	d�	d�I�/A�)�Bb�/c�/c�I�,�,��w�w�'�'��i�8�8�8r)NN)rrrr.rKr0r1s@rrGrGsC�������Y�Y�9�9�9�9�9�9�9�9�9�9rrGc���eZdZdZeZejeej	edffZ
					ddejejedejej
e
efdejej
e
efdejdejejejejd	ejd
ejddf�fd�
Zddedfd
�Zd�Zd�Zd�Zd�Zd�Z�xZS)�ArgParseConfigLoaderzEA loader that uses the argparse module to load from the command line..N�argv�aliases�flagsr��classes�parser_args�	parser_kwr�c���|pg}tt|���|���|���|�tjdd�}||_|pi|_|pi|_||_||_	|�
dd��|_ttj���}|�|��||_dS)a>Create a config loader for use with argparse.

        Parameters
        ----------
        classes : optional, list
            The classes to scan for *container* config-traits and decide
            for their "multiplicity" when adding them as *argparse* arguments.
        argv : optional, list
            If given, used to read command-line arguments from, otherwise
            sys.argv[1:] is used.
        *parser_args : tuple
            A tuple of positional arguments that will be passed to the
            constructor of :class:`argparse.ArgumentParser`.
        **parser_kw : dict
            A tuple of keyword arguments that will be passed to the
            constructor of :class:`argparse.ArgumentParser`.
        aliases : dict of str to str
            Dict of aliases to full traitlets names for CLI parsing
        flags : dict of str to str
            Dict of flags to full traitlets names for CLI parsing
        log
            Passed to `ConfigLoader`

        Returns
        -------
        config : Config
            The resulting Config object.
        )r�Nr�r�)�argument_default)r*rrtr�r(rOrPrQrRrSr�r�rWr/�SUPPRESSrNrT)
r rOrPrQr�rRrSrT�kwargsr-s
         �rrtzArgParseConfigLoader.__init__s����L�-�R��
�%�t�,�,�5�5�#�5�>�>�>��
�
�����<��8�A�B�B�<�D���	��}�"����[�b��
����&��� �}�}�Y��5�5����x�'8�9�9�9���
�
�i� � � �����rc�T�|tur-tjdt|���d�td���|���|�|j}|�||_|�||_|�	��|�
|��|���|jS)a�Parse command line arguments and return as a Config object.

        Parameters
        ----------
        argv : optional, list
            If given, a list with the structure of sys.argv[1:] to parse
            arguments from. If not given, the instance's self.argv attribute
            (given at construction time) is used.
        flags
            Deprecated in traitlets 5.0, instanciate the config loader with the flags.

        zjThe `flag` argument to load_config is deprecated since Traitlets 5.0 and will be ignored, pass flags the `z` constructor.r	��
stacklevel)
�_deprecated�warnings�warnr��DeprecationWarningr�rOrPrR�_create_parser�_parse_argsr�r�)r rOrPrQrRs     rr�z ArgParseConfigLoader.load_configNs�����#�#��M�W�<@��J�J�W�W�W�"��	
�
�
�
�	
�
�
�����<��9�D���"�D�L���"�D�L�����������������!�!�!��{�rc�4�t|d��r|jSgS)N�
extra_args)r�rcrs r�get_extra_argsz#ArgParseConfigLoader.get_extra_argsps!���4��&�&�	��?�"��Irc��|j|ji|j��|_|�|j|j|j��dSr')�parser_classrSrTr0�_add_argumentsrPrQrRrs rr`z#ArgParseConfigLoader._create_parservsN��'�d�'�
�
�
�!%��
�
���	
���D�L�$�*�d�l�C�C�C�C�Crc� �td���)Nz(subclasses must implement _add_argumentsr�)r rPrQrRs    rrgz#ArgParseConfigLoader._add_arguments|s��!�"L�M�M�Mrc���	�
�d�|D��}i�
|jrqi�
|j���D]U\}}||jvr�t|t��s|f}|D]+}t|��dkrd|z�
d|z<d|z�
d|z<�,�V�
fd��	d|vr-|�d��}||dzd�}|d|�}ng}|}�	fd�|D��}|j�|��|_	||_
dS)zself.parser->self.parsed_datac�,�g|]}t|����Sr)r
�r,�as  rr-z4ArgParseConfigLoader._parse_args.<locals>.<listcomp>�s��/�/�/�Q��a���/�/�/rr��--r)c����|dkrtS����D]I\}}||kr|cS|�|dz��r"|dz|t|��dzd�zcS�J|S)Nr)r>r�)r+r~rnr�)�argr�r��unpacked_aliasess   �r�_replacez2ArgParseConfigLoader._parse_args.<locals>._replace�s�����c�z�z�(�(�(�.�.�0�0�
7�
7���1��!�8�8��H�H�H��>�>�!�c�'�*�*�7��s�7�S��Q���!����%6�6�6�6�6�7��JrNc�&��g|]
}�|����Srr)r,rlrqs  �rr-z4ArgParseConfigLoader._parse_args.<locals>.<listcomp>�s!���2�2�2�A�H�H�Q�K�K�2�2�2r)rPr~rQrKr�r�rTr0�
parse_args�parsed_datarc)r rv�uargs�alias�alias_target�alrbrc�to_parserqrps         @@rraz ArgParseConfigLoader._parse_argssh����/�/�$�/�/�/��-/���<�
	F�!��'+�|�'9�'9�';�';�
F�
F�#��|��D�J�&�&��!�%��/�/�%�"�H�E��F�F�B��2�w�w�!�|�|�59�L�5H�(��r��2�26��2E�$�T�B�Y�/�/�F�
	�	�	�	�	��5�=�=��+�+�d�#�#�C��s�Q�w�y�y�)�J��T�c�T�{�H�H��J��H�2�2�2�2��2�2�2���;�1�1�(�;�;���$����rc���t|j�����D]B\}}|�d���^}}|j}|D]
}||}�t|||���CdS)zself.parsed_data->self.configr�N)�varsrtr~r�r�ry)r r�r�r�ror��ps       rr�z'ArgParseConfigLoader._convert_to_config�s����)�*�*�0�0�2�2�	%�	%�D�A�q�������J�T�3��k�G��
%�
%��!�!�*����G�S�!�$�$�$�$�	%�	%r)NNNNN)rrrr.r%rfr��Unionr��Tuple�Flags�Optionalrrr�Typertr\r�rdr`rgrar�r0r1s@rrNrNs��������O�O�!�L�
�G�C����c��*�*�+�E�)-�26�04��59�
4 �4 ��j�����%�4 ���A�F�5�#�:�.�/�4 ��z�!�&����,�-�	4 �
�U�4 ���A�F�1�6�!�%�=�1�2�
4 ��e�4 ��U�4 �
�4 �4 �4 �4 �4 �4 �l $�T��d� � � � �D���D�D�D�N�N�N�%%�%%�%%�N%�%�%�%�%�%�%rrNc�*��eZdZdZ�fd�Zdd�Z�xZS)�_FlagActionz ArgParse action to handle a flagc����|�d��|_|�dd��|_t|d<|jsd|d<t	��j|i|��dS)N�flagrv�constr�nargs)r�r�rvrr*rt�r rvrXr-s   �rrtz_FlagAction.__init__�si����J�J�v�&�&��	��Z�Z���.�.��
�#��w���z�	 ��F�7�O������$�)�&�)�)�)�)�)rNc���|jdks	|tur8t|d��sg|_|j�|j��dSt
||j|��dS)Nr�_flags)r�rr�r�r@r�ryrv)r r0rr1r2s     rr3z_FlagAction.__call__�sj���:��?�?�f�	�1�1��9�h�/�/�
&�#%�	� ���#�#�D�I�.�.�.�.�.��I�t�z�6�2�2�2�2�2rr')rrrr.rtr3r0r1s@rr�r��sR�������*�*�*�*�*�*�*�3�3�3�3�3�3�3�3rr�c�"�eZdZdZeZd�Zd�ZdS)�KVArgParseConfigLoaderznA config loader that loads aliases and flags with argparse,

    as well as arbitrary --Class.trait value
    c	��i}|jj}|j�g���|dd���ix|_}|D]�}|�d������D]i\}}	|j�d|��}
dti}t|	ttf��r,|	j�d	d
��}|d
kr||d<n||d<|	|f||
<�j��|���D]f\}
\}}t|
t��s|
f}
|
D]C}||vr||||<�t|��d
kr
d|zd|zfnd|zf}
||
t|d���D�g|���D]�\}
}t|
t��s|
f}
|
D]�}t|�dt"��|d�}||vr?|�||d
��d|vr||vrt'd|�d|�d����||vr0|�dd��t|d<|||d<||d<t|��d
kr
d|zd|zfnd|zf}
||
i|���Ɍ�dS)N)r�rc�*)r�Trr�r��multiplicityr@�actionr�r�r)rm)r�r�)r�r/r8zThe alias `z*` for the 'append' sequence config-trait `z` cannot be also a flag!'�?r�rv)r0�add_argument�set_defaults�argparse_traits�class_traitsr~rr�rKrr�metadatarEr�r�r�r:r;rNrr�)r rPrQrR�alias_flags�paar��cls�	traitnamer��argname�
argparse_kwdsr��keysrarlros                 rrgz%KVArgParseConfigLoader._add_arguments�s7��*,���k�&���� � �� �+�+�+���L��$�$�$�$�24�3�����
	B�
	B�C�$'�$4�$4�D�$4�$A�$A�$G�$G�$I�$I�	
B�	
B� �	�5� �\�7�7�I�7�7��!'��
�
��e�i��%6�7�7�>�#(�>�#5�#5�n�h�#O�#O�L�#�x�/�/�2>�
�h�/�/�1=�
�g�.�,1�=�+A���(�(�	
B�!&���
�
�	;�	;��D�*�5�!��d�E�*�*�
��w���
;�
;���'�>�>�05�K����-��25�c�(�(�a�-�-��c�	�4�#�:�.�.�d�S�j�]����T�+�E�:�:�:�:�:�
;� '�}�}���	,�	,�O�D�)��d�E�*�*�
��w���
,�
,���%�-�-�c�3C�D�D�(�!�!�
�
��/�/�!�(�(���)C�A�)F�G�G�G��=�0�0�Y�+�5M�5M�,�m�KN�3�3�PY�PY�PY�[������+�+�"�,�,�W�c�:�:�:�.9�M�(�+�,7�	�,B�M�&�)�-6�M�'�*�25�c�(�(�a�-�-��c�	�4�#�:�.�.�d�S�j�]����T�+�]�+�+�+�+�1
,�		,�	,rc
�"�|j}t|j�����D�];\}}|dkrd�|D��|z|_�!|dkr�(|�t
d��}d|vr|j�d|��d}t|t��rt|��}n$t|t��rt|��}|j
�|��}|r|d}	|�|||����#t $rF}t|t"��r|���}t'd|�d	|�d
|�����d}~wwxYw|jjD]}|�|���dS)zJself.parsed_data->self.config, parse unrecognized extra args via KVLoader.rcc�,�g|]}|tkrdn|��Sr(r*rks  rr-z=KVArgParseConfigLoader._convert_to_config.<locals>.<listcomp>s'��"U�"U�"U�A�!�/@�*@�*@�3�3�a�"U�"U�"Urr�r�z1Unrecognized alias: '%s', it will have no effect.NrzError loading argument r>r�)rcr{rtr~r:r;r��warningrKr_r�r�r�r�rErr�r�r�rr�r!)r rcrrr�r��subcs       rr�z)KVArgParseConfigLoader._convert_to_configs����_�
��T�-�.�.�4�4�6�6�	P�	P�H�C���l�"�"�"U�"U�QT�"U�"U�"U�Xb�"b����������+�+�.��4�4�C��#�~�~��� � �!T�VY�Z�Z�Z����#�t�$�$�
0�(��-�-����C��%�%�
0�*�3�/�/���(�,�,�S�1�1�E��
!��a���
P��%�%�c�3��6�6�6�6���
P�
P�
P��c�>�2�2�,��/�/�+�+�C�#�$N�c�$N�$N�C�$N�$N�1�$N�$N�O�O�O�����
P�����$�+�	"�	"�D��O�O�D�!�!�!�!�	"�	"s�D�
E(�"AE#�#E(N)rrrr.rGrfrgr�rrrr�r��sG��������
 �L�@,�@,�@,�D&"�&"�&"�&"�&"rr�c�"��eZdZdZ�fd�Z�xZS)�KeyValueConfigLoaderz@Deprecated in traitlets 5.0

    Use KVArgParseConfigLoader
    c�r��tjdtd���t��j|i|��dS)Nz[KeyValueConfigLoader is deprecated since Traitlets 5.0. Use KVArgParseConfigLoader instead.r	rZ)r]r^r_r*rtr�s   �rrtzKeyValueConfigLoader.__init__=sK����
�
3���		
�	
�	
�	
�	�����$�)�&�)�)�)�)�)r)rrrr.rtr0r1s@rr�r�7sB���������
*�*�*�*�*�*�*�*�*rr�c���t��}|D]W}t||���}	|���}|�|���>#t$rY�Jt
$r�wxYw|S)aLoad multiple Python config files, merging each of them in turn.

    Parameters
    ----------
    config_files : list of str
        List of config files names to load and merge into the config.
    path : unicode
        The full path to the location of the config files.
    )r�)rrrr�r{rr�)�config_filesr�r��cfr�next_configs      r�load_pyconfig_filesr�Gs����X�X�F��	&�	&��#�B�T�2�2�2��	&� �,�,�.�.�K�
�L�L��%�%�%�%��"�	�	�	��D��	�	�	��	�����Ms�A�
A&�A&)8r.r/r]r�r�rer(�typingr�r]�traitlets.traitletsrrrrrr�utilsr
rr�r
rrrrr\r%r;r=rprWrrr�r�r�r_r�r�r�r�rrr6r?r;r+�Actionr%r5rGrNr�r�r�r�rrr�<module>r�s4��$�$�
������������	�	�	�	�	�	�	�	�
�
�
�
���������P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�*�*�*�*�*�*�*�*�	�	�	�	�	�)�	�	�	�	�	�	�	�	��	�	�	�	�	�	�	�	��	�	�	�	�	�	�	�	�%�	�	�	����������i�k�k��D�D�D�D�D�X�,�D�D�D� ;�;�;�
CE�CE�CE�CE�CE�i�CE�CE�CE�L���X$�X$�X$�X$�X$�T�X$�X$�X$�v
6�
6�
6�
6�
6�
6�
6�
6�B�B�B�B�B�3��B�B�B�B'B�'B�'B�'B�'B��~�'B�'B�'B�^4�4�4�4�4�4�4�4�n@�@�@�@�@�|�@�@�@�84!�4!�4!�4!�4!�+�4!�4!�4!�n/Q�/Q�/Q�/Q�/Q�)�/Q�/Q�/Q�d*6�*6�*6�*6�*6�l�*6�*6�*6�f%�"�*�%F�G�G������-�-�-�-�-���-�-�-�&#�#�#�#�#��#�#�#�L9�9�9�9�9�8�*�9�9�9�[%�[%�[%�[%�[%�2�[%�[%�[%�|3�3�3�3�3�(�/�3�3�3�(p"�p"�p"�p"�p"�1�p"�p"�p"�f
*�
*�
*�
*�
*�1�
*�
*�
*� ����r

Youez - 2016 - github.com/yon3zu
LinuXploit