luvatrix 0.2.2__tar.gz → 0.2.3__tar.gz

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

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

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

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

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

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

{luvatrix-0.2.2 → luvatrix-0.2.3}/luvatrix_core/core/app_runtime.py

@@ -445,6 +445,13 @@ class AppContext:
         payload = self.runtime_telemetry_provider()
         return payload if isinstance(payload, dict) else {}
 
+    def has_presented_frame(self) -> bool:
+        """Return whether the runtime has successfully presented at least one frame."""
+        try:
+            return int(self.runtime_telemetry().get("frames_presented", 0)) > 0
+        except (TypeError, ValueError):
+            return False
+
     def begin_scene_frame(
         self,
         *,
@@ -1574,6 +1581,8 @@ def _parse_entrypoint(entrypoint: str) -> tuple[str, str]:
 def _load_module_from_app_dir(app_dir: Path, module_name: str):
     rel_parts = module_name.split(".")
     module_path = app_dir.joinpath(*rel_parts).with_suffix(".py")
+    if not module_path.exists():
+        module_path = module_path.with_suffix(".pyc")
     if not module_path.exists():
         raise ValueError(f"entrypoint module file not found: {module_name}")
     unique_name = f"luvatrix_app_{abs(hash((str(app_dir), module_name)))}"

{luvatrix-0.2.2 → luvatrix-0.2.3}/luvatrix_core/core/interaction_work.py

@@ -20,7 +20,9 @@ class InteractionAwareWorkScheduler:
 
     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.
+    work from starting until ``interaction_active`` returns false. Pass
+    ``startup_ready=ctx.has_presented_frame`` to keep preparation from
+    competing with the app's first presentation.
 
     Pair with ``SwipeMomentumController`` using
     ``interaction_active=lambda: swipe.active`` and call
@@ -32,12 +34,14 @@ class InteractionAwareWorkScheduler:
         self,
         *,
         interaction_active: Callable[[], bool],
+        startup_ready: Callable[[], bool] | None = None,
         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.startup_ready = startup_ready
         self.request_render = request_render
         self.on_error = on_error
         self.idle_poll_interval = max(0.001, float(idle_poll_interval))
@@ -83,6 +87,11 @@ class InteractionAwareWorkScheduler:
         with self._condition:
             self._condition.notify_all()
 
+    def notify_startup_state_changed(self) -> None:
+        """Wake queued work after the startup gate becomes ready."""
+        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))
@@ -123,12 +132,20 @@ class InteractionAwareWorkScheduler:
                 self._report_error(pending_key, exc)
                 interaction_active = False
 
+            startup_ready = True
+            if self.startup_ready is not None:
+                try:
+                    startup_ready = bool(self.startup_ready())
+                except Exception as exc:
+                    self._report_error(pending_key, exc)
+                    startup_ready = False
+
             with self._condition:
                 if self._closed:
                     return
                 if not self._pending:
                     continue
-                if interaction_active:
+                if interaction_active or not startup_ready:
                     self._condition.wait(self.idle_poll_interval)
                     continue
                 item = self._pending.popleft()

{luvatrix-0.2.2 → luvatrix-0.2.3}/luvatrix_core/core/unified_runtime.py

@@ -75,6 +75,7 @@ class UnifiedRuntime:
         self._active_provider = active_provider
         self._app_loop_rate = _RollingRate()
         self._app_loop_ticks = 0
+        self._frames_presented = 0
         self._scene_buffer = SceneGraphBuffer() if scene_target is not None and render_mode in ("auto", "scene") else None
         if render_mode == "scene" and scene_target is None:
             raise ValueError("render_mode='scene' requires a scene_target")
@@ -123,6 +124,7 @@ class UnifiedRuntime:
             "app_loop_fps": self._app_loop_rate.rate,
             "app_loop_ticks": int(self._app_loop_ticks),
             "app_active": int(self._is_active()),
+            "frames_presented": int(self._frames_presented),
             "scene_deduplicated_submissions": (
                 int(self._scene_buffer.deduplicated_submissions) if self._scene_buffer is not None else 0
             ),
@@ -259,6 +261,7 @@ class UnifiedRuntime:
                     matrix_tick = self._display_runtime.run_once(timeout=display_timeout)
                     if matrix_tick is not None:
                         frames_presented += 1
+                        self._frames_presented = frames_presented
                 sleep_for = rate.compute_sleep(
                     loop_started_at=now,
                     loop_finished_at=time.perf_counter(),
@@ -288,6 +291,7 @@ class UnifiedRuntime:
                         active_target.stop()
         if self._scene_display_runtime is not None:
             frames_presented = self._scene_display_runtime.frames_presented
+            self._frames_presented = frames_presented
         return UnifiedRunResult(
             ticks_run=ticks_run,
             frames_presented=frames_presented,

{luvatrix-0.2.2 → luvatrix-0.2.3}/luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/MainActivity.kt

@@ -11,6 +11,7 @@ import com.chaquo.python.android.AndroidPlatform
 
 class MainActivity : Activity() {
     private lateinit var luvatrixView: LuvatrixVulkanView
+    private lateinit var pythonModule: PyObject
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
@@ -24,17 +25,17 @@ class MainActivity : Activity() {
             Python.start(AndroidPlatform(this))
         }
         Log.i(TAG, "loading luvatrix_android_boot")
-        val module = Python.getInstance().getModule("luvatrix_android_boot")
-        pythonBridge = PythonBridge(module)
+        pythonModule = Python.getInstance().getModule("luvatrix_android_boot")
+        pythonBridge = PythonBridge(pythonModule)
 
         val importProbe = intent.getBooleanExtra("luvatrix_import_probe", false)
         Thread {
             try {
                 Log.i(TAG, "starting Luvatrix visual runtime importProbe=$importProbe")
                 if (importProbe) {
-                    module.callAttr("import_probe")
+                    pythonModule.callAttr("import_probe")
                 } else {
-                    module.callAttr("run_app_vulkan", luvatrixView)
+                    pythonModule.callAttr("run_app_vulkan", luvatrixView)
                 }
                 Log.i(TAG, "Luvatrix visual runtime returned")
             } catch (exc: Throwable) {
@@ -44,6 +45,17 @@ class MainActivity : Activity() {
         }.start()
     }
 
+    override fun onDestroy() {
+        if (::pythonModule.isInitialized && ::luvatrixView.isInitialized) {
+            try {
+                pythonModule.callAttr("detach_android_view", luvatrixView)
+            } catch (exc: Throwable) {
+                Log.w(TAG, "could not detach destroyed Android view", exc)
+            }
+        }
+        super.onDestroy()
+    }
+
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
         if (requestCode == LuvatrixVulkanView.CAMERA_PERMISSION_REQUEST) {

{luvatrix-0.2.2 → luvatrix-0.2.3}/luvatrix_core/templates/native/android/app/src/main/python/luvatrix_android_boot.py

@@ -8,6 +8,7 @@ import os
 from pathlib import Path
 import sys
 import tempfile
+import threading
 import time
 import tomllib
 from urllib.parse import urlparse
@@ -20,6 +21,72 @@ if str(_ROOT) not in sys.path:
 _LAST_MARKER = ""
 _FRAME_COUNT = 0
 _ANDROID_VIEW = None
+_RUNTIME_LOCK = threading.Lock()
+_RUNTIME_RUNNING = False
+_RUNTIME_VIEW_GENERATION = 0
+
+
+class _AndroidViewPresenter:
+    """Rebinds a process-scoped runtime to the current Android Activity view."""
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._view = None
+        self._last_presentation: tuple[str, tuple[object, ...]] | None = None
+
+    def bind(self, view) -> None:
+        with self._lock:
+            self._view = view
+            presentation = self._last_presentation
+            if presentation is not None:
+                self._present(view, *presentation)
+
+    def unbind(self, view) -> None:
+        with self._lock:
+            if self._view is view:
+                self._view = None
+
+    def current_view(self):
+        with self._lock:
+            return self._view
+
+    def presentRgba(self, rgba: bytes, revision: int, width: int, height: int) -> None:
+        self._remember_and_present("presentRgba", (rgba, revision, width, height))
+
+    def presentScene(
+        self,
+        scene_json: str,
+        revision: int,
+        logical_width: int,
+        logical_height: int,
+        presentation_mode: str = "",
+    ) -> None:
+        self._remember_and_present(
+            "presentScene",
+            (scene_json, revision, logical_width, logical_height, presentation_mode),
+        )
+
+    def __getattr__(self, name: str):
+        view = self.current_view()
+        if view is None:
+            raise AttributeError(name)
+        return getattr(view, name)
+
+    def _remember_and_present(self, method_name: str, args: tuple[object, ...]) -> None:
+        with self._lock:
+            self._last_presentation = (method_name, args)
+            view = self._view
+            if view is not None:
+                self._present(view, method_name, args)
+
+    @staticmethod
+    def _present(view, method_name: str, args: tuple[object, ...]) -> None:
+        method = getattr(view, method_name, None)
+        if callable(method):
+            method(*args)
+
+
+_ANDROID_PRESENTER = _AndroidViewPresenter()
 
 
 def _log(message: str) -> None:
@@ -69,15 +136,40 @@ def run_headless_ticks(ticks: int = 5) -> str:
 
 
 def run_app_vulkan(view=None) -> str:
+    global _ANDROID_VIEW, _RUNTIME_RUNNING, _RUNTIME_VIEW_GENERATION
+    with _RUNTIME_LOCK:
+        if view is not None:
+            _ANDROID_VIEW = view
+            _ANDROID_PRESENTER.bind(view)
+            _RUNTIME_VIEW_GENERATION += 1
+        owner_generation = _RUNTIME_VIEW_GENERATION
+        if _RUNTIME_RUNNING:
+            return _mark("luvatrix visual reattached")
+        _RUNTIME_RUNNING = True
     try:
-        configure_android_tls()
-        import_probe()
-        result = _run_visual_runtime(view)
-        _log(f"luvatrix visual ticks={result.ticks_run} frames={result.frames_presented}")
-        return _mark("luvatrix visual ok")
+        while True:
+            configure_android_tls()
+            import_probe()
+            result = _run_visual_runtime(_ANDROID_PRESENTER if view is not None else None)
+            _log(f"luvatrix visual ticks={result.ticks_run} frames={result.frames_presented}")
+            with _RUNTIME_LOCK:
+                if owner_generation == _RUNTIME_VIEW_GENERATION:
+                    return _mark("luvatrix visual ok")
+                owner_generation = _RUNTIME_VIEW_GENERATION
+            _log("restarting visual runtime for replacement Android view")
     except Exception as exc:
         _log(f"luvatrix run_app_vulkan failed: {type(exc).__name__}: {exc}")
         raise
+    finally:
+        with _RUNTIME_LOCK:
+            _RUNTIME_RUNNING = False
+
+
+def detach_android_view(view) -> None:
+    global _ANDROID_VIEW
+    _ANDROID_PRESENTER.unbind(view)
+    if _ANDROID_VIEW is view:
+        _ANDROID_VIEW = None
 
 
 def configure_android_tls() -> str:
@@ -320,8 +412,6 @@ def _run_visual_runtime(view):
     if view is not None and _truthy(config.get("low_latency_mode"), default=True):
         _apply_low_latency_mode(view, target_fps=target_fps, present_fps=present_fps)
     clear_android_input_events()
-    if view is not None:
-        _ANDROID_VIEW = view
     if view is not None and _should_start_camera_preview(config):
         _start_camera_preview(view)
 
@@ -526,10 +616,17 @@ def _paint_view(view, frames: int) -> None:
 
 def _app_dir() -> Path:
     config = _launch_config()
-    configured = (_ROOT / str(config.get("app_dir", "luvatrix_app"))).resolve()
-    if (configured / "app.toml").exists() and (configured / "app_main.py").exists():
+    configured_name = str(config.get("app_dir", "luvatrix_app"))
+    configured = (_ROOT / configured_name).resolve()
+    if (configured / "app.toml").exists() and any(
+        (configured / name).exists() for name in ("app_main.py", "app_main.pyc")
+    ):
         return configured
 
+    materialized_configured = _materialize_configured_app(configured_name)
+    if materialized_configured is not None:
+        return materialized_configured
+
     source = str(config.get("source_app_dir", "") or "")
     if source:
         packaged = (_ROOT / "examples" / Path(source).name).resolve()
@@ -562,7 +659,10 @@ def _app_dir() -> Path:
 
 
 def _import_configured_app_main() -> None:
-    app_main = _app_dir() / "app_main.py"
+    app_dir = _app_dir()
+    app_main = app_dir / "app_main.py"
+    if not app_main.exists():
+        app_main = app_dir / "app_main.pyc"
     module_name = "luvatrix_configured_app_main"
     spec = importlib.util.spec_from_file_location(module_name, app_main)
     if spec is None or spec.loader is None:
@@ -576,6 +676,20 @@ def _import_configured_app_main() -> None:
         raise
 
 
+def _materialize_configured_app(package_name: str) -> Path | None:
+    try:
+        from importlib import resources
+
+        package = importlib.import_module(package_name)
+        package_root = resources.files(package)
+        app_toml = package_root.joinpath("app.toml").read_text(encoding="utf-8")
+        app_main = package_root.joinpath("app_main.pyc").read_bytes()
+    except Exception:
+        return None
+
+    return _write_materialized_bytecode_app(package_name, app_toml, app_main)
+
+
 def _materialize_packaged_app(source_app_dir: str = "") -> Path | None:
     package_name = _configured_example_package(source_app_dir)
     try:
@@ -611,6 +725,16 @@ def _write_materialized_app(package_name: str, app_toml: str, app_main: str) ->
     dest.mkdir(parents=True, exist_ok=True)
     (dest / "app.toml").write_text(app_toml, encoding="utf-8")
     (dest / "app_main.py").write_text(app_main, encoding="utf-8")
+    (dest / "app_main.pyc").unlink(missing_ok=True)
+    return dest
+
+
+def _write_materialized_bytecode_app(package_name: str, app_toml: str, app_main: bytes) -> Path:
+    dest = Path(tempfile.gettempdir()) / f"luvatrix_{package_name.replace('.', '_')}"
+    dest.mkdir(parents=True, exist_ok=True)
+    (dest / "app.toml").write_text(app_toml, encoding="utf-8")
+    (dest / "app_main.pyc").write_bytes(app_main)
+    (dest / "app_main.py").unlink(missing_ok=True)
     return dest
 
 

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

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