def create_async_bot():
if "TG_TOKEN" in os.environ:
api_key = os.environ["TG_TOKEN"]
elif (os.path.isfile("token")):
with open("token") as f:
api_key = f.read().strip()
else:
raise Exception(
"No token supplied, use TG_TOKEN env var or file named `token`")
logger = telebot.logger
configure_system_logging(telebot.logger, config['system'])
try:
requests.get("https://api.telegram.org/bot%s/getMe" % api_key)
except Exception as e:
logger.error("Cannot connect to t.me (%s)" % e)
logger.info("Trying to establish TOR socks5 proxy...")
apihelper.proxy = {'https': 'socks5://127.0.0.1:9150'}
bot = telebot.AsyncTeleBot(api_key)
bot.me = bot.get_me().wait().wait()
return bot
def fetch_singleton():
global async_bot
if async_bot is None:
import os
import telebot
token = os.environ.get('TELEGRAM_KEY')
async_bot = telebot.AsyncTeleBot(token)
return async_bot
def bot_send_msg(self, message):
'''Telegram bot to send messages to the mobile app. When we import as: from telegramBot import bot_send_msg we are importing all the module; the thing that changes is the binding.'''
bot = telebot.AsyncTeleBot(self.token)
# Every function that calls the Telegram API is executed in a separate Thread.
chat_id_group = self.chatId
bot.send_message(chat_id_group, message)
# Delete to save resources:
del bot
def check_new():
print('Start cheking')
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
bot = telebot.AsyncTeleBot(TOKEN, num_threads=3)
proxy = ('proxy.digitalresistance.dog', 443,
'd41d8cd98f00b204e9800998ecf8427e')
api_hash = "e9d6b9e0826b56613da7a625b1ced401"
api_id = 995881
client = TelegramClient('session_name',
api_id,
api_hash,
proxy=proxy,
connection=connection.tcpmtproxy.
ConnectionTcpMTProxyRandomizedIntermediate)
client.connect()
while CHECKER:
print('Checking...')
cursor.execute("select * from users")
for i in cursor.fetchall():
temp = 0
print('Work with', i)
dp = client.get_entity(i[1])
messages = client.get_messages(dp, limit=100, min_id=1)
for j in messages:
temp = max(j.id, temp)
if i[3] in j.text:
bot.send_message(i[1], j.text)
print('???', j.id, i[0], i[1])
cursor.execute(
"update users set Last_id = {} where User_id = '{}' and Channel_id = '{}'"
.format(temp, i[0], i[1]))
conn.commit()
print('!!!')
time.sleep(1)
time.sleep(15)
print('END CHECK')
bot.polling()
conn.close()
client.disconnect()
def armar_mazo(message, bot):
mazo = pd.DataFrame(columns=['carta', 'cantidad'])
bot_async = telebot.AsyncTeleBot("1077001880:AAHmY_d_jkl6fQ3uAX8NqgnZOjz3VSdeGJA")
task = bot_async.get_me()
print("test armado de mazo")
while mazo['cantidad'].sum() < 49:
bot.reply_to(message, "llevas " + str(mazo['cantidad'].sum()) + " cartas... recuerda son 49 (sin contar oro inicial)")
#print de pregunta de cartas
forzar_respuesta = types.ForceReply(selective=False)
bot_async.send_message(message.chat.id, "favor ingresa el nombre de la carta que quieres agregar al mazo: ",reply_markup=forzar_respuesta)
#print de cantidad de cartas
markup = types.ReplyKeyboardMarkup(row_width=1)
itembtn1 = types.KeyboardButton('0')
itembtn2 = types.KeyboardButton('1')
itembtn3 = types.KeyboardButton('2')
itembtn4 = types.KeyboardButton('3')
markup.add(itembtn1, itembtn2, itembtn3, itembtn4)
bot_async.send_message(message.chat.id, "cuantas copias de [insertar nombre de carta] (0 para arrepentirse):", reply_markup=markup)
result = task.wait()
print(result)
pass
print(mazo)
pass
import telebot
from telebot import types
import sqlite3
import time
import asyncio
from random import randint
#bot = telebot.TeleBot('1433503310:AAGCl7p2pBkmdQd_ivuqnHMrfEoFaJwjmWU')
bot = telebot.AsyncTeleBot('1431129673:AAHxSrKHQX4073FpL-r9kwO0jpBl0UkR-ME')
sec = 0
_connection = None
_connection2 = None
def get_connection():
global _connection
_connection = sqlite3.connect('anketa2.db', check_same_thread=False)
return _connection
def get_connection2():
global _connection2
_connection2 = sqlite3.connect("upzazh.db", check_same_thread=False)
return _connection2
def init_db(force: bool = False):
conn = get_connection()
c = conn.cursor()
from telebot.apihelper import ApiException
import texts
from config import BotSettings, DBSettings
from getters import DBGetter, YClientsGetter
reload(sys)
sys.setdefaultencoding('utf-8')
logging.basicConfig(filename='debug.log',
level=logging.INFO,
format="%(asctime)s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S %p")
bot = telebot.TeleBot(BotSettings.TOKEN)
async_bot = telebot.AsyncTeleBot(BotSettings.TOKEN)
types = telebot.types
yclient_api = YClientsGetter()
def check_current_user_password(user_id):
current_password = DBGetter(
DBSettings.HOST).get("SELECT password FROM current_password")[0][0]
try:
logged_in_password = DBGetter(DBSettings.HOST).get(
"SELECT logged_password FROM authorized_users "
"WHERE user_id = %s" % user_id)[0][0]
except IndexError:
logged_in_password = current_password
from aiohttp import web
from aiohttp.abc import Request
from telebot import apihelper
from telebot.types import Message
from torchvision.utils import save_image
from model.nst import NST
from model.srres import SRRes
from tg import db_worker
from tg.utils import WEBHOOK_URL_BASE, WEBHOOK_URL_PATH, WEBHOOK_SSL_CERT, WEBHOOK_SSL_PRIV, TELEGRAM_TOKEN, States, \
WEBHOOK_LISTEN, WEBHOOK_PORT
logger = telebot.logger
telebot.logger.setLevel(logging.INFO)
bot = telebot.AsyncTeleBot(TELEGRAM_TOKEN)
app = web.Application()
apihelper.proxy = {
'https': 'socks5://student:[email protected]:1080'}
async def handle(request: Request):
if request.match_info.get('token') == bot.token:
request_body_dict = await request.json()
update = telebot.types.Update.de_json(request_body_dict)
bot.process_new_updates([update])
return web.Response()
else:
return web.Response(status=403)
# -*- coding: utf-8 -*-
import telebot
import time
#from telepot.loop import MessageLoop
bot = telebot.AsyncTeleBot('507188636:AAErli3ZBtiT0ZB-3Ch4MHOtjIRLOUEiffU')
time.sleep(4)
#bot.getMe()
"""def handle(msg):
bot.sendMessage(msg['chat']['id'].encode('utf8'),msg['text'].encode('utf8'))
MessageLoop(bot, handle).run_as_thread()
print ('I am listening ...')
input()"""
task = bot.get_me() # Execute an API call
# Do some other operations...
a = 0
for a in range(100):
a += 10
result = task.wait()
@bot.message_handler(func=lambda message: True)
def echo_all(message):
bot.reply_to(message, message.text)
print('I am listening ...')
bot.polling()
import telebot
from flask import Flask, request, abort
import logging
import time
WEBHOOK_LISTEN = '0.0.0.0'
API_TOKEN = "638630435:AAHf0P4SXPG5JS_6k9e4cgjN9fLdqPvuVvY"
WEBHOOK_URL_BASE = "https://bot.etenal.me/"
logger = telebot.logger
telebot.logger.setLevel(logging.DEBUG)
botServer = Flask(__name__)
bot = telebot.AsyncTeleBot(API_TOKEN)
req = bot.get_webhook_info()
logging.info("[logging]" + req.url)
@botServer.route("/" + API_TOKEN, methods=['POST'])
def webhook():
bot.process_new_updates(
[telebot.types.Update.de_json(request.stream.read().decode("utf-8"))])
return "!", 200
@botServer.route("/")
def hello():
bot.remove_webhook()
time.sleep(0.1)
bot.set_webhook(url=WEBHOOK_URL_BASE + API_TOKEN)
import time
import telebot
import os
import sys
import drive_api as drive
import vimeo_api as vimeo
import shutil
from slugify import slugify
TOKEN = "1256163582:AAEUbeS_KJ77AXv68zY13beIM03FoG0H7eg"
# bot = telebot.TeleBot(token=TOKEN)
bot = telebot.AsyncTeleBot(token=TOKEN)
default_dir = '16m8_vJaE--4LludRLZNSVVP86j1XrAkT'
current_set_dir = '16m8_vJaE--4LludRLZNSVVP86j1XrAkT'
grp_Chat_id = '-478269081'
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
OUTPUT_DIR = os.path.join(BASE_DIR, "output")
TEMP_DIR = os.path.join(BASE_DIR, "temp")
download_completed_files = []
logs = []
#removing output and temp files
print("\n\n Removing Output directory and Temp directory")
if os.path.exists(OUTPUT_DIR) and os.path.isdir(OUTPUT_DIR):
print('removing output directory')
shutil.rmtree(OUTPUT_DIR)
if os.path.exists(TEMP_DIR) and os.path.isdir(TEMP_DIR):
import requests
import ssl
import logging
from logging.handlers import RotatingFileHandler
import io
from botan import *
import config
from database.tables import Book, Author, FileId, User
from webhook_check import Checker
ELEMENTS_ON_PAGE = 7
BOOKS_CHANGER = 5
bot = telebot.AsyncTeleBot(config.TOKEN)
logger = telebot.logger
if config.DEBUG:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
logging.basicConfig(handlers=[
RotatingFileHandler('../logs/bot.log', mode='a', maxBytes=25 * 1024 * 1024)
])
def normalize(
book: Book, type_: str
# pyTelegramBotAPI
import telebot
import threading
import logging
import traceback
import config # config with bot api token
help_text = """\n/isup - перевірка працездатності бота. Показує де бот зараз працює. \n/purge_nsfw - пересилає в хшп нсфв, а згодом видаляє всі повідомлення від даного до того на яке відповіли.\n/nsfw - пересилає в хшп нсфв, а згодом видаляє повідомлення на яке відповіли.\n"""
logger = telebot.logger
# telebot.logger.setLevel(logging.DEBUG) # Outputs debug messages to console.
bot = telebot.AsyncTeleBot(config.token, parse_mode=None)
def forward_to_nsfw(message):
try:
bot.forward_message(
chat_id=config.hshp_nsfw_id,
from_chat_id=config.hshp_id,
message_id=message.reply_to_message.message_id,
).wait()
bot.delete_message(config.hshp_id, message.reply_to_message.message_id)
bot.delete_message(config.hshp_id, message.message_id)
bot.send_document(
message.chat.id,
"CgACAgIAAxkBAAIBJF-LeX-4Qx5CNA4sM53U9BrxBhjwAAIJCwACvSdYSDdeBw_wiRVuGwQ",
)
"""
Created on Fri Mar 30 20:16:17 2018
@author: HateNoSaiShi
"""
import telebot
import numpy as np
from pixivpy3 import AppPixivAPI
from telebot.types import InputMediaPhoto
import time
import requests
import zipfile
import imageio
bot = telebot.AsyncTeleBot('your token')
white_list = []
black_list = []
#===============================================================================
def PixivDownloadUgoiraZip(pixiv_id, api):
if api.user_id == 0:
api.login("your username", "pswe")
json_result = api.illust_detail(pixiv_id, req_auth=True)
if ('error' in json_result.keys()):
local_url = -1
title = -1
tag = -1
import os
import sys
sys.path.append(os.getcwd())
import telebot
import tlgrm_secrets
from websockets_server.core.settings import HENDRIX_CHANNEL, REDIS_HOST, REDIS_PORT
from websockets_server.core.message_proto_handler import MessageProtoHandler
from utils.log_helper import setup_logger
import redis
import json
bot = telebot.AsyncTeleBot(tlgrm_secrets.token2)
r = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, db=0)
logger = setup_logger(__name__, filename_arg='tlgrm_listen_hendrix')
command = 'send'
@bot.message_handler(content_types=["text"], commands=['send'])
def forward_messages(message):
logger.debug('debug [%s]: [%s]', HENDRIX_CHANNEL, message)
if message.from_user.id == tlgrm_secrets.chat_id:
logger.info('[%s]: [%s]', HENDRIX_CHANNEL, message.text)
try:
suffix = message.text[len(command) + 1:]
ws_id, text = suffix.split('|')[:2]
ws_id = ws_id.strip()
text = 'PPP: ' + text.strip()
import telebot
from emoji import emojize
bot = telebot.AsyncTeleBot('')
dartz = emojize(":dart:", use_aliases=True)
@bot.message_handler(commands=['start'])
def start_message(message):
bot.send_message(message.chat.id, '/start reaction')
@bot.message_handler(content_types=['text'])
def greeting_react(message):
if message.text.lower() == 'hello':
bot.send_message(message.chat.id, 'Hello to you too')
elif message.text.lower() == 'goodbye':
bot.send_message(message.chat.id, 'See ya')
elif message.test.lower() == 'luck':
bot.send_message(emojize(dartz))
bot.polling()
while lines[0].strip()[-3:] != 'YES':
time.sleep(0.2)
lines = self.measure_raw()
equals_pos = lines[1].find('t=')
if equals_pos != -1:
temp_string = lines[1][equals_pos+2:]
self.temperature = float(temp_string) / 1000.0
# temp_f = temp_c * 9.0 / 5.0 + 32.0
# return temp_c, temp_f
def get(self):
self.measure()
return str(round(self.temperature, 2))
t = Termometer()
bot = telebot.AsyncTeleBot("230403950:AAHHFSPqeR4c9EdH0BuvJCFXVin7P0B-8Ck")
@bot.message_handler(commands=['start', 'help'])
def send_welcome(message):
bot.send_message(message.from_user.id, "Welcome to our piTemperature service. Made by Ivan Turianytsia and Jarosław Bajer. Send 'temp' to get current temperature. Send 'times <times> <delay>' to get messages repeatedly.")
@bot.message_handler(func=lambda m: True)
def echo_all(message):
chatid = message.from_user.id
message = message.text.lower()
s = re.search(timesPattern, message)
if message == "temp":
bot.send_message(chatid, "Currently temperature is: " + t.get() + u'\N{DEGREE SIGN}' + "C.")
elif s:
import time
import logging
from telebot import apihelper
from telebot import types
from src import keys
from src import config
from src.parser import Parser
parser = Parser()
logger = telebot.logger
telebot.logger.setLevel(logging.DEBUG)
apihelper.proxy = {'https': keys.TG_PROXY_KEY}
bot = telebot.AsyncTeleBot(keys.TG_API_TOKEN)
@bot.message_handler(commands=["start"])
def handle_start(message):
bot.send_message(message.chat.id, config.START_MSG)
@bot.message_handler(commands=["help"])
def handle_help(message):
bot.send_message(message.chat.id, config.HELP_MSG)
@bot.message_handler(regexp=r"\/i\d+")
def handle_imdb_id(message):
keyboard = types.InlineKeyboardMarkup()
import telebot
from telebot import types
import time as timer
import schedule
from config import token
from pars import Weather, pars_virus, parser_news
from pgSQL import request_answer, user_group
from config import day_th
from multiprocessing.context import Process
import datetime
bot_tb = telebot.AsyncTeleBot(token)
# heroku logs --tail --app polar-atoll-79899
# КОМАНДЫ
# - start
# - registration
# - virus
# - weather
# - news
# СТАРТ
@bot_tb.message_handler(commands=['start'])
def send_welcome(message):
bot_tb.send_sticker(
message.chat.id,
'CAACAgIAAxkBAAIKLV69A4QEgThXNn3yXtg8r5jOy_2YAAJFAAMNttIZjBr_PIJ9KtgZBA'
)
timer.sleep(0.1)
import logging
import random
import re
import sys
import time
import db
from generate import generate
from scheduler import scheduler
from gtts import gTTS
from constants import SMALL, MEDIUM, LARGE, HISTORY, commands, andrew_stickers
import telebot
# add your file info.py with TOKEN and MY_ID variables or simply change it in bot initialization V
from info import TOKEN, MY_ID
bot = telebot.AsyncTeleBot(TOKEN)
def print_msg(msg, date, from_id):
bot.send_message(from_id, msg)
db.delete_remind(date, msg, from_id)
def print_dict(dictionary):
for x in dictionary:
print(x, dictionary[x])
def listener(messages):
if isinstance(messages, collections.Iterable):
for m in messages:
import datetime
import json
import threading
import time
import telebot
from telebot import types
import schedule
import config
import db
from keyboards import *
from my_sched import *
# створення бота
bot = telebot.AsyncTeleBot(config.token)
# фоновый режим для нагадувань
def run_continuously(interval=1):
cease_continuous_run = threading.Event()
# нагадування у потоках
class ScheduleThread(threading.Thread):
@classmethod
def run(cls):
while not cease_continuous_run.is_set():
schedule.run_pending()
time.sleep(interval)
continuous_thread = ScheduleThread()
# coding=utf-8 import telebot import os import time import infounibot.util as util import infounibot.google_cal as cal import infounibot.telecomander as tc from telebot import types # Get the bot token fron the enviromental variables BOT_TOKEN = os.environ["bot_token"] bot = telebot.AsyncTeleBot(BOT_TOKEN) str_welcome = """Benvenuto nel fantastico *UniBot*! 🎉 Ti terrò informato di tutte le lezioni, gli esami e gli avvisi. Se hai bisogno di informazioni, puoi chiedermele quando vuoi con questi comandi: /domani permette di vedere le lezioni di domani. /oggi permette di vedere le lezioni rimaste di oggi. Puoi disabilitare le notifiche in qualunque momento digitando: /stop Grazie e a presto! :) """ markup = types.ReplyKeyboardMarkup(row_width=2)
# -*- coding: utf-8 -*-
import os
import telebot
import cloudconvert
import ujson
import requests
from botan import track
token = os.environ['TELEGRAM_TOKEN']
botan_token = os.environ['APPMETRICA_TOKEN']
cloud_convert_token = os.environ['CLOUD_CONVERT_TOKEN']
me = os.environ['CREATOR_ID']
bot = telebot.AsyncTeleBot(token)
def lang(message):
if (message.from_user.language_code is not None and
'ru' in message.from_user.language_code):
return 'ru'
elif (message.from_user.language_code is not None and
'de' in message.from_user.language_code):
return 'de'
elif (message.from_user.language_code is not None and
'ar' in message.from_user.language_code):
return 'ar'
return 'en'
strings = {'ru': {'start': 'Приветствую, {}!\nЯ Telescopy и я умею преобразовывать квадратные Видео в круглые'
' <i>Видеосообщения</i>, просто отправь мне медиафайл.\n\n'
u'My name is TeleBot,\n'
u'I am a bot that assists these wonderful bot-creating people of this bot library group chat.\n'
u'Also, I am still under development. Please improve my functionality by making a pull request! '
u'Suggestions are also welcome, just drop them in this group chat!',
'wrong_chat':
u'Hi there!\nThanks for trying me out. However, this bot can only be used in the pyTelegramAPI group chat.\n'
u'Join us!\n\n'
u'https://telegram.me/joinchat/067e22c60035523fda8f6025ee87e30b'
}
if "TELEBOT_BOT_TOKEN" not in os.environ or "GROUP_CHAT_ID" not in os.environ:
raise AssertionError(
"Please configure TELEBOT_BOT_TOKEN and GROUP_CHAT_ID as environment variables"
)
bot = telebot.AsyncTeleBot(os.environ["TELEBOT_BOT_TOKEN"])
GROUP_CHAT_ID = int(os.environ["GROUP_CHAT_ID"])
def is_api_group(chat_id):
return chat_id == GROUP_CHAT_ID
@bot.message_handler(func=lambda m: True,
content_types=['new_chat_participant'])
def on_user_joins(message):
if not is_api_group(message.chat.id):
return
name = message.new_chat_participant.first_name
if hasattr(message.new_chat_participant, 'last_name'
import httplib,urllib
import math
import requests
import os
from os.path import join, dirname
from dotenv import load_dotenv
from telebot import types
# from requests_futures.sessions import FuturesSession
import json
dotenv_path = join(dirname(__file__), '.env')
load_dotenv(dotenv_path)
telegram_api_key = os.environ.get("TELEGRAM_API_KEY")
bot = telebot.AsyncTeleBot(telegram_api_key)
def lambda_handler(event, context):
"""docstring for lambda_handler(event, context)"""
data = urllib.urlencode(event)
process_commands(event)
return event
def process_commands(event):
"""docstring for process_commands(event)"""
if event and event['body'] and event['body']['message']:
message = types.Message.de_json(event['body']['message'])
if 'location' in event['body']['message']:
weather = get_weather(message.location)
weatherMessage = get_weather_message(weather)
import time
import telebot
from strings import strings_default as txt
from system import System
from telebot import types
from threads import ThreadsController
from utils import Utils
S = System()
bot = telebot.AsyncTeleBot(S.API_key, num_threads=S.bot_threads)
U = Utils(S, bot, bot.get_me().wait())
T = ThreadsController(U, S, bot)
@bot.callback_query_handler(func=lambda c: U.check_connect(c))
@U.isadmin(True)
def f(c):
mega_id = c.data.split(" ")[1]
S.connect_mega(mega_id, c.message.chat.id)
T.start_thread(mega_id)
bot.answer_callback_query(callback_query_id=c.id,
show_alert=False,
text=txt["mega_connect_success_query"])
bot.edit_message_text(chat_id=c.message.chat.id,
message_id=c.message.message_id,
text=txt["mega_connect_success"].replace(
"%MEGA_NAME%",
S.get_mega(mega_id)['name']),
import requests
import telebot
import hashlib
import logging
import time
import random
import string
from urllib.parse import quote
logger = telebot.logger
telebot.logger.setLevel(logging.DEBUG)
bot = telebot.AsyncTeleBot("671788309:AAGCR4t_PY1xFdWTa-M2_IQP1_z9Wd3MYto")
def curlmd5(src):
m = hashlib.md5(src.encode('UTF-8'))
# 将得到的MD5值所有字符转换成大写
return m.hexdigest().upper()
def get_params(plus_item):
# 请求时间戳（秒级），用于防止请求重放（保证签名5分钟有效）
t = time.time()
time_stamp = str(int(t))
# 请求随机字符串，用于保证签名不可预测
nonce_str = ''.join(random.sample(string.ascii_letters + string.digits,
10))
# 应用标志，这里修改成自己的id和key
app_id = '1107274771'
app_key = 'tTV2E1Gvc3a4iiFK'
params = {
import telebot
from telebot import types
from config import config
from helpers import daysOfWeek, ScheduleType, get_date_keyboard, get_week_type
from scheduleCreator import create_schedule_text
from scheduledb import ScheduleDB, organization_field_length, faculty_field_length
# Статистика
from statistic import track
WEBHOOK_URL_BASE = "https://{}:{}".format(config["WEBHOOK_HOST"],
config["WEBHOOK_PORT"])
WEBHOOK_URL_PATH = "/{}/".format(config["TOKEN"])
bot = telebot.AsyncTeleBot(config["TOKEN"])
app = flask.Flask(__name__)
logger = telebot.logger
telebot.logger.setLevel(logging.INFO)
commands = { # Описание команд используещееся в команде "help"
'start': 'Стартовое сообщение и предложение зарегистрироваться',
'help': 'Информация о боте и список доступных команд',
'registration': 'Выбор ВУЗа, факультета и группы для вывода расписания',
'send_report <сообщение>': 'Отправить информацию об ошибке или что то ещё',
'auto_posting_on <ЧЧ:ММ>':
'Включение и выбор времени для автоматической отправки расписания в диалог',
'auto_posting_off': 'Выключение автоматической отправки расписания'
}
import datetime
import telebot
# NEWS WEBSITES
mal = 'https://myanimelist.net/news'
kgp = 'https://kg-portal.ru/news/anime/'
ann = 'https://animenewsnetwork.com/news'
cyr = 'https://crunchyroll.com/news'
okm = 'https://otakumode.com/news'
shm = 'https://shikimori.one/forum/news'
# BOT TOKEN AND ENABLING
tk = 'PUT YOUR BOT TOKEN HERE'
bot = telebot.AsyncTeleBot(tk)
# USERS LIST AND USERS CLASS
users = {}
class User:
def __init__(self, chatId):
self.chatId = chatId
self.mal = ""
self.kgp = ""
self.ann = ""
self.cyr = ""
self.okm = ""
self.shm = ""
import os
from datetime import datetime
import json
import re
# Скачанные библиотеки
import flask
from flask import request, redirect
import telebot
from telebot import types
# Файлы проекта
import constants
from DataBase import dbAdapter
from Statistics import statsAdapter
from Logger import logAdapter
bot = telebot.AsyncTeleBot(constants.BOT_TOKEN)
bot.threaded = False
app = flask.Flask(__name__)
def choose_word():
"""
Выбирает слово, которое будет оправленно пользователю
:return: возвращает tuple, где первый элемент - dict, содержащий информацию о слове, второй - markup
"""
word = dbAdapter.get_random_word()
markup = types.ReplyKeyboardMarkup(resize_keyboard=True)
words_order = [i for i in range(len(word["variants"]))]
random.shuffle(words_order)
