gecko-web-runtime-client 1.4.0__tar.gz → 1.4.2__tar.gz

gecko_web_runtime_client-1.4.2/PACKAGE_README.md

@@ -0,0 +1,58 @@
+# Gecko Web Runtime Client
+
+Python page and browser client for a versioned Firefox-derived WPR runtime.
+It exposes pages, contexts, navigation, DOM access, screenshots, diagnostics,
+Turnstile and WeChat workflow adapters.
+
+The native runtime is installed separately:
+
+```powershell
+python -m gecko_web_runtime install-runtime --version 155
+```
+
+The runtime is held in a private GitHub Release. Automatic download needs
+access to `childclm/gecko-web-runtime`. The Python client depends on
+`wpr-runtime-core` for Worker lifecycle and protocol compatibility. Historical
+HTTP imports are retained through `wpr-http`.
+
+## Media capture
+
+For a browser-played Widevine page, use `AsyncMediaDownloader`. It starts the
+Worker, provisions the caller's Widevine profile, enables bounded native H.264
+capture, waits for playback progress, writes a checkpoint, and verifies the
+final MP4 with FFmpeg.
+
+```python
+import asyncio
+from pathlib import Path
+
+from gecko_web_runtime import AsyncMediaDownloader
+
+
+async def main() -> None:
+    result = await AsyncMediaDownloader(
+        "https://example.test/video",
+        output_dir=Path("./media-output"),
+        ffmpeg=Path(r"C:\\ffmpeg\\bin\\ffmpeg.exe"),
+        expected_duration=2575.32,
+        max_retries=1,
+    ).download()
+    if not result["completed"]:
+        raise RuntimeError(result["attempts"])
+    print(result["package"]["output"])
+
+
+asyncio.run(main())
+```
+
+Set `WPR_RUNTIME_DIR`, `WPR_WORKER_EXE`, `WPR_PERSISTENT_PROFILE_DIR`, and
+`WPR_ENABLE_CDM=1` before creating the downloader. Widevine is installed by
+Firefox's official GMP installer into the persistent WPR profile; no existing
+Firefox profile or component is imported. This requires the Worker build with
+`runtime.widevine_start/status` support (Runtime 155.0.8 or later).
+For a bounded
+smoke test of a longer page, use `sample_seconds=120` instead of
+`expected_duration`. The downloader keeps a `checkpoint.json`; rerunning with
+the same output directory returns a completed result without starting another
+Worker.
+

gecko_web_runtime_client-1.4.2/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: gecko-web-runtime-client
+Version: 1.4.2
+Summary: Thin Python client for the Firefox-derived WPR Gecko Worker protocol
+Author: WPR project
+License: MPL-2.0-compatible client; see the runtime bundle notices
+Project-URL: Repository, https://github.com/childclm/gecko-web-runtime-client
+Project-URL: Documentation, https://github.com/childclm/gecko-web-runtime-client/blob/main/README.md
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: wpr-runtime-core<0.3,>=0.2.2
+Requires-Dist: wpr-http<0.3,>=0.2.0
+Provides-Extra: diagnostics
+Requires-Dist: loguru>=0.7.2; extra == "diagnostics"
+
+# Gecko Web Runtime Client
+
+Python page and browser client for a versioned Firefox-derived WPR runtime.
+It exposes pages, contexts, navigation, DOM access, screenshots, diagnostics,
+Turnstile and WeChat workflow adapters.
+
+The native runtime is installed separately:
+
+```powershell
+python -m gecko_web_runtime install-runtime --version 155
+```
+
+The runtime is held in a private GitHub Release. Automatic download needs
+access to `childclm/gecko-web-runtime`. The Python client depends on
+`wpr-runtime-core` for Worker lifecycle and protocol compatibility. Historical
+HTTP imports are retained through `wpr-http`.
+
+## Media capture
+
+For a browser-played Widevine page, use `AsyncMediaDownloader`. It starts the
+Worker, provisions the caller's Widevine profile, enables bounded native H.264
+capture, waits for playback progress, writes a checkpoint, and verifies the
+final MP4 with FFmpeg.
+
+```python
+import asyncio
+from pathlib import Path
+
+from gecko_web_runtime import AsyncMediaDownloader
+
+
+async def main() -> None:
+    result = await AsyncMediaDownloader(
+        "https://example.test/video",
+        output_dir=Path("./media-output"),
+        ffmpeg=Path(r"C:\\ffmpeg\\bin\\ffmpeg.exe"),
+        expected_duration=2575.32,
+        max_retries=1,
+    ).download()
+    if not result["completed"]:
+        raise RuntimeError(result["attempts"])
+    print(result["package"]["output"])
+
+
+asyncio.run(main())
+```
+
+Set `WPR_RUNTIME_DIR`, `WPR_WORKER_EXE`, `WPR_PERSISTENT_PROFILE_DIR`, and
+`WPR_ENABLE_CDM=1` before creating the downloader. Widevine is installed by
+Firefox's official GMP installer into the persistent WPR profile; no existing
+Firefox profile or component is imported. This requires the Worker build with
+`runtime.widevine_start/status` support (Runtime 155.0.8 or later).
+For a bounded
+smoke test of a longer page, use `sample_seconds=120` instead of
+`expected_duration`. The downloader keeps a `checkpoint.json`; rerunning with
+the same output directory returns a completed result without starting another
+Worker.
+

{gecko_web_runtime_client-1.4.0 → gecko_web_runtime_client-1.4.2}/gecko_web_runtime/__init__.py

@@ -24,6 +24,8 @@ from .http import (
     WprTransportError,
 )
 from .installer import install_runtime
+from .media_capture import package_media_capture
+from .media_downloader import AsyncMediaDownloader, MediaDownloadError
 from .models.navigation import TurnstileResult, WechatArticleResult
 from .session import (
     AsyncGeckoWorkerSession,
@@ -38,12 +40,14 @@ __all__ = [
     "AsyncGeckoRuntime",
     "AsyncGeckoWorkerPool",
     "AsyncGeckoWorkerSession",
+    "AsyncMediaDownloader",
     "AsyncWprHttpClient",
     "BrowserContext",
     "GeckoWorkerSession",
     "Headers",
     "HttpRequest",
     "HttpResponse",
+    "MediaDownloadError",
     "MetricsOptions",
     "NetworkTiming",
     "Page",
@@ -68,4 +72,5 @@ __all__ = [
     "WprTimeoutError",
     "WprTransportError",
     "install_runtime",
+    "package_media_capture",
 ]

{gecko_web_runtime_client-1.4.0 → gecko_web_runtime_client-1.4.2}/gecko_web_runtime/api/runtime.py

@@ -2,12 +2,13 @@
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from ..session import AsyncGeckoWorkerSession, RuntimeConfig
 from ..diagnostics import worker_resource_snapshot
+from ..session import AsyncGeckoWorkerSession, RuntimeConfig
 from .context import BrowserContext
 from .page import Page
 
@@ -64,8 +65,50 @@ class AsyncGeckoRuntime:
     async def __aenter__(self) -> "AsyncGeckoRuntime":
         self._session = AsyncGeckoWorkerSession(self.config, self.fpfile, self.proxy)
         await self._session.__aenter__()
+        worker_config = getattr(getattr(self._session, "_sync", None), "config", self.config)
+        if getattr(worker_config, "enable_widevine", False):
+            try:
+                await self.ensure_widevine()
+            except BaseException:
+                await self._session.__aexit__(None, None, None)
+                self._session = None
+                raise
         return self
 
+    async def ensure_widevine(self, *, timeout: float = 120) -> dict[str, Any]:
+        """Download, verify and register Widevine using Firefox's GMP installer.
+
+        Requires enable_widevine=True and a persistent WPR profile. A ready
+        result confirms registration; EME/CDM process readiness is a separate
+        playback capability check.
+        """
+        from wpr_runtime_core.session import require_ok
+        if self._session is None:
+            raise RuntimeError("AsyncGeckoRuntime is not open")
+        if not self._session._sync.config.enable_widevine:
+            raise ValueError("Set RuntimeConfig(enable_widevine=True) before starting the Worker")
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        last_state: dict[str, Any] = {}
+        async def wait():
+            nonlocal last_state
+            value = require_ok("runtime.widevine_start", await self._session.request(
+                {"method": "runtime.widevine_start"}))
+            while True:
+                last_state = value
+                if value.get("status") == "ready":
+                    return value
+                if value.get("status") == "failed":
+                    error = value.get("error", {})
+                    raise RuntimeError(f"Widevine [{error.get('code')}] stage={value.get('stage')}: {error.get('message')}")
+                await asyncio.sleep(0.2)
+                value = require_ok("runtime.widevine_status", await self._session.request(
+                    {"method": "runtime.widevine_status"}))
+        try:
+            return await asyncio.wait_for(wait(), timeout)
+        except asyncio.TimeoutError as exc:
+            raise TimeoutError(f"Widevine installation did not finish within {timeout}s; last_state={last_state}") from exc
+
     async def new_page(self) -> Page:
         if self._session is None:
             raise RuntimeError("AsyncGeckoRuntime is not open")
@@ -78,6 +121,24 @@ class AsyncGeckoRuntime:
         self._pages.add(page)
         return page
 
+    async def media_capture_snapshot(self) -> dict[str, Any]:
+        """Read opt-in CDM output metadata for the current Worker.
+
+        Configure ``RuntimeConfig(media_capture=True)`` before startup. The
+        result contains path, track, timing and size summaries, never media
+        bytes or license material.
+        """
+        if self._session is None:
+            raise RuntimeError("AsyncGeckoRuntime is not open")
+        return await self._session.media_capture_snapshot()
+
+    @property
+    def media_output_dir(self) -> Path | None:
+        """Per-session media output directory, when file capture is enabled."""
+        if self._session is None:
+            raise RuntimeError("AsyncGeckoRuntime is not open")
+        return self._session._sync.media_output_dir
+
     def _forget_page(self, page: Page) -> None:
         self._pages.discard(page)
 
@@ -105,8 +166,8 @@ class AsyncGeckoRuntime:
         old_pid = getattr(getattr(self._session, "_sync", None), "process", None)
         old_pid = getattr(old_pid, "pid", None)
         await self._session.__aexit__(None, None, None)
-        self._session = AsyncGeckoWorkerSession(self.config, self.fpfile, self.proxy)
-        await self._session.__aenter__()
+        self._session = None
+        await self.__aenter__()
         new_pid = getattr(getattr(self._session, "_sync", None), "process", None)
         new_pid = getattr(new_pid, "pid", None)
         self._completed_jobs = 0