algomancy-cli 0.3.17__py3-none-any.whl

algomancy_cli/cli_configuration.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from algomancy_scenario.core_configuration import CoreConfiguration
+
+
+class CliConfiguration(CoreConfiguration):
+    """Configuration for the CLI application.
+
+    Extends the core configuration with CLI-specific options.
+    """
+
+    def __init__(
+        self,
+        # core parameters (see CoreConfiguration)
+        data_path: str = "data",
+        has_persistent_state: bool = False,
+        save_type: str | None = "json",
+        data_object_type: type | None = None,
+        etl_factory: Any | None = None,
+        kpi_templates: Dict[str, Any] | None = None,
+        algo_templates: Dict[str, Any] | None = None,
+        input_configs: list | None = None,
+        autocreate: bool | None = None,
+        default_algo: str | None = None,
+        default_algo_params_values: Dict[str, Any] | None = None,
+        autorun: bool | None = None,
+        title: str = "Algomancy CLI",
+        # CLI specific
+        verbose: bool = True,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(
+            data_path=data_path,
+            has_persistent_state=has_persistent_state,
+            save_type=save_type,
+            data_object_type=data_object_type,
+            etl_factory=etl_factory,
+            kpi_templates=kpi_templates,
+            algo_templates=algo_templates,
+            input_configs=input_configs,
+            autocreate=autocreate,
+            default_algo=default_algo,
+            default_algo_params_values=default_algo_params_values,
+            autorun=autorun,
+            title=title,
+            **kwargs,
+        )
+
+        self.verbose = verbose
+        self._validate_cli()
+
+    def as_dict(self) -> Dict[str, Any]:
+        base = super().as_dict()
+        base.update(
+            {
+                "verbose": self.verbose,
+            }
+        )
+        return base
+
+    def _validate_cli(self) -> None:
+        if self.verbose is None:
+            raise ValueError(
+                "Boolean configuration 'verbose' must be set to True or False, not None"
+            )

algomancy_cli/cli_launcher.py

@@ -0,0 +1,34 @@
+from typing import Dict, Any, Union
+
+from algomancy_scenario.scenariomanager import ScenarioManager
+from algomancy_scenario.core_configuration import CoreConfiguration
+
+from .cli_shell import CliShell
+from .cli_configuration import CliConfiguration
+
+
+class CliLauncher:
+    @staticmethod
+    def build(
+        cfg: Union[CliConfiguration, CoreConfiguration, Dict[str, Any]],
+    ) -> CliShell:
+        """Create a CLI shell from a CliConfiguration/CoreConfiguration or equivalent dict."""
+        if isinstance(cfg, dict):
+            cfg_obj = CliConfiguration(**cfg)
+        elif isinstance(cfg, CliConfiguration):
+            cfg_obj = cfg
+        elif isinstance(cfg, CoreConfiguration):
+            # allow passing a CoreConfiguration; wrap minimally
+            cfg_obj = CliConfiguration(**cfg.as_dict())
+        else:
+            raise TypeError(
+                "CliLauncher.build expects CliConfiguration, CoreConfiguration, or dict"
+            )
+
+        sm = ScenarioManager.from_config(cfg_obj)
+        return CliShell(sm)
+
+    @staticmethod
+    def run(shell: CliShell) -> None:
+        """Run the interactive shell."""
+        shell.run()

algomancy_cli/cli_shell.py

@@ -0,0 +1,170 @@
+import json
+import shlex
+from typing import Any, Callable
+
+from algomancy_scenario import ScenarioManager
+from algomancy_utils.logger import MessageStatus
+
+
+class CliShell:
+    """
+    Minimal interactive shell to exercise backend functionality via ScenarioManager.
+
+    This is intended for backend development and manual testing without the GUI.
+    """
+
+    def __init__(self, scenario_manager: ScenarioManager):
+        self.sm = scenario_manager
+        self._commands: dict[str, Callable[[list[str]], None]] = {
+            "help": self._cmd_help,
+            "h": self._cmd_help,
+            "?": self._cmd_help,
+            "quit": self._cmd_quit,
+            "exit": self._cmd_quit,
+            "list-scenarios": self._cmd_list_scenarios,
+            "ls": self._cmd_list_scenarios,
+            "list-data": self._cmd_list_data,
+            "ld": self._cmd_list_data,
+            "load-data": self._cmd_load_data,
+            "etl-data": self._cmd_etl_data,
+            "create-scenario": self._cmd_create_scenario,
+            "run": self._cmd_run,
+            "status": self._cmd_status,
+        }
+        self._running = False
+
+    # ---------- Public API ----------
+    def run(self) -> None:
+        self._running = True
+        self.sm.log(
+            "Algomancy CLI Shell. Type 'help' for available commands.",
+            MessageStatus.SUCCESS,
+        )
+        while self._running:
+            try:
+                raw = input("algomancy> ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                break
+            if not raw:
+                continue
+            parts = shlex.split(raw)
+            cmd, args = parts[0], parts[1:]
+            handler = self._commands.get(cmd)
+            if handler is None:
+                self.sm.log(
+                    f"Unknown command: {cmd}. Type 'help' for a list of commands.",
+                    MessageStatus.ERROR,
+                )
+                continue
+            try:
+                handler(args)
+            except Exception as ex:  # keep shell alive during development
+                self.sm.log(f"Error: {ex}", MessageStatus.ERROR)
+
+    # ---------- Command handlers ----------
+    def _cmd_help(self, _: list[str]) -> None:
+        print(
+            "\nAvailable commands:\n"
+            "  help | h | ?                 Show this help.\n"
+            "  quit | exit                  Exit the shell.\n"
+            "  list-data | ld               List available datasets.\n"
+            "  load-data <name>             Load example data into dataset <name>.\n"
+            "  etl-data <name>              Run ETL to create dataset <name>.\n"
+            "  list-scenarios | ls          List scenarios.\n"
+            "  create-scenario <tag> <dataset_key> <algo> [json_params]\n"
+            "                               Create a scenario. Params as JSON object.\n"
+            "  run <scenario_id_or_tag>     Run a scenario (waits until complete).\n"
+            "  status                        Show processing status.\n"
+        )
+
+    def _cmd_quit(self, _: list[str]) -> None:
+        self._running = False
+
+    def _cmd_list_data(self, _: list[str]) -> None:
+        keys = self.sm.get_data_keys()
+        if not keys:
+            print("No datasets available.")
+            return
+        print("Datasets:")
+        for k in keys:
+            print(f"  - {k}")
+
+    def _cmd_load_data(self, args: list[str]) -> None:
+        if len(args) < 1:
+            self.sm.log("Usage: load-data <dataset_name>", MessageStatus.WARNING)
+            return
+        name = args[0]
+        self.sm.debug_load_data(name)
+        self.sm.log(
+            f"Loaded example data into dataset '{name}'.", MessageStatus.SUCCESS
+        )
+
+    def _cmd_etl_data(self, args: list[str]) -> None:
+        if len(args) < 1:
+            self.sm.log("Usage: etl-data <dataset_name>", MessageStatus.WARNING)
+            return
+        name = args[0]
+        self.sm.debug_etl_data(name)
+        self.sm.log(
+            f"ETL completed, dataset '{name}' available.", MessageStatus.SUCCESS
+        )
+
+    def _cmd_list_scenarios(self, _: list[str]) -> None:
+        scenarios = self.sm.list_scenarios()
+        if not scenarios:
+            print("No scenarios defined.")
+            return
+        print("Scenarios:")
+        for s in scenarios:
+            print(
+                f"  - id={s.id} tag={s.tag} algo={s.algo_name} dataset={s.dataset_key} status={getattr(s, 'status', 'n/a')}"
+            )
+
+    def _cmd_create_scenario(self, args: list[str]) -> None:
+        if len(args) < 3:
+            self.sm.log(
+                "Usage: create-scenario <tag> <dataset_key> <algo_name> [json_params]",
+                MessageStatus.WARNING,
+            )
+            return
+        tag, dataset_key, algo_name = args[0], args[1], args[2]
+        params: dict[str, Any] | None = None
+        if len(args) >= 4:
+            try:
+                params = json.loads(args[3])
+            except json.JSONDecodeError:
+                self.sm.log("Invalid JSON for parameters.", MessageStatus.ERROR)
+                return
+        s = self.sm.create_scenario(
+            tag=tag, dataset_key=dataset_key, algo_name=algo_name, algo_params=params
+        )
+        self.sm.log(f"Created scenario id={s.id} tag={s.tag}", MessageStatus.SUCCESS)
+
+    def _resolve_scenario(self, key: str):
+        s = self.sm.get_by_id(key)
+        if s is None:
+            s = self.sm.get_by_tag(key)
+        return s
+
+    def _cmd_run(self, args: list[str]) -> None:
+        if len(args) < 1:
+            self.sm.log("Usage: run <scenario_id_or_tag>", MessageStatus.WARNING)
+            return
+        identifier = args[0]
+        s = self._resolve_scenario(identifier)
+        if s is None:
+            self.sm.log(f"Scenario '{identifier}' not found.", MessageStatus.ERROR)
+            return
+        self.sm.process_scenario_async(s)
+        self.sm.wait_for_processing()
+        self.sm.log(f"Scenario '{s.tag}' completed.", MessageStatus.SUCCESS)
+
+    def _cmd_status(self, _: list[str]) -> None:
+        processing = self.sm.currently_processing
+        if processing:
+            print(
+                f"  - id={processing.id} tag={processing.tag} status={getattr(processing, 'status', 'processing')}"
+            )
+        else:
+            print("No scenarios processing.")

algomancy_cli/main.py

@@ -0,0 +1,98 @@
+import argparse
+import importlib
+import os
+import sys
+from typing import Callable
+
+
+def _ensure_dev_path():
+    here = os.path.abspath(os.path.dirname(__file__))
+    project_root = os.path.abspath(os.path.join(here, "..", "..", "..", ".."))
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+    try:
+        from algomancy_cli.cli_configuration import CliConfiguration  # noqa: F401
+        from algomancy_cli.cli_launcher import CliLauncher  # noqa: F401
+
+        return
+    except Exception:
+        pass
+
+
+_ensure_dev_path()
+
+from algomancy_cli.cli_configuration import CliConfiguration  # type: ignore  # noqa: E402
+from algomancy_cli.cli_launcher import CliLauncher  # type: ignore  # noqa: E402
+
+
+def _parse_args():
+    parser = argparse.ArgumentParser(description="Algomancy CLI shell")
+    parser.add_argument(
+        "--config-callback",
+        type=str,
+        default=None,
+        help=(
+            "Callback to construct CliConfiguration, in the form 'module:function'. "
+            "The function must return a CliConfiguration instance."
+        ),
+    )
+    parser.add_argument(
+        "--example",
+        action="store_true",
+        help="Use the example configuration bundled in this repository (for development).",
+    )
+    return parser.parse_args()
+
+
+def _load_config_from_callback(spec: str) -> CliConfiguration:
+    if ":" not in spec:
+        raise ValueError("--config-callback must be in 'module:function' form")
+    module_name, func_name = spec.split(":", 1)
+    module = importlib.import_module(module_name)
+    func: Callable[[], CliConfiguration] = getattr(module, func_name)
+    cfg = func()
+    if not isinstance(cfg, CliConfiguration):
+        raise TypeError("Config callback did not return CliConfiguration")
+    return cfg
+
+
+def _build_example_config() -> CliConfiguration:
+    # These imports rely on this repo's example package being available in the workspace
+    from example.data_handling.input_configs import example_input_configs
+    from example.data_handling.factories import ExampleETLFactory
+    from example.templates import kpi_templates, algorithm_templates
+
+    from algomancy_data import DataSource
+
+    return CliConfiguration(
+        data_path="example/data",
+        has_persistent_state=True,
+        etl_factory=ExampleETLFactory,
+        kpi_templates=kpi_templates,
+        algo_templates=algorithm_templates,
+        input_configs=example_input_configs,
+        data_object_type=DataSource,
+        autocreate=True,
+        default_algo="Slow",
+        default_algo_params_values={"duration": 1},
+        autorun=True,
+        title="Algomancy CLI (Example)",
+    )
+
+
+def main():
+    args = _parse_args()
+    if args.config_callback:
+        cfg = _load_config_from_callback(args.config_callback)
+    elif args.example:
+        cfg = _build_example_config()
+    else:
+        print("Either pass --config-callback module:function or use --example")
+        sys.exit(2)
+
+    shell = CliLauncher.build(cfg)
+    CliLauncher.run(shell)
+
+
+if __name__ == "__main__":
+    main()

algomancy_cli-0.3.17.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.3
+Name: algomancy-cli
+Version: 0.3.17
+Summary: CLI shell for Algomancy to exercise backend functionality without the GUI.
+Requires-Dist: algomancy-utils
+Requires-Dist: algomancy-scenario
+Requires-Dist: algomancy-data
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+Algomancy CLI
+
+Interactive terminal shell to exercise Algomancy backend functionality without the GUI. Useful for rapid development of ETL, algorithms, and scenarios.
+
+Install / Run
+
+```
+uv run algomancy-cli --example
+```
+
+Or point to your own configuration factory:
+
+```
+uv run algomancy-cli --config-callback myproject.config:make_config
+```
+
+Where `make_config` returns an `AppConfiguration` instance.
+
+Commands
+
+- `help` — show help
+- `list-data` / `ld` — list datasets
+- `load-data <name>` — load example data into dataset `<name>`
+- `etl-data <name>` — run ETL to create dataset `<name>`
+- `list-scenarios` / `ls` — list scenarios
+- `create-scenario <tag> <dataset_key> <algo_name> [json_params]` — create scenario
+- `run <scenario_id_or_tag>` — run scenario and wait for completion
+- `status` — show processing status
+- `quit` / `exit` — exit shell
+
+Parameters for `create-scenario` can be provided as a JSON object, e.g.:
+
+```
+create-scenario test1 "Master data" Fast "{\"duration\": 0.5}"
+```
+
+How it works
+
+The CLI wraps `ScenarioManager` created via `AppConfiguration` just like the GUI launcher. See `src/algomancy/cli_launcher.py` for details.

algomancy_cli-0.3.17.dist-info/RECORD

@@ -0,0 +1,8 @@
+algomancy_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algomancy_cli/cli_configuration.py,sha256=2skq8tJyJHKTU6HLRzmbK7ULRuSMLWzWtj-tknGgFtg,2088
+algomancy_cli/cli_launcher.py,sha256=ztU9PRcuetpD45ioGgfvmrLd7yEzB3y5gicCWio6970,1156
+algomancy_cli/cli_shell.py,sha256=_KJnf4p9SWbs9B0-zOBxu7n5LGMWO3INcw1ojAypXL0,6372
+algomancy_cli/main.py,sha256=2VlfHENrYfyaxeYlkAJGJKygwYzWMom3Y1Mpl3Eb0ng,3069
+algomancy_cli-0.3.17.dist-info/WHEEL,sha256=fAguSjoiATBe7TNBkJwOjyL1Tt4wwiaQGtNtjRPNMQA,80
+algomancy_cli-0.3.17.dist-info/METADATA,sha256=U-WNZOh1GnPiWp12KWl-01ImXD6KfdOxJ2WwBdxMZJs,1477
+algomancy_cli-0.3.17.dist-info/RECORD,,

algomancy_cli-0.3.17.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.9.28
+Root-Is-Purelib: true
+Tag: py3-none-any