diskinfo 4.1.2__tar.gz → 4.2.0__tar.gz

{diskinfo-4.1.2/src/diskinfo.egg-info → diskinfo-4.2.0}/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: diskinfo
-Version: 4.1.2
+Version: 4.2.0
 Summary: Disk information Python library for Linux
 Author-email: Peter Sulyok <peter@sulyok.net>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/petersulyok/diskinfo
-Project-URL: Changelog, https://github.com/petersulyok/diskinfo/CHANGELOG.md
+Project-URL: Changelog, https://github.com/petersulyok/diskinfo/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://diskinfo.readthedocs.io/en/latest/index.html
 Project-URL: Issues, https://github.com/petersulyok/diskinfo/issues
 Keywords: disk,linux
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: System :: Hardware
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: <4,>=3.10
+Requires-Python: <4,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pySMART
@@ -25,7 +25,7 @@ Requires-Dist: pyudev
 Dynamic: license-file
 
 # diskinfo
-[![Tests](https://github.com/petersulyok/smfc/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/tests.yml)
+[![Tests](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml)
 [![Codecov](https://codecov.io/gh/petersulyok/diskinfo/branch/main/graph/badge.svg)](https://app.codecov.io/gh/petersulyok/diskinfo)
 [![Documentation Status](https://readthedocs.org/projects/diskinfo/badge/?version=latest)](https://diskinfo.readthedocs.io/en/latest/?badge=latest)
 [![Issues](https://img.shields.io/github/issues/petersulyok/diskinfo)](https://github.com/petersulyok/diskinfo/issues)

{diskinfo-4.1.2 → diskinfo-4.2.0}/README.md

@@ -1,5 +1,5 @@
 # diskinfo
-[![Tests](https://github.com/petersulyok/smfc/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/tests.yml)
+[![Tests](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml)
 [![Codecov](https://codecov.io/gh/petersulyok/diskinfo/branch/main/graph/badge.svg)](https://app.codecov.io/gh/petersulyok/diskinfo)
 [![Documentation Status](https://readthedocs.org/projects/diskinfo/badge/?version=latest)](https://diskinfo.readthedocs.io/en/latest/?badge=latest)
 [![Issues](https://img.shields.io/github/issues/petersulyok/diskinfo)](https://github.com/petersulyok/diskinfo/issues)

{diskinfo-4.1.2 → diskinfo-4.2.0}/pyproject.toml

@@ -1,21 +1,21 @@
 [project]
 name = "diskinfo"
 description = "Disk information Python library for Linux"
-version = "4.1.2"
+version = "4.2.0"
 readme = "README.md"
 authors = [ 
     { name = "Peter Sulyok", email = "peter@sulyok.net" } 
 ]
-requires-python = ">=3.10, <4"
+requires-python = ">=3.11, <4"
 keywords = ["disk", "linux"]
 license= "MIT"
 license-files= ["LICENSE"]
 classifiers = [
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Operating System :: POSIX :: Linux",
     "Topic :: System :: Hardware",
     "Development Status :: 5 - Production/Stable"
@@ -29,10 +29,8 @@ dependencies = [
 dev = [
     "build",
     "coverage",
-    "mock",
     "pytest",
     "pytest-cov",
-    "pytest-mock",
     "twine"
 ]
 lint = [
@@ -55,7 +53,7 @@ build-backend = "setuptools.build_meta"
 
 [project.urls]
 Homepage = "https://github.com/petersulyok/diskinfo"
-Changelog = "https://github.com/petersulyok/diskinfo/CHANGELOG.md"
+Changelog = "https://github.com/petersulyok/diskinfo/blob/main/CHANGELOG.md"
 Documentation = "https://diskinfo.readthedocs.io/en/latest/index.html"
 Issues = "https://github.com/petersulyok/diskinfo/issues"
 
@@ -73,19 +71,27 @@ filterwarnings = [
 ]
 
 # coverage options
+[tool.coverage.run]
+source = ["src/diskinfo"]
+omit = [
+    "src/diskinfo/demo.py"
+]
+
 [tool.coverage.report]
+fail_under = 100
+show_missing = true
+skip_covered = false
 exclude_lines = [
     "pragma: no cover",
     "if __name__ == .__main__.:",
-    "unittest.main()"
-]
-omit = [
-    "src/diskinfo/demo.py"
+    "unittest.main()",
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:"
 ]
 
 # ruff options
 [tool.ruff]
-target-version = "py310"
+target-version = "py311"
 line-length = 120
 
 [tool.ruff.lint]

{diskinfo-4.1.2 → diskinfo-4.2.0}/src/diskinfo/demo.py

@@ -227,7 +227,8 @@ def partition_demo(name: str):
         table.add_column("Type", justify="left", style="bold orchid")
         table.add_column("Start", justify="right", style="bold gray54")
         table.add_column("Size", justify="right", style="bold gray54")
-        table.add_column("Label", justify="left", style="bold purple3")
+        table.add_column("Part label", justify="left", style="bold sky_blue3")
+        table.add_column("FS label", justify="left", style="bold purple3")
         table.add_column("Mounting point", justify="left", style="bold green")
         table.add_column("Free", justify="right", style="bold blue")
         for p in plist:
@@ -237,7 +238,7 @@ def partition_demo(name: str):
             else:
                 free_size_str = "  - %"
             table.add_row(p.get_name(), fs.get_fs_type(), str(p.get_part_offset()), str(p.get_part_size()),
-                          fs.get_fs_label(), fs.get_fs_mounting_point(), free_size_str)
+                          p.get_part_label(), fs.get_fs_label(), fs.get_fs_mounting_point(), free_size_str)
             group = Group(panel, table)
 
     rprint(Panel(group, title="[markdown.strong]diskinfo demo: partitions[/]", title_align="left",

{diskinfo-4.1.2 → diskinfo-4.2.0}/src/diskinfo/disk.py

@@ -307,7 +307,8 @@ class Disk:
         return self.__wwn
 
     def get_model(self) -> str:
-        """Returns the disk model string.
+        """Returns the disk model string. The escape sequences of the udev property (e.g. ``\\x20`` for a space
+        character) are decoded in the result.
 
         Example:
             An example about the use of this function::

{diskinfo-4.1.2 → diskinfo-4.2.0}/src/diskinfo/filesystem.py

@@ -3,6 +3,7 @@
 #    Peter Sulyok (C) 2022-2026.
 #
 import os
+import re
 from typing import Tuple
 from pyudev import Device
 from diskinfo.utils import size_in_hrf, _pyudev_getenc
@@ -10,6 +11,24 @@ from diskinfo.utils import size_in_hrf, _pyudev_getenc
 # Path to the kernel mount table.
 _PROC_MOUNTS = "/proc/mounts"
 
+# Octal escape sequence used by the kernel in the mount table (e.g. `\\040` for a space character).
+_MOUNT_ESCAPE_RE = re.compile(r"\\([0-7]{3})")
+
+
+def _unmangle_path(path: str) -> str:
+    """Decodes the octal escape sequences of a path in the kernel mount table. The kernel escapes the space,
+    tab, newline and backslash characters (i.e. ``\\040``, ``\\011``, ``\\012`` and ``\\134``) in the device node and
+    in the mounting point fields of ``/proc/mounts``.
+
+    Args:
+        path (str): path with escape sequences
+
+    Returns:
+        str: decoded path
+
+    """
+    return _MOUNT_ESCAPE_RE.sub(lambda m: chr(int(m.group(1), 8)), path)
+
 
 class FileSystem:
     """This class encapsulates filesystem-related information read from a block device's udev properties.
@@ -19,7 +38,8 @@ class FileSystem:
 
         1. The mounting point and available space are determined by reading ``/proc/mounts`` and calling
            :func:`os.statvfs`. If the file system is not mounted, the mounting point will be empty and the
-           free size will be ``0``.
+           free size will be ``0``. The octal escape sequences of the kernel mount table (e.g. ``\\040`` for a
+           space character) are decoded.
         2. Instances are created internally by :class:`~diskinfo.Partition` and :class:`~diskinfo.Disk`.
 
     Args:
@@ -55,10 +75,10 @@ class FileSystem:
                     parts = line.split()
                     if len(parts) < 2:
                         continue
-                    if parts[0] == path:
-                        self.__fs_mounting_point = parts[1]
+                    if _unmangle_path(parts[0]) == path:
+                        self.__fs_mounting_point = _unmangle_path(parts[1])
                         try:
-                            st = os.statvfs(parts[1])
+                            st = os.statvfs(self.__fs_mounting_point)
                             self.__fs_size = (st.f_blocks * st.f_frsize) // 512
                             self.__fs_free_size = (st.f_bavail * st.f_frsize) // 512
                         except OSError:
@@ -75,13 +95,15 @@ class FileSystem:
             pass
 
     def get_fs_label(self) -> str:
-        """Returns the label of the file system. The result could be empty if the file system does not have a label.
+        """Returns the label of the file system. The result could be empty if the file system does not have a
+        label. The escape sequences of the udev property (e.g. ``\\xc3\\x89`` for the ``É`` character) are decoded
+        in the result.
         """
         return self.__fs_label
 
     def get_fs_uuid(self) -> str:
         """Returns the UUID of the file system. The result could be empty if the device does not contain a
-        file system.
+        file system. The escape sequences of the udev property are decoded in the result.
         """
         return self.__fs_uuid
 
@@ -155,7 +177,8 @@ class FileSystem:
 
     def get_fs_mounting_point(self) -> str:
         """Returns the mounting point of the file system. The result could be empty if the device does not
-        contain any file system, or it is not mounted.
+        contain any file system, or it is not mounted. The octal escape sequences of the kernel mount table
+        (e.g. ``\\040`` for a space character) are decoded in the result.
         """
         return self.__fs_mounting_point
 

{diskinfo-4.1.2 → diskinfo-4.2.0}/src/diskinfo/partition.py

@@ -4,7 +4,7 @@
 #
 from typing import List, Tuple
 from pyudev import Device
-from diskinfo.utils import size_in_hrf, _pyudev_getint
+from diskinfo.utils import size_in_hrf, _pyudev_getint, _pyudev_getesc
 from diskinfo.filesystem import FileSystem
 
 
@@ -96,7 +96,7 @@ class Partition:
 
         # Save further partition attributes.
         self.__part_scheme = _device.get("ID_PART_ENTRY_SCHEME")
-        self.__part_label = _device.get("ID_PART_ENTRY_NAME")
+        self.__part_label = _pyudev_getesc(_device, "ID_PART_ENTRY_NAME")
         self.__part_uuid = _device.get("ID_PART_ENTRY_UUID")
         self.__part_type = _device.get("ID_PART_ENTRY_TYPE")
         self.__part_number = _pyudev_getint(_device, "ID_PART_ENTRY_NUMBER", 0)
@@ -347,6 +347,7 @@ class Partition:
 
     def get_part_label(self) -> str:
         """Returns the label of the partition. The result could be empty if the partition does not have a label.
+        The escape sequences of the udev property (e.g. ``\\x20`` for a space character) are decoded in the result.
 
         .. note::
             This is a GPT partition-specific value.

{diskinfo-4.1.2 → diskinfo-4.2.0}/src/diskinfo/utils.py

@@ -2,9 +2,36 @@
 #    Module `utils`: implements utility functions.
 #    Peter Sulyok (C) 2022-2026.
 #
+import re
 from typing import List, Tuple, Union
 from pyudev import Device
 
+# Escape sequences of an udev `_ENC` property value (e.g. `\\x20` for a space character). One non-ASCII
+# character is stored as several consecutive sequences, one per UTF-8 byte, so they are matched in groups.
+_UDEV_ESCAPE_RE = re.compile(r"(?:\\x[0-9a-fA-F]{2})+")
+
+
+def _unescape_udev_value(value: str) -> str:
+    """Decodes the escape sequences of an udev ``_ENC`` property value. The udev escapes all bytes outside its
+    safe character set in the form of ``\\xNN``, where ``NN`` is the hexadecimal value of the byte. The escaped
+    bytes of a group are decoded together as an UTF-8 character.
+
+    Args:
+        value (str): property value with escape sequences
+
+    Returns:
+        str: decoded property value
+
+    Example:
+        An example about the use of the function::
+
+            >>> from diskinfo import *
+            >>> _unescape_udev_value("CL\\xc3\\x89\\x20USB")
+            "CLÉ USB"
+
+    """
+    return _UDEV_ESCAPE_RE.sub(lambda m: bytes.fromhex(m.group(0).replace("\\x", "")).decode("utf-8", "replace"), value)
+
 
 def _read_file(path, encoding: str = "utf-8") -> str:
     """Reads the text content of the specified file. The function will hide :py:obj:`IOError` and
@@ -215,10 +242,40 @@ def _pyudev_getint(device: Device, key: str, default_value: int = None) -> Union
     return default_value
 
 
+def _pyudev_getesc(dev: Device, key: str) -> Union[str, None]:
+    """Returns a device attribute value where udev stores the escaped value in the property itself, so there is
+    no `_ENC` key pair (e.g. `ID_PART_ENTRY_NAME`). The escape sequences of the value will be decoded and the
+    result will be stripped.
+
+    Args:
+        device (pyudev.Device): pyudev.Device() class
+        key (str): attribute key
+
+    Returns:
+        Union[str, None]: str attribute value or None
+
+    Example:
+        An example about the use of the function::
+
+            >>> from diskinfo import *
+            >>> from pyudev import *
+            >>> c = Context()
+            >>> d = Devices.from_name(c, "block", "sda1")
+            >>> print(_pyudev_getesc(d, "ID_PART_ENTRY_NAME"))
+            Basic data partition
+
+    """
+    value = dev.get(key)
+    if value:
+        return _unescape_udev_value(value).strip()
+    return value
+
+
 def _pyudev_getenc(dev: Device, key: str) -> Union[str, None]:
     """Returns one of the device attribute key pairs. There are udev attributes key pairs (e.g. `ID_MODEL` and
-    `ID_MODEL_ENC`), where this function first tries to read and decode the `_ENC` version of the key then the simple
-    key if the previous one does not exist.
+    `ID_MODEL_ENC`), where this function reads and decodes the `_ENC` version of the key if it exists, otherwise
+    the simple key will be read. The `_ENC` version is always preferred, because the simple key contains the
+    sanitized value of udev (e.g. the space characters are replaced there).
 
     Args:
         device (pyudev.Device): pyudev.Device() class
@@ -243,8 +300,7 @@ def _pyudev_getenc(dev: Device, key: str) -> Union[str, None]:
     # Read and decode the `_ENC` key.
     value = dev.get(key + "_ENC")
     if value:
-        if "\\x20" in value:
-            return value.replace("\\x20", " ").strip()
+        return _unescape_udev_value(value).strip()
     # Read the simple key.
     return dev.get(key)
 

{diskinfo-4.1.2 → diskinfo-4.2.0/src/diskinfo.egg-info}/PKG-INFO

@@ -1,23 +1,23 @@
 Metadata-Version: 2.4
 Name: diskinfo
-Version: 4.1.2
+Version: 4.2.0
 Summary: Disk information Python library for Linux
 Author-email: Peter Sulyok <peter@sulyok.net>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/petersulyok/diskinfo
-Project-URL: Changelog, https://github.com/petersulyok/diskinfo/CHANGELOG.md
+Project-URL: Changelog, https://github.com/petersulyok/diskinfo/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://diskinfo.readthedocs.io/en/latest/index.html
 Project-URL: Issues, https://github.com/petersulyok/diskinfo/issues
 Keywords: disk,linux
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Topic :: System :: Hardware
 Classifier: Development Status :: 5 - Production/Stable
-Requires-Python: <4,>=3.10
+Requires-Python: <4,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pySMART
@@ -25,7 +25,7 @@ Requires-Dist: pyudev
 Dynamic: license-file
 
 # diskinfo
-[![Tests](https://github.com/petersulyok/smfc/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/tests.yml)
+[![Tests](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml/badge.svg)](https://github.com/petersulyok/diskinfo/actions/workflows/test.yml)
 [![Codecov](https://codecov.io/gh/petersulyok/diskinfo/branch/main/graph/badge.svg)](https://app.codecov.io/gh/petersulyok/diskinfo)
 [![Documentation Status](https://readthedocs.org/projects/diskinfo/badge/?version=latest)](https://diskinfo.readthedocs.io/en/latest/?badge=latest)
 [![Issues](https://img.shields.io/github/issues/petersulyok/diskinfo)](https://github.com/petersulyok/diskinfo/issues)

{diskinfo-4.1.2 → diskinfo-4.2.0}/test/test_filesystem.py

@@ -5,7 +5,7 @@
 import os
 from unittest.mock import MagicMock, patch, mock_open
 import pytest
-from diskinfo.filesystem import FileSystem
+from diskinfo.filesystem import FileSystem, _unmangle_path
 
 
 # ── mock helpers ──────────────────────────────────────────────────────────────
@@ -270,4 +270,71 @@ def test_filesystem_repr():
     assert "/mnt" in result
 
 
+# ── _unmangle_path ────────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "mangled, expected",
+    [
+        ("/mnt/data", "/mnt/data"),
+        ("", ""),
+        ("/run/media/user/Laptop\\040Files", "/run/media/user/Laptop Files"),
+        ("/mnt/tab\\011here", "/mnt/tab\there"),
+        ("/mnt/new\\012line", "/mnt/new\nline"),
+        ("/mnt/back\\134slash", "/mnt/back\\slash"),
+        ("/mnt/a\\040b\\040c", "/mnt/a b c"),
+        ("/mnt/mixed\\040and\\134escaped", "/mnt/mixed and\\escaped"),
+    ],
+)
+def test_unmangle_path_decodes_octal_escapes(mangled, expected):
+    """_unmangle_path() decodes the octal escape sequences of the kernel mount table."""
+    assert _unmangle_path(mangled) == expected
+
+
+def test_unmangle_path_does_not_double_decode():
+    """_unmangle_path() decodes an escaped backslash without decoding the text that follows it."""
+    # `\134040` is an escaped backslash followed by the literal text `040`.
+    assert _unmangle_path("/mnt/x\\134040") == "/mnt/x\\040"
+
+
+# ── FileSystem.__init__ – mangled paths in /proc/mounts ───────────────────────
+
+
+def test_filesystem_unmangles_mount_point_with_space():
+    """FileSystem decodes \\040 in the mounting point and calls statvfs() with the decoded path."""
+    dev = _make_fs_device(path="/dev/sdc4")
+    m = _proc_mounts(("/dev/sdc4", "/run/media/pchauhan/Laptop\\040Files"))
+    with (patch("builtins.open", m),
+          patch("os.statvfs", return_value=_statvfs_result(f_bavail=2048, f_frsize=512)) as mock_statvfs):
+        fs = FileSystem(dev)
+
+    assert fs.get_fs_mounting_point() == "/run/media/pchauhan/Laptop Files"
+    mock_statvfs.assert_called_once_with("/run/media/pchauhan/Laptop Files")
+    assert fs.get_fs_free_size() == 2048
+
+
+def test_filesystem_unmangles_mount_point_with_tab_and_backslash():
+    """FileSystem decodes the tab and backslash escape sequences in the mounting point."""
+    dev = _make_fs_device(path="/dev/sdb1")
+    m = _proc_mounts(("/dev/sdb1", "/mnt/a\\011b\\134c"))
+    with (patch("builtins.open", m),
+          patch("os.statvfs", return_value=_statvfs_result(f_bavail=100, f_frsize=512)) as mock_statvfs):
+        fs = FileSystem(dev)
+
+    assert fs.get_fs_mounting_point() == "/mnt/a\tb\\c"
+    mock_statvfs.assert_called_once_with("/mnt/a\tb\\c")
+
+
+def test_filesystem_unmangles_device_node():
+    """FileSystem matches a device node that is escaped in /proc/mounts."""
+    dev = _make_fs_device(path="/dev/disk/by-label/My Disk")
+    m = _proc_mounts(("/dev/disk/by-label/My\\040Disk", "/mnt/data"))
+    with (patch("builtins.open", m),
+          patch("os.statvfs", return_value=_statvfs_result(f_bavail=64, f_frsize=512))):
+        fs = FileSystem(dev)
+
+    assert fs.get_fs_mounting_point() == "/mnt/data"
+    assert fs.get_fs_free_size() == 64
+
+
 # End

{diskinfo-4.1.2 → diskinfo-4.2.0}/test/test_partition.py

@@ -373,4 +373,39 @@ def test_partition_repr():
     assert "filesystem=" in result
 
 
+# ── Partition – udev escape sequences in the partition label ─────────────────
+
+
+@pytest.mark.parametrize(
+    "escaped, expected",
+    [
+        ("EFI\\x20system\\x20partition", "EFI system partition"),
+        ("Basic\\x20data\\x20partition", "Basic data partition"),
+        ("Microsoft\\x20reserved\\x20partition", "Microsoft reserved partition"),
+        ("Boot", "Boot"),
+        ("Donn\\xc3\\xa9es", "Données"),
+    ],
+)
+def test_partition_decodes_part_label(escaped, expected):
+    """Partition decodes the udev escape sequences of the partition label (issue #10)."""
+    dev = _make_part_device(part_label=escaped)
+    m = _proc_mounts(("/dev/sda1", "/boot/efi"))
+    with (patch("builtins.open", m),
+          patch("os.statvfs", return_value=_statvfs_result(f_bavail=512000))):
+        p = Partition(dev)
+
+    assert p.get_part_label() == expected
+
+
+def test_partition_missing_part_label_stays_none():
+    """Partition keeps the missing partition label as None instead of raising an exception."""
+    dev = _make_part_device(part_label=None)
+    m = _proc_mounts(("/dev/sda1", "/boot/efi"))
+    with (patch("builtins.open", m),
+          patch("os.statvfs", return_value=_statvfs_result(f_bavail=512000))):
+        p = Partition(dev)
+
+    assert p.get_part_label() is None
+
+
 # End

{diskinfo-4.1.2 → diskinfo-4.2.0}/test/test_utils.py

@@ -12,6 +12,8 @@ from diskinfo.utils import (
     time_in_hrf,
     _pyudev_getint,
     _pyudev_getenc,
+    _unescape_udev_value,
+    _pyudev_getesc,
 )
 
 
@@ -263,13 +265,29 @@ def test_pyudev_getenc_falls_back_when_enc_is_none():
     assert _pyudev_getenc(dev, "ID_MODEL") == "Samsung_SSD_850"
 
 
-def test_pyudev_getenc_enc_without_x20_falls_back_to_plain_key():
-    """_pyudev_getenc() uses the plain key when _ENC exists but has no \\x20."""
+def test_pyudev_getenc_prefers_enc_key_without_escapes():
+    """_pyudev_getenc() uses the _ENC key even if it does not contain any escape sequence."""
     dev = MagicMock()
     props = {"ID_MODEL_ENC": "SamsungSSD850", "ID_MODEL": "SamsungSSD850_plain"}
     dev.get.side_effect = props.get
-    # ENC has no \x20, so falls through to plain key
-    assert _pyudev_getenc(dev, "ID_MODEL") == "SamsungSSD850_plain"
+    # The _ENC key is the unsanitized value, so it wins over the plain key (issue #9).
+    assert _pyudev_getenc(dev, "ID_MODEL") == "SamsungSSD850"
+
+
+def test_pyudev_getenc_decodes_non_ascii_with_space():
+    """_pyudev_getenc() decodes a non-ASCII character and a space in the same value (issue #9)."""
+    dev = MagicMock()
+    props = {"ID_FS_LABEL_ENC": "CL\\xc3\\x89\\x20USB", "ID_FS_LABEL": "CLÉ_USB"}
+    dev.get.side_effect = props.get
+    assert _pyudev_getenc(dev, "ID_FS_LABEL") == "CLÉ USB"
+
+
+def test_pyudev_getenc_decodes_non_ascii_without_space():
+    """_pyudev_getenc() decodes a non-ASCII character when the value has no space (issue #9)."""
+    dev = MagicMock()
+    props = {"ID_FS_LABEL_ENC": "CL\\xc3\\x89USB", "ID_FS_LABEL": "CL_USB"}
+    dev.get.side_effect = props.get
+    assert _pyudev_getenc(dev, "ID_FS_LABEL") == "CLÉUSB"
 
 
 def test_pyudev_getenc_returns_none_when_both_keys_absent():
@@ -287,4 +305,67 @@ def test_pyudev_getenc_strips_whitespace_after_decode():
     assert _pyudev_getenc(dev, "ID_FS_LABEL") == "My Label"
 
 
+# ── _unescape_udev_value ──────────────────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    "escaped, expected",
+    [
+        ("SYSTEM", "SYSTEM"),
+        ("", ""),
+        ("Recovery\\x20tools", "Recovery tools"),
+        ("Samsung\\x20SSD\\x20850", "Samsung SSD 850"),
+        ("CL\\xc3\\x89\\x20USB", "CLÉ USB"),
+        ("CL\\xc3\\x89USB", "CLÉUSB"),
+        ("caf\\xc3\\xa9\\x20dr\\xc3\\xafve", "café drïve"),
+        ("\\xe2\\x82\\xac", "€"),
+        ("\\xC3\\x89", "É"),
+    ],
+)
+def test_unescape_udev_value_decodes_escapes(escaped, expected):
+    """_unescape_udev_value() decodes the udev escape sequences into UTF-8 characters."""
+    assert _unescape_udev_value(escaped) == expected
+
+
+def test_unescape_udev_value_invalid_utf8_is_replaced():
+    """_unescape_udev_value() replaces an invalid UTF-8 byte instead of raising an exception."""
+    assert _unescape_udev_value("bad\\xffend") == "bad\ufffdend"
+
+
+def test_unescape_udev_value_keeps_non_escape_text():
+    """_unescape_udev_value() keeps a backslash that is not part of an escape sequence."""
+    assert _unescape_udev_value("a\\xzz\\x41") == "a\\xzzA"
+
+
+# ── _pyudev_getesc ────────────────────────────────────────────────────────────
+
+
+def test_pyudev_getesc_decodes_escapes():
+    """_pyudev_getesc() decodes the escape sequences stored in the property value itself."""
+    dev = MagicMock()
+    dev.get.side_effect = {"ID_PART_ENTRY_NAME": "Basic\\x20data\\x20partition"}.get
+    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") == "Basic data partition"
+
+
+def test_pyudev_getesc_strips_whitespace_after_decode():
+    """_pyudev_getesc() strips the leading and trailing whitespaces after the decoding."""
+    dev = MagicMock()
+    dev.get.side_effect = {"ID_PART_ENTRY_NAME": "\\x20Boot\\x20"}.get
+    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") == "Boot"
+
+
+def test_pyudev_getesc_missing_key_returns_none():
+    """_pyudev_getesc() returns None if the key does not exist."""
+    dev = MagicMock()
+    dev.get.return_value = None
+    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") is None
+
+
+def test_pyudev_getesc_empty_value_is_kept():
+    """_pyudev_getesc() returns the empty value without decoding."""
+    dev = MagicMock()
+    dev.get.return_value = ""
+    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") == ""
+
+
 # End