audex 1.0.7a3__py3-none-any.whl

audex/lib/repos/session.py

@@ -0,0 +1,285 @@
+from __future__ import annotations
+
+import builtins
+import typing as t
+
+import sqlalchemy as sa
+import sqlmodel as sqlm
+
+from audex.entity.session import Session
+from audex.filters import Filter
+from audex.lib.database.sqlite import SQLite
+from audex.lib.repos.database.sqlite import SQLiteRepository
+from audex.lib.repos.tables.session import SessionTable
+
+
+class SessionRepository(SQLiteRepository[Session]):
+    """SQLite implementation of Session repository.
+
+    Provides CRUD operations for Session entities with additional
+    specialized query methods for session management by doctor.
+    """
+
+    __table__ = SessionTable
+    __tablename__ = SessionTable.__tablename__
+
+    def __init__(self, sqlite: SQLite) -> None:
+        super().__init__(sqlite)
+
+    async def create(self, data: Session, /) -> str:
+        """Create a new session in the database.
+
+        Args:
+            data: The session entity to create.
+
+        Returns:
+            The ID of the created session.
+        """
+        async with self.sqlite.session() as session:
+            session_table = SessionTable.from_entity(data)
+            session.add(session_table)
+            await session.commit()
+            await session.refresh(session_table)
+            return session_table.id
+
+    async def read(self, id: str, /) -> Session | None:
+        """Read a session by ID.
+
+        Args:
+            id: The ID (id) of the session to retrieve.
+
+        Returns:
+            The session entity if found, None otherwise.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(SessionTable).where(SessionTable.id == id)
+            result = await session.execute(stmt)
+            session_obj = result.scalar_one_or_none()
+
+            if session_obj is None:
+                return None
+
+            return session_obj.to_entity()
+
+    async def first(self, filter: Filter) -> Session | None:
+        """Retrieve the first session matching the filter.
+
+        Args:
+            filter: Filter to apply when searching for the session.
+
+        Returns:
+            The first session entity matching the filter, or None if no match.
+        """
+        spec = self.build_query_spec(filter)
+
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(SessionTable)
+
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            for order in spec.order_by:
+                stmt = stmt.order_by(order)
+
+            stmt = stmt.limit(1)
+
+            result = await session.execute(stmt)
+            session_obj = result.scalar_one_or_none()
+
+            if session_obj is None:
+                return None
+
+            return session_obj.to_entity()
+
+    async def list(
+        self,
+        arg: builtins.list[str] | t.Optional[Filter] = None,  # noqa
+        *,
+        page_index: int = 0,
+        page_size: int = 100,
+    ) -> builtins.list[Session]:
+        """List sessions by IDs or with optional filtering and
+        pagination.
+
+        Args:
+            arg: Either a list of IDs to retrieve, or an optional filter.
+            page_index: Zero-based page index for pagination.
+            page_size: Number of items per page.
+
+        Returns:
+            List of session entities matching the criteria.
+        """
+        async with self.sqlite.session() as session:
+            if isinstance(arg, list):
+                if not arg:
+                    return []
+
+                stmt = sqlm.select(SessionTable).where(sqlm.col(SessionTable.id).in_(arg))
+                result = await session.execute(stmt)
+                session_objs = result.scalars().all()
+                return [obj.to_entity() for obj in session_objs]
+
+            spec = self.build_query_spec(arg)
+            stmt = sqlm.select(SessionTable)
+
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            for order in spec.order_by:
+                stmt = stmt.order_by(order)
+
+            stmt = stmt.offset(page_index * page_size).limit(page_size)
+
+            result = await session.execute(stmt)
+            session_objs = result.scalars().all()
+            return [obj.to_entity() for obj in session_objs]
+
+    async def update(self, data: Session, /) -> str:
+        """Update an existing session.
+
+        Args:
+            data: The session entity with updated values.
+
+        Returns:
+            The ID of the updated session.
+
+        Raises:
+            ValueError: If the session with the given ID does not exist.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(SessionTable).where(SessionTable.id == data.id)
+            result = await session.execute(stmt)
+            session_obj = result.scalar_one_or_none()
+
+            if session_obj is None:
+                raise ValueError(f"Session with id {data.id} not found")
+
+            session_obj.update(data)
+            session.add(session_obj)
+            await session.commit()
+            await session.refresh(session_obj)
+            return session_obj.id
+
+    async def update_many(self, datas: builtins.list[Session]) -> builtins.list[str]:
+        """Update multiple sessions in the database.
+
+        Args:
+            datas: List of session entities with updated values.
+
+        Returns:
+            List of IDs of the updated sessions.
+
+        Raises:
+            ValueError: If any session with the given ID does not exist.
+        """
+        if not datas:
+            return []
+
+        updated_ids: builtins.list[str] = []
+        async with self.sqlite.session() as session:
+            ids = [data.id for data in datas]
+            stmt = sqlm.select(SessionTable).where(sqlm.col(SessionTable.id).in_(ids))
+            result = await session.execute(stmt)
+            table_objs = {obj.id: obj for obj in result.scalars().all()}
+
+            missing_ids = set(ids) - set(table_objs.keys())
+            if missing_ids:
+                raise ValueError(f"Sessions with IDs {missing_ids} not found")
+
+            for data in datas:
+                session_obj = table_objs[data.id]
+                session_obj.update(data)
+                session.add(session_obj)
+                updated_ids.append(session_obj.id)
+
+            await session.commit()
+            return updated_ids
+
+    async def delete(self, id: str, /) -> bool:
+        """Delete a session by ID.
+
+        Args:
+            id: The ID (id) of the session to delete.
+
+        Returns:
+            True if the session was deleted, False if not found.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(SessionTable).where(SessionTable.id == id)
+            result = await session.execute(stmt)
+            session_obj = result.scalar_one_or_none()
+
+            if session_obj is None:
+                return False
+
+            await session.delete(session_obj)
+            await session.commit()
+            return True
+
+    async def delete_many(
+        self,
+        arg: builtins.list[str] | t.Optional[Filter] = None,  # noqa
+    ) -> builtins.list[str]:
+        """Delete multiple sessions by IDs or matching a filter.
+
+        Args:
+            arg: Either a list of IDs to delete, or an optional filter.
+
+        Returns:
+            If deleting by IDs, returns list of deleted IDs.
+            If deleting by filter, returns count of deleted records.
+        """
+        async with self.sqlite.session() as session:
+            if isinstance(arg, list):
+                if not arg:
+                    return []
+
+                stmt = sqlm.select(SessionTable).where(sqlm.col(SessionTable.id).in_(arg))
+                result = await session.execute(stmt)
+                session_objs = result.scalars().all()
+
+                if not session_objs:
+                    return []
+
+                session_ids = [obj.id for obj in session_objs]
+                for obj in session_objs:
+                    await session.delete(obj)
+
+                await session.commit()
+                return session_ids
+
+            spec = self.build_query_spec(arg)
+            stmt = sqlm.select(SessionTable.id)  # type: ignore
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            result = await session.execute(stmt)
+            session_ids = [row[0] for row in result.all()]
+
+            if not session_ids:
+                return []
+
+            delete_stmt = sa.delete(SessionTable).where(sqlm.col(SessionTable.id).in_(session_ids))
+            await session.execute(delete_stmt)
+            await session.commit()
+            return session_ids
+
+    async def count(self, filter: t.Optional[Filter] = None) -> int:  # noqa
+        """Count sessions matching the filter.
+
+        Args:
+            filter: Optional filter to apply. If None, counts all sessions.
+
+        Returns:
+            Number of sessions matching the filter.
+        """
+        spec = self.build_query_spec(filter)
+
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(sa.func.count()).select_from(SessionTable)
+
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            result = await session.execute(stmt)
+            return result.scalar_one()

audex/lib/repos/tables/__init__.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import abc
+import datetime
+import typing as t
+
+import sqlmodel as sqlm
+
+from audex import utils
+from audex.entity import BaseEntity
+
+E = t.TypeVar("E", bound=BaseEntity)
+
+
+class BaseTable(sqlm.SQLModel, abc.ABC, t.Generic[E], table=False):
+    """Base __table__ model with common fields for entities.
+
+    All entity __table__ models should inherit from this class to ensure
+    consistent structure across the database schema.
+    """
+
+    __tablename__: t.ClassVar[str]
+
+    sid: int | None = sqlm.Field(
+        default=None,
+        primary_key=True,
+        description="Auto-increment primary key",
+    )
+    id: str = sqlm.Field(
+        index=True,
+        unique=True,
+        max_length=50,
+        default_factory=utils.gen_id,
+        description="Business identifier (UUID/ULID)",
+    )
+    created_at: datetime.datetime = sqlm.Field(
+        default_factory=utils.utcnow,
+        nullable=False,
+        description="Creation timestamp",
+    )
+    updated_at: datetime.datetime | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        sa_column_kwargs={"onupdate": utils.utcnow},
+        description="Last update timestamp",
+    )
+
+    def __repr__(self) -> str:
+        return f"TABLE <{self.__class__.__name__}(uid={self.id!r})>"
+
+    @classmethod
+    @abc.abstractmethod
+    def from_entity(cls, entity: E) -> t.Self: ...
+
+    @abc.abstractmethod
+    def to_entity(self) -> E: ...
+
+    @abc.abstractmethod
+    def update(self, entity: E) -> None: ...
+
+
+from audex.lib.repos.tables import doctor  # noqa: E402
+from audex.lib.repos.tables import segment  # noqa: E402
+from audex.lib.repos.tables import session  # noqa: E402
+from audex.lib.repos.tables import utterance  # noqa: E402
+from audex.lib.repos.tables import vp  # noqa: E402
+
+TABLES: set[type[sqlm.SQLModel]] = (
+    doctor.TABLES | segment.TABLES | session.TABLES | utterance.TABLES | vp.TABLES
+)

audex/lib/repos/tables/doctor.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import typing as t
+
+import sqlmodel as sqlm
+
+from audex.entity.doctor import Doctor
+from audex.lib.repos.tables import BaseTable
+from audex.valueobj.common.auth import HashedPassword
+from audex.valueobj.common.email import Email
+from audex.valueobj.common.phone import CNPhone
+
+
+class DoctorTable(BaseTable[Doctor], table=True):
+    """Doctor table model for SQLite storage.
+
+    Maps the Doctor entity to the database table with all necessary fields
+    for authentication, voiceprint management, and account status.
+
+    Table: doctors
+    """
+
+    __tablename__ = "doctors"
+
+    eid: str = sqlm.Field(
+        ...,
+        unique=True,
+        index=True,
+        max_length=100,
+        description="Employee/staff ID in the hospital system.",
+    )
+    password_hash: str = sqlm.Field(
+        ...,
+        max_length=255,
+        description="The hashed password for secure authentication.",
+    )
+    name: str = sqlm.Field(
+        ...,
+        max_length=100,
+        description="The doctor's real name for display and records.",
+    )
+    department: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=100,
+        description="Department or specialty. Optional.",
+    )
+    title: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=100,
+        description="Professional title (e.g., Attending, Resident). Optional.",
+    )
+    hospital: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=150,
+        description="Affiliated hospital name. Optional.",
+    )
+    phone: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=20,
+        description="Contact phone number. Optional.",
+    )
+    email: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=100,
+        description="Contact email address. Optional.",
+    )
+    is_active: bool = sqlm.Field(
+        default=True,
+        description="Indicates if the doctor's account is active.",
+    )
+
+    @classmethod
+    def from_entity(cls, entity: Doctor) -> t.Self:
+        """Convert Doctor entity to table model.
+
+        Args:
+            entity: The Doctor entity to convert.
+
+        Returns:
+            DoctorTable instance.
+        """
+        return cls(
+            id=entity.id,
+            eid=entity.eid,
+            password_hash=entity.password_hash.value,
+            name=entity.name,
+            department=entity.department,
+            title=entity.title,
+            hospital=entity.hospital,
+            phone=entity.phone.value if entity.phone else None,
+            email=entity.email.value if entity.email else None,
+            is_active=entity.is_active,
+        )
+
+    def to_entity(self) -> Doctor:
+        """Convert table model to Doctor entity.
+
+        Returns:
+            Doctor entity instance.
+        """
+        return Doctor(
+            id=self.id,
+            eid=self.eid,
+            password_hash=HashedPassword.parse(self.password_hash, validate=False),
+            name=self.name,
+            department=self.department,
+            title=self.title,
+            hospital=self.hospital,
+            phone=CNPhone.parse(self.phone) if self.phone else None,
+            email=Email.parse(self.email, validate=False) if self.email else None,
+            is_active=self.is_active,
+        )
+
+    def update(self, entity: Doctor) -> None:
+        """Update table model fields from Doctor entity.
+
+        Args:
+            entity: The Doctor entity with updated data.
+        """
+        self.eid = entity.eid
+        self.password_hash = entity.password_hash.value
+        self.name = entity.name
+        self.department = entity.department
+        self.title = entity.title
+        self.hospital = entity.hospital
+        self.phone = entity.phone.value if entity.phone else None
+        self.email = entity.email.value if entity.email else None
+        self.is_active = entity.is_active
+
+
+TABLES: set[type[sqlm.SQLModel]] = {DoctorTable}
+"""Set of all table models for the repository."""

audex/lib/repos/tables/segment.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import datetime
+import typing as t
+
+import sqlmodel as sqlm
+
+from audex.entity.segment import Segment
+from audex.lib.repos.tables import BaseTable
+
+
+class SegmentTable(BaseTable[Segment], table=True):
+    """Segment table model for SQLite storage.
+
+    Maps the Segment entity to the database table with all necessary fields
+    for tracking audio recording segments within sessions.
+
+    Table: segments
+    """
+
+    __tablename__ = "segments"
+
+    session_id: str = sqlm.Field(
+        index=True,
+        max_length=50,
+        description="Foreign key to session this segment belongs to",
+    )
+
+    sequence: int = sqlm.Field(
+        nullable=False,
+        description="Sequence number within session",
+    )
+
+    audio_key: str = sqlm.Field(
+        max_length=500,
+        nullable=False,
+        description="Audio file key/path in storage",
+    )
+
+    started_at: datetime.datetime = sqlm.Field(
+        nullable=False,
+        description="Timestamp when segment started recording",
+    )
+
+    ended_at: datetime.datetime | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="Timestamp when segment stopped recording",
+    )
+
+    duration_ms: int | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="Duration of segment in milliseconds",
+    )
+
+    @classmethod
+    def from_entity(cls, entity: Segment) -> t.Self:
+        """Convert Segment entity to table model.
+
+        Args:
+            entity: The Segment entity to convert.
+
+        Returns:
+            SegmentTable instance.
+        """
+        return cls(
+            id=entity.id,
+            session_id=entity.session_id,
+            sequence=entity.sequence,
+            audio_key=entity.audio_key,
+            started_at=entity.started_at,
+            ended_at=entity.ended_at,
+            duration_ms=entity.duration_ms,
+            created_at=entity.created_at,
+            updated_at=entity.updated_at,
+        )
+
+    def to_entity(self) -> Segment:
+        """Convert table model to Segment entity.
+
+        Returns:
+            Segment entity instance.
+        """
+        return Segment(
+            id=self.id,
+            session_id=self.session_id,
+            sequence=self.sequence,
+            audio_key=self.audio_key,
+            started_at=self.started_at,
+            ended_at=self.ended_at,
+            duration_ms=self.duration_ms,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+        )
+
+    def update(self, entity: Segment) -> None:
+        """Update table model fields from Segment entity.
+
+        Args:
+            entity: The Segment entity with updated data.
+        """
+        self.session_id = entity.session_id
+        self.sequence = entity.sequence
+        self.audio_key = entity.audio_key
+        self.started_at = entity.started_at
+        self.ended_at = entity.ended_at
+        self.duration_ms = entity.duration_ms
+        self.updated_at = entity.updated_at
+
+
+TABLES: set[type[sqlm.SQLModel]] = {SegmentTable}
+"""Set of all table models for the repository."""