mprobe 0.0.1__tar.gz

mprobe-0.0.1/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: mprobe
+Version: 0.0.1
+Summary: Read video and audio metadata using ffprobe or avprobe
+Author-email: pi11 <webii@pm.me>
+Project-URL: Homepage, https://github.com/pi11/mprobe
+Project-URL: Issues, https://github.com/pi11/mprobe/issues
+Keywords: video,audio,metadata,ffprobe,avprobe
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: THIRD_PARTY_NOTICES
+Dynamic: license-file
+
+mprobe
+======
+
+Read video and audio metadata with Python 3.10+ and ffprobe (or avprobe).
+Install `FFmpeg <https://ffmpeg.org/download.html>`_ separately and ensure
+``ffprobe`` is on your PATH; pip does not install it.
+
+Install and use
+---------------
+
+.. code-block:: console
+
+   python -m pip install mprobe
+
+.. code-block:: python
+
+   from mprobe import mediainfo
+
+   info = mediainfo("video.mp4", timeout=30)
+   print(info.get("duration"))   # seconds, as a string
+   print(info.get("format_name"))
+
+Accepts strings and pathlib paths. Values are strings; ``TAG`` and
+``DISPOSITION`` contain dictionaries. Repeated fields use the last stream's
+value, then the container's value. Fields vary by file and may be absent.
+Missing probes raise ``FileNotFoundError``; invalid or missing media raise
+``subprocess.CalledProcessError`` (details in ``stderr``). A timeout raises
+``subprocess.TimeoutExpired``.
+
+Inspired by `pydub <https://github.com/jiaaro/pydub>`_.

mprobe-0.0.1/README.rst

@@ -0,0 +1,30 @@
+mprobe
+======
+
+Read video and audio metadata with Python 3.10+ and ffprobe (or avprobe).
+Install `FFmpeg <https://ffmpeg.org/download.html>`_ separately and ensure
+``ffprobe`` is on your PATH; pip does not install it.
+
+Install and use
+---------------
+
+.. code-block:: console
+
+   python -m pip install mprobe
+
+.. code-block:: python
+
+   from mprobe import mediainfo
+
+   info = mediainfo("video.mp4", timeout=30)
+   print(info.get("duration"))   # seconds, as a string
+   print(info.get("format_name"))
+
+Accepts strings and pathlib paths. Values are strings; ``TAG`` and
+``DISPOSITION`` contain dictionaries. Repeated fields use the last stream's
+value, then the container's value. Fields vary by file and may be absent.
+Missing probes raise ``FileNotFoundError``; invalid or missing media raise
+``subprocess.CalledProcessError`` (details in ``stderr``). A timeout raises
+``subprocess.TimeoutExpired``.
+
+Inspired by `pydub <https://github.com/jiaaro/pydub>`_.

mprobe-0.0.1/THIRD_PARTY_NOTICES

@@ -0,0 +1,23 @@
+The metadata parsing API was inspired by pydub:
+https://github.com/jiaaro/pydub
+
+pydub is distributed under the MIT license:
+
+Copyright (c) 2011 James Robert, http://jiaaro.com
+
+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.

mprobe-0.0.1/mprobe.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: mprobe
+Version: 0.0.1
+Summary: Read video and audio metadata using ffprobe or avprobe
+Author-email: pi11 <webii@pm.me>
+Project-URL: Homepage, https://github.com/pi11/mprobe
+Project-URL: Issues, https://github.com/pi11/mprobe/issues
+Keywords: video,audio,metadata,ffprobe,avprobe
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: THIRD_PARTY_NOTICES
+Dynamic: license-file
+
+mprobe
+======
+
+Read video and audio metadata with Python 3.10+ and ffprobe (or avprobe).
+Install `FFmpeg <https://ffmpeg.org/download.html>`_ separately and ensure
+``ffprobe`` is on your PATH; pip does not install it.
+
+Install and use
+---------------
+
+.. code-block:: console
+
+   python -m pip install mprobe
+
+.. code-block:: python
+
+   from mprobe import mediainfo
+
+   info = mediainfo("video.mp4", timeout=30)
+   print(info.get("duration"))   # seconds, as a string
+   print(info.get("format_name"))
+
+Accepts strings and pathlib paths. Values are strings; ``TAG`` and
+``DISPOSITION`` contain dictionaries. Repeated fields use the last stream's
+value, then the container's value. Fields vary by file and may be absent.
+Missing probes raise ``FileNotFoundError``; invalid or missing media raise
+``subprocess.CalledProcessError`` (details in ``stderr``). A timeout raises
+``subprocess.TimeoutExpired``.
+
+Inspired by `pydub <https://github.com/jiaaro/pydub>`_.

mprobe-0.0.1/mprobe.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.rst
+THIRD_PARTY_NOTICES
+mprobe.py
+pyproject.toml
+setup.py
+mprobe.egg-info/PKG-INFO
+mprobe.egg-info/SOURCES.txt
+mprobe.egg-info/dependency_links.txt
+mprobe.egg-info/top_level.txt
+tests/test_mprobe.py

mprobe-0.0.1/mprobe.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mprobe-0.0.1/mprobe.egg-info/top_level.txt

@@ -0,0 +1 @@
+mprobe

mprobe-0.0.1/mprobe.py

@@ -0,0 +1,59 @@
+"""Read video/audio metadata using ffprobe or avprobe, inspired by pydub."""
+
+import os
+import shutil
+import subprocess
+
+
+def which(program):
+    """Return the executable's path, or None when it is not on PATH."""
+    return shutil.which(program)
+
+
+def get_prober_name():
+    """Return an available probe executable, preferring ffprobe."""
+    for program in ("ffprobe", "avprobe"):
+        executable = which(program)
+        if executable:
+            return executable
+    raise FileNotFoundError("Install FFmpeg (ffprobe) or Libav (avprobe) and add it to PATH")
+
+
+def mediainfo(filepath, *, timeout=None):
+    """Return a dictionary of media metadata with string values.
+
+    TAG and DISPOSITION fields are nested dictionaries. Repeated fields are
+    overwritten by later streams and then container metadata, as in the
+    original API. filepath may be a string or a path-like object.
+
+    Raise FileNotFoundError when no prober is installed, CalledProcessError
+    when probing fails (with diagnostics in stderr), or TimeoutExpired when
+    the optional timeout in seconds is exceeded.
+    """
+    prober = get_prober_name()
+    args = ["-v", "error", "-show_format", "-show_streams", "-i", os.fsdecode(filepath)]
+    options = dict(stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                   encoding="utf-8", errors="replace", timeout=timeout)
+
+    if os.path.basename(prober).lower() in ("avprobe", "avprobe.exe"):
+        # Older Libav versions require the legacy key=value writer.
+        result = subprocess.run([prober, "-of", "old"] + args, **options)
+        if result.returncode:
+            result = subprocess.run([prober] + args, check=True, **options)
+    else:
+        result = subprocess.run([prober] + args, check=True, **options)
+
+    info = {}
+    for line in result.stdout.splitlines():
+        key, separator, value = line.partition("=")
+        if not separator:
+            continue
+        namespace, separator, nested_key = key.partition(":")
+        if separator:
+            nested = info.get(namespace)
+            if not isinstance(nested, dict):
+                nested = info[namespace] = {}
+            nested[nested_key] = value
+        else:
+            info[key] = value
+    return info

mprobe-0.0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mprobe"
+version = "0.0.1"
+description = "Read video and audio metadata using ffprobe or avprobe"
+readme = "README.rst"
+license-files = ["THIRD_PARTY_NOTICES"]
+requires-python = ">=3.10"
+authors = [{name = "pi11", email = "webii@pm.me"}]
+keywords = ["video", "audio", "metadata", "ffprobe", "avprobe"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Operating System :: OS Independent",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Multimedia :: Video",
+]
+
+[project.urls]
+Homepage = "https://github.com/pi11/mprobe"
+Issues = "https://github.com/pi11/mprobe/issues"
+
+[tool.setuptools]
+py-modules = ["mprobe"]

mprobe-0.0.1/setup.cfg

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

mprobe-0.0.1/setup.py

@@ -0,0 +1,4 @@
+"""Compatibility entry point; package metadata lives in pyproject.toml."""
+from setuptools import setup
+
+setup()

mprobe-0.0.1/tests/test_mprobe.py

@@ -0,0 +1,103 @@
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import unittest
+from unittest.mock import patch
+import wave
+
+import mprobe
+
+
+class ProbeTests(unittest.TestCase):
+    def test_missing_path_does_not_raise_key_error(self):
+        with patch.dict(os.environ, {}, clear=True):
+            self.assertIsNone(mprobe.which("mprobe-nonexistent-probe"))
+
+    def test_prefers_ffprobe(self):
+        with patch("mprobe.which", return_value="/usr/bin/ffprobe") as which:
+            self.assertEqual(mprobe.get_prober_name(), "/usr/bin/ffprobe")
+            which.assert_called_once_with("ffprobe")
+
+    def test_avprobe_fallback(self):
+        with patch("mprobe.which", side_effect=[None, "/usr/bin/avprobe"]):
+            self.assertEqual(mprobe.get_prober_name(), "/usr/bin/avprobe")
+
+    def test_missing_probe_is_actionable(self):
+        with patch("mprobe.which", return_value=None):
+            with self.assertRaisesRegex(FileNotFoundError, "Install FFmpeg"):
+                mprobe.mediainfo("video.mp4")
+
+    @patch("mprobe.get_prober_name", return_value="/usr/bin/ffprobe")
+    @patch("mprobe.subprocess.run")
+    def test_parses_metadata_and_passes_path_safely(self, run, prober):
+        run.return_value = subprocess.CompletedProcess([], 0,
+            "[STREAM]\r\ncodec_name=h264\r\nTAG:title=a=b:c\r\n"
+            "TAG:custom:key=value\r\nDISPOSITION:default=1\r\n"
+            "duration=1\r\n[/STREAM]\r\n[FORMAT]\r\nduration=2\r\n", "")
+        info = mprobe.mediainfo(Path("-video with spaces.mp4"), timeout=10)
+        self.assertEqual(info, {"codec_name": "h264", "TAG": {
+            "title": "a=b:c", "custom:key": "value"},
+            "DISPOSITION": {"default": "1"}, "duration": "2"})
+        self.assertEqual(run.call_args.args[0][-2:], ["-i", "-video with spaces.mp4"])
+        self.assertTrue(run.call_args.kwargs["check"])
+        self.assertEqual(run.call_args.kwargs["timeout"], 10)
+
+    @patch("mprobe.get_prober_name", return_value="avprobe")
+    @patch("mprobe.subprocess.run")
+    def test_legacy_writer_falls_back(self, run, prober):
+        run.side_effect = [subprocess.CompletedProcess([], 1, "", "Unknown writer"),
+                           subprocess.CompletedProcess([], 0, "duration=2\n", "")]
+        self.assertEqual(mprobe.mediainfo("audio.wav"), {"duration": "2"})
+        self.assertEqual(run.call_args_list[0].args[0][1:3], ["-of", "old"])
+        self.assertNotIn("-of", run.call_args.args[0])
+        self.assertTrue(run.call_args.kwargs["check"])
+
+    @patch("mprobe.get_prober_name", return_value="avprobe.exe")
+    @patch("mprobe.subprocess.run")
+    def test_legacy_writer_success(self, run, prober):
+        run.return_value = subprocess.CompletedProcess([], 0, "duration=3\n", "")
+        self.assertEqual(mprobe.mediainfo("audio.wav"), {"duration": "3"})
+        run.assert_called_once()
+
+    @patch("mprobe.get_prober_name", return_value="avprobe")
+    @patch("mprobe.subprocess.run")
+    def test_failed_fallback_raises(self, run, prober):
+        error = subprocess.CalledProcessError(1, ["avprobe"], stderr="bad media")
+        run.side_effect = [subprocess.CompletedProcess([], 1, "", "bad media"), error]
+        with self.assertRaises(subprocess.CalledProcessError) as raised:
+            mprobe.mediainfo("broken.mp4")
+        self.assertEqual(raised.exception.stderr, "bad media")
+
+    @patch("mprobe.get_prober_name", return_value="ffprobe")
+    @patch("mprobe.subprocess.run", side_effect=subprocess.TimeoutExpired("ffprobe", 1))
+    def test_timeout_propagates(self, run, prober):
+        with self.assertRaises(subprocess.TimeoutExpired):
+            mprobe.mediainfo("video.mp4", timeout=1)
+
+
+@unittest.skipUnless(shutil.which("ffprobe"), "ffprobe is not installed")
+class IntegrationTests(unittest.TestCase):
+    def test_real_audio_and_invalid_inputs(self):
+        with tempfile.TemporaryDirectory() as directory:
+            audio = Path(directory) / "тест audio.wav"
+            with wave.open(str(audio), "wb") as output:
+                output.setnchannels(1)
+                output.setsampwidth(2)
+                output.setframerate(8000)
+                output.writeframes(b"\0\0" * 8000)
+            info = mprobe.mediainfo(audio, timeout=10)
+            self.assertEqual(info["codec_name"], "pcm_s16le")
+            self.assertEqual(info["sample_rate"], "8000")
+            self.assertEqual(float(info["duration"]), 1.0)
+            for path in (Path(directory) / "missing.wav", Path(directory) / "invalid.wav"):
+                if path.name == "invalid.wav":
+                    path.write_text("not media")
+                with self.assertRaises(subprocess.CalledProcessError) as raised:
+                    mprobe.mediainfo(path, timeout=10)
+                self.assertTrue(raised.exception.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()