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

typed_ffmpeg/types.py

@@ -0,0 +1,119 @@
+"""
+This module defines the various types of options that can be used with FFmpeg.
+These option types can be one of several different categories.
+The source of these types is defined within the AVOptionType enumeration found in FFmpeg's opt.h header file.
+"""
+
+from typing import Literal
+
+from .schema import Default
+from .utils.lazy_eval.schema import LazyValue
+
+Boolean = bool | Literal["true", "false", "1", "0"] | Default | LazyValue
+"""
+This represents FFmpeg's boolean type. It can accept either a Python boolean value (`True` or `False`)
+or a string that represents a boolean value ("true", "false", "1", or "0").
+
+"""
+
+Duration = str | int | float | Default | LazyValue
+"""
+This represents FFmpeg's duration type. It can accept either a Python integer or float value
+or a string that represents a duration value.
+
+Note:
+    [Document](https://ffmpeg.org/ffmpeg-utils.html#Time-duration)
+"""
+
+Color = str | Default | LazyValue
+"""
+It can be the name of a color as defined below (case insensitive match) or a [0x|#]RRGGBB[AA] sequence, possibly followed by @ and a string representing the alpha component.
+The alpha component may be a string composed by "0x" followed by an hexadecimal number or a decimal number between 0.0 and 1.0, which represents the opacity value (‘0x00’ or ‘0.0’ means completely transparent, ‘0xff’ or ‘1.0’ completely opaque). If the alpha component is not specified then ‘0xff’ is assumed.
+The string ‘random’ will result in a random color.
+
+Note:
+    [Document](https://ffmpeg.org/ffmpeg-utils.html#Color)
+"""
+
+Flags = str | Default | LazyValue
+"""
+This represents FFmpeg's flags type. It accepts a string in the format "A+B",
+where "A" and "B" are individual flags. For example, "fast+bilinear" would
+represent two flags, "fast" and "bilinear", to be used in FFmpeg's command line.
+"""
+
+Dictionary = str | Default | LazyValue
+# format A=B:C=D:E=F
+Pix_fmt = str | Default | LazyValue
+"""
+please see `ffmpeg -pix_fmts` for a list of supported pixel formats.
+"""
+
+Int = int | Default | LazyValue
+"""
+This represents FFmpeg's integer type. It can accept either a Python integer value
+or a string that represents a integer value.
+"""
+
+Int64 = int | Default | LazyValue
+"""
+This represents FFmpeg's integer type. It can accept either a Python integer value
+or a string that represents a integer value.
+"""
+
+Double = int | float | Default | LazyValue
+"""
+This represents FFmpeg's double type. It can accept either a Python integer or float value
+or a string that represents a double value.
+"""
+# TODO: more info
+Float = int | float | Default | LazyValue
+"""
+This represents FFmpeg's float type. It can accept either a Python integer or float value
+or a string that represents a float value.
+"""
+String = str | int | float | Default | LazyValue
+"""
+This represents FFmpeg's string type. It can accept either a Python string value
+or a int/float that will be converted to a string.
+"""
+
+Video_rate = str | int | float | Default | LazyValue
+"""
+Specify the frame rate of a video, expressed as the number of frames generated per second. It has to be a string in the format frame_rate_num/frame_rate_den, an integer number, a float number or a valid video frame rate abbreviation.
+
+Note:
+    [Document](https://ffmpeg.org/ffmpeg-utils.html#Video-rate)
+"""
+
+# TODO: enum
+Image_size = str | Default | LazyValue
+"""
+Specify the size of the sourced video, it may be a string of the form widthxheight, or the name of a size abbreviation.
+
+Note:
+    [Document](https://ffmpeg.org/ffmpeg-utils.html#Video-size)
+"""
+
+Rational = str | Default | LazyValue
+"""
+Specify the frame rate of a video, expressed as the number of frames generated per second. It has to be a string in the format frame_rate_num/frame_rate_den, an integer number, a float number or a valid video frame rate abbreviation.
+
+Note:
+    [Document](https://ffmpeg.org/ffmpeg-utils.html#Ratio)
+"""
+
+
+Sample_fmt = str | Default | LazyValue
+Binary = str | Default | LazyValue
+
+# OPT Type
+Func = str | int | float | Default | LazyValue
+"""
+ref: OPT_TYPE_FUNC
+"""
+
+Time = str | int | float | Default | LazyValue
+"""
+ref: OPT_TYPE_TIME
+"""

typed_ffmpeg/utils/escaping.py

@@ -0,0 +1,49 @@
+from typing import Any, Iterable
+
+
+def escape(text: str | int | float, chars: str = "\\'=:") -> str:
+    """
+    Helper function to escape uncomfortable characters.
+
+    Args:
+        text: The text to escape.
+        chars: The characters to escape.
+
+    Returns:
+        The escaped text.
+    """
+    text = str(text)
+    _chars = list(set(chars))
+    if "\\" in _chars:
+        _chars.remove("\\")
+        _chars.insert(0, "\\")
+
+    for ch in _chars:
+        text = text.replace(ch, "\\" + ch)
+
+    return text
+
+
+def convert_kwargs_to_cmd_line_args(kwargs: dict[str, Any]) -> list[str]:
+    """
+    Helper function to build command line arguments out of dict.
+
+    Args:
+        kwargs: The dict to convert.
+
+    Returns:
+        The command line arguments.
+    """
+    args = []
+    for k in sorted(kwargs.keys()):
+        v = kwargs[k]
+        if isinstance(v, Iterable) and not isinstance(v, str):
+            for value in v:
+                args.append("-{}".format(k))
+                if value is not None:
+                    args.append("{}".format(value))
+            continue
+        args.append("-{}".format(k))
+        if v is not None:
+            args.append("{}".format(v))
+    return args

typed_ffmpeg/utils/lazy_eval/operator.py

@@ -0,0 +1,134 @@
+from dataclasses import dataclass
+from typing import Any
+
+from .schema import LazyOperator
+
+
+@dataclass(frozen=True, kw_only=True)
+class Add(LazyOperator):
+    """
+    A lazy operator for addition.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left + right
+
+    def __str__(self) -> str:
+        return f"({self.left}+{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Sub(LazyOperator):
+    """
+    A lazy operator for subtraction.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left - right
+
+    def __str__(self) -> str:
+        return f"({self.left}-{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Mul(LazyOperator):
+    """
+    A lazy operator for multiplication.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left * right
+
+    def __str__(self) -> str:
+        return f"({self.left}*{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class TrueDiv(LazyOperator):
+    """
+    A lazy operator for true division.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left / right
+
+    def __str__(self) -> str:
+        return f"({self.left}/{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Pow(LazyOperator):
+    """
+    A lazy operator for exponentiation.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left**right
+
+    def __str__(self) -> str:
+        return f"({self.left}**{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Neg(LazyOperator):
+    """
+    A lazy operator for negation.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return -left
+
+    def __str__(self) -> str:
+        return f"-{self.left}"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Pos(LazyOperator):
+    """
+    A lazy operator for positive.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return +left
+
+    def __str__(self) -> str:
+        return f"+{self.left}"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Abs(LazyOperator):
+    """
+    A lazy operator for absolute value.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return abs(left)
+
+    def __str__(self) -> str:
+        return f"abs({self.left})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class Mod(LazyOperator):
+    """
+    A lazy operator for modulo.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left % right
+
+    def __str__(self) -> str:
+        return f"({self.left}%{self.right})"
+
+
+@dataclass(frozen=True, kw_only=True)
+class FloorDiv(LazyOperator):
+    """
+    A lazy operator for floor division.
+    """
+
+    def _eval(self, left: Any, right: Any) -> Any:
+        return left // right
+
+    def __str__(self) -> str:
+        return f"({self.left}//{self.right})"

typed_ffmpeg/utils/lazy_eval/schema.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any
+
+from ..typing import override
+
+
+class LazyValue(ABC):
+    """
+    A base class for lazy evaluation.
+    """
+
+    def __add__(self, v: Any) -> LazyValue:
+        from .operator import Add
+
+        return Add(left=self, right=v)
+
+    def __radd__(self, v: Any) -> LazyValue:
+        from .operator import Add
+
+        return Add(left=v, right=self)
+
+    def __sub__(self, v: Any) -> LazyValue:
+        from .operator import Sub
+
+        return Sub(left=self, right=v)
+
+    def __rsub__(self, v: Any) -> LazyValue:
+        from .operator import Sub
+
+        return Sub(left=v, right=self)
+
+    def __mul__(self, v: Any) -> LazyValue:
+        from .operator import Mul
+
+        return Mul(left=self, right=v)
+
+    def __rmul__(self, v: Any) -> LazyValue:
+        from .operator import Mul
+
+        return Mul(left=v, right=self)
+
+    def __truediv__(self, v: Any) -> LazyValue:
+        from .operator import TrueDiv
+
+        return TrueDiv(left=self, right=v)
+
+    def __rtruediv__(self, v: Any) -> LazyValue:
+        from .operator import TrueDiv
+
+        return TrueDiv(left=v, right=self)
+
+    def __pow__(self, v: Any) -> LazyValue:
+        from .operator import Pow
+
+        return Pow(left=self, right=v)
+
+    def __rpow__(self, v: Any) -> LazyValue:
+        from .operator import Pow
+
+        return Pow(left=v, right=self)
+
+    def __neg__(self) -> LazyValue:
+        from .operator import Neg
+
+        return Neg(left=self)
+
+    def __pos__(self) -> LazyValue:
+        from .operator import Pos
+
+        return Pos(left=self)
+
+    def __abs__(self) -> LazyValue:
+        from .operator import Abs
+
+        return Abs(left=self)
+
+    def __mod__(self, v: Any) -> LazyValue:
+        from .operator import Mod
+
+        return Mod(left=self, right=v)
+
+    def __rmod__(self, v: Any) -> LazyValue:
+        from .operator import Mod
+
+        return Mod(left=v, right=self)
+
+    def __floordiv__(self, v: Any) -> LazyValue:
+        from .operator import FloorDiv
+
+        return FloorDiv(left=self, right=v)
+
+    def __rfloordiv__(self, v: Any) -> LazyValue:
+        from .operator import FloorDiv
+
+        return FloorDiv(left=v, right=self)
+
+    def eval(self, **values: Any) -> Any:
+        """
+        Evaluate the lazy value with the given values.
+
+        Args:
+            **values: Values to be used for evaluation.
+
+        Returns:
+            Any: The evaluated value.
+
+        Raises:
+            ValueError: If the lazy value is not ready to be evaluated.
+        """
+        v = self.partial(**values)
+        if isinstance(v, LazyValue):
+            raise ValueError(v.keys())
+        return v
+
+    @abstractmethod
+    def partial(self, **values: Any) -> Any:
+        """
+        Partially evaluate the lazy value with the given values.
+
+        Args:
+            **values: Values to be used for evaluation.
+
+        Returns:
+            Any: The partially evaluated value.
+        """
+
+        ...
+
+    def ready(self) -> bool:
+        """
+        Check if the lazy value is ready to be evaluated.
+        """
+        return not self.keys()
+
+    @abstractmethod
+    def keys(self) -> set[str]:
+        """
+        Get the keys that are required to evaluate the lazy value.
+        """
+        ...
+
+
+@dataclass(frozen=True)
+class Symbol(LazyValue):
+    """
+    A symbol that represents a variable in the lazy evaluation.
+
+    Such as `x`, `y`, `z`, etc.
+    """
+
+    key: str
+
+    def __str__(self) -> str:
+        return str(self.key)
+
+    @override
+    def partial(self, **values: Any) -> Any:
+        if self.key in values:
+            return values[self.key]
+        return self
+
+    @override
+    def keys(self) -> set[str]:
+        return {self.key}
+
+
+@dataclass(frozen=True, kw_only=True)
+class LazyOperator(LazyValue):
+    """
+    A base class for lazy operators.
+
+    Such as `Add`, `Sub`, `Mul`, `TrueDiv`, `Pow`, `Neg`, `Pos`, `Abs`, `Mod`, `FloorDiv`.
+    """
+
+    left: Any = None
+    right: Any = None
+
+    @abstractmethod
+    def _eval(self, left: Any, right: Any) -> Any:
+        """
+        Evaluate the operator with the given values.
+        """
+        ...
+
+    @override
+    def partial(self, **values: Any) -> Any:
+        if isinstance(self.left, LazyValue):
+            left = self.left.partial(**values)
+        else:
+            left = self.left
+
+        if isinstance(self.right, LazyValue):
+            right = self.right.partial(**values)
+        else:
+            right = self.right
+
+        return self._eval(left, right)
+
+    @override
+    def keys(self) -> set[str]:
+        r = set()
+        if isinstance(self.left, LazyValue):
+            r |= self.left.keys()
+
+        if isinstance(self.right, LazyValue):
+            r |= self.right.keys()
+
+        return r

typed_ffmpeg/utils/run.py

@@ -0,0 +1,27 @@
+import shlex
+
+from ..schema import Default
+from ..utils.lazy_eval.schema import LazyValue
+
+
+def command_line(args: list[str]) -> str:
+    """
+    Get the command line representation of the arguments.
+
+    Args:
+        args: The arguments to convert.
+
+    Returns:
+        The command line representation of the arguments.
+    """
+    return " ".join(shlex.quote(arg) for arg in args)
+
+
+# Filter_Node_Option_Type
+def ignore_default(
+    kwargs: dict[str, str | int | float | bool | Default]
+) -> tuple[tuple[str, str | int | float | bool | LazyValue], ...]:
+    """
+    Convert the values of the dictionary to strings.
+    """
+    return tuple((k, v) for k, v in kwargs.items() if not isinstance(v, Default))

typed_ffmpeg/utils/snapshot.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from syrupy.extensions.image import PNGImageSnapshotExtension
+from syrupy.types import PropertyFilter, PropertyMatcher, SerializableData, SerializedData
+
+from ..dag.schema import Stream
+
+
+class DAGSnapshotExtenstion(PNGImageSnapshotExtension):
+    """
+    A snapshot extension for the DAG. This extension is used to serialize and match the DAG.
+    """
+
+    def serialize(
+        self,
+        data: "SerializableData",
+        *,
+        exclude: Optional["PropertyFilter"] = None,
+        include: Optional["PropertyFilter"] = None,
+        matcher: Optional["PropertyMatcher"] = None,
+    ) -> "SerializedData":
+        stream = Stream(node=data)
+        graph_path = stream.view()
+
+        with open(graph_path, "rb") as ifile:
+            return super().serialize(ifile.read())

typed_ffmpeg/utils/typing.py

@@ -0,0 +1,17 @@
+from typing import TypeVar
+
+V = TypeVar("V")
+
+
+def override(func: V) -> V:
+    """
+    Decorator to indicate overriding a method.
+    the true override method is implemented until in python 3.12
+
+    Args:
+        func: The function to decorate.
+
+    Returns:
+        The decorated function.
+    """
+    return func

typed_ffmpeg/utils/view.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from ..dag.context import DAGContext
+from ..dag.nodes import FilterNode, InputNode, OutputNode
+from ..dag.schema import Node
+
+
+def _get_node_color(node: Node) -> str | None:
+    if isinstance(node, InputNode):
+        color = "#99cc00"
+    elif isinstance(node, OutputNode):
+        color = "#99ccff"
+    elif isinstance(node, FilterNode):
+        color = "#ffcc00"
+    else:
+        color = None
+    return color
+
+
+def view(node: Node, format: Literal["png", "svg", "dot"]) -> str:
+    """
+    Visualize the graph via graphviz.
+
+    Args:
+        node: The node to visualize.
+        format: The format to render the graph in.
+
+    Returns:
+        The path to the rendered graph.
+    """
+
+    try:
+        import graphviz  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "failed to import graphviz; please make sure graphviz is installed (e.g. " "`pip install graphviz`)"
+        )
+
+    graph = graphviz.Digraph(format=format)
+    graph.attr(rankdir="LR")
+    graph.attr(fontname="Helvetica")
+    graph.attr(fontsize="12")
+
+    context = DAGContext.build(node)
+
+    for node in context.all_nodes:
+        color = _get_node_color(node)
+        graph.node(
+            name=node.hex,
+            label=node.repr(),
+            shape="box",
+            style="filled",
+            fillcolor=color,
+            fontname="Helvetica",
+            fontsize="12",
+        )
+
+    for node in context.all_nodes:
+        for idx, stream in enumerate(node.inputs):
+            graph.edge(stream.node.hex, node.hex, label=f"{'*' if stream.index is None else stream.index} => {idx}")
+
+    return graph.render(engine="dot")

typed_ffmpeg_compatible-2.4.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 livingbio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.