remap-badblocks 0.8__py3-none-any.whl → 0.9__py3-none-any.whl

remap_badblocks/__init__.py

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

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/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/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.9.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: remap_badblocks
+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
+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 CLI tool written in Python that scans a block device for bad sectors and creates a device-mapper target that skips over them. It can also reserve extra space to dynamically remap future badblocks.
+
+It's a simple way to extend the usefulness of slightly damaged drives, ideal for anyone who wants to avoid discarding a disk due to a few bad sectors.
+
+## Features
+
+* Scans disks using `badblocks` to identify damaged sectors
+* Creates a `device-mapper` target that avoids bad sectors
+* Reserves spare sectors for dynamic remapping
+* Supports using only part of a device (e.g., for hard partitioning or isolation)
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install remap-badblocks
+```
+
+### From source
+
+```bash
+git clone https://gitlab.com/Luigi-98/remap-badblocks.git
+cd remap-badblocks
+pip install -e .[dev]
+```
+
+## Usage
+
+### Database
+
+`remap-badblocks` relies on a single source of stateful storage: a SQLite database. By default, it is stored at `/etc/remap_badblocks/devices_config.db`, but you can specify an alternative location using the `-P` option.
+
+### Device Identification
+
+Devices can be referenced by either:
+
+* **Name**: set at creation, used as the name of the output device-mapper
+* **ID**: an internal remap-badblocks identifier
+
+### CLI Reference
+
+```bash
+remap-badblocks --help
+```
+
+### Example Workflow
+
+```bash
+# Add a new device
+remap-badblocks add my_remapped_device --path /dev/sda
+
+# Run a read-mode scan and initialize the mapping
+#   by reserving spare space
+remap-badblocks update --name my_remapped_device --mode read --spare-space 100MB
+
+# Apply changes to generate the device-mapper
+remap-badblocks apply
+
+# Resulting device appears under /dev/mapper
+ls /dev/mapper/
+# /dev/mapper/my_remapped_device
+```
+
+## Contributing
+
+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, then open an issue or submit a merge request to get involved.
+
+## License
+
+GPL v3 License — see LICENSE for details.
+
+## Community
+
+* GitLab: [remap-badblocks project page](https://gitlab.com/Luigi-98/remap_badblocks)
+* PyPI: [remap-badblocks](https://pypi.org/project/remap-badblocks/)
+* Issues: [remap-badblocks Gitlab issues](https://gitlab.com/Luigi-98/remap_badblocks/-/issues)
+
+## Acknowledgements & Related Tools
+
+* [`badblocks`](https://linux.die.net/man/8/badblocks)
+* [`device-mapper`](https://linux.die.net/man/8/dmsetup)

remap_badblocks-0.9.dist-info/RECORD

@@ -0,0 +1,36 @@
+remap_badblocks/__init__.py,sha256=uh9pQzPKdlMD_35fZuzjLFDquAyCl9a9KlBFbGf0sQI,68
+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=kX_ZGvkm5dx6tOsViLHc_6S9ybuBcBvAW1i9yFjMGrA,7042
+remap_badblocks/cli/commands/version.py,sha256=uJIZLqK8zlNEgXlx-V7-yhhvsZfBKAE1tlF76t_Fg2I,168
+remap_badblocks/src/devices_config_constants.py,sha256=spRtelXdR9kWw-MzFI-CWfmZ6QM0gXvVHbk4J1CeKcM,103
+remap_badblocks/src/mapping.py,sha256=1OI4Si8QTWa3IM9dG5ms7bHNVDjqAsvK8hqF9r1XvGM,3409
+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=XmdlXHucfW6hHitsO8xDxgBgo01uHmEa601bYVYWYcU,4063
+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=wxOuLfpAHqEHPTZz3LafqZxISGvQWaBlI0kR0Qhl1fk,10380
+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.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+remap_badblocks-0.9.dist-info/METADATA,sha256=AZAzZOzzYCrz2CF8d4BMXvdvNpCEpHQia03_ZBX53ww,3293
+remap_badblocks-0.9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+remap_badblocks-0.9.dist-info/entry_points.txt,sha256=JmLHnqW16bljetWHJrYYAuP0vBrxfO0QY0mFdaWqOKg,70
+remap_badblocks-0.9.dist-info/top_level.txt,sha256=FqRo65stYjF_GyJQCLGIQN1Tj0YQcaiinI5bvzd0OpY,16
+remap_badblocks-0.9.dist-info/RECORD,,

{remap_badblocks-0.8.dist-info → remap_badblocks-0.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

cli/__main__.py

@@ -1,239 +0,0 @@
-from argparse import ArgumentParser, Namespace
-from pathlib import Path
-from typing import Callable
-
-from remap_badblocks.cli.commands import (add, apply, get, remove, update,
-                                          version)
-from remap_badblocks.src.devices.devices_config import DevicesConfig
-from remap_badblocks.src.devices_config_constants import \
-    DEFAULT_DEVICES_CONFIG_PATH
-
-argparse = ArgumentParser(
-    description="Badblocks remapper for block devices.",
-)
-
-argparse.add_argument(
-    "-P",
-    "--db-path",
-    type=Path,
-    default=DEFAULT_DEVICES_CONFIG_PATH,
-    help="Path to the devices configuration database.",
-)
-
-subparser = argparse.add_subparsers(
-    title="Actions",
-    description="Available actions for the badblocks remapper.",
-    dest="action",
-    help="Action to perform",
-    required=True,
-)
-
-add_new_device_parser = subparser.add_parser(
-    "add",
-    help="Add a new device to the database.",
-)
-
-add_new_device_parser.add_argument(
-    "name", type=str, help="The name of the output device."
-)
-add_new_device_parser.add_argument(
-    "--wwn",
-    type=str,
-    help="The WWN of the device to add.",
-)
-add_new_device_parser.add_argument(
-    "--path",
-    type=Path,
-    help="The path to the device to add.",
-)
-add_new_device_parser.add_argument(
-    "--depends-on",
-    type=str,
-    default=[],
-    action="append",
-    help=(
-        "The name of a device that this device depends on. Can be specified multiple times to add multiple"
-        " dependencies. This is used to ensure that devices are applied in the correct order."
-    ),
-)
-add_new_device_parser.add_argument(
-    "--depends-on-id",
-    type=int,
-    default=[],
-    action="append",
-    help=(
-        "The ID of a device that this device depends on. Can be specified multiple times to add multiple"
-        " dependencies. This is used to ensure that devices are applied in the correct order."
-    ),
-)
-add_new_device_parser.add_argument(
-    "--logical-sector-range",
-    type=str,
-    default="-",
-    help=(
-        "Logical sector range to assign to the device. Format: 'start-end', where 'end' can be omitted to mean"
-        " 'till the end of the device'. Both start and end can be specified as sector numbers or as byte offsets."
-        " In case of byte offsets, they must be multiples of the sector size. If not specified, the whole device"
-        " will be used. Note that end is not included in the range."
-    ),
-)
-
-
-get_devices_parser = subparser.add_parser(
-    "get",
-    help="Get the existing device(s) in the database.",
-)
-get_devices_parser.add_argument(
-    "--id",
-    type=int,
-    default=None,
-    help="The ID of the device to get. If neither --id or --name are provided, all devices will be returned.",
-)
-get_devices_parser.add_argument(
-    "--name",
-    type=str,
-    default=None,
-    help="The name of the device to get. If neither --id or --name are provided, all devices will be returned.",
-)
-
-remove_devices_parser = subparser.add_parser(
-    "remove",
-    help="Remove an existing device in the database.",
-)
-remove_devices_parser.add_argument(
-    "--id",
-    type=int,
-    default=None,
-    help="The ID of the device to remove. If neither --id or --name are provided, an error will be raised.",
-)
-remove_devices_parser.add_argument(
-    "--name",
-    type=str,
-    default=None,
-    help="The name of the device to remove. If neither --id or --name are provided, an error will be raised.",
-)
-
-update_mapping_parser = subparser.add_parser(
-    "update",
-    help=(
-        "Update the mapping of a device in the database. More specifically: compute/update the device's badblocks and"
-        " store them in the database, compute the new mapping of a device; if the mapping has changed, the user will"
-        " be prompted to confirm the changes."
-    ),
-)
-update_mapping_parser.add_argument(
-    "--id",
-    type=int,
-    default=None,
-    help="The ID of the device to update.",
-)
-update_mapping_parser.add_argument(
-    "--name",
-    type=str,
-    default=None,
-    help="The name of the device to update.",
-)
-update_mapping_parser.add_argument(
-    "--mode",
-    type=str,
-    choices=["read", "write", "skip"],
-    default="read",
-    help="Mode for computing badblocks",
-)
-update_mapping_parser.add_argument(
-    "--known-badblocks-file",
-    type=Path,
-    default=None,
-    help=(
-        "Path to file with known badblocks (a sector number for each line) that will be merged to those found so far."
-        " Take care the sector size is the same as configured into remap_badblocks"
-    ),
-)
-update_mapping_parser.add_argument(
-    "--block-range",
-    type=str,
-    help=(
-        "Block range to check (e.g., 0-1000, or 1573-), omitted start and end means the whole logical range. Note"
-        " that the end is not included in the range"
-    ),
-    default="-",
-)
-update_mapping_parser.add_argument(
-    "--output",
-    type=Path,
-    default=None,
-    help="Badblocks are stored internally. If provided, they will also be copied to this file.",
-)
-update_mapping_parser.add_argument(
-    "--spare-space",
-    type=str,
-    default=None,
-    help="Number of spare sectors to reserve from the good ranges. Cannot be changed after first time",
-)
-update_mapping_parser.add_argument(
-    "--reset-mapping",
-    action="store_true",
-    help=(
-        "If specified, will ignore existing mapping and build a new mapping from scratch."
-        " DANGER: this might lead to data loss, handle with care"
-    ),
-)
-
-apply_devices_parser = subparser.add_parser(
-    "apply",
-    help="Apply a remapping that's already existing in the database.",
-)
-apply_devices_parser.add_argument(
-    "--id",
-    type=int,
-    default=None,
-    help="The ID of the device to apply. If neither --id or --name are provided, all devices will be applied.",
-)
-apply_devices_parser.add_argument(
-    "--name",
-    type=str,
-    default=None,
-    help="The name of the device to apply. If neither --id or --name are provided, all devices will be applied.",
-)
-apply_devices_parser.add_argument(
-    "--method",
-    type=str,
-    default="device-mapper",
-    choices=["device-mapper"],
-    help="Method to apply the mapping. Only device-mapper is available",
-)
-
-version_parser = subparser.add_parser("version")
-
-
-def main() -> None:
-    args = argparse.parse_args()
-    db_path: Path = args.db_path
-
-    actions: dict[str, Callable[[DevicesConfig, Namespace], None]] = {
-        "add": add,
-        "apply": apply,
-        "get": get,
-        "remove": remove,
-        "update": update,
-    }
-
-    static_actions: dict[str, Callable[[], None]] = {
-        "version": version,
-    }
-
-    if args.action in actions:
-        if db_path.is_dir():
-            raise ValueError("The provided path must not be a directory.")
-        devices_config = DevicesConfig(db_path)
-        actions[args.action](devices_config, args)
-    elif args.action in static_actions:
-        static_actions[args.action]()
-    else:
-        raise ValueError(
-            f"Unknown action: {args.action}. Please use one of {tuple(actions.keys()) + tuple(static_actions.keys())}."
-        )
-
-
-if __name__ == "__main__":
-    main()

cli/commands/__init__.py

@@ -1,8 +0,0 @@
-from .add import add
-from .apply import apply
-from .get import get
-from .remove import remove
-from .update import update
-from .version import version
-
-__all__ = ["add", "apply", "get", "remove", "update", "version"]

cli/commands/add.py

@@ -1,91 +0,0 @@
-import os
-from argparse import Namespace
-from pathlib import Path
-from typing import Optional, TypedDict
-
-from remap_badblocks.src.devices.devices_config import DevicesConfig
-from remap_badblocks.src.utils._get_device_info import (
-    get_disk_block_size, get_disk_number_of_blocks, resolve_device_name)
-from remap_badblocks.src.utils._parse_inputs import \
-    parse_memory_range_to_sectors
-
-
-class AddArgs(TypedDict):
-    wwn: Optional[str]
-    path: Optional[Path]
-    name: str
-    depends_on_id: set[int]
-    depends_on: set[str]
-    logical_sector_range: str
-
-
-def parse_args(args: Namespace) -> AddArgs:
-    return {
-        "wwn": args.wwn,
-        "path": args.path,
-        "name": args.name,
-        "depends_on_id": set(args.depends_on_id),
-        "depends_on": set(args.depends_on),
-        "logical_sector_range": args.logical_sector_range.strip(),
-    }
-
-
-def get_path_from_args(args: AddArgs) -> Path:
-    wwn = args["wwn"]
-    path = args["path"]
-
-    if wwn is not None and path is not None:
-        raise ValueError("Only one of --wwn or --path can be provided, not both.")
-
-    if path is not None:
-        if isinstance(path, str):
-            path = Path(path)
-        return path
-    elif wwn is not None:
-        if not wwn.startswith("/dev/disk/by-id/"):
-            wwn = os.path.join("/dev/disk/by-id/", wwn)
-        return Path(wwn)
-    else:
-        raise ValueError("Either --wwn or --path must be provided.")
-
-
-def get_device_dependencies_from_args(dc: DevicesConfig, args: AddArgs) -> set[int]:
-    return args["depends_on_id"] | {
-        dc.get_device(name=dep).id for dep in args["depends_on"] if dep
-    }
-
-
-def get_logical_block_range_from_args(
-    args: AddArgs, sector_size: int, total_sectors: int
-) -> tuple[int, int]:
-    logical_start_block, logical_end_block = parse_memory_range_to_sectors(
-        args["logical_sector_range"], sector_size
-    )
-
-    if logical_start_block is None:
-        logical_start_block = 0
-    if logical_end_block is None:
-        logical_end_block = total_sectors
-
-    return logical_start_block, logical_end_block
-
-
-def add(dc: DevicesConfig, _args: Namespace) -> None:
-    """
-    Add a new device to the database.
-    """
-    args = parse_args(_args)
-    path: Path = get_path_from_args(args)
-
-    sector_size = get_disk_block_size(resolve_device_name(path))
-    total_sectors = get_disk_number_of_blocks(resolve_device_name(path))
-
-    dc.add_device(
-        path=path,
-        name=args["name"],
-        sector_size=sector_size,
-        depends_on=get_device_dependencies_from_args(dc, args),
-        logical_range=get_logical_block_range_from_args(
-            args, sector_size, total_sectors
-        ),
-    )