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 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(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 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 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 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 main():
updater = ext.Updater('1267970793:AAFIiTln0imXgRAQQOk3rX-byuEmZXf7A_s', use_context=True)
dp = updater.dispatcher
dp.add_handler(ext.MessageHandler(ext.Filters.text, route))
dp.add_handler(ext.CallbackQueryHandler(call, pattern=r'[^0]'))
dp.add_handler(ext.CallbackQueryHandler(final_times, pattern=r'[0]'))
updater.start_polling()
updater.idle()
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 __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 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 decorator(callback):
self._dispatcher.add_handler(handler=ext.MessageHandler(
filters=filters,
callback=callback,
allow_edited=allow_edited,
pass_update_queue=pass_update_queue,
pass_job_queue=pass_job_queue,
pass_user_data=pass_user_data,
pass_chat_data=pass_chat_data,
message_updates=message_updates,
channel_post_updates=channel_post_updates,
edited_updates=edited_updates),
group=group)
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():
""" 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():
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_document_route(self, route: DocumentRoute) -> None:
"""
Registers given document handler.
.........
Arguments
---------
route: DocumentRoute, required
route to register
"""
self.__doсument_routes.append(route)
self.__tg.add_handler(
tg_ext.MessageHandler(filters=tg_ext.Filters.document,
callback=self.__serve_document_route))
def register_image_route(self, route: ImageRoute) -> None:
"""
Registers given image handler.
.........
Arguments
---------
route: ImageRoute, required
route to register
"""
self.__image_routes.append(route)
self.__tg.add_handler(
tg_ext.MessageHandler(filters=tg_ext.Filters.photo,
callback=self.__serve_image_route))
def register_message_route(self, route: MessageRoute) -> None:
"""
Registers given text message handler.
.........
Arguments
---------
route: MessageRoute, required
route to register
"""
self.__message_routes.append(route)
self.__tg.add_handler(
tg_ext.MessageHandler(filters=tg_ext.Filters.regex(route.message),
callback=self.__serve_message_route))
def start_telegram_updater():
updater = t_ext.Updater(os.environ["CECIBOT_TELEGRAM_SECRET"])
updater.dispatcher.add_handler(t_ext.ConversationHandler(
entry_points=[
t_ext.CommandHandler("start", start),
t_ext.MessageHandler(t_ext.Filters.text, only)
],
allow_reentry=True,
states={},
fallbacks=[],
))
updater.dispatcher.add_error_handler(error)
updater.start_polling()
def __init__(self):
self.Pyborg = pyborg.pyborg(settings.get('gentbot'))
self.Learning = settings.get('gentbot').get('learning')
self.ReplyRate = settings.get('gentbot').get('replyrate')
self.Name = settings.get('gentbot').get('name')
self.updater = telext.Updater(
token=settings.get('telegram').get('token'))
# Setting up handlers
dispatcher = self.updater.dispatcher
gent_handler = telext.MessageHandler(telext.Filters.text, self.process)
# Adding handlers
dispatcher.add_handler(gent_handler)
dispatcher.add_handler(telext.CommandHandler("save", self.save))
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 main():
with open('config.json') as json_file:
config = json.load(json_file)
updater = tgext.Updater(token=config['token'], use_context=True)
valid_user: Set[int] = set(config['valid_user'])
lamp_url = config['url']
auth = config['auth']
start_handler = tgext.CommandHandler('start', start)
dispatcher = updater.dispatcher
dispatcher.add_handler(start_handler)
control_light_handler = tgext.MessageHandler(
tgext.Filters.text, make_control_light(valid_user, lamp_url, auth))
dispatcher.add_handler(control_light_handler)
updater.start_polling()
def main(dp, group):
for chat_id in [
i for i in configs
if check_conf(i + '.questions.enabled', bool, False)
]:
name = 'question' + chat_id
dp.chat_data[int(chat_id)][name] = dp.job_queue.run_repeating(
callback=send_question,
interval=check_conf(chat_id + '.questions.timer', int, 60 * 60),
context=chat_id,
name=name,
)
for i in [
tg_ext.MessageHandler(tg_ext.Filters.all,
queue_question,
pass_job_queue=True,
pass_chat_data=True),
]:
dp.add_handler(i, group)
def main():
token_filename = 'token.txt'
if os.path.exists(token_filename):
with open(token_filename, 'r') as token_file:
token = token_file.read().strip()
else:
token = os.environ['TOKEN']
updater = ext.Updater(
token=token,
use_context=True,
)
dispatcher = updater.dispatcher
start_handler = ext.CommandHandler('start', start)
dispatcher.add_handler(start_handler)
country_handler = ext.MessageHandler(ext.Filters.text, get_country_info)
dispatcher.add_handler(country_handler)
logger.info("Ready!")
mode = os.environ.get('MODE', 'dev')
if mode == 'prod':
port = int(os.environ.get("PORT", "8443"))
HEROKU_APP_NAME = os.environ.get("HEROKU_APP_NAME", "covid19-infobot")
# Code from https://github.com/python-telegram-bot/python-telegram-bot/wiki/Webhooks#heroku
updater.start_webhook(listen="0.0.0.0",
port=port,
url_path=token)
updater.bot.set_webhook(
"https://{}.herokuapp.com/{}".format(HEROKU_APP_NAME, token))
elif mode == 'dev':
updater.start_polling()
else:
logger.error("No MODE specified!")
sys.exit(1)
def create_tg_conversation_handler(self):
return tg.ConversationHandler(
entry_points=[
tg.CommandHandler('track', self.start, pass_user_data=True)
],
states={
SET_SPENT_ON: [
tg.CallbackQueryHandler(self.spent_on,
pattern='^\d{4}-\d{2}-\d{2}$',
pass_user_data=True)
],
SET_ISSUE: [
tg.CallbackQueryHandler(self.issue,
pattern='^\d+$',
pass_user_data=True)
],
SET_COMMENTS: [
tg.MessageHandler(Filters.text,
self.comment,
pass_user_data=True)
],
SET_HOURS: [
tg.CallbackQueryHandler(self.add_hours,
pattern='^[\\d.]+$',
pass_user_data=True),
tg.CallbackQueryHandler(self.reset_hours,
pattern='^Reset$',
pass_user_data=True)
],
},
fallbacks=[
tg.CallbackQueryHandler(self.done,
pattern='^Done$',
pass_user_data=True),
tg.CommandHandler('cancel', self.cancel, pass_user_data=True)
],
)
def cancel(update, context):
user = update.message.from_user
logger.info("User %s canceled the conversation.", user.first_name)
update.message.reply_text('Oh no! :(')
return ext.ConversationHandler.END
VOICE, COMUNE = range(2)
conv_handler = ext.ConversationHandler(
entry_points=[ext.CommandHandler('sample', sample)],
states={
COMUNE:
[ext.MessageHandler(ext.Filters.text & ~ext.Filters.command, comune)],
VOICE:
[ext.MessageHandler(ext.Filters.audio | ext.Filters.voice, audio)]
},
fallbacks=[ext.CommandHandler('cancel', cancel)])
with open('token', 'r') as tok_f:
token = tok_f.read().strip()
updater = ext.Updater(token=token, use_context=True)
dispatcher = updater.dispatcher
dispatcher.add_handler(start_handler)
dispatcher.add_handler(debug_handler)
dispatcher.add_handler(conv_handler)
dotenv.load_dotenv()
TG_BOT_TOKEN = os.getenv('TG_BOT_TOKEN')
PROXY = os.getenv('PROXY') # Fill in .env if you are from mother Russia
DF_PROJECT_ID = os.getenv('DF_PROJECT_ID')
DF_CREDENTIALS_PATH = os.getenv('DF_CREDENTIALS_PATH')
DF_SESSION_ID = os.getenv('DF_SESSION_ID')
DF_LANGUAGE_CODE = os.getenv('DF_LANGUAGE_CODE')
# For deploy local
if DF_CREDENTIALS_PATH is not None:
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = DF_CREDENTIALS_PATH
# create updater. More highlevel interface of Bot
request_kwargs = None
if PROXY is not None:
request_kwargs = {'proxy_url': PROXY}
updater = ext.Updater(token=TG_BOT_TOKEN, request_kwargs=request_kwargs)
# add handlers
msg_handler = lambda bot, update: dialog_flow_answer(
bot, update, DF_PROJECT_ID, DF_SESSION_ID, DF_LANGUAGE_CODE)
updater.dispatcher.add_handler(ext.CommandHandler('start', start))
updater.dispatcher.add_handler(
ext.MessageHandler(ext.Filters.text, msg_handler))
while True:
try:
updater.start_polling()
except Exception:
logger.exception('Critical error in ')
username = update.effective_user.username
user = active_users.get_user(username)
update.message.reply_text(ans.answers[ans.BYE][user.language])
user.delete_document()
return tg_ext.ConversationHandler.END
create_pdf_handler = tg_ext.ConversationHandler(
entry_points=[tg_ext.CommandHandler('create_pdf', create_pdf)],
states={
FILENAME: [
tg_ext.MessageHandler(
tg_ext.Filters.text & ~tg_ext.Filters.command, get_filename)
],
AMOUNT_OF_PHOTOS: [
tg_ext.MessageHandler(
tg_ext.Filters.text & ~tg_ext.Filters.command,
get_amount_of_photo)
],
PHOTO: [tg_ext.MessageHandler(tg_ext.Filters.photo, get_photo)],
ADD_OR_END: [
tg_ext.CommandHandler("add", add_photos),
tg_ext.CommandHandler("end", end_pdf)
],
},
fallbacks=[tg_ext.CommandHandler("cancel", cancel)])
dispatcher.add_handler(create_pdf_handler)
updater.dispatcher.add_handler(tg_ext.CommandHandler('info', info))
@handle_chat_data
def read_hw(update, context):
keyword = HW_SEARCH.search(update.message.text).groups()[0]
buttons = tg.InlineKeyboardMarkup([
[tg.InlineKeyboardButton(text='Из электронного дневника', callback_data=f"READ_HW#EXT#{keyword}#{'1' if 'сегодня' in update.message.text else ''}")],
[tg.InlineKeyboardButton(text='Из этого чата', callback_data=f"READ_HW#LOCAL#{keyword}#{'1' if 'сегодня' in update.message.text else ''}")],
[tg.InlineKeyboardButton(text='Отмена', callback_data="READ_HW#CANCEL")]
])
answer = update.message.reply_text(text='Откуда получить Д/З?', reply_markup=buttons)
context.bot_data.update({answer.message_id: answer})
p1 = re.compile(f"\\b((что|че|чё|чо|шо|що)\\b.*по.?({'|'.join(LESSONS_SHORTCUTS)})|по.?({'|'.join(LESSONS_SHORTCUTS)}).+(что|че)[- ]?(то)?.*зад.*)", re.IGNORECASE)
updater.dispatcher.add_handler(tg_ext.MessageHandler(tg_ext.Filters.regex(p1), read_hw))
p2 = re.compile(f"^({'|'.join(LESSONS_SHORTCUTS)}).*[:-] (.*)", re.IGNORECASE+re.MULTILINE)
@handle_chat_data
def write_hw(update, context):
if update.message.photo:
if update.message.media_group_id in list(context.chat_data['media_groups'].keys()): #проверка на id альбома в памяти
context.chat_data['hw'][context.chat_data['media_groups'][update.message.media_group_id]]['photoid'].append(
update.message.photo[0].file_id
) #добавление фото из сообщения к дз с одинаковым id альбома, что и у нового фото
else:
hw_match = HW_SEARCH.search(update.message.caption if update.message.caption else '')
if hw_match:
keyword = hw_match.groups()[0].lower()
