Python Enhancement Proposals (PEPs)

https://peps.python.org/
Admin
An official index and repository for Python Enhancement Proposals (PEPs), which are design documents...
Tokens:1,476,695
Snippets:21,353
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Application README Installation Instructions

Source: https://peps.python.org/pep-0773

Standardized instructions for project README files to guide users through environment setup and package installation.

```text
To install and use our application, first install Python following the
guidance for your operating system at https://docs.python.org/using/. Then,
create a virtual environment and use 'pip' to install.

``python3 -m venv .venv``
``source .venv/bin/activate`` or ``.venv\Scripts\Activate`` (on Windows)
``python -m pip install OurAwesomePackage``
...
```

--------------------------------

### Example build-details.json file

Source: https://peps.python.org/pep-0739

A sample JSON file demonstrating the structure and fields required to describe a Python installation.

```json
 1{
 2  "schema_version": "1.0",
 3  "base_prefix": "/usr",
 4  "base_interpreter": "/usr/bin/python",
 5  "platform": "linux-x86_64",
 6  "language": {
 7    "version": "3.14",
 8    "version_info": {
 9      "major": 3,
10      "minor": 14,
11      "micro": 0,
12      "releaselevel": "alpha",
13      "serial": 0
14    }
15  },
16  "implementation": {
17    "name": "cpython",
18    "version": {
19      "major": 3,
20      "minor": 14,
21      "micro": 0,
22      "releaselevel": "alpha",
23      "serial": 0
24    },
25    "hexversion": 51249312,
26    "cache_tag": "cpython-314",
27    "_multiarch": "x86_64-linux-gnu"
28  },
29  "abi": {
30    "flags": ["t", "d"],
31    "extension_suffix": ".cpython-314-x86_64-linux-gnu.so",
32    "stable_abi_suffix": ".abi3.so"
33  },
34  "suffixes": {
35    "source": [".py"],
36    "bytecode": [".pyc"],
37    "optimized_bytecode": [".pyc"],
38    "debug_bytecode": [".pyc"],
39    "extensions": [".cpython-314-x86_64-linux-gnu.so", ".abi3.so", ".so"]
40  },
41  "libpython": {
42    "dynamic": "/usr/lib/libpython3.14.so.1.0",
43    "dynamic_stableabi": "/usr/lib/libpython3.so",
44    "static": "/usr/lib/python3.14/config-3.14-x86_64-linux-gnu/libpython3.14.a",
45    "link_extensions": true
46  },
47  "c_api": {
48    "headers": "/usr/include/python3.14",
49    "pkgconfig_path": "/usr/lib/pkgconfig"
50  }
51}
```

--------------------------------

### Install commands for incompatible extras

Source: https://peps.python.org/pep-0771

Example demonstrating how default extras can lead to broken installations when combined with other extras.

```bash
$ pip install package  # this installs package[A]
$ pip install package[B]
```

--------------------------------

### Install packages with and without extras

Source: https://peps.python.org/pep-0771

Command line examples demonstrating how default extras are triggered or ignored based on user input.

```bash
$ pip install package

```

```bash
$ pip install package[extra2]

```

--------------------------------

### Install Dependency Groups via CLI

Source: https://peps.python.org/pep-0735

Example commands for installing dependency groups using a hypothetical tool.

```bash
$TOOL install-dependency-group test
pip install -e .
```

```bash
$TOOL install-dependency-group docs
```

--------------------------------

### Configure installer backend in pyproject.toml

Source: https://peps.python.org/pep-0650

Example configuration for specifying an installer backend within the pyproject.toml file.

```toml
[install-system]
  #Eg : pipenv
  requires = ["pep650pip", "pip"]
  install-backend = "pep650pip:main"
```

--------------------------------

### Introductory Python Installation Guide

Source: https://peps.python.org/pep-0773

Provides standard instructional text for users to manage Python versions and virtual environments on Windows.

```text
Python installs on Windows are managed using an installer tool. After it has
been installed, you can run ``python`` to launch the interpreter, and it will
choose the best version already installed, available online, or referenced by
the script you are launching (if any). If you have a preference for a
particular version, you can specify it with ``py -V:<version>`` followed
by the rest of your command.

To install a version of Python without running any command, use ``py install
<version>``. You can see all of your installs with ``py list`` and remove them
with ``py uninstall <version>``. Run ``py help`` to see all the options that
are available.

Because each version of Python will be shared by all your projects, we
recommend using virtual environments. This will usually be created for a
particular Python version by running ``py -V:<version> -m venv .venv``, and
activated with ``.venv\Scripts\Activate``. Now, rather than the install
manager, ``python`` or ``py`` will always launch your virtual environment, and
any packages you install are only available while this environment is active.
To get access to the manager again, you can ``deactivate`` the environment, or
use ``py <command>``.
```

--------------------------------

### Install PyTorch with custom index URL

Source: https://peps.python.org/pep-0817

Example of installing a specific PyTorch variant by pointing to a custom package index.

```bash
pip install torch --index-url https://download.pytorch.org/whl/cu129
```

--------------------------------

### Manage multiple default backend and frontend extras

Source: https://peps.python.org/pep-0771

Examples of how users might install packages with combinations of default and explicit backend/frontend extras.

```bash
$ pip install package  # installs default backend and frontend
$ pip install package[]  # installs no backends or frontends
$ pip install package[backend1]  # installs backend1 and default frontend
$ pip install package[frontend2]  # installs frontend2 and default backend
$ pip install package[backend1, frontend2]  # installs backend1 and frontend2

```

```bash
$ pip install package  # installs default backend and frontend
$ pip install package[]  # installs no backends or frontends
$ pip install package[backend1, defaultfrontend]  # installs backend1 and default frontend
$ pip install package[defaultbackend, frontend2]  # installs frontend2 and default backend
$ pip install package[backend1, frontend2]  # installs backend1 and frontend2

```

--------------------------------

### Install XGBoost variants

Source: https://peps.python.org/pep-0817

Example of using distinct package names to select between GPU and CPU variants of XGBoost.

```bash
pip install xgboost      # NVIDIA GPU variant
pip install xgboost-cpu  # CPU-only variant
```

--------------------------------

### Install subcommand syntax

Source: https://peps.python.org/pep-0773

Usage patterns for the py install command, including options for source specification, forced installation, upgrades, and directory targeting.

```text
py install [-s|--source <URL>] [-f|--force] [-u|--upgrade] tag [...]
py install [-s|--source <URL>] [-t|--target <DIR>] tag
py install [-s|--source <URL>] [-d|--download <DIR>] tag [...]
py install --refresh
```

--------------------------------

### Implement an installer backend using pip

Source: https://peps.python.org/pep-0650

A basic implementation of an installer backend that invokes pip via subprocess to install dependencies.

```python
import subprocess
import sys


def invoke_install(path, *, dependency_group=None, **kwargs):
    try:
        return subprocess.run(
            [
                sys.executable,
                "-m",
                "pip",
                "install",
                "-r",
                dependency_group or "requirements.txt",
            ],
            cwd=path,
        ).returncode
    except subprocess.CalledProcessError as e:
        return e.returncode
```

--------------------------------

### Simple major.minor.micro versioning examples

Source: https://peps.python.org/pep-0440

Examples of major.minor.micro versioning schemes.

```text
1.1.0
1.1.1
1.1.2
1.2.0
...
```

--------------------------------

### Directory Layout Example

Source: https://peps.python.org/pep-0402

An example of a directory structure that could cause import conflicts.

```text
datagen.py
json/
    foo.js
    bar.js
```

--------------------------------

### Spack Installation with Target Architecture

Source: https://peps.python.org/pep-0817

Example of specifying a target microarchitecture during a Spack package installation.

```bash
spack install fftw target=broadwell
```

--------------------------------

### Configure setup.cfg for licenses

Source: https://peps.python.org/pep-0639/appendix-examples

Example configuration for license expression and files in setup.cfg.

```ini
[metadata]
license_expression = MIT AND (Apache-2.0 OR BSD-2-Clause)
license_files =
    LICENSE
    setuptools/_vendor/packaging/LICENSE
    setuptools/_vendor/packaging/LICENSE.APACHE
    setuptools/_vendor/packaging/LICENSE.BSD

```

--------------------------------

### Example .mv configuration file

Source: https://peps.python.org/pep-0364

A sample .mv file demonstrating the mapping of old module names to new module names using full dotted-path syntax.

```text
# Map the various string i/o libraries to their new names
StringIO    stringio
cStringIO   cstringio
```

--------------------------------

### InstallationDatabase.__init__

Source: https://peps.python.org/pep-0262

Initializes the InstallationDatabase by reading the database rooted at the specified path.

```APIDOC
## InstallationDatabase.__init__(path=None)

### Description
Initializes the database instance. If path is None, the default INSTALLDB location is used.

### Parameters
- **path** (string) - Optional - The root path of the installation database.
```

--------------------------------

### Install Dependency Groups via pip

Source: https://peps.python.org/pep-0735

Example interface for installing specific dependency groups using pip.

```bash
pip install --dependency-groups=test,typing
```

--------------------------------

### Define Complete InstallPath Configuration

Source: https://peps.python.org/pep-0514

Example of a full InstallPath configuration including executable paths and arguments.

```registry
HKEY_CURRENT_USER\Software\Python\ExampleCorp\examplepy\InstallPath
    (Default) = "C:\ExampleDistro30"
    ExecutablePath = "C:\ExampleDistro30\ex_python.exe"
    ExecutableArguments = "--arg1"
    WindowedExecutablePath = "C:\ExampleDistro30\ex_pythonw.exe"
    WindowedExecutableArguments = "--arg1"
```

--------------------------------

### Usage of enumerate with a start index

Source: https://peps.python.org/pep-0279

Example showing how to use enumerate to iterate over a source with a custom starting index.

```python
for linenum, line in enumerate(source,1):  print linenum, line
```

--------------------------------

### Example File Layout

Source: https://peps.python.org/pep-0338

A directory structure demonstrating a package hierarchy for testing module execution.

```text
devel/
    pkg/
        __init__.py
        moduleA.py
        moduleB.py
        test/
            __init__.py
            test_A.py
            test_B.py
```

--------------------------------

### Specify package requirements in setup

Source: https://peps.python.org/pep-0262

Example of using the requires argument within the distutils setup function to declare module dependencies.

```python
setup(..., requires=['xml.utils.iso8601',
```

--------------------------------

### Install packages with external and unverified flags

Source: https://peps.python.org/pep-0470

Examples of command-line invocations required by PEP 438 to install projects hosted externally or without verification.

```bash
$ pip install --allow-external myproject --allow-unverified myproject myproject
$ pip install --allow-all-external --allow-unverified myproject myproject
```

--------------------------------

### Initialize Python using PyInitConfig

Source: https://peps.python.org/pep-0741

Demonstrates the basic initialization sequence using the PyInitConfig API.

```c
PyInitConfig *config = PyInitConfig_Create();
PyInitConfig_SetInt(config, "bytes_warning", 1);
Py_InitializeFromInitConfig(config);
PyInitConfig_Free(config);
```

--------------------------------

### Configuration as text format example

Source: https://peps.python.org/pep-0741

Example of a text-based configuration format using key-value pairs for different data types.

```text
# integer
bytes_warning = 2

# string
filesystem_encoding = "utf8"   # comment

# list of strings
argv = ['python', '-c', 'code']

```

--------------------------------

### direct_url.json for Local Directory

Source: https://peps.python.org/pep-0610

Example of a direct_url.json file for a package installed from a local directory.

```json
{
    "url": "file:///home/user/project",
    "dir_info": {}
}
```

--------------------------------

### Handle non-existent extras in pip

Source: https://peps.python.org/pep-0771

Example of warning output when an invalid extra is specified during installation.

```bash
$ pip install package[non-existent-extra]
WARNING: package 3.0.0 does not provide the extra 'non-existent-extra'
...

```

--------------------------------

### Create virtual environment and install requirements

Source: https://peps.python.org/docs/build

Initializes the local environment for building PEPs.

```bash
make venv
```

```powershell
PS> python -m venv .venv
PS> .\.venv\Scripts\activate
(venv) PS> python -m pip install --upgrade pip
(venv) PS> python -m pip install -r requirements.txt
```

--------------------------------

### direct_url.json for Source Archive

Source: https://peps.python.org/pep-0610

Example of a direct_url.json file for a package installed from a source archive URL.

```json
{
    "url": "https://github.com/pypa/pip/archive/1.3.1.zip",
    "archive_info": {
        "hash": "sha256=2dc6b5a470a1bde68946f263f1af1515a2574a150a30d6ce02c6ff742fcc0db8"
    }
}
```

--------------------------------

### Simulated build failure output

Source: https://peps.python.org/pep-0804

Example of error output when external dependencies are missing during a pip install.

```text
$ pip install .
...
× Encountered error while generating package metadata.
╰─> See above for output.

note: This is an issue with the package mentioned above, not pip.

This package has the following external dependencies, if those are missing
on your system they are likely to be the cause of this build failure:

  dep:virtual/compiler/cxx
  dep:generic/zlib
```

--------------------------------

### Extract package metadata via setup.py

Source: https://peps.python.org/pep-0390

Demonstrates retrieving package name and version using the setup.py command line interface.

```bash
$ python setup.py --name
Distribute

$ python setup.py --version
0.6.4
```

--------------------------------

### RECORD entry for absolute path

Source: https://peps.python.org/pep-0376

Example of a RECORD entry for a configuration file installed at an absolute path.

```text
/etc/myapp/config.ini,md5=gLfd6IANquzGLhOkW4Mfgg,9544
```

--------------------------------

### Define install-system in pyproject.toml

Source: https://peps.python.org/pep-0650

Example configuration for the install-system table, specifying the required backend dependencies and entry point.

```toml
#pyproject.toml
[install-system]
#Eg : pipenv
requires = ["pipenv"]
install-backend = "pipenv.api:main"
```

--------------------------------

### tracemalloc.start(nframe: int=1)

Source: https://peps.python.org/pep-0454

Starts tracing Python memory allocations by installing hooks on memory allocators.

```APIDOC
## tracemalloc.start(nframe: int=1)

### Description
Starts tracing Python memory allocations. Collected tracebacks will be limited to nframe frames.

### Parameters
- **nframe** (int) - Optional - The maximum number of frames to store in a traceback. Defaults to 1.
```

--------------------------------

### Example pip configuration command

Source: https://peps.python.org/pep-0517

Demonstrates how a frontend might map command-line arguments into a configuration dictionary.

```bash
pip install                                           \
  --package-config CC=gcc                             \
  --global-option="--some-global-option"              \
  --build-option="--build-option1"                    \
  --build-option="--build-option2"
```

--------------------------------

### Example YAML configuration

Source: https://peps.python.org/pep-0518

A sample YAML file structure defining build requirements.

```yaml
build:
    requires:
        - setuptools
        - wheel>=0.27
```

--------------------------------

### direct_url.json for Editable Local Directory

Source: https://peps.python.org/pep-0610

Example of a direct_url.json file for a package installed from a local directory in editable mode.

```json
{
    "url": "file:///home/user/project",
    "dir_info": {
        "editable": true
    }
}
```

--------------------------------

### Custom Index Installation Instructions

Source: https://peps.python.org/pep-0773

Guidance for users to install specialized distributions by referencing a custom index URL.

```text
Our distribution can be installed on Windows using the Python Install Manager
(include link) by referencing our index:

``py install --source <your index URL here> latest``

This index contains all our versions. Use ``py list --source <URL>`` to
see everything that is available.
```

--------------------------------

### Install and use the say module

Source: https://peps.python.org/pep-0502

Demonstrates installing the 'say' package and using it for string interpolation with Python expressions.

```bash
＞ pip install say
```

```python
from say import say
nums = list(range(4))
say("Nums has {len(nums)} items: {nums}")
```

--------------------------------

### Define python.constraints extension

Source: https://peps.python.org/pep-0459

Example of the python.constraints structure including installer requirements, supported environments, and extension metadata.

```json
"python.constraints": {
  "installer_must_handle": true,
  "environments": ["python_version >= 2.6"],
  "extension_metadata": {
    "fortranlib": {
      "fortranlib.compatibility": {
        "fortran_abi": "openblas-g77"
      }
    }
  }
}
```

--------------------------------

### Runtime dependency installation from script block

Source: https://peps.python.org/pep-0722

Example of a runtime manager reading dependencies from a standard script dependency block.

```python
# Script Dependencies:
#     rich
#     click
env_mgr.install_dependencies(__file__)

import rich
import click

...
```

--------------------------------

### Version matching examples for 1.1.post1

Source: https://peps.python.org/pep-0440

Demonstrates how strict equality and prefix matching operators evaluate against the version 1.1.post1.

```text
== 1.1        # Not equal, so 1.1.post1 does not match clause
== 1.1.post1  # Equal, so 1.1.post1 matches clause
== 1.1.*      # Same prefix, so 1.1.post1 matches clause
```

--------------------------------

### direct_url.json for Git Repository

Source: https://peps.python.org/pep-0610

Example of a direct_url.json file for a package installed from a Git repository with a specific tag and commit hash.

```json
{
    "url": "https://github.com/pypa/pip.git",
    "vcs_info": {
        "vcs": "git",
        "requested_revision": "1.3.1",
        "resolved_revision_type": "tag",
        "commit_id": "7921be1537eac1e97bc40179a57f0349c2aee67d"
    }
}
```

--------------------------------

### Example JSON Configuration

Source: https://peps.python.org/pep-0518

A sample representation of the proposed build configuration using the JSON format.

```json
{
    "build": {
        "requires": [
            "setuptools",
            "wheel>=0.27"
        ]
    }
}
```

--------------------------------

### Assigning to directive identifier

Source: https://peps.python.org/pep-0244

Example of using directive as an identifier at the start of a module, which would be treated as a keyword under the proposed specification.

```python
directive = 1

```

--------------------------------

### Parse version from file in setup.py

Source: https://peps.python.org/pep-0396

Parsing the version string from a file to avoid import-time issues during conversion.

```python
from distutils2 import get_version
setup(name='elle', version=get_version('elle.py'))
```

--------------------------------

### Example Explicit Configuration JSON

Source: https://peps.python.org/pep-0708

A sample configuration file structure demonstrating how repositories and path mappings can be defined for package resolution.

```json
{
  "repositories": {
    "PyTorch": ["https://download.pytorch.org/whl/nightly"],
    "PyPI": ["https://pypi.org/simple"]
  },
  "mapping": [
    {
      "paths": ["torch*"],
      "repositories": ["PyTorch"],
      "terminating": true
    },
    {
      "paths": ["*"],
      "repositories": ["PyPI"]
    }
  ]
}
```

--------------------------------

### Lockfile Tool Usage with Dependency Groups

Source: https://peps.python.org/pep-0735

Example commands for a hypothetical tool to lock and install dependencies based on a specific group.

```bash
$TOOL lock --dependency-group=test
$TOOL install --dependency-group=test --use-locked
```

--------------------------------

### Configure legacy license metadata in setup.cfg

Source: https://peps.python.org/pep-0639/appendix-examples

Shows the legacy approach using classifiers to specify the license.

```ini
[metadata]
classifiers =
    License :: OSI Approved :: MIT License
```

--------------------------------

### Example of dependency group inclusion in pyproject.toml

Source: https://peps.python.org/pep-0735

Demonstrates how a typing group could reference other dependency groups to avoid installing the package itself.

```toml
[project]
dependencies = [{include = "runtime"}]
[optional-dependencies]
foo = [{include = "foo"}]
[dependency-groups]
runtime = ["a", "b"]
foo = ["c", "d"]
typing = ["mypy", {include = "runtime"}, {include = "foo"}]
```

--------------------------------

### Configure version from file in setup.cfg

Source: https://peps.python.org/pep-0396

Declarative configuration for versioning when the version must be parsed from a larger file.

```ini
[metadata]
version-from-file: elle.py
```

--------------------------------

### RECORD entry for Windows absolute path

Source: https://peps.python.org/pep-0376

Example of a RECORD entry for a file installed on a Windows platform including the drive letter.

```text
c:\etc\myapp\config.ini,md5=gLfd6IANquzGLhOkW4Mfgg,9544
```

--------------------------------

### Version matching examples for 1.1a1

Source: https://peps.python.org/pep-0440

Demonstrates how version matching operators evaluate against the pre-release version 1.1a1.

```text
== 1.1        # Not equal, so 1.1a1 does not match clause
== 1.1a1      # Equal, so 1.1a1 matches clause
== 1.1.*      # Same prefix, so 1.1a1 matches clause if pre-releases are requested
```

--------------------------------

### Publishing Session with Index-specific Metadata

Source: https://peps.python.org/pep-0694

An example of a publishing session request including optional index-specific metadata keys starting with an underscore.

```json
{
  "meta": {
    "api-version": "2.0",
    "_pypi.org": {
        "organization": "my-org"
    }
  },
  "name": "foo",
  "version": "1.0",
}
```

--------------------------------

### Bootstrap package installation via command line

Source: https://peps.python.org/pep-0365

Proposed command-line syntax to download and install a package from PyPI using pkg_resources.

```bash
python -m pkg_resources SomePackage==1.2
```

--------------------------------

### Range Literal Syntax Examples

Source: https://peps.python.org/pep-0204

Demonstrates the proposed syntax for creating lists using range literals with start, end, and step parameters.

```python
>>> [1:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [:5]
[0, 1, 2, 3, 4]
>>> [5:1:-1]
[5, 4, 3, 2]
```

--------------------------------

### Version matching examples for 1.1

Source: https://peps.python.org/pep-0440

Demonstrates how version matching operators evaluate against the version 1.1, including zero-padding behavior.

```text
== 1.1        # Equal, so 1.1 matches clause
== 1.1.0      # Zero padding expands 1.1 to 1.1.0, so it matches clause
== 1.1.dev1   # Not equal (dev-release), so 1.1 does not match clause
== 1.1a1      # Not equal (pre-release), so 1.1 does not match clause
== 1.1.post1  # Not equal (post-release), so 1.1 does not match clause
== 1.1.*      # Same prefix, so 1.1 matches clause
```

--------------------------------

### Example EXTERNALLY-MANAGED configuration file

Source: https://peps.python.org/pep-0668

An INI-style file placed in the standard library directory to provide user-facing error messages when package installation is blocked.

```ini
[externally-managed]
Error=To install Python packages system-wide, try apt install
 python3-xyz, where xyz is the package you are trying to
 install.

 If you wish to install a non-Debian-packaged Python package,
 create a virtual environment using python3 -m venv path/to/venv.
 Then use path/to/venv/bin/python and path/to/venv/bin/pip. Make
 sure you have python3-full installed.

 If you wish to install a non-Debian packaged Python application,
 it may be easiest to use pipx install xyz, which will manage a
 virtual environment for you. Make sure you have pipx installed.

 See /usr/share/doc/python3.9/README.venv for more information.
```

```ini
Error-de_DE=Wenn ist das Nunstück git und Slotermeyer?

 Ja! Beiherhund das Oder die Virtualenvironment gersput!
```

--------------------------------

### Define metadata in setup.cfg

Source: https://peps.python.org/pep-0390

Basic structure for defining package name and version within the setup.cfg file.

```ini
[metadata]
name = Distribute
version = 0.6.4
```

--------------------------------

### Interact with Distribution metadata and files

Source: https://peps.python.org/pep-0376

Demonstrates initializing a distribution object, retrieving metadata, and querying installed files using the PEP 376 API.

```python
>>> from pkgutil import get_distribution, get_file_users, distinfo_dirname
>>> dist = get_distribution('docutils')
>>> dist.name
'docutils'
>>> dist.metadata.version
'0.5'

>>> distinfo_dirname('docutils', '0.5')
'docutils-0.5.dist-info'

>>> distinfo_dirname('python-ldap', '2.5')
'python_ldap-2.5.dist-info'

>>> distinfo_dirname('python-ldap', '2.5 a---5')
'python_ldap-2.5.a_5.dist-info'

>>> for path, hash, size in dist.get_installed_files()::
...     print '%s %s %d' % (path, hash, size)
...
python2.6/site-packages/docutils/__init__.py,b690274f621402dda63bf11ba5373bf2,9544
python2.6/site-packages/docutils/core.py,9c4b84aff68aa55f2e9bf70481b94333,66188
python2.6/site-packages/roman.py,a4b84aff68aa55f2e9bf70481b943D3,234
/usr/local/bin/rst2html.py,a4b84aff68aa55f2e9bf70481b943D3,234
python2.6/site-packages/docutils-0.5.dist-info/METADATA,6fe57de576d749536082d8e205b77748,195
python2.6/site-packages/docutils-0.5.dist-info/RECORD

>>> dist.uses('docutils/core.py')
True

>>> dist.uses('/usr/local/bin/rst2html.py')
True

>>> dist.get_distinfo_file('METADATA')
<open file at ...>

>>> dist.requested
True
```

--------------------------------

### Runtime path discovery formats

Source: https://peps.python.org/pep-0491

Examples of generated files that allow packages to locate their installed files at runtime without packaging library dependencies.

```python
data='../wheel-0.26.0.dev1.data/data'
headers='../wheel-0.26.0.dev1.data/headers'
platlib='../wheel-0.26.0.dev1.data/platlib'
purelib='../wheel-0.26.0.dev1.data/purelib'
scripts='../wheel-0.26.0.dev1.data/scripts'
# ...
```

```json
{ "data": "../wheel-0.26.0.dev1.data/data", ... }
```

--------------------------------

### PyConfig Initialization and Configuration

Source: https://peps.python.org/pep-0587

Example demonstrating how to initialize a PyConfig structure, read the default configuration, override specific parameters, and initialize the Python interpreter.

```APIDOC
## PyConfig Initialization Example

### Description
This example shows the standard workflow for configuring the Python interpreter using the PyConfig API. It involves initializing the structure, reading system defaults, applying custom modifications, and finally starting the interpreter.

### Code
```c
PyStatus init_python(const char *program_name)
{
    PyStatus status;

    PyConfig config;
    PyConfig_InitPythonConfig(&config);

    /* Set the program name before reading the configuration */
    status = PyConfig_SetBytesString(&config, &config.program_name,
                                  program_name);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Read all configuration at once */
    status = PyConfig_Read(&config);
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Append our custom search path to sys.path */
    status = PyWideStringList_Append(&config.module_search_paths,
                                  L"/path/to/more/modules");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    /* Override executable computed by PyConfig_Read() */
    status = PyConfig_SetString(&config, &config.executable,
                                L"/path/to/my_executable");
    if (PyStatus_Exception(status)) {
        goto done;
    }

    status = Py_InitializeFromConfig(&config);

done:
    PyConfig_Clear(&config);
    return status;
}
```
```
Tokens:
Raw