luvatrix 0.2.1__tar.gz → 0.2.2__tar.gz

{luvatrix-0.2.1/luvatrix.egg-info → luvatrix-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luvatrix
-Version: 0.2.1
+Version: 0.2.2
 Summary: Luvatrix runtime and plotting toolkit
 Author: Luvatrix contributors
 License-Expression: LicenseRef-Proprietary

{luvatrix-0.2.1 → luvatrix-0.2.2}/luvatrix/app.py

@@ -22,6 +22,7 @@ from luvatrix_core.core.app_runtime import (
     ResolvedAppVariant,
 )
 from luvatrix_core.core.hdi_thread import HDIEvent, HDIThread
+from luvatrix_core.core.interaction_work import InteractionAwareWorkScheduler
 from luvatrix_core.core.sensor_manager import SensorManagerThread, SensorSample
 from luvatrix_core.core.window_matrix import FullRewrite, WriteBatch, WindowMatrix
 from luvatrix_core import accel
@@ -299,6 +300,11 @@ class SwipeMomentumController:
     def dragging(self) -> bool:
         return self._dragging
 
+    @property
+    def active(self) -> bool:
+        """Whether a drag or post-release momentum is active."""
+        return self._dragging or self._velocity != 0.0
+
     def reset(self) -> None:
         self._touch_id = None
         self._last_position = None
@@ -1856,6 +1862,7 @@ __all__ = [
     "Display",
     "InputManager",
     "InputState",
+    "InteractionAwareWorkScheduler",
     "MatrixFrame",
     "MissingOptionalDependencyError",
     "ResolvedAppVariant",

{luvatrix-0.2.1 → luvatrix-0.2.2/luvatrix.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luvatrix
-Version: 0.2.1
+Version: 0.2.2
 Summary: Luvatrix runtime and plotting toolkit
 Author: Luvatrix contributors
 License-Expression: LicenseRef-Proprietary

{luvatrix-0.2.1 → luvatrix-0.2.2}/luvatrix.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ luvatrix_core/core/engine.py
 luvatrix_core/core/events.py
 luvatrix_core/core/frame_rate_controller.py
 luvatrix_core/core/hdi_thread.py
+luvatrix_core/core/interaction_work.py
 luvatrix_core/core/process_runtime.py
 luvatrix_core/core/process_sdk.py
 luvatrix_core/core/protocol_governance.py

{luvatrix-0.2.1 → luvatrix-0.2.2}/luvatrix_core/__init__.py

@@ -1,4 +1,4 @@
 """Luvatrix runtime."""
 
 __all__ = ["__version__"]
-__version__ = "0.2.1"
+__version__ = "0.2.2"

luvatrix-0.2.2/luvatrix_core/core/interaction_work.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from collections import deque
+from collections.abc import Callable, Hashable
+from dataclasses import dataclass
+import threading
+import time
+from typing import Any
+
+
+@dataclass(frozen=True)
+class _WorkItem:
+    key: Hashable
+    prepare: Callable[[], Any]
+    on_complete: Callable[[Any], None] | None
+
+
+class InteractionAwareWorkScheduler:
+    """Run keyed preparation work only while user interaction is idle.
+
+    Work and callbacks execute sequentially on one daemon thread. Running work
+    is not preempted when interaction begins; the idle gate prevents queued
+    work from starting until ``interaction_active`` returns false.
+
+    Pair with ``SwipeMomentumController`` using
+    ``interaction_active=lambda: swipe.active`` and call
+    :meth:`notify_interaction_state_changed` after controller updates to wake
+    queued work immediately when momentum stops.
+    """
+
+    def __init__(
+        self,
+        *,
+        interaction_active: Callable[[], bool],
+        request_render: Callable[[], None] | None = None,
+        on_error: Callable[[Hashable, Exception], None] | None = None,
+        idle_poll_interval: float = 1.0 / 120.0,
+        thread_name: str = "luvatrix-interaction-work",
+    ) -> None:
+        self.interaction_active = interaction_active
+        self.request_render = request_render
+        self.on_error = on_error
+        self.idle_poll_interval = max(0.001, float(idle_poll_interval))
+        self.thread_name = str(thread_name)
+        self._condition = threading.Condition()
+        self._pending: deque[_WorkItem] = deque()
+        self._keys: set[Hashable] = set()
+        self._thread: threading.Thread | None = None
+        self._closed = False
+
+    @property
+    def pending_count(self) -> int:
+        with self._condition:
+            return len(self._keys)
+
+    def submit(
+        self,
+        key: Hashable,
+        prepare: Callable[[], Any],
+        *,
+        on_complete: Callable[[Any], None] | None = None,
+    ) -> bool:
+        """Queue work unless the key is already queued or running."""
+        with self._condition:
+            if self._closed:
+                raise RuntimeError("interaction-aware work scheduler is closed")
+            if key in self._keys:
+                return False
+            self._keys.add(key)
+            self._pending.append(_WorkItem(key, prepare, on_complete))
+            if self._thread is None:
+                self._thread = threading.Thread(
+                    target=self._run,
+                    name=self.thread_name,
+                    daemon=True,
+                )
+                self._thread.start()
+            self._condition.notify_all()
+            return True
+
+    def notify_interaction_state_changed(self) -> None:
+        """Wake idle-gated work after a controller state update."""
+        with self._condition:
+            self._condition.notify_all()
+
+    def wait_idle(self, timeout: float | None = None) -> bool:
+        """Wait until queued/running work and its callbacks have completed."""
+        deadline = None if timeout is None else time.monotonic() + max(0.0, float(timeout))
+        with self._condition:
+            while self._keys:
+                if deadline is None:
+                    self._condition.wait()
+                    continue
+                remaining = deadline - time.monotonic()
+                if remaining <= 0.0:
+                    return False
+                self._condition.wait(remaining)
+            return True
+
+    def close(self, *, wait: bool = False) -> None:
+        """Cancel queued work and optionally wait for running work to finish."""
+        with self._condition:
+            self._closed = True
+            while self._pending:
+                self._keys.discard(self._pending.popleft().key)
+            thread = self._thread
+            self._condition.notify_all()
+        if wait and thread is not None and thread is not threading.current_thread():
+            thread.join()
+
+    def _run(self) -> None:
+        while True:
+            with self._condition:
+                while not self._closed and not self._pending:
+                    self._condition.wait()
+                if self._closed:
+                    return
+                pending_key = self._pending[0].key
+
+            try:
+                interaction_active = bool(self.interaction_active())
+            except Exception as exc:
+                self._report_error(pending_key, exc)
+                interaction_active = False
+
+            with self._condition:
+                if self._closed:
+                    return
+                if not self._pending:
+                    continue
+                if interaction_active:
+                    self._condition.wait(self.idle_poll_interval)
+                    continue
+                item = self._pending.popleft()
+
+            try:
+                value = item.prepare()
+            except Exception as exc:
+                self._report_error(item.key, exc)
+            else:
+                if item.on_complete is not None:
+                    try:
+                        item.on_complete(value)
+                    except Exception as exc:
+                        self._report_error(item.key, exc)
+            try:
+                if self.request_render is not None:
+                    self.request_render()
+            except Exception as exc:
+                self._report_error(item.key, exc)
+            finally:
+                with self._condition:
+                    self._keys.discard(item.key)
+                    self._condition.notify_all()
+
+    def _report_error(self, key: Hashable, error: Exception) -> None:
+        if self.on_error is None:
+            return
+        try:
+            self.on_error(key, error)
+        except Exception:
+            return

{luvatrix-0.2.1 → luvatrix-0.2.2}/luvatrix_core/platform/android/runner.py

@@ -332,14 +332,17 @@ def sync_android_python_assets(app_dir: Path, *, project_dir: Path) -> None:
 
 def _android_python_packages_for_app(app_dir: Path, *, exclude_dirs: Iterable[Path] = ()) -> tuple[str, ...]:
     packages = ["luvatrix", "luvatrix_core"]
-    imports = _top_level_imports_for_app(app_dir, exclude_dirs=exclude_dirs)
+    imported_modules = _imported_modules_for_app(app_dir, exclude_dirs=exclude_dirs)
+    imports = {module.split(".", 1)[0] for module in imported_modules}
+    for module in imported_modules:
+        imports.update(_first_party_module_import_roots(module))
     for optional_pkg in ("luvatrix_ui", "luvatrix_plot"):
         if optional_pkg in imports:
             packages.append(optional_pkg)
     return tuple(packages)
 
 
-def _top_level_imports_for_app(app_dir: Path, *, exclude_dirs: Iterable[Path] = ()) -> set[str]:
+def _imported_modules_for_app(app_dir: Path, *, exclude_dirs: Iterable[Path] = ()) -> set[str]:
     imports: set[str] = set()
     excluded = tuple(path.resolve() for path in exclude_dirs)
     for path in app_dir.rglob("*.py"):
@@ -355,12 +358,37 @@ def _top_level_imports_for_app(app_dir: Path, *, exclude_dirs: Iterable[Path] =
         for node in ast.walk(tree):
             if isinstance(node, ast.Import):
                 for alias in node.names:
-                    imports.add(alias.name.split(".", 1)[0])
+                    imports.add(alias.name)
             elif isinstance(node, ast.ImportFrom) and node.module:
-                imports.add(node.module.split(".", 1)[0])
+                imports.add(node.module)
     return imports
 
 
+def _first_party_module_import_roots(module_name: str) -> set[str]:
+    package_name, _, relative_module = module_name.partition(".")
+    if package_name not in {"luvatrix", "luvatrix_core"}:
+        return set()
+    package_dir = _python_package_dir(package_name)
+    if relative_module:
+        module_path = package_dir.joinpath(*relative_module.split("."))
+        source_path = module_path.with_suffix(".py")
+        if not source_path.is_file():
+            source_path = module_path / "__init__.py"
+    else:
+        source_path = package_dir / "__init__.py"
+    try:
+        tree = ast.parse(source_path.read_text(encoding="utf-8"), filename=str(source_path))
+    except (OSError, SyntaxError):
+        return set()
+    roots: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            roots.update(alias.name.split(".", 1)[0] for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module:
+            roots.add(node.module.split(".", 1)[0])
+    return roots
+
+
 def _make_android_app_ignore(project_dir: Path):
     pattern_ignore = shutil.ignore_patterns("__pycache__", "*.pyc", ".pytest_cache", ".luvatrix")
     project = project_dir.resolve()

{luvatrix-0.2.1 → luvatrix-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "luvatrix"
-version = "0.2.1"
+version = "0.2.2"
 description = "Luvatrix runtime and plotting toolkit"
 readme = "README.md"
 requires-python = ">=3.14,<3.15"