Send raw text to the distant end.
554748
def send(self, text):
        
        if text:
            self.send_buffer += text.replace('\n', '\r\n')
            self.send_pending = True
901334
async def _send_text(self,
                         request: Request,
                         stack: Stack,
                         parse_mode: Optional[Text] = None):
        

        parts = []
        chat_id = request.message.get_chat_id()

        for layer in stack.layers:
            if isinstance(layer, (lyr.Text, lyr.RawText, lyr.Markdown)):
                text = await render(layer.text, request)
                parts.append(text)

        for part in parts[:-1]:
            await self.call(
                'sendMessage',
                text=part,
                chat_id=chat_id,
            )

        msg = {
            'text': parts[-1],
            'chat_id': chat_id,
        }

        if parse_mode is not None:
            msg['parse_mode'] = parse_mode

        await set_reply_markup(msg, request, stack)

        if stack.has_layer(Reply):
            reply = stack.get_layer(Reply)
            if reply.message:
                msg['reply_to_message_id'] = reply.message['message_id']

        if stack.has_layer(Update):
            update = stack.get_layer(Update)

            if update.inline_message_id:
                msg['inline_message_id'] = update.inline_message_id
                del msg['chat_id']
            else:
                msg['message_id'] = update.message_id

            await self.call(
                'editMessageText',
                {'Bad Request: message is not modified'},
                **msg
            )
        else:
            await self.call('sendMessage', **msg)
520469
def _send(self, message):
        """"""
        charset='UTF-8'
        params = {
          'action' : 'sendsms',
          'user' : self.get_username(),
          'password' : self.get_password(),
          'from' : message.from_phone,
          'to' : ",".join(message.to),
          'text' : message.body,
          'clientcharset' : charset,
          'detectcharset' : 1,
          'maxsplit': int(math.ceil(len(message.body) / 160))
        }
        
        req = urllib2.Request(SMSGLOBAL_API_URL_SENDSMS, urllib.urlencode(params))
        result_page = urllib2.urlopen(req).read()
        results = self._parse_response(result_page)
        
        if results is None:
            if not self.fail_silently:
                raise Exception("Error determining response: [" + result_page + "]")
            return False
        
        code, sendqmsgid, msgid = results
        
        if code != '0':
            if not self.fail_silently:
                raise Exception("Error sending sms: [%s], extracted results(code, sendqmsgid, msgid): [%s]" % (result_page, results))
            return False
        else:
            logger.info('SENT to: %s; sender: %s; code: %s; sendqmsgid: %s; msgid: %s; message: %s' % (
                message.to,
                message.from_phone,
                code, 
                sendqmsgid, 
                msgid,
                message.body
            ))
            return True
210632
function clickSendMessage() {
    var currentText = $('#message_text').val().trim();

    if (!currentText.length) {
        return;
    }

    $('#message_text').val('').focus();

    sendMessage(currentText, null);
}
127783
def send(self, message):
        """"""
        log.debug("sending '{0}' message".format(message.type))
        send_miu = self.socket.getsockopt(nfc.llcp.SO_SNDMIU)
        try:
            data = str(message)
        except nfc.llcp.EncodeError as e:
            log.error("message encoding failed: {0}".format(e))
        else:
            return self._send(data, send_miu)
65237
def send(self, sock, msg):
    """"""
    data = pickle.dumps(msg)
    buf = struct.pack('>I', len(data)) + data
    sock.sendall(buf)
193699
def sendline(sock, msg, confidential=False):
    """"""
    log.debug('<- %r', ('<snip>' if confidential else msg))
    sock.sendall(msg + b'\n')
161046
def text(max_length = 2048)
      buffer = "\0" * max_length
      length = if is_control?
        SendMessageA(handle, WM_GETTEXT, buffer.length, buffer)
      else
        GetWindowText(handle, buffer, buffer.length)
      end

      length == 0 ? '' : buffer[0..length - 1]
    end
731284
def raw(self, query, settings=None, stream=False):
        '''
        
        '''
        query = self._substitute(query, None)
        return self._send(query, settings=settings, stream=stream).text
564756
async def send(self, message: Union[str, bytes],
                   binary: bool=False,
                   compress: Optional[int]=None) -> None:
        """"""
        if isinstance(message, str):
            message = message.encode('utf-8')
        if binary:
            await self._send_frame(message, WSMsgType.BINARY, compress)
        else:
            await self._send_frame(message, WSMsgType.TEXT, compress)
1192833
def raw_command(self, lun, netfn, raw_bytes):
        
        return self.interface.send_and_receive_raw(self.target, lun, netfn,
                                                   raw_bytes)
1265760
def send_single_text(self, sender, receiver, content):
        
        return self.send_text(sender, 'single', receiver, content)
128488
def set_text(self, text, length=-1):
        

        Gtk.TextBuffer.set_text(self, text, length)
123486
async def send(self, clear=True, parse_mode=()):
        
        await self._client.send_message(
            self._peer, self.text, reply_to=self.reply_to_msg_id,
            link_preview=self.link_preview, parse_mode=parse_mode,
            clear_draft=clear
        )
1260820
def recv_raw(self, x=MTU):
        """"""  # noqa: E501
        pkt, sa_ll = self.ins.recvfrom(x)
        if self.outs and sa_ll[2] == socket.PACKET_OUTGOING:
            return None, None, None
        ts = get_last_packet_timestamp(self.ins)
        return self.LL, pkt, ts
1036085
def reach_process_text():
    """"""
    if request.method == 'OPTIONS':
        return {}
    response = request.body.read().decode('utf-8')
    body = json.loads(response)
    text = body.get('text')
    offline = True if body.get('offline') else False
    rp = reach.process_text(text, offline=offline)
    return _stmts_from_proc(rp)
42898
def sendDAT(self):
        """"""
        finished = False
        blocknumber = self.context.next_block
        # Test hook
        if DELAY_BLOCK and DELAY_BLOCK == blocknumber:
            import time
            log.debug("Deliberately delaying 10 seconds...")
            time.sleep(10)
        dat = None
        blksize = self.context.getBlocksize()
        buffer = self.context.fileobj.read(blksize)
        log.debug("Read %d bytes into buffer", len(buffer))
        if len(buffer) < blksize:
            log.info("Reached EOF on file %s"
                % self.context.file_to_transfer)
            finished = True
        dat = TftpPacketDAT()
        dat.data = buffer
        dat.blocknumber = blocknumber
        self.context.metrics.bytes += len(dat.data)
        log.debug("Sending DAT packet %d", dat.blocknumber)
        self.context.sock.sendto(dat.encode().buffer,
                                 (self.context.host, self.context.tidport))
        if self.context.packethook:
            self.context.packethook(dat)
        self.context.last_pkt = dat
        return finished