Metadata-Version: 2.5
Name: pip-auto
Version: 0.8.0
Summary: Just import it. Missing packages install themselves - fast, safe, and in your language.
License-Expression: MIT
License-File: LICENSE
Keywords: auto-install,dependencies,import,installer,pep723,pip
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: Natural Language :: Chinese (Simplified)
Classifier: Natural Language :: Chinese (Traditional)
Classifier: Natural Language :: English
Classifier: Natural Language :: French
Classifier: Natural Language :: German
Classifier: Natural Language :: Japanese
Classifier: Natural Language :: Korean
Classifier: Natural Language :: Portuguese
Classifier: Natural Language :: Russian
Classifier: Natural Language :: Spanish
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
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: Programming Language :: Python :: 3.14
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: System :: Software Distribution
Requires-Python: >=3.8
Description-Content-Type: text/markdown

# pip-auto

**Just `import` it. Missing packages install themselves.**

```bash
pip install pip-auto
```

That's the whole setup. From now on, when your code imports something that isn't installed, pip-auto finds the
right package on PyPI, installs it on the spot, and your program keeps running — no `ModuleNotFoundError`,
no stopping to run `pip install`, no restarting.

```python
import pyfiglet               # not installed? fine
from PIL import Image         # import name ≠ package name? fine (installs pillow)
import cv2                    # installs opencv-python
print(pyfiglet.figlet_format("hello"))
```

```
[autopip] 'pyfiglet' not found → installing pyfiglet
[autopip] installed pyfiglet==1.0.4 (2.51s)
```

## Why it's nice

- **Zero setup.** `pip install pip-auto` turns it on for that Python. `pip uninstall pip-auto` removes every trace.
- **It knows the real package name.** `PIL` → `pillow`, `cv2` → `opencv-python`, `sklearn` → `scikit-learn`,
  `bs4` → `beautifulsoup4`, `google.generativeai` → `google-generativeai`, plus ~1,000 more mappings — and it
  learns new ones from every wheel it sees. Before installing, it **opens the wheel and checks the module is really
  inside**, so a same-named impostor never gets installed.
- **Fast.** Its own installer (pip is not used): the whole dependency tree is discovered in parallel over one shared
  connection setup, and every file of every wheel is written in a single parallel pass. From the second time on it just
  hard-links from a local cache (filled in the background, at low priority).
  Installing requests + numpy + pandas + flask + rich (22 packages) into a fresh environment on one Windows PC:
  **pip ≈ 55 s → pip-auto ≈ 4 s → ≈ 1 s the second time** (slower when the machine is busy). Heavy set (numpy, pandas, scipy,
  matplotlib, scikit-learn, pillow; 19 packages, 7,757 files): **pip 161 s / 94 s → uv 11 s / 17 s → pip-auto ≈ 10 s / ≈ 1 s**
  (first / second install; first-install time is mostly network and disk writes, so it varies). On Windows the second install
  links whole package folders (junctions) instead of thousands of files. It adds only about
  **5 ms** to Python startup.
- **Safe.** Names that look like popular packages (typosquats such as `requets`) and brand-new unknown packages are
  never installed automatically. If anything fails halfway, everything — including the old versions it replaced — is
  rolled back.
- **Respects "optional" imports.** `try: import x / except ImportError:` in your code, optional imports inside
  libraries, and `importlib.util.find_spec("x")` checks are left alone.
- **Works everywhere you run Python:** scripts, Jupyter / IPython, virtual environments.
- **Speaks your language.** Messages follow your OS language: English, 日本語, 简体中文, 繁體中文, 한국어,
  Español, Français, Deutsch, Português, Русский.

## Tell it what you want (optional)

```python
# /// script
# dependencies = ["requests<3", "rich"]
# ///
import requests, rich            # a PEP 723 block is installed up front, all at once
import numpy  # autopip: numpy<2   ← pin a version with an end-of-line comment
```

## Project settings: allow / deny lists (optional)

Put an `autopip.toml` (or a `[tool.autopip]` table in `pyproject.toml`) next to your scripts. `autopip init` creates one.

```toml
[autopip]
allow = ["requests<3", "numpy", "types-*"]   # only these may be installed automatically (versions and wildcards OK)
deny  = ["evil-pkg"]                         # never — even when something else needs it as a dependency
constraints = ["numpy<2"]                    # version limits for automatic installs (same as pip -c)
ask = true                                   # settings here override your personal ones
```

It is looked up from the script's folder upwards and applies to automatic installs only (imports, `autopip run`, PEP 723);
what you type yourself with `autopip install` is never blocked. `autopip policy [x.py] [pkg...]` shows what is in effect
and whether a package would be allowed. With a settings file present, autopip never falls back to plain `pip`
(which would bypass the lists).

## One-file bundles

```bash
autopip bundle app.py            # → app.pyz
python app.pyz                   # the other person needs nothing else installed
```

`app.py`, the local modules it imports, and every dependency are packed into **one solid-compressed block** (all files
concatenated, compressed once — smaller than zipping file by file: e.g. 28 MB of wheels → 18 MB). At run time the block
is decompressed in a single streaming pass while files are written in parallel, then cached; later runs start instantly.

Bundles that contain compiled packages (numpy, …) are tied to the Python version and OS they were built for. For those,
**all bytecode goes into one code-archive file** instead of thousands of `.py`/`.pyc` files: a tiny import hook loads
modules straight from it (sources are kept inside, so tracebacks and `inspect.getsource` still show code), and only real
files — `.pyd`/`.so`, data — are written to disk. Example (numpy + pandas + flask + rich + requests): 7,357 files → 2,022;
first run ≈ 8 s instead of ≈ 40 s. Child processes (`multiprocessing` spawn) work too. Pure-Python bundles are portable and
are extracted as ordinary files.

Options: `--codec lzma|zlib|none`, `--level N`, `--include "pkg==1.0"`, `--loose` (ordinary files, no code archive),
`--no-pyc`, `--info app.pyz`, `--diff old.pyz new.pyz` (which packages and files changed). The loader depends on nothing but the standard library. Limitation: with
`python -S` / `-I` (no `site`), child processes cannot use the code archive.

## Commands

| Command | What it does |
|---|---|
| `autopip run x.py` | Install everything `x.py` needs first, then run it (`--venv` creates and uses `.venv` next to it) |
| `autopip lock x.py` | Write `x.autopip.lock` with every version **and sha256** pinned; `run` then installs exactly that |
| `autopip install ...` | **Same syntax as `pip install`**: `-r requirements.txt` (nested `-r`, `-c`, `--hash`, `-i`), `-e .`, `-U`, `--no-deps`, `--force-reinstall`, `--dry-run`, `-t DIR`, `--user` (`--dry-run` prints a per-package plan: new / upgrade) |
| `autopip uninstall pkg...` | Remove (also `-r file`) |
| `autopip list [--outdated]` / `show pkg` | Installed packages / packages with newer versions / details |
| `autopip upgrade pkg...` / `--all` | Upgrade (`--dry-run` to only show) |
| `autopip freeze [x.py]` | Pin what a script uses (`--requirements`, `--pep723`), or the whole environment |
| `autopip clean [--days 30] [--yes]` | Remove auto-installed packages you haven't used for a while |
| `autopip bundle x.py` | Pack a script + dependencies into one solid-compressed file: `python x.pyz` |
| `autopip init` / `policy` | Create / inspect the project settings file (allow / deny lists) |
| `autopip gui` | Browser dashboard: sizes, last used, clean-up, settings (127.0.0.1 only) |
| `autopip doctor [--fix]` | Diagnose the setup (hook, cache, settings file, PyPI); `--fix` repairs the hook file, leftovers of interrupted installs and broken links |
| `autopip check pkg` | Run the safety check only |
| `autopip off` / `on` | Turn it off / back on |

`AUTOPIP_DISABLE=1` turns it off for a single command.

## Settings (`autopip config KEY VALUE`)

- `ask` — `true` to confirm before every install (asks on the console; never installs when nobody can answer)
- `safety` — `strict` (default) / `warn` / `off`
- `link_mode` — `junction` (default on Windows, fastest: one folder link per package instead of one link per file) / `hardlink` (default elsewhere) / `copy` (separate files per environment). With `junction` and `hardlink` the files are shared with the cache (`~/.autopip`): don't delete the cache while environments use it, and don't edit installed files in place (use `copy` for that).
- `lang` — `en`, `ja`, `zh`, `zh-TW`, `ko`, `es`, `fr`, `de`, `pt`, `ru` (default: your OS language; also `AUTOPIP_LANG`)
- `index_url` / `extra_index_urls` — other package indexes (`pip.ini` / `PIP_INDEX_URL` are read too)

## Compatibility

- **Python 3.8 – 3.14** (the test suite runs on all seven). Tested mainly on Windows; wheel selection on Linux / macOS
  is handled by `packaging`.
- Modules removed from the standard library in Python 3.13 (`imghdr`, `cgi`, `telnetlib`, …) are provided by
  installing their maintained successors (`standard-imghdr`, `legacy-cgi`, …).
- No dependencies. MIT license.

## Good to know

- Only packages from PyPI (or the indexes you configure) are installed, and every install is logged.
- In `junction` / `hardlink` mode, environments share the same files. If you edit installed files in place, use `link_mode copy`.

日本語の説明: README.ja.md (included in the source distribution)
