taze 0.1.0__py3-none-any.whl

taze/__init__.py

@@ -0,0 +1,3 @@
+from .main import __version__
+
+__all__ = ["__version__"]

taze/display.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import json as _json
+from datetime import date
+
+from rich import box
+from rich.console import Console
+from rich.padding import Padding
+from rich.table import Table
+from rich.text import Text
+
+from .models import BUMP_BADGE, BUMP_COLOR, DepInfo
+
+console = Console()
+
+
+def _age(release_date: str | None) -> str:
+    """Return a compact age string like ~2mo, ~3d, ~1y, or empty string."""
+    if not release_date:
+        return ""
+    try:
+        days = (date.today() - date.fromisoformat(release_date)).days
+    except ValueError:
+        return ""
+    if days < 1:
+        return "~0d"
+    if days < 30:
+        return f"~{days}d"
+    if days < 365:
+        return f"~{days // 30}mo"
+    return f"~{days // 365}y"
+
+
+def _age_color(release_date: str | None) -> str:
+    if not release_date:
+        return "dim"
+    try:
+        days = (date.today() - date.fromisoformat(release_date)).days
+    except ValueError:
+        return "dim"
+    if days < 28:
+        return "green"
+    if days < 180:
+        return "yellow"
+    return "red"
+
+
+def render_group(
+    label: str,
+    infos: list[DepInfo],
+    *,
+    mode: str,
+    show_up_to_date: bool,
+    sort: str | None,
+    col_widths: tuple[int, int, int, int, int] = (0, 0, 0, 0, 0),
+) -> bool:
+    """Render one dependency group table. Returns True if anything was printed."""
+    visible = [i for i in infos if show_up_to_date or i.is_shown(mode) or i.fetch_error]
+    if not visible:
+        return False
+
+    if sort:
+        _sort_infos(visible, sort, mode)
+
+    outdated = sum(1 for i in infos if i.is_shown(mode))
+
+    header = Text()
+    header.append(f"  {label}", style="bold blue")
+    if outdated:
+        header.append(f"  {outdated} outdated", style="dim")
+    else:
+        header.append("  all up to date", style="dim green")
+    console.print(header)
+
+    name_width = max(max((len(i.name) for i in visible), default=0), col_widths[0])
+    spec_width = max(
+        max((len(i.current_spec) for i in visible), default=0), col_widths[1]
+    )
+    cur_age_width = max(
+        max((len(_age(i.current_release_date)) for i in visible), default=0),
+        col_widths[2],
+    )
+    lat_age_width = max(
+        max((len(_age(i.release_date)) for i in visible), default=0), col_widths[3]
+    )
+    latest_spec_width = max(
+        max((len(i.latest_spec) for i in visible), default=0), col_widths[4]
+    )
+
+    table = Table(
+        box=box.SIMPLE,
+        show_header=False,
+        padding=(0, 2, 0, 0),
+        expand=False,
+        show_edge=False,
+    )
+    table.add_column("name", style="bold", no_wrap=True, min_width=name_width)
+    table.add_column("cur_age", style="dim", no_wrap=True, min_width=cur_age_width)
+    table.add_column("current", style="dim", no_wrap=True, min_width=spec_width)
+    table.add_column("arrow", no_wrap=True)
+    table.add_column("latest", no_wrap=True, min_width=latest_spec_width)
+    table.add_column("lat_age", style="dim", no_wrap=True, min_width=lat_age_width)
+    table.add_column("badge", no_wrap=True)
+
+    for info in visible:
+        color = BUMP_COLOR.get(info.bump, "dim")
+        badge = BUMP_BADGE.get(info.bump, "")
+        cur_age = _age(info.current_release_date)
+        lat_age = _age(info.release_date)
+        cur_age_color = _age_color(info.current_release_date)
+        lat_age_color = _age_color(info.release_date)
+
+        if info.fetch_error:
+            table.add_row(
+                info.name,
+                "",
+                info.current_spec,
+                Text("→", style="dim"),
+                Text("fetch failed", style="dim red"),
+                "",
+                "",
+            )
+        elif info.bump == "same":
+            table.add_row(
+                Text(info.name, style="dim"),
+                Text(cur_age, style="dim"),
+                Text(info.current_spec, style="dim"),
+                Text("·", style="dim"),
+                Text(info.current_spec, style="dim"),
+                "",
+                "",
+            )
+        else:
+            table.add_row(
+                info.name,
+                Text(cur_age, style=cur_age_color),
+                Text(info.current_spec, style="dim"),
+                Text("→", style=color),
+                Text(info.latest_spec, style=f"bold {color}"),
+                Text(lat_age, style=lat_age_color),
+                Text.from_markup(badge),
+            )
+
+    console.print(Padding(table, (0, 0, 0, 4)))
+    return True
+
+
+def _sort_infos(infos: list[DepInfo], sort: str, mode: str) -> None:
+    from .models import BUMP_ORDER
+
+    if sort == "name-asc":
+        infos.sort(key=lambda i: i.name)
+    elif sort == "name-desc":
+        infos.sort(key=lambda i: i.name, reverse=True)
+    elif sort == "diff-asc":
+        infos.sort(key=lambda i: BUMP_ORDER.get(i.bump, -1))
+    elif sort == "diff-desc":
+        infos.sort(key=lambda i: BUMP_ORDER.get(i.bump, -1), reverse=True)
+
+
+def render_json(resolved: dict[str, dict[str, list[DepInfo]]]) -> None:
+    output: dict = {}
+    for file_label, groups in resolved.items():
+        output[file_label] = {}
+        for group_label, infos in groups.items():
+            output[file_label][group_label] = [
+                {
+                    "name": i.name,
+                    "current": i.current,
+                    "current_spec": i.current_spec,
+                    "latest": i.latest,
+                    "latest_spec": i.latest_spec if i.latest else None,
+                    "bump": i.bump,
+                    "outdated": i.is_outdated,
+                    "release_date": i.release_date,
+                    "error": i.fetch_error,
+                }
+                for i in infos
+            ]
+    print(_json.dumps(output, indent=2))
+
+
+def interactive_select(outdated: list[DepInfo]) -> list[DepInfo]:
+    """Prompt the user to choose which packages to update. Returns selected subset."""
+    if not outdated:
+        return []
+
+    console.print()
+    console.print("  [bold]Select packages to update:[/]")
+    for idx, info in enumerate(outdated, 1):
+        color = BUMP_COLOR.get(info.bump, "dim")
+        badge = BUMP_BADGE.get(info.bump, "")
+        console.print(
+            f"  [dim]{idx:>2}.[/]  [bold]{info.name}[/]  "
+            f"[dim]{info.current_spec}[/] [dim]→[/] "
+            f"[bold {color}]{info.latest_spec}[/]  {badge}"
+        )
+    console.print()
+    console.print(
+        "  [dim]Enter numbers (e.g. [cyan]1,3[/]), [cyan]a[/] for all, "
+        "or press Enter to skip:[/] ",
+        end="",
+    )
+
+    try:
+        raw = input().strip()
+    except EOFError, KeyboardInterrupt:
+        console.print()
+        return []
+
+    if not raw or raw.lower() == "n":
+        return []
+    if raw.lower() in ("a", "all"):
+        return outdated
+
+    selected: list[DepInfo] = []
+    for token in raw.split(","):
+        token = token.strip()
+        if "-" in token:
+            parts = token.split("-", 1)
+            try:
+                lo, hi = int(parts[0]), int(parts[1])
+                for i in range(lo, hi + 1):
+                    if 1 <= i <= len(outdated):
+                        selected.append(outdated[i - 1])
+            except ValueError:
+                pass
+        else:
+            try:
+                i = int(token)
+                if 1 <= i <= len(outdated):
+                    selected.append(outdated[i - 1])
+            except ValueError:
+                pass
+
+    return selected

taze/main.py

@@ -0,0 +1,480 @@
+from __future__ import annotations
+
+import re
+import subprocess
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from .display import console, interactive_select, render_group, render_json
+from .models import MODE_SETTINGS, MODES, DepInfo, FileKind, calc_bump
+from .parsers import (
+    build_name_filter,
+    parse_dep_string,
+    parse_pyproject,
+    parse_requirements_file,
+)
+from .pypi import fetch_pypi_info
+from .writers import write_pyproject_updates, write_requirements_updates
+
+__version__ = "0.1.0"
+
+app = typer.Typer(
+    name="taze",
+    help="🥬 Keep your Python deps fresh",
+    add_completion=False,
+    rich_markup_mode="rich",
+    no_args_is_help=False,
+)
+
+SORT_CHOICES = ("name-asc", "name-desc", "diff-asc", "diff-desc")
+
+
+# ─── Resolution ───────────────────────────────────────────────────────────────
+
+
+def resolve_deps(
+    entries: list[tuple[str, Path | None, FileKind, int | None]],
+    *,
+    include_pat: re.Pattern[str] | None,
+    exclude_pat: re.Pattern[str] | None,
+    pre: bool,
+    concurrency: int,
+) -> list[DepInfo]:
+    infos: list[DepInfo] = []
+    for raw, src, kind, lineno in entries:
+        info = parse_dep_string(
+            raw, source_file=src, file_kind=kind, line_number=lineno
+        )
+        if info is None:
+            continue
+        if include_pat and not include_pat.match(info.name):
+            continue
+        if exclude_pat and exclude_pat.match(info.name):
+            continue
+        infos.append(info)
+
+    if not infos:
+        return infos
+
+    with ThreadPoolExecutor(max_workers=concurrency) as pool:
+        futures = {
+            pool.submit(fetch_pypi_info, i.name, pre=pre, current_version=i.current): i
+            for i in infos
+        }
+        for fut in as_completed(futures):
+            info = futures[fut]
+            try:
+                version, latest_date, current_date = fut.result()
+                info.latest = version
+                info.release_date = latest_date
+                info.current_release_date = current_date
+                info.fetch_error = version is None
+            except Exception:
+                info.fetch_error = True
+            info.bump = calc_bump(info.current, info.latest)
+
+    return infos
+
+
+# ─── File discovery ───────────────────────────────────────────────────────────
+
+
+def discover_files(root: Path) -> list[Path]:
+    found: list[Path] = []
+    pyproject = root / "pyproject.toml"
+    if pyproject.exists():
+        found.append(pyproject)
+    for req in sorted(root.glob("requirements*.txt")):
+        found.append(req)
+    return found
+
+
+# ─── CLI ──────────────────────────────────────────────────────────────────────
+
+
+@app.command()
+def main(
+    mode: Annotated[
+        str,
+        typer.Argument(
+            help=(
+                "Update mode: "
+                "[green]patch[/] [yellow]minor[/] [red]major[/] "
+                "[dim]default | latest | stable | newest | next[/]"
+            ),
+            show_default=False,
+        ),
+    ] = "default",
+    cwd: Annotated[
+        Path | None,
+        typer.Option("--cwd", "-C", help="Working directory", show_default=False),
+    ] = None,
+    write: Annotated[
+        bool, typer.Option("--write", "-w", help="Write updates back to file")
+    ] = False,
+    install: Annotated[
+        bool,
+        typer.Option(
+            "--install",
+            "-i",
+            help="Install directly after bumping (implies [cyan]-w[/])",
+        ),
+    ] = False,
+    update: Annotated[
+        bool,
+        typer.Option("--update", "-u", help="Alias for [cyan]--install[/]"),
+    ] = False,
+    recursive: Annotated[
+        bool,
+        typer.Option(
+            "--recursive",
+            "-r",
+            help="Recursively search for pyproject.toml / requirements*.txt",
+        ),
+    ] = False,
+    interactive: Annotated[
+        bool,
+        typer.Option(
+            "--interactive",
+            "-I",
+            help="Interactive mode — choose which packages to update",
+        ),
+    ] = False,
+    include: Annotated[
+        str | None,
+        typer.Option(
+            "--include",
+            "-n",
+            help="Only check these deps (comma-separated names or [dim]/regex/[/])",
+        ),
+    ] = None,
+    exclude: Annotated[
+        str | None,
+        typer.Option(
+            "--exclude",
+            "-x",
+            help="Skip these deps (comma-separated names or [dim]/regex/[/])",
+        ),
+    ] = None,
+    all_deps: Annotated[
+        bool, typer.Option("--all", "-a", help="Show up-to-date packages too")
+    ] = False,
+    group: Annotated[
+        bool,
+        typer.Option("--group", help="Group dependencies by source file on display"),
+    ] = False,
+    sort: Annotated[
+        str | None,
+        typer.Option(
+            "--sort", help="Sort by: name-asc | name-desc | diff-asc | diff-desc"
+        ),
+    ] = None,
+    fail_on_outdated: Annotated[
+        bool,
+        typer.Option(
+            "--fail-on-outdated",
+            help="Exit with code 1 if outdated dependencies are found",
+        ),
+    ] = False,
+    silent: Annotated[bool, typer.Option("--silent", "-s", help="No output")] = False,
+    output_json: Annotated[
+        bool, typer.Option("--json", help="Machine-readable JSON output", hidden=True)
+    ] = False,
+    version: Annotated[
+        bool,
+        typer.Option("--version", "-v", help="Show version and exit", is_eager=True),
+    ] = False,
+    concurrency: Annotated[
+        int,
+        typer.Option("--concurrency", help="Number of concurrent PyPI requests"),
+    ] = 10,
+) -> None:
+    """
+    🥬  [bold]taze[/bold] — keep your Python deps fresh
+
+    Reads [cyan]pyproject.toml[/] and/or [cyan]requirements*.txt[/], checks PyPI for
+    newer versions, and shows a grouped diff.
+
+    [dim]Examples:[/dim]
+      [cyan]taze[/]                       check everything (default mode)
+      [cyan]taze minor[/]                 only show minor and patch updates
+      [cyan]taze patch -w[/]              write patch updates back to file
+      [cyan]taze newest -I[/]             interactive, including pre-releases
+      [cyan]taze -r[/]                    scan subdirectories recursively
+      [cyan]taze -x pytest,ruff[/]        skip specific packages
+      [cyan]taze -n /^boto/[/]            only packages matching regex
+
+      [cyan]taze --sort diff-desc[/]      biggest updates first
+    """
+    if version:
+        console.print(f"taze/{__version__}")
+        raise typer.Exit(0)
+
+    if mode not in MODES:
+        console.print(
+            f"[red]✗[/]  Unknown mode [bold]{mode!r}[/]. Available: {' | '.join(MODES)}"
+        )
+        raise typer.Exit(1)
+
+    if sort and sort not in SORT_CHOICES:
+        console.print(f"[red]✗[/]  --sort must be one of: {', '.join(SORT_CHOICES)}")
+        raise typer.Exit(1)
+
+    if install or update:
+        write = True
+    if interactive:
+        write = True
+
+    _, pre = MODE_SETTINGS[mode]
+
+    root = (cwd or Path(".")).resolve()
+    include_pat = build_name_filter(include) if include else None
+    exclude_pat = build_name_filter(exclude) if exclude else None
+
+    # ── Collect files ─────────────────────────────────────────────────────────
+    if recursive:
+        target_files: list[Path] = []
+        seen: set[Path] = set()
+        for subdir in sorted(root.rglob(".")):
+            for f in discover_files(subdir):
+                if f not in seen:
+                    seen.add(f)
+                    target_files.append(f)
+    else:
+        target_files = discover_files(root)
+
+    if not target_files:
+        if not silent:
+            console.print(
+                f"[red]✗[/]  No pyproject.toml or requirements*.txt found in {root}"
+            )
+        raise typer.Exit(1)
+
+    # ── Build entries per file ────────────────────────────────────────────────
+    # file_path → group_label → raw entries
+    raw_file_groups: dict[
+        Path, dict[str, list[tuple[str, Path | None, FileKind, int | None]]]
+    ] = {}
+
+    for file_path in target_files:
+        if file_path.name == "pyproject.toml":
+            try:
+                raw_groups = parse_pyproject(file_path)
+            except Exception as e:
+                if not silent:
+                    console.print(f"[red]✗[/]  Failed to parse {file_path}: {e}")
+                continue
+            raw_file_groups[file_path] = {
+                label: [(s, file_path, FileKind.PYPROJECT, None) for s in deps]
+                for label, deps in raw_groups.items()
+            }
+        else:
+            try:
+                pairs = parse_requirements_file(file_path)
+            except Exception as e:
+                if not silent:
+                    console.print(f"[red]✗[/]  Failed to parse {file_path}: {e}")
+                continue
+            raw_file_groups[file_path] = {
+                "requirements": [
+                    (s, file_path, FileKind.REQUIREMENTS, ln) for ln, s in pairs
+                ]
+            }
+
+    if not raw_file_groups:
+        raise typer.Exit(1)
+
+    total_packages = sum(
+        len(entries)
+        for groups in raw_file_groups.values()
+        for entries in groups.values()
+    )
+
+    # ── Resolve (fetch PyPI) ──────────────────────────────────────────────────
+    resolved: dict[Path, dict[str, list[DepInfo]]] = {}
+
+    status_msg = f"[dim]Checking {total_packages} package(s) on PyPI…[/]"
+    with console.status(status_msg, spinner="dots") if not silent else _nullctx():
+        for file_path, groups in raw_file_groups.items():
+            resolved[file_path] = {}
+            for label, entries in groups.items():
+                resolved[file_path][label] = resolve_deps(
+                    entries,
+                    include_pat=include_pat,
+                    exclude_pat=exclude_pat,
+                    pre=pre,
+                    concurrency=concurrency,
+                )
+
+    # ── JSON output ───────────────────────────────────────────────────────────
+    if output_json:
+        render_json({str(fp): grps for fp, grps in resolved.items()})
+        total_outdated = _count_outdated(resolved, mode)
+        raise typer.Exit(1 if (fail_on_outdated and total_outdated) else 0)
+
+    # ── Rich display ──────────────────────────────────────────────────────────
+    if not silent:
+        console.print()
+
+    total_outdated = 0
+
+    for file_path, groups in resolved.items():
+        file_outdated = _count_outdated({file_path: groups}, mode)
+        total_outdated += file_outdated
+
+        if not silent:
+            # Compute column widths across all groups in this file so every
+            # group aligns to the same grid.
+            all_infos = [i for infos in groups.values() for i in infos]
+            from .display import _age
+
+            col_widths = (
+                max((len(i.name) for i in all_infos), default=0),
+                max((len(i.current_spec) for i in all_infos), default=0),
+                max((len(_age(i.current_release_date)) for i in all_infos), default=0),
+                max((len(_age(i.release_date)) for i in all_infos), default=0),
+                max((len(i.latest_spec) for i in all_infos), default=0),
+            )
+
+            console.print(
+                f"  [bold]📦  {file_path.name}[/]  [dim]{file_path.resolve()}[/]"
+            )
+            console.print()
+
+            for label, infos in groups.items():
+                if render_group(
+                    label,
+                    infos,
+                    mode=mode,
+                    show_up_to_date=all_deps,
+                    sort=sort,
+                    col_widths=col_widths,
+                ):
+                    console.print()
+
+            if file_outdated == 0:
+                console.print("  [green]✓  All dependencies are up to date![/]")
+                console.print()
+
+    if total_outdated == 0:
+        raise typer.Exit(0)
+
+    # ── Interactive selection ─────────────────────────────────────────────────
+    selected_for_update: set[str] | None = None  # None = all
+
+    if interactive and not silent:
+        all_outdated = [
+            i
+            for groups in resolved.values()
+            for infos in groups.values()
+            for i in infos
+            if i.is_shown(mode)
+        ]
+        chosen = interactive_select(all_outdated)
+        selected_for_update = {i.name for i in chosen}
+        console.print()
+
+    # ── Write ─────────────────────────────────────────────────────────────────
+    if write:
+        total_written = 0
+        for file_path, groups in resolved.items():
+            # Filter to selected packages if in interactive mode
+            if selected_for_update is not None:
+                filtered: dict[str, list[DepInfo]] = {
+                    label: [i for i in infos if i.name in selected_for_update]
+                    for label, infos in groups.items()
+                }
+            else:
+                filtered = groups
+
+            if file_path.name == "pyproject.toml":
+                updated = write_pyproject_updates(file_path, filtered)
+            else:
+                flat = [i for infos in filtered.values() for i in infos]
+                updated = write_requirements_updates(file_path, flat)
+
+            if updated and not silent:
+                console.print(
+                    f"  [green]✓[/]  Wrote [bold]{updated}[/] update(s) to "
+                    f"[cyan]{file_path.name}[/]"
+                )
+                total_written += updated
+
+        if total_written and not silent:
+            console.print()
+    elif not silent:
+        console.print(
+            f"  [dim]Run [cyan]taze -w[/] to write {total_outdated} update(s)[/]"
+        )
+        console.print()
+
+    # ── Prompt to install after -w (unless -i/-u already set) ───────────────
+    if write and not install and not update and not silent and total_written > 0:
+        console.print("  [dim]Run [cyan]uv sync[/] now? [bold](y/N)[/] [/]", end="")
+        try:
+            answer = input().strip().lower()
+        except EOFError, KeyboardInterrupt:
+            answer = ""
+            console.print()
+        if answer == "y":
+            install = True
+
+    # ── uv sync / install ────────────────────────────────────────────────────
+    if install or update:
+        uv_cwd = next(
+            (fp.parent for fp in resolved if fp.name == "pyproject.toml"),
+            root,
+        )
+        if not silent:
+            console.print("  [dim]Running [cyan]uv sync[/]…[/]")
+        result = subprocess.run(
+            ["uv", "sync"],
+            cwd=uv_cwd,
+            capture_output=silent,
+        )
+        if result.returncode != 0:
+            if not silent:
+                console.print("[red]✗[/]  [bold]uv sync[/] failed")
+            raise typer.Exit(result.returncode)
+        if not silent:
+            console.print("  [green]✓[/]  [bold]uv sync[/] complete")
+            console.print()
+
+    raise typer.Exit(1 if (fail_on_outdated and total_outdated) else 0)
+
+
+# ─── Helpers ──────────────────────────────────────────────────────────────────
+
+
+def _count_outdated(resolved: dict[Path, dict[str, list[DepInfo]]], mode: str) -> int:
+    return sum(
+        1
+        for groups in resolved.values()
+        for infos in groups.values()
+        for i in infos
+        if i.is_shown(mode)
+    )
+
+
+class _nullctx:
+    """No-op context manager (replaces console.status when --silent)."""
+
+    def __enter__(self) -> _nullctx:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        pass
+
+
+# ─── Entry point ──────────────────────────────────────────────────────────────
+
+
+def run() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    run()

taze/models.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+
+from packaging.requirements import Requirement
+from packaging.version import InvalidVersion, Version
+
+BUMP_ORDER: dict[str, int] = {"major": 3, "minor": 2, "patch": 1, "same": 0, "?": -1}
+
+BUMP_COLOR: dict[str, str] = {
+    "major": "red",
+    "minor": "yellow",
+    "patch": "green",
+    "same": "dim",
+    "?": "dim",
+}
+BUMP_BADGE: dict[str, str] = {
+    "major": "[bold red]MAJOR[/]",
+    "minor": "[yellow]minor[/]",
+    "patch": "[green]patch[/]",
+    "same": "[dim]up to date[/]",
+    "?": "[dim]?[/]",
+}
+
+# Mode → (min_bump_level, include_pre)
+# min_bump_level: only show updates at this level or above
+MODE_SETTINGS: dict[str, tuple[str, bool]] = {
+    "default": ("patch", False),
+    "major": ("patch", False),
+    "latest": ("patch", False),
+    "stable": ("patch", False),
+    "minor": ("patch", False),  # filter applied post-fetch
+    "patch": ("patch", False),  # filter applied post-fetch
+    "newest": ("patch", True),
+    "next": ("patch", True),
+}
+
+MODES = list(MODE_SETTINGS)
+
+# Which bump levels each mode actually shows
+MODE_MIN_BUMP: dict[str, str] = {
+    "default": "patch",
+    "major": "patch",
+    "latest": "patch",
+    "stable": "patch",
+    "newest": "patch",
+    "next": "patch",
+    "minor": "patch",  # no major bumps
+    "patch": "patch",  # no minor or major bumps
+}
+
+MODE_SHOWS_MAJOR: dict[str, bool] = {
+    "major": True,
+    "default": True,
+    "latest": True,
+    "stable": True,
+    "newest": True,
+    "next": True,
+    "minor": False,
+    "patch": False,
+}
+MODE_SHOWS_MINOR: dict[str, bool] = {
+    "major": True,
+    "default": True,
+    "latest": True,
+    "stable": True,
+    "newest": True,
+    "next": True,
+    "minor": True,
+    "patch": False,
+}
+
+
+class FileKind(StrEnum):
+    PYPROJECT = "pyproject"
+    REQUIREMENTS = "requirements"
+
+
+def calc_bump(current: str | None, latest: str | None) -> str:
+    if not current or not latest:
+        return "?"
+    try:
+        c = Version(current)
+        la = Version(latest)
+        if la <= c:
+            return "same"
+        if la.major > c.major:
+            return "major"
+        if la.minor > c.minor:
+            return "minor"
+        return "patch"
+    except InvalidVersion:
+        return "?"
+
+
+def bump_allowed(bump: str, mode: str) -> bool:
+    """Return True if this bump level should be shown/updated in the given mode."""
+    if bump in ("same", "?"):
+        return False
+    if bump == "major" and not MODE_SHOWS_MAJOR.get(mode, True):
+        return False
+    if bump == "minor" and not MODE_SHOWS_MINOR.get(mode, True):
+        return False
+    return True
+
+
+@dataclass
+class DepInfo:
+    raw: str
+    name: str
+    current: str | None
+    operator: str | None
+    source_file: Path | None = None
+    file_kind: FileKind = FileKind.PYPROJECT
+    line_number: int | None = None
+    latest: str | None = None
+    release_date: str | None = None  # ISO date of latest release
+    current_release_date: str | None = None  # ISO date of the current pinned release
+    bump: str = "?"
+    fetch_error: bool = False
+
+    @property
+    def current_spec(self) -> str:
+        if self.operator and self.current:
+            return f"{self.operator}{self.current}"
+        return "(any)"
+
+    @property
+    def latest_spec(self) -> str:
+        if not self.latest:
+            return "—"
+        if self.operator:
+            if self.operator == "~=":
+                n = len(self.current.split(".")) if self.current else 2
+                parts = self.latest.split(".")[:n]
+                return f"~={'.'.join(parts)}"
+            return f"{self.operator}{self.latest}"
+        return self.latest
+
+    @property
+    def is_outdated(self) -> bool:
+        return self.bump not in ("same", "?") and not self.fetch_error
+
+    def is_shown(self, mode: str) -> bool:
+        """True if this dep's update should be shown in the given mode."""
+        if self.fetch_error:
+            return True
+        if not self.is_outdated:
+            return False
+        return bump_allowed(self.bump, mode)
+
+    def updated_raw(self) -> str:
+        if not self.latest or not self.operator:
+            return self.raw
+        try:
+            req = Requirement(self.raw)
+        except Exception:
+            return self.raw
+
+        new_specs: list[str] = []
+        for spec in req.specifier:
+            if spec.operator in (">=", "==", ">"):
+                new_specs.append(f"{spec.operator}{self.latest}")
+            elif spec.operator == "~=":
+                n = len(spec.version.split("."))
+                parts = self.latest.split(".")[:n]
+                new_specs.append(f"~={'.'.join(parts)}")
+            else:
+                new_specs.append(str(spec))
+
+        extras = f"[{','.join(sorted(req.extras))}]" if req.extras else ""
+        return f"{req.name}{extras}{','.join(new_specs)}"

taze/parsers.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import re
+import tomllib
+from pathlib import Path
+
+from packaging.requirements import InvalidRequirement, Requirement
+
+from .models import DepInfo, FileKind
+
+
+def parse_dep_string(
+    raw: str,
+    *,
+    source_file: Path | None = None,
+    file_kind: FileKind = FileKind.PYPROJECT,
+    line_number: int | None = None,
+) -> DepInfo | None:
+    raw = raw.strip()
+    if not raw or raw.startswith(("#", "-")):
+        return None
+    raw = re.sub(r"\s+#.*$", "", raw).strip()
+    if not raw:
+        return None
+
+    try:
+        req = Requirement(raw)
+    except InvalidRequirement, Exception:
+        return None
+
+    name = req.name.lower().replace("_", "-")
+    specs = list(req.specifier)
+    current: str | None = None
+    operator: str | None = None
+
+    for op in ("==", ">=", "~=", ">"):
+        for spec in specs:
+            if spec.operator == op:
+                current = spec.version
+                operator = op
+                break
+        if current:
+            break
+
+    return DepInfo(
+        raw=raw,
+        name=name,
+        current=current,
+        operator=operator,
+        source_file=source_file,
+        file_kind=file_kind,
+        line_number=line_number,
+    )
+
+
+def parse_pyproject(path: Path) -> dict[str, list[str]]:
+    """Return group_label → raw dep strings from all recognised sections."""
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    groups: dict[str, list[str]] = {}
+
+    project_deps: list = data.get("project", {}).get("dependencies", [])
+    if project_deps:
+        groups["dependencies"] = [d for d in project_deps if isinstance(d, str)]
+
+    for grp, dep_list in (
+        data.get("project", {}).get("optional-dependencies", {}).items()
+    ):
+        groups[f"optional:{grp}"] = [d for d in dep_list if isinstance(d, str)]
+
+    for grp, dep_list in data.get("dependency-groups", {}).items():
+        str_deps = [d for d in dep_list if isinstance(d, str)]
+        if str_deps:
+            groups[f"group:{grp}"] = str_deps
+
+    uv_dev: list = data.get("tool", {}).get("uv", {}).get("dev-dependencies", [])
+    if uv_dev:
+        groups["dev-dependencies"] = [d for d in uv_dev if isinstance(d, str)]
+
+    return groups
+
+
+def parse_requirements_file(path: Path) -> list[tuple[int, str]]:
+    """Return (line_number, dep_string) pairs from a requirements file."""
+    result: list[tuple[int, str]] = []
+    for i, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+        stripped = line.strip()
+        if not stripped or stripped.startswith(("#", "-")):
+            continue
+        dep = re.sub(r"\s+#.*$", "", stripped).strip()
+        if dep:
+            result.append((i, dep))
+    return result
+
+
+def build_name_filter(pattern: str) -> re.Pattern[str] | None:
+    """
+    Build a compiled regex from a comma-separated list.
+    Entries wrapped in /slashes/ are treated as raw regex patterns;
+    plain names are matched literally (normalised to lowercase with hyphens).
+    """
+    parts = [p.strip() for p in pattern.split(",") if p.strip()]
+    if not parts:
+        return None
+    alternatives: list[str] = []
+    for p in parts:
+        if p.startswith("/") and p.endswith("/") and len(p) > 2:
+            alternatives.append(p[1:-1])
+        else:
+            alternatives.append(re.escape(p.lower().replace("_", "-")))
+    return re.compile(r"^(?:" + "|".join(alternatives) + r")$")

taze/pypi.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+import urllib.request
+from urllib.error import URLError
+
+from packaging.version import InvalidVersion, Version
+
+_USER_AGENT = "taze/0.1.0 (https://github.com/keksi/taze)"
+
+
+def fetch_pypi_info(
+    package: str,
+    *,
+    pre: bool = False,
+    current_version: str | None = None,
+) -> tuple[str | None, str | None, str | None]:
+    """
+    Return (latest_version, latest_release_date, current_release_date).
+    Dates are YYYY-MM-DD strings. All three are None on failure.
+    """
+    try:
+        url = f"https://pypi.org/pypi/{package}/json"
+        req = urllib.request.Request(url, headers={"User-Agent": _USER_AGENT})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+    except URLError, OSError, ValueError:
+        return None, None, None
+
+    info_version: str = data.get("info", {}).get("version", "")
+    releases: dict = data.get("releases", {})
+
+    current_date = _upload_date(releases, current_version) if current_version else None
+
+    # Fast path: trust info.version for stable-only queries
+    if not pre and info_version:
+        try:
+            v = Version(info_version)
+            if not v.is_prerelease and not v.is_devrelease:
+                return str(v), _upload_date(releases, info_version), current_date
+        except InvalidVersion:
+            pass
+
+    # Full scan — needed for --pre modes or when info.version is a pre-release
+    best: Version | None = None
+    for v_str, files in releases.items():
+        if not files:
+            continue
+        if all(f.get("yanked") for f in files):
+            continue
+        try:
+            v = Version(v_str)
+        except InvalidVersion:
+            continue
+        if not pre and (v.is_prerelease or v.is_devrelease):
+            continue
+        if best is None or v > best:
+            best = v
+
+    if best is None:
+        return None, None, current_date
+    return str(best), _upload_date(releases, str(best)), current_date
+
+
+def _upload_date(releases: dict, version: str | None) -> str | None:
+    if not version:
+        return None
+    files = releases.get(version) or releases.get(version.replace("-", "_")) or []
+    for f in files:
+        ts: str = f.get("upload_time", "")
+        if ts:
+            return ts[:10]  # YYYY-MM-DD
+    return None

taze/writers.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .models import DepInfo
+
+
+def write_pyproject_updates(path: Path, all_infos: dict[str, list[DepInfo]]) -> int:
+    """Replace outdated dep strings in pyproject.toml. Returns number of changes."""
+    content = path.read_text(encoding="utf-8")
+    count = 0
+
+    for _label, infos in all_infos.items():
+        for info in infos:
+            if not info.is_outdated:
+                continue
+            new_raw = info.updated_raw()
+            if new_raw == info.raw:
+                continue
+            # Handle both single and double-quoted TOML strings
+            for q in ('"', "'"):
+                old_quoted = re.escape(f"{q}{info.raw}{q}")
+                new_content = re.sub(old_quoted, f"{q}{new_raw}{q}", content)
+                if new_content != content:
+                    content = new_content
+                    count += 1
+                    break
+
+    path.write_text(content, encoding="utf-8")
+    return count
+
+
+def write_requirements_updates(path: Path, infos: list[DepInfo]) -> int:
+    """Update version specs in a requirements.txt file. Returns number of changes."""
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    count = 0
+
+    for info in infos:
+        if not info.is_outdated or info.line_number is None:
+            continue
+        new_raw = info.updated_raw()
+        if new_raw == info.raw:
+            continue
+        idx = info.line_number - 1
+        if idx >= len(lines):
+            continue
+        old_line = lines[idx]
+        # Preserve trailing comment and line ending
+        tail = re.search(r"(\s+#.*)$", old_line.rstrip("\n\r"))
+        comment = tail.group(1) if tail else ""
+        ending = old_line[len(old_line.rstrip("\n\r")) :]
+        lines[idx] = new_raw + comment + ending
+        count += 1
+
+    path.write_text("".join(lines), encoding="utf-8")
+    return count

taze-0.1.0.dist-info/METADATA

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: taze
+Version: 0.1.0
+Summary: 🥬 Keep your Python deps fresh
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: packaging>=26.2
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.26.7
+Description-Content-Type: text/markdown
+
+# taze 🥬
+
+Keep your Python dependencies fresh.
+
+Inspired by [taze](https://github.com/antfu-collective/taze) for Node.js — ported to the Python ecosystem with support for `pyproject.toml` and `requirements.txt`.
+
+---
+
+## Features
+
+- Checks all dependencies against PyPI in parallel
+- Shows the bump level (patch / minor / **MAJOR**) with colors
+- Displays release age for both the current and latest version
+- Supports `pyproject.toml` (PEP 508, PEP 735, uv) and `requirements*.txt`
+- Writes updated version constraints back to the file (`-w`)
+- Runs `uv sync` after writing (`-i`)
+- Interactive package selection (`-I`)
+- Recursive monorepo scanning (`-r`)
+- Pre-release support (`newest` / `next` mode)
+- Regex filtering for include / exclude
+
+---
+
+## Installation
+
+```sh
+uv tool install taze
+# or
+pip install taze
+```
+
+---
+
+## Usage
+
+```
+taze [mode] [options]
+```
+
+### Modes
+
+| Mode      | What it shows                          |
+|-----------|----------------------------------------|
+| `default` | All stable updates (default)           |
+| `major`   | Same as default                        |
+| `minor`   | Minor and patch updates only           |
+| `patch`   | Patch updates only                     |
+| `latest`  | All stable updates                     |
+| `stable`  | All stable updates                     |
+| `newest`  | All updates including pre-releases     |
+| `next`    | Same as newest                         |
+
+### Examples
+
+```sh
+# Check everything in the current directory
+taze
+
+# Only show minor and patch updates
+taze minor
+
+# Write patch updates back to pyproject.toml
+taze patch -w
+
+# Write all updates and run uv sync
+taze -w -i
+
+# Interactive — pick which packages to update
+taze -I
+
+# Include pre-releases
+taze newest
+
+# Scan all subdirectories (monorepo)
+taze -r
+
+# Only check specific packages
+taze -n requests,httpx
+
+# Skip packages matching a pattern
+taze -x /^pytest/
+
+# Sort by largest update first
+taze --sort diff-desc
+
+# Machine-readable JSON output
+taze --json
+```
+
+### Options
+
+```
+  -w, --write              Write updates back to file
+  -i, --install            Run uv sync after writing (implies -w)
+  -u, --update             Alias for --install
+  -I, --interactive        Choose which packages to update interactively
+  -r, --recursive          Scan subdirectories for pyproject.toml / requirements*.txt
+  -a, --all                Show up-to-date packages too
+  -n, --include <deps>     Only check these packages (comma-separated or /regex/)
+  -x, --exclude <deps>     Skip these packages (comma-separated or /regex/)
+  -C, --cwd <path>         Working directory
+  -s, --silent             No output
+  -v, --version            Show version
+      --sort <type>        Sort output: name-asc | name-desc | diff-asc | diff-desc
+      --fail-on-outdated   Exit with code 1 if any outdated dependencies are found
+      --concurrency <n>    Number of concurrent PyPI requests (default: 10)
+```
+
+---
+
+## Output
+
+```
+  📦  pyproject.toml  /home/user/myproject/pyproject.toml
+
+  dependencies  3 outdated
+    packaging  ~8mo  >=25.2     →  >=26.2     ~3mo  MAJOR
+    rich       ~4mo  >=14.0.0   →  >=15.0.0   ~3d   MAJOR
+    typer      ~6mo  >=0.25.7   →  >=0.26.7   ~3d   minor
+
+  group:dev  1 outdated
+    ruff       ~8mo  >=0.14.1   →  >=0.15.19  ~1d   minor
+
+  Run taze -w to write 4 update(s) to pyproject.toml
+```
+
+The age columns show how old the **current** pinned version is and how recently the **latest** version was released — green for < 4 weeks, yellow for < 6 months, red for older.
+
+---
+
+## Supported file formats
+
+| File                    | Section                            |
+|-------------------------|------------------------------------|
+| `pyproject.toml`        | `[project] dependencies`           |
+| `pyproject.toml`        | `[project.optional-dependencies.*]`|
+| `pyproject.toml`        | `[dependency-groups.*]` (PEP 735)  |
+| `pyproject.toml`        | `[tool.uv.dev-dependencies]`       |
+| `requirements*.txt`     | Standard pip format                |
+
+---
+
+## License
+
+MIT

taze-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+taze/__init__.py,sha256=LyNZkPBaiJXRs8v_6cxSTTTM1AzZ3_ukG7mp2UYSCOY,57
+taze/display.py,sha256=EpTj-vw-IJs18LM667M0OKgOEcovu8eoNnvjIt5Cfpk,7445
+taze/main.py,sha256=rHuZiSx2Rx94Pu_j14DrktQakG3fLr9F6NuclYTdEKM,17354
+taze/models.py,sha256=hzE4wWTykjU7mNUxogHPxig9Y_8e0JEDGlFoc4XYpV0,4928
+taze/parsers.py,sha256=QhkepCuf-4HDeuP3fis3qbX54cSBqo6pvFzT5qxZRMA,3429
+taze/pypi.py,sha256=4WkJD9-PgLKtxfwKxY0PhYBRPnavBchBG1SSXsHbYlI,2352
+taze/writers.py,sha256=5AcXG7pEXD2kiQJwToseGIw0xSnFQfk0xyW5RDvxQvw,1930
+taze-0.1.0.dist-info/METADATA,sha256=rFzVvURmoHeJ2Oq5SuoUTTuy9XOs4v_1BqA5vAFbJ5E,4324
+taze-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+taze-0.1.0.dist-info/entry_points.txt,sha256=b2bmaJT3y_KBijXe3tUSFD-7DTdNgGk395Az_wrt6Dc,39
+taze-0.1.0.dist-info/licenses/LICENSE,sha256=247Yhls8ejX4fDzpkJ4CwKXjMMlil7tOSN_N2UE88E8,1062
+taze-0.1.0.dist-info/RECORD,,

taze-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

taze-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+taze = taze.main:app

taze-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Keksi
+
+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.