def __init__(self,
dict_,
value,
at=None,
label="assignment",
setHistory=True):
if at is None:
at = getCallStack()
self._dict = dict_
self._field = self._dict._field
self._config = self._dict._config
self.__history = self._config._history.setdefault(self._field.name, [])
if value is not None:
try:
for v in value:
if v not in self._dict:
# invoke __getitem__ to ensure it's present
self._dict.__getitem__(v, at=at)
except TypeError:
msg = "Value %s is of incorrect type %s. Sequence type expected" % (
value, _typeStr(value))
raise FieldValidationError(self._field, self._config, msg)
self._set = set(value)
else:
self._set = set()
if setHistory:
self.__history.append(("Set selection to %s" % self, at, label))
def __setitem__(self, k, value, at=None, label="assignment"):
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
try:
dtype = self.types[k]
except Exception:
raise FieldValidationError(self._field, self._config,
"Unknown key %r" % k)
if value != dtype and type(value) != dtype:
msg = "Value %s at key %s is of incorrect type %s. Expected type %s" % \
(value, k, _typeStr(value), _typeStr(dtype))
raise FieldValidationError(self._field, self._config, msg)
if at is None:
at = getCallStack()
name = _joinNamePath(self._config._name, self._field.name, k)
oldValue = self._dict.get(k, None)
if oldValue is None:
if value == dtype:
self._dict[k] = value(__name=name, __at=at, __label=label)
else:
self._dict[k] = dtype(__name=name,
__at=at,
__label=label,
**value._storage)
else:
if value == dtype:
value = value()
oldValue.update(__at=at, __label=label, **value._storage)
def __getOrMake(self, instance, at=None, label="default"):
value = instance._storage.get(self.name, None)
if value is None:
if at is None:
at = getCallStack(1)
value = ConfigurableInstance(instance, self, at=at, label=label)
instance._storage[self.name] = value
return value
def __delitem__(self, i, at=None, label="delitem", setHistory=True):
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
del self._list[i]
if setHistory:
if at is None:
at = getCallStack()
self.history.append((list(self._list), at, label))
def _getOrMake(self, instance, label="default"):
instanceDict = instance._storage.get(self.name)
if instanceDict is None:
at = getCallStack(1)
instanceDict = self.dtype(instance, self)
instanceDict.__doc__ = self.doc
instance._storage[self.name] = instanceDict
history = instance._history.setdefault(self.name, [])
history.append(("Initialized from defaults", at, label))
return instanceDict
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()
instanceDict = self._getOrMake(instance)
if isinstance(value, self.instanceDictClass):
for k, v in value.items():
instanceDict.__setitem__(k, v, at=at, label=label)
instanceDict._setSelection(value._selection, at=at, label=label)
else:
instanceDict._setSelection(value, at=at, label=label)
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()
if value is not None:
value = List(instance, self, value, at, label)
else:
history = instance._history.setdefault(self.name, [])
history.append((value, at, label))
instance._storage[self.name] = value
def __init__(self, config, field, at=None, label="default"):
object.__setattr__(self, "_config", config)
object.__setattr__(self, "_field", field)
object.__setattr__(self, "__doc__", config)
object.__setattr__(self, "_target", field.target)
object.__setattr__(self, "_ConfigClass", field.ConfigClass)
object.__setattr__(self, "_value", None)
if at is None:
at = getCallStack()
at += [self._field.source]
self.__initValue(at, label)
history = config._history.setdefault(field.name, [])
history.append(("Targeted and initialized from defaults", at, label))
def discard(self, value, at=None):
"""Discard a value from the selected set.
"""
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
if value not in self._dict:
return
if at is None:
at = getCallStack()
self.__history.append(
("removed %s from selection" % value, at, "selection"))
self._set.discard(value)
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)
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)
def add(self, value, at=None):
"""Add a value to the selected set.
"""
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
if at is None:
at = getCallStack()
if value not in self._dict:
# invoke __getitem__ to make sure it's present
self._dict.__getitem__(value, at=at)
self.__history.append(
("added %s to selection" % value, at, "selection"))
self._set.add(value)
def __getitem__(self, k, at=None, label="default"):
try:
value = self._dict[k]
except KeyError:
try:
dtype = self.types[k]
except Exception:
raise FieldValidationError(
self._field, self._config,
"Unknown key %r in Registry/ConfigChoiceField" % k)
name = _joinNamePath(self._config._name, self._field.name, k)
if at is None:
at = getCallStack()
at.insert(0, dtype._source)
value = self._dict.setdefault(
k, dtype(__name=name, __at=at, __label=label))
return value
def _setSelection(self, value, at=None, label="assignment"):
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
if at is None:
at = getCallStack(1)
if value is None:
self._selection = None
elif self._field.multi:
self._selection = SelectionSet(self, value, setHistory=False)
else:
if value not in self._dict:
self.__getitem__(
value,
at=at) # just invoke __getitem__ to make sure it's present
self._selection = value
self._history.append((value, at, label))
def __setitem__(self, i, x, at=None, label="setitem", setHistory=True):
if self._config._frozen:
raise FieldValidationError(self._field, self._config,
"Cannot modify a frozen Config")
if isinstance(i, slice):
k, stop, step = i.indices(len(self))
for j, xj in enumerate(x):
xj = _autocast(xj, self._field.itemtype)
self.validateItem(k, xj)
x[j] = xj
k += step
else:
x = _autocast(x, self._field.itemtype)
self.validateItem(i, x)
self._list[i] = x
if setHistory:
if at is None:
at = getCallStack()
self.history.append((list(self._list), at, label))
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)
def retarget(self, target, ConfigClass=None, at=None, label="retarget"):
"""Target a new configurable and ConfigClass
"""
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, str(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 = "retarget(target=%s, ConfigClass=%s)" % (_typeStr(target),
_typeStr(ConfigClass))
history.append((msg, at, label))
def insert(self, i, x, at=None, label="insert", setHistory=True):
"""Insert an item into the list at the given index.
Parameters
----------
i : `int`
Index where the item is inserted.
x : object
Item that is inserted.
at : `list` of `lsst.pex.config.callStack.StackFrame`, optional
The call stack (created by
`lsst.pex.config.callStack.getCallStack`).
label : `str`, optional
Event label for the history.
setHistory : `bool`, optional
Enable setting the field's history, using the value of the ``at``
parameter. Default is `True`.
"""
if at is None:
at = getCallStack()
self.__setitem__(slice(i, i), [x],
at=at,
label=label,
setHistory=setHistory)