visqol-python 3.3.3__tar.gz → 3.3.5__tar.gz

{visqol_python-3.3.3/visqol_python.egg-info → visqol_python-3.3.5}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: visqol-python
-Version: 3.3.3
+Version: 3.3.5
 Summary: ViSQOL - Virtual Speech Quality Objective Listener (Pure Python)
-Home-page: https://github.com/talker93/visqol-python
 Author: Shan Jiang
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/talker93/visqol-python
+Project-URL: Changelog, https://github.com/talker93/visqol-python/blob/main/CHANGELOG.md
 Project-URL: Bug Reports, https://github.com/talker93/visqol-python/issues
 Project-URL: Source, https://github.com/talker93/visqol-python
 Project-URL: Original C++, https://github.com/google/visqol
@@ -14,7 +14,6 @@ Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -22,19 +21,24 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=1.20
 Requires-Dist: scipy>=1.7
 Requires-Dist: soundfile>=0.10
 Requires-Dist: libsvm-official>=3.25
-Dynamic: home-page
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
 Dynamic: license-file
-Dynamic: requires-python
 
 # ViSQOL (Python)
 
+[![PyPI version](https://img.shields.io/pypi/v/visqol-python)](https://pypi.org/project/visqol-python/)
+[![CI](https://github.com/talker93/visqol-python/actions/workflows/ci.yml/badge.svg)](https://github.com/talker93/visqol-python/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/pypi/pyversions/visqol-python)](https://pypi.org/project/visqol-python/)
+[![License](https://img.shields.io/github/license/talker93/visqol-python)](LICENSE)
+
 A pure Python implementation of [Google's ViSQOL](https://github.com/google/visqol) (Virtual Speech Quality Objective Listener) v3.3.3 for objective audio/speech quality assessment.
 
 ViSQOL compares a reference audio signal with a degraded version and outputs a **MOS-LQO** (Mean Opinion Score - Listening Quality Objective) score on a scale of **1.0 – 5.0**.
@@ -52,10 +56,10 @@ ViSQOL compares a reference audio signal with a degraded version and outputs a *
 ## Installation
 
 ```bash
-pip install numpy scipy soundfile libsvm-official
+pip install visqol-python
 ```
 
-Or install as a package:
+Or install from source:
 
 ```bash
 git clone https://github.com/talker93/visqol-python.git
@@ -167,8 +171,8 @@ Measured on Apple M-series, Python 3.13:
 ```
 visqol-python/
 ├── visqol/                    # Main package
-│   ├── __init__.py            # Package exports
-│   ├── api.py                 # Public API
+│   ├── __init__.py            # Package exports & version
+│   ├── api.py                 # Public API (VisqolApi)
 │   ├── visqol_manager.py      # Pipeline orchestrator
 │   ├── visqol_core.py         # Core algorithm
 │   ├── audio_utils.py         # Audio I/O & SPL normalization
@@ -180,14 +184,18 @@ visqol-python/
 │   ├── alignment.py           # Global alignment via cross-correlation
 │   ├── nsim.py                # NSIM similarity metric
 │   ├── quality_mapper.py      # SVR & exponential quality mapping
-│   └── __main__.py            # CLI entry point
-├── model/                     # Bundled SVR model
-│   └── libsvm_nu_svr_model.txt
-├── tests/                     # Conformance tests
-│   ├── test_conformance.py
-│   └── test_quick.py
-├── setup.py
-├── requirements.txt
+│   ├── __main__.py            # CLI entry point
+│   └── model/                 # Bundled SVR model
+│       └── libsvm_nu_svr_model.txt
+├── tests/                     # Tests (pytest)
+│   ├── conftest.py            # Shared fixtures & CLI options
+│   ├── test_quick.py          # Smoke tests (no external data needed)
+│   └── test_conformance.py    # Full conformance tests (needs testdata)
+├── .github/workflows/
+│   ├── ci.yml                 # CI: test on Python 3.9–3.13
+│   └── publish.yml            # Auto-publish to PyPI on tag push
+├── pyproject.toml             # Package metadata & build config
+├── CHANGELOG.md
 ├── LICENSE
 └── README.md
 ```

{visqol_python-3.3.3 → visqol_python-3.3.5}/README.md

@@ -1,5 +1,10 @@
 # ViSQOL (Python)
 
+[![PyPI version](https://img.shields.io/pypi/v/visqol-python)](https://pypi.org/project/visqol-python/)
+[![CI](https://github.com/talker93/visqol-python/actions/workflows/ci.yml/badge.svg)](https://github.com/talker93/visqol-python/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/pypi/pyversions/visqol-python)](https://pypi.org/project/visqol-python/)
+[![License](https://img.shields.io/github/license/talker93/visqol-python)](LICENSE)
+
 A pure Python implementation of [Google's ViSQOL](https://github.com/google/visqol) (Virtual Speech Quality Objective Listener) v3.3.3 for objective audio/speech quality assessment.
 
 ViSQOL compares a reference audio signal with a degraded version and outputs a **MOS-LQO** (Mean Opinion Score - Listening Quality Objective) score on a scale of **1.0 – 5.0**.
@@ -17,10 +22,10 @@ ViSQOL compares a reference audio signal with a degraded version and outputs a *
 ## Installation
 
 ```bash
-pip install numpy scipy soundfile libsvm-official
+pip install visqol-python
 ```
 
-Or install as a package:
+Or install from source:
 
 ```bash
 git clone https://github.com/talker93/visqol-python.git
@@ -132,8 +137,8 @@ Measured on Apple M-series, Python 3.13:
 ```
 visqol-python/
 ├── visqol/                    # Main package
-│   ├── __init__.py            # Package exports
-│   ├── api.py                 # Public API
+│   ├── __init__.py            # Package exports & version
+│   ├── api.py                 # Public API (VisqolApi)
 │   ├── visqol_manager.py      # Pipeline orchestrator
 │   ├── visqol_core.py         # Core algorithm
 │   ├── audio_utils.py         # Audio I/O & SPL normalization
@@ -145,14 +150,18 @@ visqol-python/
 │   ├── alignment.py           # Global alignment via cross-correlation
 │   ├── nsim.py                # NSIM similarity metric
 │   ├── quality_mapper.py      # SVR & exponential quality mapping
-│   └── __main__.py            # CLI entry point
-├── model/                     # Bundled SVR model
-│   └── libsvm_nu_svr_model.txt
-├── tests/                     # Conformance tests
-│   ├── test_conformance.py
-│   └── test_quick.py
-├── setup.py
-├── requirements.txt
+│   ├── __main__.py            # CLI entry point
+│   └── model/                 # Bundled SVR model
+│       └── libsvm_nu_svr_model.txt
+├── tests/                     # Tests (pytest)
+│   ├── conftest.py            # Shared fixtures & CLI options
+│   ├── test_quick.py          # Smoke tests (no external data needed)
+│   └── test_conformance.py    # Full conformance tests (needs testdata)
+├── .github/workflows/
+│   ├── ci.yml                 # CI: test on Python 3.9–3.13
+│   └── publish.yml            # Auto-publish to PyPI on tag push
+├── pyproject.toml             # Package metadata & build config
+├── CHANGELOG.md
 ├── LICENSE
 └── README.md
 ```

{visqol_python-3.3.3 → visqol_python-3.3.5}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "visqol-python"
-version = "3.3.3"
+dynamic = ["version"]
 description = "ViSQOL - Virtual Speech Quality Objective Listener (Pure Python)"
 readme = "README.md"
 license = "Apache-2.0"
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 authors = [
     {name = "Shan Jiang"},
 ]
@@ -21,7 +21,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -37,8 +36,12 @@ dependencies = [
     "libsvm-official>=3.25",
 ]
 
+[project.optional-dependencies]
+test = ["pytest>=7.0"]
+
 [project.urls]
 Homepage = "https://github.com/talker93/visqol-python"
+Changelog = "https://github.com/talker93/visqol-python/blob/main/CHANGELOG.md"
 "Bug Reports" = "https://github.com/talker93/visqol-python/issues"
 Source = "https://github.com/talker93/visqol-python"
 "Original C++" = "https://github.com/google/visqol"
@@ -46,8 +49,19 @@ Source = "https://github.com/talker93/visqol-python"
 [project.scripts]
 visqol = "visqol.__main__:main"
 
+[tool.setuptools.dynamic]
+version = {attr = "visqol.__version__"}
+
 [tool.setuptools.packages.find]
 exclude = ["tests*"]
 
 [tool.setuptools.package-data]
-visqol = ["model/*.txt"]
+visqol = ["model/*.txt", "py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+strict = true
+warn_return_any = true
+warn_unused_configs = true

visqol_python-3.3.5/tests/test_conformance.py

@@ -0,0 +1,125 @@
+"""
+ViSQOL Python conformance tests.
+
+Requires the official ViSQOL testdata directory. Provide it via:
+    pytest tests/test_conformance.py --testdata /path/to/visqol/testdata
+
+The testdata directory should contain:
+    conformance_testdata_subset/  (audio test WAV files)
+    clean_speech/                 (speech test WAV files)
+
+You can obtain these from the official ViSQOL repository:
+    https://github.com/google/visqol
+"""
+
+import os
+
+import pytest
+
+from visqol import VisqolApi
+
+
+# ── Fixtures ──
+
+@pytest.fixture(scope="session")
+def testdata_dir(request):
+    """Resolve testdata directory from --testdata or auto-detect."""
+    td = request.config.getoption("--testdata")
+    if td and os.path.isdir(td):
+        return td
+    # Fallback: look relative to this file (when inside the original visqol repo)
+    candidate = os.path.join(os.path.dirname(__file__), "..", "..", "testdata")
+    if os.path.isdir(candidate):
+        return candidate
+    pytest.skip("testdata directory not found — use --testdata /path/to/visqol/testdata")
+
+
+@pytest.fixture(scope="session")
+def conf_dir(testdata_dir):
+    return os.path.join(testdata_dir, "conformance_testdata_subset")
+
+
+@pytest.fixture(scope="session")
+def speech_dir(testdata_dir):
+    return os.path.join(testdata_dir, "clean_speech")
+
+
+@pytest.fixture(scope="session")
+def audio_api():
+    api = VisqolApi()
+    api.create(mode="audio")
+    return api
+
+
+@pytest.fixture(scope="session")
+def speech_api():
+    api = VisqolApi()
+    api.create(mode="speech")
+    return api
+
+
+# ── Test data ──
+
+TOLERANCE = 0.05
+
+AUDIO_CASES = [
+    ("strauss48_stereo.wav", "strauss48_stereo_lp35.wav",
+     1.3888791489130758, "strauss_lp35"),
+    ("steely48_stereo.wav", "steely48_stereo_lp7.wav",
+     2.2501683734385183, "steely_lp7"),
+    ("sopr48_stereo.wav", "sopr48_stereo_256kbps_aac.wav",
+     4.68228969737946, "sopr_256aac"),
+    ("ravel48_stereo.wav", "ravel48_stereo_128kbps_opus.wav",
+     4.465141897255348, "ravel_128opus"),
+    ("moonlight48_stereo.wav", "moonlight48_stereo_128kbps_aac.wav",
+     4.684292801646114, "moonlight_128aac"),
+    ("harpsichord48_stereo.wav", "harpsichord48_stereo_96kbps_mp3.wav",
+     4.22374532766003, "harpsichord_96mp3"),
+    ("guitar48_stereo.wav", "guitar48_stereo_64kbps_aac.wav",
+     4.349722308064298, "guitar_64aac"),
+    ("glock48_stereo.wav", "glock48_stereo_48kbps_aac.wav",
+     4.332452943882108, "glock_48aac"),
+    ("contrabassoon48_stereo.wav", "contrabassoon48_stereo_24kbps_aac.wav",
+     2.346868205375293, "contrabassoon_24aac"),
+    ("castanets48_stereo.wav", "castanets48_stereo.wav",
+     4.732101253042348, "castanets_identity"),
+]
+
+SPEECH_CASES = [
+    ("CA01_01.wav", "transcoded_CA01_01.wav",
+     3.374505555111911, "CA01_transcoded"),
+]
+
+
+# ── Audio mode tests ──
+
+@pytest.mark.parametrize(
+    "ref_name, deg_name, expected_mos, test_id",
+    AUDIO_CASES,
+    ids=[c[3] for c in AUDIO_CASES],
+)
+def test_audio_conformance(audio_api, conf_dir, ref_name, deg_name, expected_mos, test_id):
+    ref_path = os.path.join(conf_dir, ref_name)
+    deg_path = os.path.join(conf_dir, deg_name)
+    result = audio_api.measure(ref_path, deg_path)
+    diff = abs(result.moslqo - expected_mos)
+    assert diff < TOLERANCE, (
+        f"[{test_id}] MOS={result.moslqo:.6f}, expected={expected_mos:.6f}, diff={diff:.6f}"
+    )
+
+
+# ── Speech mode tests ──
+
+@pytest.mark.parametrize(
+    "ref_name, deg_name, expected_mos, test_id",
+    SPEECH_CASES,
+    ids=[c[3] for c in SPEECH_CASES],
+)
+def test_speech_conformance(speech_api, speech_dir, ref_name, deg_name, expected_mos, test_id):
+    ref_path = os.path.join(speech_dir, ref_name)
+    deg_path = os.path.join(speech_dir, deg_name)
+    result = speech_api.measure(ref_path, deg_path)
+    diff = abs(result.moslqo - expected_mos)
+    assert diff < TOLERANCE, (
+        f"[{test_id}] MOS={result.moslqo:.6f}, expected={expected_mos:.6f}, diff={diff:.6f}"
+    )

visqol_python-3.3.5/tests/test_quick.py

@@ -0,0 +1,168 @@
+"""
+Quick smoke tests for ViSQOL Python.
+
+These tests verify basic API functionality without requiring external testdata.
+"""
+
+import numpy as np
+import pytest
+
+from visqol import VisqolApi, SimilarityResult, AudioSignal
+
+
+# ── API creation ──
+
+
+class TestApiCreation:
+    """Test that VisqolApi can be created in different modes."""
+
+    def test_create_audio_mode(self):
+        api = VisqolApi()
+        api.create(mode="audio")
+
+    def test_create_speech_mode(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+
+    def test_create_default_mode(self):
+        """Default mode (no argument) should work as audio mode."""
+        api = VisqolApi()
+        api.create()
+
+    def test_create_case_insensitive(self):
+        api = VisqolApi()
+        api.create(mode="SPEECH")
+
+    def test_create_invalid_mode_raises(self):
+        api = VisqolApi()
+        with pytest.raises(ValueError, match="Invalid mode"):
+            api.create(mode="invalid")
+
+    def test_create_negative_search_window_raises(self):
+        api = VisqolApi()
+        with pytest.raises(ValueError, match="search_window"):
+            api.create(search_window=-1)
+
+    def test_create_missing_model_raises(self):
+        api = VisqolApi()
+        with pytest.raises(FileNotFoundError):
+            api.create(mode="audio", model_path="/nonexistent/model.txt")
+
+
+# ── Measure guards ──
+
+
+class TestMeasureGuards:
+    """Test that measure() raises helpful errors for bad inputs."""
+
+    def test_measure_before_create_raises(self):
+        api = VisqolApi()
+        with pytest.raises(RuntimeError, match="create"):
+            api.measure("a.wav", "b.wav")
+
+    def test_measure_nonexistent_ref_raises(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+        with pytest.raises(FileNotFoundError, match="Reference"):
+            api.measure("/nonexistent/ref.wav", "/nonexistent/deg.wav")
+
+    def test_measure_from_arrays_before_create_raises(self):
+        api = VisqolApi()
+        with pytest.raises(RuntimeError, match="create"):
+            api.measure_from_arrays(np.zeros(100), np.zeros(100), 16000)
+
+    def test_measure_from_arrays_bad_type_raises(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+        with pytest.raises(TypeError, match="numpy array"):
+            api.measure_from_arrays([1, 2, 3], np.zeros(100), 16000)  # type: ignore[arg-type]
+
+    def test_measure_from_arrays_empty_raises(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+        with pytest.raises(ValueError, match="empty"):
+            api.measure_from_arrays(np.array([]), np.zeros(100), 16000)
+
+    def test_measure_from_arrays_bad_sr_raises(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+        with pytest.raises(ValueError, match="sample_rate"):
+            api.measure_from_arrays(np.zeros(100), np.zeros(100), 0)
+
+
+# ── measure_from_arrays ──
+
+
+class TestMeasureFromArrays:
+    """Test measure_from_arrays with synthetic signals."""
+
+    def test_identical_signal_high_score(self):
+        """Identical signals should produce a high MOS score."""
+        api = VisqolApi()
+        api.create(mode="speech")
+        sr = 16000
+        duration = 3.0
+        t = np.linspace(0, duration, int(sr * duration), endpoint=False)
+        signal = 0.5 * np.sin(2 * np.pi * 440 * t)
+        result = api.measure_from_arrays(signal, signal, sample_rate=sr)
+        assert result.moslqo >= 4.0, (
+            f"Identical signal should give MOS >= 4.0, got {result.moslqo:.4f}"
+        )
+
+    def test_degraded_signal_lower_score(self):
+        """Adding noise to a signal should produce a lower MOS score."""
+        api = VisqolApi()
+        api.create(mode="speech")
+        sr = 16000
+        duration = 3.0
+        t = np.linspace(0, duration, int(sr * duration), endpoint=False)
+        ref = 0.5 * np.sin(2 * np.pi * 440 * t)
+        rng = np.random.default_rng(42)
+        deg = ref + 0.3 * rng.standard_normal(len(ref))
+        result = api.measure_from_arrays(ref, deg, sample_rate=sr)
+        assert 1.0 <= result.moslqo <= 5.0, (
+            f"MOS should be in [1, 5], got {result.moslqo:.4f}"
+        )
+
+
+# ── Result fields ──
+
+
+class TestResultFields:
+    """Test that SimilarityResult has all expected fields."""
+
+    def test_result_has_expected_fields(self):
+        api = VisqolApi()
+        api.create(mode="speech")
+        sr = 16000
+        duration = 3.0
+        t = np.linspace(0, duration, int(sr * duration), endpoint=False)
+        signal = 0.5 * np.sin(2 * np.pi * 440 * t)
+        result = api.measure_from_arrays(signal, signal, sample_rate=sr)
+        assert hasattr(result, "moslqo")
+        assert hasattr(result, "vnsim")
+        assert hasattr(result, "fvnsim")
+        assert hasattr(result, "fstdnsim")
+        assert hasattr(result, "fvdegenergy")
+        assert hasattr(result, "patch_sims")
+
+
+# ── Package metadata ──
+
+
+class TestVersion:
+    """Test package version is accessible."""
+
+    def test_version_string(self):
+        import visqol
+        assert hasattr(visqol, "__version__")
+        assert isinstance(visqol.__version__, str)
+        parts = visqol.__version__.split(".")
+        assert len(parts) >= 2, "Version should have at least major.minor"
+
+    def test_public_exports(self):
+        """Package should export key classes."""
+        import visqol
+        assert hasattr(visqol, "VisqolApi")
+        assert hasattr(visqol, "SimilarityResult")
+        assert hasattr(visqol, "AudioSignal")

{visqol_python-3.3.3 → visqol_python-3.3.5}/visqol/__init__.py

@@ -13,8 +13,10 @@ Usage:
     print(f"MOS-LQO: {result.moslqo}")
 """
 
-__version__ = "3.3.3"
+__version__: str = "3.3.5"
 
 from visqol.api import VisqolApi
+from visqol.visqol_core import SimilarityResult
+from visqol.audio_utils import AudioSignal
 
-__all__ = ["VisqolApi"]
+__all__: list[str] = ["VisqolApi", "SimilarityResult", "AudioSignal"]

{visqol_python-3.3.3 → visqol_python-3.3.5}/visqol/__main__.py

@@ -1,10 +1,13 @@
 """
 ViSQOL command-line interface.
 
-Usage:
+Usage::
+
     python -m visqol --reference ref.wav --degraded deg.wav [--speech_mode]
 """
 
+from __future__ import annotations
+
 import argparse
 import sys
 import logging
@@ -12,45 +15,46 @@ import logging
 from visqol.api import VisqolApi
 
 
-def main():
+def main() -> None:
+    """Entry point for the ``visqol`` CLI."""
     parser = argparse.ArgumentParser(
-        description="ViSQOL - Virtual Speech Quality Objective Listener (Python)"
+        description="ViSQOL - Virtual Speech Quality Objective Listener (Python)",
     )
     parser.add_argument(
         "--reference", "-r", required=True,
-        help="Path to reference audio file (WAV)"
+        help="Path to reference audio file (WAV)",
     )
     parser.add_argument(
         "--degraded", "-d", required=True,
-        help="Path to degraded audio file (WAV)"
+        help="Path to degraded audio file (WAV)",
     )
     parser.add_argument(
         "--speech_mode", action="store_true",
-        help="Use speech mode (16kHz, exponential mapping)"
+        help="Use speech mode (16 kHz, exponential mapping)",
     )
     parser.add_argument(
         "--model", default=None,
-        help="Path to SVR model file (Audio mode only)"
+        help="Path to SVR model file (Audio mode only)",
     )
     parser.add_argument(
         "--search_window", type=int, default=60,
-        help="Search window radius (default: 60)"
+        help="Search window radius (default: 60)",
     )
     parser.add_argument(
         "--unscaled_speech", action="store_true",
-        help="Don't scale speech MOS to max 5.0"
+        help="Don't scale speech MOS to max 5.0",
     )
     parser.add_argument(
         "--no_alignment", action="store_true",
-        help="Disable global alignment"
+        help="Disable global alignment",
     )
     parser.add_argument(
         "--no_realignment", action="store_true",
-        help="Disable fine realignment"
+        help="Disable fine realignment",
     )
     parser.add_argument(
         "--verbose", "-v", action="store_true",
-        help="Enable verbose output"
+        help="Enable verbose output",
     )
 
     args = parser.parse_args()
@@ -60,18 +64,30 @@ def main():
     logging.basicConfig(level=level, format="%(levelname)s: %(message)s")
 
     # Run ViSQOL
-    mode = "speech" if args.speech_mode else "audio"
-    api = VisqolApi()
-    api.create(
-        mode=mode,
-        model_path=args.model,
-        search_window=args.search_window,
-        use_unscaled_speech=args.unscaled_speech,
-        disable_global_alignment=args.no_alignment,
-        disable_realignment=args.no_realignment,
-    )
+    mode: str = "speech" if args.speech_mode else "audio"
+
+    try:
+        api = VisqolApi()
+        api.create(
+            mode=mode,
+            model_path=args.model,
+            search_window=args.search_window,
+            use_unscaled_speech=args.unscaled_speech,
+            disable_global_alignment=args.no_alignment,
+            disable_realignment=args.no_realignment,
+        )
+
+        result = api.measure(args.reference, args.degraded)
 
-    result = api.measure(args.reference, args.degraded)
+    except FileNotFoundError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except ValueError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+    except RuntimeError as exc:
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
 
     # Output results
     print(f"MOS-LQO:      {result.moslqo:.6f}")
@@ -83,9 +99,11 @@ def main():
         print(f"FVDEGENERGY:  {result.fvdegenergy}")
         print(f"Patches:      {len(result.patch_sims)}")
         for i, p in enumerate(result.patch_sims):
-            print(f"  Patch {i}: sim={p.similarity:.4f} "
-                  f"ref=[{p.ref_patch_start_time:.3f}-{p.ref_patch_end_time:.3f}] "
-                  f"deg=[{p.deg_patch_start_time:.3f}-{p.deg_patch_end_time:.3f}]")
+            print(
+                f"  Patch {i}: sim={p.similarity:.4f} "
+                f"ref=[{p.ref_patch_start_time:.3f}-{p.ref_patch_end_time:.3f}] "
+                f"deg=[{p.deg_patch_start_time:.3f}-{p.deg_patch_end_time:.3f}]"
+            )
 
 
 if __name__ == "__main__":