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)