o hP @sddlZddlZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z e e Z GdddeZGd d d ejed d ZGd ddZGdddZGdddZddddddddddeje jd ddZdS)N)compat connection) exceptions)protocolcs.eZdZddfdd ZeddZZS)PoolConnectionProxyMetaF)wrapc s|r?ttjD]-}|ds||vrqttj|}t|sqt|}|||}t ||}|||<qd|vr?tjj |d<t ||||S)N___doc__)dirr Connection startswithgetattrinspect isfunctioniscoroutinefunction_wrap_connection_method functoolsupdate_wrapperr super__new__) mclsnamebasesdctr attrnamemeth iscoroutinewrapper __class__`/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/asyncpg/pool.pyrs       zPoolConnectionProxyMeta.__new__csfdd}|r t||S)Ncs@|jdur tdt|jj}||jg|Ri|S)NzJcannot call Connection.{}(): connection has been released back to the pool)_conrInterfaceErrorformatrr!)selfargskwargsr meth_namer"r#call_con_method0s zHPoolConnectionProxyMeta._wrap_connection_method..call_con_method)rmarkcoroutinefunction)r+rr,r"r*r#r.s  z/PoolConnectionProxyMeta._wrap_connection_method)__name__ __module__ __qualname__r staticmethodr __classcell__r"r"r r#rsrc@sDeZdZdZdddejfddZddZd ejfd d Zd d Z dS)PoolConnectionProxy)r$_holderholderPoolConnectionHolderconcCs||_||_||dSN)r$r4 _set_proxy)r'r5r7r"r"r#__init__GszPoolConnectionProxy.__init__cCs t|j|Sr8)rr$)r'attrr"r"r# __getattr__Ms zPoolConnectionProxy.__getattr__returncCs*|jdurdS|jd}|_|d|Sr8)r$r9)r'r7r"r"r#_detachQs  zPoolConnectionProxy._detachcCs:|jdurdj|jjt|dSdj|jj|jt|dS)Nz <{classname} [released] {id:#x}>) classnameidz<{classname} {con!r} {id:#x}>)r?r7r@)r$r&r!r.r@r'r"r"r#__repr__Ys  zPoolConnectionProxy.__repr__N) r.r/r0 __slots__rr r:r<r>rBr"r"r"r#r3As  r3T) metaclassr c@seZdZdZddZddZddZdd Zd efd d Z d dZ ddZ ddZ ddZ ddZddZddZddZddZdS) r6) r$_pool_loop_proxy _max_queries_setup_max_inactive_time_in_use_inactive_callback_timeout _generationcCs@||_d|_d|_||_||_||_d|_d|_d|_d|_ dSr8) rEr$rGrHrJrIrLrKrMrN)r'pool max_queriessetupmax_inactive_timer"r"r#r:js zPoolConnectionHolder.__init__cCs|jduo |j Sr8)r$ is_closedrAr"r"r# is_connectedxsz!PoolConnectionHolder.is_connectedcCs|j Sr8rKrAr"r"r#is_idle{szPoolConnectionHolder.is_idlecsF|jdur td|jIdH|_|jj|_||dS)NzMPoolConnectionHolder.connect() called while another connection already exists)r$rInternalClientErrorrE_get_new_connectionrN_maybe_cancel_inactive_callback_setup_inactive_callbackrAr"r"r#connect~s   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)r$rSr[rNrErF create_taskcloserMrYr3rGrI ExceptionasyncioCancelledError create_futurerK)r'proxyexr"r"r#acquires. zPoolConnectionHolder.acquirec 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 holderr\)rKrrWr$rSrM _protocol queries_countrHr_rNrE_is_cancellingtime monotonicrwait_for_wait_for_cancellation_resetr]resetr`rarb terminate_releaserZ)r'r]budgetstartedrer"r"r#releasesP      (  zPoolConnectionHolder.releasecs |jdurdS|jIdHdSr8rUrAr"r"r#wait_until_releaseds z(PoolConnectionHolder.wait_until_releasedcs$|jdur|jIdHdSdSr8)r$r_rAr"r"r#r_s zPoolConnectionHolder.closecCs|jdur |jdSdSr8)r$rprAr"r"r#rps zPoolConnectionHolder.terminatecCs8|jdur td|jr|jj|j|j|_dSdS)Nz/pool connection inactivity timer already exists)rLrrWrJrErF call_later_deactivate_inactive_connectionrAr"r"r#rZs  z-PoolConnectionHolder._setup_inactive_callbackcCs"|jdur|jd|_dSdSr8)rLcancelrAr"r"r#rYs   z4PoolConnectionHolder._maybe_cancel_inactive_callbackcCs8|jdur td|jdur|j|dSdS)Nz/attempting to deactivate an acquired connection)rKrrWr$rp_release_on_closerAr"r"r#rw s    z4PoolConnectionHolder._deactivate_inactive_connectioncCs||d|_dSr8)rYrqr$rAr"r"r#rys z&PoolConnectionHolder._release_on_closecCsV|jdurdS|js|jdd|_|jdur"|jd|_|jj|dS)zRelease this connection holder.N)rKdone set_resultrGr>rE_queue put_nowaitrAr"r"r#rq s     zPoolConnectionHolder._releaseN)r.r/r0rCr:rTrVr[r3rfrtrur_rprZrYrwryrqr"r"r"r#r6bs  %?  r6c@seZdZdZdZdddddddZddZd d Zd d Zd dZ ddZ ddZ ddZ dSddZ ddZdddededefddZdddedefd d!Zddd"defd#d$Zd%dd&d'd(Zddd"d)d*Zddd"d+d,Zddddddddddddd- d.d/Zddddddddddd0 d1d2Zddddddddddddddddd3d4d5Zddddd6d7d8Zddd9d:Zd;d<Zddd=d>Zd?d@ZdAdBZ dCdDZ!dEdFZ"dGdHZ#dIdJZ$dKdLZ%dMdNZ&dOdPZ'dQdRZ(dS)TPoolaA 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`. )r|rF_minsize_maxsize_init_connectrn _connect_args_connect_kwargs_holders _initialized _initializing_closing_closed_connection_class _record_classrNrIrH!_max_inactive_connection_lifetimeN)r[rQinitroc 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)NrzPassing 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)#lenwarningswarnDeprecationWarningraget_event_looprF ValueError issubclassrr TypeErrorr&rRecordrrrrrr|rrrrrNr[rrrrIrrnrHr)r'min_sizemax_sizerP max_inactive_connection_lifetimer[rQrroloopconnection_class record_class connect_argsconnect_kwargsr"r"r#r:Gsh   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)rrrr%r _initializerAr"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)rPrRrQr)ra LifoQueuerr|ranger6rHrrIrappendr}rr[ enumeratereversedgather)r'r chfirst_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 )rrrAr"r"r# is_closings zPool.is_closingcCtdd|jDS)zaReturn the current number of connections in this pool. .. versionadded:: 0.25.0 css|]}|VqdSr8)rT.0hr"r"r# sz Pool.get_size..sumrrAr"r"r#get_sizez Pool.get_sizecC|jS)zaReturn the minimum number of connections in this pool. .. versionadded:: 0.25.0 )rrAr"r"r# get_min_sizezPool.get_min_sizecCr)ziReturn the maximum allowed number of connections in this pool. .. versionadded:: 0.25.0 )rrAr"r"r# get_max_sizerzPool.get_max_sizecCr)zfReturn the current number of idle connections in this pool. .. versionadded:: 0.25.0 css |] }|o |VqdSr8)rTrVrr"r"r#rsz%Pool.get_idle_size..rrAr"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)r'dsnrr"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 '')rrrFrrr isinstancer/r.typerr%rr`rarbr_)r'r7goodgood_nbadbad_nrer"r"r#rXsD   zPool._get_new_connectionr\queryr]r=c 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 Nr])rfexecute)r'rr]r(r7r"r"r#r,s 0z 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 Nr\)rf executemany)r'rr(r]r7r"r"r#r8s 0zPool.executemanyr]rc 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)rffetchr'rr]rr(r7r"r"r#rEs 0z Pool.fetchrcolumnr]c 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)rffetchval)r'rrr]r(r7r"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)rffetchrowrr"r"r#rjs  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)rf fetchmany)r'rr(r]rr7r"r"r#r{s   0zPool.fetchmany) columns schema_namer]r&oids 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) outputrrr]r&rrrrrrrr)rfcopy_from_table)r' table_namerrrr]r&rrrrrrrrr7r"r"r#rs& 0zPool.copy_from_table) r]r&rrrrrrrrc 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) rr]r&rrrrrrrr)rfcopy_from_query)r'rrr]r&rrrrrrrrr(r7r"r"r#rs( 0zPool.copy_from_query)rrr]r&rfreezerrrrrrforce_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 Nsourcerrr]r&rrrrrrrrrrrr)rf copy_to_table)r'rrrrr]r&rrrrrrrrrrrrr7r"r"r#rsP     0zPool.copy_to_table)rrr]rc 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)recordsrrr]r)rfcopy_records_to_table)r'rrrrr]rr7r"r"r#rs 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) )PoolAcquireContextr'r]r"r"r#rf4s z Pool.acquirecsRfdd}jrtddur|IdHStj|dIdHS)Nc sRjIdH}z |IdH}Wnttjfy#j|w|_|Sr8)r|getrfr`rarbr}rM)rrdrr"r# _acquire_implNs z$Pool._acquire.._acquire_implzpool is closingr\)rrr% _check_initrrl)r'r]rr"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 poolrN)rr3r4rErr%r&r$r _on_releaserMrashieldrt)r'rr]rr"r"r#rtes"   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")rurrr"r"r# zPool.close..cSrr"r_rr"r"r#rrF) rrrrFrv_warn_on_long_closerrarr`rbrprx)r'warning_callback release_coros close_corosr"r"r#r_s> 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().)loggerwarningrAr"r"r#rszPool._warn_on_long_closecCs0|jrdS||jD]}|q d|_dS)z&Terminate all connections in the pool.NT)rrrrpr'rr"r"r#rps    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 rN)rNrAr"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)rrrr%rrAr"r"r#rs  zPool._check_initcC$|jD] }|jdur|jqdSr8)rr$_drop_local_statement_cacherr"r"r#_drop_statement_cache   zPool._drop_statement_cachecCrr8)rr$_drop_local_type_cacherr"r"r#_drop_type_cacherzPool._drop_type_cachecCs |Sr8)r __await__rAr"r"r#r s zPool.__await__cs|IdH|Sr8)rrAr"r"r# __aenter__szPool.__aenter__cs|IdHdSr8r)r'excr"r"r# __aexit__szPool.__aexit__r8))r.r/r0r rCr:rrrrrrrrrXstrfloatrrlistrrrrrrrrrfrrtr_rrprrrrr r r r"r"r"r#r~4s   Q! (   2 / : &-    r~c@s0eZdZdZddZddZddZdd Zd S) r)r]rrzrOcCs||_||_d|_d|_dS)NF)rOr]rrz)r'rOr]r"r"r#r:s zPoolAcquireContext.__init__cs8|jdus |jrtd|j|jIdH|_|jS)Nz a connection is already acquired)rrzrr%rOrr]rAr"r"r#r s  zPoolAcquireContext.__aenter__cs*d|_|j}d|_|j|IdHdSNT)rzrrOrt)r'r r7r"r"r#r s zPoolAcquireContext.__aexit__cCsd|_|j|jSr)rzrOrr]r rAr"r"r#r  szPoolAcquireContext.__await__N)r.r/r0rCr:r r r r"r"r"r#rs  r iPgr@) rrrPrr[rQrrorrrc 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. ) rrrrrPrr[rQrror)r~) rrrrPrr[rQrrorrrrr"r"r# create_pools$  rr8)rarrloggingrjrrrrr getLoggerr.rrr_ConnectionProxyr3r6r~rr rrr"r"r"r#sL     )!SD