o gu@sddlmZddlZddlZddlZddlZddlmZddl Z ddl m Z ddlmZddlmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddl m!Z!ddl m"Z"ddl#m$Z$ddl%m&Z&ddl%m'Z'ddl(m)Z)ej*de+dZ,ej*dej-ej.eej/ej.ej0ej.ej1fdZ2GdddeZ3d!ddZ4Gdd d Z5dS)") annotationsN)WeakKeyDictionary)abort) current_app)Flask)has_app_context)_QueryProperty) BindMixin) DefaultMeta)DefaultMetaNoName)Model) NameMixin) Pagination)SelectPagination)Query) _app_ctx_id)Session_Table_O)bound_FSA_MCTc@seZdZUded<dS) _FSAModel sa.MetaDatametadataN)__name__ __module__ __qualname____annotations__r r \/var/www/html/ecg_monitoring/venv/lib/python3.10/site-packages/flask_sqlalchemy/extension.pyr/s r model_classreturnKlist[t.Type[t.Union[sa_orm.DeclarativeBase, sa_orm.DeclarativeBaseNoMeta]]]cCsdd|jDS)NcSs"g|] }t|tjtjfr|qSr ) issubclasssa_ormDeclarativeBaseDeclarativeBaseNoMeta).0br r r! 6s z-_get_2x_declarative_bases..) __bases__)r"r r r!_get_2x_declarative_bases3sr-c @sxeZdZdZ dwddeedddddxddZdyddZdzddZd{d!d"Z d|d$d%Z d}d(d)Z d~d-d.Z dd0d1Z ddd3d4Zdd5d6Zdd8d9Zedd:d;Zedd=d>Zedd?d@Z dwddCdDZddEddKdLZddEddOdPZddEddQdRZddddddSdd\d]Zdd`daZdddcddZdddedfZdddgdhZddidjZddmdnZddpdqZ ddrdsZ!ddudvZ"dS) SQLAlchemya[Integrates SQLAlchemy with Flask. This handles setting up one or more engines, associating tables and models with specific engines, and cleaning up connections and sessions after each request. Only the engine configuration is specific to each application, other things like the model, table, metadata, and session are shared for all applications using that extension instance. Call :meth:`init_app` to configure the extension on an application. After creating the extension, create model classes by subclassing :attr:`Model`, and table classes with :attr:`Table`. These can be accessed before :meth:`init_app` is called, making it possible to define the models separately from the application. Accessing :attr:`session` and :attr:`engine` requires an active Flask application context. This includes methods like :meth:`create_all` which use the engine. This class also provides access to names in SQLAlchemy's ``sqlalchemy`` and ``sqlalchemy.orm`` modules. For example, you can use ``db.Column`` and ``db.relationship`` instead of importing ``sqlalchemy.Column`` and ``sqlalchemy.orm.relationship``. This can be convenient when defining models. :param app: Call :meth:`init_app` on this Flask application now. :param metadata: Use this as the default :class:`sqlalchemy.schema.MetaData`. Useful for setting a naming convention. :param session_options: Arguments used by :attr:`session` to create each session instance. A ``scopefunc`` key will be passed to the scoped session, not the session instance. See :class:`sqlalchemy.orm.sessionmaker` for a list of arguments. :param query_class: Use this as the default query class for models and dynamic relationships. The query interface is considered legacy in SQLAlchemy. :param model_class: Use this as the model base class when creating the declarative model class :attr:`Model`. Can also be a fully created declarative model class for further customization. :param engine_options: Default arguments used when creating every engine. These are lower precedence than application config. See :func:`sqlalchemy.create_engine` for a list of arguments. :param add_models_to_shell: Add the ``db`` instance and all model classes to ``flask shell``. .. versionchanged:: 3.1.0 The ``metadata`` parameter can still be used with SQLAlchemy 1.x classes, but is ignored when using SQLAlchemy 2.x style of declarative classes. Instead, specify metadata on your Base class. .. versionchanged:: 3.1.0 Added the ``disable_autonaming`` parameter. .. versionchanged:: 3.1.0 Changed ``model_class`` parameter to accepta SQLAlchemy 2.x declarative base subclass. .. versionchanged:: 3.0 An active Flask application context is always required to access ``session`` and ``engine``. .. versionchanged:: 3.0 Separate ``metadata`` are used for each bind key. .. versionchanged:: 3.0 The ``engine_options`` parameter is applied as defaults before per-engine configuration. .. versionchanged:: 3.0 The session class can be customized in ``session_options``. .. versionchanged:: 3.0 Added the ``add_models_to_shell`` parameter. .. versionchanged:: 3.0 Engines are created when calling ``init_app`` rather than the first time they are accessed. .. versionchanged:: 3.0 All parameters except ``app`` are keyword-only. .. versionchanged:: 3.0 The extension instance is stored directly as ``app.extensions["sqlalchemy"]``. .. versionchanged:: 3.0 Setup methods are renamed with a leading underscore. They are considered internal interfaces which may change at any time. .. versionchanged:: 3.0 Removed the ``use_native_unicode`` parameter and config. .. versionchanged:: 2.4 Added the ``engine_options`` parameter. .. versionchanged:: 2.1 Added the ``metadata``, ``query_class``, and ``model_class`` parameters. .. versionchanged:: 2.1 Use the same query class across ``session``, ``Model.query`` and ``Query``. .. versionchanged:: 0.16 ``scopefunc`` is accepted in ``session_options``. .. versionchanged:: 0.10 Added the ``session_options`` parameter. NTF)rsession_options query_classr"engine_optionsadd_models_to_shelldisable_autonamingapp Flask | Nonersa.MetaData | Noner/dict[str, t.Any] | Noner0 type[Query]r"rr1r2boolr3c Cs|duri}||_ |||_ i|_ |dur4tt|dkr*tjdtddn d|j d<||jd<| |_ |j ||d|_ |durIi}||_|t|_||_|dur`||dSdS)NrzWhen using SQLAlchemy 2.x style of declarative classes, the `metadata` should be an attribute of the base class.The metadata passed into SQLAlchemy() is ignored. stacklevelbind_key)r3)r_make_scoped_sessionsession metadataslenr-warningswarnDeprecationWarninginfo_make_table_classTable_make_declarative_baser _engine_optionsr _app_engines_add_models_to_shellinit_app) selfr4rr/r0r"r1r2r3r r r!__init__s@       zSQLAlchemy.__init__r#strcCsbts dt|jdSt|jd|jj}t|jdkr+|dt|jd}d|dS)N<> rz +)rtyperengineurlrAengines)rMmessager r r!__repr__s  zSQLAlchemy.__repr__rNonecCsd|jvr td||jd<||j|jr"ddlm}|||j dd}|j }| |j di|j dd }|j d i}i}| D]"\}} |j ||<t| ttjjfrg| ||d <qL|| | qL|durw||d <d |vr| di ||std |j |i} | r| D]} | q| | D]$\}} ||| d || d||| |||| || |<q|j dd rddlm} | D]} | | q|j dd rddlm}||jdSdS)aNInitialize a Flask application for use with this extension instance. This must be called before accessing the database engine or session with the app. This sets default configuration values, then configures the extension on the application and creates the engines for each bind key. Therefore, this must be called after the application has been configured. Changes to application config after this call will not be reflected. The following keys from ``app.config`` are used: - :data:`.SQLALCHEMY_DATABASE_URI` - :data:`.SQLALCHEMY_ENGINE_OPTIONS` - :data:`.SQLALCHEMY_ECHO` - :data:`.SQLALCHEMY_BINDS` - :data:`.SQLALCHEMY_RECORD_QUERIES` - :data:`.SQLALCHEMY_TRACK_MODIFICATIONS` :param app: The Flask application to initialize. sqlalchemyzlA 'SQLAlchemy' instance has already been registered on this Flask app. Import and use that instance instead.r)r2SQLALCHEMY_DATABASE_URINSQLALCHEMY_ENGINE_OPTIONSSQLALCHEMY_ECHOFSQLALCHEMY_BINDSrUzCEither 'SQLALCHEMY_DATABASE_URI' or 'SQLALCHEMY_BINDS' must be set.echo echo_poolSQLALCHEMY_RECORD_QUERIES)record_queriesSQLALCHEMY_TRACK_MODIFICATIONS)track_modifications) extensions RuntimeErrorteardown_appcontext_teardown_sessionrKclir2shell_context_processorconfig setdefaultrIcopyupdateitems isinstancerOsarTURLrJvaluesdisposeclear_make_metadata_apply_driver_defaults _make_enginerb_listenrdr?)rMr4r2 basic_uribasic_engine_optionsr_ config_bindsr1keyvaluerVrToptionsrbrdr r r!rL#sh                  zSQLAlchemy.init_apprdict[str, t.Any]sa_orm.scoped_session[Session]cCs"|dt}||}t||S)aXCreate a :class:`sqlalchemy.orm.scoping.scoped_session` around the factory from :meth:`_make_session_factory`. The result is available as :attr:`session`. The scope function can be customized using the ``scopefunc`` key in the ``session_options`` parameter to the extension. By default it uses the current thread or greenlet id. This method is used for internal setup. Its signature may change at any time. :meta private: :param options: The ``session_options`` parameter from ``__init__``. Keyword arguments passed to the session factory. A ``scopefunc`` key is popped. .. versionchanged:: 3.0 The session is scoped to the current app context. .. versionchanged:: 3.0 Renamed from ``create_scoped_session``, this method is internal. scopefunc)popr_make_session_factoryr&scoped_session)rMrscopefactoryr r r!r>s   zSQLAlchemy._make_scoped_sessionsa_orm.sessionmaker[Session]cCs.|dt|d|jtjdd|i|S)aCreate the SQLAlchemy :class:`sqlalchemy.orm.sessionmaker` used by :meth:`_make_scoped_session`. To customize, pass the ``session_options`` parameter to :class:`SQLAlchemy`. To customize the session class, subclass :class:`.Session` and pass it as the ``class_`` key. This method is used for internal setup. Its signature may change at any time. :meta private: :param options: The ``session_options`` parameter from ``__init__``. Keyword arguments passed to the session factory. .. versionchanged:: 3.0 The session class can be customized. .. versionchanged:: 3.0 Renamed from ``create_session``, this method is internal. class_ query_clsdbNr )rlrrr& sessionmaker)rMrr r r!rs z SQLAlchemy._make_session_factoryexcBaseException | NonecCs|jdS)zuRemove the current session at the end of the request. :meta private: .. versionadded:: 3.0 N)r?remove)rMrr r r!rhszSQLAlchemy._teardown_sessionr= str | NonercCsN||jvr |j|S|dur|dj}nd}tj|d|id}||j|<|S)a$Get or create a :class:`sqlalchemy.schema.MetaData` for the given bind key. This method is used for internal setup. Its signature may change at any time. :meta private: :param bind_key: The name of the metadata being created. .. versionadded:: 3.0 Nr=)naming_conventionrE)r@rvrrqMetaData)rMr=rrr r r!rvs  zSQLAlchemy._make_metadata type[_Table]csGfdddt}|S)aLCreate a SQLAlchemy :class:`sqlalchemy.schema.Table` class that chooses a metadata automatically based on the ``bind_key``. The result is available as :attr:`Table`. This method is used for internal setup. Its signature may change at any time. :meta private: .. versionadded:: 3.0 cs&eZdZddd fd d ZZS) z+SQLAlchemy._make_table_class..TableN)r=argst.Anyr=rkwargsr#rGcsr|rt|dkrt|dtjrtj|g|Ri|S|}tj|g|d|g|ddRi|S)Nr:rr)rArprqrsuper__new__rv)clsr=rrr) __class__rMr r!rs  .z3SQLAlchemy._make_table_class..Table.__new__)rrr=rrrr#rG)rrrr __classcell__r rM)rr!rGsrGr)rMrGr rr!rFs  zSQLAlchemy._make_table_classt.Type[_FSAModel]cst|}t|dkrtd|jt|dkrFt|j|d<ttt g}|r-| tt dg||jRdt |difdd}nt|tjsa|d }|rUtnt}tj||d |d }n|}d |jvrud |jjd <|j|jd <n|jd |_|j|_t|_||_|S) aCreate a SQLAlchemy declarative model class. The result is available as :attr:`Model`. To customize, subclass :class:`.Model` and pass it as ``model_class`` to :class:`SQLAlchemy`. To customize at the metaclass level, pass an already created declarative model class as ``model_class``. This method is used for internal setup. Its signature may change at any time. :meta private: :param model_class: A model base class, or an already created declarative model class. :param disable_autonaming: Turns off automatic tablename generation in models. .. versionchanged:: 3.1.0 Added support for passing SQLAlchemy 2.x base class as model class. Added optional ``disable_autonaming`` parameter. .. versionchanged:: 3.0 Renamed with a leading underscore, this method is internal. .. versionchanged:: 2.3 ``model`` can be an already created declarative model class. rz>Only one declarative base can be passed to SQLAlchemy. Got: {}__fsa__FlaskSQLAlchemyBase metaclassrcs |SN)rn)nsbodyr r!(s z3SQLAlchemy._make_declarative_base..Nr )rrnamerr=)r-rA ValueErrorformatr,dict__dict__r rr rtypes new_classrSrpr&DeclarativeMetarvr r declarative_baser@rrErr0r queryr)rMr"r3declarative_bases mixin_classesmodelrrr rr!rHsB            z!SQLAlchemy._make_declarative_basecCs,tj|d}|jdvrj|jdus|jdvr-tjj|d<d|vr%i|d<d|dd<dS|jd d}|r>|jd d}n|j}t j |sht j |j d d t j |j |}|r^d |}|j|d|d<dSdS|jdrd|vs||dtjjur|ddd|jvr|ddi|d<dSdSdS)aApply driver-specific configuration to an engine. SQLite in-memory databases use ``StaticPool`` and disable ``check_same_thread``. File paths are relative to the app's :attr:`~flask.Flask.instance_path`, which is created if it doesn't exist. MySQL sets ``charset="utf8mb4"``, and ``pool_timeout`` defaults to 2 hours. This method is used for internal setup. Its signature may change at any time. :meta private: :param options: Arguments passed to the engine. :param app: The application that the engine configuration belongs to. .. versionchanged:: 3.0 SQLite paths are relative to ``app.instance_path``. It does not use ``NullPool`` if ``pool_size`` is 0. Driver-level URIs are supported. .. versionchanged:: 3.0 MySQL sets ``charset="utf8mb4". It does not set ``pool_size`` to 10. It does not set ``pool_recycle`` if not using a queue pool. .. versionchanged:: 3.0 Renamed from ``apply_driver_hacks``, this method is internal. It does not return anything. .. versionchanged:: 2.5 Returns ``(sa_url, options)``. rU>sqlite+pysqlitesqliteN>:memory:ry poolclass connect_argsFcheck_same_threaduriT)exist_okzfile:)databasemysql pool_class pool_recyclei charsetutf8mb4)rqrTmake_url drivernamerpool StaticPoolrgetospathisabsmakedirs instance_pathjoinset startswith QueuePoolrlupdate_query_dict)rMrr4rUis_uridb_strr r r!rw@s4       z!SQLAlchemy._apply_driver_defaultssa.engine.EnginecCstj|ddS)aCreate the :class:`sqlalchemy.engine.Engine` for the given bind key and app. To customize, use :data:`.SQLALCHEMY_ENGINE_OPTIONS` or :data:`.SQLALCHEMY_BINDS` config. Pass ``engine_options`` to :class:`SQLAlchemy` to set defaults for all engines. This method is used for internal setup. Its signature may change at any time. :meta private: :param bind_key: The name of the engine being created. :param options: Arguments passed to the engine. :param app: The application that the engine configuration belongs to. .. versionchanged:: 3.0 Renamed from ``create_engine``, this method is internal. ry)prefix)rqengine_from_config)rMr=rr4r r r!rxszSQLAlchemy._make_enginecC |jdS)zdThe default metadata used by :attr:`Model` and :attr:`Table` if no bind key is set. N)r@rr r r!rs zSQLAlchemy.metadata't.Mapping[str | None, sa.engine.Engine]cCs$t}||jvr td|j|S)aMap of bind keys to :class:`sqlalchemy.engine.Engine` instances for current application. The ``None`` key refers to the default engine, and is available as :attr:`engine`. To customize, set the :data:`.SQLALCHEMY_BINDS` config, and set defaults by passing the ``engine_options`` parameter to the extension. This requires that a Flask application context is active. .. versionadded:: 3.0 zThe current Flask app is not registered with this 'SQLAlchemy' instance. Did you forget to call 'init_app', or did you create multiple 'SQLAlchemy' instances?)r_get_current_objectrJrf)rMr4r r r!rVs   zSQLAlchemy.enginescCr)aThe default :class:`~sqlalchemy.engine.Engine` for the current application, used by :attr:`session` if the :attr:`Model` or :attr:`Table` being queried does not set a bind key. To customize, set the :data:`.SQLALCHEMY_ENGINE_OPTIONS` config, and set defaults by passing the ``engine_options`` parameter to the extension. This requires that a Flask application context is active. N)rVrr r r!rTs zSQLAlchemy.enginerrcKs,tjdtddd|vr|d}|j|S)aGet the engine for the given bind key for the current application. This requires that a Flask application context is active. :param bind_key: The name of the engine. .. deprecated:: 3.0 Will be removed in Flask-SQLAlchemy 3.2. Use ``engines[key]`` instead. .. versionchanged:: 3.0 Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app`` parameter. z'get_engine' is deprecated and will be removed in Flask-SQLAlchemy 3.2. Use 'engine' or 'engines[key]' instead. If you're using Flask-Migrate or Alembic, you'll need to update your 'env.py' file.r:r;bind)rBrCrDrrV)rMr=rr r r! get_engines  zSQLAlchemy.get_engine descriptionentitytype[_O]identrrcKs.|jj||fi|}|durtd|d|S)aLike :meth:`session.get() ` but aborts with a ``404 Not Found`` error instead of returning ``None``. :param entity: The model class to query. :param ident: The primary key to query. :param description: A custom message to show on the error page. :param kwargs: Extra arguments passed to ``session.get()``. .. versionchanged:: 3.1 Pass extra keyword arguments to ``session.get()``. .. versionadded:: 3.0 Nr)r?rr)rMrrrrrr r r! get_or_404s zSQLAlchemy.get_or_404 statementsa.sql.Select[t.Any]cCs(|j|}|durtd|d|S)a@Like :meth:`Result.scalar() `, but aborts with a ``404 Not Found`` error instead of returning ``None``. :param statement: The ``select`` statement to execute. :param description: A custom message to show on the error page. .. versionadded:: 3.0 Nrr)r?executescalarr)rMrrrr r r! first_or_404s  zSQLAlchemy.first_or_404c Cs<z |j|WStjtjfytd|dYdSw)asLike :meth:`Result.scalar_one() `, but aborts with a ``404 Not Found`` error instead of raising ``NoResultFound`` or ``MultipleResultsFound``. :param statement: The ``select`` statement to execute. :param description: A custom message to show on the error page. .. versionadded:: 3.0 rrN)r?r scalar_onesa_exc NoResultFoundMultipleResultsFoundr)rMrrr r r! one_or_404s  zSQLAlchemy.one_or_404)pageper_page max_per_page error_outcountselectr int | Nonerrrrrc Cst|||||||dS)aApply an offset and limit to a select statment based on the current page and number of items per page, returning a :class:`.Pagination` object. The statement should select a model class, like ``select(User)``. This applies ``unique()`` and ``scalars()`` modifiers to the result, so compound selects will not return the expected results. :param select: The ``select`` statement to paginate. :param page: The current page, used to calculate the offset. Defaults to the ``page`` query arg during a request, or 1 otherwise. :param per_page: The maximum number of items on a page, used to calculate the offset and limit. Defaults to the ``per_page`` query arg during a request, or 20 otherwise. :param max_per_page: The maximum allowed value for ``per_page``, to limit a user-provided value. Use ``None`` for no limit. Defaults to 100. :param error_out: Abort with a ``404 Not Found`` error if no items are returned and ``page`` is not 1, or if ``page`` or ``per_page`` is less than 1, or if either are not ints. :param count: Calculate the total number of values by issuing an extra count query. For very complex queries this may be inaccurate or slow, so it can be disabled and set manually if necessary. .. versionchanged:: 3.0 The ``count`` query is more efficient. .. versionadded:: 3.0 )rr?rrrrr)rr?)rMrrrrrrr r r!paginate"s%zSQLAlchemy.paginatestr | None | list[str | None]op_namec Cs|dkr t|j}n|dust|tr|g}n|}|D]3}z|j|}Wnty@d|d}|dur:d|}t|dw|j|}t|||dqdS)aCall a method on each metadata. :meta private: :param bind_key: A bind key or list of keys. Defaults to all binds. :param op_name: The name of the method to call. .. versionchanged:: 3.0 Renamed from ``_execute_for_all_tables``. __all__Nz Bind key 'z&' is not in 'SQLALCHEMY_BINDS' config.z-'SQLALCHEMY_DATABASE_URI' config is not set. )r) listr@rprOrVKeyErrorrUnboundExecutionErrorgetattr)rMr=rkeysr~rTrWrr r r!_call_for_bindsQs"      zSQLAlchemy._call_for_bindsrcC||ddS)afCreate tables that do not exist in the database by calling ``metadata.create_all()`` for all or some bind keys. This does not update existing tables, use a migration library for that. This requires that a Flask application context is active. :param bind_key: A bind key or list of keys to create the tables for. Defaults to all binds. .. versionchanged:: 3.0 Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app`` parameter. .. versionchanged:: 0.12 Added the ``bind`` and ``app`` parameters. create_allNrrMr=r r r!rsszSQLAlchemy.create_allcCr)aDrop tables by calling ``metadata.drop_all()`` for all or some bind keys. This requires that a Flask application context is active. :param bind_key: A bind key or list of keys to drop the tables from. Defaults to all binds. .. versionchanged:: 3.0 Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app`` parameter. .. versionchanged:: 0.12 Added the ``bind`` and ``app`` parameters. drop_allNrrr r r!rszSQLAlchemy.drop_allcCr)aLoad table definitions from the database by calling ``metadata.reflect()`` for all or some bind keys. This requires that a Flask application context is active. :param bind_key: A bind key or list of keys to reflect the tables from. Defaults to all binds. .. versionchanged:: 3.0 Renamed the ``bind`` parameter to ``bind_key``. Removed the ``app`` parameter. .. versionchanged:: 0.12 Added the ``bind`` and ``app`` parameters. reflectNrrr r r!rszSQLAlchemy.reflectcCsJ|d|jd|vr#|d}t|tr|if}|dd|jdSdS)zApply the extension's :attr:`Query` class as the default for relationships and backrefs. :meta private: r0backrefrN)rlrrprO)rMrrr r r!_set_rel_querys zSQLAlchemy._set_rel_queryr"sa_orm.RelationshipProperty[t.Any]cOs||tj|i|S)zA :func:`sqlalchemy.orm.relationship` that applies this extension's :attr:`Query` class for dynamic relationships and backrefs. .. versionchanged:: 3.0 The :attr:`Query` class is set on ``backref``. rr& relationship)rMrrr r r!rs zSQLAlchemy.relationshipargumentcKs||tj|fi|S)zA :func:`sqlalchemy.orm.dynamic_loader` that applies this extension's :attr:`Query` class for relationships and backrefs. .. versionchanged:: 3.0 The :attr:`Query` class is set on ``backref``. )rr&dynamic_loader)rMr rr r r!r s zSQLAlchemy.dynamic_loadercOs||tj}||i|S)aMA :func:`sqlalchemy.orm.relationship` that applies this extension's :attr:`Query` class for dynamic relationships and backrefs. SQLAlchemy 2.0 removes this name, use ``relationship`` instead. :meta private: .. versionchanged:: 3.0 The :attr:`Query` class is set on ``backref``. r)rMrrfr r r! _relations zSQLAlchemy._relationrcCsZ|dkr|jS|dkr tS|drt|ttfD]}t||r(t||Sqt|)Nrelationevent_)r sa_eventrAttributeErrorrqr&hasattrr)rMrmodr r r! __getattr__s   zSQLAlchemy.__getattr__r)r4r5rr6r/r7r0r8r"rr1r7r2r9r3r9)r#rO)r4rr#rY)rrr#r)rrr#r)rrr#rY)r=rr#r)r#r)F)r"rr3r9r#r)rrr4rr#rY)r=rrrr4rr#r)r#r)r#r)r#r)r=rrrr#r) rrrrrrrrr#r)rrrrr#r)rrrrrrrrrr9rr9r#r)r=rrrOr#rY)r)r=rr#rY)rrr#rY)rrrrr#r)r rrrr#r)rrOr#r)#rrr__doc__rr rNrXrLr>rrhrvrFrHrwrxpropertyrrVrTrrrrrrrrrrrr r rr r r r!r.=shh t `    I E    ! / "     r.)r"rr#r$)6 __future__rrrtypingtrBweakrefrrZrqsqlalchemy.eventrrsqlalchemy.excrrsqlalchemy.ormormr&flaskrrrrrr r r r r r paginationrrrrr?rrtablerTypeVarobjectrUnionTyperr'r(rrr-r.r r r r!sP