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

src/mapping.py

@@ -1,109 +0,0 @@
-import sqlite3
-from dataclasses import dataclass
-from typing import Collection, Iterator
-
-from remap_badblocks.src.utils._iterable_bytes_converter import (
-    iterable_from_bytes, iterable_to_bytes)
-
-DEFAULT_INT_LENGTH = 8
-
-
-@dataclass
-class MappingElement:
-    start_id_virtual: int
-    start_id_real: int
-    length: int
-
-    INT_LENGTH: int = DEFAULT_INT_LENGTH
-    BYTES_LENGTH: int = 3 * INT_LENGTH
-
-    def __bytes__(self) -> bytes:
-        """
-        Convert the MappingElement to bytes for storage.
-        """
-        return iterable_to_bytes(
-            (
-                self.start_id_virtual,
-                self.start_id_real,
-                self.length,
-            ),
-            length=self.INT_LENGTH,
-        )
-
-    def __index__(self) -> int:
-        """
-        Convert the MappingElement to an integer for storage.
-        """
-        return int.from_bytes(self.__bytes__(), "big")
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "MappingElement":
-        """
-        Create a MappingElement from bytes.
-        """
-        if len(data) != cls.BYTES_LENGTH:
-            raise ValueError(f"Data must be exactly {cls.BYTES_LENGTH} bytes long.")
-        start_id_virtual, start_id_real, length = iterable_from_bytes(
-            data, length=cls.INT_LENGTH
-        )
-        return cls(start_id_virtual, start_id_real, length)
-
-    def __hash__(self) -> int:
-        """
-        Hash the MappingElement for use in sets or dictionaries.
-        """
-        return self.__index__()
-
-    @classmethod
-    def from_tuple(cls, _tuple: tuple[int, int, int]) -> "MappingElement":
-        """
-        Create a MappingElement from a tuple.
-        """
-        if len(_tuple) != 3:
-            raise ValueError("Tuple must contain exactly three elements.")
-        return cls(
-            start_id_virtual=_tuple[0], start_id_real=_tuple[1], length=_tuple[2]
-        )
-
-    def to_tuple(self) -> tuple[int, int, int]:
-        return self.start_id_virtual, self.start_id_real, self.length
-
-    def __iter__(self) -> Iterator[int]:
-        return iter(self.to_tuple())
-
-
-@dataclass
-class Mapping:
-    elements: Collection[MappingElement]
-
-    def __bytes__(self) -> bytes:
-        """
-        Convert the Mapping to bytes for storage.
-        """
-        return b"".join(bytes(element) for element in self.elements)
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "Mapping":
-        """
-        Create a Mapping from bytes.
-        """
-        if len(data) % MappingElement.BYTES_LENGTH != 0:
-            raise ValueError(
-                "Data length is not a multiple of {} bytes.",
-                MappingElement.BYTES_LENGTH,
-            )
-        elements: list[MappingElement] = []
-        for i in range(0, len(data), MappingElement.BYTES_LENGTH):
-            elements.append(
-                MappingElement.from_bytes(data[i : i + MappingElement.BYTES_LENGTH])
-            )
-        return cls(elements)
-
-    def to_sql_binary(self) -> sqlite3.Binary:
-        """
-        Convert the Mapping to a binary format suitable for SQLite storage.
-        """
-        return sqlite3.Binary(bytes(self))
-
-    def __iter__(self) -> Iterator[MappingElement]:
-        return iter(self.elements)

src/remappers/_check_applied_devices.py

@@ -1,10 +0,0 @@
-from typing import Iterable
-
-from remap_badblocks.src.devices.device_config import DeviceConfig
-
-
-def filter_applied_devices(devices: Iterable[DeviceConfig]):
-    def check_applied(device: DeviceConfig) -> bool:
-        return device.get_applied_path().is_block_device()
-
-    return filter(check_applied, devices)

src/remappers/_generate_dm_table.py

@@ -1,27 +0,0 @@
-from pathlib import Path
-from typing import Generator, Iterable, TypeVar, Union
-
-from remap_badblocks.src.devices.devices_config import Mapping
-
-
-def generate_dm_table(
-    device: Union[Path, str],
-    mapping: Union[Iterable[tuple[int, int, int]], Mapping],
-    block_size: int,
-) -> Generator[str, None, None]:
-    """Generate a device-mapper linear mapping table from good ranges."""
-    block_size_multiplier = block_size / 512
-    assert block_size_multiplier.is_integer(), "Block size must be a multiple of 512"
-    block_size_multiplier = int(block_size_multiplier)
-
-    T = TypeVar("T")
-
-    def get_first(iterable: Iterable[T]) -> T:
-        return next(iter(iterable))
-
-    for start_virtual, start_real, length in sorted(mapping, key=get_first):
-        start_virtual *= block_size_multiplier
-        start_real *= block_size_multiplier
-        length *= block_size_multiplier
-
-        yield f"{start_virtual} {length} linear {device} {start_real}"

src/test_utils.py

@@ -1,18 +0,0 @@
-from random import shuffle
-from typing import Generator, Iterable, TypeVar
-
-T = TypeVar("T")
-
-
-def iter_to_shuffled_generator(_iter: Iterable[T]) -> Generator[T, None, None]:
-    _iter_list = list(_iter)
-    shuffle(_iter_list)
-    for v in _iter_list:
-        yield v
-
-
-def count_sectors_in_ranges(ranges: Iterable[tuple[int, int]]):
-    n_sectors = 0
-    for start, end in ranges:
-        n_sectors += end - start
-    return n_sectors

src/utils/_get_device_info.py

@@ -1,43 +0,0 @@
-import os
-import re
-from pathlib import Path
-
-
-def resolve_device_name(device: Path) -> str:
-    resolved = device.resolve()
-    if not resolved.is_block_device():
-        raise ValueError(f"{device} is not a valid block device.")
-    _resolved = str(resolved)
-    m = re.match(r"^/dev/([a-zA-Z0-9\-]+)$", _resolved)
-    if not m:
-        raise RuntimeError(f"Could not parse '{_resolved}'.")
-    return m.group(1)
-
-
-def get_disk_block_size(device_name: str) -> int:
-    """Get the block size of the disk."""
-    path = os.path.join("/sys/block/", device_name, "queue/physical_block_size")
-    try:
-        with open(path, "r") as f:
-            block_size = f.read()
-            return int(block_size.strip())
-    except Exception as e:
-        raise RuntimeError(f"Could not read block size for {device_name}: {e}") from e
-
-
-def get_disk_number_of_blocks(device_name: str) -> int:
-    """Get the number of blocks on the disk."""
-    block_size = get_disk_block_size(device_name)
-    path = os.path.join("/sys/block/", device_name, "size")
-    try:
-        with open(path, "r") as f:
-            txt = f.read()
-        size_in_blocks = int(txt.strip()) * 512 / block_size
-        assert (
-            size_in_blocks.is_integer()
-        ), f"Size in blocks is not an integer: {size_in_blocks}"
-        return int(size_in_blocks)
-    except Exception as e:
-        raise RuntimeError(
-            f"Could not read size in physical blocks for {device_name}: {e}"
-        ) from e

src/utils/_iterable_bytes_converter.py

@@ -1,19 +0,0 @@
-from typing import Iterable
-
-
-def iterable_to_bytes(iterable: Iterable[int], length: int = 4) -> bytes:
-    """
-    Convert an iterable of integers to bytes.
-    """
-    return b"".join(i.to_bytes(length, "big") for i in iterable)
-
-
-def iterable_from_bytes(data: bytes, length: int = 4) -> Iterable[int]:
-    """
-    Convert bytes to an iterable of integers.
-    """
-    if len(data) % length != 0:
-        raise ValueError(f"Data length must be a multiple of {length} bytes.")
-    return (
-        int.from_bytes(data[i : i + length], "big") for i in range(0, len(data), length)
-    )

src/utils/_parse_inputs.py

@@ -1,84 +0,0 @@
-import re
-from typing import Optional
-
-
-def parse_string_with_unit_to_bytes(txt: str, unit_multiplier: int) -> int:
-    return round(float(txt) * unit_multiplier)
-
-
-def parse_bytes_to_sectors(_input: int, sector_size: int) -> int:
-    if _input % sector_size != 0:
-        raise ValueError(
-            f"{_input}B is not a multiple of the sector size {sector_size}B."
-        )
-    return int(_input / sector_size)
-
-
-def parse_memory_number_to_bytes(txt: str, sector_size: int) -> int:
-    """
-    Parses a memory value (a sector number or a space size) and outputs a sector number.
-    """
-    txt = txt.strip()
-
-    try:
-        return parse_string_with_unit_to_bytes(txt, sector_size)
-    except ValueError:
-        pass
-    try:
-        if txt.endswith("MB"):
-            return parse_string_with_unit_to_bytes(txt[:-2], 1024**2)
-        elif txt.endswith("GB"):
-            return parse_string_with_unit_to_bytes(txt[:-2], 1024**3)
-        elif txt.endswith("KB"):
-            return parse_string_with_unit_to_bytes(txt[:-2], 1024)
-        elif txt.endswith("B"):
-            return parse_string_with_unit_to_bytes(txt[:-1], 1)
-        else:
-            raise ValueError(f"Invalid format: {txt}")
-    except ValueError as e:
-        raise ValueError(f"Failed to parse memory space from '{txt}': {e}") from e
-
-
-def parse_memory_range_to_bytes(
-    txt: str, sector_size: int
-) -> tuple[Optional[int], Optional[int]]:
-    """
-    Parse a memory space range from a string and check the format is valid. Returns a sector range.
-    I.e. checks that the format is 'start-end', where each can be omitted, and start <= end.
-    """
-    txt = txt.strip()
-
-    m = re.match(
-        r"^(?P<start>\d+(\.\d+)?(?:[KMGT]?B)?)?-(?P<end>\d+(\.\d+)?(?:[KMGT]?B)?)?$",
-        txt,
-    )
-    if m is None:
-        raise ValueError(
-            f"Invalid format: {txt}. Expected format: 'start-end', where each can be omitted."
-        )
-    groups: dict[str, str | None] = {key: m.group(key) for key in ("start", "end")}
-    values: dict[str, int] = {
-        key: parse_memory_number_to_bytes(value, sector_size)
-        for key, value in groups.items()
-        if value is not None
-    }
-
-    start, end = values.get("start"), values.get("end")
-
-    if start is not None and end is not None and (end < start):
-        raise ValueError(f"End {end} must be greater than or equal to start {start}.")
-
-    return start, end
-
-
-def parse_memory_range_to_sectors(
-    txt: str, sector_size: int
-) -> tuple[Optional[int], Optional[int]]:
-    start, end = parse_memory_range_to_bytes(txt, sector_size)
-
-    if start is not None:
-        start = parse_bytes_to_sectors(start, sector_size)
-    if end is not None:
-        end = parse_bytes_to_sectors(end, sector_size)
-
-    return start, end

src/utils/_run_command.py

@@ -1,76 +0,0 @@
-import subprocess
-import sys
-import threading
-from pathlib import Path
-from typing import IO, Iterable, Optional, Protocol, Union
-
-
-class Stringifyiable(Protocol):
-    """Protocol for objects that can be converted to a string."""
-
-    def __str__(self) -> str:
-        """Return the string representation of the object."""
-        ...
-
-
-def pipe_stderr_to_stream(pipe: IO[str], stream: IO[str]) -> None:
-    for line in pipe:
-        print(f"[stderr] {line.strip()}", file=stream)
-
-
-def run_command_realtime(cmd: list[str], stdin: Optional[str] = None) -> Iterable[str]:
-    """Run a command and yield its output line by line in real-time."""
-    with subprocess.Popen(
-        cmd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        stdin=subprocess.PIPE,
-        text=True,
-    ) as process:
-        if process.stdout is None:
-            raise RuntimeError("Failed to capture stdout from the command.")
-
-        if stdin is not None:
-            if process.stdin is None:
-                raise RuntimeError("Failed to pass stdin to command.")
-            else:
-                if not stdin.endswith("\n"):
-                    stdin += "\n"
-                process.stdin.write(stdin)
-                process.stdin.close()
-
-        # Start background stderr reader
-        stderr_thread: Optional[threading.Thread] = None
-        if process.stderr is not None:
-            stderr_thread = threading.Thread(
-                target=pipe_stderr_to_stream, args=(process.stderr, sys.stderr)
-            )
-            stderr_thread.start()
-
-        for line in process.stdout:
-            yield line.strip()
-
-        process.wait()
-        if stderr_thread is not None:
-            stderr_thread.join()
-
-        if process.returncode != 0:
-            # Capture stderr if needed
-            raise RuntimeError(f"Command failed with code {process.returncode}")
-
-
-def pipe_lines_to_file(
-    lines: Iterable[Stringifyiable], output_file: Union[str, Path, IO[str]]
-) -> None:
-    """Save the lines to the specified output file in real-time."""
-    f: Optional[IO[str]] = None
-    try:
-        if not isinstance(output_file, IO):
-            f = open(output_file, "w")
-            output_file = f
-        for line in lines:
-            output_file.write(str(line) + "\n")
-            output_file.flush()  # Ensure the content is written to the file immediately
-    finally:
-        if f is not None:
-            f.close()

src/utils/_sort_devices.py

@@ -1,26 +0,0 @@
-from typing import Collection, Iterable
-
-from remap_badblocks.src.devices.devices_config import DeviceConfig
-
-
-def sort_devices_by_dependencies(
-    devices: Collection[DeviceConfig],
-    already_applied_devices: Iterable[DeviceConfig] = set(),
-) -> Iterable[DeviceConfig]:
-    devices = list(devices)
-    sorted_devices: list[DeviceConfig] = []
-    already_sorted_ids: set[int] = set(map(lambda x: x.id, already_applied_devices))
-
-    while devices:
-        for device in devices:
-            if all(dep in already_sorted_ids for dep in device.depends_on):
-                sorted_devices.append(device)
-                already_sorted_ids.add(device.id)
-                devices.remove(device)
-                break
-        else:
-            raise ValueError(
-                "Circular dependency detected or no device can be applied."
-            )
-
-    return sorted_devices