HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
$ pwd: /usr/local/lib/python3.10/dist-packages/sqlalchemy/testing/__pycache__/
Upload Files
File: //usr/local/lib/python3.10/dist-packages/sqlalchemy/testing/__pycache__/assertions.cpython-310.pyc
o

���g�z�@s�ddlmZddlmZddlZddlmZddlmZddlZddl	Z	ddl
Z
ddlmZddlm
Z
dd	lmZdd
lmZddlmZddlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlmZd
dlmZdd�Z ej!dd��Z"dd�Z#dd�Z$dd �Z%d!d"�Z&d#d$�Z'da(da)da*	%	&	%dod'd(�Z+ej!	%	&	%	&	&dpd)d*��Z,d+d,�Z-d-d.�Z.d/d0�Z/dqd1d2�Z0dqd3d4�Z1dqd5d6�Z2dqd7d8�Z3dqd9d:�Z4dqd;d<�Z5dqd=d>�Z6dqd?d@�Z7dqdAdB�Z8dqdCdD�Z9dqdEdF�Z:e:Z;dqdGdH�Z<dqdIdJ�Z=e=Z>dqdKdL�Z?dqdMdN�Z@dOdP�ZAdQdR�ZBdSdT�ZCdUdV�ZDdWdX�ZEdYdZ�ZFd[d\�ZG	&drd]d^�ZHGd_d`�d`�ZIej!drdadb��ZJdsdcdd�ZKdsdedf�ZLGdgdh�dh�ZMGdidj�dj�ZNGdkdl�dl�ZOGdmdn�dn�ZPdS)t�)�annotations)�defaultdictN)�copy)�filterfalse�)�	assertsql)�config)�engines)�mock)�db_spec)�fail�)�exc)�schema)�sql)�types)�util)�default)�url)�LABEL_STYLE_TABLENAME_PLUS_COL��	decoratorcO�ttj|fi|��S)a�Context manager which expects one or more warnings.

    With no arguments, squelches all SAWarning emitted via
    sqlalchemy.util.warn and sqlalchemy.util.warn_limited.   Otherwise
    pass string expressions that will match selected warnings via regex;
    all non-matching warnings are sent through.

    The expect version **asserts** that the warnings were in fact seen.

    Note that the test suite sets SAWarning warnings to raise exceptions.

    )�_expect_warnings_sqla_only�sa_exc�	SAWarning��messages�kw�r�H/usr/local/lib/python3.10/dist-packages/sqlalchemy/testing/assertions.py�expect_warnings%s
r!cosb�t|�}t|t�r|tj�sdVdSt|i|���dVWd�dS1s*wYdS)z�Context manager which expects one or more warnings on specific
    dialects.

    The expect version **asserts** that the warnings were in fact seen.

    N)r�
isinstance�strr�_currentr!)�dbrr�specrrr �expect_warnings_on5s�
"�r'c�t�fdd��}|S)z�Decorator form of expect_warnings().

    Note that emits_warning does **not** assert that the warnings
    were in fact seen.

    c�@t�ddi��||i|��Wd�S1swYdS�N�assert_F)r!��fn�argsr�rrr �decorateN�$�zemits_warning.<locals>.decorater�rr0rr/r �
emits_warningFsr3cOr�N)rr�SADeprecationWarningrrrr �expect_deprecatedV�
��r6cOrr4)rr�Base20DeprecationWarningrrrr �expect_deprecated_20\r7r9cst��fdd��}|S)aVMark a test as emitting a warning on a specific dialect.

    With no arguments, squelches all SAWarning failures.  Or pass one or more
    strings; these will be matched to the root of the warning description by
    warnings.filterwarnings().

    Note that emits_warning_on does **not** assert that the warnings
    were in fact seen.

    csHt�g��Rddi��||i|��Wd�S1swYdSr*)r'r,�r%rrr r0ns$�z"emits_warning_on.<locals>.decorater)r%rr0rr:r �emits_warning_onbsr;cr()a+Mark a test as immune from fatal deprecation warnings.

    With no arguments, squelches all SADeprecationWarning failures.
    Or pass one or more strings; these will be matched to the root
    of the warning description by warnings.filterwarnings().

    As a special case, you may pass a function name prefixed with //
    and it will be re-written as needed to match the standard warning
    verbiage emitted by the sqlalchemy.util.deprecated decorator.

    Note that uses_deprecated does **not** assert that the warnings
    were in fact seen.

    cr)r*)r6r,r/rr r0�r1z!uses_deprecated.<locals>.decoraterr2rr/r �uses_deprecatedvsr<TFcCst|||||dd�S)z�SQLAlchemy internal use only _expect_warnings().

    Alembic is using _expect_warnings() directly, and should be updated
    to use this new interface.

    T)�regex�
search_msgr+�raise_on_any_unexpected)�_expect_warnings)�exc_clsrr=r>r+rrr r�s
�rc#sT��s�r
dd�|D��nt|��tdur5tdusJ�tdus!J�t���t���t|f7adVdSt���a�a|fa�rGdd��ntj��������fdd�}t	�
d|��DzdVWdaaa|r|�r|Jdd	��fd
d��D����ndaaa|r��r�Jdd	��fd
d��D����wWd�dS1s�wYdS)NcSs g|]}t�|tjtjB��qSr)�re�compile�I�S)�.0�msgrrr �
<listcomp>�s z$_expect_warnings.<locals>.<listcomp>c_std|��)NzGot unexpected warning: %r)�AssertionError)rG�argrrrr �	real_warn��z#_expect_warnings.<locals>.real_warncs�t|t�rt|�}t|�}n	|r|d}nd}|rt|t�s-�s+�|g|�Ri|��SdS�s3�s3dS�D]}�r>|�|�sK�rE|�|�sK�sS||krS��|�dSq5�sc�|g|�Ri|��dSdS)Nr)r"�_EXC_CLS�typer#�
issubclass�search�match�discard)rGrJr�	exception�filter_��filtersr?rKr=r>�seen�squelch_other_warningsrr �our_warn�s<


�����
��z"_expect_warnings.<locals>.our_warnz
warnings.warnzWarnings were not seen: %sz, c3s"�|]}d�r
|jn|VqdS)z%rN)�pattern)rF�s)r=rr �	<genexpr>�s�
�z#_expect_warnings.<locals>.<genexpr>)�list�_FILTERS�_SEENrM�extend�update�set�warnings�warnr
�patch�join)rArr=r>r+r?rXrYrrUr r@�sD�




�����"�r@cCs
t�dS)z�Check things that have to be finalized at the end of a test suite.

    Hardcoded at the moment, a modular system can be built here
    to support things like PG prepared transactions, tables all
    dropped, etc.

    N)�!_assert_no_stray_pool_connectionsrrrr �global_cleanup_assertions�s
rhcCstj��dSr4)r	�testing_reaper�assert_all_closedrrrr rg�rgcCs6t||�}t||�|ksJd||d|f��dS)Nz:Given int value %s is not within %d%% of expected value %s�d)�int�abs)�expected�received�variance�deviancerrr �int_within_variance
s��rscCs$t�||�sJ|pd||f��dS)Nz%r !~ %r)rBrQ��a�brGrrr �eq_regexs$rwcCs ||ksJ|pd||f��dS)z.Assert a == b, with repr messaging on failure.�%r != %rNrrtrrr �eq_� rycCs ||ksJ|pd||f��dS)z.Assert a != b, with repr messaging on failure.z%r == %rNrrtrrr �ne_rzr{cCs ||ksJ|pd||f��dS)z.Assert a <= b, with repr messaging on failure.rxNrrtrrr �le_#rzr|cCs"t||�sJ|p
d||f��dS)Nz%r is not an instance of %r�r"rtrrr �is_instance_of(s"r~cC�t|d|d�dS�N�rG)�is_�rurGrrr �is_none,�r�cCrr�)�is_notr�rrr �is_not_none0r�r�cC�tt|�d|d�dS)NTr��r��boolr�rrr �is_true4�r�cCr�)NFr�r�r�rrr �is_false8r�r�cCs ||usJ|pd||f��dS)z.Assert a is b, with repr messaging on failure.z%r is not %rNrrtrrr r�<rzr�cCs ||usJ|pd||f��dS)z2Assert a is not b, with repr messaging on failure.z%r is %rNrrtrrr r�Arzr�cCs ||vsJ|pd||f��dS)z.Assert a in b, with repr messaging on failure.z%r not in %rNrrtrrr �in_Jrzr�cCs ||vsJ|pd||f��dS)z2Assert a in not b, with repr messaging on failure.z%r is in %rNrrtrrr �not_inOrzr�cCs"|�|�sJ|p
d||f��dS)z>Assert a.startswith(fragment), with repr messaging on failure.z%r does not start with %rN)�
startswith)ru�fragmentrGrrr �startswith_Xs�r�cCstt�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}t�dd|�}||ks8J|p6d||f��dS)Nz^\s+?|\n�z {2,}� z\trx)rB�subrtrrr �eq_ignore_whitespace`s r�cCs,|j|jur|jsJd||jf��dSdS)aHassert that any exception we're catching does not have a __context__
    without a __cause__, and that __suppress_context__ is never set.

    Python 3 will report nested as exceptions as "during the handling of
    error X, error Y occurred". That's not what we want to do.  we want
    these exceptions in a cause chain.

    FzZException %r was correctly raised but did not set a cause, within context %r as its cause.N)�__context__�	__cause__�__suppress_context__)rSrrr � _assert_proper_exception_contextks����r�cOst||||dd�S)NT��
check_context��_assert_raises��
except_cls�	callable_r.rrrr �
assert_raises�r�r�cOst||||�Sr4r�r�rrr �assert_raises_context_ok�rkr�cOst|||||dd�S)NT�rGr�r��r�rGr�r.�kwargsrrr �assert_raises_message�s�r�cOs>t|dg��||i|��Wd�S1swYdS)alegacy adapter function for functions that were previously using
    assert_raises with SAWarning or similar.

    has some workarounds to accommodate the fact that the callable completes
    with this approach rather than stopping at the exception raise.


    z.*N�r)r�r�r.r�rrr �assert_warns�s	$�r�cOsDt||gddd��||i|��Wd�S1swYdS)aqlegacy adapter function for functions that were previously using
    assert_raises with SAWarning or similar.

    has some workarounds to accommodate the fact that the callable completes
    with this approach rather than stopping at the exception raise.

    Also uses regex.search() to match the given message to the error string
    rather than regex.match().

    TF)r>r=Nr�r�rrr �assert_warns_message�s�$�r�cOst|||||d�Sr�r�r�rrr � assert_raises_message_context_ok�sr�cCsDt|||��}||i|��Wd�|jS1swY|jSr4)�_expect_raises�error)r�r�r.r�rGr��ecrrr r��s
��r�c@seZdZdZdS)�_ErrorContainerN)�__name__�
__module__�__qualname__r�rrrr r��sr�c
cs��t|t�rt|t�st|t�rtd��t�}|rt��d}z|Vd}Wn@|yf}z4||_d}|durKt	|�}t
�||t
j�sKJd||f��|rS|sSt
|�tt	|��d��WYd}~nd}~ww~|snJd��dS)NzCUse expect_warnings for warnings, not expect_raises / assert_raisesrFTz%r !~ %s�utf-8z#Callable did not raise an exception)r"rNrO�Warning�	TypeErrorr��sys�exc_infor�r#rBrP�UNICODEr��print�encode)r�rGr�r��are_we_already_in_a_traceback�success�err�error_as_stringrrr r��s@��������r�cCst||d�S)Nr��r�)r�r�rrr �
expect_raises�rLr�cCst|||d�S)Nr�r�)r�rGr�rrr �expect_raises_message�rkr�c@s>eZdZ																				ddd�ZdS)�AssertsCompiledSQLNFTc/	s�|r
t���|
�_|�_nL|rd�nG�durt|dd���dur%tjj�n4�dks-�dkrB�dkr6t���nt�d��|
�_|�_n�dkrKt���nt	�t
�rYtj�
������|r^|�_i}i}|rh||d<|durrt|�|d<|rxd|d	<|r~d|d
<|r�d|d<|r�d|d<|r�d|d
<|s�t|dd�r�tj|d<ddlm}t	||j�r�|��}t|_|}|r�||d<Gdd�d��G�fdd�d�}||�jd5d�i|���t	|tj�r�|j}|r�t|�n|��}|r�t|d�tt�di��}|� d��!dd�}t"dt
��|� d��t#�$ddt
���}t%||d ||�f�|du�r@|�r8�j&|dd!��t%�j'|�nt%��(|�|�|	du�ru|�r_�j&|dd!��t%t)�fd"d#��j*D��|	�n�j(|dd!��t%t)�fd$d#��j*D��|	�|
du�r�t%�j+|
�|du�r�t%�fd%d&��j,D�|�|du�r�t%�fd'd&��j-D�|�|�rut�dd��rw�fd(d)�}|d*d�} |jd5d| i|��}!t#�$ddt
|!��}|dd�}"|jd5d|"i|��}#t|#j*�}$|#j.}%|#j-|#j,BD]}&|#j/|&��|$v�r��fd+d#�|$D�}$�q�g�t0t�}'|$D]B}(z.|(|'v�r|'|(d,})nd})|%�1|(|(�}*|�2d-|*f|)�d.}+��3|+�|'|(�3|+�W�qt4�yJd/|(|f},J|,��wt5�fd0d1�t6d2t7���D��}-d3d#�t8t9�|$��D�}.d4|$|.|f},t:|-|,�dSdSdS)6N�__dialect__r�
default_qmark�qmark�default_enhanced�schema_translate_map�column_keysT�
literal_binds�render_postcompile�"use_literal_execute_for_simple_int�for_executemany�render_schema_translate�assert_from_lintingF�lintingr)�orm�compile_kwargsc@�eZdZdd�ZdS)z5AssertsCompiledSQL.assert_compile.<locals>.DontAccesscSstd��)Nz=compiler accessed .statement; use compiler.current_executable)�NotImplementedError)�self�keyrrr �__getattribute__Os�zFAssertsCompiledSQL.assert_compile.<locals>.DontAccess.__getattribute__N)r�r�r�r�rrrr �
DontAccessN�r�csDeZdZdd�Zedd��Zdd�Zdd�Zd	d
�Z�fdd�Z	d
S)z>AssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccesscSsj||_i|_t|dd�|_|jr1|j|_t|d�r|j|_t|d�r&|j|_t|d�r3|j|_dSdSdS)N�supports_executionF�
_returning�_inline�_return_defaults)	�test_statement�_annotations�getattrr��_execution_options�hasattrr�r�r�)r�r�rrr �__init__Vs�


�zGAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess.__init__cSs|jjSr4)r��_variant_mapping�r�rrr r�gszOAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess._variant_mappingcSs
|j��Sr4)r��_default_dialectr�rrr r�ks
zOAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess._default_dialectc[s|jjj|fd|i|��S)N�dialect)r�rC�__func__�r�r�rrrr rCns���zFAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess.compilec[s|jjj||fi|��Sr4)r��	_compilerr�r�rrr r�ss
��zHAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess._compilercsht|d�r*tj�|d����|jj|fi|��Wd�S1s#wYdS|jj|fi|��S)N�	statement)r�r
re�objectr��_compiler_dispatch)r��compilerr��r�rr r�xs
���$���zQAssertsCompiledSQL.assert_compile.<locals>.CheckCompilerAccess._compiler_dispatchN)
r�r�r�r��propertyr�r�rCr�r�rr�rr �CheckCompilerAccessUs
r�r��paramsr��ascii�ignorez
SQL String:
z[\n\t]r�z%r != %r on dialect %r)�escape_namescsg|]}�j|�qSr)�
parameters�rF�x)�expanded_staterr rH�s��z5AssertsCompiledSQL.assert_compile.<locals>.<listcomp>csg|]}�|�qSrrr�)�prr rH��c�i|]	}�j||j�qSr��
bind_names�effective_value�rFrv��crr �
<dictcomp>����z5AssertsCompiledSQL.assert_compile.<locals>.<dictcomp>cr�rr�r�rrr r�rcst��}||_||_|Sr4)r�
paramstyle�
positional)rr�cp)r�rr �get_dialect�sz6AssertsCompiledSQL.assert_compile.<locals>.get_dialect�pyformatcsg|]}|�kr|�qSrr)rF�v��namerr rH�����z%%(%s)sr
z#Expected to find bindparam %r in %rc3s$�|]
}�|d�|kVqdS)rNr)rF�i)�	positionsrr r\�s
��
�z4AssertsCompiledSQL.assert_compile.<locals>.<genexpr>rcSsg|]\}}|�qSrr)rF�_r	rrr rH�r�zQOrder of parameters %s does not match the order in the statement %s. Statement %rr);r�DefaultDialect�supports_default_values�supports_default_metavaluer�rr%r��StrCompileDialectr"r#r�URL�creater�default_schema_namer]r�FROM_LINTING�
sqlalchemyr��Query�
_statement_20r�_label_stylerC�sqltypes�
TypeEngine�_static_cache_key�hash�_generate_cache_key�reprr��decoder�rBr�ry�construct_expanded_stater��construct_params�tuple�positiontup�prefetch�literal_execute_params�post_compile_params�escaped_bind_namesr�r�get�index�append�
ValueError�all�range�len�sorted�zipr�)/r��clause�resultr��checkparamsr��check_literal_execute�check_post_paramr��checkpositional�check_prefetch�use_default_dialect�allow_dialect_selectrrr�r�r�r�r�from_linting�check_param_orderr�rr�r��stmtr��cache_key_no_warnings�	param_str�ccr�pyformat_dialect�
pyformat_c�
qmark_dialect�qmark_c�values�escaped�
post_param�pos_by_valuer	�start�esc�posrG�orderedror)r�rr�r�rr�rr �assert_compile�s





3�
�
�
���



��

��



�

�

�����z!AssertsCompiledSQL.assert_compile)NNFNNNNNFFTTFFNFNFTF)r�r�r�rPrrrr r��s,�r�c@s"eZdZ		ddd�Zdd�ZdS)	�ComparesTablesFTcCsRt|j�t|j�ksJ�t|j|j�D]r\}}t|j|j�||j|jus(J�|r8t|j|j�t|j|j�|rPd}t|jt|j��sOJ||j|jf��n|�	||�t|jt
j�rft|jj|jj�|rytdd�|j
D�dd�|j
D��|jr�t|jtj�s�J�q|r�t|j�t|j�ks�J�|jD]}|jj|jdus�J�q�dSdS)Nz)Type '%s' doesn't correspond to type '%s'cS�h|]}|jj�qSr��columnr�rF�frrr �	<setcomp>r�z5ComparesTables.assert_tables_equal.<locals>.<setcomp>cSrRrrSrUrrr rWr�)r2rr4ryr�primary_key�nullabler"rN�assert_types_baser�String�length�foreign_keys�server_defaultr�FetchedValue�columns)r��table�reflected_table�strict_types�strict_constraintsr�reflected_crGrrr �assert_tables_equal�s@
����
�z"ComparesTables.assert_tables_equalcCs*|j�|j�sJd|j|j|jf��dS)Nz7On column %r, type '%s' doesn't correspond to type '%s')rN�_compare_type_affinityr)r��c1�c2rrr rZ(s���z ComparesTables.assert_types_baseN)FT)r�r�r�rfrZrrrr rQ�s

�+rQc@sreZdZdd�Zdd�Zdd�Zdd�Zdd
d�Zdd
�Zdd�Z	dd�Z
ejdd��Z
dd�Zejdd��Zd	S)�AssertsExecutionResultscGs&t|�}tt|��|�|||�dSr4)r]r�r"�assert_list)r�r6�class_�objectsrrr �
assert_result3sz%AssertsExecutionResults.assert_resultcCsL|�t|�t|�kd|j�tdt|��D]
}|�|||||�qdS)Nz9result list is not the same size as test list, for class r)r+r2r�r1�
assert_row)r�r6rl�list_rrrr rk8s���z#AssertsExecutionResults.assert_listc	Cs�|�|j|udt|��|��D]A\}}t|t�r?t|dt�r0|�t||�|d|d�q|�	|dt||�|d�q|�t||�|kd|t||�|f�qdS)Nzitem class is not rrz'attribute %s value %s does not match %s)
r+�	__class__r"�itemsr"r&r]rkr�ro)r�rl�rowobj�descr��valuerrr roBs�
���z"AssertsExecutionResults.assert_rowc	s�Gdd�dt��t�|�}�fdd�|D�}t�fdd�|�D]}tdt|�j�jf�qt|�t|�krBtdt|�t|�f�t����fd	d
�}|D]}|D]}|||�r`|�	|�nqRtd�jt
|�f�qNdS)
z�As assert_result, but the order of objects is not considered.

        The algorithm is very expensive but not a big deal for the small
        numbers of rows that the test suite manipulates.
        c@r�)zFAssertsExecutionResults.assert_unordered_result.<locals>.immutabledictcSst|�Sr4)�idr�rrr �__hash__[szOAssertsExecutionResults.assert_unordered_result.<locals>.immutabledict.__hash__N)r�r�r�rwrrrr �
immutabledictZr�rxcsh|]}�|��qSrr)rF�e)rxrr rW_r�zBAssertsExecutionResults.assert_unordered_result.<locals>.<setcomp>cs
t|��Sr4r})�o)�clsrr �<lambda>as
zAAssertsExecutionResults.assert_unordered_result.<locals>.<lambda>z#Unexpected type "%s", expected "%s"z+Unexpected object count "%s", expected "%s"c	st|��D]3\}}t|t�r,z�jt||�|dg|d�R�Wqty+YdSwt||��|kr7dSqdS)NrrFT)rrr"r&�assert_unordered_resultr�rI)�objr&r�ru)�NOVALUEr�rr �
_compare_itemos
����zFAssertsExecutionResults.assert_unordered_result.<locals>._compare_itemz2Expected %s instance with attributes %s not found.T)�dictr�IdentitySetrrrNr�r2r��remover")	r�r6r{ro�found�wrongr��
expected_item�
found_itemr)rr{rxr�r r}Ss<
����

����z/AssertsExecutionResults.assert_unordered_resultNcCs|dur
ddlm}t�|�S)Nr)r%)r�r%r�
assert_engine)r�r%rrr �sql_execution_asserter�s
z.AssertsExecutionResults.sql_execution_assertercGs>|�|��}|�}Wd�n1swY|j|�|Sr4�r�r+)r�r%r��rules�asserterr6rrr �assert_sql_execution�s
�
z,AssertsExecutionResults.assert_sql_executioncCsZg}|D]}t|t�rtjdd�|��D��}ntj|�}|�|�q|j||g|�R�S)NcSsg|]
\}}t�||��qSr)r�CompiledSQL)rF�kr	rrr rH�sz6AssertsExecutionResults.assert_sql.<locals>.<listcomp>)r"r�r�AllOfrrr�r.r�)r�r%r�r��newrules�rule�newrulerrr �
assert_sql�s
�
z"AssertsExecutionResults.assert_sqlcCs|�||t�|��Sr4)r�r�CountStatements)r�r%r��countrrr �assert_sql_count�s�z(AssertsExecutionResults.assert_sql_countcgs@�|�|��}dVWd�n1swY|j|�dSr4r�)r�r%r�r�rrr �assert_execution�s
��z(AssertsExecutionResults.assert_executioncCs|�|t�|��Sr4)r�rr�)r�r%r�rrr �assert_statement_count�r�z.AssertsExecutionResults.assert_statement_countc	#s���fdd�t||�D�}g}|D]\}}}|�|���qz"dVWt||�D]\}\}}}|�ddd�|�t�|��q(dSt||�D]\}\}}}|�ddd�|�t�|��qFw)Ncs g|]\}}��|�||f�qSr)r�)rFr%r�r�rr rH�s��zKAssertsExecutionResults.assert_statement_count_multi_db.<locals>.<listcomp>)r4r.�	__enter__�__exit__r+rr�)	r��dbs�counts�recs�	asserters�ctxr%r�r�rr�r �assert_statement_count_multi_db�s �
���z7AssertsExecutionResults.assert_statement_count_multi_dbr4)r�r�r�rnrkror}r�r�r�r��
contextlib�contextmanagerr�r�r�rrrr rj2s

6

rjc@seZdZd
dd�Zd	S)�ComparesIndexesra�schema.Tableror]�dialect_namer#c
Cstt|j�t|��dd�|jD�}|D]x}||d}t|j|d�dd�|dD�}tt|j�t|��|D]	}t||jv�q9|�d�}	|	rmtt|j�t|	��t|j|	|d�D]\}
}}|durlt|
j	|�q]|�d	�r�|�d
�|d	vr�t|j
|d|d	|�d
��qdS)NcSsi|]}|j|�qSrr
)rF�idxrrr r�r�zEComparesIndexes.compare_table_index_with_expected.<locals>.<dictcomp>r�uniquecSsg|]}|dur|�qSr4r)rFrrrr rH�rzEComparesIndexes.compare_table_index_with_expected.<locals>.<listcomp>�column_names�expressions�dialect_options�_include�include)ryr2�indexesr�r`r�r,r�r4�textr�)
r�raror��idx_dict�expr��colsr�exprs�idx_exp�expr�colrrr �!compare_table_index_with_expected�s6
������z1ComparesIndexes.compare_table_index_with_expectedN)rar�ror]r�r#)r�r�r�r�rrrr r��sr�)TFT)TFTFFr4)NF)T)Q�
__future__r�collectionsrr�r�	itertoolsrrBr�rcr�rrr	r
�
exclusionsrrrrrrrrr�enginerr�sql.selectablerrr!r�r'r3r6r9r;r<r^r_rMrr@rhrgrsrwryr{r|r~r�r�r�r�r�r��is_not_r�r��not_in_r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rQrjr�rrrr �<module>s�	

��P
















�
*

6
@ Telegram