pytestflow 0.2.0__py3-none-any.whl

pytestflow/backend/sequences_info.py

@@ -0,0 +1,130 @@
+import importlib
+import pytestflow
+from pytestflow.core.sequence import TestSequence
+import sys
+from pathlib import Path
+import json
+from pytestflow.backend.uuids_handler import resolve_uuids
+from pytestflow.config.config_manager import ConfigManager
+from pytestflow.steps.action_step import ActionStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.pass_fail import PassFailStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.numeric_limit import NumericLimitStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.string_check import StringCheckStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.df_numeric_limits import DFNumericLimitsStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.waveform_limit import WaveformLimitStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.message_pop_up import MessagePopUpStep # pyright: ignore[reportUnusedImport]
+from pytestflow.steps.flow_control import FlowControlStep # pyright: ignore[reportUnusedImport]
+
+config = ConfigManager()
+
+
+def get_available_sequences():
+    """Returns a list of available sequence names from the sequences folder."""
+    sequences = []
+    try:
+        SEQUENCES_FOLDER = config.get_path("test_sequences")
+        seq_folder = Path(SEQUENCES_FOLDER)
+        if seq_folder.exists() and seq_folder.is_dir():
+            for file in seq_folder.glob("*.py"):
+                if file.name == "__init__.py":
+                    continue
+                sequences.append(file.stem)
+    except ImportError:
+        print("SEQUENCES_FOLDER not defined in config.yaml", file=sys.stderr)
+    return sequences
+
+def get_single_step(step):
+    uuid_val = getattr(step, "static_uuid", None)
+    return {
+        "type": getattr(step, "step_type", "<unnamed type>"),
+        "name": getattr(step, "name", "<unnamed step>"),
+        "uuid": str(uuid_val) if uuid_val is not None else None
+    }
+
+def get_seq_structure_recursive(sequence):
+    """Return a dict with separated Setup / Main / Cleanup steps."""
+    def serialize_steps(step_list):
+        result = []
+        for step in step_list:
+            # Prefect Task
+            if isinstance(step, (
+                ActionStep,
+                PassFailStep,
+                NumericLimitStep,
+                StringCheckStep,
+                DFNumericLimitsStep,
+                WaveformLimitStep,
+                MessagePopUpStep,
+                FlowControlStep
+            )):
+                result.append(get_single_step(step))
+
+            elif isinstance(step, TestSequence):
+                result.append(get_seq_structure_recursive(step))         
+            # unknown
+            else:
+                print(f"[Unknown type: {type(step)}] {step}")
+        return result
+
+   
+    sequence_uuid = str(sequence.static_uuid)
+
+    return {
+    "type": "sub_sequence",   # ← PRIMA chiave
+    "Name": getattr(sequence, "name", "<unnamed sequence>"),
+    "uuid": sequence_uuid,
+    "Setup": {"Steps": serialize_steps(getattr(sequence, "setup_steps", []))},
+    "Main": {"Steps": serialize_steps(getattr(sequence, "main_steps", []))},
+    "Cleanup": {"Steps": serialize_steps(getattr(sequence, "cleanup_steps", []))},
+}
+
+def get_seq_structure(sequence_name: str):
+    try:
+        SEQUENCES_FOLDER = config.get_path("test_sequences")
+    except ImportError:
+        return json.dumps({"error": "SEQUENCES_FOLDER not defined in config.py"})
+    
+    seq_path = Path(SEQUENCES_FOLDER) / f"{sequence_name}.py"
+    if not seq_path.exists():
+        return json.dumps({"error": f"Sequence file {sequence_name}.py not found"})
+    
+    spec = importlib.util.spec_from_file_location(sequence_name, seq_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    if not hasattr(module, "PROCESS_HOOKS"):
+        raise RuntimeError(
+            f"PROCESS_HOOKS not defined in {seq_path}. "            
+        )
+
+    hooks = dict(module.PROCESS_HOOKS)  # copia difensiva
+
+    if "main_sequence" not in hooks:
+        raise RuntimeError("PROCESS_HOOKS['main_sequence'] is required")
+
+    main_factory = hooks["main_sequence"]
+
+    if not callable(main_factory):
+        raise TypeError("PROCESS_HOOKS['main_sequence'] must be callable")
+    
+    # istanzia UNA VOLTA
+    main_sequence = main_factory()
+
+    if not isinstance(main_sequence, TestSequence):
+        raise TypeError(
+            "PROCESS_HOOKS['main_sequence'] must return a TestSequence"
+        )
+
+    # UUID risolti QUI
+    resolve_uuids(main_sequence, main_factory)
+
+    # sostituisci la factory con l'istanza
+    hooks["main_sequence"] = main_sequence
+
+    # struttura per la UI
+    root = get_seq_structure_recursive(main_sequence)
+    root["type"] = "MainSequence"
+
+    return root, hooks   
+
+

pytestflow/backend/start_backend.py

@@ -0,0 +1,118 @@
+import asyncio
+import os
+import threading
+import traceback
+import webbrowser
+from importlib import resources
+from bottle import Bottle, response, run, static_file, route, abort
+from pathlib import Path
+from pytestflow.backend.websocket_gateway import start_server
+from pytestflow.backend.report_manager import report_manager
+from pytestflow.config.config_manager import ConfigManager
+
+CONFIG = ConfigManager().get_config()
+
+# --------------------
+# Paths
+# --------------------
+
+# BASE_DIR = directory di questo file backend/start_backend.py
+BASE_DIR = Path(__file__).parent.resolve()
+
+# percorso relativo al frontend
+FRONTEND_DIR = (BASE_DIR / "frontend").resolve()
+
+# verifica semplice (opzionale)
+if not (FRONTEND_DIR / "index.html").exists():
+    raise RuntimeError(f"Frontend not found in {FRONTEND_DIR}")
+
+
+# --------------------
+# HTTP Server (Bottle)
+# --------------------
+
+app = Bottle()
+
+
+@app.route("/")
+def index():
+    return static_file("index.html", root=FRONTEND_DIR)
+
+
+@app.route("/assets/<filepath:path>")
+def assets(filepath):
+    return static_file(filepath, root=os.path.join(FRONTEND_DIR, "assets"))
+
+
+@app.route("/config.json")
+def config():
+    response.content_type = 'application/json'
+    return {
+        "wsPort": CONFIG["websocket"]["port"],
+        "featureFlags": {
+            "reports": True
+        }
+    }
+
+
+# SPA fallback (Vue/React router)
+@app.route("/<filepath:path>")
+def spa_fallback(filepath):
+    return static_file("index.html", root=FRONTEND_DIR)
+
+
+def start_http():
+    run(
+        app,
+        host=CONFIG["http"]["host"],
+        port=CONFIG["http"]["port"],
+        quiet=True,
+        reloader=False,
+    )
+
+
+# --------------------
+# WebSocket Server
+# --------------------
+
+def start_ws():
+    asyncio.run(start_server(ws_host=CONFIG["websocket"]["host"], ws_port=CONFIG["websocket"]["port"]))
+
+
+# --------------------
+# Main
+# --------------------
+
+def main(open_browser=False):
+    gui_url = f"http://{CONFIG["http"]["host"]}:{CONFIG["http"]["port"]}/"
+    ws_url = f"ws://{CONFIG["websocket"]["host"]}:{CONFIG["websocket"]["port"]}"
+    starter_path = os.path.normpath(
+        os.path.join(os.path.dirname(BASE_DIR), "starter_here.md")
+    )
+
+    print("\nPyTestFlow backend started")
+    print(f"GUI URL: {gui_url}")
+    print(f"WebSocket URL: {ws_url}")
+    print("Next: open the GUI URL, select and launch motherboard test sequence.")
+    print(f"Guide: {starter_path}\n")
+
+    if open_browser:
+        webbrowser.open(gui_url)
+
+    # Start WebSocket server in background thread (wrap to surface exceptions)
+    def _ws_thread_target():
+        try:
+            start_ws()
+        except Exception:
+            print("WebSocket thread exception:")
+            traceback.print_exc()
+
+    ws_thread = threading.Thread(target=_ws_thread_target, daemon=True)
+    ws_thread.start()
+
+    # Start HTTP server (blocking)
+    start_http()
+
+
+if __name__ == "__main__":
+    main()

pytestflow/backend/uuids_handler.py

@@ -0,0 +1,67 @@
+from typing import Iterator, Tuple, Union
+from pytestflow.core.core import StepWrapper
+from pytestflow.core.sequence import TestSequence
+import inspect
+import uuid
+import os
+
+PTF_NAMESPACE = uuid.UUID("9c0cb974-3f6e-40ff-b4ea-a30f68fe35b7")
+
+def walk_sequence(
+    sequence: "TestSequence",
+    base_path: Tuple[str, ...] = (),
+) -> Iterator[Tuple[Union["TestSequence", "StepWrapper"], Tuple[str, ...]]]:
+    """
+    Itera ricorsivamente su una TestSequence e sui suoi step,
+    restituendo (nodo, path) per calcolare UUID coerenti.
+    """
+
+    # path per la sequence stessa
+    seq_path = (*base_path, f"SEQ:{sequence.name}")
+    yield sequence, seq_path
+
+    # funzione interna per processare liste di step
+    def walk_steps(step_list, section_name):
+        for idx, step in enumerate(step_list):
+            step_path = (*seq_path, f"{section_name}[{idx}]")
+            if isinstance(step, TestSequence):
+                # ricorsione
+                yield from walk_sequence(step, step_path)
+            else:
+                # passo normale / Prefect step
+                yield step, (*step_path, f"STEP:{getattr(step, 'name', 'unnamed')}")
+    
+    walk_lists = [
+        ("SETUP", getattr(sequence, "setup_steps", [])),
+        ("MAIN", getattr(sequence, "main_steps", [])),
+        ("CLEANUP", getattr(sequence, "cleanup_steps", [])),
+    ]
+
+    for section_name, steps in walk_lists:
+        yield from walk_steps(steps, section_name)
+
+
+def get_root_sequence_uuid(entrypoint_fn: callable) -> uuid.UUID:
+    """
+    Calcola un UUID stabile per la root TestSequence basandosi sulla funzione entrypoint.
+    - entrypoint_fn: la funzione che crea la root TestSequence (ENTRYPOINT)
+    """
+    real_fn = inspect.unwrap(entrypoint_fn)
+
+    try:
+        file_path = os.path.realpath(inspect.getfile(real_fn))
+    except Exception:
+        file_path = "nofile"
+
+    key = f"RootSequence:{file_path}:{real_fn.__qualname__}"
+    return uuid.uuid5(PTF_NAMESPACE, key)
+
+def resolve_uuids(root_sequence: "TestSequence", entrypoint_fn: callable):
+    root_id = get_root_sequence_uuid(entrypoint_fn)
+
+    for node, path in walk_sequence(root_sequence, (str(root_id),)):
+        node.static_uuid = uuid.uuid5(
+            PTF_NAMESPACE,
+            "/".join(path)
+        )
+

pytestflow/backend/websocket_gateway.py

@@ -0,0 +1,91 @@
+import asyncio
+import json
+import websockets
+from pytestflow.backend.event_bus import event_bus
+from pytestflow.backend.handlers import init_handlers
+from pytestflow.core.runtime_control import runtime_control
+
+
+async def websocket_handler(ws):
+    path = ws.request.path
+
+    if path != "/ws":
+        await ws.close(code=1008, reason="Invalid path")
+        return
+
+    # Prepare per-connection queue and register subscriber before draining queued updates
+    queue = asyncio.Queue()
+
+    async def on_outbound(payload):
+        await queue.put(payload)
+
+    event_bus.on("outbound", on_outbound)
+
+    # start outbound sender using the queue; the subscriber is already registered
+    sender_task = asyncio.create_task(outbound_sender(ws, queue))
+
+    # Drain existing queued updates so new connection receives pending messages
+    loop = asyncio.get_running_loop()
+    while True:
+        update = await loop.run_in_executor(None, runtime_control.get_gui_update, 0)
+        if not update:
+            break
+        await queue.put(update)
+
+    try:
+        async for message in ws:
+            data = json.loads(message)
+            cmd = data.get("cmd")
+            args = data.get("args", {})
+
+            if cmd:
+                await event_bus.emit(cmd, args)
+
+    except websockets.ConnectionClosed:
+        pass
+    finally:
+        # cleanup: remove subscriber and cancel sender
+        try:
+            event_bus._subscribers["outbound"].remove(on_outbound)
+        except Exception:
+            pass
+        sender_task.cancel()
+
+
+async def outbound_sender(ws, queue: asyncio.Queue):
+    try:
+        while True:
+            payload = await queue.get()
+            try:
+                await ws.send(json.dumps(payload))
+            except Exception as e:
+                print("WS send error:", repr(e))
+                continue
+
+    except websockets.ConnectionClosed:
+        print("WS disconnected")
+
+
+async def start_server(ws_host, ws_port):    
+    loop = asyncio.get_running_loop()
+    event_bus.set_loop(loop)
+    asyncio.create_task(event_bus.start())  # starts processing the queue
+    init_handlers()  # register handlers
+
+    # Start background consumer for in-process GUI updates coming from steps
+    async def consume_gui_updates():
+        while True:
+            # Only dequeue if there's at least one outbound subscriber (a connected client)
+            if not event_bus._subscribers.get("outbound"):
+                await asyncio.sleep(0.1)
+                continue
+
+            # run blocking get in executor
+            update = await loop.run_in_executor(None, runtime_control.get_gui_update, 0.5)
+            if update:
+                await event_bus.emit("outbound", update)
+            await asyncio.sleep(0)
+
+    asyncio.create_task(consume_gui_updates())
+    async with websockets.serve(websocket_handler, ws_host, ws_port):
+        await asyncio.Future()

pytestflow/cli.py

@@ -0,0 +1,183 @@
+import argparse
+import os
+import shutil
+import sys
+from pathlib import Path
+from importlib import resources
+
+APP_DIR_NAME = "pytestflow"
+
+# --------------------
+# Template map
+# --------------------
+TEMPLATE_SOURCE_MAP = {
+    "process_models": ("bootstrap_templates", "process_models"),
+    "test_sequences": ("bootstrap_templates", "test_sequences"),
+    "custom_step_types": ("bootstrap_templates", "custom_step_types"),
+}
+
+# --------------------
+# Workspace helpers
+# --------------------
+def resolve_workspace_root(custom_path: str | None = None) -> Path:
+    if custom_path:
+        return Path(custom_path).expanduser().resolve()
+
+    home = Path.home()
+    if sys.platform.startswith("win"):
+        base = Path(os.getenv("LOCALAPPDATA") or os.getenv("APPDATA") or (home / "AppData/Local"))
+    elif sys.platform == "darwin":
+        base = home / "Library/Application Support"
+    else:
+        base = Path(os.getenv("XDG_DATA_HOME") or (home / ".local/share"))
+
+    return (base / APP_DIR_NAME).resolve()
+
+
+def workspace_paths(root: Path) -> dict[str, Path]:
+    subdirs = ["process_models", "test_sequences", "test_reports", "custom_step_types"]
+    paths = {"root": root}
+    for name in subdirs:
+        paths[name] = root / name
+    return paths
+
+
+def _copy_templates(paths: dict[str, Path]) -> list[tuple[str, Path]]:
+    copied = []
+
+    for key, parts in TEMPLATE_SOURCE_MAP.items():
+        destination_dir = paths[key]
+
+        try:
+            package = parts[0]
+            inner_path = parts[1:]
+
+            source_dir = resources.files(package).joinpath(*inner_path)
+
+            with resources.as_file(source_dir) as source_path:
+                source_dir_path = Path(source_path)
+
+        except Exception as e:
+            print(f"[ERROR] Cannot load templates for {key}: {e}")
+            continue
+
+        for src in source_dir_path.rglob("*"):
+            if src.is_file():
+                relative = src.relative_to(source_dir_path)
+                target = destination_dir / relative
+                target.parent.mkdir(parents=True, exist_ok=True)
+
+                shutil.copy2(src, target)
+                print(f"[copied] {target}")
+                copied.append((key, target))
+
+    return copied
+
+
+def initialize_workspace_interactive() -> dict[str, Path]:
+    print("PyTestFlow workspace initialization:")
+    choice = input(
+        "Install templates in current folder (c) or default location (d)? [d/c]: "
+    ).strip().lower()
+
+    if choice == "c":
+        root = Path.cwd()
+    else:
+        root = resolve_workspace_root()
+
+    paths = workspace_paths(root)
+    root.mkdir(parents=True, exist_ok=True)
+    for p in paths.values():
+        p.mkdir(parents=True, exist_ok=True)
+
+    copied = _copy_templates(paths)
+
+    # Copy config.yaml to root
+    try:
+        try:
+            # Try resources first (for installed packages)
+            config_src = resources.files("bootstrap_templates") / "config.yaml"
+            print(f"Trying resources: {config_src}")
+            with resources.as_file(config_src) as src_path:
+                target = paths["root"] / "config.yaml"
+                shutil.copy2(src_path, target)
+                print(f"Used resources: {src_path}")
+        except Exception as e:
+            print(f"Resources failed: {e}")
+            # Fallback to Path (for editable installs)
+            config_src = Path(__file__).parent.parent / "bootstrap_templates" / "config.yaml"
+            target = paths["root"] / "config.yaml"
+            print(f"Using Path: {config_src}")
+            if not config_src.exists():
+                print(f"File does not exist: {config_src}")
+            else:
+                shutil.copy2(config_src, target)
+        print(f"[copied] config.yaml: {target}")
+        copied.append(("config", target))
+    except Exception as e:
+        print(f"[ERROR] Cannot copy config.yaml: {e}")
+
+    print(f"\nPyTestFlow workspace initialized at: {root}")
+    if copied:
+        for key, target in copied:
+            print(f"[copied] {key}: {target}")
+    else:
+        print("[copied] No new files copied, templates already exist.")
+
+    # Print environment variable command
+    if sys.platform.startswith("win"):
+        print(f"\nSet environment variable for this session in PowerShell:\n$env:PYTESTFLOW_HOME='{root}'")
+    else:
+        print(f"\nSet environment variable for this session in bash/zsh:\nexport PYTESTFLOW_HOME='{root}'")
+
+    return paths
+
+
+# --------------------
+# CLI
+# --------------------
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="pytestflow",
+        description="PyTestFlow CLI: initialize workspace or start backend",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    start_parser = subparsers.add_parser(
+        "start",
+        help="Start backend and serve the GUI",
+    )
+    start_parser.add_argument(
+        "--open",
+        action="store_true",
+        help="Open the GUI URL in your default browser",
+    )
+
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize PyTestFlow workspace and copy templates",
+    )
+
+    return parser
+
+
+def main(argv=None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    command = args.command or "start"
+
+    if command == "init":
+        initialize_workspace_interactive()
+        return 0
+
+    if command == "start":
+        from pytestflow.backend.start_backend import main as start_backend
+        start_backend(open_browser=getattr(args, "open", False))
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pytestflow/config/config_manager.py

@@ -0,0 +1,44 @@
+import os
+from pathlib import Path
+import yaml
+
+
+class ConfigManager:
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(ConfigManager, cls).__new__(cls)
+            cls._instance._config = None
+        return cls._instance
+
+    def get_config(self, reload=False):
+        if self._config is None or reload:
+            self._config = self._load_config()
+        return self._config
+
+    def _load_config(self):
+        home = os.getenv("PYTESTFLOW_HOME")
+
+        if not home:
+            raise Exception(
+                "PYTESTFLOW_HOME not set. Run 'pytestflow init' first."
+            )
+
+        root = Path(home)
+        config_path = root / "config.yaml"
+
+        if not config_path.exists():
+            raise Exception("Configuration file not found.")
+
+        with open(config_path) as f:
+            return yaml.safe_load(f)
+    
+    def get_path(self, key):
+        config = self.get_config()
+
+        if key not in config:
+            raise KeyError(f"Missing config key: {key}")
+
+        home = Path(os.getenv("PYTESTFLOW_HOME"))
+        return home / config[key]