"""This object represents a Telegram Bot.

def __init__(self,

token,

base_url=None):

self.token = token

if base_url is None:

self.base_url = 'https://api.telegram.org/bot%s' % self.token

else:

self.base_url = base_url + self.token

self.base_file_url = 'https://api.telegram.org/file/bot%s' % self.token

self.bot = None

self.logger = logging.getLogger(__name__)

def info(func):

"""

@functools.wraps(func)

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

"""

if not self.bot:

self.getMe()

result = func(self, *args, **kwargs)

return result

return decorator

@property

@info

def id(self):

"""int: """

return self.bot.id

@property

@info

def first_name(self):

"""str: """

return self.bot.first_name

@property

@info

def last_name(self):

"""str: """

return self.bot.last_name

@property

@info

def username(self):

"""str: """

return self.bot.username

@property

def name(self):

"""str: """

return '@%s' % self.username

def log(func):

"""

logger = logging.getLogger(func.__module__)

@functools.wraps(func)

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

"""

logger.debug('Entering: %s', func.__name__)

result = func(self, *args, **kwargs)

logger.debug(result)

logger.debug('Exiting: %s', func.__name__)

return result

return decorator

def message(func):

"""

@functools.wraps(func)

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

"""

url, data = func(self, *args, **kwargs)

if not data.get('chat_id'):

raise TelegramError('Invalid chat_id')

if kwargs.get('reply_to_message_id'):

reply_to_message_id = kwargs.get('reply_to_message_id')

data['reply_to_message_id'] = reply_to_message_id

if kwargs.get('reply_markup'):

reply_markup = kwargs.get('reply_markup')

if isinstance(reply_markup, ReplyMarkup):

data['reply_markup'] = reply_markup.to_json()

else:

data['reply_markup'] = reply_markup

result = request.post(url, data)

if result is True:

return result

return Message.de_json(result)

return decorator

@log

def getMe(self):

"""A simple method for testing your bot's auth token.

url = '%s/getMe' % self.base_url

result = request.get(url)

self.bot = User.de_json(result)

return self.bot

@log

@message

def sendMessage(self,

chat_id,

text,

parse_mode=None,

disable_web_page_preview=None,

**kwargs):

"""Use this method to send text messages.

url = '%s/sendMessage' % self.base_url

data = {'chat_id': chat_id,

'text': text}

if parse_mode:

data['parse_mode'] = parse_mode

if disable_web_page_preview:

data['disable_web_page_preview'] = disable_web_page_preview

return url, data

@log

@message

def forwardMessage(self,

chat_id,

from_chat_id,

message_id):

"""Use this method to forward messages of any kind.

url = '%s/forwardMessage' % self.base_url

data = {}

if chat_id:

data['chat_id'] = chat_id

if from_chat_id:

data['from_chat_id'] = from_chat_id

if message_id:

data['message_id'] = message_id

return url, data

@log

@message

def sendPhoto(self,

chat_id,

photo,

caption=None,

**kwargs):

"""Use this method to send photos.

url = '%s/sendPhoto' % self.base_url

data = {'chat_id': chat_id,

'photo': photo}

if caption:

data['caption'] = caption

return url, data

@log

@message

def sendAudio(self,

chat_id,

audio,

duration=None,

performer=None,

title=None,

**kwargs):

"""Use this method to send audio files, if you want Telegram clients to

url = '%s/sendAudio' % self.base_url

data = {'chat_id': chat_id,

'audio': audio}

if duration:

data['duration'] = duration

if performer:

data['performer'] = performer

if title:

data['title'] = title

return url, data

@log

@message

def sendDocument(self,

chat_id,

document,

filename=None,

**kwargs):

"""Use this method to send general files.

url = '%s/sendDocument' % self.base_url

data = {'chat_id': chat_id,

'document': document}

if filename:

data['filename'] = filename

return url, data

@log

@message

def sendSticker(self,

chat_id,

sticker,

**kwargs):

"""Use this method to send .webp stickers.

url = '%s/sendSticker' % self.base_url

data = {'chat_id': chat_id,

'sticker': sticker}

return url, data

@log

@message

def sendVideo(self,

chat_id,

video,

duration=None,

caption=None,

**kwargs):

"""Use this method to send video files, Telegram clients support mp4

url = '%s/sendVideo' % self.base_url

data = {'chat_id': chat_id,

'video': video}

if duration:

data['duration'] = duration

if caption:

data['caption'] = caption

return url, data

@log

@message

def sendVoice(self,

chat_id,

voice,

duration=None,

**kwargs):

"""Use this method to send audio files, if you want Telegram clients to

url = '%s/sendVoice' % self.base_url

data = {'chat_id': chat_id,

'voice': voice}

if duration:

data['duration'] = duration

return url, data

@log

@message

def sendLocation(self,

chat_id,

latitude,

longitude,

**kwargs):

"""Use this method to send point on the map.

url = '%s/sendLocation' % self.base_url

data = {'chat_id': chat_id,

'latitude': latitude,

'longitude': longitude}

return url, data

@log

@message

def sendChatAction(self,

chat_id,

action):

"""Use this method when you need to tell the user that something is

url = '%s/sendChatAction' % self.base_url

data = {'chat_id': chat_id,

'action': action}

return url, data

@log

def getUserProfilePhotos(self,

user_id,

offset=None,

limit=100):

"""Use this method to get a list of profile pictures for a user.

url = '%s/getUserProfilePhotos' % self.base_url

data = {'user_id': user_id}

if offset:

data['offset'] = offset

if limit:

data['limit'] = limit

result = request.post(url, data)

return UserProfilePhotos.de_json(result)

@log

def getFile(self,

file_id):

"""Use this method to get basic info about a file and prepare it for

url = '%s/getFile' % self.base_url

data = {'file_id': file_id}

result = request.post(url, data)

if result.get('file_path'):

result['file_path'] = '%s/%s' % (self.base_file_url,

result['file_path'])

return File.de_json(result)

@log

def getUpdates(self,

offset=None,

limit=100,

timeout=0,

network_delay=2.):

"""Use this method to receive incoming updates using long polling.

url = '%s/getUpdates' % self.base_url

data = {}

if offset:

data['offset'] = offset

if limit:

data['limit'] = limit

if timeout:

data['timeout'] = timeout

result = request.post(url, data, network_delay=network_delay)

if result:

self.logger.info(

'Getting updates: %s', [u['update_id'] for u in result])

else:

self.logger.info('No new updates found.')

return [Update.de_json(x) for x in result]

@log

def setWebhook(self,

webhook_url=None,

certificate=None):

"""Use this method to specify a url and receive incoming updates via an

url = '%s/setWebhook' % self.base_url

data = {}

if webhook_url:

data['url'] = webhook_url

if certificate:

data['certificate'] = certificate

result = request.post(url, data)

return result

@staticmethod

def de_json(data):

pass

def to_dict(self):

"""

data = {'id': self.id,

'username': self.username,

'first_name': self.username}

if self.last_name:

data['last_name'] = self.last_name

return data

def __reduce__(self):

return (self.__class__, (self.token,