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

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