lsst.pex.config g6ad3b95c47+77627e773c
Public Member Functions | List of all members
lsst.pex.config.registry.Registry Class Reference
Inheritance diagram for lsst.pex.config.registry.Registry:

Public Member Functions

def __init__ (self, configBaseType=Config)
 
def register (self, name, target, ConfigClass=None)
 
def __getitem__ (self, key)
 
def __len__ (self)
 
def __iter__ (self)
 
def __contains__ (self, key)
 
def makeField (self, doc, default=None, optional=False, multi=False)
 

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

Member Function Documentation

◆ makeField()

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

◆ register()

def 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.

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