killpy 0.24.0__tar.gz → 0.24.2__tar.gz

{killpy-0.24.0 → killpy-0.24.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: killpy
-Version: 0.24.0
+Version: 0.24.2
 Summary: List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹.
 Project-URL: Homepage, https://github.com/Tlaloc-Es/killpy
 Project-URL: Documentation, https://tlaloc-es.github.io/killpy/
@@ -31,6 +31,8 @@ Find and delete old `.venv`, conda, poetry, pipenv, uv and more — safely, in s
 uvx killpy --path ~
 ```
 
+> ⭐ Featured in [awesome-python](https://github.com/vinta/awesome-python) — a curated list of the best Python tools
+
 [Documentation](https://tlaloc-es.github.io/killpy/)
 
 [![PyPI](https://img.shields.io/pypi/v/killpy.svg)](https://pypi.org/project/killpy/)
@@ -40,6 +42,7 @@ uvx killpy --path ~
 [![Coverage](https://codecov.io/gh/Tlaloc-Es/killpy/branch/master/graph/badge.svg)](https://codecov.io/gh/Tlaloc-Es/killpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](<https://twitter.com/intent/tweet?text=%F0%9F%90%8D%20KillPy%20helps%20you%20reclaim%20disk%20space%20by%20detecting%20unused%20Python%20environments%20(.venv,%20poetry%20env,%20conda%20env)%20and%20pipx%20packages.%20Clean,%20organize%20and%20free%20up%20space%20effortlessly!%20%F0%9F%9A%80&url=https://github.com/Tlaloc-Es/KillPy>)
+[![Awesome Python](https://awesome.re/badge.svg)](https://github.com/vinta/awesome-python)
 
 ![killpy in action](https://raw.githubusercontent.com/Tlaloc-Es/killpy/master/show.gif)
 
@@ -584,7 +587,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.0
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.0 → killpy-0.24.2}/README.md

@@ -10,6 +10,8 @@ Find and delete old `.venv`, conda, poetry, pipenv, uv and more — safely, in s
 uvx killpy --path ~
 ```
 
+> ⭐ Featured in [awesome-python](https://github.com/vinta/awesome-python) — a curated list of the best Python tools
+
 [Documentation](https://tlaloc-es.github.io/killpy/)
 
 [![PyPI](https://img.shields.io/pypi/v/killpy.svg)](https://pypi.org/project/killpy/)
@@ -19,6 +21,7 @@ uvx killpy --path ~
 [![Coverage](https://codecov.io/gh/Tlaloc-Es/killpy/branch/master/graph/badge.svg)](https://codecov.io/gh/Tlaloc-Es/killpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](<https://twitter.com/intent/tweet?text=%F0%9F%90%8D%20KillPy%20helps%20you%20reclaim%20disk%20space%20by%20detecting%20unused%20Python%20environments%20(.venv,%20poetry%20env,%20conda%20env)%20and%20pipx%20packages.%20Clean,%20organize%20and%20free%20up%20space%20effortlessly!%20%F0%9F%9A%80&url=https://github.com/Tlaloc-Es/KillPy>)
+[![Awesome Python](https://awesome.re/badge.svg)](https://github.com/vinta/awesome-python)
 
 ![killpy in action](https://raw.githubusercontent.com/Tlaloc-Es/killpy/master/show.gif)
 
@@ -563,7 +566,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.0
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.0 → killpy-0.24.2}/killpy/__main__.py

@@ -1,4 +1,5 @@
 import logging
+import sys
 from pathlib import Path
 
 import click
@@ -6,7 +7,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from killpy.cleaner import Cleaner
+from killpy.cleaner import Cleaner, CleanerError
 from killpy.cli import TableApp
 from killpy.commands.clean import clean
 from killpy.commands.delete import delete_cmd
@@ -52,27 +53,40 @@ def _run_delete_all(path: Path, excluded: set[str], yes: bool) -> None:
             console.print("Aborted.")
             return
 
+    # Record this cleanup session up-front so `killpy stats --history` reflects
+    # it; record_deletion() below updates the same record with the freed bytes.
+    tracker = UsageTracker()
+    try:
+        tracker.record_scan_result(envs, path)
+    except Exception:  # noqa: BLE001
+        pass
+
     deleted = 0
     freed = 0
+    errors = 0
     for env in envs:
-        size = env.size_bytes
-        if cleaner.delete(env):
-            freed += size
+        try:
+            freed += cleaner.delete(env)
             deleted += 1
-        else:
-            console.print(f"[red]Failed to delete:[/red] {env.path}")
+        except CleanerError as exc:
+            console.print(f"  [red]✗ Failed to delete:[/red] {env.path}: {exc}")
+            errors += 1
 
     console.print(
         f"\n[bold green]Done.[/bold green] Deleted {deleted}/{len(envs)} environment(s), "  # noqa: E501
         f"freed [bold]{format_size(freed)}[/bold]."
+        + (f" [red]{errors} error(s).[/red]" if errors else "")
     )
 
-    # Best-effort: record deletion in history.
+    # Best-effort: update the history record created above with freed bytes.
     try:
-        UsageTracker().record_deletion(freed)
+        tracker.record_deletion(freed)
     except Exception:  # noqa: BLE001
         pass
 
+    if errors:
+        sys.exit(1)
+
 
 @click.group(invoke_without_command=True)
 @click.option(

{killpy-0.24.0 → killpy-0.24.2}/killpy/cleaner.py

@@ -11,8 +11,8 @@ Usage::
 The :class:`Cleaner` dispatches to the correct removal strategy based on
 :attr:`~killpy.models.Environment.managed_by`.  Environments with
 ``managed_by="conda"`` are removed via ``conda env remove``;
-``managed_by="pipx"`` via ``pipx uninstall``; all others via
-:func:`shutil.rmtree`.
+``managed_by="pipx"`` via ``pipx uninstall``; ``managed_by="uv"`` via
+``uv tool uninstall``; all others via :func:`shutil.rmtree`.
 """
 
 from __future__ import annotations
@@ -77,6 +77,8 @@ class Cleaner:
                 self._remove_conda(env.name)
             elif env.managed_by == "pipx":
                 self._remove_pipx(env.name)
+            elif env.managed_by == "uv":
+                self._remove_uv_tool(env.name)
             else:
                 self._remove_filesystem(env.path)
         except CleanerError:
@@ -161,3 +163,18 @@ class Cleaner:
             raise CleanerError(
                 f"pipx uninstall failed for '{package_name}': {result.stderr.strip()}"
             )
+
+    @staticmethod
+    def _remove_uv_tool(tool_name: str) -> None:
+        if shutil.which("uv") is None:
+            raise CleanerError("uv not found on PATH")
+        result = subprocess.run(
+            ["uv", "tool", "uninstall", tool_name],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise CleanerError(
+                f"uv tool uninstall failed for '{tool_name}': {result.stderr.strip()}"
+            )

{killpy-0.24.0 → killpy-0.24.2}/killpy/cli.py

@@ -11,6 +11,7 @@ from typing import Any, TypedDict
 from rich.text import Text
 from textual.app import App, ComposeResult
 from textual.binding import Binding
+from textual.coordinate import Coordinate
 from textual.widgets import (
     DataTable,
     Footer,
@@ -25,7 +26,7 @@ from textual.widgets import (
 from killpy.cleaner import Cleaner, CleanerError
 from killpy.cleaners import remove_pycache
 from killpy.files import format_size
-from killpy.intelligence import SuggestionEngine, score_all
+from killpy.intelligence import SuggestionEngine, UsageTracker, score_all
 from killpy.models import Environment
 from killpy.scanner import Scanner
 
@@ -142,9 +143,10 @@ class TableApp(App):
         self._filter_query: str = ""
         self._venv_display_indices: list[int] = []
         self._multi_select_mode: bool = False
-        self._selected_venv_indices: set[int] = set()
+        self._selected_venv_paths: set[str] = set()
         self._health_by_path: dict[str, str] = {}
         self.cleaner = Cleaner()
+        self.tracker = UsageTracker()
         self.scanner = Scanner(
             types={
                 "venv",
@@ -395,7 +397,7 @@ class TableApp(App):
                 row["size"],
                 row["size_human"],
                 _health_text(row["health"]),
-                self._compute_row_status(i, row),
+                self._compute_row_status(row),
             )
 
     def render_pipx_table(self) -> None:
@@ -416,18 +418,18 @@ class TableApp(App):
             return data_index, self.venv_rows[data_index]
         return None
 
-    def _compute_row_status(self, data_index: int, row: VenvRow) -> str:
+    def _compute_row_status(self, row: VenvRow) -> str:
         """Return the status string to display, taking multi-select into account."""
         if row["status"] == EnvStatus.DELETED.value:
             return EnvStatus.DELETED.value
-        if self._multi_select_mode and data_index in self._selected_venv_indices:
+        if self._multi_select_mode and row["path"] in self._selected_venv_paths:
             return "\u25cf SELECTED"
         return row["status"]
 
     def _update_multi_select_label(self) -> None:
         label = self.query_one("#multi-select-label", Label)
         if self._multi_select_mode:
-            n = len(self._selected_venv_indices)
+            n = len(self._selected_venv_paths)
             label.add_class("visible")
             label.update(
                 f"[bold yellow]Multi-select[/bold yellow] — "
@@ -572,8 +574,27 @@ class TableApp(App):
         status_label.update(
             f"Found {venv_count} virtual environments and {pipx_count} pipx packages"
         )
+        self._record_scan()
         await self._compute_health_scores()
 
+    def _record_scan(self) -> None:
+        """Persist this scan session so ``killpy stats --history`` reflects it."""
+        try:
+            envs = [row["environment"] for row in self.venv_rows]
+            envs += [row["environment"] for row in self.pipx_rows]
+            self.tracker.record_scan_result(envs, self.root_dir)
+        except Exception:  # noqa: BLE001
+            pass
+
+    def _record_deletion(self, freed: int) -> None:
+        """Best-effort: add *freed* bytes to the current history record."""
+        if freed <= 0:
+            return
+        try:
+            self.tracker.record_deletion(freed)
+        except Exception:  # noqa: BLE001
+            pass
+
     async def _compute_health_scores(self) -> None:
         """Score venv environments and populate the Health column."""
         if not self.venv_rows:
@@ -614,25 +635,32 @@ class TableApp(App):
 
     @is_venv_tab
     def action_confirm_delete(self):
-        if self._multi_select_mode and self._selected_venv_indices:
-            # Multi-select mode: delete all selected rows
-            for data_index in list(self._selected_venv_indices):
-                row = self.venv_rows[data_index]
+        freed_now = 0
+        if self._multi_select_mode and self._selected_venv_paths:
+            # Multi-select mode: delete all selected rows.  Selection is
+            # tracked by path (not by list position) so it stays valid even
+            # after the rows have been re-sorted.
+            for row in self.venv_rows:
+                if row["path"] not in self._selected_venv_paths:
+                    continue
                 if row["status"] == EnvStatus.DELETED.value:
                     continue
                 if self.delete_environment(row["environment"]):
+                    freed_now += int(row["size"])
                     self.bytes_release += int(row["size"])
                     row["status"] = EnvStatus.DELETED.value
-            self._selected_venv_indices.clear()
+            self._selected_venv_paths.clear()
         else:
             # Normal mode: delete all rows marked for deletion
             for row in self.venv_rows:
                 if row["status"] != EnvStatus.MARKED_TO_DELETE.value:
                     continue
                 if self.delete_environment(row["environment"]):
+                    freed_now += int(row["size"])
                     self.bytes_release += int(row["size"])
                     row["status"] = EnvStatus.DELETED.value
 
+        self._record_deletion(freed_now)
         self.render_venv_table()
         self.query_one("#status-label", Label).update(
             f"{format_size(self.bytes_release)} deleted"
@@ -675,6 +703,7 @@ class TableApp(App):
                 return
             if self.delete_environment(row["environment"]):
                 self.bytes_release += int(row["size"])
+                self._record_deletion(int(row["size"]))
                 row["status"] = EnvStatus.DELETED.value
                 table.update_cell_at(
                     (cursor_cell.row, self.VENV_COL_STATUS),
@@ -685,8 +714,9 @@ class TableApp(App):
                 )
         self.bell()
 
-    @is_venv_tab
     def delete_environment(self, environment: Environment) -> bool:
+        # Shared helper — no tab gating here: it is called from both the
+        # venv tab (delete actions) and the pipx tab (uninstall action).
         try:
             self.cleaner.delete(environment)
             return True
@@ -706,6 +736,7 @@ class TableApp(App):
                 row["status"] = EnvStatus.DELETED.value
                 table.update_cell_at((cursor_cell.row, 3), EnvStatus.DELETED.value)
                 self.bytes_release += int(row["size"])
+                self._record_deletion(int(row["size"]))
                 self.query_one("#status-label", Label).update(
                     f"{format_size(self.bytes_release)} deleted"
                 )
@@ -794,7 +825,7 @@ class TableApp(App):
         """Toggle multi-select mode on/off (T key)."""
         self._multi_select_mode = not self._multi_select_mode
         if not self._multi_select_mode:
-            self._selected_venv_indices.clear()
+            self._selected_venv_paths.clear()
         self._update_multi_select_label()
         self.render_venv_table()
 
@@ -810,17 +841,17 @@ class TableApp(App):
         resolved = self._resolve_venv_row(cursor_cell.row)
         if not resolved:
             return
-        data_index, row = resolved
+        _, row = resolved
         if row["status"] == EnvStatus.DELETED.value:
             return
-        if data_index in self._selected_venv_indices:
-            self._selected_venv_indices.discard(data_index)
+        if row["path"] in self._selected_venv_paths:
+            self._selected_venv_paths.discard(row["path"])
         else:
-            self._selected_venv_indices.add(data_index)
+            self._selected_venv_paths.add(row["path"])
         self._update_multi_select_label()
         table.update_cell_at(
-            (cursor_cell.row, self.VENV_COL_STATUS),
-            self._compute_row_status(data_index, row),
+            Coordinate(cursor_cell.row, self.VENV_COL_STATUS),
+            self._compute_row_status(row),
         )
 
     @is_venv_tab
@@ -829,13 +860,13 @@ class TableApp(App):
         if not self._multi_select_mode:
             return
         non_deleted = {
-            i
+            self.venv_rows[i]["path"]
             for i in self._venv_display_indices
             if self.venv_rows[i]["status"] != EnvStatus.DELETED.value
         }
-        if non_deleted == self._selected_venv_indices:
-            self._selected_venv_indices.clear()
+        if non_deleted == self._selected_venv_paths:
+            self._selected_venv_paths.clear()
         else:
-            self._selected_venv_indices = non_deleted
+            self._selected_venv_paths = non_deleted
         self._update_multi_select_label()
         self.render_venv_table()

{killpy-0.24.0 → killpy-0.24.2}/killpy/commands/delete.py

@@ -96,6 +96,14 @@ def delete_cmd(
             abort=True,
         )
 
+    # Record this cleanup session up-front so `killpy stats --history` reflects
+    # it; record_deletion() below updates the same record with the freed bytes.
+    tracker = UsageTracker()
+    try:
+        tracker.record_scan_result(envs, path)
+    except Exception:  # noqa: BLE001
+        pass
+
     cleaner = Cleaner(dry_run=False)
     freed = 0
     errors = 0
@@ -114,9 +122,9 @@ def delete_cmd(
         + (f" — [red]{errors} error(s)[/red]" if errors else "")
     )
 
-    # Best-effort: record deletion in history.
+    # Best-effort: update the history record created above with freed bytes.
     try:
-        UsageTracker().record_deletion(freed)
+        tracker.record_deletion(freed)
     except Exception:  # noqa: BLE001
         pass
 

{killpy-0.24.0 → killpy-0.24.2}/killpy/detectors/artifacts.py

@@ -14,6 +14,10 @@ from killpy.models import Environment
 logger = logging.getLogger(__name__)
 
 _PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
+# Environment internals are not build artifacts: every installed package has
+# a ``site-packages/*.dist-info`` directory whose deletion corrupts the env.
+# Environments are VenvDetector territory.
+_ENV_DIRS: frozenset[str] = frozenset({".venv", "site-packages"})
 _EXACT_NAMES: frozenset[str] = frozenset({"dist", "build"})
 _SUFFIXES: tuple[str, ...] = (".egg-info", ".dist-info")
 
@@ -28,7 +32,10 @@ class ArtifactsDetector(AbstractDetector):
     """Detects Python build artifact directories.
 
     Finds ``dist/``, ``build/``, ``*.egg-info/``, and ``*.dist-info/``
-    directories under the scan root.
+    directories under the scan root.  Virtual environments (``.venv``,
+    any directory containing ``pyvenv.cfg``) and ``site-packages`` trees
+    are skipped: their ``*.dist-info`` entries are package metadata, not
+    build output.
     """
 
     name = "artifacts"
@@ -38,10 +45,14 @@ class ArtifactsDetector(AbstractDetector):
 
     def detect(self, path: Path) -> list[Environment]:
         envs: list[Environment] = []
-        for current_root, directories, _ in os.walk(path, topdown=True):
+        for current_root, directories, files in os.walk(path, topdown=True):
+            if "pyvenv.cfg" in files:
+                # Inside a virtual environment (whatever its name) — skip it.
+                directories[:] = []
+                continue
             pruned = set()
             for d in directories:
-                if d in _PRUNED:
+                if d in _PRUNED or d in _ENV_DIRS:
                     pruned.add(d)
                     continue
                 if _is_artifact_dir(d):

{killpy-0.24.0 → killpy-0.24.2}/killpy/detectors/cache.py

@@ -5,8 +5,8 @@ Covers:
 * ``.mypy_cache``
 * ``.pytest_cache``
 * ``.ruff_cache``
-* Global pip cache  (``~/.cache/pip``)
-* Global uv cache   (``~/.cache/uv``)
+* Global pip cache  (``~/.cache/pip``) — only when inside the scanned path
+* Global uv cache   (``~/.cache/uv``) — only when inside the scanned path
 """
 
 from __future__ import annotations
@@ -33,6 +33,11 @@ _LOCAL_CACHE_DIRS: tuple[str, ...] = (
 # Directories to prune from the walk so we don't descend into them.
 _PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
 
+# Caches inside an environment belong to the environment: VenvDetector
+# already reports the whole tree, so listing them separately double-counts
+# their size in stats/list totals.
+_ENV_DIRS: frozenset[str] = frozenset({".venv", "site-packages"})
+
 
 class CacheDetector(AbstractDetector):
     """Detects local and global Python cache directories."""
@@ -45,18 +50,26 @@ class CacheDetector(AbstractDetector):
     def detect(self, path: Path) -> list[Environment]:
         envs: list[Environment] = []
         envs.extend(self._scan_local(path))
-        envs.extend(self._scan_global())
+        envs.extend(self._scan_global(path))
         return envs
 
     # ------------------------------------------------------------------ #
 
     def _scan_local(self, root: Path) -> list[Environment]:
-        """Walk *root* and collect all known local cache directories."""
+        """Walk *root* and collect all known local cache directories.
+
+        Virtual environments (``.venv``, any directory containing
+        ``pyvenv.cfg``) and ``site-packages`` trees are skipped.
+        """
         results: list[Environment] = []
-        for current_root, directories, _ in os.walk(root, topdown=True):
+        for current_root, directories, files in os.walk(root, topdown=True):
+            if "pyvenv.cfg" in files:
+                # Inside a virtual environment (whatever its name) — skip it.
+                directories[:] = []
+                continue
             prune = set()
             for d in directories:
-                if d in _PRUNED:
+                if d in _PRUNED or d in _ENV_DIRS:
                     prune.add(d)
                     continue
                 if d in _LOCAL_CACHE_DIRS:
@@ -70,19 +83,33 @@ class CacheDetector(AbstractDetector):
             directories[:] = [d for d in directories if d not in prune]
         return results
 
-    def _scan_global(self) -> list[Environment]:
-        """Return global pip and uv cache directories if they exist."""
+    def _scan_global(self, root: Path) -> list[Environment]:
+        """Return global pip/uv cache directories that live under *root*.
+
+        A scan scoped to a project directory (e.g. the pre-commit hooks or
+        ``killpy delete --type cache --path <repo>``) must never surface —
+        and therefore never delete — caches outside that directory.  The
+        global caches are still reported when the scan root contains them
+        (e.g. ``killpy --path ~``).
+        """
+        try:
+            scan_root = root.resolve()
+        except OSError:
+            scan_root = root
         results: list[Environment] = []
         candidates = [
             (Path.home() / ".cache" / "pip", "pip-cache"),
             (Path.home() / ".cache" / "uv", "uv-cache"),
         ]
         for cache_path, tag in candidates:
-            if cache_path.exists():
-                try:
-                    results.append(_make_cache_env(cache_path, tag))
-                except (FileNotFoundError, OSError) as exc:
-                    logger.debug("Skipping global cache %s: %s", cache_path, exc)
+            if not cache_path.exists():
+                continue
+            try:
+                if not cache_path.resolve().is_relative_to(scan_root):
+                    continue
+                results.append(_make_cache_env(cache_path, tag))
+            except (FileNotFoundError, OSError) as exc:
+                logger.debug("Skipping global cache %s: %s", cache_path, exc)
         return results
 
 

killpy-0.24.2/killpy/detectors/uv.py

@@ -0,0 +1,96 @@
+"""Detector for disk space owned by uv itself (tool envs and Pythons)."""
+
+from __future__ import annotations
+
+import logging
+import os
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+from killpy.detectors.base import AbstractDetector
+from killpy.files import get_total_size
+from killpy.models import Environment
+
+logger = logging.getLogger(__name__)
+
+
+def _uv_data_dir() -> Path:
+    xdg = os.environ.get("XDG_DATA_HOME")
+    base = Path(xdg) if xdg else Path.home() / ".local" / "share"
+    return base / "uv"
+
+
+def _uv_tools_dir() -> Path:
+    override = os.environ.get("UV_TOOL_DIR")
+    return Path(override) if override else _uv_data_dir() / "tools"
+
+
+def _uv_python_dir() -> Path:
+    override = os.environ.get("UV_PYTHON_INSTALL_DIR")
+    return Path(override) if override else _uv_data_dir() / "python"
+
+
+class UvDetector(AbstractDetector):
+    """Detects environments managed by uv itself.
+
+    Covers:
+
+    * Tool environments installed with ``uv tool install`` (uv's pipx
+      equivalent), stored under ``~/.local/share/uv/tools``.  Marked
+      ``managed_by="uv"`` so deletion goes through ``uv tool uninstall``
+      and the ``~/.local/bin`` shims are cleaned up too.
+    * Python versions installed with ``uv python install``, stored under
+      ``~/.local/share/uv/python``.
+
+    ``UV_TOOL_DIR``, ``UV_PYTHON_INSTALL_DIR`` and ``XDG_DATA_HOME`` are
+    honoured.  Project virtualenvs created by ``uv venv`` / ``uv sync``
+    are regular ``pyvenv.cfg`` environments reported by
+    :class:`~killpy.detectors.venv.VenvDetector`, and the global uv cache
+    is reported by the cache detector.  The scan *path* argument is
+    ignored.
+    """
+
+    name = "uv"
+
+    def can_handle(self) -> bool:
+        return (
+            shutil.which("uv") is not None
+            or _uv_tools_dir().exists()
+            or _uv_python_dir().exists()
+        )
+
+    def detect(self, path: Path) -> list[Environment]:  # noqa: ARG002
+        envs: list[Environment] = []
+        envs.extend(self._scan_dir(_uv_tools_dir(), managed_by="uv"))
+        envs.extend(self._scan_dir(_uv_python_dir(), managed_by=None))
+        return envs
+
+    @staticmethod
+    def _scan_dir(root: Path, managed_by: str | None) -> list[Environment]:
+        if not root.exists():
+            return []
+        envs: list[Environment] = []
+        try:
+            for env_dir in root.iterdir():
+                if not env_dir.is_dir():
+                    continue
+                try:
+                    stat = env_dir.stat()
+                    size = get_total_size(env_dir)
+                    mtime = datetime.fromtimestamp(stat.st_mtime, tz=timezone.utc)
+                    envs.append(
+                        Environment(
+                            path=env_dir,
+                            name=env_dir.name,
+                            type="uv",
+                            last_accessed=mtime,
+                            size_bytes=size,
+                            managed_by=managed_by,
+                        )
+                    )
+                except (FileNotFoundError, OSError) as exc:
+                    logger.debug("Skipping uv entry %s: %s", env_dir, exc)
+        except OSError as exc:
+            logger.error("Cannot inspect uv dir %s: %s", root, exc)
+        return envs

{killpy-0.24.0 → killpy-0.24.2}/killpy/intelligence/suggestions.py

@@ -9,7 +9,6 @@ from killpy.models import ScoredEnvironment, Suggestion
 
 # Age thresholds in days.
 _HIGH_AGE_ORPHAN_THRESHOLD = 180  # orphan + age >= this → HIGH
-_HIGH_AGE_NO_PROJECT_THRESHOLD = 365  # no project files + age >= this → HIGH
 _MEDIUM_AGE_THRESHOLD = 120  # age >= this → MEDIUM
 _LOW_AGE_THRESHOLD = 120  # age < this → LOW
 
@@ -73,7 +72,6 @@ class SuggestionEngine:
         reasons: list[str],
     ) -> tuple[Literal["HIGH", "MEDIUM", "LOW"], str]:
         is_orphan = scored.is_orphan
-        has_project_files = scored.has_project_files
         is_active_git = (
             scored.git_info is not None
             and scored.git_info.is_git_repo
@@ -86,12 +84,6 @@ class SuggestionEngine:
             reasons.append(f"Not used in {age_days} days")
             return "HIGH", _ACTION_HIGH
 
-        # ── Rule 1b: HIGH — no project files and very old ──────────────────────
-        if not has_project_files and age_days >= _HIGH_AGE_NO_PROJECT_THRESHOLD:
-            reasons.append("Orphan — no project files found nearby")
-            reasons.append(f"Not used in {age_days} days")
-            return "HIGH", _ACTION_HIGH
-
         # ── Rule 2: LOW — active git or very recent ─────────────────────────────
         if is_active_git or age_days < _LOW_AGE_THRESHOLD:
             if is_active_git:

{killpy-0.24.0 → killpy-0.24.2}/killpy/intelligence/tracker.py

@@ -6,9 +6,11 @@ import json
 import logging
 import os
 import tempfile
+from collections.abc import Iterable
+from datetime import datetime, timezone
 from pathlib import Path
 
-from killpy.models import ScanRecord, ScoredEnvironment
+from killpy.models import Environment, ScanRecord, ScoredEnvironment
 
 logger = logging.getLogger(__name__)
 
@@ -35,6 +37,32 @@ class UsageTracker:
         history.append(record.to_dict())
         self._save(history)
 
+    def record_scan_result(
+        self,
+        environments: Iterable[Environment],
+        scan_path: Path | str,
+        *,
+        deleted_bytes: int = 0,
+    ) -> None:
+        """Persist a :class:`~killpy.models.ScanRecord` built from a scan result.
+
+        Convenience wrapper around :meth:`record_scan` so callers don't have to
+        assemble a :class:`ScanRecord` by hand.  Records the number of
+        environments found and their total size; ``deleted_bytes`` can be set
+        when the freed amount is already known, otherwise use
+        :meth:`record_deletion` afterwards to update the same record.
+        """
+        envs = list(environments)
+        self.record_scan(
+            ScanRecord(
+                timestamp=datetime.now(tz=timezone.utc),
+                total_space_found=sum(e.size_bytes for e in envs),
+                total_space_deleted=deleted_bytes,
+                environments_count=len(envs),
+                scan_path=str(scan_path),
+            )
+        )
+
     def record_deletion(self, size_bytes: int) -> None:
         """Increment the ``total_space_deleted`` counter of the last scan record."""
         history = self._load()

{killpy-0.24.0 → killpy-0.24.2}/killpy/models.py

@@ -39,8 +39,8 @@ class Environment:
         Total size in bytes (recursive directory sum).
     managed_by:
         If not ``None``, the external tool that manages deletion.  Supported
-        values: ``"conda"`` and ``"pipx"``.  When ``None`` deletion is
-        performed via :func:`shutil.rmtree`.
+        values: ``"conda"``, ``"pipx"`` and ``"uv"`` (uv tool environments).
+        When ``None`` deletion is performed via :func:`shutil.rmtree`.
     """
 
     path: Path

{killpy-0.24.0 → killpy-0.24.2}/killpy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: killpy
-Version: 0.24.0
+Version: 0.24.2
 Summary: List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹.
 Project-URL: Homepage, https://github.com/Tlaloc-Es/killpy
 Project-URL: Documentation, https://tlaloc-es.github.io/killpy/
@@ -31,6 +31,8 @@ Find and delete old `.venv`, conda, poetry, pipenv, uv and more — safely, in s
 uvx killpy --path ~
 ```
 
+> ⭐ Featured in [awesome-python](https://github.com/vinta/awesome-python) — a curated list of the best Python tools
+
 [Documentation](https://tlaloc-es.github.io/killpy/)
 
 [![PyPI](https://img.shields.io/pypi/v/killpy.svg)](https://pypi.org/project/killpy/)
@@ -40,6 +42,7 @@ uvx killpy --path ~
 [![Coverage](https://codecov.io/gh/Tlaloc-Es/killpy/branch/master/graph/badge.svg)](https://codecov.io/gh/Tlaloc-Es/killpy)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](<https://twitter.com/intent/tweet?text=%F0%9F%90%8D%20KillPy%20helps%20you%20reclaim%20disk%20space%20by%20detecting%20unused%20Python%20environments%20(.venv,%20poetry%20env,%20conda%20env)%20and%20pipx%20packages.%20Clean,%20organize%20and%20free%20up%20space%20effortlessly!%20%F0%9F%9A%80&url=https://github.com/Tlaloc-Es/KillPy>)
+[![Awesome Python](https://awesome.re/badge.svg)](https://github.com/vinta/awesome-python)
 
 ![killpy in action](https://raw.githubusercontent.com/Tlaloc-Es/killpy/master/show.gif)
 
@@ -584,7 +587,7 @@ Typical minimal setup (safe for daily use):
 
 ```yaml
 - repo: https://github.com/Tlaloc-Es/KillPy
-  rev: 0.24.0
+  rev: 0.24.2
   hooks:
     - id: killpy
 ```

{killpy-0.24.0 → killpy-0.24.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "killpy"
-version = "0.24.0"
+version = "0.24.2"
 description = "List all .venv directories and Conda environments 🐍 on your system and check how much space they are using. You can then choose which ones to delete in order to free up space 🧹."
 readme = "README.md"
 classifiers = [

killpy-0.24.0/killpy/detectors/uv.py

@@ -1,64 +0,0 @@
-"""Detector for uv-managed virtual environments."""
-
-from __future__ import annotations
-
-import logging
-import os
-import shutil
-from datetime import datetime, timezone
-from pathlib import Path
-
-from killpy.detectors.base import AbstractDetector
-from killpy.files import get_total_size
-from killpy.models import Environment
-
-logger = logging.getLogger(__name__)
-
-_PRUNED: frozenset[str] = frozenset({".git", ".hg", ".svn", "node_modules"})
-
-
-class UvDetector(AbstractDetector):
-    """Detects ``.uv`` directories created by `uv venv` inside projects.
-
-    Also reports the global uv cache at ``~/.cache/uv`` – but only when
-    the cache detector is *not* included in the same scan (the scanner
-    handles deduplication by path).
-    """
-
-    name = "uv"
-
-    def can_handle(self) -> bool:
-        return shutil.which("uv") is not None
-
-    def detect(self, path: Path) -> list[Environment]:
-        envs: list[Environment] = []
-        for current_root, directories, _ in os.walk(path, topdown=True):
-            pruned = set()
-            for d in directories:
-                if d in _PRUNED:
-                    pruned.add(d)
-                    continue
-                if d == ".uv":
-                    uv_path = Path(current_root) / d
-                    try:
-                        stat = uv_path.stat()
-                        size = get_total_size(uv_path)
-                        mtime = datetime.fromtimestamp(
-                            stat.st_mtime,
-                            tz=timezone.utc,
-                        )
-                        envs.append(
-                            Environment(
-                                path=uv_path,
-                                name=str(uv_path),
-                                type="uv",
-                                last_accessed=mtime,
-                                size_bytes=size,
-                            )
-                        )
-                    except (FileNotFoundError, OSError) as exc:
-                        logger.debug("Skipping %s: %s", uv_path, exc)
-                    pruned.add(d)
-            directories[:] = [d for d in directories if d not in pruned]
-
-        return envs