"""
Patch autodoc in order to use information found by `recover_defined_module`.
"""
- from sphinx.ext.autodoc import Documenter, AttributeDocumenter
+ from sphinx.ext.autodoc import AttributeDocumenter, Documenter
orig_doc_get_real_modname = Documenter.get_real_modname
orig_attr_get_real_modname = AttributeDocumenter.get_real_modname
"""
import re
+
from docutils import nodes, utils
from docutils.parsers.rst import roles
import logging
from . import pq # noqa: F401 import early to stabilize side effects
-from . import types
-from . import postgres
+from . import dbapi20, postgres, types
from ._tpc import Xid
-from .copy import Copy, AsyncCopy
+from .copy import AsyncCopy, Copy
from ._enums import IsolationLevel
from .cursor import Cursor
-from .errors import Warning, Error, InterfaceError, DatabaseError
-from .errors import DataError, OperationalError, IntegrityError
-from .errors import InternalError, ProgrammingError, NotSupportedError
+from .errors import DatabaseError, DataError, Error, IntegrityError, InterfaceError
+from .errors import InternalError, NotSupportedError, OperationalError
+from .errors import ProgrammingError, Warning
from ._column import Column
-from ._pipeline import Pipeline, AsyncPipeline
+from .dbapi20 import BINARY, DATETIME, NUMBER, ROWID, STRING, Binary, Date
+from .dbapi20 import DateFromTicks, Time, TimeFromTicks, Timestamp, TimestampFromTicks
+from .version import __version__ as __version__ # noqa: F401
+from ._pipeline import AsyncPipeline, Pipeline
from .connection import Connection
-from .transaction import Rollback, Transaction, AsyncTransaction
+from .raw_cursor import AsyncRawCursor, AsyncRawServerCursor, RawCursor, RawServerCursor
+from .transaction import AsyncTransaction, Rollback, Transaction
from .cursor_async import AsyncCursor
from ._capabilities import Capabilities, capabilities
-from .server_cursor import AsyncServerCursor, ServerCursor
from .client_cursor import AsyncClientCursor, ClientCursor
-from .raw_cursor import AsyncRawCursor, RawCursor
-from .raw_cursor import AsyncRawServerCursor, RawServerCursor
+from .server_cursor import AsyncServerCursor, ServerCursor
from ._connection_base import BaseConnection, Notify
from ._connection_info import ConnectionInfo
from .connection_async import AsyncConnection
-from . import dbapi20
-from .dbapi20 import BINARY, DATETIME, NUMBER, ROWID, STRING
-from .dbapi20 import Binary, Date, DateFromTicks, Time, TimeFromTicks
-from .dbapi20 import Timestamp, TimestampFromTicks
-
-from .version import __version__ as __version__ # noqa: F401
-
# Set the logger to a quiet default, can be enabled if needed
logger = logging.getLogger("psycopg")
if logger.level == logging.NOTSET:
import queue
import asyncio
import threading
-from typing import Any, Callable, Coroutine, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Coroutine
from ._compat import TypeAlias, TypeVar
from __future__ import annotations
-from typing import Any, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, cast
-from . import pq
from . import errors as e
+from . import pq
from .abc import Dumper, Loader
from ._enums import PyFormat as PyFormat
from ._compat import TypeVar
from __future__ import annotations
-from . import pq
-from . import _cmodule
+from . import _cmodule, pq
from .errors import NotSupportedError
from __future__ import annotations
from types import ModuleType
+
from . import pq
__version__: str | None = None
from __future__ import annotations
-from typing import Any, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Sequence
from operator import attrgetter
if TYPE_CHECKING:
# Copyright (C) 2021 The Psycopg Team
import sys
-from functools import partial
from typing import Any
+from functools import partial
if sys.version_info >= (3, 9):
from asyncio import to_thread
from zoneinfo import ZoneInfo
from functools import cache
- from collections import Counter, deque as Deque
+ from collections import Counter
+ from collections import deque as Deque
from collections.abc import Callable
else:
import asyncio
from typing import Callable, Counter, Deque, TypeVar
from functools import lru_cache
+
from backports.zoneinfo import ZoneInfo
cache = lru_cache(maxsize=None)
if sys.version_info >= (3, 10):
- from typing import TypeGuard, TypeAlias
+ from typing import TypeAlias, TypeGuard
else:
- from typing_extensions import TypeGuard, TypeAlias
+ from typing_extensions import TypeAlias, TypeGuard
if sys.version_info >= (3, 11):
from typing import LiteralString, Self
import sys
import logging
-from typing import Callable, Generic, NamedTuple, TYPE_CHECKING
-from weakref import ref, ReferenceType
+from typing import TYPE_CHECKING, Callable, Generic, NamedTuple
+from weakref import ReferenceType, ref
from warnings import warn
from functools import partial
-from . import pq
from . import errors as e
-from . import postgres
-from . import generators
+from . import generators, postgres, pq
from .abc import PQGen, PQGenConn, Query
-from .sql import Composable, SQL
+from .sql import SQL, Composable
from ._tpc import Xid
from .rows import Row
from .adapt import AdaptersMap
from ._connection_info import ConnectionInfo
if TYPE_CHECKING:
- from .pq.abc import PGconn, PGresult
from psycopg_pool.base import BasePool
+ from .pq.abc import PGconn, PGresult
+
# Row Type variable for Cursor (when it needs to be distinguished from the
# connection's one)
CursorRow = TypeVar("CursorRow")
from . import errors as e
from .abc import ConnDict, ConnMapping
-from ._conninfo_utils import get_param, is_ip_address, get_param_def
-from ._conninfo_utils import split_attempts
-
+from ._conninfo_utils import get_param, get_param_def, is_ip_address, split_attempts
logger = logging.getLogger("psycopg")
from . import errors as e
from .abc import ConnDict, ConnMapping
-from ._conninfo_utils import get_param, is_ip_address, get_param_def
-from ._conninfo_utils import split_attempts
+from ._conninfo_utils import get_param, get_param_def, is_ip_address, split_attempts
if True: # ASYNC:
import asyncio
from ipaddress import ip_address
from dataclasses import dataclass
+from . import errors as e
from . import pq
from .abc import ConnDict, ConnMapping
-from . import errors as e
def split_attempts(params: ConnMapping) -> list[ConnDict]:
from abc import ABC, abstractmethod
from types import TracebackType
-from typing import Any, Iterator, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Iterator, Sequence
-from . import pq
from . import errors as e
+from . import pq
from ._compat import Self
-from ._copy_base import BaseCopy, MAX_BUFFER_SIZE, QUEUE_SIZE, PREFER_FLUSH
-from .generators import copy_to, copy_end
-from ._acompat import spawn, gather, Queue, Worker
+from ._acompat import Queue, Worker, gather, spawn
+from ._copy_base import MAX_BUFFER_SIZE, PREFER_FLUSH, QUEUE_SIZE, BaseCopy
+from .generators import copy_end, copy_to
if TYPE_CHECKING:
from .abc import Buffer
from abc import ABC, abstractmethod
from types import TracebackType
-from typing import Any, AsyncIterator, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, AsyncIterator, Sequence
-from . import pq
from . import errors as e
+from . import pq
from ._compat import Self
-from ._copy_base import BaseCopy, MAX_BUFFER_SIZE, QUEUE_SIZE, PREFER_FLUSH
-from .generators import copy_to, copy_end
-from ._acompat import aspawn, agather, AQueue, AWorker
+from ._acompat import AQueue, AWorker, agather, aspawn
+from ._copy_base import MAX_BUFFER_SIZE, PREFER_FLUSH, QUEUE_SIZE, BaseCopy
+from .generators import copy_end, copy_to
if TYPE_CHECKING:
from .abc import Buffer
import sys
import struct
from abc import ABC, abstractmethod
-from typing import Any, Generic, Match, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic, Match, Sequence
-from . import pq
from . import adapt
from . import errors as e
+from . import pq
from .abc import Buffer, ConnectionType, PQGen, Transformer
from .pq.misc import connection_summary
from ._cmodule import _psycopg
from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Generic, Iterable, NoReturn, Sequence
from functools import partial
-from typing import Any, Generic, Iterable, NoReturn, Sequence
-from typing import TYPE_CHECKING
-from . import pq
from . import adapt
from . import errors as e
-from .abc import ConnectionType, Query, Params, PQGen
+from . import pq
+from .abc import ConnectionType, Params, PQGen, Query
from .rows import Row, RowMaker
-from ._capabilities import capabilities
from ._column import Column
from .pq.misc import connection_summary
-from ._queries import PostgresQuery, PostgresClientQuery
+from ._queries import PostgresClientQuery, PostgresQuery
from ._preparing import Prepare
from .generators import execute, fetch, send
+from ._capabilities import capabilities
if TYPE_CHECKING:
from .abc import Transformer
import re
import warnings
from random import randint
-from typing import Any, DefaultDict, NamedTuple, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, DefaultDict, NamedTuple, Sequence
from collections import defaultdict
try:
- from dns.resolver import Resolver, Cache
- from dns.asyncresolver import Resolver as AsyncResolver
+ from dns.resolver import Cache, Resolver
from dns.exception import DNSException
+ from dns.asyncresolver import Resolver as AsyncResolver
except ImportError:
raise ImportError(
"the module psycopg._dns requires the package 'dnspython' installed"
)
-from . import errors as e
from . import conninfo
+from . import errors as e
if TYPE_CHECKING:
from dns.rdtypes.IN.SRV import SRV
from __future__ import annotations
import re
-import string
import codecs
-from typing import Any, TYPE_CHECKING
+import string
+from typing import TYPE_CHECKING, Any
-from .pq._enums import ConnStatus
from .errors import NotSupportedError
from ._compat import cache
+from .pq._enums import ConnStatus
if TYPE_CHECKING:
from ._connection_base import BaseConnection
import logging
from types import TracebackType
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
-from . import pq
from . import errors as e
+from . import pq
from .abc import PipelineCommand, PQGen
from ._compat import Deque, Self, TypeAlias
from .pq.misc import connection_summary
-from .generators import pipeline_communicate, fetch_many, send
+from .generators import fetch_many, pipeline_communicate, send
from ._capabilities import capabilities
if TYPE_CHECKING:
from .pq.abc import PGresult
- from .connection import Connection
from ._preparing import Key, Prepare # noqa: F401
+ from .connection import Connection
from ._cursor_base import BaseCursor # noqa: F401
from ._connection_base import BaseConnection
from .connection_async import AsyncConnection
from __future__ import annotations
from enum import IntEnum, auto
-from typing import Any, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Sequence
from collections import OrderedDict
from . import pq
from __future__ import annotations
-from typing import Any, Sequence, DefaultDict, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, DefaultDict, Sequence
from collections import defaultdict
-from . import pq
from . import abc
from . import errors as e
-from .abc import Buffer, LoadFunc, AdaptContext, PyFormat, NoneType
+from . import pq
+from .abc import AdaptContext, Buffer, LoadFunc, NoneType, PyFormat
from .rows import Row, RowMaker
from ._oids import INVALID_OID, TEXT_OID
from ._compat import TypeAlias
from __future__ import annotations
import re
-from typing import Any, Callable, Mapping, Match, NamedTuple
-from typing import Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Mapping, Match, NamedTuple, Sequence
from functools import lru_cache
-from . import pq
from . import errors as e
+from . import pq
+from .abc import Buffer, Params, Query
from .sql import Composable
-from .abc import Buffer, Query, Params
from ._enums import PyFormat
from ._compat import TypeAlias, TypeGuard
from ._encodings import conn_encoding
from __future__ import annotations
import struct
-from typing import Callable, cast, Protocol
+from typing import Callable, Protocol, cast
from . import errors as e
from .abc import Buffer
import re
import datetime as dt
-from base64 import b64encode, b64decode
+from base64 import b64decode, b64encode
from dataclasses import dataclass, replace
_re_xid = re.compile(r"^(\d+)_([^_]*)_([^_]*)$")
from __future__ import annotations
-from typing import Any, Iterator, overload, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Iterator, Sequence, overload
-from . import sql
from . import errors as e
+from . import sql
from .abc import AdaptContext, Query
from .rows import dict_row
from ._compat import TypeAlias, TypeVar
if TYPE_CHECKING:
from .connection import Connection
- from .connection_async import AsyncConnection
from ._connection_base import BaseConnection
+ from .connection_async import AsyncConnection
T = TypeVar("T", bound="TypeInfo")
RegistryKey: TypeAlias = "str | int | tuple[type, int]"
from __future__ import annotations
-from typing import Any, Callable, Generator, Mapping
-from typing import Protocol, Sequence, TYPE_CHECKING
-from typing import Dict, Union # drop with Python 3.8
+from typing import TYPE_CHECKING, Any, Callable, Dict # drop with Python 3.8
+from typing import Generator, Mapping, Protocol, Sequence, Union
from . import pq
from ._enums import PyFormat as PyFormat
from . import sql # noqa: F401
from .rows import Row, RowMaker
from .pq.abc import PGresult
- from .waiting import Wait, Ready # noqa: F401
+ from .waiting import Ready, Wait # noqa: F401
from ._adapters_map import AdaptersMap
from ._connection_base import BaseConnection
from __future__ import annotations
from abc import ABC, abstractmethod
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
-from . import pq, abc
+from . import abc, pq
# Objects exported here
from ._enums import PyFormat as PyFormat
from typing import TYPE_CHECKING
from functools import partial
-from ._queries import PostgresQuery, PostgresClientQuery
-
-from . import pq
from . import adapt
from . import errors as e
-from .abc import ConnectionType, Query, Params
+from . import pq
+from .abc import ConnectionType, Params, Query
from .rows import Row
from .cursor import Cursor
+from ._queries import PostgresClientQuery, PostgresQuery
from ._preparing import Prepare
from ._cursor_base import BaseCursor
from .cursor_async import AsyncCursor
if TYPE_CHECKING:
from typing import Any # noqa: F401
+
from .connection import Connection # noqa: F401
from .connection_async import AsyncConnection # noqa: F401
import logging
from time import monotonic
from types import TracebackType
-from typing import Any, Generator, Iterator, cast, overload, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generator, Iterator, cast, overload
+from threading import Lock
from contextlib import contextmanager
-from . import pq
from . import errors as e
-from . import waiting
-from .abc import AdaptContext, ConnDict, ConnParam, Params, PQGen, Query, RV
+from . import pq, waiting
+from .abc import RV, AdaptContext, ConnDict, ConnParam, Params, PQGen, Query
from ._tpc import Xid
-from .rows import Row, RowFactory, tuple_row, args_row
+from .rows import Row, RowFactory, args_row, tuple_row
from .adapt import AdaptersMap
from ._enums import IsolationLevel
+from .cursor import Cursor
from ._compat import Self
-from .conninfo import make_conninfo, conninfo_to_dict
-from .conninfo import conninfo_attempts, timeout_from_conninfo
+from .conninfo import conninfo_attempts, conninfo_to_dict, make_conninfo
+from .conninfo import timeout_from_conninfo
from ._pipeline import Pipeline
from .generators import notifies
from .transaction import Transaction
-from .cursor import Cursor
from ._capabilities import capabilities
from .server_cursor import ServerCursor
from ._connection_base import BaseConnection, CursorRow, Notify
-from threading import Lock
-
if TYPE_CHECKING:
from .pq.abc import PGconn
import logging
from time import monotonic
from types import TracebackType
-from typing import Any, AsyncGenerator, AsyncIterator, cast, overload, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, AsyncGenerator, AsyncIterator, cast, overload
from contextlib import asynccontextmanager
-from . import pq
from . import errors as e
-from . import waiting
-from .abc import AdaptContext, ConnDict, ConnParam, Params, PQGen, Query, RV
+from . import pq, waiting
+from .abc import RV, AdaptContext, ConnDict, ConnParam, Params, PQGen, Query
from ._tpc import Xid
-from .rows import Row, AsyncRowFactory, tuple_row, args_row
+from .rows import AsyncRowFactory, Row, args_row, tuple_row
from .adapt import AdaptersMap
from ._enums import IsolationLevel
from ._compat import Self
-from .conninfo import make_conninfo, conninfo_to_dict
-from .conninfo import conninfo_attempts_async, timeout_from_conninfo
+from .conninfo import conninfo_attempts_async, conninfo_to_dict, make_conninfo
+from .conninfo import timeout_from_conninfo
from ._pipeline import AsyncPipeline
from .generators import notifies
from .transaction import AsyncTransaction
import sys
import asyncio
from asyncio import Lock
+
from ._compat import to_thread
else:
from threading import Lock
import re
-from . import pq
+from . import _conninfo_attempts, _conninfo_attempts_async, _conninfo_utils
from . import errors as e
-from . import _conninfo_utils
-from . import _conninfo_attempts
-from . import _conninfo_attempts_async
-from .abc import ConnParam, ConnDict
+from . import pq
+from .abc import ConnDict, ConnParam
# re-exoprts
conninfo_attempts = _conninfo_attempts.conninfo_attempts
from typing import IO
-from .abc import Buffer
from . import _copy, _copy_async
+from .abc import Buffer
# re-exports
# Copyright (C) 2022 The Psycopg Team
from . import _types
-from .connection import CrdbConnection, AsyncCrdbConnection, CrdbConnectionInfo
+from .connection import AsyncCrdbConnection, CrdbConnection, CrdbConnectionInfo
adapters = _types.adapters # exposed by the package
connect = CrdbConnection.connect
# Copyright (C) 2022 The Psycopg Team
from enum import Enum
-from .._typeinfo import TypeInfo, TypesRegistry
from ..abc import AdaptContext, NoneType
from .._oids import TEXT_OID
from .._typemod import BitTypeModifier, CharTypeModifier, NumericTypeModifier
from .._typemod import TimeTypeModifier
-from .._adapters_map import AdaptersMap
-from ..types.enum import EnumDumper, EnumBinaryDumper
+from .._typeinfo import TypeInfo, TypesRegistry
+from ..types.enum import EnumBinaryDumper, EnumDumper
from ..types.none import NoneDumper
+from .._adapters_map import AdaptersMap
types = TypesRegistry()
def _register_postgres_adapters(context: AdaptContext) -> None:
# Same adapters used by PostgreSQL, or a good starting point for customization
- from ..types import array, bool, composite, datetime
- from ..types import numeric, numpy, string, uuid
+ from ..types import array, bool, composite, datetime, numeric, numpy, string, uuid
array.register_default_adapters(context)
composite.register_default_adapters(context)
from __future__ import annotations
import re
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
from .. import errors as e
from ..rows import Row
+from ._types import adapters
from ..connection import Connection
from .._adapters_map import AdaptersMap
from .._connection_info import ConnectionInfo
from ..connection_async import AsyncConnection
-from ._types import adapters
if TYPE_CHECKING:
from ..pq.abc import PGconn
from __future__ import annotations
from types import TracebackType
-from typing import Any, Iterator, Iterable, TYPE_CHECKING, overload
+from typing import TYPE_CHECKING, Any, Iterable, Iterator, overload
from contextlib import contextmanager
-from . import pq
from . import errors as e
-from .abc import Query, Params
+from . import pq
+from .abc import Params, Query
from .copy import Copy, Writer
-from .rows import Row, RowMaker, RowFactory
+from .rows import Row, RowFactory, RowMaker
from ._compat import Self
from ._pipeline import Pipeline
from ._cursor_base import BaseCursor
from __future__ import annotations
from types import TracebackType
-from typing import Any, AsyncIterator, Iterable, TYPE_CHECKING, overload
+from typing import TYPE_CHECKING, Any, AsyncIterator, Iterable, overload
from contextlib import asynccontextmanager
-from . import pq
from . import errors as e
-from .abc import Query, Params
+from . import pq
+from .abc import Params, Query
from .copy import AsyncCopy, AsyncWriter
-from .rows import Row, RowMaker, AsyncRowFactory
+from .rows import AsyncRowFactory, Row, RowMaker
from ._compat import Self
from ._pipeline import Pipeline
from ._cursor_base import BaseCursor
from . import _oids
from .abc import AdaptContext, Buffer
-from .types.string import BytesDumper, BytesBinaryDumper
+from .types.string import BytesBinaryDumper, BytesDumper
class DBAPITypeObject:
from __future__ import annotations
-from dataclasses import dataclass, field, fields
-from typing import Any, Callable, NoReturn, Sequence, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, NoReturn, Sequence
from asyncio import CancelledError
+from dataclasses import dataclass, field, fields
from .pq.abc import PGconn, PGresult
-from .pq._enums import ConnStatus, DiagnosticField, PipelineStatus, TransactionStatus
from ._compat import TypeAlias, TypeGuard
+from .pq._enums import ConnStatus, DiagnosticField, PipelineStatus, TransactionStatus
if TYPE_CHECKING:
- from .pq.misc import PGnotify, ConninfoOption
+ from .pq.misc import ConninfoOption, PGnotify
ErrorInfo: TypeAlias = "PGresult | dict[int, bytes | None] | None"
import logging
from time import monotonic
-from . import pq
from . import errors as e
+from . import pq
from .abc import Buffer, PipelineCommand, PQGen, PQGenConn
from .pq.abc import PGcancelConn, PGconn, PGresult
-from .waiting import Wait, Ready
from ._compat import Deque
+from .waiting import Ready, Wait
from ._cmodule import _psycopg
from ._encodings import conninfo_encoding
def register_default_adapters(context: AdaptContext) -> None:
- from .types import array, bool, composite, datetime, enum, json, multirange
- from .types import net, none, numeric, numpy, range, string, uuid
+ from .types import array, bool, composite, datetime, enum, json, multirange, net
+ from .types import none, numeric, numpy, range, string, uuid
array.register_default_adapters(context)
composite.register_default_adapters(context)
from typing import Callable
from . import abc
-from .misc import ConninfoOption, PGnotify, PGresAttDesc
-from .misc import error_message, version_pretty
-from ._enums import ConnStatus, DiagnosticField, ExecStatus, Format, Trace
-from ._enums import Ping, PipelineStatus, PollingStatus, TransactionStatus
+from .misc import ConninfoOption, PGnotify, PGresAttDesc, error_message, version_pretty
+from ._enums import ConnStatus, DiagnosticField, ExecStatus, Format, Ping
+from ._enums import PipelineStatus, PollingStatus, Trace, TransactionStatus
logger = logging.getLogger(__name__)
import logging
from typing import Any, Callable
from functools import wraps
-from .._compat import Self, TypeVar
-from . import abc
-from . import PGconn
+from . import PGconn, abc
from .misc import connection_summary
+from .._compat import Self, TypeVar
Func = TypeVar("Func", bound=Callable[..., Any])
import sys
import ctypes
import ctypes.util
-from ctypes import Structure, CFUNCTYPE, POINTER
-from ctypes import c_char, c_char_p, c_int, c_size_t, c_ubyte, c_uint, c_void_p
+from ctypes import CFUNCTYPE, POINTER, Structure, c_char, c_char_p, c_int, c_size_t
+from ctypes import c_ubyte, c_uint, c_void_p
from typing import Any, NoReturn
from .misc import find_libpq_full_path, version_pretty
# Copyright (C) 2020 The Psycopg Team
+from ctypes import Array, _Pointer, c_char, c_char_p, c_int, c_ubyte, c_uint, c_ulong
+from ctypes import pointer
from typing import Any, Callable, Sequence
-from ctypes import Array, pointer, _Pointer
-from ctypes import c_char, c_char_p, c_int, c_ubyte, c_uint, c_ulong
class FILE: ...
from __future__ import annotations
-from typing import Any, Callable, Protocol, Sequence, TYPE_CHECKING
from typing import Union # drop with Python 3.8
+from typing import TYPE_CHECKING, Any, Callable, Protocol, Sequence
from ._enums import Format, Trace
from .._compat import Self, TypeAlias
if TYPE_CHECKING:
- from .misc import PGnotify, ConninfoOption, PGresAttDesc
+ from .misc import ConninfoOption, PGnotify, PGresAttDesc
# An object implementing the buffer protocol (ish)
Buffer: TypeAlias = Union[bytes, bytearray, memoryview]
from __future__ import annotations
-import re
import os
+import re
import sys
import logging
import ctypes.util
from pathlib import Path
from . import abc
-from ._enums import ConnStatus, TransactionStatus, PipelineStatus
+from ._enums import ConnStatus, PipelineStatus, TransactionStatus
from .._compat import cache
logger = logging.getLogger("psycopg.pq")
import sys
import logging
from os import getpid
+from ctypes import POINTER, Array, addressof, byref, c_char_p, c_int, c_size_t, c_ulong
+from ctypes import c_void_p, cast, create_string_buffer, py_object, string_at
+from typing import TYPE_CHECKING, Any, Callable, Sequence
+from typing import cast as t_cast
from weakref import ref
-from ctypes import Array, POINTER, cast, string_at, create_string_buffer, byref
-from ctypes import addressof, c_char_p, c_int, c_size_t, c_ulong, c_void_p, py_object
-from typing import Any, Callable, Sequence
-from typing import cast as t_cast, TYPE_CHECKING
-
-from .. import errors as e
-from .._encodings import pg2pyenc
from . import _pq_ctypes as impl
-from .misc import PGnotify, ConninfoOption, PGresAttDesc
-from .misc import connection_summary, _clean_error_message
+from .. import errors as e
+from .misc import ConninfoOption, PGnotify, PGresAttDesc, _clean_error_message
+from .misc import connection_summary
from ._enums import ConnStatus, ExecStatus, Format, Trace
# Imported locally to call them from __del__ methods
-from ._pq_ctypes import PQclear, PQfinish, PQfreeCancel, PQcancelFinish, PQstatus
+from ._pq_ctypes import PQcancelFinish, PQclear, PQfinish, PQfreeCancel, PQstatus
+from .._encodings import pg2pyenc
if TYPE_CHECKING:
from . import abc
from __future__ import annotations
from typing import TYPE_CHECKING
-from .abc import ConnectionType, Query, Params
+
+from .abc import ConnectionType, Params, Query
from .sql import Composable
from .rows import Row
from ._enums import PyFormat
from .cursor import Cursor
-from .cursor_async import AsyncCursor
-from .server_cursor import ServerCursor, AsyncServerCursor
from ._queries import PostgresQuery
from ._cursor_base import BaseCursor
+from .cursor_async import AsyncCursor
+from .server_cursor import AsyncServerCursor, ServerCursor
if TYPE_CHECKING:
from typing import Any # noqa: F401
+
from .connection import Connection # noqa: F401
from .connection_async import AsyncConnection # noqa: F401
from __future__ import annotations
import functools
-from typing import Any, Callable, NamedTuple, NoReturn
-from typing import TYPE_CHECKING, Protocol, Sequence
-from typing import Dict, Tuple # drop with Python 3.8
+from typing import TYPE_CHECKING, Any, Callable, Dict # drop with Python 3.8
+from typing import NamedTuple, NoReturn, Protocol, Sequence, Tuple
from collections import namedtuple
-from . import pq
from . import errors as e
+from . import pq
from ._compat import TypeAlias, TypeVar
from ._encodings import _as_python_identifier
if TYPE_CHECKING:
+ from psycopg.pq.abc import PGresult
+
from .cursor import Cursor
from ._cursor_base import BaseCursor
from .cursor_async import AsyncCursor
- from psycopg.pq.abc import PGresult
COMMAND_OK = pq.ExecStatus.COMMAND_OK
TUPLES_OK = pq.ExecStatus.TUPLES_OK
from __future__ import annotations
-from typing import Any, AsyncIterator, Iterable, Iterator, TYPE_CHECKING, overload
+from typing import TYPE_CHECKING, Any, AsyncIterator, Iterable, Iterator, overload
from warnings import warn
-from . import pq
-from . import sql
from . import errors as e
-from .abc import ConnectionType, Query, Params, PQGen
-from .rows import Row, RowFactory, AsyncRowFactory
+from . import pq, sql
+from .abc import ConnectionType, Params, PQGen, Query
+from .rows import AsyncRowFactory, Row, RowFactory
from .cursor import Cursor
from ._compat import Self
from .generators import execute
import codecs
import string
from abc import ABC, abstractmethod
-from typing import Any, Iterator, Iterable, Sequence
+from typing import Any, Iterable, Iterator, Sequence
from .pq import Escaping
from .abc import AdaptContext
from __future__ import annotations
import logging
-
from types import TracebackType
-from typing import Any, Generic, Iterator, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic, Iterator
-from . import pq
-from . import sql
from . import errors as e
+from . import pq, sql
from .abc import ConnectionType, PQGen
from ._compat import Self
from .pq.misc import connection_summary
import re
import struct
from math import prod
-from typing import Any, cast, Callable, Pattern
+from typing import Any, Callable, Pattern, cast
-from .. import pq
from .. import errors as e
-from .. import postgres
-from ..abc import AdaptContext, Buffer, Dumper, DumperKey, NoneType, Loader, Transformer
-from ..adapt import RecursiveDumper, RecursiveLoader, PyFormat
-from .._oids import TEXT_OID, INVALID_OID, TEXT_ARRAY_OID
+from .. import postgres, pq
+from ..abc import AdaptContext, Buffer, Dumper, DumperKey, Loader, NoneType, Transformer
+from .._oids import INVALID_OID, TEXT_ARRAY_OID, TEXT_OID
+from ..adapt import PyFormat, RecursiveDumper, RecursiveLoader
from .._compat import cache
from .._struct import pack_len, unpack_len
from .._cmodule import _psycopg
import re
import struct
+from typing import TYPE_CHECKING, Any, Callable, Iterator, NamedTuple, Sequence, cast
from collections import namedtuple
-from typing import Any, Callable, cast, Iterator
-from typing import NamedTuple, Sequence, TYPE_CHECKING
-
-from .. import pq
-from .. import abc
-from .. import sql
-from .. import postgres
-from ..adapt import Transformer, PyFormat, RecursiveDumper, Loader, Dumper, Buffer
+
+from .. import abc, postgres, pq, sql
from .._oids import TEXT_OID
+from ..adapt import Buffer, Dumper, Loader, PyFormat, RecursiveDumper, Transformer
from .._compat import cache
from .._struct import pack_len, unpack_len
from .._typeinfo import TypeInfo
import re
import struct
+from typing import TYPE_CHECKING, Any, Callable, cast
from datetime import date, datetime, time, timedelta, timezone
-from typing import Any, Callable, cast, TYPE_CHECKING
from .. import _oids
from ..pq import Format
from .._tz import get_tzinfo
from ..abc import AdaptContext, DumperKey
from ..adapt import Buffer, Dumper, Loader, PyFormat
-from ..errors import InterfaceError, DataError
+from ..errors import DataError, InterfaceError
from .._struct import pack_int4, pack_int8, unpack_int4, unpack_int8
if TYPE_CHECKING:
from __future__ import annotations
from enum import Enum
-from typing import Any, Generic, Mapping, Sequence, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic, Mapping, Sequence, cast
-from .. import sql
-from .. import postgres
from .. import errors as e
+from .. import postgres, sql
from ..pq import Format
from ..abc import AdaptContext, Query
from ..adapt import Buffer, Dumper, Loader
-from .._compat import cache, TypeAlias, TypeVar
-from .._encodings import conn_encoding
+from .._compat import TypeAlias, TypeVar, cache
from .._typeinfo import TypeInfo
+from .._encodings import conn_encoding
if TYPE_CHECKING:
from .._connection_base import BaseConnection
from .. import errors as e
from .. import postgres
-from ..abc import Buffer, AdaptContext
+from ..abc import AdaptContext, Buffer
from .._oids import TEXT_OID
from ..adapt import PyFormat, RecursiveDumper, RecursiveLoader
-from .._compat import cache, TypeAlias
+from .._compat import TypeAlias, cache
from .._typeinfo import TypeInfo
_re_escape = re.compile(r'(["\\])')
import json
from typing import Any, Callable
-from .. import abc
-from .. import _oids
+from .. import _oids, abc
from .. import errors as e
from ..pq import Format
-from ..adapt import Buffer, Dumper, Loader, PyFormat, AdaptersMap
+from ..adapt import AdaptersMap, Buffer, Dumper, Loader, PyFormat
from ..errors import DataError
-from .._compat import cache, TypeAlias
+from .._compat import TypeAlias, cache
JsonDumpsFunction: TypeAlias = Callable[[Any], "str | bytes"]
JsonLoadsFunction: TypeAlias = Callable[["str | bytes"], Any]
from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Generic, Iterable, MutableSequence, overload
from decimal import Decimal
-from typing import Any, Generic, Iterable, MutableSequence, overload, TYPE_CHECKING
from datetime import date, datetime
-from .. import sql
from .. import _oids
from .. import errors as e
-from .. import postgres
+from .. import postgres, sql
from ..pq import Format
from ..abc import AdaptContext, Buffer, Dumper, DumperKey, Query
-from ..adapt import RecursiveDumper, RecursiveLoader, PyFormat
+from .range import Range, T, dump_range_binary, dump_range_text, fail_dump
+from .range import load_range_binary, load_range_text
from .._oids import INVALID_OID, TEXT_OID
+from ..adapt import PyFormat, RecursiveDumper, RecursiveLoader
from .._compat import cache
from .._struct import pack_len, unpack_len
from .._typeinfo import TypeInfo, TypesRegistry
-from .range import Range, T, load_range_text, load_range_binary
-from .range import dump_range_text, dump_range_binary, fail_dump
-
if TYPE_CHECKING:
from .._connection_base import BaseConnection
from __future__ import annotations
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
from .. import _oids
from ..pq import Format
global IPv4Network, IPv6Network
if ip_address is None:
- from ipaddress import ip_address, ip_interface, ip_network
- from ipaddress import IPv4Address, IPv6Address
- from ipaddress import IPv4Interface, IPv6Interface
- from ipaddress import IPv4Network, IPv6Network
+ from ipaddress import IPv4Address, IPv4Interface, IPv4Network, IPv6Address
+ from ipaddress import IPv6Interface, IPv6Network, ip_address, ip_interface
+ from ipaddress import ip_network
class InterfaceDumper(Dumper):
from __future__ import annotations
-from ..abc import AdaptContext, NoneType, Buffer
+from ..abc import AdaptContext, Buffer, NoneType
from ..adapt import Dumper
import struct
from abc import ABC, abstractmethod
from math import log
-from typing import Any, Callable, DefaultDict, cast, TYPE_CHECKING
-from decimal import Decimal, DefaultContext, Context
+from typing import TYPE_CHECKING, Any, Callable, DefaultDict, cast
+from decimal import Context, Decimal, DefaultContext
from .. import _oids
from .. import errors as e
from ..pq import Format
from ..abc import AdaptContext
from ..adapt import Buffer, Dumper, Loader, PyFormat
-from .._struct import pack_int2, pack_uint2, unpack_int2
-from .._struct import pack_int4, pack_uint4, unpack_int4, unpack_uint4
-from .._struct import pack_int8, unpack_int8
-from .._struct import pack_float4, pack_float8, unpack_float4, unpack_float8
+from .._struct import pack_float4, pack_float8, pack_int2, pack_int4, pack_int8
+from .._struct import pack_uint2, pack_uint4, unpack_float4, unpack_float8, unpack_int2
+from .._struct import unpack_int4, unpack_int8, unpack_uint4
# Exposed here
-from .._wrappers import (
- Int2 as Int2,
- Int4 as Int4,
- Int8 as Int8,
- IntNumeric as IntNumeric,
- Oid as Oid,
- Float4 as Float4,
- Float8 as Float8,
-)
+from .._wrappers import Float4 as Float4
+from .._wrappers import Float8 as Float8
+from .._wrappers import Int2 as Int2
+from .._wrappers import Int4 as Int4
+from .._wrappers import Int8 as Int8
+from .._wrappers import IntNumeric as IntNumeric
+from .._wrappers import Oid as Oid
if TYPE_CHECKING:
import numpy
from .. import _oids
from ..pq import Format
from ..abc import AdaptContext, Buffer
-from .._struct import pack_int2, pack_int4, pack_int8
-
-from .bool import BoolDumper, BoolBinaryDumper
+from .bool import BoolBinaryDumper, BoolDumper
+from .numeric import Float4BinaryDumper, Float4Dumper, FloatBinaryDumper, FloatDumper
from .numeric import _IntDumper, dump_int_to_numeric_binary
-from .numeric import FloatDumper, Float4Dumper, FloatBinaryDumper, Float4BinaryDumper
+from .._struct import pack_int2, pack_int4, pack_int8
class NPInt16Dumper(_IntDumper):
from __future__ import annotations
import re
-from typing import Any, Generic, cast, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Generic, cast
from decimal import Decimal
from datetime import date, datetime
-from .. import sql
from .. import _oids
from .. import errors as e
-from .. import postgres
+from .. import postgres, sql
from ..pq import Format
from ..abc import AdaptContext, Buffer, Dumper, DumperKey, DumpFunc, LoadFunc, Query
-from ..adapt import RecursiveDumper, RecursiveLoader, PyFormat
from .._oids import INVALID_OID, TEXT_OID
-from .._compat import cache, TypeVar
+from ..adapt import PyFormat, RecursiveDumper, RecursiveLoader
+from .._compat import TypeVar, cache
from .._struct import pack_len, unpack_len
from .._typeinfo import TypeInfo, TypesRegistry
from __future__ import annotations
from .. import postgres
+from ..pq import Format
from ..abc import AdaptContext, Buffer
from ..adapt import Dumper, Loader
-from ..pq import Format
from .._compat import cache
from .._typeinfo import TypeInfo
try:
- from shapely.wkb import loads, dumps
+ from shapely.wkb import dumps, loads
from shapely.geometry.base import BaseGeometry
except ImportError:
from typing import TYPE_CHECKING
from .. import _oids
-from ..pq import Format, Escaping
+from ..pq import Escaping, Format
from ..abc import AdaptContext
from ..adapt import Buffer, Dumper, Loader
from ..errors import DataError
from __future__ import annotations
-from typing import Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
from .. import _oids
from ..pq import Format
import select
import logging
import selectors
-from asyncio import get_event_loop, wait_for, Event, TimeoutError
+from asyncio import Event, TimeoutError, get_event_loop, wait_for
from selectors import DefaultSelector
from . import errors as e
from .abc import RV, PQGen, PQGenConn, WaitFunc
-from ._enums import Wait as Wait, Ready as Ready # re-exported
+from ._enums import Ready as Ready
+from ._enums import Wait as Wait # re-exported
from ._cmodule import _psycopg
WAIT_R = Wait.R
from typing import Any, Sequence
-from psycopg import pq, abc, BaseConnection
+from psycopg import BaseConnection, abc, pq
from psycopg.rows import Row, RowMaker
from psycopg.adapt import AdaptersMap, PyFormat
from psycopg.pq.abc import PGcancelConn, PGconn, PGresult
from typing import Any
cimport cython
+from libc.string cimport memchr, memcpy
+from cpython.bytearray cimport PyByteArray_AS_STRING, PyByteArray_FromStringAndSize
+from cpython.bytearray cimport PyByteArray_GET_SIZE, PyByteArray_Resize
-from libc.string cimport memcpy, memchr
-from cpython.bytearray cimport PyByteArray_FromStringAndSize, PyByteArray_Resize
-from cpython.bytearray cimport PyByteArray_GET_SIZE, PyByteArray_AS_STRING
-
-from psycopg_c.pq cimport _buffer_as_string_and_size, Escaping
+from psycopg_c.pq cimport Escaping, _buffer_as_string_and_size
from psycopg import errors as e
# Copyright (C) 2020 The Psycopg Team
+from libc.stdint cimport int32_t, uint16_t, uint32_t
from libc.string cimport memcpy
-from libc.stdint cimport uint16_t, uint32_t, int32_t
-from cpython.bytearray cimport PyByteArray_FromStringAndSize, PyByteArray_Resize
-from cpython.bytearray cimport PyByteArray_AS_STRING, PyByteArray_GET_SIZE
+from cpython.bytearray cimport PyByteArray_AS_STRING, PyByteArray_FromStringAndSize
+from cpython.bytearray cimport PyByteArray_GET_SIZE, PyByteArray_Resize
from cpython.memoryview cimport PyMemoryView_FromObject
-from psycopg_c._psycopg cimport endian
from psycopg_c.pq cimport ViewBuffer
+from psycopg_c._psycopg cimport endian
from psycopg import errors as e
+
cdef int32_t _binary_null = -1
from libc.stdint cimport uint16_t, uint32_t, uint64_t
+
cdef extern from * nogil:
# from https://gist.github.com/panzi/6856583
# Improved in:
from psycopg import errors as e
from psycopg.pq import abc
from psycopg.abc import PipelineCommand, PQGen
-from psycopg._enums import Wait, Ready
+from psycopg._enums import Ready, Wait
from psycopg._compat import Deque
from psycopg._encodings import conninfo_encoding
+
cdef object WAIT_W = Wait.W
cdef object WAIT_R = Wait.R
cdef object WAIT_RW = Wait.RW
# Copyright (C) 2020 The Psycopg Team
cimport cython
-from cpython.ref cimport Py_INCREF, Py_DECREF
+from cpython.ref cimport Py_DECREF, Py_INCREF
from cpython.set cimport PySet_Add, PySet_Contains
from cpython.dict cimport PyDict_GetItem, PyDict_SetItem
-from cpython.list cimport (
- PyList_New, PyList_CheckExact,
- PyList_GET_ITEM, PyList_SET_ITEM, PyList_GET_SIZE)
+from cpython.list cimport PyList_CheckExact, PyList_GET_ITEM, PyList_GET_SIZE
+from cpython.list cimport PyList_New, PyList_SET_ITEM
from cpython.bytes cimport PyBytes_AS_STRING
from cpython.tuple cimport PyTuple_New, PyTuple_SET_ITEM
from cpython.object cimport PyObject, PyObject_CallFunctionObjArgs
# Copyright (C) 2020 The Psycopg Team
+from cpython.mem cimport PyMem_Free, PyMem_Malloc
from libc.string cimport strlen
-from cpython.mem cimport PyMem_Malloc, PyMem_Free
cdef class Escaping:
pid_t getpid()
from libc.stdio cimport fdopen
-from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from cpython.mem cimport PyMem_Free, PyMem_Malloc
from cpython.bytes cimport PyBytes_AsString
from cpython.memoryview cimport PyMemoryView_FromObject
import sys
-from psycopg._encodings import pg2pyenc
-from psycopg.pq import Format as PqFormat, Trace, version_pretty
-from psycopg.pq.misc import PGnotify, connection_summary, _clean_error_message
+from psycopg.pq import Format as PqFormat
+from psycopg.pq import Trace, version_pretty
+from psycopg.pq.misc import PGnotify, _clean_error_message, connection_summary
from psycopg.pq._enums import ExecStatus
+from psycopg._encodings import pg2pyenc
+
from psycopg_c.pq cimport PQBuffer
+
cdef object _check_supported(fname, int pgversion):
if libpq.PG_VERSION_NUM < pgversion:
raise e.NotSupportedError(
# Copyright (C) 2020 The Psycopg Team
cimport cython
-from cpython.mem cimport PyMem_Malloc, PyMem_Free
+from cpython.mem cimport PyMem_Free, PyMem_Malloc
from psycopg.pq.misc import PGresAttDesc
from psycopg.pq._enums import ExecStatus
cimport cython
from cpython.bytes cimport PyBytes_AsStringAndSize
-from cpython.buffer cimport PyObject_CheckBuffer, PyBUF_SIMPLE
-from cpython.buffer cimport PyObject_GetBuffer, PyBuffer_Release
+from cpython.buffer cimport PyBUF_SIMPLE, PyBuffer_Release, PyObject_CheckBuffer
+from cpython.buffer cimport PyObject_GetBuffer
@cython.freelist(32)
import cython
+from cpython.mem cimport PyMem_Free, PyMem_Realloc
+from cpython.ref cimport Py_INCREF
from libc.stdint cimport int32_t, uint32_t
from libc.string cimport memset, strchr
-from cpython.mem cimport PyMem_Realloc, PyMem_Free
-from cpython.ref cimport Py_INCREF
-from cpython.list cimport PyList_New,PyList_Append, PyList_GetSlice
-from cpython.list cimport PyList_GET_ITEM, PyList_SET_ITEM, PyList_GET_SIZE
+from cpython.list cimport PyList_Append, PyList_GET_ITEM, PyList_GET_SIZE
+from cpython.list cimport PyList_GetSlice, PyList_New, PyList_SET_ITEM
from cpython.object cimport PyObject
from psycopg_c.pq cimport _buffer_as_string_and_size
-from psycopg_c.pq.libpq cimport Oid
from psycopg_c._psycopg cimport endian
+from psycopg_c.pq.libpq cimport Oid
from psycopg import errors as e
+
cdef extern from *:
"""
/* Defined in PostgreSQL in src/include/utils/array.h */
# Copyright (C) 2021 The Psycopg Team
+from cpython cimport datetime as cdt
from libc.stdint cimport int64_t
from libc.string cimport memset, strchr
-from cpython cimport datetime as cdt
from cpython.dict cimport PyDict_GetItem
from cpython.object cimport PyObject, PyObject_CallFunctionObjArgs
+
cdef extern from "Python.h":
const char *PyUnicode_AsUTF8AndSize(unicode obj, Py_ssize_t *size) except NULL
object PyTimeZone_FromOffset(object offset)
"""
cdef int *_uspad
-from datetime import date, time, timedelta, datetime, timezone
+from datetime import date, datetime, time, timedelta, timezone
from psycopg_c._psycopg cimport endian
from psycopg import errors as e
from psycopg._compat import ZoneInfo
-
# Initialise the datetime C API
cdt.import_datetime()
# Copyright (C) 2020 The Psycopg Team
cimport cython
-
+from cpython.mem cimport PyMem_Free
from libc.stdint cimport *
from libc.string cimport memcpy, memset, strlen
-from cpython.mem cimport PyMem_Free
from cpython.dict cimport PyDict_GetItem, PyDict_SetItem
-from cpython.long cimport (
- PyLong_FromString, PyLong_FromLong, PyLong_FromLongLong,
- PyLong_FromUnsignedLong, PyLong_AsLongLong)
+from cpython.long cimport PyLong_AsLongLong, PyLong_FromLong, PyLong_FromLongLong
+from cpython.long cimport PyLong_FromString, PyLong_FromUnsignedLong
from cpython.bytes cimport PyBytes_AsStringAndSize
-from cpython.float cimport PyFloat_FromDouble, PyFloat_AsDouble
+from cpython.float cimport PyFloat_AsDouble, PyFloat_FromDouble
from cpython.unicode cimport PyUnicode_DecodeUTF8
import sys
-from decimal import Decimal, Context, DefaultContext
+from decimal import Context, Decimal, DefaultContext
from psycopg_c._psycopg cimport endian
+
from psycopg import errors as e
from psycopg._wrappers import Int2, Int4, Int8, IntNumeric
+
cdef extern from "Python.h":
# work around https://github.com/cython/cython/issues/3909
double PyOS_string_to_double(
# Copyright (C) 2020 The Psycopg Team
cimport cython
-
-from libc.string cimport memcpy, memchr
+from libc.string cimport memchr, memcpy
from cpython.bytes cimport PyBytes_AsString, PyBytes_AsStringAndSize
from cpython.unicode cimport (
PyUnicode_AsEncodedString,
PyUnicode_DecodeUTF8,
)
-from psycopg_c.pq cimport libpq, Escaping, _buffer_as_string_and_size
+from psycopg_c.pq cimport Escaping, _buffer_as_string_and_size, libpq
from psycopg import errors as e
from psycopg._encodings import pg2pyenc
+
cdef extern from "Python.h":
const char *PyUnicode_AsUTF8AndSize(unicode obj, Py_ssize_t *size) except NULL
import os
import sys
import subprocess as sp
-
-from setuptools import setup, Extension
-from distutils.command.build_ext import build_ext
from distutils import log
+from distutils.command.build_ext import build_ext
+
+from setuptools import Extension, setup
# Move to the directory of setup.py: executing this file from another location
# (e.g. from the project root) will fail
# Copyright (C) 2021 The Psycopg Team
from .pool import ConnectionPool
-from .pool_async import AsyncConnectionPool
-from .null_pool import NullConnectionPool
-from .null_pool_async import AsyncNullConnectionPool
from .errors import PoolClosed, PoolTimeout, TooManyRequests
from .version import __version__ as __version__ # noqa: F401
+from .null_pool import NullConnectionPool
+from .pool_async import AsyncConnectionPool
+from .null_pool_async import AsyncNullConnectionPool
__all__ = [
"AsyncConnectionPool",
import asyncio
import logging
import threading
-from typing import Any, Callable, Coroutine, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Coroutine
from ._compat import TypeAlias, TypeVar
import psycopg.errors as e
if sys.version_info >= (3, 9):
- from collections import Counter, deque as Deque
+ from collections import Counter
+ from collections import deque as Deque
else:
from typing import Counter, Deque
from __future__ import annotations
-from typing import Awaitable, Callable, TYPE_CHECKING
from typing import Union # drop with Python 3.8
+from typing import TYPE_CHECKING, Awaitable, Callable
from ._compat import TypeAlias, TypeVar
if TYPE_CHECKING:
from typing import Any # noqa: F401
+
+ from psycopg import AsyncConnection, Connection # noqa: F401
+ from psycopg.rows import TupleRow # noqa: F401
+
from .pool import ConnectionPool # noqa: F401
from .pool_async import AsyncConnectionPool # noqa: F401
- from psycopg import Connection, AsyncConnection # noqa: F401
- from psycopg.rows import TupleRow # noqa: F401
# Connection types to make the pool generic
CT = TypeVar("CT", bound="Connection[Any]", default="Connection[TupleRow]")
from time import monotonic
from random import random
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
from psycopg import errors as e
from psycopg import Connection
from psycopg.pq import TransactionStatus
-from .abc import CT, ConnectionCB, ConnectFailedCB
+from .abc import CT, ConnectFailedCB, ConnectionCB
+from .pool import AddConnection, ConnectionPool
from .errors import PoolTimeout, TooManyRequests
from ._compat import ConnectionTimeout
from ._acompat import Event
from .base_null_pool import _BaseNullConnectionPool
-from .pool import ConnectionPool, AddConnection
logger = logging.getLogger("psycopg.pool")
from psycopg import AsyncConnection
from psycopg.pq import TransactionStatus
-from .abc import ACT, AsyncConnectionCB, AsyncConnectFailedCB
+from .abc import ACT, AsyncConnectFailedCB, AsyncConnectionCB
from .errors import PoolTimeout, TooManyRequests
from ._compat import ConnectionTimeout
from ._acompat import AEvent
+from .pool_async import AddConnection, AsyncConnectionPool
from .base_null_pool import _BaseNullConnectionPool
-from .pool_async import AsyncConnectionPool, AddConnection
logger = logging.getLogger("psycopg.pool")
from abc import ABC, abstractmethod
from time import monotonic
from types import TracebackType
-from typing import Any, Iterator, cast, Generic
+from typing import Any, Generic, Iterator, cast
from weakref import ref
from contextlib import contextmanager
-from psycopg import errors as e
from psycopg import Connection
+from psycopg import errors as e
from psycopg.pq import TransactionStatus
-from .abc import CT, ConnectionCB, ConnectFailedCB
+from .abc import CT, ConnectFailedCB, ConnectionCB
from .base import AttemptWithBackoff, BasePool
+from .sched import Scheduler
from .errors import PoolClosed, PoolTimeout, TooManyRequests
from ._compat import Deque, Self
-from ._acompat import Condition, Event, Lock, Queue, Worker, spawn, gather
-from ._acompat import sleep, current_thread_name
-from .sched import Scheduler
-
+from ._acompat import Condition, Event, Lock, Queue, Worker, current_thread_name
+from ._acompat import gather, sleep, spawn
logger = logging.getLogger("psycopg.pool")
from abc import ABC, abstractmethod
from time import monotonic
from types import TracebackType
-from typing import Any, AsyncIterator, cast, Generic
+from typing import Any, AsyncIterator, Generic, cast
from weakref import ref
from contextlib import asynccontextmanager
-from psycopg import errors as e
from psycopg import AsyncConnection
+from psycopg import errors as e
from psycopg.pq import TransactionStatus
-from .abc import ACT, AsyncConnectionCB, AsyncConnectFailedCB
+from .abc import ACT, AsyncConnectFailedCB, AsyncConnectionCB
from .base import AttemptWithBackoff, BasePool
from .errors import PoolClosed, PoolTimeout, TooManyRequests
from ._compat import Deque, Self
-from ._acompat import ACondition, AEvent, ALock, AQueue, AWorker, aspawn, agather
-from ._acompat import asleep, current_task_name
+from ._acompat import ACondition, AEvent, ALock, AQueue, AWorker, agather, asleep
+from ._acompat import aspawn, current_task_name
from .sched_async import AsyncScheduler
if True: # ASYNC
import logging
from time import monotonic
-from heapq import heappush, heappop
+from heapq import heappop, heappush
from typing import Any, Callable
from ._task import Task
-from ._acompat import Lock, Event
+from ._acompat import Event, Lock
logger = logging.getLogger(__name__)
import logging
from time import monotonic
-from heapq import heappush, heappop
+from heapq import heappop, heappush
from typing import Any, Callable
from ._task import Task
-from ._acompat import ALock, AEvent
+from ._acompat import AEvent, ALock
logger = logging.getLogger(__name__)
from dataclasses import dataclass
import pytest
+
import psycopg
from psycopg.conninfo import conninfo_to_dict
from typing import Any, Match
import pytest
+
import psycopg
from psycopg.rows import RowMaker
import sys
+
import pytest
+
import psycopg
from psycopg import pq
-
# TODOCRDB: is this the expected behaviour?
crdb_skip_external_observer = pytest.mark.crdb(
"skip", reason="deadlock on observer connection"
from __future__ import annotations
from psycopg import pq
-from psycopg.abc import Dumper, Loader, AdaptContext, PyFormat, Buffer
+from psycopg.abc import AdaptContext, Buffer, Dumper, Loader, PyFormat
def f() -> None:
from __future__ import annotations
+import sys
import asyncio
import selectors
-import sys
from typing import Any
import pytest
import pytest
-from psycopg.crdb import adapters, CrdbConnection
-
+from psycopg.crdb import CrdbConnection, adapters
from psycopg.adapt import PyFormat, Transformer
-from psycopg.types.array import ListDumper
from psycopg.postgres import types as builtins
+from psycopg.types.array import ListDumper
-from ..test_adapt import MyStr, make_dumper, make_bin_dumper
-from ..test_adapt import make_loader, make_bin_loader
+from ..test_adapt import MyStr, make_bin_dumper, make_bin_loader, make_dumper
+from ..test_adapt import make_loader
pytestmark = pytest.mark.crdb
from psycopg import errors as e
from psycopg.crdb import CrdbConnection
-from ..acompat import sleep, spawn, gather
+from ..acompat import gather, sleep, spawn
pytestmark = [pytest.mark.crdb]
from psycopg import errors as e
from psycopg.crdb import AsyncCrdbConnection
-from ..acompat import asleep, spawn, gather
+from ..acompat import asleep, gather, spawn
pytestmark = [pytest.mark.crdb]
if True: # ASYNC
# WARNING: this file is auto-generated by 'async_to_sync.py'
# from the original file 'test_copy_async.py'
# DO NOT CHANGE! Change the original file instead.
-import pytest
import string
-from random import randrange, choice
+from random import choice, randrange
from typing import Any # noqa: ignore
-from psycopg import pq, sql, errors as e
+import pytest
+
+from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
from psycopg.types.numeric import Int4
from ..utils import eur
-from .._test_copy import sample_text, sample_binary # noqa
+from .._test_copy import sample_binary # noqa
from .._test_copy import ensure_table, sample_records
from .._test_copy import sample_tabledef as sample_tabledef_pg
+from .._test_copy import sample_text
# CRDB int/serial are int8
sample_tabledef = sample_tabledef_pg.replace("int", "int4").replace("serial", "int4")
-import pytest
import string
-from random import randrange, choice
+from random import choice, randrange
from typing import Any # noqa: ignore
-from psycopg import pq, sql, errors as e
+import pytest
+
+from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
from psycopg.types.numeric import Int4
from ..utils import eur
-from .._test_copy import sample_text, sample_binary # noqa
+from .._test_copy import sample_binary # noqa
from .._test_copy import ensure_table_async, sample_records
from .._test_copy import sample_tabledef as sample_tabledef_pg
+from .._test_copy import sample_text
# CRDB int/serial are int8
sample_tabledef = sample_tabledef_pg.replace("int", "int4").replace("serial", "int4")
from uuid import uuid4
import pytest
-from psycopg import pq, errors as e
+
+from psycopg import errors as e
+from psycopg import pq
from psycopg.rows import namedtuple_row
-from ..acompat import Queue, spawn, gather
+
+from ..acompat import Queue, gather, spawn
pytestmark = [pytest.mark.crdb]
from uuid import uuid4
import pytest
-from psycopg import pq, errors as e
+
+from psycopg import errors as e
+from psycopg import pq
from psycopg.rows import namedtuple_row
-from ..acompat import AQueue, spawn, gather
+
+from ..acompat import AQueue, gather, spawn
pytestmark = [pytest.mark.crdb]
if True: # ASYNC
+import pytest
+
from psycopg.pq import TransactionStatus
from psycopg.crdb import CrdbConnection
-import pytest
-
pytestmark = pytest.mark.crdb("skip")
__version__ = '$Revision: 1.12 $'[11:-2]
__author__ = 'Stuart Bishop <stuart@stuartbishop.net>'
-import unittest
-import time
import sys
+import time
+import unittest
from typing import Any
-
# Revision 1.12 2009/02/06 03:35:11 kf7xm
# Tested okay with Python 3.0, includes last minute patches from Mark H.
#
import pytest
-from .utils import VersionCheck
from psycopg.crdb import CrdbConnection
+from .utils import VersionCheck
+
def pytest_configure(config):
# register libpq marker
import io
import os
import sys
-import pytest
import logging
from contextlib import contextmanager
+import pytest
+
import psycopg
-from psycopg import pq
-from psycopg import sql
-from psycopg.conninfo import conninfo_to_dict, make_conninfo
+from psycopg import pq, sql
from psycopg._compat import cache
+from psycopg.conninfo import conninfo_to_dict, make_conninfo
from psycopg.pq._debug import PGconnDebug
from .utils import check_postgres_version
-import asyncio
import socket
+import asyncio
import pytest
from random import choice, random, randrange
from typing import Any
from decimal import Decimal
-from contextlib import contextmanager, asynccontextmanager
+from contextlib import asynccontextmanager, contextmanager
import pytest
from psycopg import sql
from psycopg.adapt import PyFormat
from psycopg._compat import Deque
-from psycopg.types.range import Range
from psycopg.types.json import Json, Jsonb
+from psycopg.types.range import Range
from psycopg.types.numeric import Int4, Int8
from psycopg.types.multirange import Multirange
self.conn = conn
def check_tpc(self):
- from .fix_crdb import is_crdb, crdb_skip_message
+ from .fix_crdb import crdb_skip_message, is_crdb
if is_crdb(self.conn):
pytest.skip(crdb_skip_message("2-phase commit"))
import psycopg
from psycopg.pq import TransactionStatus
-from psycopg.rows import class_row, Row, TupleRow
+from psycopg.rows import Row, TupleRow, class_row
-from ..utils import assert_type, Counter, set_autocommit
-from ..acompat import Event, spawn, gather, sleep, skip_sync
+from ..utils import Counter, assert_type, set_autocommit
+from ..acompat import Event, gather, skip_sync, sleep, spawn
from .test_pool_common import delay_connection
try:
import psycopg
from psycopg.pq import TransactionStatus
-from psycopg.rows import class_row, Row, TupleRow
+from psycopg.rows import Row, TupleRow, class_row
-from ..utils import assert_type, Counter, set_autocommit
-from ..acompat import AEvent, spawn, gather, asleep, skip_sync
+from ..utils import Counter, assert_type, set_autocommit
+from ..acompat import AEvent, asleep, gather, skip_sync, spawn
from .test_pool_common_async import delay_connection
try:
# These tests relate to AsyncConnectionPool, but are not marked asyncio
# because they rely on the pool initialization outside the asyncio loop.
-import asyncio
import sys
+import asyncio
import pytest
import psycopg
from ..utils import set_autocommit
-from ..acompat import Event, spawn, gather, sleep, is_alive, skip_async, skip_sync
+from ..acompat import Event, gather, is_alive, skip_async, skip_sync, sleep, spawn
try:
import psycopg_pool as pool
import psycopg
from ..utils import set_autocommit
-from ..acompat import AEvent, spawn, gather, asleep, is_alive, skip_async, skip_sync
+from ..acompat import AEvent, asleep, gather, is_alive, skip_async, skip_sync, spawn
try:
import psycopg_pool as pool
import psycopg
from psycopg.pq import TransactionStatus
-from psycopg.rows import class_row, Row, TupleRow
+from psycopg.rows import Row, TupleRow, class_row
from ..utils import assert_type, set_autocommit
-from ..acompat import Event, sleep, spawn, gather, skip_sync
+from ..acompat import Event, gather, skip_sync, sleep, spawn
from .test_pool_common import delay_connection, ensure_waiting
try:
import psycopg
from psycopg.pq import TransactionStatus
-from psycopg.rows import class_row, Row, TupleRow
+from psycopg.rows import Row, TupleRow, class_row
from ..utils import assert_type, set_autocommit
-from ..acompat import AEvent, asleep, spawn, gather, skip_sync
+from ..acompat import AEvent, asleep, gather, skip_sync, spawn
from .test_pool_common_async import delay_connection, ensure_waiting
try:
import pytest
-from ..acompat import spawn, gather, sleep
+from ..acompat import gather, sleep, spawn
try:
from psycopg_pool.sched import Scheduler
import pytest
-from ..acompat import spawn, gather, asleep
+from ..acompat import asleep, gather, spawn
try:
from psycopg_pool.sched_async import AsyncScheduler
from __future__ import annotations
-import contextlib
import os
import sys
import time
import ctypes
import logging
import weakref
-from functools import partial
+import contextlib
from select import select
-from typing import Iterator, TYPE_CHECKING
+from typing import TYPE_CHECKING, Iterator
+from functools import partial
import pytest
import psycopg
-from psycopg import pq
import psycopg.generators
+from psycopg import pq
if TYPE_CHECKING:
from psycopg.pq.abc import PGcancelConn, PGconn
import ctypes
+
import pytest
from psycopg import pq
from argparse import ArgumentParser, Namespace
import psycopg
-from psycopg.abc import Query
from psycopg import sql
+from psycopg.abc import Query
logger = logging.getLogger()
logging.basicConfig(
from random import randrange
from decimal import Decimal
+
import psycopg
from psycopg import sql
from __future__ import annotations
-import argparse
import asyncio
import logging
-from contextlib import contextmanager
-from functools import partial
+import argparse
from typing import Any, Iterator, Sequence
+from functools import partial
+from contextlib import contextmanager
from psycopg import AsyncConnection, Connection
-from psycopg import pq, waiting
from psycopg import errors as e
+from psycopg import pq, waiting
+from psycopg.pq import DiagnosticField, Format
from psycopg.abc import PipelineCommand
-from psycopg.generators import pipeline_communicate
-from psycopg.pq import Format, DiagnosticField
from psycopg._compat import Deque
+from psycopg.generators import pipeline_communicate
psycopg_logger = logging.getLogger("psycopg")
pipeline_logger = logging.getLogger("pipeline")
# mypy: allow-untyped-calls
import time
+import logging
import threading
import psycopg
import psycopg_pool
from psycopg.rows import Row
-import logging
-
def main() -> None:
opt = parse_cmdline()
import pytest
import psycopg
-from psycopg import pq, sql, postgres
from psycopg import errors as e
+from psycopg import postgres, pq, sql
from psycopg.abc import Buffer
-from psycopg.adapt import Transformer, PyFormat, Dumper, Loader
+from psycopg.adapt import Dumper, Loader, PyFormat, Transformer
from psycopg._cmodule import _psycopg
from psycopg.postgres import types as builtins
-from psycopg.types.array import ListDumper, ListBinaryDumper
-from psycopg.types.string import StrDumper, StrBinaryDumper
+from psycopg.types.array import ListBinaryDumper, ListDumper
+from psycopg.types.string import StrBinaryDumper, StrDumper
@pytest.mark.parametrize(
import pytest
-from psycopg import pq, _cmodule
+from psycopg import _cmodule, pq
try:
- from psycopg import Capabilities, capabilities, NotSupportedError
+ from psycopg import Capabilities, NotSupportedError, capabilities
except ImportError:
# Allow to import the module with Psycopg 3.1
pass
import pytest
from psycopg.postgres import types as builtins
-from .fix_crdb import is_crdb, crdb_encoding, skip_crdb
+
+from .fix_crdb import crdb_encoding, is_crdb, skip_crdb
def test_description_attribs(conn):
import queue
import signal
import threading
-import multiprocessing
import subprocess as sp
+import multiprocessing
import pytest
import sys
import time
-import pytest
import logging
import weakref
from typing import Any
+import pytest
+
import psycopg
-from psycopg import pq, errors as e
+from psycopg import errors as e
+from psycopg import pq
from psycopg.rows import tuple_row
from psycopg.conninfo import conninfo_to_dict, timeout_from_conninfo
-from .acompat import is_async, skip_sync, skip_async, sleep
+from .acompat import is_async, skip_async, skip_sync, sleep
+from .test_adapt import make_bin_dumper, make_dumper
from ._test_cursor import my_row_factory
-from ._test_connection import tx_params, tx_params_isolation, tx_values_map
-from ._test_connection import conninfo_params_timeout
from ._test_connection import testctx # noqa: F401 # fixture
-from .test_adapt import make_bin_dumper, make_dumper
+from ._test_connection import conninfo_params_timeout, tx_params, tx_params_isolation
+from ._test_connection import tx_values_map
def test_connect(conn_cls, dsn):
import sys
import time
-import pytest
import logging
import weakref
from typing import Any
+import pytest
+
import psycopg
-from psycopg import pq, errors as e
+from psycopg import errors as e
+from psycopg import pq
from psycopg.rows import tuple_row
from psycopg.conninfo import conninfo_to_dict, timeout_from_conninfo
-from .acompat import is_async, skip_sync, skip_async, asleep
+from .acompat import asleep, is_async, skip_async, skip_sync
+from .test_adapt import make_bin_dumper, make_dumper
from ._test_cursor import my_row_factory
-from ._test_connection import tx_params, tx_params_isolation, tx_values_map
-from ._test_connection import conninfo_params_timeout
from ._test_connection import testctx # noqa: F401 # fixture
-from .test_adapt import make_bin_dumper, make_dumper
+from ._test_connection import conninfo_params_timeout, tx_params, tx_params_isolation
+from ._test_connection import tx_values_map
async def test_connect(aconn_cls, dsn):
import pytest
import psycopg
-from psycopg.conninfo import make_conninfo, conninfo_to_dict
+from psycopg.conninfo import conninfo_to_dict, make_conninfo
from psycopg._encodings import pg2pyenc
from .fix_crdb import crdb_encoding
import pytest
from psycopg import ProgrammingError
-from psycopg.conninfo import make_conninfo, conninfo_to_dict
-from psycopg.conninfo import timeout_from_conninfo, _DEFAULT_CONNECT_TIMEOUT
+from psycopg.conninfo import _DEFAULT_CONNECT_TIMEOUT, conninfo_to_dict, make_conninfo
+from psycopg.conninfo import timeout_from_conninfo
snowman = "\u2603"
import pytest
import psycopg
-from psycopg.conninfo import conninfo_to_dict, conninfo_attempts
+from psycopg.conninfo import conninfo_attempts, conninfo_to_dict
pytestmark = pytest.mark.anyio
import pytest
import psycopg
-from psycopg.conninfo import conninfo_to_dict, conninfo_attempts_async
+from psycopg.conninfo import conninfo_attempts_async, conninfo_to_dict
pytestmark = pytest.mark.anyio
import pytest
import psycopg
-from psycopg import pq, sql, errors as e
+from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.copy import Copy, LibpqWriter, QueuedLibpqWriter
from psycopg.adapt import PyFormat
from psycopg.types import TypeInfo
from psycopg.types.numeric import Int4
from .utils import eur
-from ._test_copy import sample_text, sample_binary, sample_binary_rows # noqa
-from ._test_copy import sample_values, sample_records, sample_tabledef
-from ._test_copy import ensure_table, py_to_raw, special_chars, FileWriter
-from .test_adapt import StrNoneDumper, StrNoneBinaryDumper
+from ._test_copy import sample_binary # noqa
+from ._test_copy import FileWriter, ensure_table, py_to_raw, sample_binary_rows
+from ._test_copy import sample_records, sample_tabledef, sample_text, sample_values
+from ._test_copy import special_chars
+from .test_adapt import StrNoneBinaryDumper, StrNoneDumper
pytestmark = pytest.mark.crdb_skip("copy")
import pytest
import psycopg
-from psycopg import pq, sql, errors as e
+from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.copy import AsyncCopy, AsyncLibpqWriter, AsyncQueuedLibpqWriter
from psycopg.adapt import PyFormat
from psycopg.types import TypeInfo
from .utils import eur
from .acompat import alist
-from ._test_copy import sample_text, sample_binary, sample_binary_rows # noqa
-from ._test_copy import sample_values, sample_records, sample_tabledef
-from ._test_copy import ensure_table_async, py_to_raw, special_chars, AsyncFileWriter
-from .test_adapt import StrNoneDumper, StrNoneBinaryDumper
+from ._test_copy import sample_binary # noqa
+from ._test_copy import AsyncFileWriter, ensure_table_async, py_to_raw
+from ._test_copy import sample_binary_rows, sample_records, sample_tabledef
+from ._test_copy import sample_text, sample_values, special_chars
+from .test_adapt import StrNoneBinaryDumper, StrNoneDumper
pytestmark = pytest.mark.crdb_skip("copy")
"""
import pytest
+
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from psycopg.adapt import PyFormat
"""
import pytest
+
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from psycopg.adapt import PyFormat
import datetime as dt
import pytest
+
import psycopg
from psycopg import rows
import datetime as dt
import pytest
+
import psycopg
from psycopg import rows
import weakref
import datetime as dt
from typing import Any
-from packaging.version import parse as ver
import pytest
+from packaging.version import parse as ver
import psycopg
-from psycopg import pq, sql, rows
+from psycopg import pq, rows, sql
from psycopg.adapt import PyFormat
from psycopg.types import TypeInfo
from .utils import raiseif
from .acompat import closing
from .fix_crdb import crdb_encoding
-from ._test_cursor import my_row_factory, ph
-from ._test_cursor import execmany, _execmany # noqa: F401
+from ._test_cursor import _execmany, execmany, my_row_factory, ph # noqa: F401
execmany = execmany # avoid F811 underneath
import weakref
import datetime as dt
from typing import Any
-from packaging.version import parse as ver
import pytest
+from packaging.version import parse as ver
import psycopg
-from psycopg import pq, sql, rows
+from psycopg import pq, rows, sql
from psycopg.adapt import PyFormat
from psycopg.types import TypeInfo
from .utils import raiseif
from .acompat import aclosing, alist, anext
from .fix_crdb import crdb_encoding
-from ._test_cursor import my_row_factory, ph
-from ._test_cursor import execmany, _execmany # noqa: F401
+from ._test_cursor import _execmany, execmany, my_row_factory, ph # noqa: F401
execmany = execmany # avoid F811 underneath
# from the original file 'test_cursor_raw_async.py'
# DO NOT CHANGE! Change the original file instead.
import pytest
+
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from psycopg.adapt import PyFormat
from ._test_cursor import ph
import pytest
+
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from psycopg.adapt import PyFormat
from ._test_cursor import ph
from packaging.version import parse as ver
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from ._test_cursor import ph
from packaging.version import parse as ver
import psycopg
-from psycopg import pq, rows, errors as e
+from psycopg import errors as e
+from psycopg import pq, rows
from .acompat import alist
from ._test_cursor import ph
-
pytestmark = pytest.mark.crdb_skip("server-side cursor")
cursor_classes = [psycopg.AsyncServerCursor]
def get_fake_srv_function(monkeypatch):
import_dnspython()
+ from dns.exception import DNSException
from dns.rdtypes.IN.A import A
from dns.rdtypes.IN.SRV import SRV
- from dns.exception import DNSException
fake_hosts = {
("_pg._tcp.dot.com", "SRV"): ["0 0 5432 ."],
import codecs
+
import pytest
import psycopg
import pytest
import psycopg
-from psycopg import pq
from psycopg import errors as e
+from psycopg import pq
from .utils import eur
from .fix_crdb import is_crdb
import time
-from collections import deque
from functools import partial
+from collections import deque
import pytest
import psycopg
-from psycopg import waiting
-from psycopg import pq
+from psycopg import pq, waiting
from psycopg.conninfo import conninfo_to_dict, make_conninfo
import subprocess as sp
import pytest
+
import psycopg
pytest.importorskip("gevent")
from time import time
import pytest
+
from psycopg import Notify
-from .acompat import Event, sleep, gather, spawn
+from .acompat import Event, gather, sleep, spawn
pytestmark = pytest.mark.crdb_skip("notify")
from time import time
import pytest
+
from psycopg import Notify
from .acompat import AEvent, alist, asleep, gather, spawn
import pytest
import psycopg
-from psycopg import pq
from psycopg import errors as e
+from psycopg import pq
from .acompat import is_async
import pytest
import psycopg
-from psycopg import pq
from psycopg import errors as e
+from psycopg import pq
-from .acompat import is_async, anext
+from .acompat import anext, is_async
pytestmark = [
pytest.mark.pipeline,
from __future__ import annotations
-import pytest
import datetime as dt
from typing import Any
+import pytest
+
import psycopg
from psycopg.conninfo import conninfo_to_dict
-from . import dbapi20
-from . import dbapi20_tpc
+from . import dbapi20, dbapi20_tpc
@pytest.fixture(scope="class")
import psycopg
from psycopg import pq
-from psycopg.adapt import Transformer, PyFormat
+from psycopg.adapt import PyFormat, Transformer
from psycopg._queries import PostgresQuery, _split_query
import pytest
-from psycopg import pq, sql, ProgrammingError
+from psycopg import ProgrammingError, pq, sql
from psycopg.adapt import PyFormat
-from psycopg._encodings import py2pgenc
from psycopg.types import TypeInfo
+from psycopg._encodings import py2pgenc
from psycopg.types.string import StrDumper
from .utils import eur
import pytest
from psycopg import Rollback
-from psycopg import pq, errors as e
+from psycopg import errors as e
+from psycopg import pq
-from ._test_transaction import in_transaction, insert_row, inserted, get_exc_info
-from ._test_transaction import ExpectedException, crdb_skip_external_observer
from ._test_transaction import create_test_table # noqa # autouse fixture
+from ._test_transaction import ExpectedException, crdb_skip_external_observer
+from ._test_transaction import get_exc_info, in_transaction, insert_row, inserted
@pytest.fixture
import pytest
from psycopg import Rollback
-from psycopg import pq, errors as e
+from psycopg import errors as e
+from psycopg import pq
-from ._test_transaction import in_transaction, insert_row, inserted, get_exc_info
-from ._test_transaction import ExpectedException, crdb_skip_external_observer
from ._test_transaction import create_test_table # noqa # autouse fixture
+from ._test_transaction import ExpectedException, crdb_skip_external_observer
+from ._test_transaction import get_exc_info, in_transaction, insert_row, inserted
@pytest.fixture
from psycopg import sql
from psycopg.pq import TransactionStatus
from psycopg.types import TypeInfo
-from psycopg.types.composite import CompositeInfo
from psycopg.types.enum import EnumInfo
-from psycopg.types.multirange import MultirangeInfo
from psycopg.types.range import RangeInfo
+from psycopg.types.composite import CompositeInfo
+from psycopg.types.multirange import MultirangeInfo
from .fix_crdb import crdb_encoding
import pytest
import psycopg
-from psycopg import waiting
-from psycopg import generators
+from psycopg import generators, waiting
from psycopg.pq import ConnStatus, ExecStatus
skip_if_not_linux = pytest.mark.skipif(
-import pytest
-import asyncio
import sys
+import asyncio
+
+import pytest
from psycopg.errors import InterfaceError
import psycopg
import psycopg.types.numeric
-from psycopg import pq
-from psycopg import sql
-from psycopg.adapt import PyFormat, Transformer, Dumper
+from psycopg import pq, sql
+from psycopg.adapt import Dumper, PyFormat, Transformer
from psycopg.types import TypeInfo
from psycopg.postgres import types as builtins
from psycopg.types.array import register_array
-from ..test_adapt import StrNoneDumper, StrNoneBinaryDumper
+from ..test_adapt import StrNoneBinaryDumper, StrNoneDumper
tests_str = [
([[[[[["a"]]]]]], "{{{{{{a}}}}}}"),
import pytest
-from psycopg import pq
-from psycopg import sql
-from psycopg.adapt import Transformer, PyFormat
+from psycopg import pq, sql
+from psycopg.adapt import PyFormat, Transformer
from psycopg.postgres import types as builtins
import pytest
-from psycopg import pq, postgres, sql
+from psycopg import postgres, pq, sql
from psycopg.adapt import PyFormat
from psycopg.postgres import types as builtins
from psycopg.types.range import Range
-from psycopg.types.composite import CompositeInfo, register_composite
-from psycopg.types.composite import TupleDumper, TupleBinaryDumper
+from psycopg.types.composite import CompositeInfo, TupleBinaryDumper, TupleDumper
+from psycopg.types.composite import register_composite
from ..utils import eur
-from ..fix_crdb import is_crdb, crdb_skip_message
-from ..test_adapt import StrNoneDumper, StrNoneBinaryDumper
-
+from ..fix_crdb import crdb_skip_message, is_crdb
+from ..test_adapt import StrNoneBinaryDumper, StrNoneDumper
pytestmark = pytest.mark.crdb_skip("composite")
# NOTE: this is an example in the docs. Make sure it doesn't regress when
# adding binary datetime adapters
from datetime import date
- from psycopg.types.datetime import DateLoader, DateDumper
+
+ from psycopg.types.datetime import DateDumper, DateLoader
class InfDateDumper(DateDumper):
def dump(self, obj):
import pytest
-from psycopg import pq, sql, errors as e
+from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
from psycopg.types import TypeInfo
from psycopg.types.enum import EnumInfo, register_enum
import pytest
import psycopg.types
-from psycopg import pq
-from psycopg import sql
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
from psycopg.types.json import set_json_dumps, set_json_loads
from psycopg import pq, sql
from psycopg.adapt import PyFormat
-from psycopg.types.range import Range
from psycopg.types import multirange
-from psycopg.types.multirange import Multirange, MultirangeInfo
-from psycopg.types.multirange import register_multirange
+from psycopg.types.range import Range
+from psycopg.types.multirange import Multirange, MultirangeInfo, register_multirange
from ..utils import eur
from .test_range import create_test_range
-from ..test_adapt import StrNoneDumper, StrNoneBinaryDumper
+from ..test_adapt import StrNoneBinaryDumper, StrNoneDumper
pytestmark = [
pytest.mark.pg(">= 14"),
import pytest
-from psycopg import pq
-from psycopg import sql
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
crdb_skip_inet = pytest.mark.crdb_skip("inet")
from psycopg import sql
-from psycopg.adapt import Transformer, PyFormat
+from psycopg.adapt import PyFormat, Transformer
def test_quote_none(conn):
from __future__ import annotations
import enum
-from math import isnan, isinf, exp
+from math import exp, isinf, isnan
from decimal import Decimal
import pytest
import psycopg
-from psycopg import pq
-from psycopg import sql
+from psycopg import pq, sql
from psycopg.abc import Buffer
-from psycopg.adapt import Transformer, PyFormat
-from psycopg.types.numeric import Int8, Int8Dumper, Int8BinaryDumper, FloatLoader
+from psycopg.adapt import PyFormat, Transformer
+from psycopg.types.numeric import FloatLoader, Int8, Int8BinaryDumper, Int8Dumper
from ..fix_crdb import is_crdb
import pytest
from packaging.version import parse as ver # noqa: F401 # used in skipif
-from psycopg.adapt import PyFormat
from psycopg.pq import Format
+from psycopg.adapt import PyFormat
try:
import numpy as np
from psycopg.types.range import Range, RangeInfo, register_range
from ..utils import eur
-from ..fix_crdb import is_crdb, crdb_skip_message
-from ..test_adapt import StrNoneDumper, StrNoneBinaryDumper
+from ..fix_crdb import crdb_skip_message, is_crdb
+from ..test_adapt import StrNoneBinaryDumper, StrNoneDumper
pytestmark = pytest.mark.crdb_skip("range")
import psycopg
from psycopg.pq import Format
-from psycopg.types import TypeInfo
from psycopg.adapt import PyFormat
+from psycopg.types import TypeInfo
pytest.importorskip("shapely")
-from shapely.geometry import Point, Polygon, MultiPolygon # noqa: E402
+from shapely.geometry import MultiPolygon, Point, Polygon # noqa: E402
+
from psycopg.types.shapely import register_shapely # noqa: E402
pytestmark = [
import pytest
import psycopg
-from psycopg import pq
-from psycopg import sql
+from psycopg import Binary
from psycopg import errors as e
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
-from psycopg import Binary
from ..utils import eur
from ..fix_crdb import crdb_encoding, crdb_scs_off
import sys
-from uuid import UUID
import subprocess as sp
+from uuid import UUID
import pytest
-from psycopg import pq
-from psycopg import sql
+from psycopg import pq, sql
from psycopg.adapt import PyFormat
from __future__ import annotations
-from dataclasses import dataclass
from typing import Any, Callable, Sequence
+from dataclasses import dataclass
-from psycopg import Connection, Cursor, ServerCursor, connect, rows
-from psycopg import AsyncConnection, AsyncCursor, AsyncServerCursor
+from psycopg import AsyncConnection, AsyncCursor, AsyncServerCursor, Connection, Cursor
+from psycopg import ServerCursor, connect, rows
def int_row_factory(
from typing import Callable
from contextlib import contextmanager
-
if sys.version_info >= (3, 9):
import collections
from __future__ import annotations
import os
-from concurrent.futures import ProcessPoolExecutor
import sys
import logging
import subprocess as sp
from typing import Any, Literal
from pathlib import Path
from argparse import ArgumentParser, Namespace, RawDescriptionHelpFormatter
+from concurrent.futures import ProcessPoolExecutor
from importlib.metadata import version
import ast_comments as ast # type: ignore
import sys
import logging
-import requests
from pathlib import Path
+
+import requests
from ruamel.yaml import YAML # pip install ruamel.yaml
logger = logging.getLogger()
import re
import sys
import logging
-from urllib.request import urlopen
from collections import defaultdict, namedtuple
+from urllib.request import urlopen
from psycopg.errors import get_base_exception
import psycopg
from psycopg.pq import version_pretty
-from psycopg.rows import TupleRow
from psycopg.crdb import CrdbConnection
+from psycopg.rows import TupleRow
from psycopg._compat import TypeAlias
Connection: TypeAlias = psycopg.Connection[TupleRow]
projects / thirdparty / psycopg.git / commitdiff
