pex.config.registry.Registry Class Reference

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

Definition at line 52 of file registry.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 116 of file registry.py.

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

Member Function Documentation

__contains__()

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

Definition at line 172 of file registry.py.

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

__getitem__()

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

Definition at line 163 of file registry.py.

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

__iter__()

def pex.config.registry.Registry.__iter__

(

self

)

Definition at line 169 of file registry.py.

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

__len__()

def pex.config.registry.Registry.__len__

(

self

)

Definition at line 166 of file registry.py.

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

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.

Definition at line 175 of file registry.py.

    def 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.
        """
        return RegistryField(doc, self, default, optional, multi)
 
 

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.

Definition at line 122 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("An item with name %r already exists" % name)
        if ConfigClass is None:
            wrapper = target
        else:
            wrapper = ConfigurableWrapper(target, ConfigClass)
        if not issubclass(wrapper.ConfigClass, self._configBaseType):
            raise TypeError("ConfigClass=%s is not a subclass of %r" %
                            (_typeStr(wrapper.ConfigClass), _typeStr(self._configBaseType)))
        self._dict[name] = wrapper
 

---

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

• /j/snowflake/release/lsstsw/stack/cb4e2dc/Linux64/pex_config/20.0.0+34a42eae2c/python/lsst/pex/config/registry.py