Usando "importlib.metadata"
***************************

Nuevo en la versión 3.8.

Distinto en la versión 3.10: "importlib.metadata" ya no es
provisional.

**Source code:** Lib/importlib/metadata/__init__.py

"importlib.metadata" es una biblioteca que proporciona acceso a los
metadatos del paquete instalado. Construida en parte sobre el sistema
de importación de Python, esta biblioteca tiene la intención de
reemplazar una funcionalidad similar ofrecida por la API del punto de
entrada y la API de metadatos de "pkg_resources". Junto con
"importlib.resources" en Python 3.7 y versiones posteriores
(respaldada como importlib_resources para versiones anteriores de
Python), esto puede eliminar la necesidad de usar el paquete
"pkg_resources", antiguo y menos eficiente.

Por "paquete instalado" generalmente nos referimos a un paquete de
terceros instalado en el directorio "site-packages" de Python a través
de herramientas como pip. Específicamente, significa un paquete con un
directorio reconocible "dist-info" o "egg-info" y metadatos definidos
por **PEP 566** o sus especificaciones anteriores. De forma
predeterminada, los metadatos del paquete pueden vivir en el sistema
de archivos o en archivos zip en "sys.path". A través de un mecanismo
de extensión, los metadatos pueden vivir casi en cualquier lugar.


Descripción general
===================

Supongamos que desea obtener la cadena de versión para un paquete que
ha instalado con "pip".  Comenzamos creando un entorno virtual e
instalando algo en él:

   $ python -m venv example
   $ source example/bin/activate
   (example) $ pip install wheel

Se puede obtener la cadena de versión para "wheel" ejecutando lo
siguiente:

   (example) $ python
   >>> from importlib.metadata import version  
   >>> version('wheel')  
   '0.32.3'

También se puede obtener el conjunto de los puntos de entrada
clasificados usando el grupo, como "console_scripts",
"distutils.commands" y otros, como claves. Cada grupo contiene una
secuencia de objetos EntryPoint.

Se pueden obtener los metadatos para una distribución:

   >>> list(metadata('wheel'))  
   ['Metadata-Version', 'Name', 'Version', 'Summary', 'Home-page', 'Author', 'Author-email', 'Maintainer', 'Maintainer-email', 'License', 'Project-URL', 'Project-URL', 'Project-URL', 'Keywords', 'Platform', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Requires-Python', 'Provides-Extra', 'Requires-Dist', 'Requires-Dist']

También se puede obtener el número de versión de una distribución,
enumerar sus archivos constituyentes y obtener una lista de los
Requerimientos de la distribución de la distribución.


API funcional
=============

Este paquete provee la siguiente funcionalidad a través de su API
pública.


Puntos de entrada
-----------------

La función "entry_points()" retorna una colección de todos los puntos
de entrada. Los puntos de entrada están representados por instancias
de "EntryPoint". Cada "EntryPoint" tiene los atributos ".name",
".group" y ".value", y un método ".load()" para resolver el valor.
También hay atributos ".module", ".attr" y ".extras" para obtener los
componentes del atributo ".value".

Consultar todos los puntos de entrada:

   >>> eps = entry_points()  

La función "entry_points()" retorna un objeto "EntryPoints", una
secuencia de todos los objetos "EntryPoint" con atributos "names" y
"groups" por conveniencia:

   >>> sorted(eps.groups)  
   ['console_scripts', 'distutils.commands', 'distutils.setup_keywords', 'egg_info.writers', 'setuptools.installation']

"EntryPoints" tiene un método "select" para seleccionar puntos de
entrada que coincidan con propiedades específicas. Seleccione los
puntos de entrada en el grupo "console_scripts":

   >>> scripts = eps.select(group='console_scripts')  

De manera equivalente, ya que "entry_points" para argumentos de
palabra clave para seleccionar:

   >>> scripts = entry_points(group='console_scripts')  

Elige un script específico llamado "wheel" (que se encuentra en el
proyecto *wheel*):

   >>> 'wheel' in scripts.names  
   True
   >>> wheel = scripts['wheel']  

De manera equivalente, consulta por ese punto de entrada durante la
selección:

   >>> (wheel,) = entry_points(group='console_scripts', name='wheel')  
   >>> (wheel,) = entry_points().select(group='console_scripts', name='wheel')  

Inspeccionar el punto de entrada resuelto:

   >>> wheel  
   EntryPoint(name='wheel', value='wheel.cli:main', group='console_scripts')
   >>> wheel.module  
   'wheel.cli'
   >>> wheel.attr  
   'main'
   >>> wheel.extras  
   []
   >>> main = wheel.load()  
   >>> main  
   <function main at 0x103528488>

The "group" and "name" are arbitrary values defined by the package
author and usually a client will wish to resolve all entry points for
a particular group.  Read the setuptools docs for more information on
entry points, their definition, and usage.

*Nota de compatibilidad*

Los puntos de entrada "seleccionables" se introdujeron en
"importlib_metadata" 3.6 y Python 3.10. Antes de esos cambios,
"entry_points" no aceptaba parámetros y siempre retornaba un
diccionario de puntos de entrada, cifrados por grupo. Para la
compatibilidad, si no se pasa ningún parámetro a *entry_points*, se
retorna un objeto "SelectableGroups", implementando esa interfaz de
diccionario. En el futuro, llamar a "entry_points" sin parámetros
retornará un objeto "EntryPoints". Los usuarios deberían confiar en la
interfaz de selección para recuperar los puntos de entrada por grupo.


Metadatos de distribución
-------------------------

Cada distribución incluye algunos metadatos, que se pueden extraer
utilizando la función "metadata()":

   >>> wheel_metadata = metadata('wheel')  

Las claves de la estructura de datos retornada un "PackageMetadata",
nombran las palabras clave de los metadatos y sus valores se retornan
sin analizar de los metadatos de distribución:

   >>> wheel_metadata['Requires-Python']  
   '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*'

"PackageMetadata" también presenta un atributo "json" que retorna
todos los metadatos en un formulario compatible con JSON por **PEP
566**:

   >>> wheel_metadata.json['requires_python']
   '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*'

Distinto en la versión 3.10: La "Descripción" ahora se incluye en los
metadatos cuando se presenta a través de la carga útil. Se han
eliminado los caracteres de continuación de línea.

Nuevo en la versión 3.10: El atributo "json" fue añadido.


Versiones de distribución
-------------------------

La función "version()" es la forma más rápida para obtener el número
de versión de una distribución, como una cadena de caracteres:

   >>> version('wheel')  
   '0.32.3'


Archivos de distribución
------------------------

También se puede obtener el conjunto completo de archivos contenidos
dentro de una distribución. La función "files()" toma el nombre de un
paquete de distribución y retorna todos los archivos instalados por
esta distribución. Cada objeto de archivo retornado es un
"PackagePath", un objeto derivado de "pathlib.PurePath" con las
propiedades adicionales "dist", "size" y "hash" según indican los
metadatos. Por ejemplo:

   >>> util = [p for p in files('wheel') if 'util.py' in str(p)][0]  
   >>> util  
   PackagePath('wheel/util.py')
   >>> util.size  
   859
   >>> util.dist  
   <importlib.metadata._hooks.PathDistribution object at 0x101e0cef0>
   >>> util.hash  
   <FileHash mode: sha256 value: bYkw5oMccfazVCoYQwKkkemoVyMAFoR34mmKBx8R1NI>

Una vez que se tiene el archivo, también se puede leer su contenido:

   >>> print(util.read_text())  
   import base64
   import sys
   ...
   def as_bytes(s):
       if isinstance(s, text_type):
           return s.encode('utf-8')
       return s

También puede usar el método "locate" para obtener la ruta absoluta al
archivo:

   >>> util.locate()  
   PosixPath('/home/gustav/example/lib/site-packages/wheel/util.py')

En el caso de que el archivo de metadatos que enumera los archivos
(RECORD o SOURCES.txt) falte, "files()" retornará "None". Para evitar
esta condición, si no se sabe si la distribución de destino contiene
los metadatos, se puede envolver las llamadas a "files()" con
always_iterable u otra protección similar.


Requerimientos de la distribución
---------------------------------

Para obtener el conjunto completo de los requerimientos de una
distribución, usa la función "requires()":

   >>> requires('wheel')  
   ["pytest (>=3.0.0) ; extra == 'test'", "pytest-cov ; extra == 'test'"]


Distribuciones de paquetes
--------------------------

Un método conveniente para resolver la distribución o distribuciones
(en el caso de un paquete de espacio de nombres) para paquetes o
módulos de Python de nivel superior:

   >>> packages_distributions()
   {'importlib_metadata': ['importlib-metadata'], 'yaml': ['PyYAML'], 'jaraco': ['jaraco.classes', 'jaraco.functools'], ...}

Nuevo en la versión 3.10.


Distribuciones
==============

Si bien la API de arriba es el uso más común y conveniente, se puede
obtener toda esa información de la clase "Distribution". Una instancia
de "Distribution" es un objeto abstracto que representa los metadatos
de un paquete de Python. Se puede obtener la instancia de
"Distribución" de la siguiente forma:

   >>> from importlib.metadata import distribution  
   >>> dist = distribution('wheel')  

Por lo tanto, una forma alternativa de obtener el número de versión es
mediante la instancia de "Distribución":

   >>> dist.version  
   '0.32.3'

Hay todo tipo de metadatos disponibles adicionales en la instancia de
"Distribution":

   >>> dist.metadata['Requires-Python']  
   '>=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*'
   >>> dist.metadata['License']  
   'MIT'

El conjunto completo de metadatos disponible no está descripto aquí.
Consultar **PEP 566** para detalles adicionales.


Extendiendo el algoritmo de búsqueda
====================================

Debido a que los metadatos de los paquetes no están disponibles a
través de las búsquedas en "sys.path", o en los cargadores de paquetes
directamente, los metadatos de un paquete se encuentran a través del
sistema de importación finders.  Para encontrar los metadatos de un
paquete de distribución, "importlib.metadata" consulta la lista de
*meta path finders* en "sys.meta_path".

El "PathFinder" predeterminado para Python incluye un enlace que llama
a "importlib.metadata.MetadataPathFinder" para encontrar
distribuciones cargadas desde rutas basadas en sistemas de archivos
típicos.

La clase abstracta "importlib.abc.MetaPathFinder" define la interfaz
que se espera de los buscadores por el sistema de importación de
Python. "importlib.metadata" amplía este protocolo buscando una
"find_distributions" opcional invocable en los buscadores desde
"sys.meta_path" y presenta esta interfaz extendida como la clase base
abstracta "DistributionFinder", que define este método abstracto:

   @abc.abstractmethod
   def find_distributions(context=DistributionFinder.Context()):
       """Return an iterable of all Distribution instances capable of
       loading the metadata for packages for the indicated ``context``.
       """

El objeto "DistributionFinder.Context" proporciona propiedades ".path"
y ".name" que indican la ruta de búsqueda y los nombres que deben
coincidir y puede proporcionar otro contexto relevante.

Lo que esto significa en la práctica es que, para soportar la búsqueda
de metadatos en paquetes de distribución en ubicaciones distintas al
sistema de archivos, se debe subclasificar "Distribution" e
implementar sus métodos abstractos. Luego, en el método
"find_distributions()" de un buscador personalizado no hay más que
retornar instancias de esta "Distribution" derivada.
