toposync-ext-streaming 0.7.10__tar.gz → 0.8.0__tar.gz

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/.gitignore

@@ -38,3 +38,4 @@ extensions/streaming/src/toposync_ext_streaming/bin/ffmpeg/**/ffmpeg*
 extensions/vision/models/
 
 *.temporary.*
+.playwright-mcp/*

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: toposync-ext-streaming
-Version: 0.7.10
+Version: 0.8.0
 Summary: Toposync first-party extension: streaming settings, API surface, and pipeline sink bootstrap.
 License-Expression: MIT
 License-File: LICENSE

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "toposync-ext-streaming"
-version = "0.7.10"
+version = "0.8.0"
 description = "Toposync first-party extension: streaming settings, API surface, and pipeline sink bootstrap."
 readme = "README.md"
 license = "MIT"

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/api/routes.py

@@ -5903,6 +5903,7 @@ async def _sync_pipeline_output_publication_nodes(
         graph = pipeline.graph if isinstance(pipeline.graph, dict) else {}
         nodes = graph.get("nodes") if isinstance(graph.get("nodes"), list) else []
         changed = False
+        publication_targets: dict[str, tuple[str, str, str]] = {}
         for node in nodes:
             if not isinstance(node, dict):
                 continue
@@ -5914,11 +5915,25 @@ async def _sync_pipeline_output_publication_nodes(
                 continue
             cfg = node.get("config") if isinstance(node.get("config"), dict) else {}
             expected_transmission_id = _publication_transmission_id(publication)
-            if str(cfg.get("transmission_id") or "").strip() == expected_transmission_id:
-                continue
-            next_cfg = {**cfg, "transmission_id": expected_transmission_id}
-            node["config"] = next_cfg
-            changed = True
+            expected_output_id = f"hls_{_publication_quality_profile(publication)}"
+            expected_quality_profile_id = _publication_quality_profile(publication)
+            publication_targets[node_id] = (
+                expected_transmission_id,
+                expected_output_id,
+                expected_quality_profile_id,
+            )
+            if str(cfg.get("transmission_id") or "").strip() != expected_transmission_id:
+                next_cfg = {**cfg, "transmission_id": expected_transmission_id}
+                node["config"] = next_cfg
+                changed = True
+        if publication_targets:
+            updated_gate_ids = _sync_demand_gates_for_publication_targets(
+                graph=graph,
+                nodes=nodes,
+                publication_targets=publication_targets,
+            )
+            if updated_gate_ids:
+                changed = True
         if not changed:
             continue
         updated = pipeline.model_copy(update={"graph": graph})
@@ -5937,6 +5952,87 @@ async def _sync_pipeline_output_publication_nodes(
     return changed_pipelines
 
 
+def _sync_demand_gates_for_publication_targets(
+    *,
+    graph: dict[str, Any],
+    nodes: list[Any],
+    publication_targets: dict[str, tuple[str, str, str]],
+) -> list[str]:
+    if not publication_targets:
+        return []
+    edges = graph.get("edges") if isinstance(graph.get("edges"), list) else []
+    downstream_by_node: dict[str, set[str]] = {}
+    for edge in edges:
+        if not isinstance(edge, dict):
+            continue
+        source = edge.get("from")
+        target = edge.get("to")
+        if not isinstance(source, dict) or not isinstance(target, dict):
+            continue
+        source_node = str(source.get("node") or "").strip()
+        target_node = str(target.get("node") or "").strip()
+        if not source_node or not target_node:
+            continue
+        downstream_by_node.setdefault(source_node, set()).add(target_node)
+
+    changed_gate_ids: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        if str(node.get("operator") or "").strip() != "stream.demand_gate":
+            continue
+        gate_id = str(node.get("id") or "").strip()
+        if not gate_id:
+            continue
+        reachable_publications = [
+            publish_node_id
+            for publish_node_id in publication_targets
+            if _graph_node_reaches(gate_id, publish_node_id, downstream_by_node)
+        ]
+        if len(reachable_publications) != 1:
+            continue
+        transmission_id, output_id, quality_profile_id = publication_targets[reachable_publications[0]]
+        cfg = node.get("config") if isinstance(node.get("config"), dict) else {}
+        demand_scope = str(cfg.get("demand_scope") or "").strip().lower()
+        use_specific_output = demand_scope == "output"
+        next_cfg = {**cfg, "transmission_id": transmission_id}
+        if use_specific_output:
+            next_cfg["demand_scope"] = "output"
+            next_cfg["output_id"] = str(cfg.get("output_id") or "").strip() or output_id
+            next_cfg["quality_profile_id"] = str(cfg.get("quality_profile_id") or "").strip() or quality_profile_id
+        else:
+            next_cfg["demand_scope"] = "transmission"
+            next_cfg["output_id"] = ""
+            next_cfg["quality_profile_id"] = ""
+        if next_cfg == cfg:
+            continue
+        node["config"] = next_cfg
+        changed_gate_ids.append(gate_id)
+    return changed_gate_ids
+
+
+def _graph_node_reaches(
+    source_node_id: str,
+    target_node_id: str,
+    downstream_by_node: dict[str, set[str]],
+) -> bool:
+    if source_node_id == target_node_id:
+        return True
+    seen: set[str] = set()
+    stack = [source_node_id]
+    while stack:
+        current = stack.pop()
+        if current in seen:
+            continue
+        seen.add(current)
+        for child in downstream_by_node.get(current, set()):
+            if child == target_node_id:
+                return True
+            if child not in seen:
+                stack.append(child)
+    return False
+
+
 async def _delete_camera_live_pipelines(
     *,
     request: Request,

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/pipelines/operators.py

@@ -8,7 +8,7 @@ import numpy
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from toposync.runtime.pipelines.execution import PipelineRuntimeDependencies, SinkRuntime, SourceOperatorRuntime
-from toposync.runtime.pipelines.images import normalize_artifact_name
+from toposync.runtime.pipelines.images import MAIN_ARTIFACT_NAME, normalize_artifact_name
 from toposync.runtime.pipelines.operator_registry import OperatorDiagnostic, OperatorRegistry
 from toposync.runtime.pipelines.packet_contract import resolve_media_ts
 from toposync.runtime.pipelines.runtime import Lifecycle, Packet
@@ -85,11 +85,30 @@ class DemandGateConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     transmission_id: str = ""
+    demand_scope: Literal["transmission", "output"] = "transmission"
     output_id: str = ""
     quality_profile_id: str = ""
     poll_interval_ms: int = Field(default=500, ge=100, le=10_000)
     fail_open: bool = True
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_legacy_scope(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        data = dict(value)
+        scope = str(data.get("demand_scope") or "").strip().lower()
+        if scope == "auto":
+            scope = "transmission"
+        if scope not in {"transmission", "output"}:
+            has_specific_output = bool(
+                str(data.get("output_id") or "").strip()
+                or str(data.get("quality_profile_id") or "").strip()
+            )
+            scope = "output" if has_specific_output else "transmission"
+        data["demand_scope"] = scope
+        return data
+
     @field_validator("transmission_id", "output_id", "quality_profile_id", mode="after")
     @classmethod
     def _trim(cls, value: str) -> str:
@@ -147,10 +166,11 @@ class DemandGateRuntime(SourceOperatorRuntime):
         self._last_open = is_open
         self._last_payload = payload
         lifecycle = Lifecycle.OPEN if is_open else Lifecycle.CLOSE
+        output_id, quality_profile_id = self._selected_demand_target()
         stream_id = _demand_gate_stream_id(
             self._config.transmission_id,
-            output_id=self._config.output_id,
-            quality_profile_id=self._config.quality_profile_id,
+            output_id=output_id,
+            quality_profile_id=quality_profile_id,
         )
         return Packet.create(
             stream_id=stream_id,
@@ -158,8 +178,9 @@ class DemandGateRuntime(SourceOperatorRuntime):
             payload={
                 "gate_open": bool(is_open),
                 "transmission_id": self._config.transmission_id,
-                "output_id": self._config.output_id,
-                "quality_profile_id": self._config.quality_profile_id,
+                "demand_scope": self._config.demand_scope,
+                "output_id": output_id,
+                "quality_profile_id": quality_profile_id,
                 **payload,
             },
         )
@@ -175,11 +196,12 @@ class DemandGateRuntime(SourceOperatorRuntime):
                 "reason": "services_unavailable",
             }
         try:
+            output_id, quality_profile_id = self._selected_demand_target()
             raw = await services.call(
                 "streaming.demand.snapshot",
                 transmission_id=self._config.transmission_id,
-                output_id=self._config.output_id,
-                quality_profile_id=self._config.quality_profile_id,
+                output_id=output_id,
+                quality_profile_id=quality_profile_id,
             )
         except Exception as exc:  # noqa: BLE001
             return bool(self._config.fail_open), {
@@ -199,6 +221,11 @@ class DemandGateRuntime(SourceOperatorRuntime):
             "matched_outputs": int(snapshot.get("matched_outputs") or 0),
         }
 
+    def _selected_demand_target(self) -> tuple[str, str]:
+        if self._config.demand_scope != "output":
+            return "", ""
+        return self._config.output_id, self._config.quality_profile_id
+
 
 def register_streaming_pipeline_operators(registry: OperatorRegistry) -> None:
     if registry.get("stream.demand_gate") is None:
@@ -227,6 +254,7 @@ def register_streaming_pipeline_operators(registry: OperatorRegistry) -> None:
         capabilities=["streaming", "sink", "realtime"],
         defaults=PublishVideoConfig(publication_enabled=True).model_dump(mode="json"),
         share_strategy="never",
+        requires_artifacts=[MAIN_ARTIFACT_NAME],
         requires_media_fields=["ts", "width", "height"],
         input_modalities=["video"],
         owner=EXTENSION_ID,

{toposync_ext_streaming-0.7.10 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/wizard/pipeline_builder.py

@@ -91,6 +91,15 @@ def build_streaming_wizard_graph(
     demand_gate_fail_open = _coerce_bool(options.get("demand_gate_fail_open"), default=True)
     demand_gate_output_id = _safe_text(options.get("demand_gate_output_id"))
     demand_gate_quality_profile_id = _safe_text(options.get("demand_gate_quality_profile_id"))
+    demand_gate_scope_default = "output" if demand_gate_output_id or demand_gate_quality_profile_id else "transmission"
+    demand_gate_scope = _pick_choice(
+        options.get("demand_gate_scope"),
+        allowed={"transmission", "output"},
+        default=demand_gate_scope_default,
+    )
+    if demand_gate_scope != "output":
+        demand_gate_output_id = ""
+        demand_gate_quality_profile_id = ""
     demand_gate_poll_interval_ms = _coerce_int(
         options.get("demand_gate_poll_interval_ms"),
         default=500,
@@ -144,6 +153,7 @@ def build_streaming_wizard_graph(
                 "operator": "stream.demand_gate",
                 "config": {
                     "transmission_id": transmission_id,
+                    "demand_scope": demand_gate_scope,
                     "output_id": demand_gate_output_id,
                     "quality_profile_id": demand_gate_quality_profile_id,
                     "poll_interval_ms": int(demand_gate_poll_interval_ms),