androidctl 0.1.0__py3-none-any.whl

androidctld/__main__.py

@@ -0,0 +1,63 @@
+"""Command-line entry point for running androidctld."""
+
+from __future__ import annotations
+
+import argparse
+import signal
+import sys
+from pathlib import Path
+from threading import Event
+from types import FrameType
+
+from androidctld.auth.token_store import DaemonTokenStore
+from androidctld.config import DEFAULT_HOST, DaemonConfig
+from androidctld.daemon.server import AndroidctldHttpServer
+from androidctld.runtime_policy import MAIN_LOOP_SLEEP_SECONDS
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="androidctld")
+    parser.add_argument("--workspace-root", required=True)
+    parser.add_argument("--owner-id", required=True)
+    parser.add_argument("--host", default=DEFAULT_HOST)
+    parser.add_argument("--port", type=int, default=0)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_arg_parser().parse_args(argv)
+    config = DaemonConfig(
+        workspace_root=Path(args.workspace_root),
+        owner_id=args.owner_id,
+        host=args.host,
+        port=args.port,
+    )
+    should_stop = Event()
+
+    def request_shutdown() -> None:
+        should_stop.set()
+
+    server = AndroidctldHttpServer(
+        config=config,
+        token_store=DaemonTokenStore(config),
+        shutdown_callback=request_shutdown,
+    )
+    server.start()
+
+    def request_stop(signum: int, frame: FrameType | None) -> None:
+        del signum, frame
+        request_shutdown()
+
+    signal.signal(signal.SIGINT, request_stop)
+    signal.signal(signal.SIGTERM, request_stop)
+
+    try:
+        while not should_stop.wait(MAIN_LOOP_SLEEP_SECONDS):
+            pass
+    finally:
+        server.stop()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

androidctld/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

androidctld/actions/__init__.py

@@ -0,0 +1 @@
+"""Action runtime helpers for androidctld."""

androidctld/actions/action_target.py

@@ -0,0 +1,142 @@
+"""Public-safe actionTarget projection helpers."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from androidctl_contracts.command_results import (
+    ActionTargetEvidence,
+    ActionTargetIdentityStatus,
+    ActionTargetPayload,
+)
+from androidctld.refs.models import NodeHandle
+from androidctld.semantics.compiler import CompiledScreen, SemanticNode
+from androidctld.semantics.public_models import PublicScreen, iter_public_nodes
+from androidctld.snapshots.models import RawNode
+
+
+def public_ref_for_handle(
+    *,
+    compiled_screen: CompiledScreen | None,
+    public_screen: PublicScreen | None,
+    handle: NodeHandle | None,
+) -> str | None:
+    if compiled_screen is None or public_screen is None or handle is None:
+        return None
+    if compiled_screen.screen_id != public_screen.screen_id:
+        return None
+    if compiled_screen.source_snapshot_id != handle.snapshot_id:
+        return None
+    return _unique_public_ref_for_raw_rid(
+        compiled_screen=compiled_screen,
+        public_screen=public_screen,
+        raw_rid=handle.rid,
+    )
+
+
+def public_ref_for_raw_node(
+    *,
+    compiled_screen: CompiledScreen | None,
+    public_screen: PublicScreen | None,
+    node: RawNode | None,
+) -> str | None:
+    if compiled_screen is None or public_screen is None or node is None:
+        return None
+    if compiled_screen.screen_id != public_screen.screen_id:
+        return None
+    return _unique_public_ref_for_raw_rid(
+        compiled_screen=compiled_screen,
+        public_screen=public_screen,
+        raw_rid=node.rid,
+    )
+
+
+def build_action_target_payload(
+    *,
+    source_ref: str,
+    source_screen_id: str,
+    subject_ref: str | None,
+    next_screen_id: str,
+    identity_status: ActionTargetIdentityStatus,
+    evidence: Iterable[ActionTargetEvidence],
+    dispatched_ref: str | None = None,
+    next_ref: str | None = None,
+) -> ActionTargetPayload | None:
+    if subject_ref is None:
+        return None
+    payload_kwargs = {
+        "source_ref": source_ref,
+        "source_screen_id": source_screen_id,
+        "subject_ref": subject_ref,
+        "next_screen_id": next_screen_id,
+        "identity_status": identity_status,
+        "evidence": tuple(evidence),
+    }
+    if dispatched_ref is not None:
+        payload_kwargs["dispatched_ref"] = dispatched_ref
+    if next_ref is not None:
+        payload_kwargs["next_ref"] = next_ref
+    return ActionTargetPayload(**payload_kwargs)
+
+
+def build_same_or_successor_action_target(
+    *,
+    source_ref: str,
+    source_screen_id: str,
+    subject_ref: str | None,
+    dispatched_ref: str | None,
+    next_screen_id: str,
+    next_ref: str | None,
+    evidence: Iterable[ActionTargetEvidence],
+) -> ActionTargetPayload | None:
+    if subject_ref is None or next_ref is None:
+        return None
+    identity_status: ActionTargetIdentityStatus = (
+        "sameRef" if next_ref == subject_ref else "successor"
+    )
+    return build_action_target_payload(
+        source_ref=source_ref,
+        source_screen_id=source_screen_id,
+        subject_ref=subject_ref,
+        dispatched_ref=dispatched_ref,
+        next_screen_id=next_screen_id,
+        next_ref=next_ref,
+        identity_status=identity_status,
+        evidence=evidence,
+    )
+
+
+def _unique_public_ref_for_raw_rid(
+    *,
+    compiled_screen: CompiledScreen,
+    public_screen: PublicScreen,
+    raw_rid: str,
+) -> str | None:
+    refs = {
+        node.ref
+        for node in _compiled_nodes(compiled_screen)
+        if node.raw_rid == raw_rid and node.ref
+    }
+    if len(refs) != 1:
+        return None
+    ref = next(iter(refs))
+    return ref if _public_ref_is_unique(public_screen, ref) else None
+
+
+def _compiled_nodes(compiled_screen: CompiledScreen) -> tuple[SemanticNode, ...]:
+    return (
+        *compiled_screen.targets,
+        *compiled_screen.context,
+        *compiled_screen.dialog,
+        *compiled_screen.keyboard,
+        *compiled_screen.system,
+    )
+
+
+def _public_ref_is_unique(public_screen: PublicScreen, ref: str) -> bool:
+    count = 0
+    for group in public_screen.groups:
+        for node in iter_public_nodes(group.nodes):
+            if node.ref == ref:
+                count += 1
+    return count == 1