Set a single Visual Property Value

        :param visual_property: Visual Property ID
        :param value: New value for the VP
        :return: None
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)
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)
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)
499536
function(vPropertyValues, oProperties, sTarget, oSchema) {

		function setEdmType(vValueIndex) {
			var oPropertyValue, sEdmType = '';

			if (vPropertyValues[vValueIndex]) {
				oPropertyValue = vPropertyValues[vValueIndex];
				if (oPropertyValue.Value && oPropertyValue.Value.Path) {
					sEdmType = AnnotationParser.getEdmType(oPropertyValue.Value.Path, oProperties, sTarget, oSchema);
					if (sEdmType) {
						vPropertyValues[vValueIndex].EdmType = sEdmType;
					}
				} else if (oPropertyValue.Path) {
					sEdmType = AnnotationParser.getEdmType(oPropertyValue.Path, oProperties, sTarget, oSchema);
					if (sEdmType) {
						vPropertyValues[vValueIndex].EdmType = sEdmType;
					}
				} else if (oPropertyValue.Facets) {
					vPropertyValues[vValueIndex].Facets = AnnotationParser.setEdmTypes(oPropertyValue.Facets, oProperties, sTarget, oSchema);
				} else if (oPropertyValue.Data) {
					vPropertyValues[vValueIndex].Data = AnnotationParser.setEdmTypes(oPropertyValue.Data, oProperties, sTarget, oSchema);
				} else if (vValueIndex === "Data") {
					vPropertyValues.Data = AnnotationParser.setEdmTypes(oPropertyValue, oProperties, sTarget, oSchema);
				} else if (oPropertyValue.Value && oPropertyValue.Value.Apply) {
					vPropertyValues[vValueIndex].Value.Apply.Parameters = AnnotationParser.setEdmTypes(oPropertyValue.Value.Apply.Parameters,
							oProperties, sTarget, oSchema);
				} else if (oPropertyValue.Value && oPropertyValue.Type && (oPropertyValue.Type === "Path")) {
					sEdmType = AnnotationParser.getEdmType(oPropertyValue.Value, oProperties, sTarget, oSchema);
					if (sEdmType) {
						vPropertyValues[vValueIndex].EdmType = sEdmType;
					}
				}
			}
		}

		if (Array.isArray(vPropertyValues)) {
			for (var iValueIndex = 0; iValueIndex < vPropertyValues.length; iValueIndex += 1) {
				setEdmType(iValueIndex);
			}
		} else {
			for (var sValueIndex in vPropertyValues) {
				setEdmType(sValueIndex);
			}
		}

		return vPropertyValues;
	}
890743
def update(self, value=None):
        

        # Update self.value
        if value is None:
            value = self._current_value + 1
        self._current_value = value

        # Choose the appropriate environment
        if self._ipython_widget:
            try:
                self._update_ipython_widget(value)
            except RuntimeError:
                pass
        else:
            self._update_console(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)
996070
public void setValue(float value) {
		mBarPointerPosition = Math.round((mSVToPosFactor * (1 - value))
				+ mBarPointerHaloRadius + (mBarLength / 2));
		calculateColor(mBarPointerPosition);
		mBarPointerPaint.setColor(mColor);
		// Check whether the Saturation/Value bar is added to the ColorPicker
		// wheel
		if (mPicker != null) {
			mPicker.setNewCenterColor(mColor);
			mPicker.changeOpacityBarColor(mColor);
		}
		invalidate();
	}
6909
def setProperty(self, prop: str, value: str, priority: str = None
                    ) -> None:
        
        self[prop] = value
1127905
def set(self, name, value):
        
        if self.vars is None:
            self.vars = {}
        self.vars[name] = value
613958
def set_default (feature, value):
    
    f = __all_features[feature]
    bad_attribute = None

    if f.free:
        bad_attribute = "free"
    elif f.optional:
        bad_attribute = "optional"

    if bad_attribute:
        raise InvalidValue ("%s property %s cannot have a default" % (bad_attribute, f.name))

    if value not in f.values:
        raise InvalidValue ("The specified default value, '%s' is invalid.\n" % value + "allowed values are: %s" % f.values)

    f.set_default(value)
724252
def set_final_value(self, description_type, value):
        
        types, _, _, vbox_values, extra_config = self.get_description()

        # find offset to description type
        for offset, t in enumerate(types):
            if t == description_type:
                break
        else:
            raise Exception("Failed to find type for %s" % description_type)

        enabled = [True] * len(types)
        vbox_values = list(vbox_values)
        extra_config = list(extra_config)

        if isinstance(value, basestring):
            final_value = value
        elif isinstance(value, Enum):
            final_value = str(value._value)
        elif isinstance(value, int):
            final_value = str(value)
        else:
            raise ValueError("Incorrect value type.")

        vbox_values[offset] = final_value
        self.set_final_values(enabled, vbox_values, extra_config)
612408
public V setValue(final V value) {
		V oldValue = this.getValue();
		this.values[tree.pageIndex] = value;
		return oldValue;
	}
1292057
def set_property(property, value)
      cmd = ["SET",self.class.object_name, id, property, value].compact.join(" ")
      Skyper::Skype.send_command(cmd)
    end
342190
private static void setSimpleValue(Object obj, Property property, Object value) {
        if (property == null) {
            throw new IllegalArgumentException("Cannot set a new value to a property with a 'null' propertyName.");
        }

        property.set(obj, value);
    }
1144196
protected function _setPropertyValue($property, $value)
    {
        //if a value is null and it's requires set it to the default
        //value
        $property = $this->_description->getProperty($property);
        $name = $property->getName();

        if ($property->isAttribute()) {
            $default = $property->getDefaultValue();

            if ($value === null && $default) {
                $value = $default;
            }
        }

        $this->_property[$name] = $value;
        $this->_materialized[$name] = $name;
    }
333119
public void setValue(String v) {
    if (Lemma_Type.featOkTst && ((Lemma_Type)jcasType).casFeat_value == null)
      jcasType.jcas.throwFeatMissing("value", "de.julielab.jules.types.Lemma");
    jcasType.ll_cas.ll_setStringValue(addr, ((Lemma_Type)jcasType).casFeatCode_value, v);}
968523
def assign_value(self, comp_def, value, src_ref):
        
        super().assign_value(comp_def, value, src_ref)
        comp_def.properties['incrthreshold'] = value