Sends a new value to the data bus
        :param channel: Defines the name of the value
        :param value: Defines the value itself
776618
def publish(self, channel: str, value: Any):
        
        self._r.publish(channel, str(value))
921257
def send_put(self, mri, attribute_name, value):
        
        path = attribute_name + ".value"
        typ, value = convert_to_type_tuple_value(serialize_object(value))
        if isinstance(typ, tuple):
            # Structure, make into a Value
            _, typeid, fields = typ
            value = Value(Type(fields, typeid), value)
        try:
            self._ctxt.put(mri, {path: value}, path)
        except RemoteError:
            if attribute_name == "exports":
                # TODO: use a tag instead of a name
                # This will change the structure of the block
                # Wait for reconnect
                self._queues[mri].get(timeout=DEFAULT_TIMEOUT)
            else:
                # Not expected, raise
                raise
1321896
def set(self, new_value):
        
        return self._encode_invoke(atomic_reference_set_codec,
                                   new_value=self._to_data(new_value))
1056147
def send(self, subname, value, timestamp=None):
        '''
        '''
        if timestamp is None:
            ts = int(dt.datetime.now().strftime("%s"))
        else:
            ts = timestamp
        name = self._get_name(self.name, subname)
        self.logger.info('%s: %s %s' % (name, value, ts))
        return statsd.Client._send(self, {name: '%s|r|%s' % (value, ts)})
1174576
def set_channel(self, channel):
        
        if channel != self.current_channel:
            _send_vendor_setup(self.handle, SET_RADIO_CHANNEL, channel, 0, ())
            self.current_channel = channel
53430
void sendHeaderAndCounterNameAndRead(Channel channel) {
      ByteBuf buf = getHeaderAndCounterNameBufferAndRead(channel, 0);
      channel.writeAndFlush(buf);
   }
678299
def _send_int(self,value):
        

        # Coerce to int. This will throw a ValueError if the value can't 
        # actually be converted.
        if type(value) != int:
            new_value = int(value)

            if self.give_warnings:
                w = "Coercing {} into int ({})".format(value,new_value)
                warnings.warn(w,Warning)
                value = new_value

        # Range check
        if value > self.board.int_max or value < self.board.int_min:
            err = "Value {} exceeds the size of the board's int.".format(value)
            raise OverflowError(err)
           
        return struct.pack(self.board.int_type,value)
1202954
def send(self, message, channel_name=None, fail_silently=False,
             options=None):
        # type: (Text, Optional[str], bool, Optional[SendOptions]) -> None
        
        if channel_name is None:
            channels = self.settings["CHANNELS"]
        else:
            try:
                channels = {
                    "__selected__": self.settings["CHANNELS"][channel_name]
                }
            except KeyError:
                raise Exception("channels does not exist %s", channel_name)

        for _, config in channels.items():
            if "_backend" not in config:
                raise ImproperlyConfigured(
                    "Specify the backend class in the channel configuration")

            backend = self._load_backend(config["_backend"])  # type: Any
            config = deepcopy(config)
            del config["_backend"]
            channel = backend(**config)
            channel.send(message, fail_silently=fail_silently, options=options)
432386
public void send(String channel, String message) {
		// CAUSE: Assignment to method parameter
		Pair<Boolean, String> sendValidation = isSendValid(channel, message, null, null);

		//String lMessage = message.replace("\n", "\\n");

		if (sendValidation != null && sendValidation.first) {
			try {
				String messageId = Strings.randomString(8);
				ArrayList<Pair<String, String>> messagesToSend = multiPartMessage(
						message, messageId);
				for (Pair<String, String> messageToSend : messagesToSend) {
					send(channel, messageToSend.second, messageToSend.first,
							sendValidation.second);
				}
			} catch (IOException e) {
				raiseOrtcEvent(EventEnum.OnException, this, e);
			}
		}
	}
4814
def set_value(self, string_value):
        
        value = self.validate_value(string_value)
        self._value[self._channel._selected] = value
700025
def send(self, payload):
        
        payload = self.encode(payload)
        payload = self.sign(payload)
        self.socket.send(payload)
467907
def send(self, value, error=False):
        
        if error:
            resp = [1, self._request_id, value, None]
        else:
            resp = [1, self._request_id, None, value]
        debug('sending response to request %d: %s', self._request_id, resp)
        self._msgpack_stream.send(resp)
307861
def set_current_limit(self, value, channel=1):
        
        cmd = "I%d %f" % (channel, value)
        self.write(cmd)
127599
def send_framer(self, value):
        

        if not isinstance(value, framers.Framer):
            raise ValueError("framer must be an instance of tendril.Framer")

        self._send_framer = value
1219424
def send_to_pipe_channel(channel_name,
                         label,
                         value):
    ''
    async_to_sync(async_send_to_pipe_channel)(channel_name=channel_name,
                                              label=label,
                                              value=value)
277529
def write_byte(self, cmd, value):
        
        self.bus.write_byte_data(self.address, cmd, value)
        self.log.debug(
            "write_byte: Wrote 0x%02X to command register 0x%02X" % (
                value, cmd
            )
        )
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)