audex 1.0.7a3__py3-none-any.whl

audex/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+__title__ = "Audex"
+__prog__ = "audex"
+__version__ = "1.0.7-a3"
+__description__ = """
+Audex is an intelligent medical transcription system designed specifically for clinical scenarios.
+It uses Voice Print Recognition (VPR) and real-time speech-to-text technology to automatically distinguish between the doctor and the patient, producing structured medical documentation from their conversations.
+"""

audex/__main__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+import sys
+
+from audex.cli import main
+
+sys.exit(main())

audex/cli/__init__.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import argparse
+import pathlib
+import sys
+
+import dotenv
+
+from audex.cli.apis import register_apis
+from audex.cli.args import parser_with_version
+from audex.cli.exceptions import CLIError
+from audex.cli.helper import display
+from audex.config import Config
+from audex.config import build_config
+from audex.config import setconfig
+from audex.exceptions import AudexError
+from audex.utils import flatten_dict
+
+
+def main() -> int:
+    """Main entry point for the Audex CLI.
+
+    This function parses command-line arguments, executes the appropriate
+    command, and handles errors gracefully.
+
+    Returns:
+        Exit code indicating success or type of failure.
+    """
+
+    # Load environment variables from .env file if it exists
+    if dotenv.find_dotenv():
+        dotenv.load_dotenv()
+
+    try:
+        args = parse_args()
+        args.func(args)
+        return 0
+    except KeyboardInterrupt:
+        # Handle Ctrl+C gracefully
+        print()
+        display.warning("Cancelled by user")
+        return 130
+    except CLIError as e:
+        # Handle known CLI errors
+        verbose = "--verbose" in sys.argv or "-v" in sys.argv
+        display.show_error(e, verbose=verbose)
+        return e.exit_code
+    except AudexError as e:
+        # Handle known Audex errors
+        verbose = "--verbose" in sys.argv or "-v" in sys.argv
+        display.show_error(e, verbose=verbose)
+        return e.code
+    except Exception as e:
+        # Handle unexpected errors
+        verbose = "--verbose" in sys.argv or "-v" in sys.argv
+        display.show_error(e, verbose=verbose)
+        return 1
+
+
+def parse_args() -> argparse.Namespace:
+    parser = parser_with_version()
+
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Enable verbose output for debugging",
+    )
+
+    # Add config argument at top level
+    parser.add_argument(
+        "--config",
+        "-c",
+        type=pathlib.Path,
+        default=None,
+        help="Path to the configuration file",
+    )
+
+    # Create subparsers for other commands (serve, init, etc.)
+    subparsers = parser.add_subparsers(
+        title="Available Commands",
+        dest="command",
+        help="Command to execute (optional, default is to run the application)",
+        metavar="<command>",
+        required=False,
+    )
+
+    # Register other commands (not run, since it's default)
+    register_apis(subparsers)
+
+    # Set default function to run the application
+    parser.set_defaults(func=run_application)
+
+    return parser.parse_args()
+
+
+def run_application(args: argparse.Namespace) -> None:
+    """Run the main Audex application (default behavior)."""
+    from nicegui import core
+
+    core.app.native.start_args.update({"gui": "qt"})
+
+    display.banner("Audex", subtitle="Smart Medical Recording & Transcription System")
+
+    # Bootstrap
+    display.step("Bootstrapping application", step=0)
+    print()
+
+    # Load configuration
+    with display.section("Loading Configuration"):
+        if args.config:
+            display.info(f"Loading config from: {args.config}")
+            display.path(args.config, exists=args.config.exists())
+
+            if args.config.suffix in {".yaml", ".yml"}:
+                setconfig(Config.from_yaml(args.config))
+                display.success("YAML configuration loaded")
+            else:
+                from audex.cli.exceptions import InvalidArgumentError
+
+                raise InvalidArgumentError(
+                    arg="config",
+                    value=args.config,
+                    reason=f"Unsupported config file format: {args.config.suffix}."
+                    "Supported formats are .yaml, .yml, .json, .jsonc, .json5",
+                )
+        else:
+            display.info("Using default configuration")
+
+    # Show configuration summary
+    cfg = build_config()
+    with display.section("Application Configuration"):
+        display.table_dict(flatten_dict(cfg.model_dump()))
+
+    # Initialize container
+    display.step("Initializing application", step=1)
+    with display.loading("Wiring dependencies..."):
+        from audex.container import Container
+        import audex.view.pages
+
+        container = Container()
+        container.wire(packages=[audex.view.pages])
+
+    display.success("Application initialized")
+
+    # Launch info
+    display.step("Launching application", step=2)
+    print()
+
+    import platform
+
+    if cfg.core.app.native:
+        display.info("Launching in native window mode")
+        display.info(f"GUI Backend: PyQt6 ({platform.system()})")
+    else:
+        display.info("Application will open in your default browser")
+
+    display.info("Press Ctrl+C to stop")
+
+    # Separator before app logs
+    print()
+    display.separator()
+    print()
+
+    # Start application
+    view = container.views().view()
+    view.run()
+
+
+def cli() -> None:
+    """Entry point for installed command-line script.
+
+    This function is called when running `audex` as an installed command.
+    It's registered in pyproject.toml as a console script entry point.
+
+    Example:
+        After installing with pip:
+
+        ```bash
+        audex --help
+        audex -c .config.yml
+        audex serve --port 8080
+        ```
+    """
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    sys.exit(main())

audex/cli/apis/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import argparse
+
+
+def register_apis(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    from audex.cli.apis import init
+    from audex.cli.apis import serve
+
+    # Only register serve and init, not run
+    serve.Args.register_subparser(subparsers, name="serve", help_text="Serve Audex export service")
+    init.register(subparsers)

audex/cli/apis/init/__init__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import argparse
+
+
+def register(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    from audex.cli.apis.init import gencfg
+    from audex.cli.apis.init import setup
+    from audex.cli.apis.init import vprgroup
+
+    parser = subparsers.add_parser(
+        "init",
+        help="Initialize various Audex components.",
+    )
+    init_subparsers = parser.add_subparsers(
+        title="init commands",
+        dest="init_command",
+    )
+
+    gencfg.Args.register_subparser(
+        init_subparsers,
+        name="gencfg",
+        help_text="Generate a default configuration file for Audex.",
+    )
+    setup.Args.register_subparser(
+        init_subparsers,
+        name="setup",
+        help_text="Run the initial setup wizard for Audex.",
+    )
+    vprgroup.Args.register_subparser(
+        init_subparsers,
+        name="vprgroup",
+        help_text="Initialize a VPR service group.",
+    )

audex/cli/apis/init/gencfg.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import typing as t
+
+from pydantic import Field
+
+from audex.cli.args import BaseArgs
+from audex.cli.helper import display
+from audex.utils import flatten_dict
+
+
+class Args(BaseArgs):
+    format: t.Literal["dotenv", "yaml", "json", "system"] = Field(
+        default="dotenv",
+        alias="f",
+        description="The format of the generated configuration file.",
+    )
+
+    output: pathlib.Path | None = Field(
+        default=None,
+        alias="o",
+        description="The output file path.If not provided, the configuration will be printed to stdout.",
+    )
+
+    platform: t.Literal["linux", "windows"] | None = Field(
+        default=None,
+        alias="p",
+        description="Target platform for system configuration (only used with --format=system).",
+    )
+
+    def run(self) -> None:
+        from audex.config import Config
+
+        display.banner("Configuration Generator", subtitle="Generate Configuration File")
+
+        # Show format selection
+        with display.section("Generation Options"):
+            options_info = {
+                "Format": self.format.upper(),
+                "Output": str(self.output) if self.output else "(auto-generated filename)",
+            }
+            if self.format == "system":
+                options_info["Platform"] = self.platform or "(current platform)"  # type: ignore
+            display.key_value(options_info)
+
+        # Load default configuration
+        display.step("Loading default configuration", step=1)
+        cfg = Config()
+
+        # For system format, show platform-specific preview
+        platform = self.platform or ("linux" if os.name == "posix" else "windows")  # type: ignore
+        if self.format == "system":
+            with display.section(f"System Configuration Preview ({platform})"):
+                display.info(f"Generating system configuration for {platform.upper()}")
+                display.warning("Only fields with platform-specific defaults will be included")
+                display.info("Unset fields will be omitted from the output")
+        else:
+            # Preview configuration
+            with display.section("Default Configuration Preview"):
+                cfg_dict = flatten_dict(cfg.model_dump())
+                display.info(f"Total {len(cfg_dict)} configuration keys")
+                display.table_dict(cfg_dict)
+
+        # Confirm generation
+        if not display.confirm("Generate configuration file?", default=True):
+            display.warning("Operation cancelled by user")
+            return
+
+        # Generate configuration file
+        display.step("Generating configuration file", step=2)
+
+        out = self.output
+
+        with display.loading(f"Writing {self.format.upper()} configuration..."):
+            if self.format == "dotenv":
+                cfg.to_dotenv(out or (out := pathlib.Path(".env.gen")))
+            elif self.format == "yaml":
+                cfg.to_yaml(out or (out := pathlib.Path(".config.gen.yml")))
+            elif self.format == "json":
+                cfg.to_json(out or (out := pathlib.Path(".config.gen.jsonc")))
+            elif self.format == "system":
+                platform = self.platform or ("linux" if os.name == "posix" else "windows")
+                default_filename = f"config.system.{platform}.yml"
+                cfg.to_system_yaml(
+                    out or (out := pathlib.Path(default_filename)),
+                    platform=platform,  # type: ignore
+                )
+
+        # Show result
+        print()
+        display.success("Configuration file generated successfully!")
+
+        # Summary
+        display.header("Generation Summary")
+        summary_data: dict[str, t.Any] = {
+            "Format": self.format.upper(),
+            "Output File": str(out),
+        }
+
+        if self.format == "system":
+            summary_data["Platform"] = platform.upper()
+            summary_data["Note"] = "Only non-Unset fields included"
+        else:
+            summary_data["Total Keys"] = len(cfg_dict)
+
+        display.key_value(summary_data)
+
+        # Show file path with existence check
+        display.path(out, label="Saved to", exists=out.exists())
+
+        # Show usage hints
+        if self.format == "system":
+            print()
+            display.header("Usage Instructions")
+            display.info("This system configuration file is intended for:")
+            print("  • Deployment to /etc/audex/config.system.yml on Linux")
+            print("  • Use as read-only system-wide defaults")
+            print("  • User configurations should override this at ~/.config/audex/config.yml")
+
+            if platform == "linux":
+                print()
+                display.info("To deploy on Linux:")
+                print(f"  sudo cp {out} /etc/audex/config.system.yml")
+                print("  sudo chown root:root /etc/audex/config.system.yml")
+                print("  sudo chmod 644 /etc/audex/config.system.yml")
+
+        print()
+        display.success("Done!  🎉")