class SetWebHook(metaclass=MetaSingleton):
def __init__(self):
self.bot = TeleBot(settings.TOKEN)
log.info('delete webhook')
self.bot.delete_webhook()
log.info('set webhook')
self.bot.set_webhook(url=f"{settings.DOMAIN}/" f"{settings.TOKEN}")
log.info('setup webhook complete')
def add_bot(message: types.Message):
token = util.extract_arguments(message.text)
tokens[token] = True
new_bot = TeleBot(token)
new_bot.delete_webhook()
new_bot.set_webhook(f"{config.WEBHOOK_HOST}/{config.WEBHOOK_PATH}/{token}")
new_bot.send_message(message.chat.id, "Webhook was set.")
class Bot(object):
def __init__(self):
self._setting = settings
self._bot = TeleBot(self._setting.TOKEN)
self._logger = logger
self._request = requests
def delete_webhook(self):
self._bot.delete_webhook()
def _get_url(self, method):
return "{}/bot{}/{}".format(self._setting.TELEGRAM_URL,
self._setting.TOKEN, method)
def set_webhook(self):
self._request.get(
self._get_url("setWebhook"),
data={"url": f"{self._setting.DOMAIN}/{self._setting.TOKEN}"})
self._request.get(self._get_url("getWebhookInfo"))
json_string = request.get_data().decode('utf-8')
update = types.Update.de_json(json_string)
if token == main_bot.token:
main_bot.process_new_updates([update])
return ''
from_update_bot = TeleBot(token)
register_handlers(from_update_bot)
from_update_bot.process_new_updates([update])
return ''
@main_bot.message_handler(commands=['add_bot'])
def add_bot(message: types.Message):
token = util.extract_arguments(message.text)
tokens[token] = True
new_bot = TeleBot(token)
new_bot.delete_webhook()
new_bot.set_webhook(f"{config.WEBHOOK_HOST}/{config.WEBHOOK_PATH}/{token}")
new_bot.send_message(message.chat.id, "Webhook was set.")
if __name__ == '__main__':
main_bot.delete_webhook()
main_bot.set_webhook(
f"{config.WEBHOOK_HOST}/{config.WEBHOOK_PATH}/{config.MAIN_BOT_TOKEN}")
app.run(host=config.WEBAPP_HOST, port=config.WEBAPP_PORT)
class TelegramBot:
def __init__(self, work_dir: Path, token: str):
self.last_requests = {} # type: Dict[int, List[datetime]]
self.work_dir = work_dir
self.work_dir.mkdir(0o755, parents=True, exist_ok=True)
self.token = token
self.bot = TeleBot(token)
self.bot.add_message_handler({
'function': self.process_link,
'filters': {
'regexp': r'https?:\/\/.+\..+'
}
})
self.bot.add_message_handler({
'function': self.process_message,
'filters': {
'func': lambda _: True
}
})
def process_link(self, message: Message):
user_id = message.from_user.id
if user_id not in self.last_requests:
self.last_requests[user_id] = []
limit_req, limit_min = get_rate_limit()
now = datetime.now(tz=timezone.utc)
last_requests = []
for dt in self.last_requests[user_id]:
time_passed = now - dt
if time_passed.min < timedelta(minutes=limit_min):
last_requests.append(dt)
self.last_requests[user_id] = last_requests
if len(self.last_requests[user_id]) > limit_req:
next_available = self.last_requests[user_id][0] + timedelta(
minutes=limit_min) - now
self.bot.reply_to(
message,
f'Rate limited. Try again in {next_available.seconds} seconds')
return
else:
self.last_requests[user_id].append(now)
msg = self.bot.reply_to(message, "Link detected, processing")
# detach from telebot update thread
def download():
try:
with YoutubeDL({'noplaylist': True}) as ydl:
info = ydl.extract_info(message.text, download=False)
if info['duration'] > 900:
self.bot.edit_message_text('Source too long',
message_id=msg.id,
chat_id=msg.chat.id)
return
with YoutubeDL(get_options_audio(self.work_dir)) as ydl:
ydl.add_post_processor(
UploadHandler(self.bot, msg.id, msg.chat.id))
self.bot.edit_message_text('Downloading',
message_id=msg.id,
chat_id=msg.chat.id)
ydl.download([message.text])
except UnsupportedError:
self.bot.edit_message_text('Unsupported URL',
message_id=msg.id,
chat_id=msg.chat.id)
except DownloadError:
self.bot.edit_message_text('Download error',
message_id=msg.id,
chat_id=msg.chat.id)
except Exception as e:
self.bot.edit_message_text('Unknown error',
message_id=msg.id,
chat_id=msg.chat.id)
logger.error('Unknown error', exc_info=e)
reactor.callInThread(lambda: download())
def process_message(self, message: Message):
self.bot.reply_to(message, 'Send me a link')
def polling(self):
self.bot.delete_webhook()
self.bot.polling(long_polling_timeout=5)
def stop_polling(self):
self.bot.stop_polling()
def set_webhook(self, host: str, port: int):
cert_path, pkey_path = get_or_create_root_cert(self.work_dir, host)
self.bot.remove_webhook()
self.bot.set_webhook(url=f'https://{host}:{port}/{self.token}/',
certificate=open(cert_path, 'r'))
bot = self.bot
class WebhookHandler(Resource):
isLeaf = True
def render_POST(self, request):
request_body_dict = json.load(request.content)
update = Update.de_json(request_body_dict)
reactor.callInThread(lambda: bot.process_new_updates([update]))
return b''
root = ErrorPage(403, 'Forbidden', '')
root.putChild(self.token.encode(), WebhookHandler())
site = Site(root)
sslcontext = ssl.DefaultOpenSSLContextFactory(str(pkey_path),
str(cert_path))
reactor.listenSSL(port, site, sslcontext)
bot.token,
bot.get_file(data.file_id).file_path
)
xml_data = requests.post(
"https://asr.yandex.net/asr_xml?uuid={}&key={}&topic={}&lang={}".format(
md5.new(str(message.from_user.id)).hexdigest(),
YANDEX_KEY,
'queries',
VOICE_LANGUAGE
),
data=requests.get(file_url).content,
headers={"Content-type": 'audio/ogg;codecs=opus'}
).content
e_tree = ElementTree.fromstring(xml_data)
if not int(e_tree.attrib.get('success', '0')):
return bot.reply_to(message, "ERROR: {}".format(xml_data))
text = e_tree[0].text
if ('<censored>' in text) or (not text):
return bot.reply_to(message, "Don't understand you, please repeat.")
return bot.reply_to(message, text)
logger.setLevel(logging.DEBUG)
bot.delete_webhook() # just in case
bot.polling()
