Refactor scripts

src/scripts/code_gen/context.py

@@ -0,0 +1,68 @@
+from typing import Any, cast
+
+from ..parse_help import parse_codecs, parse_formats
+from ..parse_help.schema import (
+    FFMpegAVOption,
+    FFMpegCodec,
+    FFMpegDecoder,
+    FFMpegDemuxer,
+    FFMpegEncoder,
+    FFMpegFormat,
+    FFMpegMuxer,
+    FFMpegOptionChoice,
+)
+from .schema import (
+    FFMpegAVOptionIR,
+    FFMpegCodecIR,
+    FFMpegFormatIR,
+    FFMpegOptionChoiceIR,
+)
+
+
+def convert(obj: Any) -> Any:
+    match obj:
+        case FFMpegCodec():
+            return FFMpegCodecIR(
+                name=obj.name,
+                help=obj.help,
+                options=tuple(convert(option) for option in obj.options),
+                is_decoder=isinstance(obj, FFMpegDecoder),
+                is_encoder=isinstance(obj, FFMpegEncoder),
+            )
+        case FFMpegFormat():
+            return FFMpegFormatIR(
+                name=obj.name,
+                help=obj.help,
+                options=tuple(convert(option) for option in obj.options),
+                is_muxer=isinstance(obj, FFMpegMuxer),
+                is_demuxer=isinstance(obj, FFMpegDemuxer),
+            )
+        case FFMpegAVOption():
+            return FFMpegAVOptionIR(
+                name=obj.name,
+                help=obj.help,
+                type=obj.type,
+                choices=tuple(convert(choice) for choice in obj.choices),
+                default=obj.default,
+            )
+        case FFMpegOptionChoice():
+            return FFMpegOptionChoiceIR(
+                name=obj.name,
+                help=obj.help,
+                flags=obj.flags,
+                value=obj.value,
+            )
+        case _:
+            raise ValueError(f"Unknown object: {obj}")
+
+
+def all_codecs() -> list[FFMpegCodecIR]:
+    return cast(
+        list[FFMpegCodecIR], [convert(codec) for codec in parse_codecs.extract()]
+    )
+
+
+def all_formats() -> list[FFMpegFormatIR]:
+    return cast(
+        list[FFMpegFormatIR], [convert(format) for format in parse_formats.extract()]
+    )

src/scripts/code_gen/python/cli.py

@@ -0,0 +1,29 @@
+
+from pathlib import Path
+
+import typer
+from ...parse_help import parse_codecs
+from .render import render
+app = typer.Typer()
+
+@app.command()
+def generate(outpath: Path | None = None, rebuild: bool = False) -> None:
+    """
+    Generate filter and option documents
+
+    Args:
+        outpath: The output path
+        rebuild: Whether to rebuild the filters and options from scratch, ignoring the cache
+    """
+    if not outpath:
+        outpath = Path(__file__).parent.parent.parent / "ffmpeg"
+
+    codecs = parse_codecs.extract()
+
+    render(
+    )
+    os.system("pre-commit run -a")
+
+
+if __name__ == "__main__":
+    app()

src/scripts/code_gen/python/context.py

@@ -0,0 +1,67 @@
+from .. import context
+from .schema import (
+    PythonFFMpegCodec,
+    PythonFFMpegFormat,
+    PythonFFMpegOption,
+    PythonFFMpegOptionChoice,
+)
+
+
+def all_codecs() -> list[PythonFFMpegCodec]:
+    return [
+        PythonFFMpegCodec(
+            name=codec.name,
+            options=tuple(
+                PythonFFMpegOption(
+                    name=option.name,
+                    type=option.type,
+                    default=option.default,
+                    help=option.help,
+                    choices=tuple(
+                        PythonFFMpegOptionChoice(
+                            name=choice.name,
+                            help=choice.help,
+                            flags=choice.flags,
+                            value=choice.value,
+                        )
+                        for choice in option.choices
+                    ),
+                )
+                for option in codec.options
+            ),
+            help=codec.help,
+            is_decoder=codec.is_decoder,
+            is_encoder=codec.is_encoder,
+        )
+        for codec in context.all_codecs()
+    ]
+
+
+def all_formats() -> list[PythonFFMpegFormat]:
+    return [
+        PythonFFMpegFormat(
+            name=format.name,
+            options=tuple(
+                PythonFFMpegOption(
+                    name=option.name,
+                    type=option.type,
+                    default=option.default,
+                    help=option.help,
+                    choices=tuple(
+                        PythonFFMpegOptionChoice(
+                            name=choice.name,
+                            help=choice.help,
+                            flags=choice.flags,
+                            value=choice.value,
+                        )
+                        for choice in option.choices
+                    ),
+                )
+                for option in format.options
+            ),
+            help=format.help,
+            is_muxer=format.is_muxer,
+            is_demuxer=format.is_demuxer,
+        )
+        for format in context.all_formats()
+    ]

src/scripts/code_gen/python/schema.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+
+from ..schema import (
+    FFMpegAVOptionIR,
+    FFMpegCodecIR,
+    FFMpegFilterIR,
+    FFMpegFormatIR,
+    FFMpegOptionChoiceIR,
+)
+from .utils import option_typing, safe_name
+
+
+@dataclass(frozen=True, kw_only=True)
+class PythonFFMpegOptionChoice(FFMpegOptionChoiceIR): ...
+
+
+@dataclass(frozen=True, kw_only=True)
+class PythonFFMpegCodec(FFMpegCodecIR):
+    @property
+    def safe_name(self) -> str:
+        return safe_name(self.name)
+
+
+@dataclass(frozen=True, kw_only=True)
+class PythonFFMpegOption(FFMpegAVOptionIR):
+    @property
+    def safe_name(self) -> str:
+        return safe_name(self.name)
+
+    @property
+    def typing(self) -> str:
+        return option_typing(self)
+
+
+@dataclass(frozen=True, kw_only=True)
+class PythonFFMpegFormat(FFMpegFormatIR):
+    @property
+    def safe_name(self) -> str:
+        return safe_name(self.name)
+
+
+@dataclass(frozen=True, kw_only=True)
+class PythonFFMpegFilter(FFMpegFilterIR):
+    @property
+    def safe_name(self) -> str:
+        return safe_name(self.name)
+
+    @property
+    def return_typing(self) -> str:
+        raise NotImplementedError()

src/scripts/code_gen/python/tests/__snapshots__/test_render/test_render_codecs[decoders.py].raw

@@ -0,0 +1,26 @@
+from typing import Literal
+from .schema import FFMpegDecoderOption
+from ..utils.frozendict import FrozenDict, merge
+
+
+
+def h264(
+
+    profile: String| Literal["baseline"] = None,
+
+) -> FFMpegDecoderOption:
+    """
+    H.264 video codec for encoding/decoding
+
+    Args:
+        profile: Set H.264 profile (baseline, main, high)
+
+    Returns:
+        the set codec options
+    """
+    return FFMpegDecoderOption(kwargs=merge({
+
+        "profile": profile,
+
+    }))
+

src/scripts/code_gen/python/tests/__snapshots__/test_render/test_render_codecs[encoders.py].raw

@@ -0,0 +1,6 @@
+from typing import Literal
+from .schema import FFMpegEncoderOption
+from ..utils.frozendict import FrozenDict, merge
+
+
+

src/scripts/code_gen/python/tests/__snapshots__/test_render/test_render_formats[demuxers.py].raw

@@ -0,0 +1,6 @@
+from typing import Literal
+from .schema import FFMpegDemuxerOption
+from ..utils.frozendict import FrozenDict, merge
+
+
+

src/scripts/code_gen/python/tests/__snapshots__/test_render/test_render_formats[muxers.py].raw

@@ -0,0 +1,26 @@
+from typing import Literal
+from .schema import FFMpegMuxerOption
+from ..utils.frozendict import FrozenDict, merge
+
+
+
+def mp4(
+
+    profile: String| Literal["baseline"] = None,
+
+) -> FFMpegMuxerOption:
+    """
+    MP4 container format
+
+    Args:
+        profile: Set MP4 profile (baseline, main, high)
+
+    Returns:
+        the set codec options
+    """
+    return FFMpegMuxerOption(kwargs=merge({
+
+        "profile": profile,
+
+    }))
+