importlib.resources: accede a archivos de paquetes

Las aplicaciones Python suelen necesitar archivos distribuidos junto al código: modelos JSON, plantillas HTML, certificados de prueba, esquemas SQL, catálogos de traducción, ejemplos, imágenes o datos estáticos. Un error común consiste en asumir que esos recursos siempre viven en un directorio normal y construir rutas con __file__. Esa solución puede funcionar durante el desarrollo, pero falla después de instalar un wheel, cuando el paquete se carga desde un archivo zip o cuando un importador personalizado no expone archivos físicos. importlib.resources en Python ofrece la API oficial para acceder a recursos que pertenecen a paquetes importables.

Esta guía explica cómo localizar, leer y materializar temporalmente recursos, cómo incluirlos en la distribución, cómo probar el wheel final y cómo evitar errores de path traversal y de duración de rutas temporales. El tema complementa nuestros artículos sobre importlib en Python, pathlib en Python, zipfile en Python, tempfile en Python y shlex en Python.

Por qué __file__ no es suficiente

Una ruta basada en Path(__file__).parent presupone que el módulo tiene un archivo físico y que el recurso está junto a él. Eso no está garantizado. Los paquetes pueden importarse desde archivos comprimidos, aplicaciones congeladas o loaders alternativos. Las rutas basadas en el directorio de trabajo actual son todavía más frágiles porque dependen de cómo se inició el programa.

from pathlib import Path

# Frágil en algunos escenarios de distribución
ruta = Path(__file__).parent / "datos" / "config.json"

importlib.resources consulta al sistema de importación en lugar de adivinar la estructura física.

Estructura del paquete

mi_paquete/
    __init__.py
    lector.py
    datos/
        config.json
        mensaje.txt

Los archivos deben incluirse en la distribución construida. La API no puede leer un recurso omitido por el backend de build. Configura package data en pyproject.toml y revisa el wheel generado antes de publicar.

Empezar con files()

La interfaz moderna comienza con importlib.resources.files(). Devuelve un objeto traversable que representa un paquete o módulo.

from importlib.resources import files

raiz = files("mi_paquete")
recurso = raiz.joinpath("datos", "config.json")
print(recurso)

El objeto puede corresponder a una ruta real o a un recurso virtual. Continúa usando sus métodos en lugar de convertirlo inmediatamente a Path.

Leer texto

texto = (
    files("mi_paquete")
    .joinpath("datos", "mensaje.txt")
    .read_text(encoding="utf-8")
)

Declara siempre la codificación. UTF-8 evita diferencias entre sistemas. Para JSON, lee el texto y usa json.loads().

import json

datos = json.loads(
    files("mi_paquete")
    .joinpath("datos", "config.json")
    .read_text(encoding="utf-8")
)

Leer datos binarios

Imágenes, modelos comprimidos y otros formatos binarios deben leerse con read_bytes().

contenido = files("mi_paquete").joinpath("datos", "logo.png").read_bytes()

No decodifiques bytes arbitrarios como texto. La API entrega el contenido, pero no valida el formato.

Usar el paquete como ancla

import mi_paquete
from importlib.resources import files

raiz = files(mi_paquete)

Pasar el paquete importado reduce errores de escritura y hace explícita la dependencia.

Comprobar existencia y tipo

recurso = files("mi_paquete").joinpath("datos", "config.json")
if not recurso.is_file():
    raise FileNotFoundError("falta config.json")

Usa is_file() e is_dir() cuando la ausencia sea esperada. Los recursos obligatorios deben fallar pronto para revelar un empaquetado incompleto.

Listar recursos

carpeta = files("mi_paquete").joinpath("datos")
for item in carpeta.iterdir():
    print(item.name, item.is_file())

La lista no convierte en segura una entrada externa. Si un usuario elige un recurso, utiliza una lista permitida en lugar de añadir componentes arbitrarios.

Evitar path traversal

PERMITIDOS = {
    "normal": "config.json",
    "prueba": "config-prueba.json",
}

nombre = PERMITIDOS.get(opcion)
if nombre is None:
    raise ValueError("opción desconocida")

recurso = files("mi_paquete").joinpath("datos", nombre)

Esta estrategia impide que valores como ../secreto cambien la ubicación prevista.

Cuando una biblioteca exige una ruta física

Algunas bibliotecas antiguas aceptan solamente rutas del sistema. Usa as_file() para obtener una ruta física temporal.

from importlib.resources import as_file, files

recurso = files("mi_paquete").joinpath("datos", "modelo.bin")
with as_file(recurso) as ruta:
    cargar_modelo(str(ruta))

La ruta puede desaparecer al salir del contexto. No la guardes para utilizarla más tarde. Completa todo el trabajo dentro del bloque with.

Materializar directorios

Versiones recientes permiten materializar directorios traversable en escenarios compatibles.

plantillas = files("mi_paquete").joinpath("plantillas")
with as_file(plantillas) as ruta_plantillas:
    renderizador.cargar_directorio(ruta_plantillas)

Trata el directorio como temporal y no asumas una ubicación fija.

Compatibilidad entre versiones

La API moderna evolucionó entre versiones de Python. Los proyectos compatibles con versiones antiguas pueden usar el backport importlib_resources.

try:
    from importlib.resources import files, as_file
except ImportError:
    from importlib_resources import files, as_file

Centraliza esta compatibilidad. Consulta la documentación oficial de importlib.resources y la guía oficial de empaquetado para detalles de tu versión mínima y backend.

Incluir recursos en el wheel

Que un recurso funcione en el repositorio no demuestra que llegó al artefacto. Construye el wheel, inspecciónalo, instálalo en un entorno limpio y ejecuta pruebas.

python -m build
python -m zipfile -l dist/mi_paquete-1.0.0-py3-none-any.whl

Así detectas package data ausente antes de que llegue a producción.

Recursos frente a configuración editable

Los recursos empaquetados son adecuados para valores predeterminados inmutables. La configuración editable debe vivir fuera del paquete, en un directorio de datos, variables de entorno o un servicio de configuración. Escribir en site-packages es frágil y puede requerir permisos elevados.

No escribir en recursos del paquete

La API está orientada a lectura. Copia un archivo inicial a una ubicación escribible antes de modificarlo.

from pathlib import Path
from importlib.resources import files

origen = files("mi_paquete").joinpath("datos", "base.json")
destino = Path.home() / ".mi_app" / "base.json"
destino.parent.mkdir(parents=True, exist_ok=True)
destino.write_bytes(origen.read_bytes())

Pruebas automatizadas

def test_config_empaquetada():
    recurso = files("mi_paquete").joinpath("datos", "config.json")
    assert recurso.is_file()
    datos = json.loads(recurso.read_text(encoding="utf-8"))
    assert "version" in datos

Añade una prueba de integración que construya e instale el wheel en un entorno temporal. Esa prueba valida el artefacto que recibe el usuario.

Manejo de errores

def cargar_config():
    recurso = files("mi_paquete").joinpath("datos", "config.json")
    try:
        return json.loads(recurso.read_text(encoding="utf-8"))
    except FileNotFoundError as error:
        raise RuntimeError("el paquete se instaló sin config.json") from error
    except json.JSONDecodeError as error:
        raise RuntimeError("config.json del paquete es inválido") from error

Convierte los errores bajos en mensajes que distingan una instalación incompleta de un contenido inválido.

Rendimiento y caché

Los recursos pequeños e inmutables pueden cargarse una vez con functools.cache.

from functools import cache

@cache
def cargar_esquema():
    return files("mi_paquete").joinpath("datos", "schema.json").read_text(encoding="utf-8")

No almacenes archivos grandes indiscriminadamente. Mide memoria y utiliza streaming cuando sea posible.

Errores frecuentes

• Construir rutas desde el directorio de trabajo.
• Suponer que todo recurso tiene una ruta permanente.
• Olvidar package data en el wheel.
• Guardar una ruta de as_file() después del contexto.
• Añadir entrada no confiable a joinpath().
• Intentar modificar recursos instalados.
• Probar solamente desde el árbol fuente.
• Leer texto sin indicar la codificación.

Buenas prácticas

• Usa files() como punto de entrada.
• Lee texto con UTF-8 explícito.
• Usa as_file() solamente cuando otra API exija ruta.
• Mantén la ruta temporal dentro del contexto.
• Valida recursos en el wheel construido.
• Separa valores inmutables de configuración editable.
• Restringe nombres derivados de entrada externa.
• Prueba todas las versiones soportadas.

Conclusión

importlib.resources en Python proporciona una abstracción confiable para archivos distribuidos con paquetes sin depender de rutas físicas frágiles. Los recursos traversable funcionan en instalaciones normales, wheels y loaders alternativos, mientras as_file() conecta bibliotecas que todavía requieren una ruta real.

El empaquetado correcto sigue siendo esencial: incluye los datos, inspecciona el wheel y prueba el artefacto instalado. Con estas prácticas, plantillas, esquemas y recursos predeterminados permanecen previsibles en desarrollo y producción.