:"ri ddlmZddlZddlmZmZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZddlZddlmZddlmZdd lmZdd lmZej,eZGd d eZGd dej6edZGddZGddZGddZddddddddddej@ejBd dZ"y)) annotationsN) AwaitableCallable) TracebackType)AnyOptionalType)compat connection) exceptions)protocolcVeZdZdd dfdZe ddZxZS)PoolConnectionProxyMetaF)wrapc|rttjD]}|jds||vrt tj|}t j |sIt j|}|j||}tj||}|||<d|vrtjj|d<t |5||||S)N___doc__)dirr Connection startswithgetattrinspect isfunctioniscoroutinefunction_wrap_connection_method functoolsupdate_wrapperrsuper__new__) mclsnamebasesdctrattrnamemeth iscoroutinewrapper __class__s T/var/www/fortnox.pascalinesoft.com/venv/lib/python3.12/site-packages/asyncpg/pool.pyr!zPoolConnectionProxyMeta.__new__s  5 56 (&&s+x3z44h?))$/%99$? 66xM#227DA 'H  (#!+!6!6!>!>IwtT5#66cBdfd }|rtj||S)Nc|j$tjdjt |jj }||jg|i|S)NzJcannot call Connection.{}(): connection has been released back to the pool)_conrInterfaceErrorformatrr*)selfargskwargsr' meth_names r+call_con_methodzHPoolConnectionProxyMeta._wrap_connection_method..call_con_method=seyy  //DDJF!E#$$ 499.. :D 3D3F3 3r,)r2rr3rr4rreturnr)r markcoroutinefunction)r5r(r6s` r+rz/PoolConnectionProxyMeta._wrap_connection_method9s! 4   ( ( 9r,) r#strr$ztuple[Type[Any], ...]r%zdict[str, Any]rboolr7r)r5r9r(r:r7zCallable[..., Any])__name__ __module__ __qualname__r! staticmethodr __classcell__)r*s@r+rrsi 77%7 7  7 !76%) r,rc<eZdZdZ ddZddZd dZd dZy) PoolConnectionProxy)r/_holdercB||_||_|j|yN)r/rB _set_proxy)r2holdercons r+__init__zPoolConnectionProxy.__init__Ts   tr,c.t|j|SrD)rr/)r2attrs r+ __getattr__zPoolConnectionProxy.__getattr__[styy$''r,cj|jy|jdc}|_|jd|SrD)r/rE)r2rGs r+_detachzPoolConnectionProxy._detach_s1 99  DTY t r,c|j0dj|jjt |Sdj|jj|jt |S)Nz <{classname} [released] {id:#x}>) classnameidz<{classname} {con!r} {id:#x}>)rOrGrP)r/r1r*r;rPr2s r+__repr__zPoolConnectionProxy.__repr__gsn 99 5<<..11bh=@ @399..11tyyRX:O Or,N)rFPoolConnectionHolderrGzconnection.Connectionr7None)rJr9r7r)r7zOptional[connection.Connection])r7r9)r;r<r= __slots__rHrKrMrRr,r+rArANs6$I*1F (Or,rAT) metaclassrceZdZdZ ddZddZddZddZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZddZddZy)rS) r/_pool_loop_proxy _max_queries_setup_max_inactive_time_in_use_inactive_callback_timeout _generationc||_d|_d|_||_||_||_d|_d|_d|_d|_ yrD) rYr/r[r\r^r]r`r_rarb)r2pool max_queriessetupmax_inactive_times r+rHzPoolConnectionHolder.__init__xsN 59 59 '"3 6:15 )- *.r,cX|jduxr|jj SrD)r/ is_closedrQs r+ is_connectedz!PoolConnectionHolder.is_connecteds&yy$BTYY-@-@-B)BBr,c|j SrDr_rQs r+is_idlezPoolConnectionHolder.is_idles<<r,cK|jtjd|jj d{|_|jj |_|j |jy7Ew)NzMPoolConnectionHolder.connect() called while another connection already exists)r/rInternalClientErrorrY_get_new_connectionrb_maybe_cancel_inactive_callback_setup_inactive_callbackrQs r+connectzPoolConnectionHolder.connectsp 99 00,- -**88:: ::11 ,,. %%';s?B BAB cPK|j|jjr d|_|jd{n|j|jjk7rh|jj j |jj|jd|_|jd{|jt||jx|_ }|j |j|d{|jj j!|_|S7774#ttjf$r1} |jjd{7|#|xYwd}~wwxYww)Ntimeout)r/rirsrbrYrZ create_taskcloserarqrAr[r] ExceptionasyncioCancelledError create_futurer_)r2proxyexs r+acquirezPoolConnectionHolder.acquiresG 99  3 3 5DI,,.   !7!7 7 JJ   ( (  6 8DI,,.  ,,.1$ BB e ;; " kk%(((zz''557  A ! !)w556   ))//+++H"H syAF&EB F&E=F&E"E#E',F&F&EF#3FFFFFFF##F&czK|jtjd|jj ryd|_|jj j|jk\r%|jj|d{y|j|jjk7r%|jj|d{y |}|jj jrptj}tj |jj j#|d{||tj|z z}|jj$~tj&|4d{|jj%d{|jj%|jd{dddd{n$|jj)|d{|j3|j5y77y7777f7X#1d{7swYCxYw7J#t*t,j.f$r(} |jj1|#|xYwd}~wwxYww)NzAPoolConnectionHolder.release() called on a free connection holderru)r_rror/rira _protocol queries_countr\rxrbrY_is_cancellingtime monotonicr wait_for_wait_for_cancellation_resetrvresetryrzr{ terminate_releaserr)r2rvbudgetstartedr~s r+releasezPoolConnectionHolder.releasesB << 00+, , 99     99   , ,0A0A A))//'/2 2 2    tzz55 5))//'/2 2 2  Fyy""113..*ooII''>>@%dnn.88Fzz  ,!>>&177))**,,,**++DII666777iioofo555  %%'[ 3 37,6777767112   ##%b sBJ;IAJ;IJ;!A5I7IAI7&I'I7*I I ,I 5I6I : I7I$I7*I5+I7/"J;J;I7I7I I I7 I2&I) 'I2.I77J8J-+J3-J00J33J88J;cRK|jy|jd{y7wrDrlrQs r+wait_until_releasedz(PoolConnectionHolder.wait_until_releaseds <<  ,,  s '%'cnK|j#|jjd{yy7wrD)r/rxrQs r+rxzPoolConnectionHolder.closes0 99 ))//# # # ! $s *535cR|j|jjyyrD)r/rrQs r+rzPoolConnectionHolder.terminates# 99  II   ! !r,c|jtjd|jr@|jj j |j|j|_yy)Nz/pool connection inactivity timer already exists)r`rror^rYrZ call_later_deactivate_inactive_connectionrQs r+rrz-PoolConnectionHolder._setup_inactive_callbackse  " " .00AC C  " "&*jj&6&6&A&A'')M)M'OD # #r,c`|j"|jjd|_yyrD)r`cancelrQs r+rqz4PoolConnectionHolder._maybe_cancel_inactive_callbacks-  " " .  # # * * ,&*D # /r,c|jtjd|j+|jj |j yy)Nz/attempting to deactivate an acquired connection)r_rror/r_release_on_closerQs r+rz4PoolConnectionHolder._deactivate_inactive_connection"sU << #00AC C 99  II   !  " " $ !r,cR|j|jd|_yrD)rqrr/rQs r+rz&PoolConnectionHolder._release_on_close0s ,,.  r,c:|jy|jjs|jjdd|_|j!|jj d|_|j j j|y)zRelease this connection holder.N)r_done set_resultr[rMrY_queue put_nowaitrQs r+rzPoolConnectionHolder._release5su <<  ||  " LL # #D )  ;; " KK   !DK $$T*r,N) rdz'Pool'refloatrfz:Optional[Callable[[PoolConnectionProxy], Awaitable[None]]]rgrr7rT)r7r:)r7rT)r7rA)rvOptional[float]r7rT)r;r<r=rUrHrjrmrsrrrrxrrrrqrrrrVr,r+rSrSps I // / J / ! / /*C  (#J=(~ $ " O+ % +r,rSceZdZdZdZddddddZdZdZdZd Z d Z d Z d Z d.d Z dZdd d/dZdd d0dZddd d1dZddddZddddZddddZddddddddddddd dZddddddddddd dZddddddddddddddddddZdddddd Zddd!Zd"Zddd#Zd$Zd%Zd&Zd'Zd(Z d)Z!d*Z"d+Z#d,Z$d-Z%y)2PoolaA connection pool. Connection pool can be used to manage a set of connections to the database. Connections are first acquired from the pool, then used, and then released back to the pool. Once a connection is released, it's reset to close all open cursors and other resources *except* prepared statements. Pools are created by calling :func:`~asyncpg.pool.create_pool`. )rrZ_minsize_maxsize_init_connectr _connect_args_connect_kwargs_holders _initialized _initializing_closing_closed_connection_class _record_classrbr]r\!_max_inactive_connection_lifetimeN)rsrfinitrc 0t| dkDrtjdtd| t j } | |_|dkr td|dkr td||kDr td|dkr td |dkr td t| tjstd j| t| tjstd j| ||_||_g|_d |_d |_d|_| |_| |_d |_d |_d|_||ntj4|_| |_| |_||_||_||_ ||_!||_"y)Nr zPassing multiple positional arguments to asyncpg.Pool constructor is deprecated and will be removed in asyncpg 0.17.0. The non-deprecated form is asyncpg.Pool(, **kwargs)) stacklevelrz,max_size is expected to be greater than zeroz3min_size is expected to be greater or equal to zeroz!min_size is greater than max_sizez/max_queries is expected to be greater than zerozKmax_inactive_connection_lifetime is expected to be greater or equal to zerozMconnection_class is expected to be a subclass of asyncpg.Connection, got {!r}zErecord_class is expected to be a subclass of asyncpg.Record, got {!r}F)#lenwarningswarnDeprecationWarningrzget_event_looprZ ValueError issubclassr r TypeErrorr1rRecordrrrrrrrrrrrbrsrrrr]rrr\r)r2min_sizemax_sizere max_inactive_connection_lifetimersrfrrloopconnection_class record_class connect_argsconnect_kwargss r+rHz Pool.__init__\s | q MM0#q  2 <))+D q=KL L a<EG G h @A A ! NO O +a /#$ $*J,A,AB//5v6F/GI I,8++16,+?A A!    !" !1)  #*#6J t}}% 'A% --"&"H"Hkk #B MM  $ KK " "2 & ' ==}}R(H""$ $ $}}q " &x cr0B'CD7EArDMMA--!((6 7 nnm444!  %5s%CE&E"BE&E$E&$E&c6|jxs |jS)z_Return ``True`` if the pool is closing or is closed. .. versionadded:: 0.28.0 )rrrQs r+ is_closingzPool.is_closings ||,t}},r,c:td|jDS)zaReturn the current number of connections in this pool. .. versionadded:: 0.25.0 c3<K|]}|jywrD)rj.0hs r+ z Pool.get_size..s;1>>#;ssumrrQs r+get_sizez Pool.get_sizes ;T]];;;r,c|jS)zaReturn the minimum number of connections in this pool. .. versionadded:: 0.25.0 )rrQs r+ get_min_sizezPool.get_min_size }}r,c|jS)ziReturn the maximum allowed number of connections in this pool. .. versionadded:: 0.25.0 )rrQs r+ get_max_sizezPool.get_max_sizerr,c:td|jDS)zfReturn the current number of idle connections in this pool. .. versionadded:: 0.25.0 c3`K|]&}|jxr|j(ywrD)rjrmrs r+rz%Pool.get_idle_size..s%K1>>#3 3Ks,.rrQs r+ get_idle_sizezPool.get_idle_sizes KT]]KKKr,c "|g|_||_y)aSet the new connection arguments for this pool. The new connection arguments will be used for all subsequent new connection attempts. Existing connections will remain until they expire. Use :meth:`Pool.expire_connections() ` to expedite the connection expiry. :param str dsn: Connection arguments specified using as a single string in the following format: ``postgres://user:pass@host:port/database?option=value``. :param \*\*connect_kwargs: Keyword arguments for the :func:`~asyncpg.connection.connect` function. .. versionadded:: 0.16.0 N)rr)r2dsnrs r+set_connect_argszPool.set_connect_argss*"U-r,cK|j|j|j|j|jd|j d{}t ||js|j}|jd|j}t|}|jdk(r |j}n|jd|j}tjd|d|d|j |j|d{|S|S77 #ttjf$r'} |j!d{7|#|xYwd}~wwxYww)N)rrr.builtinsz9expected pool connect callback to return an instance of 'z', got '')rrrZrrr isinstancer<r;typerr0rryrzr{rx)r2rGgoodgood_nbadbad_nr~s r+rpzPool._get_new_connectionsW!DMM   !33++  ""   #t556))D($--9Fs)C~~+ >>*!CLL>:++8<wa1  :: ! jjo%% s K ,&w556   ))+%%H"H sgA EDB+E;DDDEDE6E E  EEEEEErucK|j4d{}|j|g|d|id{cdddd{S7377 #1d{7swYyxYww)aExecute an SQL command (or commands). Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.execute() `. .. versionadded:: 0.10.0 Nrv)rexecute)r2queryrvr3rGs r+rz Pool.executeAsj<<> D DS$UCTC7CC D D DC D D D DsSA&A A&AA A A&AA& AA&A#A A#A&cK|j4d{}|j|||d{cdddd{S7177 #1d{7swYyxYww)aCExecute an SQL *command* for each sequence of arguments in *args*. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.executemany() `. .. versionadded:: 0.10.0 Nru)r executemany)r2commandr3rvrGs r+rzPool.executemanyRsd <<> I IS$HH I I IH I I I IsSA$A A$AA A A$A A$ A A$A!A A!A$rvrcK|j4d{}|j|g|||dd{cdddd{S7477 #1d{7swYyxYww)a-Run a query and return the results as a list of :class:`Record`. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.fetch() `. .. versionadded:: 0.10.0 Nr)rfetchr2rrvrr3rGs r+rz Pool.fetchess<<>  S" )        SA'A A'AAA A'AA'AA'A$A A$ A'rcolumnrvcK|j4d{}|j|g|||dd{cdddd{S7477 #1d{7swYyxYww)a+Run a query and return a value in the first row. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.fetchval() `. .. versionadded:: 0.10.0 Nr)rfetchval)r2rrrvr3rGs r+rz Pool.fetchval|sp<<> > >S%>>%+W>> > > >> > > > >rcK|j4d{}|j|g|||dd{cdddd{S7477 #1d{7swYyxYww)aRun a query and return the first row. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.fetchrow() `. .. versionadded:: 0.10.0 Nr)rfetchrowrs r+rz Pool.fetchrowss<<>  S% )        rcK|j4d{}|j||||d{cdddd{S7277 #1d{7swYyxYww)anRun a query for each sequence of arguments in *args* and return the results as a list of :class:`Record`. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.fetchmany() `. .. versionadded:: 0.30.0 Nr)r fetchmany)r2rr3rvrrGs r+r zPool.fetchmanysg<<>  StW<'       sSA%A A%AA A A%AA% AA%A"A A"A%) columns schema_namervr1oids delimiternullheaderquoteescape force_quoteencodingc K|j4d{}|j||||||||| | | | | |d{cdddd{S7<77 #1d{7swYyxYww)a;Copy table contents to a file or file-like object. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.copy_from_table() `. .. versionadded:: 0.24.0 N) outputr r rvr1r rrrrrrr)rcopy_from_table)r2 table_namerr r rvr1r rrrrrrrrGs r+rzPool.copy_from_tables6<<>  S,,'#'!-       sTA/AA/#AAA A/AA/AA/A, A# !A,(A/) rvr1r rrrrrrrc K|j4d{}|j|g| |||||||| | | | d d{cdddd{S7=77 #1d{7swYyxYww)aCCopy the results of a query to a file or file-like object. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.copy_from_query() `. .. versionadded:: 0.24.0 N) rrvr1r rrrrrrr)rcopy_from_query)r2rrrvr1r rrrrrrrr3rGs r+rzPool.copy_from_querys2<<>  S,,,#'!       sUA0AA0$AAA A0AA0AA0A-!A$ "A-)A0)r r rvr1r freezerrrrrrforce_not_null force_nullrwherecK|j4d{}|j||||||||| | | | | |||||d{cdddd{S7@77 #1d{7swYyxYww)a&Copy data to the specified table. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.copy_to_table() `. .. versionadded:: 0.24.0 N)sourcer r rvr1r rrrrrrrrrrr)r copy_to_table)r2rr r r rvr1r rrrrrrrrrrrrGs r+r!zPool.copy_to_tables><<>  S**'#'-%!%+       sVA3AA3'AAA A3AA3AA3A0$A' %A0,A3)r r rvrc K|j4d{}|j||||||d{cdddd{S7477 #1d{7swYyxYww)aUCopy a list of records to the specified table using binary COPY. Pool performs this operation using one of its connections. Other than that, it behaves identically to :meth:`Connection.copy_records_to_table() `. .. versionadded:: 0.24.0 N)recordsr r rvr)rcopy_records_to_table)r2rr#r r rvrrGs r+r$zPool.copy_records_to_table7sr&<<>  S22' 3       rct||S)aTAcquire a database connection from the pool. :param float timeout: A timeout for acquiring a Connection. :return: An instance of :class:`~asyncpg.connection.Connection`. Can be used in an ``await`` expression or with an ``async with`` block. .. code-block:: python async with pool.acquire() as con: await con.execute(...) Or: .. code-block:: python con = await pool.acquire() try: await con.execute(...) finally: await pool.release(con) )PoolAcquireContext)r2rvs r+rz Pool.acquireTs."$00r,cKfd}jrtjdj|d{St j |d{S7(7w)NcKjjd{} |jd{}|_|S7&7#tt j f$rjj|wxYwwrD)rgetrraryrzr{r)rr}r2rvs r+ _acquire_implz$Pool._acquire.._acquire_implnsr{{((B  jjl*&  )*w556  &&r* s5BABA A A B A 6BBzpool is closingru)rrr0 _check_initr r)r2rvr*s`` r+_acquirez Pool._acquiremsk  ==++,=> >  ?&( (22 2)2s$AA5A1 #A5,A3-A53A5cKt|tus|jj|ur%t j dj ||jy|j|jj|j}| |j}tj|j|d{S7w)aRelease a database connection back to the pool. :param Connection connection: A :class:`~asyncpg.connection.Connection` object to release. :param float timeout: A timeout for releasing the connection. If not specified, defaults to the timeout provided in the corresponding call to the :meth:`Pool.acquire() ` method. .. versionchanged:: 0.14.0 Added the *timeout* parameter. zWPool.release() received invalid connection: {connection!r} is not a member of this poolr N)rrArBrYrr0r1r/r+ _on_releaserarzshieldr)r2r rvrs r+rz Pool.releases  $7 7""((4++>>Df)?E?+, , ?? "   ##%    ?kkG ^^BJJw$78888sCC C CcK|jry|jd|_d} |jj d|j }|j Dcgc]}|j}}tj|d{|j Dcgc]}|j}}tj|d{ ||jd|_d|_ycc}w7lcc}w72#ttjf$r|jwxYw#||jd|_d|_wxYww)aAttempt to gracefully close all connections in the pool. Wait until all pool connections are released, close them and shut down the pool. If any error (including cancellation) occurs in ``close()`` the pool will terminate by calling :meth:`Pool.terminate() `. It is advisable to use :func:`python:asyncio.wait_for` to set a timeout. .. versionchanged:: 0.16.0 ``close()`` now waits until all pool connections are released before closing them and the pool. Errors raised in ``close()`` will cause immediate pool termination. NT<F)rr+rrZr_warn_on_long_closerrrzrrxryr{rr)r2warning_callbackr release_coros close_coross r+rxz Pool.closesB <<    "#zz44D,, . 48==B-/&&(BMB..-0 0 0&*]]4! 4K4..+. . . + '')DL!DM!B 04 .7112  NN     + '')DL!DMsd'E4DC45D C9 DC;6D DD!E4D;D+D--D00"EEc.tjdy)NzPool.close() is taking over 60 seconds to complete. Check if you have any unreleased connections left. Use asyncio.wait_for() to set a timeout for Pool.close().)loggerwarningrQs r+r2zPool._warn_on_long_closes' (r,c|jry|j|jD]}|jd|_y)z&Terminate all connections in the pool.NT)rr+rrr2rs r+rzPool.terminates; <<  -- B LLN  r,c6K|xjdz c_yw)zExpire all currently open connections. Cause all currently open connections to get replaced on the next :meth:`~asyncpg.pool.Pool.acquire()` call. .. versionadded:: 0.16.0 r N)rbrQs r+expire_connectionszPool.expire_connectionss Asc|js6|jrtjdtjd|jrtjdy)Nzipool is being initialized, but not yet ready: likely there is a race between creating a pool and using itzpool is not initializedr)rrrr0rrQs r+r+zPool._check_inits^  !! //  ++,EF F <<++,<= = r,ct|jD])}|j|jj+yrD)rr/_drop_local_statement_cacher:s r+_drop_statement_cachezPool._drop_statement_caches/-- 6Bww"335 6r,ct|jD])}|j|jj+yrD)rr/_drop_local_type_cacher:s r+_drop_type_cachezPool._drop_type_caches/-- 1Bww"..0 1r,c>|jjSrD)r __await__rQs r+rEzPool.__await__s""$..00r,cBK|jd{|S7wrD)rrQs r+ __aenter__zPool.__aenter__ s"!!###  $s c@K|jd{y7wrD)rx)r2excs r+ __aexit__zPool.__aexit__sjjls rD)rr9rvrr7r9)rr9rvr)r7list)&r;r<r=rrUrHrrrrrrrrrprrrrrr rrr!r$rr,rrxr2rr<r+r@rCrErGrJrVr,r+rrIsIO-b% 5B-<L.0&X"& DD! D D,"& II ! I.   .34T >48d"7;*  !+d  (^  )3t:"&122048$9L+"Z(  >6 1 1r,rcBeZdZdZddZdZ d d dZdZy) r&)rvr rrdc<||_||_d|_d|_y)NF)rdrvr r)r2rdrvs r+rHzPoolAcquireContext.__init__s   r,cK|j |jrtjd|jj |j d{|_|jS7w)Nz a connection is already acquired)r rrr0rdr,rvrQs r+rGzPoolAcquireContext.__aenter__sU ?? &$))++,NO O $ 2 24<< @@AsAA0A.A0NcKd|_|j}d|_|jj|d{y7wNT)rr rdr)r2exc_typeexc_valexc_tbrGs r+rJzPoolAcquireContext.__aexit__#s7  ooii$$$s9AAAcvd|_|jj|jj SrP)rrdr,rvrErQs r+rEzPoolAcquireContext.__await__.s+ yy!!$,,/99;;r,)rdrrvrr7rT)NNN)rQzOptional[Type[BaseException]]rRzOptional[BaseException]rSzOptional[TracebackType]r7rT)r;r<r=rUrHrGrJrErVr,r+r&r&sL9I 37+/*. %/ %) %( %  %` and :meth:`Connection.cursor() ` become invalid once the connection is released. Likewise, all notification and log listeners are removed, and ``asyncpg`` will issue a warning if there are any listener callbacks registered on a connection that is being released to the pool. :param str dsn: Connection arguments specified using as a single string in the following format: ``postgres://user:pass@host:port/database?option=value``. :param \*\*connect_kwargs: Keyword arguments for the :func:`~asyncpg.connection.connect` function. :param Connection connection_class: The class to use for connections. Must be a subclass of :class:`~asyncpg.connection.Connection`. :param type record_class: If specified, the class to use for records returned by queries on the connections in this pool. Must be a subclass of :class:`~asyncpg.Record`. :param int min_size: Number of connection the pool will be initialized with. :param int max_size: Max number of connections in the pool. :param int max_queries: Number of queries after a connection is closed and replaced with a new connection. :param float max_inactive_connection_lifetime: Number of seconds after which inactive connections in the pool will be closed. Pass ``0`` to disable this mechanism. :param coroutine connect: A coroutine that is called instead of :func:`~asyncpg.connection.connect` whenever the pool needs to make a new connection. Must return an instance of type specified by *connection_class* or :class:`~asyncpg.connection.Connection` if *connection_class* was not specified. :param coroutine setup: A coroutine to prepare a connection right before it is returned from :meth:`Pool.acquire()`. An example use case would be to automatically set up notifications listeners for all connections of a pool. :param coroutine init: A coroutine to initialize a connection when it is created. An example use case would be to setup type codecs with :meth:`Connection.set_builtin_type_codec() <\ asyncpg.connection.Connection.set_builtin_type_codec>` or :meth:`Connection.set_type_codec() <\ asyncpg.connection.Connection.set_type_codec>`. :param coroutine reset: A coroutine to reset a connection before it is returned to the pool by :meth:`Pool.release()`. The function is supposed to reset any changes made to the database session so that the next acquirer gets the connection in a well-defined state. The default implementation calls :meth:`Connection.reset() <\ asyncpg.connection.Connection.reset>`, which runs the following:: SELECT pg_advisory_unlock_all(); CLOSE ALL; UNLISTEN *; RESET ALL; The exact reset query is determined by detected server capabilities, and a custom *reset* implementation can obtain the default query by calling :meth:`Connection.get_reset_query() <\ asyncpg.connection.Connection.get_reset_query>`. :param loop: An asyncio event loop instance. If ``None``, the default event loop will be used. :return: An instance of :class:`~asyncpg.pool.Pool`. .. versionchanged:: 0.10.0 An :exc:`~asyncpg.exceptions.InterfaceError` will be raised on any attempted operation on a released connection. .. versionchanged:: 0.13.0 An :exc:`~asyncpg.exceptions.InterfaceError` will be raised on any attempted operation on a prepared statement or a cursor created on a connection that has been released to the pool. .. versionchanged:: 0.13.0 An :exc:`~asyncpg.exceptions.InterfaceWarning` will be produced if there are any active listeners (added via :meth:`Connection.add_listener() ` or :meth:`Connection.add_log_listener() `) present on the connection at the moment of its release to the pool. .. versionchanged:: 0.22.0 Added the *record_class* parameter. .. versionchanged:: 0.30.0 Added the *connect* and *reset* parameters. ) rrrrrerrsrfrrr)r) rrrrerrsrfrrrrrrs r+ create_poolrW3sE~   )!  )I   r,rD)# __future__rrzcollections.abcrrrrloggingrtypesrtypingrrr rr r rr getLoggerr;r7rr_ConnectionProxyrArSrr&rrrWrVr,r+r`s#/ &&   8 $/d/dO*55$;#ODV+V+rG G T<<@m!16!+!6!6%__mr,