audex 1.0.7a3__py3-none-any.whl

audex/cli/helper/display.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import pathlib
+import sys
+import textwrap
+import traceback
+import typing as t
+
+import halo
+
+from audex.cli.helper.ansi import ANSI
+
+spinner = halo.Halo(spinner="dots")
+
+
+def success(message: str, /, prefix: str = "✓") -> None:
+    """Print a success message."""
+    print(f"{ANSI.success(prefix)} {message}")
+
+
+def error(message: str, /, prefix: str = "✗") -> None:
+    """Print an error message."""
+    print(f"{ANSI.error(prefix)} {message}", file=sys.stderr)
+
+
+def warning(message: str, /, prefix: str = "⚠") -> None:
+    """Print a warning message."""
+    print(f"{ANSI.warning(prefix)} {message}")
+
+
+def info(message: str, /, prefix: str = "ℹ") -> None:
+    """Print an info message."""
+    print(f"{ANSI.info(prefix)} {message}")
+
+
+def debug(message: str, /, prefix: str = "→") -> None:
+    """Print a debug message (dimmed)."""
+    print(ANSI.format(f"{prefix} {message}", ANSI.STYLE.DIM))
+
+
+def step(message: str, /, step: int | None = None) -> None:
+    """Print a step message in a process."""
+    if step is not None:
+        prefix = ANSI.format(f"[{step}]", ANSI.FG.CYAN, ANSI.STYLE.BOLD)
+        print(f"\n{prefix} {message}")
+    else:
+        print(f"\n▸ {message}")
+
+
+def path(
+    path: str | pathlib.Path | os.PathLike[str],
+    /,
+    label: str | None = None,
+    exists: bool | None = None,
+) -> None:
+    """Print a formatted file path."""
+    path = pathlib.Path(path)
+
+    parts = []
+    if label:
+        parts.append(ANSI.format(f"{label}:", ANSI.STYLE.BOLD))
+
+    if exists is not None:
+        indicator = ANSI.success("✓") if exists else ANSI.error("✗")
+        parts.append(indicator)
+
+    parts.append(ANSI.format(str(path), ANSI.FG.CYAN))
+    print(" ".join(parts))
+
+
+def command(cmd: str, /) -> None:
+    """Print a command being executed."""
+    print(ANSI.format(f"  $ {cmd}", ANSI.FG.GRAY, ANSI.STYLE.DIM))
+
+
+def header(text: str, /) -> None:
+    """Print a section header."""
+    print()
+    print(ANSI.format(text, ANSI.STYLE.BOLD))
+    print(ANSI.format("─" * len(text), ANSI.FG.GRAY))
+
+
+def separator() -> None:
+    """Print a separator line."""
+    print(ANSI.format("─" * 60, ANSI.FG.GRAY))
+
+
+def key_value(
+    data: dict[str, t.Any],
+    /,
+    indent: int = 0,
+) -> None:
+    """Print key-value pairs in a clean format."""
+    if not data:
+        return
+
+    max_key_len = max(len(str(k)) for k in data)
+    indent_str = "  " * indent
+
+    for key, value in data.items():
+        key_str = ANSI.format(str(key).ljust(max_key_len), ANSI.STYLE.BOLD)
+        value_str = str(value)
+        print(f"{indent_str}{key_str}  {value_str}")
+
+
+def list_items(
+    items: list[str],
+    /,
+    bullet: str = "•",
+    indent: int = 0,
+) -> None:
+    """Print a bulleted list of items."""
+    indent_str = "  " * indent
+    for item in items:
+        print(f"{indent_str}{ANSI.format(bullet, ANSI.FG.CYAN)} {item}")
+
+
+@contextlib.contextmanager
+def loading(
+    text: str = "Loading",
+    /,
+    success_text: str | None = None,
+    error_text: str | None = None,
+) -> t.Generator[t.Any, None, None]:
+    """Context manager for showing a loading spinner."""
+    spinner.text = text
+    spinner.start()
+
+    try:
+        yield spinner
+        if success_text:
+            spinner.succeed(success_text)
+        else:
+            spinner.succeed()
+    except Exception as e:
+        if error_text:
+            spinner.fail(error_text)
+        else:
+            spinner.fail(f"{text} failed: {e}")
+        raise
+    finally:
+        spinner.stop()
+
+
+@contextlib.contextmanager
+def section(title: str, /) -> t.Generator[None, None, None]:
+    """Context manager for a named section."""
+    print()
+    print(ANSI.format(f"┌─ {title}", ANSI.FG.CYAN, ANSI.STYLE.BOLD))
+
+    try:
+        yield
+    finally:
+        print(ANSI.format("└─" + "─" * (len(title) + 2), ANSI.FG.CYAN))
+
+
+def banner(text: str, /, subtitle: str | None = None, version: str | None = None) -> None:
+    """Print an application banner."""
+    width = max(len(text), len(subtitle) if subtitle else 0) + 4
+
+    print()
+    print(ANSI.format("┌" + "─" * (width - 2) + "┐", ANSI.FG.CYAN, ANSI.STYLE.BOLD))
+    print(ANSI.format(f"│ {text.center(width - 4)} │", ANSI.FG.CYAN, ANSI.STYLE.BOLD))
+
+    if subtitle:
+        print(ANSI.format(f"│ {subtitle.center(width - 4)} │", ANSI.FG.CYAN))
+
+    if version:
+        version_text = f"v{version}"
+        print(ANSI.format(f"│ {version_text.center(width - 4)} │", ANSI.FG.GRAY))
+
+    print(ANSI.format("└" + "─" * (width - 2) + "┘", ANSI.FG.CYAN, ANSI.STYLE.BOLD))
+    print()
+
+
+def confirm(prompt: str, /, default: bool = False) -> bool:
+    """Ask for user confirmation with a yes/no prompt."""
+    suffix = ANSI.format("[Y/n]" if default else "[y/N]", ANSI.STYLE.DIM)
+    response = input(f"{prompt} {suffix} ").strip().lower()
+
+    if not response:
+        return default
+
+    if response in ("y", "yes"):
+        return True
+    if response in ("n", "no"):
+        return False
+
+    error("Please answer 'y' or 'n'")
+    return confirm(prompt, default)
+
+
+def exception_detail(exc: Exception, /, show_traceback: bool = False) -> None:
+    """Display detailed exception information."""
+    from audex.exceptions import AudexError
+
+    print()
+    print(ANSI.error("┌" + "─" * 68 + "┐"))
+    print(ANSI.error(f"│ ERROR: {type(exc).__name__}".ljust(70) + "│"))
+
+    if isinstance(exc, AudexError):
+        print(ANSI.error(f"│ Code: {exc.code}".ljust(70) + "│"))
+
+    print(ANSI.error("├" + "─" * 68 + "┤"))
+
+    # Wrap error message
+    msg = str(exc)
+    for line in textwrap.wrap(msg, width=66):
+        print(ANSI.error(f"│ {line}".ljust(70) + "│"))
+
+    print(ANSI.error("└" + "─" * 68 + "┘"))
+
+    if show_traceback:
+        print()
+        print(ANSI.format("Traceback:", ANSI.STYLE.DIM))
+        print(ANSI.format("─" * 70, ANSI.FG.GRAY))
+        traceback.print_exception(type(exc), exc, exc.__traceback__)
+
+
+def error_summary(
+    title: str,
+    /,
+    details: dict[str, str] | None = None,
+    suggestions: list[str] | None = None,
+) -> None:
+    """Display an error summary with optional details and
+    suggestions."""
+    print()
+    print(ANSI.error(f"✗ {title}"))
+    print()
+
+    if details:
+        print(ANSI.format("Details:", ANSI.STYLE.BOLD))
+        key_value(details, indent=1)
+        print()
+
+    if suggestions:
+        print(ANSI.format("Suggestions:", ANSI.STYLE.BOLD))
+        list_items(suggestions, bullet="→", indent=1)
+        print()
+
+
+def fatal_error(message: str, /, exit_code: int = 1) -> t.NoReturn:
+    """Display a fatal error and exit."""
+    print()
+    print(ANSI.error("╔" + "═" * 68 + "╗"))
+    print(ANSI.error("║" + " FATAL ERROR ".center(68) + "║"))
+    print(ANSI.error("╠" + "═" * 68 + "╣"))
+
+    for line in textwrap.wrap(message, width=66):
+        print(ANSI.error("║ " + line.ljust(67) + "║"))
+
+    print(ANSI.error("╚" + "═" * 68 + "╝"))
+    print()
+    sys.exit(exit_code)
+
+
+def show_error(exc: Exception, verbose: bool = False) -> None:
+    """Display error information."""
+    from audex.exceptions import AudexError
+
+    error(f"{type(exc).__name__}: {exc}")
+
+    if isinstance(exc, AudexError):
+        info(f"Error code: {exc.code}")
+
+    if verbose:
+        print()
+        print(ANSI.format("Traceback:", ANSI.STYLE.DIM))
+        traceback.print_exception(type(exc), exc, exc.__traceback__)
+
+
+# Simplified table functions - removed overly complex wrapping logic
+def table_dict(
+    data: dict[str, t.Any],
+    /,
+) -> None:
+    """Print a simple table from a dictionary."""
+    if not data:
+        return
+
+    max_key_len = max(len(str(k)) for k in data)
+
+    for key, value in data.items():
+        key_str = ANSI.format(str(key).ljust(max_key_len), ANSI.STYLE.BOLD)
+        print(f"  {key_str}  {value}")

audex/config/__init__.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import typing as t
+
+from pydantic import Field
+from pydantic_settings import SettingsConfigDict
+
+from audex.config.core import CoreConfig
+from audex.config.infrastructure import InfrastructureConfig
+from audex.config.provider import ProviderConfig
+from audex.helper.mixin import ContextMixin
+from audex.helper.settings import Settings
+
+
+class Config(ContextMixin, Settings):
+    model_config: t.ClassVar[SettingsConfigDict] = SettingsConfigDict(
+        env_prefix="AUDEX__",
+        validate_default=False,
+        env_nested_delimiter="__",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    core: CoreConfig = Field(
+        default_factory=CoreConfig,
+        description="Core configuration settings.",
+    )
+
+    provider: ProviderConfig = Field(
+        default_factory=ProviderConfig,
+        description="Provider configuration settings.",
+    )
+
+    infrastructure: InfrastructureConfig = Field(
+        default_factory=InfrastructureConfig,
+        description="Infrastructure configuration settings.",
+    )
+
+    def init(self) -> None:
+        self.core.logging.init()
+
+
+config = None  # type: t.Optional[Config]
+
+
+def build_config() -> Config:
+    global config
+    if config is None:
+        config = Config()
+    return config
+
+
+def setconfig(cfg: Config, /) -> None:
+    global config
+    config = cfg
+
+
+def getconfig() -> Config:
+    global config
+    if config is None:
+        raise RuntimeError(
+            "Configuration has not been initialized. Please call `build_config()` or `setconfig()` before accessing the configuration."
+        )
+    return config

audex/config/core/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from audex.config.core.app import AppConfig
+from audex.config.core.audio import AudioConfig
+from audex.config.core.logging import LoggingConfig
+from audex.config.core.session import SessionConfig
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class CoreConfig(BaseModel):
+    app: AppConfig = Field(
+        default_factory=AppConfig,
+        description="Application specific configuration",
+    )
+
+    logging: LoggingConfig = Field(
+        default_factory=LoggingConfig,
+        description="Logging configuration",
+    )
+
+    audio: AudioConfig = Field(
+        default_factory=AudioConfig,
+        description="Audio processing configuration",
+    )
+
+    session: SessionConfig = Field(
+        default_factory=SessionConfig,
+        description="Session management configuration",
+    )

audex/config/core/app.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from audex import __title__
+from audex import __version__
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class AppConfig(BaseModel):
+    app_name: str = Field(
+        default=__title__,
+        description="The name of the application.",
+    )
+
+    app_version: str = Field(
+        default=__version__,
+        description="The version of the application.",
+    )
+
+    debug: bool = Field(
+        default=False,
+        description="Enable or disable debug mode.",
+    )
+
+    native: bool = Field(
+        default=False,
+        description="Indicates if the application is running in native mode.",
+        linux_default=True,
+    )

audex/config/core/audio.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from audex import __prog__
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class AudioConfig(BaseModel):
+    sample_rate: int = Field(
+        default=16000,
+        description="The sample rate of the audio in Hz.",
+    )
+
+    vpr_sample_rate: int = Field(
+        default=16000,
+        description="The sample rate for voice print recognition in Hz.",
+    )
+
+    vpr_text_content: str = Field(
+        default="您好，请问您今天需要什么帮助？",
+        min_length=10,
+        max_length=100,
+        description="The text content used for voice print recognition.",
+    )
+
+    vpr_threshold: float = Field(
+        default=0.5,
+        gt=0.0,
+        lt=1.0,
+        description="The threshold for voice print recognition similarity.",
+    )
+
+    key_prefix: str = Field(
+        default=__prog__,
+        min_length=1,
+        max_length=50,
+        description="The prefix for storing audio files in cloud storage.",
+    )
+
+    segment_buffer: int = Field(
+        default=2000,
+        gt=0,
+        lt=5000,
+        description="The buffer time in milliseconds for audio segmentation.",
+    )

audex/config/core/logging.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+import typing as t
+
+from pydantic import model_validator
+
+from audex.helper.mixin import ContextMixin
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class SizeBasedRotation(BaseModel):
+    max_size: int = Field(
+        default=10,
+        description="Maximum size (MB) of the log file before rotation",
+        ge=1,
+        le=1024 * 1024,
+    )
+
+    backup_count: int = Field(
+        default=5,
+        description="Number of backup files to keep",
+        ge=0,
+        le=100,
+    )
+
+
+class TimeBasedRotation(BaseModel):
+    interval: int = Field(
+        default=1,
+        description="Interval in hours for log rotation",
+        ge=1,
+        le=24,
+    )
+
+    backup_count: int = Field(
+        default=5,
+        description="Number of backup files to keep",
+        ge=0,
+        le=100,
+    )
+
+
+class Rotation(BaseModel):
+    size_based: SizeBasedRotation | None = Field(
+        default=None,
+        description="Configuration for size-based log rotation",
+    )
+
+    time_based: TimeBasedRotation | None = Field(
+        default=None,
+        description="Configuration for time-based log rotation",
+    )
+
+    @model_validator(mode="after")
+    def validate_rotation_config(self) -> t.Self:
+        if self.size_based and self.time_based:
+            raise ValueError("Only one type of rotation configuration can be provided")
+
+        return self
+
+
+class LoggingTarget(ContextMixin, BaseModel):
+    logname: t.Literal["stdout", "stderr"] | os.PathLike[str] = Field(
+        default="stdout",
+        description="Name of the target, can be 'stdout', 'stderr', or a file path",
+    )
+
+    loglevel: t.Literal[
+        "debug",
+        "DEBUG",
+        "info",
+        "INFO",
+        "warning",
+        "WARNING",
+        "error",
+        "ERROR",
+        "critical",
+        "CRITICAL",
+    ] = Field(
+        default="info",
+        description="Log level for this target",
+    )
+
+    rotation: Rotation | None = Field(
+        default=None,
+        description="Configuration for log rotation",
+    )
+
+
+class LoggingConfig(BaseModel):
+    targets: list[LoggingTarget] = Field(
+        default_factory=lambda: [
+            LoggingTarget(logname="stdout", loglevel="debug"),
+            LoggingTarget(logname="stderr", loglevel="error"),
+            LoggingTarget(
+                logname=pathlib.Path("logs/audex.jsonl"),
+                loglevel="info",
+                rotation=Rotation(size_based=SizeBasedRotation()),
+            ),
+        ],
+        description="List of logging targets",
+        windows_default=lambda: [
+            LoggingTarget(logname="stdout", loglevel="info"),
+            LoggingTarget(
+                logname=pathlib.PureWindowsPath("%PROGRAMDATA%\\logs\\audex.log"),
+                loglevel="info",
+                rotation=Rotation(size_based=SizeBasedRotation()),
+            ),
+        ],
+        linux_default=lambda: [
+            LoggingTarget(logname="stdout", loglevel="info"),
+            LoggingTarget(
+                logname=pathlib.PurePosixPath("${HOME}/.local/share/audex/logs/audex.log"),
+                loglevel="info",
+                rotation=Rotation(size_based=SizeBasedRotation()),
+            ),
+        ],
+    )
+
+    def init(self) -> None:
+        from loguru import logger
+
+        if t.TYPE_CHECKING:
+            pass
+
+        # Clear existing handlers
+        logger.remove()
+
+        # Set up each logging target
+        for target in self.targets:
+            level = target.loglevel.upper()
+            if target.logname == "stdout":
+                logger.add(sys.stdout, level=level)
+                continue
+            if target.logname == "stderr":
+                logger.add(sys.stderr, level=level)
+                continue
+            sink = target.logname
+
+            # Configure rotation if specified
+            if target.rotation:
+                if target.rotation.size_based:
+                    logger.add(
+                        sink,
+                        retention=target.rotation.size_based.backup_count,
+                        level=level,
+                        rotation=f"{target.rotation.size_based.max_size} MB",
+                        serialize=True,
+                    )
+                elif target.rotation.time_based:
+                    logger.add(
+                        sink,
+                        retention=target.rotation.time_based.backup_count,
+                        level=level,
+                        rotation=f"{target.rotation.time_based.interval} hours",
+                        serialize=True,
+                    )
+            else:
+                logger.add(sink, level=level)

audex/config/core/session.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class SessionConfig(BaseModel):
+    ttl_hours: float = Field(
+        default=24 * 7,
+        description="Time to live for a session in hours.",
+    )

audex/config/helper/__init__.py

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

audex/config/helper/client/__init__.py

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

audex/config/helper/client/http.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import typing as t
+
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class HttpClientConfig(BaseModel):
+    proxy: str | None = Field(
+        default=None,
+        description="Proxy URL to route HTTP requests through. Example: 'http://localhost:8080'",
+    )
+
+    timeout: float = Field(
+        default=10.0,
+        description="Timeout in seconds for HTTP requests.",
+    )
+
+    default_headers: dict[str, str] | None = Field(
+        default=None,
+        description="Default headers to include in every HTTP request.",
+    )
+
+    default_params: dict[str, t.Any] | None = Field(
+        default=None,
+        description="Default query parameters to include in every HTTP request.",
+    )

audex/config/helper/client/websocket.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from audex.helper.settings import BaseModel
+from audex.helper.settings.fields import Field
+
+
+class WebsocketClientConfig(BaseModel):
+    max_connections: int = Field(
+        default=10,
+        description="Maximum concurrent connections to Dashscope API.",
+    )
+
+    idle_timeout: int = Field(
+        default=60,
+        description="Idle timeout in seconds for websocket connections.",
+    )
+
+    drain_timeout: float = Field(
+        default=5.0,
+        description="Timeout in seconds to drain connections on shutdown.",
+    )

audex/config/helper/provider/__init__.py

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