
    ha                    Z   d Z ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm	Z	 dd	lm
Z
 dd
lmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlZddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlmZ ddlm Z  ddlm!Z! ddl"m#Z# dd l"m$Z$ er<dd!lm%Z% dd"lm&Z& dd#lm'Z' dd$lm(Z( dd%lm)Z) dd&l*m+Z+ dd'l,m-Z- dd(l.m/Z/ dd)lm0Z0 dd*lm1Z1  ed+e,      Z2 ejf                  d-      Z4 G d. d/e$      Z5 G d0 d1e$      Z6 G d2 d3e!ee7d4f   e	e   e       Z8 G d5 d6      Z9 G d7 d8e       Z: e:       Z;ejx                  xZ<Z=ej|                  xZ>Z?ej                  xZ@ZAej                  xZBZC	 	 	 	 	 	 d=	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 d>d9ZDd: ZEd; ZFd< ZGy)?a  Defines SQLAlchemy's system of class instrumentation.

This module is usually not directly visible to user applications, but
defines a large part of the ORM's interactivity.

instrumentation.py deals with registration of end-user classes
for state tracking.   It interacts closely with state.py
and attributes.py which establish per-instance and per-class-attribute
instrumentation, respectively.

The class instrumentation system can be customized on a per-class
or global basis using the :mod:`sqlalchemy.ext.instrumentation`
module, which provides the means to build and specify
alternate instrumentation forms.

.. versionchanged: 0.8
   The instrumentation extension system was moved out of the
   ORM and into the external :mod:`sqlalchemy.ext.instrumentation`
   package.  When that package is imported, it installs
   itself within sqlalchemy.orm so that its more comprehensive
   resolution mechanics take effect.

    )annotations)Any)Callable)cast)
Collection)Dict)Generic)Iterable)List)Optional)Set)Tuple)Type)TYPE_CHECKING)TypeVar)UnionN   )base)collections)exc)
interfaces)state)_O)_is_collection_attribute_impl   )util)EventTarget)HasMemoized)Literal)Protocol)_RegistryType)AttributeImpl)QueryableAttribute)_AdaptedCollectionProtocol)_CollectionFactoryType)_MapperConfig)InstanceEvents)Mapper)InstanceState)
dispatcher_T)boundDEL_ATTRc                  $    e Zd Z	 	 	 	 	 	 	 	 ddZy)_ExpiredAttributeLoaderProtoc                     y N )selfr   toloadpassives       GD:\EasyAligner\venv\Lib\site-packages\sqlalchemy/orm/instrumentation.py__call__z%_ExpiredAttributeLoaderProto.__call__S   s    
     N)r   state.InstanceState[Any]r4   zSet[str]r5   zbase.PassiveFlagreturnNone__name__
__module____qualname__r7   r2   r8   r6   r/   r/   R   s-    '  "	
 
r8   r/   c                      e Zd ZddZy)_ManagerFactoryc                     y r1   r2   r3   class_s     r6   r7   z_ManagerFactory.__call__\   s    cr8   NrD   Type[_O]r:   ClassManager[_O]r<   r2   r8   r6   rA   rA   [   s    Ar8   rA   c                  r   e Zd ZU dZded<   ej                  Zej                  Z	 e
 ej                  e	            Zded<   	 ded<   dZded	<   d
ed<   dZded<   ded<   esdZded<   ded<   e ej&                  dd      d               Zej*                   ej&                  dd      d               Zd Z	 	 	 	 	 	 dE	 	 	 	 	 	 	 	 	 	 	 	 	 dFdZdGdZdHdZdIdZedJd       Zej:                  d        Zej:                  d         Zej:                  d!        Z ej:                  d"        Z!ejD                  dKd#       Z#dLd$Z$dLd%Z%dMd&Z&dNd'Z'd( Z(ejD                  dOd)       Z)d* Z*ejV                  d+        Z,ejV                  d,        Z-ejV                  d-        Z.	 dP	 	 	 	 	 	 	 dQd.Z/d/ Z0d0 Z1dPd1Z2dGd2Z3	 	 	 	 	 	 dRd3Z4dSd4Z5dTd5Z6dSd6Z7	 	 	 	 	 	 dUd7Z8	 	 	 	 	 	 	 	 dVd8Z9dPdWd9Z:dXd:Z;edYd;       Z<dLdZd<Z=	 dL	 	 	 	 	 d[d=Z>d\d>Z?	 	 	 	 	 	 d]d?Z@	 	 	 	 d^d@ZAd_dAZB	 dP	 	 	 	 	 	 	 d`dBZCdJdCZDdadDZEy)bClassManagerz,Tracks state information at the class level.zdispatcher[ClassManager[_O]]dispatchr/   expired_attribute_loaderOptional[Callable[..., None]]init_methodNoriginal_initzOptional[_ManagerFactory]factoryz$Optional[weakref.ref[_MapperConfig]]declarative_scanr!   registryrF   rD   zList[ClassManager[Any]]_basesz1.4zWThe ClassManager.deferred_scalar_loader attribute is now named expired_attribute_loader)messagec                    | j                   S r1   rK   r3   s    r6   deferred_scalar_loaderz#ClassManager.deferred_scalar_loader   s     ,,,r8   c                    || _         y r1   rU   )r3   objs     r6   rW   z#ClassManager.deferred_scalar_loader   s     ),%r8   c           
        || _         i | _        d | _        i | _        i | _        d| _        d | _        d | _        t        d| j                   j                  D cg c]  }t        |t              rt        |       c}      D cg c]  }|| c}| _        | j                  D ]  }| j                  |        t        d| j                  j                         j#                  ||        |j$                  D ]5  }t        |      }|| j                  j'                  |j                         7 | j)                          d|j*                  v rt-        j.                  d|z         y y c c}w c c}w )NFz!List[Optional[ClassManager[Any]]]r'   __del__z__del__() method on class %s will cause unreachable cycles and memory leaks, as SQLAlchemy instrumentation often creates reference cycles.  Please remove this method.)rD   infonew_initlocal_attrs	originals
_finalizedrO   rM   r   	__bases__
isinstancetypeopt_manager_of_classrR   updaterJ   _events_new_classmanager_instance__mro___updatemanage__dict__r   warn)r3   rD   r   mgrbase_baseclss         r6   __init__zClassManager.__init__   s`   	 3 !% 5 5 5!$- ). 5
  
 [[EKK ! 	dmm33	

$
$VT
2~~G&w/C%%cll3 &
 	'II@ CII (/	
s   "E#
E(c                   |r|| _         |r|j                  |        |rt        j                  |      | _        |r|| _        |r| j                  r
J d|z         || _        | j                  sY| j                  2| j                  j                  t        j                  u r| j                  n| j                  j                  | _        |r| j                  s| j                          y y y )Nz>class is already instrumented, init_method %s can't be applied)mapper_add_managerweakrefrefrP   rK   r`   rM   rD   rp   objectrN   	_finalize)r3   finalizerr   rQ   rP   rK   rM   s          r6   _update_statezClassManager._update_state   s      DK!!$'$+KK0@$AD!#,DD) 24?@&  +D ##/KK((FOO;    [[))	  DOONN ,8r8   c                    | j                   ry d| _         | j                          t        j                  j	                  | j
                         y NT)r`   _instrument_init_instrumentation_factoryrJ   class_instrumentrD   rV   s    r6   rw   zClassManager._finalize   s7    ?? ))::4;;Gr8   c                    t        |       S r1   )idrV   s    r6   __hash__zClassManager.__hash__   s    $xr8   c                
    || u S r1   r2   )r3   others     r6   __eq__zClassManager.__eq__   s    }r8   c                    d| j                   v S )Nrr   )rk   rV   s    r6   	is_mappedzClassManager.is_mapped   s    4==((r8   c                    t        |       S r1   )	frozensetrV   s    r6   _all_key_setzClassManager._all_key_set   s    r8   c                    t        | j                         D cg c]%  }|j                  j                  s|j                  ' c}      S c c}w r1   )r   valuesimpl
collectionkeyr3   attrs     r6   _collection_impl_keysz"ClassManager._collection_impl_keys   s:    "&++-H-$4993G3GTXX-H
 	
Hs
   A	A	c                    t        | j                         D cg c]$  }|j                  j                  r|j                  & c}      S c c}w r1   )r   r   r   accepts_scalar_loaderr   s     r6   _scalar_loader_implsz!ClassManager._scalar_loader_impls  sH     !KKM)D9922 		)
 	
s   )Ac                n    t        | j                         D cg c]  }|j                   c}      S c c}w r1   )r   r   r   r   s     r6   _loader_implszClassManager._loader_impls  s)    >$))>??>s   2c                @    t        j                  | j                        r1   )r   UnmappedClassErrorrD   rV   s    r6   rr   zClassManager.mapper  s     $$T[[11r8   c              #  N  K   i }| j                   j                  dd D ]  }|j                  d   }|j                  D ]c  }|j                  ||       ||j                  v r$||   j                  |   }t	        |t
        j                        sQ|j                  s^||f e  yw)a  return an iterator of all classbound attributes that are
        implement :class:`.InspectionAttr`.

        This includes :class:`.QueryableAttribute` as well as extension
        types such as :class:`.hybrid_property` and
        :class:`.AssociationProxy`.

        r   r   N)rD   rh   rk   
setdefaultrb   r   InspectionAttris_attribute)r3   excludefoundsuperclsinheritsr   vals          r6   _all_sqla_attributesz!ClassManager._all_sqla_attributes  s      !# ++Ab1H''*H((  h/(+++Cj))#.sJ$=$=>((s(N ) 2s   B
B%B%B%c                z    | j                   j                  D ]!  }||j                  v s|j                  |   c S  |S )z5return an attribute on the class without tripping it.)rD   rh   rk   )r3   r   defaultr   s       r6   _get_class_attr_mroz ClassManager._get_class_attr_mro8  s>     ++Hh'''((-- , Nr8   c                0    || v xr | |   j                   duS )z\Return True if the given attribute is fully initialized.

        i.e. has an impl.
        Nr   r3   r   s     r6   _attr_has_implzClassManager._attr_has_implA  s      d{9tCy~~T99r8   c                    t        |d      S )a  Create a new ClassManager for a subclass of this ClassManager's
        class.

        This is called automatically when attributes are instrumented so that
        the attributes can be propagated to subclasses against their own
        class-local manager, without the need for mappers etc. to have already
        pre-configured managers for the full class hierarchy.   Mappers
        can post-configure the auto-generated ClassManager when needed.

        F)rx   )register_class)r3   clss     r6   _subclass_managerzClassManager._subclass_managerI  s     cE22r8   c                    t        | j                  | | j                        | _        | j	                  d| j                         y )Nrp   )_generate_initrD   rN   r]   install_memberrV   s    r6   r|   zClassManager._instrument_initV  s0    &t{{D$:L:LMJ6r8   c                n    | j                   j                  | | j                         t        j                  S r1   )rJ   
first_initrD   r   r)   rV   s    r6   _state_constructorzClassManager._state_constructorZ  s&      t{{3"""r8   c                F    t        | j                  | j                  |        y)z0Mark this instance as the manager for its class.N)setattrrD   MANAGER_ATTRrV   s    r6   rj   zClassManager.manage_  s     	T..5r8   c                    t         S r1   )_default_manager_getterrV   s    r6   manager_getterzClassManager.manager_getterd  s    &&r8   c                    t         S )zReturn a (instance) -> InstanceState callable.

        "state getter" callables should raise either KeyError or
        AttributeError if no InstanceState could be found for the
        instance.
        )_default_state_getterrV   s    r6   state_getterzClassManager.state_getterh  s
     %$r8   c                    t         S r1   )_default_dict_getterrV   s    r6   dict_getterzClassManager.dict_getters  s    ##r8   c                   |r|| j                   v r"y || j                   |<   | j                  ||       | j                          || |<   | j                  j	                         D ]&  }| j                  |      }|j                  ||d       ( y r{   )r^   install_descriptor_reset_memoizationsrD   __subclasses__r   instrument_attribute)r3   r   inst
propagatedr   managers         r6   r   z!ClassManager.instrument_attributew  s     d&&&$(DS!##C.  "S	;;--/C,,S1G((dD9 0r8   c              #     K   | j                   j                         D ]5  }t        |      }||| us| |s|j                  d      E d {    7 y 7 wr{   )rD   r   rd   subclass_managers)r3   	recursiver   rm   s       r6   r   zClassManager.subclass_managers  sS     ;;--/C&s+C3d?	"44T::: 0
 ;s    +AAAAAAc                `    t         j                  j                  | j                  || |          y r1   )r}   rJ   attribute_instrumentrD   r   s     r6   post_configure_attributez%ClassManager.post_configure_attribute  s%     ))>>KKd3i	
r8   c                   || vry |r|| j                   v ry | j                   |= | j                  |       | j                          | |= | j                  j	                         D ]"  }t        |      }|s|j                  |d       $ y r{   )r^   uninstall_descriptorr   rD   r   rd   uninstrument_attribute)r3   r   r   r   r   s        r6   r   z#ClassManager.uninstrument_attribute  s    d?d&&&  %%%c*  "I;;--/C*3/G..sD9 0r8   c                   t        | j                        D ]  }| j                  |        d| _        d| _        d| _        | j                  j                          t        |       D ]"  }|| j                  v s| j                  |       $ | j                  | j                  j                  v r!t        | j                  | j                         yy)z<remove all instrumentation established by this ClassManager.N)listr_   uninstall_memberrr   rJ   r]   r\   clearr^   r   r   rD   rk   delattrr   s     r6   
unregisterzClassManager.unregister  s     'C!!#& ( 		:Cd&&&++C0   4 44DKK!2!23 5r8   c                    || j                   | j                  fv rt        d|z        t        | j                  ||       y NzW%r: requested attribute name conflicts with instrumentation attribute of the same name.)
STATE_ATTRr   KeyErrorr   rD   )r3   r   r   s      r6   r   zClassManager.install_descriptor  sH     4??D$5$566>@CD  	S$'r8   c                0    t        | j                  |       y r1   )r   rD   r   s     r6   r   z!ClassManager.uninstall_descriptor  s    S!r8   c                
   || j                   | j                  fv rt        d|z        | j                  j	                  || j
                  j                  j                  |t                     t        | j
                  ||       y r   )
r   r   r   r_   r   rD   rk   getr-   r   )r3   r   implementations      r6   r   zClassManager.install_member  sq    4??D$5$566>@CD  	!!#t{{';';'?'?X'NOS.1r8   c                    | j                   j                  |d       }|t        urt        | j                  ||       y t        | j                  |       y r1   )r_   popr-   r   rD   r   )r3   r   originals      r6   r   zClassManager.uninstall_member  s>    >>%%c408#DKKh/DKK%r8   c                ,    t        j                  |      S r1   )r   prepare_instrumentation)r3   r   collection_classs      r6   instrument_collection_classz(ClassManager.instrument_collection_class  s     223CDDr8   c                     |       }| j                  |      }t        |      sJ t        j                  |||      }||fS r1   )get_implr   r   CollectionAdapter)r3   r   r   rO   	user_datar   adapters          r6   initialize_collectionz"ClassManager.initialize_collection  sF     I	}}S!,T222//eYG	!!r8   c                *    |r|| v S || j                   v S r1   )r^   )r3   r   searchs      r6   is_instrumentedzClassManager.is_instrumented  s     $;$****r8   c                     | |   j                   S r1   r   r   s     r6   r   zClassManager.get_impl  s    Cy~~r8   c                4    t        | j                               S r1   )iterr   rV   s    r6   
attributeszClassManager.attributes  s    DKKM""r8   c                    | j                   j                  | j                         }|| j                  ||       }| j                  ||       |S r1   )rD   __new__r   _state_setter)r3   r   instances      r6   new_instancezClassManager.new_instance  sH    
 ;;&&t{{3=++Hd;E8U+r8   c                P    || j                  ||       }| j                  ||       y r1   )r   r   r3   r   r   s      r6   setup_instancezClassManager.setup_instance  s+     =++Hd;E8U+r8   c                0    t        || j                         y r1   )r   r   r3   r   s     r6   teardown_instancezClassManager.teardown_instance  s    $//*r8   c                    t        ||      S r1   )_SerializeManager)r3   r   
state_dicts      r6   
_serializezClassManager._serialize  s     !
33r8   c                   t        || j                        ry| j                  |j                  ur6| j                  r*| j                  |j                        j                  |      S | j                  ||       }| j                  ||       |S )zInstall a default InstanceState if none is present.

        A private convenience method used by the __init__ decorator.

        F)	hasattrr   rD   	__class__r   r   _new_state_if_noner   r   r   s      r6   r  zClassManager._new_state_if_none  s     8T__-[[ 2 22t~~ ))""  *+ ++Hd;Ex/Lr8   c                .    t        || j                        S r1   )r  r   r   s     r6   	has_statezClassManager.has_state(  s    x11r8   c                F    | j                  |      j                  ||      S )TODO)
optimistic)r   	hasparent)r3   r   r   r  s       r6   
has_parentzClassManager.has_parent+  s#     }}S!++Ej+IIr8   c                     y)z=All ClassManagers are non-zero regardless of attribute state.Tr2   rV   s    r6   __bool__zClassManager.__bool__1  s    r8   c                `    d| j                   j                  | j                  t        |       fz  S )Nz<%s of %r at %x>)r  r=   rD   r   rV   s    r6   __repr__zClassManager.__repr__5  s/    !NN##KKtH%
 
 	
r8   )FNNNNN)rx   boolrr   Optional[Mapper[_O]]rQ   Optional[_RegistryType]rP   Optional[_MapperConfig]rK   &Optional[_ExpiredAttributeLoaderProto]rM   rL   r:   r;   )r:   r;   )r:   int)r   r   r:   r  )r:   r  )r:   z
Mapper[_O]r1   )r   strr:   r  )r   zType[_T]r:   zClassManager[_T])r:   zType[state.InstanceState[_O]])F)r   r  r   QueryableAttribute[Any]r   r  r:   r;   )r   r  r   r  r:   r;   )r   r  r:   r;   )r   r  r   r   r:   r;   )r   r  r   zType[Collection[Any]]r:   r%   )r   r  r   InstanceState[_O]rO   r%   r:   z@Tuple[collections.CollectionAdapter, _AdaptedCollectionProtocol])r   r  r   r  r:   r  )r   r  r:   r"   )r:   zIterable[Any])r   Optional[InstanceState[_O]]r:   r   )r   r   r   r  r:   r;   )r   r   r:   r;   )r   r  r  Dict[str, Any]r:   r   )r   r   r:   z(Union[Literal[False], InstanceState[_O]])r   r   r:   r  )r   r  r   r  r  r  r:   r  )r:   r  )Fr=   r>   r?   __doc____annotations__r   DEFAULT_MANAGER_ATTRr   DEFAULT_STATE_ATTRr   staticmethodr   
attrsetterr   rN   rP   r   rQ   property
deprecatedrW   setterrp   ry   rw   r   r   r   r   memoized_attributer   r   r   r   memoized_propertyrr   r   r   r   r   r|   r   rj   hybridmethodr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r2   r8   r6   rI   rI   _   s    7**,,L((J !<=M::0..37M07&&=A:A##T__)
- - ""T__)
, #,+^ '+,048 59$$ %$ *	$
 2$#
$ 3$ 
$LH ) ) ## $ ##
 $

 ##
 $
 ##@ $@ 
2 2#B:37 
# #6
 
' ' 
% % 
$ $ !	:: &: 	:
 
:&;

: 4$((5(	("2&EE*?E	E

"
" !
" (	
"
 
J
"+ # #
	 BF,,#>,	,+4&44B4	4
	102 FKJ&J-0J>BJ	J
r8   rI   r  c                      e Zd ZdZddZd Zy)r   zProvide serialization of a :class:`.ClassManager`.

    The :class:`.InstanceState` uses ``__init__()`` on serialize
    and ``__call__()`` on deserialize.

    c                v    |j                   | _         |j                  }|j                  j                  ||       y r1   )rD   r   rJ   pickle)r3   r   dr   s       r6   rp   z_SerializeManager.__init__E  s,    ll--q)r8   c                ^   t        | j                        x|_        }|#t        j                  |d| j                  z        |j
                  r0|j                  j                  s|j                  j                          ||j                  ||       |j                  j                  ||       y )NzxCannot deserialize object of type %r - no mapper() has been configured for this class within the current Python process!)rd   rD   r   r   UnmappedInstanceErrorr   rr   
configured_check_configurer   rJ   unpickle)r3   r   r   r  r   s        r6   r7   z_SerializeManager.__call__J  s    "6t{{"CC?++" %)KK0  w~~'@'@NN++-
 ""4/!!%4r8   N)r   r9   r,  r  )r=   r>   r?   r  rp   r7   r2   r8   r6   r   r   =  s    *
5r8   r   c                  P    e Zd ZU dZded<   d	dZ	 	 	 	 d
dZ	 	 	 	 	 	 ddZddZy)InstrumentationFactoryz'Factory for new ClassManager instances.z"dispatcher[InstrumentationFactory]rJ   c                    |J t        |      J | j                  |      \  }}|t        }t        |      }n|J | j                  ||       ||_        |S r1   )rd   _locate_extended_factoryrI   _check_conflictsrO   )r3   rD   r   rO   s       r6   create_manager_for_clsz-InstrumentationFactory.create_manager_for_clsd  sr    !!!#F+333  88@?"G"6*G&&&fg.!r8   c                     y)z2Overridden by a subclass to do an extended lookup.)NNr2   rC   s     r6   r5  z/InstrumentationFactory._locate_extended_factoryx  s     r8   c                     y)z;Overridden by a subclass to test for conflicting factories.Nr2   )r3   rD   rO   s      r6   r6  z'InstrumentationFactory._check_conflicts~  s    r8   c                p    t        |      }|j                          | j                  j                  |       y r1   )manager_of_classr   rJ   class_uninstrument)r3   rD   r   s      r6   r   z!InstrumentationFactory.unregister  s*    "6*((0r8   NrE   )rD   rF   r:   z<Tuple[Optional[ClassManager[_O]], Optional[_ManagerFactory]])rD   rF   rO   z&Callable[[Type[_O]], ClassManager[_O]]r:   r;   )rD   rF   r:   r;   )	r=   r>   r?   r  r  r7  r5  r6  r   r2   r8   r6   r3  r3  _  sK    100(	EJJ)OJ	J
1r8   r3  c                x    t        |       }|t        j                  |       }|j                  ||||||       |S )z_Register class instrumentation.

    Returns the existing or newly created class manager.

    )rr   rQ   rP   rK   rM   rx   )rd   r}   r7  ry   )rD   rx   rr   rQ   rP   rK   rM   r   s           r6   r   r     sO     #6*G*AA&I)!9   Nr8   c                .    t         j                  |        y)z!Unregister class instrumentation.N)r}   r   )rD   s    r6   unregister_classr?    s     ''/r8   c                N    t        | j                        j                  |d      S )zReturn True if the given attribute on the given instance is
    instrumented by the attributes package.

    This function may be used regardless of instrumentation
    applied directly to the class, i.e. no descriptors are required.

    T)r   )r;  r  r   )r   r   s     r6   r   r     s-     H../??D @  r8   c                J   || j                   }d}t        j                  |d      }||z  }t        |dd      }t        |dd      }t	               j                         }t        |d<   t        ||       |d   }	|j                  |	_        ||	_	        |r||	_
        |r||	_        |	S )	z>Build an __init__ decorator that triggers ClassManager events.Nzdef __init__(%(apply_pos)s):
    new_state = class_manager._new_state_if_none(%(self_arg)s)
    if new_state:
        return new_state._initialize_instance(%(apply_kw)s)
    else:
        return original_init(%(apply_kw)s)
F)grouped__defaults____kwdefaults__r=   rp   )rp   r   format_argspec_initgetattrlocalscopyr=   execr  _sa_original_initrC  rD  )
rD   class_managerrN   	func_body	func_vars	func_textfunc_defaultsfunc_kw_defaultsenvrp   s
             r6   r   r     s     I ((FII%IM>4@M}.>E
(--/CC
OC:H$,,H!.H -"2Or8   )TNNNNN)rD   rF   rx   r  rr   r  rQ   r  rP   r  rK   r  rM   rL   r:   rG   )Hr  
__future__r   typingr   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r   rt    r   r   r   r   r   _typingr   r   r   r   eventr   r   util.typingr   r    r!   r"   r#   r$   r%   	decl_baser&   eventsr'   rr   r(   r)   r*   r+   symbolr-   r/   rA   r  rI   r   r3  r}   instance_stater   instance_dictr   r;  r   rd   _default_opt_manager_getterr   r?  r   r   r2   r8   r6   <module>r^     s  2 #                        5    ! "&).73(&$"T4;;z"8 Bh B[
'	'(BK	[
|5 5D'1[ '1X 23 
 *.)<)< <&'+'9'9 9$-1-B-B B *595N5N N 2
 #'(,04GK15 ! &	
 . E / <0
)r8   