Set prop value

        :param instance:
        :param value:
        :param parent:
        :return:
767585
def set_value(self, instance, value, parent=None):
        
        self.resolve_base(instance)
        value = self.deserialize(value, parent)
        instance.values[self.alias] = value
        self._trigger_changed(instance, value)
834504
def _set_virtual(self, key, value):
        
        if key in self and key not in self._virtual_keys:
            return  # Do nothing for non-virtual keys.

        self._virtual_keys.add(key)
        if key in self and self[key] is not value:
            self._on_change(key, value)
        dict.__setitem__(self, key, value)
        for overlay in self._iter_overlays():
            overlay._set_virtual(key, value)
420879
def set_value(self, visual_property, value):
        
        if visual_property is None or value is None:
            raise ValueError('Both VP and value are required.')

        new_value = [
            {
                'visualProperty': visual_property,
                "value": value
            }
        ]
        requests.put(self.url, data=json.dumps(new_value), headers=HEADERS)
777467
function set (obj, key, val) {
	  if (Array.isArray(obj)) {
	    obj.splice(key, 1, val);
	    return val
	  }
	  if (hasOwn(obj, key)) {
	    obj[key] = val;
	    return
	  }
	  var ob = obj.__ob__;
	  if (obj._isVue || (ob && ob.vmCount)) {
	    "development" !== 'production' && warn(
	      'Avoid adding reactive properties to a Vue instance or its root $data ' +
	      'at runtime - declare it upfront in the data option.'
	    );
	    return
	  }
	  if (!ob) {
	    obj[key] = val;
	    return
	  }
	  defineReactive$$1(ob.value, key, val);
	  ob.dep.notify();
	  return val
	}
55824
def setProp(self, name, value):
        
        ret = libxml2mod.xmlSetProp(self._o, name, value)
        if ret is None:raise treeError('xmlSetProp() failed')
        __tmp = xmlAttr(_obj=ret)
        return __tmp
1192087
def SetParserProp(self, prop, value):
        
        ret = libxml2mod.xmlTextReaderSetParserProp(self._o, prop, value)
        return ret
1209675
def setProperty(self, prop, *args, **kwargs):
        
        f = self.__setAttrs.get(prop)
        if not f:
            raise KeyError('Unknown writable property: %s' % prop)
        f(self, *args, **kwargs)
279116
def set(self, instance, value, **kwargs):
        
        val = get_date(instance, value)
        super(DateTimeField, self).set(instance, val, **kwargs)
113991
def set(self, value, parse=False):
        
        self.value = self.parse(value) if parse else value
671532
def set_child(self, i, child):
        
        child.parent = self
        self.children[i].parent = None
        self.children[i] = child
        self.changed()
221097
def set_property(self, **kwargs):
        
        if not isinstance(self._value, nparray.ndarray):
            raise ValueError("value is not a nparray object")

        for property, value in kwargs.items():
            setattr(self._value, property, value)
532906
def set(option, value=(not_set=true), ignore_setter=false, &block)
      raise ArgumentError, 'value not set' if block and !not_set
      return self if !not_set and value.nil?

      if not_set
        set_options option
        return self
      end

      if respond_to?("#{option}=") and not ignore_setter
        return __send__("#{option}=", value)
      end

      define_accessors option, value
      self
    end
1037944
def _setter(self, obj, value):
        
        if isinstance(value, DynamicValue):  # execute lambda values.
            fvalue = value()

        else:
            fvalue = value

        self._validate(data=fvalue, owner=obj)

        if self._fset_ is not None:
            self._fset_(obj, fvalue)

        else:
            setattr(obj, self._attrname(), value)

        # notify obj about the new value.
        if isinstance(obj, Schema):
            obj._setvalue(self, fvalue)
627761
def _set(self, obj, value):
        """"""
        if value not in self.lenum:
            raise ValueError("Not a valid value: %s" % value)

        type(obj).__dict__[self.propname].__set__(obj, value)
976297
def set(self, instance, value, **kw):
        
        if value:
            try:
                value = DateTime(value)
            except SyntaxError:
                logger.warn("Value '{}' is not a valid DateTime string"
                            .format(value))
                return False

        self._set(instance, value, **kw)
542455
def set_value(obj, attrs, value, _copy=False):
    
    for attr in attrs:
        if _copy:
            value = copy(value)
        setattr(obj, attr, value)
316806
def set(self, instance, value, **kwargs):
        
        # Retrieve the proxy object
        proxy_object = self.get_proxy(instance)

        # Return None if we could not find a proxied object, e.g. through
        # the proxy expression 'context.getSample()' on an AR
        if not proxy_object:
            logger.debug("Expression '{}' did not return a valid Proxy Object on {}"
                         .format(self.proxy, instance))
            return None

        # Lookup the proxied field by name
        field_name = self.getName()
        field = proxy_object.getField(field_name)

        # Bail out if the proxy object has no identical named field.
        if field is None:
            raise KeyError("Object '{}' with id '{}' has no field named '{}'".format(
                proxy_object.portal_type, proxy_object.getId(), field_name))

        # set the value on the proxy object
        field.set(proxy_object, value, **kwargs)

        # get the current time
        now = DateTime.DateTime()

        # update the modification date of the proxied object
        proxy_object.setModificationDate(now)

        # update the modification date of the holding object
        instance.setModificationDate(now)