lsst.pex.config.dictField.DictField Class Reference

Inheritance diagram for lsst.pex.config.dictField.DictField:

Public Member Functions
	__init__ (self, doc, keytype=None, itemtype=None, default=None, optional=False, dictCheck=None, keyCheck=None, itemCheck=None, deprecated=None)
	validate (self, instance)
None	__set__ (self, Config instance, Mapping[KeyTypeVar, ItemTypeVar]|None value, Any at=None, str label="assignment")
	toDict (self, instance)
	__class_getitem__ (cls, tuple[type,...]|type|ForwardRef params)
	rename (self, instance)
	freeze (self, instance)
	save (self, outfile, instance)
Field[FieldTypeVar]	__get__ (self, None instance, Any owner=None, Any at=None, str label="default")
FieldTypeVar	__get__ (self, Config instance, Any owner=None, Any at=None, str label="default")
	__get__ (self, instance, owner=None, at=None, label="default")
	__delete__ (self, instance, at=None, label="deletion")
ItemTypeVar	__getitem__ (self, KeyTypeVar k)
int	__len__ (self)
Iterator[KeyTypeVar]	__iter__ (self)
bool	__contains__ (self, Any k)
None	__setitem__ (self, KeyTypeVar k, ItemTypeVar x, Any at=None, str label="setitem", bool setHistory=True)
None	__delitem__ (self, KeyTypeVar k, Any at=None, str label="delitem", bool setHistory=True)
	__repr__ (self)
	__str__ (self)
	__setattr__ (self, attr, value, at=None, label="assignment")
	__reduce__ (self)

Public Attributes
	keytype = keytype
	itemtype = itemtype
	dictCheck = dictCheck
	keyCheck = keyCheck
	itemCheck = itemCheck
	dtype = dtype
	doc = doc
	deprecated = deprecated
	default = default
	check = check
	optional = optional
	source = source

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

Protected Member Functions
Dict[KeyTypeVar, ItemTypeVar]|None	_copy_storage (self, Config old, Config new)
	_compare (self, instance1, instance2, shortcut, rtol, atol, output)
	_setup (self, doc, dtype, default, check, optional, source, deprecated)
	_validateValue (self, value)
	_collectImports (self, instance, imports)
Config	_config (self)
Dict	_copy (self, Config config)

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

Protected Attributes
	_field = field
	_config_ = weakref.ref(config)
dict	_dict = {}
Config	_history = self._config._history.setdefault(self._field.name, [])
	_config

Properties
	history = property(lambda x: x._history)

Detailed Description

A configuration field (`~lsst.pex.config.Field` subclass) that maps keys
and values.

The types of both items and keys are restricted to these builtin types:
`int`, `float`, `complex`, `bool`, and `str`). All keys share the same type
and all values share the same type. Keys can have a different type from
values.

Parameters
----------
doc : `str`
    A documentation string that describes the configuration field.
keytype : {`int`, `float`, `complex`, `bool`, `str`}, optional
    The type of the mapping keys. All keys must have this type. Optional
    if keytype and itemtype are supplied as typing arguments to the class.
itemtype : {`int`, `float`, `complex`, `bool`, `str`}, optional
    Type of the mapping values. Optional if keytype and itemtype are
    supplied as typing arguments to the class.
default : `dict`, optional
    The default mapping.
optional : `bool`, optional
    If `True`, the field doesn't need to have a set value.
dictCheck : callable
    A function that validates the dictionary as a whole.
keyCheck : callable
    A function that validates individual mapping keys.
itemCheck : callable
    A function that validates individual mapping values.
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
ConfigurableField
Field
ListField
RangeField
RegistryField

Examples
--------
This field maps has `str` keys and `int` values:

>>> from lsst.pex.config import Config, DictField
>>> class MyConfig(Config):
...     field = DictField(
...         doc="Example string-to-int mapping field.",
...         keytype=str,
...         itemtype=int,
...         default={},
...     )
>>> config = MyConfig()
>>> config.field["myKey"] = 42
>>> print(config.field)
{'myKey': 42}

Definition at line 209 of file dictField.py.

Constructor & Destructor Documentation

__init__()

lsst.pex.config.dictField.DictField.__init__	(		self,
			doc,
			keytype = None,
			itemtype = None,
			default = None,
			optional = False,
			dictCheck = None,
			keyCheck = None,
			itemCheck = None,
			deprecated = None )

Definition at line 304 of file dictField.py.

    ):
        source = getStackFrame()
        self._setup(
            doc=doc,
            dtype=Dict,
            default=default,
            check=None,
            optional=optional,
            source=source,
            deprecated=deprecated,
        )
        if keytype is None:
            raise ValueError(
                "keytype must either be supplied as an argument or as a type argument to the class"
            )
        if keytype not in self.supportedTypes:
            raise ValueError(f"'keytype' {_typeStr(keytype)} is not a supported type")
        elif itemtype is not None and itemtype not in self.supportedTypes:
            raise ValueError(f"'itemtype' {_typeStr(itemtype)} is not a supported type")
 
        check_errors = []
        for name, check in (("dictCheck", dictCheck), ("keyCheck", keyCheck), ("itemCheck", itemCheck)):
            if check is not None and not callable(check):
                check_errors.append(name)
        if check_errors:
            raise ValueError(f"{', '.join(check_errors)} must be callable")
 
        self.keytype = keytype
        self.itemtype = itemtype
        self.dictCheck = dictCheck
        self.keyCheck = keyCheck
        self.itemCheck = itemCheck
 

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)
 

__contains__()

bool lsst.pex.config.dictField.Dict.__contains__ ( self, Any k )

inherited

Definition at line 124 of file dictField.py.

    def __contains__(self, k: Any) -> bool:
        return k in self._dict
 

__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 808 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)
 

__delitem__()

None lsst.pex.config.dictField.Dict.__delitem__ ( self, KeyTypeVar k, Any at = None, str label = "delitem", bool setHistory = True )

inherited

Definition at line 171 of file dictField.py.

    ) -> None:
        if self._config._frozen:
            raise FieldValidationError(self._field, self._config, "Cannot modify a frozen Config")
 
        del self._dict[k]
        if setHistory:
            if at is None:
                at = getCallStack()
            self._history.append((dict(self._dict), at, label))
 

__get__() [1/3]

FieldTypeVar lsst.pex.config.config.Field.__get__ ( self, Config instance, Any owner = None, Any at = None, str label = "default" )

inherited

Definition at line 717 of file config.py.

    ) -> FieldTypeVar: ...
 

__get__() [2/3]

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

inherited

Define how attribute access should occur on the Config instance
This is invoked by the owning config object and should not be called
directly.

When the field attribute is accessed on a Config class object, it
returns the field object itself in order to allow inspection of
Config classes.

When the field attribute is access on a config instance, the actual
value described by the field (and held by the Config instance) is
returned.

Definition at line 721 of file config.py.

    def __get__(self, instance, owner=None, at=None, label="default"):
        """Define how attribute access should occur on the Config instance
        This is invoked by the owning config object and should not be called
        directly.
 
        When the field attribute is accessed on a Config class object, it
        returns the field object itself in order to allow inspection of
        Config classes.
 
        When the field attribute is access on a config instance, the actual
        value described by the field (and held by the Config instance) is
        returned.
        """
        if instance is None:
            return self
        else:
            # try statements are almost free in python if they succeed
            try:
                return instance._storage[self.name]
            except AttributeError:
                if not isinstance(instance, Config):
                    return self
                else:
                    raise AttributeError(
                        f"Config {instance} is missing _storage attribute, likely incorrectly initialized"
                    ) from None
 

__get__() [3/3]

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

inherited

Definition at line 712 of file config.py.

    ) -> Field[FieldTypeVar]: ...
 

__getitem__()

ItemTypeVar lsst.pex.config.dictField.Dict.__getitem__ ( self, KeyTypeVar k )

inherited

Definition at line 115 of file dictField.py.

    def __getitem__(self, k: KeyTypeVar) -> ItemTypeVar:
        return self._dict[k]
 

__iter__()

Iterator[KeyTypeVar] lsst.pex.config.dictField.Dict.__iter__ ( self )

inherited

Definition at line 121 of file dictField.py.

    def __iter__(self) -> Iterator[KeyTypeVar]:
        return iter(self._dict)
 

__len__()

int lsst.pex.config.dictField.Dict.__len__ ( self )

inherited

Definition at line 118 of file dictField.py.

    def __len__(self) -> int:
        return len(self._dict)
 

__reduce__()

lsst.pex.config.dictField.Dict.__reduce__ ( self )

inherited

Definition at line 201 of file dictField.py.

    def __reduce__(self):
        raise UnexpectedProxyUsageError(
            f"Proxy container for config field {self._field.name} cannot "
            "be pickled; it should be converted to a built-in container before "
            "being assigned to other objects or variables."
        )
 
 

__repr__()

lsst.pex.config.dictField.Dict.__repr__ ( self )

inherited

Definition at line 183 of file dictField.py.

    def __repr__(self):
        return repr(self._dict)
 

__set__()

None lsst.pex.config.dictField.DictField.__set__	(		self,
		Config	instance,
		Mapping[KeyTypeVar, ItemTypeVar] | None	value,
		Any	at = None,
		str	label = "assignment" )

Definition at line 379 of file dictField.py.

    ) -> None:
        if instance._frozen:
            msg = f"Cannot modify a frozen Config. Attempting to set field to value {value}"
            raise FieldValidationError(self, instance, msg)
 
        if at is None:
            at = getCallStack()
        if value is not None:
            value = self.DictClass(instance, self, value, at=at, label=label)
        else:
            history = instance._history.setdefault(self.name, [])
            history.append((value, at, label))
 
        instance._storage[self.name] = value
 

__setattr__()

lsst.pex.config.dictField.Dict.__setattr__ ( self, attr, value, at = None, label = "assignment" )

inherited

Definition at line 189 of file dictField.py.

    def __setattr__(self, attr, value, at=None, label="assignment"):
        if hasattr(getattr(self.__class__, attr, None), "__set__"):
            # This allows properties to work.
            object.__setattr__(self, attr, value)
        elif attr in self.__dict__ or attr in ["_field", "_config_", "_history", "_dict", "__doc__"]:
            # This allows specific private attributes to work.
            object.__setattr__(self, attr, value)
        else:
            # We throw everything else.
            msg = f"{_typeStr(self._field)} has no attribute {attr}"
            raise FieldValidationError(self._field, self._config, msg)
 

__setitem__()

None lsst.pex.config.dictField.Dict.__setitem__ ( self, KeyTypeVar k, ItemTypeVar x, Any at = None, str label = "setitem", bool setHistory = True )

inherited

Definition at line 127 of file dictField.py.

    ) -> None:
        if self._config._frozen:
            msg = f"Cannot modify a frozen Config. Attempting to set item at key {k!r} to value {x}"
            raise FieldValidationError(self._field, self._config, msg)
 
        # validate keytype
        k = _autocast(k, self._field.keytype)
        if type(k) is not self._field.keytype:
            msg = f"Key {k!r} is of type {_typeStr(k)}, expected type {_typeStr(self._field.keytype)}"
            raise FieldValidationError(self._field, self._config, msg)
 
        # validate itemtype
        x = _autocast(x, self._field.itemtype)
        if self._field.itemtype is None:
            if type(x) not in self._field.supportedTypes and x is not None:
                msg = f"Value {x} at key {k!r} is of invalid type {_typeStr(x)}"
                raise FieldValidationError(self._field, self._config, msg)
        else:
            if type(x) is not self._field.itemtype and x is not None:
                msg = (
                    f"Value {x} at key {k!r} is of incorrect type {_typeStr(x)}. "
                    f"Expected type {_typeStr(self._field.itemtype)}"
                )
                raise FieldValidationError(self._field, self._config, msg)
 
        # validate key using keycheck
        if self._field.keyCheck is not None and not self._field.keyCheck(k):
            msg = f"Key {k!r} is not a valid key"
            raise FieldValidationError(self._field, self._config, msg)
 
        # validate item using itemcheck
        if self._field.itemCheck is not None and not self._field.itemCheck(x):
            msg = f"Item at key {k!r} is not a valid value: {x}"
            raise FieldValidationError(self._field, self._config, msg)
 
        if at is None:
            at = getCallStack()
 
        self._dict[k] = x
        if setHistory:
            self._history.append((dict(self._dict), at, label))
 

__str__()

lsst.pex.config.dictField.Dict.__str__ ( self )

inherited

Definition at line 186 of file dictField.py.

    def __str__(self):
        return str(self._dict)
 

_collectImports()

lsst.pex.config.config.Field._collectImports ( self, instance, imports )

protectedinherited

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 in lsst.pex.config.configChoiceField.ConfigChoiceField, lsst.pex.config.configDictField.ConfigDictField, lsst.pex.config.configField.ConfigField, lsst.pex.config.configurableActions._configurableActionStructField.ConfigurableActionStructField, and lsst.pex.config.configurableField.ConfigurableField.

Definition at line 626 of file config.py.

    def _collectImports(self, instance, imports):
        """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
        """
        pass
 

_compare()

lsst.pex.config.dictField.DictField._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.

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.

Reimplemented in lsst.pex.config.configDictField.ConfigDictField.

Definition at line 425 of file dictField.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.
 
        Returns
        -------
        isEqual : bool
            `True` if the fields are equal, `False` otherwise.
 
        Notes
        -----
        Floating point comparisons are performed by `numpy.allclose`.
        """
        d1 = getattr(instance1, self.name)
        d2 = getattr(instance2, self.name)
        name = getComparisonName(
            _joinNamePath(instance1._name, self.name), _joinNamePath(instance2._name, self.name)
        )
        if d1 is None or d2 is None:
            return compareScalars(name, d1, d2, output=output)
        if not compareScalars(f"{name} (keys)", set(d1.keys()), set(d2.keys()), output=output):
            return False
        equal = True
        for k, v1 in d1.items():
            v2 = d2[k]
            result = compareScalars(
                f"{name}[{k!r}]", v1, v2, dtype=self.itemtype, rtol=rtol, atol=atol, output=output
            )
            if not result and shortcut:
                return False
            equal = equal and result
        return equal

_config()

Config lsst.pex.config.dictField.Dict._config ( self )

protectedinherited

Definition at line 101 of file dictField.py.

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

_copy()

Dict lsst.pex.config.dictField.Dict._copy ( self, Config config )

protectedinherited

Reimplemented in lsst.pex.config.configDictField.ConfigDict.

Definition at line 112 of file dictField.py.

    def _copy(self, config: Config) -> Dict:
        return type(self)(config, self._field, self._dict.copy(), at=None, label="copy", setHistory=False)
 

_copy_storage()

Dict[KeyTypeVar, ItemTypeVar] | None lsst.pex.config.dictField.DictField._copy_storage ( self, Config old, Config new )

protected

Copy the storage for this field in the given field into an object
suitable for storage in a new copy of that config.

Any frozen storage should be unfrozen.

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

Definition at line 418 of file dictField.py.

    def _copy_storage(self, old: Config, new: Config) -> Dict[KeyTypeVar, ItemTypeVar] | None:
        value: Dict[KeyTypeVar, ItemTypeVar] | None = old._storage[self.name]
        if value is not None:
            return value._copy(new)
        else:
            return None
 

_parseTypingArgs()

Mapping[str, Any] lsst.pex.config.dictField.DictField._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 275 of file dictField.py.

    ) -> Mapping[str, Any]:
        if len(params) != 2:
            raise ValueError("Only tuples of types that are length 2 are supported")
        resultParams = []
        for typ in params:
            if isinstance(typ, str):
                _typ = ForwardRef(typ)
                # type ignore below because typeshed seems to be wrong. It
                # indicates there are only 2 args, as it was in python 3.8, but
                # 3.9+ takes 3 args.
                result = _typ._evaluate(globals(), locals(), recursive_guard=set())  # type: ignore
                if result is None:
                    raise ValueError("Could not deduce type from input")
                typ = cast(type, result)
            resultParams.append(typ)
        keyType, itemType = resultParams
        results = dict(kwds)
        if (supplied := kwds.get("keytype")) and supplied != keyType:
            raise ValueError("Conflicting definition for keytype")
        else:
            results["keytype"] = keyType
        if (supplied := kwds.get("itemtype")) and supplied != itemType:
            raise ValueError("Conflicting definition for itemtype")
        else:
            results["itemtype"] = itemType
        return results
 

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

freeze()

lsst.pex.config.config.Field.freeze ( self, instance )

inherited

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 in lsst.pex.config.configChoiceField.ConfigChoiceField, lsst.pex.config.configDictField.ConfigDictField, lsst.pex.config.configField.ConfigField, lsst.pex.config.configurableActions._configurableActionStructField.ConfigurableActionStructField, and lsst.pex.config.configurableField.ConfigurableField.

Definition at line 581 of file config.py.

    def 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.**
        """
        pass
 

rename()

lsst.pex.config.config.Field.rename ( self, instance )

inherited

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 in lsst.pex.config.configChoiceField.ConfigChoiceField, lsst.pex.config.configDictField.ConfigDictField, lsst.pex.config.configField.ConfigField, lsst.pex.config.configurableActions._configurableActionStructField.ConfigurableActionStructField, and lsst.pex.config.configurableField.ConfigurableField.

Definition at line 531 of file config.py.

    def rename(self, instance):
        r"""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`.
        """
        pass
 

save()

lsst.pex.config.config.Field.save ( self, outfile, instance )

inherited

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 in lsst.pex.config.configChoiceField.ConfigChoiceField, lsst.pex.config.configDictField.ConfigDictField, lsst.pex.config.configField.ConfigField, lsst.pex.config.configurableActions._configurableActionField.ConfigurableActionField, lsst.pex.config.configurableActions._configurableActionStructField.ConfigurableActionStructField, and lsst.pex.config.configurableField.ConfigurableField.

Definition at line 640 of file config.py.

    def 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.
        """
        value = self.__get__(instance)
        fullname = _joinNamePath(instance._name, self.name)
 
        if self.deprecated and value == self.default:
            return
 
        # write full documentation string as comment lines
        # (i.e. first character is #)
        doc = "# " + str(self.doc).replace("\n", "\n# ")
        if isinstance(value, float) and not math.isfinite(value):
            # non-finite numbers need special care
            outfile.write(f"{doc}\n{fullname}=float('{value!r}')\n\n")
        else:
            outfile.write(f"{doc}\n{fullname}={value!r}\n\n")
 

toDict()

lsst.pex.config.dictField.DictField.toDict	(		self,
			instance )

Convert this field's key-value pairs into a regular `dict`.

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

Returns
-------
result : `dict` or `None`
    If this field has a value of `None`, then this method returns
    `None`. Otherwise, this method returns the field's value as a
    regular Python `dict`.

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

Reimplemented in lsst.pex.config.configDictField.ConfigDictField.

Definition at line 400 of file dictField.py.

    def toDict(self, instance):
        """Convert this field's key-value pairs into a regular `dict`.
 
        Parameters
        ----------
        instance : `lsst.pex.config.Config`
            The configuration that contains this field.
 
        Returns
        -------
        result : `dict` or `None`
            If this field has a value of `None`, then this method returns
            `None`. Otherwise, this method returns the field's value as a
            regular Python `dict`.
        """
        value = self.__get__(instance)
        return dict(value) if value is not None else None
 

validate()

lsst.pex.config.dictField.DictField.validate	(		self,
			instance )

Validate the field's value (for internal use only).

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

Raises
------
lsst.pex.config.FieldValidationError
    Raised if validation fails for this field (see *Notes*).

Notes
-----
This method validates values according to the following criteria:

- A non-optional field is not `None`.
- If a value is not `None`, it must pass the `ConfigField.dictCheck`
  user callback function.

Individual key and item checks by the ``keyCheck`` and ``itemCheck``
user callback functions are done immediately when the value is set on a
key. Those checks are not repeated by this method.

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

Reimplemented in lsst.pex.config.configDictField.ConfigDictField.

Definition at line 348 of file dictField.py.

    def validate(self, instance):
        """Validate the field's value (for internal use only).
 
        Parameters
        ----------
        instance : `lsst.pex.config.Config`
            The configuration that contains this field.
 
        Raises
        ------
        lsst.pex.config.FieldValidationError
            Raised if validation fails for this field (see *Notes*).
 
        Notes
        -----
        This method validates values according to the following criteria:
 
        - A non-optional field is not `None`.
        - If a value is not `None`, it must pass the `ConfigField.dictCheck`
          user callback function.
 
        Individual key and item checks by the ``keyCheck`` and ``itemCheck``
        user callback functions are done immediately when the value is set on a
        key. Those checks are not repeated by this method.
        """
        Field.validate(self, instance)
        value = self.__get__(instance)
        if value is not None and self.dictCheck is not None and not self.dictCheck(value):
            msg = f"{value} is not a valid value"
            raise FieldValidationError(self, instance, msg)
 

Member Data Documentation

_config

lsst.pex.config.dictField.Dict._config

protectedinherited

Definition at line 96 of file dictField.py.

_config_

lsst.pex.config.dictField.Dict._config_ = weakref.ref(config)

protectedinherited

Definition at line 85 of file dictField.py.

_dict

lsst.pex.config.dictField.Dict._dict = {}

protectedinherited

Definition at line 86 of file dictField.py.

_field

lsst.pex.config.dictField.Dict._field = field

protectedinherited

Definition at line 84 of file dictField.py.

_history

Config lsst.pex.config.dictField.Dict._history = self._config._history.setdefault(self._field.name, [])

protectedinherited

Definition at line 87 of file dictField.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.

dictCheck

lsst.pex.config.dictField.DictField.dictCheck = dictCheck

Definition at line 344 of file dictField.py.

DictClass

type lsst.pex.config.dictField.DictField.DictClass = Dict

static

Definition at line 272 of file dictField.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.

itemCheck

lsst.pex.config.dictField.DictField.itemCheck = itemCheck

Definition at line 346 of file dictField.py.

itemtype

lsst.pex.config.dictField.DictField.itemtype = itemtype

Definition at line 343 of file dictField.py.

keyCheck

lsst.pex.config.dictField.DictField.keyCheck = keyCheck

Definition at line 345 of file dictField.py.

keytype

lsst.pex.config.dictField.DictField.keytype = keytype

Definition at line 342 of file dictField.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

history

lsst.pex.config.dictField.Dict.history = property(lambda x: x._history)

staticinherited

Definition at line 108 of file dictField.py.

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-12.1.0/Linux/pex_config/gbaa8f7a6c5+38b34f4976/python/lsst/pex/config/dictField.py