def main(dp, group):
for i in [
tg_ext.CommandHandler('reboot', bot_reboot),
tg_ext.CommandHandler('shutdown', bot_shutdown),
tg_ext.CommandHandler('usage', bot_usage),
tg_ext.CommandHandler('leave', bot_leave),
]: dp.add_handler(i, group)
def start_telegram_bot():
updater = telegram.Updater("576999277:AAGFOfw8WUOz2FB-TGgTVkNjBdkLZC1AAUU")
# Get the dispatcher to register handlers
dp = updater.dispatcher
# on different commands - answer in Telegram
dp.add_handler(telegram.CommandHandler("start", start))
dp.add_handler(telegram.CommandHandler("help", start))
dp.add_handler(
telegram.CommandHandler("set",
set_timer,
pass_args=True,
pass_job_queue=True,
pass_chat_data=True))
dp.add_handler(telegram.CommandHandler("unset", unset,
pass_chat_data=True))
# log all errors
dp.add_error_handler(error)
# Start the Bot
updater.start_polling()
# Block 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.
pool = ThreadPool(1)
pool.map(updater.idle, [])
return updater
def main():
console.log('Starting...')
exchanges['bitstamp'] = Exchange(
ccxt.bitstamp(config=config.bitstamp.to_dict()))
exchanges['binance'] = Exchange(
ccxt.binance(config=config.binance.to_dict()))
exchanges['bittrex'] = Exchange(
ccxt.bittrex(config=config.bittrex.to_dict()))
exchanges['cryptopia'] = Exchange(
ccxt.cryptopia(config=config.cryptopia.to_dict()))
exchanges['hitbtc'] = Exchange(
ccxt.hitbtc2(config=config.hitbtc.to_dict()))
telebot.add_handler(
telegram.CommandHandler(command='balance',
callback=TelegramCommands.get_balance))
telebot.add_handler(
telegram.CommandHandler(command='start',
callback=TelegramCommands.start))
telebot.add_handler(
telegram.CommandHandler(command='help',
callback=TelegramCommands.show_help))
telebot.start()
console.log('Ready...')
telebot.idle()
def init_handlers(dispatcher):
global debug_mode
debug_mode = False
# start command
start_handler = ext.CommandHandler('start', start)
dispatcher.add_handler(start_handler)
# add to follower list
# TODO: do a thing when not given an argument
follow_handler = ext.CommandHandler('follow', follow, pass_args=True)
dispatcher.add_handler(follow_handler)
# list followers
list_handler = ext.CommandHandler('list_followed', list_followed)
dispatcher.add_handler(list_handler)
# help command
help_handler = ext.CommandHandler("help", help)
dispatcher.add_handler(help_handler)
# debug command
debug_handler = ext.CommandHandler("debug", debug)
dispatcher.add_handler(debug_handler)
def run_tbot(ip):
updater = ext.Updater(token=token)
sounds = get_sounds()
sound_keys = sorted(list(sounds.keys()))
def generic(bot, update):
sound = sounds[update.message.text[1:]]
requests.get('http://{}:5000/play_sound/{}'.format(ip, sound))
bot.send_message(chat_id=update.message.chat_id, text='sent: {}'.format(sound))
def play(bot, update):
keyboard = [
[
InlineKeyboardButton(sound_keys[2*i], callback_data=sounds[sound_keys[2*i]]),
InlineKeyboardButton(sound_keys[2*i+1], callback_data=sounds[sound_keys[2*i+1]]) \
if 2*i+1 < len(sound_keys) else InlineKeyboardButton('', callback_data=sounds[sound_keys[2*i]]),
] for i in range((len(sound_keys) +1 ) //2)
]
reply_markup = InlineKeyboardMarkup(keyboard)
update.message.reply_text('Buttons:', reply_markup=reply_markup)
def button(bot, update):
query = update.callback_query
requests.get('http://{}:5000/play_sound/{}'.format(ip, query.data))
bot.edit_message_text(text="sent: {}".format(query.data),
chat_id=query.message.chat_id,
message_id=query.message.message_id)
updater.dispatcher.add_handler(ext.CallbackQueryHandler(button))
updater.dispatcher.add_handler(ext.CommandHandler('play', play))
for key in sound_keys:
updater.dispatcher.add_handler(ext.CommandHandler(key, generic))
updater.start_polling()
def main(dp, group):
for i in [
tg_ext.CommandHandler('audio', youtube_audio, pass_args = True),
tg_ext.CommandHandler('video', youtube_video, pass_args = True),
tg_ext.CommandHandler('nightcore', youtube_nightcore, pass_args = True),
tg_ext.CommandHandler('daycore', youtube_daycore, pass_args = True),
tg_ext.CommandHandler('debug', youtube_debug, pass_args = True),
]: dp.add_handler(i, group)
def group_conv():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('view', group_view)],
states={},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def change_logiks():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('change', logik_change)],
states={
LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, enter_logiks)],
},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def main():
global welcome_message
global command_list_message
try:
with open("welcome.txt", 'r', encoding='utf8') as welcome_file:
welcome_message = welcome_file.read()
except FileNotFoundError:
logger.error('failed to load welcome.txt')
try:
with open("commands.txt", 'r', encoding='utf8') as commands_file:
command_list_message = commands_file.read()
except FileNotFoundError:
logger.error('failed to load welcome.txt')
updater = ext.Updater(os.environ['TELEGRAM_BOT_KEY'])
dispatcher = updater.dispatcher
dispatcher.add_handler(ext.CommandHandler('cadastro', register))
dispatcher.add_handler(ext.CommandHandler('start', hello))
#dispatcher.add_handler(ext.CommandHandler('cadastrar', signup))
dispatcher.add_handler(ext.CommandHandler('email', update_email, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('planilha', register_spreadsheet_name, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('telegram', change_alert_telegram, pass_args=True))
dispatcher.add_handler(ext.CommandHandler('limpar_email', clear_email))
dispatcher.add_handler(ext.CommandHandler('ajuda', help))
dispatcher.add_handler(ext.CommandHandler('dia', show_weekday_keyboard))
dispatcher.add_handler(ext.CommandHandler('teste', show_names_suggestion))
dispatcher.add_handler(ext.CallbackQueryHandler(callback_handler))
dispatcher.add_handler(ext.MessageHandler(ext.Filters.text, text_decoder))
logger.info("Starting polling")
updater.start_polling()
logger.info("Bot in idle, awaiting users messages")
updater.idle()
def people_conv():
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('teacher_admin', teacher_admin)],
states={
GR_ID: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, gr_id)],
USERNAME: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, username)],
LOGIKS: [ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, logiks)],
},
fallbacks=[ext.CommandHandler('cancel', cancel)],
)
dispatcher.add_handler(conv_handler)
def main():
print("Connection to Telegram established; starting bot.")
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('start', start, pass_user_data=True)],
states={
CHOOSING: [
ext.RegexHandler('^(Nama|NIM_or_NIP|Email)$',
regular_choice,
pass_user_data=True),
],
TYPING_CHOICE: [
ext.MessageHandler(ext.Filters.text,
regular_choice,
pass_user_data=True),
],
TYPING_REPLY: [
ext.MessageHandler(ext.Filters.text,
received_information,
pass_user_data=True),
],
},
fallbacks=[ext.RegexHandler('^Done$', done, pass_user_data=True)])
dp.add_handler(conv_handler)
# log all errors
dp.add_error_handler(error)
# Start command
# dp.add_handler(ext.CommandHandler(
# ('start'), start))
# Home command
dp.add_handler(ext.CommandHandler(('home'), home))
# Tata Tulis PKL dan TA
dp.add_handler(ext.CommandHandler(('tatatulis'), tatatulis))
# Layanan TA
dp.add_handler(ext.CommandHandler(('layananta'), layananta))
# Layanan PKL
dp.add_handler(ext.CommandHandler(('layananpkl'), layananpkl))
# Button Handler
dp.add_handler(ext.CallbackQueryHandler(button))
# Filter Command
dp.add_handler(ext.MessageHandler((ext.Filters.command), unknowncommand))
updater.start_polling()
updater.idle()
def main():
""" Inicie o bot e habilite o reconhecimento dos comandos iniciar,
twitter e tts. Além disso, permita a identificação de áudio
enviado ao grupo.
"""
updater = ext.Updater(bot_key)
dp = updater.dispatcher
dp.add_handler(ext.MessageHandler(ext.Filters.voice, voz))
dp.add_handler(ext.CommandHandler('iniciar', iniciar))
dp.add_handler(ext.CommandHandler('twitter', twitter))
dp.add_handler(ext.CommandHandler('tts', tts))
updater.start_polling()
updater.idle()
def main(dispatcher):
send_broadcast_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('send_broadcast', __send_broadcast)],
states={
REVIEW: [ext.MessageHandler(ext.Filters.text, __review_message)],
CONFIRMATION: [
ext.MessageHandler(ext.Filters.regex('Yes|No'),
__confirm_broadcast)
]
},
fallbacks=[ext.CommandHandler('cancel', __send_broadcast_cancel)])
dispatcher.add_handler(send_broadcast_handler)
def __set_handlers(self) -> None:
self.__dispatcher.add_handler(
tg_ext.MessageHandler(filters=tg_ext.Filters.text
& ~tg_ext.Filters.command,
callback=self.__send_weather_callback))
self.__dispatcher.add_handler(
tg_ext.CommandHandler(command='start',
callback=self.__start_command_callback))
self.__dispatcher.add_handler(
tg_ext.CommandHandler(command='help',
callback=self.__help_command_callback))
def main():
'''
Main function to run the bot.
'''
# set up updater and dispatcher
updater = tg.Updater(_get_token())
dp = updater.dispatcher
jq = updater.job_queue
# JobQueue functions
job_bday = jq.run_repeating(callback_birthday,
interval=timedelta(days=1),
first=_get_tmr())
# Event related
dp.add_handler(tg.CommandHandler('event', event))
# dp.add_handler(tg.CommandHandler('trophy', trophy))
# dp.add_handler(tg.RegexHandler(patterns['top'], top))
# Gacha related
dp.add_handler(tg.CommandHandler('gacha', gacha))
# dp.add_handler(tg.CommandHandler('nextgacha', next_gacha))
# dp.add_handler(tg.RegexHandler(patterns['roll'], roll))
# Others
dp.add_handler(tg.RegexHandler(patterns['help'], help))
dp.add_handler(tg.RegexHandler(patterns['calmdown'], calmdown))
dp.add_handler(tg.RegexHandler(patterns['ken'], ken))
dp.add_handler(tg.RegexHandler(patterns['epluslomo'], epluslomo))
# Twitter forwarding
dp.add_handler(
tg.MessageHandler(tg.Filters.chat(chat_id=_get_forward('Chihiro')),
forward))
# Debug
dp.add_handler(
tg.MessageHandler(tg.Filters.user(username=_get_username()), debug))
# log 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 create_tg_conversation_handler(self) -> tg.ConversationHandler:
return tg.ConversationHandler(
entry_points=[tg.CommandHandler('start', self.start)],
states={
STAGE_SET_KEY: [tg.MessageHandler(Filters.text, self.set_key)]
},
fallbacks=[])
def __init__(self, config: Config, engine: Engine):
self.updater = tg.Updater(config.token,
workers=1,
request_kwargs={
'proxy_url': config.proxy_url,
'urllib3_proxy_kwargs': {
'username': config.proxy_username,
'password': config.proxy_password,
},
})
self.config = config
self.engine = engine
self.logger = logging.getLogger(__name__)
dp = self.updater.dispatcher
rm_setting_handler = RedmineSettingHandler(
engine, self.config, self.logger).create_tg_conversation_handler()
dp.add_handler(rm_setting_handler)
rm_task_handler = RedmineTrackHandler(
engine, self.config, self.logger).create_tg_conversation_handler()
dp.add_handler(rm_task_handler)
dp.add_handler(tg.CommandHandler('help', self.help))
dp.add_error_handler(self.error)
def main(dispatcher):
add_word_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('add_word', __add_word)],
states={
WORD: [ext.MessageHandler(ext.Filters.text, __set_word)],
MEANING: [
ext.MessageHandler(ext.Filters.text, __set_meaning),
ext.CallbackQueryHandler(__word_meaning_verification,
pattern=r'^word_meaning:\d$')
],
MEANING_ERROR:
[ext.MessageHandler(ext.Filters.text, __handle_meaning_error)],
},
fallbacks=[ext.CommandHandler('cancel', __add_word_cancel)])
dispatcher.add_handler(add_word_handler)
def add_handlers(dispatcher: tg.ext.Dispatcher):
start_handler = tge.CommandHandler('start', start_callback)
dispatcher.add_handler(start_handler)
tree_handler = tge.CommandHandler('tree', tree_callback)
dispatcher.add_handler(tree_handler)
callback_handler = tge.CallbackQueryHandler(query_callback)
dispatcher.add_handler(callback_handler)
link_handler = tge.MessageHandler(
filters=tgFilters.text &
(tgFilters.entity(tg.MessageEntity.URL)
| tgFilters.entity(tg.MessageEntity.TEXT_LINK)),
callback=link_callback)
dispatcher.add_handler(link_handler)
def create_updater(token):
updater = tg.Updater(token=token)
for command in commands:
handler = tg.CommandHandler(command.__name__, command)
updater.dispatcher.add_handler(handler)
return updater
def main():
try:
console.log('Starting...')
target_user_trades = queue.Queue()
target_user_trades_fetched = threading.Event()
trader = Trader(ex_api=exchange_api)
trader.start()
analyzer = Analyzer(ex_api=exchange_api,
target_user_trades=target_user_trades,
target_user_trades_fetched=target_user_trades_fetched)
analyzer.start()
trade_book_loader = TradeBookWatcher(ex_api=exchange_api,
target_user_trades=target_user_trades,
target_user_trades_fetched=target_user_trades_fetched)
trade_book_loader.start()
market_price_watcher = MarketPriceWatcher(ex_api=exchange_api)
market_price_watcher.start()
telebot.add_handler(telegram.CommandHandler(command='prices', callback=telegram_get_market_prices))
telebot.add_handler(telegram.CommandHandler(command='buy', callback=telegram_create_buy_order))
telebot.add_handler(telegram.CommandHandler(command='sell', callback=telegram_create_sell_order))
telebot.start()
console.log('Ready!')
try:
while trader.is_alive() \
and analyzer.is_alive() \
and trade_book_loader.is_alive() \
and market_price_watcher.is_alive() \
and telebot.is_alive():
time.sleep(5)
except:
telebot.stop()
while telebot.is_alive():
time.sleep(1)
raise
except KeyboardInterrupt:
return
except:
raise
finally:
console.log('', n=1)
def main_bot():
persistence = te.PicklePersistence(
filename=configuration["filenames"]["persistence"])
defaults = te.Defaults(parse_mode=tele.ParseMode.HTML)
token = get_secret_token()
updater = te.Updater(token=token,
use_context=True,
persistence=persistence,
defaults=defaults)
dispatcher = updater.dispatcher
dispatcher.add_handler(te.CommandHandler("start", start_callback))
dispatcher.add_handler(te.CommandHandler("help", help_callback))
dispatcher.add_handler(te.CommandHandler("aiuto", help_callback))
dispatcher.add_handler(
te.MessageHandler(te.Filters.regex(r'^/id'), id_callback))
dispatcher.add_handler(te.CommandHandler("dosi", dosi_callback))
dispatcher.add_handler(te.CommandHandler("stagione", stagione_callback))
dispatcher.add_handler(te.CommandHandler("categorie", categorie_callback))
dispatcher.add_handler(te.CommandHandler("portate", portate_callback))
dispatcher.add_handler(te.CallbackQueryHandler(portate_button_callback))
dispatcher.add_handler(te.MessageHandler(te.Filters.text, query_callback))
dispatcher.add_error_handler(error_callback)
updater.start_polling()
updater.idle()
def setup_handlers(self):
"""
Cria os comandos do bot
"""
# Começar
self.dispatcher.add_handler(
tgm.CommandHandler(command="start", callback=self.start_handler))
# Ajuda
self.dispatcher.add_handler(
tgm.CommandHandler(command="ajuda", callback=self.help_handler))
# Informações
self.dispatcher.add_handler(
tgm.CommandHandler(command="info", callback=self.info_handler))
# Cadastrar chat
self.dispatcher.add_handler(
tgm.CommandHandler(command="cadastrar",
callback=self.subscribe_handler))
# Descadastrar chat
self.dispatcher.add_handler(
tgm.CommandHandler(command="descadastrar",
callback=self.unsubscribe_handler))
# Listar sites
self.dispatcher.add_handler(
tgm.CommandHandler(command="listar_sites",
callback=self.list_scrapers))
# Atualizar tudo
self.dispatcher.add_handler(
tgm.CommandHandler(command="atualizar_tudo",
callback=self.update_all))
# Comandos concurso
self.dispatcher.add_handler(
tgm.CallbackQueryHandler(callback=self.button_actions))
# Erro
self.dispatcher.add_error_handler(callback=self.error_handler)
def main(dispatcher):
get_suggestions_handler = ext.CommandHandler('get_suggestions',
__get_suggestions)
get_suggestions_callback_handler = ext.CallbackQueryHandler(
__handle_suggestion_callback, pattern=r'^[1,0],.*$')
dispatcher.add_handler(get_suggestions_handler)
dispatcher.add_handler(get_suggestions_callback_handler)
def main(dp, group):
for i in [
tg_ext.CommandHandler('set', set_parser, pass_args=True),
tg_ext.CommandHandler('get', get_parser, pass_args=True),
tg_ext.CommandHandler('del', del_parser, pass_args=True),
tg_ext.CommandHandler('reg', registry_search, pass_args=True),
tg_ext.CommandHandler('s', set_parser, pass_args=True),
tg_ext.CommandHandler('g', get_parser, pass_args=True),
tg_ext.CommandHandler('d', del_parser, pass_args=True),
tg_ext.CommandHandler('r', registry_search, pass_args=True),
tg_ext.MessageHandler(tg_ext.Filters.all, register),
]:
dp.add_handler(i, group)
def main():
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(message)s")
updater = tex.Updater(
token='1611542237:AAGPMlkeNxp3geL0urxsSsBncnOBROjctsg')
dp = updater.dispatcher
# Handler do jogo
game_handler = tex.ConversationHandler(
entry_points=[tex.CommandHandler('start', start)],
states={'ROUND': [tex.CallbackQueryHandler(round)]},
fallbacks=[tex.CommandHandler('start', start)])
dp.add_handler(game_handler)
updater.start_polling()
logging.info("=== Bot running! ===")
updater.idle()
logging.info("=== Bot shutting down! ===")
def main(dp, group):
for i in [
tg_ext.CommandHandler('info', info_meta, pass_args=True),
tg_ext.CommandHandler('i', info_meta, pass_args=True),
tg_ext.CommandHandler('iu', info_user, pass_args=True),
tg_ext.CommandHandler('ic', info_chat, pass_args=True),
tg_ext.CommandHandler('im', info_message, pass_args=True),
tg_ext.CommandHandler('if', info_forward, pass_args=True),
tg_ext.CommandHandler('iF', info_full, pass_args=True),
]:
dp.add_handler(i, group=group)
def run(self):
"""
Run your bot with all command added
"""
self._generate_help()
self._dispatcher.add_handler(handler=ext.CommandHandler(
"help", self._help()),
group=ext.dispatcher.DEFAULT_GROUP)
self._dispatcher.add_handler(handler=ext.MessageHandler(
ext.Filters.command, self._unknown_command),
group=ext.dispatcher.DEFAULT_GROUP)
self._updater.start_polling()
self.stop()
def main():
parser = create_parser()
args = parser.parse_args()
# bot auth
updater = te.Updater(token=args.token)
dispatcher = updater.dispatcher
# database
client = pymongo.MongoClient('localhost',
username=args.dbuser,
password=args.dbpasswd,
authSource='training',
authMechanism='SCRAM-SHA-1')
db = client.training
# TODO one config file
with open('keys.json', 'r') as f:
keys = json.loads(f.read())
with open('attributes.json', 'r') as f:
attrs = json.loads(f.read())
with open('collections.json', 'r') as f:
collections = json.loads(f.read())
gym_bot = logbot.LogBot(db=db,
keys=keys,
attrs=attrs,
collections=collections)
# TODO better logging!
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# help_handler = te.CommandHandler('help', gym_bot.send_help)
# dispatcher.add_handler(help_handler)
stronglift_handler = te.CommandHandler('stronglift', gym_bot.stronglift)
dispatcher.add_handler(stronglift_handler)
# message handler
msg_handler = te.MessageHandler(te.Filters.chat(args.user_id), gym_bot.analyze_msg)
dispatcher.add_handler(msg_handler)
# t0 = datetime.time(hour=0, minute=8)
job_queue = dispatcher.job_queue
# job_queue.run_repeating(callback=gym_bot.job, interval=30, first=0)
updater.start_polling()
def register_command_route(self, route: CommandRoute) -> None:
"""
Registers given command handler.
.........
Arguments
---------
route: CommandRoute, required
route to register
"""
self.__command_routes.append(route)
self.__tg.add_handler(
tg_ext.CommandHandler(command=route.command,
callback=self.__serve_command_route))
