hatui-kit 0.1.0__py3-none-any.whl

hatui/runtime/provider_manager.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from collections import deque
+from time import perf_counter
+from typing import Any
+
+from hatui.providers.base import SKIP_RESULT, VALUE_RESULT
+from hatui.runtime.bindings import set_path
+
+
+class ProviderManager:
+    def __init__(self, providers: list[Any]):
+        self.providers = self._order_providers(providers)
+
+    def setup(self, context):
+        provider_status = context.data.setdefault("_providers", {})
+        for provider in self.providers:
+            provider_status.setdefault(provider.name, self._status_template(provider))
+            provider.setup(context)
+
+    def update(self, delta_time: float, context):
+        provider_status = context.data.setdefault("_providers", {})
+        for provider in self.providers:
+            status = provider_status.setdefault(provider.name, self._status_template(provider))
+            blocked_by = self._blocked_dependencies(provider, provider_status)
+            if blocked_by:
+                status["status"] = "blocked"
+                status["blocked_by"] = blocked_by
+                status["error"] = None
+                status["last_reason"] = "dependency_error"
+                status["blocked"] += 1
+                self._write_metadata(provider, context, status)
+                continue
+
+            started = perf_counter()
+            try:
+                result = provider.update(delta_time, context)
+                status["blocked_by"] = []
+                status["last_duration_ms"] = round((perf_counter() - started) * 1000.0, 3)
+
+                if result.state == SKIP_RESULT:
+                    status["status"] = "waiting"
+                    status["error"] = None
+                    status["last_reason"] = result.reason
+                    status["skips"] += 1
+                    self._write_metadata(provider, context, status)
+                    continue
+
+                if result.state != VALUE_RESULT:
+                    raise ValueError(f"Unknown provider result state: {result.state}")
+
+                status["status"] = "ok"
+                status["error"] = None
+                status["last_reason"] = None
+                status["attempts"] += 1
+                status["successes"] += 1
+                status["last_run_at"] = round(context.elapsed_time, 3)
+                status["last_success_at"] = round(context.elapsed_time, 3)
+                if provider.target and result.value is not None:
+                    set_path(context.data, provider.target, result.value)
+                self._write_metadata(provider, context, status)
+            except Exception as exc:
+                status["status"] = "error"
+                status["error"] = str(exc)
+                status["last_reason"] = "exception"
+                status["attempts"] += 1
+                status["errors"] += 1
+                status["last_run_at"] = round(context.elapsed_time, 3)
+                status["last_duration_ms"] = round((perf_counter() - started) * 1000.0, 3)
+                self._write_metadata(provider, context, status)
+
+    def teardown(self, context):
+        for provider in self.providers:
+            provider.teardown(context)
+
+    def _order_providers(self, providers: list[Any]) -> list[Any]:
+        by_name: dict[str, Any] = {}
+        for provider in providers:
+            if provider.name in by_name:
+                raise ValueError(f"Duplicate provider name: {provider.name}")
+            by_name[provider.name] = provider
+
+        indegree = {provider.name: 0 for provider in providers}
+        outgoing = {provider.name: [] for provider in providers}
+        for provider in providers:
+            for dependency in provider.depends_on:
+                if dependency not in by_name:
+                    raise ValueError(f"Provider '{provider.name}' depends on unknown provider '{dependency}'")
+                indegree[provider.name] += 1
+                outgoing[dependency].append(provider.name)
+
+        queue = deque(provider.name for provider in providers if indegree[provider.name] == 0)
+        ordered_names: list[str] = []
+        while queue:
+            name = queue.popleft()
+            ordered_names.append(name)
+            for dependent in outgoing[name]:
+                indegree[dependent] -= 1
+                if indegree[dependent] == 0:
+                    queue.append(dependent)
+
+        if len(ordered_names) != len(providers):
+            unresolved = sorted(name for name, degree in indegree.items() if degree > 0)
+            raise ValueError(f"Provider dependency cycle detected: {', '.join(unresolved)}")
+
+        return [by_name[name] for name in ordered_names]
+
+    def _blocked_dependencies(self, provider, provider_status: dict[str, dict[str, Any]]) -> list[str]:
+        blocked: list[str] = []
+        for dependency in provider.depends_on:
+            dependency_status = provider_status.get(dependency, {})
+            if dependency_status.get("status") in {"error", "blocked"}:
+                blocked.append(dependency)
+        return blocked
+
+    def _status_template(self, provider) -> dict[str, Any]:
+        return {
+            "name": provider.name,
+            "group": provider.group,
+            "target": provider.target,
+            "depends_on": list(provider.depends_on),
+            "status": "idle",
+            "error": None,
+            "blocked_by": [],
+            "attempts": 0,
+            "successes": 0,
+            "errors": 0,
+            "skips": 0,
+            "blocked": 0,
+            "last_reason": None,
+            "last_run_at": None,
+            "last_success_at": None,
+            "last_duration_ms": None,
+        }
+
+    def _write_metadata(self, provider, context, status: dict[str, Any]):
+        if provider.metadata_target:
+            set_path(context.data, provider.metadata_target, dict(status))

hatui/runtime/registries.py

@@ -0,0 +1,65 @@
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class WidgetRegistration:
+    widget_type: str
+    factory: Callable[[dict[str, Any], Any], Any]
+    widget_cls: type | None = None
+    allowed_keys: set[str] = field(default_factory=set)
+    required_keys: set[str] = field(default_factory=set)
+
+
+class WidgetRegistry:
+    def __init__(self):
+        self._registrations: dict[str, WidgetRegistration] = {}
+
+    def register(
+        self,
+        widget_type: str,
+        factory: Callable[[dict[str, Any], Any], Any],
+        *,
+        widget_cls: type | None = None,
+        allowed_keys: set[str] | None = None,
+        required_keys: set[str] | None = None,
+    ):
+        self._registrations[widget_type] = WidgetRegistration(
+            widget_type=widget_type,
+            factory=factory,
+            widget_cls=widget_cls,
+            allowed_keys=set(allowed_keys or set()),
+            required_keys=set(required_keys or set()),
+        )
+
+    def create(self, widget_type: str, spec: dict[str, Any], loader):
+        registration = self.get(widget_type)
+        if registration is None:
+            raise ValueError(f"Unknown widget type: {widget_type}")
+        return registration.factory(spec, loader)
+
+    def get(self, widget_type: str) -> WidgetRegistration | None:
+        return self._registrations.get(widget_type)
+
+    def registered_types(self) -> list[str]:
+        return sorted(self._registrations)
+
+
+class ProviderRegistry:
+    def __init__(self):
+        self._providers: dict[str, type] = {}
+
+    def register(self, provider_type: str, provider_cls: type):
+        self._providers[provider_type] = provider_cls
+
+    def create(self, provider_type: str, spec: dict[str, Any]):
+        if provider_type not in self._providers:
+            raise ValueError(f"Unknown provider type: {provider_type}")
+        return self._providers[provider_type](spec)
+
+    def get(self, provider_type: str) -> type | None:
+        return self._providers.get(provider_type)
+
+    def registered_types(self) -> list[str]:
+        return sorted(self._providers)

hatui/runtime/render_policy.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+UNICODE_TRANSLATION = str.maketrans(
+    {
+        "╭": "+",
+        "╮": "+",
+        "╰": "+",
+        "╯": "+",
+        "┌": "+",
+        "┐": "+",
+        "└": "+",
+        "┘": "+",
+        "│": "|",
+        "─": "-",
+        "═": "=",
+        "█": "#",
+        "▇": "#",
+        "▆": "#",
+        "▅": "#",
+        "▄": "#",
+        "▃": "*",
+        "▂": "*",
+        "▁": ".",
+        "░": ".",
+        "▒": ":",
+        "▓": "#",
+        "»": ">",
+        "▸": ">",
+        "▾": "v",
+        "•": "*",
+        "●": "*",
+        "╲": "\\",
+        "╱": "/",
+    }
+)
+
+
+UNICODE_CHARS = {
+    "horizontal": "─",
+    "vertical": "│",
+    "point": "●",
+    "bullet": "•",
+    "collapsed": "▸",
+    "expanded": "▾",
+    "diag_down": "╲",
+    "diag_up": "╱",
+    "fill": "█",
+    "scroll_track": "│",
+    "scroll_thumb": "█",
+    "empty_block": "░",
+}
+
+ASCII_CHARS = {
+    "horizontal": "-",
+    "vertical": "|",
+    "point": "*",
+    "bullet": "*",
+    "collapsed": ">",
+    "expanded": "v",
+    "diag_down": "\\",
+    "diag_up": "/",
+    "fill": "#",
+    "scroll_track": "|",
+    "scroll_thumb": "#",
+    "empty_block": ".",
+}
+
+UNICODE_LEVELS = {
+    "spark": "▁▂▃▄▅▆▇█",
+    "block": " ▁▂▃▄▅▆▇█",
+    "shade": " ░▒▓█",
+}
+
+ASCII_LEVELS = {
+    "spark": ".:-=+*#",
+    "block": " .:-=+*#",
+    "shade": " .:*#",
+}
+
+UNICODE_BORDERS = {
+    "ascii": {
+        "top_left": "+",
+        "top_right": "+",
+        "bottom_left": "+",
+        "bottom_right": "+",
+        "horizontal": "-",
+        "vertical": "|",
+    },
+    "sharp": {
+        "top_left": "┌",
+        "top_right": "┐",
+        "bottom_left": "└",
+        "bottom_right": "┘",
+        "horizontal": "─",
+        "vertical": "│",
+    },
+    "rounded": {
+        "top_left": "╭",
+        "top_right": "╮",
+        "bottom_left": "╰",
+        "bottom_right": "╯",
+        "horizontal": "─",
+        "vertical": "│",
+    },
+}
+
+ASCII_BORDER = {
+    "top_left": "+",
+    "top_right": "+",
+    "bottom_left": "+",
+    "bottom_right": "+",
+    "horizontal": "-",
+    "vertical": "|",
+}
+
+
+@dataclass(frozen=True)
+class RenderPolicy:
+    glyph_mode: str = "unicode"
+
+    @property
+    def is_ascii(self) -> bool:
+        return self.glyph_mode == "ascii"
+
+    def char(self, name: str, default: str = " ") -> str:
+        source = ASCII_CHARS if self.is_ascii else UNICODE_CHARS
+        return source.get(name, default)
+
+    def levels(self, name: str, default: str = "") -> str:
+        source = ASCII_LEVELS if self.is_ascii else UNICODE_LEVELS
+        return source.get(name, default)
+
+    def border(self, style: str) -> dict[str, str]:
+        if self.is_ascii:
+            return dict(ASCII_BORDER)
+        return dict(UNICODE_BORDERS.get(style, UNICODE_BORDERS["sharp"]))
+
+    def translate(self, text: str) -> str:
+        if self.is_ascii:
+            return text.translate(UNICODE_TRANSLATION)
+        return text

hatui/runtime/router.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from hatui.runtime.bindings import set_path
+
+
+class Router:
+    def __init__(
+        self,
+        routes: list[str] | None = None,
+        initial: str | None = None,
+        root_path: str = "_router",
+    ):
+        self.routes = list(routes or [])
+        default_route = initial or (self.routes[0] if self.routes else None)
+        self.stack: list[str] = [default_route] if default_route else []
+        self.root_path = root_path
+
+    @property
+    def current(self) -> str | None:
+        return self.stack[-1] if self.stack else None
+
+    def sync_to_context(self, context):
+        set_path(
+            context.data,
+            self.root_path,
+            {
+                "current": self.current,
+                "stack": deepcopy(self.stack),
+                "routes": list(self.routes),
+            },
+        )
+
+    def has_route(self, route: str | None) -> bool:
+        return bool(route) and route in self.routes
+
+    def set_current(self, route: str) -> bool:
+        if not self.has_route(route):
+            return False
+        if self.stack:
+            self.stack[-1] = route
+        else:
+            self.stack.append(route)
+        return True
+
+    def push(self, route: str) -> bool:
+        if not self.has_route(route):
+            return False
+        self.stack.append(route)
+        return True
+
+    def pop(self) -> bool:
+        if len(self.stack) <= 1:
+            return False
+        self.stack.pop()
+        return True
+
+    def next(self) -> bool:
+        if not self.routes:
+            return False
+        if self.current not in self.routes:
+            return self.set_current(self.routes[0])
+        index = self.routes.index(self.current)
+        return self.set_current(self.routes[(index + 1) % len(self.routes)])
+
+    def previous(self) -> bool:
+        if not self.routes:
+            return False
+        if self.current not in self.routes:
+            return self.set_current(self.routes[-1])
+        index = self.routes.index(self.current)
+        return self.set_current(self.routes[(index - 1) % len(self.routes)])

hatui/runtime/store.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Any
+
+from hatui.runtime.bindings import resolve_path, set_path
+
+
+class Store:
+    def __init__(self, initial_state: dict[str, Any] | None = None, root_path: str = "state"):
+        self.root_path = root_path
+        self.state = deepcopy(initial_state or {})
+
+    def sync_to_context(self, context):
+        set_path(context.data, self.root_path, deepcopy(self.state))
+
+    def get(self, path: str | None = None, default: Any = None) -> Any:
+        if not path:
+            return self.state
+        return resolve_path(self.state, path, default)
+
+    def set(self, path: str, value: Any):
+        set_path(self.state, path, value)
+        return value
+
+    def toggle(self, path: str, default: bool = False) -> bool:
+        next_value = not bool(self.get(path, default))
+        self.set(path, next_value)
+        return next_value