Python 3.15 for LLM App Developers: Lazy Imports, UTF-8 by Default and a Sampling Profiler

Release schedule (PEP 790)

Before and after: an agent CLI with heavy imports

A typical agent CLI imports an SDK, an array library and a tokenizer at the top of the file and then uses each in one subcommand. With PEP 810 you put the soft keyword lazy in front of the import: the name is bound to a lightweight proxy and the module loads on first use. The syntax below is the one in the language reference. There are no timings because I have not measured your workload — the next block shows how you will.

# agent_cli.py — Python 3.14 and earlier: everything loads before main() runs
import argparse
import json
import numpy as np        # only the `embed` subcommand needs it
import tiktoken           # only `count` needs it
from openai import OpenAI

# agent_cli.py — Python 3.15 (PEP 810): proxies first, real modules on first use
import argparse
import json
lazy import numpy as np
lazy import tiktoken
lazy from openai import OpenAI

def main():
    args = build_parser().parse_args()   # --help never loads the heavy three
    if args.cmd == 'embed':
        vectors = np.asarray(load_vectors(args.path))   # numpy loads here

The import graph for --help

Nothing else in the file changes. Names are bound immediately; the cost moves to the first line that actually uses them.

agent_cli.py --help
├─ argparse, json
├─ numpy        loaded
├─ tiktoken     loaded
└─ openai       loaded
   └─ whole dependency tree

agent_cli.py --help
├─ argparse, json
├─ numpy        proxy only
├─ tiktoken     proxy only
└─ openai       proxy only

agent_cli.py embed
└─ numpy        loads on first use

Measure it, don’t trust it

python -X importtime prints self and cumulative time for every import to stderr, and -X importtime=2 (3.14+) also lists modules that were already loaded, marked cached. Run it before and after on the commands users run most. The PEP’s motivation says laziness can cut start-up by 50–70% for CLI tools but cites no source for that figure; the only attributed number in its case studies is 10–20% for PySide applications. Your result depends entirely on what you import and what runs at import time.

# per-import cost (self and cumulative, microseconds) goes to stderr
python -X importtime agent_cli.py --help 2> importtime.txt

# top 15 by cumulative time (second column)
sort -t'|' -k2 -n -r importtime.txt | head -15

# also list modules that were already loaded, marked `cached`
python -X importtime=2 agent_cli.py --help 2> importtime2.txt

# prove laziness instead of assuming it (expect False once the import is lazy)
python -c "import sys, agent_cli; print('openai' in sys.modules)"

Going beyond one import at a time

Two knobs exist. __lazy_modules__ makes ordinary import statements for the listed modules lazy on 3.15+ and is ignored by older versions, which suits libraries and mixed 3.14/3.15 fleets. The global mode (-X lazy_imports=all, PYTHON_LAZY_IMPORTS=all or sys.set_lazy_imports) makes every module-level import potentially lazy; the sys docs say library authors should generally not call it. A filter keeps the blast radius to your own package.

# Option A: one source tree for 3.14 and 3.15 (older versions ignore the list)
__lazy_modules__ = ['numpy', 'tiktoken']
import numpy
import tiktoken

# Option B: flip the process to lazy, but only for your own package
import sys

def only_mine(importing, imported, fromlist):
    return imported.startswith('myagent.')   # True = may be lazy, False = force eager

sys.set_lazy_imports_filter(only_mine)
sys.set_lazy_imports('all')                   # same switch as -X lazy_imports=all

# Option C: no code change, whole process
#   python -X lazy_imports=all agent_cli.py
#   PYTHON_LAZY_IMPORTS=all python agent_cli.py