videopython 0.48.0__tar.gz → 0.49.0__tar.gz

{videopython-0.48.0 → videopython-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.48.0
+Version: 0.49.0
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
@@ -28,13 +28,10 @@ Requires-Dist: chatterbox-tts>=0.1.7; extra == 'ai'
 Requires-Dist: demucs>=4.0.0; extra == 'ai'
 Requires-Dist: diffusers>=0.30.0; extra == 'ai'
 Requires-Dist: imagehash>=4.3; extra == 'ai'
-Requires-Dist: llama-cpp-python>=0.3.0; extra == 'ai'
 Requires-Dist: ollama>=0.5.0; extra == 'ai'
 Requires-Dist: openai-whisper>=20240930; extra == 'ai'
 Requires-Dist: pyannote-audio>=4.0.0; extra == 'ai'
 Requires-Dist: pyloudnorm>=0.1.1; extra == 'ai'
-Requires-Dist: qwen-vl-utils>=0.0.10; extra == 'ai'
-Requires-Dist: sentencepiece>=0.1.99; extra == 'ai'
 Requires-Dist: silero-vad>=5.1; extra == 'ai'
 Requires-Dist: torch>=2.8.0; extra == 'ai'
 Requires-Dist: torchaudio>=2.8.0; extra == 'ai'

{videopython-0.48.0 → videopython-0.49.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.48.0"
+version = "0.49.0"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },
@@ -72,13 +72,9 @@ ai = [
     "ultralytics>=8.0.0",
     "transnetv2-pytorch>=1.0.5",
     "transformers>=5.2.0",
-    "qwen-vl-utils>=0.0.10",
     "imagehash>=4.3",
     # Audio source separation (understanding/separation.py)
     "demucs>=4.0.0",
-    # Translation backends (generation/translation.py MarianMT, generation/qwen3.py GGUF)
-    "sentencepiece>=0.1.99",
-    "llama-cpp-python>=0.3.0",
     # Voice cloning TTS (generation/audio.py — Chatterbox); its strict pins drive
     # the [tool.uv].override-dependencies block below.
     "chatterbox-tts>=0.1.7",
@@ -120,9 +116,7 @@ module = [
     "pyannote", "pyannote.*",
     "silero_vad", "silero_vad.*",
     "cv2", "cv2.*",
-    "llama_cpp", "llama_cpp.*",
     "pyloudnorm", "pyloudnorm.*",
-    "qwen_vl_utils", "qwen_vl_utils.*",
     "imagehash", "imagehash.*",
 ]
 ignore_missing_imports = true

videopython-0.49.0/src/videopython/ai/_ollama.py

@@ -0,0 +1,71 @@
+"""Shared structured-generation client over a local Ollama server."""
+
+from __future__ import annotations
+
+import base64
+import io
+import json
+from typing import Any
+
+import numpy as np
+from PIL import Image
+
+from videopython.ai._optional import require
+
+
+class OllamaError(RuntimeError):
+    """Ollama returned unusable output (non-JSON or an unexpected shape)."""
+
+
+class OllamaStructuredClient:
+    """Generate schema-constrained JSON from text + optional images via Ollama.
+
+    Shared by the auto-edit planner, scene captioner, and translator. The model
+    must be served by a local Ollama daemon and support structured-output
+    ``format`` (and vision, when images are passed); ``options`` are extra Ollama
+    generation options merged over ``temperature=0``.
+    """
+
+    def __init__(self, model: str, *, host: str | None = None, options: dict[str, Any] | None = None) -> None:
+        self.model = model
+        self.host = host
+        self.options: dict[str, Any] = {"temperature": 0.0, **(options or {})}
+        self._client: Any = None
+
+    def _get_client(self) -> Any:
+        if self._client is None:
+            ollama = require("ollama", "ai", feature="Ollama")
+            self._client = ollama.Client(host=self.host)
+        return self._client
+
+    def generate_json(
+        self,
+        *,
+        system: str,
+        text: str,
+        schema: dict[str, Any],
+        images: list[np.ndarray] | None = None,
+    ) -> dict[str, Any]:
+        """Return the parsed JSON object Ollama generates under ``schema``."""
+        user: dict[str, Any] = {"role": "user", "content": text}
+        if images:
+            user["images"] = [_encode_png_b64(image) for image in images]
+        messages = [{"role": "system", "content": system}, user]
+        response = self._get_client().chat(model=self.model, messages=messages, format=schema, options=self.options)
+        content = response.message.content
+        try:
+            data = json.loads(content)
+        except (ValueError, TypeError) as exc:
+            raise OllamaError(f"Ollama returned non-JSON output: {content!r}") from exc
+        if not isinstance(data, dict):
+            raise OllamaError(f"Ollama returned a non-object JSON value: {type(data).__name__}")
+        return data
+
+    def unload(self) -> None:
+        self._client = None
+
+
+def _encode_png_b64(frame: np.ndarray) -> str:
+    buffer = io.BytesIO()
+    Image.fromarray(frame).save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode("ascii")

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/_revisions.py

@@ -41,11 +41,6 @@ Usage:
 #     from the HF repo ``arnabdhar/YOLOv8-Face-Detection`` via
 #     hf_hub_download, and that one IS pinned below.)
 #
-#   * Dynamic Marian pairs -- ai/generation/translation.py builds the model
-#     name per language pair at runtime (e.g. "Helsinki-NLP/opus-mt-en-de").
-#     The set of repos is open-ended (one per direction), so pinning each pair
-#     to a SHA is impractical and out of scope; left unpinned by design.
-#
 #   * Chatterbox internal load -- ai/generation/audio.py calls
 #     ``ChatterboxMultilingualTTS.from_pretrained(device=...)`` with no repo
 #     argument. The repo id + revision are resolved internally by the
@@ -67,10 +62,6 @@ from __future__ import annotations
 # ``pinned(model_id)`` resolves with a plain dict lookup. SHAs captured from
 # the HuggingFace model API (see module docstring for refresh instructions).
 MODEL_REVISIONS: dict[str, str] = {
-    # SceneVLM (ai/understanding/image.py: SCENE_VLM_MODEL_IDS)
-    "Qwen/Qwen3.5-4B": "851bf6e806efd8d0a36b00ddf55e13ccb7b8cd0a",
-    "Qwen/Qwen3.5-9B": "c202236235762e1c871ad0ccb60c8ee5ba337b9a",
-    "Qwen/Qwen3.5-27B": "fc05daec18b0a78c049392ed2e771dde82bdf654",
     # Speaker diarization (ai/understanding/audio.py: PYANNOTE_DIARIZATION_MODEL).
     # Gated repo (auto-approved); from_pretrained needs an accepted HF token.
     "pyannote/speaker-diarization-community-1": "3533c8cf8e369892e6b79ff1bf80f7b0286a54ee",
@@ -78,8 +69,6 @@ MODEL_REVISIONS: dict[str, str] = {
     "MIT/ast-finetuned-audioset-10-10-0.4593": "f826b80d28226b62986cc218e5cec390b1096902",
     # Face detection checkpoint (ai/understanding/faces.py: hf_hub_download)
     "arnabdhar/YOLOv8-Face-Detection": "52fa54977207fa4f021de949b515fb19dcab4488",
-    # Qwen3 translation GGUF (ai/generation/qwen3.py: DEFAULT_REPO_ID)
-    "unsloth/Qwen3-4B-Instruct-2507-GGUF": "a06e946bb6b655725eafa393f4a9745d460374c9",
     # MusicGen (ai/generation/audio.py: TextToMusic)
     "facebook/musicgen-small": "4c8334b02c6ec4e8664a91979669a501ec497792",
     # SDXL (ai/generation/image.py: TextToImage)

videopython-0.49.0/src/videopython/ai/auto_edit/local.py

@@ -0,0 +1,39 @@
+"""A local, model-agnostic planner backed by an Ollama server."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from videopython.ai._ollama import OllamaError, OllamaStructuredClient
+
+from .backend import ImagePart, Part, PlannerError, TextPart
+
+DEFAULT_OLLAMA_MODEL = "gemma3:27b"
+
+
+class OllamaVisionLLM:
+    """A StructuredVisionLLM backed by a local Ollama server.
+
+    The model must be vision-capable (it is sent keyframes) AND support Ollama's
+    structured-output ``format`` (the EditPlan schema constrains the decode). Not
+    every model supports schema conditioning -- ``gemma3:27b`` is verified working;
+    some builds (e.g. certain MLX ones) fail it. ``ollama pull <model>`` first;
+    ``options`` are extra generation options merged over ``temperature=0``.
+    """
+
+    def __init__(
+        self,
+        model: str = DEFAULT_OLLAMA_MODEL,
+        *,
+        host: str | None = None,
+        options: dict[str, Any] | None = None,
+    ) -> None:
+        self._client = OllamaStructuredClient(model=model, host=host, options=options)
+
+    def generate_json(self, *, system: str, parts: list[Part], schema: dict[str, Any]) -> dict[str, Any]:
+        text = "\n\n".join(part.text for part in parts if isinstance(part, TextPart))
+        images = [part.image for part in parts if isinstance(part, ImagePart)]
+        try:
+            return self._client.generate_json(system=system, text=text, schema=schema, images=images or None)
+        except OllamaError as exc:
+            raise PlannerError(str(exc)) from exc

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/dubbing/__init__.py

@@ -1,11 +1,10 @@
 """Local video dubbing functionality, lazily re-exported (PEP 562).
 
-The pipeline's translation backends (``MarianTranslator``/``Qwen3Translator``)
-top-level import transformers/llama-cpp/torch, so eagerly chaining ``pipeline``
-here would drag the ``[dub]`` translation stack in just to read
-``DubbingConfig`` (pydantic-only). Lazy re-exports keep the lightweight
-config/model symbols importable without that; only ``LocalDubbingPipeline`` /
-``VideoDubber`` access loads the heavy chain. The ``TYPE_CHECKING`` block keeps
+The pipeline pulls heavy stages (Whisper, Demucs, Chatterbox), so eagerly
+chaining ``pipeline`` here would drag them in just to read ``DubbingConfig``
+(pydantic-only). Lazy re-exports keep the lightweight config/model symbols
+importable without that; only ``LocalDubbingPipeline`` / ``VideoDubber`` access
+loads the heavy chain. The ``TYPE_CHECKING`` block keeps
 symbols visible to mypy and IDEs.
 """
 

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/dubbing/config.py

@@ -6,7 +6,7 @@ from typing import Literal
 
 from pydantic import BaseModel, ConfigDict
 
-TranslatorChoice = Literal["auto", "marian", "qwen3"]
+TranslatorChoice = Literal["auto", "ollama"]
 WhisperModel = Literal["tiny", "base", "small", "medium", "large", "turbo"]
 
 
@@ -18,7 +18,7 @@ class DubbingConfig(BaseModel):
 
     Attributes:
         device: Execution device (``cpu``, ``cuda``, ``mps``, or ``None`` for auto).
-        low_memory: When True, each pipeline stage (Whisper, Demucs, MarianMT,
+        low_memory: When True, each pipeline stage (Whisper, Demucs, translation,
             Chatterbox TTS) is unloaded from memory after it runs, so only one
             model is resident at a time. Trades per-run latency (~10-30s of
             extra model loads) for a much lower memory ceiling. Recommended
@@ -47,12 +47,9 @@ class DubbingConfig(BaseModel):
             WARNING but processing continues. Either way the
             :class:`TranscriptQuality` is exposed on ``DubbingResult`` for
             inspection.
-        translator: Translation backend to use. ``"auto"`` (default) picks
-            Qwen3 on GPU, MarianMT on CPU; ``"marian"`` and ``"qwen3"`` force
-            the named backend regardless of device. See
-            :class:`videopython.ai.generation.qwen3.Qwen3Translator` for
-            tradeoffs (Qwen3 is slower on CPU but produces context-aware,
-            length-budgeted output).
+        translator: Translation backend; ``"auto"`` and ``"ollama"`` both use the
+            local Ollama text model. ``translator_model`` sets the Ollama tag and
+            ``translator_host`` the server URL.
     """
 
     model_config = ConfigDict(frozen=True)
@@ -66,6 +63,8 @@ class DubbingConfig(BaseModel):
     vocabulary: list[str] | None = None
     strict_quality: bool = False
     translator: TranslatorChoice = "auto"
+    translator_model: str | None = None
+    translator_host: str | None = None
 
     def init_log_fields(self) -> dict[str, object]:
         """Subset of fields surfaced in the init-log line.

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/dubbing/dubber.py

@@ -247,6 +247,6 @@ class VideoDubber:
 
     @staticmethod
     def get_supported_languages() -> dict[str, str]:
-        from videopython.ai.generation.translation import TextTranslator
+        from videopython.ai.generation.translation import OllamaTranslator
 
-        return TextTranslator.get_supported_languages()
+        return OllamaTranslator.get_supported_languages()

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/dubbing/models.py

@@ -218,11 +218,9 @@ class DubbingResult(BaseModel):
         timing_summary: Aggregate stats over per-segment timing adjustments.
         transcript_quality: Heuristic quality assessment of the transcription
             (None when the pipeline returned early on an empty transcription).
-        translation_failures: Indices of segments where translation failed
-            entirely. Used by Qwen3Translator when both the primary call and
-            the per-segment Marian fallback fail; those segments are dubbed
-            with empty text. Empty list under MarianTranslator (Marian has
-            no failure mode that drops segments).
+        translation_failures: Indices of segments the translator could not
+            translate (missing after its parse-retry pass); those segments are
+            dubbed with empty text.
     """
 
     model_config = ConfigDict(arbitrary_types_allowed=True)

{videopython-0.48.0 → videopython-0.49.0}/src/videopython/ai/dubbing/pipeline.py

@@ -7,18 +7,12 @@ import tempfile
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable
 
-from videopython.ai._device import select_device
 from videopython.ai.dubbing import expressiveness, loudness, voice_sample
 from videopython.ai.dubbing.config import DubbingConfig
 from videopython.ai.dubbing.models import DubbingResult, Expressiveness, RevoiceResult, SeparatedAudio, TimingSummary
 from videopython.ai.dubbing.quality import GarbageTranscriptError, assess_transcript
 from videopython.ai.dubbing.timing import TimingSynchronizer
-from videopython.ai.generation.qwen3 import Qwen3Translator
-from videopython.ai.generation.translation import (
-    MarianTranslator,
-    TranslationBackend,
-    UnsupportedLanguageError,
-)
+from videopython.ai.generation.translation import DEFAULT_TRANSLATION_MODEL, OllamaTranslator
 
 if TYPE_CHECKING:
     from videopython.ai.dubbing.models import TranslatedSegment
@@ -205,63 +199,11 @@ class LocalDubbingPipeline:
         )
 
     def _init_translator(self, source_lang: str, target_lang: str) -> None:
-        """Initialize the translation backend.
-
-        Resolves the configured ``self.config.translator`` choice into a concrete
-        backend. ``"auto"`` uses :meth:`_resolve_translator_auto`; explicit
-        choices instantiate the named backend directly. Re-initialization
-        is a no-op when ``self._translator`` is already a matching instance
-        for the same language pair (handled at call sites via the existing
-        ``self._translator is None`` gate).
-        """
-        if self.config.translator == "marian":
-            self._translator = MarianTranslator(device=self.config.device)
-        elif self.config.translator == "qwen3":
-            self._translator = Qwen3Translator(device=self.config.device)
-        else:  # "auto"
-            self._translator = self._resolve_translator_auto(source_lang, target_lang)
-
-    def _resolve_translator_auto(self, source_lang: str, target_lang: str) -> TranslationBackend:
-        """Pick a backend based on language coverage AND device.
-
-        Qwen3-4B Q4_K_M on CPU is roughly 10-15x slower than MarianMT (M2.1
-        spike on dreams_15min.mp4). The resolver picks Marian on CPU
-        whenever it covers the language pair and only escalates to Qwen
-        when a GPU is available or Marian doesn't cover the pair.
-        """
-        device = select_device(self.config.device, mps_allowed=True)
-        has_gpu = device in ("cuda", "mps")
-
-        # 1. GPU + Qwen covers the pair → Qwen wins (best quality).
-        if has_gpu and Qwen3Translator.supports(source_lang, target_lang):
-            logger.info(
-                "translator: auto-selected qwen3 (device=%s, supports %s->%s)",
-                device,
-                source_lang,
-                target_lang,
-            )
-            return Qwen3Translator(device=self.config.device)
-
-        # 2. Marian covers the pair → Marian (fast).
-        if MarianTranslator.has_model_for(source_lang, target_lang):
-            if has_gpu:
-                reason = f"Qwen does not cover {source_lang}->{target_lang}"
-            else:
-                reason = f"device={device} (Qwen would be ~10-15x slower; pass translator='qwen3' to override)"
-            logger.info("translator: auto-selected marian (%s)", reason)
-            return MarianTranslator(device=self.config.device)
-
-        # 3. CPU + only Qwen covers it: warn loudly and use Qwen anyway.
-        if Qwen3Translator.supports(source_lang, target_lang):
-            logger.warning(
-                "translator: auto-selected qwen3 on CPU (%s->%s not in Marian); "
-                "translation will be slow (~10-15x MarianMT). Consider GPU.",
-                source_lang,
-                target_lang,
-            )
-            return Qwen3Translator(device=self.config.device)
-
-        raise UnsupportedLanguageError(source_lang, target_lang)
+        """Initialize the Ollama translation backend."""
+        self._translator = OllamaTranslator(
+            model=self.config.translator_model or DEFAULT_TRANSLATION_MODEL,
+            host=self.config.translator_host,
+        )
 
     def _init_tts(self, language: str = "en") -> None:
         """Resolve the text-to-speech backend for ``language``.