o
    . hN                     @  s  U d Z ddlmZ ddlZddlZddl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 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  ej!sesd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( n$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d#ed$Z+ed%ed$Z,ed&ed$Z-ed'd(d)Z.e/ Z0d*e1d+< e/dgZ2d*e1d,< d{d1d2Z3d|d6d7Z4e# Z5d8e1d9< G d:d; d;e&e,e-f Z6ed<ed$Z7ed=ed$Z8G d>d? d?ee+ Z9G d@dA dAe9e+ Z:G dBdC dCe%e9e+ Z;d}dDdEZ<e=Z>e<Z?G dFdG dGee+ Z@G dHdI dIe$ZAG dJdK dKee,e-f ZBG dLdM dMee,e-f ZCeDZEe=ZFe'ZGG dNdO dOee+ ZHd~dRdSZId}ddWdXZJdd^d_ZKd`da ZLddcddZM	d}ddidjZNddmdnZOG dodp dpejPe,e-f ZQG dqdr dre e. ZRG dsdt dte ZSG dudv dvee+ ZTG dwdx dxeTe+ ZUdydz ZVdS )zCollection classes and helpers.    )annotationsN)Any)Callable)cast)	Container)Dict)	FrozenSet)Generic)Iterable)Iterator)List)Mapping)NoReturn)Optional)overload)Sequence)Set)Tuple)TypeVar)Union)
ValuesView   )HAS_CYEXTENSION)is_non_string_iterable)Literal)Protocol)immutabledict)IdentitySet)ReadOnlyContainer)ImmutableDictBase)
OrderedSet)unique_list_T)bound_KT_VT_T_coT)	covariantzFrozenSet[Any]	EMPTY_SETNONE_SETa	List[Any]breturnc                 C  sl   t | |}g }t| t|}}	 |D ]}||v r'|| ||}} n|| q|| 	 |S q)af  merge two lists, maintaining ordering as much as possible.

    this is to reconcile vars(cls) with cls.__annotations__.

    Example::

        >>> a = ["__tablename__", "id", "x", "created_at"]
        >>> b = ["id", "name", "data", "y", "created_at"]
        >>> merge_lists_w_ordering(a, b)
        ['__tablename__', 'id', 'name', 'data', 'y', 'x', 'created_at']

    This is not necessarily the ordering that things had on the class,
    in this case the class is::

        class User(Base):
            __tablename__ = "users"

            id: Mapped[int] = mapped_column(primary_key=True)
            name: Mapped[str]
            data: Mapped[Optional[str]]
            x = Column(Integer)
            y: Mapped[int]
            created_at: Mapped[datetime.datetime] = mapped_column()

    But things are *mostly* ordered.

    The algorithm could also be done by creating a partial ordering for
    all items in both lists and then using topological_sort(), but that
    is too much overhead.

    Background on how I came up with this is at:
    https://gist.github.com/zzzeek/89de958cf0803d148e74861bd682ebae

    )setintersectioniterdiscardappendextend)r*   r,   Zoverlapresultcurrentotherelement r8   d/var/www/html/figdemos/bartoux_crm/venv/lib/python3.10/site-packages/sqlalchemy/util/_collections.pymerge_lists_w_orderingL   s   #


r:   dMapping[_KT, _VT]immutabledict[_KT, _VT]c                 C  s   | st S t| tr| S t| S N)
EMPTY_DICT
isinstancer   r;   r8   r8   r9   coerce_to_immutabledict   s
   
rB   zimmutabledict[Any, Any]r?   c                   @  sB   e Zd ZdZdddZdd	d
ZdddZdddZdddZdS )
FacadeDictz*A dictionary that is not publicly mutable.argsr   r-   FacadeDict[Any, Any]c                 G  s   t | }|S r>   )r   __new__)clsrD   newr8   r8   r9   rF      s   
zFacadeDict.__new__r   c                 C  s   t d)Nz\an immutabledict shouldn't need to be copied.  use dict(d) if you need a mutable dictionary.)NotImplementedErrorselfr8   r8   r9   copy   s   zFacadeDict.copyc                 C  s   t t| ffS r>   )rC   dictrJ   r8   r8   r9   
__reduce__      zFacadeDict.__reduce__keyr$   valuer%   Nonec                 C  s   t | || dS )z,insert an item into the dictionary directly.N)rM   __setitem__rK   rP   rQ   r8   r8   r9   _insert_item      zFacadeDict._insert_itemstrc                 C  s   dt |  S )NzFacadeDict(%s))rM   __repr__rJ   r8   r8   r9   rX      rO   zFacadeDict.__repr__N)rD   r   r-   rE   )r-   r   r-   r   rP   r$   rQ   r%   r-   rR   )r-   rW   )	__name__
__module____qualname____doc__rF   rL   rN   rU   rX   r8   r8   r8   r9   rC      s    



rC   _DT_Fc                      s  e Zd ZU dZdZded< dKddZdLd
dZdMddZdN fddZ	dOddZ
dPddZdQddZdRd d!ZdPd"d#ZdSd%d&ZdTd(d)ZdQd*d+ZdUd-d.ZdVd0d1ZdWd3d4ZedXd6d7ZedYd:d7Z	;dZd[d>d7ZdNd?d@Zd\dBdCZd]dEdFZdUdGdHZd^dIdJZ  ZS )_
Propertiesz8Provide a __getattr__/__setattr__ interface over a dict._dataDict[str, _T]rc   datac                 C  s   t | d| d S Nrc   object__setattr__)rK   re   r8   r8   r9   __init__      zProperties.__init__r-   intc                 C  
   t | jS r>   lenrc   rJ   r8   r8   r9   __len__      
zProperties.__len__Iterator[_T]c                 C  s   t t| j S r>   )r0   listrc   valuesrJ   r8   r8   r9   __iter__   rk   zProperties.__iter__	List[str]c                   s   t t dd | j D  S )Nc                 S  s   g | ]}t |qS r8   )rW   .0kr8   r8   r9   
<listcomp>   s    z&Properties.__dir__.<locals>.<listcomp>)dirsuperrc   keysrJ   	__class__r8   r9   __dir__   s   zProperties.__dir__r6   Properties[_F]List[Union[_T, _F]]c                 C  s   t | t | S r>   )rs   )rK   r6   r8   r8   r9   __add__      zProperties.__add__rP   rW   objr"   rR   c                 C     || j |< d S r>   rb   rK   rP   r   r8   r8   r9   rS      rO   zProperties.__setitem__c                 C  s
   | j | S r>   rb   rK   rP   r8   r8   r9   __getitem__   rq   zProperties.__getitem__c                 C     | j |= d S r>   rb   r   r8   r8   r9   __delitem__      zProperties.__delitem__c                 C  r   r>   rb   r   r8   r8   r9   ri      rO   zProperties.__setattr__Dict[str, Any]c                 C  s
   d| j iS rf   rb   rJ   r8   r8   r9   __getstate__   rq   zProperties.__getstate__statec                 C  s   t | d|d  d S rf   rg   )rK   r   r8   r8   r9   __setstate__   s   zProperties.__setstate__c                 C  s$   z| j | W S  ty   t|w r>   )rc   KeyErrorAttributeErrorr   r8   r8   r9   __getattr__   s
   zProperties.__getattr__boolc                 C  
   || j v S r>   rb   r   r8   r8   r9   __contains__   rq   zProperties.__contains__ReadOnlyProperties[_T]c                 C  rm   )z8Return an immutable proxy for this :class:`.Properties`.)ReadOnlyPropertiesrc   rJ   r8   r8   r9   as_readonly   s   
zProperties.as_readonlyrQ   c                 C  s   | j | d S r>   )rc   update)rK   rQ   r8   r8   r9   r      r   zProperties.updateOptional[_T]c                 C     d S r>   r8   r   r8   r8   r9   get      zProperties.getdefaultUnion[_DT, _T]c                 C  r   r>   r8   rK   rP   r   r8   r8   r9   r      r   NOptional[Union[_DT, _T]]Optional[Union[_T, _DT]]c                 C  s   || v r| | S |S r>   r8   r   r8   r8   r9   r      s   c                 C  rm   r>   )rs   rc   rJ   r8   r8   r9   r}      rq   zProperties.keysList[_T]c                 C     t | j S r>   )rs   rc   rt   rJ   r8   r8   r9   rt      rO   zProperties.valuesList[Tuple[str, _T]]c                 C  r   r>   )rs   rc   itemsrJ   r8   r8   r9   r      rO   zProperties.itemsc                 C  r   r>   rb   r   r8   r8   r9   has_key   rq   zProperties.has_keyc                 C  s   | j   d S r>   )rc   clearrJ   r8   r8   r9   r      rO   zProperties.clear)re   rd   r-   rl   r-   rr   )r-   rv   )r6   r   r-   r   )rP   rW   r   r"   r-   rR   )rP   rW   r-   r"   )rP   rW   r-   rR   )r-   r   )r   r   r-   rR   )rP   rW   r-   r   )r-   r   )rQ   rd   r-   rR   )rP   rW   r-   r   )rP   rW   r   r   r-   r   r>   )rP   rW   r   r   r-   r   )r-   r   )r-   r   r-   rR   )r[   r\   r]   r^   	__slots____annotations__rj   rp   ru   r   r   rS   r   r   ri   r   r   r   r   r   r   r   r   r}   rt   r   r   r   __classcell__r8   r8   r~   r9   ra      s<   
 

















ra   c                   @  s   e Zd ZdZdZdd ZdS )OrderedPropertieszUProvide a __getattr__/__setattr__ interface with an OrderedDict
    as backing store.r8   c                 C  s   t | t  d S r>   )ra   rj   OrderedDictrJ   r8   r8   r9   rj   
  rk   zOrderedProperties.__init__N)r[   r\   r]   r^   r   rj   r8   r8   r8   r9   r     s    r   c                   @  s   e Zd ZdZdZdS )r   zDProvide immutable dict/object attribute to an underlying dictionary.r8   N)r[   r\   r]   r^   r   r8   r8   r8   r9   r     s    r   c                   s0    fddt  |dD }    | dS )zSort an OrderedDict in-place.c                   s   g | ]}| | fqS r8   r8   rw   rA   r8   r9   rz     s    z,_ordered_dictionary_sort.<locals>.<listcomp>)rP   N)sortedr   r   )r;   rP   r   r8   rA   r9   _ordered_dictionary_sort  s   r   c                   @  s8   e Zd ZddddZdd Zdd	 Zd
d Zdd ZdS )WeakSequencer8   _WeakSequence__elementsSequence[_T]c                   s0   t | fdd  | _ fdd|D | _d S )Nc                 S  s"   | }|d ur|j |  d S d S r>   )_storageremove)itemselfrefrK   r8   r8   r9   _remove&  s   z&WeakSequence.__init__.<locals>._removec                   s   g | ]}t | qS r8   )weakrefref)rx   r7   r   r8   r9   rz   ,  s    z)WeakSequence.__init__.<locals>.<listcomp>)r   r   r   r   )rK   r   r8   r   r9   rj   #  s
   
zWeakSequence.__init__c                 C  s   | j t|| j d S r>   )r   r2   r   r   r   )rK   r   r8   r8   r9   r2   0     zWeakSequence.appendc                 C  rm   r>   )ro   r   rJ   r8   r8   r9   rp   3  rq   zWeakSequence.__len__c                 C  s   dd dd | j D D S )Nc                 s  s    | ]	}|d ur|V  qd S r>   r8   )rx   r   r8   r8   r9   	<genexpr>7  s    z(WeakSequence.__iter__.<locals>.<genexpr>c                 s  s    | ]}| V  qd S r>   r8   )rx   r   r8   r8   r9   r   8  s    )r   rJ   r8   r8   r9   ru   6  s   zWeakSequence.__iter__c                 C  s.   z	| j | }W | S  ty   td| w )NzIndex %s out of range)r   r   
IndexError)rK   indexr   r8   r8   r9   r   ;  s   zWeakSequence.__getitem__N)r8   )r   r   )r[   r\   r]   rj   r2   rp   ru   r   r8   r8   r8   r9   r   "  s    r   c                   @  s   e Zd ZddddZdS )OrderedIdentitySetNiterableOptional[Iterable[Any]]c                 C  s2   t |  t | _|r|D ]	}| | qd S d S r>   )r   rj   r   Z_membersadd)rK   r   or8   r8   r9   rj   E  s   
zOrderedIdentitySet.__init__r>   )r   r   )r[   r\   r]   rj   r8   r8   r8   r9   r   D  s    r   c                   @  $   e Zd ZdZdddZdd	d
ZdS )PopulateDictzA dict which populates missing values via a creation function.

    Note the creation function takes a key, unlike
    collections.defaultdict.

    creatorCallable[[_KT], _VT]c                 C  s
   || _ d S r>   r   )rK   r   r8   r8   r9   rj   U  rq   zPopulateDict.__init__rP   r   r-   c                 C  s   |  | | |< }|S r>   r   rK   rP   valr8   r8   r9   __missing__X  s   zPopulateDict.__missing__N)r   r   rP   r   r-   r   r[   r\   r]   r^   rj   r   r8   r8   r8   r9   r   M  s    
r   c                   @  r   )WeakPopulateDictzaLike PopulateDict, but assumes a self + a method and does not create
    a reference cycle.

    creator_methodtypes.MethodTypec                 C  s   |j | _|j}t|| _d S r>   )__func__r   __self__r   r   weakself)rK   r   r   r8   r8   r9   rj   c  s   zWeakPopulateDict.__init__rP   r   r-   c                 C  s   |  |  | | |< }|S r>   )r   r   r   r8   r8   r9   r   h  s   zWeakPopulateDict.__missing__N)r   r   r   r   r8   r8   r8   r9   r   ]  s    
r   c                   @  sP   e Zd ZU dZdZded< ded< ded< 		ddddZdddZdddZd	S )UniqueAppenderzAppends items to a collection ensuring uniqueness.

    Additional appends() of the same object are ignored.  Membership is
    determined by identity (``is a``) not equality (``==``).
    )re   _data_appender_unique&Union[Iterable[_T], Set[_T], List[_T]]re   zCallable[[_T], None]r   zDict[int, Literal[True]]r   NviaOptional[str]c                 C  s\   || _ i | _|rt||| _d S t|drtd|j| _d S t|dr,td|j| _d S d S )Nr2   r   r   zSet[_T])re   r   getattrr   hasattrr   r2   r   )rK   re   r   r8   r8   r9   rj     s   

zUniqueAppender.__init__r   r"   r-   rR   c                 C  s.   t |}|| jvr| | d| j|< d S d S )NT)idr   r   )rK   r   Zid_r8   r8   r9   r2     s
   

zUniqueAppender.appendrr   c                 C  rm   r>   )r0   re   rJ   r8   r8   r9   ru     rq   zUniqueAppender.__iter__r>   )re   r   r   r   )r   r"   r-   rR   r   )	r[   r\   r]   r^   r   r   rj   r2   ru   r8   r8   r8   r9   r   v  s   
 
r   argr   c                 C  s2   t | dkrt| d tjrt| d S td| S )Nr   r   r+   )ro   r@   typesGeneratorTypers   r   )r   r8   r8   r9   coerce_generator_arg  s   
r   xr   Optional[List[Any]]c                 C  s0   | d u r|S t | s| gS t| tr| S t| S r>   )r   r@   rs   )r   r   r8   r8   r9   to_list  s   
r   set_Container[Any]r   Iterable[Any]r   c                   s   t  fdd|D S )zreturn True if any items of set\_ are present in iterable.

    Goes through special effort to ensure __hash__ is not called
    on items in iterable that don't support it.

    c                 3  s    | ]
}|j r| v V  qd S r>   )__hash__)rx   ir   r8   r9   r     s    z#has_intersection.<locals>.<genexpr>)any)r   r   r8   r   r9   has_intersection  s   r   c                 C  (   | d u rt  S t| t st t| S | S r>   )r.   r@   r   r   r8   r8   r9   to_set  
   
r   Set[Any]c                 C  r   r>   )
column_setr@   r   r   r8   r8   r9   to_column_set  r   r   Dict[Any, Any]_newOptional[Dict[Any, Any]]kwc                 K  s*   |   } |r| | | jdi | | S )z5Copy the given dict and update with the given values.Nr8   )rL   r   )r;   r   r   r8   r8   r9   update_copy  s
   
r   Iterable[_T]rr   c                 c  s:    | D ]}t |tst|drt|E dH  q|V  qdS )zGiven an iterator of which further sub-elements may also be
    iterators, flatten the sub-elements into a single iterator.

    ru   N)r@   rW   r   flatten_iterator)r   elemr8   r8   r9   r     s   r   c                   @  s   e Zd ZU dZdZded< ded< ded< 			
	d2d3ddZdd Zed4ddZ	ed5ddZ		d6d7ddZ	d8ddZ
d9d d!Zd:d"d#Zd;d%d&Zd<d)d*Zd=d,d-Zed>d.d/Zd?d0d1ZdS )@LRUCachezDictionary with 'squishy' removal of least
    recently used items.

    Note that either get() or [] should be used here, but
    generally its not safe to do an "in" check first as the dictionary
    can change subsequent to that call.

    )capacity	threshold
size_alertrc   _counter_mutexrl   r   floatr  z.Optional[Callable[[LRUCache[_KT, _VT]], None]]r  d         ?NOptional[Callable[..., None]]c                 C  s,   || _ || _|| _d| _t | _i | _d S )Nr   )r   r  r  r  	threadingLockr  rc   )rK   r   r  r  r8   r8   r9   rj     s   

zLRUCache.__init__c                 C  s   |  j d7  _ | j S )Nr   )r  rJ   r8   r8   r9   _inc_counter  s   zLRUCache._inc_counterrP   r$   r-   Optional[_VT]c                 C  r   r>   r8   r   r8   r8   r9   r   
  r   zLRUCache.getr   Union[_VT, _T]c                 C  r   r>   r8   r   r8   r8   r9   r     r   Optional[Union[_VT, _T]]c                 C  s0   | j |}|d ur|  |d d< |d S |S N   r   r   )rc   r   r  )rK   rP   r   r   r8   r8   r9   r     s
   r%   c                 C  s"   | j | }|  |d d< |d S r  )rc   r  )rK   rP   r   r8   r8   r9   r     s   
zLRUCache.__getitem__Iterator[_KT]c                 C  rm   r>   )r0   rc   rJ   r8   r8   r9   ru     rq   zLRUCache.__iter__c                 C  rm   r>   rn   rJ   r8   r8   r9   rp   "  rq   zLRUCache.__len__ValuesView[_VT]c                 C  s   t dd | j D S )Nc                 S  s   i | ]	\}}||d  qS )r   r8   )rx   ry   r   r8   r8   r9   
<dictcomp>&  s    z#LRUCache.values.<locals>.<dictcomp>)typingr   rc   r   rJ   r8   r8   r9   rt   %  r   zLRUCache.valuesrQ   rR   c                 C  s"   |||   gf| j|< |   d S r>   )r  rc   _manage_sizerT   r8   r8   r9   rS   (  s   zLRUCache.__setitem___LRUCache__vc                 C  r   r>   rb   )rK   r  r8   r8   r9   r   ,  r   zLRUCache.__delitem__c                 C  s   | j | j | j  S r>   )r   r  rJ   r8   r8   r9   size_threshold/  rV   zLRUCache.size_thresholdc              	   C  s   | j dsd S z`t| j}t| | j| j| j  kra|r$d}| |  t| j	 t
ddd}|| jd  D ]}z| j|d = W q8 tyK   Y q8w t| | j| j| j  ksW | j   d S W | j   d S | j   w )NFr  T)rP   reverser   )r  acquirer   r  ro   r   r  r   rc   rt   operator
itemgetterr   release)rK   r  Z
by_counterr   r8   r8   r9   r  3  s.   

zLRUCache._manage_size)r  r  N)r   rl   r  r  r  r  )rP   r$   r-   r  )rP   r$   r   r  r-   r  r>   )rP   r$   r   r  r-   r  )rP   r$   r-   r%   )r-   r  r   )r-   r  rZ   )r  r$   r-   rR   )r-   r  r   )r[   r\   r]   r^   r   r   rj   r  r   r   r   ru   rp   rt   rS   r   propertyr  r  r8   r8   r8   r9   r     s4   
 		






r   c                   @     e Zd ZdddZdS )_CreateFuncTyper-   r&   c                 C  r   r>   r8   rJ   r8   r8   r9   __call__L      z_CreateFuncType.__call__N)r-   r&   r[   r\   r]   r   r8   r8   r8   r9   r  K      r  c                   @  r  )_ScopeFuncTyper-   r   c                 C  r   r>   r8   rJ   r8   r8   r9   r   P  r!  z_ScopeFuncType.__call__NrY   r"  r8   r8   r8   r9   r$  O  r#  r$  c                   @  s`   e Zd ZU dZdZded< ded< ded< dddZdddZdddZdddZ	dddZ
dS ) ScopedRegistrya  A Registry that can store one or multiple instances of a single
    class on the basis of a "scope" function.

    The object implements ``__call__`` as the "getter", so by
    calling ``myregistry()`` the contained object is returned
    for the current scope.

    :param createfunc:
      a callable that returns a new object to be placed in the registry

    :param scopefunc:
      a callable that will return a key to store/retrieve an object.
    
createfunc	scopefuncregistryz_CreateFuncType[_T]r'  r$  r(  r   r)  Callable[[], _T]Callable[[], Any]c                 C  s   || _ || _i | _dS )aV  Construct a new :class:`.ScopedRegistry`.

        :param createfunc:  A creation function that will generate
          a new value for the current scope, if none is present.

        :param scopefunc:  A function that returns a hashable
          token representing the current scope (such as, current
          thread identifier).

        Nr&  )rK   r'  r(  r8   r8   r9   rj   h  s   
zScopedRegistry.__init__r-   r"   c                 C  s:   |   }z| j| W S  ty   | j||   Y S w r>   )r(  r)  r   
setdefaultr'  r   r8   r8   r9   r   y  s   zScopedRegistry.__call__r   c                 C  s   |   | jv S )z9Return True if an object is present in the current scope.)r(  r)  rJ   r8   r8   r9   has  s   zScopedRegistry.hasr   rR   c                 C  s   || j |  < dS )z$Set the value for the current scope.N)r)  r(  rK   r   r8   r8   r9   r.     s   zScopedRegistry.setc                 C  s(   z	| j |  = W dS  ty   Y dS w )z Clear the current scope, if any.N)r)  r(  r   rJ   r8   r8   r9   r     s
   zScopedRegistry.clearN)r'  r*  r(  r+  r-   r"   r-   r   r   r"   r-   rR   r   )r[   r\   r]   r^   r   r   rj   r   r-  r.   r   r8   r8   r8   r9   r%  S  s   
 



r%  c                   @  sB   e Zd ZdZdddZddd	ZdddZdddZdddZdS )ThreadLocalRegistryz\A :class:`.ScopedRegistry` that uses a ``threading.local()``
    variable for storage.

    r'  r*  c                 C  s   || _ t | _d S r>   )r'  r	  localr)  )rK   r'  r8   r8   r9   rj     s   zThreadLocalRegistry.__init__r-   r"   c                 C  s2   z| j jW S  ty   |   }| j _| Y S w r>   )r)  rQ   r   r'  )rK   r   r8   r8   r9   r     s   
zThreadLocalRegistry.__call__r   c                 C  s   t | jdS )NrQ   )r   r)  rJ   r8   r8   r9   r-    r   zThreadLocalRegistry.hasr   rR   c                 C  s   || j _d S r>   )r)  rQ   r.  r8   r8   r9   r.     r   zThreadLocalRegistry.setc                 C  s"   z| j `W d S  ty   Y d S w r>   )r)  rQ   r   rJ   r8   r8   r9   r     s
   zThreadLocalRegistry.clearN)r'  r*  r/  r0  r1  r   )	r[   r\   r]   r^   rj   r   r-  r.   r   r8   r8   r8   r9   r2    s    



r2  c                 C  s0   d}| D ]}||u r|d7 }|dkr dS qdS )zrGiven a sequence and search object, return True if there's more
    than one, False if zero or one of them.


    r   r   TFr8   )sequencetargetcr   r8   r8   r9   	has_dupes  s   
r7  )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   r-   r   )r   r   r-   r   )r;   r   r   r   r   r   r-   r   )r   r   r-   rr   )Wr^   
__future__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   r   Z_has_cyr   r   r   r   TYPE_CHECKINGZ_py_collectionsr   r   r   r   r    r!   Z$sqlalchemy.cyextension.immutabledictZ"sqlalchemy.cyextension.collectionsr"   r$   r%   r&   	frozensetr(   r   r)   r:   rB   r?   rC   r_   r`   ra   r   r   r   rM   r   sort_dictionaryr   r   r   r   r.   r   column_dictordered_column_setr   r   r   r   r   r   r   r   MutableMappingr   r  r$  r%  r2  r7  r8   r8   r8   r9   <module>   s   


8	W


"	
%


	

i@