� l\�g�;���UdZddlmZddlZddlmZddlmZddlmZddlmZddlmZdd lm Z dd lm Z dd lm Z dd lm Z dd lm Z ddlmZddlmZddlmZddlZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZeje��Z de!d<d6d!�Z"Gd"�d#��Z#Gd$�d%ee��Z$Gd&�d'e$e��Z%d7d+�Z&Gd,�d-ee��Z'Gd.�d/e$e��Z(Gd0�d1e'e��Z)Gd2�d3ee��Z*Gd4�d5e*e��Z+dS)8a�Base implementation classes. The public-facing ``Events`` serves as the base class for an event interface; its public attributes represent different kinds of events. These attributes are mirrored onto a ``_Dispatch`` class, which serves as a container for collections of listener functions. These collections are represented both at the class level of a particular ``_Dispatch`` class as well as within instances of ``_Dispatch``. �)� annotationsN)�Any)�cast)�Dict)�Generic)�Iterator)�List)�Mapping)�MutableMapping)�Optional)�overload)�Tuple)�Type)�Union�)�_ClsLevelDispatch)�_EmptyListener)�_InstanceLevelDispatch)�_JoinedListener)�_ET)� _EventKey�)�util)�Literalz8MutableMapping[str, List[Type[_HasEventsDispatch[Any]]]]� _registrars�name�str�return�boolc�d�|�d�� o|dkp|�d��S)N�_�dispatch� _sa_event)� startswith)rs �e/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/sqlalchemy/event/base.py�_is_event_namer&2s9�� �O�O�C� � � �7�T�Z�%7� &� ���� %� %�&�c��eZdZdZdd�ZdS) �_UnpickleDispatchz�Serializable callable that re-generates an instance of :class:`_Dispatch` given a particular :class:`.Events` subclass. � _instance_cls� Type[_ET]r�_Dispatch[_ET]c��|jD]@}d|jvr5td|jdj���|��cS�At d���)Nr"r,z*No class with a 'dispatch' member present.)�__mro__�__dict__rr"� _for_class�AttributeError)�selfr*�clss r%�__call__z_UnpickleDispatch.__call__Bsq�� �(� O� O�C��S�\�)�)��$�c�l�:�&>�&G����*�]�+�+�,�,�,�*� !�!M�N�N� Nr'N)r*r+rr,)�__name__� __module__� __qualname__�__doc__r4�r'r%r)r)<s8�������� O�O�O�O�O�Or'r)c�F�eZdZUdZded<dd�Zdd �Zedd���ZdS)�_DispatchCommonr9�Optional[Type[_ET]]r*�other�_DispatchCommon[_ET]r�_JoinedDispatcher[_ET]c��t����N��NotImplementedError�r2r=s r%�_joinz_DispatchCommon._joinQ���!�#�#�#r'rr�_InstanceLevelDispatch[_ET]c��t���rArB�r2rs r%� __getattr__z_DispatchCommon.__getattr__TrFr'�Type[_HasEventsDispatch[_ET]]c��t���rArB�r2s r%�_eventsz_DispatchCommon._eventsWs��!�#�#�#r'N�r=r>rr?�rrrrG�rrK) r5r6r7� __slots__�__annotations__rErJ�propertyrNr9r'r%r;r;Lso��������I�&�&�&�&�$�$�$�$�$�$�$�$��$�$�$��X�$�$�$r'r;c���eZdZUdZdZded<ej��Zded<ded<d ed <d ed <d ed<ded< d3d4d�Z d5d�Z e d6d���Z d7d"�Z d8d%�Zd9d(�Zd:d,�Zd;d.�Z d<d=d1�Zd>d2�ZdS)?� _DispatchaMMirror the event listening definitions of an Events class with listener collections. Classes which define a "dispatch" member will return a non-instantiated :class:`._Dispatch` subclass when the member is accessed at the class level. When the "dispatch" member is accessed at the instance level of its owner, an instance of the :class:`._Dispatch` class is returned. A :class:`._Dispatch` class is generated for each :class:`.Events` class defined, by the :meth:`._HasEventsDispatch._create_dispatcher_class` method. The original :class:`.Events` classes remain untouched. This decouples the construction of :class:`.Events` subclasses from the implementation used by the event internals, and allows inspecting tools like Sphinx to work in an unsurprising way against the public API. )�_parentr*r/�_empty_listenersr�_active_historyz9MutableMapping[Type[_ET], Dict[str, _EmptyListener[_ET]]]�_empty_listener_regzDict[str, _EmptyListener[_ET]]rXz List[str]� _event_namesr<r*zType[_JoinedDispatcher[_ET]]�_joined_dispatch_clsrKrNN�parent�Optional[_Dispatch[_ET]]� instance_clsc����||_�|_�rL|�J� |j�|_dS#t$r&�fd�|jD��x|_|j�<YdSwxYwi|_dS)Nc�<��i|]}|jt|�����Sr9)rr)�.0�lsr_s �r%� <dictcomp>z&_Dispatch.__init__.<locals>.<dictcomp>�s7��������G�^�B� �=�=���r')rWr*rZrX�KeyError�_event_descriptors)r2r]r_s `r%�__init__z_Dispatch.__init__�s���� �� �)��� � '��%�%�%� �(,�(@��(N��%�%�%��� � � �����$�7������%��(@� �)�)�)�)� ����%'�D� !� !� !s�+�,A�ArrrrGc�� |j|}t||j|��|S#t$rt |���wxYwrA)rX�setattrrrer1)r2rrcs r%rJz_Dispatch.__getattr__�sZ�� ��&�t�,�B� �D�"�'�2� &� &� &��I�� � '� '� '� ��&�&� &� '���s � '�A� Iterator[_ClsLevelDispatch[_ET]]c#�BK�|jD]}t||��V��dSrA)r[�getattr)r2�ks r%rfz_Dispatch._event_descriptors�s=�����"� #� #�A��$��"�"� "� "� "� "� #� #r'� event_key�_EventKey[_ET]�kwr�Nonec �(�|jj|fi|��SrA)rN�_listen�r2rnrps r%rsz_Dispatch._listen�s��#�t�|�#�I�4�4��4�4�4r'r+r,c�.�|�||��SrA)� __class__)r2r_s r%r0z_Dispatch._for_class�s���~�~�d�L�1�1�1r'�instancerc�:�|j}|�|��SrA)rvr0)r2rwr_s r%� _for_instancez_Dispatch._for_instance�s���)� ����|�,�,�,r'r=r>r?c�N�d|jjvsJ�|�||��S)z�Create a 'join' of this :class:`._Dispatch` and another. This new dispatcher will dispatch events to both :class:`._Dispatch` objects. r\)rvr/r\rDs r%rEz_Dispatch._join�s0��&���)@�@�@�@�@��(�(��u�5�5�5r'�Union[str, Tuple[Any, ...]]c�.�t��|jffSrA)r)r*rMs r%� __reduce__z_Dispatch.__reduce__�s�� �"�"�T�%7�$9�9�9r'T�only_propagatec���|jD]U}t|t��r�t||j���|���||����VdS)zIPopulate from the listeners in another :class:`_Dispatch` object.)r~N)rf� isinstancerrlr� for_modify�_update)r2r=r~rcs r%r�z_Dispatch._update�sv�� �*� � �B��"�n�-�-� �� �D�"�'� "� "� -� -�d� 3� 3� ;� ;��>� <� � � � � � r'c�h�|jD])}|�|������*dSrA)rfr��clear)r2rcs r%�_clearz_Dispatch._clear�s?���)� (� (�B� �M�M�$� � � %� %� '� '� '� '� (� (r'rA)r]r^r_r<rP)rrj�rnrorprrrq)r_r+rr,)rwrrr,rO)rr{)T)r=r,r~rrrq�rrq)r5r6r7r8rRrS�weakref�WeakKeyDictionaryrZrgrJrTrfrsr0ryrEr}r�r�r9r'r%rVrV\s����������*K�I����� "��!�#�#��$�$�$�$�5�4�4�4�����&�&�&�&�6�6�6�6�*�*�*�*��-1�'�'�'�'�'�, � � � ��#�#�#��X�#� 5�5�5�5�2�2�2�2�-�-�-�-� 6� 6� 6� 6�:�:�:�:�=A� � � � � �(�(�(�(�(�(r'rVr3rKrqc��|jjD]7}t|�|��t|st|=�8dSrA)r"r[r�remove)r3rms r%�_remove_dispatcherr��sL�� �\� &�����A����c�"�"�"��1�~� ��A����r'c��eZdZUded< ded< ejrd'd �Zd(d �Zed)d���Z eddddd�d*d���Z e d+d���Z ed,d%���Z d&S)-�_HasEventsDispatchr<�_dispatch_targetr,r"rrrrGc��dSrAr9rIs r%rJz_HasEventsDispatch.__getattr__�s���r'rqc�R�|�|j|j|j��dS)zOIntercept new Event subclasses and create associated _Dispatch classes.N)�_create_dispatcher_classr5� __bases__r/�r3s r%�__init_subclass__z$_HasEventsDispatch.__init_subclass__�s(�� �$�$�S�\�3�=�#�,�O�O�O�O�Or'�target�Union[_ET, Type[_ET]]� identifier�Optional[Union[_ET, Type[_ET]]]c��t���rArB)r3r�r�s r%� _accept_withz_HasEventsDispatch._accept_with�s��"�#�#�#r'F�� propagate�insert�named�asynciornror�rr�r�r�c��t���rArB�r3rnr�r�r�r�s r%rsz_HasEventsDispatch._listen�s��"�#�#�#r'�klassrK� dispatch_cls�Type[_Dispatch[_ET]]c�>�|d��|_||_|jSrA)r"rN)r�r�s r%� _set_dispatchz _HasEventsDispatch._set_dispatchs%��&��d�+�+���$� ���~�r'� classname�bases�Tuple[type, ...]�dict_�Mapping[str, Any]c ��t|d��r |jj}nt}d�|D��}t dt d|z|fd|i����}||_|�||��}|jD]G}t||t|||����t|� |���H|j D]i} t| t��rR| turI| jjjD]7} t|| j| ��|j� | j���8�jt#|dd��rM|j} | �J�t| d��rd| jvrt)|��| _nt+|��| _t d |jzt.fd|i��} | |_| t3��| j<dS) zVCreate a :class:`._Dispatch` class corresponding to an :class:`.Events` class.r"c�0�g|]}t|���|��Sr9)r&)rbrms r%� <listcomp>z?_HasEventsDispatch._create_dispatcher_class.<locals>.<listcomp>%s%��=�=�=�Q�>�!�+<�+<�=�q�=�=�=r'r�z %sDispatchrRr�N�_slots_dispatchzJoined%s)�hasattrr"rvrVr�typer[r�rirr�appendr�� issubclassrNrfrrlr�rR�slots_dispatcher� dispatcherr5�_JoinedDispatcherr\�globals) r3r�r�r�� dispatch_base� event_namesr�� dispatch_instrm�super_rc�dispatch_target_clsr�s r%r�z+_HasEventsDispatch._create_dispatcher_classs �� �3� � #� #� &��L�2�M�M�%�M�=�=�%�=�=�=� �� "� ��y�(�� ��k�*� � � � � �%0� �!��)�)�#�|�<�<� ��*� '� '�A� �M�1�&7��U�1�X�&F�&F� G� G� G� ��N� !� !�#� &� &� &� &�"�,� >� >�F��&�)�,�,� >��y�1H�1H� �.�1�D�>�>�B��M�2�7�B�7�7�7� �-�4�4�R�W�=�=�=�=�� �3�*�D� 1� 1� ?�"%�"6� �&�2�2�2��+�[�9�9� ?�%�)<�)F�F�F�/?��/D�/D�#�,�,�/9�#���#�,�� ��.� .� � � �+� &� � �� -2� �)�%*�� � �%�.�!�!�!r'NrPr��r�r�r�rrr�� rnror�rr�rr�rr�rrrq)r�rKr�r�rr,)r�rr�r�r�r�rrq)r5r6r7rS�typing� TYPE_CHECKINGrJr�� classmethodr�rs� staticmethodr�r�r9r'r%r�r��s�������)�)�)�)�;������ ��M�L�L�L�L�P�P�P�P� �$�$�$��[�$� �  ���� $� $� $� $� $��[� $�� � � ��\� ��7*�7*�7*��[�7*�7*�7*r'r�c�n�eZdZUdZdZded<ded<ded<dd�Zdd �Zdd�Zdd�Z e dd���Z dS)r�z5Represent a connection between two _Dispatch objects.��localr]r*r>r�r]r<r*c�D�||_||_|jj|_dSrAr�)r2r�r]s r%rgz_JoinedDispatcher.__init__Zs%���� ��� �!�Z�5����r'rrc�,�|j|j|jffSrA)rvr�r]rMs r%r}z_JoinedDispatcher.__reduce__as������T�[� 9�:�:r'rr�_JoinedListener[_ET]c��t|j|��}t|j|j|��}t ||j|��|SrA)rlr�rr]rri)r2rrc�jls r%rJz_JoinedDispatcher.__getattr__dsC���T�Z�� &� &�� �T�[�"�'�2� 6� 6����b�g�r�"�"�"�� r'rnrorprqc �(�|jj|fi|��SrA)r]rsrts r%rsz_JoinedDispatcher._listenls��"�t�{�"�9�3�3��3�3�3r'rKc��|jjSrA)r]rNrMs r%rNz_JoinedDispatcher._eventsos ���{�"�"r'N)r�r>r]r>)rr)rrrr�r�rQ) r5r6r7r8rRrSrgr}rJrsrTrNr9r'r%r�r�Qs��������?�?�2�I����� � � � �&�&�&�&�6�6�6�6�;�;�;�;�����4�4�4�4��#�#�#��X�#�#�#r'r�c�~�eZdZdZedd���Zed d d d d �dd���Zedd���Zedd���ZdS)�Eventsz>Define event listening functions for a particular target type.r�r�r�rrr�c����d �fd� }d �fd� }t�d��rW||jj��s@|t|jj��s%|t��r||jj��r�SdS) N�types� Type[Any]rrc�:��t�fd�|D����S)Nc3�B�K�|]}t�j|��V��dSrA)r�r")rb�tr�s �r%� <genexpr>z;Events._accept_with.<locals>.dispatch_is.<locals>.<genexpr>|s/�����E�E�!�z�&�/�1�5�5�E�E�E�E�E�Er')�all)r�r�s �r%� dispatch_isz(Events._accept_with.<locals>.dispatch_is{s&����E�E�E�E�u�E�E�E�E�E� Er'r�c����td�j��j}t|t��r*td|��j}t|t���*t||��S)Nr?)rr"r]r�r�)r�r]r�s �r%�dispatch_parent_isz/Events._accept_with.<locals>.dispatch_parent_is~sg����2�F�O�D�D�K�F��V�%6�7�7� G��6��?�?�F���V�%6�7�7� G��f�a�(�(� (r'r")r�r�rr)r�r�rr)r�r"rvr�r�)r3r�r�r�r�s ` r%r�zEvents._accept_withws���� F� F� F� F� F� F� )� )� )� )� )� )� �6�:� &� &� �� �C�L�2�3�3� ��;�t�S�\�%;�<�<� � �K� 1�2�2�  � +�*�3�<�+A�B�B�  �� ��tr'Fr�rnror�rr�r�r�rqc�8�|�||||���dS)Nr�)� base_listenr�s r%rszEvents._listen�s4�� �����e�W� � � � � � r'c�.�|���dSrA)r�)r3rns r%�_removezEvents._remove�s���������r'c�8�|j���dSrA)r"r�r�s r%r�z Events._clear�s�� � �������r'Nr�r�)rnrorrqr�) r5r6r7r8r�r�rsr�r�r9r'r%r�r�ts�������H�H������[��8�  ����  �  �  �  �  ��[�  ������[�������[���r'r�c�R�eZdZdZdd�Zedd ���Zedd���Zdd�ZdS)r�z�Descriptor used by target classes to deliver the _Dispatch class at the class level and produce new _Dispatch instances for target instances. �eventsrKc�,�|j|_||_dSrA)r"r�)r2r�s r%rgzdispatcher.__init__�s����� ��� � � r'�obj� Literal[None]r3r�rr�c��dSrAr9�r2r�r3s r%�__get__zdispatcher.__get__�s �� #�sr'rr>c��dSrAr9r�s r%r�zdispatcher.__get__�s��IL�r'c��|�|jS|j�|��} ||jd<n&#t$r}t d|�d���|�d}~wwxYw|S)Nr"ztarget z> doesn't have __dict__, should it be defining _slots_dispatch?)r"ryr/r1� TypeError)r2r�r3�disp�aes r%r�zdispatcher.__get__�s��� �;��=� ��}�*�*�3�/�/�� �'+�C�L�� $� $��� � � ��)�/2�s�s�5���� ����� ���� � s� 0� A�A�AN)r�rK)r�r�r3r�rr�)r�rr3r�rr>�r�rr3r�rr)r5r6r7r8rgr r�r9r'r%r�r��s~�������������#�#�#��X�#��L�L�L��X�L� � � � � � r'r�c��eZdZdd�ZdS) r�r�rr3r�rc��|�|jSt|d��r|jS|j�|��}||_|S)Nr�)r"r�r�ry)r2r�r3r�s r%r�zslots_dispatcher.__get__�sM�� �;��=� � �3�)� *� *� '��&� &��}�*�*�3�/�/��"���� r'Nr�)r5r6r7r�r9r'r%r�r��s(������ � � � � � r'r�)rrrr)r3rKrrq),r8� __future__rr�rrrrrr r r r r rrrr��attrrrrr�registryrr�r� util.typingr� defaultdict�listrrSr&r)r;rVr�r�r�r�r�r�r9r'r%�<module>r�s��� � � �#�"�"�"�"�"� � � � �������������������������������������������!�!�!�!�!�!�����������������������������������#�#�#�#�#�#� � � � � � �(�(�(�(�(�(�!�!�!�!�!�!�������������������!�!�!�!�!�!��D��T��� ����� &�&�&�&� O� O� O� O� O� O� O� O� $� $� $� $� $�g�c�l� $� $� $� {(�{(�{(�{(�{(���$�{(�{(�{(�|����m*�m*�m*�m*�m*����m*�m*�m*�` #� #� #� #� #���,� #� #� #�F4�4�4�4�4� �� $�4�4�4�n � � � � ���� � � �F � � � � �z�#�� � � � � r'
Memory