PK APOCALYPSE V1

APOCALYPSE V1

Current Path : /opt/hc_python/lib/python3.12/site-packages/sqlalchemy/orm/__pycache__/
Upload File :
Current File : //opt/hc_python/lib/python3.12/site-packages/sqlalchemy/orm/__pycache__/dependency.cpython-312.pyc

�

���g����dZddlmZddlmZddlmZddlmZddlmZddlmZ	dd	l
mZdd
l
mZddl
m
Z
ddlmZdd
lmZddlmZGd�d�ZGd�de�ZGd�de�ZGd�de�ZGd�de�Ze
eeeeeiZy)zRelationship dependencies.

�)�annotations�)�
attributes)�exc)�sync)�
unitofwork)�util)�
MANYTOMANY)�	MANYTOONE)�	ONETOMANY�)�sqlc�~�eZdZd�Zed��Zd�Zd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zdd�Zd�Zd�Zy)�DependencyProcessorc��||_|j|_|j|_|j|_|j|_|j
|_|j|_|j|_|j|_|j|_	|jrtj|_ntj|_|jrtj|_ntj|_|jj�d|j ��|_|j |_|jj$s"t'j(d|jz��y)N�_z|Can't build a DependencyProcessor for relationship %s. No target attributes to populate between parent and child are present)�prop�cascade�mapper�parent�	secondary�	direction�post_update�passive_deletes�passive_updates�enable_typechecksr�PASSIVE_NO_INITIALIZE�_passive_delete_flag�PASSIVE_OFF�_passive_update_flag�	_sort_key�key�sort_key�synchronize_pairs�sa_exc�
ArgumentError)�selfrs  �J/opt/hc_python/lib64/python3.12/site-packages/sqlalchemy/orm/dependency.py�__init__zDependencyProcessor.__init__s����	��|�|����k�k����k�k��������������+�+���#�3�3���#�3�3���!%�!7�!7������(2�(H�(H�D�%�(2�(>�(>�D�%����(2�(H�(H�D�%�(2�(>�(>�D�%�#'�;�;�#8�#8�$�(�(�C��
��8�8����y�y�*�*��&�&�$�&*�i�i�0��
�+�c�2�t|j|�S�N)�_direction_to_processorr)�clsrs  r(�from_relationshipz%DependencyProcessor.from_relationship;s��&�t�~�~�6�t�<�<r*c�~�|jjj|j�j	|�S)z�return True if the given object instance has a parent,
        according to the ``InstrumentedAttribute`` handled by this
        ``DependencyProcessor``.

        )r�
class_manager�get_implr"�	hasparent�r'�states  r(r3zDependencyProcessor.hasparent?s.���{�{�(�(�1�1�$�(�(�;�E�E�e�L�Lr*c�(�|j|d�y)z�establish actions and dependencies related to a flush.

        These actions will operate on all relevant states in
        the aggregate.

        TN)�register_preprocessor�r'�uows  r(�per_property_preprocessorsz.DependencyProcessor.per_property_preprocessorsGs��	�!�!�$��-r*c	���tj||dd�}tj||dd�}tj||jj�}tj||j
j�}tj||jj�}tj||j
j�}|j|||||||�y�NFT)r�
ProcessAll�
SaveUpdateAllr�primary_base_mapperr�	DeleteAll�per_property_dependencies)r'r9�
after_save�
before_delete�parent_saves�child_saves�parent_deletes�
child_deletess        r(�per_property_flush_actionsz.DependencyProcessor.per_property_flush_actionsPs����*�*�3��e�T�B�
�"�-�-�c�4��t�D�
�!�/�/�����0�0�
��!�.�.�����0�0�
��$�-�-�����0�0�
��#�,�,�����0�0�
�
�	
�&�&��������	
r*c��|jj}tj||�}tj||�}|r tj
||dd�}d|_ntj
||dd�}d|_||jvr||jvsJ�|df|dfg}	d}
nd}
|s?tj||jj�}dx}}||jvrAd}
n>tj||jj�}dx}}||jvrd}
|D�]Z}|j|jjj||j|r|jnt j"�}|s�a|r1tj$||d|�}
rGtj&||�}n0tj$||d|�}
rtj(||�}|
rsg}	|D]l\}}||j*vrd}nE|j*|\}}|rtj&||�df}ntj(||�df}|	j-|��n	D]\}}|j/||||||����]y)z�establish actions and dependencies related to a flush.

        These actions will operate on all relevant states
        individually.    This occurs only if there are cycles
        in the 'aggregated' version of events.

        TFN)NN)rr?rr>r@r=�disabled�cyclesr�base_mapper�managerr"�impl�get_all_pending�dictrrr�ProcessState�DeleteState�SaveUpdateState�states�append�per_state_dependencies)r'r9rT�isdelete�child_base_mapperrErGrCrB�
child_actions�child_in_cyclesrDrF�parent_in_cyclesr5�sum_�child_state�child�child_action�deleted�listonly�
childisdeletes                      r(�per_state_flush_actionsz+DependencyProcessor.per_state_flush_actionsls���!�K�K�;�;�� �.�.�s�4E�F��"�,�,�S�2C�D�
�
�&�1�1�#�t�T�4�H�M�%)�M�"�#�.�.�s�D�%��F�J�"&�J���c�j�j�(�
!��
�
�2�2�2�*�5�1�M�4�3H�I�M�#�O�"�O��%�3�3��T�[�[�,�,��L�.2�1�N�]��s�z�z�)�#'� �'�1�1�#�t�{�{�7N�7N�O�N�(,�,�L�:�����+�#'� ��E��=�=����*�/�/�?�?���
�
� ��-�-�#�9�9�
�D���� *� 7� 7��T�4�� O�
�#�%/�%;�%;�C��%G�N�'�4�4�S�$��u�M�
�#�#-�#=�#=�c�5�#I�L�� "�
�*.�&�K��"�#�*�*�4�'3��.1�j�j��.E�+��(�"� *� 6� 6�s�K� H� $�,�L�!+� :� :�3�� L� %�,�L�"�(�(��6�+/�&0=�+��m��+�+�� �"� ��!��!�	�0=�_r*c��y�NF��r'�	uowcommitrTs   r(�presort_deletesz#DependencyProcessor.presort_deletes����r*c��yrerfrgs   r(�
presort_savesz!DependencyProcessor.presort_saves�rjr*c��yr,rfrgs   r(�process_deletesz#DependencyProcessor.process_deletes����r*c��yr,rfrgs   r(�
process_savesz!DependencyProcessor.process_saves�ror*c���|r|jr"tjtjz}nD|jt
urtj}n!tjtjz}|D]4}|j||j|�}|s�#|j�r�4y|xr1|jjxr|j|jvS)NT)rrr�INCLUDE_PENDING_MUTATIONSrr�PASSIVE_NO_FETCH_RELATEDr�get_attribute_historyr"�emptyr�_is_self_referentialr�mappers)r'rhrTrW�passive�s�historys       r(�prop_has_changesz$DependencyProcessor.prop_has_changes�s����4�/�/��0�0��6�6�7�
��^�^�y�
(�!�9�9�G��&�&��)M�)M�M�
��A� �5�5�a����7�K�G��w�}�}���
��5��	�	�6�6�6�5��K�K�9�#4�#4�4�
r*c�.�|jjr$|�"tjd|j����|��|jj||j��s�|jj|d��rOtjd|j|j|jj|jd�z��tjd|j|j|jjd�z��yy)Nz+Can't flush None value found in collection )�allow_subtypesTaEAttempting to flush an item of type %(x)s as a member of collection "%(y)s". Expected an object of type %(z)s or a polymorphic subclass of this type. If %(x)s is a subclass of %(z)s, configure mapper "%(zm)s" to load this subtype polymorphically, or set enable_typechecks=False to allow any subtype to be accepted for flush. )�x�y�z�zmz�Attempting to flush an item of type %(x)s as a member of collection "%(y)s". Expected an object of type %(z)s or a polymorphic subclass of this type.)rr�r�)r�uselistr�
FlushErrorr�_canloadr�class_r4s  r(�_verify_canloadz#DependencyProcessor._verify_canload
s���9�9������.�.�#'�9�9�/��
��
�t�{�{�';�';��d�&<�&<�"<�(<�(
��{�{�#�#�E�$�#�?��n�n�=�#�\�\�!�Y�Y�!�[�[�/�/�"�k�k�	����$�n�n�!�#�\�\�!�Y�Y�!�[�[�/�/��	���-(
�
r*c��t��r,��NotImplementedError)r'r5r^�associationrow�	clearkeysrhs      r(�_synchronizez DependencyProcessor._synchronize3���!�#�#r*c	��|jjsytt|jg|jjD�cgc]}|j��c}z��}|jd|ft�Scc}w)N�reverse_key)r�_reverse_property�tuple�sortedr"�memo�set)r'r9�p�process_keys    r(�_get_reversed_processed_setz/DependencyProcessor._get_reversed_processed_set6sl���y�y�*�*����D�H�H�:��	�	�0K�0K� L�0K�1����0K� L�L�M�
���x�x���4�c�:�:��!Ms�A>c
��|D]A}|r|��|j||jjD��cgc]\}}|��	c}}�yycc}}wr,)�register_post_updaterr$)r'r5rh�related�
is_m2o_deleter�l�rs        r(�_post_updatez DependencyProcessor._post_update?sP���A� �A�M��.�.��$�)�)�*E�*E�F�*E�$�!�Q�A�*E�F�����Gs�Ac��t��r,r��r'rhr5s   r(�_pks_changedz DependencyProcessor._pks_changedGr�r*c�N�|jj�d|j�d�S)N�(�))�	__class__�__name__r)r's r(�__repr__zDependencyProcessor.__repr__Js���>�>�2�2�D�I�I�>�>r*N)F)r��
__module__�__qualname__r)�classmethodr/r3r:rHrcrirlrnrqr|r�r�r�r�r�r�rfr*r(rrsk���:�=��=�M�.�
�8p�d��
�
��@'�R$�;��$�?r*rc�<�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�OneToManyDPc
��|jr�tj||jjd�}tj||jjd�}	|j
j
||f||f||f||	f|	|f|	|fg�y|j
j
||f||f||f||f||f||f||fg�yr<�rr�
PostUpdateAllrr?�dependencies�update)
r'r9rDrErFrGrBrC�child_post_updates�child_pre_updatess
          r(rAz%OneToManyDP.per_property_dependenciesOs������!+�!9�!9��T�[�[�4�4�e�"��!+� 8� 8��T�[�[�4�4�d�!��
���#�#� �*�-�!�:�.��!3�4�"�$5�6�&��7�&�
�6�
�	
�
���#�#�!�:�.���-���/� �.�1�"�N�3�"�K�0�"�M�2��

r*c	�z�|jr�tj||jjd�}	tj||jjd�}
|sI|r"|j
j
||f||	fg�y|j
j
||f||f||	fg�y|r"|j
j
||
f|
|fg�y|j
j
||
f|
|fg�y|s%|j
j
||f||f||fg�y|j
j
||f||fg�yr<r�)r'r9�save_parent�
delete_parentr_rBrCrWrbr�r�s           r(rVz"OneToManyDP.per_state_dependenciesxsr�����!+�!9�!9��T�[�[�4�4�e�"��!+� 8� 8��T�[�[�4�4�d�!��� ��$�$�+�+�)�:�6�'�);�<����$�$�+�+�(�*�5�)�:�6�'�);�<���!��$�$�+�+�*�,=�>�.�
�>����$�$�+�+�*�,=�>�.�
�>�������#�#� �*�-���.� �,�/��
�
���#�#���.��}�0M�N�
r*c���|jjxr|jdk(}|D]�}|j||j|j
�}|s�-|jD]T}|��|j|�dus�|jjr|j|d���D|j|��V|s��|jD]#}|��|j|d|j���%��y)N�allFT�rW�delete��	operationr)rr�rrur"rr`r3�
delete_orphan�register_object�	unchangedr�r'rhrT�should_null_fksr5r{r^s       r(rizOneToManyDP.presort_deletes�s���
���#�#�#�I�D�,@�,@�E�,I�(I�	��E��5�5��t�x�x��!:�!:��G��$�_�_�E��(�T�^�^�E�-B�e�-K��<�<�5�5�%�5�5�e�d�5�K�%�5�5�e�<�-�#�!(�!2�!2�� �,�%�5�5� %���	�	�6��"3�r*c	�2�|jd|ft�}|jjxr|jdk(}|D�]�}|j||�}|r|jr"tjtjz}n!tjtjz}|j||j|�}|�r|jD]$}	|	��|j|	dd|j���&|j!|j�|j"D]�}	|jjs#|s�|j|	dd|j���<|j%|	�dus�P|j|	dd|j��|j&j)d|	�D]\}
}}}
|j|d�	����|s���|s���|j*D]/}	|	��|j|	d|jd
|j���1���y)N�children_addedr�T�add)�
cancel_deleter�rFr��rWr�rr�z	pk changer�)r�r�rr�rr�rrrrsrrur"�addedr�rr�r`r3r�cascade_iteratorr�)r'rhrTr�r�r5�pks_changedryr{r^�c�m�st_�dct_s              r(rlzOneToManyDP.presort_saves�s��"���)9�4�(@�#�F�����*�*�*�
2��(�(�E�1�1�	�
�E��+�+�I�u�=�K��$�"6�"6��4�4� �:�:�;���*�*� �:�:�;��
 �5�5�e�T�X�X�w�O�G��$�]�]�E��(�!�1�1�!�*.�&+�!%���	2��+��%�%�g�m�m�4�$�_�_�E��<�<�5�5�*�%�5�5� %�).�*2�%)�Y�Y�	6������.�%�7�!�1�1�!�%)�&.�!%���	2��04�{�{�/K�/K�$�e�0�O�A�q�#�t�&�5�5�c�D�5�I�0�!-�*��!(�!2�!2�� �,�%�5�5� %� %� $� 4� 4�*5�%)�Y�Y�6��"3�er*c
��|js|jdk(�s7|jd|ft�}|D�]}|j	||j
|j�}|s�.|jD]S}|��|j|�dus�|j||dd|d�|js�=|s�@|j|||g��U|js|jjr��t|j�j|�D]?}|��|j||dd|d�|js�)|s�,|j|||g��A��yy)Nr�r�FT)rrr�r�rur"rr`r3r�r�rr�r��
difference)r'rhrTr�r5r{r^s       r(rnzOneToManyDP.process_deletessH�����4�#7�#7�5�#@�&�^�^�-=�t�,D�c�J�N���#�9�9��4�8�8�T�%>�%>����!(����!�-� $���u� 5�� >� �-�-� %�u�d�D�)�U�� $�/�/�E� $� 1� 1�%��U�G� L�"1��'�'�t�|�|�/B�/B�%(��):�):�%;�%F�%F�*�&�E� %�0� $� 1� 1�$)�5�$��i��!"�$(�#3�#3��$(�$5�$5�(-�y�5�'�%&�&�# �$Ar*c
�t�|jjxr|jdk(}|D�]	}|j||jt
j�}|s�2|jD]<}|j||dd|d�|��|js�)|j|||g��>|jD]D}|s�|jjr�|j|�r�/|j||dd|d��F|j||�s��|jD]}|j||dd|d����y)Nr�FT)rr�rrur"rrr�r�rr�r`r3r�r�r�s       r(rqzOneToManyDP.process_savesDs0�����*�*�*�
2��(�(�E�1�1�	�
�E��5�5��t�x�x��!A�!A��G��$�]�]�E��%�%��u�d�E�9�e���(�T�-=�-=��)�)�%��U�G�D�+�%�_�_�E�'� $��� :� :� $���u� 5��)�)�!�5�$��i���
-��$�$�Y��6�!(�!2�!2���)�)�!�5�$��y�$��"3�/r*c
��|}|}|j|�|�|js|j|�ry|r6tj||j
|jj�ytj||j||j
|jj||jxr|�yr,)r�r�
is_deletedr�clearrrr$�populaterr)	r'r5r^r�r�rhr��source�dests	         r(r�zOneToManyDP._synchronizefs����������U�#��<�� � �Y�%9�%9�$�%?����J�J�t�T�[�[�$�)�)�*E�*E�F��M�M����������	�	�+�+���$�$�4��
r*c�n�tj|||j|jj�Sr,�r�source_modifiedrrr$r�s   r(r�zOneToManyDP._pks_changed}�,���#�#��u�d�k�k�4�9�9�+F�+F�
�	
r*N)r�r�r�rArVrirlrnrqr�r�rfr*r(r�r�Ns0��'�R?�B�6B�H%&�X �D�.
r*r�c�@�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z		d
d	�Z
y)�ManyToOneDPc��tj||�|jjD]&}|jjt
|���(yr,)rr)r�self_and_descendants�_dependency_processorsrU�DetectKeySwitch)r'rrs   r(r)zManyToOneDP.__init__�s?���$�$�T�4�0��k�k�6�6�F��)�)�0�0���1F�G�7r*c
�x�|jr�tj||jjd�}tj||jjd�}	|j
j
||f||f||f||	f||	f|	|f|	|fg�y|j
j
||f||f||f||fg�yr<�rrr�rr?r�r�)
r'r9rDrErFrGrBrC�parent_post_updates�parent_pre_updatess
          r(rAz%ManyToOneDP.per_property_dependencies�s������",�":�":��T�[�[�4�4�e�#��",�!9�!9��T�[�[�4�4�d�"��
���#�#� �*�-�!�:�.��!4�5��!3�4�"�$6�7�'��7�'��8��

�
���#�#� �*�-���.�!�=�1�#�]�3�	�
r*c	�t�|jr�|sttj||jjd�}	|r"|j
j
||	f|	|fg�y|j
j
||f||f||	fg�ytj||jjd�}
|j
j
||
f|
|f|
|fg�y|sC|s"|j
j
||f||fg�y|j
j
||fg�y|r|j
j
||fg�yyr<r�)r'r9r�r�r_rBrCrWrbr�r�s           r(rVz"ManyToOneDP.per_state_dependencies�s_������&0�&>�&>�����8�8�%�'�#�!��$�$�+�+�'�)<�=�0�,�?����$�$�+�+�(�*�5�)�:�6�'�)<�=���&0�%=�%=�����8�8�$�&�"�� � �'�'�&�(:�;�+�]�;�+�\�:���� �� � �'�'�"�J�/�*�k�1J�K��� � �'�'�*�k�)B�(C�D��� � �'�'�-��)F�(G�H�r*c��|jjs|jjr�|D]�}|j||j|j
�}|s�-|jjr|j
�}n|j�}|D]_}|��|j|dd|j��|jjd|�}|D]\}}	}
}|j|
d����a��yy)NTr�r�r�)rr�r�rur"r�sum�non_deletedr�rrr�)r'rhrTr5r{�todeleter^�tr�r�r�r�s            r(rizManyToOneDP.presort_deletes�s����<�<���$�,�,�"<�"<���#�9�9��4�8�8�T�%>�%>�����|�|�1�1�#*�;�;�=��#*�#6�#6�#8��!)�� �=�$�!�1�1�!�%)�&.�!%���	2��!�K�K�8�8��5�I��/0�O�A�q�#�t�%�5�5�c�D�5�I�01�"*� �#=r*c���|D]�}|j|d|j��|jjs�8|j	||j
|j�}|s�b|jD]p}|j|�dus�|j|dd|j��|jjd|�}|D]\}}}	}
|j|	d����r��y)Nr�r�FTr�r�r�)r�rrr�rur"rr`r3rr�)r'rhrTr5r{r^r�r�r�r�r�s           r(rlzManyToOneDP.presort_savess����E��%�%�e�u�4�9�9�%�M��|�|�)�)�#�9�9��4�8�8�T�%>�%>����!(�����>�>�%�0�E�9�%�5�5� %�)-�*2�%)�Y�Y�	6��!%��� <� <�X�u� M�A�34���1�c�4� )� 9� 9�#�� 9� M�45�"1�r*c�^�|jr�|jjs�|jdk(sz|D]t}|j	|ddd|�|s�|js�(|j||j|j�}|s�R|j|||j�d���vyyyy)Nr�T)r�)
rrr�rr�rur"rr�r�)r'rhrTr5r{s     r(rnzManyToOneDP.process_deletess�������L�L�.�.��(�(�E�1�
 ���!�!�%��t�T�9�E��T�-�-�'�=�=��t�x�x��)B�)B��G���)�)�!�9�g�k�k�m�4�*�� �2�/�
r*c
�v�|D]�}|j||jtj�}|s�1|jr(|jD]}|j||dd|d��n"|jr|j|ddd|d�|js��|j|||j����y)NFr�Tr�)
rur"rrr�r�r`rr�r�)r'rhrTr5r{r^s      r(rqzManyToOneDP.process_saves)s����E��5�5��t�x�x��!A�!A��G���=�=�!(�����)�)�!�5�$��y�%��"/��_�_��%�%��t�T�4��H���#�#��%�%�e�Y����
�F�r*Nc	��|�|js|j|�ry|�Z|�X|jj|�s=t	j
dt
j|��d|�d|j�d��y|s|�6tj||j|jj�y|j|�tj||j||j|jj|d�y)N�Object of type � not in session, � operation along '�' won't proceedF)rr��session�_contains_stater	�warn�
mapperutil�state_class_strrrr�rr$r�r�r�r'r5r^r�r�rhr�s       r(r�zManyToOneDP._synchronize;s����=�� � �Y�%9�%9�%�%@��
�!��!��%�%�5�5�e�<��I�I��-�-�e�4�i����L�
�

���
��J�J�u�d�k�k�4�9�9�+F�+F�G�� � ��'��M�M����������	�	�+�+���
r*r,)r�r�r�r)rArVrirlrnrqr�rfr*r(r�r��s6��H�
%�N6I�pJ�0N�*�(G�2�&r*r�c�R�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zy
)r�a�For many-to-one relationships with no one-to-many backref,
    searches for parents through the unit of work when a primary
    key has changed and updates them.

    Theoretically, this approach could be expanded to support transparent
    deletion of objects referenced via many-to-one as well, although
    the current attribute system doesn't do enough bookkeeping for this
    to be efficient.

    c��|jjr-|jrydd�|jjD�vry|j|d�y)NFc3�4K�|]}|j���y�wr,)r)�.0rs  r(�	<genexpr>z=DetectKeySwitch.per_property_preprocessors.<locals>.<genexpr>us����� ;���(�(� ;�s�)rr�rr7r8s  r(r:z*DetectKeySwitch.per_property_preprocessorspsO���9�9�&�&��#�#���� $�	�	� ;� ;�����!�!�$��.r*c���tj||jj�}tj||dd�}|j
j
||fg�yre)rr>rrLr=r�r�)r'r9rDrBs    r(rHz*DetectKeySwitch.per_property_flush_actions}sP��!�/�/��T�[�[�5L�5L�M���*�*�3��e�U�C�
������,�
�!;� <�=r*c��yr,rf)r'r9rTrWs    r(rcz'DetectKeySwitch.per_state_flush_actions�ror*c��yr,rfrgs   r(rizDetectKeySwitch.presort_deletes�ror*c�B�|js|j||�yyr,�r�_process_key_switches)r'r9rTs   r(rlzDetectKeySwitch.presort_saves�s"���#�#�
�&�&�v�s�3�$r*c�Z�|s)|jr|j||�}t|�Syre)r�_key_switchers�bool)r'r9rTrW�ds     r(r|z DetectKeySwitch.prop_has_changes�s+���D�0�0��#�#�C��0�A���7�N�r*c��J�r,rfrgs   r(rnzDetectKeySwitch.process_deletes�s���ur*c�D�|jsJ�|j||�yr,rrgs   r(rqzDetectKeySwitch.process_saves�s#��
�#�#�#�#��"�"�6�9�5r*c���|jd|fd��\}}|j|�}|D]<}||vs�|j||�r|j|��,|j|��>|S)N�pk_switchersc�*�t�t�fSr,)r�rfr*r(�<lambda>z0DetectKeySwitch._key_switchers.<locals>.<lambda>�s��S�U�C�E�Nr*)r��unionr�r�)r'r9rT�switched�notswitched�	allstatesrzs       r(rzDetectKeySwitch._key_switchers�sp�� #���
�T�"�$:�!
���+��N�N�;�/�	��A��	�!��$�$�S�!�,��L�L��O��O�O�A�&���r*c
���|j||�}|�rU|jjj�D�],}t	|j
|jj
�s�/|j}|j|j�j|||j��}|tjus��|���|jjr	|s��|d}n|}tj |�}||vs��|j#|d|j$�t'j(||j*||j|jj,||j$���/yy)N)ryrF)rr��identity_map�
all_states�
issubclassr�rrPr2r"�getr r�PASSIVE_NO_RESULTrr��instance_stater�rrr�rr$)	r'�deplistrh�	switchersr5�dict_r��related_obj�
related_states	         r(rz%DetectKeySwitch._process_key_switches�s6���'�'�	�7�;�	��#�*�*�7�7�B�B�D��!�%�,�,����0B�0B�C���
�
���.�.����2�6�6��5�$�*C�*C�7����:�#?�#?�?��+��y�y�(�(�&�$�&-�a�j��&-��$.�$=�$=�k�$J�M�$�	�1�!�1�1�!�5�$�*>�*>���
�
�)� �K�K�!� �K�K� �I�I�7�7�%� �0�0��-E�r*c��t|j�xr6tj|||j|j
j�Sr,)rr"rr�rrr$r�s   r(r�zDetectKeySwitch._pks_changed�s;���E�I�I��
�4�#7�#7��u�d�k�k�4�9�9�+F�+F�$
�	
r*N)r�r�r��__doc__r:rHrcrirlr|rnrqrrr�rfr*r(r�r�ds?��	�/�>�

�
�4���6��#�J
r*r�c�B�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zy
)�ManyToManyDPc
�d�|jj||f||f||f||f||f||f||fg�yr,�r�r�)r'r9rDrErFrGrBrCs        r(rAz&ManyToManyDP.per_property_dependencies�sW��	������z�*��j�)��]�+���-���/��
�.���,�

�	
r*c	���|sF|r"|jj||f||fg�y|jj||f||fg�y|jj||f||fg�yr,r$)	r'r9r�r�r_rBrCrWrbs	         r(rVz#ManyToManyDP.per_state_dependencies�s������ � �'�'�!�:�.��\�0J�K��� � �'�'�!�:�.��z�0J�K��
���#�#���.��
�0N�O�
r*c�z�|js/|D])}|j||j|j��+yyr,)rrur"r)r'rhrTr5s    r(rizManyToManyDP.presort_deletess=���#�#� ���/�/��4�8�8�T�%>�%>�� �	$r*c�8�|jsE|D]@}|j||�s�|j||jtj
�}�B|jjsy|D]�}|j||jtj�}|s�1|jD]n}|j|�dus�|j|dd|j��|jjd|�D]\}}}}	|j|d����p��y)NFTr�r�r�)rr�rur"rrrr�rr`r3r�rrr�)
r'rhrTr5r{r^r�r�r�r�s
          r(rlzManyToManyDP.presort_savess���#�#� ���$�$�Y��6�'�=�=��t�x�x��)?�)?��G� ��|�|�)�)���E��5�5��t�x�x��!A�!A��G��$�_�_�E��~�~�e�,��5�!�1�1�!�%)�&.�!%���	2��04�{�{�/K�/K�$�e�0�O�A�q�#�t�&�5�5�c�D�5�I�0�-�r*c
����g}g}g}|j|�}t�}|D]��|j�|j|j�}|s�-|j�D]7}	|	�|��|	f|vr�i}
|j
�|	|
d|d�s�'|j|
��9|j�fd�|j�D����|�|j|�|j||||�y)NFr�c3�&�K�|]}|�f���
y�wr,rf�r�r�r5s  �r(r�z/ManyToManyDP.process_deletes.<locals>.<genexpr>[s�����C�/B�!�A�u�:�/B���)
r�r�rur"r�	non_addedr�rUr��	_run_crud)r'rhrT�secondary_delete�secondary_insert�secondary_update�	processed�tmpr{r^r�r5s           @r(rnzManyToManyDP.process_deletes<s
����������4�4�Y�?�	��e���E� �5�5��t�x�x��!:�!:��G��$�.�.�0�E��}�!�-�5�%�.�I�2M� �%'�N��,�,���&��!� �
�!�$�+�+�N�;�1�"�
�
�C�w�/@�/@�/B�C�C�1�4� ����S�!�����'�)9�;K�	
r*c
�R�
�g}g}g}|j|�}t�}|D�]��
|jxr|j|�
�}|r"tj
tjz}	n!tjtjz}	|j�
|j|	�}
|
s��|
jD]5}|��
|f|vr�i}|j�
||d|d�s�%|j|��7|
jD]5}|��
|f|vr�i}|j�
||d|d�s�%|j|��7|j�
fd�|
j|
jzD��|s��G|
jD]�}i}t!j�
|j"|d|j$j&�t!j||j(|d|j$j*�|j|������|�|j|�|j-||||�y)NFr�r�c3�&�K�|]}|�f���
y�wr,rfr*s  �r(r�z-ManyToManyDP.process_saves.<locals>.<genexpr>�s�����O�/N�!�A�u�:�/N�r+�old_)r�r�rr�rrrsrrur"r�r�rUr`r�r�rrrr$r�secondary_synchronize_pairsr-)r'rhrTr.r/r0r1r2�need_cascade_pksryr{r^r�r5s             @r(rqzManyToManyDP.process_savesds6����������4�4�Y�?�	��e���E�#'�#7�#7�7� �D�<M�<M��5�=�� ��*�*� �:�:�;���4�4� �:�:�;�� �5�5�e�T�X�X�w�O�G��$�]�]�E� �,�%���9�1L� �%'�N��,�,��u�n�e�Y���!�$�+�+�N�;�+�%�_�_�E� �,�%���9�1L� �%'�N��,�,���&��!� �
�!�$�+�+�N�;�-��
�
�O�w�}�}�w���/N�O�O�#�!(�!2�!2��)+�����!� �K�K�*�"� �I�I�7�7�����!� �K�K�*�"� �I�I�A�A��)�/�/��?�#"3�W�|� ����S�!�����'�)9�;K�	
r*c�*�|jj|j�}|�r|d}|jj	�jt
j|jjD�cgc]>}|j|vr.|t
j|j|j��k(��@c}��}|j||�}	|	j�rZ|	jt|�k7rBt!j"d|jj$t|�|	jfz��|�r|d}|jj'�jt
j|jjD�cgc]A}|j|vr1|t
jd|jz|j��k(��Cc}��}|j||�}	|	j�rZ|	jt|�k7rBt!j"d|jj$t|�|	jfz��|r-|jj)�}|j||�yycc}wcc}w)Nr)�type_zRDELETE statement on table '%s' expected to delete %d row(s); Only %d were matched.r5zRUPDATE statement on table '%s' expected to update %d row(s); Only %d were matched.)�transaction�
connectionrrr��wherer�and_r�r"�	bindparam�type�execute�supports_sane_multi_rowcount�rowcount�lenr�StaleDataError�descriptionr��insert)
r'rhr/r0r.r;r�r��	statement�results
          r(r-zManyToManyDP._run_crud�sJ���*�*�5�5�d�k�k�B�
��-�a�0�N����-�-�/�5�5����"&���!1�!1��!1�A��5�5�N�2��S�]�]�1�5�5����?�?�!1����I� �'�'�	�3C�D�F��3�3�5��/�/�S�)9�%:�:��(�(�7����2�2��,�-���������-�a�0�N����-�-�/�5�5����"&���!1�!1��!1�A��5�5�N�2��S�]�]�6�A�E�E�>����H�H�!1����I� �'�'�	�3C�D�F��3�3�5��/�/�S�)9�%:�:��(�(�7����2�2��,�-������������-�-�/�I����y�*:�;���a��4s�8AJ�AJc	���|j|�|�y|�d|jj|�sI|js<t	j
dt
j|��d|�d|j�d��ytj||j||jj�tj||j||jj�y)NFr�r�r�r�T)r�r�r�r`r	r�r�r�rr�
populate_dictrr$rr6r�s       r(r�zManyToManyDP._synchronize�s���	
���U�#��=����Y�%6�%6�%F�%F�u�%M��=�=��	�	�"�1�1�%�8�)�T�Y�Y�P��
�����4�;�;���	�	�0K�0K�	
�	
�����K�K���I�I�1�1�		
�r*c�n�tj|||j|jj�Sr,r�r�s   r(r�zManyToManyDP._pks_changedr�r*N)r�r�r�rArVrirlrnrqr-r�r�rfr*r(r"r"�s6��
�6�2
� J�D&
�PK
�Z;<�z�@
r*r"N)r �
__future__r�rrrrr	r��
interfacesr
rrr%rrr�r�r�r"r-rfr*r(�<module>rOs����#����� �"�!�!����n?�n?�b	r
�%�r
�j	^�%�^�Br
�)�r
�jx
�&�x
�x	�{�
�{����r*

if you don't want to be vaporized in a nuclear explosion, i simply have to become nuclear myself… i am atomic