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 | |
| _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.
123 def __init__(self, configBaseType=Config):
124 if not issubclass(configBaseType, Config):
125 raise TypeError(f"configBaseType={_typeStr(configBaseType)} must be a subclass of Config")
126 self._configBaseType = configBaseType
127 self._dict = {}
128
Member Function Documentation
◆ __contains__()
| lsst.pex.config.registry.Registry.__contains__ | ( | self, | |
| key ) |
Definition at line 181 of file registry.py.
181 def __contains__(self, key):
182 return key in self._dict
183
◆ __getitem__()
| lsst.pex.config.registry.Registry.__getitem__ | ( | self, | |
| key ) |
Definition at line 172 of file registry.py.
172 def __getitem__(self, key):
173 return self._dict[key]
174
◆ __iter__()
| lsst.pex.config.registry.Registry.__iter__ | ( | self | ) |
Definition at line 178 of file registry.py.
178 def __iter__(self):
179 return iter(self._dict)
180
◆ __len__()
| lsst.pex.config.registry.Registry.__len__ | ( | self | ) |
Definition at line 175 of file registry.py.
175 def __len__(self):
176 return len(self._dict)
177
◆ 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.
184 def makeField(self, doc, default=None, optional=False, multi=False, on_none=None):
185 """Create a `RegistryField` configuration field from this registry.
186
187 Parameters
188 ----------
189 doc : `str`
190 A description of the field.
191 default : object, optional
192 The default target for the field.
193 optional : `bool`, optional
194 When `False`, `lsst.pex.config.Config.validate` fails if the
195 field's value is `None`.
196 multi : `bool`, optional
197 A flag to allow multiple selections in the `RegistryField` if
198 `True`.
199 on_none : `Callable`, optional
200 A callable that should be invoked when ``apply`` is called but the
201 selected name or names is `None`. Will be passed the field
202 attribute proxy (`RegistryInstanceDict`) and then all positional
203 and keyword arguments passed to ``apply``.
204
205 Returns
206 -------
207 field : `lsst.pex.config.RegistryField`
208 `~lsst.pex.config.RegistryField` Configuration field.
209 """
210 return RegistryField(doc, self, default, optional, multi, on_none=on_none)
211
212
◆ 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.
129 def register(self, name, target, ConfigClass=None):
130 """Add a new configurable target to the registry.
131
132 Parameters
133 ----------
134 name : `str`
135 Name that the ``target`` is registered under. The target can
136 be accessed later with `dict`-like patterns using ``name`` as
137 the key.
138 target : obj
139 A configurable type, usually a subclass of `lsst.pipe.base.Task`.
140 ConfigClass : `lsst.pex.config.Config`-type, optional
141 A subclass of `lsst.pex.config.Config` used to configure the
142 configurable. If `None` then the configurable's ``ConfigClass``
143 attribute is used.
144
145 Raises
146 ------
147 RuntimeError
148 Raised if an item with ``name`` is already in the registry.
149 AttributeError
150 Raised if ``ConfigClass`` is `None` and ``target`` does not have
151 a ``ConfigClass`` attribute.
152
153 Notes
154 -----
155 If ``ConfigClass`` is provided then the ``target`` configurable is
156 wrapped in a new object that forwards function calls to it. Otherwise
157 the original ``target`` is stored.
158 """
159 if name in self._dict:
160 raise RuntimeError(f"An item with name {name!r} already exists")
161 if ConfigClass is None:
162 wrapper = target
163 else:
164 wrapper = ConfigurableWrapper(target, ConfigClass)
165 if not issubclass(wrapper.ConfigClass, self._configBaseType):
166 raise TypeError(
167 f"ConfigClass={_typeStr(wrapper.ConfigClass)} is not a subclass of "
168 f"{_typeStr(self._configBaseType)!r}"
169 )
170 self._dict[name] = wrapper
171
Member Data Documentation
◆ _configBaseType
|
protected |
Definition at line 126 of file registry.py.
◆ _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-9.0.0/Linux64/pex_config/g89c8672015+f4add4ffd5/python/lsst/pex/config/registry.py
