# `importlib.resources` – Package resource reading, opening and access

Source code: Lib/importlib/resources/__init__.py

Added in version 3.7.

This module leverages Python’s import system to provide access to resources within packages.

«Resources» are file-like resources associated with a module or package in Python. The resources may be contained directly in a package, within a subdirectory contained in that package, or adjacent to modules outside a package. Resources may be text or binary. As a result, Python module sources (.py) of a package and compilation artifacts (pycache) are technically de-facto resources of that package. In practice, however, resources are primarily those non-Python artifacts exposed specifically by the package author.

Resources can be opened or read in either binary or text mode.

Los recursos son más o menos similares a los archivos dentro de los directorios, aunque es importante tener en cuenta que esto es solo una metáfora. Los recursos y paquetes no deben existir como archivos y directorios físicos en el sistema de archivos: por ejemplo, un paquete y sus recursos se pueden importar desde un archivo zip usando `zipimport`.

Nota

Este módulo proporciona una funcionalidad similar a pkg_resources Acceso a los recursos básicos sin la sobrecarga de rendimiento de ese paquete. Esto facilita la lectura de los recursos incluidos en los paquetes, con una semántica más estable y consistente.

El soporte independiente de este módulo proporciona más información sobre el uso de importlib.resources y migración de pkg_resources a importlib.resources.

`Los loaders` que deseen soportar la lectura de recursos deben implementar un método `get_resource_reader(fullname)` según lo especificado por `importlib.resources.abc.ResourceReader`.

class importlib.resources.Anchor

  Represents an anchor for resources, either a `module object` or a module name as a string. Defined as `Union[str, ModuleType]`.

importlib.resources.files(anchor: Anchor | None = None)

  Returns a `Traversable` object representing the resource container (think directory) and its resources (think files). A Traversable may contain other containers (think subdirectories).

  anchor is an optional `Anchor`. If the anchor is a package, resources are resolved from that package. If a module, resources are resolved adjacent to that module (in the same package or the package root). If the anchor is omitted, the caller’s module is used.

  Added in version 3.9.

  Distinto en la versión 3.12: package parameter was renamed to anchor. anchor can now be a non-package module and if omitted will default to the caller’s module. package is still accepted for compatibility but will raise a `DeprecationWarning`. Consider passing the anchor positionally or using `importlib_resources >= 5.10` for a compatible interface on older Pythons.

importlib.resources.as_file(traversable)

  Given a `Traversable` object representing a file or directory, typically from `importlib.resources.files()`, return a context manager for use in a `with` statement. The context manager provides a `pathlib.Path` object.

  Exiting the context manager cleans up any temporary file or directory created when the resource was extracted from e.g. a zip file.

  Use `as_file` when the Traversable methods (`read_text`, etc) are insufficient and an actual file or directory on the file system is required.

  Added in version 3.9.

  Distinto en la versión 3.12: Added support for traversable representing a directory.

## Functional API

An older, previously deprecated set of functions is still available. The main drawback of these functions is that they do not support directories: they assume all resources are located directly within a package.

importlib.resources.Package

  Cada vez que una función acepta un argumento `Package`, puede pasar un `module object` o un nombre de módulo como una cadena. Solo puede pasar objetos de módulo cuyo `__spec__.submodule_search_locations` no sea `None`.

  El tipo `Package` se define como `Union[str, ModuleType]`.

importlib.resources.Resource

  Para los argumentos recurso de las siguientes funciones, puede pasar el nombre de un recurso como una cadena o `path-like object`.

  El tipo `Resource` se define como `Union[str, os.PathLike]`.

importlib.resources.open_binary(package, resource)

  Abierto para lectura binaria de recurso dentro de paquete.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`. resource es el nombre del recurso para abrir dentro de package; puede que no contenga separadores de ruta y que no tenga subrecursos (es decir, no puede ser un directorio). Esta función retorna una instancia `typing.BinaryIO`, un flujo de E/S binario abierto para lectura.

  This function is roughly equivalent to:

      files(package).joinpath(resource).open('rb')

importlib.resources.open_text(package, resource, encoding='utf-8', errors='strict')

  Abierto para texto que lea resource dentro de package. De forma predeterminada, el recurso se abre para lectura como UTF-8.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`. resource es el nombre del recurso para abrir dentro de package; puede que no contenga separadores de ruta y que no tenga subrecursos (es decir, no puede ser un directorio). encoding y errors tienen el mismo significado que con `open()` incorporado.

  Esta función retorna una instancia `typing.TextIO`, un flujo de E/S de texto abierto para lectura.

  This function is roughly equivalent to:

      files(package).joinpath(resource).open('r', encoding=encoding)

importlib.resources.read_binary(package, resource)

  Lee y retorna el contenido de resource dentro de package como `bytes`.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`. resource es el nombre del recurso para abrir dentro de package; puede que no contenga separadores de ruta y que no tenga subrecursos (es decir, no puede ser un directorio). Esta función retorna el contenido del recurso como `bytes`.

  This function is roughly equivalent to:

      files(package).joinpath(resource).read_bytes()

importlib.resources.read_text(package, resource, encoding='utf-8', errors='strict')

  Lee y retorna el contenido de resource dentro de package como `str`. De forma predeterminada, los contenidos se leen como UTF-8 estricto.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`. resource es el nombre del recurso para abrir dentro de package; puede que no contenga separadores de ruta y que no tenga subrecursos (es decir, no puede ser un directorio). encoding y errors tienen el mismo significado que con `open()` integrado. Esta función retorna el contenido del recurso como `str`.

  This function is roughly equivalent to:

      files(package).joinpath(resource).read_text(encoding=encoding)

importlib.resources.path(package, resource)

  Retorna la ruta al resource como una ruta real del sistema de archivos. Esta función retorna un administrador de contexto para usar en una declaración `with`. El administrador de contexto proporciona un objeto `pathlib.Path`.

  Al salir del administrador de contexto, se limpia cualquier archivo temporal creado cuando se necesita extraer el recurso, p. ej: un archivo comprimido.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`. resource es el nombre del recurso para abrir dentro de package; puede que no contenga separadores de ruta y que no tenga subrecursos (es decir, no puede ser un directorio).

  This function is roughly equivalent to

      as_file(files(package).joinpath(resource))

importlib.resources.is_resource(package, name)

  Retorna `True` si hay un recurso llamado name en el paquete, de lo contrario, `False`. Esta función no considera los directorios como recursos. package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`.

  This function is roughly equivalent to:

      files(package).joinpath(resource).is_file()

importlib.resources.contents(package)

  Retorna un iterable sobre los elementos nombrados dentro del paquete. El iterable retorna recursos `str` (por ejemplo, archivos) y no recursos (por ejemplo, directorios). El iterable no recurre a subdirectorios.

  package es un nombre o un objeto de módulo que cumple con los requisitos de `Package`.

  This function is roughly equivalent to:

      (resource.name for resource in files(package).iterdir() if resource.is_file())