Sends data to destination Node
        Args:
            data — serializable object
            destination — <str> '127.0.0.1:8000' or <tuple> (127.0.0.1, 8000)
354638
async def send(self, data, destination):
        
        if isinstance(destination, str):
            host, port = destination.split(':')
            destination = host, int(port)

        await self.requests.put({
            'data': data,
            'destination': destination
        })
63819
def send_data(data = "", end_stream: true)
      max = @connection.remote_settings[:max_frame_size]
      if data.is_a?(IO)
        until data.eof?
          fragment = data.readpartial(max)
          send Frame::Data.new(id, fragment, end_stream: end_stream && data.eof?)
        end
      else
        send Frame::Data.new(id, data, end_stream: end_stream)
      end
      @state = :half_closed_local if end_stream
    end
338220
def send(self, data):
        
        self.future_session.post(url=self.url, data=data)
557713
def data_received(self, data):
        
        self.time_out_handle.cancel()
        self.session.update(data.decode())

        if self.session.state == STATE_STARTING:
            self.transport.write(self.method.message.encode())
            self.time_out_handle = self.loop.call_later(
                TIME_OUT_LIMIT, self.time_out)

        elif self.session.state == STATE_PLAYING:
            self.callback(SIGNAL_PLAYING)

            if self.session.session_timeout != 0:
                interval = self.session.session_timeout - 5
                self.loop.call_later(interval, self.keep_alive)

        else:
            self.stop()
983139
public void send(String data) throws UnsupportedEncodingException {
        log.trace("send message: {}", data);
        // process the incoming string
        if (StringUtils.isNotBlank(data)) {
            send(Packet.build(data.getBytes("UTF8"), MessageType.TEXT));
        } else {
            throw new UnsupportedEncodingException("Cannot send a null string");
        }
    }
1175886
def _send(self, data):
        
        # check link
        if self.__sock is None:
            self.__debug_msg('call _send on close socket')
            return None
        # send
        data_l = len(data)
        try:
            send_l = self.__sock.send(data)
        except socket.error:
            send_l = None
        # handle send error
        if (send_l is None) or (send_l != data_l):
            self.__last_error = const.MB_SEND_ERR
            self.__debug_msg('_send error')
            self.close()
            return None
        else:
            return send_l
1274971
def send(self, data):
        
        answer = None
        try:
            logging.info("Client conntecting to {server}".format(server=self.server_address))
            if six.PY2:
                sock = socket.socket(family=socket.AF_UNIX, type=socket.SOCK_STREAM)
                answer = self.sending(sock, data)
                sock.close()
            else:
                with socket.socket(family=socket.AF_UNIX, type=socket.SOCK_STREAM) as sock:
                    answer = self.sending(sock, data)

        except socket.error as e:
            logging.error("Client cannot conntect to {server}: {msg}".format(server=self.server_address, msg=e.strerror))
            return None

        return answer
370377
def send(scope, data):
    
    conn = scope.get('__connection__')
    for line in data:
        conn.send(line)
    return True
787314
def send(self, data, flags=0):
        
        return self.llc.send(self._tco, data, flags)
814993
def send(self, data):
        

        if self._device:
            if isinstance(data, str):
                data = str.encode(data)

            # Hack to support unicode under Python 2.x
            if sys.version_info < (3,):
                if isinstance(data, unicode):
                    data = bytes(data)

            self._device.write(data)
380885
def send(self, data, opcode=ABNF.OPCODE_TEXT):
        

        if not self.sock or self.sock.send(data, opcode) == 0:
            raise WebSocketConnectionClosedException(
                "Connection is already closed.")
1066321
def send(self, data):
        """"""
        bytes_sent = self._sock.send(extract_bytes(data))
        self.bytes_written += bytes_sent
        return bytes_sent
1012025
def sendMessage(self, data):
      
      opcode = BINARY
      if isinstance(data, unicode):
         opcode = TEXT
      self._sendMessage(False, opcode, data)
693605
def send(self, data):
        
        start = time.time()
        try:
            scgi_resp = ''.join(self.transport.send(_encode_payload(data)))
        finally:
            self.latency = time.time() - start

        resp, self.resp_headers = _parse_response(scgi_resp)
        return resp
1241285
def send_data(self, message):
        '''
            
        '''
        #logger.debug("TX:\n%s", json.dumps(message, indent=2))
        data = json.dumps(message).encode('utf-8') + b'\n'
        self.transport.write(data)
1297860
async def send(self, data):
        
        self.writer.write(data)
        await self.writer.drain()
971733
def send_msg(self, connection, data):
        
        # serialize as JSON
        msg = json.dumps(data)
        # Prefix each message with a 4-byte length (network byte order)
        msg = struct.pack('>I', len(msg)).decode() + msg
        connection.sendall(msg.encode())
        return