typed-ffmpeg-compatible 3.5.1__py3-none-any.whl → 3.6__py3-none-any.whl

typed_ffmpeg/ffprobe/__init__.py

@@ -0,0 +1 @@
+"""FFprobe utilities for media file analysis."""

typed_ffmpeg/ffprobe/parse.py

@@ -1,4 +1,6 @@
-#!/usr/bin/env python3
+"""FFprobe XML parsing utilities."""
+
+# !/usr/bin/env python3
 
 import json
 import types
@@ -29,6 +31,7 @@ def _get_actual_type(type_hint: Any) -> type[Any]:
 
     Returns:
         The actual type
+
     """
     # If type_hint is a string, evaluate it in the schema's module context
     if isinstance(type_hint, str):
@@ -57,6 +60,7 @@ def is_dataclass_type(obj: type[Any]) -> TypeGuard[type[T]]:
 
     Returns:
         True if the object is a dataclass type, False otherwise
+
     """
     return is_dataclass(obj)
 
@@ -71,6 +75,7 @@ def _parse_obj_from_dict(data: Any, cls: type[T]) -> T | None:
 
     Returns:
         The parsed dataclass instance
+
     """
     if data is None:
         return None
@@ -125,6 +130,7 @@ def parse_ffprobe(xml_string: str) -> ffprobeType:
 
     Returns:
         The parsed ffprobeType instance
+
     """
     json_str = xml_string_to_json(xml_string)
     json_dict = json.loads(json_str)

typed_ffmpeg/ffprobe/probe.py

@@ -79,6 +79,7 @@ def _probe(
         print(f"Duration: {float(info['format']['duration']):.2f} seconds")
         print(f"Streams: {len(info['streams'])}")
         ```
+
     """
     args = [
         cmd,
@@ -172,6 +173,7 @@ def probe(
         print(f"Duration: {float(info['format']['duration']):.2f} seconds")
         print(f"Streams: {len(info['streams'])}")
         ```
+
     """
     return json.loads(
         _probe(
@@ -250,8 +252,8 @@ def probe_obj(
         print(f"Duration: {float(info.format.duration):.2f} seconds")
         print(f"Streams: {len(info.streams)}")
         ```
-    """
 
+    """
     xml = _probe(
         filename,
         show_program_version=show_program_version,

typed_ffmpeg/ffprobe/schema.py

@@ -1,4 +1,6 @@
-#!/usr/bin/env python3
+"""FFprobe XML schema definitions."""
+
+# !/usr/bin/env python3
 
 from dataclasses import dataclass
 from typing import Optional
@@ -6,6 +8,8 @@ from typing import Optional
 
 @dataclass(kw_only=True, frozen=True)
 class ffprobeType:
+    """Root type for FFprobe XML output."""
+
     program_version: Optional["programVersionType"] = None
     library_versions: Optional["libraryVersionsType"] = None
     pixel_formats: Optional["pixelFormatsType"] = None
@@ -21,17 +25,23 @@ class ffprobeType:
 
 @dataclass(kw_only=True, frozen=True)
 class packetsType:
+    """Container for packet information."""
+
     packet: tuple["packetType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class framesType:
+    """Container for frame information."""
+
     frame: tuple["frameType", ...] | None = None
     subtitle: tuple["subtitleType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class packetsAndFramesType:
+    """Container for both packet and frame information."""
+
     packet: tuple["packetType", ...] | None = None
     frame: tuple["frameType", ...] | None = None
     subtitle: tuple["subtitleType", ...] | None = None
@@ -39,11 +49,15 @@ class packetsAndFramesType:
 
 @dataclass(kw_only=True, frozen=True)
 class tagsType:
+    """Container for tag information."""
+
     tag: tuple["tagType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class packetType:
+    """Information about a single packet."""
+
     tags: Optional["tagsType"] = None
     side_data_list: Optional["packetSideDataListType"] = None
     codec_type: str | None = None
@@ -63,23 +77,31 @@ class packetType:
 
 @dataclass(kw_only=True, frozen=True)
 class packetSideDataListType:
+    """Container for packet side data information."""
+
     side_data: tuple["packetSideDataType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class packetSideDataType:
+    """Information about packet side data."""
+
     side_datum: tuple["packetSideDatumType", ...] | None = None
     type: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class packetSideDatumType:
+    """Individual packet side data item."""
+
     key: str | None = None
     value: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameType:
+    """Information about a single frame."""
+
     tags: Optional["tagsType"] = None
     logs: Optional["logsType"] = None
     side_data_list: Optional["frameSideDataListType"] = None
@@ -125,11 +147,15 @@ class frameType:
 
 @dataclass(kw_only=True, frozen=True)
 class logsType:
+    """Container for log information."""
+
     log: tuple["logType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class logType:
+    """Information about a single log entry."""
+
     context: str | None = None
     level: int | None = None
     category: int | None = None
@@ -140,11 +166,15 @@ class logType:
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataListType:
+    """Container for frame side data information."""
+
     side_data: tuple["frameSideDataType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataType:
+    """Information about frame side data."""
+
     timecodes: Optional["frameSideDataTimecodeList"] = None
     components: Optional["frameSideDataComponentList"] = None
     side_datum: tuple["frameSideDatumType", ...] | None = None
@@ -155,43 +185,59 @@ class frameSideDataType:
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDatumType:
+    """Individual frame side data item."""
+
     key: str | None = None
     value: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataTimecodeList:
+    """Container for frame side data timecode information."""
+
     timecode: tuple["frameSideDataTimecodeType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataTimecodeType:
+    """Information about frame side data timecode."""
+
     value: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataComponentList:
+    """Container for frame side data component information."""
+
     component: tuple["frameSideDataComponentType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataComponentType:
+    """Information about frame side data component."""
+
     pieces: Optional["frameSideDataPieceList"] = None
     side_datum: tuple["frameSideDatumType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataPieceList:
+    """Container for frame side data piece information."""
+
     piece: tuple["frameSideDataPieceType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class frameSideDataPieceType:
+    """Information about frame side data piece."""
+
     side_datum: tuple["frameSideDatumType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class subtitleType:
+    """Information about a subtitle frame."""
+
     media_type: str | None = None
     pts: int | None = None
     pts_time: float | None = None
@@ -203,16 +249,22 @@ class subtitleType:
 
 @dataclass(kw_only=True, frozen=True)
 class streamsType:
+    """Container for stream information."""
+
     stream: tuple["streamType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class programsType:
+    """Container for program information."""
+
     program: tuple["programType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class streamDispositionType:
+    """Information about stream disposition flags."""
+
     default: int | None = None
     dub: int | None = None
     original: int | None = None
@@ -235,6 +287,8 @@ class streamDispositionType:
 
 @dataclass(kw_only=True, frozen=True)
 class streamType:
+    """Information about a single stream."""
+
     disposition: Optional["streamDispositionType"] = None
     tags: Optional["tagsType"] = None
     side_data_list: Optional["packetSideDataListType"] = None
@@ -290,6 +344,8 @@ class streamType:
 
 @dataclass(kw_only=True, frozen=True)
 class programType:
+    """Information about a single program."""
+
     tags: Optional["tagsType"] = None
     streams: Optional["streamsType"] = None
     program_id: int | None = None
@@ -301,6 +357,8 @@ class programType:
 
 @dataclass(kw_only=True, frozen=True)
 class formatType:
+    """Information about the media format."""
+
     tags: Optional["tagsType"] = None
     filename: str | None = None
     nb_streams: int | None = None
@@ -317,18 +375,24 @@ class formatType:
 
 @dataclass(kw_only=True, frozen=True)
 class tagType:
+    """Information about a single tag."""
+
     key: str | None = None
     value: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class errorType:
+    """Information about an error."""
+
     code: int | None = None
     string: str | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class programVersionType:
+    """Information about the program version."""
+
     version: str | None = None
     copyright: str | None = None
     build_date: str | None = None
@@ -339,11 +403,15 @@ class programVersionType:
 
 @dataclass(kw_only=True, frozen=True)
 class chaptersType:
+    """Container for chapter information."""
+
     chapter: tuple["chapterType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class chapterType:
+    """Information about a single chapter."""
+
     tags: tuple["tagsType", ...] | None = None
     id: int | None = None
     time_base: str | None = None
@@ -355,6 +423,8 @@ class chapterType:
 
 @dataclass(kw_only=True, frozen=True)
 class libraryVersionType:
+    """Information about a library version."""
+
     name: str | None = None
     major: int | None = None
     minor: int | None = None
@@ -365,11 +435,15 @@ class libraryVersionType:
 
 @dataclass(kw_only=True, frozen=True)
 class libraryVersionsType:
+    """Container for library version information."""
+
     library_version: tuple["libraryVersionType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class pixelFormatFlagsType:
+    """Information about pixel format flags."""
+
     big_endian: int | None = None
     palette: int | None = None
     bitstream: int | None = None
@@ -381,17 +455,23 @@ class pixelFormatFlagsType:
 
 @dataclass(kw_only=True, frozen=True)
 class pixelFormatComponentType:
+    """Information about a pixel format component."""
+
     index: int | None = None
     bit_depth: int | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class pixelFormatComponentsType:
+    """Container for pixel format component information."""
+
     component: tuple["pixelFormatComponentType", ...] | None = None
 
 
 @dataclass(kw_only=True, frozen=True)
 class pixelFormatType:
+    """Information about a pixel format."""
+
     flags: Optional["pixelFormatFlagsType"] = None
     components: Optional["pixelFormatComponentsType"] = None
     name: str | None = None
@@ -403,6 +483,8 @@ class pixelFormatType:
 
 @dataclass(kw_only=True, frozen=True)
 class pixelFormatsType:
+    """Container for pixel format information."""
+
     pixel_format: tuple["pixelFormatType", ...] | None = None
 
 

typed_ffmpeg/ffprobe/xml2json.py

@@ -1,10 +1,13 @@
+"""XML to JSON conversion utilities for FFprobe output."""
+
 import json
 import xml.etree.ElementTree as ET
 from typing import Any, cast
 
 
 def xml_to_dict(element: ET.Element) -> dict[str, Any]:
-    """Convert an XML Element to a dictionary representation.
+    """
+    Convert an XML Element to a dictionary representation.
 
     This function recursively converts an XML Element and its children into a nested
     dictionary structure. Attributes are preserved as dictionary keys, and text content
@@ -19,6 +22,7 @@ def xml_to_dict(element: ET.Element) -> dict[str, Any]:
             - Child elements are stored as nested dictionaries
             - Multiple elements with the same tag are stored as lists
             - Text content is stored under the 'text' key
+
     """
     node: dict[str, Any] = {}
     if element.attrib:
@@ -43,7 +47,8 @@ def xml_to_dict(element: ET.Element) -> dict[str, Any]:
 
 
 def xml_string_to_json(xml_string: str) -> str:
-    """Convert an XML string to a JSON string.
+    """
+    Convert an XML string to a JSON string.
 
     This function takes an XML string, parses it into an ElementTree structure,
     converts it to a dictionary using xml_to_dict, and then serializes it to a JSON string.
@@ -65,6 +70,7 @@ def xml_string_to_json(xml_string: str) -> str:
             }
           }
         }'
+
     """
     root = ET.fromstring(xml_string)
     return json.dumps({root.tag: xml_to_dict(root)}, indent=2)