python-du 0.1.0__py3-none-any.whl

python_du/cli.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .renderer import RenderConfig, render_tree
+from .scanner import scan
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="python-du",
+        description="Disk usage analyzer — scan a directory and print a visual size map.",
+    )
+    parser.add_argument(
+        "path",
+        nargs="?",
+        default=".",
+        help="directory to scan (default: current directory)",
+    )
+    parser.add_argument(
+        "-d",
+        "--max-depth",
+        type=int,
+        default=4,
+        help="maximum depth to display (default: 4)",
+    )
+    parser.add_argument(
+        "-m",
+        "--min-percent",
+        type=float,
+        default=0.5,
+        help="hide entries smaller than this percentage (default: 0.5)",
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="disable colored output",
+    )
+    parser.add_argument(
+        "--sort-alpha",
+        action="store_true",
+        help="sort entries alphabetically instead of by size",
+    )
+    parser.add_argument(
+        "--scan-depth",
+        type=int,
+        default=None,
+        help="maximum directory depth to scan (default: unlimited)",
+    )
+    parser.add_argument(
+        "-L",
+        "--follow-symlinks",
+        action="store_true",
+        help="follow symbolic links",
+    )
+
+    args = parser.parse_args(argv)
+    target = Path(args.path)
+
+    if not target.exists():
+        print(f"python-du: error: '{target}' does not exist", file=sys.stderr)
+        sys.exit(1)
+    if not target.is_dir():
+        print(f"python-du: error: '{target}' is not a directory", file=sys.stderr)
+        sys.exit(1)
+
+    tree = scan(target, max_depth=args.scan_depth, follow_symlinks=args.follow_symlinks)
+
+    config = RenderConfig(
+        max_depth=args.max_depth,
+        min_percent=args.min_percent,
+        use_color=not args.no_color and sys.stdout.isatty(),
+        sort_by_size=not args.sort_alpha,
+    )
+
+    print(render_tree(tree, config))
+
+
+if __name__ == "__main__":
+    main()

python_du/renderer.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import shutil
+from dataclasses import dataclass
+
+from .scanner import DirNode
+
+BLOCK_CHARS = " ░▒▓█"
+BAR_COLORS = {
+    "red": "\033[91m",
+    "yellow": "\033[93m",
+    "green": "\033[92m",
+    "cyan": "\033[96m",
+    "blue": "\033[94m",
+    "magenta": "\033[95m",
+    "white": "\033[97m",
+}
+RESET = "\033[0m"
+DIM = "\033[2m"
+BOLD = "\033[1m"
+
+PALETTE = ["blue", "cyan", "green", "yellow", "magenta", "red"]
+
+TREE_PIPE = "│   "
+TREE_TEE = "├── "
+TREE_BEND = "└── "
+TREE_BLANK = "    "
+
+
+def format_size(size: int) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(size) < 1024:
+            if unit == "B":
+                return f"{size} B"
+            return f"{size:.1f} {unit}"
+        size /= 1024  # type: ignore[assignment]
+    return f"{size:.1f} PB"
+
+
+@dataclass
+class RenderConfig:
+    max_depth: int = 4
+    min_percent: float = 0.5
+    bar_width: int | None = None  # auto-detect from terminal
+    use_color: bool = True
+    sort_by_size: bool = True
+    show_percent: bool = True
+
+
+def render_tree(root: DirNode, config: RenderConfig | None = None) -> str:
+    cfg = config or RenderConfig()
+    term_width = shutil.get_terminal_size((80, 24)).columns
+    bar_width = cfg.bar_width or max(20, min(50, term_width - 60))
+    lines: list[str] = []
+
+    total = root.total_size or 1
+
+    header = f"{BOLD}{root.name}{RESET}" if cfg.use_color else root.name
+    lines.append(f"{header}  [{format_size(root.total_size)}]")
+    lines.append("")
+
+    _render_node(root, lines, cfg, bar_width, total, prefix="", depth=0, color_idx=0)
+
+    lines.append("")
+    lines.append(_summary_line(root, cfg))
+    return "\n".join(lines)
+
+
+def _render_node(
+    node: DirNode,
+    lines: list[str],
+    cfg: RenderConfig,
+    bar_width: int,
+    root_total: int,
+    prefix: str,
+    depth: int,
+    color_idx: int,
+) -> None:
+    children = node.children
+    if cfg.sort_by_size:
+        children = sorted(children, key=lambda c: c.total_size, reverse=True)
+
+    own_files_size = node.own_size
+    entries: list[tuple[str, int, DirNode | None]] = []
+    for child in children:
+        pct = (child.total_size / root_total * 100) if root_total else 0
+        if pct >= cfg.min_percent or depth < 1:
+            entries.append((child.name, child.total_size, child))
+
+    if own_files_size > 0:
+        pct = (own_files_size / root_total * 100) if root_total else 0
+        if pct >= cfg.min_percent or depth < 1:
+            entries.append(("<files>", own_files_size, None))
+
+    for i, (name, size, child_node) in enumerate(entries):
+        is_last = i == len(entries) - 1
+        connector = TREE_BEND if is_last else TREE_TEE
+        child_prefix = TREE_BLANK if is_last else TREE_PIPE
+
+        pct = (size / root_total * 100) if root_total else 0
+        bar = _make_bar(pct, bar_width, PALETTE[(color_idx + i) % len(PALETTE)], cfg.use_color)
+
+        size_str = format_size(size)
+        pct_str = f" ({pct:5.1f}%)" if cfg.show_percent else ""
+
+        if cfg.use_color and child_node is None:
+            name_str = f"{DIM}{name}{RESET}"
+        elif cfg.use_color:
+            name_str = name
+        else:
+            name_str = name
+
+        lines.append(f"{prefix}{connector}{name_str:<30s} {size_str:>10s}{pct_str}  {bar}")
+
+        if child_node and depth < cfg.max_depth:
+            _render_node(
+                child_node,
+                lines,
+                cfg,
+                bar_width,
+                root_total,
+                prefix=prefix + child_prefix,
+                depth=depth + 1,
+                color_idx=color_idx + i,
+            )
+
+
+def _make_bar(pct: float, width: int, color: str, use_color: bool) -> str:
+    filled = int(pct / 100 * width)
+    filled = max(0, min(filled, width))
+
+    if use_color:
+        c = BAR_COLORS.get(color, "")
+        bar = f"{c}{'█' * filled}{RESET}{'░' * (width - filled)}"
+    else:
+        bar = "█" * filled + "░" * (width - filled)
+    return f"▕{bar}▏"
+
+
+def _summary_line(root: DirNode, cfg: RenderConfig) -> str:
+    total_files = _count_files(root)
+    total_dirs = _count_dirs(root)
+    size_str = format_size(root.total_size)
+    summary = f"Total: {size_str}  |  {total_dirs} directories, {total_files} files"
+    if cfg.use_color:
+        return f"{DIM}{summary}{RESET}"
+    return summary
+
+
+def _count_files(node: DirNode) -> int:
+    return node.file_count + sum(_count_files(c) for c in node.children)
+
+
+def _count_dirs(node: DirNode) -> int:
+    return len(node.children) + sum(_count_dirs(c) for c in node.children)

python_du/scanner.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class DirNode:
+    """Represents a directory and its computed disk usage."""
+
+    path: Path
+    own_size: int = 0  # size of files directly in this dir
+    total_size: int = 0  # recursive total including children
+    children: list[DirNode] = field(default_factory=list)
+    file_count: int = 0
+    error: str | None = None
+
+    @property
+    def name(self) -> str:
+        return self.path.name or str(self.path)
+
+
+def scan(root: Path, *, max_depth: int | None = None, follow_symlinks: bool = False) -> DirNode:
+    """Walk *root* and return a tree of DirNode objects with computed sizes."""
+    return _scan_dir(root.resolve(), depth=0, max_depth=max_depth, follow_symlinks=follow_symlinks)
+
+
+def _scan_dir(
+    path: Path,
+    *,
+    depth: int,
+    max_depth: int | None,
+    follow_symlinks: bool,
+) -> DirNode:
+    node = DirNode(path=path)
+
+    try:
+        entries = sorted(os.scandir(path), key=lambda e: e.name)
+    except PermissionError:
+        node.error = "permission denied"
+        return node
+    except OSError as exc:
+        node.error = str(exc)
+        return node
+
+    for entry in entries:
+        try:
+            if entry.is_symlink() and not follow_symlinks:
+                continue
+
+            if entry.is_file(follow_symlinks=follow_symlinks):
+                try:
+                    node.own_size += entry.stat(follow_symlinks=follow_symlinks).st_size
+                    node.file_count += 1
+                except OSError:
+                    pass
+
+            elif entry.is_dir(follow_symlinks=follow_symlinks):
+                if max_depth is not None and depth >= max_depth:
+                    child = _shallow_size(Path(entry.path))
+                else:
+                    child = _scan_dir(
+                        Path(entry.path),
+                        depth=depth + 1,
+                        max_depth=max_depth,
+                        follow_symlinks=follow_symlinks,
+                    )
+                node.children.append(child)
+        except OSError:
+            pass
+
+    node.total_size = node.own_size + sum(c.total_size for c in node.children)
+    return node
+
+
+def _shallow_size(path: Path) -> DirNode:
+    """Get total size of a directory without building a child tree."""
+    node = DirNode(path=path)
+    total = 0
+    fcount = 0
+    try:
+        for dirpath, _dirnames, filenames in os.walk(path):
+            for fname in filenames:
+                try:
+                    total += os.path.getsize(os.path.join(dirpath, fname))
+                    fcount += 1
+                except OSError:
+                    pass
+    except PermissionError:
+        node.error = "permission denied"
+    node.own_size = total
+    node.total_size = total
+    node.file_count = fcount
+    return node

python_du-0.1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: python-du
+Version: 0.1.0
+Summary: A disk usage analyzer that prints a visual map of folder sizes
+Requires-Python: >=3.9

python_du-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+python_du/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_du/cli.py,sha256=0dY0IorPKHsqG7mPhF9ElXEqnZeX868HmTij6v7APZ0,2144
+python_du/renderer.py,sha256=grBwc1TCVRaTRG2NFU4I-9yyIYasV7Q6GZDhoKL5HQ0,4589
+python_du/scanner.py,sha256=nmfI8bL9_OzOST44_pN-BlZ3XkNWBQ5aDRNm4DMaPS8,2882
+python_du-0.1.0.dist-info/METADATA,sha256=d06m7hakzgKnzo3TyLgw2dy0eWe6R3CF5ZglaH-D8sM,148
+python_du-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+python_du-0.1.0.dist-info/entry_points.txt,sha256=m8Km0ZaanWCYWdBPcLTC3XREnJtG-CwE95yKdAli9kw,49
+python_du-0.1.0.dist-info/top_level.txt,sha256=PLwVAljOX1Zv_ACc2YSYHmL7MhJ_szkcvz7XyY2StKc,10
+python_du-0.1.0.dist-info/RECORD,,

python_du-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_du-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+python-du = python_du.cli:main

python_du-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+python_du