def main():
if load._cfg['Servers']['Mod']['mod'] == 'long':
bot = load.bot
updater = Updater(bot=bot, use_context=True)
dp = updater.dispatcher
dp.add_handler(CH("help", _h._help))
dp.add_handler(CH('search',sA.searchALL))
dp.add_handler(InlineQueryHandler(ilQuery.inlinequery,run_async=True))
'''
Start TGBOT
'''
updater.start_polling()
LOG.info("Fxxkr LAB :: Bingo" + __version__.__version__ + " is Started")
updater.idle()
else:
print('Wrong Arguments')
def main():
# Lanzamos el updater y lo asignamos al TOKEN
updater = Updater("TOKEN_AQUI")
# Get the dispatcher to register handlers
dp = updater.dispatcher
# Comandos a los que responder
dp.add_handler(CommandHandler("mimimi", mimimi))
# sin comando respondemos inline
dp.add_handler(InlineQueryHandler(inlinequery))
# log de errores
dp.add_error_handler(error)
# arranque del bot
updater.start_polling()
# El bot correrá hasta que pulsemo Ctrl+C
updater.idle()
def main() -> None:
# Create the Updater and pass it your bot's token.
updater = Updater("TOKEN")
# Get the dispatcher to register handlers
dispatcher = updater.dispatcher
# on different commands - answer in Telegram
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(CommandHandler("help", help_command))
# on noncommand i.e message - echo the message on Telegram
dispatcher.add_handler(InlineQueryHandler(inlinequery))
# Start the Bot
updater.start_polling()
# Block until the user 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 main():
#676428333:AAEYXfSt7tDKsqSzEloCwUDlgFdv-2tq3UU debug
#873370289:AAEl2az5yYNkZg5cs57J2-_AThtpC_qOVso main
TOKEN = "873370289:AAEl2az5yYNkZg5cs57J2-_AThtpC_qOVso"
updater = Updater(TOKEN)
dispatcher = updater.dispatcher
#Handlers
dispatcher.add_handler(InlineQueryHandler(inlinequery))
dispatcher.add_handler(MessageHandler(Filters.text, message))
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(CallbackQueryHandler(button))
updater.start_webhook(listen="0.0.0.0",
port=PORT,
url_path=TOKEN)
updater.bot.setWebhook("https://iranmeteorologybot.herokuapp.com/" + TOKEN)
#updater.start_polling()
updater.idle()
def main():
updater = Updater('TOKEN')
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CallbackQueryHandler(echo_photo))
dp.add_handler(CommandHandler("photo", photo))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("lang_code", lang_code))
dp.add_handler(CommandHandler("def", defenition,
pass_args=True,
pass_chat_data=True))
dp.add_handler(MessageHandler(Filters.text, echo))
dp.add_handler(MessageHandler(Filters.document, echo_file))
dp.add_handler(MessageHandler(Filters.photo, get_photo))
dp.add_handler(InlineQueryHandler(inlinequery))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
def main():
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
print('bot start')
updater.dispatcher.add_handler(
CommandHandler('mmsi', vesselinfo, None, False, True))
updater.dispatcher.add_handler(
CommandHandler('globallastposdate',
globallastposdate,
None,
False,
pass_args=True))
updater.dispatcher.add_handler(InlineQueryHandler(inlinequery))
updater.dispatcher.add_handler(
ChosenInlineResultHandler(process_chosen,
pass_user_data=True,
pass_chat_data=True,
pass_update_queue=True))
updater.start_polling()
updater.idle()
def __init__(self, bot_token, bot_db):
self.db = bot_db
self.token = bot_token
read_timeout = Cfg.get("telegram", "read_timeout")
connect_timeout = Cfg.get("telegram", "connect_timeout")
kwargs = dict()
if read_timeout:
kwargs["read_timeout"] = read_timeout
if connect_timeout:
kwargs["connect_timeout"] = connect_timeout
try:
self.updater = Updater(bot_token, request_kwargs=kwargs)
except InvalidToken as e:
cls_name = f"Class: {type(self).__name__}"
logging.error(f"{repr(e)} - {cls_name}")
exit("ERROR: Bot token not valid")
self.job_queue = self.updater.job_queue
self.dispatcher = self.updater.dispatcher
# Handler for command-links
self._add_link_handler()
# Load classes in folder 'plugins'
self._load_plugins()
# Handler for inline-mode
self.dispatcher.add_handler(InlineQueryHandler(self._inline))
# Handle all Telegram related errors
self.dispatcher.add_error_handler(self._handle_tg_errors)
# Refresh cache periodically
self._refresh_cache()
# Check for updates periodically
self._update_check()
def main():
"""Start the bot."""
# Create the EventHandler and pass it your bot's token.
updater = Updater("TOKEN")
j = updater.job_queue
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("gitname", gitname))
dp.add_handler(CommandHandler("help", help))
# dp.add_handler(CommandHandler("todo", todo))
dp.add_handler(CommandHandler("done", done))
dp.add_handler(CommandHandler("completed", completed))
dp.add_handler(CommandHandler("tasks", tasks_))
dp.add_handler(CommandHandler("leaderboard", leaderboard))
dp.add_handler(CommandHandler("streak", streak))
dp.add_handler(InlineQueryHandler(inlinequery))
dp.add_handler(CommandHandler("todo", todo))
dp.add_handler(CommandHandler("reminder",reminder,
pass_args=True,
pass_job_queue=True,
pass_chat_data=True))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(MessageHandler(Filters.text, echo))
dp.add_handler(MessageHandler(Filters.command, command_handler))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# 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 run(self):
print("Starting server...")
self.updater = Updater(token = BotServer.TOKEN)
self.dispatcher = self.updater.dispatcher
self.job_queue = self.updater.job_queue
# self.ipchecker = ipchecker.IPChecker(self)
# self.ipchecker.start()
# self.db = database.Database()
# self.db.connect()
self.api = APIClient()
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
start_handler = CommandHandler('start', self.start)
echo_handler = MessageHandler(Filters.text, BotServer.echo)
caps_handler = CommandHandler('caps', BotServer.caps, pass_args=True)
inline_caps_handler = InlineQueryHandler(BotServer.inline_caps)
# checkip_handler = CommandHandler('checkip', self.check_ip)
get_languages_handler = CommandHandler('get_languages', self.get_languages)
unknown_handler = MessageHandler(Filters.command, BotServer.unknown)
self.dispatcher.add_handler(start_handler)
self.dispatcher.add_handler(echo_handler)
self.dispatcher.add_handler(caps_handler)
self.dispatcher.add_handler(inline_caps_handler)
# self.dispatcher.add_handler(checkip_handler)
self.dispatcher.add_handler(get_languages_handler)
self.dispatcher.add_handler(unknown_handler)
print("Server started.")
self.updater.start_polling()
try:
while True:
pass
except KeyboardInterrupt:
print("Stopping server. Please wait...")
# self.db.close()
# self.ipchecker.join()
self.updater.stop()
print("Server stopped.")
def main():
# Create the EventHandler and pass it to the bot's token
updater = Updater(token=TOKEN)
# Get the dispathcher to register handlers
dispatcher = updater.dispatcher
# Add handlers
start_handler = CommandHandler('start', startMsg)
list_exchanges_handler = CommandHandler('list', listExchangesMsg)
price_handler = CommandHandler('price', priceMsg)
fx_handler = CommandHandler('fx', fxMsg)
exchange_handler = CommandHandler('exchange', exchangeMsg)
summary_handler = CommandHandler('summary', summaryMsg)
bitmex_handler = CommandHandler('bitmex', bitmexMsg)
inline_query_handler = InlineQueryHandler(inline_query)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(list_exchanges_handler)
dispatcher.add_handler(price_handler)
dispatcher.add_handler(fx_handler)
dispatcher.add_handler(exchange_handler)
dispatcher.add_handler(summary_handler)
dispatcher.add_handler(bitmex_handler)
dispatcher.add_handler(inline_query_handler)
unknown_handler = MessageHandler(Filters.text, unknownMsg)
dispatcher.add_handler(unknown_handler)
# log all errors
dispatcher.add_error_handler(error)
# start the bot
logger.info("Starting bot.")
updater.start_polling()
# The above runs the bot until CTRL-C or SIGINT, SIGTERM, or SIGABRT is
# received. start_polling() is non-blocking and this will stop the bot
# gracefully
updater.idle()
logger.info("Exiting bot.")
def __init__(self, token):
# Creating the Updater and the dispatcher:
self.logger = logging.getLogger(__name__)
self.bot = Bot(token)
self.updater = Updater(token)
dp = self.updater.dispatcher
# Adding some CommandHandlers:
dp.add_handler(CommandHandler("start", self.start))
dp.add_handler(CommandHandler("help", self.help))
# This CommandHandler will receive arguments from the user:
dp.add_handler(CommandHandler("search", self.search, pass_args=True))
dp.add_handler(CommandHandler("list", self.get_list))
# These will handler callback queries and inline queries:
dp.add_handler(CallbackQueryHandler(self.callback_query_handler))
dp.add_handler(InlineQueryHandler(self.inline_query_handler))
# Log all errors:
dp.add_error_handler(self.error)
def test_illegal_handlers(self):
with self.assertRaises(ValueError):
ConversationHandler(entry_points=[
CommandHandler('/test', lambda bot, update: None)
],
states={},
fallbacks=[],
per_message=True)
with self.assertRaises(ValueError):
ConversationHandler(
entry_points=[CallbackQueryHandler(lambda bot, update: None)],
states={},
fallbacks=[],
per_message=False)
with self.assertRaises(ValueError):
ConversationHandler(
entry_points=[InlineQueryHandler(lambda bot, update: None)],
states={},
fallbacks=[],
per_chat=True)
def main(bot=None):
token = bot_token
updater = Updater(token)
for item in parse_data['items']:
updater.dispatcher.add_handler(CommandHandler(item, commands))
updater.dispatcher.add_handler(CommandHandler('help', start))
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CommandHandler('ping', ping))
updater.dispatcher.add_handler(CommandHandler('info', info))
updater.dispatcher.add_handler(MessageHandler(Filters.text, messages))
updater.dispatcher.add_handler(CallbackQueryHandler(callback))
updater.dispatcher.add_handler(InlineQueryHandler(inline))
updater.dispatcher.add_error_handler(error)
try:
updater.start_polling(clean=True, timeout=120)
updater.idle()
except Exception:
traceback.print_exc()
finally:
sys.exit(1)
def start():
"""Connects to Telegram and starts the bot."""
bot = Updater(token=API_KEY, use_context=True)
dp = bot.dispatcher
# Register inline query handler
dp.add_handler(InlineQueryHandler(on_inline_query))
# Register command handlers
dp.add_handler(CommandHandler("start", on_command_start))
dp.add_handler(CommandHandler("help", on_command_help))
# Register text message handler
dp.add_handler(MessageHandler(Filters.text, on_message_text))
log.info("Bot ready, dood! Connected as {username} (with ID {id}).".format(
username=bot.bot.username,
id=bot.bot.id
))
bot.start_polling()
bot.idle()
def run_bot():
"""Start the bot."""
updater = Updater(config['telegram']['token'])
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("about", about))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("ipsum", ipsum))
dp.add_handler(CommandHandler("feedback", feedback))
dp.add_handler(CallbackQueryHandler(button))
dp.add_handler(InlineQueryHandler(inlinequery))
dp.add_handler(MessageHandler(Filters.text, translation))
dp.add_error_handler(error)
updater.start_polling()
updater.idle()
def add_handlers(dispatcher):
"""Adding inline handlers to dispatcher
:param dispatcher: dispatcher object
:type dispatcher: telegram.dispatcher
"""
dispatcher.add_handler(
CallbackQueryHandler(
Inline.join_program,
pattern='{0}:.+'
.format(Actions.JOIN_PROGRAM)))
# Inline show link to channel
dispatcher.add_handler(
CallbackQueryHandler(
Inline.show_link,
pattern=r'.{60}'))
# On noncommand i.e message - echo the message on Telegram
dispatcher.add_handler(
InlineQueryHandler(
Inline.inline_query_handler))
def start():
# configure logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info("logger initialized. starting bot..")
# get bot token
try:
from bot.api_tokens import get_bot_token
bot_token = get_bot_token()
except TokenNotFoundError:
sys.exit()
tg_updater = tg_ext.Updater(token=bot_token, use_context=True)
dispatcher = tg_updater.dispatcher
# configure command handlers
# general
help_handler = tg_ext.CommandHandler('help', help.help)
dispatcher.add_handler(help_handler)
# popular_locations
popularity_now_handler = CommandHandler('wievolljetzt', send_current_popularity)
dispatcher.add_handler(popularity_now_handler)
setlocation_handler = CommandHandler('setlocation', set_location)
dispatcher.add_handler(setlocation_handler)
popularity_handler = CommandHandler('wievoll', start_popularity_dialog)
dispatcher.add_handler(popularity_handler)
# inline
inline_query_handler = InlineQueryHandler(inline.handle_inline_query)
dispatcher.add_handler(inline_query_handler)
callback_handler = CallbackQueryHandler(inline.handle_inline_callback)
dispatcher.add_handler(callback_handler)
tg_updater.start_polling()
def main():
config = configparser.ConfigParser()
config.read('config.ini')
token = config['DEFAULT']['API_KEY']
Global.games = config['DEFAULT']['GAMES'].split(',')
Global.host = config['DEFAULT']['HOST']
Global.port = config['DEFAULT']['PORT']
Global.featured = config['DEFAULT']['FEATURED']
updater = Updater(token=token)
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(InlineQueryHandler(inlinequery))
updater.dispatcher.add_handler(CallbackQueryHandler(button))
updater.dispatcher.add_error_handler(error)
Global.bot = updater.bot
print("Polling telegram")
updater.start_polling()
print("Starting http server")
http = HTTPServer((Global.host, int(Global.port)), GameHTTPRequestHandler)
http.serve_forever()
def main():
TOKEN = os.environ.get('TOKEN')
PORT = int(os.environ.get('PORT', '5000'))
# Create the Updater and pass it your bot's token.
updater = Updater(TOKEN)
updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TOKEN)
updater.bot.set_webhook("https://filmaffinitybot.herokuapp.com/" + TOKEN)
# Get the dispatcher to register handlers
dp = updater.dispatcher
filmaffinity = FilmaffinityBot()
# on different commands - answer in Telegram
dp.add_handler(CommandHandler("start", filmaffinity.start))
dp.add_handler(CommandHandler("help", filmaffinity.help))
dp.add_handler(
CommandHandler("top_filmaffinity", filmaffinity.top_filmaffinity))
dp.add_handler(CommandHandler("top_netflix", filmaffinity.top_netflix))
dp.add_handler(CommandHandler("top_hbo", filmaffinity.top_hbo))
dp.add_handler(CommandHandler("top_dvd", filmaffinity.top_dvd))
dp.add_handler(CommandHandler("top_movistar", filmaffinity.top_movistar))
dp.add_handler(CommandHandler("top_rakuten", filmaffinity.top_rakuten))
dp.add_handler(CommandHandler("top_tv_series", filmaffinity.top_tv_series))
dp.add_handler(
CommandHandler("recommend_netflix", filmaffinity.recommend_netflix))
dp.add_handler(
CommandHandler("recommend_movistar", filmaffinity.recommend_movistar))
dp.add_handler(CommandHandler("recommend_hbo", filmaffinity.recommend_hbo))
dp.add_handler(CommandHandler("premieres", filmaffinity.premieres))
# on noncommand i.e message - echo the message on Telegram
dp.add_handler(InlineQueryHandler(filmaffinity.inlinequery))
# log all errors
dp.add_error_handler(filmaffinity.error)
# Start the Bot
updater.start_polling()
updater.idle()
def main():
updater = Updater(token = '1105160055:AAGkIIuk_M4B3r_uwumehJwJ8ZLwQDqylqo', use_context = True)
dispatcher = updater.dispatcher
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', start)],
states={
#CPF: [MessageHandler(Filters.text, cpf)],
CPF: [InlineQueryHandler(cpf)],
SENHA: [MessageHandler(Filters.text, senha)]
},
fallbacks = [CommandHandler("sair", sair)]
)
dispatcher.add_handler(conv_handler)
#Log errors
dispatcher.add_error_handler(error)
#Start the bot
updater.start_polling()
updater.idle()
def main():
updater = Updater(token=TOKEN)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('r', command_roll, pass_args=True, pass_chat_data=True))
dispatcher.add_handler(CommandHandler('coc7', coc7stats, pass_args=True))
dispatcher.add_handler(CommandHandler('dnd5e', dnd5e_attributes))
dispatcher.add_handler(CommandHandler('coctrait', coc_trait))
dispatcher.add_handler(CommandHandler('name', random_text('name'), pass_args=True))
dispatcher.add_handler(CommandHandler('male', random_text('name_male'), pass_args=True))
dispatcher.add_handler(CommandHandler('female', random_text('name_female'), pass_args=True))
dispatcher.add_handler(CommandHandler('company', random_text('company'), pass_args=True))
dispatcher.add_handler(CommandHandler('address', random_text('address'), pass_args=True))
dispatcher.add_handler(CommandHandler('city', random_text('city'), pass_args=True))
dispatcher.add_handler(CommandHandler('decide', select, pass_args=True))
dispatcher.add_handler(CommandHandler('choice', select, pass_args=True))
dispatcher.add_handler(CommandHandler('select', select, pass_args=True))
dispatcher.add_handler(InlineQueryHandler(inline_query))
dispatcher.add_error_handler(error)
updater.start_polling()
updater.idle()
def main():
token = "207013186:AAGimWjXwN9PlvHIW_EWfOgbLAQ3SVIESik"
updater = Updater(token, workers=2)
dp = updater.dispatcher
dp.add_handler(InlineQueryHandler(inlinequery))
# Commands
dp.add_handler(CommandHandler("fact", send_fact))
dp.add_handler(CommandHandler("help", send_help))
dp.add_error_handler(error)
updater.start_webhook(
port=int(os.environ.get("DOKKU_PROXY_PORT")),
url_path=token,
)
print('Listening...')
logging.info('Listening...')
updater.idle()
def __init__(self):
load_dotenv()
token = os.getenv('TOKEN')
# proxy_url = os.getenv('PROXY_URL')
# proxy_username = os.getenv('PROXY_USERNAME')
# proxy_password = os.getenv('PROXY_PASSWORD')
# request_kwargs = {
# 'proxy_url': proxy_url,
# 'urllib3_proxy_kwargs': {
# 'username': proxy_username,
# 'password': proxy_password,
# }
# }
self.updater = Updater(token, use_context=True)
self.dp = self.updater.dispatcher
self.dp.add_handler(CommandHandler('tags', self.get_tags))
self.dp.add_handler(CommandHandler('start', self.start_command))
self.dp.add_handler(CommandHandler('help', self.help_command))
self.dp.add_handler(InlineQueryHandler(self.inlinequery))
self.dp.add_error_handler(self.error)
def main():
# Create the Updater and pass it your bot's token.
updater = Updater(BOT_TOKEN)
# Get the dispatcher to register handlers
dp = updater.dispatcher
# 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)
# Start the Bot
updater.start_polling()
# Block until the user 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 main():
# creating bot
bot = Updater(TOKEN, use_context=True, request_kwargs=PROXY)
# creating dispatcher
dp = bot.dispatcher
# creating job for regular sync database
bot.job_queue.run_repeating(callback=sync_current_leagues,
interval=3600,
first=10)
bot.job_queue.run_repeating(callback=sync_game_current_league,
interval=3600,
first=10)
bot.job_queue.run_repeating(callback=sync_league_baner,
interval=3600,
first=40)
# TODO get_baner
# creating write in log about start bot
logging.info("Bot is run")
# creating handlers
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("help", help_me))
dp.add_handler(
MessageHandler(Filters.regex("OK, search informations about(.*)"),
view_league_info))
dp.add_handler(
CallbackQueryHandler(view_game_info, pattern="^view_game_info \d+$"))
dp.add_handler(CallbackQueryHandler(subs_video,
pattern="^subs_video \d+$"))
dp.add_handler(CallbackQueryHandler(subs_text, pattern="^subs_text \d+$"))
dp.add_handler(InlineQueryHandler(inlinequery))
# dp.add_handler(CommandHandler("alarm", set_alarm, pass_args=True, pass_job_queue=True))
# run bot
bot.start_polling()
bot.idle()
def main():
updater = Updater(token=TOKEN, request_kwargs=REQUEST_KWARGS)
dispatcher = updater.dispatcher
# Add conversation handler
conv_handler = ConversationHandler(
entry_points=[CommandHandler("start", start)],
states={
CHOOSING: [CallbackQueryHandler(button)],
WEATHER: [
MessageHandler(Filters.location | Filters.text, get_weather),
CommandHandler("back", back)
],
CURRENCY: [
MessageHandler(Filters.text, get_currency),
CommandHandler("back", back)
],
},
fallbacks=[CommandHandler("finish", finish)])
# handlers
help_handler = CommandHandler("help", help)
inline_switch_pm_handler = InlineQueryHandler(inline_switch_pm)
unknown_handler = MessageHandler(Filters.command, unknown)
# registration handlers
dispatcher.add_handler(help_handler)
dispatcher.add_handler(conv_handler)
dispatcher.add_handler(inline_switch_pm_handler)
dispatcher.add_handler(unknown_handler)
# log all errors
dispatcher.add_error_handler(error)
# start the bot
updater.start_polling(timeout=5)
# stop the bot gracefully
updater.idle()
def main():
# Create the EventHandler and pass it your bot's token.
updater = Updater(CONFIGURATION["telegram_token"])
global RESPONSE_DICT
# Load the responses
RESPONSE_DICT = EmojiconFinder.load_response_json(
CONFIGURATION["responses_file"])
# Get the dispatcher to register handlers
dp = updater.dispatcher
# Add conversation handler with the states EMOJICONNAME e EMOJICON
conv_handler = ConversationHandler(
entry_points=[CommandHandler('addemojicon', addemojicon_command)],
states={
EMOJICONNAME: [MessageHandler(Filters.text, emojiconname_command)],
EMOJICON: [MessageHandler(Filters.text, newemojicon_command)]
},
fallbacks=[CommandHandler('cancel', cancel)])
dp.add_handler(conv_handler)
dp.add_handler(CommandHandler("start", start_command))
dp.add_handler(CommandHandler("starten", starten_command))
dp.add_handler(CommandHandler("help", help_command))
dp.add_handler(CommandHandler("helpen", helpen_command))
dp.add_handler(InlineQueryHandler(inline_busca_emojicon))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# 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():
global popularity
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO,
)
# load popularity numbers from disk
if popularity_filename:
try:
with open(popularity_filename, "r") as popularity_data:
popularity = json.load(popularity_data)
logging.info(
f"popularity numbers loaded from {popularity_filename}.")
except FileNotFoundError:
logging.warning(
f"popularity data could not be found at {popularity_filename}; counting from scratch."
)
else:
logging.warning(
"POPULARITY_DATA not set, popularity will not be saved for this session."
)
u = Updater(token=api_token, use_context=True)
d = u.dispatcher
d.add_handler(InlineQueryHandler(callback=process_query, ))
d.add_handler(ChosenInlineResultHandler(callback=count_hits, ))
d.add_error_handler(report_error)
j = u.job_queue
if ranking_update_frequency:
j.run_repeating(update_ranking, ranking_update_frequency)
else:
update_ranking(None) # guarantees update_ranking runs on startup
u.start_polling()
u.idle()
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 main():
users = defaultdict(User)
updater = Updater(BOT_TOKEN)
dp = updater.dispatcher
dp.add_handler(InlineQueryHandler(on_inline))
dp.add_handler(ChosenInlineResultHandler(on_inline_chosen))
dp.add_handler(
CallbackQueryHandler(
lambda bot, update: on_callback_query(bot, update, users)))
dp.add_handler(
CommandHandler(
'start',
lambda bot, update, args: cmd_start(bot, update, args, users),
pass_args=True))
dp.add_handler(
CommandHandler('cancel',
lambda bot, update: cmd_cancel(bot, update, users)))
dp.add_handler(CommandHandler('clear', cmd_clear))
dp.add_handler(CommandHandler('help', cmd_help))
dp.add_handler(CommandHandler('unban', cmd_unban, pass_args=True))
dp.add_handler(
MessageHandler(Filters.all,
lambda bot, update: on_message(bot, update, users)))
dp.add_error_handler(error)
j = updater.job_queue
j.run_repeating(lambda bot, job: database.store_request_count(),
interval=5,
first=0)
j.run_repeating(job_forget_old_owners, interval=60, first=0)
updater.start_polling()
updater.idle()
