LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Member Functions | List of all members
lsst.pex.config.registry.Registry Class Reference
Inheritance diagram for lsst.pex.config.registry.Registry:
lsst.meas.base.pluginRegistry.PluginRegistry

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

Definition at line 52 of file registry.py.

Constructor & Destructor Documentation

◆ __init__()

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

Definition at line 116 of file registry.py.

116  def __init__(self, configBaseType=Config):
117  if not issubclass(configBaseType, Config):
118  raise TypeError("configBaseType=%s must be a subclass of Config" % _typeStr(configBaseType,))
119  self._configBaseType = configBaseType
120  self._dict = {}
121 

Member Function Documentation

◆ __contains__()

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

Definition at line 172 of file registry.py.

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

◆ __getitem__()

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

Definition at line 163 of file registry.py.

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

◆ __iter__()

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

Definition at line 169 of file registry.py.

169  def __iter__(self):
170  return iter(self._dict)
171 

◆ __len__()

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

Definition at line 166 of file registry.py.

166  def __len__(self):
167  return len(self._dict)
168 

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

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

Definition at line 175 of file registry.py.

175  def makeField(self, doc, default=None, optional=False, multi=False):
176  """Create a `RegistryField` configuration field from this registry.
177 
178  Parameters
179  ----------
180  doc : `str`
181  A description of the field.
182  default : object, optional
183  The default target for the field.
184  optional : `bool`, optional
185  When `False`, `lsst.pex.config.Config.validate` fails if the
186  field's value is `None`.
187  multi : `bool`, optional
188  A flag to allow multiple selections in the `RegistryField` if
189  `True`.
190 
191  Returns
192  -------
193  field : `lsst.pex.config.RegistryField`
194  `~lsst.pex.config.RegistryField` Configuration field.
195  """
196  return RegistryField(doc, self, default, optional, multi)
197 
198 

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

Definition at line 122 of file registry.py.

122  def register(self, name, target, ConfigClass=None):
123  """Add a new configurable target to the registry.
124 
125  Parameters
126  ----------
127  name : `str`
128  Name that the ``target`` is registered under. The target can
129  be accessed later with `dict`-like patterns using ``name`` as
130  the key.
131  target : obj
132  A configurable type, usually a subclass of `lsst.pipe.base.Task`.
133  ConfigClass : `lsst.pex.config.Config`-type, optional
134  A subclass of `lsst.pex.config.Config` used to configure the
135  configurable. If `None` then the configurable's ``ConfigClass``
136  attribute is used.
137 
138  Raises
139  ------
140  RuntimeError
141  Raised if an item with ``name`` is already in the registry.
142  AttributeError
143  Raised if ``ConfigClass`` is `None` and ``target`` does not have
144  a ``ConfigClass`` attribute.
145 
146  Notes
147  -----
148  If ``ConfigClass`` is provided then the ``target`` configurable is
149  wrapped in a new object that forwards function calls to it. Otherwise
150  the original ``target`` is stored.
151  """
152  if name in self._dict:
153  raise RuntimeError("An item with name %r already exists" % name)
154  if ConfigClass is None:
155  wrapper = target
156  else:
157  wrapper = ConfigurableWrapper(target, ConfigClass)
158  if not issubclass(wrapper.ConfigClass, self._configBaseType):
159  raise TypeError("ConfigClass=%s is not a subclass of %r" %
160  (_typeStr(wrapper.ConfigClass), _typeStr(self._configBaseType)))
161  self._dict[name] = wrapper
162 

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