psycopg 3.3.4__tar.gz → 3.3.6__tar.gz

{psycopg-3.3.4 → psycopg-3.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psycopg
-Version: 3.3.4
+Version: 3.3.6
 Summary: PostgreSQL database adapter for Python
 Author-email: Daniele Varrazzo <daniele.varrazzo@gmail.com>
 License-Expression: LGPL-3.0-only
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Database
@@ -33,14 +34,14 @@ License-File: LICENSE.txt
 Requires-Dist: typing-extensions>=4.6; python_version < "3.13"
 Requires-Dist: tzdata; sys_platform == "win32"
 Provides-Extra: c
-Requires-Dist: psycopg-c==3.3.4; implementation_name != "pypy" and extra == "c"
+Requires-Dist: psycopg-c==3.3.6; implementation_name != "pypy" and extra == "c"
 Provides-Extra: binary
-Requires-Dist: psycopg-binary==3.3.4; implementation_name != "pypy" and extra == "binary"
+Requires-Dist: psycopg-binary==3.3.6; implementation_name != "pypy" and extra == "binary"
 Provides-Extra: pool
 Requires-Dist: psycopg-pool; extra == "pool"
 Provides-Extra: test
 Requires-Dist: anyio>=4.0; extra == "test"
-Requires-Dist: mypy>=1.19.0; implementation_name != "pypy" and extra == "test"
+Requires-Dist: mypy>=2.1.0; implementation_name != "pypy" and extra == "test"
 Requires-Dist: pproxy>=2.7; extra == "test"
 Requires-Dist: pytest>=6.2.5; extra == "test"
 Requires-Dist: pytest-cov>=3.0; extra == "test"
@@ -49,12 +50,12 @@ Provides-Extra: dev
 Requires-Dist: ast-comments>=1.1.2; extra == "dev"
 Requires-Dist: black>=26.1.0; extra == "dev"
 Requires-Dist: codespell>=2.2; extra == "dev"
-Requires-Dist: cython-lint>=0.16; extra == "dev"
+Requires-Dist: cython-lint>=0.21; extra == "dev"
 Requires-Dist: dnspython>=2.1; extra == "dev"
 Requires-Dist: flake8>=4.0; extra == "dev"
 Requires-Dist: isort[colors]>=6.0; extra == "dev"
-Requires-Dist: isort-psycopg; extra == "dev"
-Requires-Dist: mypy>=1.19.0; extra == "dev"
+Requires-Dist: isort-psycopg>=0.0.3; extra == "dev"
+Requires-Dist: mypy>=2.1.0; extra == "dev"
 Requires-Dist: pre-commit>=4.0.1; extra == "dev"
 Requires-Dist: types-setuptools>=57.4; extra == "dev"
 Requires-Dist: types-shapely>=2.0; extra == "dev"

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_adapters_map.py

@@ -48,7 +48,7 @@ class AdaptersMap:
     already created are not affected if a wider scope (e.g. the global one) is
     changed.
 
-    The connections adapters are initialised using a global `!AdptersMap`
+    The connections adapters are initialised using a global `!AdaptersMap`
     template, exposed as `psycopg.adapters`: changing such mapping allows to
     customise the type mapping for every connections created afterwards.
 

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_compat.py

@@ -33,24 +33,27 @@ else:
 if sys.version_info >= (3, 14):
     from string.templatelib import Interpolation, Template
 else:
+    from typing import Generic, Literal
     from dataclasses import dataclass
 
+    T = TypeVar("T")
+
     class Template:
         strings: tuple[str]
-        interpolations: tuple[Interpolation]
+        interpolations: tuple[Interpolation[Any]]
 
-        def __new__(cls, *args: str | Interpolation) -> Self:
+        def __new__(cls, *args: str | Interpolation[Any]) -> Self:
             return cls()
 
-        def __iter__(self) -> Iterator[str | Interpolation]:
+        def __iter__(self) -> Iterator[str | Interpolation[Any]]:
             return
             yield
 
     @dataclass
-    class Interpolation:
-        value: Any
+    class Interpolation(Generic[T]):
+        value: T
         expression: str
-        conversion: str | None
+        conversion: Literal["a", "r", "s"] | None
         format_spec: str
 
 

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_connection_base.py

@@ -314,10 +314,10 @@ class BaseConnection(Generic[Row]):
             )
         return True
 
-    def _cancel_gen(self, *, timeout: float) -> PQGenConn[None]:
+    def _cancel_gen(self) -> PQGenConn[None]:
         cancel_conn = self.pgconn.cancel_conn()
         cancel_conn.start()
-        yield from generators.cancel(cancel_conn, timeout=timeout)
+        yield from generators.cancel(cancel_conn)
 
     def add_notice_handler(self, callback: NoticeHandler) -> None:
         """
@@ -434,11 +434,9 @@ class BaseConnection(Generic[Row]):
     # should have a lock and hold it before calling and consuming them.
 
     @classmethod
-    def _connect_gen(
-        cls, conninfo: str = "", *, timeout: float = 0.0
-    ) -> PQGenConn[Self]:
+    def _connect_gen(cls, conninfo: str = "") -> PQGenConn[Self]:
         """Generator to connect to the database and create a new instance."""
-        pgconn = yield from generators.connect(conninfo, timeout=timeout)
+        pgconn = yield from generators.connect(conninfo)
         conn = cls(pgconn)
         return conn
 
@@ -477,7 +475,13 @@ class BaseConnection(Generic[Row]):
         else:
             self.pgconn.send_query_params(command, None, result_format=result_format)
 
-        result: PGresult = (yield from generators.execute(self.pgconn))[-1]
+        results: list[PGresult] = (yield from generators.execute(self.pgconn))
+        if len(results) != 1:
+            raise e.InternalError(
+                f"received {len(results)} results from command {command.decode()!r}"
+            )
+
+        result = results[0]
         if result.status != COMMAND_OK and result.status != TUPLES_OK:
             if result.status == FATAL_ERROR:
                 raise e.error_from_result(result, encoding=self.pgconn._encoding)
@@ -514,7 +518,10 @@ class BaseConnection(Generic[Row]):
 
         self.pgconn.send_close_prepared(name)
 
-        result = (yield from generators.execute(self.pgconn))[-1]
+        if not (results := (yield from generators.execute(self.pgconn))):
+            raise e.InternalError("no result from deallocate command")
+
+        result = results[-1]
         if result.status != COMMAND_OK:
             if result.status == FATAL_ERROR:
                 raise e.error_from_result(result, encoding=self.pgconn._encoding)

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_copy_base.py

@@ -350,6 +350,8 @@ def _format_row_binary(row: Sequence[Any], tx: Transformer, out: bytearray) -> N
 def _parse_row_text(data: Buffer, tx: Transformer) -> tuple[Any, ...]:
     if not isinstance(data, bytes):
         data = bytes(data)
+    if not data.endswith(b"\n"):
+        raise e.DataError("bad copy data: field delimiter not found")
     fields = data.split(b"\t")
     fields[-1] = fields[-1][:-1]  # drop \n
     row = [None if f == b"\\N" else _load_re.sub(_load_sub, f) for f in fields]
@@ -358,12 +360,19 @@ def _parse_row_text(data: Buffer, tx: Transformer) -> tuple[Any, ...]:
 
 def _parse_row_binary(data: Buffer, tx: Transformer) -> tuple[Any, ...]:
     row: list[Buffer | None] = []
+    len_data = len(data)
+    if len_data < 2:
+        raise e.DataError("bad copy data: fields number truncated")
     nfields = _unpack_int2(data, 0)[0]
     pos = 2
     for i in range(nfields):
+        if pos + 4 > len_data:
+            raise e.DataError("bad copy data: field length truncated")
         length = _unpack_int4(data, pos)[0]
         pos += 4
         if length >= 0:
+            if pos + length > len_data:
+                raise e.DataError("bad copy data: length exceeding data")
             row.append(data[pos : pos + length])
             pos += length
         else:

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_encodings.py

@@ -13,70 +13,69 @@ from typing import TYPE_CHECKING, Any
 from functools import cache
 
 from .errors import NotSupportedError
-from .pq._enums import ConnStatus
 
 if TYPE_CHECKING:
     from ._connection_base import BaseConnection
 
-OK = ConnStatus.OK
-
-
-_py_codecs = {
-    "BIG5": "big5",
-    "EUC_CN": "gb2312",
-    "EUC_JIS_2004": "euc_jis_2004",
-    "EUC_JP": "euc_jp",
-    "EUC_KR": "euc_kr",
-    # "EUC_TW": not available in Python
-    "GB18030": "gb18030",
-    "GBK": "gbk",
-    "ISO_8859_5": "iso8859-5",
-    "ISO_8859_6": "iso8859-6",
-    "ISO_8859_7": "iso8859-7",
-    "ISO_8859_8": "iso8859-8",
-    "JOHAB": "johab",
-    "KOI8R": "koi8-r",
-    "KOI8U": "koi8-u",
-    "LATIN1": "iso8859-1",
-    "LATIN10": "iso8859-16",
-    "LATIN2": "iso8859-2",
-    "LATIN3": "iso8859-3",
-    "LATIN4": "iso8859-4",
-    "LATIN5": "iso8859-9",
-    "LATIN6": "iso8859-10",
-    "LATIN7": "iso8859-13",
-    "LATIN8": "iso8859-14",
-    "LATIN9": "iso8859-15",
-    # "MULE_INTERNAL": not available in Python
-    "SHIFT_JIS_2004": "shift_jis_2004",
-    "SJIS": "shift_jis",
+# From: https://www.postgresql.org/docs/current/multibyte.html#CHARSET-TABLE
+_py_codecs = (
+    (("BIG5", "WIN950", "Windows950"), "big5"),
+    (("EUC_CN",), "gb2312"),
+    (("EUC_JIS_2004",), "euc_jis_2004"),
+    (("EUC_JP",), "euc_jp"),
+    (("EUC_KR",), "euc_kr"),
+    # (("EUC_TW",), not available in Python
+    (("GB18030",), "gb18030"),
+    (("GBK", "WIN936", "Windows936"), "gbk"),
+    (("ISO_8859_5",), "iso8859-5"),
+    (("ISO_8859_6",), "iso8859-6"),
+    (("ISO_8859_7",), "iso8859-7"),
+    (("ISO_8859_8",), "iso8859-8"),
+    (("JOHAB",), "johab"),
+    (("KOI8R", "KOI8"), "koi8-r"),
+    (("KOI8U",), "koi8-u"),
+    (("LATIN1", "ISO88591"), "iso8859-1"),
+    (("LATIN10", "ISO885916"), "iso8859-16"),
+    (("LATIN2", "ISO88592"), "iso8859-2"),
+    (("LATIN3", "ISO88593"), "iso8859-3"),
+    (("LATIN4", "ISO88594"), "iso8859-4"),
+    (("LATIN5", "ISO88599"), "iso8859-9"),
+    (("LATIN6", "ISO885910"), "iso8859-10"),
+    (("LATIN7", "ISO885913"), "iso8859-13"),
+    (("LATIN8", "ISO885914"), "iso8859-14"),
+    (("LATIN9", "ISO885915"), "iso8859-15"),
+    # "MULE_INTERNAL" not available in Python
+    (("SHIFT_JIS_2004",), "shift_jis_2004"),
+    (("SJIS", "Mskanji", "ShiftJIS", "WIN932", "Windows932"), "shift_jis"),
     # this actually means no encoding, see PostgreSQL docs
     # it is special-cased by the text loader.
-    "SQL_ASCII": "ascii",
-    "UHC": "cp949",
-    "UTF8": "utf-8",
-    "WIN1250": "cp1250",
-    "WIN1251": "cp1251",
-    "WIN1252": "cp1252",
-    "WIN1253": "cp1253",
-    "WIN1254": "cp1254",
-    "WIN1255": "cp1255",
-    "WIN1256": "cp1256",
-    "WIN1257": "cp1257",
-    "WIN1258": "cp1258",
-    "WIN866": "cp866",
-    "WIN874": "cp874",
-}
-
-py_codecs: dict[bytes, str] = {}
-py_codecs.update((k.encode(), v) for k, v in _py_codecs.items())
+    (("SQL_ASCII",), "ascii"),
+    (("UHC", "WIN949", "Windows949"), "cp949"),
+    (("UTF8", "Unicode"), "utf-8"),
+    (("WIN1250",), "cp1250"),
+    (("WIN1251", "WIN"), "cp1251"),
+    (("WIN1252",), "cp1252"),
+    (("WIN1253",), "cp1253"),
+    (("WIN1254",), "cp1254"),
+    (("WIN1255",), "cp1255"),
+    (("WIN1256",), "cp1256"),
+    (("WIN1257",), "cp1257"),
+    (("WIN1258", "ABC", "TCVN", "TCVN5712", "VSCII"), "cp1258"),
+    (("WIN866", "ALT"), "cp866"),
+    (("WIN874",), "cp874"),
+)
+
+py_codecs = {a.upper().encode(): v for aliases, v in _py_codecs for a in aliases}
 
 # Add an alias without underscore, for lenient lookups
 py_codecs.update(
-    (k.replace("_", "").encode(), v) for k, v in _py_codecs.items() if "_" in k
+    (a.replace("_", "").encode(), v)
+    for aliases, v in _py_codecs
+    for a in aliases
+    if "_" in a
 )
 
-pg_codecs = {v: k.encode() for k, v in _py_codecs.items()}
+pg_codecs = {v: k[0].encode() for k, v in _py_codecs}
 
 
 def conn_encoding(conn: BaseConnection[Any] | None) -> str:

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_preparing.py

@@ -6,6 +6,7 @@ Support for prepared statements
 
 from __future__ import annotations
 
+import re
 from enum import IntEnum, auto
 from typing import TYPE_CHECKING, Any, TypeAlias
 from collections import OrderedDict, deque
@@ -78,7 +79,14 @@ class PrepareManager:
             # The query is not to be prepared yet
             return Prepare.NO, b""
 
-    def _should_discard(self, prep: Prepare, results: Sequence[PGresult]) -> bool:
+    def _should_discard(
+        self,
+        prep: Prepare,
+        results: Sequence[PGresult],
+        __should_clear: Any = re.compile(
+            rb"^(?:DROP|ALTER|ROLLBACK|DISCARD ALL|DEALLOCATE ALL)\b"
+        ).match,
+    ) -> bool:
         """Check if we need to discard our entire state: it should happen on
         rollback or on dropping objects, because the same object may get
         recreated and postgres would fail internal lookups.
@@ -87,8 +95,7 @@ class PrepareManager:
             for result in results:
                 if result.status != COMMAND_OK:
                     continue
-                cmdstat = result.command_status
-                if cmdstat and (cmdstat.startswith(b"DROP ") or cmdstat == b"ROLLBACK"):
+                if (cmdstat := result.command_status) and __should_clear(cmdstat):
                     return self.clear()
         return False
 

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_py_transformer.py

@@ -65,6 +65,7 @@ class Transformer(AdaptContext):
 
     def __init__(self, context: AdaptContext | None = None):
         self._pgresult = self.types = self.formats = None
+        self._none_oid = -1
 
         # WARNING: don't store context, or you'll create a loop with the Cursor
         if context:
@@ -187,12 +188,14 @@ class Transformer(AdaptContext):
                     out[i] = self._row_dumpers[i].dump(param)
             return out
 
-        types = [self._get_none_oid()] * nparams
+        types = [-1] * nparams
         pqformats = [TEXT] * nparams
 
         for i in range(nparams):
             if (param := params[i]) is None:
+                types[i] = self._get_none_oid()
                 continue
+
             dumper = self.get_dumper(param, formats[i])
             out[i] = dumper.dump(param)
             types[i] = dumper.oid
@@ -266,17 +269,12 @@ class Transformer(AdaptContext):
             return dumper
 
     def _get_none_oid(self) -> int:
-        try:
-            return self._none_oid
-        except AttributeError:
-            pass
-
-        try:
-            rv = self._none_oid = self._adapters.get_dumper(NoneType, PY_TEXT).oid
-        except KeyError:
-            raise e.InterfaceError("None dumper not found")
-
-        return rv
+        if self._none_oid < 0:
+            try:
+                self._none_oid = self._adapters.get_dumper(NoneType, PY_TEXT).oid
+            except KeyError:
+                raise e.InterfaceError("None dumper not found")
+        return self._none_oid
 
     def get_dumper_by_oid(self, oid: int, format: pq.Format) -> abc.Dumper:
         """

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_tstrings.py

@@ -40,7 +40,7 @@ class TemplateProcessor:
         self._process_template(self.template)
         self.query = b"".join(self._chunks)
 
-    def _check_template_format(self, item: Interpolation, want_fmt: str) -> None:
+    def _check_template_format(self, item: Interpolation[Any], want_fmt: str) -> None:
         if item.format_spec == want_fmt:
             return
         fmt = f":{item.format_spec}" if item.format_spec else ""
@@ -94,7 +94,7 @@ class TemplateProcessor:
                 else:
                     self._process_client_variable(item, fmt)
 
-    def _process_server_variable(self, item: Interpolation, fmt: str) -> None:
+    def _process_server_variable(self, item: Interpolation[Any], fmt: str) -> None:
         try:
             pyfmt = PyFormat(fmt)
         except ValueError:
@@ -107,7 +107,7 @@ class TemplateProcessor:
         self.params.append(item.value)
         self._chunks.append(b"$%d" % len(self.params))
 
-    def _process_client_variable(self, item: Interpolation, fmt: str) -> None:
+    def _process_client_variable(self, item: Interpolation[Any], fmt: str) -> None:
         try:
             PyFormat(fmt)
         except ValueError:
@@ -120,7 +120,7 @@ class TemplateProcessor:
         self._chunks.append(param)
         self.params.append(param)
 
-    def _process_composable(self, item: Interpolation) -> None:
+    def _process_composable(self, item: Interpolation[Any]) -> None:
         if isinstance(item.value, sql.Identifier):
             self._check_template_format(item, FMT_IDENT)
             self._chunks.append(item.value.as_bytes(self._tx))

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_typeinfo.py

@@ -303,7 +303,7 @@ class TypesRegistry:
         """
         Return the oid of a PostgreSQL type by name.
 
-        :param key: the name of the type to look for.
+        :param name: the name of the type to look for.
 
         Return the array oid if the type ends with "``[]``"
 

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/_typemod.py

@@ -84,3 +84,21 @@ class TimeTypeModifier(TypeModifier):
 
     def get_precision(self, typemod: int) -> int | None:
         return typemod & 0xFFFF if typemod >= 0 else None
+
+
+class IntervalTypeModifier(TimeTypeModifier):
+    """Handle interval type modifier.
+
+    Unlike the other time-related types, the interval typmod is a composite:
+    the fields restriction is packed in the high bits and the precision in the
+    low ones. A typmod written without an explicit precision (e.g. ``interval
+    day to second``) stores ``INTERVAL_FULL_PRECISION`` (0xFFFF) there, which
+    means "unspecified" rather than a precision of 65535.
+    """
+
+    def get_precision(self, typemod: int) -> int | None:
+        if typemod < 0:
+            return None
+
+        precision = typemod & 0xFFFF
+        return precision if precision != 0xFFFF else None

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/abc.py

@@ -57,7 +57,13 @@ class WaitFunc(Protocol):
     Wait on the connection which generated `PQgen` and return its final result.
     """
 
-    def __call__(self, gen: PQGen[RV], fileno: int, interval: float = ...) -> RV: ...
+    def __call__(
+        self,
+        gen: PQGen[RV],
+        fileno: int,
+        interval: float = ...,
+        timeout: float | None = ...,
+    ) -> RV: ...
 
 
 # Adaptation types

{psycopg-3.3.4 → psycopg-3.3.6}/psycopg/connection.py

@@ -50,7 +50,7 @@ IDLE = pq.TransactionStatus.IDLE
 ACTIVE = pq.TransactionStatus.ACTIVE
 INTRANS = pq.TransactionStatus.INTRANS
 
-_INTERRUPTED = KeyboardInterrupt
+_INTERRUPTED = (KeyboardInterrupt, SystemExit)
 
 logger = logging.getLogger("psycopg")
 
@@ -105,8 +105,12 @@ class Connection(BaseConnection[Row]):
             logger.debug("connection attempt: %s", descr)
             try:
                 conninfo = make_conninfo("", **attempt)
-                gen = cls._connect_gen(conninfo, timeout=timeout)
-                rv = waiting.wait_conn(gen, interval=_WAIT_INTERVAL)
+                gen = cls._connect_gen(conninfo)
+                rv = waiting.wait_conn(gen, interval=_WAIT_INTERVAL, timeout=timeout)
+            except e._WaitTimeout:
+                tex = e.ConnectionTimeout("connection timeout expired")
+                logger.debug("connection failed: %s: %s", descr, str(tex))
+                conn_errors.append((tex, descr))
             except e.Error as ex:
                 logger.debug("connection failed: %s: %s", descr, str(ex))
                 conn_errors.append((ex, descr))
@@ -329,9 +333,12 @@ class Connection(BaseConnection[Row]):
             return
 
         if capabilities.has_cancel_safe():
-            waiting.wait_conn(
-                self._cancel_gen(timeout=timeout), interval=_WAIT_INTERVAL
-            )
+            try:
+                waiting.wait_conn(
+                    self._cancel_gen(), interval=_WAIT_INTERVAL, timeout=timeout or None
+                )
+            except e._WaitTimeout:
+                raise e.CancellationTimeout("cancellation timeout expired") from None
         else:
             self.cancel()
 
@@ -374,15 +381,7 @@ class Connection(BaseConnection[Row]):
             You might actually receive more than this number if more than one
             notifications arrives in the same packet.
         """
-        # Allow interrupting the wait with a signal by reducing a long timeout
-        # into shorter intervals.
-        if timeout is not None:
-            deadline = monotonic() + timeout
-            interval = min(timeout, _WAIT_INTERVAL)
-        else:
-            deadline = None
-            interval = _WAIT_INTERVAL
-
+        deadline = monotonic() + timeout if timeout is not None else None
         nreceived = 0
 
         if self._notify_handlers:
@@ -407,8 +406,14 @@ class Connection(BaseConnection[Row]):
                             yield d.popleft()
                             nreceived += 1
                     else:
+                        if deadline is not None:
+                            remaining = max(0.0, deadline - monotonic())
+                        else:
+                            remaining = None
                         try:
-                            pgns = self.wait(notifies(self.pgconn), interval=interval)
+                            pgns = self.wait(notifies(self.pgconn), timeout=remaining)
+                        except e._WaitTimeout:
+                            break
                         except e._NO_TRACEBACK as ex:
                             raise ex.with_traceback(None)
                         # Emit the notifications received.
@@ -426,10 +431,8 @@ class Connection(BaseConnection[Row]):
 
                     # Check the deadline after the loop to ensure that timeout=0
                     # polls at least once.
-                    if deadline:
-                        interval = min(_WAIT_INTERVAL, deadline - monotonic())
-                        if interval < 0.0:
-                            break
+                    if deadline is not None and monotonic() > deadline:
+                        break
             finally:
                 self._notifies_backlog = d
 
@@ -473,24 +476,43 @@ class Connection(BaseConnection[Row]):
             assert pipeline is self._pipeline
             self._pipeline = None
 
-    def wait(self, gen: PQGen[RV], interval: float = _WAIT_INTERVAL) -> RV:
+    def wait(
+        self,
+        gen: PQGen[RV],
+        interval: float = _WAIT_INTERVAL,
+        timeout: float | None = None,
+    ) -> RV:
         """
         Consume a generator operating on the connection.
 
         The function must be used on generators that don't change connection
         fd (i.e. not on connect and reset).
+
+        Raise `~errors._WaitTimeout` if `!gen` doesn't complete within
+        `!timeout` seconds.
         """
         try:
-            return waiting.wait(gen, self.pgconn.socket, interval=interval)
+            return waiting.wait(
+                gen, self.pgconn.socket, interval=interval, timeout=timeout
+            )
         except _INTERRUPTED:
             if self.pgconn.transaction_status == ACTIVE:
                 # On Ctrl-C, try to cancel the query in the server, otherwise
                 # the connection will remain stuck in ACTIVE state.
                 self._try_cancel(timeout=5.0)
                 try:
-                    waiting.wait(gen, self.pgconn.socket, interval=interval)
+                    waiting.wait(
+                        gen, self.pgconn.socket, interval=interval, timeout=5.0
+                    )
                 except e.QueryCanceled:
                     pass  # as expected
+                except e._WaitTimeout:
+                    # The server didn't terminate the query: the connection
+                    # is in an unknown state, so don't wait forever (#1371).
+                    logger.warning(
+                        "query not terminated after cancellation: closing connection"
+                    )
+                    self.pgconn.finish()
             raise
 
     def _set_autocommit(self, value: bool) -> None: