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

typed_ffmpeg/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '3.6'
-__version_tuple__ = version_tuple = (3, 6)
+__version__ = version = '3.7.1'
+__version_tuple__ = version_tuple = (3, 7, 1)
+
+__commit_id__ = commit_id = None

typed_ffmpeg/common/serialize.py

@@ -259,4 +259,4 @@ def dumps(instance: Any) -> str:
 
     """
     obj = to_dict_with_class_info(instance)
-    return json.dumps(obj, indent=2)
+    return json.dumps(obj, indent=2, sort_keys=True)

typed_ffmpeg/dag/io/_output.py

@@ -154,7 +154,7 @@ def output(
         program: add program with specified streams
         stream_group: add stream group with specified streams and group type-specific arguments
         dframes: set the number of data frames to output
-        target: specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\ "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")
+        target: specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")
         shortest: finish encoding within shortest input
         shortest_buf_duration: maximum buffering duration (in seconds) for the -shortest option
         bitexact: bitexact mode

typed_ffmpeg/dag/io/output_args.py

@@ -164,8 +164,7 @@ class OutputArgs(ABC):
             program: add program with specified streams
             stream_group: add stream group with specified streams and group type-specific arguments
             dframes: set the number of data frames to output
-            target: specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\
-        "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")
+            target: specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")
             shortest: finish encoding within shortest input
             shortest_buf_duration: maximum buffering duration (in seconds) for the -shortest option
             bitexact: bitexact mode

typed_ffmpeg/filters.py

@@ -3289,6 +3289,64 @@ def overlay(
     return filter_node.video(0)
 
 
+def overlay_cuda(
+    _main: VideoStream,
+    _overlay: VideoStream,
+    *,
+    x: String = Default("0"),
+    y: String = Default("0"),
+    eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default("repeat"),
+    eval: Int | Literal["init", "frame"] | Default = Default("frame"),
+    shortest: Boolean = Default("false"),
+    repeatlast: Boolean = Default("true"),
+    framesync_options: FFMpegFrameSyncOption | None = None,
+    extra_options: dict[str, Any] | None = None,
+) -> VideoStream:
+    """
+
+    Overlay one video on top of another using CUDA.
+
+    Args:
+        x: set the x expression of overlay (default "0")
+        y: set the y expression of overlay (default "0")
+        eof_action: Action to take when encountering EOF from secondary input (from 0 to 2) (default repeat)
+        eval: specify when to evaluate expressions (from 0 to 1) (default frame)
+        shortest: force termination when the shortest input terminates (default false)
+        repeatlast: repeat overlay of the last overlay frame (default true)
+        framesync_options: Framesync options
+        extra_options: Extra options for the filter
+
+    Returns:
+        default: the video stream
+
+    References:
+        [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#overlay_005fcuda)
+
+    """
+    filter_node = filter_node_factory(
+        FFMpegFilterDef(
+            name="overlay_cuda",
+            typings_input=("video", "video"),
+            typings_output=("video",),
+        ),
+        _main,
+        _overlay,
+        **merge(
+            {
+                "x": x,
+                "y": y,
+                "eof_action": eof_action,
+                "eval": eval,
+                "shortest": shortest,
+                "repeatlast": repeatlast,
+            },
+            extra_options,
+            framesync_options,
+        ),
+    )
+    return filter_node.video(0)
+
+
 def overlay_opencl(
     _main: VideoStream,
     _overlay: VideoStream,

typed_ffmpeg/sources.py

@@ -789,7 +789,7 @@ def avsynctest(
     )
     return (
         filter_node.audio(0),
-        filter_node.video(1),
+        filter_node.video(0),
     )
 
 

typed_ffmpeg/streams/video.py

@@ -625,6 +625,49 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def bilateral_cuda(
+        self,
+        *,
+        sigmaS: Float = Default("0.1"),
+        sigmaR: Float = Default("0.1"),
+        window_size: Int = Default("1"),
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        GPU accelerated bilateral filter.
+
+        Args:
+            sigmaS: set spatial sigma (from 0.1 to 512) (default 0.1)
+            sigmaR: set range sigma (from 0.1 to 512) (default 0.1)
+            window_size: set neighbours window_size (from 1 to 255) (default 1)
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#bilateral_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="bilateral_cuda",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
+            self,
+            **merge(
+                {
+                    "sigmaS": sigmaS,
+                    "sigmaR": sigmaR,
+                    "window_size": window_size,
+                },
+                extra_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def bitplanenoise(
         self,
         *,
@@ -690,7 +733,7 @@ class VideoStream(FilterableStream):
             default: the video stream
 
         References:
-            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#blackdetect)
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#blackdetect_002c-blackdetect_005fvulkan)
 
         """
         filter_node = filter_node_factory(
@@ -1367,6 +1410,54 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def bwdif_cuda(
+        self,
+        *,
+        mode: Int
+        | Literal[
+            "send_frame", "send_field", "send_frame_nospatial", "send_field_nospatial"
+        ]
+        | Default = Default("send_frame"),
+        parity: Int | Literal["tff", "bff", "auto"] | Default = Default("auto"),
+        deint: Int | Literal["all", "interlaced"] | Default = Default("all"),
+        timeline_options: FFMpegTimelineOption | None = None,
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        Deinterlace CUDA frames.
+
+        Args:
+            mode: specify the interlacing mode (from 0 to 3) (default send_frame)
+            parity: specify the assumed picture field parity (from -1 to 1) (default auto)
+            deint: specify which frames to deinterlace (from 0 to 1) (default all)
+            timeline_options: Timeline options
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#bwdif_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="bwdif_cuda", typings_input=("video",), typings_output=("video",)
+            ),
+            self,
+            **merge(
+                {
+                    "mode": mode,
+                    "parity": parity,
+                    "deint": deint,
+                },
+                extra_options,
+                timeline_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def bwdif_vulkan(
         self,
         *,
@@ -1620,6 +1711,52 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def chromakey_cuda(
+        self,
+        *,
+        color: Color = Default("black"),
+        similarity: Float = Default("0.01"),
+        blend: Float = Default("0"),
+        yuv: Boolean = Default("false"),
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        GPU accelerated chromakey filter.
+
+        Args:
+            color: set the chromakey key color (default "black")
+            similarity: set the chromakey similarity value (from 0.01 to 1) (default 0.01)
+            blend: set the chromakey key blend value (from 0 to 1) (default 0)
+            yuv: color parameter is in yuv instead of rgb (default false)
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#chromakey_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="chromakey_cuda",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
+            self,
+            **merge(
+                {
+                    "color": color,
+                    "similarity": similarity,
+                    "blend": blend,
+                    "yuv": yuv,
+                },
+                extra_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def chromanr(
         self,
         *,
@@ -2736,6 +2873,43 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def colorspace_cuda(
+        self,
+        *,
+        range: Int | Literal["tv", "mpeg", "pc", "jpeg"] | Default = Default("0"),
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        CUDA accelerated video color converter.
+
+        Args:
+            range: Output video range (from 0 to 2) (default 0)
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#colorspace_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="colorspace_cuda",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
+            self,
+            **merge(
+                {
+                    "range": range,
+                },
+                extra_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def colortemperature(
         self,
         *,
@@ -9716,6 +9890,65 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def overlay_cuda(
+        self,
+        _overlay: VideoStream,
+        *,
+        x: String = Default("0"),
+        y: String = Default("0"),
+        eof_action: Int | Literal["repeat", "endall", "pass"] | Default = Default(
+            "repeat"
+        ),
+        eval: Int | Literal["init", "frame"] | Default = Default("frame"),
+        shortest: Boolean = Default("false"),
+        repeatlast: Boolean = Default("true"),
+        framesync_options: FFMpegFrameSyncOption | None = None,
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        Overlay one video on top of another using CUDA.
+
+        Args:
+            x: set the x expression of overlay (default "0")
+            y: set the y expression of overlay (default "0")
+            eof_action: Action to take when encountering EOF from secondary input (from 0 to 2) (default repeat)
+            eval: specify when to evaluate expressions (from 0 to 1) (default frame)
+            shortest: force termination when the shortest input terminates (default false)
+            repeatlast: repeat overlay of the last overlay frame (default true)
+            framesync_options: Framesync options
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#overlay_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="overlay_cuda",
+                typings_input=("video", "video"),
+                typings_output=("video",),
+            ),
+            self,
+            _overlay,
+            **merge(
+                {
+                    "x": x,
+                    "y": y,
+                    "eof_action": eof_action,
+                    "eval": eval,
+                    "shortest": shortest,
+                    "repeatlast": repeatlast,
+                },
+                extra_options,
+                framesync_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def overlay_opencl(
         self,
         _overlay: VideoStream,
@@ -11546,6 +11779,66 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def scale_cuda(
+        self,
+        *,
+        w: String = Default("iw"),
+        h: String = Default("ih"),
+        interp_algo: Int
+        | Literal["nearest", "bilinear", "bicubic", "lanczos"]
+        | Default = Default("0"),
+        format: Pix_fmt = Default("none"),
+        passthrough: Boolean = Default("true"),
+        param: Float = Default("999999"),
+        force_original_aspect_ratio: Int
+        | Literal["disable", "decrease", "increase"]
+        | Default = Default("disable"),
+        force_divisible_by: Int = Default("1"),
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        GPU accelerated video resizer.
+
+        Args:
+            w: Output video width (default "iw")
+            h: Output video height (default "ih")
+            interp_algo: Interpolation algorithm used for resizing (from 0 to 4) (default 0)
+            format: Output video pixel format (default none)
+            passthrough: Do not process frames at all if parameters match (default true)
+            param: Algorithm-Specific parameter (from -FLT_MAX to FLT_MAX) (default 999999)
+            force_original_aspect_ratio: decrease or increase w/h if necessary to keep the original AR (from 0 to 2) (default disable)
+            force_divisible_by: enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used (from 1 to 256) (default 1)
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#scale_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="scale_cuda", typings_input=("video",), typings_output=("video",)
+            ),
+            self,
+            **merge(
+                {
+                    "w": w,
+                    "h": h,
+                    "interp_algo": interp_algo,
+                    "format": format,
+                    "passthrough": passthrough,
+                    "param": param,
+                    "force_original_aspect_ratio": force_original_aspect_ratio,
+                    "force_divisible_by": force_divisible_by,
+                },
+                extra_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def scdet(
         self,
         *,
@@ -13812,6 +14105,43 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def thumbnail_cuda(
+        self,
+        *,
+        n: Int = Default("100"),
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        Select the most representative frame in a given sequence of consecutive frames.
+
+        Args:
+            n: set the frames batch size (from 2 to INT_MAX) (default 100)
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#thumbnail_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="thumbnail_cuda",
+                typings_input=("video",),
+                typings_output=("video",),
+            ),
+            self,
+            **merge(
+                {
+                    "n": n,
+                },
+                extra_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def tile(
         self,
         *,
@@ -15944,6 +16274,54 @@ class VideoStream(FilterableStream):
         )
         return filter_node.video(0)
 
+    def yadif_cuda(
+        self,
+        *,
+        mode: Int
+        | Literal[
+            "send_frame", "send_field", "send_frame_nospatial", "send_field_nospatial"
+        ]
+        | Default = Default("send_frame"),
+        parity: Int | Literal["tff", "bff", "auto"] | Default = Default("auto"),
+        deint: Int | Literal["all", "interlaced"] | Default = Default("all"),
+        timeline_options: FFMpegTimelineOption | None = None,
+        extra_options: dict[str, Any] | None = None,
+    ) -> VideoStream:
+        """
+
+        Deinterlace CUDA frames.
+
+        Args:
+            mode: specify the interlacing mode (from 0 to 3) (default send_frame)
+            parity: specify the assumed picture field parity (from -1 to 1) (default auto)
+            deint: specify which frames to deinterlace (from 0 to 1) (default all)
+            timeline_options: Timeline options
+            extra_options: Extra options for the filter
+
+        Returns:
+            default: the video stream
+
+        References:
+            [FFmpeg Documentation](https://ffmpeg.org/ffmpeg-filters.html#yadif_005fcuda)
+
+        """
+        filter_node = filter_node_factory(
+            FFMpegFilterDef(
+                name="yadif_cuda", typings_input=("video",), typings_output=("video",)
+            ),
+            self,
+            **merge(
+                {
+                    "mode": mode,
+                    "parity": parity,
+                    "deint": deint,
+                },
+                extra_options,
+                timeline_options,
+            ),
+        )
+        return filter_node.video(0)
+
     def yaepblur(
         self,
         *,

{typed_ffmpeg_compatible-3.6.dist-info → typed_ffmpeg_compatible-3.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typed-ffmpeg-compatible
-Version: 3.6
+Version: 3.7.1
 Summary: Modern Python FFmpeg wrappers offer comprehensive support for complex filters, complete with detailed typing and documentation.
 Author-email: lucemia <lucemia@gmail.com>
 License-Expression: MIT
@@ -199,3 +199,12 @@ This project is dedicated to my son, Austin, on his seventh birthday (February 2
 ---
 
 Feel free to check the [Documentation](https://livingbio.github.io/typed-ffmpeg/) for detailed information and more advanced features.
+
+## Development Setup
+
+Install all development dependencies:
+```
+uv pip install --group dev
+```
+
+No need to use requirements.in or requirements.txt anymore. All dependencies are managed in `pyproject.toml` and locked in `uv.lock`.

{typed_ffmpeg_compatible-3.6.dist-info → typed_ffmpeg_compatible-3.7.1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 typed_ffmpeg/__init__.py,sha256=oeMvHs-zZNS0BRey13UCwyaMhthxBrsWlmet2rXeKIw,1733
-typed_ffmpeg/_version.py,sha256=zHozo5CInO1y8pIQ5L0CzIoB6_255ZDJd8Kizd5-AK8,506
+typed_ffmpeg/_version.py,sha256=9MjBMdn1ZPGLj9feYeo3MHJ_MYQCg5VstClhojAgSI8,704
 typed_ffmpeg/base.py,sha256=Aq-eIkDfji8FMEGx17DCJCUnIT4wCQvbAA6rBMwW2dE,6312
 typed_ffmpeg/exceptions.py,sha256=rNHAJZXkpUQNgAlnf-R8b4cYNEMkYNNH7NLg2pyk0G0,2475
 typed_ffmpeg/expressions.py,sha256=oQnBqdkjB-1tuHxdf4udhye-qVcNsj1IeBI1t-hIeTg,19669
-typed_ffmpeg/filters.py,sha256=TQAWvxxknFDLjauWL9tt9pQjEOVSGRH3Uey7tm8tAtA,137124
+typed_ffmpeg/filters.py,sha256=v6jMMTwaMeNFlJBsW466yutHOWdDRjkBNAzQmYYt8bc,139011
 typed_ffmpeg/info.py,sha256=gnXfruqjy5KeIxcNRxy-GZRSpdOUQ8_oTn9RN79dCxA,9529
 typed_ffmpeg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 typed_ffmpeg/schema.py,sha256=xlF84RA-loeHLU0CQ1DgAujm1oop2wFuKZOfCqtDHY4,1854
-typed_ffmpeg/sources.py,sha256=PWszm9xJ5s3U3s5JLre3SkgrKqc390EKhT6puG25Tpo,124617
+typed_ffmpeg/sources.py,sha256=_LGxviThVDKVbrD7uzj2w2S2TGk6OKZA3IJ3X2ISnE8,124617
 typed_ffmpeg/types.py,sha256=Hz_pm1ZL5g_zAzy-3kTUOfSyoqkvcJ93zaYSA3fmkec,4271
 typed_ffmpeg/codecs/__init__.py,sha256=EL82KdkvLHvxvKwV6nD5_kMbdOa34XHbIIBYKFOgy5c,117
 typed_ffmpeg/codecs/decoders.py,sha256=fg3v-su1qq2w2nclNW5-o-vNV5GTbX_0VP_rBOk26FA,120176
@@ -16,7 +16,7 @@ typed_ffmpeg/codecs/schema.py,sha256=lJe4qWOzfWzrSy0ZYH8M8wSoe2vZYzxwu7mzdxURV6s
 typed_ffmpeg/common/__init__.py,sha256=MOaoqb-pQq-OZGWfzLptwfGX6v3qDh3zUzncr_Vi_n4,39
 typed_ffmpeg/common/cache.py,sha256=JxjvPujIUCs1SdqBhYsrucIWp6ShRSF8EF7hJPbmXrA,1429
 typed_ffmpeg/common/schema.py,sha256=P618Bw4ngMhxvjuMkWUVy0EF-WveFWn2OmRP-tg1TiE,19762
-typed_ffmpeg/common/serialize.py,sha256=8Ldy3Y7cb71a1Z-msSTp_ZNdcamGpunTBv-gTAd-r_c,7795
+typed_ffmpeg/common/serialize.py,sha256=cb6sbOYVNcfXC08Ya4PTSHY_GrHlJjwmbJpHYtoJuuU,7811
 typed_ffmpeg/compile/__init__.py,sha256=arrUostAUZzB8cQujLg9xo8OOfB4eoU3CYObAAY198A,44
 typed_ffmpeg/compile/compile_cli.py,sha256=aNRaJnno7ICF6NKoIGQqhTpldMuykCGQCxC5JiVqpnE,34234
 typed_ffmpeg/compile/compile_json.py,sha256=Sp84ss73C5YnUsEmhoqzy-y-gVk8G8q6d3SSKD3YWvE,1048
@@ -33,8 +33,8 @@ typed_ffmpeg/dag/global_runnable/global_args.py,sha256=fB1iw1VrrdqMelb_8O7WYGMF3
 typed_ffmpeg/dag/global_runnable/runnable.py,sha256=KJZuCI05fx4isD4xZHbVNDn0yYImY0Hw7b76uVIySis,12617
 typed_ffmpeg/dag/io/__init__.py,sha256=KSxmqhZYVNbckRCCL575eUjV0GpyvV9EbwnmwGKHdbQ,56
 typed_ffmpeg/dag/io/_input.py,sha256=v-g0lBHveGG1-NFp6ODL4QKjDdEVRfLcZghXZivl6nE,8237
-typed_ffmpeg/dag/io/_output.py,sha256=48weTEWSLP7DVVYWSr8bnr_hHrcd_MgDGksw2GKPnEc,13646
-typed_ffmpeg/dag/io/output_args.py,sha256=B0vHF2Mjv1T-R4rXUFQMbOvbCpNkU8obQlYPgLCYoRI,15232
+typed_ffmpeg/dag/io/_output.py,sha256=U06M4RQepPleGS3odR9C1IVXijTCv5Q0R-_MOk8PiJI,13646
+typed_ffmpeg/dag/io/output_args.py,sha256=GZJcg8TGBPk5S5jRjz4Xzy21UcIRQY4JnBRoKrt6ync,15224
 typed_ffmpeg/ffprobe/__init__.py,sha256=XsPSdQyt12eJF3YF_5Rb101gjaBgvRasgO7gK4CyzZc,49
 typed_ffmpeg/ffprobe/parse.py,sha256=FKYTp_18SsnQFvStsGFl1fV4bbDfDPVQ3n44-5QtmOE,3834
 typed_ffmpeg/ffprobe/probe.py,sha256=iuGxqhxpNdFJb7SUDXl9gjR4CtGR4nzxJpWLTSH4_K4,10369
@@ -54,7 +54,7 @@ typed_ffmpeg/streams/audio.py,sha256=xo5CKu9ym82q0W-7OFB9vZzaWAEVugH-ftc1woG-qv0
 typed_ffmpeg/streams/av.py,sha256=OyRRhSOEDYC1WtcXxX6h4eCkgDw6b4jFOx7yyUXJ3iA,2627
 typed_ffmpeg/streams/channel_layout.py,sha256=hGagaoc1tnWS8K1yiITp4f_92qq5e7C_zB15bHOL0DI,1162
 typed_ffmpeg/streams/subtitle.py,sha256=f139Wt9OtExHjzSm64HdKYk8KyfXSuv0HjmBZhjOVtQ,165
-typed_ffmpeg/streams/video.py,sha256=U17bBaPBgLAwALZT_QZFRTdVz7FXgyMKmX5ltyCUkvQ,519673
+typed_ffmpeg/streams/video.py,sha256=MqmcjRB2ft2dv0R3PouM17u-p2hbf0auolVWV3ZwiM4,532100
 typed_ffmpeg/utils/__init__.py,sha256=YUl7EosqAlIpB153d39qj5fG4SVFcFG2XI4hRDxUBDQ,52
 typed_ffmpeg/utils/escaping.py,sha256=cM0CJc6LNQ-1gZZ3D9-VmMPgBT6rqJA6G6OngK_c9XI,2965
 typed_ffmpeg/utils/frozendict.py,sha256=TCzkxaS_lxTeBrIop8UNnzsnx_sXuM8ca2e2O2nZWlM,5047
@@ -65,9 +65,9 @@ typed_ffmpeg/utils/view.py,sha256=wbfHsX4vhXTGgvxvoLdlJgIXbWtzh5TohcMDVgZobGw,34
 typed_ffmpeg/utils/lazy_eval/__init__.py,sha256=_yEaOR9o5QerwmrLev_bGFB4cyWeEA_YvxE2WyToK2c,50
 typed_ffmpeg/utils/lazy_eval/operator.py,sha256=w61XIH0kdJkGuo201837lqvKHStTHumOlvyDCm8Gu5o,5472
 typed_ffmpeg/utils/lazy_eval/schema.py,sha256=Xn8ABlx_EK2hv6dsZ2Hu7nPRCzQFvMWxLPXEOgSLnSM,13329
-typed_ffmpeg_compatible-3.6.dist-info/licenses/LICENSE,sha256=8Aaya5i_09Cou2i3QMxTwz6uHGzi_fGA4uhkco07-A4,1066
-typed_ffmpeg_compatible-3.6.dist-info/METADATA,sha256=JRpsWlXyQFsSewJ-yMfE_gjT9Dxs-9T-LbEU9k3-Nzc,8383
-typed_ffmpeg_compatible-3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-typed_ffmpeg_compatible-3.6.dist-info/entry_points.txt,sha256=kUQvZ27paV-07qtkIFV-emKsYtjFOTw9kknBRSXPs04,45
-typed_ffmpeg_compatible-3.6.dist-info/top_level.txt,sha256=vuASJGVRQiNmhWY1pt0RXESWSNkknWXqWLIRAU7H_L4,13
-typed_ffmpeg_compatible-3.6.dist-info/RECORD,,
+typed_ffmpeg_compatible-3.7.1.dist-info/licenses/LICENSE,sha256=8Aaya5i_09Cou2i3QMxTwz6uHGzi_fGA4uhkco07-A4,1066
+typed_ffmpeg_compatible-3.7.1.dist-info/METADATA,sha256=OgrA0DqIzR7zalB9eDOtr9XRdtfspmdMQAhK24rpz8Y,8616
+typed_ffmpeg_compatible-3.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+typed_ffmpeg_compatible-3.7.1.dist-info/entry_points.txt,sha256=kUQvZ27paV-07qtkIFV-emKsYtjFOTw9kknBRSXPs04,45
+typed_ffmpeg_compatible-3.7.1.dist-info/top_level.txt,sha256=vuASJGVRQiNmhWY1pt0RXESWSNkknWXqWLIRAU7H_L4,13
+typed_ffmpeg_compatible-3.7.1.dist-info/RECORD,,