H`Tc@sdZddlZddlZddlZddlmZmZmZmZm Z ddl m Z ddl m Z m Z mZddlmZiZdZd Ze jd Ze jd Ze jd Zd efdYZdejfdYZdefdYZedZeZ defdYZ!defdYZ"defdYZ#defdYZ$defdYZ%defdYZ&d efd!YZ'dS("s{Connection pooling for DB-API connections. Provides a number of connection pool implementations for a variety of usage scenarios and thread behavior requirements imposed by the application, DB-API or database itself. Also provides a DB-API 2.0 connection proxying mechanism allowing regular DB-API connect() methods to be transparently managed by a SQLAlchemy connection pool. iNi(texctlogteventt interfacestutil(tqueue(t threadingtmemoized_propertytchop_traceback(tdequecKs:y t|SWn'tk r5tj|t||SXdS(sIReturn a proxy for a DB-API module that automatically pools connections. Given a DB-API 2.0 module and pool management parameters, returns a proxy for the module that will automatically pool connections, creating new connection pools for each distinct set of connection arguments sent to the decorated module's connect() function. :param module: a DB-API 2.0 database module :param poolclass: the class used by the pool module to provide pooling. Defaults to :class:`.QueuePool`. :param \*\*params: will be passed through to *poolclass* N(tproxiestKeyErrort setdefaultt_DBProxy(tmoduletparams((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytmanage!s  cCs/xtjD]}|jq WtjdS(sYRemove all current DB-API 2.0 managers. All pools and connections are disposed. N(R tvaluestclosetclear(tmanager((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytclear_managers8streset_rollbackt reset_committ reset_nonet _ConnDialectcBs)eZdZdZdZdZRS(spartial implementation of :class:`.Dialect` which provides DBAPI connection methods. When a :class:`.Pool` is combined with an :class:`.Engine`, the :class:`.Engine` replaces this with its own :class:`.Dialect`. cCs|jdS(N(trollback(tselftdbapi_connection((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt do_rollbackRscCs|jdS(N(tcommit(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt do_commitUscCs|jdS(N(R(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytdo_closeXs(t__name__t __module__t__doc__RRR (((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRGs   tPoolc BseZdZeZddededdddd ZdZ e j dddZ dZ dZdd Zd Zd Zd Zd ZdZdZdZRS(s)Abstract base class for connection pools.ic Cs|r||_|_n d|_tj|d|tj|_||_||_ d|_ ||_ |dt t fkrt |_nR|dttfkrt|_n1|dtfkrt|_ntjd|||_| r|jj| dtn| r| |_n|rHx*|D]\} } tj|| | q"Wn|r|tjdx|D]} |j| qbWndS( s{ Construct a Pool. :param creator: a callable function that returns a DB-API connection object. The function will be called with parameters. :param recycle: If set to non -1, number of seconds between connection recycling, which means upon checkout, if this timeout is surpassed the connection will be closed and replaced with a newly opened connection. Defaults to -1. :param logging_name: String identifier which will be used within the "name" field of logging records generated within the "sqlalchemy.pool" logger. Defaults to a hexstring of the object's id. :param echo: If True, connections being pulled and retrieved from the pool will be logged to the standard output, as well as pool sizing information. Echoing can also be achieved by enabling logging for the "sqlalchemy.pool" namespace. Defaults to False. :param use_threadlocal: If set to True, repeated calls to :meth:`connect` within the same application thread will be guaranteed to return the same connection object, if one has already been retrieved from the pool and has not been returned yet. Offers a slight performance advantage at the cost of individual transactions by default. The :meth:`.Pool.unique_connection` method is provided to return a consistenty unique connection to bypass this behavior when the flag is set. .. warning:: The :paramref:`.Pool.use_threadlocal` flag **does not affect the behavior** of :meth:`.Engine.connect`. :meth:`.Engine.connect` makes use of the :meth:`.Pool.unique_connection` method which **does not use thread local context**. To produce a :class:`.Connection` which refers to the :meth:`.Pool.connect` method, use :meth:`.Engine.contextual_connect`. Note that other SQLAlchemy connectivity systems such as :meth:`.Engine.execute` as well as the orm :class:`.Session` make use of :meth:`.Engine.contextual_connect` internally, so these functions are compatible with the :paramref:`.Pool.use_threadlocal` setting. .. seealso:: :ref:`threadlocal_strategy` - contains detail on the "threadlocal" engine strategy, which provides a more comprehensive approach to "threadlocal" connectivity for the specific use case of using :class:`.Engine` and :class:`.Connection` objects directly. :param reset_on_return: Determine steps to take on connections as they are returned to the pool. reset_on_return can have any of these values: * ``"rollback"`` - call rollback() on the connection, to release locks and transaction resources. This is the default value. The vast majority of use cases should leave this value set. * ``True`` - same as 'rollback', this is here for backwards compatibility. * ``"commit"`` - call commit() on the connection, to release locks and transaction resources. A commit here may be desirable for databases that cache query plans if a commit is emitted, such as Microsoft SQL Server. However, this value is more dangerous than 'rollback' because any data changes present on the transaction are committed unconditionally. * ``None`` - don't do anything on the connection. This setting should only be made on a database that has no transaction support at all, namely MySQL MyISAM. By not doing anything, performance can be improved. This setting should **never be selected** for a database that supports transactions, as it will lead to deadlocks and stale state. * ``False`` - same as None, this is here for backwards compatibility. .. versionchanged:: 0.7.6 :paramref:`.Pool.reset_on_return` accepts ``"rollback"`` and ``"commit"`` arguments. :param events: a list of 2-tuples, each of the form ``(callable, target)`` which will be passed to :func:`.event.listen` upon construction. Provided here so that event listeners can be assigned via :func:`.create_engine` before dialect-level listeners are applied. :param listeners: Deprecated. A list of :class:`~sqlalchemy.interfaces.PoolListener`-like objects or dictionaries of callables that receive events when DB-API connections are created, checked out and checked in to the pool. This has been superseded by :func:`~sqlalchemy.event.listen`. techoflagiRRs'Invalid value for 'reset_on_return': %rtonly_propagatesZThe 'listeners' argument to Pool (and create_engine()) is deprecated. Use event.listen().N(t logging_namet_orig_logging_nametNoneRtinstance_loggerRtlocalt _threadconnst_creatort_recyclet_invalidate_timet_use_threadlocaltTrueRt_reset_on_returntFalseRRRt ArgumentErrortechotdispatcht_updatet_dialectRtlistenRtwarn_deprecatedt add_listener(RtcreatortrecycleR5tuse_threadlocalR'treset_on_returnt listenersteventst _dispatchR8tfnttargettl((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt__init__bs>p            cCsg|jjd|y|jj|Wn9ttfk rCn |jjd|dtnXdS(NsClosing connection %rsException closing connection %rtexc_info(tloggertdebugR8R t SystemExittKeyboardInterruptterrorR1(Rt connection((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_close_connections g@s4Pool.add_listener is deprecated. Use event.listen()cCstjj||dS(sAdd a :class:`.PoolListener`-like object to this pool. ``listener`` may be an object that implements some or all of PoolListener, or a dictionary of callables containing implementations of some or all of the named methods in PoolListener. N(Rt PoolListenert_adapt_listener(Rtlistener((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR;s cCs tj|S(sProduce a DBAPI connection that is not referenced by any thread-local context. This method is equivalent to :meth:`.Pool.connect` when the :paramref:`.Pool.use_threadlocal` flag is not set to True. When :paramref:`.Pool.use_threadlocal` is True, the :meth:`.Pool.unique_connection` method provides a means of bypassing the threadlocal context. (t_ConnectionFairyt _checkout(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytunique_connection s cCs t|S(s6Called by subclasses to create a new ConnectionRecord.(t_ConnectionRecord(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_create_connectionscCsct|dd}| s+|j|jkr=tj|_nt|dtr_|j|ndS(sMark all connections established within the generation of the given connection as invalidated. If this pool's last invalidate time is before when the given connection was created, update the timestamp til now. Otherwise, no action is performed. Connections with a start time prior to this pool's invalidation time will be recycled upon next checkout. t_connection_recordtis_validN(tgetattrR)R/t starttimettimeR3t invalidate(RRMt exceptiontrec((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt _invalidates cCs tdS(sReturn a new :class:`.Pool`, of the same class as this one and configured with identical creation arguments. This method is used in conjunction with :meth:`dispose` to close out an entire :class:`.Pool` and create a new one in its place. N(tNotImplementedError(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytrecreate0s cCs tdS(sDispose of this pool. This method leaves the possibility of checked-out connections remaining open, as it only affects connections that are idle in the pool. See also the :meth:`Pool.recreate` method. N(R`(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytdispose<s cCsf|jstj|Sy|jj}Wntk r<nX|dk rS|jStj||jS(sReturn a DBAPI connection from the pool. The connection is instrumented such that when its ``close()`` method is called, the connection will be returned to the pool. N(R0RRRSR,tcurrenttAttributeErrorR)t_checkout_existing(RR^((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytconnectIs     cCs>|jr-y |j`Wq-tk r)q-Xn|j|dS(sGiven a _ConnectionRecord, return it to the :class:`.Pool`. This method is called when an instrumented DBAPI connection has its ``close()`` method called. N(R0R,RcRdt_do_return_conn(Rtrecord((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt _return_conn^s    cCs tdS(s7Implementation for :meth:`get`, supplied by subclasses.N(R`(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_do_getlscCs tdS(s?Implementation for :meth:`return_conn`, supplied by subclasses.N(R`(Rtconn((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRgqscCs tdS(N(R`(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytstatusvsN(R!R"R#RR8R)R3R1RFRNRt deprecatedR;RTRVR_RaRbRfRiRjRgRl(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR$\s.        RUcBsweZdZdZd ZejdZe dZ dZ dZ d dZ dZdZd ZRS( sInternal object which maintains an individual DBAPI connection referenced by a :class:`.Pool`. The :class:`._ConnectionRecord` object always exists for any particular DBAPI connection whether or not that DBAPI connection has been "checked out". This is in contrast to the :class:`._ConnectionFairy` which is only a public facade to the DBAPI connection while it is checked out. A :class:`._ConnectionRecord` may exist for a span longer than that of a single DBAPI connection. For example, if the :meth:`._ConnectionRecord.invalidate` method is called, the DBAPI connection associated with this :class:`._ConnectionRecord` will be discarded, but the :class:`._ConnectionRecord` may be used again, in which case a new DBAPI connection is produced when the :class:`.Pool` next uses this record. The :class:`._ConnectionRecord` is delivered along with connection pool events, including :meth:`.PoolEvents.connect` and :meth:`.PoolEvents.checkout`, however :class:`._ConnectionRecord` still remains an internal object whose API and internals may change. .. seealso:: :class:`._ConnectionFairy` cCsc||_|j|_t|_|jjj|jj|j||jj |j|dS(N( t_ConnectionRecord__poolt_ConnectionRecord__connectRMR tfinalize_callbackR6t first_connectt for_modifyt exec_onceRf(Rtpool((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRFs     cCsiS(sThe ``.info`` dictionary associated with the DBAPI connection. This dictionary is shared among the :attr:`._ConnectionFairy.info` and :attr:`.Connection.info` accessors. ((R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytinfoscsjyjWnjnXjt}tj|fd_tj rj j dn|S(Ncstot|S(N(t_finalize_fairy(tref(RR5R^Rt(sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytss#Connection %r checked out from pool( Rjtget_connectiontcheckint_should_log_debugRRtweakrefRwt fairy_reft_refstaddRHRI(tclsRttfairy((RR5R^RtsU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytcheckouts       cCswd|_|j}|j}x&|jrC|jj}||qW|jjrf|jj||n|j|dS(N( R)R}RMRnRptpopR6RzRi(RRMRtt finalizer((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRzs     cCs |jdk r|jndS(N(RMR)t_ConnectionRecord__close(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCs|jdkrdS|jjj|j|||dk rc|jjjd|j|jj|n|jjjd|j|j d|_dS(sInvalidate the DBAPI connection held by this :class:`._ConnectionRecord`. This method is called for all connection invalidations, including when the :meth:`._ConnectionFairy.invalidate` or :meth:`.Connection.invalidate` methods are called, as well as when any so-called "automatic invalidation" condition occurs. .. seealso:: :ref:`pool_connection_invalidation` Ns(Invalidate connection %r (reason: %s:%s)sInvalidate connection %r( RMR)RnR6R\RHRut __class__R!R(Rte((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR\s     cCsNt}|jdkr_|j|_|jj|jjjr|jjj|j|qn|jj dkrt j |j |jj kr|jj jd|jt }n;|jj|j kr|jj jdd|jt }n|rG|j|j|_|jj|jjjrG|jjj|j|qGn|jS(Nis)Connection %r exceeded timeout; recyclings4Connection %r invalidated due to pool invalidation; t recycling(R3RMR)RoRuRRnR6RfR.R[RZRHR1R/R(RR=((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRys2         cCs|jj|jdS(N(RnRNRM(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt__closescCsoy<tj|_|jj}|jjjd||SWn,tk rj}|jjjd|nXdS(NsCreated new connection %rsError on connect(): %s(R[RZRnR-RHRIt Exception(RRMR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt __connectsN(R!R"R#RFR)RMRRRut classmethodRRzRR\RyRRo(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRUzs       cCs(tj||dk r,|j|k r,dS|dk r|rZ|rZ|jjd|nyT|prt|||}|j|kst|j ||s|j |nWqt k r }|jj ddt |r|jd|nt|ttfrqqXn|r$|jndS(sfCleanup for a :class:`._ConnectionFairy` whether or not it's already been garbage collected. Ns$Connection %r being returned to pools!Exception during reset or similarRGR(R~tdiscardR)R}RHRIRRRMtAssertionErrort_resetRNRRLR1R\t isinstanceRJRKRz(RMtconnection_recordRtRwR5RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRv"s0           RRcBseZdZdZdZdZdZedddZ dZ dZ e Z dZ edZedZejdZdd Zd Zd Zd Zd ZRS(sXProxies a DBAPI connection and provides return-on-dereference support. This is an internal object used by the :class:`.Pool` implementation to provide context management to a DBAPI connection delivered by that :class:`.Pool`. The name "fairy" is inspired by the fact that the :class:`._ConnectionFairy` object's lifespan is transitory, as it lasts only for the length of a specific DBAPI connection being checked out from the pool, and additionally that as a transparent proxy, it is mostly invisible. .. seealso:: :class:`._ConnectionRecord` cCs||_||_||_dS(N(RMRWt_echo(RRRR5((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRF`s  cCs]|sKtj|}||_d|_|dk rKtj||_qKn|jdkrlt j dn|jd7_|j j s|jdkr|Sd}x|dkr/y$|j j|j|j ||SWqt j k r+}|jjd||j j||j j|_|d8}qXqW|jjd|jt j ddS(NisThis connection is closediis&Disconnection detected on checkout: %ss+Reconnection attempts exhausted on checkout(RURt_poolt_counterR)R|RwRcRMRtInvalidRequestErrorR6RWtDisconnectionErrorRHRuR\Ry(RRtt threadconnsRtattemptsR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRSs6      cCstj|jd|S(NR(RRRSR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRescCs>t|j|j|jd|jd|d|_d|_dS(NR(RvRMRWRR)R(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_checkins cCs|jjr%|jj||jn|jtkr|jrh|jjd|j|j r^dndn|j r|j j q|j j |no|jt kr|jr|jjd|j|j rdndn|j r|j jq|j j|ndS(Ns"Connection %s rollback-on-return%ss , via agentts Connection %s commit-on-return%s(R6tresetRWR2RRRHRIRMt _reset_agentRR8RRRR(RRt((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRs$       cCs |jjS(N(RRH(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_loggerscCs |jdk S(sbReturn True if this :class:`._ConnectionFairy` still refers to an active DBAPI connection.N(RMR)(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRXscCs |jjS(sInfo dictionary associated with the underlying DBAPI connection referred to by this :class:`.ConnectionFairy`, allowing user-defined data to be associated with the connection. The data here will follow along with the DBAPI connection including after it is returned to the connection pool and used again in subsequent instances of :class:`._ConnectionFairy`. It is shared with the :attr:`._ConnectionRecord.info` and :attr:`.Connection.info` accessors. (RWRu(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRus cCsV|jdkr tjddS|jr?|jjd|nd|_|jdS(sMark this connection as invalidated. This method can be called directly, and is also called as a result of the :meth:`.Connection.invalidate` method. When invoked, the DBAPI connection is immediately closed and discarded from further use by the pool. The invalidation mechanism proceeds via the :meth:`._ConnectionRecord.invalidate` internal method. .. seealso:: :ref:`pool_connection_invalidation` s.Can't invalidate an already-closed connection.NR(RMR)RtwarnRWR\R(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR\s   cOs|jj||S(sReturn a new DBAPI cursor for the underlying connection. This method is a proxy for the ``connection.cursor()`` DBAPI method. (RMtcursor(Rtargstkwargs((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCst|j|S(N(RYRM(Rtkey((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt __getattr__scCsl|jdk rhtj|jd|j_d|j_|jj|j|jj |_d|_ndS(s"Separate this connection from its Pool. This means that the connection will no longer be returned to the pool when closed, and will instead be literally closed. The containing ConnectionRecord is separated from the DB-API connection, and will create a new connection when next used. Note that any overall connection limiting constraints imposed by a Pool implementation may be violated after a detach, as the detached connection is removed from the pool's knowledge and control. N( RWR)R~tremoveR}RMRRgRutcopy(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytdetachs   cCs/|jd8_|jdkr+|jndS(Nii(RR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRsN(R!R"R#RFR)RMRWRRRSReRt_closeRtpropertyRRXRRRuR\RRRR(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRRKs& $      tSingletonThreadPoolcBsPeZdZddZdZdZdZdZdZdZ RS( sA Pool that maintains one connection per thread. Maintains one connection per each thread, never moving a connection to a thread other than the one which it was created in. Options are the same as those of :class:`.Pool`, as well as: :param pool_size: The number of threads in which to maintain connections at once. Defaults to five. :class:`.SingletonThreadPool` is used by the SQLite dialect automatically when a memory-based database is used. See :ref:`sqlite_toplevel`. icKsEt|d( R1R$RFRR+t_conntsett _all_connstsize(RR<t pool_sizetkw((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRF4s   cCsh|jjd|j|jd|jd|jd|jd|jd|jd|j d|j d |j S( NsPool recreatingRR=R5R'R>R?RBR8( RHRuRR-RR.R5R(R0R2R6R8(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRa;s       cCsVxB|jD]7}y|jWq ttfk r:q q Xq W|jjdS(sDispose of this pool.N(RRRJRKR(RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRbGscCs<x5t|j|jkr7|jj}|jqWdS(N(tlenRRRR(Rtc((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt_cleanupVscCsdt|t|jfS(Ns"SingletonThreadPool id:%d size: %d(tidRR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRl[scCsdS(N((RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRg_scCsy|jj}|r|SWntk r0nX|j}tj||j_t|j|jkrw|j n|jj ||S(N( RRcRdRVR|RwRRRRR(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRjbs   ( R!R"R#RFRaRbRRlRgRj(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR"s     t QueuePoolcBseZdZddddZdZdZdZdZd Zd Z d Z d Z d Z dZ dZRS(sA :class:`.Pool` that imposes a limit on the number of open connections. :class:`.QueuePool` is the default pooling implementation used for all :class:`.Engine` objects, unless the SQLite dialect is in use. ii icKsWtj|||tj||_d||_||_||_tj |_ dS(s Construct a QueuePool. :param creator: a callable function that returns a DB-API connection object, same as that of :paramref:`.Pool.creator`. :param pool_size: The size of the pool to be maintained, defaults to 5. This is the largest number of connections that will be kept persistently in the pool. Note that the pool begins with no connections; once this number of connections is requested, that number of connections will remain. ``pool_size`` can be set to 0 to indicate no size limit; to disable pooling, use a :class:`~sqlalchemy.pool.NullPool` instead. :param max_overflow: The maximum overflow size of the pool. When the number of checked-out connections reaches the size set in pool_size, additional connections will be returned up to this limit. When those additional connections are returned to the pool, they are disconnected and discarded. It follows then that the total number of simultaneous connections the pool will allow is pool_size + `max_overflow`, and the total number of "sleeping" connections the pool will allow is pool_size. `max_overflow` can be set to -1 to indicate no overflow limit; no limit will be placed on the total number of concurrent connections. Defaults to 10. :param timeout: The number of seconds to wait before giving up on returning a connection. Defaults to 30. :param \**kw: Other keyword arguments including :paramref:`.Pool.recycle`, :paramref:`.Pool.echo`, :paramref:`.Pool.reset_on_return` and others are passed to the :class:`.Pool` constructor. iN( R$RFt sqla_queuetQueueRt _overflowt _max_overflowt_timeoutRtLockt_overflow_lock(RR<Rt max_overflowttimeoutR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRFzs '   cCsNy|jj|tWn0tjk rIz|jWd|jXnXdS(N(RtputR3RtFullRt _dec_overflow(RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRgs cCs|jdk}y2|o'|j|jk}|jj||jSWntjk r|r|j|jkr|s||jStj d|j |j |jfn|j ry|j SWq|jqXq|jSnXdS(NisPQueuePool limit of size %d overflow %d reached, connection timed out, timeout %d(RRRtgetRRtEmptyRjRt TimeoutErrorRtoverflowt _inc_overflowRVR(Rt use_overflowtwait((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRjs$ %   cCs_|jdkr"|jd7_tS|j.|j|jkrQ|jd7_tStSWdQXdS(Nii(RRR1RR3(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRs cCsI|jdkr"|jd8_tS|j|jd8_tSWdQXdS(Nii(RRR1R(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRs  cCs}|jjd|j|jd|jjd|jd|jd|jd|j d|j d|j d |j d |j d |j S( NsPool recreatingRRRR=R5R'R>R?RBR8(RHRuRR-RtmaxsizeRRR.R5R(R0R2R6R8(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRas      cCsuxBtrDy |jjt}|jWqtjk r@PqXqWd|j|_|j j d|j dS(NisPool disposed. %s( R1RRR3RRRRRRHRuRl(RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRbs  cCs,d|j|j|j|jfS(Ns_Pool size: %d Connections in pool: %d Current Overflow: %d Current Checked out connections: %d(Rt checkedinRt checkedout(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRls    cCs |jjS(N(RR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCs |jjS(N(Rtqsize(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCs|jS(N(R(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCs|jj|jj|jS(N(RRRR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRs(R!R"R#RFRgRjRRRaRbRlRRRR(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRqs.      tNullPoolcBs;eZdZdZdZdZdZdZRS(sA Pool which does not pool connections. Instead it literally opens and closes the underlying DB-API connection per each connection open/close. Reconnect-related functions such as ``recycle`` and connection invalidation are not supported by this Pool implementation, since no connections are held persistently. .. versionchanged:: 0.7 :class:`.NullPool` is used by the SQlite dialect automatically when a file-based database is used. See :ref:`sqlite_toplevel`. cCsdS(NR((R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRlscCs|jdS(N(R(RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRgscCs |jS(N(RV(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRj scCs_|jjd|j|jd|jd|jd|jd|jd|jd|j d|j S( NsPool recreatingR=R5R'R>R?RBR8( RHRuRR-R.R5R(R0R2R6R8(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRa#s      cCsdS(N((R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRb/s(R!R"R#RlRgRjRaRb(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR s     t StaticPoolcBsbeZdZedZedZdZdZdZdZ dZ dZ RS( s.A Pool of exactly one connection, used for all requests. Reconnect-related functions such as ``recycle`` and connection invalidation (which is also used to support auto-reconnect) are not currently supported by this Pool implementation but may be implemented in a future release. cCs |jS(N(R-(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR>scCs t|S(N(RU(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRMBscCsdS(NR((R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRlFscCs,d|jkr(|jjd|_ndS(NR(t__dict__RRR)(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRbIs cCsb|jjd|jd|jd|jd|jd|jd|jd|jd|j d |j S( NsPool recreatingR<R=R>R?R5R'RBR8( RHRuRR-R.R0R2R5R(R6R8(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRaNs      cCs|jS(N(R(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRVYscCsdS(N((RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRg\scCs|jS(N(RM(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRj_s( R!R"R#RRRMRlRbRaRVRgRj(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR3s     t AssertionPoolcBsDeZdZdZdZdZdZdZdZRS(sA :class:`.Pool` that allows at most one checked out connection at any given time. This will raise an exception if more than one connection is checked out at a time. Useful for debugging code that is using more connections than desired. .. versionchanged:: 0.7 :class:`.AssertionPool` also logs a traceback of where the original connection was checked out, and reports this in the assertion error raised. cOsGd|_t|_|jdt|_d|_tj |||dS(Ntstore_traceback( R)RR3t _checked_outRR1t_store_tracebackt_checkout_tracebackR$RF(RRR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRFss    cCsdS(NR((R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRlzscCs:|jstdnt|_||jks6tdS(Nsconnection is not checked out(RRR3R(RRk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRg}s  cCs&t|_|jr"|jjndS(N(R3RRR(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRbs  c CsD|jjd|j|jd|jd|jd|jd|jS(NsPool recreatingR5R'RBR8(RHRuRR-R5R(R6R8(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRas   cCs|jrJ|jr1ddjt|j}nd}td|n|jse|j|_nt|_|jrt j |_n|jS(Ns at: %sRs!connection is already checked out( RRtjoinRRRRVR1Rt tracebackt format_stack(Rtsuffix((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRjs      ( R!R"R#RFRlRgRbRaRj(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRcs     R cBsYeZdZedZdZdZdZdZdZ dZ dZ RS( s Layers connection pooling behavior on top of a standard DB-API module. Proxies a DB-API 2.0 connect() call to a connection pool keyed to the specific connect parameters. Other functions and attributes are delegated to the underlying DB-API module. cKs7||_||_||_i|_tj|_dS(sInitializes a new proxy. module a DB-API 2.0 module poolclass a Pool class, defaulting to QueuePool Other parameters are sent to the Pool object's constructor. N(RRt poolclasstpoolsRRt_create_pool_mutex(RRRR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRFs    cCs(x!t|jD]}|j|=qWdS(N(tlistR(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscCs|jdS(N(R(R((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyt__del__scCst|j|S(N(RYR(RR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRscsj}yj|SWntk rjjzc|jkrjddjfdj}|j|<|Sj|SWdjj XnXdS(Nt sa_pool_keycsjjS(N(RRf((RRR(sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRxs( t _serializeRR RtacquireRR)RRtrelease(RRRRRt((RRRsU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pytget_pools   cOs|j||jS(s,Activate a connection to the database. Connect to the database using this DBProxy's module and the given connect arguments. If the arguments match an existing pool, the connection will be returned from the pool's current thread-local connection instance, or if there is no thread-local connection instance it will be checked out from the set of pooled connections. If the pool has no available connections and allows new connections to be created, a new database connection will be made. (RRf(RRR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRfscOs8|j||}y|j|=Wntk r3nXdS(s;Dispose the pool referenced by the given connect arguments.N(RRR (RRRR((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRbs  cOsKd|kr|dStt|gt|D]}|||f^q-S(NR(ttupleRtsorted(RRRtk((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyRs   ( R!R"R#RRFRRRRRfRbR(((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyR s       ((R#R[RR|RRRRRRRRRRRt collectionsR R RRtsymbolRRRtobjectRt IdentifiedR$RUR)RvRR~RRRRRRRR (((sU/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/pool.pyts4   (   % O*0>