,h "SrSSKJr SSKrSSKrSSKrSSKJr 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 SSKJ!r! SSKJ"r" SSKJ#r# SS KJ$r$ SS!KJ%r% SS"KJ&r& SS#KJ'r' SS$KJ(r( SS%KJ)r) SS&KJ*r* S'S(KJ+r+ S'SKJr, S'S)KJ-r- S'S*KJ.r. S'S+K/J0r0 S'S,K/J1r1 S'S-K/J2r2 S'S.K3J4r4 S'S/K3J5r5 S'S0K6J7r7 S'S1K8J9r9 S'S2K:J;r; S'S3Kr> S'S5K?J@r@ S'S6K?JArA \R*(aSS7KBJCrC SS8KBJDrD SS9KBJErE SS:KBJFrF SS;KBJGrG SSKKJLrL SS?KKJMrM SS@KKJNrN SSAKOJPrP SSBKQJRrR SSCKSJTrT SSDKUJVrV SSEKJWrW SSFKXJYrY SSGKZJ[r[ SSHK\J]r] SSIK^J_r_ SSJK.J`r` SSKK.Jara S'SLKbJcrc S'SMKdJere S'SNKdJfrf S'SOKdJgrg S'SPKdJhrh S'SQK8Jiri S'SRKjJkrk S'SSK?Jlrl \\ST4rm\"SU\SV9rn\"SW\SXSY9ro\"SZS[SV9rp"S\S]\1R5rr"S^S_\1R\1R\n5ru"S`Sa\u\n5rv"SbSc\1R5rx"SdSe\A5ry"SfSg5rz"ShSi\5r{\{"\4R\4R\4R\4R\4R\4R\4R5r}\{"Sj\4R\4R\4R\4R\4R\4R5r~"SkSl5r"SmSn\\\n5r\-GR"SoSp\7\\\n\"\.GR55r\-GR"SqSr\*\o\ \o\955r"SsSt\\n5r"SuSv\55r"SwSx\7\5r"SySz\5r"S{S|\5r"S}S~\5r\.GR"SSSS9"SS\55r"SS5rg)z Contains various base classes used throughout the ORM. Defines some key base classes prominent within the internals. This module and the classes within are mostly private, though some attributes are exposed when inspecting mappings. ) annotationsN)Any)Callable)cast)ClassVar)Dict)Generic)Iterator)List) NamedTuple)NoReturn)Optional)Sequence)Set)Tuple)Type) TYPE_CHECKING)TypeVar)Union)exc) path_registry)_MappedAttribute) EXT_CONTINUE)EXT_SKIP)EXT_STOP)InspectionAttr)InspectionAttrInfo) MANYTOMANY) MANYTOONE)NO_KEY)NO_VALUE) NotExtension) ONETOMANY)RelationshipDirection)SQLORMOperations) ColumnElement) inspection)util) operators)roles)visitors)_NoArg)ExecutableOption) HasCacheKey)ColumnOperators)Column) TypeEngine)warn_deprecated)RODescriptorReference) TypedDict) _EntityType)_IdentityKeyType) _InstanceDict)_InternalEntityType)_ORMAdapterProto)InstrumentedAttribute)Mapped) _MapperEntity)ORMCompileState) QueryContext) RegistryType)_ClassScanMapperConfig)_PopulatorDict)Mapper)AbstractEntityRegistry)Query)Session) InstanceState) _LoadElement) AliasedInsp) ORMAdapter)Result)_ColumnExpressionArgument)_ColumnsClauseArgument)_DMLColumnArgument) _InfoType) OperatorType)_TraverseInternalsType)_AnnotationScanType._T)bound_T_coT)rU covariant_TLSType[LoaderStrategy]c\rSrSrSrSrSrg)ORMStatementRolesz?Executable SQL or text() construct, including ORM aware objectsN__name__ __module__ __qualname____firstlineno__ __slots__ _role_name__static_attributes__r]Q/var/www/auris/envauris/lib/python3.13/site-packages/sqlalchemy/orm/interfaces.pyr[r[ssIIrfr[c\rSrSrSrSrSrg)ORMColumnsClauseRolezr]z7ORM mapped entity, aliased entity, or Column expressionNr^r]rfrgririzsIJJrfric\rSrSrSrSrSrg)ORMEntityColumnsClauseRoler]zORM mapped or aliased entityNr^r]rfrgrlrls I/Jrfrlc\rSrSrSrSrSrg)ORMFromClauseRoler]z5ORM mapped entity, aliased entity, or FROM expressionNr^r]rfrgroros IHJrfrocH\rSrSr%S\S'S\S'S\S'S\S 'S \S 'S rg )ORMColumnDescriptionstrnamez!Union[Type[Any], TypeEngine[Any]]typeboolaliasedz_ColumnsClauseArgument[Any]exprz%Optional[_ColumnsClauseArgument[Any]]entityr]N)r_r`rarb__annotations__rer]rfrgrrrrs I ,+ M %% 11rfrrcr\rSrSrSr\SSj5rS SjrS SjrS Sjr Sr g) _IntrospectsAnnotationsr]cUR$N)r_)clss rg_mapper_property_name-_IntrospectsAnnotations._mapper_property_names ||rfc>[SUR5<S35e)zjreturn a copy of this object to use in declarative when the object is found inside of an Annotated object.z Use of the z> construct inside of an Annotated object is not yet supported.)NotImplementedErrorrselfs rgfound_in_pep593_annotated1_IntrospectsAnnotations.found_in_pep593_annotateds."$4469:L L  rfc g)zaPerform class-specific initializaton at early declarative scanning time. .. versionadded:: 2.0 Nr]) r decl_scanregistryroriginating_modulekeymapped_container annotationextracted_mapped_annotationis_dataclass_fields rgdeclarative_scan(_IntrospectsAnnotations.declarative_scanrfc r[R"SURSUSUR5S35e)Nz4Python typing annotation is required for attribute ".z " when primary argument(s) for "z#" construct are None or not present)sa_exc ArgumentErrorr_r)rrrs rg_raise_for_required+_IntrospectsAnnotations._raise_for_requiredsG"" ~Qse$**,-.0 0  rfNreturnrt)rr)rrBrrAr Type[Any]r Optional[str]rrtrzOptional[Type[Mapped[Any]]]rOptional[_AnnotationScanType]rrrrwrNone)rrtrrrr ) r_r`rarbrc classmethodrrrrrer]rfrgr}r}sI  )    *    6 2 &C !   & rfr}c\rSrSr%SrS\S'S\S'S\S'S\S 'S\S 'S\S 'S \S 'SSjr\SSj5rSr g)_AttributeOptionszdefine Python-local attribute behavior options common to all :class:`.MapperProperty` objects. Currently this includes dataclass-generation arguments. .. versionadded:: 2.0 zUnion[_NoArg, bool]dataclasses_initdataclasses_reprzUnion[_NoArg, Any]dataclasses_defaultz Union[_NoArg, Callable[[], Any]]dataclasses_default_factorydataclasses_comparedataclasses_kw_onlyzUnion[_NoArg, bool, None]dataclasses_hashc^0nUR[RLaURUS'UR[RLaURUS'UR[RLaURUS'UR [RLaUR US'UR [RLaUR US'UR[RLaURUS'UR[RLaURUS'SU;a$[US5(a[SU<S 3S 5 SU;aCUS(d9SU;a3[US5(d SU;aURS5mU4S jUS'[R"S 0UD6$) zT$rr])rsrg7_AttributeOptions._as_dataclass_field..sGrfr])rr.NO_ARGrrrrrrcallabler4pop dataclassesfield)rrkwrs @rg_as_dataclass_field%_AttributeOptions._as_dataclass_fields   + +6== @$($D$DB !  # #6== 8 44ByM   5..BvJ   5..BvJ  # #6== 8 44ByM  # #6== 8 44ByM   5..BvJ ?x9 66  G$= =  bLvJRR ]++!+ffY'G$3B !  &2&&rfc[U[5(aURRU5nXU4$U[R LaXU4$UbS5eX4$)zgiven attribute key, annotation, and value from a class, return the argument tuple we would pass to dataclasses.make_dataclass() for this attribute. z/Mapped[] received without a mapping declaration) isinstance_DCAttributeOptions_attribute_optionsrr.r)rrrrelemdc_fields rg!_get_arguments_for_make_dataclass3_AttributeOptions._get_arguments_for_make_dataclasssi d/ 0 0..BB3GHX. .  &T* *  ) LK K5 $ $rfr]N)rrtrr) rrtrrSr Optional[Any]rrTrz_Union[Tuple[str, _AnnotationScanType], Tuple[str, _AnnotationScanType, dataclasses.Field[Any]]]) r_r`rarb__doc__r{rrrrer]rfrgrrs}*)))++!AA,,,,///'b%% %%(%%( %%  %%   %%%%rfrFc4\rSrSr%SrSrS\S'S\S'Srg) riBa_mixin for descriptors or configurational objects that include dataclass field options. This includes :class:`.MapperProperty`, :class:`._MapsColumn` within the ORM, but also includes :class:`.AssociationProxy` within ext. Can in theory be used for other descriptors that serve a similar role as association proxy. (*maybe* hybrids, not sure yet.) r]rrrw_has_dataclass_argumentsN)r_r`rarbrrcr{rer]rfrgrrBs!I)) #"rfrcD\rSrSrSrSr\SSj5r\SSj5rSr g) _MapsColumnsiYzinterface for declarative-capable construct that delivers one or more Column objects to the declarative process to be part of a Table. r]c[5e)zAreturn a MapperProperty to be assigned to the declarative mappingrrs rgmapper_property_to_assign&_MapsColumns.mapper_property_to_assign`s "##rfc[5e)zVA list of Column objects that should be declaratively added to the new Table object. rrs rgcolumns_to_assign_MapsColumns.columns_to_assignes "##rfN)rzOptional[MapperProperty[_T]])rzList[Tuple[Column[_T], int]]) r_r`rarbrrcpropertyrrrer]rfrgrrYs4I $$$$rfrc\rSrSr%SrSrS\RR4S\RR4/r S\ S'\ (dSr S rS \ S 'S \ S'S \ S'SrS\ S'S\ S'S\ S'S#SjrS$SjrS%SjrS&S'SjjrS(SjrS)SjrS*S+SjjrS,Sjr\S-Sj5rS,SjrS)SjrS.S jrS/S!jrS"rg)0MapperPropertyiwaRepresent a particular class attribute mapped by :class:`_orm.Mapper`. The most common occurrences of :class:`.MapperProperty` are the mapped :class:`_schema.Column`, which is represented in a mapping as an instance of :class:`.ColumnProperty`, and a reference to another class produced by :func:`_orm.relationship`, represented in the mapping as an instance of :class:`.Relationship`. )_configure_started_configure_finishedrrparentrinfodocrrrR_cache_key_traversalNTzPropComparator[_T] comparatorrt Mapper[Any]Frw_links_to_entityrrrPrc0$)aInfo dictionary associated with the object, allowing user-defined data to be associated with this :class:`.InspectionAttr`. The dictionary is generated when first accessed. Alternatively, it can be specified as a constructor argument to the :func:`.column_property`, :func:`_orm.relationship`, or :func:`.composite` functions. .. seealso:: :attr:`.QueryableAttribute.info` :attr:`.SchemaItem.info` r]rs rg_memoized_attr_info"MapperProperty._memoized_attr_infos " rfc g)zCalled by Query for the purposes of constructing a SQL statement. Each MapperProperty associated with the target mapper processes the statement referenced by the query context, adding columns and/or criterion as appropriate. Nr])rcontext query_entitypathadapterkwargss rgsetupMapperProperty.setuprrfcg)zSProduce row processing functions and append to the given set of populators lists. Nr])rrrrmapperresultr populatorss rgcreate_row_processor#MapperProperty.create_row_processorrrfc[S5$)afIterate through instances related to the given instance for a particular 'cascade', starting with this MapperProperty. Return an iterator3-tuples (instance, mapper, state). Note that the 'cascade' collection on this MapperProperty is checked first for the given type before cascade_iterator is called. This method typically only applies to Relationship. r])iter)rtype_statedict_visited_stateshalt_ons rgcascade_iteratorMapperProperty.cascade_iterators ,BxrfcXlg)zSet the parent mapper that references this MapperProperty. This method is overridden by some subclasses to perform extra setup when the mapper is first known. N)r)rrrs rg set_parentMapperProperty.set_parents  rfcg)aHook called by the Mapper to the property to initiate instrumentation of the class attribute managed by this MapperProperty. The MapperProperty here will typically call out to the attributes module to set up an InstrumentedAttribute. This step is the first of two steps to set up an InstrumentedAttribute, and is called early in the mapper setup process. The second step is typically the init_class_attribute step, called from StrategizedProperty via the post_instrument_class() hook. This step assigns additional state to the InstrumentedAttribute (specifically the "impl") which has been determined after the MapperProperty has determined what kind of persistence management it needs to do (e.g. scalar, object, collection, etc). Nr]rrs rginstrument_classMapperProperty.instrument_classrrfcSUlSUlU(a[nO[nU(aX:waSUlXlgSUlX0lg)NFT)rr#_DEFAULT_READONLY_ATTRIBUTE_OPTIONS_DEFAULT_ATTRIBUTE_OPTIONSrr)rattribute_options_assume_readonly_dc_attributes default_attrss rg__init__MapperProperty.__init__1sF #(#( )?M6M !2!C,0D )&7 #,1D )&3 #rfc@SUlUR5 SUlg)zCalled after all mappers are created to assemble relationships between mappers and perform other post-mapper-creation initialization steps. TN)rdo_initrrs rgrMapperProperty.initEs#' #' rfcV[URRUR5$)a>Return the class-bound descriptor corresponding to this :class:`.MapperProperty`. This is basically a ``getattr()`` call:: return getattr(self.parent.class_, self.key) I.e. if this :class:`.MapperProperty` were named ``addresses``, and the class to which it is mapped is ``User``, this sequence is possible:: >>> from sqlalchemy import inspect >>> mapper = inspect(User) >>> addresses_property = mapper.attrs.addresses >>> addresses_property.class_attribute is User.addresses True >>> User.addresses.property is addresses_property True )getattrrclass_rrs rgclass_attributeMapperProperty.class_attributePs0t{{))48844rfcg)zPerform subclass-specific initialization post-mapper-creation steps. This is a template method called by the ``MapperProperty`` object's init() method. Nr]rs rgr MapperProperty.do_initjrrfcg)aPerform instrumentation adjustments that need to occur after init() has completed. The given Mapper is the Mapper invoking the operation, which may not be the same Mapper as self.parent in an inheritance scenario; however, Mapper will always at least be a sub-mapper of self.parent. This method is typically used by StrategizedProperty, which delegates it to LoaderStrategy.init_class_attribute() to perform final setup on the class-bound InstrumentedAttribute. Nr]rs rgpost_instrument_class$MapperProperty.post_instrument_classsrrfc g)z_Merge the attribute represented by this ``MapperProperty`` from source to destination object. Nr]) rsession source_state source_dict dest_state dest_dictload _recursive_resolve_conflict_maps rgmergeMapperProperty.mergerrfcbSURR[U5[USS54-$)Nz<%s at 0x%x; %s>rzno key) __class__r_idrrs rg__repr__MapperProperty.__repr__s4! NN # # tH D% *%   rf)rrrrrrrP rr?rr>rrErOptional[ORMAdapter]rrrrrr?rr>rrErrr Result[Any]rr)rrCrrr) rrtrInstanceState[Any]rr9rzSet[InstanceState[Any]]rz.Optional[Callable[[InstanceState[Any]], bool]]rzGIterator[Tuple[object, Mapper[Any], InstanceState[Any], _InstanceDict]])rrrrwrrrrrrNF)rzOptional[_AttributeOptions]rrwrrrr)rzInstrumentedAttribute[_T])rrGrr,rr9rr,rr9rrwrzDict[Any, object]rz#Dict[_IdentityKeyType[Any], object]rrr)r_r`rarbrrcr-ExtendedInternalTraversaldp_has_cache_key dp_stringrr{rcascade is_property_is_relationshiprrrrrrrrrrr rr r%rer]rfrgrrws:  I 855FFG 22<<=40 K #"C H! 6 ' O &   $ %  &          $  %      &  #     *CG "  0  @  0 ,:>/4464)-4  4( (552     ) #  '  !   &  C    rfrc\rSrSr%SrSrSrS\S'S\S'S \S 'SS S jjr\ RS!S j5r S"Sjr S#Sjr S$Sjr\ RS%Sj5rSS&Sjjr\ RS'Sj5r\ RS(Sj5r\S)Sj5r\S*Sj5r\S+Sj5r\"\R4\5r\"\R4\5r\"\R4\5r\R>(aS,Sjr S,Sjr!S-Sjr"S.Sjr#SS/Sjjr$SS/Sjjr%Sr&g )0PropComparatoria Defines SQL operations for ORM mapped attributes. SQLAlchemy allows for operators to be redefined at both the Core and ORM level. :class:`.PropComparator` is the base class of operator redefinition for ORM-level operations, including those of :class:`.ColumnProperty`, :class:`.Relationship`, and :class:`.Composite`. User-defined subclasses of :class:`.PropComparator` may be created. The built-in Python comparison and math operator methods, such as :meth:`.operators.ColumnOperators.__eq__`, :meth:`.operators.ColumnOperators.__lt__`, and :meth:`.operators.ColumnOperators.__add__`, can be overridden to provide new operator behavior. The custom :class:`.PropComparator` is passed to the :class:`.MapperProperty` instance via the ``comparator_factory`` argument. In each case, the appropriate subclass of :class:`.PropComparator` should be used:: # definition of custom PropComparator subclasses from sqlalchemy.orm.properties import ( ColumnProperty, Composite, Relationship, ) class MyColumnComparator(ColumnProperty.Comparator): def __eq__(self, other): return self.__clause_element__() == other class MyRelationshipComparator(Relationship.Comparator): def any(self, expression): "define the 'any' operation" # ... class MyCompositeComparator(Composite.Comparator): def __gt__(self, other): "redefine the 'greater than' operation" return sql.and_( *[ a > b for a, b in zip( self.__clause_element__().clauses, other.__composite_values__(), ) ] ) # application of custom PropComparator subclasses from sqlalchemy.orm import column_property, relationship, composite from sqlalchemy import Column, String class SomeMappedClass(Base): some_column = column_property( Column("some_column", String), comparator_factory=MyColumnComparator, ) some_relationship = relationship( SomeOtherClass, comparator_factory=MyRelationshipComparator ) some_composite = composite( Column("a", String), Column("b", String), comparator_factory=MyCompositeComparator, ) Note that for column-level operator redefinition, it's usually simpler to define the operators at the Core level, using the :attr:`.TypeEngine.comparator_factory` attribute. See :ref:`types_operators` for more detail. .. seealso:: :class:`.ColumnProperty.Comparator` :class:`.Relationship.Comparator` :class:`.Composite.Comparator` :class:`.ColumnOperators` :ref:`types_operators` :attr:`.TypeEngine.comparator_factory` prop _parententity_adapt_to_entityorm_prop_comparator_InternalEntityType[Any]r:Optional[AliasedInsp[Any]]r;z,RODescriptorReference[MapperProperty[_T_co]]r9Nc<XlU=(d UUlX0lgrr8)rr9 parentmapperadapt_to_entitys rgrPropComparator.__init__s  ,<  /rfcUR$)zReturn the :class:`.MapperProperty` associated with this :class:`.PropComparator`. Return values here will commonly be instances of :class:`.ColumnProperty` or :class:`.Relationship`. )r9rs rgrPropComparator.propertysyyrfc[SU-5e)Nz%rrrs rg__clause_element__!PropComparator.__clause_element__s!$+..rfc<[SUR55U4/$)zReceive a SQL expression that represents a value in the SET clause of an UPDATE statement. Return a tuple that can be passed to a :class:`_expression.Update` construct. rO)rrF)rvalues rg_bulk_update_tuples"PropComparator._bulk_update_tupless#*D,C,C,EFNOOrfcPURURURU5$)zzReturn a copy of this PropComparator which will use the given :class:`.AliasedInsp` to produce corresponding expressions. )r#r9r:)rrAs rgrAPropComparator.adapt_to_entity+s! ~~dii););_MMrfc.URR$)zRlegacy; this is renamed to _parententity to be compatible with QueryableAttribute.)r:rrs rg _parentmapperPropComparator._parentmapper3s!!(((rfc PURRR"U40UD6$r)r9r_criterion_existsr criterionrs rgrR PropComparator._criterion_exists9s$ yy##55iJ6JJrfcJURcgURR$)zbProduce a callable that adapts column expressions to suit an aliased version of this comparator. N)r;_orm_adapt_elementrs rgrPropComparator.adapter@s%  (((;; ;rfc.URR$r)r9rrs rgrPropComparator.infoKsyy~~rfc (UR"U40UD6$r)any)abrs rg_any_opPropComparator._any_opOsuuQ!&!!rfc (UR"U40UD6$r)has)leftotherrs rg_has_opPropComparator._has_opSsxx(((rfc$URU5$r)of_type)r]rs rg _of_type_opPropComparator._of_type_opWsyy  rfcgrr]roprdrs rgoperatePropComparator.operatea!$rfc grr]rls rgreverse_operatePropComparator.reverse_operateerprfcBUR[RU5$)a5Redefine this object in terms of a polymorphic subclass, :func:`_orm.with_polymorphic` construct, or :func:`_orm.aliased` construct. Returns a new PropComparator from which further criterion can be evaluated. e.g.:: query.join(Company.employees.of_type(Engineer)).filter( Engineer.name == "foo" ) :param \class_: a class or mapper indicating that criterion will be against this specific subclass. .. seealso:: :ref:`orm_queryguide_joining_relationships_aliased` - in the :ref:`queryguide_toplevel` :ref:`inheritance_of_type` )rnr7 of_type_op)rrs rgrhPropComparator.of_typeis4||N55v>>rfcDUR"[R/UQ76$)aAdd additional criteria to the ON clause that's represented by this relationship attribute. E.g.:: stmt = select(User).join( User.addresses.and_(Address.email_address != "foo") ) stmt = select(User).options( joinedload(User.addresses.and_(Address.email_address != "foo")) ) .. versionadded:: 1.4 .. seealso:: :ref:`orm_queryguide_join_on_augmented` :ref:`loader_option_criteria` :func:`.with_loader_criteria` )rnr+and_)rcriterias rgrxPropComparator.and_s8||INN6X66rfc FUR"[RU40UD6$)aReturn a SQL expression representing true if this element references a member which meets the given criterion. The usual implementation of ``any()`` is :meth:`.Relationship.Comparator.any`. :param criterion: an optional ClauseElement formulated against the member class' table or attributes. :param \**kwargs: key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values. )rnr7any_oprSs rgr\PropComparator.any (||N119GGGrfc FUR"[RU40UD6$)aReturn a SQL expression representing true if this element references a member which meets the given criterion. The usual implementation of ``has()`` is :meth:`.Relationship.Comparator.has`. :param criterion: an optional ClauseElement formulated against the member class' table or attributes. :param \**kwargs: key/value pairs corresponding to member class attribute names which will be compared via equality to the corresponding values. )rnr7has_oprSs rgrbPropComparator.hasr~rf)r;r:r9r)r9zMapperProperty[_T]r@r=rAr>)rzMapperProperty[_T_co])rzroles.ColumnsClauseRole)rIrrz(Sequence[Tuple[_DMLColumnArgument, Any]])rAzAliasedInsp[Any]rPropComparator[_T_co])rr)rT)Optional[_ColumnExpressionArgument[bool]]rrrColumnElement[Any])rzOptional[_ORMAdapterProto]r')r]rr^rrrrr)rcrrdrrrrr)r]rrrrr)rmrQrdrrrrr)rz_EntityType[Any]rr)ryz_ColumnExpressionArgument[bool]rzPropComparator[bool])rTrrrrzColumnElement[bool])'r_r`rarbrrc__visit_name__r{rr*non_memoized_propertyrrFrJrAro_non_memoized_propertyrOrRrr staticmethodr_rerirr+rQr|rrutypingrrnrrrhrxr\rbrer]rfrgr7r7sV^@ %  % %" %+. %:= %  %?8787 7@@DH<HH  H0@DH<HH  HHrfr7c:\rSrSr%SrSrSrS\S'S\S'S \S 'SS jrSS jr SS jr SSjr SSjr SSjr SSjrS Sjr\R""\5rS\S'\S!Sj5r\S"Sj5rSrg)#StrategizedPropertyia`A MapperProperty which uses selectable strategies to affect loading behavior. There is a single strategy selected by default. Alternate strategies can be selected at Query time through the usage of ``StrategizedOption`` objects via the Query.options() method. The mechanics of StrategizedProperty are used for every Query invocation for every mapped attribute participating in that Query, to determine first how the attribute will be rendered in SQL and secondly how the attribute will retrieve a value from a result row and apply it to a mapped object. The routines here are very performance-critical. ) _strategiesstrategy_wildcard_token_default_path_loader_key strategy_keyTz ClassVar[str]strategy_wildcard_key _StrategyKeyrz"Dict[_StrategyKey, LoaderStrategy]rcBURS[R34$)N:)rr_WILDCARD_TOKENrs rg_memoized_attr__wildcard_token2StrategizedProperty._memoized_attr__wildcard_tokens())*!M,I,I+J K  rfcFSURS[R344$)Nloaderr)rr_DEFAULT_TOKENrs rg'_memoized_attr__default_path_loader_key;StrategizedProperty._memoized_attr__default_path_loader_keys0 **+1]-I-I,J K M  rfcSnX nURURUR4H$nXQR;dMURUn U$ U$r) _loader_key_wildcard_path_loader_keyr attributes)rrrr search_pathpath_keys rg_get_context_loader'StrategizedProperty._get_context_loadersh(,j  # #  1 1  0 0 H ---))(3 !  rfcURU$![a Of=fUR"U/UQ76nU"X5=URU'nU$r)rKeyError_strategy_lookup)rrrrs rg _get_strategy!StrategizedProperty._get_strategysa ##C( (   ##D/3/,/t>9s  c URX5nU(a-UR(aURUR5nO URnUR"XX6U40UD6 gr)rrr setup_query)rrrrrrrstrats rgrStrategizedProperty.setup%sW))'8 foo&&v7EMME  4 SUR;a/Ul[[TR 555nUTR TU'URR U5 U$)N_strategy_keys)__dict__rtuplesorteditemsrappend)dec_clsrrrs rgdecorate2StrategizedProperty.strategy_for..decorateas^ w'7'77)+&rxxz*+C,3C   $S )  " " ) )# .Nrf)rrXrrXr])rrrs`` rg strategy_for StrategizedProperty.strategy_for_s  rfcURR URHJnX0R;dM[(a[ U[ 5(deURUnXBs $ URR5HupVX&;dM UnXbn O SnSn[R"UUUUU5e![a Mf=fr) r_with_polymorphic_mappers__mro__rr issubclassrrrorm_excLoaderStrategyException) rrequesting_propertyrprop_cls strategies property_typestratsintended_property_typeactual_strategys rgr$StrategizedProperty._strategy_lookupms ""<< H... =%h???? 00: %?* $&)%8%8%>%>%@ !M})6&"(+ &A &* ""O--   "      s)B?? C  C )rrN)rz Tuple[str])rzTuple[str, Tuple[str]])rr?rrErOptional[_LoadElement])rrrLoaderStrategyr(r*r/r-)rrrzCallable[[_TLS], _TLS])rMapperProperty[Any]rrrrY)r_r`rarbrrc inherit_cacher{rrrrrrr r collections defaultdictdictrrrrrer]rfrgrrsV IM((33   &.D 6    $ %  &      "   $ %      & #   4>7 %&   "5 =@   rfrcP\rSrSrSrSrSrSrSrSr Sr Sr Sr SSjr Srg) ORMOptioniaBase class for option objects that are passed to ORM queries. These options may be consumed by :meth:`.Query.options`, :meth:`.Select.options`, or in a more general sense by any :meth:`.Executable.options` method. They are interpreted at statement compile time or execution time in modern use. The deprecated :class:`.MapperOption` is consumed at ORM query construction time. .. versionadded:: 1.4 r]FcUbU$U$)aadapt this option to the "uncached" version of itself in a loader strategy context. given "self" which is an option from a cached query, as well as the corresponding option from the uncached version of the same query, return the option we should use in a new query, in the context of a loader strategy being asked to load related rows on behalf of that cached query, which is assumed to be building a new query based on entities passed to us from the cached query. Currently this routine chooses between "self" and "uncached" without manufacturing anything new. If the option is itself a loader strategy option which has a path, that path needs to match to the entities being passed to us by the cached query, so the :class:`_orm.Load` subclass overrides this to return "self". For all other options, we return the uncached form which may have changing state, such as a with_loader_criteria() option which will very often have new state. This routine could in the future involve generating a new option based on both inputs if use cases arise, such as if with_loader_criteria() needed to match up to ``AliasedClass`` instances given in the parent query. However, longer term it might be better to restructure things such that ``AliasedClass`` entities are always matched up on their cache key, instead of identity, in things like paths and such, so that this whole issue of "the uncached option does not match the entities" goes away. However this would make ``PathRegistry`` more complicated and difficult to debug as well as potentially less performant in that it would be hashing enormous cache keys rather than a simple AliasedInsp. UNLESS, we could get cache keys overall to be reliably hashed into something like an md5 key. .. versionadded:: 1.4.41 r])rr uncached_opts rg'_adapt_cached_option_to_uncached_option1ORMOption._adapt_cached_option_to_uncached_optionsN  # KrfN)rr@rrrr)r_r`rarbrrc_is_legacy_optionpropagate_to_loaders_is_core_is_user_defined_is_compile_state_is_criteria_option_is_strategy_optionrrer]rfrgrrs[ I  H*#*3<* *rfrc@\rSrSrSrSrSrSSjrS SjrSr g) CompileStateOptioniabase for :class:`.ORMOption` classes that affect the compilation of a SQL query and therefore need to be part of the cache key. .. note:: :class:`.CompileStateOption` is generally non-public and should not be used as a base class for user-defined options; instead, use :class:`.UserDefinedOption`, which is easier to use as it does not interact with ORM compilation internals or caching. :class:`.CompileStateOption` defines an internal attribute ``_is_compile_state=True`` which has the effect of the ORM compilation routines for SELECT and other statements will call upon these options when a SQL string is being compiled. As such, these classes implement :class:`.HasCacheKey` and need to provide robust ``_cache_key_traversal`` structures. The :class:`.CompileStateOption` class is used to implement the ORM :class:`.LoaderOption` and :class:`.CriteriaOption` classes. .. versionadded:: 1.4.28 r]Tcg)zApply a modification to a given :class:`.ORMCompileState`. This method is part of the implementation of a particular :class:`.CompileStateOption` and is only invoked internally when an ORM query is compiled. Nr])r compile_states rgprocess_compile_state(CompileStateOption.process_compile_staterrfcg)a9Apply a modification to a given :class:`.ORMCompileState`, given entities that were replaced by with_only_columns() or with_entities(). This method is part of the implementation of a particular :class:`.CompileStateOption` and is only invoked internally when an ORM query is compiled. .. versionadded:: 1.4.19 Nr]rrmapper_entitiess rg'process_compile_state_replaced_entities:CompileStateOption.process_compile_state_replaced_entitiesrrfN)rr?rrrr?rzSequence[_MapperEntity]rr) r_r`rarbrrcrrrrer]rfrgrrs:.I  & 1    rfrc2\rSrSrSrSrSSjrSrg) LoaderOptioniz`Describe a loader modification to an ORM statement at compilation time. .. versionadded:: 1.4 r]c&URU5 gr)rrs rgr4LoaderOption.process_compile_state_replaced_entitiess ""=1rfNr)r_r`rarbrrcrrer]rfrgrrs/ I2&212  2rfrc*\rSrSrSrSrSrSSjrSrg)CriteriaOptioni'zhDescribe a WHERE criteria modification to an ORM statement at compilation time. .. versionadded:: 1.4 r]Tcg)zOupdate additional entity criteria options in the given attributes dictionary. Nr])rrs rgget_global_criteria"CriteriaOption.get_global_criteria3rrfN)rzDict[str, Any]rr) r_r`rarbrrcrrrer]rfrgrr'sI rfrc8\rSrSrSrSrSrSrSrSS Sjjr Sr g) UserDefinedOptioni:zvBase class for a user-defined option that can be consumed from the :meth:`.SessionEvents.do_orm_execute` event hook. payloadFTNcXlgrr)rrs rgrUserDefinedOption.__init__Ms rfr)rr) r_r`rarbrrcrrrrrer]rfrgrr:s/ I  rfrz1.4aKThe :class:`.MapperOption class is deprecated and will be removed in a future release. For modifications to queries on a per-execution basis, use the :class:`.UserDefinedOption` class to establish state within a :class:`.Query` or other Core statement, then use the :meth:`.SessionEvents.before_orm_execute` hook to consume them.) constructorc:\rSrSrSrSrSrSrS SjrS Sjr Sr g) MapperOptioniQz"Describe a modification to a Queryr]TFcg)z8Apply a modification to the given :class:`_query.Query`.Nr]rquerys rg process_queryMapperOption.process_queryirrfc&URU5 g)a?same as process_query(), except that this option may not apply to the given query. This is typically applied during a lazy load or scalar refresh operation to propagate options stated in the original Query to the new Query being used for the load. It occurs for those options that specify propagate_to_loaders=True. N)r rs rgprocess_query_conditionally(MapperOption.process_query_conditionallyls 5!rfN)rz Query[Any]rr) r_r`rarbrrcrrr r rer]rfrgrrQs(-I  G "rfrc\rSrSr%SrSrS\S'S SjrSSjrSSjr SS jr SS jr S r g )rizaDescribe the loading behavior of a StrategizedProperty object. The ``LoaderStrategy`` interacts with the querying process in three ways: * it controls the configuration of the ``InstrumentedAttribute`` placed on a class to handle the behavior of the attribute. this may involve setting up class-level callable functions to fire off a select operation when the attribute is first accessed (i.e. a lazy load) * it processes the ``QueryContext`` at statement construction time, where it can modify the SQL statement that is being produced. For example, simple column attributes will add their represented column to the list of selected columns, a joined eager loader may establish join clauses to add to the statement. * It produces "row processor" functions at result fetching time. These "row processor" functions populate a particular attribute on a particular mapped instance. )parent_propertyis_class_levelrrr strategy_optszClassVar[List[_StrategyKey]]rcXlSUlURRUlURRUlX l[ U5Ulgr.)rrrrrrr)rrrs rgrLoaderStrategy.__init__sK &#**11 ''++(!,/rfcgrr]rs rgr#LoaderStrategy.init_class_attributes rfc g)zEstablish column and other state for a given QueryContext. This method fulfills the contract specified by MapperProperty.setup(). StrategizedProperty delegates its setup() method directly to this method. Nr])rrrrloadoptrrs rgrLoaderStrategy.setup_queryrrfc g)zEstablish row processing functions for a given QueryContext. This method fulfills the contract specified by MapperProperty.create_row_processor(). StrategizedProperty delegates its create_row_processor() method directly to this method. Nr]) rrrrrrrrrs rgr#LoaderStrategy.create_row_processorrrfc,[UR5$r)rtrrs rg__str__LoaderStrategy.__str__s4''((rf)rrrrrrN)rrrrr-)rr?rr>rrErrrr)rrrr)rr?rr>rrErrrrrr+rr)rrCrrr) r_r`rarbrrcr{rrrrrrer]rfrgrrzs.I100)09E0  & $ %  (  &     $   $ %  (     & #   *)rfr)r __future__rrrrrrrrrr r r r r rrrrrrrrrrrbaserrrrrrrr r!r"r#r$r%r&r(rr)r*sqlr+r,r-sql.baser.r/ sql.cache_keyr0 sql.operatorsr1 sql.schemar2 sql.type_apir3r4 util.typingr5r6_typingr7r8r9r:r;rr<r=rr>r?r@decl_apirA decl_baserBloadingrCrrDrErrFrrGrrHstrategy_optionsrIrJrK engine.resultrL sql._typingrMrNrOrPrQ sql.visitorsrRrSrrTrVrX StatementRoler[ColumnsClauseRoleTypedColumnsClauseRolerirlStrictFromClauseRolerorrr}rrrrrr_self_inspects MemoizedSlotsrr7rrrrrrdeprecated_clsrrr]rfrgr7se #  6.&&2:*("&.(@"''+%"/# $)&,)1&(%&1'5 $.! &740',51S#X  Tsd3v34u**K U99"=K0!5b!90 I22I 292) ) Xi% i%X/ MM MM MM MM MM MM MM'8  MM MM MM MM MM MM'###.$&(8(<$< _ R _ _ D  rH%e,genorHrHj | .,| ~M M`4 i4 n2%2" ' & . F  "9" ">X)X)rf