ferro-orm 0.8.0__tar.gz → 0.9.0__tar.gz

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/.gitignore

@@ -242,6 +242,7 @@ __marimo__/
 ferro_test.db
 .cursorrules
 .cursor
+.context/
 playground.ipynb
 IMPLEMENTATION.md
 Cargo.lock

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/CHANGELOG.md

@@ -1,6 +1,25 @@
 # CHANGELOG
 
 
+## v0.9.0 (2026-05-09)
+
+### Chores
+
+- Gitignore .context and untrack committed artifacts
+  ([#49](https://github.com/syn54x/ferro-orm/pull/49),
+  [`cac6330`](https://github.com/syn54x/ferro-orm/commit/cac63304bbcf6bb3fad22037c33e6e60dcb8946e))
+
+### Features
+
+- Add get_or_none method
+  ([`0c81e9f`](https://github.com/syn54x/ferro-orm/commit/0c81e9f414074c9a3631eb94f3a8077d16671e41))
+
+### Testing
+
+- Add tests for explicit shadow fields
+  ([`78a3471`](https://github.com/syn54x/ferro-orm/commit/78a3471d55afec3b9b7da9f44e497ec521f7d1c0))
+
+
 ## v0.8.0 (2026-05-09)
 
 ### Features

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/Cargo.lock

@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.8.0"
+version = "0.9.0"
 dependencies = [
  "dashmap",
  "once_cell",

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ferro"
-version = "0.8.0"
+version = "0.9.0"
 edition = "2024"
 readme = "README.md"
 

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/PKG-INFO

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

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/TEST_RESULTS.md

@@ -36,7 +36,7 @@ All field types and constraints work as documented:
 All documented CRUD operations work correctly:
 
 - `Model.create()` ✅
-- `Model.get()` ✅
+- `Model.get()` / `Model.get_or_none()` ✅
 - `Model.all()` ✅
 - `instance.save()` ✅
 - `instance.delete()` ✅

ferro_orm-0.9.0/docs/api/exceptions.md

@@ -0,0 +1,15 @@
+# Exceptions
+
+Public exception types raised by Ferro’s ORM layer.
+
+::: ferro.exceptions.ModelDoesNotExist
+    options:
+      show_source: false
+      heading_level: 2
+      show_root_heading: true
+
+## See Also
+
+- [Queries](../guide/queries.md) — `Model.get` vs `Model.get_or_none`
+- [Model API](model.md)
+- [Mutations](../guide/mutations.md) — error handling patterns

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/api/model.md

@@ -8,6 +8,7 @@ Complete reference for the `Model` base class and related methods.
         - create
         - bulk_create
         - get
+        - get_or_none
         - where
         - select
         - all
@@ -25,5 +26,6 @@ Complete reference for the `Model` base class and related methods.
 ## See Also
 
 - [Models & Fields Guide](../guide/models-and-fields.md)
-- [Queries Guide](../guide/queries.md)
+- [Queries Guide](../guide/queries.md) — fetch by primary key (`get` / `get_or_none`)
+- [Exceptions](exceptions.md) — `ModelDoesNotExist`
 - [Mutations Guide](../guide/mutations.md)

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/api/utilities.md

@@ -57,14 +57,17 @@ from ferro import evict_instance
 # Evict user with ID=1
 evict_instance("User", 1)
 
-# Next fetch will hit database
+# Next fetch will hit database (raises ModelDoesNotExist if row was removed)
 user = await User.get(1)
 ```
 
+If the row may no longer exist, use `User.get_or_none(1)` or handle [`ModelDoesNotExist`](exceptions.md).
+
 See [Identity Map Concept](../concepts/identity-map.md) for when and why to evict instances.
 
 ## See Also
 
 - [Database Setup Guide](../guide/database.md) - Connection configuration
 - [Identity Map Concept](../concepts/identity-map.md) - Instance caching details
+- [Exceptions](exceptions.md) - `ModelDoesNotExist` and related types
 - [Schema Management](../guide/migrations.md) - Production migrations

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/changelog.md

@@ -7,7 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Breaking
+
+- `Model.get` and `Model.using(...).get` now return the concrete model type and raise `ModelDoesNotExist` when no row exists (previously they returned `T | None`). Use the new `get_or_none` for the old optional behavior.
+
 ### Added
+
+- `Model.get_or_none` and `Model.using(...).get_or_none` for primary-key lookup without raising.
+- `ModelDoesNotExist` (`LookupError` subclass with `.model` and `.pk`), exported from `ferro`. Documented under [Exceptions](api/exceptions.md).
 - Typed query predicates: `col()` wrapper and lambda predicate API on `Query.where`, `Relation.where`, and `Model.where` for static-typing-clean predicates without model annotation changes ([#48](https://github.com/syn54x/ferro-orm/pull/48)). See [Typed Query Predicates](concepts/query-typing.md).
 - `FieldProxy` is now generic (`FieldProxy[T]`); operator overloads are typed `T | FieldProxy[T] -> QueryNode`, `.like()` is gated to `FieldProxy[str]`.
 - New public symbols re-exported from `ferro.query`: `col`, `QueryProxy`, `Predicate`.

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/concepts/type-safety.md

@@ -57,16 +57,19 @@ class User(Model):
     username: str
     age: int
 
-# Type checker knows return type
+# Fetch by PK: definite model instance (raises ModelDoesNotExist if missing)
 user: User = await User.get(1)
 
+# Optional PK lookup
+maybe_user: User | None = await User.get_or_none(999)
+
 # Autocomplete works
 user.username  # ✓ Known attribute
 user.invalid   # ✗ Type error
 
 # Query results are typed
 users: list[User] = await User.all()
-first: User | None = await User.first()
+first: User | None = await User.where(User.username == "alice").first()
 ```
 
 ## IDE Autocomplete

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/guide/mutations.md

@@ -381,6 +381,23 @@ await User.bulk_create(users)
 !!! note "Exception Types"
     The documentation references exception types like `IntegrityError` and `ValidationError`. These exceptions come from the underlying database driver or Pydantic. Import paths may vary. Catch general `Exception` or check your specific database driver's exceptions.
 
+### Primary key lookup (`Model.get`)
+
+`Model.get(pk)` and `Model.using(...).get(pk)` raise [`ModelDoesNotExist`](../api/exceptions.md) when no row exists. Import it from `ferro`. For “maybe there is a row” flows (for example verifying a delete), use `get_or_none` instead of catching the exception.
+
+```python
+from ferro import ModelDoesNotExist
+
+try:
+    user = await User.get(user_id)
+except ModelDoesNotExist:
+    # e.model, e.pk
+    ...
+
+# Or, when None is the natural result:
+user = await User.get_or_none(user_id)
+```
+
 ### Unique Constraint Violations
 
 ```python

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/guide/queries.md

@@ -2,6 +2,29 @@
 
 Ferro provides a fluent, type-safe API for constructing and executing database queries. All queries are constructed in Python and executed by the high-performance Rust engine.
 
+## Fetch by primary key
+
+`Model.get(pk)` loads exactly one row by primary key and returns **your model type** (not `YourModel | None`). If no row exists, Ferro raises [`ModelDoesNotExist`](../api/exceptions.md), a subclass of `LookupError` with `.model` and `.pk` set—useful for HTTP 404s or structured logging.
+
+When a missing row is a normal outcome, use `Model.get_or_none(pk)`, which returns `YourModel | None` and never raises for “not found”. The same pair exists on [`Model.using("name")`](../howto/multiple-databases.md) for named connections.
+
+```python
+from ferro import ModelDoesNotExist
+
+user = await User.get(42)
+
+try:
+    user = await User.get(client_supplied_id)
+except ModelDoesNotExist:
+    ...  # e.g. return 404 from your HTTP layer
+
+draft = await User.get_or_none(999)  # None if no such row
+
+replica_view = await User.using("replica").get_or_none(1)
+```
+
+Lazy forward relations (e.g. `await post.author`) use optional fetch internally so a broken or missing FK still resolves to `None` instead of raising.
+
 ## Basic Filtering
 
 Use standard Python comparison operators on model fields to create filter conditions:

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/howto/multiple-databases.md

@@ -33,6 +33,10 @@ users = await User.all()
 # Specific database
 replica_users = await User.using("replica").all()
 analytics_data = await Metric.using("analytics").all()
+
+# Primary-key fetch on a named connection (same semantics as Model.get / get_or_none)
+user = await User.using("replica").get(1)  # raises ModelDoesNotExist if missing
+maybe = await User.using("replica").get_or_none(unknown_id)
 ```
 
 ## Transactions

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/docs/migration-sqlalchemy.md

@@ -69,6 +69,26 @@ users = result.scalars().all()
 users = await User.where(User.age >= 18).all()
 ```
 
+### Get by primary key
+
+SQLAlchemy’s `session.get(User, pk)` returns `None` when the row is missing. Ferro’s `await User.get(pk)` returns `User` and raises `ModelDoesNotExist` when absent. Use `await User.get_or_none(pk)` for the optional pattern.
+
+```python
+# SQLAlchemy
+user = await session.get(User, 1)
+
+# Ferro — raises if missing
+from ferro import ModelDoesNotExist
+
+try:
+    user = await User.get(1)
+except ModelDoesNotExist:
+    user = None
+
+# Ferro — optional (like session.get when no row)
+user = await User.get_or_none(1)
+```
+
 ## Relationships
 
 ### One-to-Many

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/mkdocs.yml

@@ -155,6 +155,7 @@ nav:
 
   - API Reference:
       - Model: api/model.md
+      - Exceptions: api/exceptions.md
       - Query: api/query.md
       - Fields: api/fields.md
       - Relationships: api/relationships.md

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/pyproject.toml

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

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/src/ferro/__init__.py

@@ -22,6 +22,7 @@ from ._core import (
     connect as _core_connect,
 )
 from .base import FerroField, FerroNullable, ForeignKey
+from .exceptions import ModelDoesNotExist
 from .fields import BackRef, Field, ManyToMany
 from .models import Model, transaction
 from .query import Relation
@@ -96,6 +97,7 @@ __all__ = [
     "connect",
     "PoolConfig",
     "Model",
+    "ModelDoesNotExist",
     "FerroField",
     "FerroNullable",
     "Field",

ferro_orm-0.9.0/src/ferro/exceptions.py

@@ -0,0 +1,17 @@
+"""ORM-specific exceptions."""
+
+from typing import Any
+
+
+class ModelDoesNotExist(LookupError):
+    """Raised when :meth:`~ferro.models.Model.get` finds no row for the primary key."""
+
+    model: type
+    pk: Any
+
+    def __init__(self, model_cls: type, pk: Any) -> None:
+        self.model = model_cls
+        self.pk = pk
+        super().__init__(
+            f"No {model_cls.__name__} record found for primary key {pk!r}"
+        )

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/src/ferro/models.py

@@ -31,6 +31,7 @@ from ._core import (
     transaction_connection_name,
 )
 from .base import ForeignKey, foreign_key_allows_none
+from .exceptions import ModelDoesNotExist
 from .metaclass import ModelMetaclass
 from .query import Query, QueryNode
 from .state import _CURRENT_TRANSACTION, _CURRENT_TRANSACTION_CONNECTION
@@ -260,7 +261,7 @@ class Model(BaseModel, metaclass=ModelMetaclass):
             None
 
         Examples:
-            >>> user = await User.get(1)
+            >>> user = await User.get_or_none(1)
             >>> if user:
             ...     await user.delete()
         """
@@ -361,20 +362,39 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         return results
 
     @classmethod
-    async def get(cls, pk: Any) -> Self | None:
-        """Fetch one record by primary key value
+    async def get(cls, pk: Any) -> Self:
+        """Fetch one record by primary key value.
 
         Args:
             pk: Primary key value to fetch a single record.
 
         Returns:
-            The matching model instance, or None when no record exists.
+            The matching model instance.
+
+        Raises:
+            ModelDoesNotExist: When no row exists for this primary key. Use
+                :meth:`get_or_none` if you need optional lookup without raising.
 
         Examples:
             >>> user = await User.get(1)
-            >>> user is None or isinstance(user, User)
+            >>> isinstance(user, User)
             True
         """
+        instance = await cls.get_or_none(pk)
+        if instance is None:
+            raise ModelDoesNotExist(cls, pk)
+        return instance
+
+    @classmethod
+    async def get_or_none(cls, pk: Any) -> Self | None:
+        """Fetch one record by primary key, or return None if no row exists.
+
+        Args:
+            pk: Primary key value to fetch a single record.
+
+        Returns:
+            The matching model instance, or None when no record exists.
+        """
         pk_field_name = cls._primary_key_field_name()
         if pk_field_name is None:
             raise RuntimeError(f"Model {cls.__name__} does not define a primary key")
@@ -395,8 +415,7 @@ class Model(BaseModel, metaclass=ModelMetaclass):
 
         Examples:
             >>> user = await User.get(1)
-            >>> if user:
-            ...     await user.refresh()
+            >>> await user.refresh()
         """
         pk_field_name = self.__class__._primary_key_field_name()
         pk_val = getattr(self, pk_field_name) if pk_field_name is not None else None
@@ -579,7 +598,7 @@ class ModelConnection[M: Model]:
 
     Generic over the concrete model class so that every accessor preserves
     the bound type — e.g. ``Transcript.using("service").get(pk)`` resolves
-    to ``Transcript | None`` rather than ``Model | None``.
+    to ``Transcript`` rather than ``Model``.
     """
 
     def __init__(self, model_cls: type[M], connection_name: str) -> None:
@@ -600,14 +619,25 @@ class ModelConnection[M: Model]:
     def where(self, node: QueryNode) -> Query[M]:
         return self.select().where(node)
 
-    async def get(self, pk: Any) -> M | None:
+    async def get(self, pk: Any) -> M:
+        instance = await self.get_or_none(pk)
+        if instance is None:
+            raise ModelDoesNotExist(self.model_cls, pk)
+        return instance
+
+    async def get_or_none(self, pk: Any) -> M | None:
         pk_field_name = self.model_cls._primary_key_field_name()
         if pk_field_name is None:
             raise RuntimeError(
                 f"Model {self.model_cls.__name__} does not define a primary key"
             )
 
-        return await self.where(getattr(self.model_cls, pk_field_name) == pk).first()
+        instance = await self.where(
+            getattr(self.model_cls, pk_field_name) == pk
+        ).first()
+        if instance:
+            self.model_cls._fix_types(instance)
+        return instance
 
     async def bulk_create(self, instances: list[M]) -> int:
         return await self.model_cls.bulk_create(instances, using=self._connection_name)

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/src/ferro/relations/descriptors.py

@@ -109,7 +109,7 @@ class ForwardDescriptor(BaseModel):
 
             origin = _instance_origin_outside_transaction(instance)
             if origin is not None:
-                return await self._target_model.using(origin).get(id_val)
-            return await self._target_model.get(id_val)
+                return await self._target_model.using(origin).get_or_none(id_val)
+            return await self._target_model.get_or_none(id_val)
 
         return _fetch()

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_alembic_bridge.py

@@ -16,6 +16,7 @@ from ferro import (
     reset_engine,
 )
 from ferro.migrations import get_metadata
+from ferro.schema_metadata import build_model_schema
 
 
 @pytest.fixture(autouse=True)
@@ -179,3 +180,76 @@ def test_on_delete_translation():
     fk = list(product_table.c.category_id.foreign_keys)[0]
     assert fk.ondelete == "SET NULL"
     assert product_table.c.category_id.nullable is True
+
+
+def test_explicit_foreign_key_shadow_id_no_duplicate_alembic_columns():
+    """Declaring ``{relation}_id`` for static checkers must not duplicate DDL columns.
+
+    Ferro injects a shadow ``*_id`` for every :class:`~ferro.base.ForeignKey`. Some
+    type checkers (for example Ty) do not see metaclass-injected fields, so users may
+    duplicate the declaration in the class body. That must still produce exactly one
+    JSON-schema property and one SQLAlchemy column for Alembic autogenerate.
+    """
+
+    class TyShadowFkJobRole(Model):
+        id: Annotated[int | None, FerroField(primary_key=True)] = None
+        name: str
+        scorecards: Relation[list["TyShadowFkScorecard"]] = BackRef()
+
+    class TyShadowFkScorecard(Model):
+        id: Annotated[int | None, FerroField(primary_key=True)] = None
+        title: str
+        job_role: Annotated[TyShadowFkJobRole, ForeignKey(related_name="scorecards")]
+        job_role_id: int | None = None
+
+    assert list(TyShadowFkScorecard.model_fields).count("job_role_id") == 1
+
+    schema = build_model_schema(TyShadowFkScorecard)
+    props = schema["properties"]
+    assert "job_role_id" in props
+    assert sum(1 for k in props if k == "job_role_id") == 1
+    fk_meta = props["job_role_id"].get("foreign_key") or {}
+    assert fk_meta.get("to_table") == "tyshadowfkjobrole"
+
+    metadata = get_metadata()
+    tbl = metadata.tables["tyshadowfkscorecard"]
+    assert list(tbl.columns.keys()).count("job_role_id") == 1
+    col = tbl.c.job_role_id
+    fks = list(col.foreign_keys)
+    assert len(fks) == 1
+    assert fks[0].target_fullname == "tyshadowfkjobrole.id"
+
+
+@pytest.mark.asyncio
+@pytest.mark.backend_matrix
+async def test_explicit_foreign_key_shadow_id_auto_migrate_roundtrip(db_url):
+    """Runtime migrate + ORM must treat explicit ``*_id`` as the single FK column."""
+
+    from ferro import connect
+
+    class TyRoundJobRole(Model):
+        id: Annotated[int | None, FerroField(primary_key=True)] = None
+        name: str
+        scorecards: Relation[list["TyRoundScorecard"]] = BackRef()
+
+    class TyRoundScorecard(Model):
+        id: Annotated[int | None, FerroField(primary_key=True)] = None
+        title: str
+        job_role: Annotated[TyRoundJobRole, ForeignKey(related_name="scorecards")]
+        job_role_id: int | None = None
+
+    await connect(db_url, auto_migrate=True)
+
+    role = await TyRoundJobRole.create(name="ic")
+    card = await TyRoundScorecard.create(title="card-a", job_role=role)
+    assert card.job_role_id == role.id
+
+    by_attr = await TyRoundScorecard.where(
+        TyRoundScorecard.job_role_id == role.id
+    ).first()
+    assert by_attr is not None and by_attr.id == card.id
+
+    by_lambda = await TyRoundScorecard.where(
+        lambda s: s.job_role_id == role.id
+    ).first()
+    assert by_lambda is not None and by_lambda.id == card.id

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_connection.py

@@ -289,7 +289,7 @@ async def test_service_loaded_instance_delete_uses_origin_connection(tmp_path):
     await service_row.delete()
 
     assert await ConnectionRouteMarker.get(1) is not None
-    assert await ConnectionRouteMarker.using("service").get(1) is None
+    assert await ConnectionRouteMarker.using("service").get_or_none(1) is None
 
 
 @pytest.mark.asyncio

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_crud.py

@@ -1,7 +1,7 @@
 import pytest
 from pydantic import Field
 import ferro
-from ferro import Model
+from ferro import Model, ModelDoesNotExist
 
 pytestmark = pytest.mark.backend_matrix
 
@@ -158,7 +158,7 @@ async def test_model_get_invalid_usage(db_url):
 
 @pytest.mark.asyncio
 async def test_model_get_not_found(db_url):
-    """Test that get() returns None if the record does not exist."""
+    """Test that get() raises when the record does not exist."""
 
     class CrudUser(Model):
         id: int = Field(default=None, json_schema_extra={"primary_key": True})
@@ -166,5 +166,8 @@ async def test_model_get_not_found(db_url):
         email: str
 
     await ferro.connect(db_url, auto_migrate=True)
-    user = await CrudUser.get(9999)
-    assert user is None
+    with pytest.raises(ModelDoesNotExist) as exc_info:
+        await CrudUser.get(9999)
+    assert exc_info.value.model is CrudUser
+    assert exc_info.value.pk == 9999
+    assert await CrudUser.get_or_none(9999) is None

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_deletion.py

@@ -27,7 +27,7 @@ async def test_instance_delete(db_url):
     await user.delete()
 
     # Verify it's gone from DB
-    assert await DeletableUser.get(user_id) is None
+    assert await DeletableUser.get_or_none(user_id) is None
 
     # Verify it's gone from Identity Map (fetching again should return None)
     # Note: the 'user' object still exists in Python memory, but it's disconnected from the DB.
@@ -84,4 +84,4 @@ async def test_delete_evicts_identity_map(db_url):
     await DeletableUser.where(DeletableUser.id == user_id).delete()
 
     # A fresh 'get' should NOT return the old 'user' object (it should be None)
-    assert await DeletableUser.get(user_id) is None
+    assert await DeletableUser.get_or_none(user_id) is None

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_documentation_features.py

@@ -254,8 +254,7 @@ async def test_delete_method(db_url):
 
     await user.delete()
 
-    fetched = await User.get(user_id)
-    assert fetched is None
+    assert await User.get_or_none(user_id) is None
 
 
 @pytest.mark.asyncio

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_named_connections_integration.py

@@ -35,7 +35,8 @@ if TYPE_CHECKING:
             bound.where(NamedSmokeMarker.id == 1),  # type: ignore[arg-type]
             "Query[NamedSmokeMarker]",
         )
-        assert_type(await bound.get(1), NamedSmokeMarker | None)
+        assert_type(await bound.get(1), NamedSmokeMarker)
+        assert_type(await bound.get_or_none(1), NamedSmokeMarker | None)
         assert_type(await bound.bulk_create([]), int)
         assert_type(
             await bound.get_or_create(label="x"),
@@ -96,7 +97,7 @@ async def test_named_connections_smoke_matrix_sqlite(tmp_path):
 
     assert await delete_record("NamedSmokeMarker", "1", using="service") is True
     assert await NamedSmokeMarker.get(1) is app_row
-    assert await NamedSmokeMarker.using("service").get(1) is None
+    assert await NamedSmokeMarker.using("service").get_or_none(1) is None
 
 
 @pytest.mark.asyncio

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/tests/test_transactions.py

@@ -135,7 +135,7 @@ async def test_instance_methods_loaded_inside_transaction_inherit_transaction(db
 
         await loaded.delete()
 
-    assert await TxInstanceMethodUser.get(1) is None
+    assert await TxInstanceMethodUser.get_or_none(1) is None
 
 
 @pytest.mark.asyncio

{ferro_orm-0.8.0 → ferro_orm-0.9.0}/uv.lock

@@ -537,7 +537,7 @@ wheels = [
 
 [[package]]
 name = "ferro-orm"
-version = "0.7.0"
+version = "0.8.0"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },