pip-requirements-parser

32.0.1 · active · verified Mon Apr 06

pip-requirements-parser is a Python library designed for robustly parsing `pip` requirement files. It distinguishes itself by leveraging `pip`'s own internal parsing logic, ensuring high accuracy in handling the diverse and often complex `pip` requirement format. The library provides a stable, offline API for parsing, making it suitable for environments where network access is restricted or where precise `pip`-compatible parsing is critical. It is currently at version 32.0.1 and aims for a stable API for its users, despite the inherent complexities of `pip`'s internal requirement file format.

Warnings

gotcha The `pip` requirements file format is tightly coupled with `pip`'s internal implementation details and command-line options, making it notoriously difficult to parse correctly. While `pip-requirements-parser` aims to provide a stable API by incorporating `pip`'s own logic, users should be aware that the underlying `requirements.txt` format is not a stable public API and its full syntax can evolve with `pip` releases.
Fix: Rely on `pip-requirements-parser`'s documented API. If issues arise with new `pip` requirement syntaxes, ensure you are using the latest version of `pip-requirements-parser` as it tracks `pip`'s internal changes.
gotcha It is generally discouraged to parse `requirements.txt` files directly to populate `install_requires` in `setup.py` or `pyproject.toml` for package distribution. Packaging metadata (e.g., in `pyproject.toml`'s `[project]` section) should use PEP 508 compliant specifiers for abstract dependencies, while `requirements.txt` is typically for concrete/pinned dependencies of applications.
Fix: For package distribution, define dependencies in `pyproject.toml` (PEP 508). Use `pip-requirements-parser` only when you explicitly need to read and interpret the `requirements.txt` format itself, for example, in tools that analyze application environments.
gotcha Unlike `pip` itself, which might perform network requests during its operations (e.g., resolving VCS requirements or fetching metadata), `pip-requirements-parser` is designed to work entirely offline. It parses the syntax without making external network calls.
Fix: This is generally a feature for isolation and speed. If you require resolution of network-based requirements (e.g., installing packages from custom URLs or VCS), you will need to use `pip` directly or another tool that handles network operations.

Install

pip install pip-requirements-parser Install with pip

Imports

parse
```
import requirements
for req in requirements.parse(req_string):
```
Directly importing from `pip._internal` is strongly discouraged by pip's developers as its APIs are unstable and subject to change without notice. `pip-requirements-parser` provides a stable wrapper around this complex parsing logic.

Quickstart

This quickstart demonstrates how to parse a string containing pip-style requirements using `requirements.parse()`. Each parsed requirement object provides attributes like `name`, `specs` (version specifiers), `vcs` (Version Control System information), and `url` for detailed analysis. The library also supports parsing directly from file-like objects.

import requirements

req_string = """
django==3.2.1
requests>=2.25.1,<3.0.0
-e git+https://github.com/my/project.git#egg=myproject
"""

# Parse a string of requirements
for req in requirements.parse(req_string):
    print(f"Name: {req.name}, Specs: {req.specs}, Vcs: {req.vcs}, Url: {req.url}")

# You can also parse from a file-like object
# with open('requirements.txt', 'r') as f:
#     for req in requirements.parse(f):
#         print(f"Name: {req.name}, Specs: {req.specs}")

view raw JSON →