python-du 0.1.0__tar.gz

python_du-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,97 @@
+# python-du
+
+A disk usage analyzer that scans a directory and prints a visual tree map of folder sizes — right in your terminal.
+
+## Example
+
+```
+$ python-du /usr -d 2 -m 2
+usr  [60.2 GB]
+
+├── share                             27.4 GB ( 45.6%)  ▕█████████░░░░░░░░░░░▏
+│   └── ollama                            22.6 GB ( 37.5%)  ▕███████░░░░░░░░░░░░░▏
+│       └── .ollama                           22.6 GB ( 37.5%)  ▕███████░░░░░░░░░░░░░▏
+├── lib                               26.4 GB ( 43.8%)  ▕████████░░░░░░░░░░░░▏
+│   ├── x86_64-linux-gnu                  11.7 GB ( 19.3%)  ▕███░░░░░░░░░░░░░░░░░▏
+│   ├── arm-none-eabi                      2.7 GB (  4.5%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+│   ├── jvm                                2.1 GB (  3.5%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+│   ├── dotnet                             1.5 GB (  2.5%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+│   └── apache-netbeans                    1.3 GB (  2.2%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+├── local                              3.8 GB (  6.3%)  ▕█░░░░░░░░░░░░░░░░░░░▏
+│   └── lib                                3.2 GB (  5.3%)  ▕█░░░░░░░░░░░░░░░░░░░▏
+├── bin                                1.4 GB (  2.4%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+│   └── <files>                            1.4 GB (  2.4%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+└── <files>                           33.7 KB (  0.0%)  ▕░░░░░░░░░░░░░░░░░░░░▏
+
+Total: 60.2 GB  |  46966 directories, 390046 files
+```
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```bash
+python-du [path] [options]
+```
+
+If no path is given, the current directory is scanned.
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-d`, `--max-depth N` | Maximum tree depth to display (default: 4) |
+| `-m`, `--min-percent N` | Hide entries smaller than N% of total (default: 0.5) |
+| `--no-color` | Disable colored output |
+| `--sort-alpha` | Sort alphabetically instead of by size |
+| `--scan-depth N` | Limit how deep the filesystem scan goes (default: unlimited) |
+| `-L`, `--follow-symlinks` | Follow symbolic links |
+
+### Examples
+
+Scan the current directory with defaults:
+
+```bash
+python-du
+```
+
+Scan `/var/log` showing only entries above 5%, two levels deep:
+
+```bash
+python-du /var/log -d 2 -m 5
+```
+
+Pipe to a file (automatically disables color):
+
+```bash
+python-du /home > usage-report.txt
+```
+
+## Publishing to PyPI
+
+```
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+When prompted, use `__token__` as the username and your PyPI API token as the password.
+
+To skip the prompt, create a `~/.pypirc` file:
+
+```ini
+[pypi]
+username = __token__
+password = pypi-YOUR-TOKEN-HERE
+```
+
+> **Note:** Bump the `version` in `pyproject.toml` before each upload — PyPI rejects duplicate version numbers.
+
+## Requirements
+
+- Python >= 3.9
+- No external dependencies

python_du-0.1.0/pyproject.toml

@@ -0,0 +1,12 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-du"
+version = "0.1.0"
+description = "A disk usage analyzer that prints a visual map of folder sizes"
+requires-python = ">=3.9"
+
+[project.scripts]
+python-du = "python_du.cli:main"

python_du-0.1.0/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-0.1.0/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-0.1.0/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/python_du.egg-info/PKG-INFO

@@ -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/python_du.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+python_du/__init__.py
+python_du/cli.py
+python_du/renderer.py
+python_du/scanner.py
+python_du.egg-info/PKG-INFO
+python_du.egg-info/SOURCES.txt
+python_du.egg-info/dependency_links.txt
+python_du.egg-info/entry_points.txt
+python_du.egg-info/top_level.txt

python_du-0.1.0/python_du.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

python_du-0.1.0/python_du.egg-info/entry_points.txt

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

python_du-0.1.0/python_du.egg-info/top_level.txt

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

python_du-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+