-h) SSKrSSKrSSKrSSKJr SSKJr SSKJr SSKJr SSKJ r SSKJ r SS KJ r SS KJ r SS KJ r SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJ r SSK!J"r" SSKJr# SSKJ$r$ SS KJ%r% SS!KJ&r& SS"KJ'r' SSKJ r( SS#KJ)r) SS$K*J+r+ SS%K,J-r- \."S&5r/"S'S(\.5r0S)r1SKS*jr2S+r3"S,S-\(Rh5r5"S.S/\65r7"S0S1\\\#Rp\ 5r9"S2S3\65r:"S4S5\5r;\Rx"\75"S65 \Rx"\95"S75 SLS8jr=SMS9jr>\R~"S:S;\\+\#Rp\ 55r@SNS<jrAS=rBS>rC"S?S@\%R5rESOSAjrFSPSBjrGSNSCjrHSDrISErJSFrKSGrLSHrMSIrNSJrOg)QN) attributes)_class_to_mapper) _never_set) _none_set) attribute_str) class_mapper)InspectionAttr) instance_str) object_mapper) object_state)state_attribute_str)state_class_str) state_str)CriteriaOption)MapperProperty)ORMColumnsClauseRole)ORMEntityColumnsClauseRole)ORMFromClauseRole)PropComparator) PathRegistry)event)exc) inspection)sql)util result_tuple)base) coercions) expression)lambdas)roles)visitors)SupportsCloneAnnotations)ColumnCollection)delete delete-orphanallmergeexpunge save-updaterefresh-expirenonecj\rSrSrSr\R /SQ5r\r/SQr Sr Sr Sr \ S5rS rg ) CascadeOptions@zDKeeps track of the options sent to :paramref:`.relationship.cascade`)r*r/r))r,r*r/r.r+) save_updater(refresh_expirer+r, delete_orphanc @[U[R5(dUcURU5$[ U5nUR UR 5(ad[R"SSR[UR UR 55Vs/sHn[U5PM sn5-5eSU;aURUR5 SU;aUR5 URS5 [ R#[$U5nSU;UlSU;UlSU;UlSU;UlS U;UlS U;UlUR0(a'UR((d[R2"S 5 U$s snf) NzInvalid cascade option(s): %s, r*r/r-r(r.r+r,r)z5The 'delete-orphan' cascade option requires 'delete'.) isinstancer string_types from_stringset difference_allowed_cascadessa_exc ArgumentErrorjoinsortedreprupdate_add_w_all_cascadescleardiscard frozenset__new__r1r3r(r4r+r,r5warn)cls value_listvaluesxselfs hC:\Users\ROHAN GUPTA\OneDrive\Desktop\mathbuddy-assessment\venv\Lib\site-packages\sqlalchemy/orm/util.pyrHCascadeOptions.__new__Tsm j$"3"3 4 4 8J??:. .Z   S22 3 3&&/))"("--c.C.CD""AQ"   F? MM#11 2 V  LLNu  8(F2&( .&8&  F* ,6   dkk IIJ  7s!FcfSSR[U5Vs/sHoPM sn5-$s snf)NzCascadeOptions(%r),)r@rA)rNrMs rO__repr__CascadeOptions.__repr__ys,#sxxF4L0ILqL0I'JKK0Is . c[R"SU=(d S5Vs/sH o"(dM UPM nnU"U5$s snf)Nz\s*,\s*)resplit)rJargcrLs rOr:CascadeOptions.from_string|s9XXj#)<B<!<B6{Cs AA)r(r5r,r+r4r3N)__name__ __module__ __qualname____firstlineno____doc__ all_cascadesr<rDr=_viewonly_cascades __slots__rHrS classmethodr:__static_attributes__rOr1r1@sR)'11(%NI#JLrgr1c^^^^ T(dU4Sjm U(a%U UUU4SjnU UUU4SjnU UUU4SjnU UUU4SjnOU UUU4SjnU UUU4SjnU UUU4Sjn[R"US US S S 9 [R"US US S 9 [R"USUS S S 9 U(a[R"USWS S S 9 gg)zFRuns a validation method on an attribute value to be set or appended. cR>URTRnURUL$N)managerimpl)state initiatorrlkeys rOdetect_is_backref,_validator_events..detect_is_backrefs&==%**D>>- -rgc>UR[RLa-T(d T"X5(dT"UR5TUS5$U$NFoprOP_BULK_REPLACEobjrmvaluernrpinclude_backrefsro validators rOappend!_validator_events..appends?||:#=#== (9%(K(K c5%@@ rgc >T(d T"X5(d0UR5nUVs/sHnT"UTUS5PM snUSS&ggs snfrsrw rmrLrnrwryrprzror{s rObulk_set#_validator_events..bulk_setsO'8'J'JiikCICI%Ic3u56q (KsAcb>T(d T"X5(dT"UR5TUS5$U$rsrrmryoldvaluernrprzror{s rOset__validator_events..set_s-'8'J'J c5%@@ rgcb>T(d T"X5(dT"UR5TUS5 gg)NTrrxs rOremove!_validator_events..removes+'8'J'J%))+sE48(Krgc>UR[RLa,T(d T"X5(dT"UR5TU5$U$rjrtrxs rOr|r}s=||:#=#== (9%(K(K c599 rgc>T(d T"X5(d/UR5nUVs/sH nT"UTU5PM snUSS&ggs snfrjrrs rOrrsF'8'J'JiikEKLVEYsC7VLq (KLsAc`>T(d T"X5(dT"UR5TU5$U$rjrrs rOrrs+'8'J'J c599 rgr|T)rawretval bulk_replace)rr;rN)rlisten) descror{include_removesrzr|rrrrps `` ` @rO_validator_eventsrs  .        9 9    M M     LLxT$? LL~xT: LLudT: T8VdCrgc ^^ ^[R"5n0m 0mUHnXn[R"[R USS9nX`U'0nUR HtnURU:Xa[R"SU<SU<S35eURUR5 XUR'URTUR'Mv UT U'M UU U4Sjn /n UR5HupUbU R[R"UV s/sH o"X5PM sn [R "["R$"U 55R'U5/-6R)U55 MU R[R"UV s/sH o"X5PM sn 6R)U55 M [R*"U 6R-U5$s sn fs sn f)aCreate a ``UNION`` statement used by a polymorphic mapper. See :ref:`concrete_inheritance` for an example of how this is used. :param table_map: mapping of polymorphic identities to :class:`_schema.Table` objects. :param typecolname: string name of a "discriminator" column, which will be derived from the query, producing the polymorphic identity for each row. If ``None``, no polymorphic discriminator is generated. :param aliasname: name of the :func:`~sqlalchemy.sql.expression.alias()` construct generated. :param cast_nulls: if True, non-existent columns, which are represented as labeled NULLs, will be passed into CAST. This is a legacy behavior that is problematic on some backends such as Oracle - in which case it can be set to False. T) allow_selectzPolymorphic union can't use 'z3' as the discriminator column due to mapped column zn; please apply the 'typecolname' argument; this is available on ConcreteBase as '_concrete_discriminator_name'c8>TUU$![a T(a>[R"[R"5TU5R U5s$[R "[R"5TU5R U5s$f=frj)KeyErrorrcastnulllabel type_coerce)nametable cast_nulls colnamemapstypess rOcolpolymorphic_union..colsy Lu%d+ + Lxx E$K8>>tDDsxxz5;?EEdKK  Ls A BInvalidRequestErroraddtypeitemsr|rselectliteral_columnsql_util_quote_ddl_exprr select_from union_allalias) table_map typecolname aliasnamercolnamesrormrZrresulttype_rrrs ` @@rOpolymorphic_unionrs, HK E   & &D # Auu #00 #A ' LL aeeH66E!%%L E-0LF!)   " MM 6>?hdT)h?.. ( 8 8 ?#eK0 +e$  MM 3;<84c$&8<+e$ *( ==& ! ' ' 22@=s G0"G5cU(aSn[U5nUS:XaUSnURS5nO$US;aUupEO[R"SU-5eURSS5nU(a([R"S S R U5-5e[ U5nUc$UR[R"W5US 9$URX&S 9$URS 5nU(a2[R"S S R UR5-5e[U5nURU5$![a URS5nGNf=f) aGenerate "identity key" tuples, as are used as keys in the :attr:`.Session.identity_map` dictionary. This function has several call styles: * ``identity_key(class, ident, identity_token=token)`` This form receives a mapped class and a primary key scalar or tuple as an argument. E.g.:: >>> identity_key(MyClass, (1, 2)) (, (1, 2), None) :param class: mapped class (must be a positional argument) :param ident: primary key, may be a scalar or tuple argument. :param identity_token: optional identity token .. versionadded:: 1.2 added identity_token * ``identity_key(instance=instance)`` This form will produce the identity key for a given instance. The instance need not be persistent, only that its primary key attributes are populated (else the key will contain ``None`` for those missing values). E.g.:: >>> instance = MyClass(1, 2) >>> identity_key(instance=instance) (, (1, 2), None) In this form, the given instance is ultimately run though :meth:`_orm.Mapper.identity_key_from_instance`, which will have the effect of performing a database check for the corresponding row if the object is expired. :param instance: object instance (must be given as a keyword arg) * ``identity_key(class, row=row, identity_token=token)`` This form is similar to the class/tuple form, except is passed a database result row as a :class:`.Row` object. E.g.:: >>> row = engine.execute(\ text("select * from table where a=1 and b=2")\ ).first() >>> identity_key(MyClass, row=row) (, (1, 2), None) :param class: mapped class (must be a positional argument) :param row: :class:`.Row` row returned by a :class:`_engine.CursorResult` (must be given as a keyword arg) :param identity_token: optional identity token .. versionadded:: 1.2 added identity_token Nrrrowident)rz1expected up to three positional arguments, got %sidentity_tokenzunknown keyword arguments: %sr7)rinstance)lenpoprr>r?r@r identity_key_from_primary_keyrto_listidentity_key_from_rowkeysr identity_key_from_instance) argskwargsrlargsclass_rrmapperrs rO identity_keyrsk@ D  A:!WF ,jj'f_ MFE&&FN  $4d; &&/$))F2CC f% ;77 U#N8 //0 ::j) &&/$))FKK2HH x(00::= , 7+ ,sD??EEc0\rSrSrSrSSjrSrSrg) ORMAdapteri~zYColumnAdapter subclass which excludes adaptation of entities from non-matching mappers. Nc [R"U5nURUlURnURnU(aXlOSUl[ RRUUUUUUURS9 g)N)adapt_requiredallow_label_resolveanonymize_labels include_fn) rinspectr selectableis_aliased_class aliased_classr ColumnAdapter__init__ _include_fn) rNentity equivalentsrrrinforrs rOrORMAdapter.__init__sy!!&)kk __ 00 !' !%D ''   ) 3-'' ( rgcURRSS5nU(+=(d= URUR5=(d URRU5$)N parentmapper) _annotationsgetisar)rNelemrs rOrORMAdapter._include_fnsF""&&~t<zOVZZ 4O 8OOrg)rr)NFTF)r\r]r^r_r`rrrerfrgrOrr~s    8Prgrc\\rSrSrSrS Sjr\S5rSrSr Sr S r S r g) AliasedClassiaDRepresents an "aliased" form of a mapped class for usage with Query. The ORM equivalent of a :func:`~sqlalchemy.sql.expression.alias` construct, this object mimics the mapped class using a ``__getattr__`` scheme and maintains a reference to a real :class:`~sqlalchemy.sql.expression.Alias` object. A primary purpose of :class:`.AliasedClass` is to serve as an alternate within a SQL statement generated by the ORM, such that an existing mapped entity can be used in multiple contexts. A simple example:: # find all pairs of users with the same name user_alias = aliased(User) session.query(User, user_alias).\ join((user_alias, User.id > user_alias.id)).\ filter(User.name == user_alias.name) :class:`.AliasedClass` is also capable of mapping an existing mapped class to an entirely new selectable, provided this selectable is column- compatible with the existing mapped selectable, and it can also be configured in a mapping as the target of a :func:`_orm.relationship`. See the links below for examples. The :class:`.AliasedClass` object is constructed typically using the :func:`_orm.aliased` function. It also is produced with additional configuration when using the :func:`_orm.with_polymorphic` function. The resulting object is an instance of :class:`.AliasedClass`. This object implements an attribute scheme which produces the same attribute and method interface as the original mapped class, allowing :class:`.AliasedClass` to be compatible with any attribute technique which works on the original class, including hybrid attributes (see :ref:`hybrids_toplevel`). The :class:`.AliasedClass` can be inspected for its underlying :class:`_orm.Mapper`, aliased selectable, and other information using :func:`_sa.inspect`:: from sqlalchemy import inspect my_alias = aliased(MyClass) insp = inspect(my_alias) The resulting inspection object is an instance of :class:`.AliasedInsp`. .. seealso:: :func:`.aliased` :func:`.with_polymorphic` :ref:`relationship_aliased_class` :ref:`relationship_to_window_function` Nc [R"U5n U Rn Sn UcbU R(a6U RR (aU RR 5nO.U RRUUS9nOU R(aSn [UU UUU(aUO U RUbUO U RUU UU U 5 Ul SU RR-Ulg)NFrflatTAliasedClass_%s)rrrrr _is_subqueryr_with_polymorphic_selectable_anonymous_fromclause AliasedInspwith_polymorphic_mapperspolymorphic_on _aliased_insprr\)rNmapped_class_or_acrrradapt_on_namesrwith_polymorphic_discriminator base_aliasuse_mapper_pathrepresents_outer_joininspr nest_adapterss rOrAliasedClass.__init__s!!"45 =$$)E)E--/77MM!!N  " " M(    ' %00-9 +&&    !  $*FMM,B,BB rgcBURU5nSURRR-UlXlUR (aNUR H>nX1LdM [RU5n[X#RRU5 M@ U$)Nr) rHrrr\r_is_with_polymorphic_with_polymorphic_entitiesr_reconstitute_from_aliased_inspsetattr)rJ aliased_insprwsub_aliased_inspents rOr,AliasedClass._reconstitute_from_aliased_inspskk#(<+>+>+E+E+N+NN (  , ,$0$K$K #7&FF(CC!8!8!A!A3G %L rgcURSnURn[X15n[ US5(a2[ US5(a![ R"URU5$[ US5(aURSU5n[ US5(aURU5n[XU5 U$![a [ 5ef=f)Nr__call____self____get__adapt_to_entity) __dict___targetgetattrrAttributeErrorhasattrr MethodType__func__rr r)rNrortargetattrs rO __getattr__AliasedClass.__getattr__%s ( MM/:M#**F6'D 4 $ $z)B)B##DMM48 8 4 # #<<d+D 4* + +'' 6D Dt $ 1 # " " #s B>>Ccz[X!5n[US5(a2[US5(a![R"URU5$[US5(aUR SU5n[US5(a8[ R"U5UlURU5n[XU5 U$)Nrrrr ) r rrrrrweakrefref _weak_entityr r)rNro mapped_classrrs rO_get_from_serialized!AliasedClass._get_from_serializedBs|) 4 $ $z)B)B##DMM48 8 4 # #<<d+D 4* + +(/ D(9L %'' 5D Dt $ rgc^S[U5URRR4-$)Nz)idrr r\rNs rOrSAliasedClass.__repr__Ws0+ tH    & & / //   rgc,[UR5$rj)strrrs rO__str__AliasedClass.__str__]s4%%&&rg)r\r) NNFFrfNNFF) r\r]r^r_r`rrdrrrrSr"rerfrgrOrrsT8z  !#'+#2Ch  :* 'rgrch\rSrSrSrS\R R4S\R R4S\R R4S\R R4S\R R4S\RR4S \RR4/r S r\S 5rS r\R&S 5r\S5r\S5r\S5rSrSrSSjrSr\R8S5r\R8S5r\R8S5rSr Sr!Sr"Sr#g)riaaProvide an inspection interface for an :class:`.AliasedClass` object. The :class:`.AliasedInsp` object is returned given an :class:`.AliasedClass` using the :func:`_sa.inspect` function:: from sqlalchemy import inspect from sqlalchemy.orm import aliased my_alias = aliased(MyMappedClass) insp = inspect(my_alias) Attributes on :class:`.AliasedInsp` include: * ``entity`` - the :class:`.AliasedClass` represented. * ``mapper`` - the :class:`_orm.Mapper` mapping the underlying class. * ``selectable`` - the :class:`_expression.Alias` construct which ultimately represents an aliased :class:`_schema.Table` or :class:`_expression.Select` construct. * ``name`` - the name of the alias. Also is used as the attribute name when returned in a result tuple from :class:`_query.Query`. * ``with_polymorphic_mappers`` - collection of :class:`_orm.Mapper` objects indicating all those mappers expressed in the select construct for the :class:`.AliasedClass`. * ``polymorphic_on`` - an alternate column or SQL expression which will be used as the "discriminator" for a polymorphic load. .. seealso:: :ref:`inspection_toplevel` r_adapt_on_names_use_mapper_pathr rrrc URn URn [R"U5UlXlU=Ul=UlUlX@lX`l [R"U=(d U5Ul Xl Xl Xl U(aSUlXPl/UlURHpnXLdM [#UR$UUU US9n['URUR$R(U5 UR R+UR,5 Mr OSUlU /Ul[.R0"UU R2U SURVs1sHnU (aM UR iM snS9UlU (a*UR4R7UR45UlXlXlgs snf)NT)rrrF)rrradapt_from_selectables)rrrrrrpersist_selectable local_tablerr _base_aliasr&r_nest_adaptersrrrrrrr\r|rrr_equivalent_columns_adapterwrapr%r )rNr inspectedrrrrr+r&rrrrrpolyrrs rOrAliasedInsp.__init__s'--!!#KK/  * * *  #   ,";;{':d; 0%:"+ #(,D %,D ).0D +55%& "#''5(8 CDKK)=)=sC33::3;L;LM6).D %-3HD ) .. 22)! 66$6A% 6$    %..33DMMBDM-) $s ( G7GcUR5nUc0[RU5n[R"U5UlU$rj)rrrrr)rNrs rOrAliasedInsp.entitys=! ;>>tDC ' C 0D  rgTcxURRURUUS.5RSUS.5$)N)r parententityentity_namespaceormcompile_state_pluginplugin_subject)r _annotater_set_propagate_attrsrs rO__clause_element__AliasedInsp.__clause_element__s@(( $ $$(   %*d C  rgcUR$rj)rrs rOr7AliasedInsp.entity_namespaces {{rgc.URR$)zMReturn the mapped class ultimately represented by this :class:`.AliasedInsp`.)rrrs rOrAliasedInsp.class_s{{!!!rgc|UR(aURR$[R"U5$rj)r&r_path_registryr per_mapperrs rOrEAliasedInsp._path_registry s,  ;;-- -**40 0rgc URURURURURUR UR UR5URURURS. $)N) rrrrrrrrrrr) rrrrr%rrr+r&rr,rs rO __getstate__AliasedInsp.__getstate__sjkkkk__II"22(,(E(E.2.A.A**,#44%)%?%?!00  rgc|URUSUSUSUSUSUSUSUSUS US US 5 g) Nrrrrrrrrrrr)r)rNrms rO __setstate__AliasedInsp.__setstate__ sg (O (O 'N &M , - 2 3 ,  # $ " # ) * / " rgNcUURS.nU(aX#S'URRU5RU5R SUS.5$)N)r6r proxy_keyr8r9)rr.traverser<r=)rNrrods rO_adapt_elementAliasedInsp._adapt_element/sR  KK   kN MM " "4 ( Yq\ ! !).$G rgcURnX;aDXRLaU$[URURR 5R $URUR5(aU$SU<SU<35e)Nzmapper z doesn't correspond to )rrr rrr\rr)rNr self_polys rO_entity_for_mapperAliasedInsp._entity_for_mapper>sp11  $ KK!7!7- ZZ $ $K O&$O O5rgcURRupURRU5UR 5VVs0sH!up4URRU5U_M# snn4$s snnfrj)r _get_clauser.rPr)rNonclause replacemaprparams rOrYAliasedInsp._get_clauseLsq#{{66 MM " "8 ,#-"2"2"4 "4JC &&s+U2"4    s(A3c0$rjrfrs rO_memoized_valuesAliasedInsp._memoized_valuesWs rgcPUR(a@URRURVs/sHoRPM sn5nOURR5nUVVs/sHup4X0R U54PM nnn[ U5$s snfs snnfrj)rr_columns_plus_keysrrRr')rNrcols_plus_keysrors rO_all_column_expressions#AliasedInsp._all_column_expressions[s  $ $![[;;'+'F'FG'F'FGN"[[;;=N=K 'AliasedInsp.__repr__..ss+-Jr ""-Js"$rVz)rr@rrr\)rN with_polys rOrSAliasedInsp.__repr__qsc  ( (+-1-J-J+"II, tH KK 0   rgc^TR(aBSTRR<SSRU4SjTR55<S3$STRR<S3$)Nzwith_polymorphic(z, [r7c3r># UH,nUTRLdMURRv M. g7frj)rrr\)rmrnrNs rOro&AliasedInsp.__str__..s0;,'BII&&;s77z])zaliased())rr r\r@rrs`rOr"AliasedInsp.__str__~s_  $ $ $ %% ";;  %%)LL$9$9; ;rg)r%r.r+rr,r r&rrr*rrr)rrrrrj)$r\r]r^r_r`r%ExtendedInternalTraversal dp_string dp_booleandp_inspectabledp_clauseelementInternalTraversaldp_has_cache_key_list_cache_key_traversalrpropertyrrrmemoized_instancemethodr>r7rrErIrLrRrVmemoized_propertyrYr_rdrirSr"rerfrgrOrras $N 33==> H>>IIJ X??JJK H66EEF x99JJK &  & & < <  855FFG F*R   !!  "  "" 11       P      0 0   >%%..))$ : ## #   T "H$:$:) ) ##D)..w7 77) )rgN) r\r]r^r_r`rcrrpreload_modulerrerfrgrOrrs3I 23 *4 *rgrcN\rSrSrSrS\R R4S\R R4S\RR4S\RR4S\RR4/r SSjr \S 5rS rS rS rS rSrSrSrSrg)LoaderCriteriaOptionizAdd additional WHERE criteria to the load for all occurrences of a particular entity. :class:`_orm.LoaderCriteriaOption` is invoked using the :func:`_orm.with_loader_criteria` function; see that function for details. .. versionadded:: 1.4 root_entityrwhere_criteriainclude_aliasespropagate_to_loadersc  [R"US5nUcXlSUlO SUlXplX l[ U5(a{SUl[R"U[R[URb UROURR54[R"US9S9Ul O1SUl[R"[RU5Ul X@lXPlg)aAdd additional WHERE criteria to the load for all occurrences of a particular entity. .. versionadded:: 1.4 The :func:`_orm.with_loader_criteria` option is intended to add limiting criteria to a particular kind of entity in a query, **globally**, meaning it will apply to the entity as it appears in the SELECT query as well as within any subqueries, join conditions, and relationship loads, including both eager and lazy loaders, without the need for it to be specified in any particular part of the query. The rendering logic uses the same system used by single table inheritance to ensure a certain discriminator is applied to a table. E.g., using :term:`2.0-style` queries, we can limit the way the ``User.addresses`` collection is loaded, regardless of the kind of loading used:: from sqlalchemy.orm import with_loader_criteria stmt = select(User).options( selectinload(User.addresses), with_loader_criteria(Address, Address.email_address != 'foo')) ) Above, the "selectinload" for ``User.addresses`` will apply the given filtering criteria to the WHERE clause. Another example, where the filtering will be applied to the ON clause of the join, in this example using :term:`1.x style` queries:: q = session.query(User).outerjoin(User.addresses).options( with_loader_criteria(Address, Address.email_address != 'foo')) ) The primary purpose of :func:`_orm.with_loader_criteria` is to use it in the :meth:`_orm.SessionEvents.do_orm_execute` event handler to ensure that all occurrences of a particular entity are filtered in a certain way, such as filtering for access control roles. It also can be used to apply criteria to relationship loads. In the example below, we can apply a certain set of rules to all queries emitted by a particular :class:`_orm.Session`:: session = Session(bind=engine) @event.listens_for("do_orm_execute", session) def _add_filtering_criteria(execute_state): if ( execute_state.is_select and not execute_state.is_column_load and not execute_state.is_relationship_load ): execute_state.statement = execute_state.statement.options( with_loader_criteria( SecurityRole, lambda cls: cls.role.in_(['some_role']), include_aliases=True ) ) In the above example, the :meth:`_orm.SessionEvents.do_orm_execute` event will intercept all queries emitted using the :class:`_orm.Session`. For those queries which are SELECT statements and are not attribute or relationship loads a custom :func:`_orm.with_loader_criteria` option is added to the query. The :func:`_orm.with_loader_criteria` option will be used in the given statement and will also be automatically propagated to all relationship loads that descend from this query. The criteria argument given is a ``lambda`` that accepts a ``cls`` argument. The given class will expand to include all mapped subclass and need not itself be a mapped class. .. tip:: When using :func:`_orm.with_loader_criteria` option in conjunction with the :func:`_orm.contains_eager` loader option, it's important to note that :func:`_orm.with_loader_criteria` only affects the part of the query that determines what SQL is rendered in terms of the WHERE and FROM clauses. The :func:`_orm.contains_eager` option does not affect the rendering of the SELECT statement outside of the columns clause, so does not have any interaction with the :func:`_orm.with_loader_criteria` option. However, the way things "work" is that :func:`_orm.contains_eager` is meant to be used with a query that is already selecting from the additional entities in some way, where :func:`_orm.with_loader_criteria` can apply it's additional criteria. In the example below, assuming a mapping relationship as ``A -> A.bs -> B``, the given :func:`_orm.with_loader_criteria` option will affect the way in which the JOIN is rendered:: stmt = select(A).join(A.bs).options( contains_eager(A.bs), with_loader_criteria(B, B.flag == 1) ) Above, the given :func:`_orm.with_loader_criteria` option will affect the ON clause of the JOIN that is specified by ``.join(A.bs)``, so is applied as expected. The :func:`_orm.contains_eager` option has the effect that columns from ``B`` are added to the columns clause:: SELECT b.id, b.a_id, b.data, b.flag, a.id AS id_1, a.data AS data_1 FROM a JOIN b ON a.id = b.a_id AND b.flag = :flag_1 The use of the :func:`_orm.contains_eager` option within the above statement has no effect on the behavior of the :func:`_orm.with_loader_criteria` option. If the :func:`_orm.contains_eager` option were omitted, the SQL would be the same as regards the FROM and WHERE clauses, where :func:`_orm.with_loader_criteria` continues to add its criteria to the ON clause of the JOIN. The addition of :func:`_orm.contains_eager` only affects the columns clause, in that additional columns against ``b`` are added which are then consumed by the ORM to produce ``B`` instances. .. warning:: The use of a lambda inside of the call to :func:`_orm.with_loader_criteria` is only invoked **once per unique class**. Custom functions should not be invoked within this lambda. See :ref:`engine_lambda_caching` for an overview of the "lambda SQL" feature, which is for advanced use only. :param entity_or_base: a mapped class, or a class that is a super class of a particular set of mapped classes, to which the rule will apply. :param where_criteria: a Core SQL expression that applies limiting criteria. This may also be a "lambda:" or Python function that accepts a target class as an argument, when the given class is a base with many different mapped subclasses. .. note:: To support pickling, use a module-level Python function to produce the SQL expression instead of a lambda or a fixed SQL expression, which tend to not be picklable. :param include_aliases: if True, apply the rule to :func:`_orm.aliased` constructs as well. :param propagate_to_loaders: defaults to True, apply to relationship loaders such as lazy loaders. This indicates that the option object itself including SQL expression is carried along with each loaded instance. Set to ``False`` to prevent the object from being assigned to individual instances. .. seealso:: :ref:`examples_session_orm_events` - includes examples of using :func:`_orm.with_loader_criteria`. :ref:`do_orm_execute_global_criteria` - basic example on how to combine :func:`_orm.with_loader_criteria` with the :meth:`_orm.SessionEvents.do_orm_execute` event. :param track_closure_variables: when False, closure variables inside of a lambda expression will not be used as part of any cache key. This allows more complex expressions to be used inside of a lambda expression but requires that the lambda ensures it returns the identical SQL every time given a particular class. .. versionadded:: 1.4.0b2 FNT)track_closure_variables) lambda_argsopts)rrrr_where_crit_origcallabledeferred_where_criteriar#DeferredLambdaElementr$WhereHavingRoler LambdaOptionsrr!rrr)rNentity_or_baser loader_onlyrrrrs rOrLoaderCriteriaOption.__init__sh##NE: >- DK#D  K . N # #+/D (")"?"?%%#++7((![[//**,C #D ,1D ("+"2"2%%~#D  /$8!rgc[UUUUS9$)N)rr)r)rJrrrrs rO _unreduceLoaderCriteriaOption._unreduces$  +!5   rgc[RUR(aURRO URUR UR UR44$rj)rrrrrrrrrs rO __reduce__LoaderCriteriaOption.__reduce__sP * *&*kk ""t7G7G%%$$))    rgc## UR(a,URRRHnUv M g[URR 55nU(axUR S5n[R"USS9nU(a"URRHnUv M OURUR 55 U(aMwgg7f)NrF)raiseerr) rrself_and_descendantslistr__subclasses__rrrextend)rNrstacksubclassrns rO _all_mappers!LoaderCriteriaOption._all_mapperss ;;{{))>> ?))88:;E 99Q< ((EB!jj== >LL!8!8!:;%s CC#!C#cXURRRSS5ULagg)Nfor_loader_criteriaFT)select_statementrrrN compile_states rO_should_include$LoaderCriteriaOption._should_includes3  * * 7 7 ; ;%t   rgcUR(a&URRUR5nO URn[R "USU0SS9$)NrT)detect_subquery_cols)rr_resolve_with_argsrr_deep_annotate)rNext_infocrits rO_resolve_where_criteria,LoaderCriteriaOption._resolve_where_criteriasP  ' '&&99(//JD&&D&& ($/d  rgc$URU5$rj)process_compile_state)rNrmapper_entitiess rO'process_compile_state_replaced_entitiesrs &2F2FrgcU$rjrfrs rOrrsrgc[U[R5(aVU(a[R"S5eU(aUR X#S9$[ R"[RXS9$[UUUUUS9$)aProduce an alias of the given element, usually an :class:`.AliasedClass` instance. E.g.:: my_alias = aliased(MyClass) session.query(MyClass, my_alias).filter(MyClass.id > my_alias.id) The :func:`.aliased` function is used to create an ad-hoc mapping of a mapped class to a new selectable. By default, a selectable is generated from the normally mapped selectable (typically a :class:`_schema.Table` ) using the :meth:`_expression.FromClause.alias` method. However, :func:`.aliased` can also be used to link the class to a new :func:`_expression.select` statement. Also, the :func:`.with_polymorphic` function is a variant of :func:`.aliased` that is intended to specify a so-called "polymorphic selectable", that corresponds to the union of several joined-inheritance subclasses at once. For convenience, the :func:`.aliased` function also accepts plain :class:`_expression.FromClause` constructs, such as a :class:`_schema.Table` or :func:`_expression.select` construct. In those cases, the :meth:`_expression.FromClause.alias` method is called on the object and the new :class:`_expression.Alias` object returned. The returned :class:`_expression.Alias` is not ORM-mapped in this case. .. seealso:: :ref:`tutorial_orm_entity_aliases` - in the :ref:`unified_tutorial` :ref:`orm_queryguide_orm_aliases` - in the :ref:`queryguide_toplevel` :param element: element to be aliased. Is normally a mapped class, but for convenience can also be a :class:`_expression.FromClause` element. :param alias: Optional selectable unit to map the element to. This is usually used to link the object to a subquery, and should be an aliased select construct as one would produce from the :meth:`_query.Query.subquery` method or the :meth:`_expression.Select.subquery` or :meth:`_expression.Select.alias` methods of the :func:`_expression.select` construct. :param name: optional string name to use for the alias, if not specified by the ``alias`` parameter. The name, among other things, forms the attribute name that will be accessible via tuples returned by a :class:`_query.Query` object. Not supported when creating aliases of :class:`_sql.Join` objects. :param flat: Boolean, will be passed through to the :meth:`_expression.FromClause.alias` call so that aliases of :class:`_expression.Join` objects will alias the individual tables inside the join, rather than creating a subquery. This is generally supported by all modern databases with regards to right-nested joins and generally produces more efficient queries. :param adapt_on_names: if True, more liberal "matching" will be used when mapping the mapped columns of the ORM entity to those of the given selectable - a name-based match will be performed if the given selectable doesn't otherwise have a column that corresponds to one on the entity. The use case for this is when associating an entity with some derived selectable such as one that uses aggregate functions:: class UnitPrice(Base): __tablename__ = 'unit_price' ... unit_id = Column(Integer) price = Column(Numeric) aggregated_unit_price = Session.query( func.sum(UnitPrice.price).label('price') ).group_by(UnitPrice.unit_id).subquery() aggregated_unit_price = aliased(UnitPrice, alias=aggregated_unit_price, adapt_on_names=True) Above, functions on ``aggregated_unit_price`` which refer to ``.price`` will return the ``func.sum(UnitPrice.price).label('price')`` column, as it is matched on the name "price". Ordinarily, the "price" function wouldn't have any "column correspondence" to the actual ``UnitPrice.price`` column as it is not a proxy of the original. z+adapt_on_names only applies to ORM elementsrr)rrrr) r8r" FromClauser>r?rr!rr$AnonymizedFromClauseRoler)elementrrrrs rOaliasedrsx':0011 &&=  ==d=6 6##..  )   rgc [U5n US;aU(a[R"S5eU (anU RU Lde[R "U5n[ U RV s/sHoRPM sn 5n X:XaU $URU 5nU RXUS9upU(dU(aURUS9n[UUUU UUU(+S9$s sn f)a Produce an :class:`.AliasedClass` construct which specifies columns for descendant mappers of the given base. Using this method will ensure that each descendant mapper's tables are included in the FROM clause, and will allow filter() criterion to be used against those tables. The resulting instances will also have those columns already loaded so that no "post fetch" of those columns will be required. .. seealso:: :ref:`with_polymorphic` - full discussion of :func:`_orm.with_polymorphic`. :param base: Base class to be aliased. :param classes: a single class or mapper, or list of class/mappers, which inherit from the base class. Alternatively, it may also be the string ``'*'``, in which case all descending mapped classes will be added to the FROM clause. :param aliased: when True, the selectable will be aliased. For a JOIN, this means the JOIN will be SELECTed from inside of a subquery unless the :paramref:`_orm.with_polymorphic.flat` flag is set to True, which is recommended for simpler use cases. :param flat: Boolean, will be passed through to the :meth:`_expression.FromClause.alias` call so that aliases of :class:`_expression.Join` objects will alias the individual tables inside the join, rather than creating a subquery. This is generally supported by all modern databases with regards to right-nested joins and generally produces more efficient queries. Setting this flag is recommended as long as the resulting SQL is functional. :param selectable: a table or subquery that will be used in place of the generated FROM clause. This argument is required if any of the desired classes use concrete table inheritance, since SQLAlchemy currently cannot generate UNIONs among tables automatically. If used, the ``selectable`` argument must represent the full set of tables and columns mapped by every mapped class. Otherwise, the unaccounted mapped columns will result in their table being appended directly to the FROM clause which will usually lead to incorrect results. When left at its default value of ``False``, the polymorphic selectable assigned to the base mapper is used for selecting rows. However, it may also be passed as ``None``, which will bypass the configured polymorphic selectable and instead construct an ad-hoc selectable for the target classes given; for joined table inheritance this will be a join that includes all target mappers and their subclasses. :param polymorphic_on: a column to be used as the "discriminator" column for the given selectable. If not given, the polymorphic_on attribute of the base classes' mapper will be used, if any. This is useful for mappings that don't have polymorphic loading behavior by default. :param innerjoin: if True, an INNER JOIN will be used. This should only be specified if querying for one specific subtype only :param adapt_on_names: Passes through the :paramref:`_orm.aliased.adapt_on_names` parameter to the aliased object. This may be useful in situations where the given selectable is not directly related to the existing mapped selectable. .. versionadded:: 1.4.33 rsz[the 'flat' and 'selectable' arguments cannot be passed simultaneously to with_polymorphic()) innerjoinr)rrrrr) rr>r?rrto_setr;rrunion_with_polymorphic_argsrr)r classesrrrrrrr&_existing_aliasprimary_mapperrn new_classesmapperss rOwith_polymorphicr]sd&d+N&4"" 3  %%777++g&!0!I!I J!I2YY!I J   !" "mmK0G(??y@G$5545@  %!('5("+m  Ks0C'c\rSrSrSrSrSrSrSrSr \ R"5r Sr Sr\S5r\S5r\S 5rS rS rS rS r\S 5rSrSrSrg )BundleiaA grouping of SQL expressions that are returned by a :class:`.Query` under one namespace. The :class:`.Bundle` essentially allows nesting of the tuple-based results returned by a column-oriented :class:`_query.Query` object. It also is extensible via simple subclassing, where the primary capability to override is that of how the set of expressions should be returned, allowing post-processing as well as custom return types, without involving ORM identity-mapped classes. .. versionadded:: 0.9.0 .. seealso:: :ref:`bundles` FTc |U=UlUlUVs/sH&n[R"[R X@S9PM( sn=Uln[SUVs/sHoURRSU5PM sn55=Ul Ul URSUR5Ul gs snfs snf)aConstruct a new :class:`.Bundle`. e.g.:: bn = Bundle("mybundle", MyClass.x, MyClass.y) for row in session.query(bn).filter( bn.c.x == 5).filter(bn.c.y == 4): print(row.mybundle.x, row.mybundle.y) :param name: name of the bundle. :param \*exprs: columns or SQL expressions comprising the bundle. :param single_entity=False: if True, rows for this :class:`.Bundle` can be returned as a "single entity" outside of any enclosing tuple in the same manner as a mapped entity. )apply_propagate_attrsc3T# UHn[USUR5U4v M g7f)roN)r _label)rmrs rOro"Bundle.__init__..s)1 GS% ,c 2Gs&(bundle single_entityN)rrr!rr$ColumnsClauseRoleexprsr'rrrZcolumnsrr)rNrrrhexpres rOrBundle.__init__s$#'& DK      ''     U!11 AFGA**8Q7G1 !   VVOT5G5GH Hs -B4%B9 c URURUR4[URVs/sHo3R X5PM sn5-$s snfrj) __class__rrtupler_gen_cache_key)rNanon_map bindparamsrs rOrBundle._gen_cache_keysN 4+=+=>CG:: N:4  6: NB   NsA cTURSRRSS5$)Nrrrrrrs rOr Bundle.mapper#zz!}))--ndCCrgcTURSRRSS5$)Nrr6rrs rOr Bundle.entity#rrgcUR$rj)rZrs rOr7Bundle.entity_namespace's vv rgNcURRUR5nURRUR5 U$rj)rrHr rC)rNcloneds rO_clone Bundle._cloneGs5''7t}}- rgc XS.nURUR5 URSRR SUR 5n[ R"URVs/sHo3RR SU5PM sn[RSS.6RU5RSUS.5$s snf) N)rr7rr;rF)_literal_as_text_rolegroupr8r9) rCrr_propagate_attrsrrr" ClauseListr$rr<r=)rN annotationsr;rs rOr>Bundle.__clause_element__Ls!%@ 4,,-A77;; dkk   ! !<@::F:a..$$Xq1:F',&=&=  Y{ # ! !-2&4 Gs1%C c6UR5R$rj)r>clausesrs rOrBundle.clauseses&&(000rgc2UR5nXlU$)zT"TVs/sH o"U5PM sn5$s snfrjrf)rproc keyed_tupleprocss rOr)Bundle.create_row_processor..proc|s$e ,@s ( )rrZrrrr)r\r]r^r_r`ris_clause_element is_mapperr is_bundler immutabledictrrrrrrr7rrZr r>rrr#rerfrgrOrrs(M<II))+I@ DDDDG0 A/  211rgrc6[R"USS0U5$)zDeep copy the given ClauseElement, annotating each element with the "_orm_adapt" flag. Elements within the exclude collection will be cloned but not annotated. _orm_adaptT)rr)rexcludes rO _orm_annotater,s  " "7\4,@' JJrgc,[R"USS9$)zRemove annotations that link a column to a particular mapping. Note this doesn't affect "remote" and "foreign" annotations passed by the :func:`_orm.foreign` and :func:`_orm.remote` annotators. )r*r6)rLr_deep_deannotaters rO_orm_deannotater1s  $ $6 rgc.[R"U5$rjr.r0s rO_orm_full_deannotater3s  $ $W --rgc\rSrSrSr\R RrSrS Sjr Sr S Sjr S Sjr S r g) _ORMJoiniz/Extend Join to support ORM constructs as input.TNc :[R"U5n [R"U5n U Rn X`lXpl[ USU 5n Xl[U[R5(a[ U RU5n[U[R5(a5URR5n URnXR - nO0[U["5(aUnUR$Rn OSnU RnU(a[&R("W U5(aU nOUnUR+UU SU SUS9unnnnnnUb>U(a[,R."UUU5nUnO[,R."UUUU5nUnOUnUUlU R2(aUR4R7SS5nO'U R8(dU R:(aU nOSnUb"UR4R=SU05Ul[?U5=(a U(+n[@RBREXX#XE5 U(a&U=RF[,RH"U6-sl#U(d[ U SS5(awU RJRL(a[U RJRNnUbAU R:(aU RPRSU5nURFU-Ul#ggggg)N_joined_from_infoT)source_selectabledest_selectablesource_polymorphicof_type_entityalias_secondaryextra_criteriar6r)*rrr _left_memo _right_memor r7r8rr9rrQueryableAttribute comparator_source_selectabler_extra_criteriarparentrclause_is_present _create_joinsrr@_target_adapter is_selectablerrr&rrboolr"JoinrrZand_rsingle_single_table_criterionr.rP)rNleftrightrZisouterfullr>r?rC left_info right_infoadapt_to left_orm_info on_selectablepropleft_selectable adapt_frompjsjsourcedest secondarytarget_adapterr6augment_onclause single_crits rOr_ORMJoin.__init__s&&t, ''. ((%& &99E !+ h 1 1 2 2}33X>H h = = > >$//BBDM$$D 77 7O . 1 1D KK22MD#.. ))-II* , """, (#') $. # ~HHYr:E!H88D)RAD!H#1D  " "*77;;L I$>$>$LL  # $ 1 1 7 7.!D  0=X  UgL  MMSXX7 7M Hd33!!(( %++CCK&..","5"5">">{"KK $ ; ' )4rgc Un[U[R5(a-URn[U[R5(aM-URULde[ URURUR URURURS9n[ UURUR URURS9$)z\Splice a join into the center. Given join(a, b) and join(b, c), return join(a, b).join(c) )rPr>r?)rPr?) r8rrJrNrOr5rZrPr>r?)rNotherleftmostrNs rO_splice_into_center_ORMJoin._splice_into_centers 388,,}}H388,,zzX%%% II JJ MMLL((    KK NNMM))   rgc[XX$US9$)N)rQrPr5)rNrOrZrPrQ join_to_lefts rOr@ _ORMJoin.join3sX'JJrgc[XUSUS9$)NT)rPrQri)rNrOrZrQrjs rO outerjoin_ORMJoin.outerjoin=sXt$GGrg)rr7r>r?rGrZ)NFFNNrfNFFNNFN)r\r]r^r_r`r"rJ__visit_name__ inherit_cacherrfr@rmrerfrgrOr5r5sT9__33NM  o fn(A, A) -> True someoption(A).someoption(C.d) # -> fn(A, C) -> False a1 = aliased(A) someoption(a1).someoption(A.b) # -> fn(a1, A) -> False someoption(a1).someoption(a1.b) # -> fn(a1, a1) -> True wp = with_polymorphic(A, [A1, A2]) someoption(wp).someoption(A1.foo) # -> fn(wp, A1) -> False someoption(wp).someoption(wp.A1.foo) # -> fn(wp, wp.A1) -> True )rr&rrrrrs rO$_entity_corresponds_to_use_path_implrs(   # # P+++ PNE-N-N$N  $ $""6==11  # # 9888 rgcUR(a0XR;=(d URRU5$UR(aXR;$URU5$)z]determine if 'given' "is a" mapper, in terms of the given would load rows of type 'mapper'. )rrrr)rrs rO _entity_isars`  777 5<<;K;K <    ' '7777yy  rgczSSKJnJnJnJn SSKJn SSKJn U=Ul =Ul =Ul =Ul Ul g)aUse random-ordering sets within the unit of work in order to detect unit of work sorting issues. This is a utility function that can be used to help reproduce inconsistent unit of work sorting issues. For example, if two kinds of objects A and B are being inserted, and B has a foreign key reference to A - the A must be inserted first. However, if there is no relationship between A and B, the unit of work won't know to perform this sorting, and an operation may or may not fail, depending on how the ordering works out. Since Python sets and dictionaries have non-deterministic ordering, such an issue may occur on some runs and not on others, and in practice it tends to have a great dependence on the state of the interpreter. This leads to so-called "heisenbugs" where changing entirely irrelevant aspects of the test program still cause the failure behavior to change. By calling ``randomize_unitofwork()`` when a script first runs, the ordering of a key series of sets within the unit of work implementation are randomized, so that the script can be minimized down to the fundamental mapping and operation that's failing, while still reproducing the issue on at least some runs. This utility is also available when running the test suite via the ``--reversetop`` flag. r) unitofworksessionr dependency) topological) RandomSetN) sqlalchemy.ormrrrrsqlalchemy.utilrsqlalchemy.testing.utilrr;)rrrrrrs rOrandomize_unitofworkr.sA6GF+15>>KO>> >j:>rgc:^U4Sjn[U[5(a[R"U5upEn[U[5(a[U[5(a XT- S::a/$[U[5(aUS:d[U[5(aUS:aU"5 [ U5U$URXE5nUb[ U5SSUR 2$[ U5$US:XaU"5 [ U5S$[ XUS-5S$)z\calculate __getitem__ in terms of an iterable query object that also has a slice() method. cV>T(d [S5e[R"S5 g)Nz@negative indexes are not accepted by SQL index / slice operatorszSupport for negative indexes for SQL index / slice operators will be removed in 2.0; these operators fetch the complete result and do not work efficiently.) IndexErrorrrw)allow_negativesrO_no_negative_indexes&_getitem.._no_negative_indexesXs-*   # #/ rgrNr)r8slicer decode_sliceintrstep)iterable_queryitemrrstartstoprress ` rO_getitemrRs $ --d3T tS ! !5#&& !I$$ tS ! !dQh "'- -""5/  9TD49945 59  2: "'+ +dQh78; ;rg)p_unionT)NNFF)FFNFFFFNrjrorp)PrWrrrVrr rrrrr r r r r rrr interfacesrrrrrr path_registryrrrr>rrr engine.resultrsql_baser!r"r#r$rr%sql.annotationr&sql.baser'rGrar1rrrrrrrMemoizedHasCacheKeyrrr _inspectsrr_self_inspectsrr,r1r3rJr5r@rmrzr}rrrrrrrfrgrOrs " %!&&,2)&'(""5'   ?Y?D?DF=AO3de;P%P''%PPx'6x'vh<    h}'@  \"#FG [!"78n h  qh m    mm`K .`Hz`HHIM2:j7C@L  "'(  F !!>H.