"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())
