psycopg 3.3.6__tar.gz → 3.3.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psycopg
-Version: 3.3.6
+Version: 3.3.7
 Summary: PostgreSQL database adapter for Python
 Author-email: Daniele Varrazzo <daniele.varrazzo@gmail.com>
 License-Expression: LGPL-3.0-only
@@ -34,9 +34,9 @@ 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.6; implementation_name != "pypy" and extra == "c"
+Requires-Dist: psycopg-c==3.3.7; implementation_name != "pypy" and extra == "c"
 Provides-Extra: binary
-Requires-Dist: psycopg-binary==3.3.6; implementation_name != "pypy" and extra == "binary"
+Requires-Dist: psycopg-binary==3.3.7; implementation_name != "pypy" and extra == "binary"
 Provides-Extra: pool
 Requires-Dist: psycopg-pool; extra == "pool"
 Provides-Extra: test

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/_dns.py

@@ -1,4 +1,3 @@
-# type: ignore  # dnspython is currently optional and mypy fails if missing
 """
 DNS query support
 """
@@ -13,12 +12,13 @@ import warnings
 from random import randint
 from typing import TYPE_CHECKING, Any, DefaultDict, NamedTuple
 from collections import defaultdict
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 
 try:
     from dns.resolver import Cache, Resolver
     from dns.exception import DNSException
     from dns.asyncresolver import Resolver as AsyncResolver
+    from dns.rdtypes.IN.SRV import SRV
 except ImportError:
     raise ImportError(
         "the module psycopg._dns requires the package 'dnspython' installed"
@@ -28,7 +28,7 @@ from . import conninfo
 from . import errors as e
 
 if TYPE_CHECKING:
-    from dns.rdtypes.IN.SRV import SRV
+    from dns.rdata import Rdata
 
 resolver = Resolver()
 resolver.cache = Cache()
@@ -56,9 +56,9 @@ async def resolve_hostaddr_async(params: dict[str, Any]) -> dict[str, Any]:
 
     for attempt in await conninfo.conninfo_attempts_async(params):
         if attempt.get("host") is not None:
-            hosts.append(attempt["host"])
+            hosts.append(str(attempt["host"]))
         if attempt.get("hostaddr") is not None:
-            hostaddrs.append(attempt["hostaddr"])
+            hostaddrs.append(str(attempt["hostaddr"]))
         if attempt.get("port") is not None:
             ports.append(str(attempt["port"]))
 
@@ -165,6 +165,7 @@ class Rfc2782Resolver:
         return out if srv_found else []
 
     def _resolve_srv(self, hp: HostPort) -> list[HostPort]:
+        ans: Iterable[Rdata]
         try:
             ans = resolver.resolve(hp.host, "SRV")
         except DNSException:
@@ -172,15 +173,16 @@ class Rfc2782Resolver:
         return self._get_solved_entries(hp, ans)
 
     async def _resolve_srv_async(self, hp: HostPort) -> list[HostPort]:
+        ans: Iterable[Rdata]
         try:
             ans = await async_resolver.resolve(hp.host, "SRV")
         except DNSException:
             ans = ()
         return self._get_solved_entries(hp, ans)
 
-    def _get_solved_entries(
-        self, hp: HostPort, entries: Sequence[SRV]
-    ) -> list[HostPort]:
+    def _get_solved_entries(self, hp: HostPort, ans: Iterable[Rdata]) -> list[HostPort]:
+        # A SRV query only returns SRV records: this only narrows the type.
+        entries = [rr for rr in ans if isinstance(rr, SRV)]
         if not entries:
             # No SRV entry found. Delegate the libpq a QNAME=target lookup
             if hp.target and hp.port.lower() != "srv":

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/adapt.py

@@ -141,7 +141,9 @@ class RecursiveDumper(Dumper):
 
     def __init__(self, cls: type, context: abc.AdaptContext | None = None):
         super().__init__(cls, context)
-        self._tx = Transformer.from_context(context)
+        # Don't use from_context(): if the context is a transformer, it will
+        # cache this adapter, creating a reference loop.
+        self._tx = Transformer(context)
 
 
 class RecursiveLoader(Loader):
@@ -149,4 +151,6 @@ class RecursiveLoader(Loader):
 
     def __init__(self, oid: int, context: abc.AdaptContext | None = None):
         super().__init__(oid, context)
-        self._tx = Transformer.from_context(context)
+        # Don't use from_context(): if the context is a transformer, it will
+        # cache this adapter, creating a reference loop.
+        self._tx = Transformer(context)

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/generators.py

@@ -83,10 +83,8 @@ def _connect(conninfo: str) -> PQGenConn[PGconn]:
 
         if status == POLL_READING or status == POLL_WRITING:
             wait = WAIT_R if status == POLL_READING else WAIT_W
-            while True:
-                ready = yield conn.socket, wait
-                if ready:
-                    break
+            while not (yield conn.socket, wait):
+                pass
 
         elif status == POLL_OK:
             break
@@ -109,10 +107,10 @@ def _cancel(cancel_conn: PGcancelConn) -> PQGenConn[None]:
     while True:
         if (status := cancel_conn.poll()) == POLL_OK:
             break
-        elif status == POLL_READING:
-            yield cancel_conn.socket, WAIT_R
-        elif status == POLL_WRITING:
-            yield cancel_conn.socket, WAIT_W
+        elif status == POLL_READING or status == POLL_WRITING:
+            wait = WAIT_R if status == POLL_READING else WAIT_W
+            while not (yield cancel_conn.socket, wait):
+                pass
         elif status == POLL_FAILED:
             raise e.OperationalError(
                 f"cancellation failed: {cancel_conn.get_error_message()}"

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/transaction.py

@@ -96,9 +96,11 @@ class BaseTransaction(Generic[ConnectionType]):
         sp = f"{self.savepoint_name!r} " if self.savepoint_name else ""
         return f"<{cls} {sp}({self.status.value}) {info} at 0x{id(self):x}>"
 
-    def _enter_gen(self) -> PQGen[None]:
+    def _check_enter(self) -> None:
         if self.status != self.Status.NOT_STARTED:
             raise TypeError("transaction blocks can be used only once")
+
+    def _enter_gen(self) -> PQGen[None]:
         self.status = self.Status.ACTIVE
 
         self._push_savepoint()
@@ -257,7 +259,17 @@ class Transaction(BaseTransaction["Connection[Any]"]):
 
     def __enter__(self) -> Self:
         with self._conn.lock:
-            self._conn.wait(self._enter_gen())
+            self._check_enter()
+            try:
+                self._conn.wait(self._enter_gen())
+            except BaseException as ex:
+                # Undo the enter if it was interrupted (e.g. by Ctrl-C)
+                # as __exit__ won't be called.
+                if self.pgconn.status == OK:
+                    self._conn.wait(self._exit_gen(type(ex), ex, None))
+                else:
+                    self.status = self.Status.FAILED
+                raise
         return self
 
     def __exit__(
@@ -291,7 +303,17 @@ class AsyncTransaction(BaseTransaction["AsyncConnection[Any]"]):
 
     async def __aenter__(self) -> Self:
         async with self._conn.lock:
-            await self._conn.wait(self._enter_gen())
+            self._check_enter()
+            try:
+                await self._conn.wait(self._enter_gen())
+            except BaseException as ex:
+                # Undo the enter if it was interrupted (e.g. by a cancellation)
+                # as __aexit__ won't be called.
+                if self.pgconn.status == OK:
+                    await self._conn.wait(self._exit_gen(type(ex), ex, None))
+                else:
+                    self.status = self.Status.FAILED
+                raise
         return self
 
     async def __aexit__(

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/types/array.py

@@ -157,33 +157,39 @@ class ListDumper(BaseListDumper):
     def dump(self, obj: list[Any]) -> Buffer | None:
         tokens: list[Buffer] = []
         needs_quotes = _get_needs_quotes_regexp(self.delimiter).search
+        self._dump_list(obj, tokens, needs_quotes)
+        return b"".join(tokens)
 
-        def dump_list(obj: list[Any]) -> None:
-            if not obj:
-                tokens.append(b"{}")
-                return
-
-            tokens.append(b"{")
-            for item in obj:
-                if isinstance(item, list):
-                    dump_list(item)
-                elif item is not None:
-                    if (ad := self._dump_item(item)) is None:
-                        tokens.append(b"NULL")
-                    else:
-                        if needs_quotes(ad):
-                            ad = b'"' + self._re_esc.sub(rb"\\\1", ad) + b'"'
-                        tokens.append(ad)
-                else:
-                    tokens.append(b"NULL")
-
-                tokens.append(self.delimiter)
+    def _dump_list(
+        self,
+        obj: list[Any],
+        tokens: list[Buffer],
+        needs_quotes: Callable[[Buffer], object],
+    ) -> None:
+        """
+        Append the tokens of the text representation of a list to *tokens*.
+        """
+        if not obj:
+            tokens.append(b"{}")
+            return
 
-            tokens[-1] = b"}"
+        tokens.append(b"{")
+        for item in obj:
+            if isinstance(item, list):
+                self._dump_list(item, tokens, needs_quotes)
+            elif item is not None:
+                if (ad := self._dump_item(item)) is None:
+                    tokens.append(b"NULL")
+                else:
+                    if needs_quotes(ad):
+                        ad = b'"' + self._re_esc.sub(rb"\\\1", ad) + b'"'
+                    tokens.append(ad)
+            else:
+                tokens.append(b"NULL")
 
-        dump_list(obj)
+            tokens.append(self.delimiter)
 
-        return b"".join(tokens)
+        tokens[-1] = b"}"
 
     def _dump_item(self, item: Any) -> Buffer | None:
         if self.sub_dumper:
@@ -201,11 +207,19 @@ def _get_needs_quotes_regexp(delimiter: bytes) -> re.Pattern[bytes]:
     The array output routine will put double quotes around element values if
     they are empty strings, contain curly braces, delimiter characters,
     double quotes, backslashes, or white space, or match the word NULL.
+
+    Also quote values containing Unicode white space: Postgres doesn't strip
+    it from unquoted elements, but CockroachDB does (see
+    https://github.com/cockroachdb/cockroach/issues/176211).
     """
     return re.compile(rb"""(?xi)
           ^$              # the empty string
         | ["{}%s\\\s]      # or a char to escape
         | ^null$          # or the word NULL
+        | \xe1\x9a\x80    # or UTF-8 Unicode spaces stripped by CockroachDB:
+        | \xe2\x80[\x80-\x8a\xa8\xa9\xaf]   # U+1680, U+2000-U+200A,
+        | \xe2\x81\x9f    # U+2028, U+2029, U+202F, U+205F, U+3000
+        | \xe3\x80\x80
         """ % delimiter)
 
 
@@ -247,58 +261,76 @@ class ListBinaryDumper(BaseListDumper):
 
         data: list[Buffer] = [b"", b""]  # placeholders to avoid a resize
         dims: list[int] = []
-        hasnull = 0
-
-        def calc_dims(L: list[Any]) -> None:
-            if isinstance(L, self.cls):
-                if not L:
-                    raise e.DataError("lists cannot contain empty lists")
-                dims.append(len(L))
-                calc_dims(L[0])
-
-        calc_dims(obj)
-
-        def dump_list(L: list[Any], dim: int) -> None:
-            nonlocal hasnull
-            if len(L) != dims[dim]:
-                raise e.DataError("nested lists have inconsistent lengths")
-
-            if dim == len(dims) - 1:
-                for item in L:
-                    if item is not None:
-                        # If we get here, the sub_dumper must have been set
-                        item = self.sub_dumper.dump(item)  # type: ignore[union-attr]
-                    if item is not None:
-                        data.append(pack_len(len(item)))
-                        data.append(item)
-                    else:
-                        hasnull = 1
-                        data.append(ARRAY_NULL)
-            else:
-                for item in L:
-                    if not isinstance(item, self.cls):
-                        raise e.DataError("nested lists have inconsistent depths")
-                    dump_list(item, dim + 1)  # type: ignore
-
-        dump_list(obj, 0)
+        self._calc_dims(obj, dims)
+        hasnull = self._dump_list(obj, 0, dims, data)
 
         data[0] = _pack_head(len(dims), hasnull, sub_oid)
         data[1] = b"".join(_pack_dim(dim, 1) for dim in dims)
         return b"".join(data)
 
+    def _calc_dims(self, L: list[Any], dims: list[int]) -> None:
+        if isinstance(L, self.cls):
+            if not L:
+                raise e.DataError("lists cannot contain empty lists")
+            dims.append(len(L))
+            self._calc_dims(L[0], dims)
+
+    def _dump_list(
+        self, L: list[Any], dim: int, dims: list[int], data: list[Buffer]
+    ) -> int:
+        """
+        Append the dumped items of a list to *data*.
+
+        Return 1 if any item is null, else 0.
+        """
+        if len(L) != dims[dim]:
+            raise e.DataError("nested lists have inconsistent lengths")
+
+        hasnull = 0
+        if dim == len(dims) - 1:
+            for item in L:
+                if item is not None:
+                    # If we get here, the sub_dumper must have been set
+                    item = self.sub_dumper.dump(item)  # type: ignore[union-attr]
+                if item is not None:
+                    data.append(pack_len(len(item)))
+                    data.append(item)
+                else:
+                    hasnull = 1
+                    data.append(ARRAY_NULL)
+        else:
+            for item in L:
+                if not isinstance(item, self.cls):
+                    raise e.DataError("nested lists have inconsistent depths")
+                hasnull |= self._dump_list(item, dim + 1, dims, data)  # type: ignore
+
+        return hasnull
+
 
 class ArrayLoader(RecursiveLoader):
     delimiter = b","
     base_oid: int
 
+    def __init__(self, oid: int, context: AdaptContext | None = None):
+        super().__init__(oid, context)
+        # Create the element loader now: the connection might be closed
+        # by the time data is loaded (#1428).
+        self._loader = self._tx.get_loader(self.base_oid, self.format)
+
     def load(self, data: Buffer) -> list[Any]:
-        loader = self._tx.get_loader(self.base_oid, self.format)
-        return _load_text(data, loader, self.delimiter)
+        return _load_text(data, self._loader, self.delimiter)
 
 
 class ArrayBinaryLoader(RecursiveLoader):
     format = pq.Format.BINARY
 
+    def __init__(self, oid: int, context: AdaptContext | None = None):
+        super().__init__(oid, context)
+        # The element oid is in the data, but if the array type is known,
+        # create the element loader now, while the connection is still open.
+        if (info := self._tx.adapters.types.get(oid)) and info.array_oid == oid:
+            self._tx.get_loader(info.oid, self.format)
+
     def load(self, data: Buffer) -> list[Any]:
         return _load_binary(data, self._tx)
 

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/types/composite.py

@@ -324,9 +324,7 @@ def register_composite(
         factory = cast("Callable[..., T]", _nt_from_info(info))
 
     if not make_object:
-
-        def make_object(values: Sequence[Any], info: CompositeInfo) -> T:
-            return factory(*values)
+        make_object = _make_object_from_factory(factory)
 
     adapters = context.adapters if context else postgres.adapters
 
@@ -353,17 +351,10 @@ def register_composite(
                     " argument in the `register_composite()` call",
                     factory.__name__,
                 )
-
-                def make_sequence(obj: T, into: CompositeInfo) -> Sequence[Any]:
-                    raise TypeError(
-                        f"{type(obj).__name__!r} objects cannot be dumped without"
-                        " specifying 'make_sequence' in 'register_composite()'"
-                    )
+                make_sequence = _make_sequence_unsupported
 
             else:
-
-                def make_sequence(obj: T, info: CompositeInfo) -> Sequence[Any]:
-                    return obj  # type: ignore[return-value]  # it's a sequence
+                make_sequence = _make_sequence_from_sequence
 
         type_name = factory.__name__
         dumper: type[Dumper] = _make_binary_dumper(type_name, info, make_sequence)
@@ -514,6 +505,25 @@ def _make_nt(name: str, fields: tuple[str, ...]) -> type[NamedTuple]:
     return namedtuple(name, fields)  # type: ignore[return-value]
 
 
+@cache
+def _make_object_from_factory(factory: Callable[..., T]) -> ObjectMaker[T]:
+    def make_object(values: Sequence[Any], info: CompositeInfo) -> T:
+        return factory(*values)
+
+    return make_object
+
+
+def _make_sequence_from_sequence(obj: Any, info: CompositeInfo) -> Sequence[Any]:
+    return obj  # type: ignore[no-any-return]  # it's a sequence
+
+
+def _make_sequence_unsupported(obj: Any, info: CompositeInfo) -> Sequence[Any]:
+    raise TypeError(
+        f"{type(obj).__name__!r} objects cannot be dumped without"
+        " specifying 'make_sequence' in 'register_composite()'"
+    )
+
+
 @cache
 def _make_loader(
     info: CompositeInfo, make_object: ObjectMaker[T]

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/types/datetime.py

@@ -613,7 +613,8 @@ class IntervalLoader(Loader):
 
         ye, mo, da, sgn, ho, mi, se = m.groups()
         days = 0
-        seconds = 0.0
+        seconds = 0
+        micros = 0
 
         if ye:
             days += 365 * int(ye)
@@ -623,12 +624,14 @@ class IntervalLoader(Loader):
             days += int(da)
 
         if ho:
-            seconds = 3600 * int(ho) + 60 * int(mi) + float(se)
+            seconds = 3600 * int(ho) + 60 * int(mi)
+            micros = round(float(se) * 1_000_000)
             if sgn == b"-":
                 seconds = -seconds
+                micros = -micros
 
         try:
-            return timedelta(days=days, seconds=seconds)
+            return timedelta(days=days, seconds=seconds, microseconds=micros)
         except OverflowError as e:
             s = bytes(data).decode("utf8", "replace")
             raise DataError(f"can't parse interval {s!r}: {e}") from None

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg/types/json.py

@@ -296,7 +296,7 @@ _default_dumpers: dict[tuple[type[_JsonWrapper], PyFormat], type[Dumper]] = {
     (Json, PyFormat.BINARY): JsonBinaryDumper,
     (Json, PyFormat.TEXT): JsonDumper,
     (Jsonb, PyFormat.BINARY): JsonbBinaryDumper,
-    (Jsonb, PyFormat.TEXT): JsonDumper,
+    (Jsonb, PyFormat.TEXT): JsonbDumper,
 }
 
 

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psycopg
-Version: 3.3.6
+Version: 3.3.7
 Summary: PostgreSQL database adapter for Python
 Author-email: Daniele Varrazzo <daniele.varrazzo@gmail.com>
 License-Expression: LGPL-3.0-only
@@ -34,9 +34,9 @@ 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.6; implementation_name != "pypy" and extra == "c"
+Requires-Dist: psycopg-c==3.3.7; implementation_name != "pypy" and extra == "c"
 Provides-Extra: binary
-Requires-Dist: psycopg-binary==3.3.6; implementation_name != "pypy" and extra == "binary"
+Requires-Dist: psycopg-binary==3.3.7; implementation_name != "pypy" and extra == "binary"
 Provides-Extra: pool
 Requires-Dist: psycopg-pool; extra == "pool"
 Provides-Extra: test

{psycopg-3.3.6 → psycopg-3.3.7}/psycopg.egg-info/requires.txt

@@ -8,12 +8,12 @@ tzdata
 [binary]
 
 [binary:implementation_name != "pypy"]
-psycopg-binary==3.3.6
+psycopg-binary==3.3.7
 
 [c]
 
 [c:implementation_name != "pypy"]
-psycopg-c==3.3.6
+psycopg-c==3.3.7
 
 [dev]
 ast-comments>=1.1.2

{psycopg-3.3.6 → psycopg-3.3.7}/pyproject.toml

@@ -7,7 +7,7 @@ name = "psycopg"
 description = "PostgreSQL database adapter for Python"
 
 # STOP AND READ! if you change:
-version = "3.3.6"
+version = "3.3.7"
 # also change:
 # - `docs/news.rst` to declare this as the current version or an unreleased one;
 # - `psycopg_c/pyproject.toml` to the same version;
@@ -61,10 +61,10 @@ content-type = "text/x-rst"
 
 [project.optional-dependencies]
 c = [
-    "psycopg-c == 3.3.6; implementation_name != \"pypy\"",
+    "psycopg-c == 3.3.7; implementation_name != \"pypy\"",
 ]
 binary = [
-    "psycopg-binary == 3.3.6; implementation_name != \"pypy\"",
+    "psycopg-binary == 3.3.7; implementation_name != \"pypy\"",
 ]
 pool = [
     "psycopg-pool",