ferrum-orm 0.1.16__tar.gz → 0.1.17__tar.gz

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/Cargo.lock

@@ -223,7 +223,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "ferrum-core"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "criterion",
  "proptest",
@@ -234,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-migrate"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "ferrum-core",
  "serde",
@@ -243,7 +243,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-pyo3"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "ferrum-core",
  "ferrum-sql",
@@ -255,7 +255,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-sql"
-version = "0.1.16"
+version = "0.1.17"
 dependencies = [
  "criterion",
  "ferrum-core",

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/ferrum-core", "crates/ferrum-sql", "crates/ferrum-pyo3"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.16"
+version = "0.1.17"
 edition = "2021"
 authors = ["Ferrum Contributors"]
 license = "Apache-2.0"

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferrum-orm
-Version: 0.1.16
+Version: 0.1.17
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ferrum-orm"
-version = "0.1.16"
+version = "0.1.17"
 description = "Next-generation async ORM for Python with a Rust-powered core"
 license = { text = "Apache-2.0" }
 readme = "README.md"

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/python/ferrum/__init__.py

@@ -6,7 +6,7 @@ Import paths are stable API; internal module paths are not.
 
 from __future__ import annotations
 
-__version__ = "0.1.16"
+__version__ = "0.1.17"
 __all__ = [
     "Aggregate",
     "CreateExtension",

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/python/ferrum/drivers/postgres.py

@@ -159,6 +159,7 @@ class AsyncpgDriver:
         self._statement_timeout_ms = statement_timeout_ms
         self._max_lifetime = max_lifetime
         self._pool: Any = None
+        self._extra_codecs: list[dict[str, Any]] = []
 
     async def open(self) -> None:
         try:
@@ -177,9 +178,12 @@ class AsyncpgDriver:
             pool_kwargs["max_inactive_connection_lifetime"] = self._max_lifetime
 
         statement_timeout_ms = self._statement_timeout_ms
+        extra_codecs = self._extra_codecs
 
         async def _init_conn(conn: Any) -> None:
             await _register_json_codecs(conn)
+            for codec in extra_codecs:
+                await conn.set_type_codec(**codec)
             if statement_timeout_ms is not None:
                 await conn.execute(f"SET statement_timeout = {statement_timeout_ms}")
 
@@ -193,6 +197,39 @@ class AsyncpgDriver:
                 f"{type(exc).__name__} [FERR-E101]"
             ) from None
 
+    async def add_type_codec(
+        self,
+        type_name: str,
+        *,
+        schema: str,
+        encoder: Any,
+        decoder: Any,
+        format: str = "text",
+    ) -> None:
+        """Register an asyncpg type codec on every connection in the pool.
+
+        asyncpg exposes ``set_type_codec`` on a connection, not on a pool, so
+        registering directly against one acquired connection only covers that
+        connection — every other pooled connection keeps the default codec and
+        the same query succeeds or fails depending on which one it lands on.
+        Recording the codec here applies it from the pool ``init`` hook, and
+        expiring the pool forces already-initialized connections to be replaced
+        so the registration is uniform.
+        """
+        if any(c["typename"] == type_name and c["schema"] == schema for c in self._extra_codecs):
+            return
+        self._extra_codecs.append(
+            {
+                "typename": type_name,
+                "schema": schema,
+                "encoder": encoder,
+                "decoder": decoder,
+                "format": format,
+            }
+        )
+        if self._pool is not None:
+            await self._pool.expire_connections()
+
     async def close(self) -> None:
         if self._pool is not None:
             await self._pool.close()

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/python/ferrum/ext/pgvector.py

@@ -61,40 +61,43 @@ async def register_vector_codecs(
 ) -> None:
     """Ensure the ``vector`` extension exists and register asyncpg codecs.
 
+    The codec is installed pool-wide (every current and future connection), so
+    ``vector`` columns decode to ``list[float]`` no matter which pooled
+    connection serves a query.
+
+    Writing a vector does not require this call: Ferrum binds vector values as
+    pgvector text literals, which asyncpg accepts without a codec.
+
     Idempotent: safe to call multiple times and from concurrent startup paths.
-    ``DuplicateObjectError`` from the extension-creation step and codec
-    re-registration on an already-configured pool are both handled gracefully.
+    ``DuplicateObjectError`` from the extension-creation step and repeat
+    registration of the same codec are both handled gracefully.
 
     Args:
         conn: An open Ferrum ``Connection``.
-        timeout: Statement timeout (seconds) for the ``CREATE EXTENSION`` DDL.
+        timeout: Timeout (seconds) for the ``CREATE EXTENSION`` DDL.
             Defaults to 5 s.  Set to ``0`` to disable the timeout guard.
 
     Raises:
-        FerrumConfigError: If the connection is not a PostgreSQL connection or
-            the pool is not open.
+        FerrumConfigError: If the connection is not a PostgreSQL connection, the
+            pool is not open, or the driver is not the asyncpg driver.
     """
     if conn.dialect != "postgres":
         raise FerrumConfigError(
             "pgvector integration requires a PostgreSQL connection. [FERR-C001]"
         )
-    driver = conn._require_driver()
+    driver = conn._driver
     pool = getattr(driver, "_pool", None)
-    # TimedQueryExecutor wraps the real driver; fall back to its _inner attribute.
-    if pool is None:
-        inner = getattr(driver, "_inner", None)
-        pool = getattr(inner, "_pool", None) if inner is not None else None
-    if pool is None:
+    if driver is None or pool is None:
         raise FerrumConfigError("PostgreSQL pool is not open. [FERR-C001]")
 
     # CREATE EXTENSION — idempotent via IF NOT EXISTS; the DuplicateObjectError
     # guard covers rare race conditions where two concurrent startup paths both
     # attempt the DDL at the same moment.
     try:
-        create_sql = "CREATE EXTENSION IF NOT EXISTS vector"
-        if timeout > 0:
-            create_sql = f"SET LOCAL statement_timeout = {int(timeout * 1000)}; {create_sql}"
-        await pool.execute("CREATE EXTENSION IF NOT EXISTS vector")
+        await pool.execute(
+            "CREATE EXTENSION IF NOT EXISTS vector",
+            timeout=timeout if timeout > 0 else None,
+        )
     except Exception as exc:
         # asyncpg raises DuplicateObjectError (SQLSTATE 42710) if another
         # concurrent caller committed the extension between our IF NOT EXISTS
@@ -103,37 +106,21 @@ async def register_vector_codecs(
         if "DuplicateObject" not in exc_name:
             raise
 
-    # Codec registration — asyncpg raises InvalidStateError if the same custom
-    # type is registered twice on the same pool.  Treat it as idempotent.
-    try:
-        set_pool_codec = getattr(pool, "set_type_codec", None)
-        if set_pool_codec is not None:
-            await set_pool_codec(
-                "vector",
-                schema="public",
-                encoder=_encode_vector,
-                decoder=_decode_vector,
-                format="text",
-            )
-        else:
-            # asyncpg exposes codecs on Connection, not Pool. Ferrum's normal
-            # vector query path casts bound text to ``vector`` and projects the
-            # vector column out, so registering the currently acquired
-            # connection is sufficient for callers that explicitly hydrate a
-            # vector immediately after startup without making pool startup fail.
-            async with pool.acquire() as raw_conn:
-                await raw_conn.set_type_codec(
-                    "vector",
-                    schema="public",
-                    encoder=_encode_vector,
-                    decoder=_decode_vector,
-                    format="text",
-                )
-    except Exception as exc:
-        exc_name = type(exc).__name__
-        if exc_name not in ("InvalidStateError", "AlreadyInitializedError"):
-            # Re-raise unknown errors; swallow the known re-registration ones.
-            raise
+    # Registering through the driver applies the codec from the pool's ``init``
+    # hook, so every connection — including ones the pool opens later — decodes
+    # ``vector`` columns to ``list[float]``. Registering against a single
+    # acquired connection instead made vector reads depend on which pooled
+    # connection served the query.
+    add_codec = getattr(driver, "add_type_codec", None)
+    if add_codec is None:
+        raise FerrumConfigError("pgvector integration requires the asyncpg driver. [FERR-C001]")
+    await add_codec(
+        "vector",
+        schema="public",
+        encoder=_encode_vector,
+        decoder=_decode_vector,
+        format="text",
+    )
 
 
 async def vector_search(

{ferrum_orm-0.1.16 → ferrum_orm-0.1.17}/python/ferrum/queryset.py

@@ -215,8 +215,16 @@ def _encode_bind_value(value: object) -> dict[str, object]:
 
 def _prepare_field_value(field: Any, value: object) -> object:  # noqa: ANN401
     """Normalize a Python value for the field's database representation."""
-    if value is not None and field.field_type == "json":
+    if value is None:
+        return value
+    if field.field_type == "json":
         return json.dumps(value, default=str, separators=(",", ":"))
+    if field.field_type == "vector" and isinstance(value, (list, tuple)):
+        # asyncpg has no built-in codec for the pgvector ``vector`` type and
+        # falls back to text, so a bound ``list[float]`` raises DataError
+        # ("expected str, got list"). Bind the pgvector text literal instead —
+        # the same encoding ``nearest_to()`` uses on the read path.
+        return _encode_vector_literal([float(v) for v in cast(list[Any], value)])
     return value