Python 3.15 para Devs de Apps con LLM: Lazy Imports, UTF-8 por Defecto y un Profiler de Muestreo

Calendario de lanzamiento (PEP 790)

Antes y después: una CLI de agente con imports pesados

Una CLI de agente típica importa un SDK, una librería de arrays y un tokenizador al inicio del archivo y después usa cada uno en un solo subcomando. Con el PEP 810 ponés la soft keyword lazy delante del import: el nombre queda enlazado a un proxy liviano y el módulo se carga en el primer uso. La sintaxis de abajo es la de la referencia del lenguaje. No hay tiempos porque no medí tu carga de trabajo — el siguiente bloque te muestra cómo lo vas a medir vos.

# agent_cli.py — Python 3.14 y anteriores: todo se carga antes de que corra main()
import argparse
import json
import numpy as np        # solo lo necesita el subcomando `embed`
import tiktoken           # solo lo necesita `count`
from openai import OpenAI

# agent_cli.py — Python 3.15 (PEP 810): primero proxies, módulos reales en el primer uso
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 nunca carga los tres pesados
    if args.cmd == 'embed':
        vectors = np.asarray(load_vectors(args.path))   # numpy se carga acá

El grafo de imports de --help

Nada más cambia en el archivo. Los nombres se enlazan al instante; el costo se mueve a la primera línea que realmente los usa.

agent_cli.py --help
├─ argparse, json
├─ numpy        cargado
├─ tiktoken     cargado
└─ openai       cargado
   └─ todo su árbol de deps

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

agent_cli.py embed
└─ numpy        carga al primer uso

Medilo, no le creas

python -X importtime imprime en stderr el tiempo propio y acumulado de cada import, y -X importtime=2 (3.14+) también lista los módulos que ya estaban cargados, marcados como cached. Corrélo antes y después sobre los comandos que más usan tus usuarios. La motivación del PEP dice que la laziness puede recortar el arranque un 50–70% en CLIs pero no cita fuente para esa cifra; el único número atribuido en sus casos de estudio es 10–20% para aplicaciones PySide. Tu resultado depende por completo de qué importás y qué corre al importar.

# el costo por import (propio y acumulado, en microsegundos) va a stderr
python -X importtime agent_cli.py --help 2> importtime.txt

# top 15 por tiempo acumulado (segunda columna)
sort -t'|' -k2 -n -r importtime.txt | head -15

# listar también los módulos que ya estaban cargados, marcados `cached`
python -X importtime=2 agent_cli.py --help 2> importtime2.txt

# comprobá la laziness en vez de suponerla (esperá False cuando el import es lazy)
python -c "import sys, agent_cli; print('openai' in sys.modules)"

Ir más allá de un import a la vez

Hay dos perillas. __lazy_modules__ hace lazy los import normales de los módulos listados en 3.15+ y las versiones viejas lo ignoran, lo que sirve a librerías y a flotas mixtas 3.14/3.15. El modo global (-X lazy_imports=all, PYTHON_LAZY_IMPORTS=all o sys.set_lazy_imports) vuelve potencialmente lazy todo import a nivel de módulo; la doc de sys dice que los autores de librerías en general no deberían llamarlo. Un filtro limita el radio de impacto a tu propio paquete.

# Opción A: un solo árbol de fuentes para 3.14 y 3.15 (las versiones viejas ignoran la lista)
__lazy_modules__ = ['numpy', 'tiktoken']
import numpy
import tiktoken

# Opción B: pasar el proceso a lazy, pero solo para tu propio paquete
import sys

def only_mine(importing, imported, fromlist):
    return imported.startswith('myagent.')   # True = puede ser lazy, False = fuerza eager

sys.set_lazy_imports_filter(only_mine)
sys.set_lazy_imports('all')                   # el mismo interruptor que -X lazy_imports=all

# Opción C: sin tocar código, todo el proceso
#   python -X lazy_imports=all agent_cli.py
#   PYTHON_LAZY_IMPORTS=all python agent_cli.py