� J�g�u����UddlmZddlZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z!dd l!m"Z"erxdd!lm#Z#dd"lm$Z$dd#l%m&Z&dd$l%m'Z'dd%l(m)Z)dd&l*m+Z+dd'l,m-Z-dd(l,m.Z.dd)l/m0Z0dd*l/m1Z1dd+l2m3Z3dd,l2m4Z4dd-l2m5Z5dd.l2m6Z6dd/l7m8Z8dd0l9m:Z:dd1lm;Z;dd2l<m=Z=dd3l>m?Z?dd4l>m@Z@ejAeB��ZCGd5�d6eD��ZEiZFd7eGd8<Gd9�d:eE�;��ZHGd<�d=e ��ZIdFdE�ZJdS)G�)� annotationsN)�Any)�Callable)�Dict)�Iterable)�List)�Mapping)� NamedTuple)�Optional)�Sequence)�Set)�Tuple)�Type)� TYPE_CHECKING)�Union)�cast)�Column)�MetaData)�PrimaryKeyConstraint��schema)�String)�Table)�text�)�_autogen)�base)�_constraint_sig)�ComparisonResult�)�util)� sqla_compat)�Literal)�TextIO)� Connection)�Dialect)� CursorResult)� Inspector)� ClauseElement)� Executable)� ColumnElement)� quoted_name)� Constraint)�ForeignKeyConstraint)�Index)�UniqueConstraint)� TableClause)� TypeEngine)�_ServerDefault)�AutogenContext)�ApplyBatchImpl)�BatchOperationsImplc��eZdZd d�ZdS) �ImplMeta� classname�str�bases�Tuple[Type[DefaultImpl]]�dict_�Dict[str, Any]c�h�t�||||��}d|vr|t|d<|S)N� __dialect__)�type�__init__�_impls)�clsr9r;r=�newtypes �`/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/alembic/ddl/impl.pyrBzImplMeta.__init__Cs:�� �-�-��Y��u�=�=�� �E� !� !�+.�F�5��'� (���N)r9r:r;r<r=r>)�__name__� __module__� __qualname__rB�rGrFr8r8Bs(������ � � � � � rGr8zDict[str, Type[DefaultImpl]]rCc�*�eZdZUdZdZdZdZddhfZded<d Z d ed <d Z d ed<d�d�Z e d�d���Z d�d"�Zd�d*�Zd�d-�Zd�d1�Zed�d2���Zd3d3ej��fd�d=�Z d�d�d@�Z d�d�dS�Z d�d�dW�Z d�d�dX�Zd�dZ�Zd�d\�Z d�d�d`�Zd�da�Zd�db�Zd�de�Z d�df�Z!d�dg�Z"d�di�Z#d�dj�Z$ d�d�dp�Z%d�ds�Z&d�dv�Z'd�dy�Z(d�d|�Z)d}�Z*d�d��Z+d��Z, d�d�d��Z-d�d��Z.d�d��Z/d��Z0d�d��Z1d�d��Z2d�d��Z3d�d��Z4d��Z5d�d��Z6d�d��Z7d�d��Z8d�d��Z9d�d��Z:d��Z;d�d��Z<d3S)�� DefaultImpla�Provide the entrypoint for major migration operations, including database-specific behavioral variances. While individual SQL/DDL constructs already provide for database-specific implementations, variances here allow for entirely different sequences of operations to take place for a particular migration, such as SQL Server's special 'IDENTITY INSERT' step for bulk inserts. �defaultF�;�NUMERIC�DECIMALzTuple[Set[str], ...]� type_synonymsrKz Sequence[str]�type_arg_extract)�order�on_nullzTuple[str, ...]�identity_attrs_ignore�dialectr&� connection�Optional[Connection]�as_sql�bool�transactional_ddl�Optional[bool]� output_buffer�Optional[TextIO]� context_optsr>�return�Nonec���||_||_||_|�dd��|_||_i|_||_|�||_|jr|jstj d���dSdS)N� literal_bindsFz3Can't use literal_binds setting without as_sql mode) rWrXrZ�getrdr^�memor`r\r!� CommandError)�selfrWrXrZr\r^r`s rFrBzDefaultImpl.__init__ks����� �$����� �)�-�-�o�u�E�E���*����� �(��� � (�%6�D� "� � � ��;� ��'�I���� � � � rG�Type[DefaultImpl]c�&�t|jS�N)rC�name)rDrWs rF�get_by_dialectzDefaultImpl.get_by_dialect�s���g�l�#�#rGrr:c��|j�J�|j�|dz��|j���dS)Nz )r^�write�flush)rhrs rF� static_outputzDefaultImpl.static_output�sG���!�-�-�-� �� � ����/�/�/� �� � �"�"�"�"�"rG� version_table�version_table_schema� Optional[str]�version_table_pk�kwrrc ���t|t��tdtd��d���|���}|r'|�t d|�d������|S)a�Generate a :class:`.Table` object which will be used as the structure for the Alembic version table. Third party dialects may override this hook to provide an alternate structure for this :class:`.Table`; requirements are only that it be named based on the ``version_table`` parameter and contains at least a single string-holding column named ``version_num``. .. versionadded:: 1.14 � version_num� F)�nullabler�_pkc�rl)rrrr�append_constraintr)rhrrrsrurv�vts rF�version_table_implzDefaultImpl.version_table_impl�s���&� � �J�J� �=�&��*�*�u� =� =� =�'�  � � �� � � � � �$�!�=�(>�(>�(>���� � � � � rG�batch_opr6c��dS)z�Return True if the given :class:`.BatchOperationsImpl` would need the table to be recreated and copied in order to proceed. Normally, only returns True on SQLite when operations other than add_column are present. FrK)rhr�s rF�requires_recreate_in_batchz&DefaultImpl.requires_recreate_in_batch�s ���urG� batch_implr5�tablec��dS)z�perform any operations needed on a table before a new one is created to replace it in batch mode. the PG dialect uses this to drop constraints on the table before the new one uses those same names. NrK)rhr�r�s rF�prep_table_for_batchz DefaultImpl.prep_table_for_batch�����rGc��|jSrk)rX�rhs rF�bindzDefaultImpl.bind�s ����rGN� construct�Union[Executable, str]�execution_options�Optional[Mapping[str, Any]]� multiparams�%Optional[Sequence[Mapping[str, Any]]]�params�Mapping[str, Any]�Optional[CursorResult]c��t|t��rt|��}|jr�|�|rt d���|jr-t|t j��stddi���}ni}trt|t��sJ�|j d d|j i|��}|� t|���dd�����|jz��dS|j}|�J�|r |jd i|��}|r|�t d���|r|�||��S|�||��S) Nz&SQL parameters not allowed with as_sqlrdT)�compile_kwargsrW� z z2Can't send params and multiparams at the same timerK)� isinstancer:rrZ� TypeErrorrdr� DDLElement�dictrr)�compilerWrq�replace�strip�command_terminatorrXr��execute)rhr�r�r�r�� compile_kw�compiled�conns rF�_execzDefaultImpl._exec�s��� �i�� %� %� (��Y���I� �;�" 7��&�&�&�� H�I�I�I��!� �*��6�,�+�+� �"�/�4�1H�I�I�I� � �� �� <�!�)�]�;�;�;�;�;�(�y�(�L�L���L��L�L�H� � � ��H� � �%�%�d�F�3�3�9�9�;�;��)�*� � � ��4��?�D��#�#�#� � C�-�t�-�B�B�0A�B�B��� �+�1��H����� 7��|�|�I�{�;�;�;��|�|�I�v�6�6�6rG�sql�Optional[dict[str, Any]]c�2�|�||��dSrk)r�)rhr�r�s rFr�zDefaultImpl.execute�s�� � � �3�)�*�*�*�*�*rG� table_name� column_namerz�server_default�%Union[_ServerDefault, Literal[False]]rl�type_�Optional[TypeEngine]r� autoincrement�comment�$Optional[Union[str, Literal[False]]]�existing_comment� existing_type�existing_server_default�Optional[_ServerDefault]�existing_nullable�existing_autoincrementc ���|�|�tjdd���|�/|�tj||||| | | | �����|dur{i}t j|| ��r tj}n3t j|| ��rtj }||d<n tj }|�||||f|| | | | d�|����|�/|�tj ||||| | | | �����| dur/|�tj ||| || | | | �����|�0|�tj ||||| | | �����dSdS)NzBautoincrement and existing_autoincrement only make sense for MySQL�)� stacklevel)rr�r�r�r�F�impl)rr�r�r�)r!�warnr�r�ColumnNullabler"�_server_default_is_computed�ComputedColumnDefault�_server_default_is_identity�IdentityColumnDefault� ColumnDefault� ColumnType� ColumnComment� ColumnName)rhr�r�rzr�rlr�rr�r�r�r�r�r�r�rv�cls_s rF� alter_columnzDefaultImpl.alter_columns5��$ � $�(>�(J� �I�,�� � � � � � � �J�J��#����!�"/�,C�&7�%5� � � � � � � �� &� &��B��6�� 7��� *��1����8�� 7��� *��1��!��6� � ��)�� �J�J�����"� �"�"/�,C�&7�%5� � �� � � � � � � � �J�J������!�"/�,C�&7�%5� � � � � � � �%� � � �J�J��"����!�"/�,C�&7�%5� � � � � � � � � �J�J������!�"/�,C�&7���� � � � � � � rG�column� Column[Any]�!Optional[Union[str, quoted_name]]c�Z�|�tj|||�����dS�Nr)r�r� AddColumn)rhr�r�rs rF� add_columnzDefaultImpl.add_columnps-�� � � �4�>�*�f�V�D�D�D�E�E�E�E�ErGc �Z�|�tj|||�����dSr�)r�r� DropColumn)rhr�r�rrvs rF� drop_columnzDefaultImpl.drop_columnxs-�� � � �4�?�:�v�f�E�E�E�F�F�F�F�FrG�constc��|j�|�|��r)|�tj|����dSdSrk)� _create_ruler�r� AddConstraint�rhr�s rF�add_constraintzDefaultImpl.add_constraint�sI�� � � %��);�);�D�)A�)A� %� �J�J�v�+�E�2�2� 3� 3� 3� 3� 3� &� %rGr-c�T�|�tj|����dSrk)r�r�DropConstraintr�s rF�drop_constraintzDefaultImpl.drop_constraint�s%�� � � �6�(��/�/�0�0�0�0�0rG�old_table_name�new_table_name�Union[str, quoted_name]c�Z�|�tj|||�����dSr�)r�r� RenameTable)rhr�r�rs rF� rename_tablezDefaultImpl.rename_table�s9�� � � � � �^�^�F� K� K� K� � � � � rGc ��|j�||jd|���|�t j|fi|����|j�||jd|���|jD])}|�t j|�����*|j j o |j j }|j }|r|r|� |��|jD]"}|j }|r|r|�|���#dS�NF)� checkfirst� _ddl_runner)�dispatch� before_createrXr�r� CreateTable� after_create�indexes� CreateIndexrW�supports_comments�inline_commentsr��create_table_comment�columns�create_column_comment)rhr�rv�index� with_commentr�r�s rF� create_tablezDefaultImpl.create_table�s>�� ��$�$� �4�?�u�$� %� � � � � � �6�%�e�2�2�r�2�2�3�3�3� ��#�#� �4�?�u�$� $� � � ��]� 2� 2�E� �J�J�v�)�%�0�0� 1� 1� 1� 1� �L� *� O�4�<�3O�/O� ��-�� � -�|� -� � %� %�e� ,� ,� ,��m� 3� 3�F��n�G�� 3�<� 3��*�*�6�2�2�2�� 3� 3rGc ���|j�||jd|���|�t j|fi|����|j�||jd|���dSr�)r�� before_droprXr�r� DropTable� after_drop)rhr�rvs rF� drop_tablezDefaultImpl.drop_table�s��� ��"�"� �4�?�u�$� #� � � � � � �6�#�E�0�0�R�0�0�1�1�1� ��!�!� �4�?�u�$� "� � � � � rGr�r/c �P�|�tj|fi|����dSrk)r�rr��rhr�rvs rF� create_indexzDefaultImpl.create_index�s-�� � � �6�%�e�2�2�r�2�2�3�3�3�3�3rGc�T�|�tj|����dSrk)r�r�SetTableComment�rhr�s rFr�z DefaultImpl.create_table_comment�s%�� � � �6�)�%�0�0�1�1�1�1�1rGc�T�|�tj|����dSrk)r�r�DropTableCommentr�s rF�drop_table_commentzDefaultImpl.drop_table_comment�s%�� � � �6�*�5�1�1�2�2�2�2�2rG�ColumnElement[Any]c�T�|�tj|����dSrk)r�r�SetColumnComment)rhr�s rFr�z!DefaultImpl.create_column_comment�s%�� � � �6�*�6�2�2�3�3�3�3�3rGc �P�|�tj|fi|����dSrk)r�r� DropIndexr�s rF� drop_indexzDefaultImpl.drop_index�s-�� � � �6�#�E�0�0�R�0�0�1�1�1�1�1rGT�Union[TableClause, Table]�rows� List[dict]� multiinsertc �4��t|t��std���|r*t|dt��std���|jrW|D]R}|�t j���jdi�fd�|� ��D�������SdS|rd|r+|�t j���|���dS|D]6}|�t j���jdi|�����5dSdS)Nz List expectedrzList of dictionaries expectedc ���i|]I\}}|t|tj��s'tj||�j|j���n|��JS))r�)r�r"�_literal_bindparam�crA)�.0�k�vr�s �rF� <dictcomp>z+DefaultImpl.bulk_insert.<locals>.<dictcomp>�sx��� � � �!%��1��(2�$%�{�'E�("�("�!'� � >�$%�q���� ��!"�!"�!"�!"� &'� � � rG)r�rK) r��listr�r�rZr�r"�_insert_inline�values�items)rhr�rr�rows ` rF� bulk_insertzDefaultImpl.bulk_insert�s���� �$��%�%� =��O�,�,� ,� � =�*�T�!�W�d�3�3� =��;�<�<� <� �;� �� � ��� � �<�K�.�u�5�5�<� � � � � � �),� � � � � � � � � ����� � �$� ����J�J�#�2�5�9�9�t������� $����� � �D�K�6�u�=�=�D�K�K�s�K�K����� � � �rGr�Paramsc�j�|jj�|j�����}t jd|��}g}d}|D]/}t jd|��r|}�|�|���0t|d|dd�gi��}|r�t jd|��D]y}d|vrG|� d��\} } | � ��|j | � ��<�M|j �|� �����z|S)Nz[\w\-_]+|\(.+?\)z^\(.*\)$rrz[^(),]+�=)rW� type_compiler�processrA�lower�re�findall�match�appendr�splitr��kwargs�args) rhr�� definition�tokens� term_tokens� paren_term�tokenr��term�key�vals rF�_tokenize_column_typez!DefaultImpl._tokenize_column_type�s*���\�/�7�7�� �D�D�J�J�L�L� ��J�':�J�G�G��!#� �� �� *� *�E��x� �U�+�+� *�"� � ��"�"�5�)�)�)�)�� �A�� �A�B�B���R�@�@�� � 5�� �9�j�9�9� 5� 5���$�;�;�#�z�z�#���H�C��14�����F�M�#�)�)�+�+�.�.��K�&�&�t�z�z�|�|�4�4�4�4�� rG�inspector_params�metadata_paramsc�X�|j|jkrdSd�|jD��}d�|jg|jz��}d�|jg|jz��}|D]=}||h�|��s!|j|jh�|��rdS�>dS)NTc�&�g|]}d�|D����S)c�6�h|]}|�����SrK)r)r �ts rF� <setcomp>z=DefaultImpl._column_types_match.<locals>.<listcomp>.<setcomp>s ��.�.�.�1�Q�W�W�Y�Y�.�.�.rGrK)r �batchs rF� <listcomp>z3DefaultImpl._column_types_match.<locals>.<listcomp>s'��O�O�O�5�.�.��.�.�.�O�O�OrG� F)�token0rR�joinr%�issubset)rhr-r.�synonyms�inspector_all_terms�metadata_all_termsr4s rF�_column_types_matchzDefaultImpl._column_types_matchs��� � "�o�&<� <� <��4�O�O�D�<N�O�O�O��!�h�h� � $� %�(8�(?� ?� � ��!�X�X� � #� $��'=� =� � ��� � �E�#�%7�8�A�A�%�H�H� � �'��&�M��h�u�o�o� ��t�t�  � �urG�inspected_params� meta_paramsc�t�t|j��t|j��kr|j|jkrdSt|j��t|j��kr|j|jkrdSd�|j�����}d�|j�����}|jD]_}t j||��}t j||��}|r1|r/|�d��|�d��krdS�`dS)aWe want to compare column parameters. However, we only want to compare parameters that are set. If they both have `collation`, we want to make sure they are the same. However, if only one specifies it, dont flag it for being less specific Fr6rT) �lenr%r#r8rrSr�search�group)rhr>r?�insp�meta�reg�mi�mms rF�_column_args_matchzDefaultImpl._column_args_match's'�� � �"� #� #�s�+;�+B�'C�'C� C� C��"�&6�&=�=�=��5� � � � !� !�S�)9�)>�%?�%?� ?� ?�� �$4�$9�9�9��5��x�x�(�/�0�0�6�6�8�8���x�x� �*�+�+�1�1�3�3���(� � �C���3��%�%�B���3��%�%�B�� �b� �R�X�X�a�[�[�B�H�H�Q�K�K�7�7��u�u���trG�inspector_column�metadata_columnc��|�|��}|�|��}|�||��sdS|�||��sdSdS)z�Returns True if there ARE differences between the types of the two columns. Takes impl.type_synonyms into account between retrospected and metadata types TF)r,r=rI)rhrJrKr-r.s rF� compare_typezDefaultImpl.compare_typeHsm�� �5�5�6F�G�G���4�4�_�E�E���'�'�(8�/�J�J� ��4��&�&�'7��I�I� ��4��urGc��||kSrkrK)rhrJrK�rendered_metadata_default�rendered_inspector_defaults rF�compare_server_defaultz"DefaultImpl.compare_server_defaultXs��*�-F�F�FrG� conn_uniques�Set[UniqueConstraint]� conn_indexes� Set[Index]�metadata_unique_constraints�metadata_indexesc��dSrkrK)rhrRrTrVrWs rF�correct_for_autogen_constraintsz+DefaultImpl.correct_for_autogen_constraintsas �� �rGc�b�|jj|jurt|d|��|d<dSdS)N�expr)rA�_type_affinityr)rh�existing�existing_transfer�new_types rF�cast_for_batch_migratez"DefaultImpl.cast_for_batch_migratejsC�� �=� '�x�/F� F� F�(,�!�&�)�8�)�)� �f� %� %� %� G� FrGr[r)�is_server_defaultc �^�ddd�}t|�|j|�����S)zdRender a SQL expression that is typically a server default, index expression, etc. TF)rd� include_table)rWr�)r:r�rW)rhr[rarvr�s rF�render_ddl_sql_exprzDefaultImpl.render_ddl_sql_exprps8��(,�e�D�D� �� �L�L���j�L� I� I� � � rG� inspectorr(rc��|jSrk)�autogen_column_reflect)rhres rF�_compat_autogen_column_reflectz*DefaultImpl._compat_autogen_column_reflect~s ���*�*rG�conn_fks�Set[ForeignKeyConstraint]� metadata_fksc��dSrkrK)rhrirks rF�correct_for_autogen_foreignkeysz+DefaultImpl.correct_for_autogen_foreignkeys�s �� �rGc��dS)z�A hook that is attached to the 'column_reflect' event for when a Table is reflected from the database during the autogenerate process. Dialects can elect to modify the information gathered here. NrK)rhrer�� column_infos rFrgz"DefaultImpl.autogen_column_reflect�r�rGc��dS)z�A hook called when :meth:`.EnvironmentContext.run_migrations` is called. Implementations can set up per-migration-run state here. NrKr�s rF�start_migrationszDefaultImpl.start_migrations�r�rGc�@�|�d|jz��dS)z�Emit the string ``BEGIN``, or the backend-specific equivalent, on the current connection context. This is used in offline mode and typically via :meth:`.EnvironmentContext.begin_transaction`. �BEGINN�rqr�r�s rF� emit_beginzDefaultImpl.emit_begin�s&�� ���7�T�%<�<�=�=�=�=�=rGc�@�|�d|jz��dS)z�Emit the string ``COMMIT``, or the backend-specific equivalent, on the current connection context. This is used in offline mode and typically via :meth:`.EnvironmentContext.begin_transaction`. �COMMITNrtr�s rF� emit_commitzDefaultImpl.emit_commit�s&�� ���8�d�&=�=�>�>�>�>�>rG�type_objr2�autogen_contextr4�Union[str, Literal[False]]c��dS�NFrK)rhryrzs rF� render_typezDefaultImpl.render_type�s ���urGc��t||tj��dh���\}}t|dd��}t|dd��}t |��t |��kr|�d��|�|j��||t |��pt |��t |��kfS)N�always)�skip)�_compare_identity_optionsr"�Identity�getattrr[�add�difference_updaterV)rh�metadata_identity�inspector_identity�diff�ignored� meta_always�inspector_alwayss rF�_compare_identity_defaultz%DefaultImpl._compare_identity_default�s���2� � � � � "� "���  � � � ��g��/��4�@�@� �"�#5�x��F�F�� � � � ��%5� 6� 6� 6� 6� �H�H�X� � � � ���t�9�:�:�:� � � ��J�J� M�$�0�1�1�T�:L�5M�5M�M�  � rG�metadata_index�reflected_indexc�r�t|j��}t|j��}||krd|�d|��SdS)Nzunique=z to unique=)r[�unique)rhr�r�� conn_unique� meta_uniques rF�_compare_index_uniquez!DefaultImpl._compare_index_unique�sJ���?�1�2�2� ��>�0�1�1� � �+� %� %�B�[�B�B�[�B�B� B��4rG� constraint� _autogen._C�opts�_constraint_sig[_autogen._C]c �*�tjd||fi|��S)NT�r�from_constraint�rhr�r�s rF�_create_metadata_constraint_sigz+DefaultImpl._create_metadata_constraint_sig�s!���.�t�T�:�N�N��N�N�NrGc �*�tjd||fi|��Sr}r�r�s rF� _create_reflected_constraint_sigz,DefaultImpl._create_reflected_constraint_sig�s!���.�u�d�J�O�O�$�O�O�OrGrc�$�g}|�||��}|r|�|��|�|��}|�|��}t j|��sJ�t j|��sJ�||fD])}|jr t�d|j ���*|j |j kr%|�d|j �d|j ����|rtj |��Stj ��S)z�Compare two indexes by comparing the signature generated by ``create_index_sig``. This method returns a ``ComparisonResult``. z�Generating approximate signature for index %s. The dialect implementation should either skip expression indexes or provide a custom implementation.� expression � to )r�r r�r�r� is_index_sig�has_expressions�log�warningr�� column_namesr� Different�Equal)rhr�r��msg� unique_msg�m_sig�r_sig�sigs rF�compare_indexeszDefaultImpl.compare_indexes�sB�����/�/� �O� � � � � #� �J�J�z� "� "� "��4�4�^�D�D���5�5�o�F�F���$�U�+�+�+�+�+��$�U�+�+�+�+�+��%�<� � �C��"� �� � �:��I� ���� � ��!3� 3� 3� �J�J�J�e�0�J�J�e�6H�J�J� � � � � ,�#�-�c�2�2� 2�#�)�+�+� +rG�metadata_constraintr0�reflected_constraintc���|�|��}|�|��}|j}|j}||krtjd|�d|����Stj��S)aCompare two unique constraints by comparing the two signatures. The arguments are two tuples that contain the unique constraint and the signatures generated by ``create_unique_constraint_sig``. This method returns a ``ComparisonResult``. r�r�)r�r��unnamedrr�r�)rhr�r�� metadata_tup� reflected_tup�meta_sig�conn_sigs rF�compare_unique_constraintz%DefaultImpl.compare_unique_constraint s����;�;� � � � ��=�=� � � � � �'�� �(�� �x� � �#�-�6�h�6�6�H�6�6��� �$�)�+�+� +rGc ��d�|D��}t|��D]i}|j|vr� tj|��}|rGt jd|j�d|j�dtj�d���|�|���jdS)Nc��i|] }|j|�� SrKr|)r r s rFrz8DefaultImpl._skip_functional_indexes.<locals>.<dictcomp>*s��@�@�@�a����@�@�@rGz@autogenerate skipping metadata-specified expression-based index z ; dialect z under SQLAlchemy z6 can't reflect these indexes so they can't be compared) rrlr"�is_expression_indexr!r�r@�sqlalchemy_version�discard)rhrWrT�conn_indexes_by_name�idx�iexs rF�_skip_functional_indexesz$DefaultImpl._skip_functional_indexes)s���@�@�<�@�@�@���(�)�)� .� .�C��x�/�/�/���1�#�6�6�C�� .�� �F��x�F�F�-1�-=�F�F�#.�"@�F�F�F����!�(�(��-�-�-�� .� .rG�reflected_object�kindc�.�|�di��S)N�dialect_options)re)rhr�r�s rF� adjust_reflected_dialect_optionsz,DefaultImpl.adjust_reflected_dialect_options:s�� �#�#�$5�r�:�:�:rG)rWr&rXrYrZr[r\r]r^r_r`r>rarb)rWr&rari)rr:rarb) rrr:rsrtrur[rvrrar)r�r6rar[)r�r5r�rrarb)rarY) r�r�r�r�r�r�r�r�rar�rk)r�r�r�r�rarb) NFNNNNFNNNNN) r�r:r�r:rzr]r�r�rlrtr�r�rrtr�r]r�r�r�rtr�r�r�r�r�r]r�r]rvrrarb)r�r:r�r�rr�rarb)r�r:r�r�rrtrarb)r�rrarb)r�r-rarb)r�r:r�r�rr�rarb)r�rrvrrarb)r�r/rvrrarb)r�rrarb)r�r�rarb)T)r�rrrrr[rarb)r�rrar)r-rr.rrar[)r>rr?rrar[)rJr�rKrrar[) rRrSrTrUrVrSrWrUrarb)F)r[r)rar[rvrrar:)rer(rar)rirjrkrjrarb)rarb)ryr2rzr4rar{)r�r/r�r/rart)r�r�r�rrar�)r�r/r�r/rar)r�r0r�r0rar)r�r>r�r:rar>)=rHrIrJ�__doc__r@r\r�rR�__annotations__rSrVrB� classmethodrmrqrr�r��propertyr�r!� immutabledictr�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr,r=rIrMrQrYr`rdrhrmrgrqrurxr~r�r�r�r�r�r�r�r�rKrGrFrMrMRs�������� � ��K�����,5�y�+A�*C�M�C�C�C�C�&(��(�(�(�(� .B��A�A�A�A�����4�$�$�$��[�$�#�#�#�#� � � � �D � � � �  �  �  �  ������X�� :>�=A�$6�D�$6�$8�$8� +7�+7�+7�+7�+7�`7;�+�+�+�+�+�$(�@E�"�&*� $�(,�8=�*.�.2�<@�,0�15�n�n�n�n�n�h59� F�F�F�F�F�!%� G�G�G�G�G�4�4�4�4�1�1�1�1�59�  � � � � �3�3�3�3�. � � � �4�4�4�4�2�2�2�2�3�3�3�3�4�4�4�4�2�2�2�2�!� &�&�&�&�&�P&�&�&�&�P����,����B���� G�G�G� � � � ����>C�  �  �  �  �  �+�+�+�+� � � � � � � � � � � �>�>�>�>�?�?�?�?�����  � � �8����O�O�O�O� P�P�P�P� ),�),�),�),�V,�,�,�,�8.�.�.�";�;�;�;�;�;rGrM)� metaclassc�8�eZdZUded<ded<ded<ded<dS) rr:r7z List[str]r%r#zDict[str, str]r"N)rHrIrJr�rKrGrFrr@s<��������K�K�K������O�O�O������rGr� metadata_io�-Union[schema.Identity, schema.Sequence, None]� inspector_io� default_io�'Union[schema.Identity, schema.Sequence]r��Set[str]c ������tj|��}tj|��}t���t���d ���fd� }|||tj|��t|���|����tjr@|t |di��t |di��|jt |di������fS) N� meta_dictr�� insp_dict� default_dict�attrs� Iterable[str]c�>��t|���� ��D]x}|�|��}|�|��}||krF|�|��}||kr� �|���c��|���ydSrk)�set� differencerer�) r�r�r�r��attr� meta_value� insp_value� default_valuer�� ignored_attrr�s ���rF� check_dictsz._compare_identity_options.<locals>.check_dictsVs���� ��J�J�)�)�$�/�/� #� #�D�"���t�,�,�J�"���t�,�,�J��Z�'�'� ,� 0� 0�� 6� 6� ���.�.� �$�$�T�*�*�*�*��H�H�T�N�N�N�� #� #rG�dialect_kwargs)r�r�r�r�r�r�r�r�)r"�_get_identity_options_dictr��union�identity_has_dialect_kwargsr�r�) r�r�r�r��meta_d�insp_dr�r�r�s ` @@rFr�r�Gs������ 3�K� @� @�F� � 3�L� A� A�F� �5�5�D��5�5�L�#�#�#�#�#�#�#�#� �K����.�z�:�:� �F� � ���&�!�!� ��� �.� � � � �K�!1�2� 6� 6� �L�"2�B� 7� 7� � %� �L�"2�B� 7� 7�  � � � �� �rG)r�r�r�r�r�r�r�r�)K� __future__r�loggingr�typingrrrrrr r r r r rrrr� sqlalchemyrrrrrrrr�rrrrr!r"r#r$�sqlalchemy.enginer%r&�sqlalchemy.engine.cursorr'�sqlalchemy.engine.reflectionr(�sqlalchemy.sqlr)r*�sqlalchemy.sql.elementsr+r,�sqlalchemy.sql.schemar-r.r/r0�sqlalchemy.sql.selectabler1�sqlalchemy.sql.type_apir2r3�autogenerate.apir4�operations.batchr5r6� getLoggerrHr�rAr8rCr�rMrr�rKrGrF�<module>r�sf��#�"�"�"�"�"�"����� � � � ������������������������������������������������������������������������� � � � � � �������������������������+�+�+�+�+�+�������������������������������������8�8�8�8�8�8�:�:�:�:�:�:��������������7�������������,�,�,�,�,�,�)�)�)�)�)�)�5�5�5�5�5�5�6�6�6�6�6�6�,�,�,�,�,�,�)�)�)�)�)�)�5�5�5�5�5�5�3�3�3�3�3�3�0�0�0�0�0�0�:�:�:�:�:�:�+�+�+�+�+�+�6�6�6�6�6�6�5�5�5�5�5�5�2�2�2�2�2�2�$�$�$�$�$�$�1�1�1�1�1�1�1�1�1�1�1�1�6�6�6�6�6�6��g���!�!�� � � � � �t� � � �(*��)�)�)�)�k ;�k ;�k ;�k ;�k ;�H�k ;�k ;�k ;�k ;�\�����Z����/�/�/�/�/�/rG
Memory