audex 1.0.7a3__py3-none-any.whl

audex/lib/repos/decorators.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import functools as ft
+import typing as t
+
+if t.TYPE_CHECKING:
+    from audex.lib.repos import BaseRepository
+
+    RepositoryMethodT = t.TypeVar("RepositoryMethodT", bound=t.Callable[..., t.Awaitable[t.Any]])
+
+
+def log_repo_call(func: RepositoryMethodT) -> RepositoryMethodT:
+    """Decorator to log repository method calls.
+
+    Logs the operation with repo type, collection/table name, and operation
+    name. This decorator should be applied BEFORE track_repo_call decorator.
+
+    Example:
+        ```python
+        class UserRepository(MongoRepository[User]):
+            @log_repo_call
+            @track_repo_call
+            async def create(self, data: User) -> str:
+                # Implementation
+                return user_id
+        ```
+    """
+
+    @ft.wraps(func)
+    async def wrapper(self: BaseRepository[t.Any], *args: t.Any, **kwargs: t.Any) -> t.Any:
+        operation = func.__name__
+        repo_type = self.__repotype__
+
+        # Get collection name from subclass
+        if hasattr(self, "__collname__"):
+            collection = self.__collname__
+        elif hasattr(self, "__tablename__"):
+            collection = self.__tablename__
+        else:
+            collection = "unknown"
+
+        # Log the call
+        self.logger.info(  # type: ignore
+            f"Repository operation: {repo_type}.{collection}.{operation}",
+            repo_type=repo_type,
+            collection=collection,
+            operation=operation,
+        )
+
+        try:
+            result = await func(self, *args, **kwargs)
+
+            self.logger.info(  # type: ignore
+                f"Repository operation completed: {repo_type}.{collection}.{operation}",
+                repo_type=repo_type,
+                collection=collection,
+                operation=operation,
+                status="success",
+            )
+            return result
+
+        except Exception as e:
+            self.logger.error(  # type: ignore
+                f"Repository operation failed: {repo_type}.{collection}.{operation}: {e}",
+                repo_type=repo_type,
+                collection=collection,
+                operation=operation,
+                error=str(e),
+                error_type=type(e).__name__,
+                status="error",
+            )
+            raise
+
+    return wrapper  # type: ignore

audex/lib/repos/doctor.py

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

audex/lib/repos/segment.py

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