def setup(token):
# Create bot, update queue and dispatcher instances
bot = telegram.Bot(token)
dispatcher = Dispatcher(bot, None, workers=0)
##### Register handlers here #####
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(
MessageHandler(Filters.text & ~Filters.command, echo))
return dispatcher, bot
def __init__(self, telegram_token, hook_path):
self.hook_path = hook_path # + token_urlsafe(32)
self.bot_name = os.environ["BOT_NAME"]
self.bot = Bot(token=telegram_token)
self.dispatcher = Dispatcher(bot=self.bot,
update_queue=None,
workers=0,
use_context=True)
self._set_handlers()
self.datastore_client = datastore.Client()
self.storage_kind = "user_registry"
def setup(token):
bot = Bot(token)
update_queue = Queue()
bot.set_webhook(config['webhook_url'])
dispatcher = Dispatcher(bot, update_queue)
thread = Thread(target=dispatcher.start, name='dispatcher')
thread.start()
return dispatcher
def __init__(self, token=None):
super().__init__()
self.TOKEN = token or os.environ.get('TOKEN')
self.telegram_bot = telegram.Bot(token=self.TOKEN)
update_queue = Queue()
self.dp = Dispatcher(self.telegram_bot, update_queue)
self.dp = self.add_update_handlers(self.dp)
# log all errors
self.dp.add_error_handler(error)
def vika(event, context):
logger.debug(event)
update_queue = None
bot = telegram.Bot(TOKEN)
dispatcher = Dispatcher(bot, update_queue, use_context=True)
setup_dispatcher(dispatcher=dispatcher)
update = telegram.Update.de_json(json.loads(event['body']), bot)
dispatcher.process_update(update)
return {
"statusCode": 200,
}
def test_remove_watchlist():
(mock_bot, update, telegram_user_id) = init_telegram()
from bot.db import db
user = {
'telegram': {
'id': telegram_user_id
}
}
user_id = db.users.insert(user)
watchlist_1 = {
'userId': user_id,
'make': 'Honda',
'model': 'Saber',
'year': {
'min': 2004,
'max': 2009
},
'mileage': {
'max': 300000
},
'price': {
'max': 3500
}
}
watchlist_2 = {
'userId': user_id,
'make': 'Toyota',
'model': 'Aqua',
'year': {
'min': 2010,
'max': 2020
},
'mileage': {
'max': 200000
},
'price': {
'max': 15500
}
}
watchlist_1_id = db.watchlists.insert(watchlist_1)
db.watchlists.insert(watchlist_2)
context = Dispatcher(bot=mock_bot, update_queue=update)
remove_watchlist(update, context)
update = get_mock_callback_query(mock_bot, update, data=str(watchlist_1_id))
watchlist_selected_for_removal(update, context)
user_watchlists = list(db.watchlists.find({'userId': user_id}))
removed_watchlist = db.watchlists.find_one({'_id': watchlist_1_id})
assert removed_watchlist == None
assert len(user_watchlists) == 1
def get_handler():
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher(bot, None, workers=0)
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(InlineQueryHandler(inlinequery))
# log all errors
dp.add_error_handler(error)
return dp, bot
def __init__(self, hass, bot, config):
"""Create Dispatcher before calling super()."""
self.bot = bot
self.trusted_networks = config[CONF_TRUSTED_NETWORKS]
# Dumb dispatcher that just gets our updates to our handler callback (self.handle_update)
self.dispatcher = Dispatcher(bot, None)
self.dispatcher.add_handler(TypeHandler(Update, self.handle_update))
super().__init__(hass, config)
self.base_url = config.get(CONF_URL) or get_url(
hass, require_ssl=True, allow_internal=False)
self.webhook_url = f"{self.base_url}{TELEGRAM_WEBHOOK_URL}"
def webhookInit(self, botToken):
webhookURL = self.config["callback"]
self.bot = Bot(botToken)
self.bot.set_webhook(webhookURL)
self.updateQueue = Queue()
self.dispatcher = Dispatcher(self.bot, self.updateQueue)
self.dispatcherThread = Thread(
target=self.dispatcher.start, name='dispatcher', daemon=True)
log.debug('Dispatcher spawned')
self.registerHandlers()
log.debug('Handlers registered')
self.dispatcherThread.start()
def setup():
telegram_bot = Bot(settings.TELEGRAM_BOT_TOKEN)
if settings.TELEGRAM_BOT_WEBHOOK_ENABLED:
telegram_bot.set_webhook(settings.TELEGRAM_BOT_WEBHOOK_URL)
telegram_dispatcher = Dispatcher(telegram_bot, None, workers=6)
# register your handlers here
command_start = CommandHandler('start', base_commands.command_start)
telegram_dispatcher.add_handler(command_start)
return telegram_bot, telegram_dispatcher
def setup():
'''GAE DISPATCHER SETUP'''
global dispatcher
dispatcher = Dispatcher(bot=bot, update_queue=None, workers=0)
# ---Register handlers here---
dispatcher.add_handler(InlineQueryHandler(parseInlineQuery))
dispatcher.add_error_handler(error)
return dispatcher
def create_dp(bot):
# Dispatcher is heavy to init (due to many threads and such) so we have a single session
# scoped one here, but before each test, reset it (dp fixture below)
dispatcher = Dispatcher(bot, Queue(), job_queue=JobQueue(bot), workers=2)
thr = Thread(target=dispatcher.start)
thr.start()
sleep(2)
yield dispatcher
sleep(1)
if dispatcher.running:
dispatcher.stop()
thr.join()
def webhook(request):
bot = Bot(token=os.environ["TELEGRAM_TOKEN"])
dispatcher = Dispatcher(bot, None, 0)
dispatcher.add_handler(CommandHandler('coronamundo', world))
dispatcher.add_handler(CommandHandler('coronabrasil', brazil))
if request.method == 'POST':
update = Update.de_json(request.get_json(force=True), bot)
dispatcher.process_update(update)
return 'ok'
def __init__(self, TOKEN, NAME):
super(ManageBot, self).__init__()
self.TOKEN = TOKEN
self.NAME=NAME
self.bot = telegram.Bot(self.TOKEN)
try:
self.bot.setWebhook("https://{}.herokuapp.com/{}".format(self.NAME, self.TOKEN))
except:
raise RuntimeError("Failed to set the webhook")
self.update_queue = Queue()
self.dp = Dispatcher(self.bot, self.update_queue, use_context=True)
self.dp.add_handler(CommandHandler("start", GenericComm.start))
self.dp.add_handler(MessageHandler(Filters.text('кинь музыку') & (~Filters.command), GenericComm.music_get))
self.conv_photo_add = ConversationHandler(
entry_points=[CommandHandler("photo_add", AdmComm.adm_photo)],
states={
config.PHOTO: [MessageHandler(Filters.photo, AdmComm.photo_add)],
},
fallbacks=[MessageHandler(Filters.all & (~Filters.photo), "это не фото")],
)
self.dp.add_handler(self.conv_photo_add)
self.conv_audio_add = ConversationHandler(
entry_points=[CommandHandler("audio_add", AdmComm.adm_audio)],
states={
config.AUDIO: [MessageHandler(Filters.audio, AdmComm.audio_add)],
},
fallbacks=[MessageHandler(Filters.all & (~Filters.audio), "это не аудио")],
)
self.dp.add_handler(self.conv_audio_add)
self.conv_docs_add = ConversationHandler(
entry_points=[CommandHandler("docs_add", AdmComm.adm_docs)],
states={
config.DOCS: [MessageHandler(Filters.document, AdmComm.docs_add)],
},
fallbacks=[MessageHandler(Filters.all & (~Filters.document), "это не док")],
)
self.dp.add_handler(self.conv_docs_add)
self.conv_stickers_add = ConversationHandler(
entry_points=[CommandHandler("sticker_add", AdmComm.adm_stickers)],
states={
config.STICKER: [MessageHandler(Filters.sticker, AdmComm.stickers_add)],
},
fallbacks=[MessageHandler(Filters.all & (~Filters.sticker), "это не стикер")],
)
self.dp.add_handler(self.conv_stickers_add)
def __init__(self,
token=None,
base_url=None,
workers=4,
bot=None,
user_sig_handler=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')
self.logger = logging.getLogger(__name__)
con_pool_size = workers + 4
if bot is not None:
self.bot = bot
if bot.request.con_pool_size < con_pool_size:
self.logger.warning(
'Connection pool of Request object is smaller than optimal value (%s)',
con_pool_size)
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'] = con_pool_size
self._request = Request(**request_kwargs)
self.bot = Bot(token, base_url, request=self._request)
self.user_sig_handler = user_sig_handler
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.running = False
self.is_idle = False
self.httpd = None
self.__lock = Lock()
self.__threads = []
def setup(webhook_url=None):
"""If webhook_url is not passed, run with long-polling."""
logging.basicConfig(level=logging.WARNING)
if webhook_url:
bot = Bot(TOKEN)
update_queue = Queue()
dp = Dispatcher(bot, update_queue)
else:
updater = Updater(TOKEN)
bot = updater.bot
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("new_room", new_room, pass_args=True))
dp.add_handler(CommandHandler("new_bet", new_bet))
dp.add_handler(CommandHandler("remove_bet", remove_bet,
pass_args=True))
dp.add_handler(CommandHandler("join", join_room, pass_args=True))
dp.add_handler(CommandHandler("bets", show_bets))
dp.add_handler(CommandHandler("close_bet", close_bet, pass_args=True))
dp.add_handler(CommandHandler("open_bet", open_bet, pass_args=True))
dp.add_handler(
CommandHandler("submit_result", submit_result, pass_args=True))
dp.add_handler(CommandHandler("pred", modify_bet, pass_args=True))
dp.add_handler(CommandHandler("refill", refill_bets))
dp.add_handler(CommandHandler("show", show_predictions,
pass_args=True))
dp.add_handler(CommandHandler("score_board", score_board))
dp.add_handler(CommandHandler("members", show_members))
dp.add_handler(CommandHandler("description", set_desc))
dp.add_handler(CommandHandler("delete_room", delete_room))
dp.add_handler(CommandHandler("hack", hack, pass_args=True))
dp.add_handler(CommandHandler("hack_score", hack_score,
pass_args=True))
dp.add_handler(CommandHandler("hack_start", hack_start,
pass_args=True))
# # on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(Filters.text, echo))
# log all errors
dp.add_error_handler(error)
# Add your handlers here
if webhook_url:
bot.set_webhook(webhook_url=webhook_url)
thread = Thread(target=dp.start, name='dispatcher')
thread.start()
return update_queue, bot
else:
bot.set_webhook() # Delete webhook
updater.start_polling()
updater.idle()
def main():
dp = Dispatcher(bot, None, workers=0)
if request.method == "POST":
print('POST')
update = telegram.Update.de_json(request.get_json(force=True), bot)
dp.add_handler(CommandHandler('start', start))
dp.add_handler(MessageHandler(Filters.text, hi))
dp.process_update(update)
return 'ok'
def run(message):
"""Receive a message, handle it, and send a response"""
bot = Bot(config.bot_token)
dp = Dispatcher(bot, None, workers=0)
# add your handlers here
dp.add_handler(CommandHandler("test", test))
dp.add_handler(MessageHandler(Filters.text, echo))
# decode update and try to process it
update = Update.de_json(message, bot)
dp.process_update(update)
def __init__(self, token, url):
self.bot = TelegramBot(token)
self.bot.set_webhook(f'{url}/bot/{token}/')
self.update_queue = Queue()
self.dispatcher = Dispatcher(self.bot,
self.update_queue,
workers=4,
use_context=True)
self.update_obj = None
self.__register_handlers__()
def webhook(botname, arg_token):
settings = get_bot_settings(botname)
if not settings:
raise abort(404,f"No bot {botname} known.")
if arg_token != settings['token']:
abort(403, "Wrong token")
bot = Bot(token = settings['token'])
# decode update and try to process it
dp = Dispatcher(bot, None, workers=0, use_context = True)
add_handlers(botname, dp)
update = Update.de_json(request.json, bot)
dp.process_update(update)
return ""
def tg_bot_init(config):
bot = Bot(config.BOT_TOKEN)
bot.set_webhook(url=config.WEBHOOK_URI)
update_queue = Queue()
dispatcher = Dispatcher(bot, update_queue)
dispatcher.add_handler(MessageHandler(Filters.text, match_keyword_callback))
dispatcher.add_handler(CallbackQueryHandler(scanner_callback))
thread = Thread(target=dispatcher.start, name='dispatcher')
thread.start()
return (bot, update_queue)
def webhook(request):
bot = Bot(token=os.environ["TELEGRAM_TOKEN"])
dispatcher = Dispatcher(bot, None, 0)
dispatcher.add_handler(CommandHandler('start', start))
dispatcher.add_handler(CommandHandler('kotlin', msg))
dispatcher.add_handler(MessageHandler(Filters.command, unknown))
if request.method == 'POST':
update = Update.de_json(request.get_json(force=True), bot)
dispatcher.process_update(update)
return 'ok'
def __init__(self, logger, postgres):
self._status = {}
self._logger = logger
self._postgres = postgres
# self._updater = Updater(token=BOT_TOKEN, use_context=True)
self._bot = TelegramBot(token=BOT_TOKEN)
self._job_queue = JobQueue()
self._update_queue = Queue()
self._dispatcher = Dispatcher(self._bot, self._update_queue, use_context=True)
self._translator = Translator(file=TRANSLATION_FILE)
self._set_commands()
self._load_status()
self._set_job_queue()
def webhook(request):
bot = Bot(token=os.environ["TELEGRAM_TOKEN"])
dispatcher = Dispatcher(bot, None, 0)
dispatcher.add_handler(CommandHandler("intercomp", intercomp_callback))
dispatcher.add_handler(CommandHandler("contagem", contagem_callback))
dispatcher.add_handler(CommandHandler("mackenzie", mackenzie_callback))
dispatcher.add_handler(CommandHandler("cidade", cidade_callback))
dispatcher.add_handler(CommandHandler("mochila", mochila_callback))
if request.method == "POST":
update = Update.de_json(request.get_json(force=True), bot)
dispatcher.process_update(update)
return "ok"
def test_add_full_watchlist():
(mock_bot, update, telegram_user_id) = init_telegram()
from bot.db import db
user = {
'telegram': {
'id': telegram_user_id
}
}
user_id = db.users.insert(user)
context = Dispatcher(bot=mock_bot, update_queue=update)
add_watchlist(update, context)
update = get_mock_callback_query(mock_bot, update, data='T')
watchlist_letter_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Toyota')
watchlist_make_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Aqua')
watchlist_model_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add more details')
confirm_watchlist_details(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add year')
input_car_parameters(update, context)
update = get_mock_callback_query(mock_bot, update, data='2010')
watchlist_from_year_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='2020')
watchlist_to_year_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add more details')
confirm_watchlist_details(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add max mileage')
input_car_parameters(update, context)
update = get_mock_message(mock_bot, update, text='200000')
watchlist_miles_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add more details')
confirm_watchlist_details(update, context)
update = get_mock_callback_query(mock_bot, update, data='Add max price')
input_car_parameters(update, context)
update = get_mock_message(mock_bot, update, text='15500')
watchlist_price_inputted(update, context)
update = get_mock_callback_query(mock_bot, update, data='Save watchlist')
confirm_watchlist_details(update, context)
watchlist = db.watchlists.find_one({'userId': user_id})
assert watchlist['make'] == 'Toyota'
assert watchlist['model'] == 'Aqua'
assert watchlist['year'] == {
'min': 2010,
'max': 2020
}
assert watchlist['mileage']['max'] == 200000
assert watchlist['price']['max'] == 15500
def setup(bot):
# Create bot, update queue and dispatcher instances
update_queue = Queue()
dispatcher = Dispatcher(bot, update_queue)
##### Register handlers here #####
dispatcher.add_handler(CommandHandler("start", start_callback))
# Start the thread
thread = Thread(target=dispatcher.start, name='dispatcher')
thread.start()
return update_queue
def start_bot(bot):
dp = Dispatcher(bot, None, workers=0, use_context=True)
dp.add_handler(CommandHandler('start', help_start))
dp.add_handler(CommandHandler('help', help_start))
dp.add_handler(
MessageHandler(Filters.text & Filters.regex('ℹ️ О сервисе'),
help_info))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex('🚀 Увеличить лимит запросов'),
help_no_limits))
dp.add_handler(
CallbackQueryHandler(help_analyse_category,
pattern='keyboard_analyse_category'))
dp.add_handler(
CallbackQueryHandler(help_catalog_link,
pattern='keyboard_help_catalog_link'))
dp.add_handler(
CallbackQueryHandler(help_feedback,
pattern='keyboard_help_info_feedback'))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(
r'(ozon\.ru|beru\.ru|goods\.ru|tmall\.ru|lamoda\.ru)/'),
help_marketplace_not_supported))
dp.add_handler(
MessageHandler(
Filters.text
& Filters.regex(r'www\.wildberries\.ru/catalog/.*/detail\.aspx'),
help_command_not_found))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/catalog/'),
wb_catalog))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/brands/'),
wb_catalog))
dp.add_handler(
MessageHandler(
Filters.text & Filters.regex(r'www\.wildberries\.ru/promotions/'),
wb_catalog))
dp.add_handler(MessageHandler(Filters.all, help_command_not_found))
return dp
def setup_dispatcher(token: str) -> 'Dispatcher':
bot = TelegramBot(token=token)
dispatcher = Dispatcher(
bot=bot,
update_queue=None,
workers=0,
use_context=True,
)
dispatcher.add_handler(get_movie_handler())
dispatcher.add_handler(get_inline_handler())
return dispatcher
def create_bot(self, app, persistence):
self.app = app
self.persistence = persistence or DictPersistence()
token = app.config.get("API_TOKEN")
autodiscovery(app.config.get("APPS", []))
self.bot = telegram.Bot(token=token)
self.dispatcher = Dispatcher(self.bot,
None,
workers=0,
use_context=True,
persistence=self.persistence)
setup_handlers(self.dispatcher)
# log all errors
self.dispatcher.add_error_handler(self.error)
def setup():
global token
bot = Bot(token)
dispatcher = Dispatcher(bot, None, workers=0)
dispatcher.add_handler(CommandHandler('saymyname', saymyname))
dispatcher.add_handler(CommandHandler('naointendo', naointendo))
dispatcher.add_handler(CommandHandler('debug', debug))
dispatcher.add_handler(CommandHandler('redhead', redhead))
dispatcher.add_handler(
CommandHandler('randompic', randompic, pass_args=True))
# bot.set_webhook("https://maclarensbot.herokuapp.com/" + token)
return dispatcher
