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
Classes | Public Member Functions | List of all members
lsst.meas.base.pluginRegistry.PluginRegistry Class Reference
Inheritance diagram for lsst.meas.base.pluginRegistry.PluginRegistry:
lsst.pex.config.registry.Registry

Classes

class  Configurable
 

Public Member Functions

def register (self, name, PluginClass, shouldApCorr=False, apCorrList=())
 
def makeField (self, doc, default=None, optional=False, multi=False)
 
def register (self, name, target, ConfigClass=None)
 
def __getitem__ (self, key)
 
def __len__ (self)
 
def __iter__ (self)
 
def __contains__ (self, key)
 

Detailed Description

Base class for plugin registries.

Notes
-----
The class of plugins allowed in the registry is defined in the constructor
of the registry.

Single-frame and forced plugins have different registries.

Definition at line 76 of file pluginRegistry.py.

Member Function Documentation

◆ __contains__()

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

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 
)
inherited

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)
inherited

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)
inherited

Definition at line 166 of file registry.py.

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

◆ makeField()

def lsst.meas.base.pluginRegistry.PluginRegistry.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 from lsst.pex.config.registry.Registry.

Definition at line 159 of file pluginRegistry.py.

159  def makeField(self, doc, default=None, optional=False, multi=False):
160  return lsst.pex.config.RegistryField(doc, self, default, optional, multi)
161 
162 

◆ register() [1/2]

def lsst.meas.base.pluginRegistry.PluginRegistry.register (   self,
  name,
  PluginClass,
  shouldApCorr = False,
  apCorrList = () 
)
Register a plugin class with the given name.

Parameters
----------
name : `str`
    The name of the plugin. This is used as a prefix for all fields
    produced by the plugin, and it should generally contain the name
    of the plugin or algorithm class itself as well as enough of the
    namespace to make it clear where to find the code.  For example
    ``base_GaussianFlux`` indicates an algorithm in `lsst.meas.base`
    that measures Gaussian Flux and produces fields such as
    ``base_GaussianFlux_instFlux``, ``base_GaussianFlux_instFluxErr``
    and ``base_GaussianFlux_flag``.
shouldApCorr : `bool`
    If `True`, then this algorithm measures an instFlux that should
    be aperture corrected. This is shorthand for ``apCorrList=[name]``
    and is ignored if ``apCorrList`` is specified.
apCorrList : `list` of `str`
    List of field name prefixes for instFlux fields to be aperture
    corrected.  If an algorithm produces a single instFlux that should
    be aperture corrected then it is simpler to set
    ``shouldApCorr=True``. But if an algorithm produces multiple such
    fields then it must specify ``apCorrList`` instead. For example,
    ``modelfit_CModel`` produces three such fields:
    ``apCorrList=("modelfit_CModel_exp", "modelfit_CModel_exp",
    "modelfit_CModel_def")``. If ``apCorrList`` is not empty then
    shouldApCorr is ignored.

Notes
-----
The same plugin may be registered multiple times with different names;
this can be useful if we often want to run it multiple times with
different configuration.

Definition at line 118 of file pluginRegistry.py.

118  def register(self, name, PluginClass, shouldApCorr=False, apCorrList=()):
119  """Register a plugin class with the given name.
120 
121  Parameters
122  ----------
123  name : `str`
124  The name of the plugin. This is used as a prefix for all fields
125  produced by the plugin, and it should generally contain the name
126  of the plugin or algorithm class itself as well as enough of the
127  namespace to make it clear where to find the code. For example
128  ``base_GaussianFlux`` indicates an algorithm in `lsst.meas.base`
129  that measures Gaussian Flux and produces fields such as
130  ``base_GaussianFlux_instFlux``, ``base_GaussianFlux_instFluxErr``
131  and ``base_GaussianFlux_flag``.
132  shouldApCorr : `bool`
133  If `True`, then this algorithm measures an instFlux that should
134  be aperture corrected. This is shorthand for ``apCorrList=[name]``
135  and is ignored if ``apCorrList`` is specified.
136  apCorrList : `list` of `str`
137  List of field name prefixes for instFlux fields to be aperture
138  corrected. If an algorithm produces a single instFlux that should
139  be aperture corrected then it is simpler to set
140  ``shouldApCorr=True``. But if an algorithm produces multiple such
141  fields then it must specify ``apCorrList`` instead. For example,
142  ``modelfit_CModel`` produces three such fields:
143  ``apCorrList=("modelfit_CModel_exp", "modelfit_CModel_exp",
144  "modelfit_CModel_def")``. If ``apCorrList`` is not empty then
145  shouldApCorr is ignored.
146 
147  Notes
148  -----
149  The same plugin may be registered multiple times with different names;
150  this can be useful if we often want to run it multiple times with
151  different configuration.
152  """
153  lsst.pex.config.Registry.register(self, name, self.Configurable(name, PluginClass))
154  if shouldApCorr and not apCorrList:
155  apCorrList = [name]
156  for prefix in apCorrList:
157  addApCorrName(prefix)
158 
def register(name, shouldApCorr=False, apCorrList=())

◆ register() [2/2]

def lsst.pex.config.registry.Registry.register (   self,
  name,
  target,
  ConfigClass = None 
)
inherited
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: