videopython 0.52.1__tar.gz → 0.54.0__tar.gz

{videopython-0.52.1 → videopython-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.52.1
+Version: 0.54.0
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
@@ -26,7 +26,8 @@ Provides-Extra: ai
 Requires-Dist: accelerate>=0.29.2; extra == 'ai'
 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: diffusers>=0.35.0; extra == 'ai'
+Requires-Dist: ftfy>=6.1; extra == 'ai'
 Requires-Dist: imagehash>=4.3; extra == 'ai'
 Requires-Dist: ollama>=0.5.0; extra == 'ai'
 Requires-Dist: openai-whisper>=20240930; extra == 'ai'
@@ -35,9 +36,9 @@ Requires-Dist: pyloudnorm>=0.1.1; 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'
+Requires-Dist: torchvision<0.24.0,>=0.23.0; extra == 'ai'
 Requires-Dist: transformers>=5.2.0; extra == 'ai'
 Requires-Dist: transnetv2-pytorch>=1.0.5; extra == 'ai'
-Requires-Dist: ultralytics>=8.0.0; extra == 'ai'
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.27; extra == 'mcp'
 Description-Content-Type: text/markdown
@@ -63,7 +64,7 @@ pip install "videopython[ai]"        # + ALL local AI features (GPU recommended)
 pip install "videopython[ai,mcp]"    # + MCP server for agent-driven editing
 ```
 
-Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull gemma3:27b`).
+Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull qwen3.6:27b`).
 
 ## Quick Start
 
@@ -99,7 +100,7 @@ Give `AutoEditor` your clips and a brief; a local Ollama vision model selects an
 ```python
 from videopython.ai import AutoEditor, OllamaVisionLLM
 
-editor = AutoEditor(planner=OllamaVisionLLM(model="gemma3:27b"))  # ollama pull gemma3:27b
+editor = AutoEditor(planner=OllamaVisionLLM(model="qwen3.6:27b"))  # ollama pull qwen3.6:27b
 edit = editor.edit(
     ["clip_a.mp4", "clip_b.mp4", "clip_c.mp4"],
     brief="A punchy 15-second teaser; lead with the most dynamic shot.",

{videopython-0.52.1 → videopython-0.54.0}/README.md

@@ -19,7 +19,7 @@ pip install "videopython[ai]"        # + ALL local AI features (GPU recommended)
 pip install "videopython[ai,mcp]"    # + MCP server for agent-driven editing
 ```
 
-Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull gemma3:27b`).
+Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull qwen3.6:27b`).
 
 ## Quick Start
 
@@ -55,7 +55,7 @@ Give `AutoEditor` your clips and a brief; a local Ollama vision model selects an
 ```python
 from videopython.ai import AutoEditor, OllamaVisionLLM
 
-editor = AutoEditor(planner=OllamaVisionLLM(model="gemma3:27b"))  # ollama pull gemma3:27b
+editor = AutoEditor(planner=OllamaVisionLLM(model="qwen3.6:27b"))  # ollama pull qwen3.6:27b
 edit = editor.edit(
     ["clip_a.mp4", "clip_b.mp4", "clip_c.mp4"],
     brief="A punchy 15-second teaser; lead with the most dynamic shot.",

{videopython-0.52.1 → videopython-0.54.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.52.1"
+version = "0.54.0"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },
@@ -68,8 +68,8 @@ ai = [
     "openai-whisper>=20240930",
     "pyannote-audio>=4.0.0",
     "silero-vad>=5.1",
-    # Visual understanding: detection, scene/temporal, VLM (understanding/*, video_analysis)
-    "ultralytics>=8.0.0",
+    # Visual understanding: detection (D-FINE/YuNet via transformers + opencv core
+    # dep), scene/temporal, VLM (understanding/*, video_analysis)
     "transnetv2-pytorch>=1.0.5",
     "transformers>=5.2.0",
     "imagehash>=4.3",
@@ -78,16 +78,25 @@ ai = [
     # Voice cloning TTS (generation/audio.py — Chatterbox); its strict pins drive
     # the [tool.uv].override-dependencies block below.
     "chatterbox-tts>=0.1.7",
-    # Local media generation: SDXL/CogVideoX + MusicGen (generation/*)
-    "diffusers>=0.30.0",
+    # Local media generation: Qwen-Image/Wan2.2 + MusicGen (generation/*).
+    # >=0.35 is the floor that ships QwenImagePipeline + Wan2.2 support (tested on 0.37.1).
+    "diffusers>=0.35.0",
+    # Wan2.2 i2v pipeline cleans prompts with ftfy via a hard import (diffusers'
+    # pipeline_wan_i2v); the t2v pipeline guards it with is_ftfy_available(), i2v
+    # does not, so it is a required dep for ImageToVideo.
+    "ftfy>=6.1",
     "accelerate>=0.29.2",
     # Dubbing loudness matching (dubbing/loudness.py)
     "pyloudnorm>=0.1.1",
     # LLM-authored editing planner (auto_edit/local.py OllamaVisionLLM)
     "ollama>=0.5.0",
-    # Shared torch stack
+    # Shared torch stack. torchvision backs the transformers "fast" image
+    # processor used by the D-FINE object detector (understanding/objects.py).
     "torch>=2.8.0",
     "torchaudio>=2.8.0",
+    # Capped to the torch-2.8-compatible line; torchvision<->torch are ABI-coupled
+    # and uv does not know it (0.23.x pairs with torch 2.8.x).
+    "torchvision>=0.23.0,<0.24.0",
 ]
 # MCP server (videopython/mcp/). Pin <2 — v2 is pre-release/breaking.
 mcp = ["mcp>=1.27,<2"]
@@ -112,7 +121,6 @@ module = [
     "torch", "torch.*",
     "diffusers", "diffusers.*",
     "ollama", "ollama.*",
-    "ultralytics", "ultralytics.*",
     "transformers", "transformers.*",
     "transnetv2_pytorch", "transnetv2_pytorch.*",
     "chatterbox", "chatterbox.*",
@@ -133,8 +141,8 @@ ignore_missing_imports = true
 # These overrides let the combined [ai] resolve pick compatible versions; the
 # floors in [ai] are aligned with them so pip and uv resolve similar versions.
 override-dependencies = [
-    "torch>=2.8.0", "torchaudio>=2.8.0", "numpy>=2.0.0", "diffusers>=0.30.0",
-    # ultralytics depends on opencv-python which conflicts with our
+    "torch>=2.8.0", "torchaudio>=2.8.0", "torchvision>=0.23.0,<0.24.0", "numpy>=2.0.0", "diffusers>=0.35.0",
+    # Some transitive deps pull opencv-python, which conflicts with our
     # opencv-python-headless (both provide cv2). Exclude opencv-python so
     # only the headless variant is installed.
     "opencv-python ; sys_platform == '_'",

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/__init__.py

@@ -5,7 +5,7 @@ Every public symbol is re-exported lazily via PEP 562 ``__getattr__`` so that
 leaf module backing the requested symbol — not every sibling. All AI capabilities
 ship in the single ``[ai]`` extra; the laziness keeps ``import videopython`` (and
 importing one leaf class) light by deferring the heavy ML imports (torch /
-transformers / diffusers / ultralytics) until a symbol is actually used. When
+transformers / diffusers / chatterbox) until a symbol is actually used. When
 ``[ai]`` is not installed, touching a symbol raises a clear
 ``pip install 'videopython[ai]'``-pointing ``ImportError`` at attribute access
 instead of failing the whole package import.

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/_optional.py

@@ -52,7 +52,7 @@ def lazy_exports(package: str, exports: dict[str, str]) -> tuple[Callable[[str],
     imported only on first attribute access, so importing the package does not
     pull in any sibling leaf module. This keeps ``import videopython`` (and
     importing a single leaf class) light by deferring the heavy ML imports
-    (torch / transformers / diffusers / ultralytics) until a symbol is used.
+    (torch / transformers / diffusers / chatterbox) until a symbol is used.
 
     Args:
         package: The ``__name__`` of the package defining the re-exports. Used

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/_predictor.py

@@ -19,9 +19,9 @@ Subclasses with non-default model fields just declare ``_model_attrs``; those
 whose teardown isn't "null the fields + release" (e.g. delegating to a client's
 own ``unload()``) override ``unload()`` instead.
 
-The base imports no torch / transformers / ultralytics (``release_device_memory``
-defers its torch import), so it stays safe to mix into any predictor regardless
-of how it is constructed.
+The base imports no torch / transformers (``release_device_memory`` defers its
+torch import), so it stays safe to mix into any predictor regardless of how it is
+constructed.
 """
 
 from __future__ import annotations

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/_revisions.py

@@ -33,14 +33,6 @@ Usage:
 # documented here rather than registered above. ``pinned()`` returns None for
 # them, which leaves the caller on its current (unpinned) behavior.
 #
-#   * ultralytics YOLO asset -- ai/understanding/objects.py loads
-#     ``YOLO(self.model_name)`` (e.g. "yolov8n.pt"). Ultralytics resolves and
-#     downloads this from its own GitHub release assets, not from a HF repo,
-#     so there is no HF revision to pin. (The face detector in
-#     ai/understanding/faces.py is different: it pulls a YOLOv8 *checkpoint*
-#     from the HF repo ``arnabdhar/YOLOv8-Face-Detection`` via
-#     hf_hub_download, and that one IS pinned below.)
-#
 #   * 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,15 +59,26 @@ MODEL_REVISIONS: dict[str, str] = {
     "pyannote/speaker-diarization-community-1": "3533c8cf8e369892e6b79ff1bf80f7b0286a54ee",
     # Audio event classifier (ai/understanding/classification.py: AudioClassifier)
     "MIT/ast-finetuned-audioset-10-10-0.4593": "f826b80d28226b62986cc218e5cec390b1096902",
-    # Face detection checkpoint (ai/understanding/faces.py: hf_hub_download)
-    "arnabdhar/YOLOv8-Face-Detection": "52fa54977207fa4f021de949b515fb19dcab4488",
+    # Object detection — D-FINE COCO (ai/understanding/objects.py: ObjectDetector).
+    # Apache-2.0; replaced the AGPL Ultralytics YOLO weights. Loaded by AutoImageProcessor
+    # AND DFineForObjectDetection.from_pretrained, both keyed on the full repo id.
+    "ustc-community/dfine-nano-coco": "066438d3d8f0da137a37b38fdf3368fd4afceced",
+    "ustc-community/dfine-small-coco": "f79e65b5fbb33ceb9d3ebba042955d7410c608f8",
+    "ustc-community/dfine-medium-coco": "4ab9f5e466432f4fcf9a9a023da6aa5ecc9c9829",
+    "ustc-community/dfine-large-coco": "aa8f8211545e4cff5adf52ea512f9ac74a9824ec",
+    # Face detection checkpoint — OpenCV YuNet ONNX, MIT (ai/understanding/faces.py:
+    # hf_hub_download). Replaced the AGPL arnabdhar/YOLOv8-Face-Detection weights.
+    "opencv/face_detection_yunet": "3cc26e7f1014a5ee5d74a42acee58bafc9d0a310",
     # MusicGen (ai/generation/audio.py: TextToMusic)
     "facebook/musicgen-small": "4c8334b02c6ec4e8664a91979669a501ec497792",
-    # SDXL (ai/generation/image.py: TextToImage)
-    "stabilityai/stable-diffusion-xl-base-1.0": "462165984030d82259a11f4367a4eed129e94a7b",
-    # CogVideoX (ai/generation/video.py: TextToVideo / ImageToVideo)
-    "THUDM/CogVideoX1.5-5B": "fdc5267c90b5c06492985b966e43aae984e189e0",
-    "THUDM/CogVideoX1.5-5B-I2V": "46c90528707aebbe69066390b4fe7e7d24c9c2a4",
+    # Text-to-image — Qwen-Image (ai/generation/image.py: TextToImage), Apache-2.0;
+    # replaced the OpenRAIL++-licensed SDXL.
+    "Qwen/Qwen-Image-2512": "25468b98e3276ca6700de15c6628e51b7de54a26",
+    # Text/image-to-video — Wan2.2 (ai/generation/video.py: TextToVideo / ImageToVideo),
+    # Apache-2.0; replaced the custom-licensed CogVideoX. The fp32 VAE is loaded from the
+    # same repo (subfolder="vae"), so revision=pinned(repo) covers both from_pretrained calls.
+    "Wan-AI/Wan2.2-T2V-A14B-Diffusers": "5be7df9619b54f4e2667b2755bc6a756675b5cd7",
+    "Wan-AI/Wan2.2-I2V-A14B-Diffusers": "596658fd9ca6b7b71d5057529bbf319ecbc61d74",
 }
 
 

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/auto_edit/local.py

@@ -11,16 +11,17 @@ from .backend import PlannerError
 if TYPE_CHECKING:
     import numpy as np
 
-DEFAULT_OLLAMA_MODEL = "gemma3:27b"
+DEFAULT_OLLAMA_MODEL = "qwen3.6: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;
+    structured-output ``format`` (the EditPlan schema constrains the decode). The
+    default ``qwen3.6:27b`` is an Apache-2.0 vision model; not every model supports
+    schema conditioning (some builds, e.g. certain MLX ones, fail it), so confirm
+    ``format`` works for a custom model locally. ``ollama pull <model>`` first;
     ``options`` are extra generation options merged over ``temperature=0``.
 
     Thin wrapper over the shared :class:`OllamaStructuredClient`: its only job is

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/dubbing/translation.py

@@ -24,7 +24,7 @@ logger = logging.getLogger(__name__)
 
 # Default Ollama text model for translation; override via the `model` arg (and
 # `ollama pull` it first). Any instruct model that supports structured output works.
-DEFAULT_TRANSLATION_MODEL = "gemma3:27b"
+DEFAULT_TRANSLATION_MODEL = "qwen3.6:27b"
 
 
 def _is_translatable_text(text: str) -> bool:

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/effects.py

@@ -14,7 +14,7 @@ from typing import Any, Literal
 import numpy as np
 from pydantic import Field, PrivateAttr
 
-from videopython.ai.understanding.objects import ObjectDetector
+from videopython.ai.understanding.objects import MODEL_SIZES, ObjectDetector
 from videopython.base.description import DetectedObject
 from videopython.base.draw_detections import DetectionStyle, draw_detections
 from videopython.editing.operation import Effect
@@ -25,7 +25,7 @@ __all__ = ["ObjectDetectionOverlay"]
 class ObjectDetectionOverlay(Effect):
     """Detect objects per frame and overlay labelled bounding boxes.
 
-    Runs a YOLOv8-COCO detector and composites tidy, colour-coded boxes with
+    Runs a D-FINE COCO detector and composites tidy, colour-coded boxes with
     class labels (and optional confidence) onto every frame in the window.
 
     Detection runs on a ``detection_interval`` cadence in the streaming path and
@@ -70,7 +70,7 @@ class ObjectDetectionOverlay(Effect):
     model_size: Literal["n", "s", "m"] = Field(
         "n",
         description=(
-            "YOLOv8 model size: 'n' (nano, fastest), 's' (small), 'm' (medium, most accurate). "
+            "D-FINE detector size: 'n' (nano, fastest), 's' (small), 'm' (medium, most accurate). "
             "Larger detects better but is slower."
         ),
     )
@@ -96,7 +96,7 @@ class ObjectDetectionOverlay(Effect):
         """Build the detector lazily. Single patch point for tests."""
         if self._detector is None:
             self._detector = ObjectDetector(
-                model_name=f"yolov8{self.model_size}.pt",
+                model_name=MODEL_SIZES[self.model_size],
                 confidence_threshold=self.confidence_threshold,
                 class_filter=tuple(self.class_filter or ()),
                 backend=self.backend,

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/generation/__init__.py

@@ -2,7 +2,7 @@
 
 Each symbol's backing leaf module is imported only on first access, so
 ``from videopython.ai.generation import TextToImage`` does not pull in
-``audio`` (chatterbox/musicgen) or ``video`` (diffusers/CogVideoX). The
+``audio`` (chatterbox/musicgen) or ``video`` (diffusers/Wan2.2). The
 ``TYPE_CHECKING`` block keeps the symbols visible to mypy and IDEs.
 """
 

videopython-0.54.0/src/videopython/ai/generation/image.py

@@ -0,0 +1,93 @@
+"""Image generation using local diffusion models (Qwen-Image)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from PIL import Image
+
+from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._predictor import ManagedPredictor
+from videopython.ai._revisions import pinned
+
+_MODEL_NAME = "Qwen/Qwen-Image-2512"
+
+# Qwen-Image recommends appending a quality "magic" suffix to the prompt
+# (verbatim from the model card).
+_POSITIVE_MAGIC = ", Ultra HD, 4K, cinematic composition."
+
+
+class TextToImage(ManagedPredictor):
+    """Generates images from text descriptions using local models (Qwen-Image, Apache-2.0)."""
+
+    _model_attrs = ("_pipeline",)
+
+    def __init__(self, device: str | None = None):
+        self.device = device
+        self._pipeline: Any = None
+
+    def _init_local(self) -> None:
+        """Initialize the local Qwen-Image diffusion pipeline (CUDA-only)."""
+        import torch
+
+        from videopython.ai._optional import require
+
+        requested_device = self.device
+        device = select_device(self.device, mps_allowed=False)
+        if device != "cuda":
+            raise RuntimeError("TextToImage requires a CUDA GPU; Qwen-Image (~20B) is impractical on CPU/MPS.")
+
+        QwenImagePipeline = require("diffusers", feature="TextToImage").QwenImagePipeline
+        self._pipeline = QwenImagePipeline.from_pretrained(
+            _MODEL_NAME,
+            revision=pinned(_MODEL_NAME),
+            torch_dtype=torch.bfloat16,
+            use_safetensors=True,
+        )
+        # ~20B params (Qwen2.5-VL text encoder + transformer + VAE). Offload submodules
+        # to the GPU on demand so it fits a single GPU; offload manages device placement,
+        # so we must NOT also call .to("cuda").
+        self._pipeline.enable_model_cpu_offload()
+        self._pipeline.enable_vae_tiling()
+
+        self.device = device
+        log_device_initialization(
+            "TextToImage",
+            requested_device=requested_device,
+            resolved_device=device,
+        )
+
+    def generate_image(
+        self,
+        prompt: str,
+        *,
+        negative_prompt: str = " ",
+        true_cfg_scale: float = 4.0,
+        num_inference_steps: int = 50,
+        width: int = 1328,
+        height: int = 1328,
+        add_magic: bool = True,
+        seed: int = 42,
+    ) -> Image.Image:
+        """Generate an image from a text prompt.
+
+        Qwen-Image uses ``true_cfg_scale`` (not ``guidance_scale``) for
+        classifier-free guidance; a non-empty ``negative_prompt`` (default a single
+        space) is required to enable it. ``add_magic`` appends the model's
+        recommended quality suffix to ``prompt``.
+        """
+        import torch
+
+        if self._pipeline is None:
+            self._init_local()
+
+        full_prompt = prompt + _POSITIVE_MAGIC if add_magic else prompt
+        return self._pipeline(
+            prompt=full_prompt,
+            negative_prompt=negative_prompt,
+            true_cfg_scale=true_cfg_scale,
+            num_inference_steps=num_inference_steps,
+            width=width,
+            height=height,
+            generator=torch.Generator(device=self.device).manual_seed(seed),
+        ).images[0]

videopython-0.54.0/src/videopython/ai/generation/video.py

@@ -0,0 +1,207 @@
+"""Video generation using local diffusion models (Wan2.2)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from videopython.ai._device import log_device_initialization, select_device
+from videopython.ai._predictor import ManagedPredictor
+from videopython.ai._revisions import pinned
+from videopython.base.video import Video
+
+if TYPE_CHECKING:
+    from PIL.Image import Image
+
+# Canonical Wan2.2 negative prompt (from the diffusers WanPipeline docstring example).
+_WAN_NEGATIVE_PROMPT = (
+    "Bright tones, overexposed, static, blurred details, subtitles, style, works, "
+    "paintings, images, static, overall gray, worst quality, low quality, JPEG "
+    "compression residue, ugly, incomplete, extra fingers, poorly drawn hands, "
+    "poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, "
+    "still picture, messy background, three legs, many people in the background, "
+    "walking backwards"
+)
+
+
+def _retie_umt5_embeddings(pipeline: Any) -> None:
+    """Restore Wan's text conditioning under transformers>=5.2.
+
+    Wan's checkpoint ships the UMT5 token embedding only as ``shared.weight``, but
+    transformers 5.2's ``UMT5EncoderModel`` has ``tie_word_embeddings=False`` and reads a
+    *separate* ``encoder.embed_tokens`` that the checkpoint never populates -- so it stays
+    zero-initialized. The encoder then emits an all-zero embedding for every prompt and
+    generation silently ignores the text (verified on GPU: prompt has no effect). Point the
+    embedding lookup back at the loaded ``shared`` weight to make conditioning live again.
+    """
+    text_encoder = pipeline.text_encoder
+    text_encoder.encoder.embed_tokens = text_encoder.shared
+
+
+def _require_cuda_device(device: str | None, component: str) -> str:
+    """Resolve to a CUDA device or raise.
+
+    Wan2.2-A14B (~28B MoE) is too large to run on CPU/MPS, so generation requires
+    a CUDA GPU rather than silently falling back to an unusable device.
+    """
+    selected_device = select_device(device, mps_allowed=False)
+    if selected_device != "cuda":
+        raise RuntimeError(f"{component} requires a CUDA GPU; Wan2.2-A14B (~28B) is impractical on CPU/MPS.")
+    return selected_device
+
+
+class TextToVideo(ManagedPredictor):
+    """Generates videos from text descriptions using Wan2.2-T2V (Apache-2.0)."""
+
+    _model_attrs = ("_pipeline",)
+
+    def __init__(self, device: str | None = None):
+        self.device = device
+        self._pipeline: Any = None
+
+    def _init_local(self) -> None:
+        import torch
+
+        from videopython.ai._optional import require
+
+        diffusers = require("diffusers", feature="TextToVideo")
+        WanPipeline = diffusers.WanPipeline
+        AutoencoderKLWan = diffusers.AutoencoderKLWan
+
+        requested_device = self.device
+        device = _require_cuda_device(self.device, "TextToVideo")
+
+        model_name = "Wan-AI/Wan2.2-T2V-A14B-Diffusers"
+        revision = pinned(model_name)
+        # VAE stays float32 for decode quality; the transformer/pipeline use bf16.
+        vae = AutoencoderKLWan.from_pretrained(
+            model_name, subfolder="vae", revision=revision, torch_dtype=torch.float32
+        )
+        self._pipeline = WanPipeline.from_pretrained(model_name, vae=vae, revision=revision, torch_dtype=torch.bfloat16)
+        _retie_umt5_embeddings(self._pipeline)
+        # A14B is a MoE (high+low-noise experts), too large for a single-GPU .to("cuda");
+        # offload submodules on demand (offload manages placement, so do NOT also call .to).
+        self._pipeline.enable_model_cpu_offload()
+
+        self.device = device
+        log_device_initialization(
+            "TextToVideo",
+            requested_device=requested_device,
+            resolved_device=device,
+        )
+
+    def generate_video(
+        self,
+        prompt: str,
+        num_steps: int = 40,
+        num_frames: int = 81,
+        guidance_scale: float = 4.0,
+    ) -> Video:
+        """Generate video from text prompt."""
+        import torch
+
+        if self._pipeline is None:
+            self._init_local()
+
+        # output_type="pil" is required: the "np" default returns float32 in [0, 1],
+        # which the uint8 cast below would floor to an all-black video.
+        video_frames = self._pipeline(
+            prompt=prompt,
+            negative_prompt=_WAN_NEGATIVE_PROMPT,
+            height=720,
+            width=1280,
+            num_frames=num_frames,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance_scale,
+            guidance_scale_2=3.0,  # low-noise MoE expert; None would reuse guidance_scale
+            output_type="pil",
+            generator=torch.Generator(device=self.device).manual_seed(42),
+        ).frames[0]
+        video_frames = np.asarray(video_frames, dtype=np.uint8)
+        return Video.from_frames(video_frames, fps=16.0)
+
+
+class ImageToVideo(ManagedPredictor):
+    """Generates videos from static images using Wan2.2-I2V (Apache-2.0)."""
+
+    _model_attrs = ("_pipeline",)
+
+    def __init__(self, device: str | None = None):
+        self.device = device
+        self._pipeline: Any = None
+
+    def _init_local(self) -> None:
+        import torch
+
+        from videopython.ai._optional import require
+
+        diffusers = require("diffusers", feature="ImageToVideo")
+        WanImageToVideoPipeline = diffusers.WanImageToVideoPipeline
+        AutoencoderKLWan = diffusers.AutoencoderKLWan
+
+        requested_device = self.device
+        device = _require_cuda_device(self.device, "ImageToVideo")
+
+        model_name = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"
+        revision = pinned(model_name)
+        vae = AutoencoderKLWan.from_pretrained(
+            model_name, subfolder="vae", revision=revision, torch_dtype=torch.float32
+        )
+        self._pipeline = WanImageToVideoPipeline.from_pretrained(
+            model_name, vae=vae, revision=revision, torch_dtype=torch.bfloat16
+        )
+        _retie_umt5_embeddings(self._pipeline)
+        # A14B MoE is too large for a single-GPU .to("cuda"); offload submodules on demand.
+        self._pipeline.enable_model_cpu_offload()
+
+        self.device = device
+        log_device_initialization(
+            "ImageToVideo",
+            requested_device=requested_device,
+            resolved_device=device,
+        )
+
+    def _resize_to_model_grid(self, image: Image) -> tuple[Image, int, int]:
+        """Resize ``image`` to Wan's area budget, snapped to the model's spatial grid.
+
+        Returns the resized image plus the ``(height, width)`` to request, derived
+        from the input aspect ratio against Wan's 480x832 area (per the model card).
+        """
+        max_area = 480 * 832
+        aspect_ratio = image.height / image.width
+        mod_value = self._pipeline.vae_scale_factor_spatial * self._pipeline.transformer.config.patch_size[1]
+        height = round(np.sqrt(max_area * aspect_ratio)) // mod_value * mod_value
+        width = round(np.sqrt(max_area / aspect_ratio)) // mod_value * mod_value
+        return image.resize((width, height)), height, width
+
+    def generate_video(
+        self,
+        image: Image,
+        prompt: str = "",
+        num_steps: int = 40,
+        num_frames: int = 81,
+        guidance_scale: float = 3.5,
+    ) -> Video:
+        """Generate video animation from a static image."""
+        import torch
+
+        if self._pipeline is None:
+            self._init_local()
+
+        image, height, width = self._resize_to_model_grid(image)
+        video_frames = self._pipeline(
+            image=image,
+            prompt=prompt,
+            negative_prompt=_WAN_NEGATIVE_PROMPT,
+            height=height,
+            width=width,
+            num_frames=num_frames,
+            num_inference_steps=num_steps,
+            guidance_scale=guidance_scale,
+            # No guidance_scale_2: the low-noise MoE expert reuses guidance_scale (its None default).
+            output_type="pil",
+            generator=torch.Generator(device=self.device).manual_seed(42),
+        ).frames[0]
+        video_frames = np.asarray(video_frames, dtype=np.uint8)
+        return Video.from_frames(video_frames, fps=16.0)

{videopython-0.52.1 → videopython-0.54.0}/src/videopython/ai/transforms.py

@@ -74,8 +74,6 @@ class FaceTrackingCrop(Operation):
         ),
     )
     detection_interval: int = Field(3, ge=1, description="Frames between face detections.")
-    backend: Literal["cpu", "gpu", "auto"] = Field("auto", description='Detection backend - "cpu", "gpu", or "auto".')
-    sample_rate: int = Field(1, ge=1, description="For GPU backend, detect every Nth frame and interpolate.")
 
     def _apply_framing_offset(self, face_cx: float, face_cy: float, face_h: float) -> tuple[float, float]:
         if self.framing_rule == "offset":
@@ -139,8 +137,6 @@ class FaceTrackingCrop(Operation):
             face_index=self.face_index,
             smoothing=self.smoothing,
             detection_interval=self.detection_interval,
-            backend=self.backend,
-            sample_rate=self.sample_rate,
         )
         default = ((frame_w - out_w) // 2, (frame_h - out_h) // 2)
         last = default