diskinfo 4.2.0__tar.gz → 4.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diskinfo
-Version: 4.2.0
+Version: 4.2.1
 Summary: Disk information Python library for Linux
 Author-email: Peter Sulyok <peter@sulyok.net>
 License-Expression: MIT

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

@@ -1,7 +1,7 @@
 [project]
 name = "diskinfo"
 description = "Disk information Python library for Linux"
-version = "4.2.0"
+version = "4.2.1"
 readme = "README.md"
 authors = [ 
     { name = "Peter Sulyok", email = "peter@sulyok.net" } 

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

@@ -7,7 +7,7 @@ import re
 from typing import List, Tuple, Union
 import pySMART
 from pyudev import Context, Device, Devices, DeviceNotFoundAtPathError
-from diskinfo.utils import _read_file, size_in_hrf, _pyudev_getenc
+from diskinfo.utils import _read_file, size_in_hrf, _pyudev_getenc, _pyudev_getstr
 from diskinfo.disktype import DiskType
 from diskinfo.filesystem import FileSystem
 from diskinfo.partition import Partition
@@ -186,11 +186,11 @@ class Disk:
                 raise RuntimeError(f"Disk type cannot be determined: disk={pyudev_device.sys_name}, queue/rotational={rotational}.")
 
         # Read further disk attributes.
-        self.__serial_number = pyudev_device.get("ID_SERIAL_SHORT")
-        self.__firmware = pyudev_device.get("ID_REVISION")
-        self.__wwn = pyudev_device.get("ID_WWN")
-        self.__part_table_type = pyudev_device.get("ID_PART_TABLE_TYPE")
-        self.__part_table_uuid = pyudev_device.get("ID_PART_TABLE_UUID")
+        self.__serial_number = _pyudev_getstr(pyudev_device, "ID_SERIAL_SHORT")
+        self.__firmware = _pyudev_getstr(pyudev_device, "ID_REVISION")
+        self.__wwn = _pyudev_getstr(pyudev_device, "ID_WWN")
+        self.__part_table_type = _pyudev_getstr(pyudev_device, "ID_PART_TABLE_TYPE")
+        self.__part_table_uuid = _pyudev_getstr(pyudev_device, "ID_PART_TABLE_UUID")
         self.__model = _pyudev_getenc(pyudev_device, "ID_MODEL")
 
         # Read `/dev/disk/by-byid/` and `/dev/disk/by-path/` path elements.

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

@@ -6,7 +6,7 @@ import os
 import re
 from typing import Tuple
 from pyudev import Device
-from diskinfo.utils import size_in_hrf, _pyudev_getenc
+from diskinfo.utils import size_in_hrf, _pyudev_getenc, _pyudev_getstr
 
 # Path to the kernel mount table.
 _PROC_MOUNTS = "/proc/mounts"
@@ -60,9 +60,9 @@ class FileSystem:
         # Read filesystem attributes from udev properties.
         self.__fs_label = _pyudev_getenc(_device, "ID_FS_LABEL")
         self.__fs_uuid = _pyudev_getenc(_device, "ID_FS_UUID")
-        self.__fs_type = _device.get("ID_FS_TYPE")
-        self.__fs_version = _device.get("ID_FS_VERSION")
-        self.__fs_usage = _device.get("ID_FS_USAGE")
+        self.__fs_type = _pyudev_getstr(_device, "ID_FS_TYPE")
+        self.__fs_version = _pyudev_getstr(_device, "ID_FS_VERSION")
+        self.__fs_usage = _pyudev_getstr(_device, "ID_FS_USAGE")
         self.__fs_mounting_point = ""
         self.__fs_size = 0
         self.__fs_free_size = 0

{diskinfo-4.2.0 → diskinfo-4.2.1}/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, _pyudev_getesc
+from diskinfo.utils import size_in_hrf, _pyudev_getint, _pyudev_getesc, _pyudev_getstr
 from diskinfo.filesystem import FileSystem
 
 
@@ -95,10 +95,10 @@ class Partition:
                 continue
 
         # Save further partition attributes.
-        self.__part_scheme = _device.get("ID_PART_ENTRY_SCHEME")
+        self.__part_scheme = _pyudev_getstr(_device, "ID_PART_ENTRY_SCHEME")
         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_uuid = _pyudev_getstr(_device, "ID_PART_ENTRY_UUID")
+        self.__part_type = _pyudev_getstr(_device, "ID_PART_ENTRY_TYPE")
         self.__part_number = _pyudev_getint(_device, "ID_PART_ENTRY_NUMBER", 0)
         self.__part_offset = _pyudev_getint(_device, "ID_PART_ENTRY_OFFSET", -1)
         self.__part_size = _pyudev_getint(_device, "ID_PART_ENTRY_SIZE", 0)

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

@@ -242,17 +242,42 @@ 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]:
+def _pyudev_getstr(device: Device, key: str) -> str:
+    """Returns a string attribute value of a pyudev.Device() class. The function returns an empty string if the
+    attribute does not exist.
+
+    Args:
+        device (pyudev.Device): pyudev.Device() class
+        key (str): attribute key
+
+    Returns:
+        str: attribute value or empty string
+
+    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_getstr(d, "ID_FS_TYPE"))
+            ext4
+
+    """
+    return device.get(key) or ""
+
+
+def _pyudev_getesc(dev: Device, key: str) -> str:
     """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.
+    result will be stripped. The function returns an empty string if the attribute does not exist.
 
     Args:
         device (pyudev.Device): pyudev.Device() class
         key (str): attribute key
 
     Returns:
-        Union[str, None]: str attribute value or None
+        str: attribute value or empty string
 
     Example:
         An example about the use of the function::
@@ -268,21 +293,22 @@ def _pyudev_getesc(dev: Device, key: str) -> Union[str, None]:
     value = dev.get(key)
     if value:
         return _unescape_udev_value(value).strip()
-    return value
+    return ""
 
 
-def _pyudev_getenc(dev: Device, key: str) -> Union[str, None]:
+def _pyudev_getenc(dev: Device, key: str) -> str:
     """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 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).
+    sanitized value of udev (e.g. the space characters are replaced there). The function returns an empty string
+    if none of the attributes exists.
 
     Args:
         device (pyudev.Device): pyudev.Device() class
         key (str): attribute key
 
     Returns:
-        Union[str, None]: str attribute value or None
+        str: attribute value or empty string
 
     Example:
         An example about the use of the function::
@@ -302,7 +328,7 @@ def _pyudev_getenc(dev: Device, key: str) -> Union[str, None]:
     if value:
         return _unescape_udev_value(value).strip()
     # Read the simple key.
-    return dev.get(key)
+    return dev.get(key) or ""
 
 
 # End

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diskinfo
-Version: 4.2.0
+Version: 4.2.1
 Summary: Disk information Python library for Linux
 Author-email: Peter Sulyok <peter@sulyok.net>
 License-Expression: MIT

{diskinfo-4.2.0 → diskinfo-4.2.1}/test/test_disk.py

@@ -1053,6 +1053,18 @@ def test_disk_blank_no_filesystem():
     assert d.get_filesystem() is None
 
 
+def test_disk_missing_properties_return_empty_strings():
+    """Disk returns empty strings (not None) for all missing udev string properties."""
+    dev = _make_device(name="sdc", dev_id="8:32", size=2097152, phys_bs=512, log_bs=512, rotational="1",
+                       serial=None, firmware=None, wwn=None, model=None, part_table_type=None, part_table_uuid=None)
+    with pyudev_patched(dev):
+        d = Disk(dev.sys_name)
+
+    values = [d.get_serial_number(), d.get_firmware(), d.get_wwn(), d.get_model(), d.get_partition_table_type(),
+              d.get_partition_table_uuid()]
+    assert values == [""] * 6
+
+
 def test_disk_with_partitions_no_raw_filesystem(ssd_device):
     """Disk does not detect a raw filesystem when partitions exist."""
     part = _make_partition_device(

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

@@ -83,6 +83,31 @@ def test_filesystem_stores_all_attributes():
     assert fs.get_fs_mounting_point() == "/mnt/data"
 
 
+@pytest.mark.parametrize("attribute", ["fs_label", "fs_uuid", "fs_type", "fs_version", "fs_usage"])
+def test_filesystem_missing_attribute_returns_empty_string(attribute):
+    """FileSystem returns an empty string (not None) when a udev property is missing."""
+    dev = _make_fs_device(**{attribute: None})
+    with patch("builtins.open", _proc_mounts()):
+        fs = FileSystem(dev)
+
+    value = getattr(fs, f"get_{attribute}")()
+    assert value == ""
+    assert isinstance(value, str)
+
+
+def test_filesystem_without_any_property_returns_empty_strings():
+    """FileSystem of a device without file system properties (e.g. a reserved partition) returns empty values."""
+    dev = _make_fs_device(fs_label=None, fs_uuid=None, fs_type=None, fs_version=None, fs_usage=None)
+    with patch("builtins.open", _proc_mounts()):
+        fs = FileSystem(dev)
+
+    values = [fs.get_fs_label(), fs.get_fs_uuid(), fs.get_fs_type(), fs.get_fs_version(), fs.get_fs_usage(),
+              fs.get_fs_mounting_point()]
+    assert values == [""] * 6
+    assert fs.get_fs_size() == 0
+    assert fs.get_fs_free_size() == 0
+
+
 # ── FileSystem.__init__ – /proc/mounts parsing ──────────────────────────
 
 

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

@@ -397,15 +397,30 @@ def test_partition_decodes_part_label(escaped, expected):
     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."""
+def test_partition_missing_part_label_returns_empty_string():
+    """Partition returns an empty string for a missing partition label 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
+    assert p.get_part_label() == ""
+
+
+def test_partition_missing_properties_return_empty_strings():
+    """Partition and its FileSystem return empty strings (not None) for all missing udev string properties."""
+    dev = _make_part_device(scheme=None, part_label=None, part_uuid=None, part_type=None, fs_label=None,
+                            fs_uuid=None, fs_type=None, fs_version=None, fs_usage=None)
+    with patch("builtins.open", _proc_mounts()):
+        p = Partition(dev)
+
+    fs = p.get_filesystem()
+    values = [p.get_part_scheme(), p.get_part_label(), p.get_part_uuid(), p.get_part_type(), fs.get_fs_label(),
+              fs.get_fs_uuid(), fs.get_fs_type(), fs.get_fs_version(), fs.get_fs_usage()]
+    assert values == [""] * 9
+    # A typical caller pattern must not fail on a partition without a label.
+    assert fs.get_fs_label().startswith("hassos") is False
 
 
 # End

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

@@ -14,6 +14,7 @@ from diskinfo.utils import (
     _pyudev_getenc,
     _unescape_udev_value,
     _pyudev_getesc,
+    _pyudev_getstr,
 )
 
 
@@ -246,6 +247,26 @@ def test_pyudev_getint_non_integer_no_default_returns_none():
     assert _pyudev_getint(dev, "key") is None
 
 
+# ── _pyudev_getstr ────────────────────────────────────────────────────────────
+
+
+def test_pyudev_getstr_returns_value():
+    """_pyudev_getstr() returns the value of an existing key."""
+    dev = MagicMock()
+    dev.get.side_effect = {"ID_FS_TYPE": "ext4"}.get
+    assert _pyudev_getstr(dev, "ID_FS_TYPE") == "ext4"
+
+
+@pytest.mark.parametrize("value", [None, ""], ids=["missing", "empty"])
+def test_pyudev_getstr_missing_or_empty_returns_empty_string(value):
+    """_pyudev_getstr() returns an empty string if the key does not exist or its value is empty."""
+    dev = MagicMock()
+    dev.get.return_value = value
+    result = _pyudev_getstr(dev, "ID_FS_TYPE")
+    assert result == ""
+    assert isinstance(result, str)
+
+
 # ── _pyudev_getenc ────────────────────────────────────────────────────────────
 
 
@@ -290,11 +311,11 @@ def test_pyudev_getenc_decodes_non_ascii_without_space():
     assert _pyudev_getenc(dev, "ID_FS_LABEL") == "CLÉUSB"
 
 
-def test_pyudev_getenc_returns_none_when_both_keys_absent():
-    """_pyudev_getenc() returns None when neither _ENC nor plain key exists."""
+def test_pyudev_getenc_returns_empty_string_when_both_keys_absent():
+    """_pyudev_getenc() returns an empty string when neither _ENC nor plain key exists."""
     dev = MagicMock()
     dev.get.return_value = None
-    assert _pyudev_getenc(dev, "ID_MODEL") is None
+    assert _pyudev_getenc(dev, "ID_MODEL") == ""
 
 
 def test_pyudev_getenc_strips_whitespace_after_decode():
@@ -354,11 +375,11 @@ def test_pyudev_getesc_strips_whitespace_after_decode():
     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."""
+def test_pyudev_getesc_missing_key_returns_empty_string():
+    """_pyudev_getesc() returns an empty string if the key does not exist."""
     dev = MagicMock()
     dev.get.return_value = None
-    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") is None
+    assert _pyudev_getesc(dev, "ID_PART_ENTRY_NAME") == ""
 
 
 def test_pyudev_getesc_empty_value_is_kept():