typed-ffmpeg-compatible 2.4.1__tar.gz → 2.6.0__tar.gz

{typed_ffmpeg_compatible-2.4.1 → typed_ffmpeg_compatible-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: typed-ffmpeg-compatible
-Version: 2.4.1
+Version: 2.6.0
 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

{typed_ffmpeg_compatible-2.4.1 → typed_ffmpeg_compatible-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "typed-ffmpeg-compatible"
-version = "2.4.1"
+version = "2.6.0"
 description = "Modern Python FFmpeg wrappers offer comprehensive support for complex filters, complete with detailed typing and documentation."
 authors = ["lucemia <lucemia@gmail.com>"]
 readme = "README.md"

{typed_ffmpeg_compatible-2.4.1 → typed_ffmpeg_compatible-2.6.0}/src/typed_ffmpeg/__init__.py

@@ -2,6 +2,7 @@ from . import dag, filters
 from .base import afilter, filter_multi_output, input, merge_outputs, output, vfilter
 from .dag import Stream
 from .exceptions import FFMpegExecuteError, FFMpegTypeError, FFMpegValueError
+from .info import get_codecs, get_decoders, get_encoders
 from .probe import probe
 from .streams import AudioStream, AVStream, VideoStream
 
@@ -22,4 +23,7 @@ __all__ = [
     "afilter",
     "filter_multi_output",
     "dag",
+    "get_codecs",
+    "get_decoders",
+    "get_encoders",
 ]

{typed_ffmpeg_compatible-2.4.1 → typed_ffmpeg_compatible-2.6.0}/src/typed_ffmpeg/dag/nodes.py

@@ -351,7 +351,8 @@ class InputNode(Node):
             if isinstance(value, bool):
                 if value is True:
                     commands += [f"-{key}"]
-                # NOTE: the -nooption is not supported
+                elif value is False:
+                    commands += [f"-no{key}"]
             else:
                 commands += [f"-{key}", str(value)]
         commands += ["-i", self.filename]
@@ -398,7 +399,8 @@ class OutputNode(Node):
             if isinstance(value, bool):
                 if value is True:
                     commands += [f"-{key}"]
-                # NOTE: the -nooption is not supported
+                elif value is False:
+                    commands += [f"-no{key}"]
             else:
                 commands += [f"-{key}", str(value)]
         commands += [self.filename]
@@ -451,7 +453,8 @@ class GlobalNode(Node):
             if isinstance(value, bool):
                 if value is True:
                     commands += [f"-{key}"]
-                # NOTE: the -no{key} format since not really for global options
+                elif value is False:
+                    commands += [f"-no{key}"]
             else:
                 commands += [f"-{key}", str(value)]
         return commands

typed_ffmpeg_compatible-2.6.0/src/typed_ffmpeg/info.py

@@ -0,0 +1,161 @@
+import logging
+import subprocess
+from dataclasses import dataclass
+from enum import Flag, auto
+
+from .exceptions import FFMpegExecuteError
+from .utils.run import command_line
+
+logger = logging.getLogger(__name__)
+
+
+class CodecFlags(Flag):
+    video = auto()
+    audio = auto()
+    subtitle = auto()
+    frame_level_multithreading = auto()
+    slice_level_multithreading = auto()
+    experimental = auto()
+    draw_horiz_band = auto()
+    direct_rendering_method_1 = auto()
+
+
+@dataclass(frozen=True)
+class Codec:
+    name: str
+    flags: CodecFlags
+    description: str
+
+
+def parse_codec_flags(flags: str) -> CodecFlags:
+    flags_enum = CodecFlags(0)
+    if flags[0] == "V":
+        flags_enum |= CodecFlags.video
+    if flags[0] == "A":
+        flags_enum |= CodecFlags.audio
+    if flags[0] == "S":
+        flags_enum |= CodecFlags.subtitle
+    if flags[1] == "F":
+        flags_enum |= CodecFlags.frame_level_multithreading
+    if flags[2] == "S":
+        flags_enum |= CodecFlags.slice_level_multithreading
+    if flags[3] == "X":
+        flags_enum |= CodecFlags.experimental
+    if flags[4] == "B":
+        flags_enum |= CodecFlags.draw_horiz_band
+    if flags[5] == "D":
+        flags_enum |= CodecFlags.direct_rendering_method_1
+    return flags_enum
+
+
+def get_codecs() -> tuple[Codec, ...]:
+    args = ["ffmpeg", "-hide_banner", "-codecs"]
+    logger.info("Running ffmpeg command: %s", command_line(args))
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = p.communicate()
+
+    retcode = p.poll()
+    if p.returncode != 0:
+        raise FFMpegExecuteError(retcode=retcode, cmd=command_line(args), stdout=out, stderr=err)
+
+    codecs = out.decode("utf-8")
+    codecs_lines = codecs.strip().split("\n")
+    # Skip header lines until we find the separator
+    for i, line in enumerate(codecs_lines):
+        if line.startswith(" ------"):
+            codecs_lines = codecs_lines[i + 1 :]
+            break
+    return tuple(
+        Codec(
+            name=parts[1],
+            flags=parse_codec_flags(parts[0]),
+            description=parts[2],
+        )
+        for line in codecs_lines
+        for parts in [line.split(None, 3)]
+    )
+
+
+class CoderFlags(Flag):
+    video = auto()
+    audio = auto()
+    subtitle = auto()
+    frame_level_multithreading = auto()
+    slice_level_multithreading = auto()
+    experimental = auto()
+    draw_horiz_band = auto()
+    direct_rendering_method_1 = auto()
+
+
+def parse_coder_flags(flags: str) -> CoderFlags:
+    flags_enum = CoderFlags(0)
+    if flags[0] == "V":
+        flags_enum |= CoderFlags.video
+    if flags[0] == "A":
+        flags_enum |= CoderFlags.audio
+    if flags[0] == "S":
+        flags_enum |= CoderFlags.subtitle
+    if flags[1] == "F":
+        flags_enum |= CoderFlags.frame_level_multithreading
+    if flags[2] == "S":
+        flags_enum |= CoderFlags.slice_level_multithreading
+    if flags[3] == "X":
+        flags_enum |= CoderFlags.experimental
+    if flags[4] == "B":
+        flags_enum |= CoderFlags.draw_horiz_band
+    if flags[5] == "D":
+        flags_enum |= CoderFlags.direct_rendering_method_1
+    return flags_enum
+
+
+@dataclass
+class Coder:
+    name: str
+    flags: CoderFlags
+    description: str
+
+
+def get_coders(codes: str) -> tuple[Coder, ...]:
+    codecs_lines = codes.strip().split("\n")
+    # Skip header lines until we find the separator
+    for i, line in enumerate(codecs_lines):
+        if line.startswith(" ------"):
+            codecs_lines = codecs_lines[i + 1 :]
+            break
+    return tuple(
+        Coder(
+            name=parts[1],
+            flags=parse_coder_flags(parts[0]),
+            description=parts[2],
+        )
+        for line in codecs_lines
+        for parts in [line.split(None, 3)]
+    )
+
+
+def get_decoders() -> tuple[Coder, ...]:
+    args = ["ffmpeg", "-hide_banner", "-decoders"]
+    logger.info("Running ffmpeg command: %s", command_line(args))
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = p.communicate()
+
+    retcode = p.poll()
+    if p.returncode != 0:
+        raise FFMpegExecuteError(retcode=retcode, cmd=command_line(args), stdout=out, stderr=err)
+
+    decoders = out.decode("utf-8")
+    return get_coders(decoders)
+
+
+def get_encoders() -> tuple[Coder, ...]:
+    args = ["ffmpeg", "-hide_banner", "-encoders"]
+    logger.info("Running ffmpeg command: %s", command_line(args))
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    out, err = p.communicate()
+
+    retcode = p.poll()
+    if p.returncode != 0:
+        raise FFMpegExecuteError(retcode=retcode, cmd=command_line(args), stdout=out, stderr=err)
+
+    encoders = out.decode("utf-8")
+    return get_coders(encoders)

{typed_ffmpeg_compatible-2.4.1 → typed_ffmpeg_compatible-2.6.0}/src/typed_ffmpeg/utils/snapshot.py

@@ -1,12 +1,13 @@
+from dataclasses import asdict
 from typing import Optional
 
-from syrupy.extensions.image import PNGImageSnapshotExtension
+from syrupy.extensions.json import JSONSnapshotExtension
 from syrupy.types import PropertyFilter, PropertyMatcher, SerializableData, SerializedData
 
 from ..dag.schema import Stream
 
 
-class DAGSnapshotExtenstion(PNGImageSnapshotExtension):
+class DAGSnapshotExtenstion(JSONSnapshotExtension):
     """
     A snapshot extension for the DAG. This extension is used to serialize and match the DAG.
     """
@@ -20,7 +21,5 @@ class DAGSnapshotExtenstion(PNGImageSnapshotExtension):
         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())
+        return super().serialize(asdict(stream))