def initialize_bot():
executor.start_polling(
dp,
on_startup=on_startup,
on_shutdown=on_shutdown,
skip_updates=True,
)
def main(self):
log.info('run serve subcommand')
token = Core.config.telegram.api_token()
if type(token) is not str:
log.critical(
'Can not find "telegram:api_token" in config. Exiting.')
exit(1)
self._bot = Bot(token=Core.config.telegram.api_token())
dp = Dispatcher(self._bot)
self._processor = VolleyProcessor(
YandexTranslate(Core.config.yandex_translate.api_key()),
ChatScript(Core.config.chatscript.host(),
Core.config.chatscript.port(), 'botan'))
dp.register_message_handler(self.send_welcome,
commands=['start', 'help'])
dp.register_message_handler(self.everything)
start_polling(
dp,
skip_updates=True,
# on_startup=self.on_startup,
# on_shutdown=self.on_shutdown
)
def main():
"""Start bot in webhook mode.
Bot's main entry point.
"""
bot.setup()
if config.SET_WEBHOOK:
url_token = secrets.token_urlsafe()
webhook_path = config.WEBHOOK_PATH + "/" + url_token
executor.start_webhook(
dispatcher=dp,
webhook_path=webhook_path,
on_startup=lambda *args: on_startup(webhook_path, *args),
on_shutdown=lambda *args: close_blockchains(),
host=config.INTERNAL_HOST,
port=config.SERVER_PORT,
)
else:
executor.start_polling(
dispatcher=dp,
on_startup=lambda *args: on_startup(None, *args),
on_shutdown=lambda *args: close_blockchains(),
)
print() # noqa: T001 Executor stopped with ^C
# Stop all background tasks
loop = asyncio.get_event_loop()
for task in asyncio.all_tasks(loop):
task.cancel()
try:
loop.run_until_complete(task)
except asyncio.CancelledError:
pass
def main() -> NoReturn:
create_connection('language_bot_db.db')
check_db_exists()
executor.start_polling(dispatcher,
skip_updates=True,
timeout=60,
on_shutdown=on_shutdown)
def main():
setup_logging()
bot = Bot(token=BOT_TOKEN, parse_mode='html')
dp = make_dispatcher(bot)
executor.start_polling(dp,
on_startup=on_startup,
on_shutdown=on_shutdown,
skip_updates=True)
def main(config: dict):
# Bot, storage, dispatcher and telegram_api_server instances
bot = Bot(**config["app"]["bot"])
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
bot[APP_CONFIG_KEY] = config
start_polling(dp, on_startup=on_startup, on_shutdown=on_shutdown)
def run():
if config.SENTRY_DSN:
sentry_sdk.init(config.SENTRY_DSN)
middlewares.setup(dp)
import i17obot.handlers
executor.start_polling(dp, skip_updates=True)
def start_polling():
dispatcher = Dispatcher(bot.obj)
dispatcher.middleware.setup(LoggingMiddleware())
admin.init(dispatcher)
auth.init(dispatcher)
cashier.init(dispatcher)
executor.start_polling(dispatcher, skip_updates=True)
def run_tg(token, proxy, agent):
loop = asyncio.get_event_loop()
bot = Bot(token=token, loop=loop, proxy=proxy)
dp = Dispatcher(bot)
tg_msg_processor = TelegramMessageProcessor(agent.register_msg)
dp.message_handler()(tg_msg_processor.handle_message)
executor.start_polling(dp, skip_updates=True)
def main():
executor.start_polling(dp, skip_updates=True)
logging.basicConfig(level=logging.INFO)
start_webhook(
dispatcher=dp,
webhook_path=WEBHOOK_PATH,
skip_updates=True,
host=WEBAPP_HOST,
#port=WEBAPP_PORT
)
def use_polling():
start_polling(
dispatcher=dp,
on_startup=on_startup_for_polling,
on_shutdown=on_shutdown_for_polling,
skip_updates=bot_section.APP_BOT_SKIP_UPDATES,
timeout=bot_section.APP_BOT_TIMEOUT,
relax=bot_section.APP_BOT_RELAX,
fast=bot_section.APP_BOT_FAST
)
def start(self) -> None:
if self.mode == Frameworks.AIOGRAM:
from aiogram.utils import executor
executor.start_polling(self.dp,
skip_updates=True,
on_startup=self._events["on_startup"],
on_shutdown=self._events["on_shutdown"])
elif self.mode == Frameworks.VKWAVE:
self._task_manager.add_task(self.bot.run)
self._task_manager.run(on_startup=self._events["on_startup"],
on_shutdown=self._events["on_shutdown"])
def main():
args = _parse_args()
dispatcher = prepare(
logs_dir=args.logs_dir,
telegram_api_token=args.telegram_api_token,
text_generator_service_url=args.text_generator_service_url,
text_generator_service_login=args.text_generator_service_login,
text_generator_service_password=args.text_generator_service_password)
executor.start_polling(dispatcher, skip_updates=True)
def start_polling(token: str, connection_string: str):
bot = init_bot(token)
dp = init_dispatcher(bot)
dp["connection_string"] = connection_string
bind_filters(dp)
register_middlewares(dp)
register_handlers(dp)
executor.start_polling(dp, skip_updates=True, on_startup=on_startup)
def telegram_polling():
try:
executor.start_polling(
dp, skip_updates=True) #constantly get messages from Telegram
except:
traceback_error_string = traceback.format_exc()
with open("Error.Log", "a") as myfile:
myfile.write("\r\n\r\n" + time.strftime("%c") +
"\r\n<<ERROR polling>>\r\n" + traceback_error_string +
"\r\n<<ERROR polling>>")
time.sleep(10)
telegram_polling()
def start(stamp):
if os.environ.get('local'):
threads = [logger, google_update]
Auth.dev.printer(f'Запуск бота локально за {time_now() - stamp} сек.')
else:
Auth.dev.start(stamp)
threads = [logger, google_update, google_files, auto_reboot, alt_image]
Auth.dev.printer(f'Бот запущен за {time_now() - stamp} сек.')
for thread_element in threads:
_thread.start_new_thread(thread_element, ())
executor.start_polling(dispatcher, allowed_updates=objects.allowed_updates)
def test_bot():
# Setup Django environment
print('Setting Django environment...')
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'crypto_bot.settings')
django.setup()
# Import necessary objects
print('Importing modules...')
from bot.sources.bot import dp, startup, shutdown
# Start bot
print('Starting bot...')
executor.start_polling(dp,
skip_updates=True,
on_startup=startup,
on_shutdown=shutdown)
def main():
if os.environ.get("DATABASE_URL"):
logging.basicConfig(level=logging.INFO)
start_webhook(
dispatcher=dp,
webhook_path=WEBHOOK_PATH,
skip_updates=True,
on_startup=on_startup,
host=WEBAPP_HOST,
port=WEBAPP_PORT,
)
else:
try:
executor.start_polling(dp)
except KeyboardInterrupt:
exit(0)
def main(arguments):
args = parser.parse_args(arguments)
token = args.token
sock = args.sock
host = args.host
port = args.port
cert = args.cert
pkey = args.pkey
host_name = args.host_name or host
webhook_port = args.webhook_port or port
webhook_path = args.webhook_path
# Fi webhook path
if not webhook_path.startswith('/'):
webhook_path = '/' + webhook_path
# Generate webhook URL
webhook_url = f"https://{host_name}:{webhook_port}{webhook_path}"
# Create bot & dispatcher instances.
bot = Bot(token)
dispatcher = Dispatcher(bot)
if (sock or host) and host_name:
if cert and pkey:
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.load_cert_chain(cert, pkey)
else:
ssl_context = None
start_webhook(dispatcher,
webhook_path,
on_startup=functools.partial(on_startup,
url=webhook_url,
cert=cert),
on_shutdown=on_shutdown,
host=host,
port=port,
path=sock,
ssl_context=ssl_context)
else:
start_polling(dispatcher,
on_startup=on_startup,
on_shutdown=on_shutdown)
def start(self):
bot = Bot(self.token)
dp = Dispatcher(bot)
#/start:
@dp.message_handler(commands=["start"])
async def process_start_command(message: types.Message):
await bot.send_message(message.from_user.id, temp.start_message)
#/help:
@dp.message_handler(commands=["help"])
async def process_start_command(message: types.Message):
await bot.send_message(message.from_user.id, temp.help_message)
#messages:
@dp.message_handler()
async def echo_message(message: types.Message):
try:
result = wikipedia.summary(message.text)
except:
result = temp.error_message
finally:
await bot.send_message(message.from_user.id, result)
#stickers:
@dp.message_handler(content_types=["sticker"])
async def echo_message(message: types.Message):
await bot.send_message(message.from_user.id,
"Я не умею понимать стикеры.")
#photos:
@dp.message_handler(content_types=["photo"])
async def echo_message(message: types.Message):
await bot.send_message(message.from_user.id,
"Я не умею смотреть фотки.")
#videos:
@dp.message_handler(content_types=["video"])
async def echo_message(message: types.Message):
await bot.send_message(message.from_user.id,
"Я не умею декодировать видео.")
executor.start_polling(dp)
def start_bot(mode, config):
api = config["general"]["api"]
token = api["token"]
webhook_url = URL(api["webhook"]["url"]) if api["webhook"]["url"] else None
cert = api["webhook"]["cert"]
pkey = api["webhook"]["pkey"]
proxy_url = api["proxy"]["url"]
if not api["proxy"]["login"] or not api["proxy"]["password"]:
proxy_auth = None
else:
proxy_auth = BasicAuth(login=api["proxy"]["login"],
password=api["proxy"]["password"])
# Create bot & dispatcher instances.
bot = Bot(token, proxy=proxy_url, proxy_auth=proxy_auth)
dispatcher = Dispatcher(bot)
dispatcher["config"] = config
logger.info(f"Initialize dispatcher: {dispatcher}")
if mode == "webhook":
if cert and pkey:
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
ssl_context.load_cert_chain(cert, pkey)
else:
ssl_context = None
start_webhook(dispatcher,
webhook_url.path,
on_startup=on_startup,
url=str(webhook_url),
cert=cert,
on_shutdown=on_shutdown,
host=webhook_url.host,
port=webhook_url.port,
ssl_context=ssl_context)
else:
start_polling(dispatcher,
on_startup=on_startup,
on_shutdown=on_shutdown)
def run(self):
dp = Dispatcher(self.bot)
@dp.message_handler(commands=['start'])
async def process_start_command(message: types.Message):
await message.reply("Привет!\nНапиши мне что-нибудь!")
@dp.message_handler(commands=['help'])
async def process_help_command(message: types.Message):
await message.reply(
"Напиши мне что-нибудь, и я отпрпавлю этот текст тебе в ответ!"
)
@dp.message_handler()
async def echo_message(msg: types.Message):
await self.bot.send_message(msg.from_user.id, msg.text)
self.repository.save_message(msg.from_user.id, msg.text,
datetime.datetime.now())
executor.start_polling(dp)
def main():
try:
db.create_pool()
with db.get_connection() as conn:
db.create_schema(conn)
if settings.WEBHOOK_ENABLED:
start_webhook(
dispatcher=dp,
webhook_path=settings.WEBHOOK_PATH,
skip_updates=True,
on_startup=bot_startup,
host=settings.WEBAPP_HOST,
port=settings.WEBAPP_PORT,
)
else:
executor.start_polling(dp,
on_startup=bot_startup,
on_shutdown=bot_shutdown)
finally:
db.close_pool()
def start(self):
"""Register message handlers, and start the bot"""
commands_mapping = [
(['link'], self.link_account),
(['list'], self.list_requests),
(['note'], self.set_note),
(['ping'], self.ping),
(['passwd'], self.set_password),
(['search'], self.search_requests),
(['whoami'], self.whoami),
(['register'], self.register),
(['edit_desc'], self.edit_desc),
(['claim', 'unclaim'], self.claim_request),
(['start', 'help'], self.show_help),
(['done', 'reject', 'reopen'], self.set_status),
(['pakreq', 'updreq', 'optreq'], self.new_request)
]
for command in commands_mapping:
logging.info('Registering command: %s' % command[0])
self.dp.register_message_handler(command[1], commands=command[0])
executor.start_polling(self.dp)
def set_up_app() -> None:
"""
:return:
"""
logging.basicConfig(filename="base.log", level=logging.INFO)
log = logging.getLogger("bot")
uvloop.install()
vars_json = var.Var()
loop = asyncio.get_event_loop()
loop.run_until_complete(
vars_json.set_var_from_file(path=os.path.abspath("config.json")))
bot = Bot(token=vars_json.token,
loop=loop,
parse_mode=types.ParseMode.HTML)
dp = Dispatcher(bot, storage=MemoryStorage())
dp.middleware.setup(LoggingMiddleware())
register(dp=dp, logger=log)
executor.start_polling(dp, on_shutdown=shutdown, loop=loop)
def init():
evloop = asyncio.new_event_loop()
asyncio.set_event_loop(evloop)
logger.info("Don't forget to check proxy settings!")
bot_extra_settings = {}
if settings.TELEGRAM_PROXY:
bot_extra_settings['proxy'] = settings.TELEGRAM_PROXY
bot = aiogram.Bot(settings.MASTERMIND_BOT_CONFIG["token"], **bot_extra_settings,)
dsp = Dispatcher(bot)
register_handlers(dsp)
# check connection
me = evloop.run_until_complete(dsp.bot.me)
logger.info(me)
init_rpc(evloop, bot)
executor.start_polling(dsp)
def main():
if config.USE_WEBHOOK:
app = get_new_configured_app(dp, config.WEBHOOK_PATH)
app.on_startup.append(on_startup)
if not config.HEROKU:
app.on_shutdown.append(on_shutdown)
context = None
if config.CUSTOM_SSL_CERT:
context = ssl.SSLContext()
context.load_cert_chain(config.SSL_CERT, config.SSL_PRIV)
run_app(app, port=config.WEBHOOK_LOCAL_PORT, ssl_context=context)
else:
async def proxy_login(*args, **kwargs):
await api.login()
try:
start_polling(dp, loop=loop, skip_updates=True, on_startup=proxy_login)
except KeyboardInterrupt:
print('goodbye')
dp.stop_polling()
msg_payload = get_choose_categories_msg_payload(activity, categories)
await bot.send_message(u.id, msg_payload['msg'], **msg_payload['payload'])
@dp.callback_query_handler(lambda c: 'act_id' in c.data)
async def finish_activity(callback_query: types.CallbackQuery):
await bot.answer_callback_query(callback_query.id)
data = json.loads(callback_query.data)
user = callback_query.from_user
try:
activity_id, category_id = data['act_id'], data['cat_id']
db.stop_activity(activity_id, category_id)
except DoesNotExist:
reply = 'Промежуток уже был заполнен'
except RuntimeError:
reply = 'Ошибка на сервере! Как сказал инженер Чернобыльской АЭС: "...Упс"'
else:
_, _, category_name = db.get_category(category_id)
reply = f'Заполнено: `{category_name}`'
await bot.send_message(user.id, reply, parse_mode='Markdown')
if __name__ == '__main__':
from aiogram.utils import executor
db.migrate()
executor.start_polling(dp, skip_updates=True)
await message.answer(messages.FINISH_MESSAGE,
reply_markup=keyboard.create_keyboard(
keyboard.COMMANDS, one_time_keyboard=False),
parse_mode='HTML')
await UserStates.START.set()
elif content == 'restart':
# Start pathfinder from beginning
await message.answer(messages.RESTART_MESSAGE, parse_mode='HTML')
await state.update_data(step=0)
await message.answer(messages.reply_message(await state.get_data()),
reply_markup=keyboard.create_keyboard(
keyboard.PATHFINDER_BUTTONS['navigation']),
parse_mode='HTML')
await UserStates.BUILDING.set()
@dp.message_handler(state='*')
async def process_unknown(message: types.Message):
await message.answer(messages.UNKNOWN_COMMAND_MESSAGE, parse_mode='HTML')
async def shutdown(dispatcher: Dispatcher):
await dispatcher.storage.close()
await dispatcher.storage.wait_closed()
if __name__ == '__main__':
executor.start_polling(dp, on_shutdown=shutdown)
@dp.message_handler(content_types=['photo'])
async def echo_image(msg: types.Message):
file_id = msg['photo'][-1]['file_id']
path = save_path + file_id + '.jpg'
await msg.reply("Файл загружен, добавьте следующий или завершите работу.")
await msg.photo[-1].download(path)
path = await evaluate(path)
if msg.from_user.id in files_paths.keys():
files_paths[msg.from_user.id].append(path)
else:
files_paths[msg.from_user.id] = [path]
# await bot.send_photo(msg.from_user.id, aaa)
@dp.message_handler(commands=['finish'])
async def finish_uploading(msg: types.Message):
await msg.reply("Ожидайте обработки.")
if msg.from_user.id not in files_paths.keys():
await bot.send_message(msg.from_user.id, "А где изображения?")
else:
for path in files_paths[msg.from_user.id]:
file = InputFile(path)
await bot.send_photo(msg.from_user.id, file)
files_paths[msg.from_user.id] = []
# await bot.send_message(msg.from_user.id, "К сожалению, модель не отвечает. Возможно, сервер не запущен, обратитесь к администратору.")
if __name__ == '__main__':
executor.start_polling(dp)
import asyncio
from typing import Optional
import aiogram.utils.markdown as md
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.types import ParseMode
from aiogram.utils import executor
from config import API_TOKEN
loop = asyncio.get_event_loop()
bot = Bot(token=API_TOKEN, loop=loop)
bot = Bot(token=API_TOKEN, loop=loop)
# For example use simple MemoryStorage for Dispatcher.
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
@dp.message_handler(commands=['start'])
async def cmd_start(message: types.Message):
await message.reply(message.chat.first_name)
if __name__ == '__main__':
executor.start_polling(dp, loop=loop, skip_updates=True)