Inheritance diagram for 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 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 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:
- python/lsst/pex/config/registry.py
