pulse-engine 0.2.26__tar.gz → 0.2.27__tar.gz

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/PKG-INFO

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

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/pyproject.toml

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

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/adapters/models.py

@@ -147,6 +147,9 @@ class VideoAudio:
     transcript: str
     language: str
     segments: list[TranscriptSegment] = field(default_factory=list)
+    provider: str | None = None
+    used_proxy: bool = False
+    error: str | None = None
 
 
 @dataclass

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/adapters/transcription/providers/youtube_captions.py

@@ -215,6 +215,23 @@ class YouTubeCaptionsProvider(TranscriptionProvider):
             raise TranscriptionUnavailable("yt-dlp not installed")
 
         video_id = source.video_id
+        proxy = os.environ.get("YT_DLP_PROXY", "").strip()
+
+        try:
+            result = await self._attempt(video_id, language, use_proxy=False)
+            result.used_proxy = False
+            return result
+        except TranscriptionUnavailable:
+            if not (proxy and self._cookies_secret_id):
+                raise
+            logger.info("youtube_captions_retry_with_proxy", video_id=video_id)
+            result = await self._attempt(video_id, language, use_proxy=True)
+            result.used_proxy = True
+            return result
+
+    async def _attempt(
+        self, video_id: str, language: str, use_proxy: bool
+    ) -> VideoAudio:
         raw_clients = os.environ.get("YT_DLP_PLAYER_CLIENTS", "").strip()
         clients: list[str] = (
             [c.strip() for c in raw_clients.split(",") if c.strip()]
@@ -236,17 +253,19 @@ class YouTubeCaptionsProvider(TranscriptionProvider):
 
             # Optional residential/mobile proxy — YouTube bot-gates datacenter
             # IPs regardless of cookies, so caption fetches from cloud runs need
-            # the same proxy the audio downloader uses. Unset = unchanged.
-            proxy = os.environ.get("YT_DLP_PROXY", "").strip()
-            if proxy:
-                base_opts["proxy"] = proxy
-
-            cookies = await self._resolve_cookies()
-            if cookies:
-                cookies_path = tmp / "cookies.txt"
-                cookies_path.write_text(cookies, encoding="utf-8")
-                cookies_path.chmod(0o600)
-                base_opts["cookiefile"] = str(cookies_path)
+            # the same proxy the audio downloader uses. Only used on retry
+            # after a direct (no-proxy, no-cookies) attempt fails.
+            if use_proxy:
+                proxy = os.environ.get("YT_DLP_PROXY", "").strip()
+                if proxy:
+                    base_opts["proxy"] = proxy
+
+                cookies = await self._resolve_cookies()
+                if cookies:
+                    cookies_path = tmp / "cookies.txt"
+                    cookies_path.write_text(cookies, encoding="utf-8")
+                    cookies_path.chmod(0o600)
+                    base_opts["cookiefile"] = str(cookies_path)
 
             try:
                 manual_langs, auto_langs = await self._list_available_langs(

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/adapters/transcription/service.py

@@ -40,22 +40,32 @@ class TranscriptionService:
             audio_resolver=audio_resolver,
         )
 
+        last_error: str | None = None
         for name in chain:
             try:
                 provider = self._factory.get(name)
-                return await provider.transcribe(source, cfg.language)
+                result = await provider.transcribe(source, cfg.language)
+                result.provider = name
+                return result
             except TranscriptionUnavailable as exc:
+                last_error = str(exc)
                 logger.info(
                     "transcription_provider_unavailable",
                     provider=name,
                     reason=str(exc),
                 )
                 continue
-            except Exception:
+            except Exception as exc:
+                last_error = str(exc)
                 logger.warning(
                     "transcription_provider_failed", provider=name, exc_info=True
                 )
                 continue
 
         logger.warning("transcription_all_providers_failed", chain=chain)
-        return VideoAudio(transcript="", language=cfg.language, segments=[])
+        return VideoAudio(
+            transcript="",
+            language=cfg.language,
+            segments=[],
+            error=f"all providers failed ({', '.join(chain)}): {last_error}",
+        )

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/adapters/youtube_downloader.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
@@ -17,6 +18,20 @@ logger = structlog.get_logger(__name__)
 # age-restricted videos when cookies are provided. Override via YT_DLP_PLAYER_CLIENTS.
 _DEFAULT_PLAYER_CLIENTS = ["tv_embedded", "web"]
 
+# Cap fragment/segment retries on the proxy path — a flaky proxy shouldn't
+# re-pull fragments repeatedly on the metered egress. Direct-path retries are
+# unaffected (governed entirely by the caller's `extra` overrides).
+_PROXY_MAX_RETRIES = 1
+
+
+@dataclass
+class DownloadResult:
+    """Outcome of a `YouTubeDownloader.download()` call."""
+
+    path: Path | None
+    used_proxy: bool
+    error: str | None = None
+
 
 def _build_yt_dlp_opts(
     output_template: str,
@@ -36,8 +51,9 @@ def _build_yt_dlp_opts(
     opts: dict[str, Any] = {
         # Cap source bitrate — output is always re-encoded to 64kbps mp3, so
         # pulling a higher-bitrate stream just to downsample it wastes egress
-        # (metered on the proxy path).
-        "format": "bestaudio[abr<=96]/bestaudio/best",
+        # (metered on the proxy path). Capped to match the 64kbps mp3 output
+        # exactly; fallback chain keeps degrading gracefully if unavailable.
+        "format": "bestaudio[abr<=64]/bestaudio/best",
         "outtmpl": output_template,
         "postprocessors": [
             {
@@ -87,6 +103,17 @@ def _build_yt_dlp_opts(
                     merged[k] = v
             opts["extractor_args"] = merged
 
+    if use_proxy and "proxy" in opts:
+        # Cap retries on the metered proxy path regardless of caller overrides
+        # (e.g. feed's hardening opts default retries=2) — a flaky proxy
+        # shouldn't re-pull fragments repeatedly on billed egress.
+        opts["retries"] = min(
+            opts.get("retries", _PROXY_MAX_RETRIES), _PROXY_MAX_RETRIES
+        )
+        opts["fragment_retries"] = min(
+            opts.get("fragment_retries", _PROXY_MAX_RETRIES), _PROXY_MAX_RETRIES
+        )
+
     if clip_start is not None or clip_end is not None:
         from yt_dlp.utils import download_range_func
 
@@ -129,31 +156,33 @@ class YouTubeDownloader:
         output_dir: str,
         start: float | None = None,
         end: float | None = None,
-    ) -> Path | None:
-        """Download audio for *video_id* into *output_dir*, returning path to mp3.
+    ) -> DownloadResult:
+        """Download audio for *video_id* into *output_dir*.
 
-        Returns ``None`` if the download fails for any reason.
+        Returns a `DownloadResult` — `path` is `None` if the download failed
+        for any reason, with `used_proxy`/`error` describing which attempt
+        ran and why it failed.
         """
         url = f"https://www.youtube.com/watch?v={video_id}"
         logger.info("youtube_download_started", video_id=video_id)
 
-        result = await self._download_audio(
+        path, error = await self._download_audio(
             url, output_dir, start=start, end=end, use_proxy=False, use_cookies=False
         )
 
-        if result is None and self._proxy_configured and self._cookies_secret_id:
+        used_proxy = False
+        if path is None and self._proxy_configured and self._cookies_secret_id:
             logger.info("youtube_download_retry_with_proxy", video_id=video_id)
-            result = await self._download_audio(
+            used_proxy = True
+            path, error = await self._download_audio(
                 url, output_dir, start=start, end=end, use_proxy=True, use_cookies=True
             )
 
-        if result is None:
+        if path is None:
             logger.warning("youtube_download_failed", video_id=video_id)
         else:
-            logger.info(
-                "youtube_download_completed", video_id=video_id, path=str(result)
-            )
-        return result
+            logger.info("youtube_download_completed", video_id=video_id, path=str(path))
+        return DownloadResult(path=path, used_proxy=used_proxy, error=error)
 
     # ------------------------------------------------------------------
     # Private helpers
@@ -207,13 +236,17 @@ class YouTubeDownloader:
         end: float | None = None,
         use_proxy: bool = False,
         use_cookies: bool = False,
-    ) -> Path | None:
-        """Download audio from a YouTube URL to *output_dir* via yt-dlp."""
+    ) -> tuple[Path | None, str | None]:
+        """Download audio from a YouTube URL to *output_dir* via yt-dlp.
+
+        Returns `(path, error)` — `path` is `None` on failure, with `error`
+        carrying the failure reason (`None` on success).
+        """
         try:
             import yt_dlp
         except ImportError:
             logger.warning("yt_dlp_not_installed", url=url)
-            return None
+            return None, "yt-dlp not installed"
 
         output_template = str(Path(output_dir) / "%(id)s.%(ext)s")
         ydl_opts = _build_yt_dlp_opts(
@@ -245,7 +278,11 @@ class YouTubeDownloader:
                 return candidate if candidate.exists() else None
 
         try:
-            return await asyncio.to_thread(_download)
-        except Exception:
+            path = await asyncio.to_thread(_download)
+        except Exception as exc:
             logger.warning("youtube_audio_download_failed", url=url, exc_info=True)
-            return None
+            return None, str(exc)
+
+        if path is None:
+            return None, "download completed but output file not found"
+        return path, None

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/cron/runner.py

@@ -81,7 +81,7 @@ def cron_job_flow(
     try:
         method = (webhook_method or "POST").upper()
         if method == "GET":
-            resp = httpx.get(webhook_url, headers=webhook_headers, timeout=300.0)
+            resp = httpx.get(webhook_url, headers=webhook_headers, timeout=1800.0)
         else:
             resp = httpx.post(
                 webhook_url,

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/deployment/infra_provisioner.py

@@ -13,6 +13,8 @@ Prerequisites (created by Terraform once):
 from __future__ import annotations
 
 import logging
+import random
+import time
 from typing import Any
 
 import boto3
@@ -20,6 +22,14 @@ from botocore.exceptions import ClientError
 
 logger = logging.getLogger(__name__)
 
+# ECS throttles concurrent register_task_definition calls against the same
+# family with this exact message. Retried with backoff since it's transient.
+_ECS_CONCURRENT_REVISION_MESSAGE = (
+    "Too many concurrent attempts to create a new revision"
+)
+_ECS_REGISTER_MAX_RETRIES = 5
+_ECS_REGISTER_BASE_DELAY_SECONDS = 1.0
+
 
 class InfraProvisioner:
     """Auto-provisions AWS infrastructure for pipeline step containers.
@@ -101,6 +111,36 @@ class InfraProvisioner:
             except ClientError as e:
                 if e.response["Error"]["Code"] != "ClientException":
                     raise
+        else:
+            # A specific image was requested — reuse the latest revision if
+            # it already matches (same image/cpu/memory) instead of blindly
+            # registering a new one every call. Concurrent pipeline runs
+            # otherwise all race to create new revisions of the same shared
+            # family, which ECS throttles with a ClientException.
+            try:
+                resp = ecs.describe_task_definition(taskDefinition=family)
+                existing = resp["taskDefinition"]
+                existing_containers = existing.get("containerDefinitions", [])
+                existing_image = (
+                    existing_containers[0]["image"] if existing_containers else None
+                )
+                if (
+                    existing_image == image
+                    and existing.get("cpu") == cpu
+                    and existing.get("memory") == memory
+                ):
+                    result_arn = str(existing["taskDefinitionArn"])
+                    logger.info(
+                        "Reusing matching ECS task definition: %s (rev %s, image=%s)",
+                        family,
+                        existing["revision"],
+                        image,
+                    )
+                    self._ecs_task_def_cache[cache_key] = result_arn
+                    return result_arn
+            except ClientError as e:
+                if e.response["Error"]["Code"] != "ClientException":
+                    raise
 
         # Register new task definition with the specified (or placeholder) image
         container_def: dict[str, Any] = {
@@ -124,15 +164,12 @@ class InfraProvisioner:
             },
         }
 
-        resp = ecs.register_task_definition(
+        resp = self._register_task_definition_with_retry(
+            ecs,
             family=family,
-            networkMode="awsvpc",
-            requiresCompatibilities=["FARGATE"],
             cpu=cpu,
             memory=memory,
-            executionRoleArn=self._exec_role_arn,
-            taskRoleArn=self._task_role_arn,
-            containerDefinitions=[container_def],
+            container_def=container_def,
         )
 
         result_arn = str(resp["taskDefinition"]["taskDefinitionArn"])
@@ -140,6 +177,53 @@ class InfraProvisioner:
         self._ecs_task_def_cache[cache_key] = result_arn
         return result_arn
 
+    def _register_task_definition_with_retry(
+        self,
+        ecs: Any,
+        *,
+        family: str,
+        cpu: str,
+        memory: str,
+        container_def: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Call register_task_definition, retrying with backoff+jitter on the
+        ECS "too many concurrent attempts" throttle for this family."""
+        for attempt in range(1, _ECS_REGISTER_MAX_RETRIES + 1):
+            try:
+                return ecs.register_task_definition(  # type: ignore[no-any-return]
+                    family=family,
+                    networkMode="awsvpc",
+                    requiresCompatibilities=["FARGATE"],
+                    cpu=cpu,
+                    memory=memory,
+                    executionRoleArn=self._exec_role_arn,
+                    taskRoleArn=self._task_role_arn,
+                    containerDefinitions=[container_def],
+                )
+            except ClientError as e:
+                error = e.response.get("Error", {})
+                is_concurrent_revision_throttle = (
+                    error.get("Code") == "ClientException"
+                    and _ECS_CONCURRENT_REVISION_MESSAGE in error.get("Message", "")
+                )
+                if (
+                    not is_concurrent_revision_throttle
+                    or attempt == _ECS_REGISTER_MAX_RETRIES
+                ):
+                    raise
+                delay = _ECS_REGISTER_BASE_DELAY_SECONDS * (2 ** (attempt - 1))
+                delay += random.uniform(0, delay * 0.5)
+                logger.warning(
+                    "ECS register_task_definition throttled for family %s "
+                    "(attempt %d/%d), retrying in %.1fs",
+                    family,
+                    attempt,
+                    _ECS_REGISTER_MAX_RETRIES,
+                    delay,
+                )
+                time.sleep(delay)
+        raise AssertionError("unreachable")  # loop always returns or raises
+
     # ------------------------------------------------------------------
     # Lambda Function
     # ------------------------------------------------------------------

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/pipeline/router_pipelines.py

@@ -192,6 +192,7 @@ async def init_pipeline_run(
         config_snapshot=body.config_snapshot,
         global_config=body.global_config,
         orchestrator=body.orchestrator,
+        orchestrator_run_id=body.orchestrator_run_id,
     )
     return InitRunResponse(run_id=run_id, token=token)
 

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/pipeline/schemas.py

@@ -244,6 +244,7 @@ class InitRunRequest(BaseModel):
     config_snapshot: dict[str, Any]
     global_config: dict[str, Any] = Field(default_factory=dict)
     orchestrator: str = "prefect"
+    orchestrator_run_id: str | None = None
 
 
 class InitRunResponse(BaseModel):

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/pipeline/service.py

@@ -315,6 +315,7 @@ class PipelineService:
         config_snapshot: dict[str, Any],
         global_config: dict[str, Any],
         orchestrator: str = "prefect",
+        orchestrator_run_id: str | None = None,
     ) -> tuple[str, str]:
         """Register a fresh pipeline run for a cron-triggered execution.
 
@@ -330,6 +331,8 @@ class PipelineService:
             global_config=global_config,
         )
         now = datetime.now(tz=UTC)
+        if orchestrator_run_id is not None:
+            await self._run_repo.set_orchestrator_run_id(run.id, orchestrator_run_id)
         await self._run_repo.update_status(run.id, "running", started_at=now)
 
         # Cron/scheduled per-execution runs may retry or run for days after the

{pulse_engine-0.2.26 → pulse_engine-0.2.27}/src/pulse_engine/runners/prefect_pipeline_flow.py

@@ -15,6 +15,8 @@ import asyncio
 import json
 import logging
 import os
+import re
+import uuid
 from collections import deque
 from collections.abc import Callable
 from typing import Any, TypeVar
@@ -521,6 +523,13 @@ async def _dispatch_vm(
     step_name = env.get("STEP_NAME", "unknown")
     pipeline_run_id_val = env.get("PIPELINE_RUN_ID", "unknown")
 
+    # Give the container a stable, greppable name instead of Docker's random
+    # adjective_scientist default, so it shows up correctly in log shipping
+    # (promtail relabels containers named "pulse-*" to job=pulse-engine-logs).
+    _name_safe = re.sub(r"[^a-zA-Z0-9_.-]", "-", f"{step_name}-{pipeline_run_id_val}")
+    _short_id = uuid.uuid4().hex[:8]
+    container_name = f"pulse-engine-{_name_safe}-{_short_id}"[:128]
+
     try:
         from pulse_engine.config import get_settings
 
@@ -608,6 +617,7 @@ async def _dispatch_vm(
         "subprocess.run(['docker', 'pull', image], check=True)\n"
         "docker_cmd = [\n"
         "    'docker', 'run', '--rm',\n"
+        f"    '--name', {repr(container_name)},\n"
         "    '--memory', f'{memory_mb}m',\n"
         "    '--cpus', str(cpu_count),\n"
         "]\n"
@@ -726,6 +736,16 @@ async def _dispatch_container(
 # ---------------------------------------------------------------------------
 
 
+def _current_flow_run_id() -> str | None:
+    """Best-effort Prefect flow-run id for the flow currently executing."""
+    try:
+        from prefect.runtime import flow_run
+
+        return str(flow_run.id) if flow_run.id else None
+    except Exception:
+        return None
+
+
 def _init_cron_run(
     pulse_engine_url: str,
     pulse_api_token: str,
@@ -744,6 +764,7 @@ def _init_cron_run(
             "product": product,
             "config_snapshot": config_snapshot,
             "global_config": global_config,
+            "orchestrator_run_id": _current_flow_run_id(),
         },
         headers={"Authorization": f"Bearer {pulse_api_token}"},
         timeout=30.0,