ptdu 0.1.0__py3-none-any.whl

ptdu/fonts.py

@@ -0,0 +1,237 @@
+"""Font configuration utility for PTDU.
+
+Provides OS-aware font detection and configuration.
+"""
+
+from __future__ import annotations
+
+import sys
+import tkinter as tk
+from tkinter import font as tkfont
+from typing import Literal, Optional
+
+
+class FontManager:
+    """Manages font detection and configuration for different operating systems."""
+
+    # Font size recommendations (increased for better readability)
+    BASE_SIZE: int = 13
+    HEADING_SIZE: int = 12
+    STATUS_SIZE: int = 12
+
+    # Font size adjustment
+    SIZE_STEP: int = 1
+    MIN_SIZE: int = 8
+    MAX_SIZE: int = 20
+
+    # OS-specific font preferences (prioritize cleaner, more modern fonts)
+    LINUX_FONTS: tuple[str, ...] = (
+        "Ubuntu",  # Clean, modern, highly readable
+        "Noto Sans",  # Google's unified font, very readable
+        "DejaVu Sans",  # Widely available, clean
+        "Cantarell",  # GNOME's default, modern
+        "Liberation Sans",  # Metric-compatible with Arial
+    )
+    MACOS_FONTS: tuple[str, ...] = (".SF NS", "Helvetica Neue", "Helvetica", "Arial")
+    WINDOWS_FONTS: tuple[str, ...] = ("Segoe UI", "Tahoma", "Arial")
+
+    def __init__(self, root: Optional[tk.Tk] = None) -> None:
+        """Initialize the font manager.
+
+        Args:
+            root: Tk root window for font querying
+        """
+        self._root: Optional[tk.Tk] = root
+        self._family: Optional[str] = None
+        self._fonts: dict[str, tkfont.Font] = {}
+
+    def _get_available_fonts(self) -> set[str]:
+        """Get set of available font families on the system.
+
+        Returns:
+            Set of available font family names
+        """
+        if self._root is None:
+            # Create temporary root for font querying if needed
+            temp_root = tk.Tk()
+            temp_root.withdraw()
+            families = set(tkfont.families(temp_root))
+            temp_root.destroy()
+        else:
+            families = set(tkfont.families(self._root))
+
+        return families
+
+    def detect_font_family(self) -> str:
+        """Detect the best available font family for the current OS.
+
+        Returns:
+            Font family name
+        """
+        available = self._get_available_fonts()
+        system = sys.platform
+
+        if system == "darwin":  # macOS
+            preferences = self.MACOS_FONTS
+        elif system == "win32":  # Windows
+            preferences = self.WINDOWS_FONTS
+        else:  # Linux and others
+            preferences = self.LINUX_FONTS
+
+        # Find first available preferred font
+        for family in preferences:
+            if family in available:
+                self._family = family
+                return family
+
+        # Fallback to TkDefaultFont
+        self._family = "TkDefaultFont"
+        return self._family
+
+    def get_family(self) -> str:
+        """Get the detected or default font family.
+
+        Returns:
+            Font family name
+        """
+        if self._family is None:
+            return self.detect_font_family()
+        return self._family
+
+    def get_font(
+        self,
+        name: str,
+        size: Optional[int] = None,
+        weight: Literal["normal", "bold"] = "normal",
+        slant: Literal["roman", "italic"] = "roman",
+    ) -> tkfont.Font:
+        """Get or create a named font configuration.
+
+        Args:
+            name: Font configuration name (e.g., 'treeview', 'heading', 'status')
+            size: Font size in points (uses default if None)
+            weight: Font weight ('normal', 'bold')
+            slant: Font slant ('roman', 'italic')
+
+        Returns:
+            Configured tkinter Font object
+        """
+        if name in self._fonts:
+            return self._fonts[name]
+
+        family = self.get_family()
+        actual_size = size if size is not None else self.BASE_SIZE
+
+        font = tkfont.Font(family=family, size=actual_size, weight=weight, slant=slant)
+        self._fonts[name] = font
+
+        return font
+
+    def get_treeview_font(self) -> tkfont.Font:
+        """Get font for treeview items.
+
+        Returns:
+            Font for treeview content
+        """
+        return self.get_font("treeview", size=self.BASE_SIZE)
+
+    def get_heading_font(self) -> tkfont.Font:
+        """Get font for treeview headings.
+
+        Returns:
+            Font for column headings
+        """
+        return self.get_font("heading", size=self.HEADING_SIZE, weight="bold")
+
+    def get_status_font(self) -> tkfont.Font:
+        """Get font for status bar.
+
+        Returns:
+            Font for status bar text
+        """
+        return self.get_font("status", size=self.STATUS_SIZE)
+
+    def get_directory_font(self) -> tkfont.Font:
+        """Get font for directory entries (bold).
+
+        Returns:
+            Font for directory names
+        """
+        return self.get_font("directory", size=self.BASE_SIZE, weight="bold")
+
+    def get_file_font(self) -> tkfont.Font:
+        """Get font for file entries.
+
+        Returns:
+            Font for file names
+        """
+        return self.get_font("file", size=self.BASE_SIZE)
+
+    def update_font_sizes(self, base_size: int) -> None:
+        """Update all font sizes relative to new base size.
+
+        Args:
+            base_size: New base font size
+        """
+        self.BASE_SIZE = base_size
+        self.HEADING_SIZE = base_size - 1
+        self.STATUS_SIZE = base_size - 1
+
+        # Recreate fonts with new sizes
+        for name, font in self._fonts.items():
+            if name == "heading":
+                font.configure(size=self.HEADING_SIZE)
+            elif name == "status":
+                font.configure(size=self.STATUS_SIZE)
+            else:
+                font.configure(size=self.BASE_SIZE)
+
+    def measure_text_width(self, text: str, font_name: str = "treeview") -> int:
+        """Measure the pixel width of text.
+
+        Args:
+            text: Text to measure
+            font_name: Name of font to use
+
+        Returns:
+            Width in pixels
+        """
+        font = self.get_font(font_name)
+        return font.measure(text)
+
+    def increase_font_size(self) -> int:
+        """Increase all font sizes by SIZE_STEP.
+
+        Returns:
+            New base font size
+        """
+        new_size = min(self.BASE_SIZE + self.SIZE_STEP, self.MAX_SIZE)
+        self.update_font_sizes(new_size)
+        return new_size
+
+    def decrease_font_size(self) -> int:
+        """Decrease all font sizes by SIZE_STEP.
+
+        Returns:
+            New base font size
+        """
+        new_size = max(self.BASE_SIZE - self.SIZE_STEP, self.MIN_SIZE)
+        self.update_font_sizes(new_size)
+        return new_size
+
+    def reset_font_size(self) -> int:
+        """Reset font sizes to default.
+
+        Returns:
+            New base font size
+        """
+        self.update_font_sizes(13)
+        return 13
+
+    def get_font_size(self) -> int:
+        """Get current base font size.
+
+        Returns:
+            Current base font size
+        """
+        return self.BASE_SIZE

ptdu/main.py

@@ -0,0 +1,118 @@
+"""Entry point for PTDU application."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from ptdu.cache import ScanCache
+from ptdu.scanner import Scanner
+from ptdu.ui import MainWindow
+
+
+def create_argument_parser() -> argparse.ArgumentParser:
+    """Create and configure the argument parser."""
+    parser = argparse.ArgumentParser(
+        prog="ptdu",
+        description="Python Tkinter Disk Usage analyzer - A graphical disk usage tool",
+        epilog="Keyboard shortcuts: j/k=navigate, h/l=expand/collapse, q=quit, r=rescan, d=delete",
+    )
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        type=Path,
+        help="Directory to analyze (default: current directory)",
+    )
+    parser.add_argument(
+        "--follow-symlinks",
+        action="store_true",
+        help="Follow symbolic links when scanning",
+    )
+    parser.add_argument(
+        "--exclude",
+        "-e",
+        action="append",
+        default=[],
+        help="Additional patterns to exclude (can be used multiple times)",
+    )
+    parser.add_argument(
+        "--max-depth",
+        "-d",
+        type=int,
+        default=None,
+        help="Maximum scan depth (default: unlimited)",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        help="Disable SQLite caching",
+    )
+    parser.add_argument(
+        "--clear-cache",
+        action="store_true",
+        help="Clear cache before starting",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s 0.1.0",
+    )
+    return parser
+
+
+def validate_path(path: Path) -> Path:
+    """Validate that the provided path exists and is a directory."""
+    if not path.exists():
+        raise SystemExit(f"Error: Path does not exist: {path}")
+    if not path.is_dir():
+        raise SystemExit(f"Error: Path is not a directory: {path}")
+    return path.resolve()
+
+
+def main() -> int:
+    """Main entry point for the PTDU application."""
+    parser = create_argument_parser()
+    args = parser.parse_args()
+
+    try:
+        target_path = validate_path(args.path)
+    except SystemExit as e:
+        print(str(e), file=sys.stderr)
+        return 1
+
+    # Handle cache
+    cache: ScanCache | None = None
+    if not args.no_cache:
+        cache = ScanCache()
+        if args.clear_cache:
+            cache.clear()
+            print("Cache cleared.")
+
+    # Convert exclude list to tuple
+    exclude_patterns = tuple(args.exclude) if args.exclude else None
+
+    # Create scanner with all options
+    scanner = Scanner(
+        follow_symlinks=args.follow_symlinks,
+        exclude_patterns=exclude_patterns,
+        cache=cache,
+    )
+
+    # Create main window and set scanner
+    window = MainWindow()
+    window.set_scanner(scanner)
+
+    # Set max depth if specified
+    if args.max_depth is not None:
+        window.set_max_depth(args.max_depth)
+
+    # Start background scan of initial directory
+    window.start_background_scan(target_path)
+
+    # Run the application
+    window.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ptdu/models.py

@@ -0,0 +1,130 @@
+"""Data models for PTDU directory structure."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+
+class DirNode:
+    """Represents a file or directory node in the tree structure."""
+
+    def __init__(
+        self,
+        path: Path,
+        name: str,
+        is_dir: bool,
+        parent: Optional[DirNode] = None,
+    ) -> None:
+        """Initialize a directory node.
+
+        Args:
+            path: Full filesystem path
+            name: Display name
+            is_dir: Whether this is a directory
+            parent: Reference to parent node (None for root)
+        """
+        self.path: Path = path
+        self.name: str = name
+        self.size: int = 0
+        self.children: dict[str, DirNode] = {}
+        self.parent: Optional[DirNode] = parent
+        self.is_dir: bool = is_dir
+        self.is_expanded: bool = False
+        self._is_loaded: bool = False
+
+    def get_size(self) -> int:
+        """Get the total size of this node.
+
+        For directories, returns the cached size.
+        For files, returns the file size.
+
+        Returns:
+            Size in bytes
+        """
+        return self.size
+
+    def add_child(self, node: DirNode) -> None:
+        """Add a child node to this directory.
+
+        Args:
+            node: The child node to add
+
+        Raises:
+            ValueError: If this node is not a directory
+        """
+        if not self.is_dir:
+            raise ValueError(f"Cannot add child to file: {self.name}")
+
+        self.children[node.name] = node
+        node.parent = self
+
+    def remove_child(self, name: str) -> Optional[DirNode]:
+        """Remove a child node by name.
+
+        Args:
+            name: Name of the child to remove
+
+        Returns:
+            The removed node or None if not found
+
+        Raises:
+            ValueError: If this node is not a directory
+        """
+        if not self.is_dir:
+            raise ValueError(f"Cannot remove child from file: {self.name}")
+
+        node = self.children.pop(name, None)
+        if node is not None:
+            node.parent = None
+        return node
+
+    def get_child(self, name: str) -> Optional[DirNode]:
+        """Get a child node by name.
+
+        Args:
+            name: Name of the child to get
+
+        Returns:
+            The child node or None if not found
+        """
+        return self.children.get(name)
+
+    def set_size(self, size: int) -> None:
+        """Set the size of this node and propagate to parents.
+
+        Args:
+            size: New size in bytes
+        """
+        old_size = self.size
+        self.size = size
+
+        # Propagate size change to parent
+        if self.parent is not None:
+            size_diff = size - old_size
+            self.parent.size += size_diff
+
+    def mark_loaded(self) -> None:
+        """Mark this directory as having been scanned."""
+        self._is_loaded = True
+
+    def is_loaded(self) -> bool:
+        """Check if this directory has been scanned.
+
+        Returns:
+            True if the directory has been loaded
+        """
+        return self._is_loaded
+
+    def get_item_count(self) -> int:
+        """Get the number of children.
+
+        Returns:
+            Number of children (0 for files)
+        """
+        return len(self.children)
+
+    def __repr__(self) -> str:
+        """Return string representation."""
+        node_type = "dir" if self.is_dir else "file"
+        return f"DirNode({node_type}: {self.name}, size={self.size})"