videopython 0.52.0__tar.gz → 0.53.0__tar.gz

{videopython-0.52.0 → videopython-0.53.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.52.0
+Version: 0.53.0
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
@@ -35,9 +35,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 +63,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 +99,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.0 → videopython-0.53.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.0 → videopython-0.53.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.52.0"
+version = "0.53.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",
@@ -85,9 +85,13 @@ ai = [
     "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 +116,6 @@ module = [
     "torch", "torch.*",
     "diffusers", "diffusers.*",
     "ollama", "ollama.*",
-    "ultralytics", "ultralytics.*",
     "transformers", "transformers.*",
     "transnetv2_pytorch", "transnetv2_pytorch.*",
     "chatterbox", "chatterbox.*",
@@ -133,8 +136,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.30.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.0 → videopython-0.53.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.0 → videopython-0.53.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.0 → videopython-0.53.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.0 → videopython-0.53.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,8 +59,16 @@ 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)

{videopython-0.52.0 → videopython-0.53.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.0 → videopython-0.53.0}/src/videopython/ai/dubbing/pipeline.py

@@ -229,6 +229,43 @@ class LocalDubbingPipeline:
         """Initialize the timing synchronizer."""
         self._synchronizer = TimingSynchronizer()
 
+    def _separate(
+        self,
+        source_audio: Audio,
+        transcription: Transcription,
+        progress_fraction: float,
+        report_progress: Callable[[str, float], None],
+    ) -> tuple[SeparatedAudio | None, Audio, Audio | None]:
+        """Demucs source separation over the speech regions; shared by process()/revoice().
+
+        Limits Demucs to the speech-bearing portion of the audio: the transcription
+        has already located every speech region, and separating outside those is pure
+        overhead (no vocals to isolate). On talk-heavy sources with silence/music gaps
+        this roughly halves separation time; when speech covers most of the track,
+        separate_regions falls back to a full-track separate().
+
+        Returns ``(separated_audio, vocal_audio, background_audio)``. In low_memory
+        mode the ``SeparatedAudio`` container is dropped (returned as ``None``) so
+        vocals and background release as soon as their last local reference goes.
+        """
+        report_progress("Separating audio", progress_fraction)
+        if self._separator is None:
+            self._init_separator()
+
+        from videopython.ai.dubbing.separation import merge_regions
+
+        speech_regions = merge_regions(
+            [(s.start, s.end) for s in transcription.segments],
+            audio_duration=source_audio.metadata.duration_seconds,
+        )
+        separated_audio = self._separator.separate_regions(source_audio, speech_regions)
+        self._maybe_unload("_separator")
+        vocal_audio = separated_audio.vocals
+        background_audio = separated_audio.background
+        if self.config.low_memory:
+            separated_audio = None
+        return separated_audio, vocal_audio, background_audio
+
     def _finalise_audio(
         self,
         dubbed_speech: Audio,
@@ -355,32 +392,9 @@ class LocalDubbingPipeline:
         background_audio: Audio | None = None
 
         if preserve_background:
-            report_progress("Separating audio", 0.15)
-            if self._separator is None:
-                self._init_separator()
-
-            # Limit Demucs to the speech-bearing portion of the audio. The
-            # transcription has already located every speech region; running
-            # source separation outside those is pure overhead (no vocals to
-            # isolate). On talk-heavy sources with silence/music gaps this
-            # roughly halves separation time. When speech covers most of the
-            # track separate_regions falls back to a full-track separate().
-            from videopython.ai.dubbing.separation import merge_regions
-
-            speech_regions = merge_regions(
-                [(s.start, s.end) for s in transcription.segments],
-                audio_duration=source_audio.metadata.duration_seconds,
+            separated_audio, vocal_audio, background_audio = self._separate(
+                source_audio, transcription, 0.15, report_progress
             )
-            separated_audio = self._separator.separate_regions(source_audio, speech_regions)
-            self._maybe_unload("_separator")
-            vocal_audio = separated_audio.vocals
-            background_audio = separated_audio.background
-            # In low_memory mode, drop the SeparatedAudio container so vocals
-            # and background can be released as soon as their last local
-            # reference goes (after voice-sample extraction and final overlay
-            # respectively). The result will report separated_audio=None.
-            if self.config.low_memory:
-                separated_audio = None
 
         voice_samples: dict[str, Audio] = {}
         if voice_clone:
@@ -527,22 +541,9 @@ class LocalDubbingPipeline:
         background_audio: Audio | None = None
 
         if preserve_background:
-            report_progress("Separating audio", 0.20)
-            if self._separator is None:
-                self._init_separator()
-
-            from videopython.ai.dubbing.separation import merge_regions
-
-            speech_regions = merge_regions(
-                [(s.start, s.end) for s in transcription.segments],
-                audio_duration=source_audio.metadata.duration_seconds,
+            separated_audio, vocal_audio, background_audio = self._separate(
+                source_audio, transcription, 0.20, report_progress
             )
-            separated_audio = self._separator.separate_regions(source_audio, speech_regions)
-            self._maybe_unload("_separator")
-            vocal_audio = separated_audio.vocals
-            background_audio = separated_audio.background
-            if self.config.low_memory:
-                separated_audio = None
 
         report_progress("Extracting voice sample", 0.40)
         chosen_sample: Audio | None = None

{videopython-0.52.0 → videopython-0.53.0}/src/videopython/ai/dubbing/separation.py

@@ -59,14 +59,9 @@ def merge_regions(
 class AudioSeparator(ManagedPredictor):
     """Separates audio into vocals and background components using Demucs."""
 
-    SUPPORTED_MODELS: list[str] = ["htdemucs", "htdemucs_ft", "htdemucs_6s", "mdx_extra"]
     STEM_NAMES = ["drums", "bass", "other", "vocals"]
-    STEM_NAMES_6S = ["drums", "bass", "other", "vocals", "guitar", "piano"]
 
     def __init__(self, model_name: str = "htdemucs", device: str | None = None):
-        if model_name not in self.SUPPORTED_MODELS:
-            raise ValueError(f"Model '{model_name}' not supported. Supported: {self.SUPPORTED_MODELS}")
-
         self.model_name = model_name
         self.device = device
         self._model: Any = None
@@ -129,7 +124,7 @@ class AudioSeparator(ManagedPredictor):
         sources_np = sources[0].cpu().numpy()
         del sources
 
-        stem_names = self.STEM_NAMES_6S if self.model_name == "htdemucs_6s" else self.STEM_NAMES
+        stem_names = self.STEM_NAMES
         vocals_idx = stem_names.index("vocals")
         non_vocal_indices = [i for i in range(len(stem_names)) if i != vocals_idx]
 

{videopython-0.52.0 → videopython-0.53.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.0 → videopython-0.53.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.0 → videopython-0.53.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

videopython-0.52.0/src/videopython/ai/understanding/_yolo.py → videopython-0.53.0/src/videopython/ai/understanding/_detector.py

@@ -1,21 +1,21 @@
-"""Shared lazy YOLOv8 detector wrapper for the understanding layer.
-
-``ObjectDetector`` (COCO objects) and ``_FaceDetector`` (faces) were nearly
-identical YOLO wrappers: same ``cpu``/``gpu``/``auto`` device resolution, same
-lazy load + ``.to("cuda")``, same ``detect`` / ``detect_batch`` shape, differing
-only in how the model is loaded and how a result is parsed into detections.
-:class:`YoloDetector` holds all the shared machinery; subclasses supply just
-``_load_model`` (build ``self._yolo_model``), ``_parse`` (one result -> list of
-detections), and ``_conf`` (the confidence passed to YOLO).
-
-The heavy ``ultralytics`` import is deferred to :meth:`_build_yolo` (guarded by
-``require``), so constructing a detector pulls in no torch until it actually runs.
+"""Shared lazy detector base for the understanding layer.
+
+``ObjectDetector`` (COCO objects, D-FINE via transformers) and ``_FaceDetector``
+(faces, OpenCV YuNet) share the same machinery: ``cpu``/``gpu``/``auto`` device
+resolution, lazy load, the ``detect`` / ``detect_batch`` shape, and ``unload``.
+:class:`DetectorBase` holds that machinery; subclasses supply just ``_load_model``
+(populate the ``_model_attrs`` fields) and ``_infer`` (map a batch of frames to a
+list of per-frame detections).
+
+The two backends are completely different (transformers vs OpenCV DNN), so the
+base imports no model library itself; each subclass defers its heavy import into
+``_load_model`` (guarded by ``require`` where the dep lives in the ``[ai]`` extra).
 """
 
 from __future__ import annotations
 
 import logging
-from typing import Any, Generic, Literal, TypeVar
+from typing import Generic, Literal, TypeVar
 
 import numpy as np
 
@@ -28,26 +28,25 @@ T = TypeVar("T")
 Backend = Literal["cpu", "gpu", "auto"]
 
 
-class YoloDetector(ManagedPredictor, Generic[T]):
-    """Lazy YOLOv8 wrapper: device resolution, lazy load, detect/detect_batch, unload.
+class DetectorBase(ManagedPredictor, Generic[T]):
+    """Lazy detector base: device resolution, lazy load, detect/detect_batch, unload.
 
     Context-managed via :class:`ManagedPredictor`; ``unload()`` drops the model
-    and frees the resolved device. Subclass contract:
+    reference(s) named in ``_model_attrs`` and frees the resolved device. Subclass
+    contract:
       * ``_FEATURE`` -- name surfaced in the ``[ai]``-extra ``ImportError``.
-      * ``_load_model()`` -- set ``self._yolo_model`` (call :meth:`_build_yolo`)
-        plus any label state.
-      * ``_parse(result)`` -- map one ultralytics result to a list of detections.
-      * ``_conf()`` -- the ``conf`` threshold passed to the model.
+      * ``_model_attrs`` -- attribute(s) holding loaded model state; the first one
+        doubles as the "is loaded" sentinel.
+      * ``_load_model()`` -- populate the ``_model_attrs`` fields plus any label state.
+      * ``_infer(images)`` -- map a list of frames to a list of per-frame detections.
     """
 
-    _FEATURE = "YoloDetector"
-    _model_attrs = ("_yolo_model",)
+    _FEATURE = "detector"
     _device_attr = "_resolved_device"
 
     def __init__(self, *, backend: Backend = "auto") -> None:
         self.backend: Backend = backend
         self._resolved_device: Literal["cpu", "cuda"] | None = None
-        self._yolo_model: Any = None
 
     def _resolve_device(self) -> Literal["cpu", "cuda"]:
         if self._resolved_device is not None:
@@ -67,37 +66,23 @@ class YoloDetector(ManagedPredictor, Generic[T]):
         """Resolved execution device for this detector."""
         return self._resolve_device()
 
-    def _build_yolo(self, model_path: str) -> None:
-        """Construct ``self._yolo_model`` from a model id/path and move it to the device."""
-        from videopython.ai._optional import require
-
-        YOLO = require("ultralytics", feature=self._FEATURE).YOLO
-        self._yolo_model = YOLO(model_path)
-        if self._resolve_device() == "cuda":
-            self._yolo_model.to("cuda")
-
     # --- subclass hooks -----------------------------------------------------
     def _load_model(self) -> None:
         raise NotImplementedError
 
-    def _conf(self) -> float:
-        raise NotImplementedError
-
-    def _parse(self, result: Any) -> list[T]:
+    def _infer(self, images: list[np.ndarray]) -> list[list[T]]:
         raise NotImplementedError
 
     # --- public API ---------------------------------------------------------
     def _ensure_loaded(self) -> None:
-        if self._yolo_model is None:
+        if getattr(self, self._model_attrs[0], None) is None:
             self._load_model()
 
     def detect(self, image: np.ndarray) -> list[T]:
         """Detect in a single ``(H, W, 3)`` frame."""
         self._ensure_loaded()
-        results = self._yolo_model(image, conf=self._conf(), verbose=False)
-        if not results:
-            return []
-        return self._parse(results[0])
+        results = self._infer([image])
+        return results[0] if results else []
 
     def detect_batch(self, images: list[np.ndarray] | np.ndarray) -> list[list[T]]:
         """Detect in a batch of frames (list or stacked ``(N, H, W, 3)``)."""
@@ -107,5 +92,4 @@ class YoloDetector(ManagedPredictor, Generic[T]):
             return []
 
         self._ensure_loaded()
-        results = self._yolo_model(images, conf=self._conf(), verbose=False)
-        return [self._parse(result) for result in results]
+        return self._infer(images)

{videopython-0.52.0 → videopython-0.53.0}/src/videopython/ai/understanding/classification.py

@@ -23,7 +23,6 @@ class AudioClassifier(ManagedPredictor):
     """Audio event and sound classification using AST."""
 
     _model_attrs = ("_model", "_processor")
-    SUPPORTED_MODELS: list[str] = ["MIT/ast-finetuned-audioset-10-10-0.4593"]
     AST_SAMPLE_RATE: int = 16000
     AST_CHUNK_SECONDS: float = 10.0
     AST_HOP_SECONDS: float = 5.0
@@ -35,9 +34,6 @@ class AudioClassifier(ManagedPredictor):
         top_k: int = 10,
         device: str | None = None,
     ):
-        if model_name not in self.SUPPORTED_MODELS:
-            raise ValueError(f"Model '{model_name}' not supported. Supported: {self.SUPPORTED_MODELS}")
-
         self.model_name = model_name
         self.confidence_threshold = confidence_threshold
         self.top_k = top_k