c64cast 0.1.0__py3-none-any.whl

c64cast/__init__.py

@@ -0,0 +1,15 @@
+"""Video/audio streaming to Ultimate 64 hardware over the U64 REST API."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+
+try:
+    __version__ = _pkg_version("c64cast")
+except PackageNotFoundError:
+    # Package not installed (running from a source checkout without
+    # `uv sync`). Fall back to a sentinel rather than crashing.
+    __version__ = "0+unknown"
+
+__all__ = ["__version__"]

c64cast/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

c64cast/_native_io.py

@@ -0,0 +1,43 @@
+"""Process-level stderr muting for native-library chatter.
+
+Some of our native dependencies write diagnostics straight to file
+descriptor 2, bypassing Python's `logging`, `sys.stderr`, and any
+library-level verbosity flags:
+
+* MediaPipe's C++/absl logging (GL/XNNPACK init, the benign "feedback
+  manager" + "landmark_projection NORM_RECT square ROI" warnings).
+* OpenCV's AVFoundation/FFmpeg backend, when probing camera indices past
+  the highest valid one.
+* The Obj-C runtime's "Class AVFFrameReceiver/AVFAudioReceiver is
+  implemented in both ..." warning, emitted once when PyAV's bundled
+  libavdevice loads on top of cv2's (different major versions, same
+  AVFoundation device classes) — harmless, neither file-decode path uses
+  the avfoundation input device.
+
+An fd-level redirect is the only thing that catches these. Scope it as
+tightly as possible (around the single import / construction / probe that
+emits the noise, on the main thread before worker threads start) so it
+never swallows real stderr from elsewhere.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import sys
+from collections.abc import Iterator
+
+
+@contextlib.contextmanager
+def silence_native_stderr() -> Iterator[None]:
+    """Temporarily redirect the process stderr fd (2) to /dev/null."""
+    sys.stderr.flush()
+    saved = os.dup(2)
+    devnull = os.open(os.devnull, os.O_WRONLY)
+    try:
+        os.dup2(devnull, 2)
+        os.close(devnull)
+        yield
+    finally:
+        os.dup2(saved, 2)
+        os.close(saved)

c64cast/_pollthread.py

@@ -0,0 +1,78 @@
+"""Background daemon thread with start/stop boilerplate.
+
+Most sites use the simple form — a function called repeatedly on a fixed
+cadence with a stop event handling shutdown:
+
+    self._poll = PollThread(self._fetch, period=10.0, name="rss-poll")
+    self._poll.start()    # in setup()
+    self._poll.stop()     # in teardown()
+
+For variable-cadence loops (e.g. exponential backoff) pass `manual=True`
+and the target owns its own loop and pacing:
+
+    self._poll = PollThread(self._worker, name="obs-status", manual=True)
+    # worker signature: def _worker(stop: threading.Event) -> None
+"""
+
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+
+
+class PollThread:
+    def __init__(
+        self,
+        target: Callable,
+        *,
+        name: str,
+        period: float | None = None,
+        run_first: bool = True,
+        manual: bool = False,
+        join_timeout: float = 0.5,
+    ):
+        if manual and period is not None:
+            raise ValueError("PollThread: period only meaningful when manual=False")
+        if not manual and period is None:
+            raise ValueError("PollThread: period required when manual=False")
+        self._target = target
+        self._name = name
+        self._period = period
+        self._run_first = run_first
+        self._manual = manual
+        self._join_timeout = join_timeout
+        self._stop = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    @property
+    def stop_event(self) -> threading.Event:
+        return self._stop
+
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def start(self) -> None:
+        if self.is_running():
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._run, daemon=True, name=self._name)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=self._join_timeout)
+            self._thread = None
+
+    def _run(self) -> None:
+        if self._manual:
+            self._target(self._stop)
+            return
+        assert self._period is not None
+        if self._run_first:
+            while not self._stop.is_set():
+                self._target()
+                self._stop.wait(self._period)
+        else:
+            while not self._stop.wait(self._period):
+                self._target()