reqsync 0.1.0__py3-none-any.whl

reqsync/__init__.py

@@ -0,0 +1,15 @@
+# src/reqsync/__init__.py
+
+from .core import sync
+
+__all__ = ["sync"]
+
+try:
+    from importlib.metadata import PackageNotFoundError, version
+except Exception:  # py<3.8 backport if installed
+    from importlib_metadata import PackageNotFoundError, version  # type: ignore
+
+try:
+    __version__ = version("reqsync")
+except PackageNotFoundError:
+    __version__ = "0.0.0+dev"

reqsync/_logging.py

@@ -0,0 +1,40 @@
+# src/reqsync/_logging.py
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+
+def setup_logging(verbosity: int, quiet: bool, log_file: Path | None) -> None:
+    """
+    Configure root logger with console and optional file sink.
+    Verbosity: 0 WARNING, 1 INFO, 2+ DEBUG. Quiet forces WARNING.
+    """
+    if quiet:
+        level = logging.WARNING
+    elif verbosity >= 2:
+        level = logging.DEBUG
+    elif verbosity == 1:
+        level = logging.INFO
+    else:
+        level = logging.WARNING
+
+    logger = logging.getLogger()
+    logger.handlers.clear()
+    logger.setLevel(level)
+
+    console_formatter = logging.Formatter("%(message)s")
+    ch = logging.StreamHandler(sys.stderr)
+    ch.setLevel(level)
+    ch.setFormatter(console_formatter)
+    logger.addHandler(ch)
+
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_formatter = logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+        fh = logging.FileHandler(log_file, encoding="utf-8")
+        fh.setLevel(logging.DEBUG)
+        fh.setFormatter(file_formatter)
+        logger.addHandler(fh)

reqsync/_types.py

@@ -0,0 +1,102 @@
+# src/reqsync/_types.py
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Literal, TypedDict
+
+Policy = Literal["lower-bound", "floor-only", "floor-and-cap"]
+
+
+class ExitCode:
+    OK = 0
+    GENERIC_ERROR = 1
+    MISSING_FILE = 2
+    HASHES_PRESENT = 3
+    PIP_FAILED = 4
+    PARSE_ERROR = 5
+    CONSTRAINT_CONFLICT = 6
+    SYSTEM_PYTHON_BLOCKED = 7
+    DIRTY_REPO_BLOCKED = 8
+    WRITE_FAILED_ROLLED_BACK = 10
+    CHANGES_WOULD_BE_MADE = 11
+
+
+@dataclass
+class Options:
+    path: Path
+    follow_includes: bool = True
+    update_constraints: bool = False
+    policy: Policy = "lower-bound"
+    allow_prerelease: bool = False
+    keep_local: bool = False
+    no_upgrade: bool = False
+    pip_timeout_sec: int = 900
+    pip_args: str = ""
+    only: Sequence[str] = ()
+    exclude: Sequence[str] = ()
+    check: bool = False
+    dry_run: bool = False
+    show_diff: bool = False
+    json_report: Path | None = None
+    backup_suffix: str = ".bak"
+    timestamped_backups: bool = True
+    log_file: Path | None = None
+    verbosity: int = 0
+    quiet: bool = False
+    system_ok: bool = False
+    allow_hashes: bool = False
+    allow_dirty: bool = True
+    last_wins: bool = False
+
+
+@dataclass
+class Change:
+    package: str
+    installed_version: str
+    old_line: str
+    new_line: str
+    file: Path
+
+
+@dataclass
+class FileChange:
+    file: Path
+    changes: list[Change] = field(default_factory=list)
+    original_text: str = ""
+    new_text: str = ""
+
+
+@dataclass
+class Result:
+    changed: bool
+    files: list[FileChange]
+    diff: str | None = None
+    backup_paths: list[Path] = field(default_factory=list)
+
+
+class JsonChange(TypedDict):
+    file: str
+    package: str
+    installed_version: str
+    old_line: str
+    new_line: str
+
+
+class JsonReport(TypedDict):
+    files: list[str]
+    changes: list[JsonChange]
+
+
+__all__ = [
+    "Change",
+    "ExitCode",
+    "FileChange",
+    "JsonChange",
+    "JsonReport",
+    "Options",
+    "Policy",
+    "Result",
+]

reqsync/cli.py

@@ -0,0 +1,120 @@
+# src/reqsync/cli.py
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from click.core import ParameterSource
+
+from ._logging import setup_logging
+from ._types import ExitCode, Options
+from .config import load_project_config, merge_options
+from .core import sync
+
+
+class PolicyEnum(str, Enum):
+    LOWER_BOUND = "lower-bound"
+    FLOOR_ONLY = "floor-only"
+    FLOOR_AND_CAP = "floor-and-cap"
+
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="Synchronize requirements.txt to >= installed versions safely.",
+)
+
+
+# FIX: Revert to @app.callback() to create a single-command app.
+# This aligns with the test runner's expectation and eliminates the "unexpected argument" error.
+@app.callback(invoke_without_command=True)
+def main_cli(
+    ctx: typer.Context,
+    path: Path = typer.Option(
+        Path("requirements.txt"),
+        "--path",
+        help="Path to requirements.txt",
+        dir_okay=False,
+    ),
+    follow_includes: bool = typer.Option(True, help="Follow -r includes recursively"),
+    update_constraints: bool = typer.Option(False, help="Allow updating constraint files"),
+    policy: PolicyEnum = typer.Option(
+        PolicyEnum.LOWER_BOUND,
+        help="Policy: lower-bound | floor-only | floor-and-cap",
+    ),
+    allow_prerelease: bool = typer.Option(False, help="Adopt pre/dev versions"),
+    keep_local: bool = typer.Option(False, help="Keep local version suffixes (+local)"),
+    no_upgrade: bool = typer.Option(False, help="Do not run pip upgrade; just rewrite to current env"),
+    pip_timeout_sec: int = typer.Option(900, help="Timeout for pip upgrade in seconds"),
+    pip_args: str = typer.Option("", help="Allowlisted pip args to pass through"),
+    only: Optional[str] = typer.Option(None, help="Comma-separated package globs to include"),
+    exclude: Optional[str] = typer.Option(None, help="Comma-separated package globs to exclude"),
+    check: bool = typer.Option(False, help="Exit nonzero if changes would be made"),
+    dry_run: bool = typer.Option(False, help="Preview changes without writing"),
+    show_diff: bool = typer.Option(False, help="Show unified diff"),
+    json_report: Optional[Path] = typer.Option(None, help="Write JSON report to this path"),
+    backup_suffix: str = typer.Option(".bak", help="Backup suffix"),
+    timestamped_backups: bool = typer.Option(True, help="Use timestamped backups"),
+    log_file: Optional[Path] = typer.Option(None, help="Optional log file path"),
+    verbosity: int = typer.Option(0, "--verbose", "-v", count=True, help="Increase logging verbosity"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Reduce logging"),
+    system_ok: bool = typer.Option(False, help="Allow running outside a venv"),
+    allow_hashes: bool = typer.Option(False, help="Skip hashed stanzas instead of refusing"),
+    allow_dirty: bool = typer.Option(True, help="Allow running with dirty git repo"),
+    last_wins: bool = typer.Option(False, help="If duplicates across includes, last definition wins"),
+    use_config: bool = typer.Option(True, help="Load reqsync.toml or [tool.reqsync] from pyproject"),
+) -> None:
+    """
+    Upgrade env and rewrite requirements to >= installed versions while preserving formatting.
+    """
+    setup_logging(verbosity=verbosity, quiet=quiet, log_file=log_file)
+    opts = Options(path=Path("requirements.txt"))
+    if use_config:
+        config_from_file = load_project_config(Path(".").resolve())
+        opts = merge_options(opts, config_from_file)
+    cli_overrides: dict[str, Any] = {
+        k: v for k, v in ctx.params.items() if ctx.get_parameter_source(k) is not ParameterSource.DEFAULT
+    }
+    opts = merge_options(opts, cli_overrides)
+    try:
+        result = sync(opts)
+    except FileNotFoundError:
+        typer.secho(f"Requirements file not found: {opts.path}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(ExitCode.MISSING_FILE) from None
+    except RuntimeError as err:
+        msg = str(err)
+        if "hash pins" in msg:
+            code = ExitCode.HASHES_PRESENT
+        elif "Refusing to run outside a virtualenv" in msg:
+            code = ExitCode.SYSTEM_PYTHON_BLOCKED
+        elif "pip install -U failed" in msg:
+            code = ExitCode.PIP_FAILED
+        elif "Write failed and backups restored" in msg:
+            code = ExitCode.WRITE_FAILED_ROLLED_BACK
+        else:
+            code = ExitCode.GENERIC_ERROR
+        typer.secho(msg, fg=typer.colors.RED, err=True)
+        raise typer.Exit(code) from err
+
+    if opts.json_report:
+        from .report import to_json_report, write_json_report
+
+        write_json_report(to_json_report(result.files), str(opts.json_report))
+
+    if result.changed:
+        if opts.show_diff or opts.dry_run:
+            typer.echo(result.diff or "")
+        if opts.check:
+            raise typer.Exit(ExitCode.CHANGES_WOULD_BE_MADE) from None
+
+    raise typer.Exit(ExitCode.OK) from None
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

reqsync/config.py

@@ -0,0 +1,121 @@
+# src/reqsync/config.py
+from __future__ import annotations
+
+import importlib
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from ._types import Options
+
+
+# Dynamically import tomllib (3.11+) or fall back to tomli; avoid static imports so mypy won't
+# require stubs for tomllib on older interpreters.
+def _import_toml_like() -> Any:
+    mod = None
+    try:
+        mod = importlib.import_module("tomllib")  # Python 3.11+
+    except Exception:
+        try:
+            mod = importlib.import_module("tomli")  # Backport
+        except Exception:
+            mod = None
+    return mod
+
+
+toml: Any = _import_toml_like()
+
+
+def _load_toml(path: Path) -> dict[str, Any]:
+    if not toml:
+        return {}
+    try:
+        with open(path, "rb") as f:
+            data = toml.load(f)
+            return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def load_project_config(start_dir: Path) -> dict[str, Any]:
+    cfg: dict[str, Any] = {}
+
+    # reqsync.toml
+    rs = start_dir / "reqsync.toml"
+    if rs.exists():
+        cfg.update(_load_toml(rs))
+
+    # pyproject [tool.reqsync]
+    pyproj = start_dir / "pyproject.toml"
+    if pyproj.exists():
+        data = _load_toml(pyproj)
+        tool = data.get("tool") or {}
+        section = tool.get("reqsync") or {}
+        if isinstance(section, dict):
+            cfg.update(section)
+
+    # JSON fallback
+    rj = start_dir / "reqsync.json"
+    if rj.exists():
+        try:
+            cfg.update(json.loads(rj.read_text(encoding="utf-8")))
+        except Exception as e:
+            logging.warning("Failed to parse reqsync.json: %s", e)
+
+    return cfg
+
+
+def _to_path(v: Any) -> Path | None:
+    if v in (None, "", "."):
+        return None
+    try:
+        return Path(str(v))
+    except Exception:
+        return None
+
+
+def _to_tuple(v: Any) -> tuple[str, ...]:
+    if v is None:
+        return ()
+    if isinstance(v, (list, tuple)):
+        return tuple(str(x).strip() for x in v if str(x).strip())
+    if isinstance(v, str):
+        return tuple(p for p in (s.strip() for s in v.split(",")) if p)
+    return ()
+
+
+def merge_options(base: Options, overrides: dict[str, Any]) -> Options:
+    # Don't let config override an explicit CLI --path
+    cfg_path = _to_path(overrides.get("path"))
+    if cfg_path and Path(str(base.path)) == Path("requirements.txt"):
+        effective_path = cfg_path
+    else:
+        effective_path = base.path
+
+    return Options(
+        path=effective_path,
+        follow_includes=overrides.get("follow_includes", base.follow_includes),
+        update_constraints=overrides.get("update_constraints", base.update_constraints),
+        policy=overrides.get("policy", base.policy),
+        allow_prerelease=overrides.get("allow_prerelease", base.allow_prerelease),
+        keep_local=overrides.get("keep_local", base.keep_local),
+        no_upgrade=overrides.get("no_upgrade", base.no_upgrade),
+        pip_timeout_sec=int(overrides.get("pip_timeout_sec", base.pip_timeout_sec)),
+        pip_args=str(overrides.get("pip_args", base.pip_args)),
+        only=_to_tuple(overrides.get("only")) or base.only,
+        exclude=_to_tuple(overrides.get("exclude")) or base.exclude,
+        check=overrides.get("check", base.check),
+        dry_run=overrides.get("dry_run", base.dry_run),
+        show_diff=overrides.get("show_diff", base.show_diff),
+        json_report=_to_path(overrides.get("json_report")) or base.json_report,
+        backup_suffix=str(overrides.get("backup_suffix", base.backup_suffix)),
+        timestamped_backups=overrides.get("timestamped_backups", base.timestamped_backups),
+        log_file=_to_path(overrides.get("log_file")) or base.log_file,
+        verbosity=int(overrides.get("verbosity", base.verbosity)),
+        quiet=overrides.get("quiet", base.quiet),
+        system_ok=overrides.get("system_ok", base.system_ok),
+        allow_hashes=overrides.get("allow_hashes", base.allow_hashes),
+        allow_dirty=overrides.get("allow_dirty", base.allow_dirty),
+        last_wins=overrides.get("last_wins", base.last_wins),
+    )

reqsync/core.py

@@ -0,0 +1,214 @@
+# src/reqsync/core.py
+
+from __future__ import annotations
+
+import fnmatch
+import logging
+import shutil
+from pathlib import Path
+
+from packaging.utils import canonicalize_name
+
+from . import env as env_mod
+from . import report as report_mod
+from ._types import Change, FileChange, Options, Result
+from .io import backup_file, read_text_preserve, write_text_preserve
+from .parse import find_constraints, find_includes, guard_hashes, parse_line
+from .policy import CapStrategy, apply_policy
+
+
+def _match(name: str, patterns: list[str]) -> bool:
+    return any(fnmatch.fnmatch(name, p) for p in patterns)
+
+
+def _resolve_includes(root: Path, follow: bool) -> list[Path]:
+    files: list[Path] = [root]
+    if not follow or not root.exists():
+        return files
+    seen = {root.resolve()}
+    queue = [root]
+    while queue:
+        cur = queue.pop()
+        text, _, _ = read_text_preserve(cur)
+        for rel in find_includes(text.splitlines()):
+            inc = (cur.parent / rel).resolve()
+            if inc.exists() and inc not in seen:
+                seen.add(inc)
+                files.append(inc)
+                queue.append(inc)
+    return files
+
+
+def _should_skip_pkg(pkg_name: str, only: list[str], exclude: list[str]) -> bool:
+    if only and not _match(pkg_name, only):
+        return True
+    if exclude and _match(pkg_name, exclude):
+        return True
+    return False
+
+
+def _rewrite_text(
+    path: Path,
+    text: str,
+    installed: dict[str, str],
+    options: Options,
+    cap: CapStrategy | None,
+) -> tuple[str, list[Change]]:
+    lines = text.splitlines(keepends=True)
+    out_lines: list[str] = []
+    changes: list[Change] = []
+    for line in lines:
+        parsed = parse_line(line)
+        kind = parsed.kind
+
+        if kind != "package":
+            out_lines.append(line)
+            continue
+
+        req = parsed.requirement
+        if not req:
+            out_lines.append(line)
+            continue
+
+        base = canonicalize_name(req.name)
+        if _should_skip_pkg(base, list(options.only), list(options.exclude)):
+            out_lines.append(line)
+            continue
+
+        if base not in installed:
+            logging.warning("Not installed after upgrade: %s (kept)", req.name)
+            out_lines.append(line)
+            continue
+
+        new_content = apply_policy(
+            req=req,
+            installed_version=installed[base],
+            policy=options.policy,
+            allow_prerelease=options.allow_prerelease,
+            keep_local=options.keep_local,
+            cap_strategy=cap,
+        )
+
+        if new_content is None:
+            out_lines.append(line)
+            continue
+
+        new_line = new_content + parsed.comment + parsed.eol
+        if new_line != line:
+            changes.append(
+                Change(
+                    package=req.name,
+                    installed_version=installed[base],
+                    old_line=line,
+                    new_line=new_line,
+                    file=path,
+                )
+            )
+            out_lines.append(new_line)
+        else:
+            out_lines.append(line)
+
+    return "".join(out_lines), changes
+
+
+def sync(options: Options) -> Result:
+    """
+    Orchestrate upgrade and rewrite.
+    Raises RuntimeError with clear messages for fatal conditions.
+    """
+    logging.info("Starting reqsync")
+    # This now calls the alias at the bottom of the file, which the test can patch
+    ensure_venv_or_exit(options.system_ok)
+    root = options.path
+    logging.info("Reading %s", root)
+
+    root = options.path
+    if not root.exists():
+        raise FileNotFoundError(str(root))
+
+    # The file_lock context manager has been removed.
+    # The logic is now at the top level of the function.
+    logging.info("Reading and parsing requirements files...")
+    root_text, _, _ = read_text_preserve(root)
+    try:
+        guard_hashes(root_text.splitlines(), allow_hashes=options.allow_hashes)
+    except ValueError as e:
+        raise RuntimeError(str(e)) from e
+
+    if not options.no_upgrade:
+        logging.info("Upgrading environment via pip (may take a while)...")
+        # This now calls the alias at the bottom of the file
+        code, _ = run_pip_upgrade(str(root), timeout_sec=options.pip_timeout_sec, extra_args=options.pip_args)
+        if code != 0:
+            raise RuntimeError("pip install -U failed. See logs.")
+        logging.info("Environment upgrade complete.")
+
+    logging.info("Inspecting installed packages...")
+    # This now calls the alias at the bottom of the file
+    installed = get_installed_versions()
+
+    files = _resolve_includes(root, follow=options.follow_includes)
+    logging.info("Resolved %d file(s) (follow_includes=%s)", len(files), options.follow_includes)
+    file_results: list[FileChange] = []
+    aggregate_changes: list[Change] = []
+    cap = CapStrategy(default="next-major")
+    file_properties: dict[Path, tuple[bool]] = {}
+
+    for f in files:
+        text, _, bom = read_text_preserve(f)
+        file_properties[f] = (bom,)
+        constraints = find_constraints(text.splitlines())
+        if constraints and not options.update_constraints and f != root:
+            file_results.append(FileChange(file=f, original_text=text, new_text=text, changes=[]))
+            continue
+
+        new_text, changes = _rewrite_text(f, text, installed, options, cap)
+        if changes:
+            aggregate_changes.extend(changes)
+        file_results.append(FileChange(file=f, original_text=text, new_text=new_text, changes=changes))
+
+    changed = any(fr.original_text != fr.new_text for fr in file_results)
+
+    if options.check:
+        diff = report_mod.make_diff(file_results) if changed and (options.show_diff or options.dry_run) else None
+        logging.info("Check complete. Changes detected: %s", changed)
+        return Result(changed=True, files=file_results, diff=diff)
+
+    if options.dry_run:
+        diff = report_mod.make_diff(file_results) if changed and options.show_diff else None
+        logging.info("Dry run complete. Changes detected: %s", changed)
+        return Result(changed=changed, files=file_results, diff=diff)
+
+    backups: list[Path] = []
+    if changed:
+        logging.info("Writing %d change(s) to disk...", len(aggregate_changes))
+        for fr in file_results:
+            if fr.original_text == fr.new_text:
+                continue
+            backup = backup_file(fr.file, options.backup_suffix, options.timestamped_backups)
+            backups.append(backup)
+            try:
+                bom = file_properties.get(fr.file, (False,))[0]
+                write_text_preserve(fr.file, fr.new_text, bom)
+            except Exception as e:
+                for b in backups:
+                    orig = b
+                    target = Path(str(b).rsplit(options.backup_suffix, 1)[0])
+                    try:
+                        shutil.copy2(orig, target)
+                    except Exception:
+                        pass
+                raise RuntimeError(f"Write failed and backups restored: {e}") from e
+
+    diff = report_mod.make_diff(file_results) if changed and options.show_diff else None
+    logging.info("Reqsync process finished.")
+    return Result(changed=changed, files=file_results, diff=diff, backup_paths=backups)
+
+
+# --- Back-compat test shims ---------------------------------------------------
+# Tests (and possibly external callers) patch these names on the core module.
+# Keep them as aliases to the env module so monkeypatching still works.
+get_installed_versions = env_mod.get_installed_versions
+ensure_venv_or_exit = env_mod.ensure_venv_or_exit
+run_pip_upgrade = env_mod.run_pip_upgrade
+is_venv_active = env_mod.is_venv_active