typed-ffmpeg-v7 1.0.0a1__tar.gz

typed_ffmpeg_v7-1.0.0a1/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: typed-ffmpeg-v7
+Version: 1.0.0a1
+Summary: Typed FFmpeg bindings for FFmpeg 7.x
+Author-email: lucemia <lucemia@gmail.com>
+License-Expression: MIT
+Keywords: ffmpeg,video,audio,multimedia,filter,ffmpeg-7
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: ffmpeg-core<2.0,>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: syrupy>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.9.6; extra == "dev"

typed_ffmpeg_v7-1.0.0a1/pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "typed-ffmpeg-v7"
+version = "1.0.0a1"
+description = "Typed FFmpeg bindings for FFmpeg 7.x"
+authors = [
+    {name = "lucemia", email = "lucemia@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["ffmpeg", "video", "audio", "multimedia", "filter", "ffmpeg-7"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Video",
+]
+
+dependencies = ["ffmpeg-core>=1.0,<2.0"]
+
+[tool.uv.sources]
+ffmpeg-core = { workspace = true }
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "pytest-cov>=4.0", "syrupy>=5.0", "ruff>=0.9.6"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["ffmpeg*"]
+
+[tool.setuptools.package-data]
+"ffmpeg" = ["py.typed"]

typed_ffmpeg_v7-1.0.0a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

typed_ffmpeg_v7-1.0.0a1/src/ffmpeg/__init__.py

@@ -0,0 +1,34 @@
+"""
+typed-ffmpeg v7: FFmpeg 7.x type-safe Python bindings.
+
+This package provides comprehensive type hints and IDE autocomplete for FFmpeg 7.x.
+"""
+
+__version__ = "7.1.0"
+
+# Export main API functions and classes
+from ffmpeg_core.ffprobe.probe import probe
+
+# Make commonly used modules easily accessible
+from . import codecs, filters, formats, streams
+from .base import merge_outputs
+from .dag.io import input, output
+
+__all__ = [
+    "__version__",
+    "input",
+    "output",
+    "merge_outputs",
+    "probe",
+    "filters",
+    "streams",
+    "codecs",
+    "formats",
+]
+
+# Dynamically add OutputArgs methods to FilterableStream
+# This must be done after all imports to avoid circular dependencies
+from .dag.base_streams import _add_output_args_methods
+
+_add_output_args_methods()
+del _add_output_args_methods

typed_ffmpeg_v7-1.0.0a1/src/ffmpeg/base.py

@@ -0,0 +1,195 @@
+"""
+Core functions for creating and manipulating FFmpeg filter graphs.
+
+This module defines the fundamental functions for building FFmpeg filter graphs
+in typed-ffmpeg. It provides functions to create custom filters, handle
+multi-output filters, and merge output streams. These functions serve as the
+foundation for the more specialized filters defined in the filters module.
+"""
+
+from typing import Any
+
+from .dag.io._input import input
+from .dag.io._output import output
+from .dag.nodes import (
+    FilterableStream,
+    FilterNode,
+    GlobalNode,
+    GlobalStream,
+    OutputStream,
+)
+from .schema import StreamType
+from .streams.audio import AudioStream
+from .streams.video import VideoStream
+from .utils.frozendict import FrozenDict
+
+
+def merge_outputs(*streams: OutputStream) -> GlobalStream:
+    """
+    Merge multiple output streams into a single command execution.
+
+    This function combines multiple output streams that need to be executed together
+    in a single FFmpeg command. This is useful when you need to generate multiple
+    outputs from the same input(s) in a single pass, which is more efficient than
+    running separate commands.
+
+    Args:
+        *streams: Two or more output streams to be merged together
+
+    Returns:
+        A global stream representing all merged outputs
+
+    Example:
+        ```python
+        input_video = ffmpeg.input("input.mp4")
+        output1 = input_video.output("output1.mp4", vcodec="libx264")
+        output2 = input_video.output("output2.mp4", vcodec="libx265")
+        merged = ffmpeg.merge_outputs(output1, output2)
+        merged.run()  # Executes both outputs in a single FFmpeg command
+        ```
+
+    """
+    return GlobalNode(inputs=streams).stream()
+
+
+def vfilter(
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.video,),
+    **kwargs: Any,
+) -> VideoStream:
+    """
+    Apply a custom video filter that has a single video output.
+
+    This function allows you to use any FFmpeg video filter that isn't explicitly
+    implemented in typed-ffmpeg. It creates a FilterNode with a video output type
+    and returns the resulting video stream.
+
+    Args:
+        *streams: One or more input streams to apply the filter to
+        name: The FFmpeg filter name (e.g., 'hflip', 'scale', etc.)
+        input_typings: The expected types of the input streams (defaults to video)
+        **kwargs: Filter-specific parameters as keyword arguments
+
+    Returns:
+        A VideoStream representing the filtered output
+
+    Example:
+        ```python
+        # Apply a custom deflicker filter (if not directly implemented)
+        filtered = ffmpeg.vfilter(stream, name="deflicker", mode="pm", size=10)
+        ```
+
+    Note:
+        This function is for custom filters not implemented in typed-ffmpeg.
+        Use the built-in filters from the filters module when available.
+
+    """
+    return FilterNode(
+        name=name,
+        inputs=streams,
+        output_typings=(StreamType.video,),
+        input_typings=input_typings,
+        kwargs=FrozenDict(kwargs),
+    ).video(0)
+
+
+def afilter(
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.audio,),
+    **kwargs: Any,
+) -> AudioStream:
+    """
+    Apply a custom audio filter that has a single audio output.
+
+    This function allows you to use any FFmpeg audio filter that isn't explicitly
+    implemented in typed-ffmpeg. It creates a FilterNode with an audio output type
+    and returns the resulting audio stream.
+
+    Args:
+        *streams: One or more input streams to apply the filter to
+        name: The FFmpeg filter name (e.g., 'equalizer', 'dynaudnorm', etc.)
+        input_typings: The expected types of the input streams (defaults to audio)
+        **kwargs: Filter-specific parameters as keyword arguments
+
+    Returns:
+        An AudioStream representing the filtered output
+
+    Example:
+        ```python
+        # Apply a custom audio compressor filter (if not directly implemented)
+        compressed = ffmpeg.afilter(stream, name="acompressor", threshold=0.1, ratio=2)
+        ```
+
+    Note:
+        This function is for custom filters not implemented in typed-ffmpeg.
+        Use the built-in filters from the filters module when available.
+
+    """
+    return FilterNode(
+        name=name,
+        inputs=streams,
+        output_typings=(StreamType.audio,),
+        input_typings=input_typings,
+        kwargs=FrozenDict(kwargs),
+    ).audio(0)
+
+
+def filter_multi_output(
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (),
+    output_typings: tuple[StreamType, ...] = (),
+    **kwargs: Any,
+) -> FilterNode:
+    """
+    Apply a custom filter that produces multiple output streams.
+
+    This function allows you to use any FFmpeg filter that generates multiple outputs
+    (like split, asplit, or complex filters). Unlike vfilter and afilter which return
+    a single stream, this returns a FilterNode that you can extract specific outputs from.
+
+    Args:
+        *streams: One or more input streams to apply the filter to
+        name: The FFmpeg filter name (e.g., 'split', 'channelsplit', etc.)
+        input_typings: The expected types of the input streams
+        output_typings: The expected types of each output stream
+        **kwargs: Filter-specific parameters as keyword arguments
+
+    Returns:
+        A FilterNode object that you can extract specific outputs from
+        using methods like .video(0), .audio(1), etc.
+
+    Example:
+        ```python
+        # Split a video into two identical streams
+        split_node = ffmpeg.filter_multi_output(
+            stream, name="split", output_typings=(StreamType.video, StreamType.video)
+        )
+        stream1 = split_node.video(0)
+        stream2 = split_node.video(1)
+        ```
+
+    Note:
+        This function is for custom filters not implemented in typed-ffmpeg.
+        Use the built-in filters from the filters module when available.
+
+    """
+    return FilterNode(
+        name=name,
+        kwargs=FrozenDict(kwargs),
+        inputs=streams,
+        input_typings=input_typings,
+        output_typings=output_typings,
+    )
+
+
+__all__ = [
+    "input",
+    "output",
+    "merge_outputs",
+    "vfilter",
+    "afilter",
+    "filter_multi_output",
+]