Inheritance diagram for lsst.pex.config.registry.Registry:

Public Member Functions
	__init__ (self, configBaseType=Config)

	register (self, name, target, ConfigClass=None)

	__getitem__ (self, key)

	__len__ (self)

	__iter__ (self)

	__contains__ (self, key)

	makeField (self, doc, default=None, optional=False, multi=False, on_none=None)

Protected Attributes
	_configBaseType = configBaseType

dict	_dict = {}

Detailed Description

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

Definition at line 59 of file registry.py.

Constructor & Destructor Documentation

◆ init()

lsst.pex.config.registry.Registry.__init__	(		self,
			configBaseType = Config )

Definition at line 123 of file registry.py.

    def __init__(self, configBaseType=Config):
        if not issubclass(configBaseType, Config):
            raise TypeError(f"configBaseType={_typeStr(configBaseType)} must be a subclass of Config")
        self._configBaseType = configBaseType
        self._dict = {}
 

Member Function Documentation

◆ contains()

lsst.pex.config.registry.Registry.__contains__	(		self,
			key )

Definition at line 181 of file registry.py.

    def __contains__(self, key):
        return key in self._dict
 

◆ getitem()

lsst.pex.config.registry.Registry.__getitem__	(		self,
			key )

Definition at line 172 of file registry.py.

    def __getitem__(self, key):
        return self._dict[key]
 

◆ iter()

lsst.pex.config.registry.Registry.__iter__ ( self )

Definition at line 178 of file registry.py.

    def __iter__(self):
        return iter(self._dict)
 

◆ len()

lsst.pex.config.registry.Registry.__len__ ( self )

Definition at line 175 of file registry.py.

    def __len__(self):
        return len(self._dict)
 

◆ makeField()

lsst.pex.config.registry.Registry.makeField	(	self,
		doc,
		default = None,
		optional = False,
		multi = False,
		on_none = None )

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`.
on_none : `Callable`, optional
    A callable that should be invoked when ``apply`` is called but the
    selected name or names is `None`.  Will be passed the field
    attribute proxy (`RegistryInstanceDict`) and then all positional
    and keyword arguments passed to ``apply``.

Returns
-------
field : `lsst.pex.config.RegistryField`
    `~lsst.pex.config.RegistryField` Configuration field.

Reimplemented in lsst.meas.base.pluginRegistry.PluginRegistry.

Definition at line 184 of file registry.py.

    def makeField(self, doc, default=None, optional=False, multi=False, on_none=None):
        """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`.
        on_none : `Callable`, optional
            A callable that should be invoked when ``apply`` is called but the
            selected name or names is `None`.  Will be passed the field
            attribute proxy (`RegistryInstanceDict`) and then all positional
            and keyword arguments passed to ``apply``.
 
        Returns
        -------
        field : `lsst.pex.config.RegistryField`
            `~lsst.pex.config.RegistryField` Configuration field.
        """
        return RegistryField(doc, self, default, optional, multi, on_none=on_none)
 
 

◆ register()

lsst.pex.config.registry.Registry.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.

Reimplemented in lsst.meas.base.pluginRegistry.PluginRegistry.

Definition at line 129 of file registry.py.

    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:
            raise RuntimeError(f"An item with name {name!r} already exists")
        if ConfigClass is None:
            wrapper = target
        else:
            wrapper = ConfigurableWrapper(target, ConfigClass)
        if not issubclass(wrapper.ConfigClass, self._configBaseType):
            raise TypeError(
                f"ConfigClass={_typeStr(wrapper.ConfigClass)} is not a subclass of "
                f"{_typeStr(self._configBaseType)!r}"
            )
        self._dict[name] = wrapper
 

Member Data Documentation

◆ _configBaseType

lsst.pex.config.registry.Registry._configBaseType = configBaseType

protected

Definition at line 126 of file registry.py.

◆ _dict

lsst.pex.config.registry.Registry._dict = {}

protected

Definition at line 127 of file registry.py.

The documentation for this class was generated from the following file:

/j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/pex_config/gbaa8f7a6c5+38b34f4976/python/lsst/pex/config/registry.py

Public Member Functions

Protected Attributes