def main():
print('Start')
req = Request(connect_timeout=0.5, )
bot = Bot(
request=req,
token='855883347:AAH9ikaPCy1R2GoqbhmCGilhFmqLczcUFAY',
base_url='https://telegg.ru/orig/bot',
)
updater = Updater(
bot=bot,
use_context=True,
)
print(updater.bot.get_me())
updater.dispatcher.add_handler(
MessageHandler(filters=Filters.all, callback=message_handler))
updater.start_polling()
updater.idle()
print('Finish')
def main():
print('Starting')
# my request, per 0.5 sec
req = Request(connect_timeout=0.5, )
# bot for requests
bot = Bot(
request=req,
token=config.TOKEN,
# base_url="https://telegg.ru/orig/bot", # proxy
)
# updater get new data from telegram
updater = Updater(
bot=bot,
use_context=True,
)
print('I am your bot:', updater.bot.get_me())
# only for /hello
handlerHello = CommandHandler(command='hello', callback=welcome_handler)
updater.dispatcher.add_handler(handlerHello)
# only for /help
handlerHelp = CommandHandler(command='help', callback=help_handler)
updater.dispatcher.add_handler(handlerHelp)
# only for /start
handlerStart = CommandHandler(command='start', callback=start_handler)
updater.dispatcher.add_handler(handlerStart)
# only for f*ck
handlerFck = MessageHandler(filters=Filters.text & Filters.regex('f**k'),
callback=f_handler)
updater.dispatcher.add_handler(handlerFck)
# only for weather
handlerFck = MessageHandler(filters=Filters.text
& Filters.regex('weather'),
callback=weather_handler)
updater.dispatcher.add_handler(handlerFck)
# download information from telegram
updater.start_polling()
# run bot in loop
updater.idle()
print('Finish')
def handle(self, *args, **options):
request = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot = Bot(
request=request,
token=settings.TOKEN,
base_url=getattr(settings, 'PROXY_URL', None),
)
updater = Updater(
bot=bot,
use_context=True,
)
print(bot.get_me())
message_handler = MessageHandler(Filters.text, create_db)
updater.dispatcher.add_handler(message_handler)
updater.start_polling()
updater.idle()
def handle(self, *args, **kwargs):
# correct connection
request = Request(connect_timeout=0.5, read_timeout=1.0)
bot = Bot(
request=request,
token=settings.TOKEN,
base_url=settings.PROXY_URL,
)
# print(bot.get_me())
# handler install
updater = Updater(
bot=bot,
use_context=True,
)
message_handler = MessageHandler(Filters.text, do_echo)
updater.dispatcher.add_handler(message_handler)
# non stop runner
updater.start_polling()
updater.idle()
def price_check():
if (proxy_url is None):
bot = Bot(api_key)
else:
proxy = Request(proxy_url = proxy_url, urllib3_proxy_kwargs = {'username': proxy_user, 'password': proxy_pass })
bot = Bot(token=api_key, request = proxy)
price = mysql_select_price()
# check if higher
users_high = mysql_select_price_high()
#price_high_bitgrail = max(int(price[1][0]), int(price[1][4]))
price_high_mercatox = max(int(price[0][0]), int(price[0][4]))
price_high_kucoin = max(int(price[3][0]), int(price[3][4]))
price_high_binance = max(int(price[5][0]), int(price[5][4]))
for user in users_high:
#if ((price_high_bitgrail >= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 1))):
# prices_above_below(bot, user[0], price_high_bitgrail, "BitGrail.com", 1)
if ((price_high_mercatox >= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 2))):
prices_above_below(bot, user[0], price_high_mercatox, "Mercatox.com", 1)
elif ((price_high_kucoin >= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 3))):
prices_above_below(bot, user[0], price_high_kucoin, "Kucoin.com", 1)
elif ((price_high_binance >= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 4))):
prices_above_below(bot, user[0], price_high_binance, "Binance.com", 1)
# check if lower
users_low = mysql_select_price_low()
#price_low_bitgrail = min(int(price[1][0]), int(price[1][3]))
price_low_mercatox = min(int(price[0][0]), int(price[0][3]))
price_low_kucoin = min(int(price[3][0]), int(price[3][3]))
price_low_binance = min(int(price[5][0]), int(price[5][3]))
for user in users_low:
#if ((price_low_bitgrail <= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 1))):
# prices_above_below(bot, user[0], price_low_bitgrail, "BitGrail.com", 0)
if ((price_low_mercatox <= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 2))):
prices_above_below(bot, user[0], price_low_mercatox, "Mercatox.com", 0)
elif ((price_low_kucoin <= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 3))):
prices_above_below(bot, user[0], price_low_kucoin, "Kucoin.com", 0)
elif ((price_low_binance <= int(user[1])) and ((int(user[2]) == 0) or (int(user[2]) == 4))):
prices_above_below(bot, user[0], price_low_binance, "Binance.com", 0)
def worker(inherit, **kwargs):
global logger
# app = command.app(inherit.logger, inherit.config)
app = command.app(inherit)
token = kwargs['token']
# for test purposes limit global throughput to 30 messages per 2 sec
q = messagequeue.MessageQueue(all_burst_limit=2, all_time_limit_ms=3000)
request = Request(con_pool_size=14)
testbot = MQBot(token, request=request, mqueue=q)
updater = Updater(bot=testbot, workers=10)
# admin
admins = list()
for x in inherit.config.get('admins', 'list').split(','):
admins.append(int(x))
# Get the dispatcher to register handlers
dp = updater.dispatcher
logger = inherit.logger
logger = logging.getLogger(__name__)
logger.info(f'{testbot.get_me().first_name} is listening...')
dp.add_handler(CommandHandler('update', app.update_dict,
Filters.user(user_id=admins)),
group=1)
dp.add_handler(InlineQueryHandler(app.dong), group=1)
# non command
dp.add_error_handler(app.error)
# updater.start_polling(clean=False)
# updater.idle()
try:
updater.start_polling(clean=False)
updater.idle()
except KeyboardInterrupt:
updater.stop()
updater.is_idle = False
def __init__(self, token=None, base_url=None, workers=4, bot=None, request_kwargs=None):
if (token is None) and (bot is None):
raise ValueError('`token` or `bot` must be passed')
if (token is not None) and (bot is not None):
raise ValueError('`token` and `bot` are mutually exclusive')
if bot is not None:
self.bot = bot
else:
# we need a connection pool the size of:
# * for each of the workers
# * 1 for Dispatcher
# * 1 for polling Updater (even if webhook is used, we can spare a connection)
# * 1 for JobQueue
# * 1 for main thread
if request_kwargs is None:
request_kwargs = {}
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = workers + 4
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request)
self.update_queue = Queue()
self.job_queue = JobQueue(self.bot)
self.__exception_event = Event()
self.dispatcher = Dispatcher(
self.bot,
self.update_queue,
job_queue=self.job_queue,
workers=workers,
exception_event=self.__exception_event)
self.last_update_id = 0
self.logger = logging.getLogger(__name__)
self.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
""":type: list[Thread]"""
def __init__(self):
"""
This object is to check the frozen queue in the DB, and if any update, process it.
"""
super().__init__()
self._futures = None
self._logger = get_logger(
logger_name="FROZEN_LISTENER",
file_name=config.FROZEN_LISTENER_LOG_PATH,
)
self.queue_collection = get_collection(
connection_uri=config.MONGO_CONNECTION_URI,
db_name=config.QUEUE_ALERT_DB,
collection_name=config.QUEUE_COLLECTION,
)
self.frozen_collection = get_collection(
connection_uri=config.MONGO_CONNECTION_URI,
db_name=config.FROZEN_ALERT_DB,
collection_name=config.FROZEN_ALERT_COLLECTION,
)
self.active_collection = get_collection(
connection_uri=config.MONGO_CONNECTION_URI,
db_name=config.ACTIVE_ALERTS_DB,
collection_name=config.ACTIVE_ALERTS_COLLECTION,
)
self.thread_pool = ThreadPoolExecutor(
max_workers=config.FROZEN_LISTENER_THREAD_POOL_SIZE)
req = Request(connect_timeout=5, )
self.bot = Bot(
token=config.TG_TOKEN,
request=req,
)
self.api_client = APIClient(
logger_name="FROZEN_API_CLIENT",
logger_path=config.FROZEN_API_CLIENT_LOG_PATH,
)
self._logger.info("FrozenListener created")
def main():
print('Start')
req = Request(connect_timeout=0.5, )
bot = Bot(
request=req,
token='929657905:AAE49SUBEZmO_mLi29QM-LqEybelJ5ClPhc',
base_url='https://telegg.ru/orig/bot',
)
updater = Updater(
bot=bot,
use_context=True,
)
print(updater.bot.get_me())
updater.dispatcher.add_handler(
MessageHandler(filters=Filters.all, callback=message_handler))
updater.start_polling()
updater.idle()
print('Finish')
def main():
print('Start')
req = Request(
connect_timeout=0.5,
)
bot = Bot(
request=req,
token='858860556:AAEgnFVwQdP0ECSZGxAAMHpTlFWtUG40Ce4',
base_url='https://telegg.ru/orig/bot',
)
updater = Updater(
bot=bot,
use_context=True,
)
print(updater.bot.get_me())
updater.dispatcher.add_handler(MessageHandler(filters=Filters.all, callback=message_handler))
updater.start_polling()
updater.idle()
print('Finish')
def __init__(self, token: str, state_file: str = "./state.dat"):
req = Request(con_pool_size=8)
bot = MessageDelayBot(token=token, request=req)
bot.run_tasks_manager()
self._updater = Updater(
bot=bot,
use_context=True,
)
kv = redis.Redis(
host=REDIS_HOST,
port=REDIS_PORT,
db=REDIS_DB,
)
self._view = PokerBotViewer(bot=bot)
self._model = PokerBotModel(
view=self._view,
bot=bot,
kv=kv,
)
self._controller = PokerBotCotroller(self._model, self._updater)
def handle(self, *args, **options):
request = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot = Bot(
request=request,
token=settings.BOT_TOKEN,
)
print(bot.getMe())
# 2 -- обработчики
updater = Updater(
bot=bot,
use_context=True,
)
message_handler = MessageHandler(Filters.text, do_echo)
updater.dispatcher.add_handler(message_handler)
# 3 -- запустить бесконечную обработку входящих сообщений
updater.start_polling()
updater.idle()
def __init__(self, config='setup.cfg'):
super().__init__()
self.logger = logging.getLogger('bot')
# Read bot config from file
try:
config_from_file = ConfigParser()
config_from_file.read(config)
self._token = config_from_file.get('telegram', 'token')
self._url = config_from_file.get('telegram', 'url')
if not self._url.endswith('/'):
self._url = self._url + '/'
self._port = config_from_file.getint('telegram', 'port')
except (NoSectionError, NoOptionError) as e:
self.logger.exception('Wrong config')
raise ImproperlyConfigured('Wrong config') from e
# Initialize DB
initialize_db()
request = Request(con_pool_size=8, connect_timeout=20., read_timeout=20.)
self.updater = Updater(bot=MQBot(self._token, request=request))
def __init__(
self,
token: str,
state_file=".state.dat"
):
req = Request(con_pool_size=8)
bot = Bot(token=token, request=req)
kv = redis.Redis(
host=REDIS_HOST,
port=REDIS_PORT,
)
self._updater = Updater(
bot=bot,
use_context=True,
)
self._view = ReminderBotViewer(bot=bot)
self._model = ReminderBotModel(
view=self._view,
bot=bot,
kv=kv
)
self._controller = ReminderBotCotroller(self._model, self._updater)
def ready(self):
# Singleton utility
# We load them here to avoid multiple instantiation across other
# modules, that would take too much time.
from django.conf import settings
from qteam_bot.models import AcurBot
from telegram import Bot
self.botid_to_botobj = {}
# intent_model
bots = AcurBot.objects.all()
for bot in bots:
request = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot_obj = Bot(
request=request,
token=bot.token,
base_url=getattr(settings, 'PROXY_URL', None),
)
self.botid_to_botobj[bot.telegram_bot_id] = bot_obj
def __init__(self, token, workers=4, request_kwargs=None):
counter_rlock = threading.RLock()
self.counter_lock = threading.Condition(counter_rlock)
self.message_queue = multiprocessing.Queue()
self.waiting_chats_message_queue = multiprocessing.Queue()
self.dispatcher = None
self.processing = True
self.num_workers = workers
self.messages_per_second = 0
self.messages_per_chat = {}
self.messages_per_chat_per_minute = {}
self.spam_chats_count = {}
self.second_reset_queue = multiprocessing.Queue()
self.minute_reset_queue = multiprocessing.Queue()
self.workers = []
self.resending_workers = []
self.group_workers = []
if request_kwargs is None:
request_kwargs = {}
con_pool_size = workers + 4
if 'con_pool_size' not in request_kwargs:
request_kwargs['con_pool_size'] = con_pool_size
self._request = Request(**request_kwargs)
super(AsyncBot, self).__init__(token=token, request=self._request)
self.types_to_methods = {0: self.send_message, 1: self.send_video, 2: self.send_audio, 3: self.send_photo,
4: self.send_document, 5: self.send_sticker, 6: self.send_voice, 7: self.sendVideoNote}
self.methods_ty_types = {v: k for k, v in list(self.types_to_methods.items())}
self.types_to_original_methods = {
0: super(AsyncBot, self).send_message, 1: super(AsyncBot, self).send_video,
2: super(AsyncBot, self).send_audio, 3: super(AsyncBot, self).send_photo,
4: super(AsyncBot, self).send_document, 5: super(AsyncBot, self).send_sticker,
6: super(AsyncBot, self).send_voice, 7: super(AsyncBot, self).sendVideoNote,
8: super(AsyncBot, self).answerCallbackQuery
}
def handle(self, *args, **options):
request = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot = Bot(
# request=request,
token='902495020:AAH42KO9_MpcBLa0XHRjB4wg1yOesgsEf7Y', # production
# token='1086886864:AAH4iytj0B5KvpdFcf-N6akkuuAEOym7iG4', # development
)
updater = Updater(bot=bot, use_context=True)
print(bot.get_me())
start_handler = CommandHandler("start", do_start)
# Message handlers
text_message_handler = MessageHandler(Filters.text, take_text)
img_message_handler = MessageHandler(Filters.photo, get_media)
video_message_handler = MessageHandler(Filters.video, get_media)
location_message_handler = MessageHandler(Filters.location,
get_location)
document_message_handler = MessageHandler(Filters.document,
get_document)
audio_handler = MessageHandler(
Filters.audio,
get_audio,
)
updater.dispatcher.add_handler(start_handler)
updater.dispatcher.add_handler(text_message_handler)
updater.dispatcher.add_handler(img_message_handler)
updater.dispatcher.add_handler(location_message_handler)
updater.dispatcher.add_handler(video_message_handler)
updater.dispatcher.add_handler(document_message_handler)
updater.dispatcher.add_handler(audio_handler)
updater.start_polling()
updater.idle()
def handle(self, *args, **options):
request = Request(
connect_timeout=0.5,
read_timeout=0.5,
)
bot = Bot(request=request, token=settings.TOKEN)
print(bot.get_me())
updater = Updater(
bot=bot,
use_context=True,
)
start_handler = CommandHandler("start", start)
updater.dispatcher.add_handler(start_handler)
catalog_handler = MessageHandler(Filters.text("Catalog"), catalog)
updater.dispatcher.add_handler(catalog_handler)
show_prod_handler = CallbackQueryHandler(show_prod, pattern='^[0-9]$')
updater.dispatcher.add_handler(show_prod_handler)
add_product_handler = CallbackQueryHandler(add_product,
pattern="add_to_cart")
updater.dispatcher.add_handler(add_product_handler)
cart_handler = MessageHandler(Filters.text("Cart"), cart)
updater.dispatcher.add_handler(cart_handler)
del_cart_handler = CallbackQueryHandler(del_cart, pattern="del_cart")
updater.dispatcher.add_handler(del_cart_handler)
checkout_handler = CallbackQueryHandler(checkout, pattern="proceed_to")
updater.dispatcher.add_handler(checkout_handler)
updater.start_polling()
updater.idle()
def handle(self, *args, **options):
# 1 -- правильное подключение
request = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot = Bot(
request=request,
token=settings.TOKEN,
base_url=getattr(settings, 'PROXY_URL', None),
)
print(bot.get_me())
cards_to_renew = Card.objects.filter(is_active=True)
for card in cards_to_renew:
if not card.image:
continue
print('before_send', settings.BASE_DIR + card.image.url)
with open(settings.BASE_DIR + card.image.url, 'rb') as f:
msg = bot.send_photo(733585869, f)
card.pic_file_id = msg.photo[0].file_id
card.save()
updater = Updater(
bot=bot,
use_context=True,
)
updater.dispatcher.add_handler(CommandHandler('start', handle_welcome))
updater.dispatcher.add_handler(CommandHandler('weekend', get_plans))
updater.dispatcher.add_handler(CommandHandler('send_broadcast', send_broadcast))
updater.dispatcher.add_handler(CommandHandler('see_all', see_all))
updater.dispatcher.add_handler(CallbackQueryHandler(keyboard_callback_handler, pass_chat_data=True))
# 3 -- запустить бесконечную обработку входящих сообщений
updater.start_polling()
updater.idle()
def main():
req = Request(connect_timeout=1, )
bot = Bot(
request=req,
token=TG_TOKEN,
base_url=TG_API_URL,
)
updater = Updater(
bot=bot,
use_context=True,
)
logger.info(updater.bot.get_me())
menu_handler = ConversationHandler(
entry_points=[
CommandHandler('start', start),
],
states={
KEYBOARD_CONTROLLER: [CallbackQueryHandler(keyboard_controller)],
CHECK_TOKEN: [
MessageHandler(Filters.regex('^[^/]'), check_token),
CommandHandler('cancel', cancel)
],
GET_POINTS: [
CallbackQueryHandler(get_points_get_result),
CommandHandler('cancel', cancel)
],
CHECK_ANALYSIS: [
MessageHandler(Filters.regex('^[^/]'), check_analysis),
CommandHandler('cancel', cancel)
],
},
fallbacks=[CommandHandler('stop', stop)])
updater.dispatcher.add_handler(menu_handler)
updater.start_polling()
updater.idle()
def __init__(
self,
token: str = None,
workers: int = 4,
):
"""
Initialize the updater.
"""
con_pool_size = workers + 4
request_kwargs = {'con_pool_size': con_pool_size}
self._request = Request(**request_kwargs)
self.bot = Bot(token, request=self._request)
update_queue: Queue = Queue()
job_queue = JobQueue()
exception_event = Event()
dispatcher = HomeBotDispatcher(self.bot,
update_queue,
job_queue=job_queue,
workers=workers,
exception_event=exception_event)
job_queue.set_dispatcher(dispatcher)
super().__init__(dispatcher=dispatcher, workers=None)
def main():
# Задает время на подключение
req = Request(connect_timeout=1.0, read_timeout=1.5)
# Обязатльно нужно добавлять request
bot = Bot(token=TG_TOKEN, request=req)
updater = Updater(bot=bot, use_context=True)
start_db()
# Текст каждого сообщения сначала попадает в этот блок
conv_handler = ConversationHandler(
# При сробатывании этой команды сработает весь ConversationHandler и запустит регистрацию
# Все сообщения будут переходить в этот кусок кода, пока вы не завершите регистрацию или не выйдете досрочно
entry_points=[CommandHandler('reg', do_reg)],
# Словарь состояний
states={
# Внутри может быть сколько угодно элементов
FULL_NAME: [
# pass_user_data нужен для сохранения состояния между запросами (Сохраняет переданные данные)
MessageHandler(Filters.all,
gender_handler,
pass_user_data=True),
],
AGE:
[MessageHandler(Filters.all, finish_handler, pass_user_data=True)]
},
# Позволяет досрочно выйти из регистрации
fallbacks=[CommandHandler('cancel', cancel_handler)]
# entry_points, states и fallbacks нужно обязательно указывать
)
updater.dispatcher.add_handler(conv_handler)
updater.dispatcher.add_handler(CommandHandler('start', do_start))
updater.dispatcher.add_handler(CommandHandler('help', do_help))
# Обработчик нажатий на кнопки
updater.dispatcher.add_handler(
CallbackQueryHandler(callback=keyboard_callback_handler))
updater.start_polling()
updater.idle()
def handle(self, *args, **options):
request = Request(connect_timeout=0.5, read_timeout=1)
bot = Bot(
request=request,
token=settings.TOKEN,
base_url=settings.PROXY_URL,
)
print(bot.get_me())
updater = Updater(settings.TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
message_handler = MessageHandler(Filters.text, echo)
dp.add_handler(message_handler)
dp.add_error_handler(error)
# updater.start_polling()
updater.start_webhook(
listen="0.0.0.0",
port=8443,
url_path=settings.TOKEN,
)
updater.bot.setWebhook('https://azibonu.herokuapp.com/' +
settings.TOKEN)
updater.idle()
def __init__(self):
self.__config = Configuration()
self.__flush_redis_cache()
q = mq.MessageQueue(
all_burst_limit=30,
all_time_limit_ms=1000,
group_burst_limit=20,
group_time_limit_ms=60000,
exc_route=None,
autostart=True,
)
# set connection pool size for bot
request = Request(con_pool_size=8)
self.__queue_bot = MQBot(self.__config.BOT_API_KEY,
request=request,
mqueue=q)
self.__updater = Updater(bot=self.__queue_bot)
self.__dp = self.__updater.dispatcher
self.__jq = self.__updater.job_queue
self.__reg()
self.__update()
self.__forget()
self.__timetable()
self.__ics()
self.__fuck()
self.__cbq()
self.__mega()
self.__alert()
self.__nightly()
self.__toggles()
self.__help()
self.__today()
self.__test_alert()
self.start_webhooks() # must always come last.
print("Bot online")
print(f"Current Time: {datetime.now()}")
def handle(self, *args, **options):
request = Request(
connect_timeout=1.0,
read_timeout=2.0,
)
bot = Bot(
request=request,
token=settings.TELEGRAM_BOT_TOKEN,
base_url=settings.TELEGRAM_BOT_URL,
)
updater = Updater(
bot=bot,
use_context=True,
)
updater.dispatcher.add_handler(CommandHandler("start", start))
updater.dispatcher.add_handler(CommandHandler("help", help_command))
updater.dispatcher.add_handler(CommandHandler("search", search))
updater.dispatcher.add_handler(
MessageHandler(Filters.text & ~Filters.command, search))
updater.start_polling()
updater.idle()
def __init__(self, contests=None, only_listen_to=None):
self.pwd = config.bot_pwd # Password needed during startup
self.id = None # We will only communicate with the group of
# this id (will be set during startup)
self.only_listen_to = only_listen_to
self.questions = {}
self.q_notifications = {}
self.messages_issued = []
self.contests = contests
self.err_count = 0
self.MAX_ERR_COUNT = config.telegram_bot_max_error_messages
self.bot = BotWithMessageQueue(token=config.bot_token,
request=Request(con_pool_size=8))
self.updater = Updater(bot=self.bot)
self.dispatcher = self.updater.dispatcher
self.job_queue = self.updater.job_queue
self.dispatcher.add_error_handler(self.handle_error)
self.dispatcher.add_handler(CommandHandler('start', self.start,
pass_args=True))
self.dispatcher.add_handler(CommandHandler('help', self.help))
def start(self):
queue = messagequeue.MessageQueue(all_burst_limit=28,
all_time_limit_ms=1017)
request = Request(con_pool_size=8)
bot = MQBot(self.token, request=request, mqueue=queue)
self.updater = Updater(bot=bot)
self.add_command(name='restart', func=self.restart, admins_only=True)
self.log_self()
self.send_message_if_reboot()
from . import command
from . import utils
if self.mode == 'webhook':
self.updater.start_webhook(listen=self.mode_config['listen'],
port=self.mode_config['port'],
url_path=self.mode_config['url_path'])
self.updater.bot.set_webhook(url=self.mode_config['url'])
else:
self.updater.start_polling()
self.updater.idle()
def main():
logger.info("starting bot...")
req = Request(
connect_timeout=0.5,
read_timeout=1.0,
)
bot = Bot(
token='850558425:AAFLZUjeFPPG_7-9oGRtGm12qaw-1G7BxyE',
request=req,
#base_url=config.TG_API_URL,
)
updater = Updater(
bot=bot,
use_context=True,
)
info = bot.get_me()
#logger.info(f'Bot info: {info}')
start_handler = CommandHandler("start", do_start)
help_handler = CommandHandler("help", do_help)
time_handler = CommandHandler("time", do_time)
message_handler = MessageHandler(Filters.text, do_echo)
buttons_handler = CallbackQueryHandler(callback=keyboard_callback_handler)
updater.dispatcher.add_handler(start_handler)
updater.dispatcher.add_handler(help_handler)
updater.dispatcher.add_handler(time_handler)
updater.dispatcher.add_handler(message_handler)
updater.dispatcher.add_handler(buttons_handler)
updater.start_polling()
updater.idle()
logger.info("end...")
def __init__(self):
token = "1699009884:AAHjE7wUGrSQgLUlIWgzucaV91dVJSDZhVs"
message_queue = MessageQueue(all_burst_limit=29,
all_time_limit_ms=1017)
request = Request(con_pool_size=8)
bot = MessageQueueBot(token,
request=request,
message_queue=message_queue)
self._updater = Updater(bot=bot)
self._dispatcher = self._updater.dispatcher
self._db_manager = DbManager()
self._localizer = Localizer(self._db_manager)
self._health_checker = HealthChecker(self._updater.bot,
self._db_manager)
self._health_check_interval = int(
os.environ.get('HEALTH_CHECK_INTERVAL'))
self.__setup_command_handlers()
self.__setup_callback_query_handlers()
self.__setup_message_handlers()
self.__setup_error_handler()
def main():
print('Start')
req = Request(connect_timeout=0.5, )
bot = Bot(
request=req,
token=TG_TOKEN,
base_url='https://telegg.ru/orig/bot',
)
updater = Updater(
bot=bot,
use_context=True,
)
updater.dispatcher.add_handler(
ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
PLAYERS:
[MessageHandler(Filters.all, players, pass_user_data=True)],
},
fallbacks=[CommandHandler('cancel', cancel)]))
updater.dispatcher.add_handler(
MessageHandler(Filters.regex('Начать игру'), game))
updater.dispatcher.add_handler(
MessageHandler(Filters.regex('Следующее задание'), game))
updater.dispatcher.add_handler(
MessageHandler(Filters.regex('Открыть букву'), letter))
updater.dispatcher.add_handler(CallbackQueryHandler(winner_of_the_round))
updater.dispatcher.add_handler(CommandHandler('points', points))
updater.start_polling()
updater.idle()
print('Finish')
