/opt/cloudlinux/venv/lib/python3.11/site-packages/sqlalchemy/__pycache__
Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/sqlalchemy/__pycache__/interfaces.cpython-311.pyc (15768B)
Uh< Z d Z ddlmZ ddlmZ G d de Z G d de ZdS ) a Deprecated core event interfaces.
.. deprecated:: 0.7
As of SQLAlchemy 0.7, the new event system described in
:ref:`event_toplevel` replaces the extension/proxy/listener system,
providing a consistent interface to all events without the need for
subclassing.
)event)utilc @ e Zd ZdZed Zd Zd Zd Zd Z dS ) PoolListenera Hooks into the lifecycle of connections in a :class:`_pool.Pool`.
.. deprecated:: 0.7
:class:`.PoolListener` is deprecated and will be removed in a future
release. Please refer to :func:`.event.listen` in conjunction with
the :class:`_events.PoolEvents` listener interface.
Usage::
class MyListener(PoolListener):
def connect(self, dbapi_con, con_record):
'''perform connect operations'''
# etc.
# create a new pool with a listener
p = QueuePool(..., listeners=[MyListener()])
# add a listener after the fact
p.add_listener(MyListener())
# usage with create_engine()
e = create_engine("url://", listeners=[MyListener()])
All of the standard connection :class:`~sqlalchemy.pool.Pool` types can
accept event listeners for key connection lifecycle events:
creation, pool check-out and check-in. There are no events fired
when a connection closes.
For any given DB-API connection, there will be one ``connect``
event, `n` number of ``checkout`` events, and either `n` or `n - 1`
``checkin`` events. (If a ``Connection`` is detached from its
pool via the ``detach()`` method, it won't be checked back in.)
These are low-level events for low-level objects: raw Python
DB-API connections, without the conveniences of the SQLAlchemy
``Connection`` wrapper, ``Dialect`` services or ``ClauseElement``
execution. If you execute SQL through the connection, explicitly
closing all cursors and other resources is recommended.
Events also receive a ``_ConnectionRecord``, a long-lived internal
``Pool`` object that basically represents a "slot" in the
connection pool. ``_ConnectionRecord`` objects have one public
attribute of note: ``info``, a dictionary whose contents are
scoped to the lifetime of the DB-API connection managed by the
record. You can use this shared storage area however you like.
There is no need to subclass ``PoolListener`` to handle events.
Any class that implements one or more of these methods can be used
as a pool listener. The ``Pool`` will inspect the methods
provided by a listener object and add the listener to one or more
internal event queues based on its capabilities. In terms of
efficiency and function call overhead, you're much better off only
providing implementations for the hooks you'll be using.
c P g d}t j || }|D ]Z}t t | }t ||d }|0t j || st j d|d|d [t
|d rt j |d|j t
|d rt j |d|j
t
|d rt j |d |j t
|d
r t j |d
|j dS dS ) z^Adapt a :class:`.PoolListener` to individual
:class:`event.Dispatch` events.
)connect
first_connectcheckoutcheckin)methodsNz
PoolListener.z is deprecated. The PoolListener class will be removed in a future release. Please transition to the @event interface, using @event.listens_for(Engine, '').r r r
r )
r as_interfacegetattrr methods_equivalentwarn_deprecatedhasattrr listenr r r
r )clsselflistenerr methme_methls_meths i/builddir/build/BUILD/cloudlinux-venv-1.0.12/venv/lib64/python3.11/site-packages/sqlalchemy/interfaces.py_adapt_listenerz PoolListener._adapt_listenerR sZ FEE$Xw??? D lD11G hd33G"4+B, ," $$ BFtttM 8Y ' ' < Ly(*: ; ; ; 8_ - - H L0F G G G 8Z ( ( > Lz8+< = = = 8Y ' ' < Ly(*: ; ; ; ; ; < < c dS )a( Called once for each new DB-API connection or Pool's ``creator()``.
dbapi_con
A newly connected raw DB-API connection (not a SQLAlchemy
``Connection`` wrapper).
con_record
The ``_ConnectionRecord`` that persistently manages the connection
N r dbapi_con
con_records r r zPoolListener.connects r c dS )a Called exactly once for the first DB-API connection.
dbapi_con
A newly connected raw DB-API connection (not a SQLAlchemy
``Connection`` wrapper).
con_record
The ``_ConnectionRecord`` that persistently manages the connection
Nr r s r r zPoolListener.first_connect r" r c dS )aC Called when a connection is retrieved from the Pool.
dbapi_con
A raw DB-API connection
con_record
The ``_ConnectionRecord`` that persistently manages the connection
con_proxy
The ``_ConnectionFairy`` which manages the connection for the span of
the current checkout.
If you raise an ``exc.DisconnectionError``, the current
connection will be disposed and a fresh connection retrieved.
Processing of all checkout listeners will abort and restart
using the new connection.
Nr )r r r! con_proxys r r
zPoolListener.checkout r" r c dS )a Called when a connection returns to the pool.
Note that the connection may be closed, and may be None if the
connection has been invalidated. ``checkin`` will not be called
for detached connections. (They do not return to the pool.)
dbapi_con
A raw DB-API connection
con_record
The ``_ConnectionRecord`` that persistently manages the connection
Nr r s r r zPoolListener.checkin r" r N)
__name__
__module__ __qualname____doc__ classmethodr r r r
r r r r r r sw 7 7r < < [ <@
&
r r c r e Zd ZdZed Zd Zd Zd Zd Z d Z
dd Z d
Z d Z
d Zd
Zd Zd ZdS )ConnectionProxya> Allows interception of statement execution by Connections.
.. deprecated:: 0.7
:class:`.ConnectionProxy` is deprecated and will be removed in a future
release. Please refer to :func:`.event.listen` in conjunction with
the :class:`_events.ConnectionEvents` listener interface.
Either or both of the ``execute()`` and ``cursor_execute()``
may be implemented to intercept compiled statement and
cursor level executions, e.g.::
class MyProxy(ConnectionProxy):
def execute(self, conn, execute, clauseelement,
*multiparams, **params):
print "compiled statement:", clauseelement
return execute(clauseelement, *multiparams, **params)
def cursor_execute(self, execute, cursor, statement,
parameters, context, executemany):
print "raw statement:", statement
return execute(cursor, statement, parameters, context)
The ``execute`` argument is a function that will fulfill the default
execution behavior for the operation. The signature illustrated
in the example should be used.
The proxy is installed into an :class:`~sqlalchemy.engine.Engine` via
the ``proxy`` argument::
e = create_engine('someurl://', proxy=MyProxy())
c
g d}|D ]W}t t | }t | }t j || st j d|d|d Xfd}t j |d| fd}t j |d| d
fd
} t j |d | j t j |d | j t j |d
| j t j |d | j
t j |d | j t j |d | j t j |d | j
t j |d | j t j |d | j t j |d | j d S )N) executecursor_executebeginrollbackcommit savepointrollback_savepointrelease_savepointbegin_twophaseprepare_twophaserollback_twophasecommit_twophasezConnectionProxy.z is deprecated. The ConnectionProxy class will be removed in a future release. Please transition to the @event interface, using @event.listens_for(Engine, 'r
c 0 d } j | ||g|R i |S )Nc | ||fS Nr )
clauseelement multiparamsparamss r execute_wrapperzOConnectionProxy._adapt_listener.
.adapt_execute..execute_wrapper s $k699r )r/ )connr> r? r@ rA r s r
adapt_executez6ConnectionProxy._adapt_listener..adapt_execute sL
:
:
: $8#o}7B FL
r before_executec > d } |||||| S )Nc
||fS r= r )cursor statement
parameterscontexts r rA zVConnectionProxy._adapt_listener..adapt_cursor_execute..execute_wrapper s
*,,r )r0 )rB rG rH rI rJ executemanyrA r s r adapt_cursor_executez=ConnectionProxy._adapt_listener..adapt_cursor_execute s>
-
-
- **
r before_cursor_executec d S r= r )argkws r do_nothing_callbackz.do_nothing_callback s Dr c < fd}t j | S )Nc " | g|R i | d S r= r )rB rO rP rQ fns r gozCConnectionProxy._adapt_listener..adapt_listener..go
s, 4,9s999b99999r )r update_wrapper)rT rU rQ s ` r adapt_listenerz7ConnectionProxy._adapt_listener..adapt_listener s7
:
:
:
:
:
: &r2.. .r r1 r2 r3 r4 r5 r6 r7 r8 r9 r: )r r- r r r r r r1 r2 r3 r4 r5 r6 r7 r8 r9 r: ) r r r r r r r rC rL rW rQ s ` @r r z ConnectionProxy._adapt_listener s
D ot44G h--G*7G<<
$$ BFtttM T+];;;
T24HIII / / / / / T7NN8>$B$BCCC
T:~~h6G'H'HIII
T8^^HO%D%DEEE
T;x7I(J(JKKK
N86 7 7
N85 6 6
"NN83J$K$K
$nnX5N&O&O
N85 6 6
#^^H4L%M%M
r c ||g|R i |S )z&Intercept high level execute() events.r )r rB r/ r> r? r@ s r r/ zConnectionProxy.execute/ s$ w}={===f===r c ||||| S )z,Intercept low-level cursor execute() events.r )r r/ rG rH rI rJ rK s r r0 z ConnectionProxy.cursor_execute4 s
wvy*g>>>r c | S )zIntercept begin() events.r )r rB r1 s r r1 zConnectionProxy.begin; s uwwr c | S )z Intercept rollback() events.r )r rB r2 s r r2 zConnectionProxy.rollback@ s xzzr c | S )zIntercept commit() events.r )r rB r3 s r r3 zConnectionProxy.commitE s vxxr Nc || S )z Intercept savepoint() events.)namer )r rB r4 r^ s r r4 zConnectionProxy.savepointJ s yd####r c ||| S )z&Intercept rollback_savepoint() events.r )r rB r5 r^ rJ s r r5 z"ConnectionProxy.rollback_savepointO s "!$000r c ||| S )z%Intercept release_savepoint() events.r )r rB r6 r^ rJ s r r6 z!ConnectionProxy.release_savepointT s ! w///r c || S )z"Intercept begin_twophase() events.r )r rB r7 xids r r7 z ConnectionProxy.begin_twophaseY s ~c"""r c || S )z$Intercept prepare_twophase() events.r )r rB r8 rb s r r8 z ConnectionProxy.prepare_twophase^ s $$$r c ||| S )z%Intercept rollback_twophase() events.r )r rB r9 rb is_prepareds r r9 z!ConnectionProxy.rollback_twophasec s ! k222r c ||| S )z#Intercept commit_twophase() events.r )r rB r: rb re s r r: z ConnectionProxy.commit_twophaseh s sK000r r= )r' r( r) r* r+ r r/ r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 r: r r r r- r- s D [
[
[[
z> > >
? ? ?
$ $ $ $
1 1 1
0 0 0
# # #
% % %
3 3 3
1 1 1 1 1r r- N)r* r r objectr r- r r r ri s S S S S S 6 S S S l}1 }1 }1 }1 }1f }1 }1 }1 }1 }1r