Delete this message

        :return: bool
15899
async def delete(self):
        
        return await self.bot.delete_message(self.chat.id, self.message_id)
482922
def delete(self, request, bot_id, id, format=None):
        
        return super(TelegramChatStateDetail, self).delete(request, bot_id, id, format)
1012119
def delete_event(self, client, check):
        
        self._request('DELETE', '/events/{}/{}'.format(client, check))
        return True
584013
def delete_message(self, id, remove):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # REQUIRED - remove
        """Array of message ids to be deleted"""
        data["remove"] = remove

        self.logger.debug("POST /api/v1/conversations/{id}/remove_messages with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/conversations/{id}/remove_messages".format(**path), data=data, params=params, no_data=True)
987544
def delete(self):
        
        fs, path = self._get_fs(create_dir=False)
        if fs.exists(path):
            fs.remove(path)
        if self.clean_dir and fs.exists('.'):
            fs.removedir('.')
        return True
418347
def delete(self):
        

        return self._client._delete(
            self.__class__.base_url(
                self.sys['id']
            )
        )
589238
def inplace_delete_message(
        message_queue: List[SendMessageEvent],
        state_change: Union[ReceiveDelivered, ReceiveProcessed],
) -> None:
    
    for message in list(message_queue):
        message_found = (
            message.message_identifier == state_change.message_identifier and
            message.recipient == state_change.sender
        )
        if message_found:
            message_queue.remove(message)
482623
def done(self, msg_handle):
        """"""
        self.sqs_client.delete_message(
            QueueUrl=self.queue_url,
            ReceiptHandle=msg_handle.handle,
        )
564509
def disconnect(self, message=""):
        
        try:
            del self.connected
        except AttributeError:
            return

        self.quit(message)

        try:
            self.socket.shutdown(socket.SHUT_WR)
            self.socket.close()
        except socket.error:
            pass
        del self.socket
        self._handle_event(Event("disconnect", self.server, "", [message]))
719521
def delete(self):
        '''  '''
        self.down()
        fcntl.ioctl(ifconfig.sockfd, SIOCBRDELBR, self.name)
        return self
921667
function delete_message(req, uuid) {
	debug.assert(uuid).is('uuid');
	delete req.session.client.messages[uuid];
}
1243311
def delete_message(self, message):
        

        message_id = message.object_id if isinstance(message,
                                                     Message) else message

        if message_id is None:
            raise RuntimeError('Provide a valid Message or a message id')

        url = self.build_url(
            self._endpoints.get('message').format(id=message_id))

        response = self.con.delete(url)

        return bool(response)
34396
def delete_message(self, messageid="", folderid="", stackid=""):

        

        if self.standard_grant_type is not "authorization_code":
            raise DeviantartError("Authentication through Authorization Code (Grant Type) is required in order to connect to this endpoint.")

        response = self._req('/messages/delete', post_data={
            'folderid' : folderid,
            'messageid' : messageid,
            'stackid' : stackid
        })

        return response
1351164
def _clear(self):
        """"""
        self._finished = False
        self._measurement = None
        self._message = None
        self._message_body = None
1321176
async def delete(self):
        
        the_tuple = await self.queue.delete(self.tube, self.task_id)

        self.update_from_tuple(the_tuple)

        return bool(self.state == DONE)
895182
def delete(self, rid, raise_on_error=True):
        
        return self.ds.delete(rid, raise_on_error)
312592
def deleteMessages(self, message_ids):
        
        message_ids = require_list(message_ids)
        data = dict()
        for i, message_id in enumerate(message_ids):
            data["message_ids[{}]".format(i)] = message_id
        r = self._post(self.req_url.DELETE_MESSAGES, data)
        return r.ok