vrex-flow-engine 0.3.1__tar.gz → 0.3.2__tar.gz

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vrex-flow-engine
-Version: 0.3.1
+Version: 0.3.2
 Summary: Launcher + supervisor and OpenAI-compatible image/video generation service (Vrex Flow Engine).
 Author: Vrex
 License: Proprietary

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/flow_engine/bridge/flow_rpc.py

@@ -29,6 +29,7 @@ RPC_GENERATE_IMAGE = "ogiZ0b"
 RPC_GENERATE_VIDEO_T2V = "YhhmEf"
 RPC_GENERATE_VIDEO_I2V = "eb1hJf"
 RPC_GENERATE_VIDEO_R2V = "MZZa6b"
+RPC_GENERATE_VIDEO_INTERPOLATION = "nprQif"
 RPC_GENERATE_VIDEO = RPC_GENERATE_VIDEO_T2V  # historical alias
 RPC_CHECK_MEDIA = "jwpduf"
 RPC_GET_MEDIA = "as29s"
@@ -169,6 +170,27 @@ def video_request_item_i2v(
     ]
 
 
+def video_request_item_interpolation(
+    prompt: str,
+    model_key: str,
+    aspect_enum: int,
+    start_media_id: str,
+    end_media_id: str,
+    seed: Optional[int] = None,
+    crop: Optional[list[Any]] = None,
+) -> list[Any]:
+    """Frames-to-video item (``nprQif``): the i2v item with the end frame in
+    the slot before the metadata — ``[textInput, modelKey, aspect, seed,
+    startImage, endImage, metadata]``. Passing the same media id for both
+    frames yields a clip that ends where it began (a seamless loop)."""
+    return [
+        _text_input(prompt), model_key, aspect_enum, seed,
+        [None, start_media_id, None, None, None, crop],
+        [None, end_media_id, None, None, None, crop],
+        _item_metadata(),
+    ]
+
+
 def video_request_item_r2v(
     prompt: str,
     model_key: str,

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/flow_engine/bridge/flow_sdk.py

@@ -5,10 +5,10 @@ and the job debug endpoint can inspect Flow's payload when a shape drifts.
 
 Wired from flow.google.com captures (2026-09): project list/create, model
 catalog, credits/tier, preset voices, image upload (inline) and resumable
-video upload, image generation (sync), text-/image-/reference-to-video,
-media status polling and signed URL resolution. Frame interpolation, extend
-and edit still need their batchexecute payload captured — the videos route
-answers 501 for them instead of guessing array positions.
+video upload, image generation (sync), text-/image-/reference-to-video and
+frames-to-video (interpolation), media status polling and signed URL
+resolution. Extend and edit still need their batchexecute payload captured —
+the videos route answers 501 for them instead of guessing array positions.
 """
 from __future__ import annotations
 
@@ -350,6 +350,49 @@ class FlowSDK:
         ]
         return await self._dispatch_video(flow_rpc.RPC_GENERATE_VIDEO_I2V, items, project_id, scene_id)
 
+    async def gen_video_interpolation(
+        self,
+        prompt: str,
+        project_id: str,
+        start_media_ids: list[str],
+        end_media_ids: Optional[list[str]] = None,
+        aspect_ratio: str = "VIDEO_ASPECT_RATIO_LANDSCAPE",
+        paygate_tier: Optional[int] = None,
+        seed: Optional[int] = None,
+        model_key: Optional[str] = None,
+        scene_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Frames-to-video: motion between a start and an end frame, one clip
+        per pair. ``end_media_ids`` defaults to ``start_media_ids`` — the
+        seamless-loop case; when both are given they are zipped pairwise and
+        must be the same length."""
+        if paygate_tier is None:
+            raise ValueError("paygate_tier is required — resolve the account first")
+        if not model_key:
+            return {"raw": None, "error": "interpolation_model_key_required"}
+        aspect_enum = flow_rpc.VIDEO_ASPECT_ENUM.get(aspect_ratio)
+        if aspect_enum is None:
+            return {"raw": None, "error": f"interpolation_aspect_unsupported_{aspect_ratio}"}
+        starts = [m for m in (start_media_ids or []) if isinstance(m, str) and m]
+        if not starts:
+            return {"raw": None, "error": "missing_start_media_id"}
+        ends = [m for m in (end_media_ids or []) if isinstance(m, str) and m] or list(starts)
+        if len(ends) != len(starts):
+            return {
+                "raw": None,
+                "error": (
+                    f"start/end frame count mismatch: {len(starts)} start vs "
+                    f"{len(ends)} end — pass equal-length lists or omit end frames"
+                ),
+            }
+        items = [
+            flow_rpc.video_request_item_interpolation(prompt, model_key, aspect_enum, s, e, seed=seed)
+            for s, e in list(zip(starts, ends))[:MAX_VARIANT_COUNT]
+        ]
+        return await self._dispatch_video(
+            flow_rpc.RPC_GENERATE_VIDEO_INTERPOLATION, items, project_id, scene_id
+        )
+
     async def gen_video_r2v(
         self,
         prompt: str,

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/flow_engine/catalog.py

@@ -33,10 +33,9 @@ _CACHE_FILE = STORAGE_DIR / "catalog.json"
 _CACHE_VERSION = 2
 
 # Modes whose batchexecute payload has been captured and verified. Other modes
-# (interpolation, extension, edit, upsample) still resolve a key so the error
-# can name it, but resolve() reports them as not dispatchable and the route
-# answers 501.
-_DISPATCHABLE_MODES: frozenset[str] = frozenset({"t2v", "i2v", "r2v"})
+# (extension, edit, upsample) still resolve a key so the error can name it,
+# but resolve() reports them as not dispatchable and the route answers 501.
+_DISPATCHABLE_MODES: frozenset[str] = frozenset({"t2v", "i2v", "r2v", "interpolation"})
 
 
 class _Catalog:

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/flow_engine/jobs.py

@@ -60,6 +60,7 @@ _DISPATCH = {
     "t2v": "gen_video_t2v",
     "i2v": "gen_video",
     "r2v": "gen_video_r2v",
+    "interpolation": "gen_video_interpolation",
 }
 
 

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/flow_engine/openai/videos.py

@@ -15,13 +15,9 @@ The generation MODE is inferred from the inputs you provide:
   - ``start_media_ids`` / ``start_images`` → image-to-video    (i2v, "Frames")
   - neither                                → text-to-video     (t2v, prompt only)
 
-Text-, image- and reference-to-video have captured flow.google.com payloads.
-Interpolation with explicit end frames, ``mode: extend|edit`` and r2v
-``reference_audio`` answer HTTP 501 until their request is recorded and
-ported (see flow-engine/README.md). ``loop: true`` — a seamless loop, which
-is interpolation from the start frame back to itself — is served as plain
-image-to-video meanwhile: the caller still gets motion behind its still, only
-the last-frame match is lost, and the response says so via ``degraded``.
+Text-, image-, reference- and frames-to-video have captured flow.google.com
+payloads. ``mode: extend|edit`` and r2v ``reference_audio`` answer HTTP 501
+until their request is recorded and ported (see flow-engine/README.md).
 """
 from __future__ import annotations
 
@@ -42,7 +38,7 @@ router = APIRouter(prefix="/v1/videos", tags=["videos"])
 ALLOWED_VIDEO_MODEL = "veo_3_1_lite_low_priority"
 
 # Modes with a verified flow.google.com payload.
-SUPPORTED_MODES = frozenset({"t2v", "i2v", "r2v"})
+SUPPORTED_MODES = frozenset({"t2v", "i2v", "r2v", "interpolation"})
 
 
 class VideoRequest(BaseModel):
@@ -73,44 +69,29 @@ class VideoRequest(BaseModel):
     source_seconds: Optional[int] = None            # edit: source clip length (→ frames)
 
 
-# Marker returned in the create response when a request was served in a
-# weaker mode than it asked for.
-LOOP_DEGRADED = "loop_unavailable_served_as_i2v"
-
-
-def _select_mode(req: VideoRequest) -> tuple[str, Optional[str]]:
+def _select_mode(req: VideoRequest) -> str:
     """Pick the generation mode from the request shape (explicit ``mode`` wins).
-
-    Returns ``(mode, degraded)`` — ``degraded`` names the downgrade applied
-    (currently only ``LOOP_DEGRADED``) or is None.
-    """
+    ``loop`` is sugar for "end frame is the start frame", i.e. interpolation."""
     explicit = (req.mode or "").lower().strip()
     if explicit in ("extend", "extension"):
-        return "extension", None
+        return "extension"
     if explicit == "edit":
-        return "edit", None
+        return "edit"
     has_ref = bool(req.ref_media_ids or req.ref_images)
     has_start = bool(req.start_media_ids or req.start_images)
-    explicit_end = bool(req.end_media_ids or req.end_images)
+    has_end = bool(req.end_media_ids or req.end_images) or (req.loop and has_start)
     if has_ref:
-        return "r2v", None
-    if has_start and explicit_end:
-        return "interpolation", None
-    if has_start and req.loop:
-        if "interpolation" in SUPPORTED_MODES:
-            return "interpolation", None
-        # A seamless loop is interpolation from the start frame back to itself.
-        # That payload is not captured yet, so keep the caller moving with an
-        # ordinary clip from the same frame and say so in the response.
-        return "i2v", LOOP_DEGRADED
+        return "r2v"
+    if has_start and has_end:
+        return "interpolation"
     if has_start:
-        return "i2v", None
-    if explicit_end:
+        return "i2v"
+    if has_end:
         raise HTTPException(
             status_code=400,
             detail="end frames require start frames — pass start_images/start_media_ids",
         )
-    return "t2v", None
+    return "t2v"
 
 
 def _job_view(job: jobs.Job) -> dict[str, Any]:
@@ -148,7 +129,7 @@ async def create_video(
             detail=f"only model={ALLOWED_VIDEO_MODEL!r} is supported",
         )
 
-    mode, degraded = _select_mode(req)
+    mode = _select_mode(req)
     if mode not in SUPPORTED_MODES or (mode == "r2v" and req.reference_audio):
         # Decided before any upload so a caller never pays for reference
         # ingestion on a request that cannot be dispatched.
@@ -185,10 +166,16 @@ async def create_video(
         ref_ids = list(req.ref_media_ids or [])
         ref_ids += await ingest.resolve_image_inputs(sdk, project_id, req.ref_images)
         kwargs["ref_media_ids"] = ref_ids
-    elif mode == "i2v":
+    elif mode in ("i2v", "interpolation"):
         start_ids = list(req.start_media_ids or [])
         start_ids += await ingest.resolve_image_inputs(sdk, project_id, req.start_images)
         kwargs["start_media_ids"] = start_ids
+        if mode == "interpolation":
+            end_ids = list(req.end_media_ids or [])
+            end_ids += await ingest.resolve_image_inputs(sdk, project_id, req.end_images)
+            # `loop` = end frame is the start frame; gen_video_interpolation
+            # defaults to that when no end frames are given.
+            kwargs["end_media_ids"] = end_ids or None
 
     try:
         job = jobs.start_video_job(
@@ -213,9 +200,6 @@ async def create_video(
     view["model"] = req.model
     view["model_key"] = model_key
     view["mode"] = mode
-    if degraded:
-        view["degraded"] = degraded
-        view["loop"] = False
     return view
 
 

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vrex-flow-engine"
-version = "0.3.1"
+version = "0.3.2"
 description = "Launcher + supervisor and OpenAI-compatible image/video generation service (Vrex Flow Engine)."
 # Neutral public description (the in-repo README.md carries the full internal docs).
 readme = "PYPI_README.md"

{vrex_flow_engine-0.3.1 → vrex_flow_engine-0.3.2}/vrex_flow_engine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vrex-flow-engine
-Version: 0.3.1
+Version: 0.3.2
 Summary: Launcher + supervisor and OpenAI-compatible image/video generation service (Vrex Flow Engine).
 Author: Vrex
 License: Proprietary