�
���ec@s%
dZd
dl
mZ
d
dlZd
dlZddlmZ
ddlmZ
ddlmZ
ddlm	Z	
e	j
d	�
Ze	j
d
�
Ze	j
d�
Z
def
d
��YZdef
d��YZdejf
d��YZdef
d��YZeed�ZiZdef
d��YZdS(s'Base constructs for connection pools.

i����(
tdequeNi(
tevent(
texc(
tlog(
tutiltreset_rollbacktreset_committ
reset_nonet_ConnDialectc
BsPeZ
dZeZeZd
�Zd�Zd�Zd�Z	d�Z
d�ZRS(s�partial implementation of :class:`.Dialect`
    which provides DBAPI connection methods.

    When a :class:`_pool.Pool` is combined with an :class:`_engine.Engine`,
    the :class:`_engine.Engine` replaces this with its own
    :class:`.Dialect`.

    c
Cs|
j�
dS(
N(
trollback(tselftdbapi_connection((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdo_rollback)s
c
Cs|
j�
dS(
N(
tcommit(R
R((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt	do_commit,s
c
Cs|
j�
dS(
N(
tclose(R
R((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdo_terminate/s
c
Cs|
j�
dS(
N(
R(R
R((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdo_close2s
cCstd
�
�
dS(NsJThe ping feature requires that a dialect is passed to the connection pool.(
tNotImplementedError(R
R((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdo_ping5s

c
Cs|
S(
N((R
t
connection((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytget_driver_connection;s
(t__name__t
__module__t__doc__tFalsetis_asynct
has_terminateRRRRRR(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRs
					t_AsyncConnDialectc
BseZ
eZRS((RRtTrueR(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR?s
tPoolc	Bs�eZ
dZe�Zd
ddeddedd�Ze	j
d��
Zed��
Z
e
jd��
Z
d�Zed�
Zd�Zded	�Zd
�Zd�Zd�Zd
�Zd�Zd�Zd�ZRS(s)Abstract base class for connection pools.i����c
Cs
|r||_|_
n	d	|_
tj|d
|�


|
|_||_d|_||_t	j
j|idtgt
6dd	tgt6dg
t6ddt�
|_||_|	r�|jj|	dt�


n|r�||_n|r
x*|D]\}
}tj|||
�
q�Wnd	S(
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 a value other than -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, the connection pool will log
         informational output such as when connections are invalidated
         as well as when connections are recycled to the default log handler,
         which defaults to ``sys.stdout`` for output..   If set to the string
         ``"debug"``, the logging will include pool checkouts and checkins.

         The :paramref:`_pool.Pool.echo` parameter can also be set from the
         :func:`_sa.create_engine` call by using the
         :paramref:`_sa.create_engine.echo_pool` parameter.

         .. seealso::

             :ref:`dbengine_logging` - further detail on how to configure
             logging.

        :param reset_on_return: Determine steps to take on
         connections as they are returned to the pool, which were
         not otherwise handled by a :class:`_engine.Connection`.
         Available from :func:`_sa.create_engine` via the
         :paramref:`_sa.create_engine.pool_reset_on_return` parameter.

         :paramref:`_pool.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.
         * ``"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 may be appropriate if the database / DBAPI
           works in pure "autocommit" mode at all times, or if
           a custom reset handler is established using the
           :meth:`.PoolEvents.reset` event handler.
         * ``True`` - same as 'rollback', this is here for
           backwards compatibility.
         * ``False`` - same as None, this is here for
           backwards compatibility.

         For further customization of reset on return, the
         :meth:`.PoolEvents.reset` event hook may be used which can perform
         any connection activity desired on reset.  (requires version 1.4.43
         or greater)

         .. seealso::

            :ref:`pool_reset_on_return`

        :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:`_sa.create_engine` before dialect-level
         listeners are applied.

        :param dialect: a :class:`.Dialect` that will handle the job
         of calling rollback(), close(), or commit() on DBAPI connections.
         If omitted, a built-in "stub" dialect is used.   Applications that
         make use of :func:`_sa.create_engine` should not use this parameter
         as it is handled by the engine creation strategy.

         .. versionadded:: 1.1 - ``dialect`` is now a public parameter
            to the :class:`_pool.Pool`.

        :param pre_ping: if True, the pool will emit a "ping" (typically
         "SELECT 1", but is dialect-specific) on the connection
         upon checkout, to test if the connection is alive or not.   If not,
         the connection is transparently re-connected and upon success, all
         other pooled connections established prior to that timestamp are
         invalidated.     Requires that a dialect is passed as well to
         interpret the disconnection error.

         .. versionadded:: 1.2

        techoflagiR	tnoneR
treset_on_returntresolve_symbol_namestonly_propagateN(tlogging_namet_orig_logging_nametNoneRtinstance_loggert_creatort_recyclet_invalidate_timet	_pre_pingRtsymboltparse_user_argumentRRRRRt_reset_on_returntechotdispatcht_updatet_dialectR
tlisten(R
tcreatortrecycleR/R$R!teventstdialecttpre_pingt	_dispatchtfnttarget((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt__init__Is0m
	
	
	
	
	
	







	





c


Cs
|jj
S(
N(R2R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_is_asyncio�sc

Cs|jd
S(NR((
t__dict__(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR(�scCs#|
|jd
<|j
|
�
|_dS(NR((R>t_should_wrap_creatort_invoke_creator(R
R4((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR(�s

cs�ytj
|jd
t�

}Wntk
r9


�f
d�SX|ddk	rZt|d�
p]d}t|d�
|}|d|dfdg
d	fkr��S|dkr��S�f
d�SdS(
slDetect if creator accepts a single argument, or is sent
        as a legacy style no-arg function.

        tno_selfc


s��S(
N((
tcrec(
R4(sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt<lambda>�tiitconnection_recordi
c


s��S(
N((
RB(
R4(sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRC�RDN(
N(Rtget_callable_argspecR(Rt	TypeErrorR&tlen(R
R4targspect	defaultedtpositionals((
R4sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR?�s



&
#

cCs�|jj
d
|rdnd|
�
y-|r>|jj|
�

n|jj|
�

WnAtk
r�
}
|jjd|
dt�

t|t	�s��q�n
XdS(Ns%s connection %rsHard-closingtClosingsException closing connection %rtexc_info(
tloggertdebugR2RRt
BaseExceptionterrorRt
isinstancet	Exception(R
Rt	terminatet
e((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_close_connection�s
	






	

c

Cs
t|�
S(
s6Called by subclasses to create a new ConnectionRecord.(
t_ConnectionRecord(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_create_connection
scCsit|
d
d�}|s+|j|jkr=tj�|_n|ret|
dt�re|
j|�

ndS(s�
Mark 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	starttimettimeRt
invalidate(R
Rt	exceptiont_checkintrec((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_invalidate
s




c


Cs
t��
d
S(s"
Return a new :class:`_pool.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.Pool` and create a new one in
        its place.

        N(
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytrecreate$
s
c


Cs
t��
d
S(s�Dispose 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.

        .. seealso::

            :meth:`Pool.recreate`

        N(
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdispose0
s
c

Cs
tj
|�
S(
s�Return 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.

        (t_ConnectionFairyt	_checkout(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytconnect?
scCs|j|
�

d
S(s�Given a _ConnectionRecord, return it to the :class:`_pool.Pool`.

        This method is called when an instrumented DBAPI connection
        has its ``close()`` method called.

        N(
t_do_return_conn(R
trecord((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_return_connI
sc


Cs
t��
d
S(s7Implementation for :meth:`get`, supplied by subclasses.N(
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_do_getR
sc
Cs
t��
d
S(s?Implementation for :meth:`return_conn`, supplied by subclasses.N(
R(R
tconn((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRhW
sc


Cs
t��
dS(
N(
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytstatus\
s
N(RRRRR2R&RRR<RthybridpropertyR=tpropertyR(tsetterR?RVRXRbRcRdRgRjRkRhRm(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRCs0	






�					
				RWcBs
eZ
dZed
�
ZeZdZdZ	dZ
ed��
Zed��
Z
e
jd��
Z
dZejd��
Zejd��
Zed��
Zed	�
Zed
�
Zed��
Zed��
Zd
�Zded�Zd�Zd�Zed�
Zd�ZRS(s�Internal object which maintains an individual DBAPI connection
    referenced by a :class:`_pool.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.Pool`
    next uses this record.

    The :class:`._ConnectionRecord` is delivered along with connection
    pool events, including :meth:`_events.PoolEvents.connect` and
    :meth:`_events.PoolEvents.checkout`, however :class:`._ConnectionRecord`
    still
    remains an internal object whose API and internals may change.

    .. seealso::

        :class:`._ConnectionFairy`

    cCs,|
|_|r|j
�
nt�|_dS(
N(t_ConnectionRecord__poolt_ConnectionRecord__connectRtfinalize_callback(R
tpoolRg((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR<�
s
	



c

Cs-|jd
krd
S|jjj|j�
Sd
S(s<The connection object as returned by the driver after a connect.

        For normal sync drivers that support the DBAPI protocol, this object
        is the same as the one referenced by
        :attr:`._ConnectionRecord.dbapi_connection`.

        For adapted drivers, like the Asyncio ones, this is the actual object
        that was returned by the driver ``connect`` call.

        As :attr:`._ConnectionRecord.dbapi_connection` it may be ``None``
        if this :class:`._ConnectionRecord` has been marked as invalidated.

        .. versionadded:: 1.4.24

        N(RR&RqR2R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytdriver_connection�
s

c


Cs|jS(
s�An alias to :attr:`._ConnectionRecord.dbapi_connection`.

        This alias is deprecated, please use the new name.

        .. deprecated:: 1.4.24

        (
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�
s	cCs
|
|_dS(
N(
R(R
tvalue((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�
sic


CsiS(
s`The ``.info`` dictionary associated with the DBAPI connection.

        This dictionary is shared among the :attr:`._ConnectionFairy.info`
        and :attr:`_engine.Connection.info` accessors.

        .. note::

            The lifespan of this dictionary is linked to the
            DBAPI connection itself, meaning that it is **discarded** each time
            the DBAPI connection is closed and/or invalidated.   The
            :attr:`._ConnectionRecord.record_info` dictionary remains
            persistent throughout the lifespan of the
            :class:`._ConnectionRecord` container.

        ((
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytinfo�
sc


CsiS(
s�
An "info' dictionary associated with the connection record
        itself.

        Unlike the :attr:`._ConnectionRecord.info` dictionary, which is linked
        to the lifespan of the DBAPI connection, this dictionary is linked
        to the lifespan of the :class:`._ConnectionRecord` container itself
        and will remain persistent throughout the life of the
        :class:`._ConnectionRecord`.

        .. versionadded:: 1.1

        ((
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytrecord_info�
scs��
j��y�j
�}Wn<tk
rZ
}
tj��
�j|d
t�


WdQX�n
X�
j��t|���}t	j
|��
�fd���_}�t|<�r��
j
jd|�
n|S(Nt_fairy_was_createdc

s"to!td��
|�d
t�
S(Nttransaction_was_reset(t_finalize_fairyR&R(
tref(R/RtRa(sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRC�
s

s#Connection %r checked out from pool(Rktget_connectionRPRtsafe_reraiset_checkin_failedRt_should_log_debugRetweakrefR|t	fairy_reft_strong_ref_connection_recordsRNRO(tclsRtRterrtfairyR|((R/RtRasE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytcheckout�
s"











	

cCs$|jd
|
�

|j
d|�

dS(NRURy(R^tcheckin(R
R�Ry((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRs

	
cCs�|jdkr*|
r*tjd
|�

dSd|_|j}|j}x&|jrm|jj�}||�

qHW|jj	r�|jj	||�
n|j
|�

dS(NsDouble checkin attempted on %s(R�R&RtwarnRRqRstpopR0R�Rj(R
RyRRtt	finalizer((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�s


	
	
	




c

Cs
|jdk	S(
N(R�R&(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytin_use$sc


Cs|jS(
N(
R\(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pytlast_connect_time(sc

Cs |jdk	r|j�
ndS(
N(RR&t_ConnectionRecord__close(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR,s

cCs�|jd
krd
S|r8|jjj|j||
�
n|jjj|j||
�
|
d
k	r�|jjjd|r{dnd|j|
jj	|
�
n(|jjjd|r�dnd|j�
|r�t
j
�|_n|jdt
�

d
|_d
S(s�Invalidate the DBAPI connection held by this
        :class:`._ConnectionRecord`.

        This method is called for all connection invalidations, including
        when the :meth:`._ConnectionFairy.invalidate` or
        :meth:`_engine.Connection.invalidate` methods are called,
        as well as when any
        so-called "automatic invalidation" condition occurs.

        :param e: an exception object indicating a reason for the
          invalidation.

        :param soft: if True, the connection isn't closed; instead, this
          connection will be recycled on next checkout.

         .. versionadded:: 1.0.3

        .. seealso::

            :ref:`pool_connection_invalidation`

        Ns*%sInvalidate connection %r (reason: %s:%s)sSoft RDs%sInvalidate connection %rRT(RR&RqR0tsoft_invalidateR^RNRwt	__class__RR]t_soft_invalidate_timeR�R(R
RUtsoft((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR^0s*









	







c
Cs,
t}
|j
dkr/|jj�
|j�
n�|jjd
kr�tj�|j	|jjkr�|jj
jd|j
�
t}
ns|jj|j	kr�|jj
jdd|j
�
t}
n8|j
|j	kr�|jj
jdd|j
�
t}
n|
r%
|jdt�

|jj�
|j�
n|j
S(Ni����s)Connection %r exceeded timeout; recyclings4Connection %r invalidated due to pool invalidation; t	recyclings:Connection %r invalidated due to local soft invalidation; RT(RRR&RwtclearRrRqR)R]R\RNRR*R�R�(R
R5((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR}es6








	





	





	




c

Cs4|jdkp3|jj|jkp3|j|jkS(
N(RR&RqR*R\R�(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_is_hard_or_soft_invalidated�s

cCs^|jj
�
|jjjr8|jjj|j|�
n|jj|jd
|
�


d|_dS(NRT(RsR�RqR0RRRVR&(R
RT((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt__close�s




	
c
Cs�|j}
d|_yEtj�|_|
j|�
|_}|
jjd
|�
t|_	Wn9t
k
r�
}
tj��
|
jjd|�
WdQXnZX|
j
jr�|
j
jj|
j
�
j|j|�
n|
j
jj|
j
�
j|j|�
dS(NsCreated new connection %rsError on connect(): %s(RqR&RR]R\R@RNRORtfreshRPRR~R0t
first_connectt
for_modifytexec_once_unless_exceptionRgt_exec_w_sync_on_first_run(R
RtRRU((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt	__connect�s"
		














N( RRRRR<RR�R&R�R\RRoRuRRpR�Rtmemoized_propertyRwRxtclassmethodR�RR�R�R�RR^R}R�R�Rr(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRW`
s.	5	1		cCs7|rtj
|d
�
n"|r;tj
tj|�
d
�
n|d
k	rx|
j|k	rZd
S|d
kslt�
|
j}n|jj	o�|jj
}|r�|
p�|}|}	n
|
}t}	|d
k	r|
r�|r�|jj
d|�
ny�|p

t||
|�}|j|ks
t�
|	r2
|j||�
n|r�
|
rT
||_|j�
n|	r�
|jjry
|jj|�

n|j|�

q�
d|}
|jj|
�

tj|
�

nWqtk
r

}
|jjddt�


|
r�
|
jd|�

nt|t�s�qqXn|
r3|
jd
k	r3|
j�
nd
S(sc
Cleanup for a :class:`._ConnectionFairy` whether or not it's already
    been garbage collected.

    When using an async dialect no IO can happen here (without using
    a dedicated thread), since this is called outside the greenlet
    context and with an already running loop. In this case function
    will only log a message and raise a warning.
    Ns$Connection %r being returned to poolsd
The garbage collector is trying to clean up connection %r. This feature is unsupported on unsupported on asyncio dbapis that lack a "terminate" feature, since no IO can be performed at this stage to reset the connection. Please close out all connections when they are no longer used, calling ``close()`` or using a context manager to manage their lifetime.s!Exception during reset or similarRMRU(R�R�R&R�R|R�tAssertionErrorRR2RRRRNRORet_resett_pooltdetachR0tclose_detachedRVRQRR�RPR^RRRSR�(RRERtR|R/RzR�tdont_restore_gcedR�tcan_manipulate_connectiontmessageRU((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR{�sb













	



	


	



	



	


	






RecBs

eZ
dZd
�ZdZdZed��
Zed��
Z	e	j
d��
Z	eddd��
Zd�Z
ed�
ZeZed�
Zed	��
Zed
��
Zejd��
Zed��
Zded
�Zd�Zd�Zd�Zd�Zed�
ZRS(sbProxies a DBAPI connection and provides return-on-dereference
    support.

    This is an internal object used by the :class:`_pool.Pool` implementation
    to provide context management to a DBAPI connection delivered by
    that :class:`_pool.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(RRYt_echo(R
RRER/((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR<?s
	
	
c


Cs
|jj
S(
s
The connection object as returned by the driver after a connect.

        .. versionadded:: 1.4.24

        .. seealso::

            :attr:`._ConnectionFairy.dbapi_connection`

            :attr:`._ConnectionRecord.driver_connection`

            :ref:`faq_dbapi_connection`

        (RYRu(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRu[sc


Cs|jS(
s�An alias to :attr:`._ConnectionFairy.dbapi_connection`.

        This alias is deprecated, please use the new name.

        .. deprecated:: 1.4.24

        (
R(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRls	cCs
|
|_dS(
N(
R(R
Rv((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRwscCs|sKtj
|
�
}|
|_d
|_|dk	rKtj|�
|_qKn|jdkrlt	j
d�
�
n|jd7_|
jj
r�|
js�|jdkr�|Sd}x0|d
kr�|j
j}t|j
_y�|
jrz
|sU
|jr
|
jjd|j�
n|
jj|j�
}|sw
|jrC
|
jjd|j�
nt	j��
qw
qz
|jrz
|
jjd|j�
qz
n|
jj
|j|j
|�
|SWq�t	jk
r�
}
|jr�
|
jjd|�
|j
j|�

|
j||d	t�

n)|
jjd
|j|�
|j
j|�

y|j
j�|_Wn?tk
ru
}
tj��
|j
j|dt �


~WdQXn
X|d8}q�tk
r�
}	
tj��3
|j
}
|
dk	r�|
j|	dt �


n~WdQX�q�Xq�W|
jjd�

|j�
t	j
d�
�
dS(
NisThis connection is closedi
isPool pre-ping on connection %ss;Pool pre-ping on connection %s failed, will invalidate pools)Connection %s is fresh, skipping pre-pingsoDisconnection detected on checkout, invalidating all pooled connections prior to current timestamp (reason: %r)R`sVDisconnection detected on checkout, invalidating individual connection %s (reason: %r)Rys+Reconnection attempts exhausted on checkout(!RWR�R�t_counterR&R�R|tcurrentRRtInvalidRequestErrorR0R+RYR�RR�RNROR2RtInvalidatePoolErrortDisconnectionErrortinvalidate_poolRwR^RbR}RPRR~RR(R�RttthreadconnsR�tattemptstconnection_is_freshtresultRUR�tbe_outerRa((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRf{s�
	
	








	

	
	




	
	


	
	

	


	
	

	





	







	




	


c

Cstj
|jd
|�

S(NR�(ReRfR�(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_checkout_existing�s
c
CsDt|j
|j|jd|jd
|
d|�
d|_
d|_dS(NRzR�(R{RRYR�R&R�(R
Rz((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR`�s





	

	
cCs�|
jj
r%|
jj
||j�
n|
jtkr�|r_|jr�|
jjd
|j�
q�q�|jr�|
jjd|j�
n|
j	j
|�

nD|
jtkr�|jr�|
jjd|j�
n|
j	j|�

ndS(Ns.Connection %s reset, transaction already resets Connection %s rollback-on-returnsConnection %s commit-on-return(
R0tresetRYR.RR�RNRORR2RRR(R
RtRz((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR��s&




	
	

	
	




	
	


c


Cs
|jj
S(
N(R�RN(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_loggersc

Cs
|jd
k	S(sbReturn True if this :class:`._ConnectionFairy` still refers
        to an active DBAPI connection.N(RR&(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRZsc


Cs
|jj
S(
s�Info 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:`_engine.Connection.info`
        accessors.

        The dictionary associated with a particular DBAPI connection is
        discarded when the connection itself is discarded.

        (RYRw(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRw"sc


Cs|jr|jj
Sd
Sd
S(s�
Info dictionary associated with the :class:`._ConnectionRecord
        container referred to by this :class:`.ConnectionFairy`.

        Unlike the :attr:`._ConnectionFairy.info` dictionary, the lifespan
        of this dictionary is persistent across connections that are
        disconnected and/or invalidated within the lifespan of a
        :class:`._ConnectionRecord`.

        .. versionadded:: 1.1

        N(RYRxR&(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRx5s
	

cCse|jdkr tjd
�

dS|jrE|jjd|
d|�
n|sad|_|j�
ndS(s�Mark this connection as invalidated.

        This method can be called directly, and is also called as a result
        of the :meth:`_engine.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.

        :param e: an exception object indicating a reason for the invalidation.

        :param soft: if True, the connection isn't closed; instead, this
         connection will be recycled on next checkout.

         .. versionadded:: 1.0.3

        .. seealso::

            :ref:`pool_connection_invalidation`

        s.Can't invalidate an already-closed connection.NRUR�(RR&RR�RYR^R`(R
RUR�((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR^Gs



	


	
c
Os|jj
|
|�S(
s�Return a new DBAPI cursor for the underlying connection.

        This method is a proxy for the ``connection.cursor()`` DBAPI
        method.

        (Rtcursor(R
targstkwargs((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�fscCst|j
|
�S(
N(R[R(R
tkey((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt__getattr__os
c
Cs�|jd
k	r�|j}
d
|
_d
|
_|jj|j�

|jj�|_d
|_|jjj	r�|jjj	|j|
�
q�nd
S(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(
RYR&R�RR�RhRwtcopyR0R�(R
Ra((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�rs

	
	
	

	
c

Cs/|jd
8_|jdkr+|j
�
ndS(Ni
i(R�R`(
R
((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyR�s


cCs5|jd
8_|jdkr1|j
d|
�

ndS(Ni
iRz(R�R`(R
ttransaction_reset((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt_close_special�s


N(RRRR<R&RRYRoRuRRpR�RfR�RR`t_closeR�R�RZRR�RwRxR^R�R�R�RR�(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyRe*s.	
p	
					(RtcollectionsRR]R�RDR
RRRR,RRRtobjectRRt
IdentifiedRRWRR&R{R�Re(((sE/opt/alt/python27/lib/python2.7/site-packages/sqlalchemy/pool/base.pyt<module>s(






#��j
]