molfeat.plugins

BaseFactory(group, name, load=True)

Return the plugin class registered under a given entry point group and name.

Parameters:

Name	Type	Description	Default
group	str	entry point group	required
name	str	entry point name	required
load	bool	if True, load the matched entry point and return the loaded resource instead of the entry point itself.	True

Return: the plugin class Raises: MissingEntryPointError: entry point was not registered MultipleEntryPointError: entry point could not be uniquely resolved LoadingEntryPointError: entry point could not be loaded

Source code in molfeat/plugins/factories.py

def BaseFactory(group: str, name: str, load: bool = True) -> Union[EntryPoint, Any]:
    """Return the plugin class registered under a given entry point group and name.

    Args:
        group: entry point group
        name: entry point name
        load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
    Return:
        the plugin class
    Raises:
        MissingEntryPointError: entry point was not registered
        MultipleEntryPointError: entry point could not be uniquely resolved
        LoadingEntryPointError: entry point could not be loaded
    """
    # circular import
    from .entry_point import get_entry_point, load_entry_point

    if load is True:
        return load_entry_point(group, name)

    return get_entry_point(group, name)

CalculatorFactory(entry_point_name, load=True, entry_point_group=None)

Return the SerializableCalculator sub class registered under the given entry point.

Parameters:

Name	Type	Description	Default
entry_point_name	str	the entry point name.	required
load	bool	if True, load the matched entry point and return the loaded resource instead of the entry point itself.	True
entry_point_group	Optional[str]	the optional entry point group to use	None

Return

sub class of class:~molfeat.calc.SerializableCalculator

Source code in molfeat/plugins/factories.py

def CalculatorFactory(
    entry_point_name: str,
    load: bool = True,
    entry_point_group: Optional[str] = None,
) -> Union[EntryPoint, Type["SerializableCalculator"], Callable]:
    """Return the `SerializableCalculator` sub class registered under the given entry point.

    Args:
        entry_point_name: the entry point name.
        load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
        entry_point_group: the optional entry point group to use

    Return:
        sub class of :py:class:`~molfeat.calc.SerializableCalculator`
    """
    from molfeat.calc import SerializableCalculator

    if entry_point_group is None:
        entry_point_group = "molfeat.calc"
    entry_point = BaseFactory(entry_point_group, entry_point_name, load=load)
    valid_classes = (SerializableCalculator,)

    if not load:
        return entry_point

    # if the entry point is a module, nothing to do
    if ismodule(entry_point):
        return entry_point
    if isclass(entry_point) and issubclass(entry_point, valid_classes):
        return entry_point

    raise_invalid_type_error(entry_point_name, entry_point_group, valid_classes)

DefaultFactory(entry_point_name, load=True, entry_point_group=None)

Return the Default factory for extending capabilities given a specific module.

Parameters:

Name	Type	Description	Default
entry_point_name	str	the entry point name.	required
load	bool	if True, load the matched entry point and return the loaded resource instead of the entry point itself.	True
entry_point_group	str	the optional entry point group to use	None

Returns:

Type	Description
Union[EntryPoint, Type[PretrainedMolTransformer], Callable]	sub class or module of

Raise

InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.

Source code in molfeat/plugins/factories.py

def DefaultFactory(
    entry_point_name: str,
    load: bool = True,
    entry_point_group: str = None,
) -> Union[EntryPoint, Type["PretrainedMolTransformer"], Callable]:
    """Return the Default factory for extending capabilities given a specific module.

    Args:
        entry_point_name: the entry point name.
        load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
        entry_point_group: the optional entry point group to use

    Returns:
        sub class or module of

    Raise:
        InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.
    """

    if entry_point_group is None:
        entry_point_group = "molfeat"
    entry_point = BaseFactory(entry_point_group, entry_point_name, load=load)

    if not load:
        return entry_point
    # if the entry point is a module, nothing to do
    if ismodule(entry_point):
        return entry_point
    raise_invalid_type_error(entry_point_name, entry_point_group, ())

PretrainedTransformerFactory(entry_point_name, load=True, entry_point_group=None)

Return the PretrainedMolTransformer sub class registered under the given entry point.

Parameters:

Name	Type	Description	Default
entry_point_name	str	the entry point name.	required
load	bool	if True, load the matched entry point and return the loaded resource instead of the entry point itself.	True
entry_point_group	Optional[str]	the optional entry point group to use	None

Returns:

Type	Description
Union[EntryPoint, Type[PretrainedMolTransformer], Callable]	sub class of class:~molfeat.trans.pretrained.PretrainedMolTransformer

Raise

InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.

Source code in molfeat/plugins/factories.py

def PretrainedTransformerFactory(
    entry_point_name: str,
    load: bool = True,
    entry_point_group: Optional[str] = None,
) -> Union[EntryPoint, Type["PretrainedMolTransformer"], Callable]:
    """Return the PretrainedMolTransformer sub class registered under the given entry point.

    Args:
        entry_point_name: the entry point name.
        load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
        entry_point_group: the optional entry point group to use

    Returns:
        sub class of :py:class:`~molfeat.trans.pretrained.PretrainedMolTransformer`

    Raise:
        InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.
    """
    from molfeat.trans import MoleculeTransformer
    from molfeat.trans.pretrained import PretrainedMolTransformer

    if entry_point_group is None:
        entry_point_group = "molfeat.trans.pretrained"
    entry_point = BaseFactory(entry_point_group, entry_point_name, load=load)
    valid_classes = (PretrainedMolTransformer, MoleculeTransformer)

    if not load:
        return entry_point
    # if the entry point is a module, nothing to do
    if ismodule(entry_point):
        return entry_point
    if isclass(entry_point) and issubclass(entry_point, valid_classes):
        return entry_point

    raise_invalid_type_error(entry_point_name, entry_point_group, valid_classes)

TransformerFactory(entry_point_name, load=True, entry_point_group=None)

Return the MoleculeTransformer sub class registered under the given entry point.

Parameters:

Name	Type	Description	Default
entry_point_name	str	the entry point name.	required
load	bool	if True, load the matched entry point and return the loaded resource instead of the entry point itself.	True
entry_point_group	Optional[str]	the optional entry point group to use	None

Returns:

Type	Description
Union[EntryPoint, Type[MoleculeTransformer], Callable]	sub class of class:~molfeat.trans.MoleculeTransformer

Raise

InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.

Source code in molfeat/plugins/factories.py

def TransformerFactory(
    entry_point_name: str,
    load: bool = True,
    entry_point_group: Optional[str] = None,
) -> Union[EntryPoint, Type["MoleculeTransformer"], Callable]:
    """Return the `MoleculeTransformer` sub class registered under the given entry point.

    Args:
        entry_point_name: the entry point name.
        load: if True, load the matched entry point and return the loaded resource instead of the entry point itself.
        entry_point_group: the optional entry point group to use

    Returns:
        sub class of :py:class:`~molfeat.trans.MoleculeTransformer`

    Raise:
        InvalidEntryPointTypeError: if the type of the loaded entry point is invalid.
    """
    from molfeat.trans import MoleculeTransformer
    from molfeat.trans import BaseFeaturizer

    if entry_point_group is None:
        entry_point_group = "molfeat.trans"
    entry_point = BaseFactory(entry_point_group, entry_point_name, load=load)
    valid_classes = (MoleculeTransformer, BaseFeaturizer)

    if not load:
        return entry_point

    # if the entry point is a module, nothing to do
    if ismodule(entry_point):
        return entry_point
    if isclass(entry_point) and issubclass(entry_point, valid_classes):
        return entry_point

    raise_invalid_type_error(entry_point_name, entry_point_group, valid_classes)

raise_invalid_type_error(entry_point_name, entry_point_group, valid_classes)

Raise an InvalidEntryPointTypeError with formatted message.

Parameters:

Name	Type	Description	Default
entry_point_name	str	name of the entry point	required
entry_point_group	str	name of the entry point group	required
valid_classes	Tuple[Any, ...]	tuple of valid classes for the given entry point group	required

Raises:

Type	Description
InvalidEntryPointTypeError	always

Source code in molfeat/plugins/factories.py

def raise_invalid_type_error(
    entry_point_name: str, entry_point_group: str, valid_classes: Tuple[Any, ...]
) -> NoReturn:
    """Raise an `InvalidEntryPointTypeError` with formatted message.

    Args:
        entry_point_name: name of the entry point
        entry_point_group: name of the entry point group
        valid_classes: tuple of valid classes for the given entry point group

    Raises:
        InvalidEntryPointTypeError: always
    """
    template = "entry point `{}` registered in group `{}` is invalid because its type is not one of the supported types ({})"
    args = (
        entry_point_name,
        entry_point_group,
        ", ".join([e.__name__ for e in valid_classes]),
    )
    raise InvalidEntryPointTypeError(template.format(*args))

get_entry_point(group, name)

Return an entry point with a given name within a specific group Args: group: the entry point group name: the name of the entry point

Source code in molfeat/plugins/entry_point.py

def get_entry_point(group: str, name: str) -> EntryPoint:
    """
    Return an entry point with a given name within a specific group
    Args:
        group: the entry point group
        name: the name of the entry point
    """
    found = eps().select(group=group, name=name)
    if name not in found.names:
        raise MissingEntryPointError(f"Entry point '{name}' not found in group '{group}'")
    # If multiple entry points are found and they have different values we raise, otherwise if they all
    # correspond to the same value, we simply return one of them
    if len(found) > 1 and len(set(ep.value for ep in found)) != 1:
        raise MultipleEntryPointError(
            f"Multiple entry points '{name}' found in group '{group}': {found}"
        )
    return found[name]

get_entry_points(group)

Return a list of all the entry points within a specific group

Parameters:

Name	Type	Description	Default
group	str	the entry point group	required

Returns:

Type	Description
	a list of entry points

Source code in molfeat/plugins/entry_point.py

def get_entry_points(group: str):
    """
    Return a list of all the entry points within a specific group

    Args:
        group: the entry point group

    Returns:
        a list of entry points
    """
    return eps().select(group=group)

is_registered_entry_point(class_module, class_name, groups=None) cached

Verify whether the class with the given module and class name is a registered entry point.

Note

This function only checks whether the class has a registered entry point. It does explicitly not verify if the corresponding class is also importable. Use load_entry_point for this purpose instead.

Parameters:

Name	Type	Description	Default
class_module	str	the module of the class	required
class_name	str	the name of the class	required
groups	Optional[Sequence[str]]	optionally consider only these entry point groups to look for the class	None

Returns:

Type	Description
bool	True if the class is a registered entry point, False otherwise.

Source code in molfeat/plugins/entry_point.py

@functools.lru_cache(maxsize=100)
def is_registered_entry_point(
    class_module: str, class_name: str, groups: Optional[Sequence[str]] = None
) -> bool:
    """Verify whether the class with the given module and class name is a registered entry point.

    !!! note
        This function only checks whether the class has a registered entry point. It does explicitly not verify
        if the corresponding class is also importable. Use `load_entry_point` for this purpose instead.

    Args:
        class_module: the module of the class
        class_name: the name of the class
        groups: optionally consider only these entry point groups to look for the class

    Returns:
        True if the class is a registered entry point, False otherwise.
    """
    for group in eps().groups if groups is None else groups:
        for entry_point in get_entry_points(group):
            if class_module == entry_point.module and class_name == entry_point.attr:
                return True
    return False

load_entry_point(group, name)

Load the class registered under the entry point for a given name and group

Parameters:

Name	Type	Description	Default
group	str	the entry point group	required
name	str	the name of the entry point	required

Returns:

Type	Description
Any	class registered at the given entry point

Raises:

Type	Description
MissingEntryPointError	if the entry point was not registered
MultipleEntryPointError	if the entry point could not be uniquely resolved
LoadingEntryPointError	if the entry point could not be loaded

Source code in molfeat/plugins/entry_point.py

def load_entry_point(group: str, name: str) -> Any:
    """
    Load the class registered under the entry point for a given name and group

    Args:
        group: the entry point group
        name: the name of the entry point

    Returns:
        class registered at the given entry point

    Raises:
        MissingEntryPointError: if the entry point was not registered
        MultipleEntryPointError: if the entry point could not be uniquely resolved
        LoadingEntryPointError: if the entry point could not be loaded
    """
    entry_point = get_entry_point(group, name)

    try:
        loaded_entry_point = entry_point.load()
    except ImportError:
        raise LoadingEntryPointError(
            f"Failed to load entry point '{name}':\n{traceback.format_exc()}"
        )

    return loaded_entry_point

load_registered_plugins(add_submodules=True, groups=None, plugins=None, verbose=True)

Load all registered entry points by loading them with the corresponding factory and adding them to the corresponding module attribute.

Parameters:

Name	Type	Description	Default
add_submodules	bool	if True, add the loaded entry point to the corresponding module attribute.	True
groups	Optional[List[str]]	if provided, only load entry points from the given groups.	None
plugins	Optional[List[str]]	if provided, only load entry points or modules/classes that matches entry in the plugins list.	None
verbose	bool	if True, log a warning if an entry point cannot be loaded.	True

Raises:

Type	Description
EntryPointError	if any of the registered entry points cannot be loaded. This can happen if: * The entry point cannot uniquely be resolved * The resource registered at the entry point cannot be imported * The resource's type is incompatible with the entry point group that it is defined in.

Source code in molfeat/plugins/entry_point.py

def load_registered_plugins(
    add_submodules: bool = True,
    groups: Optional[List[str]] = None,
    plugins: Optional[List[str]] = None,
    verbose: bool = True,
):
    """Load all registered entry points by loading them with the corresponding factory and adding them to the corresponding module attribute.

    Args:
        add_submodules: if True, add the loaded entry point to the corresponding module attribute.
        groups: if provided, only load entry points from the given groups.
        plugins: if provided, only load entry points or modules/classes that matches entry in the plugins list.
        verbose: if True, log a warning if an entry point cannot be loaded.

    Raises:
        EntryPointError: if any of the registered entry points cannot be loaded. This can happen if:
            * The entry point cannot uniquely be resolved
            * The resource registered at the entry point cannot be imported
            * The resource's type is incompatible with the entry point group that it is defined in.
    """
    for entry_point_group, factory in ENTRY_POINT_GROUP_FACTORYCLASS_MAPPING.items():
        if groups is not None and entry_point_group not in groups:
            continue
        entry_points = get_entry_points(entry_point_group)
        for entry_point in entry_points:
            try:
                loaded_module = factory(entry_point.name, entry_point_group=entry_point_group)
                if _is_valid_plugin(loaded_module, plugins):
                    setattr(
                        sys.modules[entry_point.group],
                        loaded_module.__name__,
                        loaded_module,
                    )
                    if add_submodules:
                        if not ismodule(loaded_module):
                            module_to_add = loaded_module.__module__
                        else:
                            module_to_add = loaded_module
                        sys.modules[f"{entry_point.group}.{entry_point.name}"] = module_to_add
            except AttributeError as e:
                if verbose:
                    logger.warning(
                        f"Could not load entry point {entry_point.name} from group {entry_point.group}"
                    )
                    logger.exception(e)

validate_registered_entry_points()

Validate all registered entry points by loading them with the corresponding factory.

Raises:

Type	Description
EntryPointError	if any of the registered entry points cannot be loaded. This can happen if: * The entry point cannot uniquely be resolved * The resource registered at the entry point cannot be imported * The resource's type is incompatible with the entry point group that it is defined in.

Source code in molfeat/plugins/entry_point.py

def validate_registered_entry_points():
    """Validate all registered entry points by loading them with the corresponding factory.

    Raises:
        EntryPointError: if any of the registered entry points cannot be loaded. This can happen if:
            * The entry point cannot uniquely be resolved
            * The resource registered at the entry point cannot be imported
            * The resource's type is incompatible with the entry point group that it is defined in.
    """
    for entry_point_group, factory in ENTRY_POINT_GROUP_FACTORYCLASS_MAPPING.items():
        entry_points = get_entry_points(entry_point_group)
        for entry_point in entry_points:
            factory(entry_point.name)