typed-ffmpeg-compatible 2.6.0__py3-none-any.whl → 2.6.2__py3-none-any.whl

typed_ffmpeg/base.py

@@ -6,7 +6,13 @@ 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 .dag.nodes import (
+    FilterableStream,
+    FilterNode,
+    GlobalNode,
+    GlobalStream,
+    OutputStream,
+)
 from .schema import StreamType
 from .streams.audio import AudioStream
 from .streams.video import VideoStream
@@ -26,7 +32,10 @@ def merge_outputs(*streams: OutputStream) -> GlobalStream:
 
 
 def vfilter(
-    *streams: FilterableStream, name: str, input_typings: tuple[StreamType, ...] = (StreamType.video,), **kwargs: Any
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.video,),
+    **kwargs: Any,
 ) -> VideoStream:
     """
     Apply a custom video filter which has only one output to this stream
@@ -53,7 +62,10 @@ def vfilter(
 
 
 def afilter(
-    *streams: FilterableStream, name: str, input_typings: tuple[StreamType, ...] = (StreamType.audio,), **kwargs: Any
+    *streams: FilterableStream,
+    name: str,
+    input_typings: tuple[StreamType, ...] = (StreamType.audio,),
+    **kwargs: Any,
 ) -> AudioStream:
     """
     Apply a custom audio filter which has only one output to this stream
@@ -84,7 +96,7 @@ def filter_multi_output(
     name: str,
     input_typings: tuple[StreamType, ...] = (),
     output_tyings: tuple[StreamType, ...] = (),
-    **kwargs: Any
+    **kwargs: Any,
 ) -> FilterNode:
     """
     Apply a custom filter which has multiple outputs to this stream
@@ -111,4 +123,11 @@ def filter_multi_output(
     )
 
 
-__all__ = ["input", "output", "merge_outputs", "vfilter", "afilter", "filter_multi_output"]
+__all__ = [
+    "input",
+    "output",
+    "merge_outputs",
+    "vfilter",
+    "afilter",
+    "filter_multi_output",
+]

typed_ffmpeg/common/schema.py

@@ -118,8 +118,10 @@ class FFMpegFilter:
     def to_def(self) -> FFMpegFilterDef:
         return FFMpegFilterDef(
             name=self.name,
-            typings_input=self.formula_typings_input or tuple(k.type.value for k in self.stream_typings_input),
-            typings_output=self.formula_typings_output or tuple(k.type.value for k in self.stream_typings_output),
+            typings_input=self.formula_typings_input
+            or tuple(k.type.value for k in self.stream_typings_input),
+            typings_output=self.formula_typings_output
+            or tuple(k.type.value for k in self.stream_typings_output),
         )
 
     @property
@@ -131,13 +133,18 @@ class FFMpegFilter:
         else:
             assert self.formula_typings_input, f"{self.name} has no input"
             if "video" not in self.formula_typings_input:
-                assert "audio" in self.formula_typings_input, f"{self.name} has no video input"
+                assert "audio" in self.formula_typings_input, (
+                    f"{self.name} has no video input"
+                )
                 return {StreamType.audio}
             elif "audio" not in self.formula_typings_input:
-                assert "video" in self.formula_typings_input, f"{self.name} has no audio input"
+                assert "video" in self.formula_typings_input, (
+                    f"{self.name} has no audio input"
+                )
                 return {StreamType.video}
             assert (
-                "video" in self.formula_typings_input and "audio" in self.formula_typings_input
+                "video" in self.formula_typings_input
+                and "audio" in self.formula_typings_input
             ), f"{self.name} has no video or audio input"
             return {StreamType.video, StreamType.audio}
 
@@ -150,13 +157,18 @@ class FFMpegFilter:
         else:
             assert self.formula_typings_output, f"{self.name} has no output"
             if "video" not in self.formula_typings_output:
-                assert "audio" in self.formula_typings_output, f"{self.name} has no video output"
+                assert "audio" in self.formula_typings_output, (
+                    f"{self.name} has no video output"
+                )
                 return {StreamType.audio}
             elif "audio" not in self.formula_typings_output:
-                assert "video" in self.formula_typings_output, f"{self.name} has no audio output"
+                assert "video" in self.formula_typings_output, (
+                    f"{self.name} has no audio output"
+                )
                 return {StreamType.video}
             assert (
-                "video" in self.formula_typings_output and "audio" in self.formula_typings_output
+                "video" in self.formula_typings_output
+                and "audio" in self.formula_typings_output
             ), f"{self.name} has no video or audio output"
             return {StreamType.video, StreamType.audio}
 
@@ -301,7 +313,11 @@ class FFMpegOption:
 
     @property
     def is_global_option(self) -> bool:
-        return not self.is_input_option and not self.is_output_option and not (self.flags & FFMpegOptionFlag.OPT_EXIT)
+        return (
+            not self.is_input_option
+            and not self.is_output_option
+            and not (self.flags & FFMpegOptionFlag.OPT_EXIT)
+        )
 
     @property
     def is_support_stream_specifier(self) -> bool:

typed_ffmpeg/common/serialize.py

@@ -1,4 +1,4 @@
-from __future__ import absolute_import, annotations
+from __future__ import annotations
 
 import importlib
 import json
@@ -21,7 +21,9 @@ def load_class(path: str, strict: bool = True) -> Any:
         The class.
     """
     if strict:
-        assert path.startswith("ffmpeg."), f"Only support loading class from ffmpeg package: {path}"
+        assert path.startswith("ffmpeg."), (
+            f"Only support loading class from ffmpeg package: {path}"
+        )
 
     module_path, class_name = path.rsplit(".", 1)
     module = importlib.import_module(module_path)
@@ -65,7 +67,7 @@ def object_hook(obj: Any, strict: bool = True) -> Any:
                 # NOTE: in our application, the dataclass is always frozen
                 return cls(**{k: frozen(v) for k, v in obj.items()})
 
-            return cls(**{k: v for k, v in obj.items()})
+            return cls(**dict(obj.items()))
 
     return obj
 
@@ -107,7 +109,10 @@ def to_dict_with_class_info(instance: Any) -> Any:
     elif is_dataclass(instance):
         return {
             "__class__": f"{instance.__class__.__module__}.{instance.__class__.__name__}",
-            **{k.name: to_dict_with_class_info(getattr(instance, k.name)) for k in fields(instance)},
+            **{
+                k.name: to_dict_with_class_info(getattr(instance, k.name))
+                for k in fields(instance)
+            },
         }
     elif isinstance(instance, Enum):
         return {

typed_ffmpeg/dag/__init__.py

@@ -1,4 +1,11 @@
-from .nodes import FilterableStream, FilterNode, GlobalNode, InputNode, OutputNode, OutputStream
+from .nodes import (
+    FilterableStream,
+    FilterNode,
+    GlobalNode,
+    InputNode,
+    OutputNode,
+    OutputStream,
+)
 from .schema import Node, Stream
 
 __all__ = [

typed_ffmpeg/dag/context.py

@@ -105,7 +105,10 @@ class DAGContext:
         """
         All streams in the graph sorted by the number of upstream nodes and the index of the stream.
         """
-        return sorted(self.streams, key=lambda stream: (len(stream.node.upstream_nodes), stream.index))
+        return sorted(
+            self.streams,
+            key=lambda stream: (len(stream.node.upstream_nodes), stream.index),
+        )
 
     @cached_property
     def outgoing_nodes(self) -> dict[Stream, list[tuple[Node, int]]]:
@@ -180,7 +183,9 @@ class DAGContext:
             The label of the node.
         """
 
-        assert isinstance(node, (InputNode, FilterNode)), "Only input and filter nodes have labels"
+        assert isinstance(node, (InputNode, FilterNode)), (
+            "Only input and filter nodes have labels"
+        )
         return self.node_labels[node]
 
     @override

typed_ffmpeg/dag/factory.py

@@ -7,23 +7,43 @@ from ..utils.run import ignore_default
 from .nodes import FilterableStream, FilterNode
 
 
-def filter_node_factory(filter: FFMpegFilterDef, *inputs: FilterableStream, **kwargs: Any) -> FilterNode:
+def filter_node_factory(
+    ffmpeg_filter_def: FFMpegFilterDef, *inputs: FilterableStream, **kwargs: Any
+) -> FilterNode:
     for k, v in kwargs.items():
         if isinstance(v, Auto):
-            kwargs[k] = eval(v, {"StreamType": StreamType, "re": re, **kwargs, "streams": inputs})
+            kwargs[k] = eval(
+                v, {"StreamType": StreamType, "re": re, **kwargs, "streams": inputs}
+            )
 
-    if isinstance(filter.typings_input, str):
-        input_typings = tuple(eval(filter.typings_input, {"StreamType": StreamType, "re": re, **kwargs}))
+    if isinstance(ffmpeg_filter_def.typings_input, str):
+        input_typings = tuple(
+            eval(
+                ffmpeg_filter_def.typings_input,
+                {"StreamType": StreamType, "re": re, **kwargs},
+            )
+        )
     else:
-        input_typings = tuple(StreamType.video if k == "video" else StreamType.audio for k in filter.typings_input)
+        input_typings = tuple(
+            StreamType.video if k == "video" else StreamType.audio
+            for k in ffmpeg_filter_def.typings_input
+        )
 
-    if isinstance(filter.typings_output, str):
-        output_typings = tuple(eval(filter.typings_output, {"StreamType": StreamType, "re": re, **kwargs}))
+    if isinstance(ffmpeg_filter_def.typings_output, str):
+        output_typings = tuple(
+            eval(
+                ffmpeg_filter_def.typings_output,
+                {"StreamType": StreamType, "re": re, **kwargs},
+            )
+        )
     else:
-        output_typings = tuple(StreamType.video if k == "video" else StreamType.audio for k in filter.typings_output)
+        output_typings = tuple(
+            StreamType.video if k == "video" else StreamType.audio
+            for k in ffmpeg_filter_def.typings_output
+        )
 
     return FilterNode(
-        name=filter.name,
+        name=ffmpeg_filter_def.name,
         input_typings=input_typings,
         output_typings=output_typings,
         inputs=inputs,

typed_ffmpeg/dag/global_runnable/global_args.py

@@ -12,8 +12,7 @@ if TYPE_CHECKING:
 
 class GlobalArgs(ABC):
     @abstractmethod
-    def _global_node(self, *streams: OutputStream, **kwargs: Any) -> GlobalNode:
-        ...
+    def _global_node(self, *streams: OutputStream, **kwargs: Any) -> GlobalNode: ...
 
     def global_args(
         self,

typed_ffmpeg/dag/global_runnable/runnable.py

@@ -82,7 +82,9 @@ class GlobalRunable(GlobalArgs):
         Returns:
             the command-line
         """
-        return command_line(self.compile(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix))
+        return command_line(
+            self.compile(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix)
+        )
 
     def run_async(
         self,
@@ -115,7 +117,9 @@ class GlobalRunable(GlobalArgs):
         stdout_stream = subprocess.PIPE if pipe_stdout or quiet else None
         stderr_stream = subprocess.PIPE if pipe_stderr or quiet else None
 
-        logger.info(f"Running command: {self.compile_line(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix)}")
+        logger.info(
+            f"Running command: {self.compile_line(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix)}"
+        )
 
         return subprocess.Popen(
             args,
@@ -166,7 +170,9 @@ class GlobalRunable(GlobalArgs):
         if retcode:
             raise FFMpegExecuteError(
                 retcode=retcode,
-                cmd=self.compile_line(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix),
+                cmd=self.compile_line(
+                    cmd, overwrite_output=overwrite_output, auto_fix=auto_fix
+                ),
                 stdout=stdout,
                 stderr=stderr,
             )

typed_ffmpeg/dag/io/_input.py

@@ -194,4 +194,6 @@ def input(
         if v is not None
     }
 
-    return InputNode(filename=str(filename), kwargs=tuple((options | (extra_options or {})).items())).stream()
+    return InputNode(
+        filename=str(filename), kwargs=tuple((options | (extra_options or {})).items())
+    ).stream()

typed_ffmpeg/dag/io/_output.py

@@ -316,5 +316,7 @@ def output(
     }
 
     return OutputNode(
-        inputs=streams, filename=str(filename), kwargs=tuple((options | (extra_options or {})).items())
+        inputs=streams,
+        filename=str(filename),
+        kwargs=tuple((options | (extra_options or {})).items()),
     ).stream()

typed_ffmpeg/dag/io/output_args.py

@@ -13,12 +13,13 @@ if TYPE_CHECKING:
 
 class OutputArgs(ABC):
     @abstractmethod
-    def _output_node(self, *streams: FilterableStream, filename: str | Path, **kwargs: Any) -> OutputNode:
-        ...
+    def _output_node(
+        self, *streams: FilterableStream, filename: str | Path, **kwargs: Any
+    ) -> OutputNode: ...
 
     def output(
         self,
-        *streams: "FilterableStream",
+        *streams: FilterableStream,
         filename: str | Path,
         f: String = None,
         c: String = None,
@@ -324,4 +325,6 @@ class OutputArgs(ABC):
             if v is not None
         }
 
-        return self._output_node(*streams, filename=filename, **options, **(extra_options or {})).stream()
+        return self._output_node(
+            *streams, filename=filename, **options, **(extra_options or {})
+        ).stream()

typed_ffmpeg/dag/nodes.py

@@ -55,7 +55,7 @@ class FilterNode(Node):
     def repr(self) -> str:
         return self.name
 
-    def video(self, index: int) -> "VideoStream":
+    def video(self, index: int) -> VideoStream:
         """
         Return the video stream at the specified index
 
@@ -67,12 +67,16 @@ class FilterNode(Node):
         """
         from ..streams.video import VideoStream
 
-        video_outputs = [i for i, k in enumerate(self.output_typings) if k == StreamType.video]
+        video_outputs = [
+            i for i, k in enumerate(self.output_typings) if k == StreamType.video
+        ]
         if not len(video_outputs) > index:
-            raise FFMpegValueError(f"Specified index {index} is out of range for video outputs {len(video_outputs)}")
+            raise FFMpegValueError(
+                f"Specified index {index} is out of range for video outputs {len(video_outputs)}"
+            )
         return VideoStream(node=self, index=video_outputs[index])
 
-    def audio(self, index: int) -> "AudioStream":
+    def audio(self, index: int) -> AudioStream:
         """
         Return the audio stream at the specified index
 
@@ -84,9 +88,13 @@ class FilterNode(Node):
         """
         from ..streams.audio import AudioStream
 
-        audio_outputs = [i for i, k in enumerate(self.output_typings) if k == StreamType.audio]
+        audio_outputs = [
+            i for i, k in enumerate(self.output_typings) if k == StreamType.audio
+        ]
         if not len(audio_outputs) > index:
-            raise FFMpegValueError(f"Specified index {index} is out of range for audio outputs {len(audio_outputs)}")
+            raise FFMpegValueError(
+                f"Specified index {index} is out of range for audio outputs {len(audio_outputs)}"
+            )
 
         return AudioStream(node=self, index=audio_outputs[index])
 
@@ -97,12 +105,16 @@ class FilterNode(Node):
         super().__post_init__()
 
         if len(self.inputs) != len(self.input_typings):
-            raise FFMpegValueError(f"Expected {len(self.input_typings)} inputs, got {len(self.inputs)}")
+            raise FFMpegValueError(
+                f"Expected {len(self.input_typings)} inputs, got {len(self.inputs)}"
+            )
 
         stream: FilterableStream
         expected_type: StreamType
 
-        for i, (stream, expected_type) in enumerate(zip(self.inputs, self.input_typings)):
+        for i, (stream, expected_type) in enumerate(
+            zip(self.inputs, self.input_typings)
+        ):
             if expected_type == StreamType.video:
                 if not isinstance(stream, VideoStream):
                     raise FFMpegTypeError(
@@ -132,7 +144,9 @@ class FilterNode(Node):
 
         commands = []
         for key, value in self.kwargs:
-            assert not isinstance(value, LazyValue), f"LazyValue should have been evaluated: {key}={value}"
+            assert not isinstance(value, LazyValue), (
+                f"LazyValue should have been evaluated: {key}={value}"
+            )
 
             # Note: the -nooption syntax cannot be used for boolean AVOptions, use -option 0/-option 1.
             if isinstance(value, bool):
@@ -142,7 +156,12 @@ class FilterNode(Node):
                 commands += [f"{key}={escape(value)}"]
 
         if commands:
-            return [incoming_labels] + [f"{self.name}="] + [escape(":".join(commands), "\\'[],;")] + [outgoing_labels]
+            return (
+                [incoming_labels]
+                + [f"{self.name}="]
+                + [escape(":".join(commands), "\\'[],;")]
+                + [outgoing_labels]
+            )
         return [incoming_labels] + [f"{self.name}"] + [outgoing_labels]
 
 
@@ -152,10 +171,12 @@ class FilterableStream(Stream, OutputArgs):
     A stream that can be used as input to a filter
     """
 
-    node: "FilterNode | InputNode"
+    node: FilterNode | InputNode
 
     @override
-    def _output_node(self, *streams: FilterableStream, filename: str | Path, **kwargs: Any) -> OutputNode:
+    def _output_node(
+        self, *streams: FilterableStream, filename: str | Path, **kwargs: Any
+    ) -> OutputNode:
         """
         Output the streams to a file URL
 
@@ -167,15 +188,19 @@ class FilterableStream(Stream, OutputArgs):
         Returns:
             the output stream
         """
-        return OutputNode(inputs=(self, *streams), filename=str(filename), kwargs=tuple(kwargs.items()))
+        return OutputNode(
+            inputs=(self, *streams),
+            filename=str(filename),
+            kwargs=tuple(kwargs.items()),
+        )
 
     def vfilter(
         self,
-        *streams: "FilterableStream",
+        *streams: FilterableStream,
         name: str,
         input_typings: tuple[StreamType, ...] = (StreamType.video,),
         **kwargs: Any,
-    ) -> "VideoStream":
+    ) -> VideoStream:
         """
         Apply a custom video filter which has only one output to this stream
 
@@ -198,11 +223,11 @@ class FilterableStream(Stream, OutputArgs):
 
     def afilter(
         self,
-        *streams: "FilterableStream",
+        *streams: FilterableStream,
         name: str,
         input_typings: tuple[StreamType, ...] = (StreamType.audio,),
         **kwargs: Any,
-    ) -> "AudioStream":
+    ) -> AudioStream:
         """
         Apply a custom audio filter which has only one output to this stream
 
@@ -225,12 +250,12 @@ class FilterableStream(Stream, OutputArgs):
 
     def filter_multi_output(
         self,
-        *streams: "FilterableStream",
+        *streams: FilterableStream,
         name: str,
         input_typings: tuple[StreamType, ...] = (),
         output_typings: tuple[StreamType, ...] = (),
         **kwargs: Any,
-    ) -> "FilterNode":
+    ) -> FilterNode:
         """
         Apply a custom filter which has multiple outputs to this stream
 
@@ -277,13 +302,17 @@ class FilterableStream(Stream, OutputArgs):
                 return f"{context.get_node_label(self.node)}:v"
             elif isinstance(self, AudioStream):
                 return f"{context.get_node_label(self.node)}:a"
-            raise FFMpegValueError(f"Unknown stream type: {self.__class__.__name__}")  # pragma: no cover
+            raise FFMpegValueError(
+                f"Unknown stream type: {self.__class__.__name__}"
+            )  # pragma: no cover
 
         if isinstance(self.node, FilterNode):
             if len(self.node.output_typings) > 1:
                 return f"{context.get_node_label(self.node)}#{self.index}"
             return f"{context.get_node_label(self.node)}"
-        raise FFMpegValueError(f"Unknown node type: {self.node.__class__.__name__}")  # pragma: no cover
+        raise FFMpegValueError(
+            f"Unknown node type: {self.node.__class__.__name__}"
+        )  # pragma: no cover
 
     def __post_init__(self) -> None:
         if isinstance(self.node, InputNode):
@@ -310,7 +339,7 @@ class InputNode(Node):
         return os.path.basename(self.filename)
 
     @property
-    def video(self) -> "VideoStream":
+    def video(self) -> VideoStream:
         """
         Return the video stream of this node
 
@@ -322,7 +351,7 @@ class InputNode(Node):
         return VideoStream(node=self)
 
     @property
-    def audio(self) -> "AudioStream":
+    def audio(self) -> AudioStream:
         """
         Return the audio stream of this node
 
@@ -333,7 +362,7 @@ class InputNode(Node):
 
         return AudioStream(node=self)
 
-    def stream(self) -> "AVStream":
+    def stream(self) -> AVStream:
         """
         Return the output stream of this node
 
@@ -371,7 +400,7 @@ class OutputNode(Node):
     def repr(self) -> str:
         return os.path.basename(self.filename)
 
-    def stream(self) -> "OutputStream":
+    def stream(self) -> OutputStream:
         """
         Return the output stream of this node
 
@@ -437,7 +466,7 @@ class GlobalNode(Node):
     def repr(self) -> str:
         return " ".join(self.get_args())
 
-    def stream(self) -> "GlobalStream":
+    def stream(self) -> GlobalStream:
         """
         Return the output stream of this node
 

typed_ffmpeg/dag/schema.py

@@ -70,7 +70,7 @@ class Stream(HashableBaseModel):
             return f.read()
 
     def _repr_svg_(self) -> str:  # pragma: no cover
-        with open(self.view(format="svg"), "r") as f:
+        with open(self.view(format="svg")) as f:
             return f.read()
 
 
@@ -109,7 +109,7 @@ class Node(HashableBaseModel, ABC):
 
             nodes.extend(k.node for k in node.inputs)
 
-            output[node.hex] = set(k.node.hex for k in node.inputs)
+            output[node.hex] = {k.node.hex for k in node.inputs}
 
         if not is_dag(output):
             raise ValueError(f"Graph is not a DAG: {output}")  # pragma: no cover
@@ -206,5 +206,5 @@ class Node(HashableBaseModel, ABC):
             return f.read()
 
     def _repr_svg_(self) -> str:  # pragma: no cover
-        with open(self.view(format="svg"), "r") as f:
+        with open(self.view(format="svg")) as f:
             return f.read()

typed_ffmpeg/dag/validate.py

@@ -10,7 +10,9 @@ from .nodes import FilterNode, InputNode
 from .schema import Node, Stream
 
 
-def remove_split(current_stream: Stream, mapping: dict[Stream, Stream] = None) -> tuple[Stream, dict[Stream, Stream]]:
+def remove_split(
+    current_stream: Stream, mapping: dict[Stream, Stream] = None
+) -> tuple[Stream, dict[Stream, Stream]]:
     """
     Rebuild the graph with the given mapping.
 
@@ -37,20 +39,28 @@ def remove_split(current_stream: Stream, mapping: dict[Stream, Stream] = None) -
     if isinstance(current_stream.node, FilterNode):
         # if the current node is a split node, we need to remove it
         if current_stream.node.name in ("split", "asplit"):
-            new_stream, _mapping = remove_split(current_stream=current_stream.node.inputs[0], mapping=mapping)
+            new_stream, _mapping = remove_split(
+                current_stream=current_stream.node.inputs[0], mapping=mapping
+            )
             mapping[current_stream] = mapping[current_stream.node.inputs[0]]
             return mapping[current_stream.node.inputs[0]], mapping
 
     inputs = {}
     for idx, input_stream in sorted(
-        enumerate(current_stream.node.inputs), key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes)
+        enumerate(current_stream.node.inputs),
+        key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes),
     ):
-        new_stream, _mapping = remove_split(current_stream=input_stream, mapping=mapping)
+        new_stream, _mapping = remove_split(
+            current_stream=input_stream, mapping=mapping
+        )
         inputs[idx] = new_stream
         mapping |= _mapping
 
     new_node = replace(
-        current_stream.node, inputs=tuple(stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0]))
+        current_stream.node,
+        inputs=tuple(
+            stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0])
+        ),
     )
     new_stream = replace(current_stream, node=new_node)
 
@@ -91,16 +101,24 @@ def add_split(
     inputs = {}
 
     for idx, input_stream in sorted(
-        enumerate(current_stream.node.inputs), key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes)
+        enumerate(current_stream.node.inputs),
+        key=lambda idx_stream: -len(idx_stream[1].node.upstream_nodes),
     ):
         new_stream, _mapping = add_split(
-            current_stream=input_stream, down_node=current_stream.node, down_index=idx, mapping=mapping, context=context
+            current_stream=input_stream,
+            down_node=current_stream.node,
+            down_index=idx,
+            mapping=mapping,
+            context=context,
         )
         inputs[idx] = new_stream
         mapping |= _mapping
 
     new_node = replace(
-        current_stream.node, inputs=tuple(stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0]))
+        current_stream.node,
+        inputs=tuple(
+            stream for idx, stream in sorted(inputs.items(), key=lambda x: x[0])
+        ),
     )
     new_stream = replace(current_stream, node=new_node)
 

typed_ffmpeg/exceptions.py

@@ -39,4 +39,4 @@ class FFMpegExecuteError(FFMpegError):
         self.cmd = cmd
         self.retcode = retcode
 
-        super(FFMpegExecuteError, self).__init__(f"{cmd} error (see stderr output for detail) {stderr!r}")
+        super().__init__(f"{cmd} error (see stderr output for detail) {stderr!r}")