typed-ffmpeg-compatible 3.0.2a0__tar.gz → 3.2.2__tar.gz

typed_ffmpeg_compatible-3.2.2/MANIFEST.in

@@ -0,0 +1,41 @@
+global-exclude **/tests/**
+global-exclude **/scripts/**
+global-exclude **/__snapshots__/**
+global-exclude **/test_*
+global-exclude **/*_test.py
+global-exclude **/*.test.py
+global-exclude **/conftest.py
+
+# Exclude development and documentation files
+global-exclude .coveragerc
+global-exclude .eslintrc.json
+global-exclude .gitignore
+global-exclude .gitmodules
+global-exclude .pre-commit-config.yaml
+global-exclude .prettierignore
+global-exclude .prettierrc
+global-exclude blog.md
+global-exclude codecov.yml
+global-exclude mkdocs.yml
+global-exclude pyproject-compatible.toml
+global-exclude requirements.in
+global-exclude requirements.txt
+global-exclude tox.ini
+global-exclude uv.lock
+global-exclude README.ipynb
+
+# Exclude development container files
+global-exclude .devcontainer/**
+global-exclude .github/**
+
+# Exclude documentation
+global-exclude docs/**
+
+# Exclude uv configuration
+global-exclude .uv/**
+
+# Include only necessary files
+include LICENSE
+include README.md
+include pyproject.toml
+include MANIFEST.in 

{typed_ffmpeg_compatible-3.0.2a0 → typed_ffmpeg_compatible-3.2.2}/PKG-INFO

@@ -1,15 +1,13 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: typed-ffmpeg-compatible
-Version: 3.0.2a0
+Version: 3.2.2
 Summary: Modern Python FFmpeg wrappers offer comprehensive support for complex filters, complete with detailed typing and documentation.
-Home-page: https://livingbio.github.io/typed-ffmpeg/
-License: MIT
+Author-email: lucemia <lucemia@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://livingbio.github.io/typed-ffmpeg/
+Project-URL: Repository, https://github.com/livingbio/typed-ffmpeg
 Keywords: ffmpeg,video,audio,multimedia,filter
-Author: lucemia
-Author-email: lucemia@gmail.com
-Requires-Python: >=3.10,<4.0
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
@@ -17,15 +15,18 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Provides-Extra: graph
-Requires-Dist: graphviz ; extra == "graph"
-Project-URL: Repository, https://github.com/livingbio/typed-ffmpeg
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: graph
+Requires-Dist: graphviz; extra == "graph"
+Dynamic: license-file
 
 ## typed-ffmpeg
 
@@ -44,6 +45,7 @@ Description-Content-Type: text/markdown
 - [Installation](#installation)
 - [Quick Usage](#quick-usage)
 - [Documentation](https://livingbio.github.io/typed-ffmpeg/)
+- [Interactive Playground](#interactive-playground)
 - [Acknowledgements](#acknowledgements)
 
 ---
@@ -63,6 +65,7 @@ Description-Content-Type: text/markdown
 - **Validation and Auto-correction:** Assists in identifying and fixing errors within filter graphs.
 - **Input and Output Options Support:** Provide a more comprehensive interface for input and output options, including support for additional codecs and formats.
 - **Partial Evaluation:** Enhance the flexibility of filter graphs by enabling partial evaluation, allowing for modular construction and reuse.
+- **Media File Analysis:** Built-in support for analyzing media files using FFmpeg's ffprobe utility, providing detailed metadata extraction with both dictionary and dataclass interfaces.
 
 ### Planned Features
 
@@ -101,12 +104,14 @@ Note: This requires Graphviz to be installed on your system.
 
 Here's how to quickly start using `typed-ffmpeg`:
 
-
-
-
 ```python
 import ffmpeg
 
+# Analyze a media file
+info = ffmpeg.probe("video.mp4")
+print(f"Duration: {float(info['format']['duration']):.2f} seconds")
+print(f"Streams: {len(info['streams'])}")
+
 # Flip video horizontally and output
 f = (
     ffmpeg
@@ -163,6 +168,21 @@ f
 
 See the [Usage](https://livingbio.github.io/typed-ffmpeg/usage/typed/) section in our documentation for more examples and detailed guides.
 
+---
+
+## Interactive Playground
+
+Try out `typed-ffmpeg` directly in your browser with our [Interactive Playground](https://livingbio.github.io/typed-ffmpeg-playground/)! The playground provides a live environment where you can:
+
+![Interactive Playground](https://raw.githubusercontent.com/livingbio/typed-ffmpeg/main/docs/media/playground-screenshot.png)
+
+- Experiment with FFmpeg filters and commands
+- Visualize filter graphs in real-time
+- Test different input/output configurations
+- Learn through interactive examples
+- Share your filter graphs with others
+
+The playground is perfect for learning and prototyping FFmpeg filter chains without setting up a local environment.
 
 ---
 
@@ -179,4 +199,3 @@ This project is dedicated to my son, Austin, on his seventh birthday (February 2
 ---
 
 Feel free to check the [Documentation](https://livingbio.github.io/typed-ffmpeg/) for detailed information and more advanced features.
-

{typed_ffmpeg_compatible-3.0.2a0 → typed_ffmpeg_compatible-3.2.2}/README.md

@@ -15,6 +15,7 @@
 - [Installation](#installation)
 - [Quick Usage](#quick-usage)
 - [Documentation](https://livingbio.github.io/typed-ffmpeg/)
+- [Interactive Playground](#interactive-playground)
 - [Acknowledgements](#acknowledgements)
 
 ---
@@ -34,6 +35,7 @@
 - **Validation and Auto-correction:** Assists in identifying and fixing errors within filter graphs.
 - **Input and Output Options Support:** Provide a more comprehensive interface for input and output options, including support for additional codecs and formats.
 - **Partial Evaluation:** Enhance the flexibility of filter graphs by enabling partial evaluation, allowing for modular construction and reuse.
+- **Media File Analysis:** Built-in support for analyzing media files using FFmpeg's ffprobe utility, providing detailed metadata extraction with both dictionary and dataclass interfaces.
 
 ### Planned Features
 
@@ -72,12 +74,14 @@ Note: This requires Graphviz to be installed on your system.
 
 Here's how to quickly start using `typed-ffmpeg`:
 
-
-
-
 ```python
 import ffmpeg
 
+# Analyze a media file
+info = ffmpeg.probe("video.mp4")
+print(f"Duration: {float(info['format']['duration']):.2f} seconds")
+print(f"Streams: {len(info['streams'])}")
+
 # Flip video horizontally and output
 f = (
     ffmpeg
@@ -134,6 +138,21 @@ f
 
 See the [Usage](https://livingbio.github.io/typed-ffmpeg/usage/typed/) section in our documentation for more examples and detailed guides.
 
+---
+
+## Interactive Playground
+
+Try out `typed-ffmpeg` directly in your browser with our [Interactive Playground](https://livingbio.github.io/typed-ffmpeg-playground/)! The playground provides a live environment where you can:
+
+![Interactive Playground](https://raw.githubusercontent.com/livingbio/typed-ffmpeg/main/docs/media/playground-screenshot.png)
+
+- Experiment with FFmpeg filters and commands
+- Visualize filter graphs in real-time
+- Test different input/output configurations
+- Learn through interactive examples
+- Share your filter graphs with others
+
+The playground is perfect for learning and prototyping FFmpeg filter chains without setting up a local environment.
 
 ---
 

typed_ffmpeg_compatible-3.2.2/pyproject.toml

@@ -0,0 +1,125 @@
+[project]
+name = "typed-ffmpeg-compatible"
+dynamic = ["version"]
+description = "Modern Python FFmpeg wrappers offer comprehensive support for complex filters, complete with detailed typing and documentation."
+authors = [
+    {name = "lucemia", email = "lucemia@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = [
+    "ffmpeg",
+    "video",
+    "audio",
+    "multimedia",
+    "filter",
+]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+
+[project.scripts]
+scripts = "scripts.main:app"
+
+[project.urls]
+Homepage = "https://livingbio.github.io/typed-ffmpeg/"
+Repository = "https://github.com/livingbio/typed-ffmpeg"
+
+[project.optional-dependencies]
+graph = ["graphviz"]
+
+[build-system]
+requires = ["setuptools>=61.0", "setuptools-scm>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["typed_ffmpeg*"]
+exclude = [
+    "**/tests/**",
+    "**/scripts/**",
+    "**/__snapshots__/**",
+    "**/test_*",
+    "**/*_test.py",
+    "**/*.test.py",
+    "**/conftest.py"
+]
+
+[tool.setuptools.package-data]
+"ffmpeg" = ["py.typed"]
+"ffmpeg.common" = ["*"]
+"ffmpeg.common.cache" = ["*"]
+"ffmpeg.common.cache.list" = ["*"]
+"ffmpeg.common.cache.FFMpegFilterManuallyDefined" = ["*"]
+"ffmpeg.utils" = ["*"]
+"ffmpeg.utils.lazy_eval" = ["*"]
+exclude = [
+    "**/tests/**",
+    "**/scripts/**",
+    "**/__snapshots__/**",
+    "**/test_*",
+    "**/*_test.py",
+    "**/*.test.py",
+    "**/conftest.py"
+]
+
+[tool.setuptools_scm]
+version_scheme = "post-release"
+local_scheme = "node-and-timestamp"
+write_to = "src/typed_ffmpeg/_version.py"
+
+[tool.mypy]
+exclude = "^(migrations|commands|sandbox|samples|sdk)/"
+show_error_codes = true
+implicit_optional = true
+follow_imports = "silent"
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+check_untyped_defs = true
+no_implicit_reexport = true
+disallow_untyped_defs = true
+
+[tool.ruff]
+line-length = 88
+exclude = ["**/cassettes/", "**/__snapshots__/"]
+src = ["src"]
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "B006",   # flake8-bugbear: Do not use mutable data structures for argument defaults
+    "C4",  # flake8-comprehensions
+    "UP",  # pyupgrade
+]
+ignore = [
+    "E741",  # Ambiguous variable name: `I`
+    "E501",  # Line too long
+    "E402",  # Module level import not at top of file
+    "E712",  # not work for pandas
+    "F811",  # FIXME: we relay on it to share fixture across app
+]
+
+[tool.ruff.format]
+quote-style = "double"
+docstring-code-format = true

typed_ffmpeg_compatible-3.2.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

{typed_ffmpeg_compatible-3.0.2a0 → typed_ffmpeg_compatible-3.2.2}/src/typed_ffmpeg/__init__.py

@@ -26,8 +26,8 @@ from . import compile, dag, filters, sources
 from .base import afilter, filter_multi_output, input, merge_outputs, output, vfilter
 from .dag import Stream
 from .exceptions import FFMpegExecuteError, FFMpegTypeError, FFMpegValueError
+from .ffprobe.probe import probe, probe_obj
 from .info import get_codecs, get_decoders, get_encoders
-from .probe import probe
 from .streams import AudioStream, AVStream, VideoStream
 
 __all__ = [
@@ -41,6 +41,7 @@ __all__ = [
     "FFMpegValueError",
     "Stream",
     "probe",
+    "probe_obj",
     "compile",
     "AudioStream",
     "VideoStream",

typed_ffmpeg_compatible-3.2.2/src/typed_ffmpeg/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '3.2.2'
+__version_tuple__ = version_tuple = (3, 2, 2)

{typed_ffmpeg_compatible-3.0.2a0 → typed_ffmpeg_compatible-3.2.2}/src/typed_ffmpeg/compile/compile_cli.py

@@ -21,13 +21,10 @@ import shlex
 from collections import defaultdict
 from collections.abc import Mapping
 
-from ffmpeg.dag.factory import filter_node_factory
-from ffmpeg.streams.audio import AudioStream
-from ffmpeg.streams.video import VideoStream
-
 from ..base import input, merge_outputs, output
 from ..common.cache import load
 from ..common.schema import FFMpegFilter, FFMpegFilterDef, FFMpegOption, StreamType
+from ..dag.factory import filter_node_factory
 from ..dag.nodes import (
     FilterableStream,
     FilterNode,
@@ -39,7 +36,9 @@ from ..dag.nodes import (
 from ..dag.schema import Node, Stream
 from ..exceptions import FFMpegValueError
 from ..schema import Default
+from ..streams.audio import AudioStream
 from ..streams.av import AVStream
+from ..streams.video import VideoStream
 from ..utils.escaping import escape
 from ..utils.lazy_eval.schema import LazyValue
 from ..utils.run import command_line
@@ -153,6 +152,15 @@ def parse_output(
             stream = parse_stream_selector(map_option, in_streams)
             inputs.append(stream)
 
+        if not inputs:
+            # NOTE: if there is no inputs, and there is only one input node
+            if len([k for k in in_streams if isinstance(in_streams[k], AVStream)]) == 1:
+                inputs = [
+                    in_streams[k]
+                    for k in in_streams
+                    if isinstance(in_streams[k], AVStream)
+                ]
+
         assert inputs, f"No inputs found for output {filename}"
         export.append(output(*inputs, filename=filename, extra_options=options))
         buffer = []
@@ -309,37 +317,21 @@ def parse_global(
         For tokens like ['-y', '-loglevel', 'quiet', '-i', 'input.mp4']:
         Returns ({'y': True, 'loglevel': 'quiet'}, ['-i', 'input.mp4'])
     """
-    global_params: dict[str, str | bool] = {}
-    remaining_tokens = tokens.copy()
-
-    # Process tokens until we hit an input file marker (-i)
-    while remaining_tokens and remaining_tokens[0] != "-i":
-        if remaining_tokens[0].startswith("-"):
-            option_name = remaining_tokens[0][1:]
-            assert option_name in ffmpeg_options, (
-                f"Unknown global option: {option_name}"
-            )
-            option = ffmpeg_options[option_name]
-
-            if not option.is_global_option:
-                continue
-
-            if len(remaining_tokens) > 1 and not remaining_tokens[1].startswith("-"):
-                # Option with value
-                global_params[option_name] = remaining_tokens[1]
-                remaining_tokens = remaining_tokens[2:]
+    options = parse_options(tokens[: tokens.index("-i")])
+    remaining_tokens = tokens[tokens.index("-i") :]
+    parameters: dict[str, str | bool] = {}
+
+    for key, value in options.items():
+        assert key in ffmpeg_options, f"Unknown option: {key}"
+        option = ffmpeg_options[key]
+
+        if option.is_global_option:
+            # Process only recognized global options
+            if value[-1] is None:
+                parameters[key] = True
             else:
-                # Boolean option
-                if option_name.startswith("no"):
-                    global_params[option_name[2:]] = False
-                else:
-                    global_params[option_name] = True
-                remaining_tokens = remaining_tokens[1:]
-        else:
-            # Skip non-option tokens
-            remaining_tokens = remaining_tokens[1:]
-
-    return global_params, remaining_tokens
+                parameters[key] = value[-1]
+    return parameters, remaining_tokens
 
 
 def parse(cli: str) -> Stream:
@@ -348,7 +340,7 @@ def parse(cli: str) -> Stream:
     ffmpeg_filters = get_filter_dict()
 
     tokens = shlex.split(cli)
-    assert tokens[0] == "ffmpeg"
+    assert tokens[0].lower().split(".")[0] == "ffmpeg"
     tokens = tokens[1:]
 
     # Parse global options first
@@ -677,6 +669,22 @@ def get_args_output_node(node: OutputNode, context: DAGContext) -> list[str]:
     if context:
         for input in node.inputs:
             if isinstance(input.node, InputNode):
+                # NOTE: specially rules,
+                # if there is only one input node,
+                # only one output node,
+                # the output node has only one input,
+                # and the stream selector is not specified,
+                # then the map can be ignore.
+                if (
+                    input.index is None
+                    and isinstance(input, AVStream)
+                    and len([k for k in context.all_nodes if isinstance(k, InputNode)])
+                    == 1
+                    and len([k for k in context.all_nodes if isinstance(k, OutputNode)])
+                    == 1
+                    and len(node.inputs) == 1
+                ):
+                    continue
                 commands += ["-map", get_stream_label(input, context)]
             else:
                 commands += ["-map", f"[{get_stream_label(input, context)}]"]

{typed_ffmpeg_compatible-3.0.2a0 → typed_ffmpeg_compatible-3.2.2}/src/typed_ffmpeg/compile/compile_python.py

@@ -3,10 +3,6 @@ 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 (
@@ -19,6 +15,9 @@ from ..dag.nodes import (
     OutputStream,
 )
 from ..dag.schema import Node, Stream
+from ..streams.audio import AudioStream
+from ..streams.av import AVStream
+from ..streams.video import VideoStream
 from .context import DAGContext
 from .validate import validate
 

typed_ffmpeg_compatible-3.2.2/src/typed_ffmpeg/ffprobe/parse.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+
+import json
+import types
+from dataclasses import is_dataclass
+from typing import (
+    Any,
+    TypeGuard,
+    TypeVar,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from .schema import ffprobeType, registered_types
+from .xml2json import xml_string_to_json
+
+T = TypeVar("T")
+
+
+def _get_actual_type(type_hint: Any) -> type[Any]:
+    """
+    Get the actual type from a type hint, handling Optional and Union (including | syntax).
+
+    Args:
+        type_hint: The type hint to get the actual type from
+
+    Returns:
+        The actual type
+    """
+    # If type_hint is a string, evaluate it in the schema's module context
+    if isinstance(type_hint, str):
+        type_hint = registered_types[type_hint]
+
+    origin = get_origin(type_hint)
+    # Handle typing.Union and types.UnionType (for int | None in Python 3.10+)
+    if origin is Union or (hasattr(types, "UnionType") and origin is types.UnionType):
+        non_none_types = [t for t in get_args(type_hint) if t is not type(None)]
+        if non_none_types:
+            return _get_actual_type(non_none_types[0])
+    # Handle direct types.UnionType (for int | None in Python 3.10+)
+    if hasattr(types, "UnionType") and isinstance(type_hint, types.UnionType):
+        non_none_types = [t for t in type_hint.__args__ if t is not type(None)]
+        if non_none_types:
+            return _get_actual_type(non_none_types[0])
+    return type_hint
+
+
+def is_dataclass_type(obj: type[Any]) -> TypeGuard[type[T]]:
+    """
+    Check if an object is a dataclass type.
+
+    Args:
+        obj: The object to check
+
+    Returns:
+        True if the object is a dataclass type, False otherwise
+    """
+    return is_dataclass(obj)
+
+
+def _parse_obj_from_dict(data: Any, cls: type[T]) -> T | None:
+    """
+    Parse a dictionary into a dataclass instance.
+
+    Args:
+        data: The dictionary to parse
+        cls: The dataclass to parse into
+
+    Returns:
+        The parsed dataclass instance
+    """
+    if data is None:
+        return None
+
+    if isinstance(cls, type):
+        if cls is str:
+            return cast(T, str(data))
+        elif cls is int:
+            return cast(T, int(data))
+        elif cls is float:
+            return cast(T, float(data))
+        elif cls is bool:
+            return cast(T, bool(data))
+
+    if not isinstance(data, dict):
+        return cls()
+
+    if isinstance(cls, str):  # NOTE: python 3.10
+        cls = registered_types[cls]
+
+    type_hints = get_type_hints(cls)
+    kwargs: dict[str, Any] = {}
+
+    for field_name, field_type in type_hints.items():
+        actual_type = _get_actual_type(field_type)
+
+        if get_origin(actual_type) is tuple:
+            tuple_args = get_args(actual_type)
+            if not tuple_args:
+                continue
+            item_type = tuple_args[0]
+            value = data.get(field_name, [])
+            # NOTE: if the value is a single item, convert it to a list (xml's issue)
+            if not isinstance(value, list):
+                value = [value]
+            kwargs[field_name] = tuple(
+                _parse_obj_from_dict(item, item_type) for item in value
+            )
+            continue
+
+        kwargs[field_name] = _parse_obj_from_dict(data.get(field_name), actual_type)
+
+    return cls(**kwargs)
+
+
+def parse_ffprobe(xml_string: str) -> ffprobeType:
+    """
+    Parse ffprobe XML output into ffprobeType dataclass using JSON dict.
+
+    Args:
+        xml_string: The XML string to parse
+
+    Returns:
+        The parsed ffprobeType instance
+    """
+    json_str = xml_string_to_json(xml_string)
+    json_dict = json.loads(json_str)
+    # The root key is 'ffprobe'
+    root_data = json_dict.get("ffprobe", json_dict)
+    return _parse_obj_from_dict(root_data, ffprobeType) or ffprobeType()