def test_slot_behaviour(self, recwarn, mro_slots):
a = Defaults(parse_mode='HTML', quote=True)
for attr in a.__slots__:
assert getattr(a, attr, 'err') != 'err', f"got extra slot '{attr}'"
assert not a.__dict__, f"got missing slot(s): {a.__dict__}"
assert len(mro_slots(a)) == len(set(mro_slots(a))), "duplicate slot"
a.custom, a._parse_mode = 'should give warning', a._parse_mode
assert len(recwarn) == 1 and 'custom' in str(
recwarn[0].message), recwarn.list
def main():
persistance = init_persistance()
defaults = Defaults(parse_mode=ParseMode.HTML)
updater = Updater(token, persistence=persistance, use_context=True, defaults=defaults,
request_kwargs={'read_timeout': timeout, 'connect_timeout': timeout})
job_queue = updater.job_queue
SELF_CHAT_ID = f'@{updater.bot.get_me().username}'
logger.info(f'SELF_CHAT_ID {SELF_CHAT_ID}')
logger.info(f'CHATID {CHATID}')
conversation_handler = ConversationHandler(
entry_points=deco.entry_points,
states=deco.entry_states,
fallbacks=deco.entry_fallbacks,
name="order",
persistent=True,
allow_reentry=True,
per_user=True,
per_chat=True,
# per_message=True
)
updater.dispatcher.add_handler(conversation_handler)
for dispather in deco.global_dispatchers:
updater.dispatcher.add_handler(dispather)
updater.dispatcher.add_handler(PollAnswerHandler(utils.poll_callback, pass_update_queue=True, pass_user_data=True, pass_chat_data=True))
#updater.dispatcher.add_error_handler(error)
updater.start_polling()
updater.idle()
def connect_bot():
"""
Make new bot with default parse mode to HTML and disabled web page preview
Make Dispatcher with PGPersistence and set JobQueue
Return value: (dispatcher, bot, job_queue)
"""
logger.info('Connecting bot...')
new_bot = Bot(token=config.BOT_TOKEN,
defaults=Defaults(
disable_web_page_preview=True,
parse_mode=ParseMode.HTML,
))
jq = JobQueue()
persistence = PGPersistence()
dp = Dispatcher(
bot=new_bot,
update_queue=None,
use_context=True,
job_queue=jq,
persistence=persistence,
)
jq.set_dispatcher(dp)
jq.start()
logger.info('Bot connected successfully')
return dp, new_bot, jq
def main():
"""Instantiate a Defaults object"""
defaults = Defaults(parse_mode=ParseMode.HTML,
tzinfo=pytz.timezone('Europe/Rome'))
updater = Updater(Config.BOT_TOKEN, defaults=defaults, workers=32)
dsp = updater.dispatcher
job_updater = updater.job_queue
# I load all admin, user and owner commands
index.user_command(dsp)
index.admin_command(dsp)
index.owner_command(dsp)
#Plugins Section (if in the config.py ENABLE_PLUGINS is True it loads the plugins if ENABLE_PLUGINS is False it does not load them)
if Config.ENABLE_PLUGINS == True:
plugin_index.function_plugins(dsp)
logger.info('Plugin Enabled')
else:
logger.info('Plugin Disabled')
# I load all handlers, commands without '/'
handlers_index.core_handlers(dsp)
handlers.logs.sys_loggers()
handlers.handlers_index.jobs_handlers(job_updater)
# I load the error handler, when the bot receives an error it sends a private message to the developer
dsp.add_error_handler(handlers.errors.error_handler)
dsp.add_error_handler(handlers.handler_errors.init)
# Start the Bot Polling
updater.start_polling(poll_interval=1.0, timeout=5.0)
updater.idle()
def main() -> None:
updater = Updater(BOT_TOKEN,
use_context=True,
defaults=Defaults(run_async=True))
dispatcher = updater.dispatcher
# dispatcher.add_handler(CommandHandler('start', start_handler))
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start_handler)],
states={
SENDING_IMAGE: [
MessageHandler(Filters.photo, image_handler),
MessageHandler(Filters.document, image_handler),
],
SEARCH_IMAGE_CHOICE: [
MessageHandler(Filters.command & Filters.regex(r'^/\d$'),
search_image_handler)
],
PROCESS_IMAGE: [CommandHandler('done', process_handler)]
},
fallbacks=[],
)
dispatcher.add_handler(conv_handler)
dispatcher.add_handler(MessageHandler(Filters.all, help_handler))
updater.start_polling()
updater.idle()
def main(token):
logging.info(f'StudentIDBot version {__version__} starting…')
db_init()
defaults = Defaults(parse_mode=ParseMode.MARKDOWN)
updater = Updater(token, defaults=defaults, use_context=True)
dp = updater.dispatcher
dp.add_handler(
ConversationHandler(
entry_points=[CommandHandler('askme', askme, pass_chat_data=True)],
states={
STUDENTID: [
MessageHandler(Filters.text & ~Filters.command,
studentid,
pass_chat_data=True)
],
FIRSTNAME: [
MessageHandler(Filters.text & ~Filters.command,
firstname,
pass_chat_data=True)
],
LASTNAME: [
MessageHandler(Filters.text & ~Filters.command,
lastname,
pass_chat_data=True)
]
},
fallbacks=[CommandHandler('cancel', cancel, pass_chat_data=True)]))
dp.add_handler(CommandHandler('whois', whois, pass_args=True))
dp.add_handler(CommandHandler('forgetme', forgetme))
dp.add_handler(CommandHandler('version', version))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
db_close()
def main():
updater = Updater(TOKEN,
use_context=True,
defaults=Defaults(parse_mode=ParseMode.HTML))
dp = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[
CommandHandler('start',
start,
pass_args=True,
pass_job_queue=True,
pass_chat_data=True)
],
states={
QUESTION: [MessageHandler(Filters.text, question)],
},
fallbacks=[CommandHandler('cancel', cancel)])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_webhook(listen="0.0.0.0", port=int(PORT), url_path=TOKEN)
updater.bot.setWebhook(HOST_URL + TOKEN)
updater.idle()
def test_update_persistence_defaults_async(self, monkeypatch, dp,
run_async, expected):
def update_persistence(*args, **kwargs):
self.count += 1
def dummy_callback(*args, **kwargs):
pass
monkeypatch.setattr(dp, 'update_persistence', update_persistence)
monkeypatch.setattr(dp, 'run_async', dummy_callback)
dp.bot.defaults = Defaults(run_async=run_async)
try:
for group in range(5):
dp.add_handler(MessageHandler(Filters.text, dummy_callback),
group=group)
update = Update(1,
message=Message(1,
None,
Chat(1, ''),
from_user=None,
text='Text'))
dp.process_update(update)
assert self.count == expected
finally:
dp.bot.defaults = None
def main():
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
defaults = Defaults(parse_mode=ParseMode.MARKDOWN)
updater = Updater(token=config["TELEGRAM_BOT_TOKEN"],
use_context=True,
defaults=defaults)
dispatcher = updater.dispatcher
j = updater.job_queue
for cmd, func in commands.items():
dispatcher.add_handler(CommandHandler(cmd, func))
dispatcher.add_handler(
MessageHandler(Filters.reply & Filters.regex(r"^s\/[\s\S]*\/[\s\S]*"),
api.sed))
dispatcher.add_handler(MessageHandler(Filters.text, api.stats_check))
j.run_daily(api.clear, time=datetime.time(18, 30))
dispatcher.bot.set_my_commands([(cmd, func.__doc__)
for cmd, func in commands.items()])
updater.start_polling(clean=True)
print("Started bot")
updater.idle()
def main():
try:
updater = Updater(TOKEN,
defaults=Defaults(parse_mode=ParseMode.MARKDOWN))
except TelegramError as err:
logging.critical("Telegram connection error: %s", err)
sys.exit(1)
dispatcher = updater.dispatcher
dispatcher.bot_data['channels'] = ChannelsCollection()
dispatcher.add_handler(ChannelsRegistrator())
dispatcher.add_handler(admin_menu)
dispatcher.add_error_handler(error)
updater.start_polling()
try:
with open(POSTS_FILE) as f:
posts = json.load(f)
schedule_posts(dispatcher.job_queue, posts)
except (FileNotFoundError, json.JSONDecodeError):
pass
logging.info("Bot started!")
updater.idle()
logging.info("Turned off.")
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater(TELEGRAM_TOKEN, defaults=Defaults(
parse_mode=ParseMode.HTML))
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# Add conversation handler with the states STATE and DISTRICT
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
CHOOSE: [MessageHandler(Filters.text(["1", "2"]), choose)],
STATE: [MessageHandler(Filters.text & ~Filters.command, state)],
DISTRICT: [MessageHandler(Filters.text & ~Filters.command, district)],
PIN: [MessageHandler(Filters.text & ~Filters.command, pin)],
AGE: [MessageHandler(Filters.text(["1", "2"]), age)],
MODE: [MessageHandler(Filters.text(["1", "2"]), mode)],
},
fallbacks=[CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
dispatcher.add_handler(CommandHandler("send", sendToEachUser))
# Start the Bot
updater.start_polling()
updater.job_queue.run_repeating(
checkForAvailableSlots, interval=300, first=15)
# Run the bot until you press Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def main():
updater = Updater(evars['bot_token'],
defaults=Defaults(parse_mode=ParseMode.HTML),
use_context=True)
# Adding all handlers from relations.py
for handler in conversation_handlers:
updater.dispatcher.add_handler(handler)
for handler in command_handlers.items():
updater.dispatcher.add_handler(CommandHandler(*handler))
for handler in button_handlers.items():
updater.dispatcher.add_handler(
MessageHandler(Filters.regex(f"^({handler[0]})$"), handler[1]))
for handler in callback_handlers.items():
updater.dispatcher.add_handler(
CallbackQueryHandler(handler[1], pattern=handler[0]))
if bool(evars['debug']) is False:
updater.dispatcher.add_error_handler(error_handler)
updater.start_polling()
updater.idle()
def main():
cpu_count = os.cpu_count()
workers = cpu_count
log.debug(f'System: CPU_COUNT={cpu_count}, WORKERS={workers}')
log.debug('Start')
persistence = PicklePersistence(filename='data.pickle')
# Create the EventHandler and pass it your bot's token.
updater = Updater(
config.TOKEN,
workers=workers,
persistence=persistence,
defaults=Defaults(run_async=True),
)
# Get the dispatcher to register handlers
dp = updater.dispatcher
dp.add_handler(CommandHandler('start', on_start))
dp.add_handler(MessageHandler(Filters.photo, on_photo))
dp.add_handler(MessageHandler(Filters.text(COMMANDS_DEEP_DREAM), on_deep_dream))
dp.add_handler(MessageHandler(Filters.text([COMMAND_RESET]), on_reset))
dp.add_handler(MessageHandler(Filters.all, on_request))
dp.add_error_handler(on_error)
# Start the Bot
updater.start_polling()
# Run the bot until the you presses Ctrl-C or the process receives SIGINT,
# SIGTERM or SIGABRT. This should be used most of the time, since
# start_polling() is non-blocking and will stop the bot gracefully.
updater.idle()
def test_all_bot_args_custom(self, builder, bot, monkeypatch):
defaults = Defaults()
request = HTTPXRequest()
get_updates_request = HTTPXRequest()
builder.token(bot.token).base_url("base_url").base_file_url(
"base_file_url").private_key(PRIVATE_KEY).defaults(
defaults).arbitrary_callback_data(42).request(
request).get_updates_request(get_updates_request)
built_bot = builder.build().bot
# In the following we access some private attributes of bot and request. this is not
# really nice as we want to test the public interface, but here it's hard to ensure by
# other means that the parameters are passed correctly
assert built_bot.token == bot.token
assert built_bot.base_url == "base_url" + bot.token
assert built_bot.base_file_url == "base_file_url" + bot.token
assert built_bot.defaults is defaults
assert built_bot.request is request
assert built_bot._request[0] is get_updates_request
assert built_bot.callback_data_cache.maxsize == 42
assert built_bot.private_key
@dataclass
class Client:
timeout: object
proxies: object
limits: object
monkeypatch.setattr(httpx, "AsyncClient", Client)
builder = ApplicationBuilder().token(bot.token)
builder.connection_pool_size(1).connect_timeout(2).pool_timeout(
3).read_timeout(4).write_timeout(5).proxy_url("proxy_url")
app = builder.build()
client = app.bot.request._client
assert client.timeout == httpx.Timeout(pool=3,
connect=2,
read=4,
write=5)
assert client.limits == httpx.Limits(max_connections=1,
max_keepalive_connections=1)
assert client.proxies == "proxy_url"
builder = ApplicationBuilder().token(bot.token)
builder.get_updates_connection_pool_size(
1).get_updates_connect_timeout(2).get_updates_pool_timeout(
3).get_updates_read_timeout(4).get_updates_write_timeout(
5).get_updates_proxy_url("proxy_url")
app = builder.build()
client = app.bot._request[0]._client
assert client.timeout == httpx.Timeout(pool=3,
connect=2,
read=4,
write=5)
assert client.limits == httpx.Limits(max_connections=1,
max_keepalive_connections=1)
assert client.proxies == "proxy_url"
def main():
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
defaults = Defaults(parse_mode=ParseMode.MARKDOWN, quote=False)
updater = Updater(
token=os.environ['TG_BOT_TOKEN'], defaults=defaults
)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('play', play, run_async=True))
dispatcher.add_handler(CommandHandler('playnext', play, run_async=True))
dispatcher.add_handler(CommandHandler('skip', skip, run_async=True))
dispatcher.add_handler(CommandHandler('status', status, run_async=True))
dispatcher.add_handler(CommandHandler('q', queue, run_async=True))
dispatcher.add_handler(CommandHandler('clear', clear, run_async=True))
dispatcher.bot_data['now_playing'] = ''
dispatcher.bot_data['song_queue'] = []
dispatcher.bot_data['PID'] = None
updater.start_polling(clean=True)
print("Started bot")
updater.idle()
def tz_bot(timezone, bot_info):
defaults = Defaults(tzinfo=timezone)
default_bot = DEFAULT_BOTS.get(defaults)
if default_bot:
return default_bot
default_bot = make_bot(bot_info, **{'defaults': defaults})
DEFAULT_BOTS[defaults] = default_bot
return default_bot
def main():
logger.warning("ahh waking up...")
defaults = Defaults(parse_mode=ParseMode.HTML)
updater = Updater(token="", use_context=True, workers=200)
msg_handlers(updater.dispatcher)
updater.start_polling()
logger.warning("Ready to rock...")
updater.idle()
def main():
global sites, storage
defaults = Defaults(quote=True)
urlFilter = Filters.entity('url') | Filters.entity(
'text_link') | Filters.caption_entity('url') | Filters.caption_entity(
'text_link')
sites.load()
# Set up the Updater
updater = Updater(config.TOKEN,
workers=32,
use_context=True,
defaults=defaults)
# Get the dispatcher to register handlers
dp = updater.dispatcher
dp.add_handler(
CommandHandler('start', start, config.adminFilter, run_async=True))
dp.add_handler(
CommandHandler('ping', ping, config.adminFilter, run_async=True))
dp.add_handler(
CommandHandler('help', get_help, config.adminFilter, run_async=True))
sites.register_commands(dp)
dp.add_handler(
CommandHandler('clear_downloads',
clear_downloads,
config.adminFilter,
pass_args=True))
dp.add_handler(
MessageHandler(config.adminFilter & urlFilter &
(~Filters.update.channel_posts),
collection_update,
pass_chat_data=True,
run_async=True))
# log all errors
dp.add_error_handler(handle_error)
if config.ENV == 'production':
# Webhook mode
print('Port number: ' + str(config.PORT) + '\n')
updater.start_webhook(listen="0.0.0.0",
port=config.PORT,
url_path=config.TOKEN,
webhook_url=config.WEBHOOK_URL + config.TOKEN)
time.sleep(5)
updater.bot.setWebhook(url=config.WEBHOOK_URL + config.TOKEN,
allowed_updates=["message"])
time.sleep(5)
#updater.bot.setWebhook(allowed_updates=["message"])
logger.info('Set webhook completed')
else:
# Polling mode
updater.start_polling()
logger.info('Started polling')
storage.load()
updater.idle()
def main():
logger.warning("ahh waking up...")
defaults = Defaults(parse_mode=ParseMode.HTML)
updater = Updater(token="1447840212:AAHWTCq879h9kaeDhvwHLhz0p1Z0oBq5PEA",
use_context=True,
workers=200)
msg_handlers(updater.dispatcher)
updater.start_polling()
logger.warning("Ready to rock...")
updater.idle()
def test_data_assignment(self, cdp):
defaults = Defaults()
with pytest.raises(AttributeError):
defaults.parse_mode = True
with pytest.raises(AttributeError):
defaults.disable_notification = True
with pytest.raises(AttributeError):
defaults.disable_web_page_preview = True
with pytest.raises(AttributeError):
defaults.allow_sending_without_reply = True
with pytest.raises(AttributeError):
defaults.timeout = True
with pytest.raises(AttributeError):
defaults.quote = True
with pytest.raises(AttributeError):
defaults.tzinfo = True
with pytest.raises(AttributeError):
defaults.run_async = True
def test_equality(self):
a = Defaults(parse_mode="HTML", quote=True)
b = Defaults(parse_mode="HTML", quote=True)
c = Defaults(parse_mode="HTML", quote=True, protect_content=True)
d = Defaults(parse_mode="HTML", protect_content=True)
e = User(123, "test_user", False)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a != c
assert hash(a) != hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def test_equality(self):
a = Defaults(parse_mode='HTML', quote=True)
b = Defaults(parse_mode='HTML', quote=True)
c = Defaults(parse_mode='HTML', quote=False)
d = Defaults(parse_mode='HTML', timeout=50)
e = User(123, 'test_user', False)
assert a == b
assert hash(a) == hash(b)
assert a is not b
assert a != c
assert hash(a) != hash(c)
assert a != d
assert hash(a) != hash(d)
assert a != e
assert hash(a) != hash(e)
def main():
updater = Updater(token=TELEGRAM_TOKEN,
defaults=Defaults(parse_mode=ParseMode.HTML))
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start',
startCommand)) # Accessed via /start
dispatcher.add_handler(CommandHandler('alert',
priceAlert)) # Accessed via /alert
updater.start_polling() # Start the bot
updater.idle() # Wait for the script to be stopped, this will stop the bot
def default_bot(request, bot_info):
param = request.param if hasattr(request, 'param') else {}
defaults = Defaults(**param)
default_bot = DEFAULT_BOTS.get(defaults)
if default_bot:
return default_bot
default_bot = make_bot(bot_info, **{'defaults': defaults})
DEFAULT_BOTS[defaults] = default_bot
return default_bot
def main():
logger.warning("ahh waking up...")
defaults = Defaults(parse_mode=ParseMode.HTML)
updater = Updater(token="1559618623:AAGHnNUQPvnh7UFI2S5Nv969o7lfGNCR2C8",
use_context=True,
workers=200)
msg_handlers(updater.dispatcher)
updater.start_polling()
logger.warning("Ready to rock...")
updater.idle()
def send_telegram_message(message):
defaults = Defaults(parse_mode=ParseMode.MARKDOWN_V2,
disable_web_page_preview=True)
updater = Updater(token=settings.TELEGRAM_TOKEN,
use_context=True,
defaults=defaults)
message = escape_tg_message(message)
updater.bot.send_message(chat_id=f"@{settings.TELEGRAM_CHANNEL_NAME}",
text=message)
def __init__(self, giphy_kwargs: tp.KwargsLike = None, **kwargs) -> None:
from vectorbt._settings import settings
telegram_cfg = settings['messaging']['telegram']
giphy_cfg = settings['messaging']['giphy']
Configured.__init__(self, giphy_kwargs=giphy_kwargs, **kwargs)
# Resolve kwargs
giphy_kwargs = merge_dicts(giphy_cfg, giphy_kwargs)
self.giphy_kwargs = giphy_kwargs
default_kwargs = dict()
passed_kwargs = dict()
for k in get_func_kwargs(Updater):
if k in telegram_cfg:
default_kwargs[k] = telegram_cfg[k]
if k in kwargs:
passed_kwargs[k] = kwargs.pop(k)
updater_kwargs = merge_dicts(default_kwargs, passed_kwargs)
persistence = updater_kwargs.pop('persistence', None)
if isinstance(persistence, str):
persistence = PicklePersistence(persistence)
defaults = updater_kwargs.pop('defaults', None)
if isinstance(defaults, dict):
defaults = Defaults(**defaults)
# Create the (persistent) Updater and pass it your bot's token.
logger.info("Initializing bot")
self._updater = Updater(persistence=persistence,
defaults=defaults,
**updater_kwargs)
# Get the dispatcher to register handlers
self._dispatcher = self.updater.dispatcher
# Register handlers
self.dispatcher.add_handler(self.log_handler)
self.dispatcher.add_handler(
CommandHandler('start', self.start_callback))
self.dispatcher.add_handler(CommandHandler("help", self.help_callback))
for handler in self.custom_handlers:
self.dispatcher.add_handler(handler)
self.dispatcher.add_handler(
MessageHandler(Filters.status_update.migrate,
self.chat_migration_callback))
self.dispatcher.add_handler(
MessageHandler(Filters.command, self.unknown_callback))
self.dispatcher.add_error_handler(
self_decorator(self, self.__class__.error_callback))
# Set up data
if 'chat_ids' not in self.dispatcher.bot_data:
self.dispatcher.bot_data['chat_ids'] = []
else:
logger.info("Loaded chat ids %s",
str(self.dispatcher.bot_data['chat_ids']))
def __init__(self, loop):
self.__loop = loop
self.__dao = None
self.__updater = Updater(
config.telegram.token,
defaults=Defaults(parse_mode=ParseMode.MARKDOWN))
self.__view = View(self.__updater, self.__handler)
self.__modal = Modal(config.meross, config.solaredge, config.sun)
self.__loop.run_until_complete(self.__modal.async_init())
def main():
pers = PicklePersistence("persistence")
defaults = Defaults(parse_mode="HTML", disable_notification=True)
updater = Updater("", defaults=defaults, persistence=pers)
dp = updater.dispatcher
dp.add_handler(MessageHandler(Filters.update.channel_post & Filters.chat(CHANNEL_ID), new_post))
dp.add_handler(MessageHandler(Filters.update.edited_channel_post & Filters.chat(CHANNEL_ID), edited_post))
dp.add_handler(MessageHandler(Filters.status_update.pinned_message & Filters.chat(GROUP_ID), del_msg))
if "messages" not in dp.bot_data:
dp.bot_data = {"messages": {}}
updater.start_polling()
updater.idle()
def main():
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(module)s - %(message)s",
)
try:
token = os.environ['TOKEN']
except KeyError:
logging.critical("Токен бота ('TOKEN') не найден в переменных окружения!")
sys.exit(1)
try:
admin = int(os.environ['ADMIN'])
except KeyError:
logging.critical("ID админа ('ADMIN') не найден в переменных окружения!")
sys.exit(1)
except ValueError:
logging.critical("ID админа должен быть числом!")
sys.exit(1)
try:
updater = Updater(token, defaults=Defaults(
parse_mode=ParseMode.MARKDOWN,
disable_notification=True
))
except TelegramError as err:
logging.critical("Ошибка подключения к телеграму - %s", err)
sys.exit(1)
try:
menu_tree = parse_document('menu.xlsx')
except ParseError as err:
logging.error("Ошибка парсинга файла - %s", err)
sys.exit(1)
dispatcher = updater.dispatcher
dispatcher.bot_data['admin'] = admin
dispatcher.bot_data['menu'] = menu_tree
dispatcher.add_handler(CommandHandler('start', menu.start))
dispatcher.add_handler(admin_form)
dispatcher.add_handler(contact_form)
dispatcher.add_handler(CallbackQueryHandler(menu.back, pattern=r'^back$'))
dispatcher.add_handler(CallbackQueryHandler(menu.choice))
dispatcher.add_handler(MessageHandler(Filters.all, menu.clean))
dispatcher.add_error_handler(menu.error)
updater.start_polling()
logging.info("Бот запущен!")
updater.idle()
logging.info("Бот выключен.")
