typed-ffmpeg-compatible 3.0.2a0__py3-none-any.whl → 3.2.1__py3-none-any.whl

typed_ffmpeg/__init__.py

@@ -26,8 +26,8 @@ from . import compile, dag, filters, sources
 from .base import afilter, filter_multi_output, input, merge_outputs, output, vfilter
 from .dag import Stream
 from .exceptions import FFMpegExecuteError, FFMpegTypeError, FFMpegValueError
+from .ffprobe.probe import probe, probe_obj
 from .info import get_codecs, get_decoders, get_encoders
-from .probe import probe
 from .streams import AudioStream, AVStream, VideoStream
 
 __all__ = [
@@ -41,6 +41,7 @@ __all__ = [
     "FFMpegValueError",
     "Stream",
     "probe",
+    "probe_obj",
     "compile",
     "AudioStream",
     "VideoStream",

typed_ffmpeg/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '3.2.1'
+__version_tuple__ = version_tuple = (3, 2, 1)

typed_ffmpeg/compile/compile_cli.py

@@ -21,13 +21,10 @@ import shlex
 from collections import defaultdict
 from collections.abc import Mapping
 
-from ffmpeg.dag.factory import filter_node_factory
-from ffmpeg.streams.audio import AudioStream
-from ffmpeg.streams.video import VideoStream
-
 from ..base import input, merge_outputs, output
 from ..common.cache import load
 from ..common.schema import FFMpegFilter, FFMpegFilterDef, FFMpegOption, StreamType
+from ..dag.factory import filter_node_factory
 from ..dag.nodes import (
     FilterableStream,
     FilterNode,
@@ -39,7 +36,9 @@ from ..dag.nodes import (
 from ..dag.schema import Node, Stream
 from ..exceptions import FFMpegValueError
 from ..schema import Default
+from ..streams.audio import AudioStream
 from ..streams.av import AVStream
+from ..streams.video import VideoStream
 from ..utils.escaping import escape
 from ..utils.lazy_eval.schema import LazyValue
 from ..utils.run import command_line
@@ -153,6 +152,15 @@ def parse_output(
             stream = parse_stream_selector(map_option, in_streams)
             inputs.append(stream)
 
+        if not inputs:
+            # NOTE: if there is no inputs, and there is only one input node
+            if len([k for k in in_streams if isinstance(in_streams[k], AVStream)]) == 1:
+                inputs = [
+                    in_streams[k]
+                    for k in in_streams
+                    if isinstance(in_streams[k], AVStream)
+                ]
+
         assert inputs, f"No inputs found for output {filename}"
         export.append(output(*inputs, filename=filename, extra_options=options))
         buffer = []
@@ -677,6 +685,22 @@ def get_args_output_node(node: OutputNode, context: DAGContext) -> list[str]:
     if context:
         for input in node.inputs:
             if isinstance(input.node, InputNode):
+                # NOTE: specially rules,
+                # if there is only one input node,
+                # only one output node,
+                # the output node has only one input,
+                # and the stream selector is not specified,
+                # then the map can be ignore.
+                if (
+                    input.index is None
+                    and isinstance(input, AVStream)
+                    and len([k for k in context.all_nodes if isinstance(k, InputNode)])
+                    == 1
+                    and len([k for k in context.all_nodes if isinstance(k, OutputNode)])
+                    == 1
+                    and len(node.inputs) == 1
+                ):
+                    continue
                 commands += ["-map", get_stream_label(input, context)]
             else:
                 commands += ["-map", f"[{get_stream_label(input, context)}]"]

typed_ffmpeg/compile/compile_python.py

@@ -3,10 +3,6 @@ from __future__ import annotations
 from collections.abc import Mapping
 from typing import Any
 
-from ffmpeg.streams.audio import AudioStream
-from ffmpeg.streams.av import AVStream
-from ffmpeg.streams.video import VideoStream
-
 from ..common.cache import load
 from ..common.schema import FFMpegFilter
 from ..dag.nodes import (
@@ -19,6 +15,9 @@ from ..dag.nodes import (
     OutputStream,
 )
 from ..dag.schema import Node, Stream
+from ..streams.audio import AudioStream
+from ..streams.av import AVStream
+from ..streams.video import VideoStream
 from .context import DAGContext
 from .validate import validate
 

typed_ffmpeg/ffprobe/parse.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+
+import json
+import types
+from dataclasses import is_dataclass
+from typing import (
+    Any,
+    TypeGuard,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from .schema import ffprobeType, registered_types
+from .xml2json import xml_string_to_json
+
+T = TypeVar("T")
+
+
+def _get_actual_type(type_hint: Any) -> type[Any]:
+    """
+    Get the actual type from a type hint, handling Optional and Union (including | syntax).
+
+    Args:
+        type_hint: The type hint to get the actual type from
+
+    Returns:
+        The actual type
+    """
+    # If type_hint is a string, evaluate it in the schema's module context
+    if isinstance(type_hint, str):
+        type_hint = registered_types[type_hint]
+
+    origin = get_origin(type_hint)
+    # Handle typing.Union and types.UnionType (for int | None in Python 3.10+)
+    if origin is Union or (hasattr(types, "UnionType") and origin is types.UnionType):
+        non_none_types = [t for t in get_args(type_hint) if t is not type(None)]
+        if non_none_types:
+            return _get_actual_type(non_none_types[0])
+    # Handle direct types.UnionType (for int | None in Python 3.10+)
+    if hasattr(types, "UnionType") and isinstance(type_hint, types.UnionType):
+        non_none_types = [t for t in type_hint.__args__ if t is not type(None)]
+        if non_none_types:
+            return _get_actual_type(non_none_types[0])
+    return type_hint
+
+
+def is_dataclass_type(obj: type[Any]) -> TypeGuard[type[T]]:
+    """
+    Check if an object is a dataclass type.
+
+    Args:
+        obj: The object to check
+
+    Returns:
+        True if the object is a dataclass type, False otherwise
+    """
+    return is_dataclass(obj)
+
+
+def _parse_obj_from_dict(data: Any, cls: type[T]) -> T | None:
+    """
+    Parse a dictionary into a dataclass instance.
+
+    Args:
+        data: The dictionary to parse
+        cls: The dataclass to parse into
+
+    Returns:
+        The parsed dataclass instance
+    """
+
+    if data is None:
+        return None
+
+    if isinstance(cls, type):
+        if cls is str:
+            return cast(T, str(data))
+        elif cls is int:
+            return cast(T, int(data))
+        elif cls is float:
+            return cast(T, float(data))
+        elif cls is bool:
+            return cast(T, bool(data))
+
+    if not isinstance(data, dict):
+        return cls()
+
+    if isinstance(cls, str):  # NOTE: python 3.10
+        cls = registered_types[cls]
+
+    type_hints = get_type_hints(cls)
+    kwargs: dict[str, Any] = {}
+
+    for field_name, field_type in type_hints.items():
+        actual_type = _get_actual_type(field_type)
+
+        if get_origin(actual_type) is tuple:
+            tuple_args = get_args(actual_type)
+            if not tuple_args:
+                continue
+            item_type = tuple_args[0]
+            value = data.get(field_name, [])
+            if not isinstance(value, list):
+                value = [value]
+            kwargs[field_name] = tuple(
+                _parse_obj_from_dict(item, item_type) for item in value
+            )
+            continue
+
+        kwargs[field_name] = _parse_obj_from_dict(data.get(field_name), actual_type)
+
+    return cls(**kwargs)
+
+
+def parse_ffprobe(xml_string: str) -> ffprobeType:
+    """
+    Parse ffprobe XML output into ffprobeType dataclass using JSON dict.
+
+    Args:
+        xml_string: The XML string to parse
+
+    Returns:
+        The parsed ffprobeType instance
+    """
+    json_str = xml_string_to_json(xml_string)
+    json_dict = json.loads(json_str)
+    # The root key is 'ffprobe'
+    root_data = json_dict.get("ffprobe", json_dict)
+    return _parse_obj_from_dict(root_data, ffprobeType) or ffprobeType()

typed_ffmpeg/ffprobe/probe.py

@@ -0,0 +1,272 @@
+"""
+Module for analyzing media files with ffprobe.
+
+This module provides functionality to extract detailed metadata from media files
+using FFmpeg's ffprobe utility. It returns a structured representation of the
+file's format, streams, and other relevant information.
+"""
+
+import json
+import logging
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from ..exceptions import FFMpegExecuteError
+from ..utils.escaping import convert_kwargs_to_cmd_line_args
+from ..utils.run import command_line
+from .parse import parse_ffprobe
+from .schema import ffprobeType
+
+logger = logging.getLogger(__name__)
+
+
+def _probe(
+    filename: str | Path,
+    *,
+    show_program_version: bool = False,
+    show_library_versions: bool = False,
+    show_pixel_formats: bool = False,
+    show_packets: bool = False,
+    show_frames: bool = False,
+    show_programs: bool = False,
+    show_streams: bool = True,
+    show_chapters: bool = False,
+    show_format: bool = True,
+    show_error: bool = False,
+    cmd: str = "ffprobe",
+    timeout: int | None = None,
+    format: str = "json",
+    **kwargs: Any,
+) -> str:
+    """
+    Analyze a media file using ffprobe and return its metadata as a dictionary.
+
+    This function executes ffprobe to extract detailed information about a media file,
+    including format metadata (container format, duration, bitrate) and stream information
+    (codecs, resolution, sample rate, etc). The result is returned as a Python dictionary
+    parsed from ffprobe's JSON output.
+
+    Args:
+        filename: Path to the media file to analyze
+        cmd: Path or name of the ffprobe executable
+        timeout: Maximum time in seconds to wait for ffprobe to complete (default: None, wait indefinitely)
+        show_program_version: Show the program version
+        show_library_versions: Show the library versions
+        show_pixel_formats: Show the pixel formats
+        show_packets: Show the packets. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_frames: Show the frames. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_programs: Show the programs
+        show_streams: Show the streams
+        show_chapters: Show the chapters
+        show_format: Show the format
+        show_error: Show the error
+        **kwargs: Additional arguments to pass to ffprobe as command line parameters
+            (e.g., loglevel="quiet", skip_frame="nokey")
+
+    Returns:
+        A dictionary containing the parsed JSON output from ffprobe with format and stream information
+
+    Raises:
+        FFMpegExecuteError: If ffprobe returns a non-zero exit code
+        subprocess.TimeoutExpired: If the timeout is reached before ffprobe completes
+
+    Example:
+        ```python
+        info = probe("video.mp4")
+        print(f"Duration: {float(info['format']['duration']):.2f} seconds")
+        print(f"Streams: {len(info['streams'])}")
+        ```
+    """
+    args = [
+        cmd,
+        *(["-show_program_version"] if show_program_version else []),
+        *(["-show_library_versions"] if show_library_versions else []),
+        *(["-show_pixel_formats"] if show_pixel_formats else []),
+        *(["-show_packets"] if show_packets else []),
+        *(["-show_frames"] if show_frames else []),
+        *(["-show_programs"] if show_programs else []),
+        *(["-show_streams"] if show_streams else []),
+        *(["-show_chapters"] if show_chapters else []),
+        *(["-show_format"] if show_format else []),
+        *(["-show_error"] if show_error else []),
+        "-of",
+        format,
+    ]
+    args += convert_kwargs_to_cmd_line_args(kwargs)
+    args += [str(filename)]
+
+    logger.info("Running ffprobe command: %s", command_line(args))
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+
+    if timeout is not None:
+        out, err = p.communicate(timeout=timeout)
+    else:
+        out, err = p.communicate()
+
+    retcode = p.poll()
+    if p.returncode != 0:
+        raise FFMpegExecuteError(
+            retcode=retcode, cmd=command_line(args), stdout=out, stderr=err
+        )
+
+    return out.decode("utf-8")
+
+
+def probe(
+    filename: str | Path,
+    *,
+    show_program_version: bool = False,
+    show_library_versions: bool = False,
+    show_pixel_formats: bool = False,
+    show_packets: bool = False,
+    show_frames: bool = False,
+    show_programs: bool = False,
+    show_streams: bool = True,
+    show_chapters: bool = False,
+    show_format: bool = True,
+    show_error: bool = False,
+    cmd: str = "ffprobe",
+    timeout: int | None = None,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    """
+    Analyze a media file using ffprobe and return its metadata as a dictionary.
+
+    This function executes ffprobe to extract detailed information about a media file,
+    including format metadata (container format, duration, bitrate) and stream information
+    (codecs, resolution, sample rate, etc). The result is returned as a Python dictionary
+    parsed from ffprobe's JSON output.
+
+    Args:
+        filename: Path to the media file to analyze
+        cmd: Path or name of the ffprobe executable
+        timeout: Maximum time in seconds to wait for ffprobe to complete (default: None, wait indefinitely)
+        show_program_version: Show the program version
+        show_library_versions: Show the library versions
+        show_pixel_formats: Show the pixel formats
+        show_packets: Show the packets. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_frames: Show the frames. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_programs: Show the programs
+        show_streams: Show the streams
+        show_chapters: Show the chapters
+        show_format: Show the format
+        show_error: Show the error
+        **kwargs: Additional arguments to pass to ffprobe as command line parameters
+            (e.g., loglevel="quiet", skip_frame="nokey")
+
+    Returns:
+        A dictionary containing the parsed JSON output from ffprobe with format and stream information
+
+    Raises:
+        FFMpegExecuteError: If ffprobe returns a non-zero exit code
+        subprocess.TimeoutExpired: If the timeout is reached before ffprobe completes
+
+    Example:
+        ```python
+        info = probe("video.mp4")
+        print(f"Duration: {float(info['format']['duration']):.2f} seconds")
+        print(f"Streams: {len(info['streams'])}")
+        ```
+    """
+    return json.loads(
+        _probe(
+            filename,
+            show_program_version=show_program_version,
+            show_library_versions=show_library_versions,
+            show_pixel_formats=show_pixel_formats,
+            show_packets=show_packets,
+            show_frames=show_frames,
+            show_programs=show_programs,
+            show_streams=show_streams,
+            show_chapters=show_chapters,
+            show_format=show_format,
+            show_error=show_error,
+            cmd=cmd,
+            timeout=timeout,
+            **kwargs,
+        )
+    )
+
+
+def probe_obj(
+    filename: str | Path,
+    *,
+    show_program_version: bool = False,
+    show_library_versions: bool = False,
+    show_pixel_formats: bool = False,
+    show_packets: bool = False,
+    show_frames: bool = False,
+    show_programs: bool = False,
+    show_streams: bool = True,
+    show_chapters: bool = False,
+    show_format: bool = True,
+    show_error: bool = False,
+    cmd: str = "ffprobe",
+    timeout: int | None = None,
+    **kwargs: Any,
+) -> ffprobeType | None:
+    """
+    Analyze a media file using ffprobe and return its metadata as a dataclass.
+
+    This function executes ffprobe to extract detailed information about a media file,
+    including format metadata (container format, duration, bitrate) and stream information
+    (codecs, resolution, sample rate, etc). The result is returned as a Python dataclass
+    parsed from ffprobe's output.
+
+    Args:
+        filename: Path to the media file to analyze
+        cmd: Path or name of the ffprobe executable
+        timeout: Maximum time in seconds to wait for ffprobe to complete (default: None, wait indefinitely)
+        show_program_version: Show the program version
+        show_library_versions: Show the library versions
+        show_pixel_formats: Show the pixel formats
+        show_packets: Show the packets. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_frames: Show the frames. Note: When both show_packets and show_frames are True,
+            ffprobe will output a combined "packets_and_frames" section instead of separate sections.
+        show_programs: Show the programs
+        show_streams: Show the streams
+        show_chapters: Show the chapters
+        show_format: Show the format
+        show_error: Show the error
+        **kwargs: Additional arguments to pass to ffprobe as command line parameters
+            (e.g., loglevel="quiet", skip_frame="nokey")
+
+    Returns:
+        A dataclass containing the parsed ffprobe output
+
+    Raises:
+        FFMpegExecuteError: If ffprobe returns a non-zero exit code
+        subprocess.TimeoutExpired: If the timeout is reached before ffprobe completes
+
+    Example:
+        ```python
+        info = probe_obj("video.mp4")
+        print(f"Duration: {float(info.format.duration):.2f} seconds")
+        print(f"Streams: {len(info.streams)}")
+        ```
+    """
+
+    xml = _probe(
+        filename,
+        show_program_version=show_program_version,
+        show_library_versions=show_library_versions,
+        show_pixel_formats=show_pixel_formats,
+        show_packets=show_packets,
+        show_frames=show_frames,
+        show_programs=show_programs,
+        show_streams=show_streams,
+        show_chapters=show_chapters,
+        show_format=show_format,
+        show_error=show_error,
+        cmd=cmd,
+        timeout=timeout,
+        format="xml",
+        **kwargs,
+    )
+    return parse_ffprobe(xml)