lsst.pex.config.configurableField.ConfigurableField Class Reference

Inheritance diagram for lsst.pex.config.configurableField.ConfigurableField:

Public Member Functions
def	validateTarget (self, target, ConfigClass)
def	__init__ (self, doc, target, ConfigClass=None, default=None, check=None)
def	__get__ (self, instance, owner=None, at=None, label="default")
def	__set__ (self, instance, value, at=None, label="assignment")
def	rename (self, instance)
def	save (self, outfile, instance)
def	freeze (self, instance)
def	toDict (self, instance)
def	validate (self, instance)
def	__deepcopy__ (self, memo)
def	__delete__ (self, instance, at=None, label='deletion')

Public Attributes
	target
	ConfigClass
	dtype
	doc
	default
	check
	optional
	source

Static Public Attributes
	supportedTypes = set((str, bool, float, int, complex))

Detailed Description

A configuration field (`~lsst.pex.config.Field` subclass) that can be
can be retargeted towards a different configurable (often a
`lsst.pipe.base.Task` subclass).

The ``ConfigurableField`` is often used to configure subtasks, which are
tasks (`~lsst.pipe.base.Task`) called by a parent task.

Parameters
----------
doc : `str`
    A description of the configuration field.
target : configurable class
    The configurable target. Configurables have a ``ConfigClass``
    attribute. Within the task framework, configurables are
    `lsst.pipe.base.Task` subclasses)
ConfigClass : `lsst.pex.config.Config`-type, optional
    The subclass of `lsst.pex.config.Config` expected as the configuration
    class of the ``target``. If ``ConfigClass`` is unset then
    ``target.ConfigClass`` is used.
default : ``ConfigClass``-type, optional
    The default configuration class. Normally this parameter is not set,
    and defaults to ``ConfigClass`` (or ``target.ConfigClass``).
check : callable, optional
    Callable that takes the field's value (the ``target``) as its only
    positional argument, and returns `True` if the ``target`` is valid (and
    `False` otherwise).

See also
--------
ChoiceField
ConfigChoiceField
ConfigDictField
ConfigField
DictField
Field
ListField
RangeField
RegistryField

Notes
-----
You can use the `ConfigurableInstance.apply` method to construct a
fully-configured configurable.

Definition at line 162 of file configurableField.py.

Constructor & Destructor Documentation

__init__()

def lsst.pex.config.configurableField.ConfigurableField.__init__	(		self,
			doc,
			target,
			ConfigClass = None,
			default = None,
			check = None
	)

Definition at line 250 of file configurableField.py.

    def __init__(self, doc, target, ConfigClass=None, default=None, check=None):
        ConfigClass = self.validateTarget(target, ConfigClass)

        if default is None:
            default = ConfigClass
        if default != ConfigClass and type(default) != ConfigClass:
            raise TypeError("'default' is of incorrect type %s. Expected %s" %
                            (_typeStr(default), _typeStr(ConfigClass)))

        source = getStackFrame()
        self._setup(doc=doc, dtype=ConfigurableInstance, default=default,
                    check=check, optional=False, source=source)
        self.target = target
        self.ConfigClass = ConfigClass

Member Function Documentation

__deepcopy__()

def lsst.pex.config.configurableField.ConfigurableField.__deepcopy__	(		self,
			memo
	)

Customize deep-copying, because we always want a reference to the
original typemap.

WARNING: this must be overridden by subclasses if they change the
constructor signature!

Definition at line 338 of file configurableField.py.

    def __deepcopy__(self, memo):
        """Customize deep-copying, because we always want a reference to the
        original typemap.

        WARNING: this must be overridden by subclasses if they change the
        constructor signature!
        """
        return type(self)(doc=self.doc, target=self.target, ConfigClass=self.ConfigClass,
                          default=copy.deepcopy(self.default))

__delete__()

def lsst.pex.config.config.Field.__delete__ (   self,   instance,   at = None,   label = 'deletion'  )

inherited

Delete an attribute from a `lsst.pex.config.Config` instance.

Parameters
----------
instance : `lsst.pex.config.Config`
    The config instance that contains this field.
at : `list` of `lsst.pex.config.callStack.StackFrame`
    The call stack (created by
    `lsst.pex.config.callStack.getCallStack`).
label : `str`, optional
    Event label for the history.

Notes
-----
This is invoked by the owning `~lsst.pex.config.Config` object and
should not be called directly.

Definition at line 528 of file config.py.

    def __delete__(self, instance, at=None, label='deletion'):
        """Delete an attribute from a `lsst.pex.config.Config` instance.

        Parameters
        ----------
        instance : `lsst.pex.config.Config`
            The config instance that contains this field.
        at : `list` of `lsst.pex.config.callStack.StackFrame`
            The call stack (created by
            `lsst.pex.config.callStack.getCallStack`).
        label : `str`, optional
            Event label for the history.

        Notes
        -----
        This is invoked by the owning `~lsst.pex.config.Config` object and
        should not be called directly.
        """
        if at is None:
            at = getCallStack()
        self.__set__(instance, None, at=at, label=label)

__get__()

def lsst.pex.config.configurableField.ConfigurableField.__get__	(		self,
			instance,
			owner = None,
			at = None,
			label = "default"
	)

Definition at line 274 of file configurableField.py.

    def __get__(self, instance, owner=None, at=None, label="default"):
        if instance is None or not isinstance(instance, Config):
            return self
        else:
            return self.__getOrMake(instance, at=at, label=label)

__set__()

def lsst.pex.config.configurableField.ConfigurableField.__set__	(		self,
			instance,
			value,
			at = None,
			label = "assignment"
	)

Definition at line 280 of file configurableField.py.

    def __set__(self, instance, value, at=None, label="assignment"):
        if instance._frozen:
            raise FieldValidationError(self, instance, "Cannot modify a frozen Config")
        if at is None:
            at = getCallStack()
        oldValue = self.__getOrMake(instance, at=at)

        if isinstance(value, ConfigurableInstance):
            oldValue.retarget(value.target, value.ConfigClass, at, label)
            oldValue.update(__at=at, __label=label, **value._storage)
        elif type(value) == oldValue._ConfigClass:
            oldValue.update(__at=at, __label=label, **value._storage)
        elif value == oldValue.ConfigClass:
            value = oldValue.ConfigClass()
            oldValue.update(__at=at, __label=label, **value._storage)
        else:
            msg = "Value %s is of incorrect type %s. Expected %s" % \
                (value, _typeStr(value), _typeStr(oldValue.ConfigClass))
            raise FieldValidationError(self, instance, msg)

freeze()

def lsst.pex.config.configurableField.ConfigurableField.freeze	(		self,
			instance
	)

Definition at line 322 of file configurableField.py.

    def freeze(self, instance):
        value = self.__getOrMake(instance)
        value.freeze()

rename()

def lsst.pex.config.configurableField.ConfigurableField.rename	(		self,
			instance
	)

Definition at line 300 of file configurableField.py.

    def rename(self, instance):
        fullname = _joinNamePath(instance._name, self.name)
        value = self.__getOrMake(instance)
        value._rename(fullname)

save()

def lsst.pex.config.configurableField.ConfigurableField.save	(		self,
			outfile,
			instance
	)

Definition at line 305 of file configurableField.py.

    def save(self, outfile, instance):
        fullname = _joinNamePath(instance._name, self.name)
        value = self.__getOrMake(instance)
        target = value.target

        if target != self.target:
            # not targeting the field-default target.
            # save target information
            ConfigClass = value.ConfigClass
            for module in set([target.__module__, ConfigClass.__module__]):
                outfile.write(u"import {}\n".format(module))
            outfile.write(u"{}.retarget(target={}, ConfigClass={})\n\n".format(fullname,
                                                                               _typeStr(target),
                                                                               _typeStr(ConfigClass)))
        # save field values
        value._save(outfile)

toDict()

def lsst.pex.config.configurableField.ConfigurableField.toDict	(		self,
			instance
	)

Definition at line 326 of file configurableField.py.

    def toDict(self, instance):
        value = self.__get__(instance)
        return value.toDict()

validate()

def lsst.pex.config.configurableField.ConfigurableField.validate	(		self,
			instance
	)

Definition at line 330 of file configurableField.py.

    def validate(self, instance):
        value = self.__get__(instance)
        value.validate()

        if self.check is not None and not self.check(value):
            msg = "%s is not a valid value" % str(value)
            raise FieldValidationError(self, instance, msg)

validateTarget()

def lsst.pex.config.configurableField.ConfigurableField.validateTarget	(		self,
			target,
			ConfigClass
	)

Validate the target and configuration class.

Parameters
----------
target
    The configurable being verified.
ConfigClass : `lsst.pex.config.Config`-type or `None`
    The configuration class associated with the ``target``. This can
    be `None` if ``target`` has a ``ConfigClass`` attribute.

Raises
------
AttributeError
    Raised if ``ConfigClass`` is `None` and ``target`` does not have a
    ``ConfigClass`` attribute.
TypeError
    Raised if ``ConfigClass`` is not a `~lsst.pex.config.Config`
    subclass.
ValueError
    Raised if:

    - ``target`` is not callable (callables have a ``__call__``
      method).
    - ``target`` is not startically defined (does not have
      ``__module__`` or ``__name__`` attributes).

Definition at line 208 of file configurableField.py.

    def validateTarget(self, target, ConfigClass):
        """Validate the target and configuration class.

        Parameters
        ----------
        target
            The configurable being verified.
        ConfigClass : `lsst.pex.config.Config`-type or `None`
            The configuration class associated with the ``target``. This can
            be `None` if ``target`` has a ``ConfigClass`` attribute.

        Raises
        ------
        AttributeError
            Raised if ``ConfigClass`` is `None` and ``target`` does not have a
            ``ConfigClass`` attribute.
        TypeError
            Raised if ``ConfigClass`` is not a `~lsst.pex.config.Config`
            subclass.
        ValueError
            Raised if:

            - ``target`` is not callable (callables have a ``__call__``
              method).
            - ``target`` is not startically defined (does not have
              ``__module__`` or ``__name__`` attributes).
        """
        if ConfigClass is None:
            try:
                ConfigClass = target.ConfigClass
            except Exception:
                raise AttributeError("'target' must define attribute 'ConfigClass'")
        if not issubclass(ConfigClass, Config):
            raise TypeError("'ConfigClass' is of incorrect type %s."
                            "'ConfigClass' must be a subclass of Config" % _typeStr(ConfigClass))
        if not hasattr(target, '__call__'):
            raise ValueError("'target' must be callable")
        if not hasattr(target, '__module__') or not hasattr(target, '__name__'):
            raise ValueError("'target' must be statically defined"
                             "(must have '__module__' and '__name__' attributes)")
        return ConfigClass

Member Data Documentation

check

lsst.pex.config.config.Field.check

inherited

Definition at line 284 of file config.py.

ConfigClass

lsst.pex.config.configurableField.ConfigurableField.ConfigClass

Definition at line 263 of file configurableField.py.

default

lsst.pex.config.config.Field.default

inherited

Definition at line 280 of file config.py.

doc

lsst.pex.config.config.Field.doc

inherited

Definition at line 271 of file config.py.

dtype

lsst.pex.config.config.Field.dtype

inherited

Definition at line 267 of file config.py.

optional

lsst.pex.config.config.Field.optional

inherited

Definition at line 288 of file config.py.

source

lsst.pex.config.config.Field.source

inherited

Definition at line 295 of file config.py.

supportedTypes

lsst.pex.config.config.Field.supportedTypes = set((str, bool, float, int, complex))

staticinherited

Definition at line 253 of file config.py.

target

lsst.pex.config.configurableField.ConfigurableField.target

Definition at line 262 of file configurableField.py.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/pex_config/16.0-13-g118c103+3/python/lsst/pex/config/configurableField.py