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("Бот выключен.")