videopython 0.50.0__tar.gz → 0.50.1__tar.gz

{videopython-0.50.0 → videopython-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.50.0
+Version: 0.50.1
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/

{videopython-0.50.0 → videopython-0.50.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.50.0"
+version = "0.50.1"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },

{videopython-0.50.0 → videopython-0.50.1}/src/videopython/ai/_ollama.py

@@ -7,6 +7,7 @@ import io
 import json
 from typing import Any
 
+import cv2
 import numpy as np
 from PIL import Image
 
@@ -65,6 +66,20 @@ class OllamaStructuredClient:
         self._client = None
 
 
+# Used only on the MCP keyframe path (videopython.mcp). SceneVLM captioning and the local
+# planner deliberately encode full-resolution frames via _encode_png_b64.
+KEYFRAME_MAX_DIM = 768  # bound a keyframe's longest side before PNG-encoding for the MCP payload
+
+
+def _downscale(frame: np.ndarray, max_dim: int = KEYFRAME_MAX_DIM) -> np.ndarray:
+    """Shrink an RGB frame so its longest side is at most ``max_dim`` (aspect preserved; never upscales)."""
+    h, w = frame.shape[:2]
+    scale = max_dim / max(h, w)
+    if scale >= 1.0:
+        return frame
+    return cv2.resize(frame, (max(1, round(w * scale)), max(1, round(h * scale))), interpolation=cv2.INTER_AREA)
+
+
 def _encode_png_b64(frame: np.ndarray) -> str:
     buffer = io.BytesIO()
     Image.fromarray(frame).save(buffer, format="PNG")

{videopython-0.50.0 → videopython-0.50.1}/src/videopython/ai/video_analysis/models.py

@@ -173,6 +173,18 @@ class VideoAnalysisConfig(BaseModel):
         """Backward-compatible alias for the default config."""
         return cls()
 
+    @classmethod
+    def for_profile(cls, profile: str, *, faces: bool = True) -> VideoAnalysisConfig:
+        """Config for an analysis profile: 'full' (all analyzers) or 'editing' (catalog-only, no audio classifier)."""
+        if profile == "full":
+            return cls()
+        if profile == "editing":
+            enabled = {SEMANTIC_SCENE_DETECTOR, SCENE_VLM, AUDIO_TO_TEXT}
+            if faces:
+                enabled.add(FACE_TRACKER)
+            return cls(enabled_analyzers=enabled)
+        raise ValueError(f"Unknown profile: {profile!r} (expected 'full' or 'editing')")
+
 
 class AudioAnalysisSection(BaseModel):
     """Audio understanding outputs."""

{videopython-0.50.0 → videopython-0.50.1}/src/videopython/mcp/server.py

@@ -13,13 +13,13 @@ import json
 import sys
 from contextlib import redirect_stdout
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from mcp.server.fastmcp import FastMCP
 from mcp.types import ImageContent, TextContent
 from pydantic import ValidationError
 
-from videopython.ai._ollama import _encode_png_b64
+from videopython.ai._ollama import _downscale, _encode_png_b64
 from videopython.ai.auto_edit import EditPlan, UnknownSceneIdsError, resolve_plan
 from videopython.ai.auto_edit import build_catalog as _build_scene_catalog
 from videopython.editing import VideoEdit
@@ -33,20 +33,24 @@ mcp = FastMCP("videopython")
 
 # Session state for one stdio client (one process per client).
 _analyses: dict[str, VideoAnalysis] = {}
-_analyzer: VideoAnalyzer | None = None
+_analyzers: dict[str, VideoAnalyzer] = {}
 _bundle: CatalogBundle | None = None
 
+_MAX_INLINE_KEYFRAMES = 12  # cap inlined keyframes in build_catalog; pull the rest with scene_keyframes
+
 
 @mcp.tool()
-def analyze_video(path: str) -> dict[str, Any]:
+def analyze_video(path: str, profile: Literal["full", "editing"] = "full") -> dict[str, Any]:
     """Analyze a source video (scenes, transcript, captions) and cache it for build_catalog.
 
-    Returns a short summary; call this once per source, then build_catalog.
+    ``profile="editing"`` skips audio classification (faster on long sources); the
+    catalog (captions + transcript + face flag) is unaffected. Returns a short
+    summary; call this once per source, then build_catalog.
     """
     # Heavy analyzer deps (e.g. transnetv2-pytorch) bare-print to stdout, which here is
     # the stdio JSON-RPC channel; send that to stderr so the transport stays clean.
     with redirect_stdout(sys.stderr):
-        analysis = _get_analyzer().analyze_path(path)
+        analysis = _get_analyzer(profile).analyze_path(path)
     _analyses[str(Path(path))] = analysis
     src = analysis.source
     return {
@@ -63,10 +67,11 @@ def analyze_video(path: str) -> dict[str, Any]:
 def build_catalog(sources: list[str] | None = None) -> list[TextContent | ImageContent]:
     """Build the candidate-scene catalog from analyzed videos and cache it.
 
-    Returns the catalog as JSON text plus one keyframe image per scene (each
-    preceded by its scene id), so the model can see the footage. Pass ``sources``
-    to restrict to specific analyzed paths, or omit for all. Author the edit by
-    referencing the returned ``id`` values via the edit-plan schema resource.
+    The first text block is the full catalog JSON (id/duration/shot_type/caption/
+    transcript per scene -- enough to shortlist from text alone). Up to
+    ``_MAX_INLINE_KEYFRAMES`` downscaled keyframes follow; a final note names any
+    scene ids whose images were omitted (fetch them with scene_keyframes). Pass
+    ``sources`` to restrict to specific analyzed paths, or omit for all.
     """
     global _bundle
     analyses = _selected_analyses(sources)
@@ -74,15 +79,36 @@ def build_catalog(sources: list[str] | None = None) -> list[TextContent | ImageC
         raise ValueError("No analyzed videos cached; call analyze_video first.")
     _bundle = _build_scene_catalog(analyses)
 
-    blocks: list[TextContent | ImageContent] = [TextContent(type="text", text=_bundle.catalog.model_dump_json())]
-    for scene in _bundle.catalog.scenes:
-        frame = _bundle.keyframes.get(scene.id)
-        if frame is not None:
-            blocks.append(TextContent(type="text", text=f"scene {scene.id}:"))
-            blocks.append(ImageContent(type="image", data=_encode_png_b64(frame), mimeType="image/png"))
+    ids = [scene.id for scene in _bundle.catalog.scenes]
+    inlined, omitted = ids[:_MAX_INLINE_KEYFRAMES], ids[_MAX_INLINE_KEYFRAMES:]
+    blocks: list[TextContent | ImageContent] = [
+        TextContent(type="text", text=_bundle.catalog.model_dump_json()),
+        *_keyframe_blocks(inlined),
+    ]
+    if omitted:
+        blocks.append(
+            TextContent(
+                type="text",
+                text=f"Keyframes omitted for {len(omitted)} scenes "
+                f"(call scene_keyframes for these ids): {', '.join(omitted)}",
+            )
+        )
     return blocks
 
 
+@mcp.tool(structured_output=False)
+def scene_keyframes(scene_ids: list[str]) -> list[TextContent | ImageContent]:
+    """Return downscaled keyframe images for specific catalog scene ids (use after build_catalog)."""
+    if _bundle is None:
+        raise ValueError("No catalog cached; call build_catalog first.")
+    known = _bundle.catalog.by_id()
+    unknown = sorted({sid for sid in scene_ids if sid not in known})
+    if unknown:
+        error = {"code": "unknown_scene_ids", "value": unknown, "message": f"Unknown scene ids: {unknown}"}
+        return [TextContent(type="text", text=json.dumps(error))]
+    return _keyframe_blocks(list(dict.fromkeys(scene_ids)))
+
+
 @mcp.tool()
 def validate_edit(plan: dict[str, Any]) -> dict[str, Any]:
     """Validate an edit plan (an EditPlan referencing catalog scene ids).
@@ -146,13 +172,12 @@ def edit_plan_schema() -> str:
     return json.dumps(EditPlan.json_schema(strict=True))
 
 
-def _get_analyzer() -> VideoAnalyzer:
-    global _analyzer
-    if _analyzer is None:
-        from videopython.ai.video_analysis import VideoAnalyzer
+def _get_analyzer(profile: str = "full") -> VideoAnalyzer:
+    if profile not in _analyzers:
+        from videopython.ai.video_analysis import VideoAnalysisConfig, VideoAnalyzer
 
-        _analyzer = VideoAnalyzer()
-    return _analyzer
+        _analyzers[profile] = VideoAnalyzer(config=VideoAnalysisConfig.for_profile(profile))
+    return _analyzers[profile]
 
 
 def _selected_analyses(sources: list[str] | None) -> list[VideoAnalysis]:
@@ -161,6 +186,17 @@ def _selected_analyses(sources: list[str] | None) -> list[VideoAnalysis]:
     return [_analyses[str(Path(s))] for s in sources if str(Path(s)) in _analyses]
 
 
+def _keyframe_blocks(scene_ids: list[str]) -> list[TextContent | ImageContent]:
+    assert _bundle is not None  # callers guard; narrows the module global for mypy
+    blocks: list[TextContent | ImageContent] = []
+    for sid in scene_ids:
+        frame = _bundle.keyframes.get(sid)
+        if frame is not None:
+            blocks.append(TextContent(type="text", text=f"scene {sid}:"))
+            blocks.append(ImageContent(type="image", data=_encode_png_b64(_downscale(frame)), mimeType="image/png"))
+    return blocks
+
+
 def _resolve(plan: dict[str, Any]) -> tuple[VideoEdit | None, list[dict[str, Any]]]:
     """Resolve a by-id plan, or return (None, structured errors) for the agent's plan mistakes."""
     if _bundle is None: