Team Ai
Datasetpublic

codekingpro/portable-devtools

sourceHugging Faceupdated 5mo agoView on Hugging Face
1likes15kdownloads
lambdas.cpython-313.pyc367 linesDownload Raw Back to __pycache__
1�

2��j�����%SSKJr SSKJr SSKrSSKrSSKrSSKrSSK	r	SSK	J3r4 SSKJr SSKJ
r
 SSKJr SSKJr SSKJr SS	KJr SS5KJr SSKJr SSKJr SS
KJr SSKJr SSKrSSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSK J!r! SSK J"r" SSK J#r# SSKJ$r$ SSK%J&r& SSKJ'r' SSKJ(r( SSKJ)r) SSK*J+r+ \(aSS KJ,r, SS!KJ-r- SS"KJ.r. SS#KJ/r/ \\\S$4\S%4r0\
S$\4r1\)Rd"S&5r3S'\4S('\
/\4r5\
S$\4r6\
/\4r7\"S)\"S*9r8\
\8/\4r9"S+S,\#5r:SASBS.jjr;"S/S0\RZ5r<"S1S2\<5r="S3S-\R|\<\"5r?"S4S5\R|\RZ5r@"S6S7\?5rA"S8S95rB"S:S;5rC"S<S=5rD"S>S?\&5rE\(R�"\<5S@5rGg)C�)�annotationsN)�CodeType)�Any)�Callable)�cast)�List)�MutableMapping)�Optional)�Tuple)�Type)�
TYPE_CHECKING)�TypeVar)�Union�)�	cache_key)�	coercions)�elements)�roles)�schema)�visitors)�_clone)�6Executable)�Options)�7CacheConst)�ColumnOperators�)�exc)�8inspection)�util)�Literal)�
BindParameter)�
ClauseElement)�SQLRole)�_CloneCallableType.)�NonAnalyzedFunction�AnalyzedFunctioni��_LambdaCacheType�_closure_per_cache_key�_E)�boundc�B�\rSrSr%SrSrSrS\S'SrSr	Sr9S\S'Srg)	�
LambdaOptions�HTN�Optional[object]�track_on�Optional[_LambdaCacheType]�lambda_cache�)�__name__�10__module__�__qualname__�__firstlineno__�enable_tracking�track_closure_variablesr/�__annotations__�global_track_bound_values�track_bound_valuesr1�__static_attributes__r2��\D:\code\apps\devtools\python\user_packages\Python313\site-packages\sqlalchemy/sql/lambdas.pyr,r,Hs/���O�"��!%�H��%� $����/3�L�,�3r=r,�StatementLambdaElementc
�P�[U[R[UUUUUUS95$)a�Produce a SQL statement that is cached as a lambda.11 12The Python code object within the lambda is scanned for both Python13literals that will become bound parameters as well as closure variables14that refer to Core or ORM constructs that may vary.   The lambda itself15will be invoked only once per particular set of constructs detected.16 17E.g.::18 19    from sqlalchemy import lambda_stmt20 21    stmt = lambda_stmt(lambda: table.select())22    stmt += lambda s: s.where(table.c.id == 5)23 24    result = connection.execute(stmt)25 26The object returned is an instance of :class:`_sql.StatementLambdaElement`.27 28.. versionadded:: 1.429 30:param lmb: a Python function, typically a lambda, which takes no arguments31 and returns a SQL expression construct32:param enable_tracking: when False, all scanning of the given lambda for33 changes in closure variables or bound parameters is disabled.  Use for34 a lambda that produces the identical results in all cases with no35 parameterization.36:param track_closure_variables: when False, changes in closure variables37 within the lambda will not be scanned.   Use for a lambda where the38 state of its closure variables will never change the SQL structure39 returned by the lambda.40:param track_bound_values: when False, bound parameter tracking will41 be disabled for the given lambda.  Use for a lambda that either does42 not produce any bound values, or where the initial bound values never43 change.44:param global_track_bound_values: when False, bound parameter tracking45 will be disabled for the entire statement including additional links46 added via the :meth:`_sql.StatementLambdaElement.add_criteria` method.47:param lambda_cache: a dictionary or other mapping-like object where48 information about the lambda's Python code as well as the tracked closure49 variables in the lambda itself will be stored.   Defaults50 to a global LRU cache.  This cache is independent of the "compiled_cache"51 used by the :class:`_engine.Connection` object.52 53.. seealso::54 55    :ref:`engine_lambda_caching`56 57 58)r7r/r8r:r;r1)r?r�
StatementRoler,)�lmbr7r8r/r:r;r1s       r>�lambda_stmtrCQs8��v"��
����+��$;�&?�1�%�
	59��r=c�n�\rSrSr%SrSrSrS\RR4/r60SrS\S'S	\S61'Sr
S\S
'S\S'S\S'S\S'S\S'S\S'Sr\S4S&SjjrSrSr\S5r\S5r\S5rSrS r\S4S'S!jjr\R8S"5rS#rS(S$jrS%r g))�
LambdaElement�a�A SQL construct where the state is stored as an un-invoked lambda.62 63The :class:`_sql.LambdaElement` is produced transparently whenever64passing lambda expressions into SQL constructs, such as::65 66    stmt = select(table).where(lambda: table.c.col == parameter)67 68The :class:`_sql.LambdaElement` is the base of the69:class:`_sql.StatementLambdaElement` which represents a full statement70within a lambda.71 72.. versionadded:: 1.473 74.. seealso::75 76    :ref:`engine_lambda_caching`77 78�lambda_elementT�	_resolvedr2zTuple[_CloneCallableType, ...]�_transformszList[BindParameter[Any]]�_resolved_bindparamsNz Optional[StatementLambdaElement]�
parent_lambdaz4Union[Tuple[Any, ...], Literal[CacheConst.NO_CACHE]]�closure_cache_key�
Type[SQLRole]�rolez,Union[AnalyzedFunction, NonAnalyzedFunction]�_rec�_AnyLambdaType�fnzTuple[CodeType, ...]�tracker_keyc�f�URR<SURR<S3$)N�(�))�	__class__r3rQ�__code__��selfs r>�__repr__�LambdaElement.__repr__�s&���N�N�#�#��G�G���79�	80r=c���XlX lUR4UlX0lUcU[81RLaUnURXU5nUbURnU(aXdl	ggg�N)82rQrNrWrR�optsrrA�_retrieve_tracker_rec�propagate_attrs�_propagate_attrs)rYrQrNr^�apply_propagate_attrs�recr`s       r>�__init__�LambdaElement.__init__�sp�����	��K�K�>����	� �(�d�e�6I�6I�.I�$(�!��(�(��D�I�� �,�!�1�1�O��9H�6��-r=c�j�URnUc[nURnURnURn[83R
UUU5n/=UlnURbURRn	OSn	U	[RLa�[R"5n84[URVs/sHnU"XcX�5PM sn5n[RU85;aX�-nX�l	UR
X\-5n
O%[RnSn
O[RnSn
X�l	U
cvU[RLaH[86R  X\-nX�;a![#XpX!5n
[%U5U
lX�U'OXNn
SSS5 Ob[)UR+U55n
OG[-U
R&U5VVs/sH unnUR/UR0SS9PM" snnUSS&X�lU[RLa�URbURRUSS&UnUbaUR2n
U
R4(a3U
R6nU
R4HnU"URUU5 M URnUbMaU
$s snf!,(df   N�=fs snnf)Nr2T��maintain_keyr)r1r(rRrQ�__closure__�AnalyzedCode�getrJrKrL�87_cache_key�NO_CACHEr�anon_map�tuple�closure_trackers�_generation_mutexr&�list�closure_bindparamsr%�_invoke_user_fn�zip�_with_value�valuerO�bindparam_trackers�tracker_instrumented_fn)rYrQrbr^r1rR�closure�tracker�88bindparams�parent_closure_cache_keyrn�getterrrc�key�	orig_bind�new_bindrGrys                   r>r_�#LambdaElement._retrieve_tracker_rec�s����(�(����1�L��&�&��
�W�W���.�.���"�"����89��24�3��!�J����)�'+�'9�'9�'K�'K�$�')�$�$�:�+>�+>�>��(�(�*�H��#*�":�":��":���7�(�?�":���I��"�"�(�2�4�@�	�)2�&�"�&�&�{�'>�?��&�/�/�	���#�+�+�I��C�!*���;��90� 3� 3�3�!�3�3�%�1�C��.�.�#�+@���26�j�1A��.�,/�S�)�*�/��4�3�*�$�*>�*>�r�*B�C��91,/��*�*�J�,��,�'�I�x��%�%�h�n�n�4�%�H�,��J�q�M��	��J�/�/�/��!�!�-�!%�!3�!3�!H�!H�92�2�A��6:�N� �,�$�)�)���)�)��3�3�,�$'�#9�#9���*�-�-�3�&��$:�"0�!=�!=��!�,��93��E�04�3��s�;J�/J�'J/�94J,c�B�[URRU5$r])�getattrrO�
expected_expr�rYrs  r>�__getattr__�LambdaElement.__getattr__<s���t�y�y�.�.��4�4r=c�.�URR$r])rO�is_sequencerXs r>�_is_sequence�LambdaElement._is_sequence?s���y�y�$�$�$r=c���UR(aC[RRURVs/sHoR95PM sn5$URR96$s snfr])r��	itertools�chain�
from_iterablerH�_select_iterable�rY�elements  r>r��LambdaElement._select_iterableCsT������?�?�0�0�9=���H��g�)�)��H��
�97�>�>�2�2�2��	I��A+c���UR(aC[RRURVs/sHoR98PM sn5$URR99$s snfr])r�r�r�r�rH�
_from_objectsr�s  r>r��LambdaElement._from_objectsMsT������?�?�0�0�6:�n�n�E�n�7�&�&�n�E��
�100�>�>�/�/�/��	Fr�c�n�URVs0sHoRUR_M sn$s snfr])rJrrw)rY�bs  r>�_param_dict�LambdaElement._param_dictWs,��(,�(A�(A�B�(A�1���q�w�w��(A�B�B��Bs� 2c�d^�URVs0sHo"RU_M snmSU4SjjnURR(a*UVs/sHn[R101"U0U5PM nnU$[
USS5(a[R102"U0U5nU$s snfs snf)Nc��>�[U[R5(a[URT;aKTURnUR(a)SUlUR103UlURUlU$g�NT)�104isinstancerr!r�	expanding�	expand_op�type)r��kw�bind�bindparam_lookups   �r>�replace�<LambdaElement._setup_binds_for_tracked_expr.<locals>.replace]sc����'�8�#9�#9�:�:��;�;�"2�2�+�G�K�K�8�D��(�(�)-���)0�):�):���$+�L�L��	��K�r=�is_clause_elementF)r��(Optional[visitors.ExternallyTraversible]r�r�returnr�)rJrrOr�r�replacement_traverser�)rY�exprr�r��sub_exprr�s     @r>�_setup_binds_for_tracked_expr�+LambdaElement._setup_binds_for_tracked_exprZs����.2�.G�.G�H�.G��E�E�1�H�.G�H��	�=�	�EH�	�
5�	��9�9� � �!%�� $�H��-�-�h��G�D� $�
�����T�.��
6�
6��0�0��r�7�C�D����1I��"s�B(�"B-c�8�U"UR4SU0UD6Ulg)N�deferred_copy_internals)rH)rY�cloner�r�s    r>�_copy_internals�LambdaElement._copy_internalsus)����N�N�105�$;�106��107��r=c�v�URRnUR(aURU5nU$r])rOr�rJr��rYr�s  r>rH�LambdaElement._resolved�s/���y�y�&�&���$�$��5�5�d�;�D��r=c���UR[RLaSU[R'gURRUR1084UR-nURnUbYUR[RLdeURnURR4U-U-nURnUbMYUR(aURUR5 U$r�)109rLrlrmrQrWrVrKrrJ�extend)rYrnr|r�parentr}s      r>�_gen_cache_key�LambdaElement._gen_cache_key�s����!�!�Z�%8�%8�8�,0�H�Z�(�(�)��
�G�G����N�N�110�
�"�"�#�	�111�#�#��� ��+�+�:�3F�3F�F�F�F��(�(�
%�112���#�#�%�(@�@�9�L�
��)�)�F�� ��$�$����d�7�7�8��r=c��U"5$r]r2�rYrQ�args   r>rt�LambdaElement._invoke_user_fn�s	���t�r=)rOrHrJrLrQr^rNrR)rQ�_LambdaTyperNrMr^�)Union[Type[LambdaOptions], LambdaOptions]rb�Optional[ClauseElement])r�r$r�zOptional[_CloneCallableType]r�rr��None)rQrPr�rr�r")!r3r4r5r6�__doc__�__visit_name__�_is_lambda_elementr�InternalTraversal�dp_clauseelement�_traverse_internalsrIr9rKrZr,rdr_r��propertyr�r�r�r�r�rr�r�memoized_propertyrHr�rtr<r2r=r>rErE�sV���&&�N���113�h�0�0�A�A�B���35�K�/�4�2�2�6:�M�3�:�K�K�114��1156�6���%�%�116�;H�9=�I��I��I�8�	I�117 7�I�,^�@5��%��%��3��3��0��0�C��:%+�@D�118�!�119�">�120��	121�122123�124�125�������8r=rEc�j^�\rSrSrSr\S4S126U4SjjjrSrSSjr\	S4U4Sjjr127S	rU=r$)�DeferredLambdaElementi�a*A LambdaElement where the lambda accepts arguments and is128invoked within the compile phase with special context.129 130This lambda doesn't normally produce its real SQL expression outside of the131compile phase.  It is passed a fixed set of initial arguments132so that it can generate a sample expression.133 134r2c�2>�X@l[TU]	XU5 gr])�lambda_args�superrd)rYrQrNr^r�rVs     �r>rd�DeferredLambdaElement.__init__�s���'��
����4�(r=c� �U"UR6$r]�r�r�s   r>rt�%DeferredLambdaElement._invoke_user_fn�s���4�#�#�$�$r=c��[UR[5(deURRnU"U6n[R135"URU5nURU5nURHnU"U5nM
 U$r])	r�rOr&ryr�expectrNr�rI)rYr��136tracker_fnr�r�s     r>�_resolve_with_args�(DeferredLambdaElement._resolve_with_args�s}���$�)�)�%5�6�6�6�6��Y�Y�6�6�137��;�'������	�	�4�0���1�1�$�7��0(,�'7�'7�#�*�4�0�D�(8��r=Nc�`>�[TU]UUUS9 U(aU=RU4-
slgg)N)r�r�r^)r�r�rI)rYr�r�r�rVs    �r>r��%DeferredLambdaElement._copy_internals�s?���	����$;��	 �	138�#����!8� :�:��#r=r�)rQrPrNzType[roles.SQLRole]r^r�r�zTuple[Any, ...])r�rr�r")
r3r4r5r6r�r,rdrtr�rr�r<�
__classcell__)rVs@r>r�r��s]����;H�')�)��)�"�)�8�	)�139%�)�)�%�"�J�D�;�;r=r�c�H�\rSrSrSr\(a\S4SSjjrSSjrSSSjjr	Sr140\SSj5r\S	5r
\S1415r\S5r\S5r\S
5r\S5r\S5r\S5r\S5r\S5rSSjrSrg)r?i�a/Represent a composable SQL statement as a :class:`_sql.LambdaElement`.142 143The :class:`_sql.StatementLambdaElement` is constructed using the144:func:`_sql.lambda_stmt` function::145 146 147    from sqlalchemy import lambda_stmt148 149    stmt = lambda_stmt(lambda: select(table))150 151Once constructed, additional criteria can be built onto the statement152by adding subsequent lambdas, which accept the existing statement153object as a single parameter::154 155    stmt += lambda s: s.where(table.c.col == parameter)156 157.. versionadded:: 1.4158 159.. seealso::160 161    :ref:`engine_lambda_caching`162 163Nc��gr]r2)rYrQrNr^rbs     r>rd�StatementLambdaElement.__init__s��r=c�$�URU5$r])�add_criteria)rY�others  r>�__add__�StatementLambdaElement.__add__s��� � ��'�'r=c	�r�UR[UUURRUUS9-n[XUS9$)a�Add new criteria to this :class:`_sql.StatementLambdaElement`.164 165E.g.::166 167    >>> def my_stmt(parameter):168    ...     stmt = lambda_stmt(169    ...         lambda: select(table.c.x, table.c.y),170    ...     )171    ...     stmt = stmt.add_criteria(lambda: table.c.x > parameter)172    ...     return stmt173 174The :meth:`_sql.StatementLambdaElement.add_criteria` method is175equivalent to using the Python addition operator to add a new176lambda, except that additional arguments may be added including177``track_closure_values`` and ``track_on``::178 179    >>> def my_stmt(self, foo):180    ...     stmt = lambda_stmt(181    ...         lambda: select(func.max(foo.x, foo.y)),182    ...         track_closure_variables=False,183    ...     )184    ...     stmt = stmt.add_criteria(lambda: self.where_criteria, track_on=[self])185    ...     return stmt186 187See :func:`_sql.lambda_stmt` for a description of the parameters188accepted.189 190)r7r8r:r/r;)rKr^)r^�dictr:�LinkedLambdaElement)rYr�r7r/r8r;r^s       r>r��#StatementLambdaElement.add_criteriasB��J�y�y�4�+�$;�&*�i�i�&I�&I��1�191�192��#�5�4�H�Hr=c��[(a+[URR[5(deURRR193(aUR
XU5$[R"U5er])	r
r�rOr�r"�supports_execution�_execute_clauseelementr�ObjectNotExecutableError�rY�194connection�distilled_params�execution_optionss    r>�_execute_on_connection�-StatementLambdaElement._execute_on_connectionNse���=��d�i�i�5�5�}�E�E�E�E��9�9�"�"�5�5��4�4��(9��
��.�.�t�4�4r=c��UR$r])�_rec_expected_exprrXs r>�_proxied�StatementLambdaElement._proxiedZs���&�&�&r=c�.�URR$r])r��
_with_optionsrXs r>r��$StatementLambdaElement._with_options^s���}�}�*�*�*r=c�.�URR$r])r��_effective_plugin_targetrXs r>r��/StatementLambdaElement._effective_plugin_targetbs���}�}�5�5�5r=c�.�URR$r])r��_execution_optionsrXs r>r�)StatementLambdaElement._execution_optionsfs���}�}�/�/�/r=c�.�URR$r])r��_all_selected_columnsrXs r>r�,StatementLambdaElement._all_selected_columnsjs���}�}�2�2�2r=c�.�URR$r])r��	is_selectrXs r>r� StatementLambdaElement.is_selectn����}�}�&�&�&r=c�.�URR$r])r��	is_updaterXs r>r195� StatementLambdaElement.is_updaterrr=c�.�URR$r])r��	is_insertrXs r>r
� StatementLambdaElement.is_insertvrr=c�.�URR$r])r��is_textrXs r>r�StatementLambdaElement.is_textzs���}�}�$�$�$r=c�.�URR$r])r��	is_deleterXs r>r� StatementLambdaElement.is_delete~rr=c�.�URR$r])r��is_dmlrXs r>r�StatementLambdaElement.is_dml�s���}�}�#�#�#r=c�4�[UR55$)zdReturn a new :class:`.StatementLambdaElement` that will run196all lambdas unconditionally each time.197 198)�NullLambdaStatementrQrXs r>�spoil�StatementLambdaElement.spoil�s��199#�4�7�7�9�-�-r=r2)rQ�_StmtLambdaTyperNrMr^r�rbr�)r��_StmtLambdaElementType[Any]r�r?)TNTT)r�rr7�boolr/z
Optional[Any]r8rr;rr�r?)r�r)r�r)r3r4r5r6r�r
r,rdr�r�r�r�r�r�r�rrrr200r
rrrrr<r2r=r>r?r?�s����0�?L�=A�	��	� �	�<�		�201$;�	�(�0�(�	�(�!%�"&�(,�#'�
-I�*�-I��-I� �	-I�202"&�-I�!�
-I�203 �-I�^2045��'��'��+��+��6��6��0��0��3��3��'��'��'��'��'��'��%��%��'��'��$��$�.r=c�p�\rSrSrSrSrSrS\RR4/r205SrSrSr
S	rS206rSrg)
ri�z�Provides the :class:`.StatementLambdaElement` API but does not207cache or analyze lambdas.208 209the lambdas are instead invoked immediately.210 211The intended use is to isolate issues that may arise when using212lambda statements.213 214rGTrHc�2�XlURUlgr])rHra)rY�	statements  r>rd�NullLambdaStatement.__init__�s��"�� )� :� :��r=c�.�[URU5$r])r�rHr�s  r>r��NullLambdaStatement.__getattr__�s���t�~�~�s�+�+r=c�<�U"UR5n[U5$r]�rHr)rYr�r!s   r>r��NullLambdaStatement.__add__�����$�.�.�)�	�"�9�-�-r=c�<�U"UR5n[U5$r]r&)rYr�r�r!s    r>r�� NullLambdaStatement.add_criteria�r(r=c��URR(aURXU5$[R"U5er])rHr�r�rr�r�s    r>r��*NullLambdaStatement._execute_on_connection�s=���>�>�,�,��4�4��(9��
��.�.�t�4�4r=)rarHN)r3r4r5r6r�r�r�rr�r�r�rdr�r�r�r�r<r2r=r>rr�sK���&�N���215�h�0�0�A�A�B���;�,�.�216.�2175r=rc�@�\rSrSr%SrS\S'S	SjrSrSrg)218r�i�zARepresent subsequent links of a :class:`.StatementLambdaElement`.r?rKc��X0lXlX lURUR4-UlURXU5 URUlgr])r^rQrKrRrWr_ra)rYrQrKr^s    r>rd�LinkedLambdaElement.__init__�sK���	���*��(�4�4����~�E����"�"�2�T�2� -� >� >��r=c�:�U"URR5$r])rKrHr�s   r>rt�#LinkedLambdaElement._invoke_user_fn�s���$�$�$�.�.�/�/r=)rarQr^rKrRN)rQrrKr?r^r�)	r3r4r5r6r�r9rdrtr<r2r=r>r�r��s1��K�)�)�?�'�?�.�?�8�	?�0r=r�c���\rSrSr%Sr\R"5rS\S'\	R"5r\S5r
SrSrSrS	rS219r\S5rSrS
rSrSSjrSSjrSrSrg)rji�)r8r;rxrp�build_py_wrappersz1weakref.WeakKeyDictionary[CodeType, AnalyzedCode]�_fnsc�l�URUR$![a Of=fUR URUR;a"URURsSSS5 $[	XU40UD6=URUR'nUsSSS5 $!,(df   g=fr])r4rW�KeyErrorrqrj)�clsrQrG�	lambda_kwr��analyzeds      r>rk�AnalyzedCode.get�s���	��8�8�B�K�K�(�(���	��	���
"�
"��{�{�c�h�h�&��x�x����,�#�
"�0<��I�0�13�0�
�C�H�H�R�[�[�!�H��#�
"�
"�s��220(�(�3B%�4'B%�%221B3c��[R"U5(a[R"SU-5eURnUR222=(a URUlURnURnURnU=(a U(+Ul	/Ul223/Ul/UlU(aAU(aURU5 URU5 U(aURU5 UR!XU5 g)Nz/Method %s may not be passed as a SQL expression)�inspect�ismethodr�
ArgumentErrorrir;r:r7r/r8rxrpr3�_init_track_on�
_init_globals�
_init_closure�"_setup_additional_closure_trackers)rYrQrGr^rzr7r/r8s        r>rd�AnalyzedCode.__init__�s������B����#�#�A�B�F��
��.�.��
�#�#�F��(F�(F�	
���.�.���=�=��"&�">�">��'>�'O�x�<��$�224#%���225!#���!#������#�#�H�-����r�"���"�"�2�&��/�/��D�Ir=c�b^�TRRU4Sj[U555 g)Nc3�J># �UHupTRX5v� M g7fr])�_cache_key_getter_track_on)�.0�idx�elemrYs   �r>�	<genexpr>�.AnalyzedCode._init_track_on.<locals>.<genexpr>s(����%226�0�	��
�+�+�C�6�6�0�s� #)rpr��	enumerate)rYr/s` r>r?�AnalyzedCode._init_track_ons)������$�$�%227�&�x�0�%228�	229r=c��URnURnURnURRH�nXQR230;aMUR
UR231U5n[R"U5(dMOURUS45 U(dMkURURU55 M� gr])r3rxr;rW�co_names�__globals__�_roll_down_to_literalr�_deep_is_literal�append�$_bound_parameter_getter_func_globals)rYrQr3rxr;�name�_bound_values       r>r@�AnalyzedCode._init_globals"s��� �2�2��!�4�4��!�4�4���K�K�(�(�D��>�>�)���5�5�b�n�n�T�6J�K�L��)�)�,�7�7�!�(�(�$���6�%�%�&�-�-��A�A�$�G��)r=c	�L�URnURnURnURnURnUR232n[
[URRU55H�unup�URU233R5n[R"U5(a=URX�45 U(a"URURX�55 MyM{U(dM�URUR!XX�R55 M� gr])r3rir;r8rxrprLrurW�co_freevarsrQ�
cell_contentsrrRrS�$_bound_parameter_getter_func_closure�"_cache_key_getter_closure_variable)rYrQr3rzr;r8rxrp�
closure_index�fv�cellrVs            r>rA�AnalyzedCode._init_closure4s�� �2�2���.�.��!�4�4��"&�">�">��!�4�4���0�0��)2�����'�'��1�*234�%�M�:�B� �5�5�d�6H�6H�I�L��)�)�,�7�7�!�(�(�"�)<�=�%�&�-�-��A�A����&�+�*�$�+�+��?�?��M�3E�3E���)*235r=c���[UUSU5nURnURH6nUR(aMUR	URX55 M8 gr])r&rp�closure_pywrappers�_sa__has_paramrS�!_cache_key_getter_tracked_literal)rYrQrGr^�analyzed_functionrp�	pywrappers       r>rB�/AnalyzedCode._setup_additional_closure_trackersWsa��-�����	236�� �0�0��*�=�=�I��+�+�+� �'�'��:�:�2�I��>r=c���[US5nU(a{[U[R[R237[45(dGUR5n[U[R[R238[45(dMGU(d+[R"USS9nUbUR5$U$U$![a MAf=f![a Us$f=f)N�__clause_element__F��raiseerr)�hasattrr�rr"r�239SchemaItemr�ri�AttributeErrorrr<)r7r�r��insps    r>rQ�"AnalyzedCode._roll_down_to_literalms���#�G�-A�B��� ��(�0�0�&�2C�2C�T�J����%�8�8�:�G�	!��(�0�0�&�2C�2C�T�J���!��%�%�g��>�D��� ��2�2�4�4�240�N��N��&�����&� ��K� �s$�	C�/C�241C�C�C#�"C#c�^�U4SjnU$)z�Return a getter that will extend a list of bound parameters242with new entries from the ``__globals__`` collection of a particular243lambda.244 245c�x>�URTn[RUS5"URTU5 g�N�_extract_bound_parameters)rP�object�__getattribute__)�246current_fnry�result�wrapperrUs    �r>�extract_parameter_value�RAnalyzedCode._bound_parameter_getter_func_globals.<locals>.extract_parameter_value�s;���.�9�9�$�?�G��#�#�G�-H�I��&�&�t�,�f�
r=r2)rYrUrzs ` r>rT�1AnalyzedCode._bound_parameter_getter_func_globals�s���	�'�&r=c�^�U4SjnU$)z�Return a getter that will extend a list of bound parameters247with new entries from the ``__closure__`` collection of a particular248lambda.249 250c�>�URTRn[RUS5"URTRU5 grs)rirZrurv)rwryrxryr]s    �r>rz�RAnalyzedCode._bound_parameter_getter_func_closure.<locals>.extract_parameter_value�sN���.�9�9����m�
�
�#�#�G�-H�I��&�&�}�5�C�C�V�
r=r2)rYrUr]rzs  ` r>r[�1AnalyzedCode._bound_parameter_getter_func_closure�s���	�'�&r=c�^�[U[5(aU4SjnU$[U[R5(aU4SjnU$U4SjnU$)z�Return a getter that will extend a cache key with new entries251from the "track_on" parameter passed to a :class:`.LambdaElement`.252 253c�N>^^�[UU4SjURT55$)Nc3�H># �UHnURTT5v� M g7fr]�r�)rG�tup_elemrnr|s  ��r>rJ�GAnalyzedCode._cache_key_getter_track_on.<locals>.get.<locals>.<genexpr>�s(�����$6���+�+�H�j�A�A�$6���")ror/�rzr^rnr|rHs  ``�r>rk�4AnalyzedCode._cache_key_getter_track_on.<locals>.get�s&�����$(�M�M�#�$6���r=c�@>�URTRX#5$r])r/r�r�s    �r>rkr��s����}�}�S�)�8�8��N�Nr=c�">�URT$r])r/r�s    �r>rkr��s����}�}�S�)�)r=)r�rorl�HasCacheKey)rYrHrIrks `  r>rF�'AnalyzedCode._cache_key_getter_track_on�sL����d�E�"�"�
� �254���j�4�4�
5�
5�
O��255�
*��256r=c�R^^^^^^�[U[R5(a257UUU4SjnU$[U[R5(aU4SjnU$[U[258R5(aUUUU4SjnU$UnSn	[US5(a9Sn	[USS5(dUR5nOO[US5(aM9U	(d,[R"USS9n259U260bTRTTTU261SS	9$OTRTTTUSS2629$TRTT5 W$)z{Return a getter that will extend a cache key with new entries263from the ``__closure__`` collection of a particular lambda.264 265c�>�UTRnT(a[R"U5nOMT(aF[US5(a5[	USS5(dUR5n[US5(aM5UR
X#5$)Nrir�F)rZrr<rlr�rir�)rzr^rnr|�objrH�use_clause_element�use_inspects     ���r>rk�<AnalyzedCode._cache_key_getter_closure_variable.<locals>.get�sw����c�l�0�0���$�,�,�S�1�C�'�!�#�';�<�<�&�s�,?��G�G�"%�"8�"8�":�C�"�#�';�<�<��)�)�(�?�?r=c�6>�UTRR$r])rZrWr�s    �r>rkr��s����s�|�1�1�:�:�:r=c�>^^�UTRn[UU4SjU55$![anTRT	TUS9 SnAgSnAff=f)Nc3�H># �UHnURTT5v� M g7fr]r�)rGrIrnr|s  ��r>rJ�OAnalyzedCode._cache_key_getter_closure_variable.<locals>.get.<locals>.<genexpr>�s(����!�$,�D��+�+�H�j�A�A�$,�r�)�from_)rZrorn�'_raise_for_uncacheable_closure_variable)266rzr^rnr|�contents�aerQrHrY�
variable_names267  ``  ����r>rkr��s^���"�3�<�5�5��� �!�$,�!����&���@�@�%�r��A����s�*�268A�A269�270AFriTr�rj)r�)r�)r�rlr��types�FunctionType�collections_abc�Sequencerlr�rirr<r\r�)rYrQr�rHrZr�r�rkr�r�ros```` ``    r>r\�/AnalyzedCode._cache_key_getter_closure_variable�sE����m�Z�%;�%;�<�<�	
@�t�271�_�
�u�'9�'9�
:�
:�
;�Z�272�U�
��'?�'?�
@�
@�
�
�P�273�-$�G� %���'�#7�8�8�$(�!��w�(;�U�C�C�%�8�8�:�G���'�#7�8�8�%�!�)�)�'�E�B���#��B�B��M�3��$�C���$�274�>�>��
�s�G��?���
�8�8���K��275r=Nc�V�[R"SU<SUR<S35Ue)NzClosure variable named 'z' inside of lambda callable a does not refer to a cacheable SQL element, and also does not appear to be serving as a SQL literal bound value based on the default SQL expression returned by the function.   This variable needs to remain outside the scope of a SQL-generating lambda so that a proper cache key may be generated from the lambda's state.  Evaluate this variable outside of the lambda, set track_on=[<elements>] to explicitly select closure elements to track, or set track_closure_variables=False to exclude closure variables from being part of the cache key.)r�InvalidRequestErrorrW)rYr�rQr�s    r>r��4AnalyzedCode._raise_for_uncacheable_closure_variables,���%�%��b�k�k�
+�276��	r=c�n�URnURnURnURXXC5$)aiReturn a getter that will extend a cache key with new entries277from the ``__closure__`` collection of a particular lambda.278 279this getter differs from _cache_key_getter_closure_variable280in that these are detected after the function is run, and PyWrapper281objects have recorded that a particular literal value is in fact282not being interpreted as a bound parameter.283 284)�_sa__to_evaluate�_sa__closure_index�	_sa__namer\)rYrQ�	pytrackerrIr]r�s      r>rd�.AnalyzedCode._cache_key_getter_tracked_literal$s=���)�)��!�4�4�
�!�+�+�
��6�6��}�285�	286r=)rxr3rpr;r8)FFr])r3r4r5r6�	__slots__�weakref�WeakKeyDictionaryr4r9�	threading�RLockrq�classmethodrkrdr?r@rArBrQrTr[rFr\r�rdr<r2r=r>rjrj�s����I�	�!�!�#�	�287;��"���)������$%J�N288��$!�F�,����2'�"'�&�@!��J�Z(,��&289r=rjc�b�\rSrSr%SrSrS\S'SrS\S'SrS	\S290'S
Sjr	\291SSj5rSrg)r%i8�r�N�"Optional[List[BindParameter[Any]]]rs�%Optional[List[_BoundParameterGetter]]rxFr"r�c��Xlgr]r�r�s  r>rd�NonAnalyzedFunction.__init__Bs���	r=c��UR$r]r�rXs r>r��!NonAnalyzedFunction.expected_exprEs���y�y�r=)r�r")r�r")
r3r4r5r6r�rsr9rxr�rdr�r�r<r2r=r>r%r%8sC���I�=A��:�A�@D��=�D��K�292������r=r%c�P�\rSrSr%SrS\S'S\S'S\S'S	rS293rSrSr	S
r294g)r&iJ)295�
analyzed_coderQrbryr�rxr�r�r`rsr�rsz)Union[ClauseElement, List[ClauseElement]]r�r�rxc��XlX@lURUlURU5 UR	X#5 gr])r�rQrx�_instrument_and_run_function�_coerce_expression)rYr�rGrbrQs     r>rd�AnalyzedFunction.__init__\s9��+����"/�"B�"B����)�)�.�9�����Fr=c	�X�URnURn/=UlnURnU(d U=UlnURU5UlgURnURnU(a?[URRU5V	V296s0sHup�X�R_M nn	n297O0nURR5nUHtup�UbOX�Rn[UU
UUURR S9=X�'nU(aUR#U5 MUMWURU
n[X=U5X�'Mv UR%UURRV
s/sHo�U
PM	 sn
U5=UlnURU5Ulgs sn298n	fs sn
f)N)r]r;)r�rQrbr3ryrtr�r8rirurWrYrZrP�copy�	PyWrapperr;rS�_rewrite_code_obj)rYrGr�rQrbr3ryr8rzr^r_�new_closure�new_globalsrUr]rwr�s                 r>r��-AnalyzedFunction._instrument_and_run_functionls����*�*�
�
�W�W��79�9���"4�)�;�;�� �EG�G�D�(�+B�&�6�6�7N�O�D�I�&3�&K�&K�#��n�n�G��%(����(?�(?��$I��$I����*�*�*�$I����299!���.�.�-�-�/�K�'8�#�� �,�#�2�@�@�E�/8����&3� �.�.�A�A�
0��K�%��/�*�1�1�$�7�/��N�N�4�0�E�(1�"�E�(B�K�%�!(9�*�&�&��35�;�;�3J�3J�K�3J�4��&�3J�K���
�D�(�+B�&'�6�6�7N�O�D�I��c��BLs�F!�-F'300c���URnURnUc�[U[R5(aHUVs/sH-n[S[R"URUUS95PM/ snUl	SUl301OD[S[R"URUUS95Ul	SUl302O
X@l	SUl303UbURUlg[RUlgs snf)aRun the tracker-generated expression through coercion rules.304 305After the user-defined lambda has been invoked to produce a statement306for reuse, run it through coercion rules to both check that it's the307correct type of object and also to coerce it to its useful form.308 309Nr")rbTF)rKr�r�r�r�rrr�rNr�r�rar`r�310EMPTY_DICT)rYrGrbrKr�r�s      r>r��#AnalyzedFunction._coerce_expression�s���'�4�4�
��y�y��� ��$�� 8� 8�9�9�%)�311&�%)���'�!�(�(�*�/�/�$�2G���%)�312&��"�$(�� �%)�#��$�$�&�+�+��.C��&��"�$)�� �!%��$�D�� �,�#8�#I�#I�D� �#'�?�?�D� ��;313&s�4C2c�V�[[U55nSnU(a:USSRSU55<SSRSU55<S3-
nUS-
nUS	SRS314U55--
nUS-
nUVs0sHnSU-X&_M
 nn[XWU5 US
"5n[	U5"UR315X1RURU5n	URU	lURU	l	URU	l316URU	lU	$s snf)zQReturn a copy of f, with a new closure and new globals317 318yes it works in pypy :P319 320zdef make_cells():321z    (z, c3�,# �UH322nSU-v� M g7f�zi%dNr2�rG�is  r>rJ�5AnalyzedFunction._rewrite_code_obj.<locals>.<genexpr>�����6�X��%�!�)�X���z) = (c3�,# �UH323nSU-v� M g7f)�o%dNr2r�s  r>rJr��r�r�z)324z    def closure():325z        return %s326c3�,# �UH327nSU-v� M g7fr�r2r�s  r>rJr��s���1N�X��%�!�)�X�r�z    return closure.__closure__r��328make_cells)�range�len�join�execr�rWr3�__defaults__r9�__kwdefaults__r�r4)329rY�f�cell_values�globals_�argrange�coder��vars_rz�funcs330          r>r��"AnalyzedFunction._rewrite_code_obj�s����[�)�*��$�����	�	�6�X�6�6��	�	�6�X�6�6��
�D�	
�&�&���%��	�	�1N�X�1N�(N�N�N���0�0��4<�=�H�q����K�N�*�H��=��T�%� ���%�'���A�w�
�J�J��*�*�a�n�n�g�331�� !�0�0����.�.����y�y����,�,������>s�D&)	r�rxrbr�r�rQr�r`ryN)r3r4r5r6r�r9rdr�r�r�r<r2r=r>r&r&Js6���I�;�:�<�<�=�=�G� BP�H+3�Zr=r&c�h�\rSrSrSrSSjrSrSrSrSr	SS	jr332S333rSrSr
S
rSrSrg)r�i�ahA wrapper object that is injected into the ``__globals__`` and334``__closure__`` of a Python function.335 336When the function is instrumented with :class:`.PyWrapper` objects, it is337then invoked just once in order to set up the wrappers.  We look through338all the :class:`.PyWrapper` objects we made to find the ones that generated339a :class:`.BindParameter` object, e.g. the expression system interpreted340something as a literal.   Those positions in the globals/closure are then341ones that we will look at, each time a new lambda comes in that refers to342the same ``__code__`` object.   In this way, we keep a single version of343the SQL expression that this lambda produced, without calling upon the344Python function that created it more than once, unless its other closure345variables have changed.   The expression is then transformed to have the346new bound values embedded into it.347 348Nc�v�XlX lX0lSUlSUl0UlXPlX@lX`lg)NF)	rQ�_name�_to_evaluate�_param�349_has_param�_bind_paths�_getter�_closure_indexr;)rYrQrU�to_evaluater]r~r;s       r>rd�PyWrapper.__init__s;�����350�'�������������+��"4�r=c�j�[RUS5nU"U0UD6nUR(a�[R"U5(ah[U[R5(dI[RUS5n[R"SU<SURR<S35eU$)Nr�r�zCan't invoke Python callable z+() inside of lambda expression argument at a�; lambda SQL constructs should not invoke functions from closure variables to produce literal values since the lambda SQL system normally extracts bound values without actually invoking the lambda or any functions within it.  Call the function outside of the lambda and assign to a local variable that is used in the lambda as a closure variable, or set track_bound_values=False if the return value of this function is used in some other way other than a SQL bound value.)rurv�_sa_track_bound_valuesrrRr�rlr�rr��_sa_fnrW)rYr�r�rIrwrUs      r>�__call__�PyWrapper.__call__#s����&�&�t�^�<���c� �R� ���'�'��*�*�5�1�1����&�&����*�*�4��9�D��)�)�!�$�+�+�"6�"6�8��
� �Lr=c�P�[RUS5"5nU"U/UQ70UD6$�N�_py_wrapper_literal�rurv�rY�opr��kwargsrIs     r>�operate�PyWrapper.operateBs-���&�&�t�-B�C�E���$�)��)�&�)�)r=c�J�[RUS5"5nU"X$40UD6$r�r�r�s     r>�reverse_operate�PyWrapper.reverse_operateFs(���&�&�t�-B�C�E���%�(��(�(r=c�,�[RUS5nUb!URUSS9nURU5 [RUS5R	5H2n[RUS5nU"U5nURXb5 M4 g)Nr�Trgr�r�)rurvrvrS�values�_sa__extract_bound_parameters)rY�starting_point�result_list�paramrfr~r�s       r>rt�#PyWrapper._extract_bound_parametersJs����'�'��h�7�����%�%�n�4�%�H�E����u�%��0�0��}�E�L�L�N�I��,�,�Y�	�B�F��^�,�G��3�3�G�I�Or=c��[RUS5n[RUS5nUcK[RUS5n[R"USSUUbUROSS9=UlnSUlURUSS9$)Nr�r�r�FT)�required�unique�_compared_to_operator�_compared_to_typerg)rurvrr!r�r�r�rv)rYr��operatorr�rr�rUs       r>r��PyWrapper._py_wrapper_literalTs����'�'��h�7���-�-�d�N�C���=��*�*�4��9�D�"*�"8�"8����&.�/3�/?�$�)�)�T�#�
�D�K�%�#�D�O�� � ��4� �@�@r=c�D�[RUS5n[U5$�Nr�)rurvr)rYr�s  r>�__bool__�PyWrapper.__bool__cs���-�-�d�N�C���K� � r=c�B�URS5(a[RXSS5$US;a[RX5$URS5(a![RUS5n[X!5$UR	U[351R5$)N�_sa_�)rir�r�r�rV�__dict__�__r�)�352startswithrurvr��_sa__add_getterr�353attrgetter�rYrrIs   r>rv�PyWrapper.__getattribute__gs����>�>�&�!�!��*�*�4�Q�R��9�9�
�354�355��*�*�4�5�5��>�>�$����*�*�4��@�D��4�%�%��'�'��X�-@�-@�A�Ar=c�D�[RUS5n[U5$r)rurv�iter)rYrIs  r>�__iter__�PyWrapper.__iter__zs���&�&�t�^�<���D�z�r=c���[RUS5n[US5(d[S5e[	U[3565(a[R"S5eURU[R5$)Nr��__getitem__zUDictionary keys / list indexes inside of a cached lambda must be Python literals only)rurvrlrnr�r�rr�rr�357itemgetterrs   r>r �PyWrapper.__getitem__~sl���&�&�t�^�<���t�]�+�+� ��/�/��c�9�%�%��)�)�6��
��#�#�C��)<�)<�=�=r=c�,�[RUS5nX4nXC;aX4$U"U5n[RUS5nU"U5n[RU5n[R358"U5(a[
URXUS9n	X�U'U	$U$)Nr�r�)r~)rurvrjrQrrRr�r�)359rYr�	getter_fn�360bind_paths�
bind_path_keyr~rIrw�rolled_down_valuerys361          r>�_add_getter�PyWrapper._add_getter�s����,�,�T�=�A�362��(�
��&��,�,��3����&�&�t�^�<���t���(�>�>�u�E���%�%�&7�8�8�����S��G�G�(/�}�%��N��Lr=)	r�r�r�r�r�r�r�rQr;)NNT)NN)r3r4r5r6r�rdr�r�r�rtr�rrvrr r(r<r2r=r>r�r��sL���,���5�&�>*�)�J�
A�!�B�&�>�r=r�c�B�[R"UR5$r])rr<rH)rBs r>roro�s�����c�m�m�,�,r=)TTNTTN)rBrr7rr8rr/r.r:rr;rr1r0r�r?)H�363__future__r�collections.abc�abcr�r<r�rr�r�r�typingrrrrr	r364rrr
rrr��rrlrrrrr�baserrrr�	operatorsrrrr�util.typingr r!r"r#r$r'�_BoundParameterGetter�LRUCacher(r9r�rPrr)�_StmtLambdaElementTyper,rCrEr��AllowsLambdaRoler?rr�rjr%r&r��	_inspectsror2r=r>�<module>r8sD��#�)�����������!���� ����%���������!�&����!��'�'��,�!�	�#�s�(�O�U�D�E�E���!��c��*��+/�=�=��+>��(�>��r�3�w����#�s�(�#���2�s�7�#���T��$��!�2�$��)�,��4�G�4�!�$(�!%�&*�#�/3�F�	�F��F�"�F��	F�365 $�F��
F�-�F��F�RN�H�*�*�N�bG;�M�G;�TV.�	���M�:�V.�r,5�%�0�0�(�2H�2H�,5�^0�0�0�.a366�a367�H��$q�q�h_��_�D���m�$�-�%�-r=
codekingpro/portable-devtools · Team Ai