pulse-engine 0.2.12__tar.gz → 0.2.13__tar.gz

{pulse_engine-0.2.12 → pulse_engine-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulse-engine
-Version: 0.2.12
+Version: 0.2.13
 Summary: Pulse Engine — Hybrid framework for building Pulse products
 Author: Pulse Team
 Requires-Python: >=3.11,<3.13

{pulse_engine-0.2.12 → pulse_engine-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pulse-engine"
-version = "0.2.12"
+version = "0.2.13"
 description = "Pulse Engine — Hybrid framework for building Pulse products"
 authors = ["Pulse Team"]
 readme = "README.md"

{pulse_engine-0.2.12 → pulse_engine-0.2.13}/src/pulse_engine/adapters/transcription/providers/youtube_captions.py

@@ -107,21 +107,45 @@ class YouTubeCaptionsProvider(TranscriptionProvider):
 
         return await asyncio.to_thread(_sync)
 
-    async def _fetch_subtitles(
-        self, video_id: str, opts: dict[str, Any], tmp: Path
-    ) -> Path | None:
-        """Download subtitle file via yt-dlp; returns path to first .vtt or None."""
+    async def _fetch_subtitle_content(
+        self, video_id: str, base_opts: dict[str, Any], langs: list[str]
+    ) -> tuple[str, str] | None:
+        """Return (vtt_content, detected_lang) by extracting subtitle URLs directly.
+
+        Uses extract_info(process=True) to get signed subtitle URLs, then downloads
+        via urllib. Avoids ydl.download() which triggers format resolution and fails
+        with "Requested format is not available" on restricted format sets from
+        data-centre IPs (GCP/AWS) when using tv_embedded player client.
+        """
+
+        def _sync() -> tuple[str, str] | None:
+            import urllib.request
 
-        def _sync() -> Path | None:
             try:
                 import yt_dlp as _yt
             except ImportError:
                 return None
             url = f"https://www.youtube.com/watch?v={video_id}"
-            with _yt.YoutubeDL(opts) as ydl:
-                ydl.download([url])
-            vtt_files = sorted(tmp.glob(f"{video_id}.*.vtt"))
-            return vtt_files[0] if vtt_files else None
+            # ignore_no_formats_error prevents DownloadError when tv_embedded
+            # returns a restricted format set from data-centre IPs with cookies.
+            fetch_opts = {**base_opts, "ignore_no_formats_error": True}
+            with _yt.YoutubeDL(fetch_opts) as ydl:
+                info = ydl.extract_info(url, download=False, process=True) or {}
+            for lang in langs:
+                for src in ("subtitles", "automatic_captions"):
+                    entries = info.get(src, {}).get(lang, [])
+                    vtt_entry = next(
+                        (e for e in entries if e.get("ext") == "vtt" and e.get("url")),
+                        None,
+                    )
+                    if not vtt_entry:
+                        continue
+                    req = urllib.request.Request(
+                        vtt_entry["url"], headers={"User-Agent": "Mozilla/5.0"}
+                    )
+                    content = urllib.request.urlopen(req, timeout=30).read().decode("utf-8")
+                    return content, lang
+            return None
 
         return await asyncio.to_thread(_sync)
 
@@ -182,30 +206,17 @@ class YouTubeCaptionsProvider(TranscriptionProvider):
                 selected=selected,
             )
 
-            opts = {
-                **base_opts,
-                "writesubtitles": True,
-                "writeautomaticsub": True,
-                "subtitleslangs": selected[:1],
-                "subtitlesformat": "vtt",
-                "outtmpl": str(tmp / "%(id)s"),
-            }
-
             try:
-                vtt_path = await self._fetch_subtitles(video_id, opts, tmp)
+                result = await self._fetch_subtitle_content(video_id, base_opts, selected)
             except Exception as exc:
                 raise TranscriptionUnavailable(
                     f"yt-dlp subtitle fetch failed for {video_id}: {exc}"
                 ) from exc
 
-            if not vtt_path:
+            if not result:
                 raise TranscriptionUnavailable(f"no subtitles found for {video_id}")
 
-            # Detect language from filename: {video_id}.{lang_code}.vtt
-            stem = vtt_path.stem  # e.g. "abc123.hi"
-            detected = stem.rsplit(".", 1)[-1] if "." in stem else language
-
-            content = vtt_path.read_text(encoding="utf-8")
+            content, detected = result
             segments = _parse_vtt(content)
 
             if not segments: