python-auto-req 0.1.0__py3-none-any.whl

auto_req/__init__.py

@@ -0,0 +1,16 @@
+"""python-auto-req – scan project files and populate requirements.txt."""
+
+from .scanner import collect_imports, imports_from_source, imports_from_notebook, stdlib_module_names
+from .resolver import resolve_all, resolve_from_env, search_pypi, ngram_score
+
+__version__ = "0.1.0"
+__all__ = [
+    "collect_imports",
+    "imports_from_source",
+    "imports_from_notebook",
+    "stdlib_module_names",
+    "resolve_all",
+    "resolve_from_env",
+    "search_pypi",
+    "ngram_score",
+]

auto_req/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m auto_req"""
+from .cli import main
+import sys
+
+sys.exit(main())

auto_req/cli.py

@@ -0,0 +1,162 @@
+"""
+cli.py – command-line interface for python-auto-req.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+from .scanner import collect_imports, stdlib_module_names
+from .resolver import resolve_all
+
+
+# ---------------------------------------------------------------------------
+# requirements.txt helpers
+# ---------------------------------------------------------------------------
+
+
+def read_existing_requirements(path: Path) -> set[str]:
+    """Return lower-cased dist names already present in *path*."""
+    if not path.exists():
+        return set()
+    existing: set[str] = set()
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        name = re.split(r"[=<>!~\s\[;]", line)[0].lower()
+        existing.add(name)
+    return existing
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def main(argv: list[str] | None = None) -> int:
+    """
+    Run the scanner and optionally write requirements.txt.
+
+    Returns 0 on success, 1 on error.
+    """
+    parser = argparse.ArgumentParser(
+        prog="auto-req",
+        description=(
+            "Scan .py / .ipynb project files and add discovered third-party "
+            "packages to requirements.txt.\n\n"
+            "Only packages explicitly imported in your source files are considered.\n"
+            "Packages installed in .venv but never imported are ignored."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--dry-run",
+        type=int,
+        default=1,
+        metavar="0|1",
+        help="1 = preview only (default);  0 = write requirements.txt",
+    )
+    parser.add_argument(
+        "--auto",
+        action="store_true",
+        help="Always pick the top PyPI match for unknown modules (no prompts)",
+    )
+    parser.add_argument(
+        "--dir",
+        type=Path,
+        default=Path("."),
+        metavar="DIR",
+        help="Project root to scan  (default: current directory)",
+    )
+    parser.add_argument(
+        "--requirements",
+        type=Path,
+        default=Path("requirements.txt"),
+        metavar="FILE",
+        help="Path to requirements.txt  (default: ./requirements.txt)",
+    )
+    args = parser.parse_args(argv)
+
+    dry_run: bool = bool(args.dry_run)
+    root: Path = args.dir.resolve()
+    req_path: Path = args.requirements
+
+    print(f"Scanning : {root}")
+    print(f"Dry-run  : {dry_run}  (pass --dry-run 0 to write)")
+    print(f"Mode     : {'auto' if args.auto else 'interactive'}\n")
+
+    # ---- scan source files (excludes .venv and other non-project dirs) ----
+    stdlib = stdlib_module_names()
+    all_imports = collect_imports(root)
+
+    if not all_imports:
+        print("No imports detected.")
+        return 0
+
+    print(f"Imports found in project files: {len(all_imports)}")
+
+    # ---- resolve module names → dist names --------------------------------
+    resolved, skipped = resolve_all(all_imports, stdlib, args.auto)
+
+    # ---- compare against existing requirements.txt ------------------------
+    existing = read_existing_requirements(req_path)
+    new_pkgs = {
+        dist: ver
+        for dist, ver in resolved.items()
+        if dist.lower() not in existing
+    }
+
+    print(f"\nPackages resolved : {len(resolved)}")
+    print(f"Already in req    : {len(resolved) - len(new_pkgs)}")
+    print(f"New to add        : {len(new_pkgs)}")
+    if skipped:
+        print(f"Skipped (manual)  : {len(skipped)}  -> {', '.join(skipped)}")
+
+    if not new_pkgs:
+        print("\nrequirements.txt is already up-to-date.")
+        return 0
+
+    lines_to_add = [
+        f"{dist}=={ver}" if ver else dist
+        for dist, ver in sorted(new_pkgs.items())
+    ]
+
+    print("\nPackages to add:")
+    for line in lines_to_add:
+        print(f"  + {line}")
+
+    if dry_run:
+        print("\n[dry-run] No files were modified. Pass --dry-run 0 to apply.")
+        return 0
+
+    # ---- write ------------------------------------------------------------
+    with req_path.open("a", encoding="utf-8") as fh:
+        if req_path.exists() and req_path.stat().st_size > 0:
+            fh.write("\n")
+        fh.write("\n".join(lines_to_add) + "\n")
+
+    print(f"\nWritten to {req_path}  ({len(lines_to_add)} package(s) added).")
+
+    # ---- offer pip install ------------------------------------------------
+    try:
+        answer = input(f"\nRun 'pip install -r {req_path}' now? [y/N] ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return 0
+
+    if answer == "y":
+        print()
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "-r", str(req_path)],
+            check=False,
+        )
+        return result.returncode
+    else:
+        print("Skipped. Run it manually when ready.")
+
+    return 0

auto_req/resolver.py

@@ -0,0 +1,258 @@
+"""
+resolver.py – map imported module names to PyPI distribution names.
+
+Resolution order for each module:
+  1. Installed packages in the active Python environment  (no I/O)
+  2. PyPI search + interactive prompt  (or --auto for unattended use)
+"""
+
+from __future__ import annotations
+
+import sys
+import urllib.parse
+import urllib.request
+import re
+from importlib.metadata import PackageNotFoundError, packages_distributions
+from importlib.metadata import version as pkg_version
+
+
+# ---------------------------------------------------------------------------
+# Confident resolution: installed env only
+# ---------------------------------------------------------------------------
+
+
+def resolve_from_env(module: str) -> str | None:
+    """
+    Return the distribution name for *module* if it is installed in the
+    current environment, else None.
+
+    This uses only packages that are actually importable – it never surfaces
+    packages that happen to be in .venv but aren't referenced in project files.
+    The caller is responsible for only passing modules that were found by
+    scanning source files.
+    """
+    dists = packages_distributions().get(module)
+    return dists[0] if dists else None
+
+
+def installed_version(dist: str) -> str:
+    """Return the installed version of *dist*, or '' if not installed."""
+    try:
+        return pkg_version(dist)
+    except PackageNotFoundError:
+        return ""
+
+
+# ---------------------------------------------------------------------------
+# PyPI search + n-gram ranking
+# ---------------------------------------------------------------------------
+
+
+def search_pypi(query: str, n: int = 5) -> list[str]:
+    """
+    Return up to *n* package names from a PyPI simple search for *query*.
+    Returns an empty list on any network/parse failure.
+    """
+    url = "https://pypi.org/search/?" + urllib.parse.urlencode({"q": query})
+    try:
+        req = urllib.request.Request(
+            url, headers={"User-Agent": "python-auto-req/1.0 (github.com/Amit-Roy/python-auto-req)"}
+        )
+        with urllib.request.urlopen(req, timeout=8) as resp:
+            html = resp.read().decode("utf-8", errors="ignore")
+    except Exception as exc:
+        print(f"      [warn] PyPI search failed: {exc}")
+        return []
+
+    names = re.findall(
+        r'class="package-snippet__name"[^>]*>\s*([^\s<]+)\s*<', html
+    )
+    return names[:n]
+
+
+def ngram_score(a: str, b: str, n: int = 2) -> float:
+    """
+    Character n-gram Jaccard similarity in [0, 1].
+    Higher = more similar.
+    """
+    a, b = a.lower(), b.lower()
+    if not a or not b:
+        return 0.0
+
+    def ngrams(s: str) -> set[str]:
+        return {s[i : i + n] for i in range(len(s) - n + 1)} if len(s) >= n else {s}
+
+    sa, sb = ngrams(a), ngrams(b)
+    union = sa | sb
+    return len(sa & sb) / len(union) if union else 0.0
+
+
+def rank_candidates(module: str, candidates: list[str]) -> list[str]:
+    """Re-rank *candidates* by n-gram similarity to *module*, best first."""
+    return sorted(candidates, key=lambda c: -ngram_score(module, c))
+
+
+# ---------------------------------------------------------------------------
+# Interactive / auto prompt
+# ---------------------------------------------------------------------------
+
+
+class StopResolution(Exception):
+    """Raised when the user chooses to abort the resolution loop."""
+
+
+def _prompt(
+    module: str,
+    candidates: list[str],
+    auto_session: bool,
+) -> tuple[str | None, bool]:
+    """
+    Present the resolution menu for one unknown *module*.
+
+    Returns
+    -------
+    (dist_name, new_auto_session)
+        dist_name is None  → skip this module
+    Raises StopResolution when user presses [q].
+    """
+    if auto_session:
+        pick = candidates[0] if candidates else module
+        print(f"      [auto] '{module}' -> '{pick}'")
+        return pick, True
+
+    print(f"\n  Unrecognised module: '{module}'")
+    if candidates:
+        print("  Top PyPI matches:")
+        for i, name in enumerate(candidates, 1):
+            print(f"    [{i}] {name}  (similarity {ngram_score(module, name):.2f})")
+    else:
+        print("  No PyPI results found.")
+
+    print()
+    print("  [1-5] select a match above")
+    print("  [a]   auto-select top match for ALL remaining unknowns")
+    print("  [m]   enter the correct dist name manually")
+    print("  [s]   skip  (omit from requirements, continue)")
+    print("  [q]   quit  (stop resolution now)")
+    print()
+
+    while True:
+        try:
+            choice = input("  Your choice: ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            raise StopResolution
+
+        if choice == "q":
+            raise StopResolution
+
+        if choice == "s":
+            return None, False
+
+        if choice == "m":
+            try:
+                name = input("  Dist name: ").strip()
+            except (EOFError, KeyboardInterrupt):
+                print()
+                raise StopResolution
+            return (name or None), False
+
+        if choice == "a":
+            pick = candidates[0] if candidates else module
+            print(f"  [auto] '{module}' -> '{pick}'")
+            return pick, True
+
+        if choice.isdigit():
+            idx = int(choice) - 1
+            if 0 <= idx < len(candidates):
+                return candidates[idx], False
+            print(f"  Invalid number. Pick 1–{len(candidates)}.")
+            continue
+
+        print("  Unknown choice. Try again.")
+
+
+def resolve_via_pypi(
+    module: str,
+    auto_mode: bool,
+) -> tuple[str | None, bool]:
+    """
+    Search PyPI for *module* and resolve via prompt (or auto).
+
+    Returns
+    -------
+    (dist_name, updated_auto_mode)
+        dist_name is None → user chose to skip
+    Raises StopResolution on quit.
+    """
+    if not auto_mode:
+        print(f"\n  Searching PyPI for '{module}'...", end=" ", flush=True)
+
+    raw = search_pypi(module)
+    candidates = rank_candidates(module, raw) if raw else []
+
+    if not auto_mode:
+        print(f"{len(candidates)} result(s)." if candidates else "no results.")
+
+    return _prompt(module, candidates, auto_mode)
+
+
+# ---------------------------------------------------------------------------
+# Full resolution pipeline
+# ---------------------------------------------------------------------------
+
+
+def resolve_all(
+    module_names: set[str],
+    stdlib: set[str],
+    auto_mode: bool,
+) -> tuple[dict[str, str], list[str]]:
+    """
+    Resolve *module_names* (found by scanning project files) to a dict of
+    ``{dist_name: version}``.
+
+    Modules that are part of the stdlib or Python builtins are silently
+    ignored.  Unknown modules go through PyPI search + user interaction.
+
+    Parameters
+    ----------
+    module_names:
+        Top-level module names collected from project source files only.
+    stdlib:
+        Set of stdlib module names (from ``scanner.stdlib_module_names()``).
+    auto_mode:
+        When True, always pick the top PyPI result without prompting.
+
+    Returns
+    -------
+    packages:
+        ``{dist_name: installed_version_or_empty}``
+    skipped:
+        Module names the user chose to skip or that couldn't be resolved.
+    """
+    packages: dict[str, str] = {}
+    skipped: list[str] = []
+    auto_session = auto_mode
+
+    for module in sorted(module_names):
+        if module in stdlib or module in sys.builtin_module_names:
+            continue
+
+        # Fast path: installed in current env → confident mapping
+        dist = resolve_from_env(module)
+
+        if dist is None:
+            # Slow path: PyPI search + user input
+            try:
+                dist, auto_session = resolve_via_pypi(module, auto_session)
+            except StopResolution:
+                print("\n  Resolution stopped. Remaining modules skipped.")
+                break
+
+        if dist is None:
+            skipped.append(module)
+            continue
+
+        packages[dist] = installed_version(dist)
+
+    return packages, skipped

auto_req/scanner.py

@@ -0,0 +1,154 @@
+"""
+scanner.py – stdlib detection and import extraction from .py / .ipynb files.
+
+Only imports that are explicitly referenced in project source files are
+collected.  The virtual-environment directory (and other non-project paths)
+are excluded so that installed-but-unreferenced packages are never surfaced.
+"""
+
+from __future__ import annotations
+
+import ast
+import json
+import re
+import sys
+from pathlib import Path
+
+# Directories that are never part of project source code.
+_EXCLUDE_DIRS: frozenset[str] = frozenset(
+    {
+        ".venv",
+        "venv",
+        ".env",
+        "env",
+        "__pycache__",
+        ".git",
+        ".hg",
+        ".tox",
+        ".nox",
+        "node_modules",
+        "dist",
+        "build",
+        "site-packages",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+    }
+)
+
+
+# ---------------------------------------------------------------------------
+# stdlib detection
+# ---------------------------------------------------------------------------
+
+
+def stdlib_module_names() -> set[str]:
+    """Return the set of top-level stdlib module names for the running Python."""
+    if hasattr(sys, "stdlib_module_names"):  # Python 3.10+
+        return set(sys.stdlib_module_names)  # type: ignore[attr-defined]
+    # Fallback for older Python
+    import sysconfig
+
+    names: set[str] = set()
+    for key in ("stdlib", "platstdlib"):
+        p = sysconfig.get_paths().get(key, "")
+        if not p:
+            continue
+        for item in Path(p).iterdir():
+            names.add(item.stem if item.is_file() else item.name)
+    return names
+
+
+# ---------------------------------------------------------------------------
+# Import extraction
+# ---------------------------------------------------------------------------
+
+
+def imports_from_source(source: str) -> set[str]:
+    """
+    Parse *source* as Python and return every top-level imported module name.
+
+    Only absolute imports are considered (relative imports are project-internal).
+    Returns an empty set on SyntaxError rather than raising.
+    """
+    names: set[str] = set()
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return names
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            if node.module and node.level == 0:
+                names.add(node.module.split(".")[0])
+
+    return names
+
+
+def imports_from_notebook(path: Path) -> set[str]:
+    """
+    Parse a Jupyter notebook and return every top-level imported module name
+    across all code cells.
+    """
+    names: set[str] = set()
+    try:
+        nb = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return names
+
+    for cell in nb.get("cells", []):
+        if cell.get("cell_type") != "code":
+            continue
+        source = "".join(cell.get("source", []))
+        # Strip IPython line/cell magics and shell commands before parsing
+        source = re.sub(r"^\s*%%?\w+.*$", "", source, flags=re.MULTILINE)
+        source = re.sub(r"^\s*!.*$", "", source, flags=re.MULTILINE)
+        names |= imports_from_source(source)
+
+    return names
+
+
+# ---------------------------------------------------------------------------
+# Directory walker
+# ---------------------------------------------------------------------------
+
+
+def _is_excluded(path: Path) -> bool:
+    """Return True if *path* lives inside an excluded directory."""
+    return any(part in _EXCLUDE_DIRS for part in path.parts)
+
+
+def collect_imports(root: Path, self_path: Path | None = None) -> set[str]:
+    """
+    Recursively walk *root* and collect every top-level imported module name
+    from .py and .ipynb files, skipping excluded directories.
+
+    Parameters
+    ----------
+    root:
+        Directory to scan.
+    self_path:
+        Absolute path of this script/package – excluded from scanning so the
+        tool doesn't try to resolve its own imports.
+    """
+    names: set[str] = set()
+
+    for py in root.rglob("*.py"):
+        if _is_excluded(py.relative_to(root)):
+            continue
+        if self_path and py.resolve() == self_path:
+            continue
+        try:
+            names |= imports_from_source(py.read_text(encoding="utf-8", errors="ignore"))
+        except OSError:
+            pass
+
+    for nb in root.rglob("*.ipynb"):
+        if _is_excluded(nb.relative_to(root)):
+            continue
+        names |= imports_from_notebook(nb)
+
+    return names

python_auto_req-0.1.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: python-auto-req
+Version: 0.1.0
+Summary: Scan project source files and populate requirements.txt – with PyPI search and interactive resolution.
+Project-URL: Homepage, https://github.com/Amit-Roy/python-auto-req
+Project-URL: Repository, https://github.com/Amit-Roy/python-auto-req
+Project-URL: Issues, https://github.com/Amit-Roy/python-auto-req/issues
+Author-email: Amit Roy <a.roy.0593@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: dependencies,pypi,requirements,scanner
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# python-auto-req
+
+Scan your Python project's `.py` and `.ipynb` files, discover every third-party
+package that is actually **imported**, and add them to `requirements.txt`.
+
+> **Only packages explicitly referenced in your source files are considered.**
+> Packages installed in `.venv` but never imported are ignored.
+
+---
+
+## Features
+
+- Recursively scans `.py` and `.ipynb` files (skips `.venv`, `.git`, `__pycache__`, etc.)
+- Uses the active Python environment to resolve module → distribution name + version
+- Falls back to a **live PyPI search** for unknown modules with an interactive menu:
+  - Pick from top-5 results ranked by n-gram similarity
+  - Auto-select top match (`[a]` or `--auto`)
+  - Enter a name manually (`[m]`)
+  - Skip (`[s]`) or quit (`[q]`)
+- Offers to run `pip install -r requirements.txt` after writing
+
+---
+
+## Installation
+
+```bash
+pip install python-auto-req
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/Amit-Roy/python-auto-req
+cd python-auto-req
+pip install -e .
+```
+
+---
+
+## Usage
+
+```bash
+# Preview what would be added (dry-run, interactive)
+auto-req
+
+# Write requirements.txt
+auto-req --dry-run 0
+
+# Write requirements.txt, auto-pick top PyPI match for unknowns
+auto-req --dry-run 0 --auto
+
+# Scan a specific directory
+auto-req --dir /path/to/project --dry-run 0
+```
+
+Or via Python:
+
+```bash
+python -m auto_req --dry-run 0
+```
+
+### CLI options
+
+| Option | Default | Description |
+|---|---|---|
+| `--dry-run 0\|1` | `1` | `1` = preview only; `0` = write to file |
+| `--auto` | off | Always pick the top PyPI match (no prompts) |
+| `--dir DIR` | `.` | Project root to scan |
+| `--requirements FILE` | `./requirements.txt` | Path to requirements.txt |
+
+---
+
+## Interactive resolution example
+
+```
+  Unrecognised module: 'yfinance'
+  Searching PyPI for 'yfinance'... 5 result(s).
+  Top PyPI matches:
+    [1] yfinance       (similarity 1.00)
+    [2] yfinance-cache (similarity 0.78)
+    [3] yfinance-ez    (similarity 0.72)
+    ...
+
+  [1-5] select a match above
+  [a]   auto-select top match for ALL remaining unknowns
+  [m]   enter the correct dist name manually
+  [s]   skip  (omit from requirements, continue)
+  [q]   quit  (stop resolution now)
+
+  Your choice: 1
+```
+
+---
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+## Publishing to PyPI
+
+Publishing is handled automatically by GitHub Actions ([.github/workflows/publish.yml](.github/workflows/publish.yml)) whenever you push a version tag.
+
+### One-time PyPI Trusted Publisher setup
+
+1. Go to <https://pypi.org/manage/account/publishing/>
+2. Add a **pending publisher** with:
+   - **PyPI project name**: `python-auto-req`
+   - **GitHub owner**: `Amit-Roy`
+   - **Repository name**: `python-auto-req`
+   - **Workflow filename**: `publish.yml`
+   - **Environment name**: `pypi`
+3. On GitHub, create a repository **Environment** named `pypi`  
+   *(Settings → Environments → New environment)*
+
+### Releasing a new version
+
+```bash
+# 1. Bump the version in pyproject.toml (and src/auto_req/__init__.py)
+# 2. Commit and push
+git add pyproject.toml src/auto_req/__init__.py
+git commit -m "chore: release v0.2.0"
+git push
+
+# 3. Tag and push – this triggers the publish workflow
+git tag v0.2.0
+git push --tags
+```
+
+The workflow will:
+1. Run the full test matrix
+2. Build wheel + sdist
+3. Verify the tag matches the package version
+4. Publish to PyPI via OIDC (no API token required)
+
+### Local build (optional)
+
+```bash
+pip install -e ".[dev]"
+python -m build
+```
+
+MIT

python_auto_req-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+auto_req/__init__.py,sha256=9uUGtjOTIrWr1BWTEGSwlADe_OAUW96peL19_fokTTE,481
+auto_req/__main__.py,sha256=QXj_L91dBemDWwJDm0tGwZdcYvMm8mCVjbHYTM2lhcI,94
+auto_req/cli.py,sha256=Yfdp-ocpyu56ttdmdr87zXrmhHf3dnuYH4GT7qXhRNU,5050
+auto_req/resolver.py,sha256=D_0cUrv1wabo1ApNjb1AyFvb3EaGdn0ZpAS8HQ5zIf4,7977
+auto_req/scanner.py,sha256=jbvoDlXTN1bh8Aels58FWKLPNSVk4aeIZBk35h66wvI,4590
+python_auto_req-0.1.0.dist-info/METADATA,sha256=p-cGOcGT0e2_XwkA1-wM9HhpgtG8KA7oi5IoAwIs_Z0,4769
+python_auto_req-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_auto_req-0.1.0.dist-info/entry_points.txt,sha256=i1vr2iQDlMqhTVYuV8z40Uc1x4qLJHZ-ZTYIxkJSI8w,47
+python_auto_req-0.1.0.dist-info/licenses/LICENSE,sha256=ESYyLizI0WWtxMeS7rGVcX3ivMezm-HOd5WdeOh-9oU,1056
+python_auto_req-0.1.0.dist-info/RECORD,,

python_auto_req-0.1.0.dist-info/WHEEL

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

python_auto_req-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+auto-req = auto_req.cli:main

python_auto_req-0.1.0.dist-info/licenses/LICENSE

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