set what this thing is! "instance of (P31)"
352396
def _update_what(self):
        
        if 'P31' not in self.data['claims']:  # missing Wikidata
            msg = ("Note: Wikidata item %s" % self.data['wikibase'],
                   "missing 'instance of' (P31)")
            utils.stderr(" ".join(msg))
            return

        instance_of = self.data['claims']['P31'][0]
        labels = self.data['labels']

        if instance_of in labels:
            self.data['what'] = labels[instance_of]
623491
def set(pin, value):
    ''''''
    if value is LOW:
        value = 0
    value = int(bool(value))
    log.debug("Write {0}: {1}".format(pin, value))
    f = _open[pin].value
    _write(f, value)
727956
def set(self, key, value):
        
        if self._component.get(key, raw=True) != value:
            self._component[key] = value
            self._main_config.dirty = True
1203222
def set(name, value)
      if respond_to?(name)
        send("#{name}=",value)
      elsif Configuration.setting_name_to_property(name)
        send("#{Configuration.setting_name_to_property(name)}=",value)
      else
        build_settings[name] = value
      end
    end
1289982
def instance_set(attribute, value)
      setter = :"#{self.name}_#{attribute}="
      self.instance.send(setter, value) if instance.respond_to?(setter)
    end
569621
void init() {
		if (! isEnabled()) {
			loggerConfig.info("Ted prime instance check is disabled");
			return;
		}
		this.primeTaskId = context.tedDaoExt.findPrimeTaskId();

		int periodMs = context.config.intervalDriverMs();
		this.postponeSec = (int)Math.round((1.0 * periodMs * TICK_SKIP_COUNT + 500 + 500) / 1000); // 500ms reserve, 500 for rounding up

		becomePrime();

		loggerConfig.info("Ted prime instance check is enabled, primeTaskId={} isPrime={} postponeSec={}", primeTaskId, isPrime, postponeSec);
		initiated = true;
	}
31777
def set(self, param, value):
        
        self._shouldOwn(param)
        try:
            value = param.typeConverter(value)
        except ValueError as e:
            raise ValueError('Invalid param value given for param "%s". %s' % (param.name, e))
        self._paramMap[param] = value
1366701
def _set_listener(instance, obs):
    """"""
    if obs.names is everything:
        names = list(instance._props)
    else:
        names = obs.names
    for name in names:
        if name not in instance._listeners:
            instance._listeners[name] = {typ: [] for typ in LISTENER_TYPES}
        instance._listeners[name][obs.mode] += [obs]
566718
def set(self, name, value):
        """"""
        name = self._convert_name(name)

        if ((name in _ELEMENTSFIELD or name == 'Platform') and
            not isinstance(value, (list, tuple))):
            if isinstance(value, string_types):
                value = [v.strip() for v in value.split(',')]
            else:
                value = []
        elif (name in _LISTFIELDS and
              not isinstance(value, (list, tuple))):
            if isinstance(value, string_types):
                value = [value]
            else:
                value = []

        if logger.isEnabledFor(logging.WARNING):
            project_name = self['Name']

            scheme = get_scheme(self.scheme)
            if name in _PREDICATE_FIELDS and value is not None:
                for v in value:
                    # check that the values are valid
                    if not scheme.is_valid_matcher(v.split(';')[0]):
                        logger.warning(
                            "'%s': '%s' is not valid (field '%s')",
                            project_name, v, name)
            # FIXME this rejects UNKNOWN, is that right?
            elif name in _VERSIONS_FIELDS and value is not None:
                if not scheme.is_valid_constraint_list(value):
                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
                                   project_name, value, name)
            elif name in _VERSION_FIELDS and value is not None:
                if not scheme.is_valid_version(value):
                    logger.warning("'%s': '%s' is not a valid version (field '%s')",
                                   project_name, value, name)

        if name in _UNICODEFIELDS:
            if name == 'Description':
                value = self._remove_line_prefix(value)

        self._fields[name] = value
1012284
def __set_name(self, value):
        '''
        
        '''
        if not value or not len(value):
            raise ValueError("Invalid name.")

        self.__name = value
1148325
private CodecCipher setInit(Key key, AlgorithmParameters params, AlgorithmParameterSpec spec, Certificate certificate, SecureRandom random)
    {
        this.key         = key;
        this.params      = params;
        this.spec        = spec;
        this.certificate = certificate;
        this.random      = random;

        return this;
    }
736438
async def SetInstanceInfo(self, machines):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='Provisioner',
                   request='SetInstanceInfo',
                   version=7,
                   params=_params)
        _params['machines'] = machines
        reply = await self.rpc(msg)
        return reply
138298
def change_setting(self, instance_name, key, raw_value):
        
        ii = self.insts[instance_name]
        mo = self.modules[ii.module]
        if key in mo.deps:
            if raw_value not in self.insts:
                raise ValueError("No such instance %s" % raw_value)
            vii = self.insts[raw_value]
            vmo = self.modules[vii.module]
            if not (mo.deps[key].type in vmo.inherits or
                    mo.deps[key].type == vii.module):
                raise ValueError("%s isn't a %s" % (
                    raw_value, mo.deps[key].type))
            value = vii.object
        elif key in mo.vsettings:
            value = self.valueTypes[mo.vsettings[key].type](
                raw_value)
        else:
            raise ValueError("No such settings %s" % key)
        self.l.info("Changing %s.%s to %s" % (instance_name,
                                              key,
                                              raw_value))
        ii.settings[key] = value
        ii.object.change_setting(key, value)
1057298
def set(self, name, value, default=False, imported=False):
        
        if name in self.__dict__:
            self.__dict__[name] = value
            return

        if name not in self.settings and self.prefix:
            prefix_name = '%s_%s' % (self.prefix, name)
            if prefix_name in self.settings:
                return  # don't do anything

        if name in self.settings:
            self.settings[name].set(value, default=default, imported=imported)
        elif not imported:
            self.params[name] = value
883681
def p_set_type(self, p):
        ''''''
        p[0] = ast.SetType(value_type=p[3], annotations=p[5])
740366
def _set_instance_prop(self, attr_name, config_prop, value):
        """"""
        setattr(self, attr_name, value)

        # add to varz if it is not private
        if not config_prop.exclude_from_varz:
            self.varz[attr_name] = value
875945
def instance_write(attr, value)
      setter = :"#{name}_#{attr}="
      responds = instance.respond_to?(setter)
      self.instance_variable_set("@_#{setter.to_s.chop}", value)
      instance.send(setter, value) if responds || attr.to_s == "file_name"
    end