Actually sets the value, first by trying it directly, then by
328206
def _set_value_safe(self, k, v, ignore_errors=False, block_user_signals=False):
        
        # for safety: by default assume it's a repr() with python code
        try:
            self.set_value(k, v, ignore_error       = ignore_errors, 
                                 block_user_signals = block_user_signals)

        except:
            print("TreeDictionary ERROR: Could not set '"+k+"' to '"+v+"'")
320717
def _set_value(self, new_value):
        """"""

        if self.min_value is not None and new_value < self.min_value:

            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is less than the minimum allowed {2}".format(
                    self.name, new_value, self.min_value))

        if self.max_value is not None and new_value > self.max_value:
            raise SettingOutOfBounds(
                "Trying to set parameter {0} = {1}, which is more than the maximum allowed {2}".format(
                    self.name, new_value, self.max_value))

        # Issue a warning if there is an auxiliary variable, as the setting does not have any effect
        if self.has_auxiliary_variable():

            with warnings.catch_warnings():

                warnings.simplefilter("always", RuntimeWarning)

                warnings.warn("You are trying to assign to a parameter which is either linked or "
                              "has auxiliary variables. The assignment has no effect.", RuntimeWarning)

        # Save the value as a pure floating point to avoid the overhead of the astropy.units machinery when
        # not needed

        if self._transformation is None:

            new_internal_value = new_value

        else:

            new_internal_value = self._transformation.forward(new_value)

        # If the parameter has changed, update its value and call the callbacks if needed

        if new_internal_value != self._internal_value:

            # Update
            self._internal_value = new_internal_value

            # Call the callbacks (if any)
            for callback in self._callbacks:

                try:

                    callback(self)

                except:

                    raise NotCallableOrErrorInCall("Could not call callback for parameter %s" % self.name)
109493
def setValue(self, key, value):
        
        curr = self._stack[-1]
        curr[key] = value
1331447
def set_value(self, value):
        
        check_call(_LIB.MXProfileSetCounter(self.handle, int(value)))
694927
def set(self, instance, value, **kw):
        
        return self._set(instance, value, **kw)
674308
def set(self, key, value):
        
        return self.__setitem__(key, value, force=True)
58818
def set(value = true)
      assert_exists
      assert_enabled

      if (value && !set?) || (!value && set?)
        @object.click
      end
    end
96648
def set_triggered_by_event(self, value):
        
        if value is None or not isinstance(value, bool):
            raise TypeError("TriggeredByEvent must be set to a bool")
        else:
            self.__triggered_by_event = value
158337
def set_value(self, value):
        """"""

        if self.data_type == self.BOOLEAN_TYPE:
            self.value_boolean = bool(value)
        elif self.data_type == self.NUMBER_TYPE:
            self.value_number = float(value)
        else:
            self.value = value
776840
function setValue(object, key, value) {
  if (key in object === true) return;
  object[key] = value;
}
1121375
def __set_amount(self, value):
        '''
        
        '''
        try:
            self.__amount = quantize(Decimal(str(value)))
        except:
            raise ValueError('Invalid amount value')
169383
public void setValue(T value)
    {
        try
        {
            lock.writeLock().lock();
            this.value = value;
        }
        finally
        {
            lock.writeLock().unlock();
        }
    }
392762
def SetValue(self, value=None, act=True):
        "  "
        if value is None:
            value = wx.TextCtrl.GetValue(self).strip()
        self.__CheckValid(value)
        self.__GetMark()
        if value is not None:
            wx.TextCtrl.SetValue(self, self.format % set_float(value))

        if self.is_valid and hasattr(self.__action, '__call__') and act:
            self.__action(value=self.__val)
        elif not self.is_valid and self.bell_on_invalid:
            wx.Bell()

        self.__SetMark()
474343
def set(self, value = True):
        """"""
        value = value in (True,1) or ( (isinstance(value, str) or (sys.version < '3' and isinstance(value, unicode))) and (value.lower() in ("1","yes","true","enabled"))) #pylint: disable=undefined-variable
        return super(BooleanParameter,self).set(value)
310703
def set_value(self, value: datetime):
        
        assert isinstance(value, datetime)

        self.value = value
1118706
def Set(self, value, context=None):
    """"""
    if self.has_error: return
    if self.value is None:
      self.value = value
      self._context["old_value"] = value
      self._context.update({"old_" + k: v for k, v in context.items()})
    elif self.value != value:
      self.has_error = True
      self._context["new_value"] = value
      self._context.update({"new_" + k: v for k, v in context.items()})
1362172
def set(self, key, value):
        """"""
        if key in self.callbacks:
            self.callbacks[key](value)
        else:
            self.prefs[key] = value