rhylthyme-cli-runner 0.2.8a0__tar.gz → 0.3.0a0__tar.gz

{rhylthyme_cli_runner-0.2.8a0/src/rhylthyme_cli_runner.egg-info → rhylthyme_cli_runner-0.3.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhylthyme-cli-runner
-Version: 0.2.8a0
+Version: 0.3.0a0
 Summary: CLI runner for Rhylthyme real-time program schedules
 Home-page: https://github.com/rhylthyme/rhylthyme-cli-runner
 Author: Rhylthyme Team
@@ -28,7 +28,7 @@ Requires-Dist: pyyaml>=6.0
 Requires-Dist: colorama>=0.4.0
 Requires-Dist: rhylthyme-spec>=0.2.1a0
 Provides-Extra: galago
-Requires-Dist: rhylthyme-galago>=0.1.0a0; extra == "galago"
+Requires-Dist: rhylthyme-galago>=0.2.0a0; extra == "galago"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.10.0; extra == "dev"

{rhylthyme_cli_runner-0.2.8a0 → rhylthyme_cli_runner-0.3.0a0}/setup.py

@@ -19,7 +19,7 @@ def read_readme():
 
 setup(
     name="rhylthyme-cli-runner",
-    version="0.2.8a0",
+    version="0.3.0a0",
     description="CLI runner for Rhylthyme real-time program schedules",
     long_description=read_readme(),
     long_description_content_type="text/markdown",
@@ -41,8 +41,8 @@ setup(
         "rhylthyme-spec>=0.2.1a0",
     ],
     extras_require={
-        # Instrument steps on galago-tools lab instruments (--workcell)
-        "galago": ["rhylthyme-galago>=0.1.0a0"],
+        # Instrument steps on galago-tools lab instruments (--workcell, rhylthyme bridge)
+        "galago": ["rhylthyme-galago>=0.2.0a0"],
         "dev": [
             # Testing framework
             "pytest>=6.0.0",

{rhylthyme_cli_runner-0.2.8a0 → rhylthyme_cli_runner-0.3.0a0}/src/rhylthyme_cli_runner/__init__.py

@@ -6,7 +6,7 @@ This package provides the command-line interface for running and validating
 Rhylthyme real-time program schedules.
 """
 
-__version__ = "0.2.8a0"
+__version__ = "0.3.0a0"
 __author__ = "Rhylthyme Team"
 __description__ = "CLI runner for Rhylthyme real-time program schedules"
 

rhylthyme_cli_runner-0.3.0a0/src/rhylthyme_cli_runner/bridge_serve.py

@@ -0,0 +1,273 @@
+"""
+``rhylthyme bridge --workcell lab.json`` with no program: wait for runs started
+from rhylthyme.com (the web bridge, slice 3; design: rhylthyme-galago
+docs/design/web-bridge.md).
+
+The bridge stays listed as online on the Bridges page. A ``start_run`` command
+names a program saved in the user's own library; this machine loads it,
+checks it against the local workcell and refuses it unless it is safe to run
+here, then runs it exactly as ``rhylthyme bridge PROGRAM`` would, and goes
+back to waiting when the run completes or is aborted.
+
+Live runs need two keys: the bridge must have been started with
+``--allow-live`` (a decision made at the lab machine), and the browser must
+send the ``live`` the user typed after seeing the pre-flight summary. Before
+a run is accepted, in either mode, its tools are configured and must report
+ready; if not, the start is refused with the pre-flight report (tool addresses
+scrubbed).
+"""
+
+import json
+import queue
+import re
+import sys
+from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple
+
+from .instruments import INSTALL_HINT, InstrumentSetupError
+
+UUID_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I
+)
+
+Outcome = Dict[str, Any]
+
+
+def _no(reason: str) -> Outcome:
+    return {"accepted": False, "reason": reason}
+
+
+def _has_code_blocks(program: Mapping[str, Any]) -> bool:
+    for group in ("tracks", "trackTemplates"):
+        for track in program.get(group) or []:
+            for step in track.get("steps") or []:
+                if isinstance(step, Mapping) and step.get("codeBlock"):
+                    return True
+    return False
+
+
+def check_start(
+    args: Mapping[str, Any],
+    fetch_program: Callable[[str], Optional[Mapping[str, Any]]],
+    workcell_source: Any,
+    schema: Mapping[str, Any],
+    allow_live: bool = False,
+) -> Tuple[Outcome, Optional[Dict[str, Any]]]:
+    """
+    Decide whether a ``start_run`` may run here. Returns (outcome, program):
+    the program when accepted, None otherwise.
+    """
+    from .validate_program import perform_additional_validations, validate_program
+
+    mode = args.get("mode") or "simulated"
+    if mode not in ("simulated", "live"):
+        return _no(f"unknown mode {mode!r}"), None
+    if mode == "live":
+        if not allow_live:
+            return (
+                _no(
+                    "this bridge does not accept live runs (start it with --allow-live)"
+                ),
+                None,
+            )
+        if args.get("confirm") != "live":
+            return _no("a live run needs the typed confirmation"), None
+    program_id = str(args.get("program_id") or "")
+    if not UUID_RE.match(program_id):
+        return _no("program_id must be the id of a program in your library"), None
+    row = fetch_program(program_id)
+    if not row or not isinstance(row.get("program_json"), dict):
+        return _no("no such program in your library"), None
+    program = json.loads(json.dumps(row["program_json"]))
+    if _has_code_blocks(program):
+        return _no("programs with code blocks cannot be started from the web"), None
+    is_valid, schema_errors = validate_program(program, dict(schema))
+    errors = list(schema_errors) + perform_additional_validations(
+        program, workcell=workcell_source
+    )
+    if not is_valid or errors:
+        shown = "; ".join(str(e) for e in errors[:3])
+        more = f" (+{len(errors) - 3} more)" if len(errors) > 3 else ""
+        return _no(f"the program is not valid on this workcell: {shown}{more}"), None
+    return {"accepted": True, "reason": ""}, program
+
+
+def serve(
+    workcell_source: Any,
+    *,
+    schema_file: str,
+    time_scale: float = 1.0,
+    record: bool = True,
+    rest=None,
+    token_fn: Optional[Callable[[], str]] = None,
+    config_path=None,
+    run: Optional[Callable[..., Any]] = None,
+    max_runs: Optional[int] = None,
+    out=None,
+    allow_live: bool = False,
+    client_factory: Optional[Callable] = None,
+) -> int:
+    """Wait for runs from the web until Ctrl-C (or ``max_runs``). Returns runs started."""
+    out = out or sys.stdout
+    try:
+        import rhylthyme_galago as galago
+        from rhylthyme_galago import bridge as B
+    except ImportError:
+        raise InstrumentSetupError(INSTALL_HINT) from None
+
+    from .remote import auth
+    from .validate_program import load_program_file
+
+    if run is None:
+        from .program_runner import run_program
+
+        run = run_program
+    run_fn: Callable[..., Any] = run
+
+    try:
+        workcell = galago.load_workcell(workcell_source)
+    except galago.WorkcellError as e:
+        raise InstrumentSetupError(str(e)) from None
+    try:
+        if rest is None or token_fn is None:
+            creds = auth.load_credentials() or {}
+            if not creds.get("supabase_url"):
+                raise InstrumentSetupError(
+                    "rhylthyme bridge needs you signed in: run `rhylthyme login`."
+                )
+            token_fn = token_fn or auth.access_token
+            rest = rest or B.SupabaseRest(
+                creds["supabase_url"], creds["supabase_anon_key"], token_fn
+            )
+        user_id = B.user_id_from_token(token_fn())
+    except (auth.AuthError, B.BridgeError) as e:
+        raise InstrumentSetupError(str(e)) from None
+
+    bridge_id = B.bridge_id_for(
+        workcell, config_path or (auth.config_dir() / "bridges.json")
+    )
+    schema = load_program_file(schema_file)
+    tools: List[Dict[str, str]] = [
+        {"name": t.name, "type": t.type, "status": "idle"}
+        for t in workcell.tools.values()
+    ]
+    starts: "queue.Queue[Tuple[Dict[str, Any], str, Any, bool]]" = queue.Queue()
+    scrub = B.scrubber(workcell)
+
+    def fetch_program(program_id: str) -> Optional[Mapping[str, Any]]:
+        rows = rest.select(
+            "programs",
+            f"id=eq.{program_id}&user_id=eq.{user_id}&select=id,name,program_json",
+        )
+        return rows[0] if rows else None
+
+    def submit(command: Dict[str, Any]) -> Outcome:
+        if not starts.empty():
+            return _no("a run is already starting")
+        args = command.get("args") or {}
+        try:
+            outcome, program = check_start(
+                args, fetch_program, workcell_source, schema, allow_live=allow_live
+            )
+        except B.BridgeError as e:
+            return _no(f"could not load the program: {e}")
+        if not outcome["accepted"] or program is None:
+            print(f"Refused a run from the web: {outcome['reason']}", file=out)
+            return outcome
+        live = args.get("mode") == "live"
+        # Configure the tools now, so a tool that is not ready is a refusal
+        # the browser sees rather than a run that never starts.
+        from .instruments import open_instruments
+
+        session = None
+        try:
+            kwargs: Dict[str, Any] = {"live": live}
+            if client_factory is not None:
+                kwargs["client_factory"] = client_factory
+            session = open_instruments(program, workcell_source, **kwargs)
+            session.prepare()
+        except InstrumentSetupError as e:
+            if session is not None:
+                session.shutdown()
+            reason = "tools not ready: " + scrub(str(e)).replace("\n", "; ")
+            print(f"Refused a run from the web: {reason}", file=out)
+            return _no(reason)
+        starts.put((program, args["program_id"], session, live))
+        if live:
+            print(
+                "\n*** LIVE run started from the web: real hardware will move. "
+                "Ctrl-C stops it. ***",
+                file=out,
+            )
+        print(
+            f"Starting {program.get('name')!r} from the web "
+            f"({'LIVE' if live else 'simulated'}).",
+            file=out,
+        )
+        return {"accepted": True, "reason": ""}
+
+    runs = 0
+    while max_runs is None or runs < max_runs:
+        idle = B.Publisher(
+            None,
+            rest=rest,
+            bridge_id=bridge_id,
+            user_id=user_id,
+            workcell=workcell,
+            tools=tools,
+            allows_live=allow_live,
+            version=getattr(galago, "__version__", ""),
+            on_error=lambda message: print(f"Bridge: {message}", file=out),
+            submit=submit,
+        )
+        try:
+            idle.start()
+        except B.BridgeError as e:
+            raise InstrumentSetupError(
+                f"Could not publish to rhylthyme.com: {e}"
+            ) from None
+        print(
+            f"Bridge {workcell.name!r} is waiting for runs from rhylthyme.com "
+            "(Bridges page). Ctrl-C stops it.",
+            file=out,
+        )
+        if allow_live:
+            print(
+                "LIVE runs may be started from the web (--allow-live); each needs "
+                "the user to type 'live' after the pre-flight summary.",
+                file=out,
+            )
+        try:
+            while True:
+                try:
+                    program, program_id, session, live = starts.get(timeout=0.5)
+                    break
+                except queue.Empty:
+                    continue
+        finally:
+            idle.stop()
+        try:
+            run_fn(
+                None,
+                schema_file,
+                time_scale,
+                False,  # validated in check_start
+                # auto_start=False: the clock runs as soon as the runner opens.
+                # (auto_start=True honours a program's manual start trigger and
+                # would wait for someone to press 's' at the lab machine.)
+                False,
+                None,
+                record=record,
+                factor_prompt=False,
+                workcell=workcell_source,
+                bridge=True,
+                program_data=program,
+                program_id=program_id,
+                exit_when_done=True,
+                live=live,
+                prepared_instruments=session,
+                bridge_allows_live=allow_live,
+            )
+        except SystemExit:
+            print("The run could not start; waiting for the next one.", file=out)
+        runs += 1
+    return runs

{rhylthyme_cli_runner-0.2.8a0 → rhylthyme_cli_runner-0.3.0a0}/src/rhylthyme_cli_runner/cli.py

@@ -360,6 +360,101 @@ def run(
     )
 
 
+@cli.command()
+@click.argument("program_file", type=click.Path(exists=True), required=False)
+@click.option(
+    "--workcell",
+    type=click.Path(exists=True, dir_okay=False),
+    required=True,
+    help="Workcell file mapping the program's instrument tools to galago-tools servers",
+)
+@click.option(
+    "--live",
+    is_flag=True,
+    help="Run on real hardware (asks first, as with rhylthyme run --live)",
+)
+@click.option(
+    "--confirm-live", is_flag=True, help="Answer the --live question in advance"
+)
+@click.option(
+    "--allow-live",
+    is_flag=True,
+    help=(
+        "Waiting for the web: also accept LIVE runs (each still needs the user "
+        "to type 'live' in the browser after the pre-flight summary)"
+    ),
+)
+@click.option(
+    "--time-scale", type=float, default=1.0, help="Time scale factor (default: 1.0)"
+)
+@click.option(
+    "--no-record",
+    is_flag=True,
+    help="Do not write a run record when the run ends",
+)
+def bridge(
+    program_file, workcell, live, confirm_live, allow_live, time_scale, no_record
+):
+    """
+    Run a program on a galago workcell and show it live on rhylthyme.com.
+
+    Without PROGRAM_FILE, wait for runs started from the Bridges page: a
+    program saved in your library, checked here against the workcell (no code
+    blocks; its tools must come up ready), run, then back to waiting. Runs are
+    simulated unless you pass --allow-live here AND the user types 'live' in
+    the browser. Ctrl-C stops.
+
+    Works like `rhylthyme run --workcell`, and while the run lasts keeps your
+    Bridges page up to date: every step, the tool it waits on, any failure.
+    Needs `rhylthyme login` and rhylthyme-galago
+    (pip install "rhylthyme[galago]"). Only outbound HTTPS; tool addresses
+    never leave this machine. From the Bridges page you can pause, resume,
+    retry or skip a failed step and abort; this machine checks and logs each
+    command, and Ctrl-C here always wins.
+    """
+    if program_file is None:
+        from .bridge_serve import serve
+        from .instruments import InstrumentSetupError
+
+        if live:
+            raise click.UsageError(
+                "--live applies to a PROGRAM_FILE run; to accept live runs "
+                "from the web, pass --allow-live."
+            )
+        try:
+            serve(
+                workcell,
+                schema_file=_default_schema_path(),
+                time_scale=time_scale,
+                record=not no_record,
+                allow_live=allow_live,
+            )
+        except InstrumentSetupError as e:
+            raise click.ClickException(str(e))
+        except KeyboardInterrupt:
+            click.echo("Bridge stopped.")
+        return
+    if allow_live:
+        raise click.UsageError(
+            "--allow-live is for waiting for runs from the web (no PROGRAM_FILE); "
+            "use --live to run PROGRAM_FILE on real hardware."
+        )
+    run_program(
+        program_file,
+        _default_schema_path(),
+        time_scale,
+        True,
+        False,
+        None,
+        record=not no_record,
+        factor_prompt=False,
+        workcell=workcell,
+        live=live,
+        confirm_live=confirm_live,
+        bridge=True,
+    )
+
+
 # Plan command
 @cli.command()
 @click.argument("input_file", type=click.Path(exists=True))

{rhylthyme_cli_runner-0.2.8a0 → rhylthyme_cli_runner-0.3.0a0}/src/rhylthyme_cli_runner/history/recorder.py

@@ -15,6 +15,7 @@ the events it emits are:
 ``program_resumed``  {time, wall_time, paused_seconds}
 ``program_aborted``  {time, reason}  (reason goes to ``context.abortReason``)
 ``instrument_reply`` {step_id, time, ok, code, errorMessage, metadata}
+``remote_command``   {time, id, kind, args, accepted, reason}  (-> ``context.remoteCommands``)
 
 All ``time`` values are the runner's program clock (an epoch float that
 advances at ``time_scale``); the record stores them as seconds from the
@@ -298,6 +299,22 @@ class RunRecorder:
             if data.get("metadata"):
                 reply["metadata"] = copy.deepcopy(data["metadata"])
             log["replies"].append(reply)
+        elif event_type == "remote_command":
+            start = self._start_epoch()
+            self.context.setdefault("remoteCommands", []).append(
+                {
+                    "id": data.get("id"),
+                    "kind": data.get("kind"),
+                    "args": copy.deepcopy(data.get("args") or {}),
+                    "atSeconds": (
+                        round(max(0.0, data["time"] - start), 3)
+                        if start is not None and data.get("time") is not None
+                        else None
+                    ),
+                    "accepted": bool(data.get("accepted")),
+                    "reason": data.get("reason") or "",
+                }
+            )
         elif event_type == "program_aborted":
             self.context["abortReason"] = data.get("reason") or "aborted"
         elif event_type == "program_paused":

{rhylthyme_cli_runner-0.2.8a0 → rhylthyme_cli_runner-0.3.0a0}/src/rhylthyme_cli_runner/instruments.py

@@ -234,6 +234,90 @@ def open_instruments(
     return InstrumentSession(galago.InstrumentExecutor(workcell, **kwargs), tools)
 
 
+def start_bridge(
+    runner,
+    session: "InstrumentSession",
+    program: Mapping[str, Any],
+    *,
+    rest=None,
+    token_fn: Optional[Callable[[], str]] = None,
+    config_path=None,
+    program_id: Optional[str] = None,
+    allows_live: bool = False,
+):
+    """
+    Start publishing this run to rhylthyme.com (``rhylthyme bridge``): the
+    user's own ``bridges`` / ``bridge_state`` rows, owner-only. Needs
+    ``rhylthyme login``. Returns the running Publisher; call ``stop()`` at the
+    end. Raises InstrumentSetupError if the site cannot be reached or written.
+    """
+    import rhylthyme_galago
+    from rhylthyme_galago import bridge as B
+
+    from .remote import auth
+
+    try:
+        if rest is None or token_fn is None:
+            creds = auth.load_credentials() or {}
+            if not creds.get("supabase_url"):
+                raise InstrumentSetupError(
+                    "rhylthyme bridge needs you signed in: run `rhylthyme login`."
+                )
+            token_fn = token_fn or auth.access_token
+            rest = rest or B.SupabaseRest(
+                creds["supabase_url"], creds["supabase_anon_key"], token_fn
+            )
+        user_id = B.user_id_from_token(token_fn())
+    except (auth.AuthError, B.BridgeError) as e:
+        raise InstrumentSetupError(str(e)) from None
+
+    workcell = session.executor.workcell
+    bridge_id = B.bridge_id_for(
+        workcell, config_path or (auth.config_dir() / "bridges.json")
+    )
+    tools = [
+        {"name": c.tool, "type": workcell.tool(c.tool).type, "status": c.status.status}
+        for c in session.checks
+    ]
+
+    def on_error(message: str) -> None:
+        runner.status_message = f"Bridge: {message}"
+
+    def submit(command: Dict[str, Any], wait: float = 3.0) -> Optional[Dict[str, Any]]:
+        """Hand a browser command to the runner thread; wait for its decision."""
+        import json as _json
+        import time as _time
+
+        runner.command_queue.put("remote:" + _json.dumps(command))
+        deadline = _time.time() + wait
+        while _time.time() < deadline:
+            outcome = runner.remote_outcomes.get(command["id"])
+            if outcome is not None:
+                return outcome
+            _time.sleep(0.05)
+        return None
+
+    publisher = B.Publisher(
+        runner,
+        rest=rest,
+        bridge_id=bridge_id,
+        user_id=user_id,
+        workcell=workcell,
+        tools=tools,
+        program=program,
+        mode="live" if session.live else "simulated",
+        allows_live=allows_live,
+        version=getattr(rhylthyme_galago, "__version__", ""),
+        on_error=on_error,
+        submit=submit,
+        program_id=program_id,
+    )
+    try:
+        return publisher.start()
+    except B.BridgeError as e:
+        raise InstrumentSetupError(f"Could not publish to rhylthyme.com: {e}") from None
+
+
 def attach_instruments(
     runner,
     workcell_source,