lsst.pex.config.configurableField.ConfigurableField Class Reference

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

Public Member Functions
	validateTarget (self, target, ConfigClass)
	__init__ (self, doc, target, ConfigClass=None, default=None, check=None, deprecated=None)
ConfigurableField	__get__ (self, None instance, Any owner=None, Any at=None, str label="default")
ConfigurableInstance[FieldTypeVar]	__get__ (self, Config instance, Any owner=None, Any at=None, str label="default")
	__get__ (self, instance, owner=None, at=None, label="default")
	__set__ (self, instance, value, at=None, label="assignment")
	rename (self, instance)
	save (self, outfile, instance)
	freeze (self, instance)
	toDict (self, instance)
	validate (self, instance)
	__deepcopy__ (self, memo)
	__class_getitem__ (cls, tuple[type,...]|type|ForwardRef params)
	__delete__ (self, instance, at=None, label="deletion")
	apply (self, *args, **kw)
	retarget (self, target, ConfigClass=None, at=None, label="retarget")
	__getattr__ (self, name)
	__setattr__ (self, name, value, at=None, label="assignment")
	__delattr__ (self, name, at=None, label="delete")
	__reduce__ (self)

Public Attributes
	dtype = dtype
	doc = doc
	deprecated = deprecated
	default = default
	check = check
	optional = optional
	source = source

Static Public Attributes
dict	supportedTypes = {str, bool, float, int, complex}

Protected Member Functions
	_collectImports (self, instance, imports)
	_compare (self, instance1, instance2, shortcut, rtol, atol, output)
	_setup (self, doc, dtype, default, check, optional, source, deprecated)
	_validateValue (self, value)
Config	_config (self)

Static Protected Member Functions
Mapping[str, Any]	_parseTypingArgs (tuple[type,...]|tuple[str,...] params, Mapping[str, Any] kwds)

Protected Attributes
	_field = self._field.validateTarget(target, ConfigClass)
	_config
	_value

Properties
	target = property(lambda x: x._target)
	ConfigClass = property(lambda x: x._ConfigClass)
	value = property(lambda x: x._value)

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).
deprecated : None or `str`, optional
    A description of why this Field is deprecated, including removal date.
    If not None, the string is appended to the docstring for this Field.

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 228 of file configurableField.py.

Constructor & Destructor Documentation

__init__()

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

Definition at line 322 of file configurableField.py.

    def __init__(self, doc, target, ConfigClass=None, default=None, check=None, deprecated=None):
        ConfigClass = self.validateTarget(target, ConfigClass)
 
        if default is None:
            default = ConfigClass
        if default != ConfigClass and type(default) is not ConfigClass:
            raise TypeError(
                f"'default' is of incorrect type {_typeStr(default)}. Expected {_typeStr(ConfigClass)}"
            )
 
        source = getStackFrame()
        self._setup(
            doc=doc,
            dtype=ConfigurableInstance,
            default=default,
            check=check,
            optional=False,
            source=source,
            deprecated=deprecated,
        )
        self.target = target
        self.ConfigClass = ConfigClass
 

Member Function Documentation

__class_getitem__()

lsst.pex.config.config.Field.__class_getitem__ ( cls, tuple[type, ...] | type | ForwardRef params )

inherited

Definition at line 464 of file config.py.

    def __class_getitem__(cls, params: tuple[type, ...] | type | ForwardRef):
        return _PexConfigGenericAlias(cls, params)
 

__deepcopy__()

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 441 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),
        )
 

__delattr__()

lsst.pex.config.configurableField.ConfigurableInstance.__delattr__ ( self, name, at = None, label = "delete" )

inherited

Pretend to be an isntance of  ConfigClass.
Attributes defiend by ConfigurableInstance will shadow those defined
in ConfigClass.

Definition at line 202 of file configurableField.py.

    def __delattr__(self, name, at=None, label="delete"):
        """
        Pretend to be an isntance of  ConfigClass.
        Attributes defiend by ConfigurableInstance will shadow those defined
        in ConfigClass.
        """
        if self._config._frozen:
            raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
 
        try:
            # attribute exists in the ConfigurableInstance wrapper
            object.__delattr__(self, name)
        except AttributeError:
            if at is None:
                at = getCallStack()
            self._value.__delattr__(name, at=at, label=label)
 

__delete__()

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 800 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__() [1/3]

ConfigurableInstance[FieldTypeVar] lsst.pex.config.configurableField.ConfigurableField.__get__	(		self,
		Config	instance,
		Any	owner = None,
		Any	at = None,
		str	label = "default" )

Definition at line 366 of file configurableField.py.

    ) -> ConfigurableInstance[FieldTypeVar]: ...
 

__get__() [2/3]

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

Definition at line 370 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)
 

__get__() [3/3]

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

Definition at line 361 of file configurableField.py.

    ) -> ConfigurableField: ...
 

__getattr__()

lsst.pex.config.configurableField.ConfigurableInstance.__getattr__ ( self, name )

inherited

Definition at line 182 of file configurableField.py.

    def __getattr__(self, name):
        return getattr(self._value, name)
 

__reduce__()

lsst.pex.config.configurableField.ConfigurableInstance.__reduce__ ( self )

inherited

Definition at line 219 of file configurableField.py.

    def __reduce__(self):
        raise UnexpectedProxyUsageError(
            f"Proxy object for config field {self._field.name} cannot "
            "be pickled; it should be converted to a normal `Config` instance "
            "via the `value` property before being assigned to other objects "
            "or variables."
        )
 
 

__set__()

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

Definition at line 376 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) is 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 = (
                f"Value {value} is of incorrect type {_typeStr(value)}. "
                f"Expected {_typeStr(oldValue.ConfigClass)}"
            )
            raise FieldValidationError(self, instance, msg)
 

__setattr__()

lsst.pex.config.configurableField.ConfigurableInstance.__setattr__ ( self, name, value, at = None, label = "assignment" )

inherited

Pretend to be an instance of ConfigClass.

Attributes defined by ConfigurableInstance will shadow those defined
in ConfigClass

Definition at line 185 of file configurableField.py.

    def __setattr__(self, name, value, at=None, label="assignment"):
        """Pretend to be an instance of ConfigClass.
 
        Attributes defined by ConfigurableInstance will shadow those defined
        in ConfigClass
        """
        if self._config._frozen:
            raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
 
        if name in self.__dict__:
            # attribute exists in the ConfigurableInstance wrapper
            object.__setattr__(self, name, value)
        else:
            if at is None:
                at = getCallStack()
            self._value.__setattr__(name, value, at=at, label=label)
 

_collectImports()

lsst.pex.config.configurableField.ConfigurableField._collectImports ( self, instance, imports )

protected

Call the _collectImports method on all config
objects the field may own, and union them with the supplied imports
set.

Parameters
----------
instance : instance or subclass of `lsst.pex.config.Config`
    A config object that has this field defined on it
imports : `set`
    Set of python modules that need imported after persistence

Reimplemented from lsst.pex.config.config.Field.

Definition at line 403 of file configurableField.py.

    def _collectImports(self, instance, imports):
        value = self.__get__(instance)
        target = value.target
        imports.add(target.__module__)
        value.value._collectImports()
        imports |= value.value._imports
 

_compare()

lsst.pex.config.configurableField.ConfigurableField._compare ( self, instance1, instance2, shortcut, rtol, atol, output )

protected

Compare two fields for equality.

Used by `lsst.pex.ConfigDictField.compare`.

Parameters
----------
instance1 : `lsst.pex.config.Config`
    Left-hand side config instance to compare.
instance2 : `lsst.pex.config.Config`
    Right-hand side config instance to compare.
shortcut : `bool`
    If `True`, this function returns as soon as an inequality if found.
rtol : `float`
    Relative tolerance for floating point comparisons.
atol : `float`
    Absolute tolerance for floating point comparisons.
output : callable
    A callable that takes a string, used (possibly repeatedly) to
    report inequalities. For example: `print`.

Returns
-------
isEqual : bool
    `True` if the fields are equal, `False` otherwise.

Notes
-----
Floating point comparisons are performed by `numpy.allclose`.

Reimplemented from lsst.pex.config.config.Field.

Definition at line 455 of file configurableField.py.

    def _compare(self, instance1, instance2, shortcut, rtol, atol, output):
        """Compare two fields for equality.
 
        Used by `lsst.pex.ConfigDictField.compare`.
 
        Parameters
        ----------
        instance1 : `lsst.pex.config.Config`
            Left-hand side config instance to compare.
        instance2 : `lsst.pex.config.Config`
            Right-hand side config instance to compare.
        shortcut : `bool`
            If `True`, this function returns as soon as an inequality if found.
        rtol : `float`
            Relative tolerance for floating point comparisons.
        atol : `float`
            Absolute tolerance for floating point comparisons.
        output : callable
            A callable that takes a string, used (possibly repeatedly) to
            report inequalities. For example: `print`.
 
        Returns
        -------
        isEqual : bool
            `True` if the fields are equal, `False` otherwise.
 
        Notes
        -----
        Floating point comparisons are performed by `numpy.allclose`.
        """
        c1 = getattr(instance1, self.name)._value
        c2 = getattr(instance2, self.name)._value
        name = getComparisonName(
            _joinNamePath(instance1._name, self.name), _joinNamePath(instance2._name, self.name)
        )
        return compareConfigs(name, c1, c2, shortcut=shortcut, rtol=rtol, atol=atol, output=output)

_config()

Config lsst.pex.config.configurableField.ConfigurableInstance._config ( self )

protectedinherited

Definition at line 111 of file configurableField.py.

    def _config(self) -> Config:
        # Config Fields should never outlive their config class instance
        # assert that as such here
        assert self._config_() is not None
        return self._config_()
 

_parseTypingArgs()

Mapping[str, Any] lsst.pex.config.configurableField.ConfigurableField._parseTypingArgs ( tuple[type, ...] | tuple[str, ...] params, Mapping[str, Any] kwds )

staticprotected

Parse type annotations into keyword constructor arguments.

This is a special private method that interprets type arguments (i.e.
Field[str]) into keyword arguments to be passed on to the constructor.

Subclasses of Field can implement this method to customize how they
handle turning type parameters into keyword arguments (see DictField
for an example)

Parameters
----------
params : `tuple` of `type` or `tuple` of str
    Parameters passed to the type annotation. These will either be
    types or strings. Strings are to interpreted as forward references
    and will be treated as such.
kwds : `MutableMapping` with keys of `str` and values of `Any`
    These are the user supplied keywords that are to be passed to the
    Field constructor.

Returns
-------
kwds : `MutableMapping` with keys of `str` and values of `Any`
    The mapping of keywords that will be passed onto the constructor
    of the Field. Should be filled in with any information gleaned
    from the input parameters.

Raises
------
ValueError
    Raised if params is of incorrect length.
    Raised if a forward reference could not be resolved
    Raised if there is a conflict between params and values in kwds

Reimplemented from lsst.pex.config.config.Field.

Definition at line 346 of file configurableField.py.

    ) -> Mapping[str, Any]:
        return kwds
 

_setup()

lsst.pex.config.config.Field._setup ( self, doc, dtype, default, check, optional, source, deprecated )

protectedinherited

Set attributes, usually during initialization.

Definition at line 486 of file config.py.

    def _setup(self, doc, dtype, default, check, optional, source, deprecated):
        """Set attributes, usually during initialization."""
        self.dtype = dtype
        """Data type for the field.
        """
 
        if not doc:
            raise ValueError("Docstring is empty.")
 
        # append the deprecation message to the docstring.
        if deprecated is not None:
            doc = f"{doc} Deprecated: {deprecated}"
        self.doc = doc
        """A description of the field (`str`).
        """
 
        self.deprecated = deprecated
        """If not None, a description of why this field is deprecated (`str`).
        """
 
        self.__doc__ = f"{doc} (`{dtype.__name__}`"
        if optional or default is not None:
            self.__doc__ += f", default ``{default!r}``"
        self.__doc__ += ")"
 
        self.default = default
        """Default value for this field.
        """
 
        self.check = check
        """A user-defined function that validates the value of the field.
        """
 
        self.optional = optional
        """Flag that determines if the field is required to be set (`bool`).
 
        When `False`, `lsst.pex.config.Config.validate` will fail if the
        field's value is `None`.
        """
 
        self.source = source
        """The stack frame where this field is defined (`list` of
        `~lsst.pex.config.callStack.StackFrame`).
        """
 

_validateValue()

lsst.pex.config.config.Field._validateValue ( self, value )

protectedinherited

Validate a value.

Parameters
----------
value : object
    The value being validated.

Raises
------
TypeError
    Raised if the value's type is incompatible with the field's
    ``dtype``.
ValueError
    Raised if the value is rejected by the ``check`` method.

Reimplemented in lsst.pex.config.choiceField.ChoiceField, and lsst.pex.config.rangeField.RangeField.

Definition at line 598 of file config.py.

    def _validateValue(self, value):
        """Validate a value.
 
        Parameters
        ----------
        value : object
            The value being validated.
 
        Raises
        ------
        TypeError
            Raised if the value's type is incompatible with the field's
            ``dtype``.
        ValueError
            Raised if the value is rejected by the ``check`` method.
        """
        if value is None:
            return
 
        if not isinstance(value, self.dtype):
            msg = (
                f"Value {value} is of incorrect type {_typeStr(value)}. Expected type {_typeStr(self.dtype)}"
            )
            raise TypeError(msg)
        if self.check is not None and not self.check(value):
            msg = f"Value {value} is not a valid value"
            raise ValueError(msg)
 

apply()

lsst.pex.config.configurableField.ConfigurableInstance.apply ( self, * args, ** kw )

inherited

Call the configurable.

Parameters
----------
*args : `~typing.Any`
    Arguments to use when calling the configurable.
**kw : `~typing.Any`
    Keyword parameters to use when calling.

Notes
-----
In addition to the user-provided positional and keyword arguments,
the configurable is also provided a keyword argument ``config`` with
the value of `ConfigurableInstance.value`.

Definition at line 130 of file configurableField.py.

    def apply(self, *args, **kw):
        """Call the configurable.
 
        Parameters
        ----------
        *args : `~typing.Any`
            Arguments to use when calling the configurable.
        **kw : `~typing.Any`
            Keyword parameters to use when calling.
 
        Notes
        -----
        In addition to the user-provided positional and keyword arguments,
        the configurable is also provided a keyword argument ``config`` with
        the value of `ConfigurableInstance.value`.
        """
        return self.target(*args, config=self.value, **kw)
 

freeze()

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

Make this field read-only (for internal use only).

Parameters
----------
instance : `lsst.pex.config.Config`
    The config instance that contains this field.

Notes
-----
Freezing is only relevant for fields that hold subconfigs. Fields which
hold subconfigs should freeze each subconfig.

**Subclasses should implement this method.**

Reimplemented from lsst.pex.config.config.Field.

Definition at line 425 of file configurableField.py.

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

rename()

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

Rename the field in a `~lsst.pex.config.Config` (for internal use
only).

Parameters
----------
instance : `lsst.pex.config.Config`
    The config instance that contains this field.

Notes
-----
This method is invoked by the `lsst.pex.config.Config` object that
contains this field and should not be called directly.

Renaming is only relevant for `~lsst.pex.config.Field` instances that
hold subconfigs. `~lsst.pex.config.Field`\s that hold subconfigs should
rename each subconfig with the full field name as generated by
`lsst.pex.config.config._joinNamePath`.

Reimplemented from lsst.pex.config.config.Field.

Definition at line 398 of file configurableField.py.

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

retarget()

lsst.pex.config.configurableField.ConfigurableInstance.retarget ( self, target, ConfigClass = None, at = None, label = "retarget" )

inherited

Target a new configurable and ConfigClass.

Parameters
----------
target : `type`
    Item to retarget.
ConfigClass : `type` or `None`, optional
    New config class to use.
at : `list` of `~lsst.pex.config.callStack.StackFrame` or `None`,\
        optional
    Stack for history recording.
label : `str`, optional
    Label for history recording.

Definition at line 148 of file configurableField.py.

    def retarget(self, target, ConfigClass=None, at=None, label="retarget"):
        """Target a new configurable and ConfigClass.
 
        Parameters
        ----------
        target : `type`
            Item to retarget.
        ConfigClass : `type` or `None`, optional
            New config class to use.
        at : `list` of `~lsst.pex.config.callStack.StackFrame` or `None`,\
                optional
            Stack for history recording.
        label : `str`, optional
            Label for history recording.
        """
        if self._config._frozen:
            raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
 
        try:
            ConfigClass = self._field.validateTarget(target, ConfigClass)
        except BaseException as e:
            raise FieldValidationError(self._field, self._config, e.message) from e
 
        if at is None:
            at = getCallStack()
        object.__setattr__(self, "_target", target)
        if ConfigClass != self.ConfigClass:
            object.__setattr__(self, "_ConfigClass", ConfigClass)
            self.__initValue(at, label)
 
        history = self._config._history.setdefault(self._field.name, [])
        msg = f"retarget(target={_typeStr(target)}, ConfigClass={_typeStr(ConfigClass)})"
        history.append((msg, at, label))
 

save()

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

Save this field to a file (for internal use only).

Parameters
----------
outfile : file-like object
    A writeable field handle.
instance : `~lsst.pex.config.Config`
    The `~lsst.pex.config.Config` instance that contains this field.

Notes
-----
This method is invoked by the `~lsst.pex.config.Config` object that
contains this field and should not be called directly.

The output consists of the documentation string
(`lsst.pex.config.Field.doc`) formatted as a Python comment. The second
line is formatted as an assignment: ``{fullname}={value}``.

This output can be executed with Python.

Reimplemented from lsst.pex.config.config.Field.

Definition at line 410 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
            outfile.write(
                f"{fullname}.retarget(target={_typeStr(target)}, ConfigClass={_typeStr(ConfigClass)})\n\n"
            )
        # save field values
        value._save(outfile)
 

toDict()

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

Convert the field value so that it can be set as the value of an
item in a `dict` (for internal use only).

Parameters
----------
instance : `~lsst.pex.config.Config`
    The `~lsst.pex.config.Config` that contains this field.

Returns
-------
value : object
    The field's value. See *Notes*.

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

Simple values are passed through. Complex data structures must be
manipulated. For example, a `~lsst.pex.config.Field` holding a
subconfig should, instead of the subconfig object, return a `dict`
where the keys are the field names in the subconfig, and the values are
the field values in the subconfig.

Reimplemented from lsst.pex.config.config.Field.

Definition at line 429 of file configurableField.py.

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

validate()

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

Validate the field (for internal use only).

Parameters
----------
instance : `lsst.pex.config.Config`
    The config instance that contains this field.

Raises
------
lsst.pex.config.FieldValidationError
    Raised if verification fails.

Notes
-----
This method provides basic validation:

- Ensures that the value is not `None` if the field is not optional.
- Ensures type correctness.
- Ensures that the user-provided ``check`` function is valid.

Most `~lsst.pex.config.Field` subclasses should call
`lsst.pex.config.Field.validate` if they re-implement
`~lsst.pex.config.Field.validate`.

Reimplemented from lsst.pex.config.config.Field.

Definition at line 433 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 = f"{value} is not a valid value"
            raise FieldValidationError(self, instance, msg)
 

validateTarget()

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

Validate the target and configuration class.

Parameters
----------
target : configurable class
    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 277 of file configurableField.py.

    def validateTarget(self, target, ConfigClass):
        """Validate the target and configuration class.
 
        Parameters
        ----------
        target : configurable class
            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 as e:
                raise AttributeError("'target' must define attribute 'ConfigClass'") from e
        if not issubclass(ConfigClass, Config):
            raise TypeError(
                f"'ConfigClass' is of incorrect type {_typeStr(ConfigClass)}. "
                "'ConfigClass' must be a subclass of Config"
            )
        if not callable(target):
            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

_config

lsst.pex.config.configurableField.ConfigurableInstance._config

protectedinherited

Definition at line 164 of file configurableField.py.

_field

lsst.pex.config.configurableField.ConfigurableInstance._field = self._field.validateTarget(target, ConfigClass)

protectedinherited

Definition at line 164 of file configurableField.py.

_value

lsst.pex.config.configurableField.ConfigurableInstance._value

protectedinherited

Definition at line 183 of file configurableField.py.

check

lsst.pex.config.config.Field.check = check

inherited

Definition at line 515 of file config.py.

default

lsst.pex.config.config.Field.default = default

inherited

Definition at line 511 of file config.py.

deprecated

lsst.pex.config.config.Field.deprecated = deprecated

inherited

Definition at line 502 of file config.py.

doc

lsst.pex.config.config.Field.doc = doc

inherited

Definition at line 498 of file config.py.

dtype

lsst.pex.config.config.Field.dtype = dtype

inherited

Definition at line 488 of file config.py.

optional

lsst.pex.config.config.Field.optional = optional

inherited

Definition at line 519 of file config.py.

source

lsst.pex.config.config.Field.source = source

inherited

Definition at line 526 of file config.py.

supportedTypes

dict lsst.pex.config.config.Field.supportedTypes = {str, bool, float, int, complex}

staticinherited

Definition at line 405 of file config.py.

Property Documentation

ConfigClass

lsst.pex.config.configurableField.ConfigurableInstance.ConfigClass = property(lambda x: x._ConfigClass)

staticinherited

Definition at line 121 of file configurableField.py.

target

lsst.pex.config.configurableField.ConfigurableInstance.target = property(lambda x: x._target)

staticinherited

Definition at line 117 of file configurableField.py.

value

lsst.pex.config.configurableField.ConfigurableInstance.value = property(lambda x: x._value)

staticinherited

Definition at line 125 of file configurableField.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-10.0.0/Linux64/pex_config/gabf8522325+fa80ff7197/python/lsst/pex/config/configurableField.py