Replies to the message (as a reply). Shorthand for
        `telethon.client.messages.MessageMethods.send_message`
        with both ``entity`` and ``reply_to`` already set.
967066
async def reply(self, *args, **kwargs):
        
        kwargs['reply_to'] = self.id
        return await self._client.send_message(
            await self.get_input_chat(), *args, **kwargs)
755489
def reply(self, text, in_thread=None):
        
        if in_thread is None:
            in_thread = 'thread_ts' in self.body

        if in_thread:
            self.send(text, thread_ts=self.thread_ts)
        else:
            text = self.gen_reply(text)
            self.send(text)
662879
def _send_command(self, method_name, data=None):
        
        try:
            response = self.lib.post(self._tpl_url % {'token': self.auth_token, 'method': method_name}, data=data)
            json = response.json()

            if not json['ok']:
                raise TelegramMessengerException(json['description'])

            return json['result']

        except self.lib.exceptions.RequestException as e:
            raise TelegramMessengerException(e)
384771
def _send(self, message):
        
        result = self._talk.put(message)
        if not result:
            self._logger.error('Failed to send "%s"' % message)
        return result
23685
def send_request(self, message):
        
        payload = message.pack()  # obtain BytesIO instance
        return self.__send_message_recv_reply(payload.getvalue())
248272
def replySocket(self, port, host='*'):
        '''
        
        '''
        try:
            socket = self._context.socket(zmq.REP)
            socket.bind(self.tcpAddress(host, port))
        except Exception as e:
            newMsg= str("%s %s:%d" % (str(e), host, port))
            raise (type(e))(newMsg)
        return socket
455348
def send_conversation_message(from, to, params={})
      ConversationMessage.new(conversation_request(
        :post,
        'send', 
        params.merge({
          :from => from,
          :to => to,
        })))
    end
335137
def send(self, msg):
        
        with self._pub_lock:
            self.publish.send_string(msg)
        return self
688870
def send_document(self, document: str, reply: Message=None, on_success: callable=None,
                      reply_markup: botapi.ReplyMarkup=None):
        

        self.twx.send_document(peer=self, document=document, reply_to_message_id=reply, on_success=on_success,
                               reply_markup=reply_markup)
704953
def sendmail(self, to, message):
        

        # If we were passed a bare string as the To: address, convert it to
        # a single element list.
        if isinstance(to, str):
            to = [ to, ]

        # Send one email with the appropriate recipient list.
        server = self._smtp_server()
        server.sendmail(self.get_rfc2822_address(), to, message)
        server.quit()
84436
def send_ClientCutText(self, message):
        
        self.sendMessage(struct.pack("!BxxxI", 6, len(message)))
        self.sendMessage(message)
437480
function sendMessage(client, to, message, callback) {
	resolveID(client, to, function(channelID) {
		client._req('post', Endpoints.MESSAGES(channelID), message, function(err, res) {
			handleResCB("Unable to send messages", err, res, callback);
		});
	});
}
300447
async def send_message(self, *args, **kwargs):
        
        message = await self._client.send_message(
            self._input_chat, *args, **kwargs)

        self._outgoing.add(message.id)
        self._last_outgoing = message.id
        return message
655307
def sendMessage(self, to, message, extra={}):
        
        to = to if isinstance(to, list) else [to]
        to = [str(num) for num in to]
        data = {'to': to, 'text': message}
        data = self.merge(data, {'callback': 7, 'mo': 1}, extra)

        content = self.parseRest(self.request('rest/message', data, {}, 'POST'));
        result = []

        # Messages in the REST response will contain errors on the message entry itself.
        for entry in content['message']:
            entry = self.merge({'apiMessageId': False, 'to': data['to'][0], 'error': False, 'errorCode': False}, entry)
            result.append({
                'id': entry['apiMessageId'].encode('utf-8'),
                'destination': entry['to'].encode('utf-8'),
                'error': entry['error']['description'].encode('utf-8') if entry['error'] != False else False,
                'errorCode': entry['error']['code'].encode('utf-8') if entry['error'] != False else False
            });

        return result
585395
function replyTo ( channel ){
    return function ( txt ){
      b9.send({ type:'message', channel:channel, text:txt });
    };
  }
178970
def message(from, to, body, callback_url=nil)
      callback = callback_url ? {:StatusCallback => callback_url} : {}
      Twilio.post("/SMS/Messages", :body => {:From => from, :To => to, :Body => body}.merge(callback))
    end
633301
def deliver(self, message, to):
        
        # Send the message via local SMTP server.
        s = smtplib.SMTP(self.host, self.port)
        s.ehlo()
        s.starttls()
        s.login(self.user, self.pw)
        # sendmail function takes 3 arguments: sender's address, recipient's address
        # and message to send - here it is sent as one string.
        s.sendmail(message['From'], to, message.as_string())
        s.quit()
        return