o LDi @s$ddlmZddlZddlmZmZddlZddlZddlZddl Z ddl m Z ddl m Z mZmZddlZddlmZddlmZdd lmZdd lmZeeZGd d d eZGd ddejeddZGdddZGdddZGdddZddddddddddej ej!d ddZ"dS)) annotationsN) AwaitableCallable) TracebackType)AnyOptionalType)compat connection) exceptions)protocolcs2eZdZdddfd d ZedddZZS)PoolConnectionProxyMetaF)wrapnamestrbasestuple[Type[Any], ...]dctdict[str, Any]rboolreturnc s|r?ttjD]-}|ds||vrqttj|}t|sqt|}|||}t ||}|||<qd|vr?tjj |d<t ||||S)N___doc__)dirr Connection startswithgetattrinspect isfunctioniscoroutinefunction_wrap_connection_method functoolsupdate_wrapperrsuper__new__) mclsrrrrattrnamemeth iscoroutinewrapper __class__X/var/www/www-root/data/www/77.83.87.30/venv/lib/python3.10/site-packages/asyncpg/pool.pyr&s       zPoolConnectionProxyMeta.__new__ meth_namer*Callable[..., Any]cs dfdd }|rt||S) Nselfrargskwargsrcs@|jdur tdt|jj}||jg|Ri|S)NzJcannot call Connection.{}(): connection has been released back to the pool)_conr InterfaceErrorformatrr-)r2r3r4r)r0r.r/call_con_method=s zHPoolConnectionProxyMeta._wrap_connection_method..call_con_method)r2rr3rr4rrr)r markcoroutinefunction)r0r*r9r.r8r/r"9s z/PoolConnectionProxyMeta._wrap_connection_method) rrrrrrrrrr)r0rr*rrr1)__name__ __module__ __qualname__r& staticmethodr" __classcell__r.r.r,r/rs rc@s8eZdZdZddd Zdd dZdddZdddZdS)PoolConnectionProxy)r5_holderholderPoolConnectionHolderconconnection.ConnectionrNonecCs||_||_||dSN)r5rA _set_proxy)r2rBrDr.r.r/__init__TszPoolConnectionProxy.__init__attrrrcCs t|j|SrG)rr5)r2rJr.r.r/ __getattr__[s zPoolConnectionProxy.__getattr__Optional[connection.Connection]cCs*|jdurdS|jd}|_|d|SrG)r5rH)r2rDr.r.r/_detach_s  zPoolConnectionProxy._detachcCs:|jdurdj|jjt|dSdj|jj|jt|dS)Nz <{classname} [released] {id:#x}>) classnameidz<{classname} {con!r} {id:#x}>)rNrDrO)r5r7r-r;rOr2r.r.r/__repr__gs  zPoolConnectionProxy.__repr__N)rBrCrDrErrF)rJrrr)rrL)rr)r;r<r= __slots__rIrKrMrQr.r.r.r/r@Ns    r@T) metaclassrc@seZdZdZd,d d Zd-ddZd-ddZd.ddZd/ddZd0ddZ d.ddZ d.ddZ d.dd Z d.d!d"Z d.d#d$Zd.d%d&Zd.d'd(Zd.d)d*Zd+S)1rC) r5_pool_loop_proxy _max_queries_setup_max_inactive_time_in_use_inactive_callback_timeout _generationpool'Pool' max_queriesfloatsetup:Optional[Callable[[PoolConnectionProxy], Awaitable[None]]]max_inactive_timerrFcCs@||_d|_d|_||_||_||_d|_d|_d|_d|_ dSrG) rTr5rVrWrYrXr[rZr\r])r2r^r`rbrdr.r.r/rIxs  zPoolConnectionHolder.__init__rcCs|jduo |j SrG)r5 is_closedrPr.r.r/ is_connectedsz!PoolConnectionHolder.is_connectedcCs|j SrGrZrPr.r.r/is_idleszPoolConnectionHolder.is_idlecsF|jdur td|jIdH|_|jj|_||dS)NzMPoolConnectionHolder.connect() called while another connection already exists)r5r InternalClientErrorrT_get_new_connectionr]_maybe_cancel_inactive_callback_setup_inactive_callbackrPr.r.r/connects   zPoolConnectionHolder.connectr@c s|jdus |jrd|_|IdHn|j|jjkr4|jj|jj|jdd|_|IdH| t ||j|_ }|j durnz | |IdHWnt tjfym}zz |jIdHW||d}~ww|jj|_|S)Ntimeout)r5rermr]rTrU create_taskcloser\rkr@rVrX ExceptionasyncioCancelledError create_futurerZ)r2proxyexr.r.r/acquires. zPoolConnectionHolder.acquireroOptional[float]c s|jdur td|jrdSd|_|jjj|jkr)|jj |dIdHdS|j |j j kr<|jj |dIdHdSzi|}|jj rbt }t|jj|IdH|durb|t |8}|j jdurt|4IdH|jIdH|j |jIdHWdIdHn 1IdHswYn |jj|dIdHWnttjfy}z z|jW||d}~ww||dS)NzAPoolConnectionHolder.release() called on a free connection holderrn)rZr rir5rer\ _protocol queries_countrWrqr]rT_is_cancellingtime monotonicr wait_for_wait_for_cancellation_resetroresetrrrsrt terminate_releaserl)r2robudgetstartedrwr.r.r/releasesP      (  zPoolConnectionHolder.releasecs |jdurdS|jIdHdSrGrgrPr.r.r/wait_until_releaseds z(PoolConnectionHolder.wait_until_releasedcs$|jdur|jIdHdSdSrG)r5rqrPr.r.r/rqs zPoolConnectionHolder.closecCs|jdur |jdSdSrG)r5rrPr.r.r/rs zPoolConnectionHolder.terminatecCs8|jdur td|jr|jj|j|j|_dSdS)Nz/pool connection inactivity timer already exists)r[r rirYrTrU call_later_deactivate_inactive_connectionrPr.r.r/rls  z-PoolConnectionHolder._setup_inactive_callbackcCs"|jdur|jd|_dSdSrG)r[cancelrPr.r.r/rks   z4PoolConnectionHolder._maybe_cancel_inactive_callbackcCs8|jdur td|jdur|j|dSdS)Nz/attempting to deactivate an acquired connection)rZr rir5r_release_on_closerPr.r.r/r"s    z4PoolConnectionHolder._deactivate_inactive_connectioncCs||d|_dSrG)rkrr5rPr.r.r/r0s z&PoolConnectionHolder._release_on_closecCsV|jdurdS|js|jdd|_|jdur"|jd|_|jj|dS)zRelease this connection holder.N)rZdone set_resultrVrMrT_queue put_nowaitrPr.r.r/r5s     zPoolConnectionHolder._releaseN) r^r_r`rarbrcrdrarrF)rr)rrF)rr@)roryrrF)r;r<r=rRrIrfrhrmrxrrrqrrlrkrrrr.r.r.r/rCps      % ?     rCc@seZdZdZdZdddddddZddZd d Zd d Zd dZ ddZ ddZ ddZ dVddZ ddZdddWdd ZdddXd"d#Zddd$dYd&d'Zd(dd)d*d+Zddd$d,d-Zddd$d.d/Zddddddddddddd0 d1d2Zddddddddddd3 d4d5Zddddddddddddddddd6d7d8Zddddd9d:d;Zdddd?Zddd@dAZdBdCZdDdEZdFdGZdHdIZdJdKZ dLdMZ!dNdOZ"dPdQZ#dRdSZ$dTdUZ%dS)ZPoolaA 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`. )rrU_minsize_maxsize_init_connectr _connect_args_connect_kwargs_holders _initialized _initializing_closing_closed_connection_class _record_classr]rXrW!_max_inactive_connection_lifetimeN)rmrbinitrc Os:t| dkrtjdtdd| durt} | |_|dkr!td|dkr)td||kr1td|dkr9td |dkrAtd t| t j sNt d | t| t js[t d | ||_||_g|_d |_d |_d|_| |_| |_d |_d |_d|_|dur|nt j|_| |_| |_||_||_||_ ||_!||_"dS)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)#lenwarningswarnDeprecationWarningrsget_event_looprU ValueError issubclassr r TypeErrorr7rRecordrrrrrrrrrrr]rmrrrrXrrrWr)r2min_sizemax_sizer` max_inactive_connection_lifetimermrbrrloopconnection_class record_class connect_argsconnect_kwargsr.r.r/rI\sh   z Pool.__init__csb|jr|S|jrtd|jrtdd|_z|IdH|Wd|_d|_Sd|_d|_w)Nz)pool is being initialized in another taskpool is closedTF)rrr r6r _initializerPr.r.r/_async__init__s" zPool._async__init__cstj|jd|_t|jD]}t||j|j|jd}|j ||j |q|j rh|j d}| IdH|j dkrjg}tt|j ddD]\}}||j dkrVn| | qItj|IdHdSdSdS)N)maxsize)r`rdrbr )rs LifoQueuerrrangerCrWrrXrappendrrrm enumeratereversedgather)r2rchfirst_ch connect_tasksir.r.r/rs.    zPool._initializecCs |jp|jS)z_Return ``True`` if the pool is closing or is closed. .. versionadded:: 0.28.0 )rrrPr.r.r/ is_closings zPool.is_closingcCtdd|jDS)zaReturn the current number of connections in this pool. .. versionadded:: 0.25.0 css|]}|VqdSrG)rf.0hr.r.r/ sz Pool.get_size..sumrrPr.r.r/get_sizez Pool.get_sizecC|jS)zaReturn the minimum number of connections in this pool. .. versionadded:: 0.25.0 )rrPr.r.r/ get_min_sizezPool.get_min_sizecCr)ziReturn the maximum allowed number of connections in this pool. .. versionadded:: 0.25.0 )rrPr.r.r/ get_max_sizerzPool.get_max_sizecCr)zfReturn the current number of idle connections in this pool. .. versionadded:: 0.25.0 css |] }|o |VqdSrG)rfrhrr.r.r/rsz%Pool.get_idle_size..rrPr.r.r/ get_idle_sizerzPool.get_idle_sizecKs|g|_||_dS)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)r2dsnrr.r.r/set_connect_argss zPool.set_connect_argsc s|j|j|j|j|jd|jIdH}t||jsI|j}|jd|j}t |}|jdkr4|j}n |jd|j}t d|d|d|j durvz | |IdHW|St tjfyu}z z |IdHW||d}~ww|S)N)rrr.builtinsz9expected pool connect callback to return an instance of 'z', got '')rrrUrrr isinstancer<r;typer r6rrrrsrtrq)r2rDgoodgood_nbadbad_nrwr.r.r/rjsD   zPool._get_new_connectionrnqueryrroryrc s`|4IdH}|j|g|Rd|iIdHWdIdHS1IdHs)wYdS)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 Nro)rxexecute)r2rror3rDr.r.r/rAs0z Pool.executecommandc sX|4IdH}|j|||dIdHWdIdHS1IdHs%wYdS)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 Nrn)rx executemany)r2rr3rorDr.r.r/rRs0zPool.executemanyrorlistc b|4IdH}|j|g|R||dIdHWdIdHS1IdHs*wYdS)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)rxfetchr2rrorr3rDr.r.r/res 0z Pool.fetchrcolumnroc r)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)rxfetchval)r2rrror3rDr.r.r/r|s  0z Pool.fetchvalc r)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)rxfetchrowrr.r.r/rs  0z Pool.fetchrowc sZ|4IdH}|j||||dIdHWdIdHS1IdHs&wYdS)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)rx fetchmany)r2rr3rorrDr.r.r/rs   0zPool.fetchmany) columns schema_nameror7oids delimiternullheaderquoteescape force_quoteencodingc sn|4IdH!}|j||||||||| | | | | |dIdHWdIdHS1IdHs0wYdS)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) outputrrror7rrrrrrrr)rxcopy_from_table)r2 table_namerrrror7rrrrrrrrrDr.r.r/rs& 0zPool.copy_from_table) ror7rrrrrrrrc st|4IdH$}|j|g| R|||||||| | | | d IdHWdIdHS1IdHs3wYdS)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) rror7rrrrrrrr)rxcopy_from_query)r2rrror7rrrrrrrrr3rDr.r.r/rs( 0zPool.copy_from_query)rrror7rfreezerrrrrrforce_not_null force_nullrwherec s|4IdHH}|j|fid|d|d|d|d|d|d|d | d | d | d | d | d|d|d|d|d|IdHWdIdHS1IdHsWwYdS)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 Nsourcerrror7rrrrrrrrrrrr)rx copy_to_table)r2rrrrror7rrrrrrrrrrrrrDr.r.r/rsP     0zPool.copy_to_table)rrrorc s^|4IdH}|j||||||dIdHWdIdHS1IdHs(wYdS)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)recordsrrror)rxcopy_records_to_table)r2rrrrrorrDr.r.r/r7s 0zPool.copy_records_to_tablecCs t||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) )PoolAcquireContextr2ror.r.r/rxTs z Pool.acquirecsRfdd}jrtddur|IdHStj|dIdHS)Nc sRjIdH}z |IdH}Wnttjfy#j|w|_|SrG)rgetrxrrrsrtrr\)rrvrr.r/ _acquire_implns z$Pool._acquire.._acquire_implzpool is closingrn)rr r6 _check_initr r)r2rorr.rr/_acquirems   z Pool._acquirecsvt|tus |jj|urtdj|d|jdurdS||j |j}|dur0|j }t | |IdHS)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)rr@rArTr r6r7r5r _on_releaser\rsshieldr)r2r rorr.r.r/rs"   z Pool.releasec s|jrdS|d|_d}zKz*|jd|j}dd|jD}tj|IdHdd|jD}tj|IdHWnt tj fyI| wW|durS| d|_d|_dS|durc| d|_d|_w)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<cSg|]}|qSr.)rrrr.r.r/ zPool.close..cSr r.rqr r.r.r/r r F) rrrrUr_warn_on_long_closerrsrrrrtrr)r2warning_callback release_coros close_corosr.r.r/rqs> z Pool.closecCstddS)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().)loggerwarningrPr.r.r/rszPool._warn_on_long_closecCs0|jrdS||jD]}|q d|_dS)z&Terminate all connections in the pool.NT)rrrrr2rr.r.r/rs    zPool.terminatecs|jd7_dS)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)r]rPr.r.r/expire_connectionsszPool.expire_connectionscCs4|js|jr tdtd|jrtddS)Nzipool is being initialized, but not yet ready: likely there is a race between creating a pool and using itzpool is not initializedr)rrr r6rrPr.r.r/rs  zPool._check_initcC$|jD] }|jdur|jqdSrG)rr5_drop_local_statement_cacherr.r.r/_drop_statement_cache   zPool._drop_statement_cachecCrrG)rr5_drop_local_type_cacherr.r.r/_drop_type_cacherzPool._drop_type_cachecCs |SrG)r __await__rPr.r.r/rs zPool.__await__cs|IdH|SrG)rrPr.r.r/ __aenter__ szPool.__aenter__cs|IdHdSrGr)r2excr.r.r/ __aexit__szPool.__aexit__rG)rrroryrr)rrrory)rr)&r;r<r=rrRrIrrrrrrrrrjrrrrrrrrrrrxrrrqrrrrrrrrr r.r.r.r/rIs   Q! , 2 / : &-    rc@s<eZdZdZddd Zd d Z ddddZddZd S)r)ror rr^r^rroryrrFcCs||_||_d|_d|_dS)NF)r^ror r)r2r^ror.r.r/rIs zPoolAcquireContext.__init__cs8|jdus |jrtd|j|jIdH|_|jS)Nz a connection is already acquired)r rr r6r^rrorPr.r.r/rs  zPoolAcquireContext.__aenter__Nexc_typeOptional[Type[BaseException]]exc_valOptional[BaseException]exc_tbOptional[TracebackType]cs*d|_|j}d|_|j|IdHdSNT)rr r^r)r2r!r#r%rDr.r.r/r #s zPoolAcquireContext.__aexit__cCsd|_|j|jSr')rr^rrorrPr.r.r/r.szPoolAcquireContext.__await__)r^rroryrrF)NNN)r!r"r#r$r%r&rrF)r;r<r=rRrIrr rr.r.r.r/rs  r iPgr@) rrr`rrmrbrrrrrc Ks(t|f| | |||| |||||d | S)a8Create a connection pool. Can be used either with an ``async with`` block: .. code-block:: python async with asyncpg.create_pool(user='postgres', command_timeout=60) as pool: await pool.fetch('SELECT 1') Or to perform multiple operations on a single connection: .. code-block:: python async with asyncpg.create_pool(user='postgres', command_timeout=60) as pool: async with pool.acquire() as con: await con.execute(''' CREATE TABLE names ( id serial PRIMARY KEY, name VARCHAR (255) NOT NULL) ''') await con.fetch('SELECT 1') Or directly with ``await`` (not recommended): .. code-block:: python pool = await asyncpg.create_pool(user='postgres', command_timeout=60) con = await pool.acquire() try: await con.fetch('SELECT 1') finally: await pool.release(con) .. warning:: Prepared statements and cursors returned by :meth:`Connection.prepare() ` 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. ) rrrrr`rrmrbrrr)r) rrrr`rrmrbrrrrrrr.r.r/ create_pool3s$  r)rG)# __future__rrscollections.abcrrr#rloggingr}typesrtypingrrrrr r r r getLoggerr;rrr_ConnectionProxyr@rCrrrrr)r.r.r.r/sT       2"ZO