Hacked By AnonymousFox

Current Path : /opt/cloudlinux/venv/lib/python3.11/site-packages/testfixtures/__pycache__/
Upload File :
Current File : //opt/cloudlinux/venv/lib/python3.11/site-packages/testfixtures/__pycache__/replace.cpython-311.pyc

�

�܋f�0����ddlZddlmZddlmZddlmZmZddlm	Z	m
Z
ddlmZddl
mZmZmZmZmZddlmZmZmZmZmZdd	lmZmZddlZeeegefZd
�Zed��Z Gd�d
��Z!		ddedede"dedededeegeffd�Z#ededefd���Z$ed dededefd���Z%ed dededefd���Z&Gd�de'��Z(dZ)ee)e!j*e!j#e#e(g��dS)!�N)�contextmanager)�partial)�
get_referrers�
get_referents)�setitem�getitem)�
ModuleType)�Any�TypeVar�Callable�Dict�Tuple)�resolve�	not_there�Resolved�classmethod_type�
class_type)�wrap�extend_docstringc�D�t||��ot||��S�N)�
isinstance)�x�y�
descriptors   �e/builddir/build/BUILD/cloudlinux-venv-1.0.6/venv/lib/python3.11/site-packages/testfixtures/replace.py�not_same_descriptorrs$���a��$�$�F�Z��:�-F�-F�)F�F��Rc���eZdZdZd�Zdefd�Z		ddeded	e	d
ede
ded
efd�Z		ddeded	e	d
ede
ded
dfd�Z
deded
dfd�Zdede	fd�Zddededed
dfd�Zddededed
dfd�Zdd�Zd�Zd�Zd�ZdS)�Replacerz�
    These are used to manage the mocking out of objects so that units
    of code can be tested without having to rely on their normal
    dependencies.
    c��i|_dSr)�	originals��selfs r�__init__zReplacer.__init__ s
��:<����r�resolvedc�0�|turk|jtur,	t|j|j��n#t$rYnwxYw|jtur!	|j|j=dS#t$rYdSwxYwdS|�|j|j|��dSr)	r�setter�setattr�delattr�	container�name�AttributeErrorr�KeyError)r%r'�values   r�_replacezReplacer._replace#s����I�����'�)�)���H�.��
�>�>�>�>��%�����D�������'�)�)�� �*�8�=�9�9�9�������D�D�����*�)�
�O�O�H�.��
�u�E�E�E�E�Es!�4�
A�A�
A"�"
A0�/A0TN�target�replacement�strictr,�accessorr-�returnc��|�|�td���t|t��r"|�td���t||��}n�t}|�|}|pt|dd��}|�td���|�I	t}|||��}nY#t$rYnMt$rt
}|||t��}Yn)wxYw	|||��}n#ttf$rYnwxYw|r4|tus+||us'|||��}	||	urt|�d|�d|�����t||turtnt||��}|j
�td���|jtur|rtd	|jz���|}
t|jt$��r�|j|jjvr|jj|j|_t)|j|t*��rt+|��}
n*t)|j|t,��rt-|��}
|�||
��t1|��}||jvr||f|j|<|S)
�M
        Replace the specified target with the supplied replacement.
        Nz-accessor is not used unless name is specifiedz0name cannot be specified when target is a string�__name__z2name must be specified when target is not a stringz
 resolved to z, expected z%target must contain at least one dot!zOriginal %r not found)�	TypeErrorr�strrr�getattrrr/r.�AssertionErrorrrr*r)�
ValueError�foundr-r,�type�__dict__r�classmethod�staticmethodr1�idr#)r%r2r3r4r,r5r-r'r?�expected�replacement_to_use�keys            r�__call__zReplacer.__call__2s���
�<�H�0��K�L�L�L��f�c�"�"�&	���� R�S�S�S��v�y�1�1�H�H��E�� �"�	��<�7�6�:�t�<�<�D��|�� T�U�U�U��#�E�#*�� (���D� 9� 9����#������$�E�E�E�#*�� (���D�)� D� D����E����� (���D� 9� 9����$�n�5�����������
]�u�	�1�1�V�y�5H�5H�#�8�I�t�4�4����)�)�(�D�)[�)[��)[�)[�SY�)[�)[�\�\�\���#�w�.�.���G���	��H��?�"��D�E�E�E��>�Y�&�&�6�&� �!8�8�=�!H�I�I�I�(���h�(�$�/�/�
	?��}�� 2� ;�;�;�!)�!3�!<�X�]�!K���"�8�>�;��L�L�
?�%0��%=�%=�"�"�$�X�^�[�,�O�O�
?�%1�+�%>�%>�"��
�
�h� 2�3�3�3���j�j���d�n�$�$�"(�(�"2�D�N�3���s*�=B�
C�"C�C�C�C'�&C'c�&�|||||||��dS)r8N��r%r2r3r4r,r5r-s       r�replacezReplacer.replace{s$��
	
��V�[�&�)�X�t�D�D�D�D�Drc	�~�|tj|td|turtnt	|�����dS)a
        This method provides a convenient way of ensuring an environment variable
        in :any:`os.environ` is set to a particular value.

        If you wish to ensure that an environment variable is *not* present,
        then use :any:`not_there` as the ``replacement``.
        F)r-r5r4r3N)�os�environrrr;)r%r-r3s   r�
in_environzReplacer.in_environ�sP��	
��R�Z�d�W�U�&1�Y�&>�&>���C��DT�DT�	V�	V�	V�	V�	V�	Vr�break_on_staticc�"�t|��D]~}|rt|t��rd|fcSt|t��rJd|vrF|�|��|ur/t|��D]}t|t
��r|dfccS� �dS)NrA)NN)rrrC�dict�getr@)r%�	attributer-rQ�referrerr,s      r�_find_containerzReplacer._find_container�s���%�i�0�0�	3�	3�H��
3�:�h��#E�#E�
3��X�~�%�%�%��H�d�+�+�
3�
�h�0F�0F��<�<��%�%��2�2�%2�8�%<�%<�3�3�	�%�i��6�6�3�#,�d�?�2�2�2�2�2�3���zrrUc��t|��std���|pt|dd��}d}t|t��r*t|��D]}t|t��r|}�n8|�||d���\}}|�|�||d���\}}|�td|�d|�����|||t|�	��dS)
au
        This method provides a convenient way to replace methods, static methods and class
        methods on their classes.

        If the attribute being replaced has a ``__name__`` that differs from the attribute
        name on the class, such as that returned by poorly implemented decorators, then
        ``name`` must be used to provide the correct name.
        zattribute must be callabler9NT)rQFzcould not find container of z using name �r-r5r3)	�callabler:r<rrrrrWr.)r%rUr3r-r,�referred�
staticmethod_�_s        r�on_classzReplacer.on_class�s���	�"�"�	:��8�9�9�9��;�w�y�*�d�;�;���	��i�!1�2�2�	`�)�)�4�4�
)�
)���h�
�3�3�)� (�I��
)�(,�';�';�I�t�]a�';�'b�'b�$�I�}��(�#�3�3�M�4�Y^�3�_�_��	�1��� �!a�	�!a�!a�Y]�!a�!a�b�b�b���Y�T�G��M�M�M�M�M�Mr�modulec�r�|pt|j��j}|j}|||t|���dS)a�
        This method provides a convenient way to replace targets that are module globals,
        particularly functions or other objects with a ``__name__`` attribute.

        If an object has been imported into a module other than the one where it has been
        defined, then ``module`` should be used to specify the module where you would
        like the replacement to occur.
        rYN)r�
__module__r?r9r<)r%r2r3r_r,r-s      r�	in_modulezReplacer.in_module�sB���>�g�f�&7�8�8�>�	������Y�T�G��M�M�M�M�M�Mrc��t|j�����D]+\}\}}|�||j��|j|=�,dS)z�
        Restore all the original objects that have been replaced by
        calls to the :meth:`replace` method of this :class:`Replacer`.
        N)�tupler#�itemsr1r?)r%�id_r2�originals    r�restorezReplacer.restore�s`��
(-�T�^�-A�-A�-C�-C�'D�'D�	$�	$�#�C�#�&�(��M�M�(�H�N�3�3�3���s�#�#�	$�	$rc��|SrrJr$s r�	__enter__zReplacer.__enter__�s���rc�.�|���dSr)rh)r%r@r0�	tracebacks    r�__exit__zReplacer.__exit__�s���������rc��|jr:tjdd�|j���D��z��dSdS)Nz;Replacer deleted without being restored, originals left: %rc��i|]\}}||��	SrJrJ)�.0�k�vs   r�
<dictcomp>z$Replacer.__del__.<locals>.<dictcomp>�s��'R�'R�'R���A��!�'R�'R�'Rr)r#�warnings�warn�valuesr$s r�__del__zReplacer.__del__�s`���>�	�
�M�%�'R�'R�$�.�:O�:O�:Q�:Q�'R�'R�'R�S�
�
�
�
�
�	�	r�TNNNr)r6N)r9ra�__qualname__�__doc__r&rr1r
r�bool�Accessorr;rHrLrPrWrr^r	rbrhrjrmrwrJrrr!r!s'��������=�=�=�
F��
F�
F�
F�
F�DH�OS�G�G�s�G��G�D�G��G�2:�G�IL�G�XY�G�G�G�G�REI�NR�E�E�c�E��E�T�E��E�19�E�HK�E�W[�E�E�E�E�	V�s�	V��	V��	V�	V�	V�	V�	�s�	�T�	�	�	�	�N�N�(�N��N�C�N�SW�N�N�N�N�6N�N��N�#�N�z�N�UY�N�N�N�N�$�$�$�$�����������rr!Tr2r3r4r,r5r-r6c�x�t��}tt|j||||||��|j��S)zY
    A decorator to replace a target object for the duration of a test
    function.
    )r!rrrHrh)r2r3r4r,r5r-�rs       rrLrL�s=��	�
�
�A����
�F�K���H�d�S�S�	�	���rc#�K�t��5}|�||��dV�ddd��dS#1swxYwYdS)zW
    This context manager provides a quick way to use :meth:`Replacer.in_environ`.
    N)r!rP)r-r3r~s   r�replace_in_environr��s�����

����q�	���T�;�'�'�'�
������������������������s
�9�=�=rUc#�K�t��5}|�|||��dV�ddd��dS#1swxYwYdS)zU
    This context manager provides a quick way to use :meth:`Replacer.on_class`.
    N)r!r^)rUr3r-r~s    r�replace_on_classr��s�����

����q�	�
�
�9�k�4�0�0�0�
�������������������������
�:�>�>r_c#�K�t��5}|�|||��dV�ddd��dS#1swxYwYdS)zV
    This context manager provides a quick way to use :meth:`Replacer.in_module`.
    N)r!rb)r2r3r_r~s    r�replace_in_moduler��s�����

����q�	���F�K��0�0�0�
������������������������r�c
�J�eZdZdZ		ddededededed	efd
�Z	defd�Z
d
�ZdS)�ReplacezU
    A context manager that uses a :class:`Replacer` to replace a single target.
    TNr2r3r4r,r5r-c��||_||_||_||_||_||_t
��|_dSr)r2r3r4r,r5r-r!�	_replacerrKs       rr&zReplace.__init__s>�����&������'���"*��
���	�!������rr6c�r�|�|j|j|j|j|j|j��Sr)r�r2r3r4r,r5r-r$s rrjzReplace.__enter__s4���~�~��K��)�4�;����
�W[�W`�
�
�	
rc�8�|j���dSr)r�rh)r%�exc_type�exc_val�exc_tbs    rrmzReplace.__exit__s������ � � � � rrx)r9raryrzr
rr{r|r;r&rjrmrJrrr�r�s���������
?C�JN�
$�
$��
$�,-�
$�7;�
$��
$�-5�
$�DG�
$�
$�
$�
$�
�1�
�
�
�
�
!�!�!�!�!rr�a
:param target: 

  This must be one of the following:
  
  - A string containing the dotted-path to the object to be replaced, in which case it will be 
    resolved the the object to be replaced.
    
    This path may specify a module in a package, an attribute of a module, or any attribute of 
    something contained within a module.
    
  - The container of the object to be replaced, in which case ``name`` must be specified.
  
  - The object to be replaced, in which case ``container`` must be specified.
    ``name`` must also be specified if it cannot be obtained from the ``__name__`` attribute
    of the object to be replaced.

:param replacement: The object to use as a replacement.

:param strict: When `True`, an exception will be raised if an
               attempt is made to replace an object that does
               not exist or if the object that is obtained using the ``accessor`` to 
               access the ``name`` from the ``container`` is not identical to the ``target``.
               
:param container: 
  The container of the object from which ``target`` can be accessed using either
  :func:`getattr` or :func:`~operator.getitem`.
  
:param accessor:
  Either :func:`getattr` or :func:`~operator.getitem`. If not supplied, this will be inferred
  preferring :func:`~operator.getitem` over :func:`getattr`.
  
:param name:
  The name used to access the ``target`` from the ``container`` using the ``accessor``.
  If required but not specified, the ``__name__`` attribute of the ``target`` will be used. 
rxr)+rN�
contextlibr�	functoolsr�gcrr�operatorrr�typesr	�typingr
rrr
r�testfixtures.resolverrrrr�testfixtures.utilsrrrtr;r|rrr!r{rLr�r�r��objectr��replace_params_docrHrJrr�<module>r�s���	�	�	�	�%�%�%�%�%�%�������+�+�+�+�+�+�+�+�%�%�%�%�%�%�%�%�������6�6�6�6�6�6�6�6�6�6�6�6�6�6�[�[�[�[�[�[�[�[�[�[�[�[�[�[�5�5�5�5�5�5�5�5������S�#�J��O�$��G�G�G��G�C�L�L��}�}�}�}�}�}�}�}�B7;�FJ�����"%��/3����)1��@C���x�j�(�"�#�������S��s������������s��#����������c����Z�������!�!�!�!�!�f�!�!�!�4#��L��#��#�X�%5�w��H�J�J�J�J�Jr

Hacked By AnonymousFox1.0, Coded By AnonymousFox