ferro-orm 0.12.0__tar.gz → 0.12.1__tar.gz

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/AGENTS.md

@@ -90,7 +90,8 @@ If you add a new schema feature (e.g. partial indexes, exclusion constraints):
    numbered list above.
 2. Implement it in **both** the Alembic and Rust paths in the same PR.
 3. Add a parity test that asserts the names match.
-4. Add a regression entry to `CHANGELOG.md`.
+4. Do not edit `CHANGELOG.md` manually — release tooling records entries at
+   release time (see I-11).
 
 ---
 
@@ -276,3 +277,21 @@ Rules:
   updates are complete before merge.
 - AI agents and human contributors follow the same requirement. If issue status
   closure is missing, the PR is not done.
+
+---
+
+## I-11: Do not edit CHANGELOG.md manually
+
+`CHANGELOG.md` is updated automatically by the release workflow (semantic
+release / release tooling). Agents and contributors must **not** add,
+reorder, or edit changelog entries in feature, bugfix, or docs PRs.
+
+What to do instead:
+
+- Describe user-visible changes in the PR title and body.
+- Rely on conventional commit messages and the release process to populate
+  `CHANGELOG.md` after merge.
+
+If release tooling fails to capture a change, fix the release configuration or
+commit message conventions — do not patch `CHANGELOG.md` by hand in ordinary
+PRs.

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/CHANGELOG.md

@@ -1,6 +1,15 @@
 # CHANGELOG
 
 
+## v0.12.1 (2026-06-23)
+
+### Bug Fixes
+
+- Stop framework predicate warnings and bind unnamed sessions to default
+  ([#124](https://github.com/syn54x/ferro-orm/pull/124),
+  [`66b92d8`](https://github.com/syn54x/ferro-orm/commit/66b92d8b691a1ad806691b9841bcbaf93c78f691))
+
+
 ## v0.12.0 (2026-06-23)
 
 ### Documentation

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/Cargo.lock

@@ -288,7 +288,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.12.0"
+version = "0.12.1"
 dependencies = [
  "dashmap",
  "ferro-migrate",

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/ferro-schema-ir", "crates/ferro-migrate"]
 
 [package]
 name = "ferro"
-version = "0.12.0"
+version = "0.12.1"
 edition = "2024"
 readme = "README.md"
 

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferro-orm
-Version: 0.12.0
+Version: 0.12.1
 Requires-Dist: pydantic>=2.0
 Requires-Dist: alembic>=1.18.1 ; extra == 'alembic'
 Requires-Dist: sqlalchemy>=2.0.46 ; extra == 'alembic'

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/docs/pages/howto/migrating-to-v0-12-0.md

@@ -72,6 +72,10 @@ active session relied on implicit default-connection routing. That fallback is
 deprecated. Wrap request- or task-scoped work in a session so routing, the
 identity map, and transactions are explicit and isolated under concurrency.
 
+After a single unnamed `connect(dsn)`, `async with ferro.engines.session()` (no
+argument) binds to that default connection — you do not need to pass
+`"default"` explicitly.
+
 === "Before (deprecated)"
 
     ```python

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ferro-orm"
-version = "0.12.0"
+version = "0.12.1"
 description = "A high-performance, Rust-backed ORM for Python."
 readme = "README.md"
 authors = [

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/src/ferro/_core.pyi

@@ -160,7 +160,7 @@ async def begin_transaction(
 async def commit_transaction(tx_id: str, session_id: Optional[str] = None) -> None: ...
 def transaction_connection_name(tx_id: str, session_id: Optional[str] = None) -> str: ...
 async def rollback_transaction(tx_id: str, session_id: Optional[str] = None) -> None: ...
-def open_session(using: Optional[str] = None) -> str: ...
+def open_session(using: Optional[str] = None) -> tuple[str, str]: ...
 def close_session(session_id: str) -> None: ...
 async def raw_execute(
     sql: str,

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/src/ferro/models.py

@@ -31,7 +31,7 @@ from ._core import (
 from .base import ForeignKey, foreign_key_allows_none
 from .exceptions import ModelDoesNotExist
 from .metaclass import ModelMetaclass
-from .query import Query, QueryNode
+from .query import Predicate, Query, QueryNode
 from .state import (
     _CURRENT_TRANSACTION,
     _CURRENT_TRANSACTION_CONNECTION,
@@ -43,6 +43,11 @@ from .state import (
 _FERRO_CONNECTION_ATTR = "__ferro_connection_name"
 
 
+def _field_eq(field_name: str, value: Any) -> Predicate[Any]:
+    """Build a lambda predicate for dynamic field equality without operator style."""
+    return lambda t, f=field_name, v=value: getattr(t, f) == v
+
+
 def _transaction_or_using(
     using: str | None, session: "Session | None"
 ) -> tuple[str | None, str | None, str | None]:
@@ -289,12 +294,10 @@ class Model(BaseModel, metaclass=ModelMetaclass):
 
         if pk_val is not None:
             name = self.__class__.__name__
-            query = self.__class__.where(
-                getattr(self.__class__, pk_field_name) == pk_val
-            )
+            query = self.__class__.where(_field_eq(pk_field_name, pk_val))
             if operation_using is not None:
                 query = Query(self.__class__, using=operation_using).where(
-                    getattr(self.__class__, pk_field_name) == pk_val
+                    _field_eq(pk_field_name, pk_val)
                 )
             await query.delete()
             evict_instance(
@@ -391,7 +394,9 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         if pk_field_name is None:
             raise RuntimeError(f"Model {cls.__name__} does not define a primary key")
 
-        instance = await cls.where(getattr(cls, pk_field_name) == pk, session=session).first()
+        instance = await cls.where(
+            _field_eq(pk_field_name, pk), session=session
+        ).first()
         if instance:
             cls._fix_types(instance)
         return instance
@@ -423,10 +428,10 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         )
 
         evict_instance(name, str(pk_val), identity_using, session_id=session_id)
-        query = self.__class__.where(getattr(self.__class__, pk_field_name) == pk_val)
+        query = self.__class__.where(_field_eq(pk_field_name, pk_val))
         if operation_using is not None:
             query = Query(self.__class__, using=operation_using).where(
-                getattr(self.__class__, pk_field_name) == pk_val
+                _field_eq(pk_field_name, pk_val)
             )
         fresh_instance = await query.first()
 
@@ -576,7 +581,7 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         """
         query = Query(cls, session=session)
         for key, val in fields.items():
-            query = query.where(getattr(cls, key) == val)
+            query = query.where(_field_eq(key, val))
 
         instance = await query.first()
         if instance:
@@ -604,7 +609,7 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         """
         query = Query(cls, session=session)
         for key, val in fields.items():
-            query = query.where(getattr(cls, key) == val)
+            query = query.where(_field_eq(key, val))
 
         instance = await query.first()
         if instance:
@@ -662,9 +667,7 @@ class ModelConnection[M: Model]:
                 f"Model {self.model_cls.__name__} does not define a primary key"
             )
 
-        instance = await self.where(
-            getattr(self.model_cls, pk_field_name) == pk
-        ).first()
+        instance = await self.where(_field_eq(pk_field_name, pk)).first()
         if instance:
             self.model_cls._fix_types(instance)
         return instance
@@ -677,7 +680,7 @@ class ModelConnection[M: Model]:
     ) -> tuple[M, bool]:
         query = Query(self.model_cls, using=self._connection_name)
         for key, val in fields.items():
-            query = query.where(getattr(self.model_cls, key) == val)
+            query = query.where(_field_eq(key, val))
 
         instance = await query.first()
         if instance:
@@ -691,7 +694,7 @@ class ModelConnection[M: Model]:
     ) -> tuple[M, bool]:
         query = Query(self.model_cls, using=self._connection_name)
         for key, val in fields.items():
-            query = query.where(getattr(self.model_cls, key) == val)
+            query = query.where(_field_eq(key, val))
 
         instance = await query.first()
         if instance:

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/src/ferro/relations/descriptors.py

@@ -69,9 +69,10 @@ class RelationshipDescriptor(BaseModel):
 
         pk_val = getattr(instance, pk_field)
 
+        fk_field = f"{self.field_name}_id"
         if self.is_one_to_one:
             return self._target_model.where(
-                getattr(self._target_model, f"{self.field_name}_id") == pk_val
+                lambda t, f=fk_field, v=pk_val: getattr(t, f) == v
             ).first()
 
         from ..query.builder import Relation
@@ -79,9 +80,7 @@ class RelationshipDescriptor(BaseModel):
         return Relation(
             self._target_model,
             using=_instance_origin_outside_transaction(instance),
-        ).where(
-            getattr(self._target_model, f"{self.field_name}_id") == pk_val
-        )
+        ).where(lambda t, f=fk_field, v=pk_val: getattr(t, f) == v)
 
 
 class ForwardDescriptor(BaseModel):

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/src/ferro/session.py

@@ -17,7 +17,9 @@ class Session:
     _token: Any = None
 
     async def __aenter__(self) -> "Session":
-        self.session_id = _core_open_session(self.connection_name)
+        self.session_id, resolved_name = _core_open_session(self.connection_name)
+        if self.connection_name is None:
+            self.connection_name = resolved_name
         self._token = _CURRENT_SESSION.set(self)
         return self
 

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/src/operations.rs

@@ -825,9 +825,10 @@ pub fn rollback_transaction(
 
 #[pyfunction]
 #[pyo3(signature = (using=None))]
-pub fn open_session(using: Option<String>) -> PyResult<String> {
+pub fn open_session(using: Option<String>) -> PyResult<(String, String)> {
     let (connection_name, _) = active_connection_for_route(using)?;
-    Ok(register_session(connection_name))
+    let session_id = register_session(connection_name.clone());
+    Ok((session_id, connection_name))
 }
 
 #[pyfunction]

ferro_orm-0.12.1/tests/test_framework_predicates.py

@@ -0,0 +1,72 @@
+"""Regression tests for framework-internal predicate style (issue #121)."""
+
+import warnings
+from typing import Annotated
+
+import pytest
+
+import ferro
+
+
+pytestmark = pytest.mark.sqlite_only
+
+
+class FrameworkPredicateMarker(ferro.Model):
+    id: Annotated[int | None, ferro.FerroField(primary_key=True)] = None
+    name: str
+
+
+@pytest.fixture(autouse=True)
+def _ensure_models_registered():
+    from ferro.state import _MODEL_REGISTRY_PY
+
+    FrameworkPredicateMarker._reregister_ferro()
+    _MODEL_REGISTRY_PY[FrameworkPredicateMarker.__name__] = FrameworkPredicateMarker
+    yield
+
+
+def _operator_predicate_warnings(caught: list[warnings.WarningMessage]) -> list[str]:
+    return [
+        str(w.message)
+        for w in caught
+        if issubclass(w.category, DeprecationWarning)
+        and "Operator predicate style" in str(w.message)
+    ]
+
+
+@pytest.mark.asyncio
+async def test_framework_helpers_do_not_emit_operator_predicate_warnings(tmp_path):
+    db = tmp_path / "framework_predicates.db"
+    await ferro.connect(f"sqlite:{db}?mode=rwc", auto_migrate=True)
+
+    async with ferro.engines.session("default"):
+        widget = FrameworkPredicateMarker(id=1, name="demo")
+        await widget.save()
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            loaded = await FrameworkPredicateMarker.get_or_none(1)
+            assert loaded is not None
+            await loaded.refresh()
+            found, created = await FrameworkPredicateMarker.get_or_create(name="demo")
+            assert found is not None
+            assert created is False
+            await loaded.delete()
+
+        assert _operator_predicate_warnings(caught) == []
+
+
+@pytest.mark.asyncio
+async def test_model_connection_get_or_none_does_not_emit_operator_warnings(tmp_path):
+    db = tmp_path / "framework_predicates_bound.db"
+    await ferro.connect(f"sqlite:{db}?mode=rwc", auto_migrate=True)
+
+    async with ferro.engines.session("default"):
+        await FrameworkPredicateMarker.create(id=2, name="bound")
+
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            loaded = await FrameworkPredicateMarker.using("default").get_or_none(2)
+
+        assert loaded is not None
+        assert _operator_predicate_warnings(caught) == []

{ferro_orm-0.12.0 → ferro_orm-0.12.1}/tests/test_session.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import Annotated
 
 import pytest
@@ -85,6 +86,31 @@ async def test_explicit_session_override_beats_ambient(tmp_path):
             assert [row.label for row in rows] == ["app"]
 
 
+@pytest.mark.asyncio
+async def test_unnamed_session_binds_default_connection(tmp_path):
+    app_db = tmp_path / "app.db"
+    await ferro.connect(f"sqlite:{app_db}?mode=rwc", auto_migrate=True)
+
+    async with ferro.engines.session() as session:
+        assert session.connection_name == "default"
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("always", DeprecationWarning)
+            exists = await SessionMarker.where(
+                lambda t: t.label == "missing"
+            ).exists()
+            created = await SessionMarker.create(id=20, label="session-bound")
+
+        session_warnings = [
+            w
+            for w in caught
+            if issubclass(w.category, DeprecationWarning)
+            and "without an active session" in str(w.message)
+        ]
+        assert not session_warnings
+        assert exists is False
+        assert created.id == 20
+
+
 @pytest.mark.asyncio
 async def test_legacy_unqualified_operation_warns(tmp_path):
     app_db = tmp_path / "app.db"