"""This object represents a Telegram Message.

def __init__(self,

message_id,

from_user,

date,

chat,

forward_from=None,

forward_from_chat=None,

forward_date=None,

reply_to_message=None,

edit_date=None,

text=None,

entities=None,

audio=None,

document=None,

photo=None,

sticker=None,

video=None,

voice=None,

caption=None,

contact=None,

location=None,

venue=None,

new_chat_member=None,

new_chat_members=None,

left_chat_member=None,

new_chat_title=None,

new_chat_photo=None,

delete_chat_photo=False,

group_chat_created=False,

supergroup_chat_created=False,

migrate_to_chat_id=None,

migrate_from_chat_id=None,

channel_chat_created=False,

pinned_message=None,

forward_from_message_id=None,

invoice=None,

successful_payment=None,

bot=None,

video_note=None,

game=None,

**kwargs):

# Required

self.message_id = int(message_id)

self.from_user = from_user

self.date = date

self.chat = chat

# Optionals

self.forward_from = forward_from

self.forward_from_chat = forward_from_chat

self.forward_date = forward_date

self.reply_to_message = reply_to_message

self.edit_date = edit_date

self.text = text

self.entities = entities or list()

self.audio = audio

self.game = game

self.document = document

self.photo = photo

self.sticker = sticker

self.video = video

self.voice = voice

self.video_note = video_note

self.caption = caption

self.contact = contact

self.location = location

self.venue = venue

self._new_chat_member = new_chat_member

self.new_chat_members = new_chat_members

self.left_chat_member = left_chat_member

self.new_chat_title = new_chat_title

self.new_chat_photo = new_chat_photo

self.delete_chat_photo = bool(delete_chat_photo)

self.group_chat_created = bool(group_chat_created)

self.supergroup_chat_created = bool(supergroup_chat_created)

self.migrate_to_chat_id = migrate_to_chat_id

self.migrate_from_chat_id = migrate_from_chat_id

self.channel_chat_created = bool(channel_chat_created)

self.pinned_message = pinned_message

self.forward_from_message_id = forward_from_message_id

self.invoice = invoice

self.successful_payment = successful_payment

self.bot = bot

self._id_attrs = (self.message_id,)

@property

def chat_id(self):

"""int: Short for :attr:`Message.chat.id`"""

return self.chat.id

@staticmethod

def de_json(data, bot):

"""

if not data:

return None

data = super(Message, Message).de_json(data, bot)

data['from_user'] = User.de_json(data.get('from'), bot)

data['date'] = from_timestamp(data['date'])

data['chat'] = Chat.de_json(data.get('chat'), bot)

data['entities'] = MessageEntity.de_list(data.get('entities'), bot)

data['forward_from'] = User.de_json(data.get('forward_from'), bot)

data['forward_from_chat'] = Chat.de_json(data.get('forward_from_chat'), bot)

data['forward_date'] = from_timestamp(data.get('forward_date'))

data['reply_to_message'] = Message.de_json(data.get('reply_to_message'), bot)

data['edit_date'] = from_timestamp(data.get('edit_date'))

data['audio'] = Audio.de_json(data.get('audio'), bot)

data['document'] = Document.de_json(data.get('document'), bot)

data['game'] = Game.de_json(data.get('game'), bot)

data['photo'] = PhotoSize.de_list(data.get('photo'), bot)

data['sticker'] = Sticker.de_json(data.get('sticker'), bot)

data['video'] = Video.de_json(data.get('video'), bot)

data['voice'] = Voice.de_json(data.get('voice'), bot)

data['video_note'] = VideoNote.de_json(data.get('video_note'), bot)

data['contact'] = Contact.de_json(data.get('contact'), bot)

data['location'] = Location.de_json(data.get('location'), bot)

data['venue'] = Venue.de_json(data.get('venue'), bot)

data['new_chat_member'] = User.de_json(data.get('new_chat_member'), bot)

data['new_chat_members'] = User.de_list(data.get('new_chat_members'), bot)

data['left_chat_member'] = User.de_json(data.get('left_chat_member'), bot)

data['new_chat_photo'] = PhotoSize.de_list(data.get('new_chat_photo'), bot)

data['pinned_message'] = Message.de_json(data.get('pinned_message'), bot)

data['invoice'] = Invoice.de_json(data.get('invoice'), bot)

data['successful_payment'] = SuccessfulPayment.de_json(data.get('successful_payment'), bot)

return Message(bot=bot, **data)

def __getitem__(self, item):

if item in self.__dict__.keys():

return self.__dict__[item]

elif item == 'chat_id':

return self.chat.id

def to_dict(self):

"""

data = super(Message, self).to_dict()

# Required

data['from'] = data.pop('from_user', None)

data['date'] = to_timestamp(self.date)

# Optionals

if self.forward_date:

data['forward_date'] = to_timestamp(self.forward_date)

if self.edit_date:

data['edit_date'] = to_timestamp(self.edit_date)

if self.photo:

data['photo'] = [p.to_dict() for p in self.photo]

if self.entities:

data['entities'] = [e.to_dict() for e in self.entities]

if self.new_chat_photo:

data['new_chat_photo'] = [p.to_dict() for p in self.new_chat_photo]

data['new_chat_member'] = data.pop('_new_chat_member', None)

if self.new_chat_members:

data['new_chat_members'] = [u.to_dict() for u in self.new_chat_members]

return data

def _quote(self, kwargs):

"""Modify kwargs for replying with or without quoting"""

if 'reply_to_message_id' in kwargs:

if 'quote' in kwargs:

del kwargs['quote']

elif 'quote' in kwargs:

if kwargs['quote']:

kwargs['reply_to_message_id'] = self.message_id

del kwargs['quote']

else:

if self.chat.type != Chat.PRIVATE:

kwargs['reply_to_message_id'] = self.message_id

def reply_text(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_message(self.chat_id, *args, **kwargs)

def reply_photo(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_photo(self.chat_id, *args, **kwargs)

def reply_audio(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_audio(self.chat_id, *args, **kwargs)

def reply_document(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_document(self.chat_id, *args, **kwargs)

def reply_sticker(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_sticker(self.chat_id, *args, **kwargs)

def reply_video(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_video(self.chat_id, *args, **kwargs)

def reply_video_note(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_video_note(self.chat_id, *args, **kwargs)

def reply_voice(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_voice(self.chat_id, *args, **kwargs)

def reply_location(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_location(self.chat_id, *args, **kwargs)

def reply_venue(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_venue(self.chat_id, *args, **kwargs)

def reply_contact(self, *args, **kwargs):

"""

self._quote(kwargs)

return self.bot.send_contact(self.chat_id, *args, **kwargs)

def forward(self, chat_id, disable_notification=False):

"""Shortcut for

return self.bot.forward_message(

chat_id=chat_id,

from_chat_id=self.chat_id,

disable_notification=disable_notification,

message_id=self.message_id)

def edit_text(self, *args, **kwargs):

"""

return self.bot.edit_message_text(

chat_id=self.chat_id, message_id=self.message_id, *args, **kwargs)

def edit_caption(self, *args, **kwargs):

"""

return self.bot.edit_message_caption(

chat_id=self.chat_id, message_id=self.message_id, *args, **kwargs)

def edit_reply_markup(self, *args, **kwargs):

"""

return self.bot.edit_message_reply_markup(

chat_id=self.chat_id, message_id=self.message_id, *args, **kwargs)

def delete(self, *args, **kwargs):

"""

return self.bot.delete_message(

chat_id=self.chat_id, message_id=self.message_id, *args, **kwargs)

def parse_entity(self, entity):

"""

# Is it a narrow build, if so we don't need to convert

if sys.maxunicode == 0xffff:

return self.text[entity.offset:entity.offset + entity.length]

else:

entity_text = self.text.encode('utf-16-le')

entity_text = entity_text[entity.offset * 2:(entity.offset + entity.length) * 2]

return entity_text.decode('utf-16-le')

def parse_entities(self, types=None):

"""

if types is None:

types = MessageEntity.ALL_TYPES

return {

entity: self.parse_entity(entity)

for entity in self.entities if entity.type in types

}

@property

def text_html(self):

"""

entities = self.parse_entities()

message_text = self.text

if not sys.maxunicode == 0xffff:

message_text = message_text.encode('utf-16-le')

markdown_text = ''

last_offset = 0

for entity, text in sorted(entities.items(), key=(lambda item: item[0].offset)):

text = escape_html(text)

if entity.type == MessageEntity.TEXT_LINK:

insert = '<a href="{}">{}</a>'.format(entity.url, text)

elif entity.type == MessageEntity.URL:

insert = '<a href="{0}">{0}</a>'.format(text)

elif entity.type == MessageEntity.BOLD:

insert = '<b>' + text + '</b>'

elif entity.type == MessageEntity.ITALIC:

insert = '<i>' + text + '</i>'

elif entity.type == MessageEntity.CODE:

insert = '<code>' + text + '</code>'

elif entity.type == MessageEntity.PRE:

insert = '<pre>' + text + '</pre>'

else:

insert = text

if sys.maxunicode == 0xffff:

markdown_text += escape_html(message_text[last_offset:entity.offset]) + insert

else:

markdown_text += escape_html(message_text[last_offset * 2:entity.offset * 2]

.decode('utf-16-le')) + insert

last_offset = entity.offset + entity.length

if sys.maxunicode == 0xffff:

markdown_text += escape_html(message_text[last_offset:])

else:

markdown_text += escape_html(message_text[last_offset * 2:].decode('utf-16-le'))

return markdown_text

@property

def text_markdown(self):

"""

entities = self.parse_entities()

message_text = self.text

if not sys.maxunicode == 0xffff:

message_text = message_text.encode('utf-16-le')

markdown_text = ''

last_offset = 0

for entity, text in sorted(entities.items(), key=(lambda item: item[0].offset)):

text = escape_markdown(text)

if entity.type == MessageEntity.TEXT_LINK:

insert = '[{}]({})'.format(text, entity.url)

elif entity.type == MessageEntity.URL:

insert = '[{0}]({0})'.format(text)

elif entity.type == MessageEntity.BOLD:

insert = '*' + text + '*'

elif entity.type == MessageEntity.ITALIC:

insert = '_' + text + '_'

elif entity.type == MessageEntity.CODE:

insert = '`' + text + '`'

elif entity.type == MessageEntity.PRE:

insert = '```' + text + '```'

else:

insert = text

if sys.maxunicode == 0xffff:

markdown_text += escape_markdown(message_text[last_offset:entity.offset]) + insert

else:

markdown_text += escape_markdown(message_text[last_offset * 2:entity.offset * 2]

.decode('utf-16-le')) + insert

last_offset = entity.offset + entity.length

if sys.maxunicode == 0xffff:

markdown_text += escape_markdown(message_text[last_offset:])

else:

markdown_text += escape_markdown(message_text[last_offset * 2:].decode('utf-16-le'))

return markdown_text

@property

def new_chat_member(self):

warn_deprecate_obj('new_chat_member', 'new_chat_members')