Set sensor with a given received value, matches :meth:`katcp.Sensor.set`
424006
def set(self, timestamp, status, value):
        """"""
        received_timestamp = self._manager.time()
        reading = KATCPSensorReading(received_timestamp, timestamp, status, value)
        self._reading = reading
        self.call_listeners(reading)
407704
def set(self, key, value):
        
        value_encoded = encode(value, self.get_change_trigger(key))

        if key in self.data and self.data[key] == value_encoded:
            return self

        self.data[key] = value_encoded
        return self.trigger_changed(key)
1314039
function (set, receive) {
	var values = setValues.call(set);
	var next;
	do {
		next = values.next();
	} while (!next.done && receive(next.value));
}
497616
def setnx(self, key, value):
        """"""
        return self.set(key, value, nx=True)
1321896
def set(self, new_value):
        
        return self._encode_invoke(atomic_reference_set_codec,
                                   new_value=self._to_data(new_value))
674308
def set(self, key, value):
        
        return self.__setitem__(key, value, force=True)
1067185
def set(self, addr, values):
        
        addr -= self._start_addr
        end = addr + len(values)
        if not 0 <= addr <= end <= len(self._data):
            addr += self._start_addr
            raise IndexError("Invalid address range [{:#06x} - {:#06x}]"
                             .format(addr, addr + len(values)))
        self._data[addr:end] = values
786392
def request_set_sensor_inactive(self, req, sensor_name):
        """"""
        sensor = self.get_sensor(sensor_name)
        ts, status, value = sensor.read()
        sensor.set_value(value, sensor.INACTIVE, ts)
        return('ok',)
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()})
214322
def set(self, name, value, ex=None, px=None, nx=False, xx=False):
        
        self.client.set(name=name, value=value, px=px, nx=nx, xx=xx)
1032808
def set_values(self, values, *, index=0):
        
        assert len(self.raw) == 1, \
            'Only devices with 1 light supported'

        return Command('put', self._device.path, {
            ATTR_LIGHT_CONTROL: [
                values
            ]
        })
113991
def set(self, value, parse=False):
        
        self.value = self.parse(value) if parse else value
1070610
def set(self, value):
        """"""
        value = min(self.max, max(self.min, value))
        self._value = value
        start_new_thread(self.func, (self.get(),))
310703
def set_value(self, value: datetime):
        
        assert isinstance(value, datetime)

        self.value = value
628449
def set_value(self, value):
        """"""
        self._value = value

        for proxy in self.get_proxies():
            proxy.handler_block(self._changed_handlers[proxy])
            proxy.set_value(self._value)
            proxy.handler_unblock(self._changed_handlers[proxy])
            pass

        self.emit('changed')
        return
236542
def set(self, key, value, key_length=0):
        
        if key_length < 1:
            key_length = len(key)
        if self.k:
            self._update(key, value)
        return self.set_method(self, key, key_length, value)
86070
def sensorupdate(self, data):
        
        if not isinstance(data, dict):
            raise TypeError('Expected a dict')
        msg = 'sensor-update '
        for key in data.keys():
            msg += '"%s" "%s" ' % (self._escape(str(key)), 
                                    self._escape(str(data[key])))
        self._send(msg)