synth-ai 0.2.13.dev2__py3-none-any.whl → 0.2.16__py3-none-any.whl

synth_ai/cli/__init__.py

@@ -8,8 +8,9 @@ pyproject entry point `synth_ai.cli:cli`.
 from __future__ import annotations
 
 import importlib
+import sys
 from collections.abc import Callable
-from typing import Any, cast
+from typing import Any
 
 # Load environment variables from a local .env if present (repo root)
 try:
@@ -21,53 +22,69 @@ except Exception:
     # dotenv is optional at runtime; proceed if unavailable
     pass
 
-try:
-    from ._typer_patch import patch_typer_make_metavar
-
-    patch_typer_make_metavar()
-except Exception:
-    pass
-
-
-from .root import cli  # new canonical CLI entrypoint
-
-# Register subcommands from this package onto the group
-# Deprecated/legacy commands intentionally not registered: watch/experiments, balance, calc,
-# man, recent, status, traces
-try:
-    from . import demo as _demo
-
-    _demo.register(cli)
-except Exception:
-    pass
-try:
-    from . import turso as _turso
-
-    _turso.register(cli)
-except Exception:
-    pass
-try:
-    _train_module = cast(Any, importlib.import_module("synth_ai.api.train"))
-    _train_register = cast(Callable[[Any], None], _train_module.register)
-    _train_register(cli)
-except Exception:
-    pass
-
-
-from .task_apps import task_app_group
-
-cli.add_command(task_app_group, name="task-app")
-
-
-try:
-    from . import task_apps as _task_apps
-
-    _task_apps.register(cli)
-except Exception:
-    pass
-
-cli.add_command(task_app_group.commands["serve"], name="serve")
-cli.add_command(task_app_group.commands["deploy"], name="deploy")
+def _callable_from(module: Any, attr: str) -> Callable[..., Any] | None:
+    candidate = getattr(module, attr, None)
+    return candidate if callable(candidate) else None
+
+
+def _maybe_import(module_path: str) -> Any | None:
+    try:
+        return importlib.import_module(module_path)
+    except Exception:
+        return None
+
+
+def _maybe_call(module_path: str, attr: str, *args: Any, **kwargs: Any) -> None:
+    module = _maybe_import(module_path)
+    if not module:
+        return
+    fn = _callable_from(module, attr)
+    if fn:
+        fn(*args, **kwargs)
+
+
+# Apply Typer patch if available
+_maybe_call("synth_ai.cli._typer_patch", "patch_typer_make_metavar")
+
+
+_cli_module = _maybe_import("synth_ai.cli.root")
+if not _cli_module:
+    raise ImportError("synth_ai.cli.root is required for CLI entrypoint")
+cli = _cli_module.cli  # type: ignore[attr-defined]
+
+
+# Register optional subcommands packaged under synth_ai.cli.*
+for _module_path in ("synth_ai.cli.demo", "synth_ai.cli.turso"):
+    module = _maybe_import(_module_path)
+    if not module:
+        continue
+    sub_name = _module_path.rsplit(".", 1)[-1]
+    setattr(sys.modules[__name__], sub_name, module)
+    fn = _callable_from(module, "register")
+    if fn:
+        fn(cli)
+
+# Train CLI lives under synth_ai.api.train
+_maybe_call("synth_ai.api.train", "register", cli)
+
+# Task app group/commands are optional and have richer API surface
+_task_apps_module = _maybe_import("synth_ai.cli.task_apps")
+if _task_apps_module:
+    task_app_group = getattr(_task_apps_module, "task_app_group", None)
+    if task_app_group is not None:
+        cli.add_command(task_app_group, name="task-app")
+        # Expose common aliases when present
+        commands = getattr(task_app_group, "commands", None)
+        if isinstance(commands, dict):
+            for alias, name in (("serve", "serve"), ("deploy", "deploy"), ("modal-serve", "modal-serve")):
+                command = commands.get(name)
+                if command is not None:
+                    cli.add_command(command, name=alias)
+    register_task_apps = _callable_from(_task_apps_module, "register")
+    if register_task_apps:
+        register_task_apps(cli)
+
+# Register TUI command if dependencies allow
+_maybe_call("synth_ai.cli.tui", "register", cli)
 
-cli.add_command(task_app_group.commands["modal-serve"], name="modal-serve")
 # Top-level 'info' alias removed; use `synth-ai task-app info` instead

synth_ai/cli/_modal_wrapper.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
 
+import importlib
 import sys
 
 
 def main() -> int:
     # Apply Typer compatibility patch before Modal CLI bootstraps Click/Typer internals.
     try:
-        from ._typer_patch import patch_typer_make_metavar
-
-        patch_typer_make_metavar()
+        module = importlib.import_module("synth_ai.cli._typer_patch")
     except Exception:
-        pass
+        module = None
+    if module is not None:
+        patch = getattr(module, "patch_typer_make_metavar", None)
+        if callable(patch):
+            patch()
 
     from modal.__main__ import main as modal_main
 
@@ -20,9 +23,9 @@ def main() -> int:
     else:
         sys.argv = ["modal"]
 
-    return modal_main()
+    result = modal_main()
+    return result if result is not None else 0
 
 
 if __name__ == "__main__":
     sys.exit(main())
-

synth_ai/cli/_typer_patch.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from click import Parameter
 
 

synth_ai/cli/_validate_task_app.py

@@ -3,9 +3,27 @@
 # This module provides the validate_task_app function for CLI use
 # The actual implementation is imported from the task module
 
-from synth_ai.task.validators import (
-    validate_task_app_endpoint as validate_task_app,  # type: ignore[attr-defined]
-)
+import importlib
+from collections.abc import Callable
+from typing import Any
 
-__all__ = ["validate_task_app"]
+_validators_module: Any | None = None
+validate_task_app: Callable[..., Any] | None = None
+
+try:
+    _validators_module = importlib.import_module("synth_ai.task.validators")
+except Exception:
+    _validators_module = None
+
+if _validators_module is not None:
+    candidate = getattr(_validators_module, "validate_task_app_endpoint", None)
+    if callable(candidate):
+        validate_task_app = candidate
 
+if validate_task_app is None:
+    def _missing_validate_task_app(*_args: Any, **_kwargs: Any) -> None:
+        raise RuntimeError("task validation utilities are unavailable in this environment")
+
+    validate_task_app = _missing_validate_task_app
+
+__all__ = ["validate_task_app"]

synth_ai/cli/legacy_root_backup.py

@@ -235,7 +235,9 @@ def view(url: str):
     """Launch the interactive TUI dashboard."""
     try:
         module = importlib.import_module(".tui.dashboard", __package__)
-        synth_dashboard_cls = getattr(module, "SynthDashboard")
+        synth_dashboard_cls = getattr(module, "SynthDashboard", None)
+        if synth_dashboard_cls is None:
+            raise RuntimeError("SynthDashboard class not available")
         app = synth_dashboard_cls(db_url=url)
         app.run()
     except ImportError:

synth_ai/cli/lib/__init__.py

@@ -0,0 +1,10 @@
+"""
+Support utilities reused across CLI subcommands.
+
+This module currently exposes helpers for env handling and discovery by
+re-exporting the maintained implementations under ``synth_ai.utils``.
+"""
+
+from __future__ import annotations
+
+from .task_app_env import *  # noqa: F401,F403

synth_ai/cli/lib/task_app_discovery.py

@@ -0,0 +1,7 @@
+"""
+Backwards-compatible re-export of task app discovery helpers.
+"""
+
+from __future__ import annotations
+
+from synth_ai.utils.task_app_discovery import *  # noqa: F401,F403