Fix new Ruff issues

Author: sbrunner

ci/schema-copy

@@ -2,23 +2,24 @@
 
 import json
 import subprocess  # nosec
+from pathlib import Path
 
 
 def _main() -> None:
-    with open("scan_to_paperless/config_schema.json", encoding="utf-8") as config_schema_file:
+    with Path("scan_to_paperless/config_schema.json").open(encoding="utf-8") as config_schema_file:
         config_schema = json.load(config_schema_file)
-    with open("scan_to_paperless/process_schema.json", encoding="utf-8") as process_schema_file:
+    with Path("scan_to_paperless/process_schema.json").open(encoding="utf-8") as process_schema_file:
         process_schema = json.load(process_schema_file)
 
-    for property in ("args", "auto_mask", "contour"):
-        process_schema["definitions"][property]["properties"] = config_schema["definitions"][property][
+    for property_ in ("args", "auto_mask", "contour"):
+        process_schema["definitions"][property_]["properties"] = config_schema["definitions"][property_][
             "properties"
         ]
-    with open("scan_to_paperless/process_schema.json", "w", encoding="utf-8") as process_schema_file:
+    with Path("scan_to_paperless/process_schema.json").open("w", encoding="utf-8") as process_schema_file:
         json.dump(process_schema, process_schema_file, indent=2)
 
-    subprocess.run(  # nosec
-        ["pre-commit", "run", "--color=never", "--files=scan_to_paperless/process_schema.json", "prettier"],
+    subprocess.run(  # noqa: S603
+        ["pre-commit", "run", "--color=never", "--files=scan_to_paperless/process_schema.json", "prettier"],  # noqa: S607
         check=False,
     )
 

scan_to_paperless/add_code.py

@@ -149,8 +149,8 @@ def _get_bar_codes_with_open_cv(
                         cv2.imwrite(
                             str(dest_filename),
                             decoded_image[
-                                int(math.floor(min(bbox_y))) : int(math.ceil(max(bbox_y))),
-                                int(math.floor(min(bbox_x))) : int(math.ceil(max(bbox_x))),
+                                math.floor(min(bbox_y)) : math.ceil(max(bbox_y)),
+                                math.floor(min(bbox_x)) : math.ceil(max(bbox_x)),
                             ],
                         )
                 founds: list[_FoundCode] = []
@@ -209,8 +209,8 @@ def _get_qr_codes_with_open_cv(
                         cv2.imwrite(
                             str(dest_filename),
                             decoded_image[
-                                int(math.floor(min(bbox_y))) : int(math.ceil(max(bbox_y))),
-                                int(math.floor(min(bbox_x))) : int(math.ceil(max(bbox_x))),
+                                math.floor(min(bbox_y)) : math.ceil(max(bbox_y)),
+                                math.floor(min(bbox_x)) : math.ceil(max(bbox_x)),
                             ],
                         )
 
@@ -227,8 +227,8 @@ def _get_qr_codes_with_open_cv(
                             )
                             retvals = detector.detectAndDecode(
                                 decoded_image[
-                                    int(math.floor(min(bbox_y))) : int(math.ceil(max(bbox_y))),
-                                    int(math.floor(min(bbox_x))) : int(math.ceil(max(bbox_x))),
+                                    (math.floor(min(bbox_y))) : (math.ceil(max(bbox_y))),
+                                    (math.floor(min(bbox_x))) : (math.ceil(max(bbox_x))),
                                 ],
                             )
                             founds.extend(

scan_to_paperless/process.py

@@ -204,7 +204,7 @@ async def wrapper(context: process_utils.Context) -> None:
                     context.image = new_image
             elapsed_time = time.perf_counter() - start_time
             if os.environ.get("TIME", "FALSE") == "TRUE":
-                print(f"Elapsed time in {self.name}: {int(round(elapsed_time))}s.")
+                print(f"Elapsed time in {self.name}: {round(elapsed_time)}s.")
 
             if self.progress:
                 context.save_progress_images(self.name)
@@ -340,8 +340,8 @@ async def _histogram(
         points.append(("max_level", max_, histogram_max / 10))
 
     for label, value, pos in points:
-        if int(round(value)) < len(histogram_data):
-            hist_value = histogram_data[int(round(value))]
+        if round(value) < len(histogram_data):
+            hist_value = histogram_data[round(value)]
             axes.annotate(
                 label,
                 xy=(value, hist_value),
@@ -507,7 +507,7 @@ async def docrop(context: process_utils.Context) -> None:
     margin_vertical = context.get_px_value(
         crop_config.setdefault("margin_vertical", schema.MARGIN_VERTICAL_DEFAULT),
     )
-    crop(context, int(round(margin_horizontal)), int(round(margin_vertical)))
+    crop(context, round(margin_horizontal), round(margin_vertical))
 
 
 @Process("sharpen")
@@ -616,10 +616,10 @@ def draw_rectangle(image: NpNdarrayInt, contour: tuple[int, int, int, int], bord
     color = (0, 255, 0)
     opacity = 0.1
     x, y, width, height = contour
-    x = int(round(x))
-    y = int(round(y))
-    width = int(round(width))
-    height = int(round(height))
+    x = round(x)
+    y = round(y)
+    width = round(width)
+    height = round(height)
 
     sub_img = image[y : y + height, x : x + width]
     mask_image = np.zeros(sub_img.shape, dtype=np.uint8)
@@ -689,20 +689,18 @@ def find_limit_contour(
     values = np.zeros(image_size)
     if vertical:
         for x, _, width, height in contours:
-            x_int = int(round(x))
+            x_int = round(x)
             for value in range(x_int, min(x_int + width, image_size)):
                 values[value] += height
     else:
         for _, y, width, height in contours:
-            y_int = int(round(y))
+            y_int = round(y)
             for value in range(y_int, min(y_int + height, image_size)):
                 values[value] += width
 
     ranges = zero_ranges(values)
 
-    return [
-        int(round(sum(ranges_) / 2)) for ranges_ in ranges if ranges_[0] != 0 and ranges_[1] != image_size
-    ]
+    return [round(sum(ranges_) / 2) for ranges_ in ranges if ranges_[0] != 0 and ranges_[1] != image_size]
 
 
 def find_limits(
@@ -813,7 +811,7 @@ def _find_contours_thresh(
         config.setdefault("contour_kernel_size", schema.CONTOUR_KERNEL_SIZE_DEFAULT),
     )
 
-    kernel_size = int(round(kernel_size / 2))
+    kernel_size = round(kernel_size / 2)
 
     # Assign a rectangle kernel size
     kernel: NpNdarrayInt = np.ones((kernel_size, kernel_size), "uint8")
@@ -1722,7 +1720,7 @@ async def split(
                     )
                     context.image = cv2.imread(process_file.name)
                     if crop_config.setdefault("enabled", schema.CROP_ENABLED_DEFAULT):
-                        crop(context, int(round(margin_horizontal)), int(round(margin_vertical)))
+                        crop(context, round(margin_horizontal), round(margin_vertical))
                         process_file = tempfile.NamedTemporaryFile(  # pylint: disable=consider-using-with
                             suffix=".png",
                         )
@@ -1959,12 +1957,12 @@ async def _process_code(name: str) -> bool:
             await add_code.add_codes(
                 pdf_filename,
                 destination_filename,
-                dpi=float(os.environ.get("SCAN_CODES_DPI", 200)),
-                pdf_dpi=float(os.environ.get("SCAN_CODES_PDF_DPI", 72)),
+                dpi=float(os.environ.get("SCAN_CODES_DPI", "200")),
+                pdf_dpi=float(os.environ.get("SCAN_CODES_PDF_DPI", "72")),
                 font_name=os.environ.get("SCAN_CODES_FONT_NAME", "Helvetica-Bold"),
-                font_size=float(os.environ.get("SCAN_CODES_FONT_SIZE", 16)),
-                margin_top=float(os.environ.get("SCAN_CODES_MARGIN_TOP", 0)),
-                margin_left=float(os.environ.get("SCAN_CODES_MARGIN_LEFT", 2)),
+                font_size=float(os.environ.get("SCAN_CODES_FONT_SIZE", "16")),
+                margin_top=float(os.environ.get("SCAN_CODES_MARGIN_TOP", "0")),
+                margin_left=float(os.environ.get("SCAN_CODES_MARGIN_LEFT", "2")),
             )
             if destination_filename.exists():
                 # Remove the source file on success

scan_to_paperless/process_utils.py

@@ -3,7 +3,6 @@
 import logging
 import math
 import os
-from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, cast
 
@@ -17,6 +16,8 @@
 from scan_to_paperless import process_schema as schema
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Sequence
+
     NpNdarrayInt = np.ndarray[tuple[int, ...], np.dtype[np.integer[Any] | np.floating[Any]]]
 else:
     NpNdarrayInt = np.ndarray
@@ -40,7 +41,7 @@ def rotate_image(image: NpNdarrayInt, angle: float, background: int | tuple[int,
         cv2.warpAffine(
             image,
             rot_mat,
-            (int(round(height)), int(round(width))),
+            ((round(height)), (round(width))),
             borderValue=cast("Sequence[float]", background),
         ),
     )
@@ -58,7 +59,7 @@ def crop_image(
     matrix: NpNdarrayInt = np.array([[1.0, 0.0, -x], [0.0, 1.0, -y]])
     return cast(
         "NpNdarrayInt",
-        cv2.warpAffine(image, matrix, (int(round(width)), int(round(height))), borderValue=background),
+        cv2.warpAffine(image, matrix, ((round(width)), (round(height))), borderValue=background),
     )
 
 

scan_to_paperless/scan.py

@@ -5,7 +5,6 @@
 import argparse
 import datetime
 import math
-import os
 import re
 import subprocess  # nosec
 import sys
@@ -182,18 +181,18 @@ def main() -> None:
 
         if mode_config.get("auto_bash", mode_default.get("auto_bash", schema.AUTO_BASH_DEFAULT)):
             call([*scanimage, "--batch-start=1", "--batch-increment=2"])
-            odd = os.listdir(root_folder)
+            odd = root_folder.iterdir()
             input("Put your document in the automatic document feeder for the other side, and press enter.")
             call(
                 [
                     *scanimage,
-                    f"--batch-start={len(odd) * 2}",
+                    f"--batch-start={len(list(odd)) * 2}",
                     "--batch-increment=-2",
-                    f"--batch-count={len(odd)}",
+                    f"--batch-count={len(list(odd))}",
                 ],
             )
             if mode_config.get("rotate_even", mode_default.get("rotate_even", schema.ROTATE_EVEN_DEFAULT)):
-                for img in os.listdir(root_folder):
+                for img in root_folder.iterdir():
                     if img not in odd:
                         path = root_folder / img
                         with PIL.Image.open(path) as image:
@@ -211,8 +210,8 @@ def main() -> None:
         print(exception)
         sys.exit(1)
 
-    for img in os.listdir(root_folder):
-        if not img.startswith("image-"):
+    for img in root_folder.iterdir():
+        if not img.name.startswith("image-"):
             continue
         if "dpi" not in args_:
             with PIL.Image.open(root_folder / img) as image:
@@ -224,8 +223,8 @@ def main() -> None:
     subprocess.call([config.get("viewer", VIEWER_DEFAULT), root_folder])  # noqa: S603
 
     images = []
-    for img in os.listdir(root_folder):
-        if not img.startswith("image-"):
+    for img in root_folder.iterdir():
+        if not img.name.startswith("image-"):
             continue
         images.append(Path("source") / img)