typed-ffmpeg-compatible 2.7.3__py3-none-any.whl → 3.0.0a0__py3-none-any.whl

typed_ffmpeg/compile/compile_python.py

@@ -0,0 +1,319 @@
+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 (
+    FilterableStream,
+    FilterNode,
+    GlobalNode,
+    GlobalStream,
+    InputNode,
+    OutputNode,
+    OutputStream,
+)
+from ..dag.schema import Node, Stream
+from .context import DAGContext
+from .validate import validate
+
+
+def filter_stream_typed_index(
+    matched_stream: FilterableStream, context: DAGContext
+) -> int:
+    """
+    Get the index of the matched stream in the outgoing streams of the node.
+
+    This is used to get the index of the stream in the outgoing streams of the node.
+    For example, if the node has 2 outgoing streams, and the first one is a video stream, and the second one is an audio stream,
+    and the matched stream is the first video stream, the index will be 0.
+
+    Args:
+        matched_stream: The stream to get the index of.
+        context: The context of the node.
+
+    Returns:
+        The index of the matched stream in the outgoing streams of the node.
+    """
+    matched_outgoing_streams = [
+        k
+        for k in context.get_outgoing_streams(matched_stream.node)
+        if isinstance(k, matched_stream.__class__)
+    ]
+    assert matched_stream in matched_outgoing_streams
+    assert all(k.index is not None for k in matched_outgoing_streams)
+    matched_outgoing_streams = sorted(
+        matched_outgoing_streams, key=lambda s: s.index or 9999
+    )
+
+    return matched_outgoing_streams.index(matched_stream)
+
+
+def get_input_var_name(
+    stream: Stream, context: DAGContext, filter_data_dict: dict[str, FFMpegFilter]
+) -> str:
+    """
+    Get the input variable name for the stream.
+
+    This is used to get the input variable name for the stream.
+    For example, if the stream is a video stream, the input variable name will be "video_stream_0".
+
+    Args:
+        stream: The stream to get the input variable name for.
+        context: The context of the node.
+
+    Returns:
+        The input variable name for the stream.
+    """
+    match stream:
+        case AVStream():
+            assert stream.index is None
+            return get_output_var_name(stream.node, context)
+        case VideoStream():
+            match stream.node:
+                case InputNode():
+                    return f"{get_output_var_name(stream.node, context)}.video"
+                case FilterNode():
+                    if filter_data_dict[stream.node.name].is_dynamic_output:
+                        return f"{get_output_var_name(stream.node, context)}.video({filter_stream_typed_index(stream, context)})"
+                    elif (
+                        len(filter_data_dict[stream.node.name].stream_typings_output)
+                        > 1
+                    ):
+                        return f"{get_output_var_name(stream.node, context)}[{stream.index}]"
+                    else:
+                        return f"{get_output_var_name(stream.node, context)}"
+        case AudioStream():
+            match stream.node:
+                case InputNode():
+                    return f"{get_output_var_name(stream.node, context)}.audio"
+                case FilterNode():
+                    if filter_data_dict[stream.node.name].is_dynamic_output:
+                        return f"{get_output_var_name(stream.node, context)}.audio({filter_stream_typed_index(stream, context)})"
+                    elif (
+                        len(filter_data_dict[stream.node.name].stream_typings_output)
+                        > 1
+                    ):
+                        return f"{get_output_var_name(stream.node, context)}[{stream.index}]"
+                    else:
+                        return f"{get_output_var_name(stream.node, context)}"
+        case OutputStream():
+            return f"{get_output_var_name(stream.node, context)}"
+        case GlobalStream():
+            return f"{get_output_var_name(stream.node, context)}"
+        case _:
+            raise ValueError(f"Unknown node type: {type(stream.node)}")
+
+
+def get_output_var_name(node: Node, context: DAGContext) -> str:
+    """
+    Get the output variable name for the node.
+
+    This is used to get the output variable name for the node.
+    For example, if the node is an input node, the output variable name will be "input_0".
+
+    Args:
+        node: The node to get the output variable name for.
+        context: The context of the node.
+
+    Returns:
+        The output variable name for the node.
+    """
+    match node:
+        case InputNode():
+            return f"input_{context.node_ids[node]}"
+        case FilterNode():
+            return f"node_{context.node_ids[node]}"
+        case OutputNode():
+            return f"output_{context.node_ids[node]}"
+        case GlobalNode():
+            return f"global_{context.node_ids[node]}"
+        case _:
+            raise ValueError(f"Unknown node type: {type(node)}")
+
+
+def compile_kwargs(kwargs: Mapping[str, Any]) -> str:
+    """
+    Compile the kwargs for the node.
+
+    This is used to compile the kwargs for the node.
+    For example, if the kwargs is {"a": 1, "b": 2}, the compiled kwargs will be "a=1, b=2".
+
+    Args:
+        kwargs: The kwargs to compile.
+
+    Returns:
+        The compiled kwargs.
+    """
+    return ", ".join(f"{k}={repr(v)}" for k, v in kwargs.items())
+
+
+def compile_fluent(code: list[str]) -> list[str]:
+    """
+    Compile the fluent code.
+
+    This is used to compile the fluent code.
+    For example, if the code is ["a=1", "b=2"], the compiled code will be ["a=1", "b=2"].
+
+    Args:
+        code: The code to compile.
+
+    Returns:
+        The compiled code.
+    """
+    buffer = [k.split("=", 1)[:2] for k in code]
+
+    # if the var used in the following expr only once, we can remove the assignment and replace the var with the expr, otherwise, we keep it
+    processed_index = 0
+    while processed_index < len(buffer):
+        var, expr = buffer[processed_index]
+        var = var.strip()
+        expr = expr.strip()
+
+        matched_times = sum(
+            _expr.count(var) for _var, _expr in buffer[processed_index + 1 :]
+        )
+        if matched_times != 1:
+            processed_index += 1
+            continue
+
+        for i, (_var, _expr) in enumerate(buffer[processed_index + 1 :]):
+            if var in _expr:
+                buffer[processed_index + 1 + i] = [_var, _expr.replace(var, expr)]
+
+        del buffer[processed_index]
+
+    return [f"{k.strip()} = {v.strip()}" for k, v in buffer]
+
+
+def compile(stream: Stream, auto_fix: bool = True, fluent: bool = True) -> str:
+    """
+    Compile the python code.
+
+    This is used to compile the python code.
+    For example, if the stream is a video stream, the compiled code will be the python code to create the video stream.
+
+    Args:
+        stream: The stream to compile.
+        auto_fix: Whether to auto fix the stream.
+        fluent: Whether to use fluent syntax.
+
+    Returns:
+        The compiled python code.
+    """
+    stream = validate(stream, auto_fix=auto_fix)
+    node = stream.node
+    context = DAGContext.build(node)
+
+    code = []
+
+    input_nodes = sorted(
+        (node for node in context.nodes if isinstance(node, InputNode)),
+        key=lambda k: context.node_ids[k],
+    )
+
+    for node in input_nodes:
+        # NOTE: technically, the expression returns a stream, but since input node can reuse the same stream multiple times, we need to assign the stream to the node
+        code.append(
+            f"{get_output_var_name(node, context)} = ffmpeg.input('{node.filename}', {compile_kwargs(node.kwargs)})"
+        )
+
+    filter_data = load(list[FFMpegFilter], "filters")
+    filter_data_dict = {f.name: f for f in filter_data}
+    filter_nodes = sorted(
+        (node for node in context.nodes if isinstance(node, FilterNode)),
+        key=lambda k: context.node_ids[k],
+    )
+
+    for node in filter_nodes:
+        filter_def = filter_data_dict[node.name]
+
+        if (
+            not filter_def.is_dynamic_input
+            and len(filter_def.stream_typings_input) == 1
+        ):
+            expression = f"{get_input_var_name(node.inputs[0], context, filter_data_dict)}.{node.name}({compile_kwargs(node.kwargs)})"
+        else:
+            in_streams_names = ", ".join(
+                get_input_var_name(stream, context, filter_data_dict)
+                for stream in node.inputs
+            )
+            expression = f"ffmpeg.filters.{node.name}({in_streams_names}, {compile_kwargs(node.kwargs)})"
+
+        code.append(f"{get_output_var_name(node, context)} = {expression}")
+
+    output_nodes = sorted(
+        (node for node in context.nodes if isinstance(node, OutputNode)),
+        key=lambda k: context.node_ids[k],
+    )
+
+    for node in output_nodes:
+        in_streams_names = ", ".join(
+            get_input_var_name(stream, context, filter_data_dict)
+            for stream in node.inputs
+        )
+
+        if len(node.inputs) == 1:
+            code.append(
+                f"{get_output_var_name(node, context)} = {get_input_var_name(node.inputs[0], context, filter_data_dict)}.output(filename='{node.filename}', {compile_kwargs(node.kwargs)})"
+            )
+        else:
+            code.append(
+                f"{get_output_var_name(node, context)} = ffmpeg.output({in_streams_names}, filename='{node.filename}', {compile_kwargs(node.kwargs)})"
+            )
+
+    global_nodes = sorted(
+        (node for node in context.nodes if isinstance(node, GlobalNode)),
+        key=lambda k: context.node_ids[k],
+    )
+
+    assert len(global_nodes) <= 1, "Only one global node is supported"
+
+    if global_nodes:
+        node = global_nodes[0]
+
+        if len(node.inputs) > 1:
+            in_streams_names = ", ".join(
+                get_input_var_name(s, context, filter_data_dict) for s in node.inputs
+            )
+            code.append(
+                f"{get_output_var_name(node, context)} = ffmpeg.merge_outputs({in_streams_names}).global_args({compile_kwargs(node.kwargs)})"
+            )
+        else:
+            code.append(
+                f"{get_output_var_name(node, context)} = {get_input_var_name(node.inputs[0], context, filter_data_dict)}.global_args({compile_kwargs(node.kwargs)})"
+            )
+
+    code.append(f"result = {get_output_var_name(node, context)}")
+    code = [k.replace(", )", ")") for k in code]
+
+    if fluent:
+        code = compile_fluent(code)
+
+    return "\n".join(["import ffmpeg", *code])
+
+
+def parse(code: str) -> Stream:
+    """
+    Parse the python code.
+
+    This is used to parse the python code.
+    For example, if the code is ["import ffmpeg", "input_0 = ffmpeg.input('input1.mp4')", "result = input_0"], the parsed stream will be the stream created by the input node.
+
+    Args:
+        code: The code to parse.
+
+    Returns:
+        The parsed stream.
+    """
+    local_vars: dict[str, Any] = {}
+    exec(code, {}, local_vars)
+    result = local_vars["result"]
+
+    assert isinstance(result, Stream)
+    return validate(result, auto_fix=True)

typed_ffmpeg/{dag → compile}/context.py

@@ -10,18 +10,19 @@ during graph validation and command-line compilation.
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterable
 from dataclasses import dataclass
 from functools import cached_property
-from typing import Any, TypeVar
+from typing import TypeVar
 
+from ..dag.nodes import FilterNode, InputNode
+from ..dag.schema import Node, Stream
 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]:
+def _remove_duplicates(seq: Iterable[T]) -> list[T]:
     """
     Remove duplicates from a list while preserving the original order.
 
@@ -36,7 +37,7 @@ def _remove_duplicates(seq: list[T]) -> list[T]:
         A new list with duplicates removed, preserving the original order
     """
     seen = set()
-    output = []
+    output: list[T] = []
 
     for x in seq:
         if x not in seen:
@@ -62,7 +63,8 @@ def _collect(node: Node) -> tuple[list[Node], list[Stream]]:
         - A list of all nodes in the upstream path (including the starting node)
         - A list of all streams connecting these nodes
     """
-    nodes, streams = [node], [*node.inputs]
+    nodes: list[Node] = [node]
+    streams: list[Stream] = list(node.inputs)
 
     for stream in node.inputs:
         _nodes, _streams = _collect(stream.node)
@@ -204,6 +206,24 @@ class DAGContext:
 
         return outgoing_streams
 
+    @cached_property
+    def node_ids(self) -> dict[Node, int]:
+        """
+        Get a mapping of nodes to their unique integer IDs.
+        This property assigns a unique integer ID to each node in the graph,
+        based on the node type and its position in the processing chain.
+        Returns:
+            A dictionary mapping nodes to their unique integer IDs
+        """
+        node_index: dict[type[Node], int] = defaultdict(int)
+        node_ids: dict[Node, int] = {}
+
+        for node in sorted(self.nodes, key=lambda node: node.max_depth):
+            node_ids[node] = node_index[node.__class__]
+            node_index[node.__class__] += 1
+
+        return node_ids
+
     @cached_property
     def node_labels(self) -> dict[Node, str]:
         """
@@ -274,9 +294,6 @@ class DAGContext:
             AssertionError: If the node is not an InputNode or FilterNode
         """
 
-        assert isinstance(node, (InputNode, FilterNode)), (
-            "Only input and filter nodes have labels"
-        )
         return self.node_labels[node]
 
     @override
@@ -296,39 +313,3 @@ class DAGContext:
             A list of streams that originate from this node
         """
         return self.outgoing_streams[node]
-
-    def render(self, obj: Any) -> Any:
-        """
-        Recursively convert graph objects to a human-readable representation.
-
-        This method processes arbitrary objects, with special handling for graph
-        elements like nodes and streams. It converts them to a readable string format
-        that includes node labels. It recursively handles nested structures like
-        lists, tuples, and dictionaries.
-
-        This is primarily used for debugging, logging, and visualization purposes.
-
-        Args:
-            obj: The object to render, which may be a Node, Stream, or a container
-                 with these objects nested inside
-
-        Returns:
-            The rendered representation of the object:
-            - For nodes: "Node(repr#label)"
-            - For streams: "Stream(node_repr#label#index)"
-            - For containers: recursively rendered contents
-            - For other objects: the original object unchanged
-        """
-
-        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 → compile}/validate.py

@@ -12,12 +12,12 @@ from __future__ import annotations
 
 from dataclasses import replace
 
+from ..dag.nodes import FilterNode, InputNode
+from ..dag.schema import Node, Stream
 from ..exceptions import FFMpegValueError
 from ..streams.audio import AudioStream
 from ..streams.video import VideoStream
 from .context import DAGContext
-from .nodes import FilterNode, InputNode
-from .schema import Node, Stream
 
 
 def remove_split(

typed_ffmpeg/dag/global_runnable/runnable.py

@@ -81,7 +81,7 @@ class GlobalRunable(GlobalArgs):
     def compile(
         self,
         cmd: str | list[str] = "ffmpeg",
-        overwrite_output: bool = None,
+        overwrite_output: bool | None = None,
         auto_fix: bool = True,
     ) -> list[str]:
         """
@@ -111,7 +111,7 @@ class GlobalRunable(GlobalArgs):
             # Result: ['ffmpeg', '-i', 'input.mp4', 'output.mp4']
             ```
         """
-        from ..compile import compile
+        from ...compile.compile_cli import compile_as_list
 
         if isinstance(cmd, str):
             cmd = [cmd]
@@ -121,12 +121,12 @@ class GlobalRunable(GlobalArgs):
         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)
+        return cmd + compile_as_list(self._global_node().stream(), auto_fix=auto_fix)
 
     def compile_line(
         self,
         cmd: str | list[str] = "ffmpeg",
-        overwrite_output: bool = None,
+        overwrite_output: bool | None = None,
         auto_fix: bool = True,
     ) -> str:
         """
@@ -165,7 +165,7 @@ class GlobalRunable(GlobalArgs):
         pipe_stdout: bool = False,
         pipe_stderr: bool = False,
         quiet: bool = False,
-        overwrite_output: bool = None,
+        overwrite_output: bool | None = None,
         auto_fix: bool = True,
     ) -> subprocess.Popen[bytes]:
         """
@@ -222,7 +222,7 @@ class GlobalRunable(GlobalArgs):
         capture_stderr: bool = False,
         input: bytes | None = None,
         quiet: bool = False,
-        overwrite_output: bool = None,
+        overwrite_output: bool | None = None,
         auto_fix: bool = True,
     ) -> tuple[bytes, bytes]:
         """