
    ci0                         d Z ddlmZ ddlmZ ddlmZ ddlmZ  G d de      Z	d	 Z
d
 Zd Zd Zd Zd Zd Zd Zd Zd Zd Z G d de      Z G d de      ZddddZy)z0Variants of ObjectProxy for different use cases.    )Callable)
ModuleType   )BaseObjectProxy)synchronizedc                   8     e Zd ZdZed        Z fdZd Z xZS )ObjectProxya  A generic object proxy which forwards special methods as needed.
    For backwards compatibility this class adds support for `__iter__()`. If
    you don't need backward compatibility for `__iter__()` support then it is
    preferable to use `BaseObjectProxy` directly. If you want automatic
    support for special dunder methods for callables, iterators, and async,
    then use `AutoObjectProxy`.c                     t         S N)r	   selfs    Q/var/www/html/spbu.com/backend/venv/lib/python3.12/site-packages/wrapt/proxies.py__object_proxy__zObjectProxy.__object_proxy__   s        c                 "    t         |   |       S r   )super__new__)clsargskwargs	__class__s      r   r   zObjectProxy.__new__   s    ws##r   c                 ,    t        | j                        S r   iter__wrapped__r   s    r   __iter__zObjectProxy.__iter__   s    D$$%%r   )	__name__
__module____qualname____doc__propertyr   r   r   __classcell__r   s   @r   r	   r	      s&    #  $&r   r	   c                  <    d } ||  \  }}  |j                   | i |S )Nc                 
    | |fS r    )r   r   s     r   _unpack_selfz&__wrapper_call__.<locals>._unpack_self%   s    Tzr   )r   )r   r   r'   r   s       r   __wrapper_call__r(   $   s/     t$JD$4T,V,,r   c                 ,    t        | j                        S r   r   r   s    r   __wrapper_iter__r*   -   s      !!r   c                 6    | j                   j                         S r   )r   __next__r   s    r   __wrapper_next__r-   1   s    $$&&r   c                 6    | j                   j                         S r   )r   	__aiter__r   s    r   __wrapper_aiter__r0   5   s    %%''r   c                 R   K   | j                   j                          d {   S 7 wr   )r   	__anext__r   s    r   __wrapper_anext__r3   9   s!     !!++----   '%'c                 6    | j                   j                         S r   )r   __length_hint__r   s    r   __wrapper_length_hint__r7   =   s    ++--r   c              #   R   K   | j                   j                         E d {   S 7 wr   )r   	__await__r   s    r   __wrapper_await__r:   A   s!     ''113343r4   c                 :    | j                   j                  ||      S r   )r   __get__)r   instanceowners      r   __wrapper_get__r?   E       ##He44r   c                 :    | j                   j                  ||      S r   )r   __set__)r   r=   values      r   __wrapper_set__rD   I   r@   r   c                 8    | j                   j                  |      S r   )r   
__delete__)r   r=   s     r   __wrapper_delete__rG   M   s    &&x00r   c                 :    | j                   j                  ||      S r   )r   __set_name__)r   r>   names      r   __wrapper_set_name__rK   Q   s    ((55r   c                   (     e Zd ZdZ fdZd Z xZS )AutoObjectProxya  An object proxy which can automatically adjust to the wrapped object
    and add special dunder methods as needed. Note that this creates a new
    class for each instance, so it has much higher memory overhead than using
    `BaseObjectProxy` directly. If you know what special dunder methods you need
    then it is preferable to use `BaseObjectProxy` directly and add them to a
    subclass as needed. If you only need `__iter__()` support for backwards
    compatibility then use `ObjectProxy` instead.
    c                 P   i }t        |      }t        t        |             }t        |      rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t
        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d	|v rd	|vr	t        |d	<   d
|v rd
|vr	t        |d
<   d|v rd|vr	t        |d<   | j                  }| t        u rt         j                  }t"        t        | K  t'        || f|            S )zInjects special dunder methods into a dynamically created subclass
        as needed based on the wrapped object.
        __call__r   r,   r/   r2   r6   r9   r<   rB   rF   rI   )dirsetcallabler(   r*   r-   r0   r3   r7   r:   r?   rD   rG   rK   r   rM   r   r   r   type)r   wrapped	namespacewrapped_attrsclass_attrsrJ   r   s         r   r   zAutoObjectProxy.__new___   sp   
 	G#c(mG;!>$4Ij!&:[+H$4Ij!&:[+H$4Ij!-'K{,J%6Ik"-'K{,J%6Ik"-2C;2V+BI'( -'K{,J%6Ik"%);*F#2Ii %);*F#2Ii =(\-L&8Il#]*~[/P(<In%||/!"++D_c24sfi3PQQr   c                 2   t        |       }t        t        |            }t        | j                        rd|vr+t
        |_        nt        |dd      t
        u rt        |d       t        | j                  d      rd|vr+t        |_        nt        |dd      t        u rt        |d       t        | j                  d      rd|vr+t        |_        nt        |dd      t        u rt        |d       t        | j                  d      rd|vr+t        |_        nt        |dd      t        u rt        |d       t        | j                  d      rd|vr+t         |_        nt        |dd      t         u rt        |d       t        | j                  d      rd|vr+t$        |_        nt        |dd      t$        u rt        |d       t        | j                  d      rd|vr+t(        |_        nt        |dd      t(        u rt        |d       t        | j                  d	      rd	|vr+t,        |_        nt        |d	d      t,        u rt        |d	       t        | j                  d
      rd
|vr+t0        |_        nt        |d
d      t0        u rt        |d
       t        | j                  d      rd|vr+t4        |_        nt        |dd      t4        u rt        |d       t        | j                  d      rd|vrt8        |_        yyt        |dd      t8        u rt        |d       yy)zAdjusts special dunder methods on the class as needed based on the
        wrapped object, when `__wrapped__` is changed.
        rP   Nr   r,   r/   r2   r6   r9   r<   rB   rF   rI   )rT   rR   rQ   rS   r   r(   rP   getattrdelattrhasattrr*   r   r-   r,   r0   r/   r3   r2   r7   r6   r:   r9   r?   r<   rD   rB   rG   rF   rK   rI   )r   r   rX   s      r   __wrapped_setattr_fixups__z*AutoObjectProxy.__wrapped_setattr_fixups__   s   
 4j#c(mD$$%,/S*d+/??C$4##Z0,/S*d+/??C$4##Z0,/S*d+/??C$4##[1+- 1S+t,0AAC%4##[1+- 1S+t,0AAC%4##%67 3&=#S+T26MMC*+4##[1+- 1S+t,0AAC%4##Y/+-S)T*o=C#4##Y/+-S)T*o=C#4##\2;.!3S,-1CCC&4##^4[0#7  1S.$/3GGC( Hr   )r   r   r   r    r   r]   r"   r#   s   @r   rM   rM   U   s    4RlH)r   rM   c                   L     e Zd ZdZd	dd fdZd	dd fdZdZd Zd Z xZ	S )
LazyObjectProxyzhAn object proxy which can generate/create the wrapped object on demand
    when it is first needed.
    .	interfacec                0   |du rt        d      }i }t        |      }t        t        |             }d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t
        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d	|v rd	|vr	t        |d	<   d
|v rd
|vr	t        |d
<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   d|v rd|vr	t        |d<   | j                  }t        t         | G  t        || f|            S )rO   .NrP   r   r,   r/   r2   r6   r9   r<   rB   rF   rI   )rT   rQ   rR   r(   r*   r-   r0   r3   r7   r:   r?   rD   rG   rK   r   r   rM   r   )r   callbackra   rV   interface_attrsrX   rJ   r   s          r   r   zLazyObjectProxy.__new__   sp   
 T
I	i.#c(m(Z{-J$4Ij!(Z{-J$4Ij!(Z{-J$4Ij!/)k.L%6Ik"/)k.L%6Ik" 0!4+BI'( /)k.L%6Ik"'I[,H#2Ii 'I[,H#2Ii ?*|;/N&8Il#_,{1R(<In%||_c24sfi3PQQr   c                6    ||| _         t        | 	  d       y)a  Initialize the object proxy with wrapped object as `None` but due
        to presence of special `__wrapped_factory__` attribute addded first,
        this will actually trigger the deferred creation of the wrapped object
        when first needed.
        N)__wrapped_factory__r   __init__)r   rc   ra   r   s      r   rg   zLazyObjectProxy.__init__  s      '/D$r   Fc                      y r   r&   r   s    r   rf   z#LazyObjectProxy.__wrapped_factory__,  s    r   c                     t        t        |             5  | j                  r| j                  cddd       S | j	                         | _        d| _        | j                  cddd       S # 1 sw Y   yxY w)z2Gets the wrapped object, creating it if necessary.NT)r   rT   __wrapped_initialized__r   rf   r   s    r   __wrapped_get__zLazyObjectProxy.__wrapped_get__/  s\     $t*% ++'' &%  $779D+/D(## &%%s   A('A((A1r   )
r   r   r   r    r   rg   rj   rf   rk   r"   r#   s   @r   r_   r_      s5    7R 7Rr
3 
 $$r   r_   N.r`   c                Z     |du rt         }n
|du rt        } fd}t        ||      S )aN  Lazily imports the module `name`, returning a `LazyObjectProxy` which
    will import the module when it is first needed. When `name is a dotted name,
    then the full dotted name is imported and the last module is taken as the
    target. If `attribute` is provided then it is used to retrieve an attribute
    from the module.
    .c                  @    t        dg      } t        |       S | S )N )fromlist)
__import__rZ   )module	attributerJ   s    r   _importzlazy_import.<locals>._importW  s)    DB40 69--r   r`   )r   r   r_   )rJ   rr   ra   rs   s   ``  r   lazy_importrt   H  s9      I"I 7i88r   r   )r    collections.abcr   typesr   	__wrapt__r   
decoratorsr   r	   r(   r*   r-   r0   r3   r7   r:   r?   rD   rG   rK   rM   r_   rt   r&   r   r   <module>ry      s    6 $  & $&/ &.-"'(..55516H)o H)Ve$o e$P93 9r   