+h"ddlmZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z ddl Z ddlmZmZmZmZddlmZddl mZmZmZdd lmZdd lmZdd lmZd d lm Z m!Z!m"Z"d dl#m$Z$d dl#m%Z%d dl&m'Z' ddl(m)Z)ddl(m*Z* ddl-m.Z/dZ2ejfdk(r)ejhdk\r ejjZ6nejnZ6n ej Z6eZ8e8jsdZ:e8jsdZ;dZdZ?dZ@dZAGd d!eBZCd"ZDGd#d$eZEGd%d&eFZGGd'd(eFZHd)ZIGd*d+eFZJGd,d-ejZLGd.d/eFZMd0ZNGd1d2eFZOd3ZPGd4d5eFZQGd6d7eFZRGd8d9e$ZSGd:d;eTZUejd._make_tableRs~ t9q=ZQ;GR[[)DH4Dzz&$'-2  D)v000r0r )r=r>s` r)r>r>Qs1 r0cd|vr||d<yy)N query_classr )dclss r)_set_default_query_classrC\sA-r0cFtjfd}|S)Nct|d|vr(|d}t|tr|if}t|d|i|S)Nbackrefr)rCr6r)r<r&rFrBfns r)newfnz-_wrap_with_default_query_class..newfnbsP -  Y'G'<0"B- $WQZ 54"6""r0) functoolswraps)rGrBrHs`` r)_wrap_with_default_query_classrKas%__R## Lr0c |ttjfD]7}|jD]&}t||rt ||t ||(9t ||_t|j||_ t|j||_ t|j||_ t|_ yN) r:r__all__hasattrr$getattrr>r;rK relationshiprelationdynamic_loaderr )objrBmoduler's r)_include_sqlalchemyrVnsjnn,8>> 8C3$S'&#"67 88 C CI5c6F6FLC1#,,DCL78J8JCPCCIr0ceZdZeedZeedZeedZeedZeedZ edZ dZ y) _DebugQueryTuplerrrc4|j|jz SrM)end_time start_timeselfs r)durationz_DebugQueryTuple.durations}}t..r0cNd|j|j|jfzS)Nz3) statement parametersr`r^s r)__repr__z_DebugQueryTuple.__repr__s*D NN OO MMH   r0N) __name__ __module__ __qualname__propertyrrbrcr]r\contextr`rdr r0r)rXrX{s_A'I*Q-(J*Q-(J 1 &Hz!}%G // r0rXcbtjd}|j|jj d}|rX||k(s|j |dzr?|j j}|j jd|jd|dS|j}|jy)Nrre.:z ()z ) sys _getframef_back f_globalsget startswithf_codeco_name co_filenamef_lineno)app_pathfrmnamefuncnames r)_calling_contextr|s -- C ** }}  , TX%C)Hzz))H &&   jj **  r0c eZdZdZddZddZy)SignallingSessionaThe signalling session is the default session that Flask-SQLAlchemy uses. It extends the default session system with bind selection and modification tracking. If you want to use a different session you can override the :meth:`SQLAlchemy.create_session` function. .. versionadded:: 2.0 .. versionadded:: 2.1 The `binds` option was added, which allows a session to be joined to an external transaction. c :|jx|_}|jd}|jddxs |j}|jd|j |}||rt j|tj|f||||d|y)NSQLALCHEMY_TRACK_MODIFICATIONSbindbinds) autocommit autoflushrr) get_appappconfigr9engine get_binds_SessionSignalEventsregister SessionBase__init__) r_r=rroptionsrtrack_modificationsrrs r)rzSignallingSession.__init__s%3!jj)IJ{{64(5BII GR\\#%67  &*= ) )$ /  '9U &- r0Nc<|i |j}t|di}|j d}|%>" -vr:Dxx +H#!$((+xx**488(*CC##D&&99" 9%+%8%8" 9s BBB)FTNN)rerfrg__doc__rrr r0r)r~r~s   :r0r~cneZdZedZedZeddZedZedZ edZ y) rctt|dsi|_tj|d|jtj|d|jtj|d|j tj|d|j tj|d|jyN_model_changes before_flush before_commit after_commitafter_rollback)rOrr listen record_opsrrrrBsessions r)rz_SessionSignalEvents.registersw 01%'G " Wncnn= Wos~~> Wos/@/@A Wnc.>.>? W.0B0BCr0cjt|dr|`tj|d|jtj|d|jtj|d|j tj|d|j tj|d|jyr)rOrr removerrrrrs r) unregisterz_SessionSignalEvents.unregisters~ 7, -& Wncnn= Wos~~> Wos/@/@A Wnc.>.>? W.0B0BCr0Nc |j}|jdf|jdf|jdffD]A\}}|D]7}t |}|j r |jn t|}||f||<9Cy#t$rYywxYw)Ninsertupdatedelete) rr"newdirtydeletedr has_identity identity_keyid) r flush_context instancesrAtargets operationtargetrr's r)rz_SessionSignalEvents.record_opss &&A%,KK#:W]]H,>e((BvJ ),# - -   s A<< BBc |j}|r9tj|jt |j yy#t$rYywxYwN)changes)rr"before_models_committedsendrlistvaluesrrAs r)rz"_SessionSignalEvents.before_commitsR &&A # ( (d188:>N ( O    s A AAc |j}|rItj|jt |j |jyy#t$rYywxYwr)rr"models_committedrrrrclearrs r)rz!_SessionSignalEvents.after_commits[ &&A  ! !'++tAHHJ7G ! H GGI    s A A&%A&c\ |j}|jy#t$rYywxYwrM)rr"rrs r)rz#_SessionSignalEvents.after_rollback s1 &&A     s  ++r) rerfrg classmethodrr staticmethodrrrrr r0r)rrs~DDDD - -PPr0rc(eZdZdZdZdZdZdZy)_EngineDebuggingSignalEventszTSets up handlers for two events that let us track the execution time of queries.c ||_||_yrM)r app_package)r_r import_names r)rz%_EngineDebuggingSignalEvents.__init__s &r0ctj|jd|jtj|jd|jy)Nbefore_cursor_executeafter_cursor_execute)r rrrrr^s r)rz%_EngineDebuggingSignalEvents.registers@ KK0$2L2L   KK/1J1J r0c0trt|_yyrM)r _timer_query_start_time)r_conncursorrbrcri executemanys r)rz2_EngineDebuggingSignalEvents.before_cursor_execute#s (.G % r0c tr` tjj}|j t |||jtt|jfyy#t$rgx}tj_YhwxYwrM) r rtopsqlalchemy_queriesr"appendrXrrr|r)r_rrrbrcrirqueriess r)rz1_EngineDebuggingSignalEvents.after_cursor_execute)s  E(,,?? NN+:w'@'@&( !1!12-  " EBDD.,,? EsA(( B  B N)rerfrgrrrrrr r0r)rrs' 1 r0rc8ttjdgS)aIn debug mode Flask-SQLAlchemy will log all the SQL queries sent to the database. This information is available until the end of request which makes it possible to easily ensure that the SQL generated is the one expected on errors or in unittesting. If you don't want to enable the DEBUG mode for your unittests you can also enable the query recording by setting the ``'SQLALCHEMY_RECORD_QUERIES'`` config variable to `True`. This is automatically enabled if Flask is in testing mode. The value returned will be a list of named tuples with the following attributes: `statement` The SQL statement issued `parameters` The parameters for the SQL statement `start_time` / `end_time` Time the query started / the results arrived. Please keep in mind that the timer function used depends on your platform. These values are only useful for sorting or comparing. They do not necessarily represent an absolute timestamp. `duration` Time the query took in seconds `context` A string giving a rough estimation of where in your application query was issued. The exact format is undefined so don't try to reconstruct filename or function name. r)rPrrr r0r)get_debug_queriesr8s@ >%%';R @@r0ceZdZdZdZedZd dZedZedZ d dZ edZ ed Z d d Z y ) Paginationa>Internal helper class returned by :meth:`BaseQuery.paginate`. You can also construct it from any other SQLAlchemy query object if you are working with other libraries. Additionally it is possible to pass `None` as query object in which case the :meth:`prev` and :meth:`next` will no longer work. cJ||_||_||_||_||_yrM)r,pageper_pagetotalr#)r_r,rrrr#s r)rzPagination.__init__cs'      r0c|jdk(rd}|Stt|jt |jz }|S)zThe total number of pagesr)rintrrfloat)r_pagess r)rzPagination.pagespsD ==A E TZZ% *>>?@E r0c|jJd|jj|jdz |j|S)z;Returns a :class:`Pagination` object for the previous page.2a query object is required for this method to workrr,paginaterrr_ error_outs r)prevzPagination.prevyFzz% A(A A%zz""499q=$--KKr0c:|jsy|jdz S)zNumber of the previous page.Nr)has_prevrr^s r)prev_numzPagination.prev_num}}yy1}r0c |jdkDS)zTrue if a previous page existsr)rr^s r)rzPagination.has_prevsyy1}r0c|jJd|jj|jdz|j|S)z7Returns a :class:`Pagination` object for the next page.rrrrs r)nextzPagination.nextrr0c4|j|jkS)zTrue if a next page exists.)rrr^s r)has_nextzPagination.has_nextsyy4::%%r0c:|jsy|jdzS)zNumber of the next pageNr)rrr^s r)next_numzPagination.next_numrr0c#Kd}td|jdzD]S}||ks:||j|z dz kDr||j|zks||j|z kDsB|dz|k7rd||}Uyw)uIterates over the page numbers in the pagination. The four parameters control the thresholds how many numbers should be produced from the sides. Skipped page numbers are represented as `None`. This is how you could render such a pagination in the templates: .. sourcecode:: html+jinja {% macro render_pagination(pagination, endpoint) %} {% endmacro %} rrN)rrr)r_ left_edge left_current right_current right_edgelastnums r) iter_pageszPagination.iter_pagess2!TZZ!^, Cidii,.22dii-//TZZ*,,!8s?J  s AA5 A5NF)rYrYrY)rerfrgrrrhrrrrrrrrr r0r)rr[s L  L && 45/0"r0rc(eZdZdZddZddZddZy) BaseQueryaZSQLAlchemy :class:`~sqlalchemy.orm.query.Query` subclass with convenience methods for querying in a web application. This is the default :attr:`~Model.query` object used for models, and exposed as :attr:`~SQLAlchemy.Query`. Override the query class for an individual model by subclassing this and setting :attr:`~Model.query_class`. NcF|j|}| td||S)zPLike :meth:`get` but aborts with 404 if not found instead of returning ``None``. description)rrr)r_identrrvs r) get_or_404zBaseQuery.get_or_404s%XXe_ : #; / r0cD|j}| td||S)zRLike :meth:`first` but aborts with 404 if not found instead of returning ``None``.rr)firstr)r_rr s r) first_or_404zBaseQuery.first_or_404s#ZZ\ : #; / r0ctrY|* ttjjdd}|3 ttjjdd}n|d}|d}| t||}|dkr|r t dnd}|dkr|r t dnd}|j|j|dz |zj}|s|dk7r |r t d|jdj}t|||||S#tt f$r|r t dd}YwxYw#tt f$r|r t dd}YwxYw)aReturns ``per_page`` items from page ``page``. If ``page`` or ``per_page`` are ``None``, they will be retrieved from the request query. If ``max_per_page`` is specified, ``per_page`` will be limited to that value. If there is no request or they aren't in the query, they default to 1 and 20 respectively. When ``error_out`` is ``True`` (default), the following rules will cause a 404 response: * No items are found and ``page`` is not 1. * ``page`` is less than 1, or ``per_page`` is negative. * ``page`` or ``per_page`` are not ints. When ``error_out`` is ``False``, ``page`` and ``per_page`` default to 1 and 20 respectively. Returns a :class:`Pagination` object. Nrrrrr)r rr<rr TypeError ValueErrorrminlimitoffsetallorder_bycountr)r_rrr max_per_pager#rs r)rzBaseQuery.paginatesZ* |w||//:;D""7<<#3#3J#CDH|  #8\2H !8c  a<c  8$++TAX,ABFFHy #J d#))+$hu==W":. c D ":." c !H "s")D)D;D87D8;EErM)NNTN)rerfrgrr rrr r0r)rrs D>r0rceZdZdZdZy)_QueryPropertyc||_yrM)sa)r_rs r)rz_QueryProperty.__init__!s r0c tj|}|r+|j||jj Sy#t $rYywxYw)N)r)r class_mapperr@rrr)r_rTtypers r)__get__z_QueryProperty.__get__$sR %%d+F''8I'JJ!  sAA AAN)rerfrgrr!r r0r)rr s r0rc|jry|jd}||St|jjdS)NTSQLALCHEMY_RECORD_QUERIESTESTING)debugrboolrr)rrqs r)_record_queriesr(-s= yy / 0B ~  y) **r0c&eZdZddZdZdZdZy)_EngineConnectorNch||_||_d|_d|_||_t |_yrM)_sa_app_engine_connected_for_bindr_lock)r_rrrs r)rz_EngineConnector.__init__8s/  " V r0c|j|jjdS|jjjdxsd}|j|vsJd|jz||jS)NSQLALCHEMY_DATABASE_URISQLALCHEMY_BINDSr zPBind %r is not specified. Set it in the SQLALCHEMY_BINDS configuration variable)r0r-rrr)r_rs r)get_uriz_EngineConnector.get_uri@s} :: 99##$=> >   $$%78>BzzU" 2 %'+zz 2 2"TZZ  r0c|j5|j}|jjd}||f|jk(r|j cdddSt |}|j||\}}|jj||x|_}t|jr8t|j |jjj||f|_|cdddS#1swYyxYw)NSQLALCHEMY_ECHO)r1r5r-rr/r.r get_optionsr, create_enginer(rrr)r_uriechosa_urlrr s r)rz_EngineConnector.get_engineIs ZZ ,,.C99##$56DT{d111||    c]F"..vt> )C CC ) >>, ''r0ceZdZdZdZy)_SQLAlchemyStatez0Remembers configuration for the (db, app) tuple.c ||_i|_yrM)r= connectors)r_r=s r)rz_SQLAlchemyState.__init__zsr0N)rerfrgrrr r0r)rErEws :r0rEceZdZdZdZddddeedfdZedZ ddZ dZ ddZ d Z d Zd Zed Zdd ZddZdZddZddZddZddZddZddZddZdZy) SQLAlchemyapThis class is used to control the SQLAlchemy integration to one or more Flask applications. Depending on how you initialize the object it is usable right away or will attach as needed to a Flask application. There are two usage modes which work very similarly. One is binding the instance to a very specific Flask application:: app = Flask(__name__) db = SQLAlchemy(app) The second possibility is to create the object once and configure the application later to support it:: db = SQLAlchemy() def create_app(): app = Flask(__name__) db.init_app(app) return app The difference between the two is that in the first case methods like :meth:`create_all` and :meth:`drop_all` will work all the time but in the second case a :meth:`flask.Flask.app_context` has to exist. By default Flask-SQLAlchemy will apply some backend-specific settings to improve your experience with them. As of SQLAlchemy 0.6 SQLAlchemy will probe the library for native unicode support. If it detects unicode it will let the library handle that, otherwise do that itself. Sometimes this detection can fail in which case you might want to set ``use_native_unicode`` (or the ``SQLALCHEMY_NATIVE_UNICODE`` configuration key) to ``False``. Note that the configuration key overrides the value you pass to the constructor. Direct support for ``use_native_unicode`` and SQLALCHEMY_NATIVE_UNICODE are deprecated as of v2.4 and will be removed in v3.0. ``engine_options`` and ``SQLALCHEMY_ENGINE_OPTIONS`` may be used instead. This class also provides access to all the SQLAlchemy functions and classes from the :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` modules. So you can declare models like this:: class User(db.Model): username = db.Column(db.String(80), unique=True) pw_hash = db.Column(db.String(80)) You can still use :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` directly, but note that Flask-SQLAlchemy customizations are available only through an instance of this :class:`SQLAlchemy` class. Query classes default to :class:`BaseQuery` for `db.Query`, `db.Model.query_class`, and the default query_class for `db.relationship` and `db.backref`. If you use these interfaces through :mod:`sqlalchemy` and :mod:`sqlalchemy.orm` directly, the default query class will be that of :mod:`sqlalchemy`. .. admonition:: Check types carefully Don't perform type or `isinstance` checks against `db.Table`, which emulates `Table` behavior but is not a class. `db.Table` exposes the `Table` interface, but is a function which allows omission of metadata. The ``session_options`` parameter, if provided, is a dict of parameters to be passed to the session constructor. See :class:`~sqlalchemy.orm.session.Session` for the standard options. The ``engine_options`` parameter, if provided, is a dict of parameters to be passed to create engine. See :func:`~sqlalchemy.create_engine` for the standard options. The values given here will be merged with and override anything set in the ``'SQLALCHEMY_ENGINE_OPTIONS'`` config variable or othewise set by this library. .. versionadded:: 0.10 The `session_options` parameter was added. .. versionadded:: 0.16 `scopefunc` is now accepted on `session_options`. It allows specifying a custom function which will define the SQLAlchemy session's scoping. .. versionadded:: 2.1 The `metadata` parameter was added. This allows for setting custom naming conventions among other, non-trivial things. The `query_class` parameter was added, to allow customisation of the query class, in place of the default of :class:`BaseQuery`. The `model_class` parameter was added, which allows a custom model class to be used in place of :class:`Model`. .. versionchanged:: 2.1 Utilise the same query class across `session`, `Model.query` and `Query`. .. versionadded:: 2.4 The `engine_options` parameter was added. .. versionchanged:: 2.4 The `use_native_unicode` parameter was deprecated. .. versionchanged:: 2.4.3 ``COMMIT_ON_TEARDOWN`` is deprecated and will be removed in version 3.1. Call ``db.session.commit()`` directly instead. NTc||_||_|j||_|j |||_t |_||_|xsi|_ t||||j|yyrM) use_native_unicodeQuerycreate_scoped_sessionrmake_declarative_baserr _engine_lockrrArVinit_app)r_rrKsession_optionsr8r@ model_classengine_optionss r)rzSQLAlchemy.__init__sw#5  11/B // XF  F-3D+. ? MM#  r0c.|jjS)z*The metadata associated with ``db.Model``.)rr8r^s r)r8zSQLAlchemy.metadataszz"""r0c|i}|jdt}|jd|jt j |j ||S)a-Create a :class:`~sqlalchemy.orm.scoping.scoped_session` on the factory from :meth:`create_session`. An extra key ``'scopefunc'`` can be set on the ``options`` dict to specify a custom scope function. If it's not provided, Flask's app context stack identity is used. This will ensure that sessions are created and removed with the request/response cycle, and should be fine in most cases. :param options: dict of keyword arguments passed to session class in ``create_session`` scopefunc query_cls)rV)r9 _ident_funcr.rLrscoped_sessioncreate_session)r_rrVs r)rMz SQLAlchemy.create_scoped_sessionsU ?GKK [9 ; 3!!    (I  r0c:tjdt|d|S)aCreate the session factory used by :meth:`create_scoped_session`. The factory **must** return an object that SQLAlchemy recognizes as a session, or registering session events may raise an exception. Valid factories include a :class:`~sqlalchemy.orm.session.Session` class or a :class:`~sqlalchemy.orm.session.sessionmaker`. The default implementation creates a ``sessionmaker`` for :class:`SignallingSession`. :param options: dict of keyword arguments passed to session class )class_r=r )r sessionmakerr~)r_rs r)rZzSQLAlchemy.create_sessions M'8TMWMMr0ct|tst|d|t}||j|ur||_t |dds|j |_t||_ |S)a|Creates the declarative base that all models will inherit from. :param model: base model class (or a tuple of base classes) to pass to :func:`~sqlalchemy.ext.declarative.declarative_base`. Or a class returned from ``declarative_base``, in which case a new base class is not created. :param metadata: :class:`~sqlalchemy.MetaData` instance to use, or none to use SQLAlchemy's default. .. versionchanged 2.3.0:: ``model`` can be an existing declarative base in order to support complex customization such as changing the metaclass. r)rBrzr8 metaclassNr@) r6rrrr8rPrLr@rr,)r_modelr8s r)rNz SQLAlchemy.make_declarative_base(sg%1$!% E  ENN($B%ENumT2 $ E $T*  r0cdjvr#djvrtjdjjddjjddjjddjjddjjd djjd djjd djjd djjd djjddjjdd}jjdi|tjt dt j jdd dt j jdd dt j jdd dt j jdd dtjd<jfd}y)zThis callback can be used to initialize an application for the use with this database setup. Never use a database in the context of an application not initialized that way or connections will leak. r3r4zxNeither SQLALCHEMY_DATABASE_URI nor SQLALCHEMY_BINDS is set. Defaulting SQLALCHEMY_DATABASE_URI to "sqlite:///:memory:".zsqlite:///:memory:NSQLALCHEMY_NATIVE_UNICODEr7Fr#SQLALCHEMY_POOL_SIZESQLALCHEMY_POOL_TIMEOUTSQLALCHEMY_POOL_RECYCLESQLALCHEMY_MAX_OVERFLOWSQLALCHEMY_COMMIT_ON_TEARDOWNrr>zSQLALCHEMY_TRACK_MODIFICATIONS adds significant overhead and will be disabled by default in the future. Set it to True or False to suppress this warning.z3.0 pool_size pool_timeout pool_recycle max_overflowr:cjdr6tjdt|jj jj |S)Nrgzt'COMMIT_ON_TEARDOWN' is deprecated and will be removed in version 3.1. Call 'db.session.commit()'` directly instead.)rwarningswarnDeprecationWarningrcommitr)response_or_excrr_s r)shutdown_sessionz-SQLAlchemy.init_app..shutdown_sessionvsUzz9: @' #*LL'') LL   !" "r0) rrmrnr.FSADeprecationWarningrengine_config_warningrErCteardown_appcontext)r_rrrrs`` r)rPzSQLAlchemy.init_appIs &SZZ 7 cjj 0 MMN  79MN 0$7 94@ /7 94@ 4d; 7> 7> 7> =uE!jj33 ,d  92>  & MM/5  ##CJJ7M{[ ##CJJ7PR`a ##CJJ7PR`a ##CJJ7PR`a'7'=|$  # ! #r0c^fd}|dd|dd|dd|dd S) z .. versionchanged:: 2.5 Returns the ``options`` dict, for consistency with :meth:`apply_driver_hacks`. c4j|}|||<yyrM)r) optionkey configkeyr(rrs r) _setdefaultz3SQLAlchemy.apply_pool_defaults.._setdefaults&JJy)E %* "!r0rhrcrirdrjrerkrfr )r_rrrzs `` r)r?zSQLAlchemy.apply_pool_defaultss;  + K!78N$=>N$=>N$=>r0c|jjdrAt|d}|jdk7r|jdd|jddn|jd k(r|j d}d }|j d vr.d }d dlm}||d<d|vri|d<d |dd<|d k(rtd|s d dlm }||d<|s?t|tjj|j|j }|jd}| |j }|sd |d<|jdt#j$dt&|j st#j$dt&||fS)aThis method is called before engine creation and used to inject driver specific hacks into the options. The `options` parameter is a dictionary of keyword arguments that will then be used to call the :func:`sqlalchemy.create_engine` function. The default implementation provides some saner defaults for things like pool sizes for MySQL and sqlite. Also it injects the setting of `SQLALCHEMY_NATIVE_UNICODE`. .. versionchanged:: 2.5 Returns ``(sa_url, options)``. SQLAlchemy 1.4 made the URL immutable, so any changes to it must now be passed back up to the original caller. mysqlutf8)charsetzmysql+gaerdbmsrh rji sqliteF)Nz:memory:Tr) StaticPool poolclass connect_argscheck_same_threadzLSQLite in memory database with an empty queue not possible due to data loss.)NullPool)databaserbrKzThe 'SQLALCHEMY_NATIVE_UNICODE' config option is deprecated and will be removed in v3.0. Use 'SQLALCHEMY_ENGINE_OPTIONS' instead.zl'use_native_unicode' is deprecated and will be removed in v3.0. Use the 'engine_options' parameter instead.) drivernamersr/r.rrrsqlalchemy.poolr RuntimeErrorrr*ospathjoin root_pathrrKrmrnro) r_rr<rrhdetected_in_memoryrrunus r)r@zSQLAlchemy.apply_driver_hackss    ' ' 0-ffEF  $44"";3"">48   ( * K0I!& "88%)"6'1 $!0.0GN+?D'(;<>&(/00 4'/ $&$RWW\\#--%Qjj45 ;))C,1G( ) ::1 2 > MMC"  && MM@"  wr0c"|jS)aUGives access to the engine. If the database configuration is bound to a specific application (initialized with an application) this will always return a database connection. If however the current application is used this might raise a :exc:`RuntimeError` if no application is active at the moment. )rr^s r)rzSQLAlchemy.engines  r0c:t||j||S)z1Creates the connector for a given state and bind.)r*r)r_rrs r)make_connectorzSQLAlchemy.make_connectorsdll3&7>>r0c|j|}t|}|j5|jj |}|!|j ||}||j|<|j cdddS#1swYyxYw)zReturns a specific engine.N)rrrOrGrrrr)r_rrr connectors r)rzSQLAlchemy.get_enginesll3#    *((,,T2I  //T: )2  &'') * * *s ABB c.tj|fi|S)a Override this method to have final say over how the SQLAlchemy engine is created. In most cases, you will want to use ``'SQLALCHEMY_ENGINE_OPTIONS'`` config variable or set ``engine_options`` for :func:`SQLAlchemy`. )r:r9)r_r< engine_optss r)r9zSQLAlchemy.create_engines''>+>>r0c||StrtjS|j |jStd)zJHelper method that implements the logic to look up an application.zNo application found. Either work inside a view function or push an application context. See http://flask-sqlalchemy.pocoo.org/contexts/.)r _get_current_objectrr)r_ reference_apps r)rzSQLAlchemy.get_appsG  $ 224 4 88 88O <  r0cg}t|jjjD]2}|jj d|k(s"|j |4|S)z1Returns a list of all tables relevant for a bind.r4)rrr8tablesr3rrr)r_rresulttables r)get_tables_for_bindzSQLAlchemy.get_tables_for_bindsS 3 3 : :; %Ezz~~j)T1 e$ % r0c |j|}dgt|jjdxsdz}i}|D]H}|j |||j |}|j tfd|DJ|S)zReturns a dictionary with a table->engine mapping. This is suitable for use of sessionmaker(binds=db.get_binds(app)). Nr4r c3&K|]}|f ywrMr ).0rrs r) z'SQLAlchemy.get_binds..+sC5vCs)rrrrrrrrr-)r_rrretvalrrrs @r)rzSQLAlchemy.get_binds s ll3cjjnn-?@FBGG ED__S$/F--d3F MM$CFCC D E r0c p|j|}|dk(r-dgt|jjdxsdz}nt |t s||g}n|}|D]V}i}|s|j |}||d<t|jj|}|dd|j||i|Xy)NrNr4r rr) rrrrrr6rrrPrr8r) r_rrr skip_tablesrextrarops r)_execute_for_all_tablesz"SQLAlchemy._execute_for_all_tables.sll3 9 FT#**..1C"D"JKKE l +t|FEE 9DE11$7"(h,,i8B  8DOOC. 8% 8  9r0c*|j||dy)z_Creates all tables. .. versionchanged:: 0.12 Parameters were added create_allNrr_rrs r)rzSQLAlchemy.create_all@s $$S$ =r0c*|j||dy)z]Drops all tables. .. versionchanged:: 0.12 Parameters were added drop_allNrrs r)rzSQLAlchemy.drop_allHs $$S$ ;r0c.|j||ddy)znReflects tables from the database. .. versionchanged:: 0.12 Parameters were added reflectT)rNrrs r)rzSQLAlchemy.reflectPs $$S$ t$Lr0cd|jjd|jstr|jj dSddS)N) __class__rerr rr%r^s r)rdzSQLAlchemy.__repr__Xs? NN # ##xx;DKKOO @  <@ @  r0rMrr)rNN)rerfrgrrLrrrrhr8rMrZrNrPr?r@rrrr9rrrrrrrrdr r0r)rIrIsdR ED$I5 $ ##  .N B;#z FP!!? *? & 9$><M r0rIceZdZfdZxZS)_BoundDeclarativeMetacptjtddtt||||y)Nz_"_BoundDeclarativeMeta" has been renamed to "DefaultMeta". The old name will be removed in 3.0.r) stacklevel)rmrnrssuperrr)rBrzbasesrArs r)rz_BoundDeclarativeMeta.__init__`s7 + 0   #S24Br0)rerfrgr __classcell__)rs@r)rr_sCCr0rc eZdZy)rsN)rerfrgr r0r)rsrshsr0rsalways)W __future__rrIrrntimermmathroperatorr threadingrr:flaskrrr r flask.signalsr r r rsqlalchemy.engine.urlrsqlalchemy.orm.excrsqlalchemy.orm.sessionrr_compatrrrr`rrrrsqlalchemy.ormrr ImportErrorsqlalchemy.ext.declarativegreenletrrXrthread __version__platform version_info perf_counterrclock_signalssignalrrr*r/r>rCrKrVtuplerXr|r~objectrrrrrLrrr(r*rrErIrrors simplefilterr r0r)rs& ==#***1955;/.42 <<7 6!"" YYF ;??#56"//*CD)   u & 0: 0:f@6@F"6"J AFddN[> [>| V +6v6r(v] ] @CKC . h 56_";;::;446 4344sH< F> G>GGG8G#"G8# G1.G80G11G87G8