dupegun 1.0.0__tar.gz

dupegun-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Prasanna B
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dupegun-1.0.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: dupegun
+Version: 1.0.0
+Summary: Cross-platform duplicate file finder and cleaner
+License: MIT License
+        
+        Copyright (c) 2025 Prasanna B
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: duplicate,files,cli,disk,cleaner
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# dupegun
+
+Fast cross-platform duplicate file finder and cleaner for Windows, Linux and macOS.
+
+## Install
+
+```bash
+pip install dupegun
+```
+
+## Commands
+
+```bash
+# Find duplicates
+dupegun scan ~/Downloads
+
+# Skip files under 1 MB
+dupegun scan ~/Downloads --min-size 1000000
+
+# Scan multiple folders
+dupegun scan ~/Downloads ~/Documents ~/Desktop
+
+# Export to JSON
+dupegun scan ~/Downloads --json results.json
+
+# Export to CSV
+dupegun scan ~/Downloads --csv results.csv
+
+# Preview what would be deleted (safe)
+dupegun delete ~/Downloads --strategy newest
+
+# Actually delete
+dupegun delete ~/Downloads --strategy newest --no-dry-run
+
+# Confirm each group before deleting
+dupegun delete ~/Downloads --no-dry-run --interactive
+
+# Move duplicates to quarantine
+dupegun move ~/Downloads --dest ~/quarantine --no-dry-run
+
+# Replace duplicates with hard links
+dupegun hardlink ~/Downloads --no-dry-run
+```
+
+## Strategies
+
+| Flag | Keeps |
+|---|---|
+| `--strategy shortest` | Shortest file path (default) |
+| `--strategy newest` | Most recently modified copy |
+| `--strategy oldest` | Oldest copy |
+
+## Features
+
+- Works on Windows, Linux, macOS
+- All file types supported
+- 3-pass engine (size → partial hash → full SHA-256)
+- Colored terminal output
+- Dry-run on by default (safe)
+- JSON and CSV export
+- Hard link support
+
+## License
+
+MIT

dupegun-1.0.0/README.md

@@ -0,0 +1,65 @@
+# dupegun
+
+Fast cross-platform duplicate file finder and cleaner for Windows, Linux and macOS.
+
+## Install
+
+```bash
+pip install dupegun
+```
+
+## Commands
+
+```bash
+# Find duplicates
+dupegun scan ~/Downloads
+
+# Skip files under 1 MB
+dupegun scan ~/Downloads --min-size 1000000
+
+# Scan multiple folders
+dupegun scan ~/Downloads ~/Documents ~/Desktop
+
+# Export to JSON
+dupegun scan ~/Downloads --json results.json
+
+# Export to CSV
+dupegun scan ~/Downloads --csv results.csv
+
+# Preview what would be deleted (safe)
+dupegun delete ~/Downloads --strategy newest
+
+# Actually delete
+dupegun delete ~/Downloads --strategy newest --no-dry-run
+
+# Confirm each group before deleting
+dupegun delete ~/Downloads --no-dry-run --interactive
+
+# Move duplicates to quarantine
+dupegun move ~/Downloads --dest ~/quarantine --no-dry-run
+
+# Replace duplicates with hard links
+dupegun hardlink ~/Downloads --no-dry-run
+```
+
+## Strategies
+
+| Flag | Keeps |
+|---|---|
+| `--strategy shortest` | Shortest file path (default) |
+| `--strategy newest` | Most recently modified copy |
+| `--strategy oldest` | Oldest copy |
+
+## Features
+
+- Works on Windows, Linux, macOS
+- All file types supported
+- 3-pass engine (size → partial hash → full SHA-256)
+- Colored terminal output
+- Dry-run on by default (safe)
+- JSON and CSV export
+- Hard link support
+
+## License
+
+MIT

dupegun-1.0.0/dupegun/actions.py

@@ -0,0 +1,103 @@
+import os
+import shutil
+from pathlib import Path
+from rich.console import Console
+from rich.prompt import Confirm
+from .reporter import human_size
+
+console = Console()
+
+def pick_keeper(paths: list, strategy: str) -> Path:
+    if strategy == "newest":
+        return max(paths, key=lambda p: p.stat().st_mtime)
+    if strategy == "oldest":
+        return min(paths, key=lambda p: p.stat().st_mtime)
+    if strategy == "shortest":
+        return min(paths, key=lambda p: len(str(p)))
+    return paths[0]
+
+def delete_dupes(
+    groups: dict,
+    strategy: str = "shortest",
+    dry_run: bool = True,
+    interactive: bool = False,
+) -> None:
+    total_freed = 0
+
+    for hash_val, paths in groups.items():
+        keeper = pick_keeper(paths, strategy)
+        to_delete = [p for p in paths if p != keeper]
+
+        console.print(f"\n[bold]Keep:[/bold]   [green]{keeper}[/green]")
+        for p in to_delete:
+            console.print(f"[bold]Delete:[/bold] [red]{p}[/red]")
+
+        if interactive:
+            if not Confirm.ask("  Proceed with this group?"):
+                continue
+
+        for p in to_delete:
+            size = p.stat().st_size
+            if dry_run:
+                console.print(f"  [dim][DRY RUN] would delete {p}[/dim]")
+            else:
+                try:
+                    p.unlink()
+                    total_freed += size
+                    console.print(f"  [red]Deleted {p}[/red]")
+                except OSError as e:
+                    console.print(f"  [yellow]Error: {e}[/yellow]")
+
+    if not dry_run:
+        console.print(
+            f"\n[bold green]Freed {human_size(total_freed)}[/bold green]"
+        )
+
+def move_dupes(
+    groups: dict,
+    dest: Path,
+    strategy: str = "shortest",
+    dry_run: bool = True,
+) -> None:
+    dest.mkdir(parents=True, exist_ok=True)
+
+    for hash_val, paths in groups.items():
+        keeper = pick_keeper(paths, strategy)
+        for p in paths:
+            if p == keeper:
+                continue
+            target = dest / p.name
+            if target.exists():
+                target = dest / f"{hash_val[:8]}_{p.name}"
+
+            if dry_run:
+                console.print(
+                    f"[dim][DRY RUN] would move {p} → {target}[/dim]"
+                )
+            else:
+                shutil.move(str(p), str(target))
+                console.print(f"[yellow]Moved {p} → {target}[/yellow]")
+
+def hardlink_dupes(
+    groups: dict,
+    strategy: str = "shortest",
+    dry_run: bool = True,
+) -> None:
+    for hash_val, paths in groups.items():
+        keeper = pick_keeper(paths, strategy)
+        for p in paths:
+            if p == keeper:
+                continue
+            if dry_run:
+                console.print(
+                    f"[dim][DRY RUN] would hardlink {p} → {keeper}[/dim]"
+                )
+            else:
+                try:
+                    p.unlink()
+                    os.link(keeper, p)
+                    console.print(
+                        f"[cyan]Hardlinked {p} → {keeper}[/cyan]"
+                    )
+                except OSError as e:
+                    console.print(f"[yellow]Error: {e}[/yellow]")

dupegun-1.0.0/dupegun/cli.py

@@ -0,0 +1,145 @@
+import click
+from pathlib import Path
+from rich.console import Console
+from rich.progress import (
+    Progress, SpinnerColumn,
+    TextColumn, BarColumn, TaskProgressColumn
+)
+
+from .scanner import find_duplicates
+from .reporter import print_table, export_json, export_csv
+from .actions import delete_dupes, move_dupes, hardlink_dupes
+
+console = Console()
+
+def _scan(paths, min_size):
+    roots = [Path(p) for p in paths]
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        transient=True,
+    ) as progress:
+        task = progress.add_task("Scanning...", total=None)
+        def cb(done, total, path):
+            progress.update(
+                task, completed=done, total=total,
+                description=f"Hashing [cyan]{path.name}[/cyan]"
+            )
+        groups = find_duplicates(roots, min_size=min_size, progress_cb=cb)
+    return groups
+
+@click.group()
+@click.version_option("1.0.0", prog_name="dupegun")
+def main():
+    """dupegun — find and destroy duplicate files.
+
+    Works on Windows, Linux and macOS. All file types supported.
+    """
+    pass
+
+@main.command()
+@click.argument("paths", nargs=-1, required=True,
+                type=click.Path(exists=True))
+@click.option("--min-size", default=1,
+              help="Minimum file size in bytes to scan (default: 1)")
+@click.option("--json", "out_json", default=None,
+              help="Export results to a JSON file")
+@click.option("--csv", "out_csv", default=None,
+              help="Export results to a CSV file")
+def scan(paths, min_size, out_json, out_csv):
+    """Scan folders and list all duplicate files."""
+    console.print(f"\n[bold]dupegun[/bold] — scanning {len(paths)} path(s)...\n")
+    groups = _scan(paths, min_size)
+
+    if not groups:
+        console.print("[bold green]No duplicates found![/bold green]")
+        return
+
+    print_table(groups)
+
+    if out_json:
+        export_json(groups, out_json)
+    if out_csv:
+        export_csv(groups, out_csv)
+
+@main.command()
+@click.argument("paths", nargs=-1, required=True,
+                type=click.Path(exists=True))
+@click.option("--strategy", default="shortest",
+              type=click.Choice(["shortest", "newest", "oldest"]),
+              help="Which copy to keep (default: shortest path)")
+@click.option("--dry-run/--no-dry-run", default=True,
+              help="Preview without deleting (default: ON)")
+@click.option("--interactive", is_flag=True,
+              help="Confirm each group before deleting")
+@click.option("--min-size", default=1)
+def delete(paths, strategy, dry_run, interactive, min_size):
+    """Delete duplicates, keeping one copy per group."""
+    groups = _scan(paths, min_size)
+
+    if not groups:
+        console.print("[bold green]No duplicates found![/bold green]")
+        return
+
+    if dry_run:
+        console.print(
+            "[yellow]DRY RUN — nothing will be deleted. "
+            "Use --no-dry-run to actually delete.[/yellow]\n"
+        )
+
+    delete_dupes(
+        groups,
+        strategy=strategy,
+        dry_run=dry_run,
+        interactive=interactive
+    )
+
+@main.command()
+@click.argument("paths", nargs=-1, required=True,
+                type=click.Path(exists=True))
+@click.option("--dest", required=True,
+              help="Destination folder to move duplicates into")
+@click.option("--strategy", default="shortest",
+              type=click.Choice(["shortest", "newest", "oldest"]))
+@click.option("--dry-run/--no-dry-run", default=True)
+@click.option("--min-size", default=1)
+def move(paths, dest, strategy, dry_run, min_size):
+    """Move duplicates to a quarantine folder instead of deleting."""
+    groups = _scan(paths, min_size)
+
+    if not groups:
+        console.print("[bold green]No duplicates found![/bold green]")
+        return
+
+    if dry_run:
+        console.print(
+            "[yellow]DRY RUN — nothing will be moved. "
+            "Use --no-dry-run to actually move.[/yellow]\n"
+        )
+
+    move_dupes(groups, Path(dest), strategy=strategy, dry_run=dry_run)
+
+@main.command()
+@click.argument("paths", nargs=-1, required=True,
+                type=click.Path(exists=True))
+@click.option("--strategy", default="shortest",
+              type=click.Choice(["shortest", "newest", "oldest"]))
+@click.option("--dry-run/--no-dry-run", default=True)
+@click.option("--min-size", default=1)
+def hardlink(paths, strategy, dry_run, min_size):
+    """Replace duplicates with hard links to save space."""
+    groups = _scan(paths, min_size)
+
+    if not groups:
+        console.print("[bold green]No duplicates found![/bold green]")
+        return
+
+    if dry_run:
+        console.print(
+            "[yellow]DRY RUN — nothing will be changed. "
+            "Use --no-dry-run to actually hardlink.[/yellow]\n"
+        )
+
+    hardlink_dupes(groups, strategy=strategy, dry_run=dry_run)

dupegun-1.0.0/dupegun/reporter.py

@@ -0,0 +1,75 @@
+import json
+import csv
+import datetime
+from pathlib import Path
+from rich.table import Table
+from rich.console import Console
+
+console = Console()
+
+def human_size(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+def print_table(groups: dict) -> None:
+    total_wasted = 0
+
+    for i, (hash_val, paths) in enumerate(groups.items(), 1):
+        size = paths[0].stat().st_size
+        wasted = size * (len(paths) - 1)
+        total_wasted += wasted
+
+        t = Table(
+            title=f"[bold]Group {i}[/bold] — {human_size(size)} each  |  "
+                  f"[red]{human_size(wasted)} wasted[/red]",
+            show_lines=True,
+        )
+        t.add_column("#", style="dim", width=4)
+        t.add_column("Path", style="cyan")
+        t.add_column("Modified", style="yellow")
+        t.add_column("Size", justify="right")
+
+        for j, p in enumerate(paths, 1):
+            stat = p.stat()
+            mtime = datetime.datetime.fromtimestamp(
+                stat.st_mtime
+            ).strftime("%Y-%m-%d %H:%M")
+            t.add_row(str(j), str(p), mtime, human_size(stat.st_size))
+
+        console.print(t)
+
+    console.print(
+        f"\n[bold green]Total reclaimable:[/bold green] "
+        f"[green]{human_size(total_wasted)}[/green] "
+        f"across [bold]{len(groups)}[/bold] duplicate group(s)\n"
+    )
+
+def export_json(groups: dict, out_path: str) -> None:
+    data = [
+        {
+            "hash": h,
+            "count": len(paths),
+            "size_each": paths[0].stat().st_size,
+            "files": [str(p) for p in paths]
+        }
+        for h, paths in groups.items()
+    ]
+    with open(out_path, "w") as f:
+        json.dump(data, f, indent=2)
+    console.print(f"[green]Exported JSON → {out_path}[/green]")
+
+def export_csv(groups: dict, out_path: str) -> None:
+    with open(out_path, "w", newline="") as f:
+        w = csv.writer(f)
+        w.writerow(["group", "hash", "path", "size_bytes", "modified"])
+        for i, (h, paths) in enumerate(groups.items(), 1):
+            for p in paths:
+                stat = p.stat()
+                mtime = datetime.datetime.fromtimestamp(
+                    stat.st_mtime
+                ).strftime("%Y-%m-%d %H:%M")
+                w.writerow([i, h, str(p), stat.st_size, mtime])
+    console.print(f"[green]Exported CSV → {out_path}[/green]")

dupegun-1.0.0/dupegun/scanner.py

@@ -0,0 +1,72 @@
+import os
+import hashlib
+from pathlib import Path
+from collections import defaultdict
+from typing import Iterator
+
+CHUNK = 65_536
+
+def _hash_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while chunk := f.read(CHUNK):
+            h.update(chunk)
+    return h.hexdigest()
+
+def _partial_hash(path: Path, size: int = 4096) -> str:
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        h.update(f.read(size))
+    return h.hexdigest()
+
+def walk_files(root: Path, min_size: int = 1) -> Iterator[Path]:
+    for dirpath, _, filenames in os.walk(root):
+        for name in filenames:
+            p = Path(dirpath) / name
+            try:
+                if p.stat().st_size >= min_size:
+                    yield p
+            except (PermissionError, OSError):
+                pass
+
+def find_duplicates(
+    roots: list,
+    min_size: int = 1,
+    progress_cb=None
+) -> dict:
+    by_size = defaultdict(list)
+    all_files = [f for root in roots for f in walk_files(root, min_size)]
+
+    for path in all_files:
+        by_size[path.stat().st_size].append(path)
+
+    size_candidates = [
+        p for files in by_size.values()
+        if len(files) > 1
+        for p in files
+    ]
+
+    by_partial = defaultdict(list)
+    for path in size_candidates:
+        try:
+            by_partial[_partial_hash(path)].append(path)
+        except (PermissionError, OSError):
+            pass
+
+    partial_candidates = [
+        p for files in by_partial.values()
+        if len(files) > 1
+        for p in files
+    ]
+
+    by_hash = defaultdict(list)
+    total = len(partial_candidates)
+    for i, path in enumerate(partial_candidates):
+        if progress_cb:
+            progress_cb(i + 1, total, path)
+        try:
+            by_hash[_hash_file(path)].append(path)
+        except (PermissionError, OSError):
+            pass
+
+    return {h: paths for h, paths in by_hash.items() if len(paths) > 1}

dupegun-1.0.0/dupegun.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: dupegun
+Version: 1.0.0
+Summary: Cross-platform duplicate file finder and cleaner
+License: MIT License
+        
+        Copyright (c) 2025 Prasanna B
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Keywords: duplicate,files,cli,disk,cleaner
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: click>=8.0
+Dynamic: license-file
+
+# dupegun
+
+Fast cross-platform duplicate file finder and cleaner for Windows, Linux and macOS.
+
+## Install
+
+```bash
+pip install dupegun
+```
+
+## Commands
+
+```bash
+# Find duplicates
+dupegun scan ~/Downloads
+
+# Skip files under 1 MB
+dupegun scan ~/Downloads --min-size 1000000
+
+# Scan multiple folders
+dupegun scan ~/Downloads ~/Documents ~/Desktop
+
+# Export to JSON
+dupegun scan ~/Downloads --json results.json
+
+# Export to CSV
+dupegun scan ~/Downloads --csv results.csv
+
+# Preview what would be deleted (safe)
+dupegun delete ~/Downloads --strategy newest
+
+# Actually delete
+dupegun delete ~/Downloads --strategy newest --no-dry-run
+
+# Confirm each group before deleting
+dupegun delete ~/Downloads --no-dry-run --interactive
+
+# Move duplicates to quarantine
+dupegun move ~/Downloads --dest ~/quarantine --no-dry-run
+
+# Replace duplicates with hard links
+dupegun hardlink ~/Downloads --no-dry-run
+```
+
+## Strategies
+
+| Flag | Keeps |
+|---|---|
+| `--strategy shortest` | Shortest file path (default) |
+| `--strategy newest` | Most recently modified copy |
+| `--strategy oldest` | Oldest copy |
+
+## Features
+
+- Works on Windows, Linux, macOS
+- All file types supported
+- 3-pass engine (size → partial hash → full SHA-256)
+- Colored terminal output
+- Dry-run on by default (safe)
+- JSON and CSV export
+- Hard link support
+
+## License
+
+MIT

dupegun-1.0.0/dupegun.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+dupegun/__init__.py
+dupegun/actions.py
+dupegun/cli.py
+dupegun/reporter.py
+dupegun/scanner.py
+dupegun.egg-info/PKG-INFO
+dupegun.egg-info/SOURCES.txt
+dupegun.egg-info/dependency_links.txt
+dupegun.egg-info/entry_points.txt
+dupegun.egg-info/requires.txt
+dupegun.egg-info/top_level.txt
+tests/test_scanner.py

dupegun-1.0.0/dupegun.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dupegun-1.0.0/dupegun.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dupegun = dupegun.cli:main

dupegun-1.0.0/dupegun.egg-info/requires.txt

@@ -0,0 +1,2 @@
+rich>=13.0
+click>=8.0

dupegun-1.0.0/dupegun.egg-info/top_level.txt

@@ -0,0 +1 @@
+dupegun

dupegun-1.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dupegun"
+version = "1.0.0"
+description = "Cross-platform duplicate file finder and cleaner"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.9"
+keywords = ["duplicate", "files", "cli", "disk", "cleaner"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+dependencies = [
+    "rich>=13.0",
+    "click>=8.0",
+]
+
+[project.scripts]
+dupegun = "dupegun.cli:main"

dupegun-1.0.0/setup.cfg

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

dupegun-1.0.0/tests/test_scanner.py

@@ -0,0 +1,25 @@
+import os
+import tempfile
+from pathlib import Path
+from dupegun.scanner import find_duplicates
+
+def test_finds_duplicates():
+    with tempfile.TemporaryDirectory() as tmp:
+        a = Path(tmp) / "a.txt"
+        b = Path(tmp) / "b.txt"
+        c = Path(tmp) / "c.txt"
+        a.write_text("hello duplicate")
+        b.write_text("hello duplicate")
+        c.write_text("unique content")
+
+        groups = find_duplicates([Path(tmp)])
+        assert len(groups) == 1
+        paths = list(groups.values())[0]
+        assert len(paths) == 2
+
+def test_no_duplicates():
+    with tempfile.TemporaryDirectory() as tmp:
+        Path(tmp, "x.txt").write_text("aaa")
+        Path(tmp, "y.txt").write_text("bbb")
+        groups = find_duplicates([Path(tmp)])
+        assert len(groups) == 0