Replace imghdr

docs/documentation/hacking.rst

@@ -145,9 +145,7 @@ raw images using ``dcraw``.
 
 To make this work, you need to implement two functions:
 
-#. A function which checks if a path is of your filetype. The function must be of the
-   same form as used by the standard library module
-   `imghdr <https://docs.python.org/3/library/imghdr.html>`_.
+#. A function which checks if a path is of your filetype.
 #. The actual loading function which creates a ``QPixmap`` from the path.
 
 Finally, you tell vimiv about the newly supported filetype::

tests/end2end/features/image/test_imageopen_bdd.py

@@ -4,22 +4,21 @@
 # Copyright 2017-2023 Christian Karl (karlch) <karlch at protonmail dot com>
 # License: GNU GPL v3, see the "LICENSE" and "AUTHORS" files for details.
 
-import imghdr  # pylint: disable=deprecated-module
-
 import pytest_bdd as bdd
 
 from vimiv import api
+from vimiv.utils import imageheader
 
 
 bdd.scenarios("imageopen.feature")
 
 
 @bdd.when("I open broken images")
 def open_broken_images(tmp_path):
-    _open_file(tmp_path, b"\211PNG\r\n\032\n")  # PNG
-    _open_file(tmp_path, b"000000JFIF")  # JPG
+    _open_file(tmp_path, b"\x89PNG\x0D\x0A\x1A\x0A")  # PNG
+    _open_file(tmp_path, b"\xFF\xD8\xFF\xDB")  # JPG
     _open_file(tmp_path, b"GIF89a")  # GIF
-    _open_file(tmp_path, b"II")  # TIFF
+    _open_file(tmp_path, b"II\x2A\x00")  # TIFF
     _open_file(tmp_path, b"BM")  # BMP
 
 
@@ -28,5 +27,5 @@ def _open_file(directory, data):
     path = directory / "broken"
     path.write_bytes(data)
     filename = str(path)
-    assert imghdr.what(filename) is not None, "Invalid magic bytes in test setup"
+    assert imageheader.detect(filename) is not None, "Invalid magic bytes in test setup"
     api.open_paths([filename])

tests/end2end/features/plugins/test_plugins_bdd.py

@@ -4,12 +4,10 @@
 # Copyright 2017-2023 Christian Karl (karlch) <karlch at protonmail dot com>
 # License: GNU GPL v3, see the "LICENSE" and "AUTHORS" files for details.
 
-import contextlib
-import imghdr  # pylint: disable=deprecated-module
-
 import pytest_bdd as bdd
 
 from vimiv import plugins
+from vimiv.utils import imageheader
 
 
 bdd.scenarios("plugins.feature")
@@ -22,9 +20,6 @@ def load_plugin(name, info):
 
 @bdd.then(bdd.parsers.parse("The {name} format should be supported"))
 def check_format_supported(name):
-    for func in imghdr.tests:
-        with contextlib.suppress(IndexError):
-            format_name = func.__name__.split("_")[-1]
-            if format_name == name:
-                return
-    assert False, f"Image format {name} is not supported"
+    assert name in [
+        filetype for filetype, _ in imageheader._registry
+    ], f"Image format {name} is not supported"

tests/unit/conftest.py

@@ -0,0 +1,16 @@
+# vim: ft=python fileencoding=utf-8 sw=4 et sts=4
+
+# This file is part of vimiv.
+# Copyright 2017-2023 Christian Karl (karlch) <karlch at protonmail dot com>
+# License: GNU GPL v3, see the "LICENSE" and "AUTHORS" files for details.
+
+"""Fixtures for pytest unit tests."""
+
+import pytest
+
+
+@pytest.fixture()
+def tmpfile(tmp_path):
+    path = tmp_path / "anything"
+    path.touch()
+    yield str(path)

tests/unit/utils/test_files.py

@@ -7,36 +7,14 @@
 """Tests for vimiv.utils.files."""
 
 import collections
-import imghdr  # pylint: disable=deprecated-module
 import os
 import tarfile
 
-from PyQt5.QtGui import QImageReader
-
 import pytest
 
 from vimiv.utils import files
 
 
-SUPPORTED_IMAGE_FORMATS = ["jpg", "png", "gif", "svg", "cr2"]
-
-
-@pytest.fixture()
-def mockimghdr(mocker):
-    """Fixture to mock imghdr.tests and QImageReader supportedImageFormats."""
-    mocker.patch.object(
-        QImageReader, "supportedImageFormats", return_value=SUPPORTED_IMAGE_FORMATS
-    )
-    yield mocker.patch("imghdr.tests", [])
-
-
-@pytest.fixture()
-def tmpfile(tmp_path):
-    path = tmp_path / "anything"
-    path.touch()
-    yield str(path)
-
-
 @pytest.fixture()
 def directory_tree(tmp_path):
     """Fixture to create a directory tree.
@@ -110,7 +88,7 @@ def test_directories_supported(mocker):
 def test_images_supported(mocker):
     mocker.patch("os.path.isdir", return_value=False)
     mocker.patch("os.path.isfile", return_value=True)
-    mocker.patch("imghdr.what", return_value=True)
+    mocker.patch("vimiv.utils.imageheader.detect", return_value=True)
     images, directories = files.supported(["a", "b"])
     assert images == ["a", "b"]
     assert not directories
@@ -173,21 +151,3 @@ def test_get_size_with_permission_error(mocker):
 def test_listfiles(directory_tree):
     expected = sorted(directory_tree.files)
     assert expected == sorted(files.listfiles(str(directory_tree.root)))
-
-
-@pytest.mark.parametrize("name", SUPPORTED_IMAGE_FORMATS)
-def test_add_supported_format(mockimghdr, tmpfile, name):
-    files.add_image_format(name, _test_dummy)
-    assert mockimghdr, "No test added by add image format"
-    assert imghdr.what(tmpfile) == name
-
-
-def test_add_unsupported_format(mockimghdr, tmpfile):
-    files.add_image_format("not_a_format", _test_dummy)
-    assert imghdr.what(tmpfile) is None
-    assert not mockimghdr, "Unsupported test not removed"
-
-
-def _test_dummy(h, f):
-    """Dummy image file test that always returns True."""
-    return True

tests/unit/utils/test_imageheader.py

@@ -0,0 +1,92 @@
+# vim: ft=python fileencoding=utf-8 sw=4 et sts=4
+
+# This file is part of vimiv.
+# Copyright 2017-2023 Christian Karl (karlch) <karlch at protonmail dot com>
+# License: GNU GPL v3, see the "LICENSE" and "AUTHORS" files for details.
+
+"""Tests for vimiv.utils.imageheader."""
+
+from PyQt5.QtGui import QPixmap, QImageReader, QImageWriter
+
+import pytest
+
+
+from vimiv.utils import imageheader
+
+# Formats that are detectable and not detectable by this module
+DETECT_FORMATS = [format for format, _ in imageheader._registry]
+NOT_DETECT_FORMATS = ["svgz", "wbmp"]
+
+# QT Formats that alias to others
+QT_ALIAS_FORMATS = ["jpeg", "tif"]
+
+# Formats that QT can create and that are also detectable
+QT_WRITE_DETECT_FORMATS = [
+    d.data().decode()
+    for d in QImageWriter.supportedImageFormats()
+    if d.data().decode() not in NOT_DETECT_FORMATS
+    and d.data().decode() not in QT_ALIAS_FORMATS
+    and d.data().decode() != "cur"  # CUR types created by QT are actually ICO?!
+]
+
+# Formats that QT can read
+QT_READ_FORMATS = [
+    d.data().decode()
+    for d in QImageReader.supportedImageFormats()
+    if d.data().decode() not in QT_ALIAS_FORMATS
+]
+
+
+@pytest.fixture()
+def mockimageheader(mocker):
+    """Fixture to mock imageheader._registry and QImageReader supportedImageFormats."""
+    mocker.patch.object(
+        QImageReader, "supportedImageFormats", return_value=QT_READ_FORMATS
+    )
+    yield mocker.patch("vimiv.utils.imageheader._registry", [])
+
+
+def create_image(filename: str, *, size=(300, 300)):
+    QPixmap(*size).save(filename)
+
+
+@pytest.mark.parametrize("imagetype", QT_WRITE_DETECT_FORMATS)
+def test_detect(qtbot, tmp_path, imagetype):
+    """Only tests check functions for formats that QT can create samples for."""
+    name = f"img.{imagetype}"
+    filename = str(tmp_path / name)
+    create_image(filename)
+    assert imageheader.detect(filename) == imagetype
+
+
+def _check_dummy(h, f):
+    """Dummy image file check that always returns True."""
+    return True
+
+
+@pytest.mark.parametrize("name", QT_READ_FORMATS)
+def test_register_supported_format(mockimageheader, tmpfile, name):
+    imageheader.register(name, _check_dummy)
+    assert mockimageheader, "No test added by add image format"
+    assert imageheader.detect(tmpfile) == name
+
+
+def test_register_unsupported_format(mockimageheader, tmpfile):
+    """Test if check of invalid format gets removed after call to `detect`."""
+    imageheader.register("not_a_format", _check_dummy)
+    assert imageheader.detect(tmpfile) is None
+    assert not mockimageheader, "Unsupported test not removed"
+
+
+def test_register_unsupported_format_not_verify(mockimageheader, tmpfile):
+    """Test if check of invalid remains when registered without verification."""
+    dummy_format = "not_a_format"
+    imageheader.register(dummy_format, _check_dummy, validate=False)
+    assert imageheader.detect(tmpfile) == dummy_format
+    assert (dummy_format, _check_dummy) in imageheader._registry
+
+
+@pytest.mark.parametrize("name", QT_READ_FORMATS)
+def test_full_support(name):
+    """Tests if all formats readable by QT are also detected."""
+    assert name in NOT_DETECT_FORMATS or name in DETECT_FORMATS, "Missing check"

vimiv/api/__init__.py

@@ -10,7 +10,7 @@
 from typing import List, Iterable, Callable, BinaryIO
 from PyQt5.QtGui import QPixmap
 
-from vimiv.utils import files, imagereader
+from vimiv.utils import files, imagereader, imageheader
 
 from vimiv.api import (
     commands,
@@ -84,7 +84,7 @@ def open_paths(paths: Iterable[str]) -> None:
 
 def add_external_format(
     file_format: str,
-    test_func: files.ImghdrTestFuncT,
+    test_func: imageheader.CheckFuncT,
     load_func: Callable[[str], QPixmap],
 ) -> None:
     """Add support for new fileformat.
@@ -94,5 +94,7 @@ def add_external_format(
         test_func: Function returning True if load_func supports this type.
         load_func: Function to load a QPixmap from the passed path.
     """
-    files.add_image_format(file_format, test_func)
+    # Prioritize external formats over all default formats, to ensure that on signature
+    # collision, the explicitly registered handler is used.
+    imageheader.register(file_format, test_func, priority=True)
     imagereader.external_handler[file_format] = load_func

vimiv/plugins/imageformats.py

@@ -6,6 +6,11 @@
 
 """Plugin enabling support for additional image formats.
 
+Adds support for image formats that are not supported by Qt natively or by the
+qtimageformats add-on, but instead require some other Qt module.
+
+The required Qt module is not installed by Vimiv and requires explicit installation.
+
 Activate it by adding::
 
     imageformats = name, ...
@@ -26,29 +31,43 @@
        ``QImageReader.supportedImageFormats()``.
 """
 
-from typing import Any, Optional, BinaryIO
+from typing import Any, BinaryIO
+
 
-from vimiv.utils import log, files
+from vimiv.utils import log, imageheader
 
 _logger = log.module_logger(__name__)
 
 
-def test_cr2(header: bytes, _f: Optional[BinaryIO]) -> bool:
-    return header[:2] in (b"II", b"MM") and header[8:10] == b"CR"
+def _test_cr2(h: bytes, _f: BinaryIO) -> bool:
+    """Canon Raw 2 (CR2).
 
+    Extension: .cr2
 
-def test_avif(header: bytes, _f: Optional[BinaryIO]) -> bool:
-    return header[4:12] in (b"ftypavif", b"ftypavis")
+    Magic bytes:
+    - 49 49 2A 00 10 00 00 00 43 52
+
+    Support: QtRaw https://gitlab.com/mardy/qtraw
+    """
+    return h[:10] == b"\x49\x49\x2A\x00\x10\x00\x00\x00\x43\x52"
 
 
-def test_jp2(header: bytes, _f: Optional[BinaryIO]) -> bool:
-    return header[:6] == b"\x00\x00\x00\x0cjP"
+def _test_avif(h: bytes, _f: BinaryIO) -> bool:
+    """AV1 Image File (AVIF).
+
+    Extension: .avif
+
+    Magic bytes:
+    - ?
+
+    Support: qt-qvif-image-plugin https://github.com/novomesk/qt-avif-image-plugin
+    """
+    return h[4:12] in (b"ftypavif", b"ftypavis")
 
 
 FORMATS = {
-    "cr2": test_cr2,
-    "avif": test_avif,
-    "jp2": test_jp2,
+    "cr2": _test_cr2,
+    "avif": _test_avif,
 }
 
 
@@ -61,8 +80,9 @@ def init(names: str, *_args: Any, **_kwargs: Any) -> None:
     for name in names.split(","):
         name = name.lower().strip()
         try:
-            test = FORMATS[name]
-            files.add_image_format(name, test)
+            check = FORMATS[name]
+            # Set priority as these types are explicitly enables
+            imageheader.register(name, check, priority=True)
             _logger.debug("Added image format '%s'", name)
         except KeyError:
             _logger.error("Ignoring unknown image format '%s'", name)