remap-badblocks 0.7__py3-none-any.whl → 0.8.1__py3-none-any.whl

cli/commands/update.py

@@ -1,208 +0,0 @@
-from argparse import Namespace
-from pathlib import Path
-from tempfile import NamedTemporaryFile
-from typing import Iterable, Literal, Optional, TypedDict
-
-from remap_badblocks.src.badblocks._compute_good_ranges import (
-    compute_good_ranges, reserve_space_from_good_ranges)
-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,
-    remap_badblocks, simplify_mapping)
-from remap_badblocks.src.devices.device_config import DeviceConfig
-from remap_badblocks.src.devices.devices_config import DevicesConfig
-from remap_badblocks.src.mapping import Mapping, MappingElement
-from remap_badblocks.src.utils._parse_inputs import (
-    parse_bytes_to_sectors, parse_memory_number_to_bytes,
-    parse_memory_range_to_sectors)
-from remap_badblocks.src.utils._run_command import pipe_lines_to_file
-
-
-class UpdateArgs(TypedDict):
-    device_id: Optional[int]
-    device_name: Optional[str]
-    mode: Literal["read", "write", "skip"]
-    output: Optional[Path]
-    block_range: str
-    spare_space: Optional[str]
-    reset_mapping: bool
-    external_known_badblocks_file: Optional[Path]
-
-
-def parse_args(args: Namespace) -> UpdateArgs:
-    return {
-        "device_id": args.id,
-        "device_name": args.name,
-        "mode": args.mode,
-        "output": args.output,
-        "block_range": args.block_range,
-        "spare_space": (None if args.spare_space is None else args.spare_space.strip()),
-        "reset_mapping": args.reset_mapping,
-        "external_known_badblocks_file": args.known_badblocks_file,
-    }
-
-
-def get_device_from_args(args: UpdateArgs, dc: DevicesConfig) -> DeviceConfig:
-    if args["device_id"] is None:
-        if args["device_name"] is not None:
-            return dc.get_device(name=args["device_name"])
-        else:
-            raise ValueError(
-                "Either --id or --name must be provided to update a device in the database."
-            )
-
-    return dc.get_device(id=args["device_id"])
-
-
-def get_update_block_range_from_args(
-    args: UpdateArgs, device: DeviceConfig
-) -> tuple[int, int]:
-    start_block, end_block = parse_memory_range_to_sectors(
-        args["block_range"],
-        sector_size=device.sector_size,
-    )
-
-    if (start_block is not None and start_block < device.logical_range[0]) or (
-        end_block is not None and end_block > device.logical_range[1]
-    ):
-        raise ValueError(
-            f"Block range {start_block}-{end_block} must be contained"
-            f" within the logical range {device.logical_range[0]}-{device.logical_range[1]}."
-        )
-
-    if start_block is None:
-        start_block = device.logical_range[0]
-    if end_block is None:
-        end_block = device.logical_range[1]
-
-    return start_block, end_block
-
-
-def get_n_spare_sectors_from_args(args: UpdateArgs, device: DeviceConfig) -> int:
-    sector_size = device.sector_size
-
-    if args["spare_space"] is None:
-        spare_blocks = None
-    else:
-        spare_blocks = parse_bytes_to_sectors(
-            parse_memory_number_to_bytes(args["spare_space"], sector_size=sector_size),
-            sector_size,
-        )
-
-    if spare_blocks is not None:
-        return spare_blocks
-    else:
-        if device.spare_sectors is None:
-            raise ValueError(
-                "Should specify spare_sectors the first time you map badblocks"
-            )
-        return device.spare_sectors
-
-
-def get_starting_badblocks(args: UpdateArgs, device: DeviceConfig) -> set[int]:
-    known_badblocks: set[int] = set(device.badblocks)
-
-    # If known badblocks file is passed, merge it into our known_badblocks
-    if args["external_known_badblocks_file"]:
-        known_badblocks.update(
-            read_known_badblocks(
-                known_badblocks_file=args["external_known_badblocks_file"]
-            )
-        )
-
-    return known_badblocks
-
-
-def get_current_badblocks(
-    args: UpdateArgs,
-    known_badblocks: set[int],
-    device: DeviceConfig,
-    block_range: tuple[int, int],
-) -> set[int]:
-    if args["mode"] == "skip":
-        return known_badblocks
-
-    with NamedTemporaryFile() as known_badblocks_file:
-        known_badblocks_file.write("\n".join(map(str, known_badblocks)).encode("utf-8"))
-        known_badblocks_file.flush()
-
-        badblocks: set[int] = set(
-            get_all_badblocks(
-                device.path,
-                device.sector_size,
-                mode=args["mode"],
-                known_badblocks_file=Path(known_badblocks_file.name),
-                block_range=block_range,
-            )
-        )
-
-        if args["output"]:
-            pipe_lines_to_file(badblocks, args["output"])
-
-        return badblocks
-
-
-def update_mapping(
-    args: UpdateArgs,
-    device: DeviceConfig,
-    badblocks: Iterable[int],
-    n_spare_sectors: int,
-) -> Mapping:
-    new_mapping: Iterable[tuple[int, int, int]]
-
-    if (device.mapping is None) or (args["reset_mapping"]):
-        good_ranges = compute_good_ranges(
-            badblocks, available_range=device.logical_range
-        )
-        good_ranges = reserve_space_from_good_ranges(good_ranges, n_spare_sectors)
-        good_ranges = reserve_space_from_good_ranges(
-            good_ranges,
-            int(100 * 1024 / device.sector_size),
-        )
-        new_mapping = generate_mapping(
-            good_ranges,
-        )
-    else:
-        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)
-        new_mapping = remap_badblocks(
-            current_mapping,
-            badblocks,
-            spare_sectors=iter_free_spare_sectors(spare_sectors, n_used_spare_sectors),
-        )
-
-    new_mapping = simplify_mapping(list(new_mapping))
-    return Mapping(set(map(MappingElement.from_tuple, new_mapping)))
-
-
-def update(dc: DevicesConfig, _args: Namespace) -> None:
-    """
-    Update the mapping of a device in the database.
-    """
-    args = parse_args(_args)
-
-    device: DeviceConfig = get_device_from_args(args, dc)
-    block_range = get_update_block_range_from_args(args, device)
-    n_spare_sectors = get_n_spare_sectors_from_args(args, device)
-
-    known_badblocks = get_starting_badblocks(args, device)
-    badblocks = get_current_badblocks(args, known_badblocks, device, block_range)
-
-    print(
-        f"Badblocks computed. Badblocks went from {len(known_badblocks)} to {len(badblocks)}."
-    )
-
-    dc.update_device(
-        id=device.id,
-        badblocks=badblocks,
-    )
-
-    print("Badblocks list updated.")
-
-    new_mapping = update_mapping(args, device, badblocks, n_spare_sectors)
-    dc.update_device(id=device.id, mapping=new_mapping, spare_sectors=n_spare_sectors)
-
-    print("Mapping updated.")

cli/commands/version.py

@@ -1,15 +0,0 @@
-import os
-from tomllib import load
-
-
-def get_version() -> str:
-
-    pyproject = os.path.join(
-        os.path.dirname(os.path.abspath(__name__)), "pyproject.toml"
-    )
-    with open(pyproject, "rb") as f:
-        return load(f)["project"]["version"]
-
-
-def version():
-    print(f"remap-badblocks version v{get_version()}")

remap_badblocks-0.7.dist-info/METADATA

@@ -1,130 +0,0 @@
-Metadata-Version: 2.4
-Name: remap_badblocks
-Version: 0.7
-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
-Project-URL: Repository, https://gitlab.com/Luigi-98/remap_badblocks.git
-Project-URL: Issues, https://gitlab.com/Luigi-98/remap_badblocks/-/issues
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Provides-Extra: dev
-Requires-Dist: mypy; extra == "dev"
-Requires-Dist: flake8; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Requires-Dist: pytest>=7.0; extra == "dev"
-Requires-Dist: pre-commit; extra == "dev"
-Requires-Dist: black; extra == "dev"
-Requires-Dist: isort; extra == "dev"
-Dynamic: license-file
-
-# remap\_badblocks
-
-`remap_badblocks` is a Linux utility that lets you safely create a virtual block device which skips bad sectors and transparently remaps new bad sectors to healthy spare sectors elsewhere on the same disk. It is useful for squeezing safe, stable usage out of partially failing disks.
-
-## 🔧 How It Works
-
-* Stores devices configurations in a persistent database (this is crucial for accessing the remapped disks)
-  * badblocks
-  * mapping between real and virtual blocks
-  * number of spare sectors in the device
-* It can either create a new mapping from scratch or update the existing one to remap new badblocks by keeping everything intact
-* It can generate device-mapper devices that follow the stored mappings
-
-## 🚀 Usage
-
-```bash
-remap-badblocks [-h] [-P DB_PATH] {add,get,update,apply} ...
-```
-
-### Global Options
-
-* `-P, --db-path` — path to the configuration database (default is internal)
-
-### Commands:
-
-#### `add`
-
-Register a new device in the remap database.
-
-```bash
-remap-badblocks add [--wwn WWN] [--path PATH] name
-```
-
-* `name`: required alias for the device
-* `--wwn`: optional WWN of the device
-* `--path`: optional device path (e.g., `/dev/sdX`)
-
-#### `get`
-
-Retrieve registered devices or a specific one:
-
-```bash
-remap-badblocks get [--id ID]
-```
-
-#### `update`
-
-Compute and store badblocks, update the mapping:
-
-```bash
-remap-badblocks update [--mode {read,write,skip}] [--block-range RANGE] [--output OUTPUT] [--spare-space N] id
-```
-
-* `--mode`: how badblocks should operate (default: `read`)
-* `--block-range`: e.g., `0-100000` or `1573-`
-* `--output`: also save badblocks to a file
-* `--spare-space`: reserve N good sectors for future remapping
-
-#### `apply`
-
-Apply the device-mapper table to create a virtual remapped device:
-
-```bash
-remap-badblocks apply [--id ID] [--method device-mapper]
-```
-
-## 🛠️ Example Workflow
-
-1. Register the device:
-
-```bash
-remap-badblocks add --path /dev/disk/by-id/myid mydrive
-```
-
-2. Run badblocks scan and create the mapping:
-
-```bash
-remap-badblocks update --mode read --spare-space 512MB --id 1
-```
-
-3. Apply the remapping to create a safe virtual block device:
-
-```bash
-remap-badblocks apply --id 1
-```
-
-4. Use `/dev/mapper/mydrive` as your new clean device
-
-## ⚠️ Warnings
-
-* This tool **does not recover corrupted data**, it only prevents future reads/writes from known bad sectors.
-* Only usable on non-boot drives.
-* Always keep backups.
-* Devices are not persistent between boots, you have to manually apply them at startup (`remap-badblocks apply`), but this will be changed in the future.
-
-## 📆 Future Plans
-
-### Done
-- [x] Manage dependencies between different devices
-- [x] Empty db column for "apply at startup"
-- [x] Leave free space in disks for possible future metadata (around 4-8B per badblock + 12-24B per mapping, let's consider around 1k badblocks + 1k mappings = 16-32kB => maybe 100kB is good)
-- [x] Check already applied devices
-- [x] Add version option for getting version
-
-## 🤝 Contributions Welcome
-
-Feel free to submit improvements or suggestions.
-
-For issues or feature requests, please [open a card on GitLab](https://gitlab.com/Luigi-98/remap_badblocks/-/issues).

remap_badblocks-0.7.dist-info/RECORD

@@ -1,66 +0,0 @@
-__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/__main__.py,sha256=9p8yZNyu012JYMfAkQVcVkhShaoyre44jcYzK0ow4NY,7132
-cli/commands/__init__.py,sha256=tGo7_yWZsDpvIIcA9y-4AlLB6grVlK2zaJ6VUKdpONo,216
-cli/commands/add.py,sha256=XRNtzUlwRmFD-5VM2us-odvx5smUcIBM6MBF7786p84,2693
-cli/commands/apply.py,sha256=uwLqEGYz4HVV_5V5Fe3dDDpmS9pt6VUmdZBsVyCnwyk,2534
-cli/commands/get.py,sha256=qDb_KP4YZA9wiXMlXk2i19TDRGaHasPQKcnkWiVv2dA,740
-cli/commands/remove.py,sha256=C3eBGmujtRktBJlGCtvdCRHBVWjRaTDx0o-LQpLEKB8,1186
-cli/commands/update.py,sha256=MA2Ka3tVEC7xg1rx8_dvzThd6huPyZOE0czSsEIoNM8,7019
-cli/commands/version.py,sha256=dAZdvgVLx5V2dMuRCLiEHFP4onIFcvUJ3iT6Bxg-1NE,323
-remap_badblocks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-remap_badblocks/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-remap_badblocks/cli/__main__.py,sha256=9p8yZNyu012JYMfAkQVcVkhShaoyre44jcYzK0ow4NY,7132
-remap_badblocks/cli/commands/__init__.py,sha256=tGo7_yWZsDpvIIcA9y-4AlLB6grVlK2zaJ6VUKdpONo,216
-remap_badblocks/cli/commands/add.py,sha256=XRNtzUlwRmFD-5VM2us-odvx5smUcIBM6MBF7786p84,2693
-remap_badblocks/cli/commands/apply.py,sha256=uwLqEGYz4HVV_5V5Fe3dDDpmS9pt6VUmdZBsVyCnwyk,2534
-remap_badblocks/cli/commands/get.py,sha256=qDb_KP4YZA9wiXMlXk2i19TDRGaHasPQKcnkWiVv2dA,740
-remap_badblocks/cli/commands/remove.py,sha256=C3eBGmujtRktBJlGCtvdCRHBVWjRaTDx0o-LQpLEKB8,1186
-remap_badblocks/cli/commands/update.py,sha256=MA2Ka3tVEC7xg1rx8_dvzThd6huPyZOE0czSsEIoNM8,7019
-remap_badblocks/cli/commands/version.py,sha256=dAZdvgVLx5V2dMuRCLiEHFP4onIFcvUJ3iT6Bxg-1NE,323
-remap_badblocks/src/devices_config_constants.py,sha256=spRtelXdR9kWw-MzFI-CWfmZ6QM0gXvVHbk4J1CeKcM,103
-remap_badblocks/src/mapping.py,sha256=o_r6fiPkzwmsUqzspVkWY7PjWGdRMgxjE5n4w1lEAls,3222
-remap_badblocks/src/test_utils.py,sha256=6kzIHJ04VJMQFYLYNw6wLX0Zy-i_aWDRmWc-zFsiw7Y,437
-remap_badblocks/src/badblocks/_compute_good_ranges.py,sha256=hMNiDurMvtxyt9VxJYTqF_i-8S0_zBLvzKybC6rA9Js,1425
-remap_badblocks/src/badblocks/_find_badblocks.py,sha256=aKgCsUpMj0KDPh_WhAXM5-sxTouVgy61ZS2UyPvcdfQ,2263
-remap_badblocks/src/badblocks/_mapping_generation.py,sha256=M9ENd3fol_C0PA2Pi7AcZ9KRPpUqiVAq8-8n7u_I0Ec,381
-remap_badblocks/src/badblocks/_remap_badblocks.py,sha256=G9ZAzGJmG_hGUrKAcGHjn6I3XGYU_BPJWPzryZY7RBk,3963
-remap_badblocks/src/badblocks/badblocks.py,sha256=AYuh0VRG6vY7of_fqqTCeoe2METVJ-xy7ZvMZw7VqTI,1046
-remap_badblocks/src/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-remap_badblocks/src/devices/device_config.py,sha256=5ZkCxvObgxGf1zVOgzy8GlEX4BfHp8KlD7XzdkJI4zs,1943
-remap_badblocks/src/devices/devices_config.py,sha256=KT0mjop4z3qodHSeJPi5StYzdcUE8WU9te7LIro2CPc,10363
-remap_badblocks/src/devices/exceptions.py,sha256=2RHEZAHQj_bl4B5KHGuqURZswHOMV0GelXXVN7EugdY,825
-remap_badblocks/src/remappers/_check_applied_devices.py,sha256=3Wv5TEoKtszKhcyNNL2pzcB6BuYLmQIJ16mlpOqlw34,314
-remap_badblocks/src/remappers/_generate_dm_table.py,sha256=7BJnqc7Ijgd8SDqdgZvEz6gDJeFokf0hDtm5UjDHlgg,961
-remap_badblocks/src/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-remap_badblocks/src/utils/_get_device_info.py,sha256=HSERimNgOpi_0VIc9LYWLjWBnLRISo2na-pcxbA2icU,1479
-remap_badblocks/src/utils/_iterable_bytes_converter.py,sha256=H0PDLANQLTaakNBHMD_ZZ0Js3seRgXZgs1lxFrqrYAw,586
-remap_badblocks/src/utils/_parse_inputs.py,sha256=KggQ80y97LIAolbhS1OsBMVdt-XDXDO3w4glJQPd4Tw,2772
-remap_badblocks/src/utils/_run_command.py,sha256=3EXIPcjx7MFsXGSDDfnS2qBwXfV-98Efj_enfQS1C_Q,2435
-remap_badblocks/src/utils/_sort_devices.py,sha256=f9w3DoMbRdkDjjaoSrz8qnmDzfaOvk2I_mq4-wwS65A,876
-remap_badblocks-0.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-src/devices_config_constants.py,sha256=spRtelXdR9kWw-MzFI-CWfmZ6QM0gXvVHbk4J1CeKcM,103
-src/mapping.py,sha256=o_r6fiPkzwmsUqzspVkWY7PjWGdRMgxjE5n4w1lEAls,3222
-src/test_utils.py,sha256=6kzIHJ04VJMQFYLYNw6wLX0Zy-i_aWDRmWc-zFsiw7Y,437
-src/badblocks/_compute_good_ranges.py,sha256=hMNiDurMvtxyt9VxJYTqF_i-8S0_zBLvzKybC6rA9Js,1425
-src/badblocks/_find_badblocks.py,sha256=aKgCsUpMj0KDPh_WhAXM5-sxTouVgy61ZS2UyPvcdfQ,2263
-src/badblocks/_mapping_generation.py,sha256=M9ENd3fol_C0PA2Pi7AcZ9KRPpUqiVAq8-8n7u_I0Ec,381
-src/badblocks/_remap_badblocks.py,sha256=G9ZAzGJmG_hGUrKAcGHjn6I3XGYU_BPJWPzryZY7RBk,3963
-src/badblocks/badblocks.py,sha256=AYuh0VRG6vY7of_fqqTCeoe2METVJ-xy7ZvMZw7VqTI,1046
-src/devices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-src/devices/device_config.py,sha256=5ZkCxvObgxGf1zVOgzy8GlEX4BfHp8KlD7XzdkJI4zs,1943
-src/devices/devices_config.py,sha256=KT0mjop4z3qodHSeJPi5StYzdcUE8WU9te7LIro2CPc,10363
-src/devices/exceptions.py,sha256=2RHEZAHQj_bl4B5KHGuqURZswHOMV0GelXXVN7EugdY,825
-src/remappers/_check_applied_devices.py,sha256=3Wv5TEoKtszKhcyNNL2pzcB6BuYLmQIJ16mlpOqlw34,314
-src/remappers/_generate_dm_table.py,sha256=7BJnqc7Ijgd8SDqdgZvEz6gDJeFokf0hDtm5UjDHlgg,961
-src/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-src/utils/_get_device_info.py,sha256=HSERimNgOpi_0VIc9LYWLjWBnLRISo2na-pcxbA2icU,1479
-src/utils/_iterable_bytes_converter.py,sha256=H0PDLANQLTaakNBHMD_ZZ0Js3seRgXZgs1lxFrqrYAw,586
-src/utils/_parse_inputs.py,sha256=KggQ80y97LIAolbhS1OsBMVdt-XDXDO3w4glJQPd4Tw,2772
-src/utils/_run_command.py,sha256=3EXIPcjx7MFsXGSDDfnS2qBwXfV-98Efj_enfQS1C_Q,2435
-src/utils/_sort_devices.py,sha256=f9w3DoMbRdkDjjaoSrz8qnmDzfaOvk2I_mq4-wwS65A,876
-remap_badblocks-0.7.dist-info/METADATA,sha256=w9kicxxd5oFt4oo1K5UrzpnSu31Pava6E4G9h5IAkMc,3974
-remap_badblocks-0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-remap_badblocks-0.7.dist-info/entry_points.txt,sha256=JmLHnqW16bljetWHJrYYAuP0vBrxfO0QY0mFdaWqOKg,70
-remap_badblocks-0.7.dist-info/top_level.txt,sha256=FqRo65stYjF_GyJQCLGIQN1Tj0YQcaiinI5bvzd0OpY,16
-remap_badblocks-0.7.dist-info/RECORD,,

src/badblocks/_compute_good_ranges.py

@@ -1,43 +0,0 @@
-from typing import Generator, Iterable
-
-
-def compute_good_ranges(
-    bad_sectors: Iterable[int], available_range: tuple[int, int]
-) -> Generator[tuple[int, int], None, None]:
-    """
-    Compute good sector ranges, excluding bad sectors.
-    available_range is expected to be a range that is right-open
-    result is a range that is right-open
-    """
-    bad_sectors = sorted(set(bad_sectors))  # Ensure bad_sectors is sorted and unique
-    current_start = available_range[0]
-    last_sector = available_range[1] - 1
-
-    for bad_sector in bad_sectors:
-        if bad_sector > last_sector:
-            break
-        if current_start < bad_sector:
-            yield (current_start, bad_sector)
-        current_start = bad_sector + 1
-
-    if current_start <= last_sector:
-        yield (current_start, last_sector + 1)
-
-
-def reserve_space_from_good_ranges(
-    good_ranges: Iterable[tuple[int, int]], spare_sectors: int
-) -> Generator[tuple[int, int], None, None]:
-    """
-    Return good sector ranges, skipping the first `spare_sectors` good sectors as reserved space.
-    Both input and output ranges are right-open.
-    """
-    to_reserve = spare_sectors
-    for start, end in good_ranges:
-        length = end - start
-        if to_reserve >= length:
-            to_reserve -= length
-            continue
-        elif to_reserve > 0:
-            start += to_reserve
-            to_reserve = 0
-        yield (start, end)

src/badblocks/_find_badblocks.py

@@ -1,76 +0,0 @@
-from itertools import chain
-from pathlib import Path
-from typing import Iterable, Optional, Union
-
-from remap_badblocks.src.utils._run_command import run_command_realtime
-
-
-def parse_badblocks(lines: Iterable[str]) -> Iterable[int]:
-    """Parse badblocks output and return a set of bad sector numbers."""
-    lines = map(lambda line: line.strip(), lines)
-    lines = filter(lambda line: line.isdigit(), lines)
-    return map(int, lines)
-
-
-def read_known_badblocks(known_badblocks_file: Union[Path, str]) -> Iterable[int]:
-    """Merge badblocks with known badblocks from a file."""
-    with open(known_badblocks_file, "r") as f:
-        known_badblocks = parse_badblocks(f.readlines())
-    return known_badblocks
-
-
-def build_badblocks_command(
-    device: Union[Path, str],
-    sector_size: int,
-    mode: str,
-    known_badblocks_file: Optional[Union[Path, str]],
-    blocks_range: Optional[tuple[int, int]],
-) -> list[str]:
-    """
-    Build the badblocks command based on the mode and optional known badblocks file.
-    blocks_range is a right-open interval
-    """
-    if mode == "read":
-        cmd = ["badblocks", "-sv"]
-    elif mode == "write":
-        cmd = ["badblocks", "-wsv"]
-    else:
-        raise ValueError("Invalid mode. Use 'read' or 'write'.")
-
-    cmd += ["-b", str(sector_size)]
-
-    if known_badblocks_file:
-        cmd += ["-i", str(known_badblocks_file)]
-
-    cmd += [str(device)]
-
-    if blocks_range:
-        start_block, end_block = blocks_range
-        cmd += [str(end_block), str(start_block)]
-
-    return cmd
-
-
-def get_all_badblocks(
-    device: Path,
-    sector_size: int,
-    mode: str = "read",
-    known_badblocks_file: Optional[Path] = None,
-    block_range: Optional[tuple[int, int]] = None,
-) -> Iterable[int]:
-    """
-    Run badblocks on a device and return the results as a set of bad sectors.
-    block_range is a right-open interval
-    """
-    badblocks: Iterable[int] = set()
-
-    if known_badblocks_file:
-        badblocks = read_known_badblocks(known_badblocks_file)
-
-    cmd = build_badblocks_command(
-        device, sector_size, mode, known_badblocks_file, block_range
-    )
-    badblocks_lines = run_command_realtime(cmd)
-    badblocks = chain(badblocks, parse_badblocks(badblocks_lines))
-
-    return badblocks

src/badblocks/_mapping_generation.py

@@ -1,12 +0,0 @@
-from typing import Generator, Iterable
-
-
-def generate_mapping(
-    ranges: Iterable[tuple[int, int]],
-) -> Generator[tuple[int, int, int], None, None]:
-    """Generate a mapping from good ranges."""
-    offset = 0
-    for start, end in ranges:
-        length = end - start
-        yield (offset, start, length)  # (start_id_virtual, start_id_real, length)
-        offset += length

src/badblocks/_remap_badblocks.py

@@ -1,114 +0,0 @@
-import itertools
-from typing import Iterable, Iterator, Optional, Union
-
-from remap_badblocks.src.devices.devices_config import Mapping
-
-
-def remap_badblocks(
-    mapping: Iterable[tuple[int, int, int]],
-    badblocks: Iterable[int],
-    spare_sectors: Iterator[int],
-) -> Iterable[tuple[int, int, int]]:
-    sorted_badblocks = sorted(badblocks)
-
-    for start_virtual, start_real, length in mapping:
-        end_real = start_real + length - 1
-        sorted_to_remap: list[int] = []
-        sorted_to_remap_virtual: list[int] = []
-        for badblock in sorted_badblocks:
-            if start_real <= badblock <= end_real:
-                sorted_to_remap.append(badblock)
-        if not sorted_to_remap:
-            # nothing to remap
-            yield start_virtual, start_real, length
-        else:
-            current_start_virtual = start_virtual
-            current_start_real = start_real
-            for badblock in sorted_to_remap:
-                if current_start_real < badblock:
-                    # pieces to keep
-                    yield current_start_virtual, current_start_real, badblock - current_start_real
-                step = badblock - current_start_real + 1
-                current_start_virtual += step
-                current_start_real += step
-                sorted_to_remap_virtual.append(current_start_virtual - 1)
-            if current_start_real < end_real:
-                # pieces to keep
-                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
-                except StopIteration:
-                    raise RuntimeError
-                # remap
-                yield virt_to_remap, spare_sector, 1
-
-
-def identify_simplifiable_couple_in_mapping(
-    mapping: list[tuple[int, int, int]],
-) -> Optional[tuple[int, int]]:
-    for i, (start_virtual_0, start_real_0, length_0) in enumerate(mapping[:-1]):
-        end_virtual_0 = start_virtual_0 + length_0
-        end_real_0 = start_real_0 + length_0
-        for _j, (start_virtual_1, start_real_1, length_1) in enumerate(
-            mapping[i + 1 :]
-        ):
-            j = _j + i + 1
-            end_virtual_1 = start_virtual_1 + length_1
-            end_real_1 = start_real_1 + length_1
-            if (start_virtual_0 == end_virtual_1) and (start_real_0 == end_real_1):
-                return j, i
-            if (start_virtual_1 == end_virtual_0) and (start_real_1 == end_real_0):
-                return i, j
-    return None
-
-
-def simplify_mapping(
-    mapping: list[tuple[int, int, int]],
-) -> Iterable[tuple[int, int, int]]:
-    while (to_simplify := identify_simplifiable_couple_in_mapping(mapping)) is not None:
-        i, j = to_simplify
-        element_i = mapping[i]
-        element_j = mapping[j]
-
-        simplified_element = element_i[0], element_i[1], element_i[2] + element_j[2]
-
-        _i = min(i, j)
-        _j = max(i, j)
-
-        mapping = (
-            mapping[:_i]
-            + mapping[_i + 1 : _j]
-            + mapping[_j + 1 :]
-            + [simplified_element]
-        )
-
-    return mapping
-
-
-def iter_all_spare_sectors(
-    n_spare_sectors: int, first_spare_sector: int
-) -> Iterator[int]:
-    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
-    for _, start, length in mapping:
-        end = start + length
-        for s in spare_sectors:
-            if start <= s < end:
-                used += 1
-
-    return used