示例#1
0
import logging
import ipaddress
import json
import paramiko
import asyncssh
from web3.auto import w3
from aiogram import Bot, Dispatcher, executor, types
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage
import config
import addr_check_helper

bot = Bot(token=config.bot_token)
memory_storage = MemoryStorage()
dp = Dispatcher(bot, storage=memory_storage)


class MySSHClient(asyncssh.SSHClient):
    def validate_host_public_key(self, host, addr, port, key):
        return True


class SetupStates(StatesGroup):
    waiting_for_server_address = State()
    waiting_for_server_login = State()
    waiting_for_server_password = State()
    waiting_for_wallet = State()
    waiting_for_wallet_password = State()

示例#2
0
X, y = vectorizer.fit_transform(
    shuffle_df['abstract']), shuffle_df['citations'].apply(
        lambda x: multiclass(x))

clf = linear_model.LogisticRegression(class_weight='balanced', max_iter=10000)
clf.fit(X, y)

######################################3

API_TOKEN = TOKEN

# Configure logging
logging.basicConfig(level=logging.INFO)

# Initialize bot and dispatcher
bot = Bot(token=API_TOKEN)

# For example use simple MemoryStorage for Dispatcher.
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)


# States
class Form(StatesGroup):
    Classic = State()  # Will be represented in storage as 'Form:Classic'
    Classic1 = State()  # Will be represented in storage as 'Form:Classic1'
    ClassicB = State()  # Will be represented in storage as 'Form:ClassicB'
    ClassicB1 = State()  # Will be represented in storage as 'Form:ClassicB'
    DDF = State()  # Will be represented in storage as 'Form:DDF'
    DDF1 = State()  # Will be represented in storage as 'Form:DDF'
示例#3
0
async def bot_fixture(event_loop):
    """ Bot fixture """
    _bot = Bot(TOKEN, loop=event_loop, parse_mode=types.ParseMode.MARKDOWN)
    yield _bot
    await _bot.close()
示例#4
0
    sys.exit(1)

BOT_TOKEN = os.getenv('BOT_TOKEN')

HEROKU_APP_NAME = os.getenv('HEROKU_APP_NAME')

# webhook settings
WEBHOOK_HOST = f'https://{HEROKU_APP_NAME}.herokuapp.com'
WEBHOOK_PATH = f'/webhook/{BOT_TOKEN}'
WEBHOOK_URL = f'{WEBHOOK_HOST}{WEBHOOK_PATH}'

# webserver settings
WEBAPP_HOST = '0.0.0.0'
WEBAPP_PORT = int(os.getenv('PORT'))

bot = Bot(BOT_TOKEN)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
dp.middleware.setup(LoggingMiddleware())


# States of the finite state machine
class BusinessLogic(StatesGroup):
    picture = State()
    colors = State()


@dp.message_handler(commands=['help'])
async def interface_description(message: types.Message):
    """Display of help information."""
    await bot.send_message(chat_id=message.from_user.id, text='''
示例#5
0
from starlette.requests import Request
from starlette.routing import Route
from starlette.responses import JSONResponse
from starlette.middleware import Middleware

from weebhook import set_weebhook
from keyboard import board_1, board_2, board_3
from functions import parser, db_list, num_list, create_reply_keyboard, save_adm
from config import TOKEN, MAIN_DB, ADMIN_DB

client = MongoClient("localhost", 27017) 
db = client['NEW_DB']
new_collection = db[MAIN_DB]
adm_collection = db[ADMIN_DB]

bot = Bot(token=TOKEN)
dp = Dispatcher(bot, storage=MongoStorage())

class States(Helper):
    mode = HelperMode.snake_case
    ADMIN = Item()
    DELETE = Item()
    FIO = Item()
    DOLJ = Item()
    ADRESS = Item()
    EMAIL = Item()
    PHONE = Item()
    CHANGE = Item()
    CHANGE_ROOM = Item()

async def home(request: Request):
示例#6
0
from functools import wraps
from aiogram import Bot
from aiogram import Dispatcher
from aiogram import types
from aiogram.utils.executor import start_polling
from aiogram.types import ContentType, ChatType
from aiogram.dispatcher.filters import Command, BoundFilter
from aiogram.dispatcher import DEFAULT_RATE_LIMIT
from aiogram.dispatcher.handler import CancelHandler, current_handler
from aiogram.dispatcher.middlewares import BaseMiddleware
from aiogram.utils.exceptions import Throttled
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.utils.markdown import escape_md

logging.basicConfig(level=logging.INFO)
bot: Bot = Bot(token="1548967936:AAGqYm37VMDR2B2WdxUk1NcuJLjoEkLH6cc")
dp: Dispatcher = Dispatcher(bot=bot, storage=MemoryStorage())


def rate_limit(func, limit=2):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        message = args[0]
        try:
            await dp.throttle("sticker", rate=limit)
        except Throttled as t:
            await message_throttled(message, t)

    return wrapper

示例#7
0
import plistlib
from hurry.filesize import size

from aiogram import Bot
from aiogram.types import Message, CallbackQuery
from aiogram.dispatcher import Dispatcher
from aiogram.utils import executor
from aiogram.types.inline_keyboard import InlineKeyboardButton, InlineKeyboardMarkup
from aiogram.types.reply_keyboard import ReplyKeyboardMarkup, KeyboardButton, ReplyKeyboardRemove
from aiohttp import ClientSession
from furl import furl

from config import BOT_TOKEN

# bot = Bot(token=BOT_TOKEN, proxy="socks5://163.172.152.192:1080")
bot = Bot(token=BOT_TOKEN)
dp = Dispatcher(bot)


@dp.message_handler(commands=['start'])
async def start(message: Message):
    await message.reply(
        'Для начала работы пришлите боту ссылку вида https://appscloud.me/free_apps/app.php?id=<application_id>'
    )


async def get_plist_file(app_id: int) -> str:
    logger.info("Script started")
    async with ClientSession() as session:
        async with session.get(
                f"https://appscloud.me/free_apps/install.php?id={app_id}",
示例#8
0
import logging
import json

from aiogram import Bot, Dispatcher, executor, types

from models import User
from defs import the_counter, get_msg, get_user, user_create, send
import config as cfg

logging.basicConfig(level=cfg.logging_level)

bot = Bot(token=cfg.bot_token, parse_mode='html')
dp = Dispatcher(bot)


@dp.message_handler(commands=['start'])
async def start(message: types.Message):
    if message.chat.type == 'private':
        text = ('Привет. В личном чате тебе доступна только команада '
                '/balance.')
        await message.answer(text)


@dp.message_handler(commands=['send'])
async def send_cmd(message: types.Message):
    if message.chat.type == 'group'\
    or message.chat.type == 'supergroup'\
    and message.chat.id in cfg.aviable_chats:
        try:
            sum = int(message.text.split(' ')[1])
            if message.reply_to_message:
示例#9
0
文件: bot.py 项目: v-sopin/egebot
import asyncio
from aiogram import Bot, Dispatcher, executor, exceptions
from scripts.db_manager import UsersDbManager
from scripts.config import TOKEN, DEVELOPER_ID, ADMINS
import scripts.markup as mk

bot = Bot(TOKEN)
dp = Dispatcher(bot)
loop = asyncio.get_event_loop()


@dp.message_handler(commands=['start'])
async def start(message):
    tel_id = message.chat.id
    if not await UsersDbManager.user_exist(tel_id, loop):
        await UsersDbManager.add_user(tel_id, loop)

    await bot.send_message(tel_id,
                           'Выбери экзамен',
                           disable_notification=True,
                           reply_markup=mk.choose_exam())


@dp.message_handler(commands=['cancle'])
async def cancel(message):
    tel_id = message.chat.id
    await UsersDbManager.update_context(tel_id, '0', loop)
    await bot.send_message(tel_id, 'Операция отменена')


'''
示例#10
0
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.types import ReplyKeyboardRemove, \
    ReplyKeyboardMarkup, KeyboardButton, \
    InlineKeyboardMarkup, InlineKeyboardButton

from helpers import *
from getnews import sort_req
from helpers_buttons import *
from helpers_variables import *
from config import *
from cache import *
from db import *
from translations import *

bot = Bot(token=API_TOKEN, proxy=PROXY, parse_mode="HTML")


class change_current_settings:
    def __init__(self):
        pass

    #  For callback query
    async def change_current(self, callback_query, dp):
        state = dp.current_state(user=callback_query.from_user.id)
        all_settings = {}
        _user_settings = {
            str(callback_query.from_user.id): {
                'category': [],
                'time_to_receive': [],
                'language': [],
示例#11
0
import os

from myHelpers import createInlineMenu

from handlers import contactsHandler as ch
from handlers import gameHandler as gh
from handlers import menuHandler as mh
from handlers import resultHandler as rh
from handlers import imageHandler as ih

from aiogram import Bot, Dispatcher, executor, types
from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup, ReplyKeyboardRemove, InputFile, ContentType

logging.basicConfig(level=logging.INFO)

bot = Bot(token=str(os.environ.get('TELEGRAM_TOKEN')), )

dp = Dispatcher(bot=bot)


@dp.message_handler(content_types=ContentType.PHOTO)
async def toPhoto(message: types.Message):
    await ih.imageHandler(message)


@dp.message_handler(commands=['start'])
async def printall(message: types.Message):
    await message.answer(
        'Привет, я создан с целью помочь тебе поразвлечься и получить полезную информацию. Жмякай ниже и да начнется веселье!',
        reply_markup=createInlineMenu(
            [  # простая функция для создания клавиатуры (см. helpers.py)
示例#12
0
    uid = message.from_user.id
    log_str += '(' + str(uid) + '):\n'

    if(typ == 'text'):
        log_str += message.text + '\n'
    elif typ == 'files':
        log_str += "Отправил документ"
    elif typ == 'photos':
        log_str += "Отправил фото"

    log_str += updates_by_user[uid]['subject_name'] + "\n"
    return log_str


#bot
bot = Bot(token=API_TOKEN, parse_mode="HTML")
disp = Dispatcher(bot)

#data
db_connection = sqlite3.connect("database.db")
cur = db_connection.cursor()

sg = SGClient()
sg.login(SG_LOGIN, SG_PASSWORD)

state = {}
updates_by_user = {}
del_subject_name = {}
day = now().weekday()
admins_id = [800155626]
users_ids = [800155626, 664331079, 998445492, 912050293, 652242346, 723471766, 539584923, 1249475977,
示例#13
0
import logging
import config
from aiogram import Bot, Dispatcher, executor, types
import asyncio
from connect import edit_bot

bot = Bot(token=config.TOKEN_FORTUNETELLER)
dp = Dispatcher(bot)

logging.basicConfig(level=logging.INFO)

side, num = 0, 0

Bot_fortuneteller = [
    [
        # 0, вступление
        ['Кто вы?', 'Я гадалка', 0],
        ['Здравствуйте. Позволите задать вам несколько вопросов?', 'Да', 1],
    ],
    [
        # 1
        ['Нет времени. Могу я вам задать несколько вопросов?', 'Да', 0],
        ['Не могу сказать, можем перейти к делу?', 'Да', 0],
    ],
    [
        # 2
        ['Скажите, знали ли вы Софию Хорову?»', 'Не могу точно сказать', 0],
        [
            'Вы моежете сказать, кто убил Софью Хорову?',
            'Не могу точно сказать', 0
        ],
示例#14
0
import os

from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage

from apiaudd.requests import MainRequests
import read_env

read_env.read_argv()
var = os.environ.get

TOKEN = var("BOT_TOKEN")
bot = Bot(TOKEN, parse_mode="html")
disp = Dispatcher(bot, storage=MemoryStorage())

APP_SPOT_URL = f"https://esc-ru.appspot.com/file/bot{TOKEN}/%s?host=api.telegram.org"
audd = MainRequests(var("AUDD_TOKEN"), APP_SPOT_URL)
示例#15
0
# APP logger
logname_app = "app.log"
handler_app = TimedRotatingFileHandler(filename=config['APP_logger']['path'] +
                                       logname_app,
                                       when="midnight",
                                       interval=1)
handler_app.suffix = "%d%m%Y"
handler_app.setLevel(log_level)
formatter = logging.Formatter(log_format)
handler_app.setFormatter(formatter)
logger_app = logging.getLogger(__name__)
logger_app.addHandler(handler_app)

# P2P logger
logname_p2p = "p2p.log"
handler_p2p = TimedRotatingFileHandler(filename=config['P2P_logger']['path'] +
                                       logname_p2p,
                                       when="midnight",
                                       interval=1)
handler_p2p.suffix = "%d%m%Y"
handler_p2p.setLevel(log_level)
formatter = logging.Formatter(log_format)
handler_p2p.setFormatter(formatter)
logger_p2p = logging.getLogger(__name__)
logger_p2p.addHandler(handler_p2p)

bot = Bot(token=config['BOT']['token'],
          parse_mode="HTML",
          proxy=config['PROXY']['url'])
dp = Dispatcher(bot)
示例#16
0
文件: load_all.py 项目: KoEzzz/bot
from aiogram import Bot
from aiogram import Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage

from config import TOKEN
from language_middleware import setup_middleware

#######################
# Если у вас РКН блокирует запросы к Телеграму, можете перезаписать адрес по которому делаются запросы
# И раскомментите следующие строки
# from aiogram.bot import api
# PATCHED_URL = "https://telegg.ru/orig/bot{token}/{method}"
# setattr(api, "API_URL", PATCHED_URL)
#######################


logging.basicConfig(format=u'%(filename)s [LINE:%(lineno)d] #%(levelname)-8s [%(asctime)s]  %(message)s',
                    level=logging.INFO)
# loop = asyncio.get_event_loop()
# Поток нам не нужен, т.к. он и так создается в диспатчере.

storage = MemoryStorage()

bot = Bot(token=TOKEN, parse_mode="HTML")
dp = Dispatcher(bot, storage=storage)

# Настроим i18n middleware для работы с многоязычностью
i18n = setup_middleware(dp)
# Создадим псевдоним для метода gettext
_ = i18n.gettext
示例#17
0
from aiogram import Bot, Dispatcher

from data import config

bot = Bot(token=config.BOT_TOKEN, parse_mode='HTML')
dp = Dispatcher(bot)
示例#18
0
import logging
import config
from aiogram import Bot, Dispatcher, executor, types

logging.basicConfig(level=logging.INFO)

bot = Bot(token=config.token)
dp = Dispatcher(bot)


@dp.message_handler(commands=["start"])
async def cmd_start(message: types.Message):
    poll_keyboard = types.ReplyKeyboardMarkup(resize_keyboard=True)
    poll_keyboard.add(
        types.KeyboardButton(text="Начать тестирование",
                             request_poll=types.KeyboardButtonPollType(
                                 type=types.PollType.QUIZ)))
    poll_keyboard.add(types.KeyboardButton(text="Отмена"))
    await message.answer("Нажмите на кнопку ниже для старта!",
                         reply_markup=poll_keyboard)


@dp.message_handler(lambda message: message.text == "Отмена")
async def action_cancel(message: types.Message):
    remove_keyboard = types.ReplyKeyboardRemove()
    await message.answer(
        "Действие отменено. Введите /start, чтобы начать заново.",
        reply_markup=remove_keyboard)


if __name__ == "__main__":
示例#19
0
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.redis import RedisStorage
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from aiogram.dispatcher import FSMContext
from aiogram.types import ReplyKeyboardMarkup, KeyboardButton

from inliner import Inliner
from utils import TestStates
from tasker import Jsoner
from dedoder import Decoder
import redis
import asyncio

logging.basicConfig(level=logging.INFO)

bot = Bot(token='1160891964:AAE0ba37vkpS14RQlH0VVlI2VPTovdS_D7U')

dp = Dispatcher(bot, storage=RedisStorage('localhost', 6379, db=5))
dp.middleware.setup(LoggingMiddleware())

r = redis.Redis(db=5)

button_task = KeyboardButton('Назначить задачу')

markup = ReplyKeyboardMarkup(resize_keyboard=True)
markup.add(button_task)

# TABLE = { 'users': {}}
# json_file = json.dumps(TABLE, indent=4)
# r.hset('TABLE', 'table', json_file)
示例#20
0
"""
Before running install aiogram, cool telegram bot-api wrapper
"""
from aioqiwi.wallet import Wallet, QiwiUpdate
from aioqiwi.utils import BeautifulSum

from aiogram import Bot, Dispatcher, types
from aiogram.utils import markdown

ME = 124191486  # your telegram user id

qiwi = Wallet("qiwiToken")
bot = Bot("telegramBotToken", parse_mode="markdown")
disp = Dispatcher(bot)


@qiwi.on_update(incoming=True)
async def new_payment(event: QiwiUpdate):
    payment = event.Payment
    text = f":D Woop-woop! {payment.account} sent you {BeautifulSum(payment.Sum).humanize}\n"
    text += f"Commentary: {payment.comment}" if payment.comment else ""

    await bot.send_message(ME, text)


@disp.message_handler(commands=["send"], prefix="./!")
@disp.message_handler(regexp=r"^.send \d*\.?\d* (\(?\+?[0-9]*\)?)?[0-9_\- \(\)] .*")
async def send_money(event: types.Message):
    # process text with pattern: .send amount_float receiver_phone_number comments
    cmd, amount, peer, comment = event.text.split(maxsplit=3)
示例#21
0
文件: bot.py 项目: chibiherbie/film
import logging
import config
from aiogram import Bot, Dispatcher, executor, types
from sqlite import DataBase
import asyncio

bot = Bot(token=config.TOKEN)
dp = Dispatcher(bot)

logging.basicConfig(level=logging.INFO)

bd = DataBase('data/user.db')
bd.clear()  # очищаем бд


# приветственное слово
@dp.message_handler(commands=['start'])
async def hi(message: types.Message):
    await message.answer(
        'Привет! Добро пожаловать. Следи за игрой и успевай отправлять ответы')


# обработка сообщений
@dp.message_handler(content_types=['text'])
async def said(message: types.Message):
    if '1' != message.text and '2' != message.text and '3' != message.text:
        await message.answer('Такого варианта ответа нет')
    elif not bd.check_id(message.from_user.id):
        bd.new_user(
            message.from_user.id,
            message.text)  # заносим id в бд для защиты от спама ответов
import config
import logging
import asyncio
from datetime import datetime

from aiogram import Bot, Dispatcher, executor, types
from sqlighter import SQLighter

from stopgame import StopGame

# задаем уровень логов
logging.basicConfig(level=logging.INFO)

# инициализируем бота
bot = Bot(token=config.API_TOKEN)
dp = Dispatcher(bot)

# инициализируем соединение с БД
db = SQLighter('db.db')

# инициализируем парсер
sg = StopGame('lastkey.txt')


# Команда активации подписки
@dp.message_handler(commands=['subscribe'])
async def subscribe(message: types.Message):
    if (not db.subscriber_exists(message.from_user.id)):
        # если юзера нет в базе, добавляем его
        db.add_subscriber(message.from_user.id)
    else:
示例#23
0
from aiogram.utils.markdown import text, bold, italic, code, pre
from aiogram.types import ParseMode, InputMediaPhoto, InputMediaVideo, ChatActions
from apscheduler.schedulers.asyncio import AsyncIOScheduler

from config import TOKEN
from config import PROXY_URL
# from config import TOKEN_DIALOGFLOW

# Create log string
logging.basicConfig(
    format=
    u'%(filename)s [ LINE:%(lineno)+3s ]#%(levelname)+8s [%(asctime)s]  %(message)s',
    level=logging.INFO)

# pass to bot token and proxy url
bot = Bot(token=TOKEN, proxy=PROXY_URL)
# bot = Bot(token=TOKEN)
dp = Dispatcher(bot)


def get_weather(arr):
    answer = ''
    for i in arr:
        owm = pyowm.OWM('70732ac514bf006244ac74c5f31de5aa', language='ru')
        town = i
        obs = owm.weather_at_place(town)
        weather = obs.get_weather()
        temp = weather.get_temperature('celsius')['temp']
        temp = round(temp)
        wind = weather.get_wind()['speed']
        wind = round(wind)
示例#24
0
文件: web.py 项目: vstasn/aiobot
# webhook config
TELEGRAM_TOKEN = os.environ.get('TELEGRAM_TOKEN')
WEBHOOK_HOST = os.environ.get('HOST')
WEBHOOK_URL_PATH = '/webhook' + '/' + TELEGRAM_TOKEN
WEBHOOK_URL = f"https://{WEBHOOK_HOST}{WEBHOOK_URL_PATH}"

# set logging settings
log = logging.getLogger(__name__)
logging.config.dictConfig(settings['logging'])

# aio debug
aio_debug = settings.get('asyncio_debug_enabled', False)
if aio_debug is True:
    loop.set_debug(True)

bot = Bot(TELEGRAM_TOKEN, loop=loop)
dispatcher = Dispatcher(bot, storage=MemoryStorage())


async def init_pg(app):
    engine = await aiopg.sa.create_engine(dsn=os.environ.get('DATABASE_URL'),
                                          loop=app.loop)
    app['db'] = engine


async def close_pg(app):
    app['db'].close()
    await app['db'].wait_closed()


async def on_shutdown(app, url=None):
示例#25
0
import asyncio

from aiogram import Bot, Dispatcher, executor, types
from googlesearch import search

from core import db_helper
from core.config import API_TOKEN


# initialize bot & dispatcher
bot = Bot(API_TOKEN)
dp = Dispatcher(bot)

# response templates
about = '''Asynchronous Google search Telegram bot built on \
<code>aiogram</code> & <code>googlesearch</code>.

GitHub repo: <a href='https://github.com/fleischgewehr/gsearch_tgbot'>here</a>'''
current_settings = '''Your settings:

- Language: {0}
- Safe search: {1}

Choose an option:'''

# results are stored here
results = []


@dp.message_handler(commands=['start'])
async def welcome(message):
示例#26
0
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.redis import RedisStorage
from aiohttp import web

from constants import config

bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage()
dp = Dispatcher(bot, storage=storage)

routes = web.RouteTableDef()
示例#27
0
文件: main.py 项目: naztar0/TutorsBot
import os

from aiogram import Bot, Dispatcher, executor, types, utils
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.memory import MemoryStorage

WEBHOOK = True
WEBHOOK_HOST = c.app  # heroku app url
WEBHOOK_PATH = '/webhook/'
WEBHOOK_URL = f"{WEBHOOK_HOST}{WEBHOOK_PATH}"

WEBAPP_HOST = '0.0.0.0'
WEBAPP_PORT = os.environ.get('PORT')

bot = Bot(c.token)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)


class Activate(StatesGroup):
    code = State()


class Export(StatesGroup):
    code = State()


class Delete(StatesGroup):
    code = State()
示例#28
0
from data import token
from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.memory import MemoryStorage

bot = Bot(token)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
示例#29
0
    async def _register_manager(self,
                                after_break=False,
                                ignore_token_checks=False) -> None:
        # Get info about user to use it in this class
        me = await self._client.get_me()
        self._me = me.id
        self._name = get_display_name(me)

        if not ignore_token_checks:
            # Assert that token is set to valid, and if not,
            # set `init_complete` to `False` and return
            is_token_asserted = await self._assert_token()
            if not is_token_asserted:
                self.init_complete = False
                return

        # We successfully asserted token, so set `init_complete` to `True`
        self.init_complete = True

        # Create bot instance and dispatcher
        self.bot = Bot(token=self._token)
        self._bot = self.bot  # This is a temporary alias so the
        # developers can adapt their code
        self._dp = Dispatcher(self.bot)

        # Get bot username to call inline queries
        try:
            self.bot_username = (await self.bot.get_me()).username
            self._bot_username = self.bot_username  # This is a temporary alias so the
            # developers can adapt their code
        except Unauthorized:
            logger.critical("Token expired, revoking...")
            return await self._dp_revoke_token(False)

        # Start the bot in case it can send you messages
        try:
            m = await self._client.send_message(self.bot_username, "/start")
        except (InputUserDeactivatedError, ValueError):
            self._db.set("geektg.inline", "bot_token", None)
            self._token = False

            if not after_break:
                return await self._register_manager(True)

            self.init_complete = False
            return False
        except Exception:
            self.init_complete = False
            logger.critical("Initialization of inline manager failed!")
            logger.exception("due to")
            return False

        await self._client.delete_messages(self.bot_username, m)

        # Register required event handlers inside aiogram
        self._dp.register_inline_handler(self._inline_handler,
                                         lambda inline_query: True)
        self._dp.register_callback_query_handler(self._callback_query_handler,
                                                 lambda query: True)
        self._dp.register_chosen_inline_handler(
            self._chosen_inline_handler, lambda chosen_inline_query: True)
        self._dp.register_message_handler(self._message_handler,
                                          lambda *args: True,
                                          content_types=["any"])

        old = self.bot.get_updates
        revoke = self._dp_revoke_token

        async def new(*args, **kwargs):
            nonlocal revoke, old
            try:
                return await old(*args, **kwargs)
            except aiogram.utils.exceptions.TerminatedByOtherGetUpdates:
                await revoke()
            except aiogram.utils.exceptions.Unauthorized:
                logger.critical("Got Unauthorized")
                await self._stop()

        self.bot.get_updates = new

        # Start polling as the separate task, just in case we will need
        # to force stop this coro. It should be cancelled only by `stop`
        # because it stops the bot from getting updates
        self._task = asyncio.ensure_future(self._dp.start_polling())
        self._cleaner_task = asyncio.ensure_future(self._cleaner())
示例#30
0
import asyncio
import logging
import random
from typing import Dict

from aiogram import Bot, types
from aiogram.contrib.fsm_storage.redis import RedisStorage
from aiogram.dispatcher import Dispatcher, FSMContext

import config

logging.basicConfig(level=logging.INFO)

loop = asyncio.get_event_loop()
bot = Bot(token=config.API_TOKEN, loop=loop)

storage = RedisStorage()
dp = Dispatcher(bot, storage=storage)

ADMIN_ID = 211270198


def check_admin(message):
    return message.chat.id in {ADMIN_ID}


def format_participants(participants: Dict) -> str:
    return '\n'.join(
        '{name} ({id}): {bonus}'.format(name=p[0], id=id, bonus=p[1])
        for id, p in participants.items())