Source code for aiida.plugins.utils
###########################################################################
# Copyright (c), The AiiDA team. All rights reserved. #
# This file is part of the AiiDA code. #
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida-core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
"""Utilities dealing with plugins and entry points."""
from __future__ import annotations
import typing as t
from importlib import import_module
from logging import Logger
from types import FunctionType
from aiida.common import AIIDA_LOGGER
from aiida.common.exceptions import EntryPointError
from .entry_point import load_entry_point_from_string
__all__ = ('PluginVersionProvider',)
KEY_VERSION_ROOT: str = 'version'
KEY_VERSION_CORE: str = 'core' # The version of `aiida-core`
KEY_VERSION_PLUGIN: str = 'plugin' # The version of the plugin top level module, e.g. `aiida-quantumespresso`
[docs]
class PluginVersionProvider:
"""Utility class that determines version information about a given plugin resource."""
[docs]
def __init__(self):
self._cache: dict[type | FunctionType, dict[t.Any, dict[t.Any, t.Any]]] = {}
self._logger: Logger = AIIDA_LOGGER.getChild('plugin_version_provider')
@property
def logger(self) -> Logger:
return self._logger
[docs]
def get_version_info(self, plugin: str | type) -> dict[t.Any, dict[t.Any, t.Any]]:
"""Get the version information for a given plugin.
.. note::
This container will keep a cache, so if this method was already called for the given ``plugin`` before for
this instance, the result computed at the last invocation will be returned.
:param plugin: A class, function, or an entry point string. If the type is string, it will be assumed to be an
entry point string and the class will attempt to load it first. It should be a full entry point string,
including the entry point group.
:return: Dictionary with the `version.core` and optionally `version.plugin` if it could be determined.
:raises EntryPointError: If ``plugin`` is a string but could not be loaded as a valid entry point.
:raises TypeError: If ``plugin`` (or the resource pointed to it in the case of an entry point) is not a class
or a function.
"""
from inspect import isclass, isfunction
from aiida import __version__ as version_core
if isinstance(plugin, str):
try:
plugin = load_entry_point_from_string(plugin)
except EntryPointError as exc:
raise EntryPointError(f'got string `{plugin}` but could not load corresponding entry point') from exc
if not isclass(plugin) and not isfunction(plugin):
raise TypeError(f'`{plugin}` is not a class nor a function.')
# If the `plugin` already exists in the cache, simply return it. On purpose we do not verify whether the version
# information is completed. If it failed the first time, we don't retry. If the failure was temporarily, whoever
# holds a reference to this instance can simply reconstruct it to start with a clean slate.
if plugin in self._cache:
return self._cache[plugin]
self._cache[plugin] = {
KEY_VERSION_ROOT: {
KEY_VERSION_CORE: version_core,
}
}
try:
parent_module_name = plugin.__module__.split('.')[0]
parent_module = import_module(parent_module_name)
except (AttributeError, IndexError, ImportError):
self.logger.debug(f'could not determine the top level module for plugin: {plugin}')
return self._cache[plugin]
try:
version_plugin = parent_module.__version__
except AttributeError:
self.logger.debug(f'parent module does not define `__version__` attribute for plugin: {plugin}')
return self._cache[plugin]
self._cache[plugin][KEY_VERSION_ROOT][KEY_VERSION_PLUGIN] = version_plugin
return self._cache[plugin]