corvic-engine 0.3.0rc82__cp38-abi3-win_amd64.whl → 0.3.0rc84__cp38-abi3-win_amd64.whl

corvic/{model → emodel}/_source.py

@@ -14,14 +14,14 @@ import sqlalchemy.orm as sa_orm
 from sqlalchemy.orm.interfaces import LoaderOption
 
 from corvic import eorm, op_graph, system
-from corvic.model._base_model import BelongsToRoomModel
-from corvic.model._defaults import Defaults
-from corvic.model._proto_orm_convert import (
+from corvic.emodel._base_model import StandardModel
+from corvic.emodel._defaults import Defaults
+from corvic.emodel._proto_orm_convert import (
     source_delete_orms,
     source_orm_to_proto,
     source_proto_to_orm,
 )
-from corvic.model._resource import Resource, ResourceID
+from corvic.emodel._resource import Resource, ResourceID
 from corvic.result import InvalidArgumentError, NotFoundError, Ok
 from corvic.table import Table
 from corvic_generated.model.v1alpha import models_pb2
@@ -45,7 +45,7 @@ def foreign_key(
             )
 
 
-class Source(BelongsToRoomModel[SourceID, models_pb2.Source, eorm.Source]):
+class Source(StandardModel[SourceID, models_pb2.Source, eorm.Source]):
     """Sources describe how resources should be treated.
 
     Example:
@@ -261,8 +261,8 @@ class Source(BelongsToRoomModel[SourceID, models_pb2.Source, eorm.Source]):
         Example:
         >>> with_feature_types(
         >>>        {
-        >>>            "id": corvic.model.feature_type.primary_key(),
-        >>>            "customer_id": corvic.model.feature_type.foreign_key(
+        >>>            "id": corvic.emodel.feature_type.primary_key(),
+        >>>            "customer_id": corvic.emodel.feature_type.foreign_key(
         >>>                customer_source.id
         >>>            ),
         >>>        },

corvic/{model → emodel}/_space.py

@@ -14,10 +14,10 @@ import sqlalchemy as sa
 from sqlalchemy import orm as sa_orm
 
 from corvic import eorm, op_graph, system
-from corvic.model._base_model import BelongsToRoomModel
-from corvic.model._defaults import Defaults
-from corvic.model._feature_view import FeatureView, FeatureViewEdgeTableMetadata
-from corvic.model._proto_orm_convert import (
+from corvic.emodel._base_model import StandardModel
+from corvic.emodel._defaults import Defaults
+from corvic.emodel._feature_view import FeatureView, FeatureViewEdgeTableMetadata
+from corvic.emodel._proto_orm_convert import (
     space_delete_orms,
     space_orm_to_proto,
     space_proto_to_orm,
@@ -53,13 +53,13 @@ name_to_proto_embedding_model = {
 def image_model_proto_to_name(image_model: embedding_models_pb2.ImageModel):
     match image_model:
         case embedding_models_pb2.IMAGE_MODEL_CUSTOM:
-            return Ok("random")
+            return Ok(system.RandomImageEmbedder.model_name())
         case embedding_models_pb2.IMAGE_MODEL_CLIP:
-            return Ok("openai/clip-vit-base-patch32")
+            return Ok(system.Clip.model_name())
         case embedding_models_pb2.IMAGE_MODEL_IDENTITY:
-            return Ok("identity")
+            return Ok(system.IdentityImageEmbedder.model_name())
         case embedding_models_pb2.IMAGE_MODEL_SIGLIP2:
-            return Ok("google/siglip2-base-patch16-512")
+            return Ok(system.SigLIP2.model_name())
         case embedding_models_pb2.IMAGE_MODEL_UNSPECIFIED:
             return Ok("")
         case _:
@@ -114,7 +114,7 @@ name_to_proto_image_model = {
 }
 
 
-class Space(BelongsToRoomModel[SpaceID, models_pb2.Space, eorm.Space]):
+class Space(StandardModel[SpaceID, models_pb2.Space, eorm.Space]):
     """Spaces apply embedding methods to FeatureViews.
 
     Example:

corvic/system/__init__.py

@@ -22,6 +22,7 @@ from corvic.system._image_embedder import (
     CombinedImageEmbedder,
     IdentityImageEmbedder,
     RandomImageEmbedder,
+    SigLIP2,
     image_from_bytes,
 )
 from corvic.system._planner import OpGraphPlanner, ValidateFirstExecutor
@@ -88,6 +89,7 @@ __all__ = [
     "OpGraphPlanner",
     "RandomImageEmbedder",
     "RandomTextEmbedder",
+    "SigLIP2",
     "SigLIP2Text",
     "StagingDB",
     "StorageManager",

corvic/system/_embedder.py

@@ -71,6 +71,9 @@ class EmbedImageResult:
 class ImageEmbedder(Protocol):
     """Use a model to embed text."""
 
+    @classmethod
+    def model_name(cls) -> str: ...
+
     def embed(
         self, context: EmbedImageContext
     ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError: ...

corvic/system/_image_embedder.py

@@ -27,6 +27,10 @@ class RandomImageEmbedder(ImageEmbedder):
     Useful for testing.
     """
 
+    @classmethod
+    def model_name(cls) -> str:
+        return "random"
+
     def embed(
         self, context: EmbedImageContext
     ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
@@ -82,6 +86,10 @@ class LoadedModels:
 class HFModelImageEmbedder(ImageEmbedder):
     """Generic image embedder from hugging face models."""
 
+    @classmethod
+    @abc.abstractmethod
+    def model_revision(cls) -> str: ...
+
     @abc.abstractmethod
     def _load_models(self) -> LoadedModels: ...
 
@@ -165,7 +173,17 @@ class Clip(HFModelImageEmbedder):
     overcoming several major challenges in computer vision.
     """
 
+    @classmethod
+    def model_name(cls) -> str:
+        return "openai/clip-vit-base-patch32"
+
+    @classmethod
+    def model_revision(cls) -> str:
+        return "5812e510083bb2d23fa43778a39ac065d205ed4d"
+
     def _load_models(self) -> LoadedModels:
+        from transformers.models.auto.modeling_auto import AutoModel
+        from transformers.models.auto.processing_auto import AutoProcessor
         from transformers.models.clip import (
             CLIPModel,
             CLIPProcessor,
@@ -174,15 +192,15 @@ class Clip(HFModelImageEmbedder):
         model = cast(
             AutoModel,
             CLIPModel.from_pretrained(  # pyright: ignore[reportUnknownMemberType]
-                pretrained_model_name_or_path="openai/clip-vit-base-patch32",
-                revision="5812e510083bb2d23fa43778a39ac065d205ed4d",
+                pretrained_model_name_or_path=self.model_name(),
+                revision=self.model_revision(),
             ),
         )
         processor = cast(
             AutoProcessor,
             CLIPProcessor.from_pretrained(  # pyright: ignore[reportUnknownMemberType]
-                pretrained_model_name_or_path="openai/clip-vit-base-patch32",
-                revision="5812e510083bb2d23fa43778a39ac065d205ed4d",
+                pretrained_model_name_or_path=self.model_name(),
+                revision=self.model_revision(),
                 use_fast=False,
             ),
         )
@@ -192,6 +210,14 @@ class Clip(HFModelImageEmbedder):
 class SigLIP2(HFModelImageEmbedder):
     """SigLIP2 image embedder."""
 
+    @classmethod
+    def model_name(cls) -> str:
+        return "google/siglip2-base-patch16-512"
+
+    @classmethod
+    def model_revision(cls) -> str:
+        return "a89f5c5093f902bf39d3cd4d81d2c09867f0724b"
+
     def _load_models(self):
         from transformers.models.auto.modeling_auto import AutoModel
         from transformers.models.auto.processing_auto import AutoProcessor
@@ -199,16 +225,16 @@ class SigLIP2(HFModelImageEmbedder):
         model = cast(
             AutoModel,
             AutoModel.from_pretrained(  # pyright: ignore[reportUnknownMemberType]
-                pretrained_model_name_or_path="google/siglip2-base-patch16-512",
-                revision="a89f5c5093f902bf39d3cd4d81d2c09867f0724b",
+                pretrained_model_name_or_path=self.model_name(),
+                revision=self.model_revision(),
                 device_map="auto",
             ),
         )
         processor = cast(
             AutoProcessor,
             AutoProcessor.from_pretrained(  # pyright: ignore[reportUnknownMemberType]
-                pretrained_model_name_or_path="google/siglip2-base-patch16-512",
-                revision="a89f5c5093f902bf39d3cd4d81d2c09867f0724b",
+                pretrained_model_name_or_path=self.model_name(),
+                revision=self.model_revision(),
                 use_fast=True,
             ),
         )
@@ -216,23 +242,25 @@ class SigLIP2(HFModelImageEmbedder):
 
 
 class CombinedImageEmbedder(ImageEmbedder):
+    @classmethod
+    def model_name(cls) -> str:
+        raise InvalidArgumentError(
+            "CombinedImageEmbedder does not have a specific model name"
+        )
+
     def __init__(self):
-        self._clip_embedder = Clip()
-        self._siglip2_embedder = SigLIP2()
-        self._random_embedder = RandomImageEmbedder()
+        self._embedders = {
+            emb.model_name(): emb()
+            for emb in [Clip, SigLIP2, RandomImageEmbedder, IdentityImageEmbedder]
+        }
 
     def embed(
         self, context: EmbedImageContext
     ) -> Ok[EmbedImageResult] | InvalidArgumentError | InternalError:
-        match context.model_name:
-            case "random":
-                return self._random_embedder.embed(context)
-            case "clip":
-                return self._clip_embedder.embed(context)
-            case "siglip2":
-                return self._siglip2_embedder.embed(context)
-            case _:
-                return InvalidArgumentError(f"Unknown model name {context.model_name}")
+        embedder = self._embedders.get(context.model_name, None)
+        if not embedder:
+            return InvalidArgumentError(f"Unknown model name {context.model_name}")
+        return embedder.embed(context)
 
     async def aembed(
         self,
@@ -254,6 +282,10 @@ class IdentityImageEmbedder(ImageEmbedder):
         - The resulting list is truncated or padded to match the expected vector length.
     """
 
+    @classmethod
+    def model_name(cls) -> str:
+        return "identity"
+
     def _image_to_embedding(
         self, image: "Image.Image", vector_length: int, *, normalization: bool = False
     ) -> list[float]:

corvic/transfer/__init__.py

@@ -0,0 +1,43 @@
+"""Common machinery for using protocol buffers as transfer objects."""
+
+from corvic.transfer._common_transformations import (
+    UNCOMMITTED_ID_PREFIX,
+    OrmIdT,
+    generate_uncommitted_id_str,
+    non_empty_timestamp_to_datetime,
+    translate_orm_id,
+)
+from corvic.transfer._orm_backed_proto import (
+    HasIdOrmBackedProto,
+    HasProtoSelf,
+    OrmBackedProto,
+    OrmHasIdModel,
+    OrmHasIdT,
+    OrmModel,
+    OrmT,
+    ProtoHasIdModel,
+    ProtoHasIdT,
+    ProtoModel,
+    ProtoT,
+    UsesOrmID,
+)
+
+__all__ = [
+    "UNCOMMITTED_ID_PREFIX",
+    "generate_uncommitted_id_str",
+    "OrmIdT",
+    "OrmModel",
+    "UsesOrmID",
+    "OrmT",
+    "ProtoT",
+    "HasProtoSelf",
+    "ProtoModel",
+    "ProtoHasIdT",
+    "OrmBackedProto",
+    "ProtoHasIdModel",
+    "OrmHasIdT",
+    "OrmHasIdModel",
+    "HasIdOrmBackedProto",
+    "translate_orm_id",
+    "non_empty_timestamp_to_datetime",
+]

corvic/transfer/_common_transformations.py

@@ -0,0 +1,37 @@
+import datetime
+import uuid
+from typing import Any, TypeVar
+
+from google.protobuf import timestamp_pb2
+
+from corvic import orm
+from corvic.result import Ok
+
+OrmIdT = TypeVar("OrmIdT", bound=orm.BaseID[Any])
+
+UNCOMMITTED_ID_PREFIX = "__uncommitted_object-"
+
+
+def generate_uncommitted_id_str():
+    return f"{UNCOMMITTED_ID_PREFIX}{uuid.uuid4()}"
+
+
+def translate_orm_id(
+    obj_id: str, id_class: type[OrmIdT]
+) -> Ok[OrmIdT | None] | orm.InvalidORMIdentifierError:
+    if obj_id.startswith(UNCOMMITTED_ID_PREFIX):
+        return Ok(None)
+    parsed_obj_id = id_class(obj_id)
+    match parsed_obj_id.to_db():
+        case orm.InvalidORMIdentifierError() as err:
+            return err
+        case Ok():
+            return Ok(parsed_obj_id)
+
+
+def non_empty_timestamp_to_datetime(
+    timestamp: timestamp_pb2.Timestamp,
+) -> datetime.datetime | None:
+    if timestamp != timestamp_pb2.Timestamp():
+        return timestamp.ToDatetime(tzinfo=datetime.UTC)
+    return None

corvic/{model/_base_model.py → transfer/_orm_backed_proto.py}

@@ -3,66 +3,59 @@ import contextlib
 import copy
 import datetime
 import functools
-import uuid
 from collections.abc import Callable, Iterable, Iterator, Sequence
-from typing import Final, Generic, Self
+from typing import Any, Final, Generic, Protocol, Self, TypeVar
 
 import sqlalchemy as sa
 import sqlalchemy.orm as sa_orm
 import structlog
 from google.protobuf import timestamp_pb2
 
-from corvic import eorm, system
-from corvic.model._proto_orm_convert import (
-    UNCOMMITTED_ID_PREFIX,
-    IdType,
-    OrmBelongsToOrgObj,
-    OrmBelongsToRoomObj,
-    OrmObj,
-    ProtoBelongsToOrgObj,
-    ProtoBelongsToRoomObj,
-    ProtoObj,
-)
-from corvic.result import (
-    InvalidArgumentError,
-    NotFoundError,
-    Ok,
-    UnavailableError,
+from corvic import orm, system
+from corvic.result import InvalidArgumentError, NotFoundError, Ok, UnavailableError
+from corvic.transfer._common_transformations import (
+    OrmIdT,
+    generate_uncommitted_id_str,
+    non_empty_timestamp_to_datetime,
 )
 
 _logger = structlog.get_logger()
 
-_EMPTY_PROTO_TIMESTAMP = timestamp_pb2.Timestamp(seconds=0, nanos=0)
 
+class OrmModel(Protocol):
+    @sa.ext.hybrid.hybrid_property
+    def created_at(self) -> datetime.datetime | None: ...
+
+    @created_at.inplace.expression
+    @classmethod
+    def _created_at_expression(cls): ...
+
+
+class OrmHasIdModel(OrmModel, Protocol[OrmIdT]):
+    id: sa_orm.Mapped[OrmIdT | None]
 
-def non_empty_timestamp_to_datetime(
-    timestamp: timestamp_pb2.Timestamp,
-) -> datetime.datetime | None:
-    if timestamp != _EMPTY_PROTO_TIMESTAMP:
-        return timestamp.ToDatetime(tzinfo=datetime.UTC)
-    return None
 
+OrmT = TypeVar("OrmT", bound=OrmModel)
+OrmHasIdT = TypeVar("OrmHasIdT", bound=OrmHasIdModel[Any])
 
-def _generate_uncommitted_id_str():
-    return f"{UNCOMMITTED_ID_PREFIX}{uuid.uuid4()}"
 
+class ProtoModel(Protocol):
+    created_at: timestamp_pb2.Timestamp
 
-@contextlib.contextmanager
-def _create_or_join_session(
-    client: system.Client, existing_session: sa_orm.Session | None
-) -> Iterator[sa_orm.Session]:
-    if existing_session:
-        yield existing_session
-    else:
-        with eorm.Session(client.sa_engine) as session:
-            yield session
 
+class ProtoHasIdModel(ProtoModel, Protocol):
+    id: str
 
-class HasProtoSelf(Generic[ProtoObj], abc.ABC):
+
+ProtoT = TypeVar("ProtoT", bound=ProtoModel)
+ProtoHasIdT = TypeVar("ProtoHasIdT", bound=ProtoHasIdModel)
+
+
+class HasProtoSelf(Generic[ProtoT], abc.ABC):
     client: Final[system.Client]
-    proto_self: Final[ProtoObj]
+    proto_self: Final[ProtoT]
 
-    def __init__(self, client: system.Client, proto_self: ProtoObj):
+    def __init__(self, client: system.Client, proto_self: ProtoT):
         self.proto_self = proto_self
         self.client = client
 
@@ -71,22 +64,22 @@ class HasProtoSelf(Generic[ProtoObj], abc.ABC):
         return non_empty_timestamp_to_datetime(self.proto_self.created_at)
 
 
-class UsesOrmID(Generic[IdType, ProtoObj], HasProtoSelf[ProtoObj]):
-    def __init__(self, client: system.Client, proto_self: ProtoObj):
+class UsesOrmID(Generic[OrmIdT, ProtoHasIdT], HasProtoSelf[ProtoHasIdT]):
+    def __init__(self, client: system.Client, proto_self: ProtoHasIdT):
         if not proto_self.id:
-            proto_self.id = _generate_uncommitted_id_str()
+            proto_self.id = generate_uncommitted_id_str()
         super().__init__(client, proto_self)
 
     @classmethod
     @abc.abstractmethod
-    def id_class(cls) -> type[IdType]: ...
+    def id_class(cls) -> type[OrmIdT]: ...
 
     @functools.cached_property
-    def id(self) -> IdType:
+    def id(self) -> OrmIdT:
         return self.id_class().from_str(self.proto_self.id)
 
 
-class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
+class OrmBackedProto(Generic[ProtoT, OrmT], HasProtoSelf[ProtoT]):
     """Base for orm wrappers providing a unified update mechanism."""
 
     @property
@@ -95,51 +88,29 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
 
     @classmethod
     @abc.abstractmethod
-    def orm_class(cls) -> type[OrmObj]: ...
+    def orm_class(cls) -> type[OrmT]: ...
 
     @classmethod
     @abc.abstractmethod
-    def orm_to_proto(cls, orm_obj: OrmObj) -> ProtoObj: ...
+    def orm_to_proto(cls, orm_obj: OrmT) -> ProtoT: ...
 
     @classmethod
     @abc.abstractmethod
     def proto_to_orm(
-        cls, proto_obj: ProtoObj, session: eorm.Session
-    ) -> Ok[OrmObj] | InvalidArgumentError: ...
-
-    @classmethod
-    @abc.abstractmethod
-    def delete_by_ids(
-        cls, ids: Sequence[IdType], session: eorm.Session
-    ) -> Ok[None] | InvalidArgumentError: ...
-
-    @classmethod
-    def load_proto_for(
-        cls,
-        obj_id: IdType,
-        client: system.Client,
-        existing_session: sa_orm.Session | None = None,
-    ) -> Ok[ProtoObj] | NotFoundError:
-        """Create a model object by loading it from the database."""
-        with _create_or_join_session(client, existing_session) as session:
-            orm_self = session.get(cls.orm_class(), obj_id)
-            if orm_self is None:
-                return NotFoundError("object with given id does not exist", id=obj_id)
-            proto_self = cls.orm_to_proto(orm_self)
-        return Ok(proto_self)
+        cls, proto_obj: ProtoT, session: orm.Session
+    ) -> Ok[OrmT] | InvalidArgumentError: ...
 
     @classmethod
     def _generate_query_results(
-        cls, query: sa.Select[tuple[OrmObj]], session: sa_orm.Session
-    ) -> Iterator[OrmObj]:
+        cls, query: sa.Select[tuple[OrmT]], session: sa_orm.Session
+    ) -> Iterator[OrmT]:
         it = iter(session.scalars(query))
         while True:
             try:
                 yield from it
             except Exception:
                 _logger.exception(
-                    "omitting source from list: "
-                    + "failed to parse source from database entry",
+                    "omitting model from list: " + "failed to parse database entry",
                 )
             else:
                 break
@@ -155,31 +126,27 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
         client: system.Client,
         *,
         limit: int | None = None,
-        room_id: eorm.RoomID | None = None,
         created_before: datetime.datetime | None = None,
-        ids: Iterable[IdType] | None = None,
         additional_query_transform: Callable[
-            [sa.Select[tuple[OrmObj]]], sa.Select[tuple[OrmObj]]
+            [sa.Select[tuple[OrmT]]], sa.Select[tuple[OrmT]]
         ]
         | None = None,
         existing_session: sa_orm.Session | None = None,
-    ) -> Ok[list[ProtoObj]] | NotFoundError | InvalidArgumentError:
+    ) -> Ok[list[ProtoT]] | NotFoundError | InvalidArgumentError:
         """List sources that exist in storage."""
         orm_class = cls.orm_class()
-        with _create_or_join_session(client, existing_session) as session:
+        with (
+            contextlib.nullcontext(existing_session)
+            if existing_session
+            else orm.Session(client.sa_engine) as session
+        ):
             query = sa.select(orm_class).order_by(sa.desc(orm_class.created_at))
             if limit is not None:
                 if limit < 0:
                     return InvalidArgumentError("limit cannot be negative")
                 query = query.limit(limit)
-            if room_id:
-                if session.get(eorm.Room, room_id) is None:
-                    return NotFoundError("room not found", room_id=room_id)
-                query = query.filter_by(room_id=room_id)
             if created_before:
                 query = query.filter(orm_class.created_at < created_before)
-            if ids is not None:
-                query = query.filter(orm_class.id.in_(ids))
             if additional_query_transform:
                 query = additional_query_transform(query)
             extra_orm_loaders = cls.orm_load_options()
@@ -198,7 +165,7 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
         This overwrites the entry at id in the database so that future readers will see
         this object. One of `id` or `derived_from_id` cannot be empty or None.
         """
-        with eorm.Session(self.client.sa_engine) as session:
+        with orm.Session(self.client.sa_engine) as session:
             try:
                 new_orm_self = self.proto_to_orm(
                     self.proto_self, session
@@ -230,7 +197,7 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
         return InvalidArgumentError.from_(err)
 
     def add_to_session(
-        self, session: eorm.Session
+        self, session: orm.Session
     ) -> Ok[None] | InvalidArgumentError | UnavailableError:
         """Like commit, but just calls session.flush to check for database errors.
 
@@ -246,8 +213,39 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
             return self._dbapi_error_to_result(err)
         return Ok(None)
 
+
+class HasIdOrmBackedProto(
+    Generic[OrmIdT, ProtoHasIdT, OrmHasIdT],
+    UsesOrmID[OrmIdT, ProtoHasIdT],
+    OrmBackedProto[ProtoHasIdT, OrmHasIdT],
+):
+    @classmethod
+    @abc.abstractmethod
+    def delete_by_ids(
+        cls, ids: Sequence[OrmIdT], session: orm.Session
+    ) -> Ok[None] | InvalidArgumentError: ...
+
+    @classmethod
+    def load_proto_for(
+        cls,
+        obj_id: OrmIdT,
+        client: system.Client,
+        existing_session: sa_orm.Session | None = None,
+    ) -> Ok[ProtoHasIdT] | NotFoundError:
+        """Create a model object by loading it from the database."""
+        with (
+            contextlib.nullcontext(existing_session)
+            if existing_session
+            else orm.Session(client.sa_engine) as session
+        ):
+            orm_self = session.get(cls.orm_class(), obj_id)
+            if orm_self is None:
+                return NotFoundError("object with given id does not exist", id=obj_id)
+            proto_self = cls.orm_to_proto(orm_self)
+        return Ok(proto_self)
+
     def delete(self) -> Ok[Self] | NotFoundError | InvalidArgumentError:
-        with eorm.Session(
+        with orm.Session(
             self.client.sa_engine, expire_on_commit=False, autoflush=False
         ) as session:
             try:
@@ -270,24 +268,33 @@ class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
                 )
             )
 
-
-class BelongsToOrgModel(
-    Generic[IdType, ProtoBelongsToOrgObj, OrmBelongsToOrgObj],
-    BaseModel[IdType, ProtoBelongsToOrgObj, OrmBelongsToOrgObj],
-):
-    """Base for orm wrappers with org mixin providing a unified update mechanism."""
-
-    @property
-    def org_id(self) -> eorm.OrgID:
-        return eorm.OrgID().from_str(self.proto_self.org_id)
-
-
-class BelongsToRoomModel(
-    Generic[IdType, ProtoBelongsToRoomObj, OrmBelongsToRoomObj],
-    BelongsToOrgModel[IdType, ProtoBelongsToRoomObj, OrmBelongsToRoomObj],
-):
-    """Base for orm wrappers with room mixin providing a unified update mechanism."""
-
-    @property
-    def room_id(self) -> eorm.RoomID:
-        return eorm.RoomID().from_str(self.proto_self.room_id)
+    @classmethod
+    def list_as_proto(
+        cls,
+        client: system.Client,
+        *,
+        limit: int | None = None,
+        created_before: datetime.datetime | None = None,
+        ids: Iterable[OrmIdT] | None = None,
+        additional_query_transform: Callable[
+            [sa.Select[tuple[OrmHasIdT]]], sa.Select[tuple[OrmHasIdT]]
+        ]
+        | None = None,
+        existing_session: sa_orm.Session | None = None,
+    ) -> Ok[list[ProtoHasIdT]] | NotFoundError | InvalidArgumentError:
+        def query_transform(
+            query: sa.Select[tuple[OrmHasIdT]],
+        ) -> sa.Select[tuple[OrmHasIdT]]:
+            if ids:
+                query = query.where(cls.orm_class().id.in_(ids))
+            if additional_query_transform:
+                query = additional_query_transform(query)
+            return query
+
+        return super().list_as_proto(
+            client,
+            limit=limit,
+            created_before=created_before,
+            additional_query_transform=query_transform,
+            existing_session=existing_session,
+        )