pip-auto

Just import it. Missing packages install themselves.

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.

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)

# /// 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.

[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

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

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)