def send_message(
self,
peer: Peer or AsyncTask,
text: str,
interactive_media_groups: List[InteractiveMediaGroup] = None,
uid: int = None) -> UUID:
"""Send text message to peer.
Message can contain interactive media groups (buttons, selects etc.).
:param peer: Peer or AsyncTask (in which located User or Group)
:param text: message text (not null)
:param interactive_media_groups: groups of interactive media components (buttons etc.)
:param uid: send message only for user by id
:return: UUID (message id)
"""
peer = get_peer(peer)
if text == '' or text is None:
raise AttributeError('Text message must contain some text.')
out_peer = self.manager.get_out_peer(peer)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if interactive_media_groups is not None:
for g in interactive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
request = messaging_pb2.RequestSendMessage(
peer=out_peer,
deduplication_id=random.randint(0, 100000000),
message=msg,
is_only_for_user=uid)
return self.__send_message(request)
def update_message(
self,
message: Message or AsyncTask,
text: str,
interactive_media_groups: List[InteractiveMediaGroup] = None
) -> None:
"""Update text message or interactive media (buttons, selects etc.).
:param message: Message or AsyncTask (in which located Message)
:param text: message text (not null)
:param interactive_media_groups: groups of interactive media components (buttons etc.)
:return: None
"""
try:
if isinstance(message, AsyncTask):
message = message.wait()[0]
if not isinstance(message, Message):
raise AttributeError()
except Exception as e:
raise AttributeError(
"if message is AsyncTask class, result must be list of Message"
)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if interactive_media_groups is not None:
for g in interactive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
self.__update(message, msg)
def reply(
self,
peer: Peer or AsyncTask,
mids: List[UUID or AsyncTask],
text: str = None,
interactive_media_groups: List[InteractiveMediaGroup] = None
) -> UUID:
"""Reply messages to peer. Message can contain interactive media groups (buttons, selects etc.).
:param peer: Peer or AsyncTask (in which located User or Group)
:param mids: list of UUIDs
:param text: message text
:param interactive_media_groups: groups of interactive media components (buttons etc.)
:return: UUID (message id)
"""
peer = get_peer(peer)
mids = get_uuids(mids)
if text is None:
text = ''
out_peer = self.manager.get_out_peer(peer)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if interactive_media_groups is not None:
for g in interactive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
request = messaging_pb2.RequestSendMessage(
peer=out_peer,
deduplication_id=random.randint(0, 100000000),
message=msg,
reply=messaging_pb2.ReferencedMessages(mids=mids))
return self.__send_message(request)
def send_image(self, peer: Peer or AsyncTask, file: str) -> UUID or None:
"""Send image as image (not as file) to peer.
:param peer: Peer or AsyncTask (in which located User or Group)
:param file: path to image file
:return: UUID (message id)
"""
peer = get_peer(peer)
if isinstance(file, str) and not is_image(file):
raise IOError('File is not an image.')
location = self.internal.uploading.upload_file(file).wait()
if location is None:
return None
location = location.to_api()
out_peer = self.manager.get_out_peer(peer)
msg = messaging_pb2.MessageContent()
msg.documentMessage.CopyFrom(content.get_image_content(file, location))
request = messaging_pb2.RequestSendMessage(
peer=out_peer,
deduplication_id=random.randint(0, 100000000),
message=msg)
return self.__send_message(request)
def send_file_by_location(self, peer, file, location):
msg = messaging_pb2.MessageContent()
msg.documentMessage.CopyFrom(self.get_document_content(file, location))
return self.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=peer,
deduplication_id=random.randint(
0, 100000000),
message=msg))
def delete(self, message: Message or AsyncTask) -> None:
"""Delete message.
:param message: Message or AsyncTask (in which located Message)
:return: None
"""
msg = messaging_pb2.MessageContent(
deletedMessage=messaging_pb2.DeletedMessage(
is_local=wrappers_pb2.BoolValue(value=False)))
self.__update(message, msg)
def __get_out_peer_and_message(self, peer: peers_pb2.Peer, text: str,
interactive_media_groups: List[InteractiveMediaGroup]) \
-> Tuple[peers_pb2.OutPeer, messaging_pb2.MessageContent]:
out_peer = self.manager.get_out_peer(peer)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if interactive_media_groups is not None:
for g in interactive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
return out_peer, msg
def send_message(self, peer, text, iteractive_media_groups=None):
outpeer = self.manager.get_outpeer(peer)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if iteractive_media_groups is not None:
for g in iteractive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
return self.internal.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=outpeer,
rid=int(time.time()),
message=msg)).mid
def send_file(self, user, target_outpeer, file):
"""Send file to current peer.
:param peer: receiver's peer
:param file: path to file
:return: value of SendMessage response object
"""
location = self.upload_file(user, file)
msg = messaging_pb2.MessageContent()
msg.documentMessage.CopyFrom(
content.get_document_content(file, location))
return user.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=target_outpeer,
deduplication_id=random.randint(
0, 100000000),
message=msg))
def send_file(self, peer, file):
"""Send file to current peer.
:param peer: receiver's peer
:param file: path to file
:return: mid value of SendMessage response object
"""
location = self.internal.uploading.upload_file(file)
outpeer = self.manager.get_outpeer(peer)
msg = messaging_pb2.MessageContent()
msg.documentMessage.CopyFrom(
content.get_document_content(file, location))
return self.internal.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=outpeer,
rid=int(time.time()),
message=msg)).mid
def send_media(self, peer: Peer or AsyncTask,
medias: List[MessageMedia]) -> UUID:
"""Send media to peer.
:param peer: Peer or AsyncTask (in which located User or Group)
:param medias: medias (list of MessageMedias)
:return: UUID (message id)
"""
peer = get_peer(peer)
medias = self.__get_medias(medias)
out_peer = self.manager.get_out_peer(peer)
text_message = messaging_pb2.TextMessage()
for media in medias:
text_message.media.append(media)
msg = messaging_pb2.MessageContent(textMessage=text_message)
request = messaging_pb2.RequestSendMessage(
peer=out_peer,
deduplication_id=random.randint(0, 100000000),
message=msg)
return self.__send_message(request)
def send_image(self, peer, file):
"""Send image as image (not as file) to current peer.
:param peer: receiver's peer
:param file: path to image file
:return: mid value of SendMessage response object
"""
if imghdr.what(file) not in ['gif', 'jpeg', 'png', 'bmp']:
raise IOError('File is not an image.')
location = self.internal.uploading.upload_file(file)
outpeer = self.manager.get_outpeer(peer)
msg = messaging_pb2.MessageContent()
msg.documentMessage.CopyFrom(content.get_image_content(file, location))
return self.internal.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=outpeer,
rid=int(time.time()),
message=msg)).mid
def send_message(self, peer, text, interactive_media_groups=None):
"""Send text message to current peer. Message can contain interactive media groups (buttons, selects etc.).
:param peer: receiver's peer
:param text: message text (not null)
:param interactive_media_groups: groups of interactive media components (buttons etc.)
:return: mid value of SendMessage response object
"""
if text == '' or text is None:
raise AttributeError('Text message must contain some text.')
outpeer = self.manager.get_outpeer(peer)
msg = messaging_pb2.MessageContent()
msg.textMessage.text = text
if interactive_media_groups is not None:
for g in interactive_media_groups:
media = msg.textMessage.media.add()
g.render(media)
return self.internal.messaging.SendMessage(
messaging_pb2.RequestSendMessage(peer=outpeer,
rid=int(time.time()),
message=msg)).mid
class TestMessaging(unittest.TestCase):
bot.internal.messaging = Messaging()
bot.internal.updates = Updates()
bot.internal.media_and_files = MediaAndFiles()
test_file = "../dialog_bot_sdk/examples/files/example.png"
peer = Peer(1, PEERTYPE_PRIVATE)
message = Message(UUID(1, 1), UUID(0, 0), peer, None, [], [], 0, 0)
outpeer = peers_pb2.OutPeer(type=PEERTYPE_PRIVATE, id=0, access_hash=0)
mid = definitions_pb2.UUIDValue(msb=0, lsb=0)
msg_content = messaging_pb2.MessageContent()
msg_content.textMessage.text = "Hello"
interactive_media = [
InteractiveMediaGroup([
InteractiveMedia("1", InteractiveMediaButton("Yes", "Да")),
InteractiveMedia("2", InteractiveMediaButton("No", "Нет")),
])
]
# msg_content_with_group = copy.deepcopy(msg_content)
# group[0].render(msg_content_with_group.textMessage.media.add())
# doc_msg = messaging_pb2.DocumentMessage(
# file_id=0,
# access_hash=0,
# file_size=60,
# name=""
# )
def test_send_message(self):
send = bot.messaging.send_message(self.peer, "text",
self.interactive_media)
self.assertTrue(isinstance(send, AsyncTask))
self.assertTrue(isinstance(send.wait(), UUID))
def test_update_message(self):
update = bot.messaging.update_message(self.message, "text",
self.interactive_media)
self.assertTrue(isinstance(update, AsyncTask))
self.assertIsNone(update.wait())
def test_delete_message(self):
delete = bot.messaging.delete(self.message)
self.assertTrue(isinstance(delete, AsyncTask))
self.assertIsNone(delete.wait())
def test_get_messages_by_id(self):
msg = bot.messaging.get_messages_by_id([UUID(1, 1)])
self.assertTrue(isinstance(msg, AsyncTask))
self.assertTrue(isinstance(msg.wait()[0], Message))
def test_messages_read(self):
read = bot.messaging.messages_read(self.peer, 0)
self.assertTrue(isinstance(read, AsyncTask))
self.assertIsNone(read.wait())
@patch('requests.put')
def test_send_file(self, put):
put.return_value = Put(200)
send = bot.messaging.send_file(self.peer, self.test_file)
self.assertTrue(isinstance(send, AsyncTask))
self.assertTrue(isinstance(send.wait(), UUID))
put.return_value = Put(400)
send = bot.messaging.send_file(self.peer, self.test_file)
self.assertTrue(isinstance(send, AsyncTask))
self.assertIsNone(send.wait())
@patch('requests.put')
def test_send_media(self, put):
put.return_value = Put(200)
image = bot.internal.uploading.upload_file(self.test_file).wait()
media = MessageMedia(image=ImageMedia(ImageLocation(image)))
send = bot.messaging.send_media(self.peer, [media])
self.assertTrue(isinstance(send, AsyncTask))
self.assertTrue(isinstance(send.wait(), UUID))
@patch('requests.put')
def test_send_image(self, put):
put.return_value = Put(200)
send = bot.messaging.send_image(self.peer, self.test_file)
self.assertTrue(isinstance(send, AsyncTask))
self.assertTrue(isinstance(send.wait(), UUID))
put.return_value = Put(400)
send = bot.messaging.send_image(self.peer, self.test_file)
self.assertTrue(isinstance(send, AsyncTask))
self.assertIsNone(send.wait())
def test_reply(self):
reply = bot.messaging.reply(self.peer, [UUID(1, 1)], None,
self.interactive_media)
self.assertTrue(isinstance(reply, AsyncTask))
self.assertTrue(isinstance(reply.wait(), UUID))
def test_forward(self):
forward = bot.messaging.forward(self.peer, [UUID(1, 1)], None,
self.interactive_media)
self.assertTrue(isinstance(forward, AsyncTask))
self.assertTrue(isinstance(forward.wait(), UUID))
def test_load_message_history(self):
history = bot.messaging.load_message_history(
self.peer, 0, ListLoadMode.LISTLOADMODE_BACKWARD, 1)
self.assertTrue(isinstance(history, AsyncTask))
self.assertTrue(isinstance(history.wait()[0], Message))
