opning ports for testing

python/ebook_search/search.py

@@ -13,7 +13,6 @@ from sqlalchemy import literal, select
 from sqlalchemy.orm import Session
 
 from python.ebook_search.bm25_corpus import (
-    BM25CorpusUnavailableError,
     load_bm25_corpus,
     score_bm25_corpus,
 )
@@ -253,12 +252,7 @@ def vector_candidates(engine: Engine, query: str, config: EbookSearchConfig) ->
 
 def bm25_candidates(query: str, config: EbookSearchConfig) -> list[SearchResult]:
     """Return BM25-ranked lexical candidates using the persisted corpus."""
-    try:
-        corpus = load_bm25_corpus(config)
-    except BM25CorpusUnavailableError as error:
-        logger.warning("ebook_bm25_index_unavailable_skipping error=%s", error)
-        return []
-
+    corpus = load_bm25_corpus(config)
     if not corpus.records:
         logger.info("ebook_bm25_search_complete corpus=0 candidates=0")
         return []

python/tools/installer.py

@@ -1,3 +1,4 @@
+# ruff: noqa: LOG015, E501, D102, D103, D107 These need the be fixed
 """Install NixOS on a ZFS pool."""
 
 from __future__ import annotations
@@ -16,9 +17,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
-logger = logging.getLogger(__name__)
-ESCAPE_KEY = 27
-
 
 def configure_logger(level: str = "INFO") -> None:
     """Configure the logger.
@@ -44,7 +42,7 @@ def bash_wrapper(command: str) -> str:
         Tuple[str, int]: A tuple containing the output of the command (stdout) as a string,
         the error output (stderr) as a string (optional), and the return code as an integer.
     """
-    logger.debug(f"running {command=}")
+    logging.debug(f"running {command=}")
     # This is a acceptable risk
     process = Popen(command.split(), stdout=PIPE, stderr=PIPE)
     output, _ = process.communicate()
@@ -65,7 +63,7 @@ def partition_disk(disk: str, swap_size: int, reserve: int = 0) -> None:
         reserve (int, optional): The size of the reserve partition in GB. Defaults to 0.
             minimum value is 0.
     """
-    logger.info(f"partitioning {disk=}")
+    logging.info(f"partitioning {disk=}")
     swap_size = max(swap_size, 1)
     reserve = max(reserve, 0)
 
@@ -73,16 +71,16 @@ def partition_disk(disk: str, swap_size: int, reserve: int = 0) -> None:
 
     if reserve > 0:
         msg = f"Creating swap partition on {disk=} with size {swap_size=}GiB and reserve {reserve=}GiB"
-        logger.info(msg)
+        logging.info(msg)
 
         swap_start = swap_size + reserve
         swap_partition = f"mkpart swap -{swap_start}GiB -{reserve}GiB "
     else:
-        logger.info(f"Creating swap partition on {disk=} with size {swap_size=}GiB")
+        logging.info(f"Creating swap partition on {disk=} with size {swap_size=}GiB")
         swap_start = swap_size
         swap_partition = f"mkpart swap -{swap_start}GiB 100% "
 
-    logger.debug(f"{swap_partition=}")
+    logging.debug(f"{swap_partition=}")
 
     create_partitions = (
         f"parted --script --align=optimal {disk} -- "
@@ -94,7 +92,7 @@ def partition_disk(disk: str, swap_size: int, reserve: int = 0) -> None:
     )
     bash_wrapper(create_partitions)
 
-    logger.info(f"{disk=} successfully partitioned")
+    logging.info(f"{disk=} successfully partitioned")
 
 
 def create_zfs_pool(pool_disks: Sequence[str], mnt_dir: str) -> None:
@@ -133,7 +131,7 @@ def create_zfs_pool(pool_disks: Sequence[str], mnt_dir: str) -> None:
     bash_wrapper(zpool_create)
     zpools = bash_wrapper("zpool list -o name")
     if "root_pool" not in zpools.splitlines():
-        logger.critical("Failed to create root_pool")
+        logging.critical("Failed to create root_pool")
         sys.exit(1)
 
 
@@ -153,7 +151,7 @@ def create_zfs_datasets() -> None:
     }
     missing_datasets = expected_datasets.difference(datasets.splitlines())
     if missing_datasets:
-        logger.critical(f"Failed to create pools {missing_datasets}")
+        logging.critical(f"Failed to create pools {missing_datasets}")
         sys.exit(1)
 
 
@@ -166,7 +164,8 @@ def get_cpu_manufacturer() -> str:
     for line in output.splitlines():
         if "vendor_id" in line:
             return id_vendor[line.split(": ")[1].strip()]
-    error = "Failed to get CPU manufacturer"
+
+    error = "CPU manufacturer not found"
     raise RuntimeError(error)
 
 
@@ -201,15 +200,7 @@ def create_nix_hardware_file(mnt_dir: str, disks: Sequence[str], *, encrypt: boo
         '  imports = [ (modulesPath + "/installer/scan/not-detected.nix") ];\n\n'
         "  boot = {\n"
         "    initrd = {\n"
-        "      availableKernelModules = [ \n"
-        '        "ahci"\n'
-        '        "ehci_pci"\n'
-        '        "nvme"\n'
-        '        "sd_mod"\n'
-        '        "usb_storage"\n'
-        '        "usbhid"\n'
-        '        "xhci_pci"\n'
-        "      ];\n"
+        '      availableKernelModules = [ \n        "ahci"\n        "ehci_pci"\n        "nvme"\n        "sd_mod"\n        "usb_storage"\n        "usbhid"\n        "xhci_pci"\n      ];\n'
         "      kernelModules = [ ];\n"
         f" {devices}"
         "    };\n"
@@ -223,18 +214,11 @@ def create_nix_hardware_file(mnt_dir: str, disks: Sequence[str], *, encrypt: boo
         '    "/nix" = {\n      device = "root_pool/nix";\n      fsType = "zfs";\n    };\n\n'
         '    "/boot" = {\n'
         f'      device = "/dev/disk/by-uuid/{get_boot_drive_id(disks[0])}";\n'
-        '      fsType = "vfat";\n'
-        "      options = [\n"
-        '        "fmask=0077"\n'
-        '        "dmask=0077"\n'
-        "      ];\n"
-        "    };\n"
-        "  };\n\n"
+        '      fsType = "vfat";\n      options = [\n        "fmask=0077"\n        "dmask=0077"\n      ];\n    };\n  };\n\n'
         "  swapDevices = [ ];\n\n"
         "  networking.useDHCP = lib.mkDefault true;\n\n"
         '  nixpkgs.hostPlatform = lib.mkDefault "x86_64-linux";\n'
-        f"  hardware.cpu.{cpu_manufacturer}.updateMicrocode = lib.mkDefault "
-        "config.hardware.enableRedistributableFirmware;\n"
+        f"  hardware.cpu.{cpu_manufacturer}.updateMicrocode = lib.mkDefault config.hardware.enableRedistributableFirmware;\n"
         f'  networking.hostId = "{host_id}";\n'
         "}\n"
     )
@@ -272,30 +256,18 @@ def installer(
     encrypt_key: str | None,
 ) -> None:
     """Main."""
-    logger.info("Starting installation")
+    logging.info("Starting installation")
 
     for disk in disks:
         partition_disk(disk, swap_size, reserve)
 
         if encrypt_key:
             sleep(1)
-            key_input = encrypt_key.encode()
-            run(
-                ("cryptsetup", "luksFormat", "--type", "luks2", f"{disk}-part2", "-"),
-                input=key_input,
-                check=True,
-            )
-            run(
-                (
-                    "cryptsetup",
-                    "luksOpen",
-                    f"{disk}-part2",
-                    f"luks-root-pool-{disk.split('/')[-1]}-part2",
-                    "-",
-                ),
-                input=key_input,
-                check=True,
-            )
+            for command in (
+                f'printf "{encrypt_key}" | cryptsetup luksFormat --type luks2 {disk}-part2 -',
+                f'printf "{encrypt_key}" | cryptsetup luksOpen {disk}-part2 luks-root-pool-{disk.split("/")[-1]}-part2 -',
+            ):
+                run(command, shell=True, check=True)  # noqa: S602
 
     mnt_dir = "/tmp/nix_install"  # noqa: S108
 
@@ -310,73 +282,59 @@ def installer(
 
     create_zfs_datasets()
 
-    install_nixos(mnt_dir, disks, encrypt=bool(encrypt_key))
+    install_nixos(mnt_dir, disks, encrypt=encrypt_key)
 
-    logger.info("Installation complete")
+    logging.info("Installation complete")
 
 
 class Cursor:
-    """Track cursor position and constrain movement to screen bounds."""
+    """Cursor class to store the cursor position."""
 
     def __init__(self) -> None:
-        """Initialize cursor position and screen dimensions."""
         self.x_position = 0
         self.y_position = 0
         self.height = 0
         self.width = 0
 
     def set_height(self, height: int) -> None:
-        """Set the maximum screen height."""
         self.height = height
 
     def set_width(self, width: int) -> None:
-        """Set the maximum screen width."""
         self.width = width
 
     def x_bounce_check(self, cursor: int) -> int:
-        """Clamp an x position to the screen width."""
         cursor = max(0, cursor)
         return min(self.width - 1, cursor)
 
     def y_bounce_check(self, cursor: int) -> int:
-        """Clamp a y position to the screen height."""
         cursor = max(0, cursor)
         return min(self.height - 1, cursor)
 
     def set_x(self, x: int) -> None:
-        """Set the cursor x position."""
         self.x_position = self.x_bounce_check(x)
 
     def set_y(self, y: int) -> None:
-        """Set the cursor y position."""
         self.y_position = self.y_bounce_check(y)
 
     def get_x(self) -> int:
-        """Get the cursor x position."""
         return self.x_position
 
     def get_y(self) -> int:
-        """Get the cursor y position."""
         return self.y_position
 
     def move_up(self) -> None:
-        """Move the cursor up one row."""
         self.set_y(self.y_position - 1)
 
     def move_down(self) -> None:
-        """Move the cursor down one row."""
         self.set_y(self.y_position + 1)
 
     def move_left(self) -> None:
-        """Move the cursor left one column."""
         self.set_x(self.x_position - 1)
 
     def move_right(self) -> None:
-        """Move the cursor right one column."""
         self.set_x(self.x_position + 1)
 
     def navigation(self, key: int) -> None:
-        """Move the cursor for a curses navigation key."""
         action = {
             curses.KEY_DOWN: self.move_down,
             curses.KEY_UP: self.move_up,
@@ -391,7 +349,6 @@ class State:
     """State class to store the state of the program."""
 
     def __init__(self) -> None:
-        """Initialize installer menu state."""
         self.key = 0
         self.cursor = Cursor()
 
@@ -409,7 +366,6 @@ class State:
 
 
 def get_device(raw_device: str) -> dict[str, str]:
-    """Parse an lsblk key-value device row."""
     raw_device_components = raw_device.split(" ")
     return {thing.split("=")[0].lower(): thing.split("=")[1].strip('"') for thing in raw_device_components}
 
@@ -439,7 +395,6 @@ def get_device_id_mapping() -> dict[str, set[str]]:
 
 
 def calculate_device_menu_padding(devices: list[dict[str, str]], column: str, padding: int = 0) -> int:
-    """Calculate the width needed for a device menu column."""
     return max(len(device[column]) for device in devices) + padding
 
 
@@ -451,7 +406,6 @@ def draw_device_ids(
     menu_width: list[int],
     device_ids: set[str],
 ) -> tuple[State, int]:
-    """Draw selectable device IDs for a device row."""
     for device_id in sorted(device_ids):
         row_number = row_number + 1
         if row_number == state.cursor.get_y() and state.cursor.get_x() in menu_width:
@@ -480,7 +434,7 @@ def draw_device_menu(
     state: State,
     menu_start_y: int = 0,
     menu_start_x: int = 0,
-) -> tuple[State, int]:
+) -> State:
     """Draw the device menu and handle user input.
 
     Args:
@@ -536,7 +490,6 @@ def draw_device_menu(
 
 
 def debug_menu(std_screen: curses.window, key: int) -> None:
-    """Draw debug information for the current curses screen."""
     height, width = std_screen.getmaxyx()
     width_height = f"Width: {width}, Height: {height}"
     std_screen.addstr(height - 4, 0, width_height, curses.color_pair(5))
@@ -556,7 +509,6 @@ def status_bar(
     width: int,
     height: int,
 ) -> None:
-    """Draw the footer status bar."""
     std_screen.attron(curses.A_REVERSE)
     std_screen.attron(curses.color_pair(3))
 
@@ -569,7 +521,6 @@ def status_bar(
 
 
 def set_color() -> None:
-    """Initialize curses color pairs."""
     curses.start_color()
     curses.use_default_colors()
     for i in range(curses.COLORS):
@@ -577,7 +528,6 @@ def set_color() -> None:
 
 
 def get_text_input(std_screen: curses.window, prompt: str, y: int, x: int) -> str:
-    """Read text input from a curses screen."""
     curses.echo()
     std_screen.addstr(y, x, prompt)
     input_str = ""
@@ -585,7 +535,7 @@ def get_text_input(std_screen: curses.window, prompt: str, y: int, x: int) -> st
         key = std_screen.getch()
         if key == ord("\n"):
             break
-        if key == ESCAPE_KEY:
+        if key == 27:  # ESC key  # noqa: PLR2004
             input_str = ""
             break
         if key in (curses.KEY_BACKSPACE, ord("\b"), 127):
@@ -603,7 +553,6 @@ def swap_size_input(
     state: State,
     swap_offset: int,
 ) -> State:
-    """Handle swap size input."""
     swap_size_text = "Swap size (GB): "
     std_screen.addstr(swap_offset, 0, f"{swap_size_text}{state.swap_size}")
     if state.key == ord("\n") and state.cursor.get_y() == swap_offset:
@@ -627,7 +576,6 @@ def reserve_size_input(
     state: State,
     reserve_offset: int,
 ) -> State:
-    """Handle reserve size input."""
     reserve_size_text = "reserve size (GB): "
     std_screen.addstr(reserve_offset, 0, f"{reserve_size_text}{state.reserve_size}")
     if state.key == ord("\n") and state.cursor.get_y() == reserve_offset:
@@ -651,7 +599,6 @@ def draw_menu(std_screen: curses.window) -> State:
 
     Args:
         std_screen (curses.window): the curses window to draw on
-
     Returns:
         State: the state object
     """
@@ -711,18 +658,17 @@ def draw_menu(std_screen: curses.window) -> State:
 
 
 def main() -> None:
-    """Run the installer menu and start installation."""
     configure_logger("DEBUG")
 
     state = curses.wrapper(draw_menu)
 
     encrypt_key = getenv("ENCRYPT_KEY")
 
-    logger.info("installing_nixos")
-    logger.info(f"disks: {state.selected_device_ids}")
-    logger.info(f"swap_size: {state.swap_size}")
-    logger.info(f"reserve: {state.reserve_size}")
-    logger.info(f"encrypted: {bool(encrypt_key)}")
+    logging.info("installing_nixos")
+    logging.info(f"disks: {state.selected_device_ids}")
+    logging.info(f"swap_size: {state.swap_size}")
+    logging.info(f"reserve: {state.reserve_size}")
+    logging.info(f"encrypted: {bool(encrypt_key)}")
 
     sleep(3)
 

tests/test_server_validate_scripts.py

@@ -21,7 +21,7 @@ def test_validate_system(mocker: MockerFixture, fs: FakeFilesystem) -> None:
     """test_validate_system."""
     fs.create_file(
         "/mock_snapshot_config.toml",
-        contents='zpools = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
+        contents='zpool = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
     )
 
     mocker.patch(f"{VALIDATE_SYSTEM}.systemd_tests", return_value=None)
@@ -33,10 +33,9 @@ def test_validate_system_errors(mocker: MockerFixture, fs: FakeFilesystem) -> No
     """test_validate_system_errors."""
     fs.create_file(
         "/mock_snapshot_config.toml",
-        contents='zpools = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
+        contents='zpool = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
     )
 
-    mocker.patch(f"{VALIDATE_SYSTEM}.signal_alert")
     mocker.patch(f"{VALIDATE_SYSTEM}.systemd_tests", return_value=["systemd_tests error"])
     mocker.patch(f"{VALIDATE_SYSTEM}.zpool_tests", return_value=["zpool_tests error"])
 
@@ -50,11 +49,9 @@ def test_validate_system_execution(mocker: MockerFixture, fs: FakeFilesystem) ->
     """test_validate_system_execution."""
     fs.create_file(
         "/mock_snapshot_config.toml",
-        contents='zpools = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
+        contents='zpool = ["root_pool", "storage", "media"]\nservices = ["docker"]\n',
     )
 
-    mocker.patch(f"{VALIDATE_SYSTEM}.signal_alert")
-    mocker.patch(f"{VALIDATE_SYSTEM}.systemd_tests", return_value=None)
     mocker.patch(f"{VALIDATE_SYSTEM}.zpool_tests", side_effect=RuntimeError("zpool_tests error"))
 
     with pytest.raises(SystemExit) as exception_info: