o gnk@sdZddlmZddlmZddlZddlZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z dd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ejrddlm$Z$ddlm%Z%ddlm&Z&dd l'm(Z(dd!l)m*Z*dd"l+m,Z,dd#l-m.Z.dd$l/m0Z0dd%l1m2Z2dd&lm3Z3dd'l4m5Z5dd(l6m7Z7dd)l6m8Z8dd*lm9Z9dd+l:m;Z;ed,ed-Zd-Z?Gd2d3d3eZ@eAe@\ZBZCZDZEZFeFZGGd4d5d5eZHeHjIJ\ZKZLZMZNZOZPZQZRZSZTZUZVZWZXZYZZZ[Z\d6Z]d7Z^Gd8d9d9eZ_eAe_\Z`ZaZbZcGd:d;d;eZdeAed\ZeZfZgGdd?d?ehZiejeGgZkejdeGeBgZlejdgZmend@ZoendAZpendBZqedCedDefd-ZredEZsddJdKZterddOdPZue ddSdTZve ddWdTZvddXdTZvdd[d\Zwdd_d`ZxndadPZudbdTZveye^ZweydcZxddedfZzddidjZ{ddkdlZ|ddndoZ}ddpdqZ~ddsdtZddvdwZee>ddydzZdd}d~ZdddZdddZdddZe dddZer1dddZnedZ ddddZdddZddddZGdddZGdddeZGdddee=e!ZGddde e=e!ZGddde e=e!ZGdddee=ee=e!ZGdddee=ee=ee=ejZGddde e=e!ZGdddee=ee=ZGdddee=ZGdddee=ZdS)z=Constants and rudimental functions used throughout the ORM. ) annotations)EnumN)Any)Callable)Dict)Generic) no_type_check)Optional)overload)Tuple)Type) TYPE_CHECKING)TypeVar)Union)exc)insp_is_mapper) inspection)util)roles)SQLColumnExpression)SQLCoreOperations) FastIntFlag) TypingOnly)Literal) _EntityType)_ExternalEntityType)_InternalEntityType)InstrumentedAttribute) AppenderQuery) ClassManager)PropComparator)Mapper) InstanceState) AliasedClass)WriteOnlyCollection)_ColumnExpressionArgument) _InfoType) ColumnElement) OperatorType_T)bound_T_coT)r, covariant_Oc@s.eZdZdZ dZ dZ dZ dZ eZdS)LoaderCallableStatusrrrN) __name__ __module__ __qualname__PASSIVE_NO_RESULTPASSIVE_CLASS_MISMATCH ATTR_WAS_SET ATTR_EMPTYNO_VALUE NEVER_SETr<r<U/var/www/html/ecg_monitoring/venv/lib/python3.10/site-packages/sqlalchemy/orm/base.pyr0Asr0c@seZdZdZdZ dZ dZ dZ dZ dZ dZ d Z d Z d Z d Zee BeBeBeBZ eeAZ eeAZ eeAZ eeAZ ee AZ ee BZd S) PassiveFlagz;Bitflag interface that passes options onto loader callablesrrrr2 @iN)r3r4r5__doc__ NO_CHANGE CALLABLES_OKSQL_OKRELATED_OBJECT_OKINIT_OKNON_PERSISTENT_OKLOAD_AGAINST_COMMITTED NO_AUTOFLUSHNO_RAISEDEFERRED_HISTORY_LOADINCLUDE_PENDING_MUTATIONS PASSIVE_OFFPASSIVE_RETURN_NO_VALUEPASSIVE_NO_INITIALIZEPASSIVE_NO_FETCHPASSIVE_NO_FETCH_RELATEDPASSIVE_ONLY_PERSISTENT PASSIVE_MERGEr<r<r<r=r>psLr>_sa_class_manager_sa_instance_statec@seZdZdZdZdZdZdS)EventConstantsrrr1r2N)r3r4r5 EXT_CONTINUEEXT_STOPEXT_SKIPNO_KEYr<r<r<r=rZs rZc@s eZdZdZdZ dZ dZdS)RelationshipDirectionzenumeration which indicates the 'direction' of a :class:`_orm.RelationshipProperty`. :class:`.RelationshipDirection` is accessible from the :attr:`_orm.Relationship.direction` attribute of :class:`_orm.RelationshipProperty`. rrr1N)r3r4r5rE ONETOMANY MANYTOONE MANYTOMANYr<r<r<r=r_s r_c@eZdZdZdS)InspectionAttrExtensionTypezXSymbols indicating the type of extension that a :class:`.InspectionAttr` is part of.N)r3r4r5rEr<r<r<r=rd srdc@rc) NotExtension not_extensionN)r3r4r5 NOT_EXTENSIONr<r<r<r=resreSET_DEFERRED_EXPIREDDEFER_FOR_STATERAISE_FOR_STATE_F._Self assertionsrreturnCallable[[_F], _F]cstjd fd d }|S) Nfnrkselfrlargsrkwrncs0D]}|||jq||g|Ri||SN)r3)rprqrrrs assertionrmr<r=generate.sz_assertions..generate) rprkrqrlrrrrsrrnrl)r decorator)rmrwr<rvr= _assertions+sryclsType[_O]ClassManager[_O]cCdSrtr<rzr<r<r=manager_of_class:rAliasedClass[Any]NonecCr}rtr<r~r<r<r=opt_manager_of_class<r_ExternalEntityType[_O]Optional[ClassManager[_O]]cCr}rtr<r~r<r<r=r?cCr}rtr<r~r<r<r=rDinstanceInstanceState[_O]cCr}rtr<rr<r<r=instance_stateHrrobjectDict[str, Any]cCr}rtr<rr<r<r= instance_dictJrrc Cs:z|jtWSty}z t|d||d}~ww)Nz2Can't locate an instrumentation manager for class )__dict__DEFAULT_MANAGER_ATTRKeyErrorrUnmappedClassError)rzker<r<r=rPs  cCs |jtSrt)rgetrr~r<r<r=rXs rstrcCs tt|S)z'Return a string describing an instance.) state_strrrr<r<r= instance_str`s rstateInstanceState[Any]cCs$|durdSd|jjt|fS)z=Return a string describing an instance via its InstanceState.Nrz <%s at 0x%x>)class_r3idobjrr<r<r=rfsrcCs|durdSd|jjfS)zNReturn a string describing an instance's class via its InstanceState. Nrz<%s>)rr3rr<r<r=state_class_strosr attributecCt|d|SN.)r)rrr<r<r= attribute_strzrcCrr)r)rrr<r<r=state_attribute_str~rr Mapper[_T]cCs t|jS)aGiven an object, return the primary Mapper associated with the object instance. Raises :class:`sqlalchemy.orm.exc.UnmappedInstanceError` if no mapping is configured. This function is available via the inspection system as:: inspect(instance).mapper Using the inspection system will raise :class:`sqlalchemy.exc.NoInspectionAvailable` if the instance is not part of a mapping. ) object_statemapperrr<r<r= object_mappers rInstanceState[_T]cCst|}|dur t||S)aGiven an object, return the :class:`.InstanceState` associated with the object. Raises :class:`sqlalchemy.orm.exc.UnmappedInstanceError` if no mapping is configured. Equivalent functionality is available via the :func:`_sa.inspect` function as:: inspect(instance) Using the inspection system will raise :class:`sqlalchemy.exc.NoInspectionAvailable` if the instance is not part of a mapping. N)_inspect_mapped_objectrUnmappedInstanceError)rrr<r<r=rs rOptional[InstanceState[_T]]c Cs*zt|WStjftjyYdSwrt)rrrNO_STATErr<r<r=rs  rclass_or_mapperUnion[Mapper[_T], Type[_T]]cCs2t|d}|dur |jSt|tsJt|)NF)rinspectr isinstancetyperr)rinspr<r<r=_class_to_mappers  rentity(Union[Type[_T], _InternalEntityType[_T]]Optional[Mapper[_T]]cCst|d}|dur |jSdS)z`Return the :class:`_orm.Mapper` for the given class or None if the class is not mapped. FN)rrrrrr<r<r=_mapper_or_nones rboolcCs(t|d}|duo|j o|jp|jS)zlReturn True if the given object is a mapped class, :class:`_orm.Mapper`, or :class:`.AliasedClass`. FN)rris_clause_element is_mapperis_aliased_classrr<r<r=_is_mapped_classs  rcCs t|d}|duot|ddS)NFr)rrgetattrrr<r<r=_is_aliased_classs r_EntityType[Any]keyc Cst|}|jr|}|j}n|jr|j}|}nt|dr#|jj}}n|}zt ||WSt yA}z t d||f|d}~ww)zReturn a class attribute given an entity and string name. May return :class:`.InstrumentedAttribute` or user-defined attribute. rz Entity '%s' has no property '%s'N) rr is_selectablecrrhasattrrrrAttributeErrorsa_excInvalidRequestError)rrr descriptionerrr<r<r=_entity_descriptors(    r Mapper[_O]cCr}rtr<rr<r<r= _state_mapperrrzmanager.mapperFr configureOptional[Mapper[_O]]cCsNzt|}|dus |jsWdS|j}Wn tjyYdSw|r%||Srt)r is_mappedrrr_check_configure)rr class_managerrr<r<r=_inspect_mapped_classs rargUnion[Mapper[_O], Type[_O]]cCs*tj|dd}t|r |Std|)NF)raiseerrz%Mapper or mapped class expected, got )rrrr ArgumentError)rrr<r<r=_parse_mapper_argumentsrcCs<t||d}|durt|tstd|ft||S)aGiven a class, return the primary :class:`_orm.Mapper` associated with the key. Raises :exc:`.UnmappedClassError` if no mapping is configured on the given class, or :exc:`.ArgumentError` if a non-class object is passed. Equivalent functionality is available via the :func:`_sa.inspect` function as:: inspect(some_mapped_class) Using the inspection system will raise :class:`sqlalchemy.exc.NoInspectionAvailable` if the class is not mapped. )rNz Class object expected, got '%r'.)rrrrrrr)rrrr<r<r= class_mappers   rc@sbeZdZUdZdZded<dZ dZ dZ dZ dZ dZ dZ dZ dZ ejZded<dS) InspectionAttraMA base class applied to all ORM objects and attributes that are related to things that can be returned by the :func:`_sa.inspect` function. The attributes defined here allow the usage of simple boolean checks to test basic facts about the object returned. While the boolean checks here are basically the same as using the Python isinstance() function, the flags here can be used without the need to import all of these classes, and also such that the SQLAlchemy class system can change while leaving the flags here intact for forwards-compatibility. r<zTuple[str, ...] __slots__Frdextension_typeN)r3r4r5rEr__annotations__rr is_instancer is_bundle is_property is_attribute_is_internal_proxyrrergrr<r<r<r=r:s.  rc@s$eZdZdZdZejdddZdS) InspectionAttrInfoaAdds the ``.info`` attribute to :class:`.InspectionAttr`. The rationale for :class:`.InspectionAttr` vs. :class:`.InspectionAttrInfo` is that the former is compatible as a mixin for classes that specify ``__slots__``; this is essentially an implementation artifact. r<rnr(cCsiS)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<)rqr<r<r=infoszInspectionAttrInfo.infoN)rnr()r3r4r5rErrro_memoized_propertyrr<r<r<r=rs rc@sJeZdZdZejr#dddZdd d Z ddddZ ddddZ d Sd S)SQLORMOperationsr<rrrnPropComparator[_T_co]cCr}rtr<)rqrr<r<r=of_typerzSQLORMOperations.of_typecriteria_ColumnExpressionArgument[bool]PropComparator[bool]cGr}rtr<)rqrr<r<r=and_rzSQLORMOperations.and_N criterion)Optional[_ColumnExpressionArgument[bool]]kwargsrColumnElement[bool]cKr}rtr<rqrrr<r<r=anyzSQLORMOperations.anycKr}rtr<rr<r<r=hasrzSQLORMOperations.has)rrrnr)rrrnrrt)rrrrrnr) r3r4r5rtypingr rrrrr<r<r<r=rs   rc@sReZdZdZdZejr'edd d Zedd d Zeddd Zddd ZdSdS) ORMDescriptorz`Represent any Python descriptor that provides a SQL expression construct at the class level.r<rrowner Literal[None]rnORMDescriptor[_T_co]cCr}rtr<rqrrr<r<r=__get__rzORMDescriptor.__get__SQLCoreOperations[_T_co]cCr}rtr<rr<r<r=rrrr-cCr}rtr<rr<r<r=rr` form of :class:`_orm.Mapper` configuration, where used explicitly it drives the configuration of ORM attributes such as :func:`_orm.mapped_class` and :func:`_orm.relationship`. .. seealso:: :ref:`orm_explicit_declarative_base` :ref:`orm_declarative_table` .. tip:: The :class:`_orm.Mapped` class represents attributes that are handled directly by the :class:`_orm.Mapper` class. It does not include other Python descriptor classes that are provided as extensions, including :ref:`hybrids_toplevel` and the :ref:`associationproxy_toplevel`. While these systems still make use of ORM-specific superclasses and structures, they are not :term:`instrumented` by the :class:`_orm.Mapper` and instead provide their own functionality when they are accessed on a class. .. versionadded:: 1.4 r<rrrrrnInstrumentedAttribute[_T_co]cCr}rtr<rr<r<r=r*rzMapped.__get__rr-cCr}rtr<rr<r<r=r/rOptional[object]*Union[InstrumentedAttribute[_T_co], _T_co]cCr}rtr<rr<r<r=r2rarg1 Mapped[_T_co]cCr}rtr<)rzr r<r<r=_empty_constructor6rzMapped._empty_constructorvalue&Union[SQLCoreOperations[_T_co], _T_co]cCr}rtr<rqrr r<r<r=__set__9rzMapped.__set__cCr}rtr<)rqrr<r<r= __delete__=rzMapped.__delete__Nrrrrrnrr)rrrrrnr)r rrnr )rrr r rnr)rrrnr) r3r4r5rErrr r r classmethodr rrr<r<r<r=rs$     rc@r)_MappedAttributezVMixin for attributes which should be replaced by mapper-assigned attributes. r<Nrr<r<r<r=r@src@s,eZdZdZdZdd d ZeZdd d Zd S)_DeclarativeMappedzMixin for :class:`.MapperProperty` subclasses that allows them to be compatible with ORM-annotated declarative mappings. r<opr*otherrrrncOtSrtNotImplementedrqrrrr<r<r=operateWrz_DeclarativeMapped.operatecKrrtrrr<r<r=reverse_operate\rz"_DeclarativeMapped.reverse_operateN)rr*rrrrrnr)r3r4r5rErr__sa_operate__rr<r<r<r=rIs  rc@LeZdZdZdZer$edd d Zedd d Zddd ZdddZdSdS) DynamicMappedaRepresent the ORM mapped attribute type for a "dynamic" relationship. The :class:`_orm.DynamicMapped` type annotation may be used in an :ref:`Annotated Declarative Table ` mapping to indicate that the ``lazy="dynamic"`` loader strategy should be used for a particular :func:`_orm.relationship`. .. legacy:: The "dynamic" lazy loader strategy is the legacy form of what is now the "write_only" strategy described in the section :ref:`write_only_relationship`. E.g.:: class User(Base): __tablename__ = "user" id: Mapped[int] = mapped_column(primary_key=True) addresses: DynamicMapped[Address] = relationship( cascade="all,delete-orphan" ) See the section :ref:`dynamic_relationship` for background. .. versionadded:: 2.0 .. seealso:: :ref:`dynamic_relationship` - complete background :class:`.WriteOnlyMapped` - fully 2.0 style version r<rrrrrnrcCr}rtr<rr<r<r=rrzDynamicMapped.__get__rAppenderQuery[_T_co]cCr}rtr<rr<r<r=rrr9Union[InstrumentedAttribute[_T_co], AppenderQuery[_T_co]]cCr}rtr<rr<r<r=rrr typing.Collection[_T_co]cCr}rtr<rr<r<r=rrzDynamicMapped.__set__Nr)rrrrrnr )rrrrrnr!rrr r"rnr r3r4r5rErr r rrr<r<r<r=rbs    rc@r)WriteOnlyMappedadRepresent the ORM mapped attribute type for a "write only" relationship. The :class:`_orm.WriteOnlyMapped` type annotation may be used in an :ref:`Annotated Declarative Table ` mapping to indicate that the ``lazy="write_only"`` loader strategy should be used for a particular :func:`_orm.relationship`. E.g.:: class User(Base): __tablename__ = "user" id: Mapped[int] = mapped_column(primary_key=True) addresses: WriteOnlyMapped[Address] = relationship( cascade="all,delete-orphan" ) See the section :ref:`write_only_relationship` for background. .. versionadded:: 2.0 .. seealso:: :ref:`write_only_relationship` - complete background :class:`.DynamicMapped` - includes legacy :class:`_orm.Query` support r<rrrrrnrcCr}rtr<rr<r<r=rrzWriteOnlyMapped.__get__rWriteOnlyCollection[_T_co]cCr}rtr<rr<r<r=rrr?Union[InstrumentedAttribute[_T_co], WriteOnlyCollection[_T_co]]cCr}rtr<rr<r<r=rrr r"cCr}rtr<rr<r<r=rrzWriteOnlyMapped.__set__Nr)rrrrrnr&)rrrrrnr'r#r$r<r<r<r=r%s   r%)rmrrnro)rzr{rnr|)rzrrnr)rzrrnr)rr/rnr)rrrnr)rrrnr)rrrnr)rrrrrnr)rrrrrnr)rr+rnr)rr+rnr)rr+rnr)rrrnr)rrrnr)rrrnr)rrrrrnr)rrrnr)F)rr{rrrnr)rrrnr)T)rr{rrrnr)rE __future__renumroperatorrrrrrrr r r r r rrr_typingrrrrsqlr sql.elementsrrrutil.langhelpersr util.typingrrrr attributesrdynamicr instrumentationr! interfacesr"rr#rr$r% writeonlyr& sql._typingr'r(r) sql.operatorsr*r+r-rr/r0tupler6r7r8r9r:r;r> __members__valuesrFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVrWrDEFAULT_STATE_ATTRrZr[r\r]r^r_r`rarbrdre frozenset _never_set _none_set_none_only_setsymbol_SET_DEFERRED_EXPIRED_DEFER_FOR_STATE_RAISE_FOR_STATErkrlryrrrr attrgetterrrrrrrr _inspectsrrrrrrr dottedgetterrrrrrrrrrDDLConstraintColumnRolerrrrr%r<r<r<r=s&                                          *^ #                            L   D 8