registry.py

Go to the documentation of this file.

# This file is part of pex_config.
#
# Developed for the LSST Data Management System.
# This product includes software developed by the LSST Project
# (http://www.lsst.org).
# See the COPYRIGHT file at the top-level directory of this distribution
# for details of code ownership.
#
# This software is dual licensed under the GNU General Public License and also
# under a 3-clause BSD license. Recipients may choose which of these licenses
# to use; please see the files gpl-3.0.txt and/or bsd_license.txt,
# respectively.  If you choose the GPL option then the following text applies
# (but note that there is still no warranty even if you opt for BSD instead):
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
__all__ = ("Registry", "makeRegistry", "RegistryField", "registerConfig", "registerConfigurable")
 
import collections.abc
import copy
 
from .config import Config, FieldValidationError, _typeStr
from .configChoiceField import ConfigChoiceField, ConfigInstanceDict
 
 
class ConfigurableWrapper:
    """A wrapper for configurables.
 
    Used for configurables that don't contain a ``ConfigClass`` attribute,
    or contain one that is being overridden.
    """
 
    def __init__(self, target, ConfigClass):
        self.ConfigClassConfigClass = ConfigClass
        self._target_target = target
 
    def __call__(self, *args, **kwargs):
        return self._target_target(*args, **kwargs)
 
 
class Registry(collections.abc.Mapping):
    """A base class for global registries, which map names to configurables.
 
    A registry acts like a read-only dictionary with an additional `register`
    method to add targets. Targets in the registry are configurables (see
    *Notes*).
 
    Parameters
    ----------
    configBaseType : `lsst.pex.config.Config`-type
        The base class for config classes in the registry.
 
    Notes
    -----
    A configurable is a callable with call signature ``(config, *args)``
    Configurables typically create an algorithm or are themselves the
    algorithm. Often configurables are `lsst.pipe.base.Task` subclasses, but
    this is not required.
 
    A ``Registry`` has these requirements:
 
    - All configurables added to a particular registry have the same call
      signature.
    - All configurables in a registry typically share something important
      in common. For example, all configurables in ``psfMatchingRegistry``
      return a PSF matching class that has a ``psfMatch`` method with a
      particular call signature.
 
    Examples
    --------
    This examples creates a configurable class ``Foo`` and adds it to a
    registry. First, creating the configurable:
 
    >>> from lsst.pex.config import Registry, Config
    >>> class FooConfig(Config):
    ...     val = Field(dtype=int, default=3, doc="parameter for Foo")
    ...
    >>> class Foo:
    ...     ConfigClass = FooConfig
    ...     def __init__(self, config):
    ...         self.config = config
    ...     def addVal(self, num):
    ...         return self.config.val + num
    ...
 
    Next, create a ``Registry`` instance called ``registry`` and register the
    ``Foo`` configurable under the ``"foo"`` key:
 
    >>> registry = Registry()
    >>> registry.register("foo", Foo)
    >>> print(list(registry.keys()))
    ["foo"]
 
    Now ``Foo`` is conveniently accessible from the registry itself.
 
    Finally, use the registry to get the configurable class and create an
    instance of it:
 
    >>> FooConfigurable = registry["foo"]
    >>> foo = FooConfigurable(FooConfigurable.ConfigClass())
    >>> foo.addVal(5)
    8
    """
 
    def __init__(self, configBaseType=Config):
        if not issubclass(configBaseType, Config):
            raise TypeError(
                "configBaseType=%s must be a subclass of Config"
                % _typeStr(
                    configBaseType,
                )
            )
        self._configBaseType_configBaseType = configBaseType
        self._dict_dict = {}
 
    def register(self, name, target, ConfigClass=None):
        """Add a new configurable target to the registry.
 
        Parameters
        ----------
        name : `str`
            Name that the ``target`` is registered under. The target can
            be accessed later with `dict`-like patterns using ``name`` as
            the key.
        target : obj
            A configurable type, usually a subclass of `lsst.pipe.base.Task`.
        ConfigClass : `lsst.pex.config.Config`-type, optional
            A subclass of `lsst.pex.config.Config` used to configure the
            configurable. If `None` then the configurable's ``ConfigClass``
            attribute is used.
 
        Raises
        ------
        RuntimeError
            Raised if an item with ``name`` is already in the registry.
        AttributeError
            Raised if ``ConfigClass`` is `None` and ``target`` does not have
            a ``ConfigClass`` attribute.
 
        Notes
        -----
        If ``ConfigClass`` is provided then the ``target`` configurable is
        wrapped in a new object that forwards function calls to it. Otherwise
        the original ``target`` is stored.
        """
        if name in self._dict_dict:
            raise RuntimeError("An item with name %r already exists" % name)
        if ConfigClass is None:
            wrapper = target
        else:
            wrapper = ConfigurableWrapper(target, ConfigClass)
        if not issubclass(wrapper.ConfigClass, self._configBaseType_configBaseType):
            raise TypeError(
                "ConfigClass=%s is not a subclass of %r"
                % (_typeStr(wrapper.ConfigClass), _typeStr(self._configBaseType_configBaseType))
            )
        self._dict_dict[name] = wrapper
 
    def __getitem__(self, key):
        return self._dict_dict[key]
 
    def __len__(self):
        return len(self._dict_dict)
 
    def __iter__(self):
        return iter(self._dict_dict)
 
    def __contains__(self, key):
        return key in self._dict_dict
 
    def makeField(self, doc, default=None, optional=False, multi=False):
        """Create a `RegistryField` configuration field from this registry.
 
        Parameters
        ----------
        doc : `str`
            A description of the field.
        default : object, optional
            The default target for the field.
        optional : `bool`, optional
            When `False`, `lsst.pex.config.Config.validate` fails if the
            field's value is `None`.
        multi : `bool`, optional
            A flag to allow multiple selections in the `RegistryField` if
            `True`.
 
        Returns
        -------
        field : `lsst.pex.config.RegistryField`
            `~lsst.pex.config.RegistryField` Configuration field.
        """
        return RegistryField(doc, self, default, optional, multi)
 
 
class RegistryAdaptor(collections.abc.Mapping):
    """Private class that makes a `Registry` behave like the thing a
    `~lsst.pex.config.ConfigChoiceField` expects.
 
    Parameters
    ----------
    registry : `Registry`
        `Registry` instance.
    """
 
    def __init__(self, registry):
        self.registryregistry = registry
 
    def __getitem__(self, k):
        return self.registryregistry[k].ConfigClass
 
    def __iter__(self):
        return iter(self.registryregistry)
 
    def __len__(self):
        return len(self.registryregistry)
 
    def __contains__(self, k):
        return k in self.registryregistry
 
 
class RegistryInstanceDict(ConfigInstanceDict):
    """Dictionary of instantiated configs, used to populate a `RegistryField`.
 
    Parameters
    ----------
    config : `lsst.pex.config.Config`
        Configuration instance.
    field : `RegistryField`
        Configuration field.
    """
 
    def __init__(self, config, field):
        ConfigInstanceDict.__init__(self, config, field)
        self.registryregistry = field.registry
 
    def _getTarget(self):
        if self._field_field.multi:
            raise FieldValidationError(
                self._field_field, self._config_config, "Multi-selection field has no attribute 'target'"
            )
        return self.typestypes.registry[self._selection_selection]
 
    target = property(_getTarget)
 
    def _getTargets(self):
        if not self._field_field.multi:
            raise FieldValidationError(
                self._field_field, self._config_config, "Single-selection field has no attribute 'targets'"
            )
        return [self.typestypes.registry[c] for c in self._selection_selection]
 
    targets = property(_getTargets)
 
    def apply(self, *args, **kw):
        """Call the active target(s) with the active config as a keyword arg
 
        If this is a multi-selection field, return a list obtained by calling
        each active target with its corresponding active config.
 
        Additional arguments will be passed on to the configurable target(s)
        """
        if self.activeactive is None:
            msg = "No selection has been made.  Options: %s" % " ".join(self.typestypes.registry.keys())
            raise FieldValidationError(self._field_field, self._config_config, msg)
        if self._field_field.multi:
            retvals = []
            for c in self._selection_selection:
                retvals.append(self.typestypes.registry[c](*args, config=self[c], **kw))
            return retvals
        else:
            return self.typestypes.registry[self.namename](*args, config=self[self.namename], **kw)
 
    def __setattr__(self, attr, value):
        if attr == "registry":
            object.__setattr__(self, attr, value)
        else:
            ConfigInstanceDict.__setattr__(self, attr, value)
 
 
class RegistryField(ConfigChoiceField):
    """A configuration field whose options are defined in a `Registry`.
 
    Parameters
    ----------
    doc : `str`
        A description of the field.
    registry : `Registry`
        The registry that contains this field.
    default : `str`, optional
        The default target key.
    optional : `bool`, optional
        When `False`, `lsst.pex.config.Config.validate` fails if the field's
        value is `None`.
    multi : `bool`, optional
        If `True`, the field allows multiple selections. The default is
        `False`.
 
    See also
    --------
    ChoiceField
    ConfigChoiceField
    ConfigDictField
    ConfigField
    ConfigurableField
    DictField
    Field
    ListField
    RangeField
    """
 
    instanceDictClass = RegistryInstanceDict
    """Class used to hold configurable instances in the field.
    """
 
    def __init__(self, doc, registry, default=None, optional=False, multi=False):
        types = RegistryAdaptor(registry)
        self.registryregistry = registry
        ConfigChoiceField.__init__(self, doc, types, default, optional, multi)
 
    def __deepcopy__(self, memo):
        """Customize deep-copying, want a reference to the original registry.
 
        WARNING: this must be overridden by subclasses if they change the
        constructor signature!
        """
        other = type(self)(
            doc=self.docdoc,
            registry=self.registryregistry,
            default=copy.deepcopy(self.defaultdefault),
            optional=self.optionaloptional,
            multi=self.multimulti,
        )
        other.source = self.sourcesource
        return other
 
 
def makeRegistry(doc, configBaseType=Config):
    """Create a `Registry`.
 
    Parameters
    ----------
    doc : `str`
        Docstring for the created `Registry` (this is set as the ``__doc__``
        attribute of the `Registry` instance.
    configBaseType : `lsst.pex.config.Config`-type
        Base type of config classes in the `Registry`
        (`lsst.pex.config.Registry.configBaseType`).
 
    Returns
    -------
    registry : `Registry`
        Registry with ``__doc__`` and `~Registry.configBaseType` attributes
        set.
    """
    cls = type("Registry", (Registry,), {"__doc__": doc})
    return cls(configBaseType=configBaseType)
 
 
def registerConfigurable(name, registry, ConfigClass=None):
    """A decorator that adds a class as a configurable in a `Registry`
    instance.
 
    Parameters
    ----------
    name : `str`
        Name of the target (the decorated class) in the ``registry``.
    registry : `Registry`
        The `Registry` instance that the decorated class is added to.
    ConfigClass : `lsst.pex.config.Config`-type, optional
        Config class associated with the configurable. If `None`, the class's
        ``ConfigClass`` attribute is used instead.
 
    See also
    --------
    registerConfig
 
    Notes
    -----
    Internally, this decorator runs `Registry.register`.
    """
 
    def decorate(cls):
        registry.register(name, target=cls, ConfigClass=ConfigClass)
        return cls
 
    return decorate
 
 
def registerConfig(name, registry, target):
    """Decorator that adds a class as a ``ConfigClass`` in a `Registry` and
    associates it with the given configurable.
 
    Parameters
    ----------
    name : `str`
        Name of the ``target`` in the ``registry``.
    registry : `Registry`
        The registry containing the ``target``.
    target : obj
        A configurable type, such as a subclass of `lsst.pipe.base.Task`.
 
    See also
    --------
    registerConfigurable
 
    Notes
    -----
    Internally, this decorator runs `Registry.register`.
    """
 
    def decorate(cls):
        registry.register(name, target=target, ConfigClass=cls)
        return cls
 
    return decorate