audex 1.0.7a3__py3-none-any.whl

audex/service/doctor/exceptions.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import typing as t
+
+from audex.exceptions import AudexError
+from audex.exceptions import InternalError
+
+
+class DoctorServiceError(AudexError):
+    """Base exception for doctor service errors."""
+
+    default_message = "Doctor service error"
+    code: t.ClassVar[int] = 0x30
+
+
+class InternalDoctorServiceError(InternalError):
+    """Internal error in doctor service."""
+
+    default_message = "Internal doctor service error"
+    code: t.ClassVar[int] = 0x31
+
+
+class DoctorNotFoundError(DoctorServiceError):
+    """Raised when doctor is not found."""
+
+    __slots__ = ("doctor_id", "message")
+
+    default_message = "Doctor not found"
+    code: t.ClassVar[int] = 0x32
+
+    def __init__(self, message: str, *, doctor_id: str) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: Error message (typically in Chinese for users).
+            doctor_id: The ID of the doctor that was not found.
+        """
+        self.doctor_id = doctor_id
+        super().__init__(message)
+
+
+class InvalidCredentialsError(DoctorServiceError):
+    """Raised for invalid login credentials."""
+
+    __slots__ = ("message", "reason")
+
+    default_message = "Invalid credentials"
+    code: t.ClassVar[int] = 0x33
+
+    def __init__(self, message: str, *, reason: str | None = None) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: Error message (typically in Chinese for users).
+            reason: Machine-readable reason code (from InvalidCredentialReasons).
+        """
+        self.reason = reason
+        super().__init__(message)
+
+
+class VoiceprintNotFoundError(DoctorServiceError):
+    """Raised when voiceprint is not found."""
+
+    __slots__ = ("doctor_id", "message")
+
+    default_message = "Voiceprint not found"
+    code: t.ClassVar[int] = 0x34
+
+    def __init__(self, message: str, *, doctor_id: str) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: Error message (typically in Chinese for users).
+            doctor_id: The ID of the doctor whose voiceprint was not found.
+        """
+        self.doctor_id = doctor_id
+        super().__init__(message)
+
+
+class DuplicateEIDError(DoctorServiceError):
+    """Raised when trying to register with an existing EID."""
+
+    __slots__ = ("eid", "message")
+
+    default_message = "Duplicate EID"
+    code: t.ClassVar[int] = 0x35
+
+    def __init__(self, message: str, *, eid: str) -> None:
+        """Initialize the exception.
+
+        Args:
+            message: Error message (typically in Chinese for users).
+            eid: The duplicate employee ID.
+        """
+        self.eid = eid
+        super().__init__(message)

audex/service/doctor/types.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import typing as t
+
+from audex.valueobj.common.auth import Password
+from audex.valueobj.common.email import Email
+from audex.valueobj.common.phone import CNPhone
+
+
+class LoginCommand(t.NamedTuple):
+    """Command for doctor login."""
+
+    eid: str
+    password: Password
+
+
+class RegisterCommand(t.NamedTuple):
+    """Command for doctor registration."""
+
+    eid: str
+    password: Password
+    name: str
+    department: str | None = None
+    title: str | None = None
+    hospital: str | None = None
+    phone: CNPhone | None = None
+    email: Email | None = None
+
+
+class UpdateCommand(t.NamedTuple):
+    """Command for updating doctor profile."""
+
+    name: str | None = None
+    department: str | None = None
+    title: str | None = None
+    hospital: str | None = None
+    phone: CNPhone | None = None
+    email: Email | None = None
+
+
+class VPEnrollResult(t.NamedTuple):
+    """Result of voiceprint enrollment/update.
+
+    Attributes:
+        vp_id: ID of the VP entity.
+        vpr_uid: UID in the VPR system.
+        audio_key: Storage key of the audio file.
+        duration_ms: Duration of the recording in milliseconds.
+    """
+
+    vp_id: str
+    vpr_uid: str
+    audio_key: str
+    duration_ms: int

audex/service/export/__init__.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+
+from audex.helper import net
+from audex.lib.cache import KVCache
+from audex.lib.exporter import Exporter
+from audex.lib.repos.doctor import DoctorRepository
+from audex.lib.server import Server
+from audex.lib.session import SessionManager
+from audex.lib.usb import USBDevice
+from audex.lib.usb import USBManager
+from audex.service import BaseService
+from audex.service.decorators import require_auth
+from audex.service.export.const import ErrorMessages
+from audex.service.export.exceptions import ExportServiceError
+from audex.service.export.exceptions import InternalExportServiceError
+from audex.service.export.exceptions import NoUSBDeviceError
+from audex.service.export.exceptions import ServerAlreadyRunningError
+from audex.service.export.types import ExportResult
+from audex.service.export.types import ServerInfo
+
+
+class ExportService(BaseService):
+    """Service for exporting session data via HTTP or USB."""
+
+    __logtag__ = "audex.service.export"
+
+    def __init__(
+        self,
+        session_manager: SessionManager,
+        cache: KVCache,
+        doctor_repo: DoctorRepository,
+        usb: USBManager,
+        exporter: Exporter,
+        server: Server,
+    ):
+        super().__init__(session_manager=session_manager, cache=cache, doctor_repo=doctor_repo)
+        self.usb = usb
+        self.exporter = exporter
+        self.server = server
+        self._server_task: asyncio.Task[None] | None = None
+        self._server_running = False
+
+    @require_auth
+    async def start_server(self) -> ServerInfo:
+        """Start HTTP export server.
+
+        Returns:
+            ServerInfo with host and port.
+
+        Raises:
+            ServerAlreadyRunningError: If server is already running.
+            InternalExportServiceError: For internal errors.
+        """
+        try:
+            if self._server_running:
+                raise ServerAlreadyRunningError(ErrorMessages.SERVER_ALREADY_RUNNING)
+
+            # Start server in background task
+            addr = net.getaddr()
+            port = net.getfreeport()
+            self._server_task = asyncio.create_task(self.server.start(host="0.0.0.0", port=port))
+            self._server_running = True
+
+            # Get server info
+            server_info = ServerInfo(
+                host=addr,
+                port=port,
+                url=f"http://{addr}:{port}",
+            )
+
+            self.logger.info(f"Started export server at {server_info.url}")
+            return server_info
+
+        except ServerAlreadyRunningError:
+            raise
+
+        except Exception as e:
+            self.logger.error(f"Failed to start server: {e}")
+            raise InternalExportServiceError(ErrorMessages.SERVER_START_FAILED) from e
+
+    @require_auth
+    async def stop_server(self) -> None:
+        """Stop HTTP export server.
+
+        Raises:
+            InternalExportServiceError: For internal errors.
+        """
+        try:
+            if not self._server_running:
+                self.logger.warning("Server is not running")
+                return
+
+            # Stop server
+            await self.server.close()
+
+            # Cancel task if exists
+            if self._server_task:
+                self._server_task.cancel()
+                with contextlib.suppress(asyncio.CancelledError):
+                    await self._server_task
+                self._server_task = None
+
+            self._server_running = False
+            self.logger.info("Stopped export server")
+
+        except Exception as e:
+            self.logger.error(f"Failed to stop server: {e}")
+            raise InternalExportServiceError(ErrorMessages.SERVER_STOP_FAILED) from e
+
+    @require_auth
+    async def is_server_running(self) -> bool:
+        """Check if HTTP export server is running."""
+        return self._server_running
+
+    @require_auth
+    async def list_usb_devices(self) -> list[USBDevice]:
+        """List all connected USB storage devices.
+
+        Returns:
+            List of connected USB devices.
+        """
+        try:
+            devices = self.usb.list_devices()
+            self.logger.debug(f"Found {len(devices)} USB device(s)")
+            return devices
+        except Exception as e:
+            self.logger.error(f"Failed to list USB devices: {e}")
+            return []
+
+    @require_auth
+    async def export_to_usb(
+        self,
+        session_ids: list[str],
+        device: USBDevice | None = None,
+    ) -> ExportResult:
+        """Export sessions to USB device.
+
+        Args:
+            session_ids: List of session IDs to export.
+            device: Target USB device.  If None, uses first available device.
+
+        Returns:
+            ExportResult with success status and details.
+
+        Raises:
+            NoUSBDeviceError: If no USB device is available.
+            InternalExportServiceError: For internal errors.
+        """
+        try:
+            # Get USB device
+            if device is None:
+                devices = await self.list_usb_devices()
+                if not devices:
+                    raise NoUSBDeviceError(ErrorMessages.NO_USB_DEVICE)
+                device = devices[0]
+                self.logger.info(f"Using first USB device: {device.mount_point}")
+
+            # Verify doctor owns all sessions
+            session = await self.session_manager.get_session()
+            if not session:
+                raise ExportServiceError(ErrorMessages.NO_ACTIVE_SESSION)
+
+            for session_id in session_ids:
+                sess = await self.exporter.session_repo.read(session_id)
+                if not sess or sess.doctor_id != session.doctor_id:
+                    raise ExportServiceError(
+                        f"无权访问会话 {session_id}",
+                    )
+
+            # Export each session
+            export_tasks = []
+
+            for session_id in session_ids:
+                # Generate ZIP
+                zip_data = await self.exporter.export_session_zip(session_id)
+
+                # Get session info for filename
+                sess = await self.exporter.session_repo.read(session_id)
+                filename = f"{session_id}"
+                if sess and sess.patient_name:
+                    filename = f"{sess.patient_name}_{session_id}"
+                filename += ".zip"
+
+                # Write to temp file
+                import pathlib
+                import tempfile
+
+                temp_path = pathlib.Path(tempfile.mkdtemp()) / filename
+                temp_path.write_bytes(zip_data)
+
+                # Add export task
+                self.usb.add_export_task(
+                    source=temp_path,
+                    dest_name=f"audex_export/{filename}",
+                    is_directory=False,
+                )
+                export_tasks.append((session_id, temp_path))
+
+            # Export to USB
+            results = await self.usb.export(device)
+
+            # Clean up temp files
+            for _, temp_path in export_tasks:
+                try:
+                    temp_path.unlink()
+                    temp_path.parent.rmdir()
+                except Exception:
+                    pass
+
+            # Clear export tasks
+            self.usb.clear_export_tasks()
+
+            # Check results
+            success_count = sum(1 for success in results.values() if success)
+            total_count = len(results)
+
+            export_result = ExportResult(
+                success=success_count == total_count,
+                total=total_count,
+                success_count=success_count,
+                failed_count=total_count - success_count,
+                device_label=device.label or device.mount_point,
+            )
+
+            self.logger.info(f"USB export completed: {success_count}/{total_count} successful")
+
+            return export_result
+
+        except (NoUSBDeviceError, ExportServiceError):
+            raise
+        except Exception as e:
+            self.logger.error(f"USB export failed: {e}")
+            raise InternalExportServiceError(ErrorMessages.USB_EXPORT_FAILED) from e

audex/service/export/const.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+
+class ErrorMessages:
+    """Error messages in Chinese for export service."""
+
+    # Server errors
+    SERVER_ALREADY_RUNNING = "服务器已在运行"
+    SERVER_START_FAILED = "启动服务器失败"
+    SERVER_STOP_FAILED = "停止服务器失败"
+
+    # USB errors
+    NO_USB_DEVICE = "未检测到U盘，请插入U盘后重试"
+    USB_EXPORT_FAILED = "导出到U盘失败"
+
+    # Session errors
+    NO_ACTIVE_SESSION = "登录状态已过期，请重新登录"

audex/service/export/exceptions.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing as t
+
+from audex.exceptions import AudexError
+from audex.exceptions import InternalError
+
+
+class ExportServiceError(AudexError):
+    """Base exception for export service errors."""
+
+    default_message = "Export service error"
+    code: t.ClassVar[int] = 0x50
+
+
+class InternalExportServiceError(InternalError):
+    """Internal error in export service."""
+
+    default_message = "Internal export service error"
+    code: t.ClassVar[int] = 0x51
+
+
+class NoUSBDeviceError(ExportServiceError):
+    """Raised when no USB device is available."""
+
+    default_message = "No USB device available"
+    code: t.ClassVar[int] = 0x52
+
+
+class ServerAlreadyRunningError(ExportServiceError):
+    """Raised when server is already running."""
+
+    default_message = "Server already running"
+    code: t.ClassVar[int] = 0x53

audex/service/export/types.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import typing as t
+
+
+class ServerInfo(t.NamedTuple):
+    """HTTP server information."""
+
+    host: str
+    port: int
+    url: str
+
+
+class ExportResult(t.NamedTuple):
+    """Result of USB export operation."""
+
+    success: bool
+    total: int
+    success_count: int
+    failed_count: int
+    device_label: str

audex/service/injectors/__init__.py

@@ -0,0 +1 @@
+from __future__ import annotations

audex/service/injectors/container.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dependency_injector import containers
+from dependency_injector import providers
+
+from audex.config import Config
+from audex.service.injectors.doctor import make_doctor_service
+from audex.service.injectors.export import make_export_service
+from audex.service.injectors.session import make_session_service
+
+
+class ServiceContainer(containers.DeclarativeContainer):
+    # Dependencies
+    config = providers.Dependency(instance_of=Config)
+    infrastructure = providers.DependenciesContainer()
+    repository = providers.DependenciesContainer()
+
+    # Components
+    doctor = providers.Factory(
+        make_doctor_service,
+        session_manager=infrastructure.session_manager,
+        cache=infrastructure.cache,
+        config=config,
+        doctor_repo=repository.doctor,
+        vp_repo=repository.vp,
+        vpr=infrastructure.vpr,
+        recorder=infrastructure.recorder,
+    )
+
+    session = providers.Factory(
+        make_session_service,
+        session_manager=infrastructure.session_manager,
+        cache=infrastructure.cache,
+        config=config,
+        doctor_repo=repository.doctor,
+        session_repo=repository.session,
+        segment_repo=repository.segment,
+        utterance_repo=repository.utterance,
+        vp_repo=repository.vp,
+        vpr=infrastructure.vpr,
+        transcription=infrastructure.transcription,
+        recorder=infrastructure.recorder,
+    )
+
+    export = providers.Factory(
+        make_export_service,
+        session_manager=infrastructure.session_manager,
+        cache=infrastructure.cache,
+        doctor_repo=repository.doctor,
+        usb=infrastructure.usb,
+        exporter=infrastructure.exporter,
+        server=infrastructure.server,
+    )

audex/service/injectors/doctor.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from audex.config import Config
+from audex.lib.cache import KVCache
+from audex.lib.recorder import AudioRecorder
+from audex.lib.repos.doctor import DoctorRepository
+from audex.lib.repos.vp import VPRepository
+from audex.lib.session import SessionManager
+from audex.lib.vpr import VPR
+from audex.service.doctor import DoctorService
+from audex.service.doctor import DoctorServiceConfig
+
+
+def make_doctor_service(
+    session_manager: SessionManager,
+    cache: KVCache,
+    config: Config,
+    doctor_repo: DoctorRepository,
+    vp_repo: VPRepository,
+    vpr: VPR,
+    recorder: AudioRecorder,
+) -> DoctorService:
+    return DoctorService(
+        session_manager=session_manager,
+        cache=cache,
+        config=DoctorServiceConfig(
+            vpr_sr=config.core.audio.vpr_sample_rate,
+            vpr_text_content=config.core.audio.vpr_text_content,
+        ),
+        doctor_repo=doctor_repo,
+        vp_repo=vp_repo,
+        vpr=vpr,
+        recorder=recorder,
+    )

audex/service/injectors/export.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from audex.lib.cache import KVCache
+from audex.lib.exporter import Exporter
+from audex.lib.repos.doctor import DoctorRepository
+from audex.lib.server import Server
+from audex.lib.session import SessionManager
+from audex.lib.usb import USBManager
+from audex.service.export import ExportService
+
+
+def make_export_service(
+    session_manager: SessionManager,
+    cache: KVCache,
+    doctor_repo: DoctorRepository,
+    usb: USBManager,
+    exporter: Exporter,
+    server: Server,
+) -> ExportService:
+    return ExportService(
+        session_manager=session_manager,
+        cache=cache,
+        doctor_repo=doctor_repo,
+        usb=usb,
+        exporter=exporter,
+        server=server,
+    )

audex/service/injectors/session.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from audex.config import Config
+from audex.lib.cache import KVCache
+from audex.lib.recorder import AudioRecorder
+from audex.lib.repos.doctor import DoctorRepository
+from audex.lib.repos.segment import SegmentRepository
+from audex.lib.repos.session import SessionRepository
+from audex.lib.repos.utterance import UtteranceRepository
+from audex.lib.repos.vp import VPRepository
+from audex.lib.session import SessionManager
+from audex.lib.transcription import Transcription
+from audex.lib.vpr import VPR
+from audex.service.session import SessionService
+from audex.service.session import SessionServiceConfig
+
+
+def make_session_service(
+    session_manager: SessionManager,
+    cache: KVCache,
+    config: Config,
+    doctor_repo: DoctorRepository,
+    session_repo: SessionRepository,
+    segment_repo: SegmentRepository,
+    utterance_repo: UtteranceRepository,
+    vp_repo: VPRepository,
+    vpr: VPR,
+    transcription: Transcription,
+    recorder: AudioRecorder,
+) -> SessionService:
+    return SessionService(
+        session_manager=session_manager,
+        cache=cache,
+        config=SessionServiceConfig(
+            audio_key_prefix=config.core.audio.key_prefix,
+            segment_buffer_ms=config.core.audio.segment_buffer,
+            sr=config.core.audio.sample_rate,
+            vpr_sr=config.core.audio.vpr_sample_rate,
+            vpr_threshold=config.core.audio.vpr_threshold,
+        ),
+        doctor_repo=doctor_repo,
+        session_repo=session_repo,
+        segment_repo=segment_repo,
+        utterance_repo=utterance_repo,
+        vp_repo=vp_repo,
+        vpr=vpr,
+        transcription=transcription,
+        recorder=recorder,
+    )