Improve Python scripts: type hints, bug fixes, cleaner code

print_lines.py:
- Fix UnboundLocalError when file is empty (count_lines uses sum())
- Use shutil.which() instead of wasteful subprocess.check_call()
- Proper main() function for clean imports
- Better error handling with specific exception types

unique_files_search.py:
- Add type hints throughout
- Search full path, not just filename (e.g., "work" finds work/todo.md)
- Extract helper functions for better testability
- Use splitlines() instead of split('\n')

shorten_path_for_notational_fzf.py:
- Add type hints and docstrings
- Cleaner code structure with main() function
- Remove commented-out code
- Better variable naming

Author: alok

print_lines.py

@@ -3,53 +3,90 @@
 """Colorize the current line in the preview window in bold red."""
 
 import os.path as path
-import sys
+import shutil
 import subprocess
+import sys
 
-line = int(sys.argv[1])
-file = sys.argv[2]
-height = int(sys.argv[3])
+# ANSI escape sequences
+RED = "\033[1;31m"
+RESET = "\033[0;0m"
+BOLD = "\033[;1m"
 
 
-def opcount(fname):
+def count_lines(fname: str) -> int:
+    """Count lines in a file, returning 0 on error."""
     try:
         with open(fname, encoding="utf-8", errors="replace") as f:
-            for i, _ in enumerate(f):
-                pass
-        return i + 1
-    except Exception:
+            return sum(1 for _ in f)
+    except (OSError, IOError):
         return 0
 
 
-if __name__ == "__main__":
+def preview_with_bat(filepath: str, target_line: int, height: int) -> bool:
+    """Preview file using bat. Returns True on success."""
+    if not shutil.which("bat"):
+        return False
+
+    lines = count_lines(filepath)
+    cmd = [
+        "bat",
+        "--style=numbers",
+        "--color=always",
+        f"--highlight-line={target_line}",
+    ]
+
+    # Center the view around the target line if possible
+    if target_line > height // 2 and lines >= height:
+        start = max(1, target_line - height // 2)
+        cmd.append(f"--line-range={start}:{lines}")
+
+    cmd.append(path.normpath(filepath))
+
+    try:
+        subprocess.run(cmd, check=False)
+        return True
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def preview_with_fallback(filepath: str, target_line: int, height: int) -> None:
+    """Preview file with basic Python fallback (no bat)."""
     try:
-        # fail fast
-        subprocess.check_call(["bat"])
-        lines = opcount(file)
-        cmd = [
-            "bat",
-            "--style=numbers",
-            "--color=always",
-            "--highlight-line={}".format(line),
-        ]
-        if (line > (height / 2)) and (lines >= height):
-            cmd.append("--line-range={}:{}".format(int(line - (height / 2)), lines))
-        cmd.append(path.normpath(file))
-        subprocess.run(cmd)
-    except Exception:
-        is_sel = False
-        # ANSI escape sequences for coloring matched line
-        RED = "\033[1;31m"
-        RESET = "\033[0;0m"
-        BOLD = "\033[;1m"
-        try:
-            with open(path.normpath(file), encoding="utf-8", errors="replace") as f:
-                for linenum, line_content in enumerate(f, start=1):
-                    if linenum == line:
-                        print(BOLD + RED + line_content.rstrip() + RESET)
-                        is_sel = True
-                    elif is_sel or (line - linenum <= (height / 2 - 1)):
-                        print(line_content.rstrip())
-        except Exception:
-            # If file can't be read, print error message
-            print(RED + "Error: Could not read file" + RESET)
+        with open(path.normpath(filepath), encoding="utf-8", errors="replace") as f:
+            lines = list(f)
+    except (OSError, IOError):
+        print(f"{RED}Error: Could not read file{RESET}")
+        return
+
+    # Calculate window around target line
+    start = max(0, target_line - height // 2 - 1)
+    end = min(len(lines), start + height)
+
+    for i in range(start, end):
+        linenum = i + 1
+        content = lines[i].rstrip()
+        if linenum == target_line:
+            print(f"{BOLD}{RED}{content}{RESET}")
+        else:
+            print(content)
+
+
+def main() -> None:
+    if len(sys.argv) < 4:
+        print(f"Usage: {sys.argv[0]} <line> <file> <height>", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        target_line = int(sys.argv[1])
+        filepath = sys.argv[2]
+        height = int(sys.argv[3])
+    except ValueError as e:
+        print(f"Error: Invalid argument: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not preview_with_bat(filepath, target_line, height):
+        preview_with_fallback(filepath, target_line, height)
+
+
+if __name__ == "__main__":
+    main()

shorten_path_for_notational_fzf.py

@@ -1,133 +1,113 @@
-#!/usr/bin/env pypy3
-# encoding: utf-8
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Shorten file paths for notational-fzf-vim display.
 
-# Supposedly, importing so that you don't need dots in names speeds up a
-# script, and the point of this one is to run fast.
+Reads lines in format `filename:linenum:contents` from stdin,
+outputs `filename:linenum:shortname:linenum:contents` with colored paths.
+"""
+
+from __future__ import annotations
 
 import platform
+import sys
 from os import pardir
 from os.path import abspath, expanduser, join, sep, split, splitdrive
 from pathlib import PurePath
-from sys import stdin
 
+# ANSI color codes
+GREEN = "\033[32m"
+PURPLE = "\033[35m"
+CYAN = "\033[36m"
+RESET = "\033[0m"
 
-# These are floated to the top so they aren't recalculated every loop.  The
-# most restrictive replacements should come earlier.
+# Path replacements (most restrictive first)
 REPLACEMENTS = ("", pardir, "~")
-old_paths = [abspath(expanduser(replacement)) for replacement in REPLACEMENTS]
+OLD_PATHS = [abspath(expanduser(r)) for r in REPLACEMENTS]
 IS_WINDOWS = platform.system().lower() == "windows"
 
 
+def color(text: str, color_code: str) -> str:
+    """Wrap text in ANSI color codes."""
+    return f"{color_code}{text}{RESET}"
+
+
 def prettyprint_path(path: str, old_path: str, replacement: str) -> str:
-    # Pretty print the path prefix
+    """Replace path prefix and shorten remaining components to first char."""
     path = path.replace(old_path, replacement, 1)
-    # Truncate the rest of the path to a single character.
-    short_path = join(replacement, *[x[0] for x in PurePath(path).parts[1:]])
+    parts = PurePath(path).parts[1:]  # Skip the replacement prefix
+    short_path = join(replacement, *(p[0] for p in parts))
     return short_path
 
 
-def shorten(path: str):
-    """Returns 2 strings, the shortened parent directory and the filename."""
-    # We don't want to shorten the filename, just its parent directory, so we
-    # `split()` and just shorten `path`.
+def shorten(path: str) -> tuple[str, str]:
+    """Returns shortened parent directory and filename."""
     path, filename = split(path)
 
-    # use empty replacement for current directory. it expands correctly
-
-    for replacement, old_path in zip(REPLACEMENTS, old_paths):
+    for replacement, old_path in zip(REPLACEMENTS, OLD_PATHS):
         if path.startswith(old_path):
             short_path = prettyprint_path(path, old_path, replacement)
-            # to avoid multiple replacements
             break
-
-    # If no replacement was found, shorten the entire path.
     else:
-        short_path = join(*[x[0] for x in PurePath(path).parts])
+        # No replacement matched - shorten entire path
+        parts = PurePath(path).parts
+        short_path = join(*(p[0] for p in parts)) if parts else ""
 
     return short_path, filename
 
 
-GREEN = "\033[32m"
-PURPLE = "\033[35m"  # looks pink to me
-CYAN = "\033[36m"
-
-RESET = "\033[0m"
-
-# RED = '\033[31m'
-# BLUE = '\033[34m'
-# LIGHTRED = '\033[91m'
-# YELLOW = '\033[93m'
-# LIGHTBLUE = '\033[94m'
-# LIGHTCYAN = '\033[96m'
-
-
-def color(line, color):
-    return color + line + RESET
-
-
 def process_line(line: str) -> str:
-    # Expected format is colon separated `name:line number:contents`
-
+    """Process a single line from ripgrep output."""
+    # Handle Windows drive letters (e.g., C:\path)
     if IS_WINDOWS:
-        # Windows paths may contain a colon, e.g. C:\Windows\ which messes up the split
-        # splitdrive(string) results in the following:
-        #   Windows drive letter, e.g. C:\Windows\Folder\Foo.txt -> ('C', '\Windows\Folder\Foo.txt')
-        #   Windows UNC path, e.g. \\Server\Share\Folder\Foo.txt -> ('\\Server\Share', '\Folder\Foo.txt')
-        #   *nix, e.g. /any/path/to/file.txt -> ('', '/any/path/to/file.txt')
-        _, line = splitdrive(line)  #  Toss the drive letter since it's not necessary.
-    filename, linenum, contents = line.split(sep=":", maxsplit=2)
-
-    # Drop trailing newline.
+        _, line = splitdrive(line)
+
+    # Parse filename:linenum:contents
+    try:
+        filename, linenum, contents = line.split(sep=":", maxsplit=2)
+    except ValueError:
+        return line  # Return unchanged if format unexpected
+
     contents = contents.rstrip()
 
-    # Normalize path for further processing.
+    # Normalize path (skip on Windows to avoid prepending cwd)
     if not IS_WINDOWS:
-        # This prepends cwd in Windows which is unnecessary.
         filename = abspath(filename)
 
     shortened_parent, basename = shorten(filename)
-    # The conditional is to avoid a leading slash if the parent is replaced
-    # with an empty directory. The slash is manually colored because otherwise
-    # `os.path.join` won't do it.
+
+    # Build colored short name
     if shortened_parent:
-        colored_short_name = color(shortened_parent + sep, PURPLE) + color(
-            basename, CYAN
-        )
+        colored_short_name = color(shortened_parent + sep, PURPLE) + color(basename, CYAN)
     else:
         colored_short_name = color(basename, CYAN)
 
-    # Format is: long form, line number, short form, line number, rest of line. This is so Vim can process it.
-    formatted_line = ":".join(
-        [
-            color(filename, CYAN),
-            color(linenum, GREEN),
-            colored_short_name,
-            color(linenum, GREEN),
-            contents,
-        ]
-    )
-    return formatted_line
-
-    # We print the long and short forms, and one form is picked in the Vim script that uses this.
-    # print(formatted_line)
+    # Output format: long_path:linenum:short_path:linenum:contents
+    return ":".join([
+        color(filename, CYAN),
+        color(linenum, GREEN),
+        colored_short_name,
+        color(linenum, GREEN),
+        contents,
+    ])
 
 
-if __name__ == "__main__":
-    # Use stdin.buffer to handle binary data, then decode with error handling
-    # This prevents the script from crashing on files with non-UTF-8 content
-    for raw_line in stdin.buffer:
+def main() -> None:
+    """Read from stdin and process each line."""
+    for raw_line in sys.stdin.buffer:
         try:
             line = raw_line.decode("utf-8")
             print(process_line(line))
         except UnicodeDecodeError:
-            # Skip lines that can't be decoded as UTF-8 (e.g., binary files)
-            # Try latin-1 as fallback since it can decode any byte sequence
+            # Try latin-1 as fallback (can decode any byte sequence)
             try:
                 line = raw_line.decode("latin-1")
                 print(process_line(line))
             except Exception:
-                # If all else fails, skip this line entirely
-                pass
+                pass  # Skip completely malformed lines
         except Exception:
-            # Skip lines that cause other errors (malformed input, etc.)
-            pass
+            pass  # Skip lines that cause other errors
+
+
+if __name__ == "__main__":
+    main()