See :func:`send_message`
491706
def send_message(self, *args, **kwargs):
        """"""
        return send_message(*args, **self._merge_overrides(**kwargs)).run()
1176635
def send(self, message):
        
        if isinstance(message, dict):
            response = self.client.mail.send.post(request_body=message)
        else:
            response = self.client.mail.send.post(request_body=message.get())
        return response
23685
def send_request(self, message):
        
        payload = message.pack()  # obtain BytesIO instance
        return self.__send_message_recv_reply(payload.getvalue())
281301
def send_text(self, text, **options):
        
        return self.bot.send_message(self.id, text, **options)
492121
async def send_message(self, msg: str, msg_type: str, msg_title: str) -> str:
        
        if not hasattr(Connection.send_message, "cb"):
            self.logger.debug("vcx_connection_send_message: Creating callback")
            Connection.send_message.cb = create_cb(CFUNCTYPE(None, c_uint32, c_uint32, c_char_p))

        c_connection_handle = c_uint32(self.handle)
        c_msg = c_char_p(msg.encode('utf-8'))
        c_msg_type = c_char_p(msg_type.encode('utf-8'))
        c_msg_title = c_char_p(msg_title.encode('utf-8'))

        result = await do_call('vcx_connection_send_message',
                               c_connection_handle,
                               c_msg,
                               c_msg_type,
                               c_msg_title,
                               Connection.send_message.cb)

        self.logger.debug("vcx_connection_send_message completed")
        return result
789214
def send_msg(self, message):
        
        packet = self.driver.send(message)
        self.send_bytes(packet)
78919
def _send_api_message(self, message):
        

        self.slack.chat.post_message(**message)
        self.log.debug("sent api message %r", message)
961792
async def send(self, message_type, message_content, timeout=None):
        
        return await self._sender.send(
            message_type, message_content, timeout=timeout)
747493
def send_message(msg)
      ws.send(msg)
    rescue => exc
      warn exc
      abort exc
    end
144587
def send_messages(messages, opts = {})
      data, _status_code, _headers = send_messages_with_http_info(messages, opts)
      return data
    end
1609
def send_message(url, message):
    '''
    
    '''
    headers = {'Content-Type': 'application/json'}
    data = {'text': message}
    result = __utils__['http.query'](url,
                                     'POST',
                                     data=json.dumps(data),
                                     header_dict=headers,
                                     decode=True,
                                     status=True)

    if result.get('status', 0) == 200:
        return True
    else:
        return False
377377
def send(self, message):
        
        self.socket.sendto(message.SerializeToString(), self.address)
        return None
84436
def send_ClientCutText(self, message):
        
        self.sendMessage(struct.pack("!BxxxI", 6, len(message)))
        self.sendMessage(message)
1012749
def sendCommand(self, **msg):
		
		assert 'type' in msg, 'Message type is required.'

		msg['id'] = self.next_message_id
		self.next_message_id += 1

		if self.next_message_id >= maxint:
			self.next_message_id = 1

		self.sendMessage(json.dumps(msg))
		return msg['id']
207365
def send_message(self, message, sign=True):
		
		if sign:
			message.sign(self.authenticators[self.defauth])
		logger.debug("sending %s", LazyStr(message.dump_oneline))
		self.transport.write(message.as_string())
1320210
def sendMessage(self, chat_id, text,
                    parse_mode=None,
                    disable_web_page_preview=None,
                    disable_notification=None,
                    reply_to_message_id=None,
                    reply_markup=None):
        
        p = _strip(locals())
        return self._api_request('sendMessage', _rectify(p))
397318
def send_message(self, msg):
        

        if self.socket is not None:

            msg.version = self.PROTOCOL_VERSION
            serialized = msg.SerializeToString()
            data = struct.pack(">I", len(serialized)) + serialized

            #print("Sending message: %s" % msg)
            try:
                self.socket.send(data)
            except Exception as e:
                #self.state = "Disconnected"
                pass