typed-ffmpeg-compatible 2.1.0__py3-none-any.whl

typed_ffmpeg/dag/context.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from dataclasses import dataclass
+from functools import cached_property
+from typing import Any, TypeVar
+
+from ..utils.typing import override
+from .nodes import FilterNode, InputNode
+from .schema import Node, Stream
+
+T = TypeVar("T")
+
+
+def _remove_duplicates(seq: list[T]) -> list[T]:
+    """
+    Remove duplicates from a list while preserving order.
+
+    Args:
+        seq: The list to remove duplicates from.
+
+    Returns:
+        The list with duplicates removed.
+    """
+    seen = set()
+    output = []
+
+    for x in seq:
+        if x not in seen:
+            output.append(x)
+            seen.add(x)
+
+    return output
+
+
+def _collect(node: Node) -> tuple[list[Node], list[Stream]]:
+    """
+    Collect all nodes and streams that are upstreamed to the given node
+
+    Args:
+        node: The node to collect from.
+
+    Returns:
+        A tuple of all nodes and streams that are upstreamed to the given node.
+    """
+    nodes, streams = [node], [*node.inputs]
+
+    for stream in node.inputs:
+        _nodes, _streams = _collect(stream.node)
+        nodes += _nodes
+        streams += _streams
+
+    return nodes, streams
+
+
+@dataclass(frozen=True, kw_only=True)
+class DAGContext:
+    """
+    A context for a directed acyclic graph (DAG).
+    """
+
+    node: Node
+    """
+    The root node (the destination) of the DAG.
+    """
+
+    nodes: tuple[Node, ...]
+    """
+    All nodes in the graph.
+    """
+
+    streams: tuple[Stream, ...]
+    """
+    All streams in the graph.
+    """
+
+    @classmethod
+    def build(cls, node: Node) -> DAGContext:
+        """
+        create a DAG context based on the given node
+
+        Args:
+            node: The root node of the DAG.
+
+        Returns:
+            A DAG context based on the given node.
+        """
+        nodes, streams = _collect(node)
+
+        return cls(
+            node=node,
+            nodes=tuple(_remove_duplicates(nodes)),
+            streams=tuple(_remove_duplicates(streams)),
+        )
+
+    @cached_property
+    def all_nodes(self) -> list[Node]:
+        """
+        All nodes in the graph sorted by the number of upstream nodes.
+        """
+        return sorted(self.nodes, key=lambda node: len(node.upstream_nodes))
+
+    @cached_property
+    def all_streams(self) -> list[Stream]:
+        """
+        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))
+
+    @cached_property
+    def outgoing_nodes(self) -> dict[Stream, list[tuple[Node, int]]]:
+        """
+        A dictionary of outgoing nodes for each stream.
+        """
+        outgoing_nodes: dict[Stream, list[tuple[Node, int]]] = defaultdict(list)
+
+        for node in self.nodes:
+            for idx, stream in enumerate(node.inputs):
+                outgoing_nodes[stream].append((node, idx))
+
+        return outgoing_nodes
+
+    @cached_property
+    def outgoing_streams(self) -> dict[Node, list[Stream]]:
+        """
+        A dictionary of outgoing streams for each node.
+        """
+
+        outgoing_streams: dict[Node, list[Stream]] = defaultdict(list)
+
+        for stream in self.streams:
+            outgoing_streams[stream.node].append(stream)
+
+        return outgoing_streams
+
+    @cached_property
+    def node_labels(self) -> dict[Node, str]:
+        """
+        A dictionary of outgoing streams for each node.
+        """
+
+        input_node_index = 0
+        filter_node_index = 0
+        node_labels: dict[Node, str] = {}
+
+        for node in sorted(self.nodes, key=lambda node: node.max_depth):
+            if isinstance(node, InputNode):
+                node_labels[node] = str(input_node_index)
+                input_node_index += 1
+            elif isinstance(node, FilterNode):
+                node_labels[node] = f"s{filter_node_index}"
+                filter_node_index += 1
+            else:
+                node_labels[node] = "out"
+
+        return node_labels
+
+    @override
+    def get_outgoing_nodes(self, stream: Stream) -> list[tuple[Node, int]]:
+        """
+        Get all outgoing nodes of the stream.
+
+        Args:
+            stream: The stream to get the outgoing nodes of.
+
+        Returns:
+            The outgoing nodes of the stream.
+        """
+        return self.outgoing_nodes[stream]
+
+    @override
+    def get_node_label(self, node: Node) -> str:
+        """
+        Get the label of the node.
+
+        Args:
+            node: The node to get the label of.
+
+        Returns:
+            The label of the node.
+        """
+
+        assert isinstance(node, (InputNode, FilterNode)), "Only input and filter nodes have labels"
+        return self.node_labels[node]
+
+    @override
+    def get_outgoing_streams(self, node: Node) -> list[Stream]:
+        """
+        Extract all node's outgoing streams from the given set of streams, Because a node only know its incoming streams.
+
+        Args:
+            node: The node to get the outgoing streams of.
+
+        Returns:
+            The outgoing streams of the node.
+        """
+        return self.outgoing_streams[node]
+
+    def render(self, obj: Any) -> Any:
+        """
+        Render the object to a string.
+
+        Args:
+            obj: The object to render.
+
+        Returns:
+            The rendered object.
+        """
+
+        if isinstance(obj, (list, tuple)):
+            return [self.render(o) for o in obj]
+        elif isinstance(obj, dict):
+            return {self.render(k): self.render(v) for k, v in obj.items()}
+
+        if isinstance(obj, Node):
+            return f"Node({obj.repr()}#{self.node_labels[obj]})"
+
+        if isinstance(obj, Stream):
+            return f"Stream({self.render(obj.node)}#{obj.index})"
+
+        return obj

typed_ffmpeg/dag/factory.py

@@ -0,0 +1,31 @@
+import re
+from typing import Any
+
+from ..common.schema import FFMpegFilterDef, StreamType
+from ..schema import Auto
+from ..utils.run import ignore_default
+from .nodes import FilterableStream, FilterNode
+
+
+def filter_node_factory(filter: 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})
+
+    if isinstance(filter.typings_input, str):
+        input_typings = tuple(eval(filter.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)
+
+    if isinstance(filter.typings_output, str):
+        output_typings = tuple(eval(filter.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)
+
+    return FilterNode(
+        name=filter.name,
+        input_typings=input_typings,
+        output_typings=output_typings,
+        inputs=inputs,
+        kwargs=ignore_default(kwargs),
+    )

typed_ffmpeg/dag/global_runnable/global_args.py

@@ -0,0 +1,178 @@
+# NOTE: this file is auto-generated, do not modify
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+from ...types import Boolean, Float, Func, Int
+
+if TYPE_CHECKING:
+    from ..nodes import GlobalNode, GlobalStream, OutputStream
+
+
+class GlobalArgs(ABC):
+    @abstractmethod
+    def _global_node(self, *streams: OutputStream, **kwargs: Any) -> GlobalNode:
+        ...
+
+    def global_args(
+        self,
+        *,
+        loglevel: Func = None,
+        v: Func = None,
+        report: Func = None,
+        max_alloc: Func = None,
+        cpuflags: Func = None,
+        cpucount: Func = None,
+        hide_banner: Boolean = None,
+        y: Boolean = None,
+        n: Boolean = None,
+        ignore_unknown: Boolean = None,
+        copy_unknown: Boolean = None,
+        recast_media: Boolean = None,
+        benchmark: Boolean = None,
+        benchmark_all: Boolean = None,
+        progress: Func = None,
+        stdin: Boolean = None,
+        timelimit: Func = None,
+        dump: Boolean = None,
+        hex: Boolean = None,
+        frame_drop_threshold: Float = None,
+        copyts: Boolean = None,
+        start_at_zero: Boolean = None,
+        copytb: Int = None,
+        dts_delta_threshold: Float = None,
+        dts_error_threshold: Float = None,
+        xerror: Boolean = None,
+        abort_on: Func = None,
+        filter_threads: Func = None,
+        filter_complex: Func = None,
+        filter_complex_threads: Int = None,
+        lavfi: Func = None,
+        filter_complex_script: Func = None,
+        auto_conversion_filters: Boolean = None,
+        stats: Boolean = None,
+        stats_period: Func = None,
+        debug_ts: Boolean = None,
+        max_error_rate: Float = None,
+        vstats: Func = None,
+        vstats_file: Func = None,
+        vstats_version: Int = None,
+        init_hw_device: Func = None,
+        filter_hw_device: Func = None,
+        adrift_threshold: Func = None,
+        qphist: Func = None,
+        vsync: Func = None,
+        **kwargs: Any,
+    ) -> GlobalStream:
+        """
+        Set global options.
+
+        Args:
+            loglevel: set logging level
+            v: set logging level
+            report: generate a report
+            max_alloc: set maximum size of a single allocated block
+            cpuflags: force specific cpu flags
+            cpucount: force specific cpu count
+            hide_banner: do not show program banner
+            y: overwrite output files
+            n: never overwrite output files
+            ignore_unknown: Ignore unknown stream types
+            copy_unknown: Copy unknown stream types
+            recast_media: allow recasting stream type in order to force a decoder of different media type
+            benchmark: add timings for benchmarking
+            benchmark_all: add timings for each task
+            progress: write program-readable progress information
+            stdin: enable or disable interaction on standard input
+            timelimit: set max runtime in seconds in CPU user time
+            dump: dump each input packet
+            hex: when dumping packets, also dump the payload
+            frame_drop_threshold: frame drop threshold
+            copyts: copy timestamps
+            start_at_zero: shift input timestamps to start at 0 when using copyts
+            copytb: copy input stream time base when stream copying
+            dts_delta_threshold: timestamp discontinuity delta threshold
+            dts_error_threshold: timestamp error delta threshold
+            xerror: exit on error
+            abort_on: abort on the specified condition flags
+            filter_threads: number of non-complex filter threads
+            filter_complex: create a complex filtergraph
+            filter_complex_threads: number of threads for -filter_complex
+            lavfi: create a complex filtergraph
+            filter_complex_script: deprecated, use -/filter_complex instead
+            auto_conversion_filters: enable automatic conversion filters globally
+            stats: print progress report during encoding
+            stats_period: set the period at which ffmpeg updates stats and -progress output
+            debug_ts: print timestamp debugging info
+            max_error_rate: ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.
+            vstats: dump video coding statistics to file
+            vstats_file: dump video coding statistics to file
+            vstats_version: Version of the vstats format to use.
+            init_hw_device: initialise hardware device
+            filter_hw_device: set hardware device used when filtering
+            adrift_threshold: deprecated, does nothing
+            qphist: deprecated, does nothing
+            vsync: set video sync method globally; deprecated, use -fps_mode
+            **kwargs: Additional options
+
+        Returns:
+            GlobalStream: GlobalStream instance
+        """
+
+        return self._global_node(
+            **(
+                {
+                    k: v
+                    for k, v in {
+                        "loglevel": loglevel,
+                        "v": v,
+                        "report": report,
+                        "max_alloc": max_alloc,
+                        "cpuflags": cpuflags,
+                        "cpucount": cpucount,
+                        "hide_banner": hide_banner,
+                        "y": y,
+                        "n": n,
+                        "ignore_unknown": ignore_unknown,
+                        "copy_unknown": copy_unknown,
+                        "recast_media": recast_media,
+                        "benchmark": benchmark,
+                        "benchmark_all": benchmark_all,
+                        "progress": progress,
+                        "stdin": stdin,
+                        "timelimit": timelimit,
+                        "dump": dump,
+                        "hex": hex,
+                        "frame_drop_threshold": frame_drop_threshold,
+                        "copyts": copyts,
+                        "start_at_zero": start_at_zero,
+                        "copytb": copytb,
+                        "dts_delta_threshold": dts_delta_threshold,
+                        "dts_error_threshold": dts_error_threshold,
+                        "xerror": xerror,
+                        "abort_on": abort_on,
+                        "filter_threads": filter_threads,
+                        "filter_complex": filter_complex,
+                        "filter_complex_threads": filter_complex_threads,
+                        "lavfi": lavfi,
+                        "filter_complex_script": filter_complex_script,
+                        "auto_conversion_filters": auto_conversion_filters,
+                        "stats": stats,
+                        "stats_period": stats_period,
+                        "debug_ts": debug_ts,
+                        "max_error_rate": max_error_rate,
+                        "vstats": vstats,
+                        "vstats_file": vstats_file,
+                        "vstats_version": vstats_version,
+                        "init_hw_device": init_hw_device,
+                        "filter_hw_device": filter_hw_device,
+                        "adrift_threshold": adrift_threshold,
+                        "qphist": qphist,
+                        "vsync": vsync,
+                    }.items()
+                    if v is not None
+                }
+                | kwargs
+            ),
+        ).stream()

typed_ffmpeg/dag/global_runnable/runnable.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+from typing import TYPE_CHECKING
+
+from ...exceptions import FFMpegExecuteError
+from ...utils.run import command_line
+from .global_args import GlobalArgs
+
+if TYPE_CHECKING:
+    from ..nodes import GlobalStream, OutputStream
+
+logger = logging.getLogger(__name__)
+
+
+class GlobalRunable(GlobalArgs):
+    def merge_outputs(self, *streams: OutputStream) -> GlobalStream:
+        """
+        Merge multiple output streams into one.
+
+        Args:
+            *streams: The output streams to merge.
+
+        Returns:
+            The merged output stream.
+        """
+        return self._global_node(*streams).stream()
+
+    def overwrite_output(self) -> GlobalStream:
+        """
+        Overwrite output files without asking (ffmpeg `-y` option)
+
+        Returns:
+            the output stream
+        """
+        return self._global_node(y=True).stream()
+
+    def compile(
+        self,
+        cmd: str | list[str] = "ffmpeg",
+        overwrite_output: bool = None,
+        auto_fix: bool = True,
+    ) -> list[str]:
+        """
+        Build command-line for invoking ffmpeg.
+
+        Args:
+            cmd: the command to invoke ffmpeg
+            overwrite_output: whether to overwrite output files without asking
+            auto_fix: whether to automatically fix the stream
+
+        Returns:
+            the command-line
+        """
+        from ..compile import compile
+
+        if isinstance(cmd, str):
+            cmd = [cmd]
+
+        if overwrite_output is True:
+            return self.global_args(y=True).compile(cmd, auto_fix=auto_fix)
+        elif overwrite_output is False:
+            return self.global_args(n=True).compile(cmd, auto_fix=auto_fix)
+
+        return cmd + compile(self._global_node().stream(), auto_fix=auto_fix)
+
+    def compile_line(
+        self,
+        cmd: str | list[str] = "ffmpeg",
+        overwrite_output: bool = None,
+        auto_fix: bool = True,
+    ) -> str:
+        """
+        Build command-line for invoking ffmpeg.
+
+        Args:
+            cmd: the command to invoke ffmpeg
+            overwrite_output: whether to overwrite output files without asking
+            auto_fix: whether to automatically fix the stream
+
+        Returns:
+            the command-line
+        """
+        return command_line(self.compile(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix))
+
+    def run_async(
+        self,
+        cmd: str | list[str] = "ffmpeg",
+        pipe_stdin: bool = False,
+        pipe_stdout: bool = False,
+        pipe_stderr: bool = False,
+        quiet: bool = False,
+        overwrite_output: bool = None,
+        auto_fix: bool = True,
+    ) -> subprocess.Popen[bytes]:
+        """
+        Run ffmpeg asynchronously.
+
+        Args:
+            cmd: the command to invoke ffmpeg
+            pipe_stdin: whether to pipe stdin
+            pipe_stdout: whether to pipe stdout
+            pipe_stderr: whether to pipe stderr
+            quiet: whether to pipe stderr to stdout
+            overwrite_output: whether to overwrite output files without asking
+            auto_fix: whether to automatically fix the stream
+
+        Returns:
+            the process
+        """
+
+        args = self.compile(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix)
+        stdin_stream = subprocess.PIPE if pipe_stdin else None
+        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)}")
+
+        return subprocess.Popen(
+            args,
+            stdin=stdin_stream,
+            stdout=stdout_stream,
+            stderr=stderr_stream,
+        )
+
+    def run(
+        self,
+        cmd: str | list[str] = "ffmpeg",
+        capture_stdout: bool = False,
+        capture_stderr: bool = False,
+        input: bytes | None = None,
+        quiet: bool = False,
+        overwrite_output: bool = None,
+        auto_fix: bool = True,
+    ) -> tuple[bytes, bytes]:
+        """
+        Run ffmpeg synchronously.
+
+        Args:
+            cmd: the command to invoke ffmpeg
+            capture_stdout: whether to capture stdout
+            capture_stderr: whether to capture stderr
+            input: the input
+            quiet: whether to pipe stderr to stdout
+            overwrite_output: whether to overwrite output files without asking
+            auto_fix: whether to automatically fix the stream
+
+        Returns:
+            stdout: he stdout
+            stderr: the stderr
+        """
+
+        process = self.run_async(
+            cmd,
+            pipe_stdin=input is not None,
+            pipe_stdout=capture_stdout,
+            pipe_stderr=capture_stderr,
+            quiet=quiet,
+            overwrite_output=overwrite_output,
+            auto_fix=auto_fix,
+        )
+        stdout, stderr = process.communicate(input)
+        retcode = process.poll()
+
+        if retcode:
+            raise FFMpegExecuteError(
+                retcode=retcode,
+                cmd=self.compile_line(cmd, overwrite_output=overwrite_output, auto_fix=auto_fix),
+                stdout=stdout,
+                stderr=stderr,
+            )
+
+        return stdout, stderr