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

typed_ffmpeg/types.py

@@ -1,5 +1,6 @@
 """
-This module defines the various types of options that can be used with FFmpeg.
+Define 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.
 """
@@ -29,7 +30,7 @@ Color = str | Default | LazyValue | None
 """
 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.
+The string 'random' will result in a random color.
 
 Note:
     [Document](https://ffmpeg.org/ffmpeg-utils.html#Color)

typed_ffmpeg/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility modules for the typed-ffmpeg package."""

typed_ffmpeg/utils/escaping.py

@@ -11,7 +11,7 @@ from typing import Any
 
 
 def escape(text: str | int | float, chars: str = "\\'=:") -> str:
-    """
+    r"""
     Escape special characters in a string for use in FFmpeg commands.
 
     This function adds backslash escaping to specified characters in a string,
@@ -34,6 +34,7 @@ def escape(text: str | int | float, chars: str = "\\'=:") -> str:
         # Escape a filter parameter value
         safe_value = escape("key=value", "=:")  # "key\\=value"
         ```
+
     """
     text = str(text)
     _chars = list(set(chars))
@@ -64,9 +65,11 @@ def convert_kwargs_to_cmd_line_args(kwargs: dict[str, Any]) -> list[str]:
 
     Example:
         ```python
-        args = convert_kwargs_to_cmd_line_args(
-            {"c:v": "libx264", "crf": 23, "preset": "medium"}
-        )
+        args = convert_kwargs_to_cmd_line_args({
+            "c:v": "libx264",
+            "crf": 23,
+            "preset": "medium",
+        })
         # Returns ['-c:v', 'libx264', '-crf', '23', '-preset', 'medium']
         ```
 
@@ -74,6 +77,7 @@ def convert_kwargs_to_cmd_line_args(kwargs: dict[str, Any]) -> list[str]:
         If a value is None, only the parameter name is included.
         If a value is an iterable (but not a string), the parameter is repeated
         for each value in the iterable.
+
     """
     args = []
     for k in sorted(kwargs.keys()):

typed_ffmpeg/utils/frozendict.py

@@ -29,6 +29,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Args:
             data: Dictionary to create a frozen copy of
+
         """
         self._data = dict(data)
         self._hash: int | None = None  # lazy computed
@@ -45,6 +46,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Raises:
             KeyError: If the key is not found
+
         """
         return self._data[key]
 
@@ -54,6 +56,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Returns:
             An iterator yielding the dictionary keys
+
         """
         return iter(self._data)
 
@@ -63,6 +66,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Returns:
             The number of key-value pairs in the dictionary
+
         """
         return len(self._data)
 
@@ -72,6 +76,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Returns:
             A string representation showing the dictionary contents
+
         """
         return f"FrozenDict({self._data})"
 
@@ -87,6 +92,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Returns:
             True if the objects are equal, False otherwise
+
         """
         if isinstance(other, Mapping):
             return dict(self._data) == dict(other)
@@ -101,6 +107,7 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
 
         Returns:
             An integer hash value
+
         """
         if self._hash is None:
             # Create a stable hash based on sorted key-value pairs
@@ -108,9 +115,29 @@ class FrozenDict(Mapping[K, V], Generic[K, V]):
         return self._hash
 
     def __or__(self, other: Mapping[Any, Any]) -> dict[Any, Any]:
+        """
+        Merge this FrozenDict with another mapping using the | operator.
+
+        Args:
+            other: Mapping to merge with
+
+        Returns:
+            A new regular dict containing the merged contents
+
+        """
         return dict(self) | dict(other)
 
     def __ror__(self, other: Mapping[Any, Any]) -> dict[Any, Any]:
+        """
+        Merge another mapping with this FrozenDict using the | operator.
+
+        Args:
+            other: Mapping to merge with
+
+        Returns:
+            A new regular dict containing the merged contents
+
+        """
         return dict(other) | dict(self)
 
 
@@ -123,6 +150,7 @@ def merge(*maps: Mapping[Any, Any] | None) -> FrozenDict[Any, Any]:
 
     Returns:
         A new dictionary containing the merged contents of all input dictionaries
+
     """
     output = {}
 
@@ -145,13 +173,14 @@ def exclude(maps: Mapping[Any, Any], exclude: Iterable[Any]) -> FrozenDict[Any,
 
     Returns:
         A new dictionary with the keys excluded
+
     """
     return FrozenDict({k: v for k, v in maps.items() if k not in exclude})
 
 
 def rekey(maps: Mapping[Any, Any], rekey: Mapping[Any, Any]) -> FrozenDict[Any, Any]:
     """
-    rekey the keys of a dictionary.
+    Rekey the keys of a dictionary.
 
     Args:
         maps: Dictionary to rekey
@@ -159,5 +188,6 @@ def rekey(maps: Mapping[Any, Any], rekey: Mapping[Any, Any]) -> FrozenDict[Any,
 
     Returns:
         A new dictionary with the keys remapped
+
     """
     return FrozenDict({rekey.get(k, k): v for k, v in maps.items()})

typed_ffmpeg/utils/lazy_eval/__init__.py

@@ -0,0 +1 @@
+"""Lazy evaluation utilities for typed-ffmpeg."""

typed_ffmpeg/utils/lazy_eval/operator.py

@@ -34,6 +34,7 @@ class Add(LazyOperator):
         # Evaluate the expression with specific values
         result = expr.eval(width=1280, height=720)  # Returns 2000
         ```
+
     """
 
     def _eval(self, left: Any, right: Any) -> Any:
@@ -46,6 +47,7 @@ class Add(LazyOperator):
 
         Returns:
             The sum of the left and right operands
+
         """
         return left + right
 
@@ -55,122 +57,168 @@ class Add(LazyOperator):
 
         Returns:
             A string in the format "(left+right)"
+
         """
         return f"({self.left}+{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Sub(LazyOperator):
-    """
-    A lazy operator for subtraction.
-    """
+    """A lazy operator for subtraction."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left - right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this subtraction operation.
+
+        Returns:
+            A string in the format "(left-right)"
+
+        """
         return f"({self.left}-{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Mul(LazyOperator):
-    """
-    A lazy operator for multiplication.
-    """
+    """A lazy operator for multiplication."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left * right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this multiplication operation.
+
+        Returns:
+            A string in the format "(left*right)"
+
+        """
         return f"({self.left}*{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class TrueDiv(LazyOperator):
-    """
-    A lazy operator for true division.
-    """
+    """A lazy operator for true division."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left / right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this division operation.
+
+        Returns:
+            A string in the format "(left/right)"
+
+        """
         return f"({self.left}/{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Pow(LazyOperator):
-    """
-    A lazy operator for exponentiation.
-    """
+    """A lazy operator for exponentiation."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left**right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this exponentiation operation.
+
+        Returns:
+            A string in the format "(left**right)"
+
+        """
         return f"({self.left}**{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Neg(LazyOperator):
-    """
-    A lazy operator for negation.
-    """
+    """A lazy operator for negation."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return -left
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this negation operation.
+
+        Returns:
+            A string in the format "-left"
+
+        """
         return f"-{self.left}"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Pos(LazyOperator):
-    """
-    A lazy operator for positive.
-    """
+    """A lazy operator for positive."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return +left
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this positive operation.
+
+        Returns:
+            A string in the format "+left"
+
+        """
         return f"+{self.left}"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Abs(LazyOperator):
-    """
-    A lazy operator for absolute value.
-    """
+    """A lazy operator for absolute value."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return abs(left)
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this absolute value operation.
+
+        Returns:
+            A string in the format "abs(left)"
+
+        """
         return f"abs({self.left})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class Mod(LazyOperator):
-    """
-    A lazy operator for modulo.
-    """
+    """A lazy operator for modulo."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left % right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this modulo operation.
+
+        Returns:
+            A string in the format "(left%right)"
+
+        """
         return f"({self.left}%{self.right})"
 
 
 @dataclass(frozen=True, kw_only=True)
 class FloorDiv(LazyOperator):
-    """
-    A lazy operator for floor division.
-    """
+    """A lazy operator for floor division."""
 
     def _eval(self, left: Any, right: Any) -> Any:
         return left // right
 
     def __str__(self) -> str:
+        """
+        Get a string representation of this floor division operation.
+
+        Returns:
+            A string in the format "(left//right)"
+
+        """
         return f"({self.left}//{self.right})"