Ytj:dZddlmZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z mZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZmZm Z m!Z!ddlm"Z"ddl#m$Z$m%Z%ddlm&Z&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4ddl-m5Z5m6Z6m7Z7ddl8m9Z9 ddl:Z:e;e:j<fZ=ej>dZ?Gddeee%Z@GddeeZAGddeZBGd d!eBZCGd"d#eBZDGd$d%eBZEGd&d'eBZFGd(d)eBZGdS)*z1 Psycopg connection pool module (async version). ) annotationsN)ABCabstractmethod) monotonic) TracebackType)AnyGenericcast)ref)asynccontextmanager)deque) AsyncIterator)AsyncConnection)errors)TransactionStatus)ACTAsyncConnectFailedCBAsyncConnectionCBAsyncConninfoParam)AsyncKwargsParam)AttemptWithBackoffBasePool) PoolClosed PoolTimeoutTooManyRequests)PSYCOPG_VERSIONAsyncPoolConnectionSelf) AConditionAEventALockAQueueAWorkeragatherasleep)aspawncurrent_task_name ensure_async)AsyncSchedulerTz psycopg.poolceZdZUded< dteeeedddddddddddd d d dd d dufd+Z dvfd/ Z dvd1Z dwdxd2Z e dydzd5Zdyd{d7Zd|d9Zd}d:Zd~d<Zdd>Zdvd?Zdd@ZdvdAZddCZddDZdddFZdvdGZ dvdHZdvdIZdvdJZddxdLZddNZddPZ ddWZ!dyddXZ"dvdYZ#e$ddZZ%dvd[Z&dd^Z'dd`Z(e)ddcZ*dyd{ddZ+ddfZ,ddhZ- dddlZ.ddmZ/ddnZ0ddoZ1ddpZ2dvdqZ3dfds Z4xZ5S)AsyncConnectionPoolz deque[ACT]_poolNF>@rg @g@gr@)connection_classkwargsmin_sizemax_sizeopen configurecheckresetname close_returnstimeout max_waiting max_lifetimemax_idlereconnect_timeoutreconnect_failed num_workersconninforr2 type[ACT]r3AsyncKwargsParam | Noner4intr5 int | Noner6 bool | Noner7AsyncConnectionCB[ACT] | Noner8r9r: str | Noner;boolr<floatr=r>r?r@rAAsyncConnectFailedCB | NonerBc R| rItdkr>|tur&tttt }nt d||_||_||_ ||_ ||_ | |_ ||_ |||ttt|_d|_d|_g|_t)||| | | | ||||  |r|| dx}|_|r|dSdS)N)r1r1zUsing 'close_returns=True' and a non-standard 'connection_class' requires psycopg 3.3 or newer. Please check the docs at https://www.psycopg.org/psycopg3/docs/advanced/pool.html#pool-sqlalchemy for a workaround.) r4r5r:r;r<r=r>r?r@rBT)rrr typerr TypeErrorrCr3r2_check _configure_reset_reconnect_failedr WaitingClient_waiting_pool_full_event _sched_runner_workerssuper__init___warn_open_asyncr"_lock_open_implicit_open)selfrCr2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rArB __class__s U/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/psycopg_pool/pool_async.pyr[zAsyncConnectionPool.__init__1s_,  _v55?22#'S 3F#G#G  9 !  0 # !1  # ,mC0133 04-1')  '#%/#   ! (%%''' <)- -D4&   JJLLLLL  returnNonecrt|ddrdS|}d}t|d|ddS)N_closedTzNyou can try to call 'close()' explicitly or to use the pool as context manager@)r< timeout_hint)getattr_signal_stop_workerr%)r`workershints rb__del__zAsyncConnectionPool.__del__sUtY-- ..00G8  Wc = = = = = =rcct|jrd|_ |dSdSNF) rZ_check_open_getconnr^r\warningswarnrO__name__DeprecationWarning)r`ras rbrqz'AsyncConnectionPool._check_open_getconnsS ##%%%   "'D  %%'''''  rcTctjdt|jdt|jdtdS)Nzopening the async pool z in the constructor is deprecated and will not be supported anymore in a future release. Please use `await pool.open()`, or use the pool as context manager using: `async with z(...) as pool: `...)rrrsrOrtRuntimeWarningr`s rbr\z$AsyncConnectionPool._warn_open_asyncsb MX$t***=XX04Dzz/BXXX      rccK||j4d{V|jrJt|j|jkr dddd{VdSt |_dddd{Vn#1d{VswxYwYtd|j |j |d{Vs-| d{Vtd|d|j4d{V|jsJd|_dddd{Vn#1d{VswxYwYtd|j dS)a- Wait for the pool to be full (with `min_size` connections) after creation. Close the pool, and raise `PoolTimeout`, if not ready within *timeout* sec. Calling this method is not mandatory: you can try and use the pool immediately after its creation. The first client will be served as soon as a connection is ready. You can use this method if you prefer your program to terminate in case the environment is not configured properly, rather than trying to stay up the hardest it can. Nz"waiting for pool %r initializationz%pool initialization incomplete after  seczpool %r is ready to use) rqr]rWlenr- _min_sizer!loggerinfor: wait_timeoutcloser)r`r<s rbwaitzAsyncConnectionPool.waits   """: - - - - - - - -, , ,,4:$.00 - - - - - - - - - - - - - -%+HHD !  - - - - - - - - - - - - - - - - - - - - - - - - - - -  8$)DDD*77@@@@@@@@ U**,,       SgSSSTT T: ) ) ) ) ) ) ) )( ( (($(D ! ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) )  -ty99999s)(BB BBD22 D<?D< float | NoneAsyncIterator[ACT]c $K||d{V} t}|4d{V|WVdddd{Vn#1d{VswxYwY||d{Vt}|j|jxxt d||z zz cc<dS#||d{Vt}|j|jxxt d||z zz cc<wxYw)a&Context manager to obtain a connection from the pool. Return the connection immediately if available, otherwise wait up to *timeout* or `self.timeout` seconds and throw `PoolTimeout` if a connection is not available in time. Upon context exit, return the connection to the pool. Apply the normal :ref:`connection context behaviour ` (commit/rollback the transaction in case of success/error). If the connection is no more in working state, replace it with a new one. r<N@@)getconnrputconn_stats _USAGE_MSrF)r`r<connt0t1s rb connectionzAsyncConnectionPool.connections\\'\22222222 CB                                    ,,t$$ $ $ $ $ $ $ $B K ' ' '3vb/A+B+B B ' ' ' ' ',,t$$ $ $ $ $ $ $ $B K ' ' '3vb/A+B+B B ' ' ' ' ' ' 's.B7AB7 AB7AB77ADrcTK||j}t|z}td|j|j|jxxdz cc<| ||d{VS#t$rtd|dddwxYw)aObtain a connection from the pool. You should preferably use `connection()`. Use this function only if it is not possible to use the connection as context manager. After using this function you *must* call a corresponding `putconn()`: failing to do so will deplete the pool. A depleted pool is a sad pool: you don't want a depleted pool. Nzconnection requested from %rr couldn't get a connection after .2frz) r<rr}r~r:r _REQUESTS_NUMrq_getconn_with_check_loopr)r`r<deadlines rbrzAsyncConnectionPool.getconns ?lG;;( 2DI>>> D&'''1,'''   """ 66x@@@@@@@@ @   D7DDDD  s ,B B'rc&Kd} ||tz d{V} ||d{Vtd|j|S#t $r ||dd{VYnwxYwt}|st||z }n| || |rtt|j d{V )NTzconnection given by %r from_getconnr)_getconn_uncheckedr_check_connectionr}r~r:CLIENT_EXCEPTIONS_putconnr update_delaytime_to_give_uprr&delay)r`rattemptrnows rbrz,AsyncConnectionPool._getconn_with_check_loopsV-1 ,00IKK1GHHHHHHHHD ,,T222222222 4di@@@ % = = =mmDtm<<<<<<<<<<< =++C *,X^DDD$$S)))&&s++ ,!mm#W]++++++++++ ,sA..'BBc jK|j4d{V||d{Vx}sdt}t}|j||j|jxxdz cc<|dddd{Vn#1d{VswxYwY|s | |d{V}nZ#t$rM|j r*| t||j d|j|jxxdz cc<wxYw t}|j|jxxt!d||z zz cc<n@#t}|j|jxxt!d||z zz cc<wxYw||_|S)NrrTrr)r]_get_ready_connectionrrUrVappendr_REQUESTS_QUEUED_maybe_grow_poolrrrrun_taskReturnConnection_REQUESTS_ERRORS_REQUESTS_WAIT_MSrFr-)r`r<rrposrs rbrz&AsyncConnectionPool._getconn_uncheckeds: ( ( ( ( ( ( ( (#'#=#=g#F#FFFFFFFGD ([[*7// $$S))) D1222a7222%%''' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( O O XXgX66666666$   8WMM"24PT"U"U"UVVV D1222a7222  [[ D2333s6R"W;M7N7NN3333[[ D2333s6R"W;M7N7NN3333333   s1BB$$ B.1B.8CE,AD,,E,,=F) ACT | NonecK||dkrtd}|jrP|j}t|j|jkrt|j|_nk|jrdt|j|jkrG|j|jxxdz cc<td|j dt|jd|S)z0Return a connection, if the client deserves one.Ngr the pool z has already z requests waiting) rr-popleftr{ _nconns_minr=rVrrrr:)r`r<rs rbrz)AsyncConnectionPool._get_ready_connection?s  7c>>--  : :%%''D4:!111#&tz??   #dm"4"48H"H"H K- . . .! 3 . . .!:DI:: &&:::  rcrcK|jsdS ||d{VdS#t$r!}td|d}~wwxYw)Nzconnection failed check: %s)rQrr}r~)r`res rbrz%AsyncConnectionPool._check_connectionRs{{  F ++d## # # # # # # # # #     KK5q 9 9 9  s* AAAc|j|jks|jrdS|xjdz c_td|j|jd|_|t|ddS)Nrgrowing pool %r to %sTgrowing)_nconns _max_size_growingr}r~r:r AddConnectionrxs rbrz$AsyncConnectionPool._maybe_grow_pool[sv <4> ) )T] ) F   +TY EEE  mD$77788888rccK||td|j||d{VrdS||dd{VdS)zReturn a connection to the loving hands of its pool. Use this function only paired with a `getconn()`. You don't need to use it if you use the much more comfortable `connection()` context manager. zreturning connection to %rNFr)_check_pool_putconnr}r~r:_maybe_close_connectionrr`rs rbrzAsyncConnectionPool.putconnes   &&& 0$)<<<--d33 3 3 3 3 3 3  FmmDum55555555555rccpK|j4d{Vt|j}|jt |_dddd{Vn#1d{VswxYwY|D]?}||d{V|t|@dS)ak Remove all the connections from the pool and create new ones. If a connection is currently out of the pool it will be closed when returned to the pool and replaced with a new one. This method is useful to force a connection re-configuration, for example when the adapters map changes after the pool was created. N) r]listr-clearr _drained_at_close_connectionrrr`connsrs rbdrainzAsyncConnectionPool.draintsL: + + + + + + + +$$E J     ({{D  + + + + + + + + + + + + + + + + + + + + + + + + + + +  / /D((.. . . . . . . . MM--- . . . . / /sAA## A-0A-rcK|jr'|t|||dS|||d{VdSNr)rSrr_return_connectionr`rrs rbrzAsyncConnectionPool._putconnsj ; K MM*4LQQQ R R R R R))$\)JJ J J J J J J J J JrccRK|jsdS||d{VdS)zgClose a returned connection if necessary. Return `!True if the connection was closed. FNT)rgrrs rbrz+AsyncConnectionPool._maybe_close_connectionsB| 5$$T*********trcrcK ||j4d{V|dddd{Vn#1d{VswxYwY|r||d{VdSdS)a`Open the pool by starting connecting and and accepting clients. If *wait* is `!False`, return immediately and let the background worker fill the pool if `min_size` > 0. Otherwise wait up to *timeout* seconds for the requested number of connections to be ready (see `wait()` for details). It is safe to call `!open()` again on a pool already open (because the method was already called, or because the pool context was entered, or because the pool was initialized with *open* = `!True`) but you cannot currently re-open a closed pool. TNr) _ensure_lockr]r_r)r`rr<s rbr6zAsyncConnectionPool.opens!      :         JJLLL                             -))G),, , , , , , , , , , - -sA  AAc"|jsdS| |t|_t |_d|_d|_|| dS)NTF) rg _check_openrr#_tasksr*_sched_opened_start_workers_start_initial_tasksrxs rbr_zAsyncConnectionPool._opens|  F        hh $&&     !!#####rcc |jdS#t$rYnwxYw tjn3#t$r&t t |jddwxYwt|_dS)z;Make sure the pool lock is created and the loop is running.Nz open with no running loop)r]AttributeErrorasyncioget_running_loop RuntimeErrorrOrtr"rxs rbrz AsyncConnectionPool._ensure_locks  !     (****   "Dzz*FFF  DJJJs 00A ct|jj|jd|_|jrJt |jD]C}t|j|j f|jd|}|j |DdS)Nz -scheduler)r:z-worker-)argsr:) r'rrunr:rXrYrangerBworkerrr)r`its rbrz"AsyncConnectionPool._start_workerss#DKOTY:R:R:RSSS=   t'(( $ $At{$+>W>WTU>W>WXXXA M  # # # # $ $rcct|jD]$}|t|%|t |t ||jdSN)rrrrSchedule ShrinkPoolr?)r`rs rbrz(AsyncConnectionPool._start_initial_taskssht|$$ / /A MM--- . . . . htZ%5%5t}EEFFFFFrcrhcK|jrdS|j4d{Vd|_td|jt |j}|jt |j}|j| d{V}dddd{Vn#1d{VswxYwYt|d|id{V|D]}| |d{V|D]3}| td|jdd{V4dS)aClose the pool and make it unavailable to new clients. All the waiting and future clients will fail to acquire a connection with a `PoolClosed` exception. Currently used connections will not be closed until returned to the pool. Wait *timeout* seconds for threads to terminate their job, if positive. If the timeout expires the pool is closed anyway, although it may raise some warnings on exit. NTzpool %r closedr<rz is closed)rgr]r}debugr:rrVrr-rkr%rfailr)r`r<waiting connectionsrlrrs rbrzAsyncConnectionPool.closes <  F: 7 7 7 7 7 7 7 7DL LL)49 5 5 54=))G M   ! ! !tz**K J     !4466666666G 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7"w0000000000  / /D((.. . . . . . . . . L LC((:&I$)&I&I&IJJKK K K K K K K K K L LsBC CC list[AWorker]cK|jddd{V|jddgc}|_|D]$}|t |%|jr!||jd|_|S)Nr)renterrYr StopWorkerrXr)r`rl_s rbrkz'AsyncConnectionPool._signal_stop_workersk4((((((((("&qqq!12 , ,A MM*T** + + + +   & NN4- . . .!%D rcrcLKd|_|d{V|Srp)r^r6rxs rb __aenter__zAsyncConnectionPool.__aenter__$s3#iikk rcexc_typetype[BaseException] | Noneexc_valBaseException | Noneexc_tbTracebackType | Nonec>K|d{VdSr)r)r`rrrs rb __aexit__zAsyncConnectionPool.__aexit__)s. jjllrccK|||\}}td||jz }td|j|||j4d{V||_||_|xj|z c_dddd{Vn#1d{VswxYwYt|D]$}| t|%dS)z+Change the size of the pool during runtime.rz&resizing %r to min_size=%s max_size=%sN) _check_sizemaxr|r}r~r:r]rrrrr)r`r4r5ngrowrs rbresizezAsyncConnectionPool.resize1sl!--hAA(Ax$.011 4di8   : " " " " " " " "%DN%DN LLE !LL " " " " " " " " " " " " " " " " " " " " " " " " " " " u / /A MM--- . . . . / /s#B B!BcDK|j4d{Vt|j}|j|dddd{Vn#1d{VswxYwY|r(|}|jtkrYt d|| |d{V| t| | |d{V||d{Vng#t$rZ|j|jxxdz cc<td|| t|YnwxYw|&dSdS)zVerify the state of the connections currently in the pool. Test each connection: if it works return it to the pool, otherwise dispose of it and create a new one. Nz discarding expired connection %srz discarding broken connection: %s)r]rr-rrpop _expire_atrr}r~rrrcheck_connection _add_to_poolrr_CONNECTIONS_LOSTwarningrs rbr8zAsyncConnectionPool.checkBs_ : $ $ $ $ $ $ $ $$$E J       ! ! # # # $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ .99;;D)++-- >EEE,,T222222222 mD11222 .++D111111111 ''---------- % 3 3 3 D2333q8333A4HHH mD1122222 3 . . . . .s%AA$$ A.1A.=D44A!FFc8K|jr|dd{VdS |dd{V |dd{V|dd{VdS#|dd{VwxYw)a> A simple check to verify that a connection is still working. Return quietly if the connection is still working, otherwise raise an exception. Used internally by `check()`, but also available for client usage, for instance as `!check` callback when a pool is created. r.NTF) autocommitexecuteset_autocommit)rs rbrz$AsyncConnectionPool.check_connectiones ? ,,,r"" " " " " " " " " " ,))$/////////5,,r*********--e44444444444$--e4444444444s A<<BcRK|jsdSt|j|d{VdS)zV Called when reconnection failed for longer than `reconnect_timeout`. N)rTr)rxs rbrAz$AsyncConnectionPool.reconnect_failedsC%  F41488888888888rctaskMaintenanceTaskc:|j|dS)z#Run a maintenance task in a worker.N)r put_nowait)r`r s rbrzAsyncConnectionPool.run_tasks t$$$$$rcrcVK|j||jd{VdS)z1Run a maintenance task in a worker in the future.N)rrtick)r`r rs rb schedule_taskz!AsyncConnectionPool.schedule_tasks8kty11111111111rcqAQueue[MaintenanceTask]cnK t|d{Vx}tr)tdt dS |d{Vn>#t$r1}td||j j |Yd}~nd}~wwxYw)zRunner to execute pending maintenance task. The function is designed to run as a task. Block on the queue *q*, run a task received. Finish running if a StopWorker is received. TNzterminating working task %sztask run %s failed: %s: %s) isinstancegetrr}rr(rrrrart)clsrr exs rbrzAsyncConnectionPool.workers !%%''MMMMMM24Z@@  :(>F$ % [[ I6.6xJJ6JJJJJJJJD B K, - - -VrBw5G1H1H H - - - - !    K0 1 1 1Q 6 1 1 1   ? //$'' ' ' ' ' ' ' '+88=N=SSS)&116(555555 ((... s C++&DstrctKt|jrt|jd{VS|jpdS)zCResolve conninfo (static string, sync callable, or async callable).Nr.)callablerCr)rxs rbrz%AsyncConnectionPool._resolve_conninfosG DM " " 5%dm44444444 4}""rcdict[str, Any]cK|jsiSt|jrt|jd{VS|jS)z?Resolve kwargs (static dict, sync callable, or async callable).N)r3r-r)rxs rbrz#AsyncConnectionPool._resolve_kwargssQ{ I DK  3%dk22222222 2{rcrAttemptWithBackoff | NonercKt}|st|j} |d{V}n(#t$r}t d|j|||rt d|j|j|j 4d{V|xj dzc_ |r|j rd|_ dddd{Vn#1d{VswxYwY| d{VnF| ||t||||jd{VYd}~dSd}~wwxYwt d||d{V|r|j 4d{V|j |jks|j |jkrb|jr[|xj dz c_ t d |j|j |t|d nd|_ dddd{VdS#1d{VswxYwYdSdS) zTry to connect and add the connection to the pool. If failed, reschedule a new attempt in the future for a few times, then give up, decrease the pool connections number and call `self.reconnect_failed()`. rNzerror connecting in %r: %sz3reconnection attempt in pool %r failed after %s secrFrz!adding new connection to the poolrT)rrr@r*rr}rr:rr]rrrArrrrr~rr|rrVr)r`rrrrrs rb_add_connectionz#AsyncConnectionPool._add_connectionskk I(1GHHHG ((((((DD     NN7B G G G&&s++ II*  :........LLA%LL.4=.(- - ........................... ++----------$$S)))((!$AAA7= FFFFF' *  7888%%%%%%%%%  *z * * * * * * * *<$.00L4>11dm1LLA%LLKK 7DLQQQMM-d"C"C"CDDDD$)DM) * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *sPA E*A)E%9!C-E%- C7 7E%:C7 ;A$E%%E*1B I IIcFK||d{V|rs|jjtjkrX|j|jxxdz cc<td| t|dSns|jjtjkrY|j|j xxdz cc<t d|| t|dS|j |jks|jt!krYtd||d{V| t|dS||d{VdS)z> Return a connection to the pool after usage. Nrz#not serving connection found brokenz discarding closed connection: %szdiscarding expired connection)_reset_connectionr#r$rUNKNOWNrrr}r~rr _RETURNS_BADr _created_atrrrrrrs rbrz&AsyncConnectionPool._return_connections$$T*********  {-1B1JJJ D2333q8333 ABBB mD11222 K{-1B1JJJ D-...!3...A4HHH mD11222  t/ / /4?ikk3Q3Q KK7 8 8 8((.. . . . . . . . MM--- . . . F%%%%%%%%%%%rcc`Kd|_|jr||d{VdS|j4d{V|jr/||d{V dddd{VdS|jr:|j|d{Vrn^|j:|j||jr6t|j|j kr|jdddd{VdS#1d{VswxYwYdS)z Add a connection to the pool. The connection can be a fresh one or one already used in the pool. If a client is already waiting for a connection pass it on, otherwise put it back into the pool N) r-rgrr]rVrsetrrWr{r|rs rbrz AsyncConnectionPool._add_to_pool.s* < ((.. . . . . . . . F: 0 0 0 0 0 0 0 0 | ,,T222222222 0 0 0 0 0 0 0 0 0 0 0 0 0 0- 0..0044T:::::::: - 0 !!$'''(0S__-N-N)--///- 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0s$D2BD D'*D'cK|jjx}tjkrn|tjkrdS|tjks|tjkrtd| | d{Vn#t$rL}td|j j ||| |d{VYd}~nNd}~wwxYw|tjkr6td|| |d{V|jr ||d{V|jjx}tjkr4t|j}t#jd|d|jddS#t$rA}td|| |d{VYd}~dSd}~wwxYwdS) z? Bring a connection to IDLE state or close it. Nz$rolling back returned connection: %sz1rollback failed: %s: %s. Discarding connection %szclosing returned connection: %srz by reset function rzerror resetting connection: %s)r#r$rr%r5INTRANSINERRORr}rrollbackrrartrACTIVErSr:rr&)r`rr(rr)s rbr4z%AsyncConnectionPool._reset_connection^srk4 4F9J9O O O  (0 0 0 F (0 0 0F>O>W4W4W NNA4 H H H 3mmoo%%%%%%%%$ 3 3 3GL)  ,,T22222222222222 3(/ / / NNrLr?rLr@rLrArMrBrFrdre)r0)r<rLrdrer)r<rrdr)r<rrdr)rrLrdrr<rLrdr)r<rrdr)rrrdre)rrrrKrdrerrrdrK)Fr0)rrKr<rLrdre)rh)rdr)rdr)rrrrrrrdre)r4rFr5rGrdre)r r rdre)r r rrLrdre)rrrdrerdr+)rdr.)F)rr0rrKrdre)rdrD)6rt __module__ __qualname____annotations__r rOrrr[rnrqr\rr rrrrrrrrrrrr6r_rrrrrkrrrr8 staticmethodrrArr classmethodrr*rrr2rrr4rrCrF __classcell__ras@rbr,r,.s_(*P'+d49o&F&F*.# 37/3/3#'##+8<)PPPPPPPPd >$     :::::@CCCCC,:,,,,4    D&9999 6 6 6 6////(KKKK    -----.$$$$,! ! ! ! !"$$$$GGGG'L'L'L'L'LR     /////"!.!.!.!.F,,,\,:9999%%%%2222[*B####CH2*2*2*2*2*h&&&&<.0.0.0.0`(3(3(3(3T33332rcr,c6eZdZdZdZddZdd Zdd ZddZdS)rUz< z at 0xx>)rcreprr:rartid)r`rcr:s rb__repr__zMaintenanceTask.__repr__sUyy{{"&*FFTFFDFFFFFrcrecK|}|r|jrtd|dStdt |||d{VdS)zRun the task. This usually happens in a worker. Call the concrete _run() implementation, if the pool is still alive. ztask run discarded: %sNztask running in %s: %s)rcclosedr}rr(_runrfs rbrzMaintenanceTask.runs yy{{ t{  LL14 8 8 8 F -/@/B/BDIIIiioorccK|}|r|jrtd|dS||dS)zRun the scheduled task This function is called by the scheduler task. Use a worker to run the task for real in order to free the scheduler immediately. ztask tick discarded: %sN)rcrpr}rrrfs rbrzMaintenanceTask.ticksX yy{{ t{  LL2D 9 9 9 F drcc KdSrrarfs rbrqzMaintenanceTask._runs BE#rcN)rcrdrLrIrcrdrdre) rtrMrNr_r[rnrrrrqrarcrbr r sBBGGGG        EEE^EEErcr ceZdZdZddZdS) rz+Signal the maintenance worker to terminate.rcrdrdrec KdSrrarfs rbrqzStopWorker._runs  rcNrtrtrMrNr_rqrarcrbrrs.55      rcrc.eZdZ d dfd Zdd ZxZS)rNFrcrdrr0rrKcft|||_||_dSr)rZr[rr)r`rcrrras rbr[zAddConnection.__init__!s/   rcrdrecXK||j|jd{VdS)Nr)r2rrrfs rbrqzAddConnection._run+s;""4<"FFFFFFFFFFFrcrp)rcrdrr0rrKrt)rtrMrNr[rqrRrSs@rbrr sf.2 GGGGGGGGrcrc,eZdZdZd fd Zd d ZxZS)rz-Clean up and return a connection to the pool.rcrdrrrrKcft|||_||_dSr)rZr[rr)r`rcrrras rbr[zReturnConnection.__init__2s0  (rcrdrecXK||j|jd{VdSr)rrrrfs rbrqzReturnConnection._run7s<%%did>O%PPPPPPPPPPPrc)rcrdrrrrKrtrtrMrNr_r[rqrRrSs@rbrr/s_77)))))) QQQQQQQQrcrceZdZdZddZdS) rzIf the pool can shrink, remove one connection. Re-schedule periodically and also reset the minimum number of connections in the pool. rcrdrdrecK|||jd{V|d{VdSr)rr?rCrfs rbrqzShrinkPool._runBs\  t}555555555!!!!!!!!!!!rcNrtrwrarcrbrr;s2 """"""rcrc,eZdZdZd fd Zd d ZxZS)rzSchedule a task in the pool scheduler. This task is a trampoline to allow to use a sync call (pool.run_task) to execute an async one (pool.schedule_task). It is pretty much no-op in sync code. rcrdr r rrLcft|||_||_dSr)rZr[r r)r`rcr rras rbr[zSchedule.__init__Qs/   rcrdrecVK||j|jd{VdSr)rr rrfs rbrqz Schedule._runXs8  DJ77777777777rc)rcrdr r rrLrtr~rSs@rbrrIs[88888888rcr)Hr_ __future__rloggingrrabcrrtimertypesrtypingrr r weakrefr contextlibr collectionsr collections.abcrpsycopgrrr psycopg.pqrrrrrrbaserrrrr_compatrrr_acompatr r!r"r#r$r%r&r'r(r) sched_asyncr*rr]CancelledErrorr getLoggerr}r,rUr rrrrrrarcrbrs #"""""########%%%%%%%%%%******))))))######((((((QQQQQQQQQQQQ!!!!!!........<<<<<<<<<<??????????QQQQQQQQQQQQQQQQQQ==========''''''"NNN#G$:;  > * *z z z z z '#,z z z z?????GCL???D)F)F)F)F)Fc)F)F)FX         G G G G GO G G G Q Q Q Q Q Q Q Q " " " " " " " "8888888888rc