videopython 0.33.1__tar.gz → 0.33.3__tar.gz

videopython-0.33.3/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: videopython
+Version: 0.33.3
+Summary: Minimal video generation and processing library.
+Project-URL: Homepage, https://videopython.com
+Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
+Project-URL: Documentation, https://videopython.com
+Author-email: Bartosz Wójtowicz <bartoszwojtowicz@outlook.com>, Bartosz Rudnikowicz <bartoszrudnikowicz840@gmail.com>, Piotr Pukisz <piotr.pukisz@gmail.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: ai,editing,generation,movie,opencv,python,shorts,video,videopython
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: <3.14,>=3.10
+Requires-Dist: numpy>=1.25.2
+Requires-Dist: opencv-python-headless>=4.9.0.80
+Requires-Dist: pillow>=12.1.1
+Requires-Dist: pydantic>=2.8.0
+Requires-Dist: tqdm>=4.66.3
+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: hf-transfer>=0.1.9; extra == 'ai'
+Requires-Dist: imagehash>=4.3; extra == 'ai'
+Requires-Dist: llama-cpp-python>=0.3.0; extra == 'ai'
+Requires-Dist: numba>=0.61.0; extra == 'ai'
+Requires-Dist: ollama>=0.4.5; 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: scikit-learn>=1.3.0; extra == 'ai'
+Requires-Dist: scipy>=1.10.0; 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'
+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'
+Description-Content-Type: text/markdown
+
+# videopython
+
+[![PyPI](https://img.shields.io/pypi/v/videopython)](https://pypi.org/project/videopython/)
+[![Python](https://img.shields.io/pypi/pyversions/videopython)](https://pypi.org/project/videopython/)
+[![License](https://img.shields.io/github/license/BartWojtowicz/videopython)](LICENSE)
+
+Minimal, LLM-friendly Python library for programmatic video editing, processing, and AI video workflows.
+
+Full documentation: [videopython.com](https://videopython.com)
+
+> **Disclaimer:** This project started as a hand-written hobby project, but most of the code is now produced by LLM agents. Humans still drive direction, approve changes, and own design decisions.
+
+## Installation
+
+```bash
+# Install FFmpeg first (macOS: brew install ffmpeg | Debian: apt-get install ffmpeg)
+pip install videopython          # core video/audio editing
+pip install "videopython[ai]"    # + local AI features (GPU recommended)
+```
+
+Python `>=3.10, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use.
+
+## Quick Start
+
+### JSON editing plans
+
+A `VideoEdit` is a multi-segment plan, defined as a dict (or JSON), validated and executed against the source files:
+
+```python
+from videopython.editing import VideoEdit
+
+edit = VideoEdit.from_dict({
+    "segments": [{
+        "source": "raw.mp4",
+        "start": 10.0,
+        "end": 20.0,
+        "operations": [
+            {"op": "resize", "width": 1080, "height": 1920},
+            {"op": "color_adjust", "saturation": 1.15, "contrast": 1.05},
+            {"op": "fade", "mode": "in", "duration": 0.5},
+        ],
+    }],
+})
+edit.validate()                  # dry-run via metadata, no frames loaded
+edit.run_to_file("output.mp4")   # streams ffmpeg decode → effects → encode
+```
+
+`run_to_file()` streams ffmpeg decode → per-frame effects → encode, so memory stays bounded even for hour-long sources. Use `edit.run()` to get a `Video` back in memory instead.
+
+### AI generation
+
+```python
+from videopython.ai import TextToImage, ImageToVideo, TextToSpeech
+
+image = TextToImage().generate_image("A cinematic mountain sunrise")
+video = ImageToVideo().generate_video(image=image)
+audio = TextToSpeech().generate_audio("Welcome to videopython.")
+video.add_audio(audio).save("ai_video.mp4")
+```
+
+## LLM & AI Agent Integration
+
+Every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every registered `Operation` — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Then `edit.validate()` dry-runs the plan via metadata before any frames are loaded, so a failed LLM output can be fed back as an error and retried cheaply.
+
+See the [LLM Integration Guide](https://videopython.com/guides/llm-integration/) for end-to-end examples, validation error loops, and operation discovery patterns.
+
+## Features
+
+- **`videopython.base`** — `Video`, `VideoMetadata`, `FrameIterator`, `ImageText`, `Transcription`, and shared result types (`BoundingBox`, `FaceTrack`, `SceneBoundary`, ...). No AI dependencies.
+- **`videopython.audio`** — `Audio` with overlay, concat, normalize, time-stretch, silence detection, segment classification.
+- **`videopython.editing`** — `Operation`/`Effect` foundation, `VideoEdit` plan runner with JSON Schema + streaming execution. Transforms (cut, resize, crop, fps, speed, reverse, freeze, silence removal) and effects (blur, zoom, color grading, vignette, Ken Burns, fade, overlays, animated subtitles).
+- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `SemanticSceneDetector`), `FaceTrackingCrop` transform, and the full-pipeline `VideoAnalyzer`.
+- **`videopython.ai.dubbing`** — `VideoDubber` for voice-cloned revoicing with timing sync.
+
+## Examples
+
+- [Social Media Clip](https://videopython.com/examples/social-clip/)
+- [AI-Generated Video](https://videopython.com/examples/ai-video/)
+- [Auto-Subtitles](https://videopython.com/examples/auto-subtitles/)
+- [Processing Large Videos](https://videopython.com/examples/large-videos/)
+
+## Development
+
+See [`DEVELOPMENT.md`](DEVELOPMENT.md) for local setup, testing, and contribution workflow.

videopython-0.33.3/README.md

@@ -0,0 +1,84 @@
+# videopython
+
+[![PyPI](https://img.shields.io/pypi/v/videopython)](https://pypi.org/project/videopython/)
+[![Python](https://img.shields.io/pypi/pyversions/videopython)](https://pypi.org/project/videopython/)
+[![License](https://img.shields.io/github/license/BartWojtowicz/videopython)](LICENSE)
+
+Minimal, LLM-friendly Python library for programmatic video editing, processing, and AI video workflows.
+
+Full documentation: [videopython.com](https://videopython.com)
+
+> **Disclaimer:** This project started as a hand-written hobby project, but most of the code is now produced by LLM agents. Humans still drive direction, approve changes, and own design decisions.
+
+## Installation
+
+```bash
+# Install FFmpeg first (macOS: brew install ffmpeg | Debian: apt-get install ffmpeg)
+pip install videopython          # core video/audio editing
+pip install "videopython[ai]"    # + local AI features (GPU recommended)
+```
+
+Python `>=3.10, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use.
+
+## Quick Start
+
+### JSON editing plans
+
+A `VideoEdit` is a multi-segment plan, defined as a dict (or JSON), validated and executed against the source files:
+
+```python
+from videopython.editing import VideoEdit
+
+edit = VideoEdit.from_dict({
+    "segments": [{
+        "source": "raw.mp4",
+        "start": 10.0,
+        "end": 20.0,
+        "operations": [
+            {"op": "resize", "width": 1080, "height": 1920},
+            {"op": "color_adjust", "saturation": 1.15, "contrast": 1.05},
+            {"op": "fade", "mode": "in", "duration": 0.5},
+        ],
+    }],
+})
+edit.validate()                  # dry-run via metadata, no frames loaded
+edit.run_to_file("output.mp4")   # streams ffmpeg decode → effects → encode
+```
+
+`run_to_file()` streams ffmpeg decode → per-frame effects → encode, so memory stays bounded even for hour-long sources. Use `edit.run()` to get a `Video` back in memory instead.
+
+### AI generation
+
+```python
+from videopython.ai import TextToImage, ImageToVideo, TextToSpeech
+
+image = TextToImage().generate_image("A cinematic mountain sunrise")
+video = ImageToVideo().generate_video(image=image)
+audio = TextToSpeech().generate_audio("Welcome to videopython.")
+video.add_audio(audio).save("ai_video.mp4")
+```
+
+## LLM & AI Agent Integration
+
+Every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every registered `Operation` — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Then `edit.validate()` dry-runs the plan via metadata before any frames are loaded, so a failed LLM output can be fed back as an error and retried cheaply.
+
+See the [LLM Integration Guide](https://videopython.com/guides/llm-integration/) for end-to-end examples, validation error loops, and operation discovery patterns.
+
+## Features
+
+- **`videopython.base`** — `Video`, `VideoMetadata`, `FrameIterator`, `ImageText`, `Transcription`, and shared result types (`BoundingBox`, `FaceTrack`, `SceneBoundary`, ...). No AI dependencies.
+- **`videopython.audio`** — `Audio` with overlay, concat, normalize, time-stretch, silence detection, segment classification.
+- **`videopython.editing`** — `Operation`/`Effect` foundation, `VideoEdit` plan runner with JSON Schema + streaming execution. Transforms (cut, resize, crop, fps, speed, reverse, freeze, silence removal) and effects (blur, zoom, color grading, vignette, Ken Burns, fade, overlays, animated subtitles).
+- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `SemanticSceneDetector`), `FaceTrackingCrop` transform, and the full-pipeline `VideoAnalyzer`.
+- **`videopython.ai.dubbing`** — `VideoDubber` for voice-cloned revoicing with timing sync.
+
+## Examples
+
+- [Social Media Clip](https://videopython.com/examples/social-clip/)
+- [AI-Generated Video](https://videopython.com/examples/ai-video/)
+- [Auto-Subtitles](https://videopython.com/examples/auto-subtitles/)
+- [Processing Large Videos](https://videopython.com/examples/large-videos/)
+
+## Development
+
+See [`DEVELOPMENT.md`](DEVELOPMENT.md) for local setup, testing, and contribution workflow.

{videopython-0.33.1 → videopython-0.33.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.33.1"
+version = "0.33.3"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },
@@ -137,6 +137,9 @@ Documentation = "https://videopython.com"
 [tool.mypy]
 mypy_path = "src/stubs"
 plugins = ["pydantic.mypy"]
+warn_unused_ignores = true
+warn_redundant_casts = true
+disallow_any_generics = true
 
 [[tool.mypy.overrides]]
 module = [
@@ -183,9 +186,11 @@ build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/videopython"]
+artifacts = ["src/videopython/base/fonts/*.ttf", "src/videopython/base/fonts/LICENSE_DEJAVU"]
 
 [tool.hatch.build.targets.sdist]
 include = ["src/videopython", "src/videopython/py.typed"]
+artifacts = ["src/videopython/base/fonts/*.ttf", "src/videopython/base/fonts/LICENSE_DEJAVU"]
 
 [tool.pytest.ini_options]
 pythonpath = ["src/"]

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/ai/generation/audio.py

@@ -33,7 +33,7 @@ class TextToSpeech:
         self._model: Any = None
 
     def _init_local(self) -> None:
-        from chatterbox.mtl_tts import ChatterboxMultilingualTTS  # type: ignore[import-untyped]
+        from chatterbox.mtl_tts import ChatterboxMultilingualTTS
 
         requested_device = self.device
         device = select_device(self.device, mps_allowed=False)

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/ai/generation/translation.py

@@ -170,7 +170,7 @@ class MarianTranslator:
         return f"Helsinki-NLP/opus-mt-{source_lang}-{target_lang}"
 
     def _init_local(self, source_lang: str, target_lang: str) -> None:
-        from transformers import MarianMTModel, MarianTokenizer  # type: ignore[attr-defined]
+        from transformers import MarianMTModel, MarianTokenizer
 
         model_name = self._get_local_model_name(source_lang, target_lang)
 

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/ai/understanding/audio.py

@@ -188,7 +188,7 @@ class AudioToText:
     def _init_diarization(self) -> None:
         """Initialize pyannote speaker diarization pipeline."""
         import torch
-        from pyannote.audio import Pipeline  # type: ignore[import-untyped]
+        from pyannote.audio import Pipeline
 
         self._diarization_pipeline = Pipeline.from_pretrained(self.PYANNOTE_DIARIZATION_MODEL)
         self._diarization_pipeline.to(torch.device(self.device))
@@ -214,7 +214,7 @@ class AudioToText:
         self._vad_model = None
         release_device_memory(self.device)
 
-    def _process_transcription_result(self, transcription_result: dict) -> Transcription:
+    def _process_transcription_result(self, transcription_result: dict[str, Any]) -> Transcription:
         """Process raw transcription result into a Transcription object."""
         transcription_segments = []
         for segment in transcription_result["segments"]:

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/ai/understanding/faces.py

@@ -237,7 +237,7 @@ class FaceTracker:
 
     def _select_face(
         self,
-        faces: list,
+        faces: list[DetectedFace],
         frame_width: int,
         frame_height: int,
     ) -> tuple[float, float, float, float] | None:
@@ -251,29 +251,24 @@ class FaceTracker:
         Returns:
             Tuple of (center_x, center_y, width, height) in normalized coords, or None.
         """
-        if not faces:
+        faces_with_box = [(f, f.bounding_box) for f in faces if f.bounding_box is not None]
+        if not faces_with_box:
             return None
 
         if self.selection_strategy == "largest":
-            face = faces[0]
+            _, bbox = faces_with_box[0]
         elif self.selection_strategy == "centered":
             frame_center = (0.5, 0.5)
-            face = min(
-                faces,
-                key=lambda f: (
-                    (f.bounding_box.center[0] - frame_center[0]) ** 2
-                    + (f.bounding_box.center[1] - frame_center[1]) ** 2
-                ),
+            _, bbox = min(
+                faces_with_box,
+                key=lambda fb: ((fb[1].center[0] - frame_center[0]) ** 2 + (fb[1].center[1] - frame_center[1]) ** 2),
             )
         elif self.selection_strategy == "index":
-            if self.face_index < len(faces):
-                face = faces[self.face_index]
-            else:
-                face = faces[0]
+            idx = self.face_index if self.face_index < len(faces_with_box) else 0
+            _, bbox = faces_with_box[idx]
         else:
-            face = faces[0]
+            _, bbox = faces_with_box[0]
 
-        bbox = face.bounding_box
         return (bbox.center[0], bbox.center[1], bbox.width, bbox.height)
 
     def detect_and_track(
@@ -407,7 +402,7 @@ class FaceTracker:
 
         sampled_frames = [frames[i] for i in sample_indices]
 
-        sampled_detections: list[list] = []
+        sampled_detections: list[list[DetectedFace]] = []
         for batch_start in range(0, len(sampled_frames), self.batch_size):
             batch_end = min(batch_start + self.batch_size, len(sampled_frames))
             batch = sampled_frames[batch_start:batch_end]

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/ai/understanding/image.py

@@ -151,7 +151,7 @@ class SceneVLM:
     def _init_local(self) -> None:
         """Initialize local Qwen3.5 model."""
         import torch
-        from transformers import AutoModelForImageTextToText, AutoProcessor  # type: ignore[attr-defined]
+        from transformers import AutoModelForImageTextToText, AutoProcessor
 
         t0 = time.perf_counter()
         requested_device = self.device
@@ -275,7 +275,7 @@ class SceneVLM:
     def _generate_from_message_batch(self, messages_batch: list[list[dict[str, Any]]]) -> list[str]:
         """Run batch generation for one or more multimodal chat messages."""
         import torch
-        from qwen_vl_utils import process_vision_info  # type: ignore
+        from qwen_vl_utils import process_vision_info
 
         if self._model is None:
             self._init_local()

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/audio/audio.py

@@ -5,7 +5,7 @@ import subprocess
 import wave
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -69,7 +69,7 @@ class Audio:
         return bool(np.all(np.abs(self.data) < 1e-7))
 
     @staticmethod
-    def _get_ffmpeg_info(file_path: Path) -> dict:
+    def _get_ffmpeg_info(file_path: Path) -> dict[str, Any]:
         """Get audio metadata using ffprobe"""
         try:
             info = _ffmpeg.probe(file_path)
@@ -483,7 +483,7 @@ class Audio:
         if first.metadata.channels == 1:
             output = np.zeros(total_samples, dtype=np.float32)
         else:
-            output = np.zeros((total_samples, 2), dtype=np.float32)  # type: ignore
+            output = np.zeros((total_samples, 2), dtype=np.float32)
 
         # Copy non-crossfaded portions
         crossfade_start = len(first.data) - crossfade_samples
@@ -761,7 +761,7 @@ class Audio:
         if base.metadata.channels == 1:
             output = np.zeros(total_length, dtype=np.float32)
         else:
-            output = np.zeros((total_length, 2), dtype=np.float32)  # type: ignore
+            output = np.zeros((total_length, 2), dtype=np.float32)
 
         # Copy base audio
         output[: len(base.data)] = base.data

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/base/_ffmpeg.py

@@ -13,7 +13,7 @@ import json
 import subprocess
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Iterator, Sequence
+from typing import Any, Iterator, Sequence
 
 from videopython.base.exceptions import FFmpegProbeError, FFmpegRunError
 
@@ -44,7 +44,7 @@ def run(cmd: Sequence[str], *, stdin: bytes | None = None) -> bytes:
     return result.stdout
 
 
-def probe(path: str | Path, *, extra_args: Sequence[str] | None = None) -> dict:
+def probe(path: str | Path, *, extra_args: Sequence[str] | None = None) -> dict[str, Any]:
     """Run ffprobe and return the parsed JSON payload.
 
     Args:
@@ -76,7 +76,7 @@ def probe(path: str | Path, *, extra_args: Sequence[str] | None = None) -> dict:
         raise FFmpegProbeError(f"Error parsing ffprobe output: {e}") from e
 
 
-def _terminate(proc: subprocess.Popen, *, timeout: float = 5) -> None:
+def _terminate(proc: subprocess.Popen[bytes], *, timeout: float = 5) -> None:
     """Terminate a still-running process, escalating to kill after ``timeout``."""
     if proc.poll() is None:
         proc.terminate()
@@ -88,7 +88,7 @@ def _terminate(proc: subprocess.Popen, *, timeout: float = 5) -> None:
 
 
 @contextmanager
-def popen_decode(cmd: Sequence[str], *, bufsize: int = -1) -> Iterator[subprocess.Popen]:
+def popen_decode(cmd: Sequence[str], *, bufsize: int = -1) -> Iterator[subprocess.Popen[bytes]]:
     """Context manager wrapping an ffmpeg decode process.
 
     Yields a Popen with ``stdout=PIPE`` and ``stderr=DEVNULL``. Callers
@@ -116,7 +116,7 @@ def popen_decode(cmd: Sequence[str], *, bufsize: int = -1) -> Iterator[subproces
 
 
 @contextmanager
-def popen_encode(cmd: Sequence[str]) -> Iterator[subprocess.Popen]:
+def popen_encode(cmd: Sequence[str]) -> Iterator[subprocess.Popen[bytes]]:
     """Context manager wrapping an ffmpeg encode process via stdin pipe.
 
     Yields a Popen with ``stdin=PIPE``, ``stdout=DEVNULL``, and

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/base/_video_io.py

@@ -173,7 +173,7 @@ def decode_video(
         if frames_read == 0:
             raise ValueError("No frames were read from the video")
 
-        frames = frames[:frames_read]  # type: ignore
+        frames = frames[:frames_read]
 
         try:
             audio = Audio.from_path(path)

{videopython-0.33.1 → videopython-0.33.3}/src/videopython/base/description.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -49,7 +50,7 @@ class SceneBoundary:
         """Number of frames in this scene."""
         return self.end_frame - self.start_frame
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "start": self.start,
@@ -59,7 +60,7 @@ class SceneBoundary:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "SceneBoundary":
+    def from_dict(cls, data: dict[str, Any]) -> "SceneBoundary":
         """Create SceneBoundary from dictionary."""
         return cls(
             start=data["start"],
@@ -95,12 +96,12 @@ class BoundingBox(BaseModel):
         """Area of the bounding box (normalized)."""
         return self.width * self.height
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Backwards-compat alias for ``model_dump()``."""
         return self.model_dump()
 
     @classmethod
-    def from_dict(cls, data: dict) -> BoundingBox:
+    def from_dict(cls, data: dict[str, Any]) -> BoundingBox:
         """Backwards-compat alias for ``model_validate(data)``."""
         return cls.model_validate(data)
 
@@ -119,7 +120,7 @@ class DetectedObject:
     confidence: float
     bounding_box: BoundingBox | None = None
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "label": self.label,
@@ -128,7 +129,7 @@ class DetectedObject:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> DetectedObject:
+    def from_dict(cls, data: dict[str, Any]) -> DetectedObject:
         """Create DetectedObject from dictionary."""
         return cls(
             label=data["label"],
@@ -160,7 +161,7 @@ class DetectedFace:
         """Area of the face bounding box (normalized), or None if no bounding box."""
         return self.bounding_box.area if self.bounding_box else None
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "bounding_box": self.bounding_box.to_dict() if self.bounding_box else None,
@@ -168,7 +169,7 @@ class DetectedFace:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> DetectedFace:
+    def from_dict(cls, data: dict[str, Any]) -> DetectedFace:
         """Create DetectedFace from dictionary."""
         return cls(
             bounding_box=BoundingBox.from_dict(data["bounding_box"]) if data.get("bounding_box") else None,
@@ -190,7 +191,7 @@ class DetectedText:
     confidence: float
     bounding_box: BoundingBox | None = None
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "text": self.text,
@@ -199,7 +200,7 @@ class DetectedText:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "DetectedText":
+    def from_dict(cls, data: dict[str, Any]) -> "DetectedText":
         """Create DetectedText from dictionary."""
         return cls(
             text=data["text"],
@@ -229,7 +230,7 @@ class AudioEvent:
         """Duration of the audio event in seconds."""
         return self.end - self.start
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "start": self.start,
@@ -239,7 +240,7 @@ class AudioEvent:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> AudioEvent:
+    def from_dict(cls, data: dict[str, Any]) -> AudioEvent:
         """Create AudioEvent from dictionary."""
         return cls(
             start=data["start"],
@@ -261,7 +262,7 @@ class AudioClassification:
     events: list[AudioEvent]
     clip_predictions: dict[str, float] = field(default_factory=dict)
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "events": [event.to_dict() for event in self.events],
@@ -269,7 +270,7 @@ class AudioClassification:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "AudioClassification":
+    def from_dict(cls, data: dict[str, Any]) -> "AudioClassification":
         """Create AudioClassification from dictionary."""
         return cls(
             events=[AudioEvent.from_dict(event) for event in data.get("events", [])],
@@ -306,7 +307,7 @@ class MotionInfo:
         """Check if this frame has significant motion."""
         return self.motion_type != "static"
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         """Convert to dictionary for JSON serialization."""
         return {
             "motion_type": self.motion_type,
@@ -315,7 +316,7 @@ class MotionInfo:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> MotionInfo:
+    def from_dict(cls, data: dict[str, Any]) -> MotionInfo:
         """Create MotionInfo from dictionary."""
         return cls(
             motion_type=data["motion_type"],
@@ -344,7 +345,7 @@ class SceneDescription:
     subjects: list[str] = field(default_factory=list)
     shot_type: str | None = None
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "caption": self.caption,
             "subjects": list(self.subjects),
@@ -352,7 +353,7 @@ class SceneDescription:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "SceneDescription":
+    def from_dict(cls, data: dict[str, Any]) -> "SceneDescription":
         return cls(
             caption=str(data["caption"]),
             subjects=[str(s) for s in data.get("subjects", [])],
@@ -386,7 +387,7 @@ class FaceTrack:
         """Number of frames in this track."""
         return len(self.frame_indices)
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict[str, Any]:
         return {
             "track_id": self.track_id,
             "frame_indices": list(self.frame_indices),
@@ -395,7 +396,7 @@ class FaceTrack:
         }
 
     @classmethod
-    def from_dict(cls, data: dict) -> "FaceTrack":
+    def from_dict(cls, data: dict[str, Any]) -> "FaceTrack":
         return cls(
             track_id=int(data["track_id"]),
             frame_indices=[int(i) for i in data.get("frame_indices", [])],