def __init__(self, config_path, config_private_path):
with open(config_path, encoding = 'utf-8') as json_file:
config = json.load(json_file)
with open(config_private_path, encoding = 'utf-8') as json_file:
config_private = json.load(json_file)
self.config_path = config_path
self.week_index = config.get("week_index")
self.folder = config.get("folder")
self.filename = config.get("filename")
self.lesson_end_time = config.get("lesson_end_time")
self.greetings = config.get("greetings")
self.day_of_week = config.get("day_of_week")
self.lessons_schedule = config.get("lessons_schedule")
self.bot_token = config_private.get("bot_token")
self.db_url = config_private.get("db_url")
self.timetable = dict()
self.bot = aiogram.Bot(self.bot_token)
self.dp = aiogram.Dispatcher(self.bot)
self.xls = XlsHandler("../{}/{}".format(
self.folder,
self.filename
),
self.day_of_week
)
self.db = dbHandler(self.db_url)
def main():
set_logging()
bot = aiogram.Bot(BOT_TOKEN)
dispatcher = aiogram.Dispatcher(bot)
aggregator = Aggregator(rapidapi_key=RAPIDAPI_KEY)
asyncio.run(aggregator.load_sources())
dispatcher.loop.create_task(aggregator.update_periodically())
communicator = Communicator(aggregator)
register_handlers(communicator, dispatcher)
run(dispatcher)
def __init__(self, token: str, chat_service: services.ChatService):
self.bot = aiogram.Bot(token)
self.dp = aiogram.Dispatcher(self.bot, storage=memory.MemoryStorage())
self.chat_service = chat_service
self.dp.register_message_handler(self.welcome, commands=['start'])
self.dp.register_message_handler(self.start_set_min_price,
commands=['set_min_price'])
self.dp.register_message_handler(self.set_min_price,
state=PriceState.wait_for_min_price)
self.dp.register_message_handler(self.start_set_max_price,
commands=['set_max_price'])
self.dp.register_message_handler(self.set_max_price,
state=PriceState.wait_for_max_price)
def main():
args = _parse_args()
logging.basicConfig(
filename=args.logfile,
format='%(asctime)s %(levelname)-8s %(message)s',
level=logging.INFO,
datefmt='%Y-%m-%d %H:%M:%S',
)
ctx = context.Context(args.config, os.environ)
dp = aiogram.Dispatcher(ctx.bot)
_register_handlers(ctx, dp)
ctx.aio_loop.create_task(_periodic_main(ctx))
aiogram.executor.start_polling(dp, skip_updates=True)
def __init__(self, logger, zalgo_text, token: str):
super().__init__(logger, zalgo_text, token)
self.client = aiogram.Bot(token)
self.dp = aiogram.Dispatcher(self.client)
@self.dp.message_handler(commands=['start'])
async def start(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /start")
await message.answer(
"Hello there! Type /help to know how to use me.\n"
"F E E L F R E E T O A B U S E T H I S W O R L D.(c)@@%!&")
@self.dp.message_handler(commands=['help'])
async def helper(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /help")
await message.answer(self.help_message)
@self.dp.message_handler(commands=['zalgo'])
async def zalgofy(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: /zalgo")
source = message.get_args()
if source:
await message.answer(self.zalgo_text.zalgofy(source))
else:
await message.answer(
"Write text to be zalgofied after the /zalgo")
@self.dp.message_handler(lambda message: message.chat.type == 'private'
)
async def zalgofy_pm(message: aiogram.types.Message):
self.logger.log_to_console_and_file("Telegram: PM's")
await message.answer(self.zalgo_text.zalgofy(message.text))
@self.dp.inline_handler(lambda query: len(query.query) > 0)
async def zalgofy_inline(query: aiogram.types.InlineQuery):
self.logger.log_to_console_and_file("Telegram: Inline")
zalgofied_text = self.zalgo_text.zalgofy(query.query)
answer = aiogram.types.InlineQueryResultArticle(
id='1',
title=zalgofied_text,
input_message_content=aiogram.types.InputTextMessageContent(
zalgofied_text))
await query.answer([answer], cache_time=0)
def main():
global Bot
args = parse_args()
logging.basicConfig(
filename=args.logfile,
format='%(asctime)s %(levelname)-8s %(message)s',
level=logging.INFO,
datefmt='%Y-%m-%d %H:%M:%S',
)
cfg = config.load_config(args.config, os.environ)
aio_loop = asyncio.get_event_loop()
Bot = aiogram.Bot(token=cfg['bot_token'], loop=aio_loop)
dispatcher = aiogram.Dispatcher(Bot)
dispatcher.register_message_handler(handle_start, commands=['start'])
aio_loop.create_task(watch_file_changes(cfg['watched_file']))
aiogram.executor.start_polling(dispatcher, skip_updates=True)
import aiogram
import asyncio
import tgdbassbot.config
import tgdbassbot.messages
import json
from tgdbassbot.downloader import SongsDownloader
import tgdbassbot.keyboards
bot = aiogram.Bot(token=tgdbassbot.config.API_TOKEN,
parse_mode=aiogram.types.ParseMode.HTML)
loop = asyncio.get_event_loop()
dp = aiogram.Dispatcher(bot, loop=loop)
users = {}
@dp.message_handler(commands=['start'])
async def start_message(message: aiogram.types.Message):
if str(message.from_user.id) in users.keys():
start_message_lang = tgdbassbot.messages.start_messages[users[str(
message.from_user.id)]['language']]
await bot.send_message(message.chat.id, start_message_lang)
elif str(message.from_user.id) not in users.keys():
keyb = tgdbassbot.keyboards.Keyboards().select_lang()
await bot.send_message(
message.chat.id,
"Выбери язык\nChoose a language\nElige un idioma",
reply_markup=keyb)
users[str(message.from_user.id)] = {
"language": "",
import dotenv
import aiogram
import tinydb
from aiogram import types
from aiogram.utils import executor
from loguru import logger
from tinydb import Query
from tinydb.operations import set as set_
import parse
env = dotenv.dotenv_values()
db = tinydb.TinyDB("botdb.json")
bot = aiogram.Bot(env["BOT_TOKEN"], proxy=env["PROXY"])
dp = aiogram.Dispatcher(bot)
HELP_TEXT = """Мои комманды:
`/add <имя>` - добавляет ученика в список
`/list` - показывает список учеников
`/edit "<старое_имя>" "<новое_имя>"` - изменяет имя ученика
`/delete <имя>` - удаляет ученика из списка
`/choose` - выдает случайный список учеников
"""
@dp.message_handler(commands=["help", "start"])
async def help_(message: types.Message):
await message.reply(HELP_TEXT, parse_mode="markdown")
def _create_dispatcher(bot: aiogram.Bot):
storage = aiogram.contrib.fsm_storage.memory.MemoryStorage()
return aiogram.Dispatcher(bot, storage=storage)
def build_bot(app):
# pylint: disable=unused-variable
bot = aiogram.Bot(token=BOT_TOKEN)
dp = aiogram.Dispatcher(bot)
dp.middleware.setup(LoggingMiddleware())
async def get_page(user_id, page=1):
keyboard = aiogram.types.InlineKeyboardMarkup()
async with get_database_connection(user_id) as db:
async with db.execute(
f'SELECT question FROM questions ORDER BY id LIMIT 6 OFFSET {(page - 1) * 6}'
) as cursor:
async for row in cursor:
keyboard.row(
aiogram.types.InlineKeyboardButton(
text=row[0], callback_data=row[0][:32]))
keyboard.row(*[
aiogram.types.InlineKeyboardButton(text=wrap_if(
f'{opage * 6 - 5}–{opage * 6}', page == opage),
callback_data=f'page:{opage}')
for opage in range(1, 4)
])
return keyboard
@dp.inline_handler()
async def search(inline_query: aiogram.types.InlineQuery):
if not inline_query.query:
return AnswerInlineQuery(inline_query.id, [])
user_id = inline_query.from_user.id
if not database_exists(user_id):
return AnswerInlineQuery(
inline_query.id, [],
is_personal=True,
cache_time=3,
switch_pm_text='Авторизуйтесь с персональной ссылкой')
results = []
try:
async with get_database_connection(user_id) as db:
if "'" in inline_query.query:
print("support: hacking attempt",
user_id,
inline_query.query.encode(),
flush=True)
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'%' +
inline_query.query + '%\' LIMIT 50') as cursor:
async for row in cursor:
if len(results) == 50:
break
results.append(
aiogram.types.InlineQueryResultArticle(
id=f'{user_id}-{gen_id(row)}',
title=row[1],
input_message_content=aiogram.types.
InputTextMessageContent(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
parse_mode='Markdown'),
reply_markup=aiogram.types.
InlineKeyboardMarkup(inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]),
description=truncate(row[2])))
except aiosqlite.OperationalError:
pass
return AnswerInlineQuery(inline_query.id,
results,
is_personal=True,
cache_time=20)
@dp.callback_query_handler()
async def navigate(callback_query: aiogram.types.CallbackQuery):
user_id = callback_query.from_user.id
if callback_query.data == 'like':
return AnswerCallbackQuery(callback_query.id,
text='Ваше мнение очень важно для нас!',
show_alert=True)
if callback_query.data.startswith('page:'):
try:
page = int(callback_query.data[5:])
except ValueError:
return AnswerCallbackQuery(callback_query.id,
text='Нет такой страницы',
show_alert=True)
questions = await get_page(user_id, page)
try:
await bot.edit_message_text(
'Выберите интересующий вас вопрос:',
user_id,
callback_query.message.message_id,
reply_markup=questions)
except aiogram.utils.exceptions.MessageNotModified:
pass
else:
async with get_database_connection(user_id) as db:
async with db.execute(
'SELECT * FROM questions WHERE question LIKE \'' +
callback_query.data + '%\' LIMIT 1') as cursor:
async for row in cursor:
await bot.edit_message_text(
f'\u2753 *{row[1]}*\n\n\U0001F4AC {row[2]}',
user_id,
callback_query.message.message_id,
parse_mode='Markdown',
reply_markup=aiogram.types.InlineKeyboardMarkup(
inline_keyboard=[[
aiogram.types.InlineKeyboardButton(
text='\U0001F44D Спасибо!',
callback_data='like')
]]))
return AnswerCallbackQuery(callback_query.id)
@dp.message_handler()
async def echo(message: aiogram.types.Message):
user_id = message.from_user.id
if message.get_command() == '/start' and message.get_args() != '':
try:
token = message.get_args()
except ValueError:
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.'
)
if not verify_token(token):
return SendMessage(
user_id,
'Ваша персональная ссылка устарела. Обратитесь в центр Клиентской Поддержки.'
)
await init_database(user_id, token)
text = 'Добро пожаловать в Департамент клиентской поддержки! Выберите интересующий вас вопрос:'
else:
text = 'К сожалению, все операторы отсутствуют. Ваш вопрос очень важен для нас, поэтому ответ на него наверняка найдётся ниже:'
if not database_exists(user_id):
return SendMessage(
user_id,
'Пожалуйста, используйте вашу персональную ссылку для входа.')
questions = await get_page(user_id)
return SendMessage(user_id, text, reply_markup=questions)
async def startup(_):
await bot.set_webhook(f'{HOST}{WEBHOOK_PATH}')
async def shutdown(_):
await bot.delete_webhook()
aiogram.utils.executor.set_webhook(dp,
WEBHOOK_PATH,
on_startup=startup,
on_shutdown=shutdown,
skip_updates=True,
web_app=app)
import aiogram
import pathlib
import urllib
import os
import typing
import asyncio
import time
from aiogram.contrib.fsm_storage import memory
from .Settings import Settings
from .BotChecks import Checks
from .Builder import Builder
bot = aiogram.Bot(token=Settings.TOKEN)
dispatcher = aiogram.Dispatcher(bot, storage=memory.MemoryStorage())
class Template:
def CreateKeyboardByInsert(
Data: list, Option: str) -> aiogram.types.InlineKeyboardMarkup:
"""
Creat InlineKeyboardMarkup.
:param list Data: [[callback_data, text], ...],
:param str Option: choosen type of keyboard
:return [InlineKeyboardMarkup, ReplyKeyboardMarkup]:
"""
# Check type of data and parametr
if isinstance(Data, list) and Option == 'Inline':
# Create object InlineKeyboardMarkup
#!/usr/bin/env python3
import aiogram as telegram
import asyncio
import logging
import os
import re
from aiohttp import web
from textwrap import dedent
TG_TOKEN = os.environ['TG_TOKEN']
PORT = os.environ.get('PORT', 8080)
bot = telegram.Bot(token=TG_TOKEN)
dispatcher = telegram.Dispatcher(bot)
subscribers = {}
repositories_full = ['nekit2-002/dummy', 'nekit2-002/dummy2']
@dispatcher.message_handler()
async def handle_message(message):
chat = message.chat.id
username = message['from'].username
txt = message.text
repositories_to_listen = []
logging.info(f'got new TG message from {username}, chat: {chat}')
async def do_listen(array):
import aiogram as ai
import logging
import random
TOKEN = '1133381423:AAEytfr8xb5xoB9iewgDWPAwKZlMgkArW_w'
logging.basicConfig(level=logging.INFO)
bot = ai.Bot(token=TOKEN)
dp = ai.Dispatcher(bot)
menu = ai.types.ReplyKeyboardMarkup(
keyboard=[[ai.types.KeyboardButton(text="Да")],
[ai.types.KeyboardButton(text="Нет")]],
resize_keyboard=True)
@dp.message_handler(commands=['start'])
async def send_mes(message: ai.types.message):
text = "Привет, тебе " + str(random.randint(1, 100)) + "?"
await message.answer(text, reply_markup=menu)
@dp.message_handler(ai.dispatcher.filters.Text(equals=["Да", "Нет"]))
async def ans(message: ai.types.message):
if (message.text == "Да"):
await message.answer("Хорошо!",
reply_markup=ai.types.ReplyKeyboardRemove())
else:
await message.answer("Ну и пошёл вон!",
reply_markup=ai.types.ReplyKeyboardRemove())
if __name__ == '__main__':
reply_to_message_id=reply_to_message_id,
reply_markup=None,
)
return await super().send_message(
chat_id,
messages[-1],
parse_mode=parse_mode,
disable_web_page_preview=disable_web_page_preview,
disable_notification=disable_notification,
reply_to_message_id=reply_to_message_id,
reply_markup=reply_markup,
)
formatter: logging.Formatter = logging.Formatter(
fmt=
"%(asctime)s [%(filename)15s:%(lineno)4s - %(funcName)20s() ] - %(message)s",
datefmt="%d-%b-%y %H:%M:%S",
)
handler_stdout: logging.Handler = logging.StreamHandler(sys.stdout)
handler_stdout.setFormatter(formatter)
handler_file: logging.Handler = logging.FileHandler(
filename=config.LOG_FILENAME, mode="a")
handler_file.setFormatter(formatter)
logging.getLogger().setLevel(config.LOG_LEVEL)
logging.getLogger().addHandler(handler_stdout)
logging.getLogger().addHandler(handler_file)
bot = Bot(token=config.TELEGRAM_TOKEN, parse_mode="HTML")
dp = aiogram.Dispatcher(bot, storage=dbhelper.DBHelper(config.DB_FILE))
def __init__(self, token: str):
self.bot = aiogram.Bot(token)
self.dp = aiogram.Dispatcher(self.bot)
from aiogram.types import ContentType
BOT_TOKEN = os.getenv("BOT_TOKEN")
STIKER_SETS = os.getenv("STIKER_SETS").split(', ')
WORDS = os.getenv("WORDS").split(', ')
HOST = "0.0.0.0"
PORT = os.getenv("PORT")
HEROKU_APP_NAME = os.getenv("HEROKU_APP_NAME")
WEBHOOK_URL = f"https://{HEROKU_APP_NAME}.herokuapp.com/{BOT_TOKEN}"
STIKERS = list()
bot = aiogram.Bot(token=BOT_TOKEN)
state_storage = MemoryStorage()
telegram_api_dispatcher = aiogram.Dispatcher(bot=bot, storage=state_storage)
def get_with_probability(probability=10):
return random.randint(0, 100) <= probability
def translate(text: str, target="uk"):
text = text.replace(' ', '|')
new_text = ts.translate_html(
text,
translator=ts.google,
to_language=target
)
return new_text.replace('|', ' ')
from functools import wraps
import aiogram
from aiogram import types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.dispatcher.filters.state import StatesGroup, State
from aiogram.utils import exceptions
from creds import TELEGRAM_TOKEN, BOT_PROXY
# bot = telebot.TeleBot(TELEGRAM_TOKEN)
log = logging.getLogger('ohaioposter')
bot = aiogram.Bot(TELEGRAM_TOKEN, proxy=BOT_PROXY)
storage = MemoryStorage()
dp = aiogram.Dispatcher(bot, storage=storage)
bot.start_time = dt.fromtimestamp(time.perf_counter())
bot.users = {}
bot.paginators = {}
bot.error_msg = None
class NewNameSetup(StatesGroup):
new_name = State()
class LimitSetup(StatesGroup):
user = State()
limit = State()
from data.weather_API import WeatherCheck
from data.dialog_module import AI_chatting
from data.db import UsersTable, ReminderTable
from data import Sticers as sticers
import data.keyboard as kb
import os
import aiogram
from datetime import datetime as dt
import asyncio
import logging
# ----------------------bot init------------------------ #
bot = aiogram.Bot(token=token)
dp = aiogram.Dispatcher(bot, storage=MemoryStorage())
dp.middleware.setup(LoggingMiddleware())
loop = asyncio.get_event_loop()
logging.basicConfig(filename='logs.txt', encoding='utf-8', level=logging.INFO)
logging.info('Я запустився')
path = os.path.abspath('data/Answers/tardis-isbv-a8b739ce96e6.json')
print(os.getenv("GOOGLE_APPLICATION_CREDENTIALS"))
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = path
print(os.getenv("GOOGLE_APPLICATION_CREDENTIALS"))
# --------------------other params----------------------- #
state = ''
