corvic-engine 0.3.0rc76__cp38-abi3-win_amd64.whl → 0.3.0rc78__cp38-abi3-win_amd64.whl

corvic/eorm/__init__.py

@@ -0,0 +1,404 @@
+"""Engine Object-Relational Mappings."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TypeAlias
+
+import sqlalchemy as sa
+from sqlalchemy import orm as sa_orm
+
+from corvic import orm
+from corvic_generated.orm.v1 import (
+    common_pb2,
+    completion_model_pb2,
+    feature_view_pb2,
+    pipeline_pb2,
+    space_pb2,
+    table_pb2,
+)
+from corvic_generated.status.v1 import event_pb2
+
+OrgID: TypeAlias = orm.OrgID
+
+
+class RoomID(orm.BaseIDFromInt):
+    """A unique identifier for a room."""
+
+
+class ResourceID(orm.BaseIDFromInt):
+    """A unique identifier for a resource."""
+
+
+class SourceID(orm.BaseIDFromInt):
+    """A unique identifier for a source."""
+
+
+class PipelineID(orm.BaseIDFromInt):
+    """A unique identifier for a pipeline."""
+
+
+class FeatureViewID(orm.BaseIDFromInt):
+    """A unique identifier for a feature view."""
+
+
+class FeatureViewSourceID(orm.BaseIDFromInt):
+    """A unique identifier for a source in a feature view."""
+
+
+class SpaceID(orm.BaseIDFromInt):
+    """A unique identifier for a space."""
+
+
+class CompletionModelID(orm.BaseIDFromInt):
+    """A unique identifier for a completion model."""
+
+
+orm.Base.registry.update_type_annotation_map(
+    {
+        # proto  message column types
+        common_pb2.BlobUrlList: orm.ProtoMessageDecorator(common_pb2.BlobUrlList()),
+        feature_view_pb2.FeatureViewOutput: orm.ProtoMessageDecorator(
+            feature_view_pb2.FeatureViewOutput()
+        ),
+        common_pb2.AgentMessageMetadata: orm.ProtoMessageDecorator(
+            common_pb2.AgentMessageMetadata()
+        ),
+        space_pb2.SpaceParameters: orm.ProtoMessageDecorator(
+            space_pb2.SpaceParameters()
+        ),
+        table_pb2.TableComputeOp: orm.ProtoMessageDecorator(table_pb2.TableComputeOp()),
+        table_pb2.NamedTables: orm.ProtoMessageDecorator(table_pb2.NamedTables()),
+        common_pb2.RetrievedEntities: orm.ProtoMessageDecorator(
+            common_pb2.RetrievedEntities()
+        ),
+        pipeline_pb2.PipelineTransformation: orm.ProtoMessageDecorator(
+            pipeline_pb2.PipelineTransformation()
+        ),
+        event_pb2.Event: orm.ProtoMessageDecorator(event_pb2.Event()),
+        completion_model_pb2.CompletionModelParameters: orm.ProtoMessageDecorator(
+            completion_model_pb2.CompletionModelParameters()
+        ),
+        # ID types
+        RoomID: orm.IntIDDecorator(RoomID()),
+        ResourceID: orm.IntIDDecorator(ResourceID()),
+        SourceID: orm.IntIDDecorator(SourceID()),
+        PipelineID: orm.IntIDDecorator(PipelineID()),
+        FeatureViewID: orm.IntIDDecorator(FeatureViewID()),
+        FeatureViewSourceID: orm.IntIDDecorator(FeatureViewSourceID()),
+        SpaceID: orm.IntIDDecorator(SpaceID()),
+        CompletionModelID: orm.IntIDDecorator(CompletionModelID()),
+    }
+)
+
+
+class Room(orm.BelongsToOrgMixin, orm.SoftDeleteMixin, orm.Base, kw_only=True):
+    """A Room is a logical collection of Documents."""
+
+    __tablename__ = "room"
+    __table_args__ = (orm.live_unique_constraint("name", "org_id"),)
+
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    id: sa_orm.Mapped[RoomID | None] = orm.primary_key_identity_column()
+
+    @property
+    def room_key(self):
+        return self.name
+
+
+class BelongsToRoomMixin(sa_orm.MappedAsDataclass):
+    room_id: sa_orm.Mapped[RoomID | None] = sa_orm.mapped_column(
+        orm.ForeignKey(Room).make(ondelete="CASCADE"),
+        nullable=True,
+        default=None,
+    )
+
+
+class DefaultObjects(orm.Base, kw_only=True):
+    """Holds the identifiers for default objects."""
+
+    __tablename__ = "default_objects"
+    default_org: sa_orm.Mapped[OrgID | None] = sa_orm.mapped_column(
+        orm.ForeignKey(orm.Org).make(ondelete="CASCADE"),
+        nullable=False,
+    )
+    default_room: sa_orm.Mapped[RoomID | None] = sa_orm.mapped_column(
+        orm.ForeignKey(Room).make(ondelete="CASCADE"), nullable=True, default=None
+    )
+    version: sa_orm.Mapped[int | None] = orm.primary_key_identity_column(
+        type_=orm.INT_PK_TYPE
+    )
+
+
+class Resource(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """A Resource is a reference to some durably stored file.
+
+    E.g., a document could be a PDF file, an image, or a text transcript of a
+    conversation
+    """
+
+    __tablename__ = "resource"
+
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text)
+    mime_type: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text)
+    url: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text)
+    md5: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.CHAR(32), nullable=True)
+    size: sa_orm.Mapped[int] = sa_orm.mapped_column(nullable=True)
+    original_path: sa_orm.Mapped[str] = sa_orm.mapped_column(nullable=True)
+    description: sa_orm.Mapped[str] = sa_orm.mapped_column(nullable=True)
+    id: sa_orm.Mapped[ResourceID | None] = orm.primary_key_identity_column()
+    latest_event: sa_orm.Mapped[event_pb2.Event | None] = sa_orm.mapped_column(
+        default=None, nullable=True
+    )
+    is_terminal: sa_orm.Mapped[bool | None] = sa_orm.mapped_column(
+        default=None, nullable=True
+    )
+    pipeline_ref: sa_orm.Mapped[PipelineInput | None] = sa_orm.relationship(
+        init=False, viewonly=True
+    )
+
+
+class Source(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """A source."""
+
+    __tablename__ = "source"
+    __table_args__ = (sa.UniqueConstraint("name", "room_id"),)
+
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text)
+    # protobuf describing the operations required to construct a table
+    table_op_graph: sa_orm.Mapped[table_pb2.TableComputeOp] = sa_orm.mapped_column()
+    id: sa_orm.Mapped[SourceID | None] = orm.primary_key_identity_column()
+
+    source_files: sa_orm.Mapped[common_pb2.BlobUrlList | None] = sa_orm.mapped_column(
+        default=None
+    )
+    pipeline_ref: sa_orm.Mapped[PipelineOutput | None] = sa_orm.relationship(
+        init=False, viewonly=True
+    )
+
+    @property
+    def source_key(self):
+        return self.name
+
+
+class Pipeline(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """A resource to source pipeline."""
+
+    __tablename__ = "pipeline"
+    __table_args__ = (sa.UniqueConstraint("name", "room_id"),)
+
+    transformation: sa_orm.Mapped[pipeline_pb2.PipelineTransformation] = (
+        sa_orm.mapped_column()
+    )
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column()
+    description: sa_orm.Mapped[str | None] = sa_orm.mapped_column()
+    id: sa_orm.Mapped[PipelineID | None] = orm.primary_key_identity_column()
+
+    outputs: sa_orm.Mapped[list[PipelineOutput]] = sa_orm.relationship(
+        viewonly=True,
+        init=False,
+        default_factory=list,
+    )
+
+
+class PipelineInput(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """Pipeline input resources."""
+
+    __tablename__ = "pipeline_input"
+    __table_args__ = (sa.UniqueConstraint("name", "pipeline_id"),)
+
+    resource: sa_orm.Mapped[Resource] = sa_orm.relationship(viewonly=True, init=False)
+    name: sa_orm.Mapped[str]
+    """A name the pipeline uses to refer to this input."""
+
+    pipeline_id: sa_orm.Mapped[PipelineID] = orm.primary_key_foreign_column(
+        orm.ForeignKey(Pipeline).make(ondelete="CASCADE")
+    )
+    resource_id: sa_orm.Mapped[ResourceID] = orm.primary_key_foreign_column(
+        orm.ForeignKey(Resource).make(ondelete="CASCADE")
+    )
+
+
+class PipelineOutput(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """Objects for tracking pipeline output sources."""
+
+    __tablename__ = "pipeline_output"
+    __table_args__ = (sa.UniqueConstraint("name", "pipeline_id"),)
+
+    source: sa_orm.Mapped[Source] = sa_orm.relationship(viewonly=True, init=False)
+    name: sa_orm.Mapped[str]
+    """A name the pipeline uses to refer to this output."""
+
+    pipeline_id: sa_orm.Mapped[PipelineID] = orm.primary_key_foreign_column(
+        orm.ForeignKey(Pipeline).make(ondelete="CASCADE")
+    )
+    source_id: sa_orm.Mapped[SourceID] = orm.primary_key_foreign_column(
+        orm.ForeignKey(Source).make(ondelete="CASCADE")
+    )
+
+
+class FeatureView(
+    orm.SoftDeleteMixin,
+    orm.BelongsToOrgMixin,
+    BelongsToRoomMixin,
+    orm.Base,
+    kw_only=True,
+):
+    """A FeatureView is a logical collection of sources used by various spaces."""
+
+    __tablename__ = "feature_view"
+    __table_args__ = (orm.live_unique_constraint("name", "room_id"),)
+
+    id: sa_orm.Mapped[FeatureViewID | None] = orm.primary_key_identity_column()
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    description: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default="")
+
+    feature_view_output: sa_orm.Mapped[feature_view_pb2.FeatureViewOutput | None] = (
+        sa_orm.mapped_column(default_factory=feature_view_pb2.FeatureViewOutput)
+    )
+
+    @property
+    def feature_view_key(self):
+        return self.name
+
+    feature_view_sources: sa_orm.Mapped[list[FeatureViewSource]] = sa_orm.relationship(
+        viewonly=True,
+        init=False,
+        default_factory=list,
+    )
+
+
+class FeatureViewSource(
+    orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True
+):
+    """A source inside of a feature view."""
+
+    __tablename__ = "feature_view_source"
+
+    table_op_graph: sa_orm.Mapped[table_pb2.TableComputeOp] = sa_orm.mapped_column()
+    feature_view_id: sa_orm.Mapped[FeatureViewID] = sa_orm.mapped_column(
+        orm.ForeignKey(FeatureView).make(ondelete="CASCADE"),
+        nullable=False,
+    )
+    id: sa_orm.Mapped[FeatureViewSourceID | None] = orm.primary_key_identity_column()
+    drop_disconnected: sa_orm.Mapped[bool] = sa_orm.mapped_column(default=False)
+    # this should be legal but pyright complains that it makes Source depend
+    # on itself
+    source_id: sa_orm.Mapped[SourceID] = sa_orm.mapped_column(
+        orm.ForeignKey(Source).make(ondelete="CASCADE"),
+        nullable=False,
+        default=None,
+    )
+    source: sa_orm.Mapped[Source] = sa_orm.relationship(
+        init=True, viewonly=True, default=None
+    )
+
+
+class Space(orm.BelongsToOrgMixin, BelongsToRoomMixin, orm.Base, kw_only=True):
+    """A space is a named evaluation of space parameters."""
+
+    __tablename__ = "space"
+    __table_args__ = (sa.UniqueConstraint("name", "room_id"),)
+
+    id: sa_orm.Mapped[SpaceID | None] = orm.primary_key_identity_column()
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    description: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default="")
+
+    feature_view_id: sa_orm.Mapped[FeatureViewID] = sa_orm.mapped_column(
+        orm.ForeignKey(FeatureView).make(ondelete="CASCADE"),
+        nullable=False,
+        default=None,
+    )
+    parameters: sa_orm.Mapped[space_pb2.SpaceParameters | None] = sa_orm.mapped_column(
+        default=None
+    )
+    auto_sync: sa_orm.Mapped[bool | None] = sa_orm.mapped_column(default=None)
+    feature_view: sa_orm.Mapped[FeatureView] = sa_orm.relationship(
+        init=False,
+        default=None,
+        viewonly=True,
+    )
+
+    @property
+    def space_key(self):
+        return self.name
+
+
+class CompletionModel(
+    orm.SoftDeleteMixin, orm.BelongsToOrgMixin, orm.Base, kw_only=True
+):
+    """A customer's custom completion model definition."""
+
+    __tablename__ = "completion_model"
+    __table_args__ = (orm.live_unique_constraint("name", "org_id"),)
+
+    id: sa_orm.Mapped[CompletionModelID | None] = orm.primary_key_identity_column()
+    name: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    description: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    parameters: sa_orm.Mapped[completion_model_pb2.CompletionModelParameters | None] = (
+        sa_orm.mapped_column(default=None)
+    )
+    secret_api_key: sa_orm.Mapped[str] = sa_orm.mapped_column(sa.Text, default=None)
+    last_validation_time: sa_orm.Mapped[datetime | None] = sa_orm.mapped_column(
+        sa.DateTime(timezone=True),
+        server_default=None,
+        default=None,
+    )
+    last_successful_validation: sa_orm.Mapped[datetime | None] = sa_orm.mapped_column(
+        sa.DateTime(timezone=True),
+        server_default=None,
+        default=None,
+    )
+
+    @property
+    def model_key(self):
+        return self.name
+
+
+ID = (
+    orm.ID
+    | CompletionModelID
+    | FeatureViewID
+    | FeatureViewSourceID
+    | PipelineID
+    | ResourceID
+    | RoomID
+    | SourceID
+    | SpaceID
+)
+
+# These are part of the public interface, exposing them here so that
+# users don't have to import orm anytime they import eorm
+Base: TypeAlias = orm.Base
+Org: TypeAlias = orm.Org
+Session: TypeAlias = orm.Session
+
+InvalidORMIdentifierError: TypeAlias = orm.InvalidORMIdentifierError
+RequestedObjectsForNobodyError: TypeAlias = orm.RequestedObjectsForNobodyError
+
+__all__ = [
+    "Base",
+    "CompletionModel",
+    "CompletionModelID",
+    "DefaultObjects",
+    "FeatureView",
+    "FeatureViewID",
+    "FeatureViewSource",
+    "FeatureViewSourceID",
+    "ID",
+    "InvalidORMIdentifierError",
+    "OrgID",
+    "PipelineID",
+    "PipelineInput",
+    "PipelineOutput",
+    "RequestedObjectsForNobodyError",
+    "Resource",
+    "ResourceID",
+    "Room",
+    "RoomID",
+    "Session",
+    "Source",
+    "SourceID",
+    "Space",
+    "SpaceID",
+]

corvic/model/_base_model.py

@@ -12,10 +12,10 @@ import sqlalchemy.orm as sa_orm
 import structlog
 from google.protobuf import timestamp_pb2
 
-from corvic import orm, system
+from corvic import eorm, system
 from corvic.model._proto_orm_convert import (
-    ID,
     UNCOMMITTED_ID_PREFIX,
+    IdType,
     OrmBelongsToOrgObj,
     OrmBelongsToRoomObj,
     OrmObj,
@@ -54,7 +54,7 @@ def _create_or_join_session(
     if existing_session:
         yield existing_session
     else:
-        with orm.Session(client.sa_engine) as session:
+        with eorm.Session(client.sa_engine) as session:
             yield session
 
 
@@ -71,7 +71,7 @@ class HasProtoSelf(Generic[ProtoObj], abc.ABC):
         return non_empty_timestamp_to_datetime(self.proto_self.created_at)
 
 
-class UsesOrmID(Generic[ID, ProtoObj], HasProtoSelf[ProtoObj]):
+class UsesOrmID(Generic[IdType, ProtoObj], HasProtoSelf[ProtoObj]):
     def __init__(self, client: system.Client, proto_self: ProtoObj):
         if not proto_self.id:
             proto_self.id = _generate_uncommitted_id_str()
@@ -79,14 +79,14 @@ class UsesOrmID(Generic[ID, ProtoObj], HasProtoSelf[ProtoObj]):
 
     @classmethod
     @abc.abstractmethod
-    def id_class(cls) -> type[ID]: ...
+    def id_class(cls) -> type[IdType]: ...
 
     @functools.cached_property
-    def id(self) -> ID:
+    def id(self) -> IdType:
         return self.id_class().from_str(self.proto_self.id)
 
 
-class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
+class BaseModel(Generic[IdType, ProtoObj, OrmObj], UsesOrmID[IdType, ProtoObj]):
     """Base for orm wrappers providing a unified update mechanism."""
 
     @property
@@ -104,19 +104,19 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
     @classmethod
     @abc.abstractmethod
     def proto_to_orm(
-        cls, proto_obj: ProtoObj, session: orm.Session
+        cls, proto_obj: ProtoObj, session: eorm.Session
     ) -> Ok[OrmObj] | InvalidArgumentError: ...
 
     @classmethod
     @abc.abstractmethod
     def delete_by_ids(
-        cls, ids: Sequence[ID], session: orm.Session
+        cls, ids: Sequence[IdType], session: eorm.Session
     ) -> Ok[None] | InvalidArgumentError: ...
 
     @classmethod
     def load_proto_for(
         cls,
-        obj_id: ID,
+        obj_id: IdType,
         client: system.Client,
         existing_session: sa_orm.Session | None = None,
     ) -> Ok[ProtoObj] | NotFoundError:
@@ -155,9 +155,9 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
         client: system.Client,
         *,
         limit: int | None = None,
-        room_id: orm.RoomID | None = None,
+        room_id: eorm.RoomID | None = None,
         created_before: datetime.datetime | None = None,
-        ids: Iterable[ID] | None = None,
+        ids: Iterable[IdType] | None = None,
         additional_query_transform: Callable[
             [sa.Select[tuple[OrmObj]]], sa.Select[tuple[OrmObj]]
         ]
@@ -173,7 +173,7 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
                     return InvalidArgumentError("limit cannot be negative")
                 query = query.limit(limit)
             if room_id:
-                if session.get(orm.Room, room_id) is None:
+                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:
@@ -198,20 +198,14 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, 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 orm.Session(self.client.sa_engine) as session:
+        with eorm.Session(self.client.sa_engine) as session:
             try:
                 new_orm_self = self.proto_to_orm(
                     self.proto_self, session
                 ).unwrap_or_raise()
                 session.commit()
-            except sa.exc.ProgrammingError as err:
-                if "violates foreign key constraint" in str(err):
-                    return InvalidArgumentError.from_(err)
-                if "could not serialize access due to concurrent update" in str(err):
-                    return UnavailableError.from_(err)
-                return InvalidArgumentError.from_(err)
-            except (sa.exc.DatabaseError, sa.exc.StatementError) as err:
-                return InvalidArgumentError.from_(err)
+            except sa.exc.DBAPIError as err:
+                return self._dbapi_error_to_result(err)
             return Ok(
                 self.__class__(
                     client=self.client,
@@ -219,8 +213,24 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
                 )
             )
 
+    @staticmethod
+    def _dbapi_error_to_result(err: sa.exc.DBAPIError):
+        try:
+            import psycopg.errors
+
+            if isinstance(err.orig, psycopg.errors.SerializationFailure):
+                return UnavailableError.from_(err)
+        except ModuleNotFoundError:
+            pass
+        if isinstance(err, sa.exc.ProgrammingError):
+            if "violates foreign key constraint" in str(err):
+                return InvalidArgumentError.from_(err)
+            if "could not serialize access due to concurrent update" in str(err):
+                return UnavailableError.from_(err)
+        return InvalidArgumentError.from_(err)
+
     def add_to_session(
-        self, session: orm.Session
+        self, session: eorm.Session
     ) -> Ok[None] | InvalidArgumentError | UnavailableError:
         """Like commit, but just calls session.flush to check for database errors.
 
@@ -232,18 +242,12 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
             _ = self.proto_to_orm(self.proto_self, session).unwrap_or_raise()
             session.flush()
         # TODO(thunt): Possibly separate out DatabaseError into a precondition error
-        except sa.exc.ProgrammingError as err:
-            if "violates foreign key constraint" in str(err):
-                return InvalidArgumentError.from_(err)
-            if "could not serialize access due to concurrent update" in str(err):
-                return UnavailableError.from_(err)
-            return InvalidArgumentError.from_(err)
-        except (sa.exc.DatabaseError, sa.exc.StatementError) as err:
-            return InvalidArgumentError.from_(err)
+        except sa.exc.DBAPIError as err:
+            return self._dbapi_error_to_result(err)
         return Ok(None)
 
     def delete(self) -> Ok[Self] | NotFoundError | InvalidArgumentError:
-        with orm.Session(
+        with eorm.Session(
             self.client.sa_engine, expire_on_commit=False, autoflush=False
         ) as session:
             try:
@@ -268,22 +272,22 @@ class BaseModel(Generic[ID, ProtoObj, OrmObj], UsesOrmID[ID, ProtoObj]):
 
 
 class BelongsToOrgModel(
-    Generic[ID, ProtoBelongsToOrgObj, OrmBelongsToOrgObj],
-    BaseModel[ID, ProtoBelongsToOrgObj, OrmBelongsToOrgObj],
+    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) -> orm.OrgID:
-        return orm.OrgID().from_str(self.proto_self.org_id)
+    def org_id(self) -> eorm.OrgID:
+        return eorm.OrgID().from_str(self.proto_self.org_id)
 
 
 class BelongsToRoomModel(
-    Generic[ID, ProtoBelongsToRoomObj, OrmBelongsToRoomObj],
-    BelongsToOrgModel[ID, ProtoBelongsToRoomObj, OrmBelongsToRoomObj],
+    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) -> orm.RoomID:
-        return orm.RoomID().from_str(self.proto_self.room_id)
+    def room_id(self) -> eorm.RoomID:
+        return eorm.RoomID().from_str(self.proto_self.room_id)

corvic/model/_completion_model.py

@@ -9,7 +9,7 @@ from typing import Literal, TypeAlias
 
 from sqlalchemy import orm as sa_orm
 
-from corvic import orm, system
+from corvic import eorm, system
 from corvic.model._base_model import BelongsToOrgModel, non_empty_timestamp_to_datetime
 from corvic.model._defaults import Defaults
 from corvic.model._proto_orm_convert import (
@@ -21,38 +21,38 @@ from corvic.result import InvalidArgumentError, NotFoundError, Ok
 from corvic_generated.model.v1alpha import models_pb2
 from corvic_generated.orm.v1 import completion_model_pb2
 
-CompletionModelID: TypeAlias = orm.CompletionModelID
-OrgID: TypeAlias = orm.OrgID
+CompletionModelID: TypeAlias = eorm.CompletionModelID
+OrgID: TypeAlias = eorm.OrgID
 
 
 class CompletionModel(
     BelongsToOrgModel[
-        CompletionModelID, models_pb2.CompletionModel, orm.CompletionModel
+        CompletionModelID, models_pb2.CompletionModel, eorm.CompletionModel
     ]
 ):
     """Completion Models."""
 
     @classmethod
     def orm_class(cls):
-        return orm.CompletionModel
+        return eorm.CompletionModel
 
     @classmethod
     def id_class(cls):
         return CompletionModelID
 
     @classmethod
-    def orm_to_proto(cls, orm_obj: orm.CompletionModel) -> models_pb2.CompletionModel:
+    def orm_to_proto(cls, orm_obj: eorm.CompletionModel) -> models_pb2.CompletionModel:
         return completion_model_orm_to_proto(orm_obj)
 
     @classmethod
     def proto_to_orm(
-        cls, proto_obj: models_pb2.CompletionModel, session: orm.Session
-    ) -> Ok[orm.CompletionModel] | InvalidArgumentError:
+        cls, proto_obj: models_pb2.CompletionModel, session: eorm.Session
+    ) -> Ok[eorm.CompletionModel] | InvalidArgumentError:
         return completion_model_proto_to_orm(proto_obj, session)
 
     @classmethod
     def delete_by_ids(
-        cls, ids: Sequence[CompletionModelID], session: orm.Session
+        cls, ids: Sequence[CompletionModelID], session: eorm.Session
     ) -> Ok[None] | InvalidArgumentError:
         return completion_model_delete_orms(ids, session)
 

corvic/model/_defaults.py

@@ -6,7 +6,7 @@ import tempfile
 
 import sqlalchemy as sa
 
-from corvic import orm, system, system_sqlite
+from corvic import eorm, system, system_sqlite
 from corvic.result import NotFoundError
 
 
@@ -33,11 +33,11 @@ class Defaults:
         return _default_default_client()
 
     @staticmethod
-    def get_default_room_id(client: system.Client) -> orm.RoomID:
-        with orm.Session(client.sa_engine) as session:
+    def get_default_room_id(client: system.Client) -> eorm.RoomID:
+        with eorm.Session(client.sa_engine) as session:
             defaults_row = session.scalars(
-                sa.select(orm.DefaultObjects)
-                .order_by(orm.DefaultObjects.version.desc())
+                sa.select(eorm.DefaultObjects)
+                .order_by(eorm.DefaultObjects.version.desc())
                 .limit(1)
             ).one_or_none()
             if not defaults_row or not defaults_row.default_room: