ޠjvSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKrSSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SS KJr SS KJr SS KJr SS KJr "S S\5r"SS\S9rS,SSSSSSSSSSSSSSSS\\R:SSSSS.Sjjr"SS5r"SS5r "SS\ RB5r""SS5r#"S S!5r$\RJ"S"/S#Q5r&S$\&l'\RJ"S%/S&Q5r(S'\(l'S(r)S-S)jr*S*r+S+r,Sq-g).N)compat) connect_utils)cursor) exceptions) introspection) prepared_stmt)protocol) serverversion) transaction)utilsc\rSrSrSrSrg)ConnectionMeta$c^[U5Rn[U;=(d [U;$N)type__mro__ Connection_ConnectionProxy)clsinstancemros L/var/www/html/gaurav/venv/lib/python3.13/site-packages/asyncpg/connection.py__instancecheck__ ConnectionMeta.__instancecheck__&s'8n$$S ;$4$;;N)__name__ __module__ __qualname____firstlineno__r__static_attributes__rrrrr$sjr0S?r1S@r2SASBSC.SDjr3SASE.SFjr4SASSC.SGjr5SHr6SS.SIjr7SJr8SKr9SS.SLjr:SMr;SNrSQr?SRr@SSrASTrBSUrCSVrDSWrESXrFSYrGSZrHS[rIS\rJS]rKSmS^jrLS_rMS`rNSarOSbrPScrQSSSSd.SejrR\SRSf5rU\SRSg5rVSSSSd.ShjrWSnSijrXSoSSSj.SkjjrYSlrZg)pr+zqA representation of a database session. Connections are created by calling :func:`~asyncpg.connection.connect`. ) _protocol _transport_loop _top_xact_aborted_pool_release_ctr _stmt_cache_stmts_to_close_stmt_cache_enabled _listeners_server_version _server_caps _intro_query _reset_query_proxy_stmt_exclusive_section_config_params_addr_log_listeners_termination_listeners_cancellations_source_traceback_query_loggers __weakref__configparamsc XlX lX0lSUlSUlSUlX@lXPlX`l[UUR[R"[[R"U55UR S9Ul[%5UlURS:Ul0Ul[%5Ul[%5Ul[%5Ul[%5UlURR55nUR6n[8R:"U5Ul[?UR<U5Ul UR<S:a[BRDUl#O[BRHUl#SUl%SUl&[O5Ul(URS5(a[U5Ul+gSUl+g)NFr)loopmax_size on_remove max_lifetime)r),r&r'r(r)r*r+r8r6r7_StatementCachestatement_cache_size functoolspartial_weak_maybe_gc_stmtweakrefrefmax_cached_statement_lifetimer,setr-r.r/r9r;r:r= get_settingsserver_versionr split_server_version_stringr0_detect_server_capabilitiesr1rINTRO_LOOKUP_TYPES_13r2INTRO_LOOKUP_TYPESr3r4_Atomicr5 get_debug_extract_stackr<) selfr transportrBaddrr?r@settings ver_strings r__init__Connection.__init__;sz"#  "#   *00''#W[[%68== ? #u#)#>#>#B !e!e&)e#!e>>..0,,  5 5j A 8  (,   ' ) - C CD  - @ @D   (/y$ >>  %3%5D "%)D "rc^UR5(dURbUR(aSRXR5nOSRU5n[R "U[ 5 URR5(dUR5 gggg)Nz)unclosed connection {!r}; created at: {}z^unclosed connection {!r}; run in asyncio debug mode to show the traceback of connection origin) is_closedr&r<formatwarningswarnResourceWarningr( terminate)rYmsgs r__del__Connection.__del__{s~~DNN$>%%BII002#VD\ MM# /::'')) *%?rcV# UR5 XR;aSURSR[R "U555IShvN [ 5URU'URUR[RU55 gNM7f)aAdd a listener for Postgres notifications. :param str channel: Channel to listen on. :param callable callback: A callable or a coroutine function receiving the following arguments: **connection**: a Connection the callback is registered with; **pid**: PID of the Postgres server that sent the notification; **channel**: name of the channel the notification was sent to; **payload**: the payload. .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. z LISTEN {}N) _check_openr/fetchrbr _quote_identrOadd _Callback from_callable)rYchannelcallbacks r add_listenerConnection.add_listeners}  // )**[//0B0B70KLM M M'*uDOOG $  $$Y%<%>    // )   $ $X . __W- -   ''+w'(**]11%2D2DW2MNO O O( OsCCCCcUR5(a[R"S5eURR [ R U55 g)aAdd a listener for Postgres log messages. It will be called when asyncronous NoticeResponse is received from the connection. Possible message types are: WARNING, NOTICE, DEBUG, INFO, or LOG. :param callable callback: A callable or a coroutine function receiving the following arguments: **connection**: a Connection the callback is registered with; **message**: the `exceptions.PostgresLogMessage` message. .. versionadded:: 0.12.0 .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. connection is closedN)rarInterfaceErrorr9rnrorprYrrs radd_log_listenerConnection.add_log_listenersB$ >>  ++,BC C  7 7 ABrc`URR[RU55 g)zHRemove a listening callback for log messages. .. versionadded:: 0.12.0 N)r9discardrorpr}s rremove_log_listenerConnection.remove_log_listeners# ##I$;$;H$EFrc`URR[RU55 g)aOAdd a listener that will be called when the connection is closed. :param callable callback: A callable or a coroutine function receiving one argument: **connection**: a Connection the callback is registered with. .. versionadded:: 0.21.0 .. versionchanged:: 0.24.0 The ``callback`` argument may be a coroutine function. N)r:rnrorpr}s radd_termination_listener#Connection.add_termination_listeners# ##'' (?(?(IJrc`URR[RU55 g)zRemove a listening callback for connection termination. :param callable callback: The callable or coroutine function that was passed to :meth:`Connection.add_termination_listener`. .. versionadded:: 0.21.0 N)r:rrorpr}s rremove_termination_listener&Connection.remove_termination_listeners# ##++I,C,CH,MNrc`URR[RU55 g)a1Add a logger that will be called when queries are executed. :param callable callback: A callable or a coroutine function receiving one argument: **record**, a LoggedQuery containing `query`, `args`, `timeout`, `elapsed`, `exception`, `conn_addr`, and `conn_params`. .. versionadded:: 0.29.0 N)r=rnrorpr}s radd_query_loggerConnection.add_query_loggers#  7 7 ABrc`URR[RU55 g)zRemove a query logger callback. :param callable callback: The callable or coroutine function that was passed to :meth:`Connection.add_query_logger`. .. versionadded:: 0.29.0 N)r=rrorpr}s rremove_query_loggerConnection.remove_query_loggers# ##I$;$;H$EFrc6URR5$)zAReturn the PID of the Postgres server the connection is bound to.)r&get_server_pidrYs rrConnection.get_server_pids~~,,..rcUR$)a6Return the version of the connected PostgreSQL server. The returned value is a named tuple similar to that in ``sys.version_info``: .. code-block:: pycon >>> con.get_server_version() ServerVersion(major=9, minor=6, micro=1, releaselevel='final', serial=0) .. versionadded:: 0.8.0 )r0rs rget_server_versionConnection.get_server_versions###rc6URR5$)zLReturn connection settings. :return: :class:`~asyncpg.ConnectionSettings`. )r&rPrs rrPConnection.get_settingss ~~**,,rNF) isolationreadonly deferrablecPUR5 [R"XX#5$)aCreate a :class:`~transaction.Transaction` object. Refer to `PostgreSQL documentation`_ on the meaning of transaction parameters. :param isolation: Transaction isolation mode, can be one of: `'serializable'`, `'repeatable_read'`, `'read_uncommitted'`, `'read_committed'`. If not specified, the behavior is up to the server and session, which is usually ``read_committed``. :param readonly: Specifies whether or not this transaction is read-only. :param deferrable: Specifies whether or not this transaction is deferrable. .. _`PostgreSQL documentation`: https://www.postgresql.org/docs/ current/static/sql-set-transaction.html )rkr Transaction)rYrrrs rr Connection.transactions#. &&tMMrc6URR5$)zReturn True if Connection is currently inside a transaction. :return bool: True if inside transaction, False otherwise. .. versionadded:: 0.16.0 )r&is_in_transactionrs rrConnection.is_in_transaction1s~~//11r)timeoutqueryrreturnc# UR5 U(dvUR(a@URXU5 URR X5IShvN nSSS5 U$URR X5IShvN nU$UR UUSUSS9IShvN upVnUR 5$Na!,(df  W$=fNHN-7f)aExecute an SQL command (or commands). This method can execute many SQL commands at once, when no arguments are provided. Example: .. code-block:: pycon >>> await con.execute(''' ... CREATE TABLE mytab (a int); ... INSERT INTO mytab (a) VALUES (100), (200), (300); ... ''') INSERT 0 3 >>> await con.execute(''' ... INSERT INTO mytab (a) VALUES ($1), ($2) ... ''', 10, 20) INSERT 0 2 :param args: Query arguments. :param float timeout: Optional timeout value in seconds. :return str: Status of the last SQL command. .. versionchanged:: 0.5.4 Made it possible to pass query arguments. NrT) return_status)rkr= _time_and_logr&r_executedecode)rYrrargsresult_statuss rexecuteConnection.execute:sB ""''W=#'>>#7#7#GGF>M $~~33ECCM!]]    +  1}}H>=MD sL;CCB>C!(C C C&C'C>C C CCcommandcb# UR5 URXU5IShvN $N7f)a|Execute an SQL *command* for each sequence of arguments in *args*. Example: .. code-block:: pycon >>> await con.executemany(''' ... INSERT INTO mytab (a) VALUES ($1, $2, $3); ... ''', [(1, 2, 3), (4, 5, 6)]) :param command: Command to execute. :param args: An iterable containing sequences of arguments. :param float timeout: Optional timeout value in seconds. :return None: This method discards the results of the operations. .. versionadded:: 0.7.0 .. versionchanged:: 0.11.0 `timeout` became a keyword-only parameter. .. versionchanged:: 0.22.0 ``executemany()`` is now an atomic operation, which means that either all executions succeed, or none at all. This is in contrast to prior versions, where the effect of already-processed iterations would remain in place when an error has occurred, unless ``executemany()`` was called in a transaction. Nrk _executemany)rYrrrs r executemanyConnection.executemanyns-D &&wg>>>> &/-/T)named use_cacheignore_custom_codec record_classrc# UcURR5nO [U5 U(ayURR XU45nUbU$UR =(aD UR R(+=(d" [U5UR R:*n[U[5(aUnO"U(dU(aURS5nOSnURRUUUUUS9IShvN nSn UR5n Sn U (aURR5n URX5IShvN upU R!U 5 UR"(+=(a UR"(+n UR5n U S- n U S:a%[$R&"SR)U 55eU (aMUR+5 U (d"UR"(d!UR (dUR-5 U(aURR/XU4U5 UR0(aUR35IShvN U$GNqGN&N 7f) NstmtrrFrrzCcould not resolve query result and/or argument types in {} attempts)r&get_record_class_check_record_classr,getr.r6max_cacheable_statement_sizelen isinstancestr_get_unique_idprepare _init_typesrP_introspect_typesregister_data_typesnamerInternalClientErrorrb _init_codecsmark_unpreparedputr-_cleanup_stmts)rYrrrrrr statement stmt_nameneed_repreparetypes_with_missing_codecstriesr\types intro_stmts r_get_statementConnection._get_statements;  >>::@ @Aw sB B: B8+B:)prefetchrrc ZUR5 [R"UUSUUUU5$)aHReturn a *cursor factory* for the specified query. :param args: Query arguments. :param int prefetch: The number of rows the *cursor iterator* will prefetch (defaults to ``50``.) :param float timeout: Optional timeout in seconds. :param type record_class: If specified, the class to use for records returned by this cursor. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: A :class:`~cursor.CursorFactory` object. .. versionchanged:: 0.22.0 Added the *record_class* parameter. N)rkr CursorFactory)rYrrrrrs rrConnection.cursor7s88 ##         rrrrcB# URUUUUS9IShvN $N7f)aCreate a *prepared statement* for the specified query. :param str query: Text of the query to create a prepared statement for. :param str name: Optional name of the returned prepared statement. If not specified, the name is auto-generated. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by the prepared statement. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: A :class:`~prepared_stmt.PreparedStatement` instance. .. versionchanged:: 0.22.0 Added the *record_class* parameter. .. versionchanged:: 0.25.0 Added the *name* parameter. rN)_prepare)rYrrrrs rrConnection.prepare^s4@]] % #    s )rrrrrrc# UR5 Uc URnURUUUUUS9IShvN n[R"XU5$N7f)N)rrr)rkr.rr PreparedStatement)rYrrrrrrs rrConnection._preparesf  <++D((  % )  ..tDAA s6AAA)rrcd# UR5 URUUSUUS9IShvN $N7f)akRun a query and return the results as a list of :class:`Record`. :param str query: Query text. :param args: Query arguments. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return list: A list of :class:`~asyncpg.Record` instances. If specified, the actual type of list elements would be *record_class*. .. versionchanged:: 0.22.0 Added the *record_class* parameter. rrNrkr)rYrrrrs rrlConnection.fetchsB6 ]]   % #    s '0.0r)columnrc# UR5 URXSU5IShvN nU(dgUSU$N7f)aARun a query and return a value in the first row. :param str query: Query text. :param args: Query arguments. :param int column: Numeric index within the record of the value to return (defaults to 0). :param float timeout: Optional timeout value in seconds. If not specified, defaults to the value of ``command_timeout`` argument to the ``Connection`` instance constructor. :return: The value of the specified column of the first record, or None if no records were returned by the query. rNrr)rYrrrrdatas rfetchvalConnection.fetchvalsA ]]57;;AwvAc~# UR5 URUUSUUS9IShvN nU(dgUS$N7f)aRun a query and return the first row. :param str query: Query text :param args: Query arguments :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for the value returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return: The first row as a :class:`~asyncpg.Record` instance, or None if no records were returned by the query. If specified, *record_class* is used as the type for the result value. .. versionchanged:: 0.22.0 Added the *record_class* parameter. rrNrr)rYrrrrrs rfetchrowConnection.fetchrowsP8 ]]   % #  Aw s '=;=cb# UR5 URXUSUS9IShvN $N7f)aRun a query for each sequence of arguments in *args* and return the results as a list of :class:`Record`. :param query: Query to execute. :param args: An iterable containing sequences of arguments for the query. :param float timeout: Optional timeout value in seconds. :param type record_class: If specified, the class to use for records returned by this method. Must be a subclass of :class:`~asyncpg.Record`. If not specified, a per-connection *record_class* is used. :return list: A list of :class:`~asyncpg.Record` instances. If specified, the actual type of list elements would be *record_class*. Example: .. code-block:: pycon >>> rows = await con.fetchmany(''' ... INSERT INTO mytab (a, b) VALUES ($1, $2) RETURNING a; ... ''', [('x', 1), ('y', 2), ('z', 3)]) >>> rows [, , ] .. versionadded:: 0.30.0 T) return_rowsrNr)rYrrrrs r fetchmanyConnection.fetchmanys?L && d'    r) columns schema_namerrboids delimiternullheaderquoteescape force_quoteencodingc ^# [R"U5nU(a[R"U5S-U-nU(a(SRSRSU555nOSnUR XgUXXXS9 nSRUUUS9nUR UX%5IS hvN $N7f) aCopy table contents to a file or file-like object. :param str table_name: The name of the table to copy data from. :param output: A :term:`path-like object `, or a :term:`file-like object `, or a :term:`coroutine function ` that takes a ``bytes`` instance as a sole argument. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_from_table( ... 'mytable', columns=('foo', 'bar'), ... output='file.csv', format='csv') ... print(result) ... >>> asyncio.run(run()) 'COPY 100' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 .({}), c3L# UHn[R"U5v M g7frr rm.0cs r -Connection.copy_from_table.._AA%,,Q//"$r rbrrrrrrrrz!COPY {tab}{cols} TO STDOUT {opts})tabcolsoptsN)r rmrbjoin_format_copy_opts _copy_out)rY table_nameoutputrrrrbrrrrrrrrtabnamer*r+ copy_stmts rcopy_from_tableConnection.copy_from_table&sf$$Z0 ((5;gEG == AAACDD%% E#&  8>>d?/ ^^Iv????sB$B-&B+'B-) rrbrrrrrrrrc # URXEUXxXXS9 nU (a[R"XU 5IShvN nSRXS9nUR XU5IShvN $N-N7f)aCopy the results of a query to a file or file-like object. :param str query: The query to copy the results of. :param args: Query arguments. :param output: A :term:`path-like object `, or a :term:`file-like object `, or a :term:`coroutine function ` that takes a ``bytes`` instance as a sole argument. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_from_query( ... 'SELECT foo, bar FROM mytable WHERE foo > $1', 10, ... output='file.csv', format='csv') ... print(result) ... >>> asyncio.run(run()) 'COPY 10' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 r(NzCOPY ({query}) TO STDOUT {opts})rr+)r-r _mogrifyrbr.)rYrr0rrbrrrrrrrrrr+r2s rcopy_from_queryConnection.copy_from_queryns{`%% E#&  ..d;;E5<<=$ ^^Iw??? < @s!5A)A%(A) A'!A)'A))rrrrbrfreezerrrrrrforce_not_null force_nullrwherec# [R"U5nU(a[R"U5S-U-nU(a(SRSRSU555nOSnUR U5nUR XgXXXUUUS9 nSRUUUUS9nUR UX%5IS hvN $N7f) a Copy data to the specified table. :param str table_name: The name of the table to copy data to. :param source: A :term:`path-like object `, or a :term:`file-like object `, or an :term:`asynchronous iterable ` that returns ``bytes``, or an object supporting the :ref:`buffer protocol `. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param str where: An optional SQL expression used to filter rows when copying. .. note:: Usage of this parameter requires support for the ``COPY FROM ... WHERE`` syntax, introduced in PostgreSQL version 12. :param float timeout: Optional timeout value in seconds. The remaining keyword arguments are ``COPY`` statement options, see `COPY statement documentation`_ for details. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_to_table( ... 'mytable', source='datafile.tbl') ... print(result) ... >>> asyncio.run(run()) 'COPY 140000' .. _`COPY statement documentation`: https://www.postgresql.org/docs/current/static/sql-copy.html .. versionadded:: 0.11.0 .. versionadded:: 0.29.0 Added the *where* parameter. rrrc3L# UHn[R"U5v M g7frr r!s rr$+Connection.copy_to_table..r&r'r) rbrr9rrrrrr:r;r)COPY {tab}{cols} FROM STDIN {opts} {cond}r)r*r+condN)r rmrbr,_format_copy_wherer-_copy_in)rYr/sourcerrrrbrr9rrrrrrr:r;rr<r1r*rBr+r2s r copy_to_tableConnection.copy_to_tablesB$$Z0 ((5;gEG == AAACDD&&u-%%VE)j & @FFdDG: ]]9f>>>>sB8C:B?;C)rrrr<c# [R"U5nU(a[R"U5S-U-nU(a*SRSU55nSRU5n OSnSn SRXxS9n UR U 5IS hvN n UR U5n S n S RXyXS 9nUR RUS S X+RU5IS hvN $NXN7f) aQCopy a list of records to the specified table using binary COPY. :param str table_name: The name of the table to copy data to. :param records: An iterable returning row tuples to copy into the table. :term:`Asynchronous iterables ` are also supported. :param list columns: An optional list of column names to copy. :param str schema_name: An optional schema name to qualify the table. :param str where: An optional SQL expression used to filter rows when copying. .. note:: Usage of this parameter requires support for the ``COPY FROM ... WHERE`` syntax, introduced in PostgreSQL version 12. :param float timeout: Optional timeout value in seconds. :return: The status string of the COPY command. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... result = await con.copy_records_to_table( ... 'mytable', records=[ ... (1, 'foo', 'bar'), ... (2, 'ham', 'spam')]) ... print(result) ... >>> asyncio.run(run()) 'COPY 2' Asynchronous record iterables are also supported: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... async def record_gen(size): ... for i in range(size): ... yield (i,) ... result = await con.copy_records_to_table( ... 'mytable', records=record_gen(100)) ... print(result) ... >>> asyncio.run(run()) 'COPY 100' .. versionadded:: 0.11.0 .. versionchanged:: 0.24.0 The ``records`` argument may be an asynchronous iterable. .. versionadded:: 0.29.0 Added the *where* parameter. rrc3L# UHn[R"U5v M g7frr r!s rr$3Connection.copy_records_to_table..Vs H1!3!3A!6!6r'r*rz SELECT {cols} FROM {tab} LIMIT 1)r)r*Nz(FORMAT binary)r@rA) r rmr,rbrrCr&copy_in_state)rYr/recordsrrrr<r1col_listr* intro_queryintro_psrBr+r2s rcopy_records_to_table Connection.copy_records_to_tablesZ$$Z0 ((5;gEG yy H HHH==*DHD8??@( k22&&u- ?FFG: ^^++ tT7OOWFF F3Fs%BC1C-AC1(C/)C1/C1cU(a1URR(d[R"S5eU(aSU-nU$SnU$)Nz5the `where` parameter requires PostgreSQL 12 or laterzWHERE r)r1sql_copy_from_whererUnsupportedServerFeatureError)rYr< where_clauses rrCConnection._format_copy_wherejsO **>>::GI I #e+LLr) rbrr9rrrrrrr:r;rc D[[55n U RS5 /nU b>[U [5(a)U RS5 U (aUR S5 U R 5HunnUcM US;aSSRSU55-S-nO(US ;a [U5nO[R"U5nUR S RUR5U55 M U(aSSRU5-S-$g ) NrYrz FORCE_QUOTE *)r:r;r(rc3L# UHn[R"U5v M g7frr r!s rr$/Connection._format_copy_opts..s'Iq!(:(:1(=(=qr'))rr9rz{} {}r) dictlocalspoprboolappenditemsr,rr _quote_literalrbupper)rYrbrr9rrrrrrr:r;rkwargsr+kvs rr-Connection._format_copy_optsvsfh 6  "z+t'D'D JJ} % O,LLNDAq}GGdii'Iq'IIICOA66AA,,Q/A GNN1779a89# 4(3. .rcJ^^ # [R"U5nSnSnURRm UbT "S[ US5IShvN mSnOT[ US5(aUmO@[U5(aUnO-[SR[U5R55eUc UU 4SjnUnURRXU5IShvN U(aTR5 $$![a SnNf=fNN0!U(aTR5 ff=f7f)NFwbTwritez_output is expected to be a file-like object, a path-like object or a coroutine function, not {}cJ># T"STRU5IShvN gN7fr)rl)rfrun_in_executors r_writer%Connection._copy_out.._writers%dAGGT:::s #!#)osfspath TypeErrorr(roopenhasattrcallablerbrrr&copy_outclose) rYr2r0rpathwriter opened_by_usrprnros @@rr.Connection._copy_outs  99V$D  **44  %dD$==AL VW % %A f  FV 5 56  > ;F 00GLL C D >*M s^D#C0/D# D A'D#4DDDD#0 C?<D#>C??D#DD  D#c~^ ^ # [R"U5nSm SnSnSnURRm UbT "S[ US5IShvN m SnOB[ US5(aUm O.[U[RR5(aUnOUnT b"U U 4SjS5nU"5nURRXUSSU5IShvN U(aT "ST R5IShvN $$![a SnNf=fNN;N!U(aT "ST R5IShvN ff=f7f)NFrbTreadc*>\rSrSrSrUU4SjrSrg)$Connection._copy_in.._ReadericU$rrrs r __aiter__.Connection._copy_in.._Reader.__aiter__sKrcv># T"STRS5IShvN n[U5S:Xa[eU$N7f)Nir)rrStopAsyncIteration)rYrrnros r __anext__.Connection._copy_in.._Reader.__anext__s7!0qvvv!FFD4yA~00# Gs 979rN)rr r!r"rrr#)rnrosr_Readerrs $$rr)rrrsrtr(rorurvr collectionsabc AsyncIterabler&rLry) rYr2rErrzreaderrr|rrnros @@rrDConnection._copy_ins5 99V$D  **44  %dD$==AL VV $ $A   = = > > FD = $ $YF 5//4tW>>%dAGG444] D >>>5%dAGG444s|D=C<3D=DA!D=2"DDDD=5D6D=< D D= D  D=DD=D:2D53D::D=publictext)rrbc |# UR5 URR5nURX5IShvN n/n[R "U5(aSn Ov[R "U5(a>US:wa[R"SSS9eSn URUS4S 5IShvN upO[R"S US US 35e[R"U5(a[R"S SSS9eUSn URXX(U X4U5 UR5 gNN7f)aSet an encoder/decoder pair for the specified data type. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``) :param format: The type of the argument received by the *decoder* callback, and the type of the *encoder* callback return value. If *format* is ``'text'`` (the default), the exchange datum is a ``str`` instance containing valid text representation of the data type. If *format* is ``'binary'``, the exchange datum is a ``bytes`` instance containing valid _binary_ representation of the data type. If *format* is ``'tuple'``, the exchange datum is a type-specific ``tuple`` of values. The table below lists supported data types and their format for this mode. +-----------------+---------------------------------------------+ | Type | Tuple layout | +=================+=============================================+ | ``interval`` | (``months``, ``days``, ``microseconds``) | +-----------------+---------------------------------------------+ | ``date`` | (``date ordinal relative to Jan 1 2000``,) | | | ``-2^31`` for negative infinity timestamp | | | ``2^31-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``timestamp`` | (``microseconds relative to Jan 1 2000``,) | | | ``-2^63`` for negative infinity timestamp | | | ``2^63-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``timestamp | (``microseconds relative to Jan 1 2000 | | with time zone``| UTC``,) | | | ``-2^63`` for negative infinity timestamp | | | ``2^63-1`` for positive infinity timestamp. | +-----------------+---------------------------------------------+ | ``time`` | (``microseconds``,) | +-----------------+---------------------------------------------+ | ``time with | (``microseconds``, | | time zone`` | ``time zone offset in seconds``) | +-----------------+---------------------------------------------+ | any composite | Composite value elements | | type | | +-----------------+---------------------------------------------+ :param encoder: Callable accepting a Python object as a single argument and returning a value encoded according to *format*. :param decoder: Callable accepting a single argument encoded according to *format* and returning a decoded Python object. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import datetime >>> from dateutil.relativedelta import relativedelta >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... def encoder(delta): ... ndelta = delta.normalized() ... return (ndelta.years * 12 + ndelta.months, ... ndelta.days, ... ((ndelta.hours * 3600 + ... ndelta.minutes * 60 + ... ndelta.seconds) * 1000000 + ... ndelta.microseconds)) ... def decoder(tup): ... return relativedelta(months=tup[0], days=tup[1], ... microseconds=tup[2]) ... await con.set_type_codec( ... 'interval', schema='pg_catalog', encoder=encoder, ... decoder=decoder, format='tuple') ... result = await con.fetchval( ... "SELECT '2 years 3 mons 1 day'::interval") ... print(result) ... print(datetime.datetime(2002, 1, 1) + result) ... >>> asyncio.run(run()) relativedelta(years=+2, months=+3, days=+1) 2004-04-02 00:00:00 .. versionadded:: 0.12.0 Added the ``format`` keyword argument and support for 'tuple' format. .. versionchanged:: 0.12.0 The ``binary`` keyword argument is deprecated in favor of ``format``. .. versionchanged:: 0.13.0 The ``binary`` keyword argument was removed in favor of ``format``. .. versionchanged:: 0.29.0 Custom codecs for composite types are now supported with ``format='tuple'``. .. note:: It is recommended to use the ``'binary'`` or ``'tuple'`` *format* whenever possible and if the underlying type supports it. Asyncpg currently does not support text I/O for composite and range types, and some other functionality, such as :meth:`Connection.copy_to_table`, does not support types with text codecs. Nscalartuplez7only tuple-format codecs can be used on composite typeszUse `set_type_codec(..., format='tuple')` and pass/interpret data as a Python tuple. See an example at https://magicstack.github.io/asyncpg/current/usage.html#example-decoding-complex-types)hint compositeoid z cannot use custom codec on type rz2: it is neither a scalar type nor a composite typez/custom codecs on domain types are not supportedzSet the codec on the base type.zePostgreSQL does not distinguish domains from their base types in query results at the protocol level.)rdetail)rkr&rPrris_scalar_typeis_composite_typerUnsupportedClientFeatureErrorrr|is_domain_typeadd_python_codec_drop_local_statement_cache) rYrrencoderdecoderrbr\typeinfofull_typeinfoskindrrs rset_type_codecConnection.set_type_codecsVr >>..0..x@@  ' ' 1 1D  , ,X 6 6  >>MMD&*&<&<%"B'(!( NA++26(!H:FCD   ' ' 1 1::A6O  uo!! 64 f & ((*KA!(s%?D<D8A5D<7D:8BD<:D<)rc# URX5IShvN nURR5RUSX5 UR 5 gNB7f)zReset *typename* codec to the default implementation. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``) .. versionadded:: 0.12.0 Nr)rr&rPremove_python_codecr)rYrrrs rreset_type_codecConnection.reset_type_codecsR..x@@ ##%99 UOX / ((* AsAAAAcd# UR5 URX5IShvN n[R"U5(d%[R "SR X!55eUSnURR5RXaUSX45 UR5 gN7f)aSet a builtin codec for the specified scalar data type. This method has two uses. The first is to register a builtin codec for an extension type without a stable OID, such as 'hstore'. The second use is to declare that an extension type or a user-defined type is wire-compatible with a certain builtin data type and should be exchanged as such. :param typename: Name of the data type the codec is for. :param schema: Schema name of the data type the codec is for (defaults to ``'public'``). :param codec_name: The name of the builtin codec to use for the type. This should be either the name of a known core type (such as ``"int"``), or the name of a supported extension type. Currently, the only supported extension type is ``"pg_contrib.hstore"``. :param format: If *format* is ``None`` (the default), all formats supported by the target codec are declared to be supported for *typename*. If *format* is ``'text'`` or ``'binary'``, then only the specified format is declared to be supported for *typename*. .. versionchanged:: 0.18.0 The *codec_name* argument can be the name of any known core data type. Added the *format* keyword argument. Nz"cannot alias non-scalar type {}.{}rr) rkrrrrr|rbr&rPset_builtin_type_codecr)rYrr codec_namerbrrs rr!Connection.set_builtin_type_codecsF ..x@@++H55++4;;&' 'uo ##%<< 68Z A ((*As%B0B.BB0cfUR=(d URR5(+$)zReturn ``True`` if the connection is closed, ``False`` otherwise. :return bool: ``True`` if the connection is closed, ``False`` otherwise. )r*r& is_connectedrs rraConnection.is_closeds# }}ADNN$?$?$A AArc*# UR5(d#URRU5IShvN UR5 gN![[R 4a UR 5 ef=f!UR5 f=f7f)zClose the connection gracefully. :param float timeout: Optional timeout value in seconds. .. versionchanged:: 0.14.0 Added the *timeout* parameter. N)rar&ry ExceptionasyncioCancelledError_abort_cleanup)rYrs rryConnection.closesp >>##nn**7333 MMO 47112  KKM   MMOs7B3AA AB A,A;;A>>BBcnUR5(dUR5 UR5 g)z:Terminate the connection without waiting for pending data.N)rarrrs rrfConnection.terminates!~~ KKM rc# UR5 URR5 URR5 URR 5(d UR buUR bUR R(d,URRSSRU505 SUlURS5IShvN ggN7f)Nmessagez4Resetting connection with an active transaction {!r}ROLLBACK) rkr/clearr9r&rr)_managedr(call_exception_handlerrbrrs r_resetConnection._resets   !!# >> + + - -1K~~%T^^-D-D 11 99?3 "DN,,z* * *2L +sC C+"C)#C+c># [R"U5IShvN UR5IShvN UR5nU(aUR U5IShvN SSS5IShvN gN]NGNN !,IShvN (df  g=f7f)aReset the connection state. Calling this will reset the connection session state to a state resembling that of a newly obtained connection. Namely, an open transaction (if any) is rolled back, open cursors are closed, all `LISTEN `_ registrations are removed, all session configuration variables are reset to their default values, and all advisory locks are released. Note that the above describes the default query returned by :meth:`Connection.get_reset_query`. If one overloads the method by subclassing ``Connection``, then this method will do whatever the overloaded method returns, except open transactions are always terminated and any callbacks registered by :meth:`Connection.add_listener` or :meth:`Connection.add_log_listener` are removed. :param float timeout: A timeout for resetting the connection. If not specified, defaults to no timeout. N)rrrget_reset_queryr)rYr reset_querys rresetConnection.resetsi.>>'**++-  ..0Kll;/// +** 0 +***sfBA;BBA=/B%A?&B* B5B6B=B?BBB B BBcTSUlURR5 SUlg)NT)r*r&abortrs rrConnection._abort%s   rcbUR5 URb$URRR5 UR 5 UR R 5 URR 5 URR 5 UR5 gr) _call_termination_listenersr4_holder_release_on_close_mark_stmts_as_closedr/rr9r= _clean_tasksrs rrConnection._cleanup+s~ ((* ;; " KK   1 1 3 ""$  !!# !!# rcUR(aUURH*nUR5(aMUR5 M, URR5 ggr)r;donecancelr)rYfuts rrConnection._clean_tasks;sH   **xxzzJJL+    % % ' rcZUR5(a[R"S5eg)Nr{)rarr|rs rrkConnection._check_openCs& >>  ++,BC C rc@[S- qSRU[5$)Nrz__asyncpg_{}_{:x}__)_uidrb)rYprefixs rrConnection._get_unique_idGs  $++FD99rcURR5HnUR5 M URHnUR5 M URR 5 URR 5 gr)r,iter_statements mark_closedr-rrYrs rr Connection._mark_stmts_as_closedLsk$$446D    7((D    )   ""$rc$URS:XaUR(anURRURUR UR 45(d,UR5 URRU5 ggggNr) refsrr,hasrrrrr-rnrs r_maybe_gc_stmtConnection._maybe_gc_stmtVsx IIN $$((T..0H0HI      $ $T * rc# URn[5UlUH5nURRU[R 5IShvN M7 gN 7fr)r-rOr&close_statementr NO_TIMEOUT)rYto_closers rrConnection._cleanup_stmtsisN''"uD..00x7J7JK K K LsAAA Ac# [R"URURURUR R UR RS9IShvN URR[R "UR55 UR5(dUR#S5 ggNe![a0nUR5(dURU5 SnANSnAf[Ra N[[R4a0nUR5(dURU5 SnANSnAff=f!URR[R "UR55 UR5(dUR#S5 ff=f7f)N)rBr[r@ backend_pidbackend_secret)r_cancelr(r8r7r&rrConnectionResetErrorr set_exceptionrrrr;r current_task set_result)rYwaiterexs rrConnection._canceltsO (''ZZdjj NN66#~~<<> > >*    ' '$$TZZ0 2;;==!!$'!/ >$ );;==$$R(%%  7112 );;==$$R( )    ' '$$TZZ0 2;;==!!$'!smG A!C %C &C *A!G  C E$&D=E'E$E'E$4&EE'E$$E''A"G  G cURRURRUR U555 gr)r;rnr( create_taskr)rYrs r_cancel_current_command"Connection._cancel_current_commands.  6 6t||F7K LMrcnUR(dg[RRXS9nUR 5nURHfnUR (a,UR RURXC55 M@UR RURXC5 Mh g)N)r) r9rPostgresLogMessagenew_unwrapis_asyncr(rrw call_soon)rYfields last_queryrcon_refrws r_process_log_messageConnection._process_log_messages|"" //33F3M,,.%%B{{ &&ruuW'>? $$RUUG= &rchUR(dgUR5nURHfnUR(a,URR UR U55 M@URR UR U5 Mh URR5 gr)r:rrr(rrwrr)rYrrws rr&Connection._call_termination_listenerssv** ,,.--B{{ &&ruuW~6 $$RUUG4 . ##))+rc :X R;agUR5nURUHhnUR(a-URR UR XAX#55 MAURR UR XAX#5 Mj gr)r/rrr(rrwr)rYpidrqpayloadrrws r_process_notification Connection._process_notificationsk // ) ,,.//'*B{{ &&ruuW7'LM $$RUUG'K +rc@URcUnU$URnU$r)r4)rYrs rrConnection._unwraps( ;; GkkGrcURb UR$URn/nUR(aURS5 UR(aURS5 UR (a"UR (aURS5 UR(aURS5 SRU5nX lU$)a Return the query sent to server on connection release. The query returned by this method is used by :meth:`Connection.reset`, which is, in turn, used by :class:`~asyncpg.pool.Pool` before making the connection available to another acquirer. .. versionadded:: 0.30.0 z SELECT pg_advisory_unlock_all();z CLOSE ALL;z UNLISTEN *;z RESET ALL; ) r3r1advisory_locksrb sql_close_all notificationsplpgsql sql_resetr,)rYcapsr3s rrConnection.get_reset_querys    ($$ $         B C       -   $,,    . >>    -yy. (rc\URbUb[R"S5eXlg)Nz5internal asyncpg error: connection is already proxied)r4rr|)rYproxys r _set_proxyConnection._set_proxys0 ;; "u'8++GI I rc U(aO[U5n[R"SRXUUS:aSOSS95n[R "U5 gg)NzL{conn!r} is being released to the pool but has {c} active {type} listener{s}rsr)connr#rr)rrInterfaceWarningrbrcrd)rY listeners listener_typecountws r_check_listenersConnection._check_listenerssU  NE++%%+V]"QYcB&,&01A MM!  rcU=RS- slUR[[RR UR R555S5 URURS5 g)Nr notificationlog) r+r%r itertoolschain from_iterabler/valuesr9)rY stacklevels r _on_releaseConnection._on_releasese !#  ..t/E/E/GH I       (rc8URR5 gr)r,rrs rr&Connection._drop_local_statement_caches  rcURb1URRRnUR5 gUR 5 gr)r4r_pool_drop_statement_cacherrYpools r_drop_global_statement_cache'Connection._drop_global_statement_caches; ;; ";;&&,,D  & & (  , , .rcTURR5R5 gr)r&rPclear_type_cachers r_drop_local_type_cache!Connection._drop_local_type_cache s ##%668rcURb1URRRnUR5 gUR 5 gr)r4rr4_drop_type_cacher<r6s r_drop_global_type_cache"Connection._drop_global_type_caches; ;; ";;&&,,D  ! ! #  ' ' )rcL# UR5 UR5 g7f)a?Indicate that the database schema information must be reloaded. For performance reasons, asyncpg caches certain aspects of the database schema, such as the layout of composite types. Consequently, when the database schema changes, and asyncpg is not able to gracefully recover from an error caused by outdated schema assumptions, an :exc:`~asyncpg.exceptions.OutdatedSchemaCacheError` is raised. To prevent the exception, this method may be used to inform asyncpg that the database schema has changed. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def change_type(con): ... result = await con.fetch('SELECT id, info FROM tbl') ... # Change composite's attribute type "int"=>"text" ... await con.execute('ALTER TYPE custom DROP ATTRIBUTE y') ... await con.execute('ALTER TYPE custom ADD ATTRIBUTE y text') ... await con.reload_schema_state() ... for id_, info in result: ... new = (info['x'], str(info['y'])) ... await con.execute( ... 'UPDATE tbl SET info=$2 WHERE id=$1', id_, new) ... >>> async def run(): ... # Initial schema: ... # CREATE TYPE custom AS (x int, y int); ... # CREATE TABLE tbl(id int, info custom); ... con = await asyncpg.connect(user='postgres') ... async with con.transaction(): ... # Prevent concurrent changes in the table ... await con.execute('LOCK TABLE tbl') ... await change_type(con) ... >>> asyncio.run(run()) .. versionadded:: 0.14.0 N)r@r8rs rreload_schema_stateConnection.reload_schema_states T $$& ))+r')rrrc # UR URUUUUUUUS9IShvN upSSS5 U$N!,(df  W$=f7f)N)rrr)r5r) rYrrrrrrrrrs rrConnection._executeEs_ ) )"nn+)$7-IF* * ) s% A ;9; A ; A A c#X# URU5 Sv URU5 g7f)aContext manager that adds `callback` to the list of query loggers, and removes it upon exit. :param callable callback: A callable or a coroutine function receiving one argument: **record**, a LoggedQuery containing `query`, `args`, `timeout`, `elapsed`, `exception`, `conn_addr`, and `conn_params`. Example: .. code-block:: pycon >>> class QuerySaver: def __init__(self): self.queries = [] def __call__(self, record): self.queries.append(record.query) >>> with con.query_logger(QuerySaver()): >>> await con.execute("SELECT 1") >>> print(log.queries) ['SELECT 1'] .. versionadded:: 0.29.0 N)rrr}s r query_loggerConnection.query_logger\s&4 h'    *s(*c #># [R"5nSnSv [R"5U- n[UUUUUURUR S9nUR Hfn U R(a,URRU RU55 M@URRU RU5 Mh g![anUneSnAff=f![R"5U- n[UUUUUURUR S9nUR Hfn U R(a,URRU RU55 M@URRU RU5 Mh f=f7f)Nrrrelapsed exception conn_addr conn_params) time monotonic BaseException LoggedQueryr8r7r=rr(rrwr) rYrrrstartrMrrLrecordrws rrConnection._time_and_logzsB   8  nn&.G #** LLF));;JJ**255=9JJ((7 * I  nn&.G #** LLF));;JJ**255=9JJ((7 *s5FCB2F C$CC$$C''B3FFc d^^^^# UUUU4SjnTRRU5nTR(a<TRUTU5 TR UUUUUS9IShvN upSSS5 X4$TR UUUUUS9IShvN upX4$N1!,(df  W W 4$=fN7f)Nc @>TRRUTSTTUS9$)Nr)stater portal_namer return_extrar)r& bind_execute)rrrrrrYs r&Connection.__execute..s,)D)D& *E* rr)r& _get_timeoutr=r _do_execute) rYrrrrrrrexecutorrrs ` `` ` r __executeConnection.__executes ..--g6   ##E49%)%5%5!-(; &6&  : |"&!1!1)$7 "2"LF| :9 t|s<A B0B&B'B-!B0B. B0B B+$ B0c :^^^# UUU4SjnTRRU5nTR TRUTU5 TR XX5S9IShvN upxSSS5 SSS5 W$N!,(df  N=f!,(df  W$=f7f)Nc>>TRRUTSUTS9$)Nr)rYrrZrr)r&bind_execute_many)rrrrrYs rr])Connection._executemany..s))I)I# *J* rr)r&r_r5rr`) rYrrrrrrarrs ` ` ` rrConnection._executemanys ..--g6  ) )##E49"&"2"2W#3# :*  :9* )  sF0BB  A8A6A8$B , B6A88 B B  BB)rrc# UcURUSUUS9IShvN nOM[R"5nURUUUUS9IShvN n[R"5n X9U- -nU nUcU"US5IShvN n X4$U"Xs5IShvN n [R"5n X9W- -nX4$NNlN;N)![R"5n X9W- -nf=f![Ra UR 5IShvN e[R aT UR5 URR5(dU(deURXUSS9IShvN s$f=f7f)NrF)retry) rrPrQrOutdatedSchemaCacheErrorrCInvalidCachedStatementErrorr8r&rr`) rYrrarrjrrrbeforeafterrs rr`Connection._do_executes ?,,)$7 -D^^%F,,)$7 -D NN$E v~ %GF/ ;'d33^|[.#+D#::F NN,Ev~-GR|G4; NN,Ev~-G22 **, , , 55 ;.  - - /~~//11!--WE.;;;;7 ;sE7B6/E7 B8 "E7/C>B:?CE7 B>B<B>C3E78E7:C<B>>CC'E4D A$E4+E.,E41E73E44E7)r*r8r;r6r2r/r9r(r7r+r&r4r=r3r1r0r<r,r.r5r-r:r)r')r)FN)T)[rr r!r"__doc__ __slots__r_ClientConfiguration_ConnectionParametersr^rhrsrxr~rrrrrrrrPr rrtypingOptionalfloatrrUnionrarrrrrrrrlrr rr3r7rFrRrCr-r.rDrrrraryrfrrrrrrkrrrrrrrrr rrrr%r/rr8r<r@rCr contextlibcontextmanagerrHrrrr`r#rrrrr+s GI>*&;;>*'<<>*@! H, PC,G K O C G/$ -(,e$N42)- 22' 2 2r)- #?#? ' #?T05!d ||CtO, dL(T0 % V % V/3Bll3d?+ B  B2 "  " H34T2 &Z)- ) ' ) X'+d%)#'D%)td F@R'+4d(,4$(4'+ <@~%)dD#'d4&*d"&t+/D%) V?r-1d,0dFL +/T$$(tD!%4%)D:%N25j%-$*`+D:B+*-5,00+dB&*& +"&*0:  (D: %+& L(:N > , L :  (!/9*+,h!.++:88@!%X 8 N"NNrr) metaclass<di,i<)hostportuserpasswordpassfileservice servicefiledatabaserBrrHrNrcommand_timeoutssl direct_tlsconnection_classrserver_settingstarget_session_attrs krbsrvnamegsslibcF# [U[5(d%[R"SR U55eU[ R La [U5 U c[R"5n [R"U 5IShvN [R"S0SU _SU_SU_SU_SU_SU_S U_S U_S U_S U_S U_SU_SU_SU_SU_SU_SU _SU _SU _SU_SU_SU_6IShvN sSSS5IShvN $NsNN !,IShvN (df  g=f7f)a/A coroutine to establish a connection to a PostgreSQL server. The connection parameters may be specified either as a connection URI in *dsn*, or as specific keyword arguments, or both. If both *dsn* and keyword arguments are specified, the latter override the corresponding values parsed from the connection URI. The default values for the majority of arguments can be specified using `environment variables `_. Returns a new :class:`~asyncpg.connection.Connection` object. :param dsn: Connection arguments specified using as a single string in the `libpq connection URI format`_: ``postgres://user:password@host:port/database?option=value``. The following options are recognized by asyncpg: ``host``, ``port``, ``user``, ``database`` (or ``dbname``), ``password``, ``passfile``, ``sslmode``, ``sslcert``, ``sslkey``, ``sslrootcert``, and ``sslcrl``. Unlike libpq, asyncpg will treat unrecognized options as `server settings`_ to be used for the connection. .. note:: The URI must be *valid*, which means that all components must be properly quoted with :py:func:`urllib.parse.quote_plus`, and any literal IPv6 addresses must be enclosed in square brackets. For example: .. code-block:: text postgres://dbuser@[fe80::1ff:fe23:4567:890a%25eth0]/dbname :param host: Database host address as one of the following: - an IP address or a domain name; - an absolute path to the directory containing the database server Unix-domain socket (not supported on Windows); - a sequence of any of the above, in which case the addresses will be tried in order, and the first successful connection will be returned. If not specified, asyncpg will try the following, in order: - host address(es) parsed from the *dsn* argument, - the value of the ``PGHOST`` environment variable, - on Unix, common directories used for PostgreSQL Unix-domain sockets: ``"/run/postgresql"``, ``"/var/run/postgresl"``, ``"/var/pgsql_socket"``, ``"/private/tmp"``, and ``"/tmp"``, - ``"localhost"``. :param port: Port number to connect to at the server host (or Unix-domain socket file extension). If multiple host addresses were specified, this parameter may specify a sequence of port numbers of the same length as the host sequence, or it may specify a single port number to be used for all host addresses. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGPORT`` environment variable, or ``5432`` if neither is specified. :param user: The name of the database role used for authentication. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGUSER`` environment variable, or the operating system name of the user running the application. :param database: The name of the database to connect to. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGDATABASE`` environment variable, or the computed value of the *user* argument. :param password: Password to be used for authentication, if the server requires one. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGPASSWORD`` environment variable. Note that the use of the environment variable is discouraged as other users and applications may be able to read it without needing specific privileges. It is recommended to use *passfile* instead. Password may be either a string, or a callable that returns a string. If a callable is provided, it will be called each time a new connection is established. :param passfile: The name of the file used to store passwords (defaults to ``~/.pgpass``, or ``%APPDATA%\postgresql\pgpass.conf`` on Windows). :param service: The name of the postgres connection service stored in the postgres connection service file. :param servicefile: The location of the connnection service file used to store connection parameters. :param loop: An asyncio event loop instance. If ``None``, the default event loop will be used. :param float timeout: Connection timeout in seconds. :param int statement_cache_size: The size of prepared statement LRU cache. Pass ``0`` to disable the cache. :param int max_cached_statement_lifetime: The maximum time in seconds a prepared statement will stay in the cache. Pass ``0`` to allow statements be cached indefinitely. :param int max_cacheable_statement_size: The maximum size of a statement that can be cached (15KiB by default). Pass ``0`` to allow all statements to be cached regardless of their size. :param float command_timeout: The default timeout for operations on this connection (the default is ``None``: no timeout). :param ssl: Pass ``True`` or an `ssl.SSLContext `_ instance to require an SSL connection. If ``True``, a default SSL context returned by `ssl.create_default_context() `_ will be used. The value can also be one of the following strings: - ``'disable'`` - SSL is disabled (equivalent to ``False``) - ``'prefer'`` - try SSL first, fallback to non-SSL connection if SSL connection fails - ``'allow'`` - try without SSL first, then retry with SSL if the first attempt fails. - ``'require'`` - only try an SSL connection. Certificate verification errors are ignored - ``'verify-ca'`` - only try an SSL connection, and verify that the server certificate is issued by a trusted certificate authority (CA) - ``'verify-full'`` - only try an SSL connection, verify that the server certificate is issued by a trusted CA and that the requested server host name matches that in the certificate. The default is ``'prefer'``: try an SSL connection and fallback to non-SSL connection if that fails. .. note:: *ssl* is ignored for Unix domain socket communication. Example of programmatic SSL context configuration that is equivalent to ``sslmode=verify-full&sslcert=..&sslkey=..&sslrootcert=..``: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import ssl >>> async def main(): ... # Load CA bundle for server certificate verification, ... # equivalent to sslrootcert= in DSN. ... sslctx = ssl.create_default_context( ... ssl.Purpose.SERVER_AUTH, ... cafile="path/to/ca_bundle.pem") ... # If True, equivalent to sslmode=verify-full, if False: ... # sslmode=verify-ca. ... sslctx.check_hostname = True ... # Load client certificate and private key for client ... # authentication, equivalent to sslcert= and sslkey= in ... # DSN. ... sslctx.load_cert_chain( ... "path/to/client.cert", ... keyfile="path/to/client.key", ... ) ... con = await asyncpg.connect(user='postgres', ssl=sslctx) ... await con.close() >>> asyncio.run(main()) Example of programmatic SSL context configuration that is equivalent to ``sslmode=require`` (no server certificate or host verification): .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> import ssl >>> async def main(): ... sslctx = ssl.create_default_context( ... ssl.Purpose.SERVER_AUTH) ... sslctx.check_hostname = False ... sslctx.verify_mode = ssl.CERT_NONE ... con = await asyncpg.connect(user='postgres', ssl=sslctx) ... await con.close() >>> asyncio.run(main()) :param bool direct_tls: Pass ``True`` to skip PostgreSQL STARTTLS mode and perform a direct SSL connection. Must be used alongside ``ssl`` param. :param dict server_settings: An optional dict of server runtime parameters. Refer to PostgreSQL documentation for a `list of supported options `_. :param type connection_class: Class of the returned connection object. 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 this connection object. Must be a subclass of :class:`~asyncpg.Record`. :param SessionAttribute target_session_attrs: If specified, check that the host has the correct attribute. Can be one of: - ``"any"`` - the first successfully connected host - ``"primary"`` - the host must NOT be in hot standby mode - ``"standby"`` - the host must be in hot standby mode - ``"read-write"`` - the host must allow writes - ``"read-only"`` - the host most NOT allow writes - ``"prefer-standby"`` - first try to find a standby host, but if none of the listed hosts is a standby server, return any of them. If not specified, the value parsed from the *dsn* argument is used, or the value of the ``PGTARGETSESSIONATTRS`` environment variable, or ``"any"`` if neither is specified. :param str krbsrvname: Kerberos service name to use when authenticating with GSSAPI. This must match the server configuration. Defaults to 'postgres'. :param str gsslib: GSS library to use for GSSAPI/SSPI authentication. Can be 'gssapi' or 'sspi'. Defaults to 'sspi' on Windows and 'gssapi' otherwise. :return: A :class:`~asyncpg.connection.Connection` instance. Example: .. code-block:: pycon >>> import asyncpg >>> import asyncio >>> async def run(): ... con = await asyncpg.connect(user='postgres') ... types = await con.fetch('SELECT * FROM pg_type') ... print(types) ... >>> asyncio.run(run()) [. s=&< &>1#'==#8#8e#8#D I  & &y 1 OOI00 1 $-- 4>>1r)rr(rrrN)rr r!r"rqr^rrrrrrrrrrrrrrrr#rrrrGrG s_"I22" "+%) .: > .C .'2rrGcz\rSrSr%\R S\S'\\S'\S\R SSS4Sj5r Sr g) roi= ).Nrwrrc[R"U5(aSnO8[U5(aSnO%[R"SR U55eU"X5$)NTFz7expected a callable or an `async def` function,got {!r})inspectiscoroutinefunctionrwrr|rb)rrwrs rrp_Callback.from_callableB sT  & &r * *H b\\H++!6":  2  rrN) rr r!r"rtCallable__annotations__ra classmethodrpr#rrrroro= s? ""N !vy9 !k ! !rroc*\rSrSrSrSrSrSrSrg)rViQ  _acquiredcSUlgrrrs rr^_Atomic.__init__T rc`UR(a[R"S5eSUlg)Nz:cannot perform operation: another operation is in progressr)rrr|rs r __enter___Atomic.__enter__W s( >>++LN NrcSUlgrr)rYtrtbs r__exit___Atomic.__exit__] rrN) rr r!r"rqr^rrr#rrrrVrVQ sI rrVc\rSrSrSrSrg)ria rN)rr r!r"rqr#rrrrra sIrrrSrKz Log record of an executed query.ServerCapabilitiesrrrrrrUrzPostgreSQL server capabilities.c [US5(aSnSnSnSnSnSnSnO^[US5(aSnSnSnSnSnSnSnO>[US5(aSnSnSnSnSnSnSnOSnSnSnSnSnUS:nURS:n[UUUUUUUS9$) N padb_revisionFT crdb_version crate_version) r r)rvmajorr) rQconnection_settingsrrrrrrrUs rrSrSt s"O44   # $n 5 5   # $o 6 6   #   ',22b8 %##/  rc [R"5Rn[RR [R "U5SS9nA[RSnSnU[U5:aLX$SRU5(a1US- nU[U5:aX$SRU5(aM1X$X@-nUR5 SR[R"U55$!Af=f)zdReplacement for traceback.extract_stack() that only does the necessary work for asyncio debug mode. F) lookup_linesrrr)sys _getframef_back traceback StackSummaryextract walk_stackasyncpg__path__r startswithreverser, format_list)rframestackapg_pathis rrXrX s MMO " "E&&..   'e/= "H A c%j.UXa[33H== Q c%j.UXa[33H== AI E MMO 779((/ 00 s 2C??DcU[RLag[U[5(a[ U[R5(aeUR [RR Ld'UR [RR La[R"S5eg[R"SRU55e)Nz2record_class must not redefine __new__ or __init__zErecord_class is expected to be a subclass of asyncpg.Record, got {!r}) r rrrr__new__r^rr|rbrs rrr sx& <&& |X__ 5 5  (?(? ?$$HOO,D,DD++D E '' ''-vl';  rc<U"5nUbURU5 ggr)r)weak_refrrYs rrKrK s" :D  D!rr)r).rr rcollections.abcrxrIr*rrrrrPrrtrcrLrrrrrrr r r r r rrrrrrrG NamedTuplerorVr namedtuplerSrprrSrXrrKrrrrrs`  up? $dT"'*03/8"&!#-'"&'+!' D   J2J2Z!!!!(    $$ 9 !++45?.b1* *"  r