SYMBOL INDEX (1440 symbols across 53 files)

FILE: .github/release_log.py
  function main (line 19) | def main():

FILE: asyncpg/_asyncio_compat.py
  function wait_for (line 25) | async def wait_for(fut: compat.Awaitable[_T], timeout: float | None) -> _T:
  function _cancel_and_wait (line 75) | async def _cancel_and_wait(fut: asyncio.Future[_T]) -> None:
  function _release_waiter (line 92) | def _release_waiter(waiter: asyncio.Future[typing.Any], *args: object) -...

FILE: asyncpg/_testbase/__init__.py
  function silence_asyncio_long_exec_warning (line 31) | def silence_asyncio_long_exec_warning():
  function with_timeout (line 44) | def with_timeout(timeout):
  class TestCaseMeta (line 52) | class TestCaseMeta(type(unittest.TestCase)):
    method _iter_methods (line 56) | def _iter_methods(bases, ns):
    method __new__ (line 77) | def __new__(mcls, name, bases, ns):
  class TestCase (line 98) | class TestCase(unittest.TestCase, metaclass=TestCaseMeta):
    method setUpClass (line 101) | def setUpClass(cls):
    method tearDownClass (line 111) | def tearDownClass(cls):
    method setUp (line 115) | def setUp(self):
    method tearDown (line 119) | def tearDown(self):
    method assertRunUnder (line 143) | def assertRunUnder(self, delta):
    method assertLoopErrorHandlerCalled (line 156) | def assertLoopErrorHandlerCalled(self, msg_re: str):
    method loop_exception_handler (line 179) | def loop_exception_handler(self, loop, context):
    method _format_loop_exception (line 183) | def _format_loop_exception(self, context, n):
  function _init_cluster (line 221) | def _init_cluster(ClusterCls, cluster_kwargs, initdb_options=None):
  function _get_initdb_options (line 229) | def _get_initdb_options(initdb_options=None):
  function _init_default_cluster (line 242) | def _init_default_cluster(initdb_options=None):
  function _shutdown_cluster (line 262) | def _shutdown_cluster(cluster):
  function create_pool (line 269) | def create_pool(dsn=None, *,
  class ClusterTestCase (line 298) | class ClusterTestCase(TestCase):
    method get_server_settings (line 300) | def get_server_settings(cls):
    method new_cluster (line 313) | def new_cluster(cls, ClusterCls, *, cluster_kwargs={}, initdb_options=...
    method start_cluster (line 320) | def start_cluster(cls, cluster, *, server_settings={}):
    method setup_cluster (line 324) | def setup_cluster(cls):
    method setUpClass (line 332) | def setUpClass(cls):
    method tearDownClass (line 338) | def tearDownClass(cls):
    method get_connection_spec (line 347) | def get_connection_spec(cls, kwargs={}):
    method connect (line 360) | def connect(cls, **kwargs):
    method setUp (line 364) | def setUp(self):
    method tearDown (line 368) | def tearDown(self):
    method create_pool (line 374) | def create_pool(self, pool_class=pg_pool.Pool,
  class ProxiedClusterTestCase (line 383) | class ProxiedClusterTestCase(ClusterTestCase):
    method get_server_settings (line 385) | def get_server_settings(cls):
    method get_proxy_settings (line 391) | def get_proxy_settings(cls):
    method setUpClass (line 395) | def setUpClass(cls):
    method tearDownClass (line 410) | def tearDownClass(cls):
    method get_connection_spec (line 415) | def get_connection_spec(cls, kwargs):
    method tearDown (line 421) | def tearDown(self):
  function with_connection_options (line 426) | def with_connection_options(**options):
  class ConnectedTestCase (line 437) | class ConnectedTestCase(ClusterTestCase):
    method setUp (line 439) | def setUp(self):
    method tearDown (line 448) | def tearDown(self):
  class HotStandbyTestCase (line 456) | class HotStandbyTestCase(ClusterTestCase):
    method setup_cluster (line 459) | def setup_cluster(cls):
    method get_cluster_connection_spec (line 504) | def get_cluster_connection_spec(cls, cluster, kwargs={}):
    method get_connection_spec (line 517) | def get_connection_spec(cls, kwargs={}):
    method connect_primary (line 533) | def connect_primary(cls, **kwargs):
    method connect_standby (line 538) | def connect_standby(cls, **kwargs):

FILE: asyncpg/_testbase/fuzzer.py
  class StopServer (line 16) | class StopServer(Exception):
  class TCPFuzzingProxy (line 20) | class TCPFuzzingProxy:
    method __init__ (line 21) | def __init__(self, *, listening_addr: str='127.0.0.1',
    method _wait (line 38) | async def _wait(self, work):
    method start (line 57) | def start(self):
    method stop (line 65) | def stop(self):
    method _stop (line 69) | def _stop(self):
    method _start_thread (line 72) | def _start_thread(self, started_event):
    method _main (line 94) | async def _main(self, started_event):
    method listen (line 108) | async def listen(self):
    method trigger_connectivity_loss (line 126) | def trigger_connectivity_loss(self):
    method _trigger_connectivity_loss (line 129) | def _trigger_connectivity_loss(self):
    method restore_connectivity (line 133) | def restore_connectivity(self):
    method _restore_connectivity (line 136) | def _restore_connectivity(self):
    method reset (line 140) | def reset(self):
    method _close_connection (line 143) | def _close_connection(self, connection):
    method close_all_connections (line 148) | def close_all_connections(self):
  class Connection (line 153) | class Connection:
    method __init__ (line 154) | def __init__(self, client_sock, backend_sock, proxy):
    method close (line 165) | def close(self):
    method handle (line 181) | async def handle(self):
    method _read (line 212) | async def _read(self, sock, n):
    method _write (line 234) | async def _write(self, sock, data):
    method proxy_to_backend (line 256) | async def proxy_to_backend(self):
    method proxy_from_backend (line 282) | async def proxy_from_backend(self):

FILE: asyncpg/cluster.py
  function platform_exe (line 30) | def platform_exe(name):
  function platform_exe (line 35) | def platform_exe(name):
  function find_available_port (line 39) | def find_available_port():
  function _world_readable_mkdtemp (line 50) | def _world_readable_mkdtemp(suffix=None, prefix=None, dir=None):
  function _mkdtemp (line 63) | def _mkdtemp(suffix=None, prefix=None, dir=None):
  class ClusterError (line 73) | class ClusterError(Exception):
  class Cluster (line 77) | class Cluster:
    method __init__ (line 78) | def __init__(self, data_dir, *, pg_config_path=None):
    method get_pg_version (line 91) | def get_pg_version(self):
    method is_managed (line 94) | def is_managed(self):
    method get_data_dir (line 97) | def get_data_dir(self):
    method get_status (line 100) | def get_status(self):
    method connect (line 127) | async def connect(self, loop=None, **kwargs):
    method init (line 132) | def init(self, **settings):
    method start (line 167) | def start(self, wait=60, *, server_settings={}, **opts):
    method reload (line 262) | def reload(self):
    method stop (line 282) | def stop(self, wait=60):
    method destroy (line 302) | def destroy(self):
    method _get_connection_spec (line 309) | def _get_connection_spec(self):
    method get_connection_spec (line 321) | def get_connection_spec(self):
    method override_connection_spec (line 328) | def override_connection_spec(self, **kwargs):
    method reset_wal (line 331) | def reset_wal(self, *, oid=None, xid=None):
    method reset_hba (line 367) | def reset_hba(self):
    method add_hba_entry (line 383) | def add_hba_entry(self, *, type='host', database, user, address=None,
    method trust_local_connections (line 418) | def trust_local_connections(self):
    method trust_local_replication_by (line 434) | def trust_local_replication_by(self, user):
    method _init_env (line 448) | def _init_env(self):
    method _connection_addr_from_pidfile (line 462) | def _connection_addr_from_pidfile(self):
    method _test_connection (line 508) | def _test_connection(self, timeout=60):
    method _run_pg_config (line 545) | def _run_pg_config(self, pg_config_path):
    method _find_pg_config (line 563) | def _find_pg_config(self, pg_config_path):
    method _find_pg_binary (line 591) | def _find_pg_binary(self, binary):
    method _get_pg_version (line 601) | def _get_pg_version(self):
  class TempCluster (line 623) | class TempCluster(Cluster):
    method __init__ (line 624) | def __init__(self, *,
  class HotStandbyCluster (line 633) | class HotStandbyCluster(TempCluster):
    method __init__ (line 634) | def __init__(self, *,
    method _init_env (line 646) | def _init_env(self):
    method init (line 650) | def init(self, **settings):
    method start (line 685) | def start(self, wait=60, *, server_settings={}, **opts):
  class RunningCluster (line 699) | class RunningCluster(Cluster):
    method __init__ (line 700) | def __init__(self, **kwargs):
    method is_managed (line 703) | def is_managed(self):
    method get_connection_spec (line 706) | def get_connection_spec(self):
    method get_status (line 709) | def get_status(self):
    method init (line 712) | def init(self, **settings):
    method start (line 715) | def start(self, wait=60, **settings):
    method stop (line 718) | def stop(self, wait=60):
    method destroy (line 721) | def destroy(self):
    method reset_hba (line 724) | def reset_hba(self):
    method add_hba_entry (line 727) | def add_hba_entry(self, *, type='host', database, user, address=None,

FILE: asyncpg/compat.py
  function get_pg_home_directory (line 26) | def get_pg_home_directory() -> pathlib.Path | None:
  function get_pg_home_directory (line 38) | def get_pg_home_directory() -> pathlib.Path | None:
  function wait_closed (line 45) | async def wait_closed(stream: asyncio.StreamWriter) -> None:
  function markcoroutinefunction (line 57) | def markcoroutinefunction(c):  # type: ignore
  class StrEnum (line 84) | class StrEnum(str, enum.Enum):

FILE: asyncpg/connect_utils.py
  class SSLMode (line 36) | class SSLMode(enum.IntEnum):
    method parse (line 45) | def parse(cls, sslmode):
  class SSLNegotiation (line 51) | class SSLNegotiation(compat.StrEnum):
  function _read_password_file (line 94) | def _read_password_file(passfile: pathlib.Path) \
  function _read_password_from_pgpass (line 137) | def _read_password_from_pgpass(
  function _validate_port_spec (line 174) | def _validate_port_spec(hosts, port):
  function _parse_hostlist (line 190) | def _parse_hostlist(hostlist, port, *, unquote=False):
  function _parse_tls_version (line 254) | def _parse_tls_version(tls_version):
  function _dot_postgresql_path (line 267) | def _dot_postgresql_path(filename) -> typing.Optional[pathlib.Path]:
  function _parse_connect_dsn_and_args (line 276) | def _parse_connect_dsn_and_args(*, dsn, host, port, user,
  function _parse_connect_arguments (line 862) | def _parse_connect_arguments(*, dsn, host, port, user, password, passfile,
  class TLSUpgradeProto (line 911) | class TLSUpgradeProto(asyncio.Protocol):
    method __init__ (line 912) | def __init__(
    method data_received (line 926) | def data_received(self, data: bytes) -> None:
    method connection_lost (line 944) | def connection_lost(self, exc: typing.Optional[Exception]) -> None:
  function _create_ssl_connection (line 956) | async def _create_ssl_connection(
  function _connect_addr (line 1022) | async def _connect_addr(
  class _RetryConnectSignal (line 1062) | class _RetryConnectSignal(Exception):
  function __connect_addr (line 1066) | async def __connect_addr(
  class SessionAttribute (line 1141) | class SessionAttribute(str, enum.Enum):
  function _accept_in_hot_standby (line 1150) | def _accept_in_hot_standby(should_be_in_hot_standby: bool):
  function _accept_read_only (line 1171) | def _accept_read_only(should_be_read_only: bool):
  function _accept_any (line 1186) | async def _accept_any(_):
  function _can_use_connection (line 1200) | async def _can_use_connection(connection, attr: SessionAttribute):
  function _connect (line 1205) | async def _connect(*, loop, connection_class, record_class, **kwargs):
  function _cancel (line 1255) | async def _cancel(*, loop, addr, params: _ConnectionParameters,
  function _get_socket (line 1293) | def _get_socket(transport):
  function _set_nodelay (line 1302) | def _set_nodelay(sock):
  function _create_future (line 1307) | def _create_future(loop):

FILE: asyncpg/connection.py
  class ConnectionMeta (line 36) | class ConnectionMeta(type):
    method __instancecheck__ (line 38) | def __instancecheck__(cls, instance):
  class Connection (line 43) | class Connection(metaclass=ConnectionMeta):
    method __init__ (line 59) | def __init__(self, protocol, transport, loop,
    method __del__ (line 123) | def __del__(self):
    method add_listener (line 139) | async def add_listener(self, channel, callback):
    method remove_listener (line 161) | async def remove_listener(self, channel, callback):
    method add_log_listener (line 175) | def add_log_listener(self, callback):
    method remove_log_listener (line 197) | def remove_log_listener(self, callback):
    method add_termination_listener (line 204) | def add_termination_listener(self, callback):
    method remove_termination_listener (line 218) | def remove_termination_listener(self, callback):
    method add_query_logger (line 229) | def add_query_logger(self, callback):
    method remove_query_logger (line 241) | def remove_query_logger(self, callback):
    method get_server_pid (line 252) | def get_server_pid(self):
    method get_server_version (line 256) | def get_server_version(self):
    method get_settings (line 272) | def get_settings(self):
    method transaction (line 279) | def transaction(self, *, isolation=None, readonly=False,
    method is_in_transaction (line 305) | def is_in_transaction(self):
    method execute (line 314) | async def execute(
    method executemany (line 366) | async def executemany(
    method _get_statement (line 403) | async def _get_statement(
    method _introspect_types (line 505) | async def _introspect_types(self, typeoids, timeout):
    method _introspect_type (line 547) | async def _introspect_type(self, typename, schema):
    method cursor (line 567) | def cursor(
    method prepare (line 606) | async def prepare(
    method _prepare (line 645) | async def _prepare(
    method fetch (line 666) | async def fetch(
    method fetchval (line 702) | async def fetchval(self, query, *args, column=0, timeout=None):
    method fetchrow (line 723) | async def fetchrow(
    method fetchmany (line 763) | async def fetchmany(
    method copy_from_table (line 806) | async def copy_from_table(self, table_name, *, output,
    method copy_from_query (line 878) | async def copy_from_query(self, query, *args, output,
    method copy_to_table (line 940) | async def copy_to_table(self, table_name, *, source,
    method copy_records_to_table (line 1028) | async def copy_records_to_table(self, table_name, *, records,
    method _format_copy_where (line 1130) | def _format_copy_where(self, where):
    method _format_copy_opts (line 1142) | def _format_copy_opts(self, *, format=None, oids=None, freeze=None,
    method _copy_out (line 1171) | async def _copy_out(self, copy_stmt, output, timeout):
    method _copy_in (line 1210) | async def _copy_in(self, copy_stmt, source, timeout):
    method set_type_codec (line 1262) | async def set_type_codec(self, typename, *,
    method reset_type_codec (line 1424) | async def reset_type_codec(self, typename, *, schema='public'):
    method set_builtin_type_codec (line 1444) | async def set_builtin_type_codec(self, typename, *,
    method is_closed (line 1494) | def is_closed(self):
    method close (line 1502) | async def close(self, *, timeout=None):
    method terminate (line 1521) | def terminate(self):
    method _reset (line 1527) | async def _reset(self):
    method reset (line 1544) | async def reset(self, *, timeout=None):
    method _abort (line 1573) | def _abort(self):
    method _cleanup (line 1579) | def _cleanup(self):
    method _clean_tasks (line 1595) | def _clean_tasks(self):
    method _check_open (line 1603) | def _check_open(self):
    method _get_unique_id (line 1607) | def _get_unique_id(self, prefix):
    method _mark_stmts_as_closed (line 1612) | def _mark_stmts_as_closed(self):
    method _maybe_gc_stmt (line 1622) | def _maybe_gc_stmt(self, stmt):
    method _cleanup_stmts (line 1641) | async def _cleanup_stmts(self):
    method _cancel (line 1652) | async def _cancel(self, waiter):
    method _cancel_current_command (line 1681) | def _cancel_current_command(self, waiter):
    method _process_log_message (line 1684) | def _process_log_message(self, fields, last_query):
    method _call_termination_listeners (line 1697) | def _call_termination_listeners(self):
    method _process_notification (line 1710) | def _process_notification(self, pid, channel, payload):
    method _unwrap (line 1721) | def _unwrap(self):
    method get_reset_query (line 1732) | def get_reset_query(self):
    method _set_proxy (line 1761) | def _set_proxy(self, proxy):
    method _check_listeners (line 1769) | def _check_listeners(self, listeners, listener_type):
    method _on_release (line 1781) | def _on_release(self, stacklevel=1):
    method _drop_local_statement_cache (line 1792) | def _drop_local_statement_cache(self):
    method _drop_global_statement_cache (line 1795) | def _drop_global_statement_cache(self):
    method _drop_local_type_cache (line 1804) | def _drop_local_type_cache(self):
    method _drop_global_type_cache (line 1807) | def _drop_global_type_cache(self):
    method reload_schema_state (line 1816) | async def reload_schema_state(self):
    method _execute (line 1861) | async def _execute(
    method query_logger (line 1885) | def query_logger(self, callback):
    method _time_and_log (line 1915) | def _time_and_log(self, query, args, timeout):
    method __execute (line 1940) | async def __execute(
    method _executemany (line 1979) | async def _executemany(
    method _do_execute (line 2002) | async def _do_execute(
  function connect (line 2083) | async def connect(dsn=None, *,
  class _StatementCacheEntry (line 2469) | class _StatementCacheEntry:
    method __init__ (line 2473) | def __init__(self, cache, query, statement):
  class _StatementCache (line 2480) | class _StatementCache:
    method __init__ (line 2485) | def __init__(self, *, loop, max_size, on_remove, max_lifetime):
    method __len__ (line 2510) | def __len__(self):
    method get_max_size (line 2513) | def get_max_size(self):
    method set_max_size (line 2516) | def set_max_size(self, new_size):
    method get_max_lifetime (line 2521) | def get_max_lifetime(self):
    method set_max_lifetime (line 2524) | def set_max_lifetime(self, new_lifetime):
    method get (line 2532) | def get(self, query, *, promote=True):
    method has (line 2555) | def has(self, query):
    method put (line 2558) | def put(self, query, statement):
    method iter_statements (line 2569) | def iter_statements(self):
    method clear (line 2572) | def clear(self):
    method _set_entry_timeout (line 2585) | def _set_entry_timeout(self, entry):
    method _new_entry (line 2594) | def _new_entry(self, query, statement):
    method _on_entry_expired (line 2599) | def _on_entry_expired(self, entry):
    method _clear_entry_callback (line 2606) | def _clear_entry_callback(self, entry):
    method _maybe_cleanup (line 2610) | def _maybe_cleanup(self):
  class _Callback (line 2621) | class _Callback(typing.NamedTuple):
    method from_callable (line 2627) | def from_callable(cls, cb: typing.Callable[..., None]) -> '_Callback':
  class _Atomic (line 2641) | class _Atomic:
    method __init__ (line 2644) | def __init__(self):
    method __enter__ (line 2647) | def __enter__(self):
    method __exit__ (line 2653) | def __exit__(self, t, e, tb):
  class _ConnectionProxy (line 2657) | class _ConnectionProxy:
  function _detect_server_capabilities (line 2676) | def _detect_server_capabilities(server_version, connection_settings):
  function _extract_stack (line 2725) | def _extract_stack(limit=10):
  function _check_record_class (line 2746) | def _check_record_class(record_class):
  function _weak_maybe_gc_stmt (line 2767) | def _weak_maybe_gc_stmt(weak_ref, stmt):

FILE: asyncpg/connresource.py
  function guarded (line 14) | def guarded(meth):
  class ConnectionResource (line 25) | class ConnectionResource:
    method __init__ (line 28) | def __init__(self, connection):
    method _check_conn_validity (line 32) | def _check_conn_validity(self, meth_name):

FILE: asyncpg/cursor.py
  class CursorFactory (line 14) | class CursorFactory(connresource.ConnectionResource):
    method __init__ (line 30) | def __init__(
    method __aiter__ (line 51) | def __aiter__(self):
    method __await__ (line 64) | def __await__(self):
    method __del__ (line 77) | def __del__(self):
  class BaseCursor (line 83) | class BaseCursor(connresource.ConnectionResource):
    method __init__ (line 94) | def __init__(self, connection, query, state, args, record_class):
    method _check_ready (line 105) | def _check_ready(self):
    method _bind_exec (line 118) | async def _bind_exec(self, n, timeout):
    method _bind (line 133) | async def _bind(self, timeout):
    method _exec (line 149) | async def _exec(self, n, timeout):
    method _close_portal (line 161) | async def _close_portal(self, timeout):
    method __repr__ (line 172) | def __repr__(self):
    method __del__ (line 188) | def __del__(self):
  class CursorIterator (line 194) | class CursorIterator(BaseCursor):
    method __init__ (line 198) | def __init__(
    method __aiter__ (line 219) | def __aiter__(self):
    method __anext__ (line 223) | async def __anext__(self):
  class Cursor (line 250) | class Cursor(BaseCursor):
    method _init (line 255) | async def _init(self, timeout):
    method fetch (line 269) | async def fetch(self, n, *, timeout=None):
    method fetchrow (line 287) | async def fetchrow(self, *, timeout=None):
    method forward (line 304) | async def forward(self, n, *, timeout=None) -> int:

FILE: asyncpg/exceptions/__init__.py
  class PostgresWarning (line 8) | class PostgresWarning(_base.PostgresLogMessage, Warning):
  class DynamicResultSetsReturned (line 12) | class DynamicResultSetsReturned(PostgresWarning):
  class ImplicitZeroBitPadding (line 16) | class ImplicitZeroBitPadding(PostgresWarning):
  class NullValueEliminatedInSetFunction (line 20) | class NullValueEliminatedInSetFunction(PostgresWarning):
  class PrivilegeNotGranted (line 24) | class PrivilegeNotGranted(PostgresWarning):
  class PrivilegeNotRevoked (line 28) | class PrivilegeNotRevoked(PostgresWarning):
  class StringDataRightTruncation (line 32) | class StringDataRightTruncation(PostgresWarning):
  class DeprecatedFeature (line 36) | class DeprecatedFeature(PostgresWarning):
  class NoData (line 40) | class NoData(PostgresWarning):
  class NoAdditionalDynamicResultSetsReturned (line 44) | class NoAdditionalDynamicResultSetsReturned(NoData):
  class SQLStatementNotYetCompleteError (line 48) | class SQLStatementNotYetCompleteError(_base.PostgresError):
  class PostgresConnectionError (line 52) | class PostgresConnectionError(_base.PostgresError):
  class ConnectionDoesNotExistError (line 56) | class ConnectionDoesNotExistError(PostgresConnectionError):
  class ConnectionFailureError (line 60) | class ConnectionFailureError(PostgresConnectionError):
  class ClientCannotConnectError (line 64) | class ClientCannotConnectError(PostgresConnectionError):
  class ConnectionRejectionError (line 68) | class ConnectionRejectionError(PostgresConnectionError):
  class TransactionResolutionUnknownError (line 72) | class TransactionResolutionUnknownError(PostgresConnectionError):
  class ProtocolViolationError (line 76) | class ProtocolViolationError(PostgresConnectionError):
  class TriggeredActionError (line 80) | class TriggeredActionError(_base.PostgresError):
  class FeatureNotSupportedError (line 84) | class FeatureNotSupportedError(_base.PostgresError):
  class InvalidCachedStatementError (line 88) | class InvalidCachedStatementError(FeatureNotSupportedError):
  class InvalidTransactionInitiationError (line 92) | class InvalidTransactionInitiationError(_base.PostgresError):
  class LocatorError (line 96) | class LocatorError(_base.PostgresError):
  class InvalidLocatorSpecificationError (line 100) | class InvalidLocatorSpecificationError(LocatorError):
  class InvalidGrantorError (line 104) | class InvalidGrantorError(_base.PostgresError):
  class InvalidGrantOperationError (line 108) | class InvalidGrantOperationError(InvalidGrantorError):
  class InvalidRoleSpecificationError (line 112) | class InvalidRoleSpecificationError(_base.PostgresError):
  class DiagnosticsError (line 116) | class DiagnosticsError(_base.PostgresError):
  class StackedDiagnosticsAccessedWithoutActiveHandlerError (line 120) | class StackedDiagnosticsAccessedWithoutActiveHandlerError(DiagnosticsErr...
  class InvalidArgumentForXqueryError (line 124) | class InvalidArgumentForXqueryError(_base.PostgresError):
  class CaseNotFoundError (line 128) | class CaseNotFoundError(_base.PostgresError):
  class CardinalityViolationError (line 132) | class CardinalityViolationError(_base.PostgresError):
  class DataError (line 136) | class DataError(_base.PostgresError):
  class ArraySubscriptError (line 140) | class ArraySubscriptError(DataError):
  class CharacterNotInRepertoireError (line 144) | class CharacterNotInRepertoireError(DataError):
  class DatetimeFieldOverflowError (line 148) | class DatetimeFieldOverflowError(DataError):
  class DivisionByZeroError (line 152) | class DivisionByZeroError(DataError):
  class ErrorInAssignmentError (line 156) | class ErrorInAssignmentError(DataError):
  class EscapeCharacterConflictError (line 160) | class EscapeCharacterConflictError(DataError):
  class IndicatorOverflowError (line 164) | class IndicatorOverflowError(DataError):
  class IntervalFieldOverflowError (line 168) | class IntervalFieldOverflowError(DataError):
  class InvalidArgumentForLogarithmError (line 172) | class InvalidArgumentForLogarithmError(DataError):
  class InvalidArgumentForNtileFunctionError (line 176) | class InvalidArgumentForNtileFunctionError(DataError):
  class InvalidArgumentForNthValueFunctionError (line 180) | class InvalidArgumentForNthValueFunctionError(DataError):
  class InvalidArgumentForPowerFunctionError (line 184) | class InvalidArgumentForPowerFunctionError(DataError):
  class InvalidArgumentForWidthBucketFunctionError (line 188) | class InvalidArgumentForWidthBucketFunctionError(DataError):
  class InvalidCharacterValueForCastError (line 192) | class InvalidCharacterValueForCastError(DataError):
  class InvalidDatetimeFormatError (line 196) | class InvalidDatetimeFormatError(DataError):
  class InvalidEscapeCharacterError (line 200) | class InvalidEscapeCharacterError(DataError):
  class InvalidEscapeOctetError (line 204) | class InvalidEscapeOctetError(DataError):
  class InvalidEscapeSequenceError (line 208) | class InvalidEscapeSequenceError(DataError):
  class NonstandardUseOfEscapeCharacterError (line 212) | class NonstandardUseOfEscapeCharacterError(DataError):
  class InvalidIndicatorParameterValueError (line 216) | class InvalidIndicatorParameterValueError(DataError):
  class InvalidParameterValueError (line 220) | class InvalidParameterValueError(DataError):
  class InvalidPrecedingOrFollowingSizeError (line 224) | class InvalidPrecedingOrFollowingSizeError(DataError):
  class InvalidRegularExpressionError (line 228) | class InvalidRegularExpressionError(DataError):
  class InvalidRowCountInLimitClauseError (line 232) | class InvalidRowCountInLimitClauseError(DataError):
  class InvalidRowCountInResultOffsetClauseError (line 236) | class InvalidRowCountInResultOffsetClauseError(DataError):
  class InvalidTablesampleArgumentError (line 240) | class InvalidTablesampleArgumentError(DataError):
  class InvalidTablesampleRepeatError (line 244) | class InvalidTablesampleRepeatError(DataError):
  class InvalidTimeZoneDisplacementValueError (line 248) | class InvalidTimeZoneDisplacementValueError(DataError):
  class InvalidUseOfEscapeCharacterError (line 252) | class InvalidUseOfEscapeCharacterError(DataError):
  class MostSpecificTypeMismatchError (line 256) | class MostSpecificTypeMismatchError(DataError):
  class NullValueNotAllowedError (line 260) | class NullValueNotAllowedError(DataError):
  class NullValueNoIndicatorParameterError (line 264) | class NullValueNoIndicatorParameterError(DataError):
  class NumericValueOutOfRangeError (line 268) | class NumericValueOutOfRangeError(DataError):
  class SequenceGeneratorLimitExceededError (line 272) | class SequenceGeneratorLimitExceededError(DataError):
  class StringDataLengthMismatchError (line 276) | class StringDataLengthMismatchError(DataError):
  class StringDataRightTruncationError (line 280) | class StringDataRightTruncationError(DataError):
  class SubstringError (line 284) | class SubstringError(DataError):
  class TrimError (line 288) | class TrimError(DataError):
  class UnterminatedCStringError (line 292) | class UnterminatedCStringError(DataError):
  class ZeroLengthCharacterStringError (line 296) | class ZeroLengthCharacterStringError(DataError):
  class PostgresFloatingPointError (line 300) | class PostgresFloatingPointError(DataError):
  class InvalidTextRepresentationError (line 304) | class InvalidTextRepresentationError(DataError):
  class InvalidBinaryRepresentationError (line 308) | class InvalidBinaryRepresentationError(DataError):
  class BadCopyFileFormatError (line 312) | class BadCopyFileFormatError(DataError):
  class UntranslatableCharacterError (line 316) | class UntranslatableCharacterError(DataError):
  class NotAnXmlDocumentError (line 320) | class NotAnXmlDocumentError(DataError):
  class InvalidXmlDocumentError (line 324) | class InvalidXmlDocumentError(DataError):
  class InvalidXmlContentError (line 328) | class InvalidXmlContentError(DataError):
  class InvalidXmlCommentError (line 332) | class InvalidXmlCommentError(DataError):
  class InvalidXmlProcessingInstructionError (line 336) | class InvalidXmlProcessingInstructionError(DataError):
  class DuplicateJsonObjectKeyValueError (line 340) | class DuplicateJsonObjectKeyValueError(DataError):
  class InvalidArgumentForSQLJsonDatetimeFunctionError (line 344) | class InvalidArgumentForSQLJsonDatetimeFunctionError(DataError):
  class InvalidJsonTextError (line 348) | class InvalidJsonTextError(DataError):
  class InvalidSQLJsonSubscriptError (line 352) | class InvalidSQLJsonSubscriptError(DataError):
  class MoreThanOneSQLJsonItemError (line 356) | class MoreThanOneSQLJsonItemError(DataError):
  class NoSQLJsonItemError (line 360) | class NoSQLJsonItemError(DataError):
  class NonNumericSQLJsonItemError (line 364) | class NonNumericSQLJsonItemError(DataError):
  class NonUniqueKeysInAJsonObjectError (line 368) | class NonUniqueKeysInAJsonObjectError(DataError):
  class SingletonSQLJsonItemRequiredError (line 372) | class SingletonSQLJsonItemRequiredError(DataError):
  class SQLJsonArrayNotFoundError (line 376) | class SQLJsonArrayNotFoundError(DataError):
  class SQLJsonMemberNotFoundError (line 380) | class SQLJsonMemberNotFoundError(DataError):
  class SQLJsonNumberNotFoundError (line 384) | class SQLJsonNumberNotFoundError(DataError):
  class SQLJsonObjectNotFoundError (line 388) | class SQLJsonObjectNotFoundError(DataError):
  class TooManyJsonArrayElementsError (line 392) | class TooManyJsonArrayElementsError(DataError):
  class TooManyJsonObjectMembersError (line 396) | class TooManyJsonObjectMembersError(DataError):
  class SQLJsonScalarRequiredError (line 400) | class SQLJsonScalarRequiredError(DataError):
  class SQLJsonItemCannotBeCastToTargetTypeError (line 404) | class SQLJsonItemCannotBeCastToTargetTypeError(DataError):
  class IntegrityConstraintViolationError (line 408) | class IntegrityConstraintViolationError(_base.PostgresError):
  class RestrictViolationError (line 412) | class RestrictViolationError(IntegrityConstraintViolationError):
  class NotNullViolationError (line 416) | class NotNullViolationError(IntegrityConstraintViolationError):
  class ForeignKeyViolationError (line 420) | class ForeignKeyViolationError(IntegrityConstraintViolationError):
  class UniqueViolationError (line 424) | class UniqueViolationError(IntegrityConstraintViolationError):
  class CheckViolationError (line 428) | class CheckViolationError(IntegrityConstraintViolationError):
  class ExclusionViolationError (line 432) | class ExclusionViolationError(IntegrityConstraintViolationError):
  class InvalidCursorStateError (line 436) | class InvalidCursorStateError(_base.PostgresError):
  class InvalidTransactionStateError (line 440) | class InvalidTransactionStateError(_base.PostgresError):
  class ActiveSQLTransactionError (line 444) | class ActiveSQLTransactionError(InvalidTransactionStateError):
  class BranchTransactionAlreadyActiveError (line 448) | class BranchTransactionAlreadyActiveError(InvalidTransactionStateError):
  class HeldCursorRequiresSameIsolationLevelError (line 452) | class HeldCursorRequiresSameIsolationLevelError(InvalidTransactionStateE...
  class InappropriateAccessModeForBranchTransactionError (line 456) | class InappropriateAccessModeForBranchTransactionError(
  class InappropriateIsolationLevelForBranchTransactionError (line 461) | class InappropriateIsolationLevelForBranchTransactionError(
  class NoActiveSQLTransactionForBranchTransactionError (line 466) | class NoActiveSQLTransactionForBranchTransactionError(
  class ReadOnlySQLTransactionError (line 471) | class ReadOnlySQLTransactionError(InvalidTransactionStateError):
  class SchemaAndDataStatementMixingNotSupportedError (line 475) | class SchemaAndDataStatementMixingNotSupportedError(
  class NoActiveSQLTransactionError (line 480) | class NoActiveSQLTransactionError(InvalidTransactionStateError):
  class InFailedSQLTransactionError (line 484) | class InFailedSQLTransactionError(InvalidTransactionStateError):
  class IdleInTransactionSessionTimeoutError (line 488) | class IdleInTransactionSessionTimeoutError(InvalidTransactionStateError):
  class TransactionTimeoutError (line 492) | class TransactionTimeoutError(InvalidTransactionStateError):
  class InvalidSQLStatementNameError (line 496) | class InvalidSQLStatementNameError(_base.PostgresError):
  class TriggeredDataChangeViolationError (line 500) | class TriggeredDataChangeViolationError(_base.PostgresError):
  class InvalidAuthorizationSpecificationError (line 504) | class InvalidAuthorizationSpecificationError(_base.PostgresError):
  class InvalidPasswordError (line 508) | class InvalidPasswordError(InvalidAuthorizationSpecificationError):
  class DependentPrivilegeDescriptorsStillExistError (line 512) | class DependentPrivilegeDescriptorsStillExistError(_base.PostgresError):
  class DependentObjectsStillExistError (line 516) | class DependentObjectsStillExistError(
  class InvalidTransactionTerminationError (line 521) | class InvalidTransactionTerminationError(_base.PostgresError):
  class SQLRoutineError (line 525) | class SQLRoutineError(_base.PostgresError):
  class FunctionExecutedNoReturnStatementError (line 529) | class FunctionExecutedNoReturnStatementError(SQLRoutineError):
  class ModifyingSQLDataNotPermittedError (line 533) | class ModifyingSQLDataNotPermittedError(SQLRoutineError):
  class ProhibitedSQLStatementAttemptedError (line 537) | class ProhibitedSQLStatementAttemptedError(SQLRoutineError):
  class ReadingSQLDataNotPermittedError (line 541) | class ReadingSQLDataNotPermittedError(SQLRoutineError):
  class InvalidCursorNameError (line 545) | class InvalidCursorNameError(_base.PostgresError):
  class ExternalRoutineError (line 549) | class ExternalRoutineError(_base.PostgresError):
  class ContainingSQLNotPermittedError (line 553) | class ContainingSQLNotPermittedError(ExternalRoutineError):
  class ModifyingExternalRoutineSQLDataNotPermittedError (line 557) | class ModifyingExternalRoutineSQLDataNotPermittedError(ExternalRoutineEr...
  class ProhibitedExternalRoutineSQLStatementAttemptedError (line 561) | class ProhibitedExternalRoutineSQLStatementAttemptedError(
  class ReadingExternalRoutineSQLDataNotPermittedError (line 566) | class ReadingExternalRoutineSQLDataNotPermittedError(ExternalRoutineError):
  class ExternalRoutineInvocationError (line 570) | class ExternalRoutineInvocationError(_base.PostgresError):
  class InvalidSqlstateReturnedError (line 574) | class InvalidSqlstateReturnedError(ExternalRoutineInvocationError):
  class NullValueInExternalRoutineNotAllowedError (line 578) | class NullValueInExternalRoutineNotAllowedError(
  class TriggerProtocolViolatedError (line 583) | class TriggerProtocolViolatedError(ExternalRoutineInvocationError):
  class SrfProtocolViolatedError (line 587) | class SrfProtocolViolatedError(ExternalRoutineInvocationError):
  class EventTriggerProtocolViolatedError (line 591) | class EventTriggerProtocolViolatedError(ExternalRoutineInvocationError):
  class SavepointError (line 595) | class SavepointError(_base.PostgresError):
  class InvalidSavepointSpecificationError (line 599) | class InvalidSavepointSpecificationError(SavepointError):
  class InvalidCatalogNameError (line 603) | class InvalidCatalogNameError(_base.PostgresError):
  class InvalidSchemaNameError (line 607) | class InvalidSchemaNameError(_base.PostgresError):
  class TransactionRollbackError (line 611) | class TransactionRollbackError(_base.PostgresError):
  class TransactionIntegrityConstraintViolationError (line 615) | class TransactionIntegrityConstraintViolationError(TransactionRollbackEr...
  class SerializationError (line 619) | class SerializationError(TransactionRollbackError):
  class StatementCompletionUnknownError (line 623) | class StatementCompletionUnknownError(TransactionRollbackError):
  class DeadlockDetectedError (line 627) | class DeadlockDetectedError(TransactionRollbackError):
  class SyntaxOrAccessError (line 631) | class SyntaxOrAccessError(_base.PostgresError):
  class PostgresSyntaxError (line 635) | class PostgresSyntaxError(SyntaxOrAccessError):
  class InsufficientPrivilegeError (line 639) | class InsufficientPrivilegeError(SyntaxOrAccessError):
  class CannotCoerceError (line 643) | class CannotCoerceError(SyntaxOrAccessError):
  class GroupingError (line 647) | class GroupingError(SyntaxOrAccessError):
  class WindowingError (line 651) | class WindowingError(SyntaxOrAccessError):
  class InvalidRecursionError (line 655) | class InvalidRecursionError(SyntaxOrAccessError):
  class InvalidForeignKeyError (line 659) | class InvalidForeignKeyError(SyntaxOrAccessError):
  class InvalidNameError (line 663) | class InvalidNameError(SyntaxOrAccessError):
  class NameTooLongError (line 667) | class NameTooLongError(SyntaxOrAccessError):
  class ReservedNameError (line 671) | class ReservedNameError(SyntaxOrAccessError):
  class DatatypeMismatchError (line 675) | class DatatypeMismatchError(SyntaxOrAccessError):
  class IndeterminateDatatypeError (line 679) | class IndeterminateDatatypeError(SyntaxOrAccessError):
  class CollationMismatchError (line 683) | class CollationMismatchError(SyntaxOrAccessError):
  class IndeterminateCollationError (line 687) | class IndeterminateCollationError(SyntaxOrAccessError):
  class WrongObjectTypeError (line 691) | class WrongObjectTypeError(SyntaxOrAccessError):
  class GeneratedAlwaysError (line 695) | class GeneratedAlwaysError(SyntaxOrAccessError):
  class UndefinedColumnError (line 699) | class UndefinedColumnError(SyntaxOrAccessError):
  class UndefinedFunctionError (line 703) | class UndefinedFunctionError(SyntaxOrAccessError):
  class UndefinedTableError (line 707) | class UndefinedTableError(SyntaxOrAccessError):
  class UndefinedParameterError (line 711) | class UndefinedParameterError(SyntaxOrAccessError):
  class UndefinedObjectError (line 715) | class UndefinedObjectError(SyntaxOrAccessError):
  class DuplicateColumnError (line 719) | class DuplicateColumnError(SyntaxOrAccessError):
  class DuplicateCursorError (line 723) | class DuplicateCursorError(SyntaxOrAccessError):
  class DuplicateDatabaseError (line 727) | class DuplicateDatabaseError(SyntaxOrAccessError):
  class DuplicateFunctionError (line 731) | class DuplicateFunctionError(SyntaxOrAccessError):
  class DuplicatePreparedStatementError (line 735) | class DuplicatePreparedStatementError(SyntaxOrAccessError):
  class DuplicateSchemaError (line 739) | class DuplicateSchemaError(SyntaxOrAccessError):
  class DuplicateTableError (line 743) | class DuplicateTableError(SyntaxOrAccessError):
  class DuplicateAliasError (line 747) | class DuplicateAliasError(SyntaxOrAccessError):
  class DuplicateObjectError (line 751) | class DuplicateObjectError(SyntaxOrAccessError):
  class AmbiguousColumnError (line 755) | class AmbiguousColumnError(SyntaxOrAccessError):
  class AmbiguousFunctionError (line 759) | class AmbiguousFunctionError(SyntaxOrAccessError):
  class AmbiguousParameterError (line 763) | class AmbiguousParameterError(SyntaxOrAccessError):
  class AmbiguousAliasError (line 767) | class AmbiguousAliasError(SyntaxOrAccessError):
  class InvalidColumnReferenceError (line 771) | class InvalidColumnReferenceError(SyntaxOrAccessError):
  class InvalidColumnDefinitionError (line 775) | class InvalidColumnDefinitionError(SyntaxOrAccessError):
  class InvalidCursorDefinitionError (line 779) | class InvalidCursorDefinitionError(SyntaxOrAccessError):
  class InvalidDatabaseDefinitionError (line 783) | class InvalidDatabaseDefinitionError(SyntaxOrAccessError):
  class InvalidFunctionDefinitionError (line 787) | class InvalidFunctionDefinitionError(SyntaxOrAccessError):
  class InvalidPreparedStatementDefinitionError (line 791) | class InvalidPreparedStatementDefinitionError(SyntaxOrAccessError):
  class InvalidSchemaDefinitionError (line 795) | class InvalidSchemaDefinitionError(SyntaxOrAccessError):
  class InvalidTableDefinitionError (line 799) | class InvalidTableDefinitionError(SyntaxOrAccessError):
  class InvalidObjectDefinitionError (line 803) | class InvalidObjectDefinitionError(SyntaxOrAccessError):
  class WithCheckOptionViolationError (line 807) | class WithCheckOptionViolationError(_base.PostgresError):
  class InsufficientResourcesError (line 811) | class InsufficientResourcesError(_base.PostgresError):
  class DiskFullError (line 815) | class DiskFullError(InsufficientResourcesError):
  class OutOfMemoryError (line 819) | class OutOfMemoryError(InsufficientResourcesError):
  class TooManyConnectionsError (line 823) | class TooManyConnectionsError(InsufficientResourcesError):
  class ConfigurationLimitExceededError (line 827) | class ConfigurationLimitExceededError(InsufficientResourcesError):
  class ProgramLimitExceededError (line 831) | class ProgramLimitExceededError(_base.PostgresError):
  class StatementTooComplexError (line 835) | class StatementTooComplexError(ProgramLimitExceededError):
  class TooManyColumnsError (line 839) | class TooManyColumnsError(ProgramLimitExceededError):
  class TooManyArgumentsError (line 843) | class TooManyArgumentsError(ProgramLimitExceededError):
  class ObjectNotInPrerequisiteStateError (line 847) | class ObjectNotInPrerequisiteStateError(_base.PostgresError):
  class ObjectInUseError (line 851) | class ObjectInUseError(ObjectNotInPrerequisiteStateError):
  class CantChangeRuntimeParamError (line 855) | class CantChangeRuntimeParamError(ObjectNotInPrerequisiteStateError):
  class LockNotAvailableError (line 859) | class LockNotAvailableError(ObjectNotInPrerequisiteStateError):
  class UnsafeNewEnumValueUsageError (line 863) | class UnsafeNewEnumValueUsageError(ObjectNotInPrerequisiteStateError):
  class OperatorInterventionError (line 867) | class OperatorInterventionError(_base.PostgresError):
  class QueryCanceledError (line 871) | class QueryCanceledError(OperatorInterventionError):
  class AdminShutdownError (line 875) | class AdminShutdownError(OperatorInterventionError):
  class CrashShutdownError (line 879) | class CrashShutdownError(OperatorInterventionError):
  class CannotConnectNowError (line 883) | class CannotConnectNowError(OperatorInterventionError):
  class DatabaseDroppedError (line 887) | class DatabaseDroppedError(OperatorInterventionError):
  class IdleSessionTimeoutError (line 891) | class IdleSessionTimeoutError(OperatorInterventionError):
  class PostgresSystemError (line 895) | class PostgresSystemError(_base.PostgresError):
  class PostgresIOError (line 899) | class PostgresIOError(PostgresSystemError):
  class UndefinedFileError (line 903) | class UndefinedFileError(PostgresSystemError):
  class DuplicateFileError (line 907) | class DuplicateFileError(PostgresSystemError):
  class FileNameTooLongError (line 911) | class FileNameTooLongError(PostgresSystemError):
  class SnapshotTooOldError (line 915) | class SnapshotTooOldError(_base.PostgresError):
  class ConfigFileError (line 919) | class ConfigFileError(_base.PostgresError):
  class LockFileExistsError (line 923) | class LockFileExistsError(ConfigFileError):
  class FDWError (line 927) | class FDWError(_base.PostgresError):
  class FDWColumnNameNotFoundError (line 931) | class FDWColumnNameNotFoundError(FDWError):
  class FDWDynamicParameterValueNeededError (line 935) | class FDWDynamicParameterValueNeededError(FDWError):
  class FDWFunctionSequenceError (line 939) | class FDWFunctionSequenceError(FDWError):
  class FDWInconsistentDescriptorInformationError (line 943) | class FDWInconsistentDescriptorInformationError(FDWError):
  class FDWInvalidAttributeValueError (line 947) | class FDWInvalidAttributeValueError(FDWError):
  class FDWInvalidColumnNameError (line 951) | class FDWInvalidColumnNameError(FDWError):
  class FDWInvalidColumnNumberError (line 955) | class FDWInvalidColumnNumberError(FDWError):
  class FDWInvalidDataTypeError (line 959) | class FDWInvalidDataTypeError(FDWError):
  class FDWInvalidDataTypeDescriptorsError (line 963) | class FDWInvalidDataTypeDescriptorsError(FDWError):
  class FDWInvalidDescriptorFieldIdentifierError (line 967) | class FDWInvalidDescriptorFieldIdentifierError(FDWError):
  class FDWInvalidHandleError (line 971) | class FDWInvalidHandleError(FDWError):
  class FDWInvalidOptionIndexError (line 975) | class FDWInvalidOptionIndexError(FDWError):
  class FDWInvalidOptionNameError (line 979) | class FDWInvalidOptionNameError(FDWError):
  class FDWInvalidStringLengthOrBufferLengthError (line 983) | class FDWInvalidStringLengthOrBufferLengthError(FDWError):
  class FDWInvalidStringFormatError (line 987) | class FDWInvalidStringFormatError(FDWError):
  class FDWInvalidUseOfNullPointerError (line 991) | class FDWInvalidUseOfNullPointerError(FDWError):
  class FDWTooManyHandlesError (line 995) | class FDWTooManyHandlesError(FDWError):
  class FDWOutOfMemoryError (line 999) | class FDWOutOfMemoryError(FDWError):
  class FDWNoSchemasError (line 1003) | class FDWNoSchemasError(FDWError):
  class FDWOptionNameNotFoundError (line 1007) | class FDWOptionNameNotFoundError(FDWError):
  class FDWReplyHandleError (line 1011) | class FDWReplyHandleError(FDWError):
  class FDWSchemaNotFoundError (line 1015) | class FDWSchemaNotFoundError(FDWError):
  class FDWTableNotFoundError (line 1019) | class FDWTableNotFoundError(FDWError):
  class FDWUnableToCreateExecutionError (line 1023) | class FDWUnableToCreateExecutionError(FDWError):
  class FDWUnableToCreateReplyError (line 1027) | class FDWUnableToCreateReplyError(FDWError):
  class FDWUnableToEstablishConnectionError (line 1031) | class FDWUnableToEstablishConnectionError(FDWError):
  class PLPGSQLError (line 1035) | class PLPGSQLError(_base.PostgresError):
  class RaiseError (line 1039) | class RaiseError(PLPGSQLError):
  class NoDataFoundError (line 1043) | class NoDataFoundError(PLPGSQLError):
  class TooManyRowsError (line 1047) | class TooManyRowsError(PLPGSQLError):
  class AssertError (line 1051) | class AssertError(PLPGSQLError):
  class InternalServerError (line 1055) | class InternalServerError(_base.PostgresError):
  class DataCorruptedError (line 1059) | class DataCorruptedError(InternalServerError):
  class IndexCorruptedError (line 1063) | class IndexCorruptedError(InternalServerError):

FILE: asyncpg/exceptions/_base.py
  function _is_asyncpg_class (line 21) | def _is_asyncpg_class(cls):
  class PostgresMessageMeta (line 26) | class PostgresMessageMeta(type):
    method __new__ (line 50) | def __new__(mcls, name, bases, dct):
    method get_message_class_for_sqlstate (line 74) | def get_message_class_for_sqlstate(mcls, code):
  class PostgresMessage (line 78) | class PostgresMessage(metaclass=PostgresMessageMeta):
    method _get_error_class (line 81) | def _get_error_class(cls, fields):
    method _get_error_dict (line 86) | def _get_error_dict(cls, fields, query):
    method _make_constructor (line 100) | def _make_constructor(cls, fields, query=None):
    method as_dict (line 156) | def as_dict(self):
  class PostgresError (line 165) | class PostgresError(PostgresMessage, Exception):
    method __str__ (line 168) | def __str__(self):
    method new (line 178) | def new(cls, fields, query=None):
  class FatalPostgresError (line 185) | class FatalPostgresError(PostgresError):
  class UnknownPostgresError (line 189) | class UnknownPostgresError(FatalPostgresError):
  class InterfaceMessage (line 193) | class InterfaceMessage:
    method __init__ (line 194) | def __init__(self, *, detail=None, hint=None):
    method __str__ (line 198) | def __str__(self):
  class InterfaceError (line 208) | class InterfaceError(InterfaceMessage, Exception):
    method __init__ (line 211) | def __init__(self, msg, *, detail=None, hint=None):
    method with_msg (line 215) | def with_msg(self, msg):
  class ClientConfigurationError (line 225) | class ClientConfigurationError(InterfaceError, ValueError):
  class DataError (line 229) | class DataError(InterfaceError, ValueError):
  class UnsupportedClientFeatureError (line 233) | class UnsupportedClientFeatureError(InterfaceError):
  class UnsupportedServerFeatureError (line 237) | class UnsupportedServerFeatureError(InterfaceError):
  class InterfaceWarning (line 241) | class InterfaceWarning(InterfaceMessage, UserWarning):
    method __init__ (line 244) | def __init__(self, msg, *, detail=None, hint=None):
  class InternalClientError (line 249) | class InternalClientError(Exception):
  class ProtocolError (line 253) | class ProtocolError(InternalClientError):
  class TargetServerAttributeNotMatched (line 257) | class TargetServerAttributeNotMatched(InternalClientError):
  class OutdatedSchemaCacheError (line 261) | class OutdatedSchemaCacheError(InternalClientError):
    method __init__ (line 264) | def __init__(self, msg, *, schema=None, data_type=None, position=None):
  class PostgresLogMessage (line 271) | class PostgresLogMessage(PostgresMessage):
    method __str__ (line 274) | def __str__(self):
    method __setattr__ (line 277) | def __setattr__(self, name, val):
    method new (line 282) | def new(cls, fields, query=None):

FILE: asyncpg/introspection.py
  function TypeRecord (line 272) | def TypeRecord(
  function is_scalar_type (line 284) | def is_scalar_type(typeinfo: protocol.Record) -> bool:
  function is_domain_type (line 291) | def is_domain_type(typeinfo: protocol.Record) -> bool:
  function is_composite_type (line 295) | def is_composite_type(typeinfo: protocol.Record) -> bool:

FILE: asyncpg/pool.py
  class PoolConnectionProxyMeta (line 28) | class PoolConnectionProxyMeta(type):
    method __new__ (line 30) | def __new__(
    method _wrap_connection_method (line 58) | def _wrap_connection_method(
  class PoolConnectionProxy (line 78) | class PoolConnectionProxy(connection._ConnectionProxy,
    method __init__ (line 84) | def __init__(
    method __getattr__ (line 91) | def __getattr__(self, attr: str) -> Any:
    method _detach (line 95) | def _detach(self) -> Optional[connection.Connection]:
    method __repr__ (line 103) | def __repr__(self) -> str:
  class PoolConnectionHolder (line 112) | class PoolConnectionHolder:
    method __init__ (line 120) | def __init__(
    method is_connected (line 141) | def is_connected(self) -> bool:
    method is_idle (line 144) | def is_idle(self) -> bool:
    method connect (line 147) | async def connect(self) -> None:
    method acquire (line 158) | async def acquire(self) -> PoolConnectionProxy:
    method release (line 195) | async def release(self, timeout: Optional[float]) -> None:
    method wait_until_released (line 258) | async def wait_until_released(self) -> None:
    method close (line 264) | async def close(self) -> None:
    method terminate (line 270) | def terminate(self) -> None:
    method _setup_inactive_callback (line 276) | def _setup_inactive_callback(self) -> None:
    method _maybe_cancel_inactive_callback (line 285) | def _maybe_cancel_inactive_callback(self) -> None:
    method _deactivate_inactive_connection (line 290) | def _deactivate_inactive_connection(self) -> None:
    method _release_on_close (line 304) | def _release_on_close(self) -> None:
    method _release (line 309) | def _release(self) -> None:
  class Pool (line 329) | class Pool:
    method __init__ (line 348) | def __init__(self, *connect_args,
    method _async__init__ (line 429) | async def _async__init__(self):
    method _initialize (line 445) | async def _initialize(self):
    method is_closing (line 478) | def is_closing(self):
    method get_size (line 485) | def get_size(self):
    method get_min_size (line 492) | def get_min_size(self):
    method get_max_size (line 499) | def get_max_size(self):
    method get_idle_size (line 506) | def get_idle_size(self):
    method set_connect_args (line 513) | def set_connect_args(self, dsn=None, **connect_kwargs):
    method _get_new_connection (line 537) | async def _get_new_connection(self):
    method execute (line 577) | async def execute(
    method executemany (line 594) | async def executemany(
    method fetch (line 613) | async def fetch(
    method fetchval (line 636) | async def fetchval(self, query, *args, column=0, timeout=None):
    method fetchrow (line 650) | async def fetchrow(self, query, *args, timeout=None, record_class=None):
    method fetchmany (line 667) | async def fetchmany(self, query, args, *, timeout=None, record_class=N...
    method copy_from_table (line 683) | async def copy_from_table(
    method copy_from_query (line 728) | async def copy_from_query(
    method copy_to_table (line 770) | async def copy_to_table(
    method copy_records_to_table (line 823) | async def copy_records_to_table(
    method acquire (line 852) | def acquire(self, *, timeout=None):
    method _acquire (line 877) | async def _acquire(self, timeout):
    method release (line 901) | async def release(self, connection, *, timeout=None):
    method close (line 939) | async def close(self):
    method _warn_on_long_close (line 984) | def _warn_on_long_close(self):
    method terminate (line 990) | def terminate(self):
    method expire_connections (line 999) | async def expire_connections(self):
    method _check_init (line 1009) | def _check_init(self):
    method _drop_statement_cache (line 1020) | def _drop_statement_cache(self):
    method _drop_type_cache (line 1026) | def _drop_type_cache(self):
    method __await__ (line 1032) | def __await__(self):
    method __aenter__ (line 1035) | async def __aenter__(self):
    method __aexit__ (line 1039) | async def __aexit__(self, *exc):
  class PoolAcquireContext (line 1043) | class PoolAcquireContext:
    method __init__ (line 1047) | def __init__(self, pool: Pool, timeout: Optional[float]) -> None:
    method __aenter__ (line 1053) | async def __aenter__(self):
    method __aexit__ (line 1059) | async def __aexit__(
    method __await__ (line 1070) | def __await__(self):
  function create_pool (line 1075) | def create_pool(dsn=None, *,

FILE: asyncpg/prepared_stmt.py
  class PreparedStatement (line 16) | class PreparedStatement(connresource.ConnectionResource):
    method __init__ (line 21) | def __init__(self, connection, query, state):
    method get_name (line 29) | def get_name(self) -> str:
    method get_query (line 37) | def get_query(self) -> str:
    method get_statusmsg (line 48) | def get_statusmsg(self) -> str:
    method get_parameters (line 62) | def get_parameters(self):
    method get_attributes (line 79) | def get_attributes(self):
    method cursor (line 104) | def cursor(self, *args, prefetch=None,
    method explain (line 126) | async def explain(self, *args, analyze=False):
    method fetch (line 168) | async def fetch(self, *args, timeout=None):
    method fetchval (line 181) | async def fetchval(self, *args, column=0, timeout=None):
    method fetchrow (line 200) | async def fetchrow(self, *args, timeout=None):
    method fetchmany (line 215) | async def fetchmany(self, args, *, timeout=None):
    method executemany (line 236) | async def executemany(self, args, *, timeout: typing.Optional[float]=N...
    method __do_execute (line 254) | async def __do_execute(self, executor):
    method __bind_execute (line 267) | async def __bind_execute(self, args, limit, timeout):
    method _check_open (line 274) | def _check_open(self, meth_name):
    method _check_conn_validity (line 280) | def _check_conn_validity(self, meth_name):
    method __del__ (line 284) | def __del__(self):

FILE: asyncpg/protocol/protocol.pyi
  class ConnectionSettings (line 43) | class ConnectionSettings(asyncpg.pgproto.pgproto.CodecContext):
    method __init__ (line 45) | def __init__(self, conn_key: object) -> None: ...
    method add_python_codec (line 46) | def add_python_codec(
    method clear_type_cache (line 57) | def clear_type_cache(self) -> None: ...
    method get_data_codec (line 58) | def get_data_codec(
    method get_text_codec (line 61) | def get_text_codec(self) -> CodecInfo: ...
    method register_data_types (line 62) | def register_data_types(self, types: Iterable[object]) -> None: ...
    method remove_python_codec (line 63) | def remove_python_codec(
    method set_builtin_type_codec (line 66) | def set_builtin_type_codec(
    method __getattr__ (line 75) | def __getattr__(self, name: str) -> Any: ...
    method __reduce__ (line 76) | def __reduce__(self) -> Any: ...
  class PreparedStatementState (line 79) | class PreparedStatementState(Generic[_Record]):
    method __init__ (line 88) | def __init__(
    method _get_parameters (line 96) | def _get_parameters(self) -> tuple[Type, ...]: ...
    method _get_attributes (line 97) | def _get_attributes(self) -> tuple[Attribute, ...]: ...
    method _init_types (line 98) | def _init_types(self) -> set[int]: ...
    method _init_codecs (line 99) | def _init_codecs(self) -> None: ...
    method attach (line 100) | def attach(self) -> None: ...
    method detach (line 101) | def detach(self) -> None: ...
    method mark_closed (line 102) | def mark_closed(self) -> None: ...
    method mark_unprepared (line 103) | def mark_unprepared(self) -> None: ...
    method __reduce__ (line 104) | def __reduce__(self) -> Any: ...
  class CoreProtocol (line 106) | class CoreProtocol:
    method __init__ (line 110) | def __init__(self, addr: object, con_params: _ConnectionParameters) ->...
    method is_in_transaction (line 111) | def is_in_transaction(self) -> bool: ...
    method __reduce__ (line 112) | def __reduce__(self) -> Any: ...
  class BaseProtocol (line 114) | class BaseProtocol(CoreProtocol, Generic[_Record]):
    method __init__ (line 118) | def __init__(
    method set_connection (line 126) | def set_connection(self, connection: object) -> None: ...
    method get_server_pid (line 127) | def get_server_pid(self, *args: object, **kwargs: object) -> int: ...
    method get_settings (line 128) | def get_settings(self, *args: object, **kwargs: object) -> ConnectionS...
    method get_record_class (line 129) | def get_record_class(self) -> type[_Record]: ...
    method abort (line 130) | def abort(self) -> None: ...
    method bind (line 131) | async def bind(
    method bind_execute (line 139) | async def bind_execute(
    method bind_execute (line 149) | async def bind_execute(
    method bind_execute (line 159) | async def bind_execute(
    method bind_execute_many (line 168) | async def bind_execute_many(
    method close (line 175) | async def close(self, timeout: _TimeoutType) -> None: ...
    method _get_timeout (line 176) | def _get_timeout(self, timeout: _TimeoutType) -> float | None: ...
    method _is_cancelling (line 177) | def _is_cancelling(self) -> bool: ...
    method _wait_for_cancellation (line 178) | async def _wait_for_cancellation(self) -> None: ...
    method close_statement (line 179) | async def close_statement(
    method copy_in (line 182) | async def copy_in(self, *args: object, **kwargs: object) -> str: ...
    method copy_out (line 183) | async def copy_out(self, *args: object, **kwargs: object) -> str: ...
    method execute (line 184) | async def execute(self, *args: object, **kwargs: object) -> Any: ...
    method is_closed (line 185) | def is_closed(self, *args: object, **kwargs: object) -> Any: ...
    method is_connected (line 186) | def is_connected(self, *args: object, **kwargs: object) -> Any: ...
    method data_received (line 187) | def data_received(self, data: object) -> None: ...
    method connection_made (line 188) | def connection_made(self, transport: object) -> None: ...
    method connection_lost (line 189) | def connection_lost(self, exc: Exception | None) -> None: ...
    method pause_writing (line 190) | def pause_writing(self, *args: object, **kwargs: object) -> Any: ...
    method prepare (line 192) | async def prepare(
    method prepare (line 203) | async def prepare(
    method close_portal (line 213) | async def close_portal(self, portal_name: str, timeout: _TimeoutType) ...
    method query (line 214) | async def query(self, *args: object, **kwargs: object) -> str: ...
    method resume_writing (line 215) | def resume_writing(self, *args: object, **kwargs: object) -> Any: ...
    method __reduce__ (line 216) | def __reduce__(self) -> Any: ...
  class Codec (line 219) | class Codec:
    method __reduce__ (line 221) | def __reduce__(self) -> Any: ...
  class DataCodecConfig (line 223) | class DataCodecConfig:
    method __init__ (line 225) | def __init__(self) -> None: ...
    method add_python_codec (line 226) | def add_python_codec(
    method add_types (line 238) | def add_types(self, types: Iterable[object]) -> Any: ...
    method clear_type_cache (line 239) | def clear_type_cache(self) -> None: ...
    method declare_fallback_codec (line 240) | def declare_fallback_codec(self, oid: int, name: str, schema: str) -> ...
    method remove_python_codec (line 241) | def remove_python_codec(
    method set_builtin_type_codec (line 244) | def set_builtin_type_codec(
    method __reduce__ (line 253) | def __reduce__(self) -> Any: ...
  class Protocol (line 255) | class Protocol(BaseProtocol[_Record], asyncio.protocols.Protocol): ...
  class Timer (line 257) | class Timer:
    method __init__ (line 258) | def __init__(self, budget: float | None) -> None: ...
    method __enter__ (line 259) | def __enter__(self) -> None: ...
    method __exit__ (line 260) | def __exit__(self, et: object, e: object, tb: object) -> None: ...
    method get_remaining_budget (line 261) | def get_remaining_budget(self) -> float: ...
    method has_budget_greater_than (line 262) | def has_budget_greater_than(self, amount: float) -> bool: ...
  class SCRAMAuthentication (line 265) | class SCRAMAuthentication:

FILE: asyncpg/protocol/record.pyi
  class Record (line 13) | class Record:
    method get (line 15) | def get(self, key: str) -> Any | None: ...
    method get (line 17) | def get(self, key: str, default: _T) -> Any | _T: ...
    method items (line 18) | def items(self) -> Iterator[tuple[str, Any]]: ...
    method keys (line 19) | def keys(self) -> Iterator[str]: ...
    method values (line 20) | def values(self) -> Iterator[Any]: ...
    method __getitem__ (line 22) | def __getitem__(self, index: str) -> Any: ...
    method __getitem__ (line 24) | def __getitem__(self, index: int) -> Any: ...
    method __getitem__ (line 26) | def __getitem__(self, index: slice) -> tuple[Any, ...]: ...
    method __iter__ (line 27) | def __iter__(self) -> Iterator[Any]: ...
    method __contains__ (line 28) | def __contains__(self, x: object) -> bool: ...
    method __len__ (line 29) | def __len__(self) -> int: ...

FILE: asyncpg/protocol/record/pythoncapi_compat.h
  function PyObject (line 64) | static inline PyObject* _Py_NewRef(PyObject *obj)
  function PyObject (line 75) | static inline PyObject* _Py_XNewRef(PyObject *obj)
  function _Py_SET_REFCNT (line 86) | static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
  function _Py_SET_TYPE (line 133) | static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
  function _Py_SET_SIZE (line 143) | static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
  function PyCodeObject (line 153) | static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)
  function PyCodeObject (line 161) | static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame)
  function PyFrameObject (line 171) | static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)
  function PyFrameObject (line 179) | static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame)
  function PyObject (line 190) | static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame)
  function PyObject (line 206) | static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame)
  function PyObject (line 215) | static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame)
  function PyFrame_GetLasti (line 224) | static inline int PyFrame_GetLasti(PyFrameObject *frame)
  function PyObject (line 243) | static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *n...
  function PyObject (line 276) | static inline PyObject*
  function PyInterpreterState (line 297) | static inline PyInterpreterState *
  function PyFrameObject (line 308) | static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)
  function PyFrameObject (line 316) | static inline PyFrameObject*
  function PyInterpreterState (line 328) | static inline PyInterpreterState* PyInterpreterState_Get(void)
  function PyThreadState_GetID (line 348) | static inline uint64_t PyThreadState_GetID(PyThreadState *tstate)
  function PyThreadState_EnterTracing (line 357) | static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
  function PyThreadState_LeaveTracing (line 370) | static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
  function PyObject (line 387) | static inline PyObject* PyObject_CallNoArgs(PyObject *func)
  function PyObject (line 398) | static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg)
  function PyModule_AddObjectRef (line 407) | static inline int
  function PyModule_AddType (line 432) | static inline int PyModule_AddType(PyObject *module, PyTypeObject *type)
  function PyObject_GC_IsTracked (line 456) | static inline int PyObject_GC_IsTracked(PyObject* obj)
  function PyObject_GC_IsFinalized (line 465) | static inline int PyObject_GC_IsFinalized(PyObject *obj)
  function _Py_IS_TYPE (line 475) | static inline int _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
  function PyFloat_Pack2 (line 487) | static inline int PyFloat_Pack2(double x, char *p, int le)
  function PyFloat_Unpack2 (line 490) | static inline double PyFloat_Unpack2(const char *p, int le)
  function PyFloat_Pack4 (line 501) | static inline int PyFloat_Pack4(double x, char *p, int le)
  function PyFloat_Pack8 (line 504) | static inline int PyFloat_Pack8(double x, char *p, int le)
  function PyFloat_Unpack4 (line 507) | static inline double PyFloat_Unpack4(const char *p, int le)
  function PyFloat_Unpack8 (line 510) | static inline double PyFloat_Unpack8(const char *p, int le)
  function PyObject (line 517) | static inline PyObject* PyCode_GetCode(PyCodeObject *code)
  function PyObject (line 526) | static inline PyObject* PyCode_GetVarnames(PyCodeObject *code)
  function PyObject (line 534) | static inline PyObject* PyCode_GetFreevars(PyCodeObject *code)
  function PyObject (line 542) | static inline PyObject* PyCode_GetCellvars(PyCodeObject *code)
  function PyObject (line 561) | static inline PyObject* PyImport_AddModuleRef(const char *name)
  function PyWeakref_GetRef (line 570) | static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)
  function Py_ssize_t (line 601) | static inline Py_ssize_t PyVectorcall_NARGS(size_t n)
  function PyObject (line 610) | static inline PyObject*
  function PyObject_GetOptionalAttr (line 686) | static inline int
  function PyObject_GetOptionalAttrString (line 708) | static inline int
  function PyMapping_GetOptionalItem (line 732) | static inline int
  function PyMapping_GetOptionalItemString (line 746) | static inline int
  function PyMapping_HasKeyWithError (line 769) | static inline int
  function PyMapping_HasKeyStringWithError (line 778) | static inline int
  function PyObject_HasAttrWithError (line 792) | static inline int
  function PyObject_HasAttrStringWithError (line 801) | static inline int
  function PyDict_GetItemRef (line 815) | static inline int
  function PyDict_GetItemStringRef (line 835) | static inline int
  function PyModule_Add (line 857) | static inline int
  function Py_IsFinalizing (line 872) | static inline int Py_IsFinalizing(void)
  function PyDict_ContainsString (line 886) | static inline int PyDict_ContainsString(PyObject *op, const char *key)
  function PyLong_AsInt (line 901) | static inline int PyLong_AsInt(PyObject *obj)
  function PyObject_VisitManagedDict (line 923) | static inline int
  function PyObject_ClearManagedDict (line 934) | static inline void
  function PyThreadState (line 948) | static inline PyThreadState*
  function PyUnicode_EqualToUTF8AndSize (line 958) | static inline int
  function PyUnicode_EqualToUTF8 (line 1021) | static inline int
  function PyList_Extend (line 1031) | static inline int
  function PyList_Clear (line 1037) | static inline int
  function PyDict_Pop (line 1046) | static inline int
  function PyDict_PopString (line 1088) | static inline int
  type Py_ssize_t (line 1108) | typedef Py_ssize_t Py_hash_t;
  function Py_hash_t (line 1114) | static inline Py_hash_t Py_HashPointer(const void *ptr)
  type _PyTime_t (line 1128) | typedef _PyTime_t PyTime_t;
  function PyTime_AsSecondsDouble (line 1132) | static inline double PyTime_AsSecondsDouble(PyTime_t t)
  function PyTime_Monotonic (line 1135) | static inline int PyTime_Monotonic(PyTime_t *result)
  function PyTime_Time (line 1138) | static inline int PyTime_Time(PyTime_t *result)
  function PyTime_PerfCounter (line 1141) | static inline int PyTime_PerfCounter(PyTime_t *result)
  function PyObject (line 1240) | static inline PyObject* Py_GetConstant(unsigned int constant_id)
  function PyObject (line 1293) | static inline PyObject* Py_GetConstantBorrowed(unsigned int constant_id)
  function PyObject (line 1304) | static inline PyObject *
  function PyDict_SetDefaultRef (line 1316) | static inline int
  type PyUnicodeWriter (line 1362) | typedef struct PyUnicodeWriter PyUnicodeWriter;
  function PyUnicodeWriter_Discard (line 1364) | static inline void PyUnicodeWriter_Discard(PyUnicodeWriter *writer)
  function PyUnicodeWriter (line 1370) | static inline PyUnicodeWriter* PyUnicodeWriter_Create(Py_ssize_t length)
  function PyObject (line 1395) | static inline PyObject* PyUnicodeWriter_Finish(PyUnicodeWriter *writer)
  function PyUnicodeWriter_WriteChar (line 1403) | static inline int
  function PyUnicodeWriter_WriteStr (line 1415) | static inline int
  function PyUnicodeWriter_WriteRepr (line 1428) | static inline int
  function PyUnicodeWriter_WriteUTF8 (line 1441) | static inline int
  function PyUnicodeWriter_WriteASCII (line 1459) | static inline int
  function PyUnicodeWriter_WriteWideChar (line 1471) | static inline int
  function PyUnicodeWriter_WriteSubstring (line 1489) | static inline int
  function PyUnicodeWriter_Format (line 1511) | static inline int
  function PyLong_GetSign (line 1530) | static inline int PyLong_GetSign(PyObject *obj, int *sign)
  function PyLong_IsPositive (line 1544) | static inline int PyLong_IsPositive(PyObject *obj)
  function PyLong_IsNegative (line 1553) | static inline int PyLong_IsNegative(PyObject *obj)
  function PyLong_IsZero (line 1562) | static inline int PyLong_IsZero(PyObject *obj)
  function PyUnicode_Equal (line 1575) | static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
  function PyObject (line 1605) | static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable)
  function Py_hash_t (line 1613) | static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len)
  function PyIter_NextItem (line 1634) | static inline int PyIter_NextItem(PyObject *iter, PyObject **item)
  function PyObject (line 1665) | static inline PyObject* PyLong_FromInt32(int32_t value)
  function PyObject (line 1671) | static inline PyObject* PyLong_FromInt64(int64_t value)
  function PyObject (line 1677) | static inline PyObject* PyLong_FromUInt32(uint32_t value)
  function PyObject (line 1683) | static inline PyObject* PyLong_FromUInt64(uint64_t value)
  function PyLong_AsInt32 (line 1689) | static inline int PyLong_AsInt32(PyObject *obj, int32_t *pvalue)
  function PyLong_AsInt64 (line 1700) | static inline int PyLong_AsInt64(PyObject *obj, int64_t *pvalue)
  function PyLong_AsUInt32 (line 1711) | static inline int PyLong_AsUInt32(PyObject *obj, uint32_t *pvalue)
  function PyLong_AsUInt64 (line 1729) | static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue)
  function _PyLong_SetSignAndDigitCount (line 1745) | static inline void
  function Py_ssize_t (line 1757) | static inline Py_ssize_t
  function digit (line 1767) | static inline digit*
  type PyLongLayout (line 1777) | typedef struct PyLongLayout {
  type PyLongExport (line 1784) | typedef struct PyLongExport {
  type PyLongWriter (line 1792) | typedef struct PyLongWriter PyLongWriter;
  function PyLongLayout (line 1794) | static inline const PyLongLayout*
  function PyLong_Export (line 1807) | static inline int
  function PyLong_FreeExport (line 1850) | static inline void
  function PyLongWriter (line 1861) | static inline PyLongWriter*
  function PyLongWriter_Discard (line 1880) | static inline void
  function PyObject (line 1889) | static inline PyObject*
  function FILE (line 1954) | static inline FILE* Py_fopen(PyObject *path, const char *mode)
  function Py_fclose (line 1987) | static inline int Py_fclose(FILE *file)
  function PyObject (line 1995) | static inline PyObject*
  function PyConfig_GetInt (line 2187) | static inline int
  function PyUnstable_Object_IsUniquelyReferenced (line 2217) | static inline int PyUnstable_Object_IsUniquelyReferenced(PyObject *obj)
  function PyObject (line 2234) | static inline PyObject*
  function PyObject (line 2251) | static inline PyObject*
  function PySys_GetOptionalAttrString (line 2266) | static inline int
  function PySys_GetOptionalAttr (line 2280) | static inline int
  type PyBytesWriter (line 2299) | typedef struct PyBytesWriter {
  function Py_ssize_t (line 2305) | static inline Py_ssize_t
  function _PyBytesWriter_Resize_impl (line 2317) | static inline int
  function Py_ssize_t (line 2375) | static inline Py_ssize_t
  function PyBytesWriter_Discard (line 2381) | static inline void
  function PyBytesWriter (line 2392) | static inline PyBytesWriter*
  function PyObject (line 2419) | static inline PyObject*
  function PyObject (line 2446) | static inline PyObject*
  function PyObject (line 2452) | static inline PyObject*
  function PyBytesWriter_Resize (line 2465) | static inline int
  function PyBytesWriter_Grow (line 2479) | static inline int
  function PyBytesWriter_WriteBytes (line 2510) | static inline int
  function PyBytesWriter_Format (line 2536) | static inline int

FILE: asyncpg/protocol/record/pythoncapi_compat_extras.h
  function PyObject (line 12) | PyObject *

FILE: asyncpg/protocol/record/recordobj.c
  type record_freelist_state (line 30) | typedef struct {
  type record_module_state (line 35) | typedef struct {
  function record_module_state (line 44) | static inline record_module_state *
  function record_module_state (line 55) | static inline record_module_state *
  type PyModuleDef (line 68) | struct PyModuleDef
  function record_module_state (line 70) | static inline record_module_state *
  function record_freelist_state (line 79) | static inline record_freelist_state *
  function PyObject (line 102) | PyObject *
  function record_dealloc (line 170) | static void
  function record_traverse (line 216) | static int
  function Py_hash_t (line 244) | static Py_hash_t
  function Py_ssize_t (line 272) | static Py_ssize_t
  function record_contains (line 279) | static int
  function PyObject (line 289) | static PyObject *
  function PyObject (line 300) | static PyObject *
  type item_by_name_result_t (line 422) | typedef enum item_by_name_result {
  function item_by_name_result_t (line 431) | static item_by_name_result_t
  function PyObject (line 476) | static PyObject *
  function PyObject (line 546) | static PyObject *
  function PyObject (line 625) | static PyObject *
  function PyObject (line 639) | static PyObject *
  function PyObject (line 652) | static PyObject *
  function PyObject (line 663) | static PyObject *
  function PyObject (line 676) | static PyObject *
  function PyObject (line 712) | static PyObject *
  type ApgRecordIterObject (line 773) | typedef struct {
  function record_iter_dealloc (line 778) | static void
  function record_iter_traverse (line 788) | static int
  function PyObject (line 795) | static PyObject *
  function PyObject (line 818) | static PyObject *
  function PyObject (line 852) | static PyObject *
  type ApgRecordItemsObject (line 868) | typedef struct {
  function record_items_dealloc (line 874) | static void
  function record_items_traverse (line 885) | static int
  function PyObject (line 893) | static PyObject *
  function PyObject (line 942) | static PyObject *
  function PyObject (line 976) | static PyObject *
  function record_desc_dealloc (line 1003) | static void
  function record_desc_traverse (line 1014) | static int
  function PyObject (line 1022) | static PyObject *
  function PyObject (line 1066) | static PyObject *
  function PyObject (line 1091) | static PyObject *
  function record_module_exec (line 1163) | static int
  function record_module_traverse (line 1204) | static int
  function record_module_clear (line 1220) | static int
  function record_module_free (line 1257) | static void
  type PyModuleDef (line 1274) | struct PyModuleDef
  function PyMODINIT_FUNC (line 1285) | PyMODINIT_FUNC

FILE: asyncpg/protocol/record/recordobj.h
  type ApgRecordDescObject (line 7) | typedef struct {
  type ApgRecordObject (line 14) | typedef struct {

FILE: asyncpg/serverversion.py
  class _VersionDict (line 24) | class _VersionDict(typing.TypedDict):
  function split_server_version_string (line 32) | def split_server_version_string(version_string: str) -> ServerVersion:

FILE: asyncpg/transaction.py
  class TransactionState (line 14) | class TransactionState(enum.Enum):
  class Transaction (line 36) | class Transaction(connresource.ConnectionResource):
    method __init__ (line 47) | def __init__(self, connection, isolation, readonly, deferrable):
    method __aenter__ (line 63) | async def __aenter__(self):
    method __aexit__ (line 70) | async def __aexit__(self, extype, ex, tb):
    method start (line 96) | async def start(self):
    method __check_state_base (line 153) | def __check_state_base(self, opname):
    method __check_state (line 167) | def __check_state(self, opname):
    method __commit (line 175) | async def __commit(self):
    method __rollback (line 194) | async def __rollback(self):
    method commit (line 214) | async def commit(self):
    method rollback (line 222) | async def rollback(self):
    method __repr__ (line 229) | def __repr__(self):

FILE: asyncpg/types.py
  class Type (line 26) | class Type(typing.NamedTuple):
  class Attribute (line 41) | class Attribute(typing.NamedTuple):
  class ServerVersion (line 51) | class ServerVersion(typing.NamedTuple):
  class _RangeValue (line 62) | class _RangeValue(typing.Protocol):
    method __eq__ (line 63) | def __eq__(self, __value: object) -> bool:
    method __lt__ (line 66) | def __lt__(self, __other: Self, /) -> bool:
    method __gt__ (line 69) | def __gt__(self, __other: Self, /) -> bool:
  class Range (line 76) | class Range(typing.Generic[_RV]):
    method __init__ (line 87) | def __init__(
    method lower (line 107) | def lower(self) -> _RV | None:
    method lower_inc (line 111) | def lower_inc(self) -> bool:
    method lower_inf (line 115) | def lower_inf(self) -> bool:
    method upper (line 119) | def upper(self) -> _RV | None:
    method upper_inc (line 123) | def upper_inc(self) -> bool:
    method upper_inf (line 127) | def upper_inf(self) -> bool:
    method isempty (line 131) | def isempty(self) -> bool:
    method _issubset_lower (line 134) | def _issubset_lower(self, other: Self) -> bool:
    method _issubset_upper (line 145) | def _issubset_upper(self, other: Self) -> bool:
    method issubset (line 156) | def issubset(self, other: Self) -> bool:
    method issuperset (line 164) | def issuperset(self, other: Self) -> bool:
    method __bool__ (line 167) | def __bool__(self) -> bool:
    method __eq__ (line 170) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 188) | def __hash__(self) -> int:
    method __repr__ (line 197) | def __repr__(self) -> str:

FILE: asyncpg/utils.py
  function _quote_ident (line 11) | def _quote_ident(ident):
  function _quote_literal (line 15) | def _quote_literal(string):
  function _mogrify (line 19) | async def _mogrify(conn, query, args):

FILE: setup.py
  function git_commitish (line 60) | def git_commitish():
  class VersionMixin (line 78) | class VersionMixin:
    method _fix_version (line 80) | def _fix_version(self, filename):
  class sdist (line 95) | class sdist(setuptools_sdist.sdist, VersionMixin):
    method make_release_tree (line 97) | def make_release_tree(self, base_dir, files):
  class build_py (line 102) | class build_py(setuptools_build_py.build_py, VersionMixin):
    method build_module (line 104) | def build_module(self, module, module_file, package):
  class build_ext (line 113) | class build_ext(setuptools_build_ext.build_ext):
    method initialize_options (line 124) | def initialize_options(self):
    method finalize_options (line 153) | def finalize_options(self):

FILE: tests/__init__.py
  function suite (line 13) | def suite():

FILE: tests/certs/gen.py
  function _new_cert (line 12) | def _new_cert(issuer=None, is_issuer=False, serial_number=None, **subject):
  function _write_cert (line 132) | def _write_cert(path, cert_key_pair, password=None):
  function new_ca (line 154) | def new_ca(path, **subject):
  function new_cert (line 160) | def new_cert(
  function new_crl (line 170) | def new_crl(path, issuer, cert):
  function main (line 190) | def main():

FILE: tests/test__environment.py
  class TestEnvironment (line 17) | class TestEnvironment(tb.ConnectedTestCase):
    method test_environment_server_version (line 20) | async def test_environment_server_version(self):
    method test_environment_asyncpg_version (line 35) | async def test_environment_asyncpg_version(self):

FILE: tests/test__sourcecode.py
  function find_root (line 13) | def find_root():
  class TestCodeQuality (line 17) | class TestCodeQuality(unittest.TestCase):
    method test_flake8 (line 19) | def test_flake8(self):
    method test_mypy (line 42) | def test_mypy(self):

FILE: tests/test_adversity.py
  class TestConnectionLoss (line 21) | class TestConnectionLoss(tb.ProxiedClusterTestCase):
    method test_connection_close_timeout (line 23) | async def test_connection_close_timeout(self):
    method test_pool_acquire_timeout (line 30) | async def test_pool_acquire_timeout(self):
    method test_pool_release_timeout (line 47) | async def test_pool_release_timeout(self):
    method test_pool_handles_abrupt_connection_loss (line 59) | async def test_pool_handles_abrupt_connection_loss(self):

FILE: tests/test_cache_invalidation.py
  class TestCacheInvalidation (line 15) | class TestCacheInvalidation(tb.ConnectedTestCase):
    method _get_cached_statements (line 17) | def _get_cached_statements(self, connection=None):
    method _check_statements_are_not_closed (line 22) | def _check_statements_are_not_closed(self, statements):
    method _check_statements_are_closed (line 26) | def _check_statements_are_closed(self, statements):
    method test_prepare_cache_invalidation_silent (line 30) | async def test_prepare_cache_invalidation_silent(self):
    method test_prepare_cache_invalidation_in_transaction (line 51) | async def test_prepare_cache_invalidation_in_transaction(self):
    method test_prepare_cache_invalidation_in_pool (line 78) | async def test_prepare_cache_invalidation_in_pool(self):
    method test_type_cache_invalidation_in_transaction (line 125) | async def test_type_cache_invalidation_in_transaction(self):
    method test_type_cache_invalidation_in_cancelled_transaction (line 156) | async def test_type_cache_invalidation_in_cancelled_transaction(self):
    method test_prepared_type_cache_invalidation (line 195) | async def test_prepared_type_cache_invalidation(self):
    method test_type_cache_invalidation_on_drop_type_attr (line 250) | async def test_type_cache_invalidation_on_drop_type_attr(self):
    method test_type_cache_invalidation_on_change_attr (line 278) | async def test_type_cache_invalidation_on_change_attr(self):
    method test_type_cache_invalidation_in_pool (line 309) | async def test_type_cache_invalidation_in_pool(self):

FILE: tests/test_cancellation.py
  class TestCancellation (line 14) | class TestCancellation(tb.ConnectedTestCase):
    method test_cancellation_01 (line 16) | async def test_cancellation_01(self):
    method test_cancellation_02 (line 67) | async def test_cancellation_02(self):
    method test_cancellation_03 (line 74) | async def test_cancellation_03(self):
    method test_cancellation_04 (line 91) | async def test_cancellation_04(self):

FILE: tests/test_codecs.py
  function _timezone (line 23) | def _timezone(offset):
  function _system_timezone (line 28) | def _system_timezone():
  class TestCodecs (line 468) | class TestCodecs(tb.ConnectedTestCase):
    method test_standard_codecs (line 470) | async def test_standard_codecs(self):
    method test_all_builtin_types_handled (line 546) | async def test_all_builtin_types_handled(self):
    method test_void (line 555) | async def test_void(self):
    method test_bitstring (line 560) | def test_bitstring(self):
    method test_interval (line 587) | async def test_interval(self):
    method test_numeric (line 600) | async def test_numeric(self):
    method test_unhandled_type_fallback (line 667) | async def test_unhandled_type_fallback(self):
    method test_invalid_input (line 687) | async def test_invalid_input(self):
    method test_arrays (line 791) | async def test_arrays(self):
    method test_composites (line 897) | async def test_composites(self):
    method test_domains (line 976) | async def test_domains(self):
    method test_range_types (line 1011) | async def test_range_types(self):
    method test_multirange_types (line 1060) | async def test_multirange_types(self):
    method test_extra_codec_alias (line 1113) | async def test_extra_codec_alias(self):
    method test_custom_codec_text (line 1186) | async def test_custom_codec_text(self):
    method test_custom_codec_binary (line 1240) | async def test_custom_codec_binary(self):
    method test_custom_codec_on_domain (line 1320) | async def test_custom_codec_on_domain(self):
    method test_custom_codec_on_stdsql_types (line 1338) | async def test_custom_codec_on_stdsql_types(self):
    method test_custom_codec_on_enum (line 1371) | async def test_custom_codec_on_enum(self):
    method test_custom_codec_on_enum_array (line 1388) | async def test_custom_codec_on_enum_array(self):
    method test_custom_codec_override_binary (line 1416) | async def test_custom_codec_override_binary(self):
    method test_custom_codec_override_text (line 1440) | async def test_custom_codec_override_text(self):
    method test_custom_codec_override_tuple (line 1487) | async def test_custom_codec_override_tuple(self):
    method test_custom_codec_composite_tuple (line 1547) | async def test_custom_codec_composite_tuple(self):
    method test_custom_codec_composite_non_tuple (line 1574) | async def test_custom_codec_composite_non_tuple(self):
    method test_timetz_encoding (line 1594) | async def test_timetz_encoding(self):
    method test_composites_in_arrays (line 1615) | async def test_composites_in_arrays(self):
    method test_table_as_composite (line 1637) | async def test_table_as_composite(self):
    method test_relacl_array_type (line 1655) | async def test_relacl_array_type(self):
    method test_enum (line 1744) | async def test_enum(self):
    method test_unknown_type_text_fallback (line 1769) | async def test_unknown_type_text_fallback(self):
    method test_enum_in_array (line 1853) | async def test_enum_in_array(self):
    method test_enum_and_range (line 1873) | async def test_enum_and_range(self):
    method test_enum_in_composite (line 1898) | async def test_enum_in_composite(self):
    method test_enum_function_return (line 1916) | async def test_enum_function_return(self):
    method test_no_result (line 1937) | async def test_no_result(self):
    method test_array_with_custom_json_text_codec (line 1941) | async def test_array_with_custom_json_text_codec(self):
  class TestCodecsLargeOIDs (line 1980) | class TestCodecsLargeOIDs(tb.ConnectedTestCase):
    method setup_cluster (line 1984) | def setup_cluster(cls):
    method test_custom_codec_large_oid (line 1989) | async def test_custom_codec_large_oid(self):

FILE: tests/test_connect.py
  function mock_dot_postgresql (line 60) | def mock_dot_postgresql(*, ca=True, crl=False, client=False, protected=F...
  function mock_no_home_dir (line 86) | def mock_no_home_dir():
  function mock_dev_null_home_dir (line 94) | def mock_dev_null_home_dir():
  class TestSettings (line 102) | class TestSettings(tb.ConnectedTestCase):
    method test_get_settings_01 (line 104) | async def test_get_settings_01(self):
    method test_server_version_01 (line 109) | async def test_server_version_01(self):
    method test_server_version_02 (line 119) | def test_server_version_02(self):
  class BaseTestAuthentication (line 143) | class BaseTestAuthentication(tb.ConnectedTestCase):
    method setUp (line 146) | def setUp(self):
    method tearDown (line 202) | def tearDown(self):
  class TestAuthentication (line 219) | class TestAuthentication(BaseTestAuthentication):
    method _try_connect (line 228) | async def _try_connect(self, **kwargs):
    method test_auth_bad_user (line 241) | async def test_auth_bad_user(self):
    method test_auth_trust (line 246) | async def test_auth_trust(self):
    method test_auth_reject (line 250) | async def test_auth_reject(self):
    method test_auth_password_cleartext (line 256) | async def test_auth_password_cleartext(self):
    method test_auth_password_cleartext_callable (line 269) | async def test_auth_password_cleartext_callable(self):
    method test_auth_password_cleartext_callable_coroutine (line 288) | async def test_auth_password_cleartext_callable_coroutine(self):
    method test_auth_password_cleartext_callable_awaitable (line 307) | async def test_auth_password_cleartext_callable_awaitable(self):
    method test_auth_password_md5 (line 326) | async def test_auth_password_md5(self):
    method test_auth_password_scram_sha_256 (line 337) | async def test_auth_password_scram_sha_256(self):
    method test_auth_md5_unsupported (line 385) | async def test_auth_md5_unsupported(self, _):
  class TestGssAuthentication (line 397) | class TestGssAuthentication(BaseTestAuthentication):
    method setUpClass (line 399) | def setUpClass(cls):
    method get_server_settings (line 424) | def get_server_settings(cls):
    method setup_cluster (line 430) | def setup_cluster(cls):
    method test_auth_gssapi_ok (line 435) | async def test_auth_gssapi_ok(self):
    method test_auth_gssapi_bad_srvname (line 439) | async def test_auth_gssapi_bad_srvname(self):
    method test_auth_gssapi_bad_user (line 447) | async def test_auth_gssapi_bad_user(self):
  class TestSspiAuthentication (line 457) | class TestSspiAuthentication(BaseTestAuthentication):
    method setUpClass (line 459) | def setUpClass(cls):
    method test_auth_sspi (line 467) | async def test_auth_sspi(self):
  class TestConnectParams (line 479) | class TestConnectParams(tb.TestCase):
    method environ (line 1109) | def environ(self, **kwargs):
    method run_testcase (line 1131) | def run_testcase(self, testcase):
    method test_test_connect_params_environ (line 1213) | def test_test_connect_params_environ(self):
    method test_test_connect_params_run_testcase (line 1240) | def test_test_connect_params_run_testcase(self):
    method test_connect_params (line 1255) | def test_connect_params(self):
    method test_connect_connection_service_file (line 1259) | def test_connect_connection_service_file(self):
    method test_connect_pgpass_regular (line 1364) | def test_connect_pgpass_regular(self):
    method test_connect_pgpass_badness_mode (line 1538) | def test_connect_pgpass_badness_mode(self):
    method test_connect_pgpass_badness_non_file (line 1562) | def test_connect_pgpass_badness_non_file(self):
    method test_connect_pgpass_nonexistent (line 1583) | def test_connect_pgpass_nonexistent(self):
    method test_connect_pgpass_inaccessible_file (line 1601) | def test_connect_pgpass_inaccessible_file(self):
    method test_connect_pgpass_inaccessible_directory (line 1622) | def test_connect_pgpass_inaccessible_directory(self):
    method test_connect_args_validation (line 1646) | async def test_connect_args_validation(self):
  class TestConnection (line 1659) | class TestConnection(tb.ConnectedTestCase):
    method test_connection_isinstance (line 1661) | async def test_connection_isinstance(self):
    method test_connection_use_after_close (line 1666) | async def test_connection_use_after_close(self):
    method test_connection_ssl_to_no_ssl_server (line 1698) | async def test_connection_ssl_to_no_ssl_server(self):
    method test_connection_sslmode_no_ssl_server (line 1709) | async def test_connection_sslmode_no_ssl_server(self):
    method test_connection_implicit_host (line 1747) | async def test_connection_implicit_host(self):
    method test_connection_no_home_dir (line 1756) | async def test_connection_no_home_dir(self):
  class BaseTestSSLConnection (line 1796) | class BaseTestSSLConnection(tb.ConnectedTestCase):
    method get_server_settings (line 1798) | def get_server_settings(cls):
    method setup_cluster (line 1813) | def setup_cluster(cls):
    method setUp (line 1818) | def setUp(self):
    method tearDown (line 1835) | def tearDown(self):
    method _add_hba_entry (line 1847) | def _add_hba_entry(self):
  class TestSSLConnection (line 1852) | class TestSSLConnection(BaseTestSSLConnection):
    method _add_hba_entry (line 1853) | def _add_hba_entry(self):
    method test_ssl_connection_custom_context (line 1864) | async def test_ssl_connection_custom_context(self):
    method test_ssl_connection_sslmode (line 1883) | async def test_ssl_connection_sslmode(self):
    method test_ssl_connection_default_context (line 1943) | async def test_ssl_connection_default_context(self):
    method test_ssl_connection_pool (line 1956) | async def test_ssl_connection_pool(self):
    method test_executemany_uvloop_ssl_issue_700 (line 1981) | async def test_executemany_uvloop_ssl_issue_700(self):
    method test_tls_version (line 2005) | async def test_tls_version(self):
  class TestClientSSLConnection (line 2058) | class TestClientSSLConnection(BaseTestSSLConnection):
    method _add_hba_entry (line 2059) | def _add_hba_entry(self):
    method test_ssl_connection_client_auth_fails_with_wrong_setup (line 2070) | async def test_ssl_connection_client_auth_fails_with_wrong_setup(self):
    method _test_works (line 2086) | async def _test_works(self, **conn_args):
    method test_ssl_connection_client_auth_custom_context (line 2094) | async def test_ssl_connection_client_auth_custom_context(self):
    method test_ssl_connection_client_auth_dsn (line 2111) | async def test_ssl_connection_client_auth_dsn(self):
    method test_ssl_connection_client_auth_env (line 2128) | async def test_ssl_connection_client_auth_env(self):
    method test_ssl_connection_client_auth_dot_postgresql (line 2142) | async def test_ssl_connection_client_auth_dot_postgresql(self):
  class TestNoSSLConnection (line 2151) | class TestNoSSLConnection(BaseTestSSLConnection):
    method _add_hba_entry (line 2152) | def _add_hba_entry(self):
    method test_nossl_connection_sslmode (line 2163) | async def test_nossl_connection_sslmode(self):
    method test_nossl_connection_prefer_cancel (line 2205) | async def test_nossl_connection_prefer_cancel(self):
    method test_nossl_connection_pool (line 2219) | async def test_nossl_connection_pool(self):
  class TestConnectionGC (line 2243) | class TestConnectionGC(tb.ClusterTestCase):
    method _run_no_explicit_close_test (line 2245) | async def _run_no_explicit_close_test(self):
    method test_no_explicit_close_no_debug (line 2268) | async def test_no_explicit_close_no_debug(self):
    method test_no_explicit_close_with_debug (line 2279) | async def test_no_explicit_close_with_debug(self):
  class TestConnectionAttributes (line 2294) | class TestConnectionAttributes(tb.HotStandbyTestCase):
    method _run_connection_test (line 2296) | async def _run_connection_test(
    method test_target_server_attribute_port (line 2303) | async def test_target_server_attribute_port(self):
    method test_target_attribute_not_matched (line 2327) | async def test_target_attribute_not_matched(self):
    method test_prefer_standby_when_standby_is_up (line 2348) | async def test_prefer_standby_when_standby_is_up(self):
    method test_prefer_standby_picks_master_when_standby_is_down (line 2355) | async def test_prefer_standby_picks_master_when_standby_is_down(self):
  function _get_connected_host (line 2375) | def _get_connected_host(con):

FILE: tests/test_copy.py
  class TestCopyFrom (line 19) | class TestCopyFrom(tb.ConnectedTestCase):
    method test_copy_from_table_basics (line 21) | async def test_copy_from_table_basics(self):
    method test_copy_from_table_large_rows (line 85) | async def test_copy_from_table_large_rows(self):
    method test_copy_from_query_basics (line 120) | async def test_copy_from_query_basics(self):
    method test_copy_from_query_with_args (line 146) | async def test_copy_from_query_with_args(self):
    method test_copy_from_query_to_path (line 171) | async def test_copy_from_query_to_path(self):
    method test_copy_from_query_to_path_like (line 193) | async def test_copy_from_query_to_path_like(self):
    method test_copy_from_query_to_bad_output (line 223) | async def test_copy_from_query_to_bad_output(self):
    method test_copy_from_query_to_sink (line 234) | async def test_copy_from_query_to_sink(self):
    method test_copy_from_query_cancellation_explicit (line 261) | async def test_copy_from_query_cancellation_explicit(self):
    method test_copy_from_query_cancellation_on_sink_error (line 283) | async def test_copy_from_query_cancellation_on_sink_error(self):
    method test_copy_from_query_cancellation_while_waiting_for_data (line 302) | async def test_copy_from_query_cancellation_while_waiting_for_data(self):
    method test_copy_from_query_timeout_1 (line 322) | async def test_copy_from_query_timeout_1(self):
    method test_copy_from_query_timeout_2 (line 340) | async def test_copy_from_query_timeout_2(self):
  class TestCopyTo (line 364) | class TestCopyTo(tb.ConnectedTestCase):
    method test_copy_to_table_basics (line 366) | async def test_copy_to_table_basics(self):
    method test_copy_to_table_large_rows (line 462) | async def test_copy_to_table_large_rows(self):
    method test_copy_to_table_from_bytes_like (line 489) | async def test_copy_to_table_from_bytes_like(self):
    method test_copy_to_table_fail_in_source_1 (line 501) | async def test_copy_to_table_fail_in_source_1(self):
    method test_copy_to_table_fail_in_source_2 (line 526) | async def test_copy_to_table_fail_in_source_2(self):
    method test_copy_to_table_timeout (line 555) | async def test_copy_to_table_timeout(self):
    method test_copy_to_table_from_file_path (line 584) | async def test_copy_to_table_from_file_path(self):
    method test_copy_records_to_table_1 (line 626) | async def test_copy_records_to_table_1(self):
    method test_copy_records_to_table_where (line 650) | async def test_copy_records_to_table_where(self):
    method test_copy_records_to_table_async (line 679) | async def test_copy_records_to_table_async(self):
    method test_copy_records_to_table_no_binary_codec (line 703) | async def test_copy_records_to_table_no_binary_codec(self):

FILE: tests/test_cursor.py
  class TestIterableCursor (line 14) | class TestIterableCursor(tb.ConnectedTestCase):
    method test_cursor_iterable_01 (line 16) | async def test_cursor_iterable_01(self):
    method test_cursor_iterable_02 (line 31) | async def test_cursor_iterable_02(self):
    method test_cursor_iterable_03 (line 51) | async def test_cursor_iterable_03(self):
    method test_cursor_iterable_04 (line 65) | async def test_cursor_iterable_04(self):
    method test_cursor_iterable_05 (line 74) | async def test_cursor_iterable_05(self):
    method test_cursor_iterable_06 (line 83) | async def test_cursor_iterable_06(self):
  class TestCursor (line 104) | class TestCursor(tb.ConnectedTestCase):
    method test_cursor_01 (line 106) | async def test_cursor_01(self):
    method test_cursor_02 (line 112) | async def test_cursor_02(self):
    method test_cursor_03 (line 150) | async def test_cursor_03(self):
    method test_cursor_04 (line 157) | async def test_cursor_04(self):

FILE: tests/test_exceptions.py
  class TestExceptions (line 12) | class TestExceptions(tb.ConnectedTestCase):
    method test_exceptions_exported (line 14) | def test_exceptions_exported(self):
    method test_exceptions_unpacking (line 25) | async def test_exceptions_unpacking(self):
    method test_exceptions_str (line 36) | async def test_exceptions_str(self):

FILE: tests/test_execute.py
  class TestExecuteScript (line 15) | class TestExecuteScript(tb.ConnectedTestCase):
    method test_execute_script_1 (line 17) | async def test_execute_script_1(self):
    method test_execute_script_2 (line 29) | async def test_execute_script_2(self):
    method test_execute_script_3 (line 43) | async def test_execute_script_3(self):
    method test_execute_script_check_transactionality (line 52) | async def test_execute_script_check_transactionality(self):
    method test_execute_exceptions_1 (line 66) | async def test_execute_exceptions_1(self):
    method test_execute_script_interrupted_close (line 72) | async def test_execute_script_interrupted_close(self):
    method test_execute_script_interrupted_terminate (line 85) | async def test_execute_script_interrupted_terminate(self):
  class TestExecuteMany (line 102) | class TestExecuteMany(tb.ConnectedTestCase):
    method setUp (line 103) | def setUp(self):
    method tearDown (line 108) | def tearDown(self):
    method test_executemany_basic (line 112) | async def test_executemany_basic(self):
    method test_executemany_returning (line 142) | async def test_executemany_returning(self):
    method test_executemany_bad_input (line 181) | async def test_executemany_bad_input(self):
    method test_executemany_error_in_input_gen (line 200) | async def test_executemany_error_in_input_gen(self):
    method test_executemany_server_failure (line 215) | async def test_executemany_server_failure(self):
    method test_executemany_server_failure_after_writes (line 225) | async def test_executemany_server_failure_after_writes(self):
    method test_executemany_server_failure_during_writes (line 235) | async def test_executemany_server_failure_during_writes(self):
    method test_executemany_client_failure_after_writes (line 256) | async def test_executemany_client_failure_after_writes(self):
    method test_executemany_timeout (line 264) | async def test_executemany_timeout(self):
    method test_executemany_timeout_flow_control (line 272) | async def test_executemany_timeout_flow_control(self):
    method test_executemany_client_failure_in_transaction (line 304) | async def test_executemany_client_failure_in_transaction(self):
    method test_executemany_client_server_failure_conflict (line 319) | async def test_executemany_client_server_failure_conflict(self):
    method test_executemany_prepare (line 328) | async def test_executemany_prepare(self):

FILE: tests/test_introspection.py
  class SlowIntrospectionConnection (line 18) | class SlowIntrospectionConnection(apg_con.Connection):
    method _introspect_types (line 22) | async def _introspect_types(self, *args, **kwargs):
  class TestIntrospection (line 28) | class TestIntrospection(tb.ConnectedTestCase):
    method setUpClass (line 30) | def setUpClass(cls):
    method tearDownClass (line 37) | def tearDownClass(cls):
    method get_server_settings (line 47) | def get_server_settings(cls):
    method setUp (line 52) | def setUp(self):
    method _add_custom_codec (line 56) | async def _add_custom_codec(self, conn):
    method test_introspection_on_large_db (line 67) | async def test_introspection_on_large_db(self):
    method test_introspection_no_stmt_cache_01 (line 82) | async def test_introspection_no_stmt_cache_01(self):
    method test_introspection_no_stmt_cache_02 (line 103) | async def test_introspection_no_stmt_cache_02(self):
    method test_introspection_no_stmt_cache_03 (line 125) | async def test_introspection_no_stmt_cache_03(self):
    method test_introspection_sticks_for_ps (line 135) | async def test_introspection_sticks_for_ps(self):
    method test_introspection_retries_after_cache_bust (line 160) | async def test_introspection_retries_after_cache_bust(self):
    method test_introspection_loads_basetypes_of_domains (line 201) | async def test_introspection_loads_basetypes_of_domains(self):

FILE: tests/test_listeners.py
  class TestListeners (line 17) | class TestListeners(tb.ClusterTestCase):
    method test_listen_01 (line 19) | async def test_listen_01(self):
    method test_listen_02 (line 72) | async def test_listen_02(self):
    method test_listen_notletters (line 90) | async def test_listen_notletters(self):
    method test_dangling_listener_warns (line 108) | async def test_dangling_listener_warns(self):
  class TestLogListeners (line 121) | class TestLogListeners(tb.ConnectedTestCase):
    method test_log_listener_01 (line 126) | async def test_log_listener_01(self):
    method test_log_listener_02 (line 230) | async def test_log_listener_02(self):
    method test_log_listener_03 (line 271) | async def test_log_listener_03(self):
    method test_dangling_log_listener_warns (line 301) | async def test_dangling_log_listener_warns(self):
  class TestConnectionTerminationListener (line 318) | class TestConnectionTerminationListener(tb.ProxiedClusterTestCase):
    method test_connection_termination_callback_called_on_remote (line 320) | async def test_connection_termination_callback_called_on_remote(self):
    method test_connection_termination_callback_called_on_local (line 344) | async def test_connection_termination_callback_called_on_local(self):

FILE: tests/test_logging.py
  class LogCollector (line 7) | class LogCollector:
    method __init__ (line 8) | def __init__(self):
    method __call__ (line 11) | def __call__(self, record):
  class TestQueryLogging (line 15) | class TestQueryLogging(tb.ConnectedTestCase):
    method test_logging_context (line 17) | async def test_logging_context(self):
    method test_error_logging (line 40) | async def test_error_logging(self):

FILE: tests/test_pool.py
  class SlowResetConnection (line 30) | class SlowResetConnection(pg_connection.Connection):
    method reset (line 32) | async def reset(self, *, timeout=None):
  class SlowCancelConnection (line 37) | class SlowCancelConnection(pg_connection.Connection):
    method _cancel (line 39) | async def _cancel(self, waiter):
  class TestPool (line 44) | class TestPool(tb.ConnectedTestCase):
    method test_pool_01 (line 46) | async def test_pool_01(self):
    method test_pool_02 (line 61) | async def test_pool_02(self):
    method test_pool_03 (line 75) | async def test_pool_03(self):
    method test_pool_04 (line 86) | async def test_pool_04(self):
    method test_pool_05 (line 109) | async def test_pool_05(self):
    method test_pool_06 (line 123) | async def test_pool_06(self):
    method test_pool_07 (line 137) | async def test_pool_07(self):
    method test_pool_08 (line 197) | async def test_pool_08(self):
    method test_pool_09 (line 205) | async def test_pool_09(self):
    method test_pool_10 (line 223) | async def test_pool_10(self):
    method test_pool_11 (line 233) | async def test_pool_11(self):
    method test_pool_12 (line 290) | async def test_pool_12(self):
    method test_pool_13 (line 300) | async def test_pool_13(self):
    method test_pool_init_run_until_complete (line 314) | def test_pool_init_run_until_complete(self):
    method test_pool_exception_in_setup_and_init (line 319) | async def test_pool_exception_in_setup_and_init(self):
    method test_pool_auth (line 362) | async def test_pool_auth(self):
    method test_pool_handles_task_cancel_in_acquire_with_timeout (line 412) | async def test_pool_handles_task_cancel_in_acquire_with_timeout(self):
    method test_pool_handles_task_cancel_in_release (line 432) | async def test_pool_handles_task_cancel_in_release(self):
    method test_pool_handles_query_cancel_in_release (line 453) | async def test_pool_handles_query_cancel_in_release(self):
    method test_pool_no_acquire_deadlock (line 474) | async def test_pool_no_acquire_deadlock(self):
    method test_pool_config_persistence (line 489) | async def test_pool_config_persistence(self):
    method test_pool_release_in_xact (line 518) | async def test_pool_release_in_xact(self):
    method test_pool_connection_methods (line 547) | async def test_pool_connection_methods(self):
    method test_pool_connection_execute_many (line 598) | async def test_pool_connection_execute_many(self):
    method test_pool_max_inactive_time_01 (line 626) | async def test_pool_max_inactive_time_01(self):
    method test_pool_max_inactive_time_02 (line 645) | async def test_pool_max_inactive_time_02(self):
    method test_pool_max_inactive_time_03 (line 668) | async def test_pool_max_inactive_time_03(self):
    method test_pool_max_inactive_time_04 (line 688) | async def test_pool_max_inactive_time_04(self):
    method test_pool_max_inactive_time_05 (line 719) | async def test_pool_max_inactive_time_05(self):
    method test_pool_handles_inactive_connection_errors (line 737) | async def test_pool_handles_inactive_connection_errors(self):
    method test_pool_size_and_capacity (line 757) | async def test_pool_size_and_capacity(self):
    method test_pool_closing (line 778) | async def test_pool_closing(self):
    method test_pool_handles_transaction_exit_in_asyncgen_1 (line 789) | async def test_pool_handles_transaction_exit_in_asyncgen_1(self):
    method test_pool_handles_transaction_exit_in_asyncgen_2 (line 810) | async def test_pool_handles_transaction_exit_in_asyncgen_2(self):
    method test_pool_handles_asyncgen_finalization (line 834) | async def test_pool_handles_asyncgen_finalization(self):
    method test_pool_close_waits_for_release (line 855) | async def test_pool_close_waits_for_release(self):
    method test_pool_close_timeout (line 878) | async def test_pool_close_timeout(self):
    method test_pool_expire_connections (line 897) | async def test_pool_expire_connections(self):
    method test_pool_set_connection_args (line 910) | async def test_pool_set_connection_args(self):
    method test_pool_init_race (line 953) | async def test_pool_init_race(self):
    method test_pool_init_and_use_race (line 967) | async def test_pool_init_and_use_race(self):
    method test_pool_remote_close (line 982) | async def test_pool_remote_close(self):
  class TestPoolReconnectWithTargetSessionAttrs (line 1009) | class TestPoolReconnectWithTargetSessionAttrs(tb.ClusterTestCase):
    method setup_cluster (line 1012) | def setup_cluster(cls):
    method simulate_cluster_recovery_mode (line 1016) | async def simulate_cluster_recovery_mode(self):
    method test_full_reconnect_on_node_change_role (line 1034) | async def test_full_reconnect_on_node_change_role(self):
  class TestHotStandby (line 1073) | class TestHotStandby(tb.HotStandbyTestCase):
    method create_pool (line 1074) | def create_pool(self, **kwargs):
    method test_standby_pool_01 (line 1079) | async def test_standby_pool_01(self):
    method test_standby_cursors (line 1095) | async def test_standby_cursors(self):

FILE: tests/test_prepare.py
  class TestPrepare (line 17) | class TestPrepare(tb.ConnectedTestCase):
    method test_prepare_01 (line 19) | async def test_prepare_01(self):
    method test_prepare_02 (line 33) | async def test_prepare_02(self):
    method test_prepare_03 (line 37) | async def test_prepare_03(self):
    method test_prepare_04 (line 65) | async def test_prepare_04(self):
    method test_prepare_05_unknownoid (line 83) | async def test_prepare_05_unknownoid(self):
    method test_prepare_06_interrupted_close (line 87) | async def test_prepare_06_interrupted_close(self):
    method test_prepare_07_interrupted_terminate (line 103) | async def test_prepare_07_interrupted_terminate(self):
    method test_prepare_08_big_result (line 120) | async def test_prepare_08_big_result(self):
    method test_prepare_09_raise_error (line 129) | async def test_prepare_09_raise_error(self):
    method test_prepare_10_stmt_lru (line 144) | async def test_prepare_10_stmt_lru(self):
    method test_prepare_11_stmt_gc (line 197) | async def test_prepare_11_stmt_gc(self):
    method test_prepare_12_stmt_gc (line 216) | async def test_prepare_12_stmt_gc(self):
    method test_prepare_13_connect (line 243) | async def test_prepare_13_connect(self):
    method test_prepare_14_explain (line 254) | async def test_prepare_14_explain(self):
    method test_prepare_15_stmt_gc_cache_disabled (line 284) | async def test_prepare_15_stmt_gc_cache_disabled(self):
    method test_prepare_16_command_result (line 314) | async def test_prepare_16_command_result(self):
    method test_prepare_17_stmt_closed_lru (line 341) | async def test_prepare_17_stmt_closed_lru(self):
    method test_prepare_18_empty_result (line 350) | async def test_prepare_18_empty_result(self):
    method test_prepare_19_concurrent_calls (line 361) | async def test_prepare_19_concurrent_calls(self):
    method test_prepare_20_concurrent_calls (line 375) | async def test_prepare_20_concurrent_calls(self):
    method test_prepare_21_errors (line 397) | async def test_prepare_21_errors(self):
    method test_prepare_22_empty (line 405) | async def test_prepare_22_empty(self):
    method test_prepare_statement_invalid (line 415) | async def test_prepare_statement_invalid(self):
    method test_prepare_23_no_stmt_cache_seq (line 434) | async def test_prepare_23_no_stmt_cache_seq(self):
    method test_prepare_24_max_lifetime (line 465) | async def test_prepare_24_max_lifetime(self):
    method test_prepare_25_max_lifetime_reset (line 486) | async def test_prepare_25_max_lifetime_reset(self):
    method test_prepare_26_max_lifetime_max_size (line 502) | async def test_prepare_26_max_lifetime_max_size(self):
    method test_prepare_27_max_cacheable_statement_size (line 518) | async def test_prepare_27_max_cacheable_statement_size(self):
    method test_prepare_28_max_args (line 538) | async def test_prepare_28_max_args(self):
    method test_prepare_29_duplicates (line 548) | async def test_prepare_29_duplicates(self):
    method test_prepare_30_invalid_arg_count (line 561) | async def test_prepare_30_invalid_arg_count(self):
    method test_prepare_31_pgbouncer_note (line 572) | async def test_prepare_31_pgbouncer_note(self):
    method test_prepare_does_not_use_cache (line 597) | async def test_prepare_does_not_use_cache(self):
    method test_prepare_explicitly_named (line 604) | async def test_prepare_explicitly_named(self):
    method test_prepare_fetchmany (line 615) | async def test_prepare_fetchmany(self):

FILE: tests/test_record.py
  class CustomRecord (line 25) | class CustomRecord(asyncpg.Record):
  class AnotherCustomRecord (line 29) | class AnotherCustomRecord(asyncpg.Record):
  class TestRecord (line 33) | class TestRecord(tb.ConnectedTestCase):
    method checkref (line 36) | def checkref(self, *objs):
    method test_record_gc (line 48) | def test_record_gc(self):
    method test_record_freelist_ok (line 73) | def test_record_freelist_ok(self):
    method test_record_len_getindex (line 78) | def test_record_len_getindex(self):
    method test_record_slice (line 104) | def test_record_slice(self):
    method test_record_immutable (line 113) | def test_record_immutable(self):
    method test_record_repr (line 118) | def test_record_repr(self):
    method test_record_iter (line 144) | def test_record_iter(self):
    method test_record_values (line 150) | def test_record_values(self):
    method test_record_keys (line 157) | def test_record_keys(self):
    method test_record_items (line 163) | def test_record_items(self):
    method test_record_hash (line 200) | def test_record_hash(self):
    method test_record_contains (line 221) | def test_record_contains(self):
    method test_record_cmp (line 233) | def test_record_cmp(self):
    method test_record_get (line 284) | def test_record_get(self):
    method test_record_not_pickleable (line 291) | def test_record_not_pickleable(self):
    method test_record_empty (line 296) | def test_record_empty(self):
    method test_record_duplicate_colnames (line 311) | async def test_record_duplicate_colnames(self):
    method test_record_isinstance (line 341) | async def test_record_isinstance(self):
    method test_record_no_new (line 346) | async def test_record_no_new(self):
    method test_record_subclass_01 (line 355) | async def test_record_subclass_01(self):
    method test_record_subclass_02 (line 380) | async def test_record_subclass_02(self):
    method test_record_subclass_03 (line 427) | async def test_record_subclass_03(self):
    method test_record_subclass_04 (line 474) | async def test_record_subclass_04(self):
    method test_record_subclass_05 (line 520) | async def test_record_subclass_05(self):
    method test_record_subclass_06 (line 537) | async def test_record_subclass_06(self):

FILE: tests/test_subinterpreters.py
  class TestSubinterpreters (line 17) | class TestSubinterpreters(unittest.TestCase):
    method test_record_module_loads_in_subinterpreter (line 18) | def test_record_module_loads_in_subinterpreter(self) -> None:
    method test_record_module_state_isolation (line 35) | def test_record_module_state_isolation(self) -> None:

FILE: tests/test_test.py
  class BaseSimpleTestCase (line 16) | class BaseSimpleTestCase:
    method test_tests_zero_error (line 18) | async def test_tests_zero_error(self):
  class TestTests (line 23) | class TestTests(unittest.TestCase):
    method test_tests_fail_1 (line 25) | def test_tests_fail_1(self):
  class TestHelpers (line 38) | class TestHelpers(tb.TestCase):
    method test_tests_assertLoopErrorHandlerCalled_01 (line 40) | async def test_tests_assertLoopErrorHandlerCalled_01(self):

FILE: tests/test_timeout.py
  class TestTimeout (line 18) | class TestTimeout(tb.ConnectedTestCase):
    method test_timeout_01 (line 20) | async def test_timeout_01(self):
    method test_timeout_02 (line 28) | async def test_timeout_02(self):
    method test_timeout_03 (line 38) | async def test_timeout_03(self):
    method test_timeout_04 (line 48) | async def test_timeout_04(self):
    method test_timeout_05 (line 65) | async def test_timeout_05(self):
    method test_timeout_06 (line 74) | async def test_timeout_06(self):
    method test_invalid_timeout (line 112) | async def test_invalid_timeout(self):
  class TestConnectionCommandTimeout (line 127) | class TestConnectionCommandTimeout(tb.ConnectedTestCase):
    method test_command_timeout_01 (line 130) | async def test_command_timeout_01(self):
  class SlowPrepareConnection (line 139) | class SlowPrepareConnection(pg_connection.Connection):
    method _get_statement (line 141) | async def _get_statement(self, query, timeout, **kwargs):
  class TestTimeoutCoversPrepare (line 146) | class TestTimeoutCoversPrepare(tb.ConnectedTestCase):
    method test_timeout_covers_prepare_01 (line 150) | async def test_timeout_covers_prepare_01(self):

FILE: tests/test_transaction.py
  class TestTransaction (line 13) | class TestTransaction(tb.ConnectedTestCase):
    method test_transaction_regular (line 15) | async def test_transaction_regular(self):
    method test_transaction_nested (line 47) | async def test_transaction_nested(self):
    method test_transaction_interface_errors (line 113) | async def test_transaction_interface_errors(self):
    method test_transaction_within_manual_transaction (line 162) | async def test_transaction_within_manual_transaction(self):
    method test_isolation_level (line 183) | async def test_isolation_level(self):
    method test_nested_isolation_level (line 214) | async def test_nested_isolation_level(self):

FILE: tests/test_types.py
  class TestTypes (line 13) | class TestTypes(tb.TestCase):
    method test_range_issubset (line 15) | def test_range_issubset(self):

FILE: tests/test_utils.py
  class TestUtils (line 14) | class TestUtils(tb.ConnectedTestCase):
    method test_mogrify_simple (line 16) | async def test_mogrify_simple(self):
    method test_mogrify_multiple (line 32) | async def test_mogrify_multiple(self):

FILE: tools/generate_exceptions.py
  function _get_error_name (line 39) | def _get_error_name(sqlstatename, msgtype, sqlstate):
  function main (line 68) | def main():

FILE: tools/generate_type_map.py
  function runner (line 46) | async def runner(args):
  function main (line 113) | def main():