remap-badblocks 0.8.1__tar.gz → 0.9__tar.gz

{remap_badblocks-0.8.1/remap_badblocks.egg-info → remap_badblocks-0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remap_badblocks
-Version: 0.8.1
+Version: 0.9
 Summary: CLI tool for remapping bad sectors on Linux disks using device-mapper
 Author-email: Luigi Privitera <priviteraluigi98@gmail.com>
 License-Expression: GPL-3.0-only
@@ -89,11 +89,11 @@ ls /dev/mapper/
 
 We welcome feedback, bug reports, feature ideas, code contributions, and help shaping the roadmap — or even rethinking the project from the ground up.
 
-Start with [CONTRIBUTING.md](./CONTRIBUTING.md), then open an issue or submit a merge request to get involved.
+Start with CONTRIBUTING.md, then open an issue or submit a merge request to get involved.
 
 ## License
 
-GPL v3 License — see [LICENSE](./LICENSE) for details.
+GPL v3 License — see LICENSE for details.
 
 ## Community
 

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/README.md

@@ -68,11 +68,11 @@ ls /dev/mapper/
 
 We welcome feedback, bug reports, feature ideas, code contributions, and help shaping the roadmap — or even rethinking the project from the ground up.
 
-Start with [CONTRIBUTING.md](./CONTRIBUTING.md), then open an issue or submit a merge request to get involved.
+Start with CONTRIBUTING.md, then open an issue or submit a merge request to get involved.
 
 ## License
 
-GPL v3 License — see [LICENSE](./LICENSE) for details.
+GPL v3 License — see LICENSE for details.
 
 ## Community
 

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "remap_badblocks"
-version = "0.8.1"
+version = "0.9"
 requires-python = ">= 3.10"
 description = "CLI tool for remapping bad sectors on Linux disks using device-mapper"
 readme = "README.md"

{remap_badblocks-0.8.1 → remap_badblocks-0.9/remap_badblocks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remap_badblocks
-Version: 0.8.1
+Version: 0.9
 Summary: CLI tool for remapping bad sectors on Linux disks using device-mapper
 Author-email: Luigi Privitera <priviteraluigi98@gmail.com>
 License-Expression: GPL-3.0-only
@@ -89,11 +89,11 @@ ls /dev/mapper/
 
 We welcome feedback, bug reports, feature ideas, code contributions, and help shaping the roadmap — or even rethinking the project from the ground up.
 
-Start with [CONTRIBUTING.md](./CONTRIBUTING.md), then open an issue or submit a merge request to get involved.
+Start with CONTRIBUTING.md, then open an issue or submit a merge request to get involved.
 
 ## License
 
-GPL v3 License — see [LICENSE](./LICENSE) for details.
+GPL v3 License — see LICENSE for details.
 
 ## Community
 

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/src/remap_badblocks/__init__.py

@@ -1,3 +1,3 @@
 from packaging.version import Version
 
-__version__ = Version("0.8.1")
+__version__ = Version("0.9")

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/src/remap_badblocks/cli/commands/update.py

@@ -9,7 +9,7 @@ from remap_badblocks.src.badblocks._find_badblocks import (
     get_all_badblocks, read_known_badblocks)
 from remap_badblocks.src.badblocks._mapping_generation import generate_mapping
 from remap_badblocks.src.badblocks._remap_badblocks import (
-    count_used_spare_sectors, iter_all_spare_sectors, iter_free_spare_sectors,
+    filter_out_used_and_bad_spare_sectors, iter_all_spare_sectors,
     remap_badblocks, simplify_mapping)
 from remap_badblocks.src.devices.device_config import DeviceConfig
 from remap_badblocks.src.devices.devices_config import DevicesConfig
@@ -165,13 +165,15 @@ def update_mapping(
             good_ranges,
         )
     else:
+        badblocks_ = set(badblocks)
         spare_sectors = iter_all_spare_sectors(n_spare_sectors, device.logical_range[0])
-        n_used_spare_sectors = count_used_spare_sectors(device.mapping, spare_sectors)
-        current_mapping = map(lambda x: x.to_tuple(), device.mapping)
+        spare_sectors = filter_out_used_and_bad_spare_sectors(
+            spare_sectors, device.mapping, badblocks_
+        )
         new_mapping = remap_badblocks(
-            current_mapping,
-            badblocks,
-            spare_sectors=iter_free_spare_sectors(spare_sectors, n_used_spare_sectors),
+            device.mapping,
+            badblocks_,
+            spare_sectors,
         )
 
     new_mapping = list(new_mapping)

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/src/remap_badblocks/src/badblocks/_remap_badblocks.py

@@ -1,13 +1,13 @@
-import itertools
-from typing import Iterable, Iterator, Optional, Union
+from collections.abc import Container, Generator, Iterable, Iterator
+from typing import Optional, Union
 
 from remap_badblocks.src.devices.devices_config import Mapping
 
 
 def remap_badblocks(
-    mapping: Iterable[tuple[int, int, int]],
+    mapping: Union[Iterable[tuple[int, int, int]], Mapping],
     badblocks: Iterable[int],
-    spare_sectors: Iterator[int],
+    usable_spare_sectors: Iterator[int],
 ) -> Iterable[tuple[int, int, int]]:
     sorted_badblocks = sorted(badblocks)
 
@@ -37,10 +37,11 @@ def remap_badblocks(
                 yield current_start_virtual, current_start_real, end_real - current_start_real + 1
             for virt_to_remap in sorted_to_remap_virtual:
                 try:
-                    while (spare_sector := next(spare_sectors)) in badblocks:
-                        pass
+                    spare_sector = next(usable_spare_sectors)
                 except StopIteration:
-                    raise RuntimeError
+                    raise RuntimeError(
+                        "Not enough spare sectors to remap all new badblocks"
+                    )
                 # remap
                 yield virt_to_remap, spare_sector, 1
 
@@ -93,22 +94,21 @@ def iter_all_spare_sectors(
     return iter(range(first_spare_sector, first_spare_sector + n_spare_sectors))
 
 
-def iter_free_spare_sectors(
-    spare_sectors: Iterable[int], n_used_spare_sectors: int
-) -> Iterator[int]:
-    return itertools.islice(spare_sectors, n_used_spare_sectors, None)
-
-
-def count_used_spare_sectors(
-    mapping: Union[Iterable[tuple[int, int, int]], Mapping],
-    spare_sectors: Iterable[int],
-) -> int:
-    spare_sectors = set(spare_sectors)
-    used = 0
+def is_sector_used_in_mapping(
+    s: int, mapping: Union[Iterable[tuple[int, int, int]], Mapping]
+):
     for _, start, length in mapping:
         end = start + length
-        for s in spare_sectors:
-            if start <= s < end:
-                used += 1
+        if start <= s < end:
+            return True
+    return False
 
-    return used
+
+def filter_out_used_and_bad_spare_sectors(
+    spare_sectors: Iterable[int],
+    current_mapping: Mapping,
+    badblocks: Container[int],
+) -> Generator[int]:
+    for s in spare_sectors:
+        if s not in badblocks and not is_sector_used_in_mapping(s, current_mapping):
+            yield s

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/src/remap_badblocks/src/mapping.py

@@ -1,6 +1,6 @@
 import sqlite3
 from dataclasses import dataclass
-from typing import Collection, Iterator
+from typing import Collection, Iterable, Iterator
 
 from remap_badblocks.src.utils._iterable_bytes_converter import (
     iterable_from_bytes, iterable_to_bytes)
@@ -107,3 +107,7 @@ class Mapping:
 
     def __iter__(self) -> Iterator[MappingElement]:
         return iter(self.elements)
+
+    @classmethod
+    def from_tuples(cls, mapping_tuples: Iterable[tuple[int, int, int]]) -> "Mapping":
+        return cls(set(map(MappingElement.from_tuple, mapping_tuples)))

{remap_badblocks-0.8.1 → remap_badblocks-0.9}/tests/test_remap_badblocks.py

@@ -3,8 +3,9 @@ from typing import Iterable
 import pytest
 
 from remap_badblocks.src.badblocks._remap_badblocks import (
-    count_used_spare_sectors, iter_all_spare_sectors, remap_badblocks,
-    simplify_mapping)
+    filter_out_used_and_bad_spare_sectors, is_sector_used_in_mapping,
+    remap_badblocks, simplify_mapping)
+from remap_badblocks.src.mapping import Mapping
 
 
 @pytest.mark.parametrize(
@@ -49,18 +50,21 @@ def test_simplify_mapping(
 
 @pytest.mark.parametrize("spare_sectors_n", [10, 20, 100])
 @pytest.mark.parametrize(
-    "mapping, badblocks",
+    "_mapping, badblocks",
     [
         ([(0, 1024, 1024), (1024, 3000, 1000)], [0, 1025, 2050, 2800, 1026]),
         ([(0, 1024, 1024)], [1, 1024, 1025, 1026, 1027, 1028]),
     ],
 )
 def test_remap_badblocks__no_badblocks_in_output(
-    mapping: Iterable[tuple[int, int, int]],
-    badblocks: Iterable[int],
+    _mapping: Iterable[tuple[int, int, int]],
+    badblocks: list[int],
     spare_sectors_n: int,
 ):
-    spare_sectors = iter(range(spare_sectors_n))
+    mapping = Mapping.from_tuples(_mapping)
+    spare_sectors = filter_out_used_and_bad_spare_sectors(
+        range(spare_sectors_n), mapping, badblocks
+    )
     remapped = list(remap_badblocks(mapping, badblocks, spare_sectors))
 
     for _, start, length in remapped:
@@ -91,8 +95,8 @@ def test_remap_badblocks__no_badblocks_in_output(
         ),
         [
             [(0, 1024, 1024)],
-            list(range(10)) + [2047],
-            10,
+            [2047],
+            0,
             False,
         ],
         [
@@ -157,28 +161,79 @@ def test_remap_badblocks__is_keeping_good_ranges_constant(
     assert old_maps_to_keep.issubset(new_maps)
 
 
+# @pytest.mark.parametrize(
+#     "mapping, n_spare_sectors, answer",
+#     [
+#         (
+#             [(0, 10, 5), (5, 17, 8)],
+#             10,
+#             0,
+#         ),
+#         (
+#             [(0, 10, 5), (5, 0, 2), (7, 17, 8)],
+#             10,
+#             2,
+#         ),
+#         (
+#             [(0, 10, 5), (5, 0, 2), (7, 17, 8), (15, 2, 4)],
+#             10,
+#             6,
+#         ),
+#     ],
+# )
+# def test_count_used_spare_sectors(
+#     mapping: Iterable[tuple[int, int, int]], n_spare_sectors: int, answer: int
+# ):
+#     spare_sectors = iter_all_spare_sectors(n_spare_sectors, 0)
+#     assert answer == count_used_spare_sectors(mapping, spare_sectors)
+
+
+@pytest.mark.parametrize("mapping_elem_0", [v * 113 for v in range(100)])
 @pytest.mark.parametrize(
-    "mapping, n_spare_sectors, answer",
-    [
-        (
-            [(0, 10, 5), (5, 17, 8)],
-            10,
-            0,
-        ),
-        (
-            [(0, 10, 5), (5, 0, 2), (7, 17, 8)],
-            10,
-            2,
-        ),
-        (
-            [(0, 10, 5), (5, 0, 2), (7, 17, 8), (15, 2, 4)],
-            10,
-            6,
-        ),
-    ],
+    ("sector", "mapping_elem_1_2", "ground_truth"),
+    (
+        (1, [(0, 4)], True),
+        (0, [(0, 4)], True),
+        (0, [(1, 4)], False),
+        (4, [(0, 4)], False),
+        (5, [(0, 4), (5, 1)], True),
+        (5, [(0, 4), (6, 5)], False),
+        (1000, [(0, 4), (5, 6)], False),
+    ),
 )
-def test_count_used_spare_sectors(
-    mapping: Iterable[tuple[int, int, int]], n_spare_sectors: int, answer: int
+def test_is_sector_used_in_mapping(
+    mapping_elem_0: int,
+    sector: int,
+    mapping_elem_1_2: Iterable[tuple[int, int]],
+    ground_truth: bool,
+):
+    mapping = [
+        (mapping_elem_0, *_mapping_elem_1_2) for _mapping_elem_1_2 in mapping_elem_1_2
+    ]
+    assert is_sector_used_in_mapping(sector, mapping) == ground_truth
+
+
+@pytest.mark.parametrize(
+    ("spare_sectors", "_current_mapping", "badblocks", "ground_truth"),
+    (
+        ([1, 3, 4, 5], [(0, 5, 2)], {0, 1, 10}, {3, 4}),
+        ([], [], [], []),
+        ([0, 1, 2], [], [], {0, 1, 2}),
+        ([0, 1, 2], [], {0, 1, 2}, []),
+        ([0, 1, 2], [(0, 0, 3)], [], []),
+        ([], [], {1, 2, 3}, []),
+        ([0, 1, 2], [(0, 0, 3)], {0, 1, 2}, []),
+    ),
+)
+def test_filter_out_used_and_bad_spare_sectors(
+    spare_sectors: Iterable[int],
+    _current_mapping: Iterable[tuple[int, int, int]],
+    badblocks: Iterable[int],
+    ground_truth: Iterable[int],
 ):
-    spare_sectors = iter_all_spare_sectors(n_spare_sectors, 0)
-    assert answer == count_used_spare_sectors(mapping, spare_sectors)
+    current_mapping = Mapping.from_tuples(_current_mapping)
+    assert set(
+        filter_out_used_and_bad_spare_sectors(
+            spare_sectors, current_mapping, set(badblocks)
+        )
+    ) == set(ground_truth)