maestro-framework 0.1.0__tar.gz

maestro_framework-0.1.0/.gitignore

@@ -0,0 +1,46 @@
+# MAESTRO — Modular Automotive Embedded Suite for Test Runtime & Operations
+# Author: Naveen Daniel Kennedy
+
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+*.egg
+.eggs/
+build/
+dist/
+.venv/
+venv/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage
+htmlcov/
+*.spec.bak
+
+# Test / run artifacts
+allure-results/
+allure-report/
+.maestro/
+runs/
+*.dlt
+*.junit.xml
+
+# Node / UI
+node_modules/
+apps/ui/dist/
+packages/maestro-server/src/maestro_server/web/
+*.tsbuildinfo
+
+# Local config & secrets (never commit secrets)
+.env
+.env.*
+!.env.example
+config/benches/*.local.toml
+
+# OS / editor
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+*.swp

maestro_framework-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: maestro-framework
+Version: 0.1.0
+Summary: MAESTRO — Modular Automotive Embedded System Test, Reporting & Orchestration: an offline-capable platform for automotive Hardware-in-the-Loop (HIL) and embedded device testing (visual designer + pytest engine + server + web UI + mini-tools).
+Project-URL: Homepage, https://github.com/NVNKENNEDY/maestro
+Project-URL: Source, https://github.com/NVNKENNEDY/maestro
+Author-email: Naveen Daniel Kennedy <nvnkennedy@gmail.com>
+License-Expression: MIT
+Keywords: adb,android,automotive,embedded,endurance,fastapi,hil,pytest,qnx,ssh,test-automation
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.11
+Requires-Dist: adbutils<3,>=2.12
+Requires-Dist: alembic<2,>=1.13
+Requires-Dist: allure-pytest<3,>=2.16
+Requires-Dist: apscheduler<4,>=3.11
+Requires-Dist: email-validator>=2.1
+Requires-Dist: fastapi<1,>=0.136
+Requires-Dist: httpx<1,>=0.28
+Requires-Dist: jinja2<4,>=3.1
+Requires-Dist: paramiko<6,>=5.0
+Requires-Dist: pydantic-settings<3,>=2.14
+Requires-Dist: pydantic<3,>=2.13
+Requires-Dist: pyjwt<3,>=2.9
+Requires-Dist: pyserial<4,>=3.5
+Requires-Dist: pytest-check<3,>=2.8
+Requires-Dist: pytest-rerunfailures<17,>=16
+Requires-Dist: pytest-xdist<4,>=3.8
+Requires-Dist: pytest<10,>=9.1
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: sqlalchemy<3,>=2.0
+Requires-Dist: tomli-w<2,>=1.2
+Requires-Dist: uvicorn[standard]<1,>=0.49
+Provides-Extra: hardware
+Requires-Dist: opencv-python<5,>=4.10; extra == 'hardware'
+Requires-Dist: pygrabber<1,>=0.2; extra == 'hardware'
+Provides-Extra: reportportal
+Requires-Dist: pytest-reportportal<6,>=5.4; extra == 'reportportal'
+Description-Content-Type: text/markdown
+
+# MAESTRO
+
+**Modular Automotive Embedded System Test, Reporting & Orchestration.**
+
+*MAESTRO* is an open-source, offline-capable test-automation platform for
+automotive Hardware-in-the-Loop (HIL) and embedded device testing. Like a maestro
+leading an orchestra, it conducts your devices, scenarios, and endurance cycles
+from one visual canvas — fitting for automotive infotainment, where the head unit
+conducts the vehicle's audio, video, and connectivity.
+
+Design test cases visually on a canvas (no code), run them on real or fake
+devices through a `pytest` engine, and get detailed step-level reports with inline
+attachments and first-class endurance/stability cycles. Results can be emailed and
+pushed to Jira/Xray.
+
+## Install
+
+```bash
+pip install maestro-framework
+# optional: real webcam capture (OpenCV / DirectShow)
+pip install "maestro-framework[hardware]"
+```
+
+## Run
+
+```bash
+maestro
+```
+
+This starts the API and serves the bundled web UI, then opens your browser.
+
+## Headless (no server / no UI)
+
+```bash
+maestro-core run scenario.json --bench bench.toml
+```
+
+## Mini-tools (drive a device without the framework)
+
+```bash
+maestro-tool list
+maestro-tool invoke turbossh --command "uname -a" --set host=10.0.0.5 --set user=root
+```
+
+MAESTRO calls your existing device tools (`turboadb`, `turbossh`, power/DLT
+scripts) through thin adapters — keep them on `PATH`. A hardware-free demo bench of
+fake drivers is included so everything runs end to end with no hardware.
+
+> Installs as `maestro-framework`; the Python modules are `maestro_core`,
+> `maestro_server`, and `maestro_tools`, and the console commands are `maestro`,
+> `maestro-core`, and `maestro-tool`.
+
+License: MIT © 2026 Naveen Daniel Kennedy

maestro_framework-0.1.0/README.md

@@ -0,0 +1,53 @@
+# MAESTRO
+
+**Modular Automotive Embedded System Test, Reporting & Orchestration.**
+
+*MAESTRO* is an open-source, offline-capable test-automation platform for
+automotive Hardware-in-the-Loop (HIL) and embedded device testing. Like a maestro
+leading an orchestra, it conducts your devices, scenarios, and endurance cycles
+from one visual canvas — fitting for automotive infotainment, where the head unit
+conducts the vehicle's audio, video, and connectivity.
+
+Design test cases visually on a canvas (no code), run them on real or fake
+devices through a `pytest` engine, and get detailed step-level reports with inline
+attachments and first-class endurance/stability cycles. Results can be emailed and
+pushed to Jira/Xray.
+
+## Install
+
+```bash
+pip install maestro-framework
+# optional: real webcam capture (OpenCV / DirectShow)
+pip install "maestro-framework[hardware]"
+```
+
+## Run
+
+```bash
+maestro
+```
+
+This starts the API and serves the bundled web UI, then opens your browser.
+
+## Headless (no server / no UI)
+
+```bash
+maestro-core run scenario.json --bench bench.toml
+```
+
+## Mini-tools (drive a device without the framework)
+
+```bash
+maestro-tool list
+maestro-tool invoke turbossh --command "uname -a" --set host=10.0.0.5 --set user=root
+```
+
+MAESTRO calls your existing device tools (`turboadb`, `turbossh`, power/DLT
+scripts) through thin adapters — keep them on `PATH`. A hardware-free demo bench of
+fake drivers is included so everything runs end to end with no hardware.
+
+> Installs as `maestro-framework`; the Python modules are `maestro_core`,
+> `maestro_server`, and `maestro_tools`, and the console commands are `maestro`,
+> `maestro-core`, and `maestro-tool`.
+
+License: MIT © 2026 Naveen Daniel Kennedy

maestro_framework-0.1.0/pyproject.toml

@@ -0,0 +1,101 @@
+# Single-distribution packaging for PyPI: bundles maestro_core + maestro_tools +
+# maestro_server (and the built UI) into one wheel, published as "maestro-framework"
+# (the bare "maestro"/"maestro-core" names are taken on PyPI; the console scripts
+# are still maestro/maestro-core/maestro-tool).
+#
+# Build with scripts/build_pypi.(sh|ps1), which assembles src/ and runs build.
+#
+# Author: Naveen Daniel Kennedy
+
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "maestro-framework"
+version = "0.1.0"
+description = "MAESTRO — Modular Automotive Embedded System Test, Reporting & Orchestration: an offline-capable platform for automotive Hardware-in-the-Loop (HIL) and embedded device testing (visual designer + pytest engine + server + web UI + mini-tools)."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Naveen Daniel Kennedy", email = "nvnkennedy@gmail.com" }]
+keywords = ["automotive", "hil", "embedded", "test-automation", "pytest", "endurance", "qnx", "android", "adb", "ssh", "fastapi"]
+classifiers = [
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Framework :: FastAPI",
+    "Topic :: Software Development :: Testing",
+    "Topic :: System :: Hardware",
+    "Intended Audience :: Developers",
+]
+
+dependencies = [
+    "pydantic>=2.13,<3",
+    "pydantic-settings>=2.14,<3",
+    "allure-pytest>=2.16,<3",
+    "pytest>=9.1,<10",
+    "pytest-xdist>=3.8,<4",
+    "pytest-rerunfailures>=16,<17",
+    "pytest-check>=2.8,<3",
+    "tomli-w>=1.2,<2",
+    "Jinja2>=3.1,<4",
+    "paramiko>=5.0,<6",
+    "pyserial>=3.5,<4",
+    "adbutils>=2.12,<3",
+    "fastapi>=0.136,<1",
+    "uvicorn[standard]>=0.49,<1",
+    "SQLAlchemy>=2.0,<3",
+    "alembic>=1.13,<2",
+    "APScheduler>=3.11,<4",
+    "httpx>=0.28,<1",
+    "PyJWT>=2.9,<3",
+    "python-multipart>=0.0.9",
+    "email-validator>=2.1",
+]
+
+[project.optional-dependencies]
+hardware = ["opencv-python>=4.10,<5", "pygrabber>=0.2,<1"]
+reportportal = ["pytest-reportportal>=5.4,<6"]
+
+[project.urls]
+Homepage = "https://github.com/NVNKENNEDY/maestro"
+Source = "https://github.com/NVNKENNEDY/maestro"
+
+[project.scripts]
+maestro = "maestro_server.cli:main"
+maestro-core = "maestro_core.cli:main"
+maestro-tool = "maestro_tools.cli:main"
+
+[project.entry-points."maestro.drivers"]
+turboadb = "maestro_core.drivers.adb_turboadb:TurboADBDriver"
+turbossh = "maestro_core.drivers.ssh_turbossh:TurboSSHDriver"
+power = "maestro_core.drivers.power:PowerScriptDriver"
+dlt = "maestro_core.drivers.dlt:DLTDriver"
+webcam = "maestro_core.drivers.webcam:WebcamDriver"
+fake_device = "maestro_core.drivers.fake:FakeDeviceController"
+fake_power = "maestro_core.drivers.fake:FakePowerController"
+fake_log = "maestro_core.drivers.fake:FakeLogController"
+fake_camera = "maestro_core.drivers.fake:FakeCameraController"
+
+[project.entry-points."maestro.steps"]
+builtins = "maestro_core.steps.builtins"
+
+[project.entry-points."maestro.detectors"]
+serial = "maestro_core.detect.serial_detector:SerialDetector"
+adb = "maestro_core.detect.adb_detector:ADBDetector"
+camera = "maestro_core.detect.camera_detector:CameraDetector"
+ssh = "maestro_core.detect.ssh_detector:SSHDetector"
+
+[project.entry-points."maestro.publishers"]
+email = "maestro_server.integrations.email:EmailPublisher"
+jiraxray = "maestro_server.integrations.jira_xray:JiraXrayPublisher"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/maestro_core", "src/maestro_tools", "src/maestro_server"]
+artifacts = ["src/maestro_server/web/**"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "README.md"]
+artifacts = ["src/maestro_server/web/**"]

maestro_framework-0.1.0/src/maestro_core/__init__.py

@@ -0,0 +1,43 @@
+"""MAESTRO core — the headless heart of the platform.
+
+MAESTRO (Modular Automotive Embedded System Test, Reporting & Orchestration) is an
+offline-capable test-automation platform for automotive Hardware-in-the-Loop
+(HIL) and embedded device testing.
+
+``maestro_core`` contains everything needed to execute a test *scenario* with no
+server and no UI:
+
+* :mod:`maestro_core.scenario` — the versioned JSON scenario model (the single
+  source of truth authored on the canvas) plus validation and JSON-Schema export.
+* :mod:`maestro_core.steps` — the step registry, the per-step execution context,
+  the built-in step library, and the generic script-wrapping adapter.
+* :mod:`maestro_core.drivers` — thin adapters that shell out to the user's own
+  device tools (turboadb, turbossh, power scripts, DLT, webcam), plus fully
+  functional fake drivers for hardware-free testing.
+* :mod:`maestro_core.detect` — device detectors (serial, adb, camera, ssh).
+* :mod:`maestro_core.engine` — the pytest plugin and small generic runner that
+  turn a scenario into executed, reported tests.
+* :mod:`maestro_core.endurance` — the long-running cycle loop and stop conditions.
+* :mod:`maestro_core.reporting` — the attachment pipeline and Allure/JUnit hooks.
+* :mod:`maestro_core.config` — layered TOML configuration loading.
+
+Author:
+    Naveen Daniel Kennedy <nvnkennedy@gmail.com>
+"""
+
+from __future__ import annotations
+
+#: Semantic version of the MAESTRO core package (single source of truth; the
+#: build backend reads this string to stamp the wheel).
+__version__ = "0.1.0"
+
+#: Human-readable product name, backronym, and tagline used across the UI, the
+#: About page, and the docs. MAESTRO conducts the test bench the way a maestro
+#: leads an orchestra — keeping devices, scenarios, and endurance cycles in time —
+#: which is fitting for automotive infotainment, where the head unit conducts the
+#: vehicle's audio, video, and connectivity.
+PRODUCT_NAME = "MAESTRO"
+PRODUCT_BACKRONYM = "Modular Automotive Embedded System Test, Reporting & Orchestration"
+PRODUCT_TAGLINE = "Automotive embedded test orchestration"
+
+__all__ = ["PRODUCT_BACKRONYM", "PRODUCT_NAME", "PRODUCT_TAGLINE", "__version__"]

maestro_framework-0.1.0/src/maestro_core/cli.py

@@ -0,0 +1,180 @@
+"""Headless command-line interface for ``maestro-core``.
+
+Run, validate, and inspect scenarios with no server and no UI:
+
+* ``maestro-core run <scenario.json> --bench <bench.toml>`` — execute a scenario.
+* ``maestro-core validate <scenario.json>`` — report validation issues.
+* ``maestro-core schema [--out file]`` — export the scenario JSON-Schema.
+* ``maestro-core steps`` — list every registered step.
+* ``maestro-core detect [--host H]`` — run device detectors and print proposals.
+
+Author:
+    Naveen Daniel Kennedy <nvnkennedy@gmail.com>
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from maestro_core import PRODUCT_BACKRONYM, PRODUCT_NAME, __version__
+from maestro_core.config import build_devices, load_bench_toml
+from maestro_core.detect import run_detection
+from maestro_core.engine import RunOptions, run_scenario
+from maestro_core.engine.plugin import ScenarioCase, run_via_pytest
+from maestro_core.reporting import write_junit, write_run_record
+from maestro_core.scenario import (
+    load_scenario_file,
+    parse_scenario,
+    scenario_json_schema,
+    validate_scenario,
+)
+from maestro_core.steps import all_steps, known_step_names, load_all_steps
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Construct the argument parser for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog="maestro-core", description=f"{PRODUCT_NAME} — {PRODUCT_BACKRONYM}"
+    )
+    parser.add_argument("-V", "--version", action="version", version=f"maestro-core {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    run = sub.add_parser("run", help="run a scenario on a bench")
+    run.add_argument("scenario", help="path to the scenario JSON")
+    run.add_argument("--bench", required=True, help="path to the bench TOML")
+    run.add_argument("--out", default=None, help="output directory for this run")
+    run.add_argument("--mode", choices=["serial", "parallel", "step"], default="serial")
+    run.add_argument("--user-steps", default=None, help="directory of drop-in step scripts")
+    run.add_argument(
+        "--pytest", action="store_true", help="execute through pytest (writes an Allure report)"
+    )
+
+    validate = sub.add_parser("validate", help="validate a scenario")
+    validate.add_argument("scenario", help="path to the scenario JSON")
+
+    schema = sub.add_parser("schema", help="export the scenario JSON-Schema")
+    schema.add_argument("--out", default=None, help="write the schema here instead of stdout")
+
+    sub.add_parser("steps", help="list registered steps")
+
+    detect = sub.add_parser("detect", help="run device detectors")
+    detect.add_argument("--host", default=None, help="ssh host to probe")
+    detect.add_argument("--port", type=int, default=22, help="ssh port to probe")
+    return parser
+
+
+def _cmd_run(args: argparse.Namespace) -> int:
+    """Execute the ``run`` subcommand."""
+    load_all_steps(args.user_steps)
+    scenario = load_scenario_file(args.scenario, validate=True, known_steps=known_step_names())
+    bench = load_bench_toml(args.bench)
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    out = (
+        Path(args.out)
+        if args.out
+        else Path(".maestro") / "runs" / f"{scenario.metadata.id}-{stamp}"
+    )
+    out.mkdir(parents=True, exist_ok=True)
+
+    devices = build_devices(bench, output_dir=out / "artifacts")
+    options = RunOptions(bench=bench.name, mode=args.mode, user_steps_dir=args.user_steps)
+
+    if args.pytest:
+        case = ScenarioCase(
+            id=f"{scenario.metadata.id}[{bench.name}]",
+            scenario=scenario,
+            devices=devices,
+            run_dir=out,
+            options=options,
+        )
+        results = run_via_pytest([case], out)
+        run = results.get(case.id)
+        if run is None:
+            print("error: the scenario did not run under pytest", file=sys.stderr)
+            return 2
+    else:
+        run = run_scenario(scenario, devices, out, options=options)
+
+    write_run_record(run, out / "run.json")
+    write_junit(run, out / "junit.xml")
+
+    print(f"{run.scenario_id} on {run.bench}: {run.status.upper()}")
+    print(f"  steps: {run.summary.get('passed', 0)} passed, {run.summary.get('failed', 0)} failed")
+    if run.is_endurance:
+        for group_id, rollup in run.summary.get("endurance", {}).items():
+            print(
+                f"  endurance[{group_id}]: {rollup['passed']}/{rollup['completed_cycles']} cycles "
+                f"passed, first failure: {rollup['first_failure_cycle']}"
+            )
+    print(f"  output: {out}")
+    return 0 if run.status == "passed" else 1
+
+
+def _cmd_validate(args: argparse.Namespace) -> int:
+    """Execute the ``validate`` subcommand."""
+    load_all_steps(None)
+    scenario = parse_scenario(Path(args.scenario).read_text(encoding="utf-8"))
+    issues = validate_scenario(scenario, known_steps=known_step_names())
+    if not issues:
+        print("valid: no issues found")
+        return 0
+    for issue in issues:
+        where = f" @{issue.location}" if issue.location else ""
+        print(f"[{issue.severity}] {issue.code}{where}: {issue.message}")
+    return 0 if all(i.severity != "error" for i in issues) else 1
+
+
+def _cmd_schema(args: argparse.Namespace) -> int:
+    """Execute the ``schema`` subcommand."""
+    text = json.dumps(scenario_json_schema(), indent=2)
+    if args.out:
+        Path(args.out).write_text(text + "\n", encoding="utf-8")
+        print(f"wrote schema to {args.out}")
+    else:
+        print(text)
+    return 0
+
+
+def _cmd_steps(_: argparse.Namespace) -> int:
+    """Execute the ``steps`` subcommand."""
+    load_all_steps(None)
+    for name, spec in sorted(all_steps().items()):
+        params = ", ".join(f"{p.name}:{p.kind}{'' if p.required else '?'}" for p in spec.params)
+        suffix = " [free-form]" if spec.freeform else ""
+        print(f"{name}  ({spec.category}){suffix}")
+        if params:
+            print(f"    {params}")
+    return 0
+
+
+def _cmd_detect(args: argparse.Namespace) -> int:
+    """Execute the ``detect`` subcommand."""
+    proposals, errors = run_detection(host=args.host, port=args.port)
+    output = {
+        "proposals": {name: [p.model_dump() for p in items] for name, items in proposals.items()},
+        "errors": errors,
+    }
+    print(json.dumps(output, indent=2))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point. Returns a process exit code."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    handlers = {
+        "run": _cmd_run,
+        "validate": _cmd_validate,
+        "schema": _cmd_schema,
+        "steps": _cmd_steps,
+        "detect": _cmd_detect,
+    }
+    return handlers[args.command](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

maestro_framework-0.1.0/src/maestro_core/config/__init__.py

@@ -0,0 +1,32 @@
+"""MAESTRO configuration — typed settings, layered TOML, and the bench bridge.
+
+Author:
+    Naveen Daniel Kennedy <nvnkennedy@gmail.com>
+"""
+
+from __future__ import annotations
+
+from maestro_core.config.devices import build_devices, driver_name_for
+from maestro_core.config.loader import (
+    deep_merge,
+    load_bench_toml,
+    load_layered,
+    load_toml,
+    write_bench_toml,
+)
+from maestro_core.config.models import BenchConfig, DeviceConfig
+from maestro_core.config.settings import MaestroSettings, get_settings
+
+__all__ = [
+    "BenchConfig",
+    "DeviceConfig",
+    "MaestroSettings",
+    "build_devices",
+    "deep_merge",
+    "driver_name_for",
+    "get_settings",
+    "load_bench_toml",
+    "load_layered",
+    "load_toml",
+    "write_bench_toml",
+]