Send text to DCC peer.

        The text will be padded with a newline if it's a DCC CHAT session.
341682
def privmsg(self, text):
        
        if self.dcctype == 'chat':
            text += '\n'
        return self.send_bytes(self.encode(text))
1371939
def send_line(self, line, ending=None):
        
        if ending is None:
            ending = self.LINE_ENDING
        return self.send(line + ending)
780055
def a_send_line(text, ctx):
    """"""
    if hasattr(text, '__iter__'):
        try:
            ctx.ctrl.sendline(text.next())
        except StopIteration:
            ctx.finished = True
    else:
        ctx.ctrl.sendline(text)
    return True
994293
def sendline(self, s=''):
        ''' '''

        n = self.send(s)
        return n + self.send(self.linesep)
961466
def clientCutText(self, message):
        
        self.transport.write(pack("!BxxxI", 6, len(message)) + message)
673217
def send(self_p, dest):
        
        return lib.zmsg_send(byref(zmsg_p.from_param(self_p)), dest)
73221
def send(self, sender: PytgbotApiBot):
        
        return sender.send_document(
            # receiver, self.media, disable_notification=self.disable_notification, reply_to_message_id=reply_id
            document=self.document, chat_id=self.receiver, reply_to_message_id=self.reply_id, thumb=self.thumb, caption=self.caption, parse_mode=self.parse_mode, disable_notification=self.disable_notification, reply_markup=self.reply_markup
        )
776117
async def send_message(self, event=None):
        
        if not self.cl.is_connected():
            return

        # The user needs to configure a chat where the message should be sent.
        #
        # If the chat ID does not exist, it was not valid and the user must
        # configure one; hint them by changing the background to red.
        if not self.chat_id:
            self.chat.configure(bg='red')
            self.chat.focus()
            return

        # Get the message, clear the text field and focus it again
        text = self.message.get().strip()
        self.message.delete(0, tkinter.END)
        self.message.focus()
        if not text:
            return

        # NOTE: This part is optional but supports editing messages
        #       You can remove it if you find it too complicated.
        #
        # Check if the edit matches any text
        m = EDIT.match(text)
        if m:
            find = re.compile(m.group(1).lstrip())
            # Cannot reversed(enumerate(...)), use index
            for i in reversed(range(len(self.sent_text))):
                msg_id, msg_text = self.sent_text[i]
                if find.search(msg_text):
                    # Found text to replace, so replace it and edit
                    new = find.sub(m.group(2), msg_text)
                    self.sent_text[i] = (msg_id, new)
                    await self.cl.edit_message(self.chat_id, msg_id, new)

                    # Notify that a replacement was made
                    self.log.insert(tkinter.END, '(message edited: {} -> {})\n'
                                    .format(msg_text, new))
                    self.log.yview(tkinter.END)
                    return

        # Check if we want to delete the message
        m = DELETE.match(text)
        if m:
            try:
                delete = self.message_ids.pop(-int(m.group(1)))
            except IndexError:
                pass
            else:
                await self.cl.delete_messages(self.chat_id, delete)
                # Notify that a message was deleted
                self.log.insert(tkinter.END, '(message deleted)\n')
                self.log.yview(tkinter.END)
                return

        # Check if we want to reply to some message
        reply_to = None
        m = REPLY.match(text)
        if m:
            text = m.group(2)
            try:
                reply_to = self.message_ids[-int(m.group(1))]
            except IndexError:
                pass

        # NOTE: This part is no longer optional. It sends the message.
        # Send the message text and get back the sent message object
        message = await self.cl.send_message(self.chat_id, text,
                                             reply_to=reply_to)

        # Save the sent message ID and text to allow edits
        self.sent_text.append((message.id, text))

        # Process the sent message as if it were an event
        await self.on_message(message)
679445
def send(self, sender: PytgbotApiBot):
        
        return sender.send_chat_action(
            # receiver, self.media, disable_notification=self.disable_notification, reply_to_message_id=reply_id
            action=self.action, chat_id=self.receiver
        )
264699
def send(self,text):
	""""""
	#print text
	self.s.write(text)
	time.sleep(0.001*len(text))
392589
function sendChat (ev) {
  if (stompClient !== null && stompClient.connected) {
    var p = '/topic/chat'
    stompClient.send(p, {}, JSON.stringify(ev))
  }
}
396170
def send(
        self,
        to=None,
        subject=None,
        contents=None,
        attachments=None,
        cc=None,
        bcc=None,
        preview_only=False,
        headers=None,
        newline_to_break=True,
    ):
        
        self.login()
        recipients, msg_string = self.prepare_send(
            to, subject, contents, attachments, cc, bcc, headers, newline_to_break
        )
        if preview_only:
            return (recipients, msg_string)
        return self._attempt_send(recipients, msg_string)
452326
def send_message(self, chat_id, text, **options):
        
        return self.api_call("sendMessage", chat_id=chat_id, text=text, **options)
845258
public void sendTextMessage(String queueName, String text){
        sendTextMessage(queueName, text, DeliveryMode.NON_PERSISTENT, 4, 0);
    }
1234166
@ObjectiveCName("sendMessageWithPeer:withText:withMarkdownText:withMentions:autoDetect:")
    public void sendMessage(@NotNull Peer peer, @NotNull String text, @Nullable String markDownText,
                            @Nullable ArrayList<Integer> mentions, boolean autoDetect) {
        modules.getMessagesModule().sendMessage(peer, text, markDownText, mentions, autoDetect);
    }
146714
def new_sent(self, text, ID=None, **kwargs):
        '''  '''
        if ID is None:
            ID = next(self.__idgen)
        return self.add_sent(Sentence(text, ID=ID, **kwargs))
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)