audex 1.0.7a3__py3-none-any.whl

audex/lib/repos/tables/session.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import datetime
+import typing as t
+
+import sqlmodel as sqlm
+
+from audex.entity.session import Session
+from audex.lib.repos.tables import BaseTable
+from audex.valueobj.session import SessionStatus
+
+
+class SessionTable(BaseTable[Session], table=True):
+    """Session table model for SQLite storage.
+
+    Maps the Session entity to the database table with all necessary fields
+    for tracking conversation sessions, their status, and timing.
+
+    Table: sessions
+    """
+
+    __tablename__ = "sessions"
+
+    doctor_id: str = sqlm.Field(
+        index=True,
+        max_length=50,
+        description="Foreign key to doctor who owns this session",
+    )
+    patient_name: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=100,
+        description="Patient name for this session",
+    )
+    clinic_number: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=50,
+        description="Clinic number or ID for this session",
+    )
+    medical_record_number: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=50,
+        description="Medical record number for this session",
+    )
+    diagnosis: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        max_length=255,
+        description="Preliminary diagnosis for this session",
+    )
+    status: str = sqlm.Field(
+        default=SessionStatus.DRAFT.value,
+        max_length=20,
+        index=True,
+        description="Session status (draft/in_progress/completed/cancelled)",
+    )
+    started_at: datetime.datetime | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="Timestamp when session first started",
+    )
+    ended_at: datetime.datetime | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="Timestamp when session ended",
+    )
+    notes: str | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="Additional notes about the session",
+    )
+
+    @classmethod
+    def from_entity(cls, entity: Session) -> t.Self:
+        """Convert Session entity to table model.
+
+        Args:
+            entity: The Session entity to convert.
+
+        Returns:
+            SessionTable instance.
+        """
+        return cls(
+            id=entity.id,
+            doctor_id=entity.doctor_id,
+            patient_name=entity.patient_name,
+            clinic_number=entity.clinic_number,
+            medical_record_number=entity.medical_record_number,
+            diagnosis=entity.diagnosis,
+            status=entity.status.value,
+            started_at=entity.started_at,
+            ended_at=entity.ended_at,
+            notes=entity.notes,
+            created_at=entity.created_at,
+            updated_at=entity.updated_at,
+        )
+
+    def to_entity(self) -> Session:
+        """Convert table model to Session entity.
+
+        Returns:
+            Session entity instance.
+        """
+        return Session(
+            id=self.id,
+            doctor_id=self.doctor_id,
+            patient_name=self.patient_name,
+            clinic_number=self.clinic_number,
+            medical_record_number=self.medical_record_number,
+            diagnosis=self.diagnosis,
+            status=SessionStatus.parse(self.status),
+            started_at=self.started_at,
+            ended_at=self.ended_at,
+            notes=self.notes,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+        )
+
+    def update(self, entity: Session) -> None:
+        """Update table model fields from Session entity.
+
+        Args:
+            entity: The Session entity with updated data.
+        """
+        self.doctor_id = entity.doctor_id
+        self.patient_name = entity.patient_name
+        self.clinic_number = entity.clinic_number
+        self.medical_record_number = entity.medical_record_number
+        self.diagnosis = entity.diagnosis
+        self.status = entity.status.value
+        self.started_at = entity.started_at
+        self.ended_at = entity.ended_at
+        self.notes = entity.notes
+        self.updated_at = entity.updated_at
+
+
+TABLES: set[type[sqlm.SQLModel]] = {SessionTable}
+"""Set of all table models for the repository."""

audex/lib/repos/tables/utterance.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import datetime
+import typing as t
+
+import sqlmodel as sqlm
+
+from audex.entity.utterance import Utterance
+from audex.lib.repos.tables import BaseTable
+from audex.valueobj.utterance import Speaker
+
+
+class UtteranceTable(BaseTable[Utterance], table=True):
+    """Utterance table model for SQLite storage.
+
+    Maps the Utterance entity to the database table with all necessary fields
+    for tracking speech utterances in conversations.
+
+    Table: utterances
+    """
+
+    __tablename__ = "utterances"
+
+    session_id: str = sqlm.Field(
+        index=True,
+        max_length=50,
+        description="Foreign key to session this utterance belongs to",
+    )
+    segment_id: str = sqlm.Field(
+        index=True,
+        max_length=50,
+        description="Foreign key to segment containing this utterance",
+    )
+    sequence: int = sqlm.Field(
+        nullable=False,
+        description="Sequence number within session",
+    )
+    speaker: str = sqlm.Field(
+        max_length=20,
+        nullable=False,
+        index=True,
+        description="Speaker identification (doctor/patient)",
+    )
+    text: str = sqlm.Field(
+        nullable=False,
+        description="Transcribed text content",
+    )
+    confidence: float | None = sqlm.Field(
+        default=None,
+        nullable=True,
+        description="ASR confidence score",
+    )
+    start_time_ms: int = sqlm.Field(
+        nullable=False,
+        description="Start time in segment (milliseconds)",
+    )
+    end_time_ms: int = sqlm.Field(
+        nullable=False,
+        description="End time in segment (milliseconds)",
+    )
+    timestamp: datetime.datetime = sqlm.Field(
+        nullable=False,
+        description="Absolute timestamp of utterance",
+    )
+
+    @classmethod
+    def from_entity(cls, entity: Utterance) -> t.Self:
+        """Convert Utterance entity to table model.
+
+        Args:
+            entity: The Utterance entity to convert.
+
+        Returns:
+            UtteranceTable instance.
+        """
+        return cls(
+            id=entity.id,
+            session_id=entity.session_id,
+            segment_id=entity.segment_id,
+            sequence=entity.sequence,
+            speaker=entity.speaker.value,
+            text=entity.text,
+            confidence=entity.confidence,
+            start_time_ms=entity.start_time_ms,
+            end_time_ms=entity.end_time_ms,
+            timestamp=entity.timestamp,
+            created_at=entity.created_at,
+            updated_at=entity.updated_at,
+        )
+
+    def to_entity(self) -> Utterance:
+        """Convert table model to Utterance entity.
+
+        Returns:
+            Utterance entity instance.
+        """
+        return Utterance(
+            id=self.id,
+            session_id=self.session_id,
+            segment_id=self.segment_id,
+            sequence=self.sequence,
+            speaker=Speaker.parse(self.speaker),
+            text=self.text,
+            confidence=self.confidence,
+            start_time_ms=self.start_time_ms,
+            end_time_ms=self.end_time_ms,
+            timestamp=self.timestamp,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+        )
+
+    def update(self, entity: Utterance) -> None:
+        """Update table model fields from Utterance entity.
+
+        Args:
+            entity: The Utterance entity with updated data.
+        """
+        self.session_id = entity.session_id
+        self.segment_id = entity.segment_id
+        self.sequence = entity.sequence
+        self.speaker = entity.speaker.value
+        self.text = entity.text
+        self.confidence = entity.confidence
+        self.start_time_ms = entity.start_time_ms
+        self.end_time_ms = entity.end_time_ms
+        self.timestamp = entity.timestamp
+        self.updated_at = entity.updated_at
+
+
+TABLES: set[type[sqlm.SQLModel]] = {UtteranceTable}
+"""Set of all table models for the repository."""

audex/lib/repos/tables/vp.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import sqlmodel as sqlm
+
+from audex.entity.vp import VP
+from audex.lib.repos.tables import BaseTable
+
+
+class VPTable(BaseTable[VP], table=True):
+    """Voiceprint (VP) table model for SQLite storage.
+
+    Maps the VP entity to the database table with fields for managing
+    voiceprint data associated with doctors.
+
+    Table: vps
+    """
+
+    __tablename__ = "vps"
+
+    doctor_id: str = sqlm.Field(
+        ...,
+        index=True,
+        max_length=50,
+        description="The ID of the doctor associated with this voiceprint.",
+    )
+    vpr_uid: str = sqlm.Field(
+        ...,
+        unique=True,
+        index=True,
+        max_length=100,
+        description="Unique voiceprint recognition UID from the VP service.",
+    )
+    vpr_group_id: str = sqlm.Field(
+        ...,
+        index=True,
+        max_length=100,
+        description="Voiceprint recognition group ID from the VP service.",
+    )
+    audio_key: str = sqlm.Field(
+        ...,
+        unique=True,
+        index=True,
+        max_length=150,
+        description="Storage key for the voiceprint audio file.",
+    )
+    text_content: str = sqlm.Field(
+        ...,
+        max_length=500,
+        description="The text content used for voiceprint enrollment.",
+    )
+    sample_rate: int = sqlm.Field(
+        ...,
+        description="Sample rate of the voiceprint audio in Hz.",
+    )
+    is_active: bool = sqlm.Field(
+        default=True,
+        description="Indicates whether the voiceprint is active for recognition.",
+    )
+
+    @classmethod
+    def from_entity(cls, entity: VP) -> VPTable:
+        """Create a VPTable instance from a VP entity."""
+        return cls(
+            id=entity.id,
+            doctor_id=entity.doctor_id,
+            vpr_uid=entity.vpr_uid,
+            vpr_group_id=entity.vpr_group_id,
+            audio_key=entity.audio_key,
+            text_content=entity.text_content,
+            sample_rate=entity.sample_rate,
+            is_active=entity.is_active,
+            created_at=entity.created_at,
+            updated_at=entity.updated_at,
+        )
+
+    def to_entity(self) -> VP:
+        return VP(
+            id=self.id,
+            doctor_id=self.doctor_id,
+            vpr_uid=self.vpr_uid,
+            vpr_group_id=self.vpr_group_id,
+            audio_key=self.audio_key,
+            text_content=self.text_content,
+            is_active=self.is_active,
+            sample_rate=self.sample_rate,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+        )
+
+    def update(self, entity: VP) -> None:
+        """Update the VPTable instance with data from a VP entity."""
+        self.doctor_id = entity.doctor_id
+        self.vpr_uid = entity.vpr_uid
+        self.vpr_group_id = entity.vpr_group_id
+        self.audio_key = entity.audio_key
+        self.text_content = entity.text_content
+        self.sample_rate = entity.sample_rate
+        self.is_active = entity.is_active
+        self.updated_at = entity.updated_at
+
+
+TABLES: set[type[sqlm.SQLModel]] = {VPTable}

audex/lib/repos/utterance.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import builtins
+import typing as t
+
+import sqlalchemy as sa
+import sqlmodel as sqlm
+
+from audex.entity.utterance import Utterance
+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.utterance import UtteranceTable
+
+
+class UtteranceRepository(SQLiteRepository[Utterance]):
+    """SQLite implementation of Utterance repository.
+
+    Provides CRUD operations for Utterance entities with additional
+    specialized query methods for utterance management by session and
+    segment.
+    """
+
+    __table__ = UtteranceTable
+    __tablename__ = UtteranceTable.__tablename__
+
+    def __init__(self, sqlite: SQLite) -> None:
+        super().__init__(sqlite)
+
+    async def create(self, data: Utterance, /) -> str:
+        """Create a new utterance in the database.
+
+        Args:
+            data: The utterance entity to create.
+
+        Returns:
+            The ID of the created utterance.
+        """
+        async with self.sqlite.session() as session:
+            utterance_table = UtteranceTable.from_entity(data)
+            session.add(utterance_table)
+            await session.commit()
+            await session.refresh(utterance_table)
+            return utterance_table.id
+
+    async def read(self, id: str, /) -> Utterance | None:
+        """Read an utterance by ID.
+
+        Args:
+            id: The ID (id) of the utterance to retrieve.
+
+        Returns:
+            The utterance entity if found, None otherwise.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(UtteranceTable).where(UtteranceTable.id == id)
+            result = await session.execute(stmt)
+            utterance_obj = result.scalar_one_or_none()
+
+            if utterance_obj is None:
+                return None
+
+            return utterance_obj.to_entity()
+
+    async def first(self, filter: Filter) -> Utterance | None:
+        """Retrieve the first utterance matching the filter.
+
+        Args:
+            filter: Filter to apply when searching for the utterance.
+
+        Returns:
+            The first utterance 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(UtteranceTable)
+
+            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)
+            utterance_obj = result.scalar_one_or_none()
+
+            if utterance_obj is None:
+                return None
+
+            return utterance_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[Utterance]:
+        """List utterances 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 utterance entities matching the criteria.
+        """
+        async with self.sqlite.session() as session:
+            if isinstance(arg, list):
+                if not arg:
+                    return []
+
+                stmt = sqlm.select(UtteranceTable).where(sqlm.col(UtteranceTable.id).in_(arg))
+                result = await session.execute(stmt)
+                utterance_objs = result.scalars().all()
+                return [obj.to_entity() for obj in utterance_objs]
+
+            spec = self.build_query_spec(arg)
+            stmt = sqlm.select(UtteranceTable)
+
+            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)
+            utterance_objs = result.scalars().all()
+            return [obj.to_entity() for obj in utterance_objs]
+
+    async def update(self, data: Utterance, /) -> str:
+        """Update an existing utterance.
+
+        Args:
+            data: The utterance entity with updated values.
+
+        Returns:
+            The ID of the updated utterance.
+
+        Raises:
+            ValueError: If the utterance with the given ID does not exist.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(UtteranceTable).where(UtteranceTable.id == data.id)
+            result = await session.execute(stmt)
+            utterance_obj = result.scalar_one_or_none()
+
+            if utterance_obj is None:
+                raise ValueError(f"Utterance with id {data.id} not found")
+
+            utterance_obj.update(data)
+            session.add(utterance_obj)
+            await session.commit()
+            await session.refresh(utterance_obj)
+            return utterance_obj.id
+
+    async def update_many(self, datas: builtins.list[Utterance]) -> builtins.list[str]:
+        """Update multiple utterances in the database.
+
+        Args:
+            datas: List of utterance entities with updated values.
+
+        Returns:
+            List of IDs of the updated utterances.
+
+        Raises:
+            ValueError: If any utterance 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(UtteranceTable).where(sqlm.col(UtteranceTable.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"Utterances with IDs {missing_ids} not found")
+
+            for data in datas:
+                utterance_obj = table_objs[data.id]
+                utterance_obj.update(data)
+                session.add(utterance_obj)
+                updated_ids.append(utterance_obj.id)
+
+            await session.commit()
+            return updated_ids
+
+    async def delete(self, id: str, /) -> bool:
+        """Delete an utterance by ID.
+
+        Args:
+            id: The ID (id) of the utterance to delete.
+
+        Returns:
+            True if the utterance was deleted, False if not found.
+        """
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(UtteranceTable).where(UtteranceTable.id == id)
+            result = await session.execute(stmt)
+            utterance_obj = result.scalar_one_or_none()
+
+            if utterance_obj is None:
+                return False
+
+            await session.delete(utterance_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 utterances 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(UtteranceTable).where(sqlm.col(UtteranceTable.id).in_(arg))
+                result = await session.execute(stmt)
+                utterance_objs = result.scalars().all()
+
+                if not utterance_objs:
+                    return []
+
+                utterance_ids = [obj.id for obj in utterance_objs]
+                for obj in utterance_objs:
+                    await session.delete(obj)
+
+                await session.commit()
+                return utterance_ids
+
+            spec = self.build_query_spec(arg)
+            stmt = sqlm.select(UtteranceTable.id)  # type: ignore
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            result = await session.execute(stmt)
+            utterance_ids = [row[0] for row in result.all()]
+
+            if not utterance_ids:
+                return []
+
+            delete_stmt = sa.delete(UtteranceTable).where(
+                sqlm.col(UtteranceTable.id).in_(utterance_ids)
+            )
+            await session.execute(delete_stmt)
+            await session.commit()
+            return utterance_ids
+
+    async def count(self, filter: t.Optional[Filter] = None) -> int:  # noqa
+        """Count utterances matching the filter.
+
+        Args:
+            filter: Optional filter to apply. If None, counts all utterances.
+
+        Returns:
+            Number of utterances matching the filter.
+        """
+        spec = self.build_query_spec(filter)
+
+        async with self.sqlite.session() as session:
+            stmt = sqlm.select(sa.func.count()).select_from(UtteranceTable)
+
+            for clause in spec.where:
+                stmt = stmt.where(clause)
+
+            result = await session.execute(stmt)
+            return result.scalar_one()