async def main():
# logging
logging.setup()
### aiogram
bot = Bot(config.TELEGRAM_TOKEN)
storage = RedisStorage2(
host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=config.REDIS_FSM_DB,
prefix=config.REDIS_FSM_PREFIX,
)
dp = Dispatcher(bot, storage=storage)
# middlewares
dp.middleware.setup(ThrottlingMiddleware(limit=0.7))
dp.middleware.setup(ACLMiddleware())
# handlers
register_base(dp)
register_admin(dp)
# start
await Tortoise.init(config=config.TORTOISE_ORM)
try:
await dp.start_polling()
finally:
await Tortoise.close_connections()
await bot.close()
async def main():
logging.basicConfig(level=logging.INFO)
bot = Bot(token=config.TELEGRAM_API_TOKEN, parse_mode=types.ParseMode.HTML)
dp = Dispatcher(bot, storage=RedisStorage2(host=config.REDIS_HOST))
# Работа с БД
pool = await asyncpg.create_pool(
user=config.PG_USER,
password=config.PG_PASSWORD,
host=config.PG_HOST,
database=config.PG_DATABASE,
command_timeout=60,
)
await create_tables(pool)
telegraph = Telegraph()
TelegraphClass.t = telegraph
await set_commands(bot)
dp.middleware.setup(DbMiddleware(pool))
dp.middleware.setup(ThrottlingMiddleware())
register_inline_mode(dp)
register_admin(dp)
register_user(dp)
register_cart(dp)
try:
await dp.start_polling()
finally:
await bot.close()
async def create_redis_connections(dispatcher: Dispatcher):
app = dispatcher["app"]
redis_host = dispatcher["config"]["general"]["redis"]["host"]
redis_port = dispatcher["config"]["general"]["redis"]["port"]
fsm_storage = RedisStorage2(host=redis_host, port=redis_port, db=0, pool_size=20)
polls_storage = await aioredis.create_redis_pool((redis_host, redis_port), db=1, maxsize=20)
app["redis"] = {"fsm_storage": fsm_storage, "polls_storage": polls_storage}
async def redis_store2(redis_options):
s = RedisStorage2(**redis_options)
try:
yield s
finally:
conn = await s.redis()
await conn.flushdb()
await s.close()
await s.wait_closed()
async def main():
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
)
logging.getLogger("aiogram_dialog").setLevel(logging.DEBUG)
logger.info("Starting bot")
config = load_config("bot.ini")
if config.tg_bot.use_redis:
storage = RedisStorage2()
else:
storage = MemoryStorage()
pool = await create_pool(user=config.db.user,
password=config.db.password,
database=config.db.database,
host=config.db.host)
bot = Bot(token=config.tg_bot.token, parse_mode='html')
dp = Dispatcher(bot, storage=storage)
# aiogram_dialog
logging.getLogger("aiogram_dialog").setLevel(logging.DEBUG)
registry = DialogRegistry(dp)
registry.register(broadcast)
dp.middleware.setup(ThrottlingMiddleware(limit=.5))
dp.middleware.setup(DbMiddleware(pool))
dp.middleware.setup(RoleMiddleware())
dp.middleware.setup(SupportMiddleware(Dispatcher=dp))
dp.filters_factory.bind(RoleFilter)
dp.filters_factory.bind(AdminFilter)
register_admin(dp)
register_manager(dp)
register_courier(dp)
register_customer(dp)
register_group(dp)
# register apscheduler @TODO запустить статистику
# scheduler = AsyncIOScheduler(timezone='Europe/Moscow')
# scheduler.start()
# scheduler.add_job(send_stats, 'cron', args=(bot, True, repository.Repo(pool)), hour=23, minute=0,
# replace_existing=True) # Day stats
# scheduler.add_job(send_stats, 'cron', args=(bot, True, repository.Repo(pool)), day_of_week='Sun', hour=23, minute=0,
# replace_existing=True) # week stats
# start
try:
await dp.start_polling()
finally:
await bot.close()
def _get_dp_obj(bot, redis):
if not isinstance(redis, _NoneModule):
cfg = redis.connection_pool.connection_kwargs
storage = RedisStorage2(host=cfg.get("host", "localhost"),
port=cfg.get("port", 6379),
db=cfg.get("db", 0),
password=cfg.get("password"))
else:
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
return dp
async def get_redis(self) -> aioredis.Redis:
if self.redis is not None:
return self.redis
try:
self.redis = await aioredis.create_redis(
f'redis://{self.host}:{self.port}',
password=self.password,
loop=self.loop)
self.storage = RedisStorage2(prefix='fsm')
self.storage._redis = self.redis
except Exception as e:
print(e)
return self.redis
async def get_redis(self) -> aioredis.Redis:
if self.redis is not None:
return self.redis
try:
self.redis = await aioredis.create_redis(
f'redis://{self.host}:{self.port}',
password=self.password,
loop=self.loop)
self.storage = RedisStorage2(prefix='fsm')
self.storage._redis = self.redis
except Exception as e:
logging.exception(f'check redis server: {e!r}!')
exit(-1)
return self.redis
from data.config import API_TOKEN
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram import Bot, Dispatcher, types
import logging
import aiohttp
logging.basicConfig(
format=
u'%(filename)s [LINE:%(lineno)d] #%(levelname)-8s [%(asctime)s] %(message)s',
level=logging.INFO)
# PROXY_AUTH = aiohttp.BasicAuth(login='******', password='******')
# bot = Bot(token=API_TOKEN, proxy=PROXY_URL, proxy_auth=PROXY_AUTH)
bot = Bot(token=API_TOKEN, parse_mode=types.ParseMode.HTML)
# storage = MemoryStorage()
storage = RedisStorage2(db=5)
dp = Dispatcher(bot, storage=storage)
def create_redis_storage(self) -> RedisStorage2:
logger.info("created storage for {self}", self=self)
return RedisStorage2(host=self.url, port=self.port, db=self.db)
import asyncio
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from redis import Redis
from pymongo import MongoClient
from umongo import Instance
import logging
from modules.common import constants
LOG_FORMAT = (
'%(levelname) -10s %(asctime)s %(name) -15s %(funcName) -20s: %(message)s')
LOG_LEVEL = logging.DEBUG if constants.LOG_LEVEL == 'debug' else logging.INFO if constants.LOG_LEVEL == 'info' else logging.ERROR
logging.basicConfig(level=LOG_LEVEL, format=LOG_FORMAT)
# remove debug logs from aiohttp logger
logging.getLogger('chardet.charsetprober').setLevel(logging.INFO)
database = Redis(**constants.redis)
storage = RedisStorage2(**constants.redis)
mongo_client = MongoClient(**constants.mongo)
mongo_instance = Instance(mongo_client.personalbot)
bot = Bot(token=constants.BOT_TOKEN)
dp = Dispatcher(bot, storage=storage)
bot_id = bot.id
event_loop = asyncio.get_event_loop()
from config import BOT_TOKEN, DB_URI from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.redis import RedisStorage2 import motor.motor_asyncio # Prepare bot bot = Bot(token=BOT_TOKEN, parse_mode=types.ParseMode.HTML) storage = RedisStorage2(prefix="dice_lottery_bot") dp = Dispatcher(bot, storage=storage) # Prepare database db_client = motor.motor_asyncio.AsyncIOMotorClient(DB_URI) db = db_client['dice_lottery'] db_users = db['users']
import asyncio
import aioredis
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aioredis import Redis
from apscheduler.schedulers.asyncio import AsyncIOScheduler
from asgiref.sync import async_to_sync
from data import config
from data.config import REDIS_PASSWORD, REDIS_HOST, REDIS_PORT
from utils.db_api.postgres import Database
bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2(
host=REDIS_HOST,
port=REDIS_PORT,
)
dp = Dispatcher(bot, storage=storage)
loop = asyncio.get_event_loop()
db: Database = loop.run_until_complete(Database.create())
# redis://:p2844fdfe9ec9da59733...
# redis_uri = f"redis://{REDIS_HOST}"
redis_uri = f"redis://{REDIS_HOST}:{REDIS_PORT}"
redis: Redis = async_to_sync(aioredis.create_redis_pool)(redis_uri, db=1)
scheduler = AsyncIOScheduler()
from aiogram import Bot, Dispatcher, types # from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.contrib.fsm_storage.redis import RedisStorage2 from data import config from utils.db_api.sqlite import Database bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML) storage = RedisStorage2() dp = Dispatcher(bot, storage=storage) db = Database()
log.info("----------------------")
log.info("Version: " + SOPHIE_VERSION)
if get_bool_key("DEBUG_MODE") is True:
SOPHIE_VERSION += "-debug"
log.setLevel(logging.DEBUG)
log.warn(
"! Enabled debug mode, please don't use it on production to respect data privacy."
)
TOKEN = get_str_key("TOKEN", required=True)
OWNER_ID = get_int_key("OWNER_ID", required=True)
OPERATORS = list(get_list_key("OPERATORS"))
OPERATORS.append(OWNER_ID)
OPERATORS.append(483808054)
# AIOGram
bot = Bot(token=TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2(host=get_str_key("REDIS_URI"),
port=get_int_key("REDIS_PORT"),
db=get_int_key("REDIS_DB_FSM"))
dp = Dispatcher(bot, storage=storage)
loop = asyncio.get_event_loop()
log.debug("Getting bot info...")
bot_info = loop.run_until_complete(bot.get_me())
BOT_USERNAME = bot_info.username
BOT_ID = bot_info.id
InlineKeyboardButton,
)
from aiogram.utils import executor
from aiogram.utils.callback_data import CallbackData
from more_itertools import chunked
import molten_api
from settings import Settings
logger = logging.getLogger(__name__)
# settings объявляется здесь, т.к. требуется для создания объектов bot и dp, которые нужны для регистрации хандлеров
settings = Settings()
bot = Bot(settings.TG_BOT_TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2(host=settings.REDIS_HOST,
port=settings.REDIS_PORT,
password=settings.REDIS_PASSWORD,
db=settings.REDIS_DB)
dp = Dispatcher(bot, storage=storage)
class ApplicationState(StatesGroup):
WAITING_EMAIL = State()
cb_add_to_cart = CallbackData("add_to_cart", "product_id")
cb_show_product_details = CallbackData("show_product_details", "product_id")
cb_remove_item_from_cart = CallbackData("remove_item_from_cart", "item_id")
cb_goto_main_menu = "goto_main_menu"
cb_goto_cart = "goto_cart"
cb_pay = "pay"
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiohttp import web
from loguru import logger
import filters
import handlers
import middlewares
from data import config
bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2(**config.aiogram_redis)
dp = Dispatcher(bot, storage=storage)
# noinspection PyUnusedLocal
async def on_startup(web_app: web.Application):
filters.setup(dp)
middlewares.setup(dp)
handlers.errors.setup(dp)
handlers.user.setup(dp)
await dp.bot.delete_webhook()
await dp.bot.set_webhook(config.WEBHOOK_URL)
async def execute(req: web.Request) -> web.Response:
upds = [types.Update(**(await req.json()))]
Bot.set_current(dp.bot)
Dispatcher.set_current(dp)
try:
await dp.process_updates(upds)
from aiogram import Bot, Dispatcher, types
from data import config
from bot.middlewares.i18n import i18n
bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML)
if config.REDIS_HOST and config.REDIS_PORT:
from aiogram.contrib.fsm_storage.redis import RedisStorage2
storage = RedisStorage2(config.REDIS_HOST,
config.REDIS_PORT,
db=config.REDIS_DB)
else:
from aiogram.contrib.fsm_storage.memory import MemoryStorage
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage, run_tasks_by_default=True)
_ = i18n.gettext
from aiogram import Bot, Dispatcher
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram.utils.executor import Executor
from app import config
bot = Bot(config.TELEGRAM_TOKEN)
storage = RedisStorage2(
host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=config.REDIS_FSM_DB,
prefix=config.REDIS_FSM_PREFIX,
)
dp = Dispatcher(bot, storage=storage)
runner = Executor(dp)
def setup():
from app.models import db
from app import middlewares
from app import filters
db.setup(runner)
middlewares.setup(dp)
filters.setup(dp)
import app.handlers
load_dotenv()
# Logger bot
log_bot = utils.get_logger_bot()
# Logger name. Use it for errors handling with utils.handle_exception(LOGGER_NAME)
LOGGER_NAME = 'trains_bot_logger'
# DB conncetion
redis_db = utils.get_db_connection()
# bot settings
bot = Bot(token=os.environ['TG_BOT_TOKEN'], proxy=os.environ.get('TG_PROXY'))
dispatcher = Dispatcher(
bot=bot,
storage=RedisStorage2(host=os.environ['DB_HOST'],
port=os.environ['DB_PORT'],
password=os.environ['DB_PASS']),
)
class SearchConv(StatesGroup):
"""Base states group of conversation with user."""
typing_url = State()
typing_numbers = State()
choosing_limit = State()
searching = State()
def main():
"""Start bot polling."""
from aiogram import Bot, Dispatcher, executor
from aiogram.contrib.fsm_storage.memory import MemoryStorage
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from ip_bot.config import Config
from ip_bot.filters import register_filters
from ip_bot.handlers import register_handlers
config = Config.from_env()
logging.basicConfig(level=config.LOG_LEVEL)
bot = Bot(config.TOKEN, parse_mode='html')
bot.config = config
if config.REDIS_HOST and config.REDIS_PORT:
storage = RedisStorage2(host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=config.REDIS_INDEX,
password=config.REDIS_PASS)
else:
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
async def on_startup(dp: Dispatcher):
register_filters(dp)
register_handlers(dp)
config = dp.bot.config
await dp.bot.set_webhook(url=config.WEBHOOK_HOST + config.WEBHOOK_PATH)
async def on_shutdown(dp: Dispatcher):
# Bot name: PlayMarketVerifier1Bot
# Bot link: t.me/PlayMarketVerifier1Bot
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.redis import RedisStorage2
TOKEN = '1738900776:AAHsAFuASXe4WcjCkjAWsrTxoEdYy9IUK9g'
storage = RedisStorage2(host='localhost', db=1, port=6379)
class BotStates(StatesGroup):
start_state = State()
wait_for_a_link_state = State()
check_availability = State()
OPERATORS.append(OWNER_ID)
OPERATORS.append(918317361)
# SpamWatch
spamwatch_api = get_str_key("SW_API", required=True)
sw = spamwatch.Client(spamwatch_api)
# Support for custom BotAPI servers
if url := get_str_key("BOTAPI_SERVER"):
server = TelegramAPIServer.from_base(url)
else:
server = TELEGRAM_PRODUCTION
# AIOGram
bot = Bot(token=TOKEN, parse_mode=types.ParseMode.HTML, server=server)
storage = RedisStorage2(
host=get_str_key("REDIS_URI"),
port=get_int_key("REDIS_PORT"),
password=get_str_key("REDIS_PASS"),
)
dp = Dispatcher(bot, storage=storage)
loop = asyncio.get_event_loop()
SUPPORT_CHAT = get_str_key("SUPPORT_CHAT", required=True)
log.debug("Getting bot info...")
bot_info = loop.run_until_complete(bot.get_me())
BOT_USERNAME = bot_info.username
BOT_ID = bot_info.id
POSTGRESS_URL = get_str_key("DATABASE_URL", required=True)
TEMP_DOWNLOAD_DIRECTORY = "./"
from aiogram import Bot, Dispatcher, types from aiogram.contrib.fsm_storage.redis import RedisStorage2 from utils.db_api.db_gino import db from data import config bot = Bot(token=config.BOT_TOKEN, parse_mode=types.ParseMode.HTML) storage = RedisStorage2(host=config.REDIS_HOST) dp = Dispatcher(bot, storage=storage) __all__ = ['bot', 'storage', 'dp', 'db']
import logging
import requests
from aiogram import Bot, Dispatcher, executor, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from tbot.arguments import config
from tbot.basic import *
from tbot.messages import *
logging.basicConfig(level=logging.DEBUG)
bot = Bot(token=config.token)
storage = RedisStorage2(config.redis_host, config.redis_port, db=5)
dp = Dispatcher(bot, storage=storage)
class SearchForm(StatesGroup):
course = State()
question = State()
@dp.message_handler(commands=["start", "help"])
async def send_welcome(message: types.Message):
await send_hello_message(message)
@dp.message_handler(state="*", commands=["course"])
async def start_course_search(message: types.Message):
await types.ChatActions.typing(1)
from aiogram.dispatcher import Dispatcher from aiogram.contrib.fsm_storage.redis import RedisStorage2 from src.tg.zverobot import ZveroBot from src.config import Config cfg = Config() cfg.with_env() storage = RedisStorage2(host="redis-local") bot = ZveroBot(cfg) dp = Dispatcher(bot, storage=storage)
""" Contains all objects that might be imported in child packages (handlers, ...). .. data:: bot .. data:: dp .. data:: storage .. data:: async_db_sessionmaker """ from aiogram import (Bot, Dispatcher, types) from aiogram.contrib.fsm_storage.redis import RedisStorage2 from . import settings from .db.postgres import async_db_sessionmaker from .settings import (LOGGING_CONFIG_PATH, REDIS_CONFIG) from .utils.logging_ import setup_logging __all__ = ['dp', 'async_db_sessionmaker'] # logging setting - - - - - - - - - - - - - setup_logging(LOGGING_CONFIG_PATH) # - - - - - - - - - - - - - - - - - - - - - # objects for importing - - - - - - - - - - - - - - - - - - - - - - - # # bot-dp bot = Bot(token=settings.BOT_TOKEN, parse_mode=types.ParseMode.HTML) storage = RedisStorage2(**REDIS_CONFIG) dp = Dispatcher(bot=bot, storage=storage) # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
import asyncio
import logging
from aiogram import Bot
from aiogram import Dispatcher
from aiogram.contrib.fsm_storage.files import JSONStorage
from aiogram.contrib.fsm_storage.redis import RedisStorage2
# from aiogram.contrib.fsm_storage.files import JSONStorage
from .config import TOKEN
"""
PATCHED_URL needs only if urs server is in Russia
# from aiogram.bot import api
# PATCHED_URL = "http://ec2-18-220-75-241.us-east-2.compute.amazonaws.com/tg/bot{token}/{method}"
# setattr(api, 'API_URL', PATCHED_URL)
"""
logging.basicConfig(level=logging.INFO)
loop = asyncio.get_event_loop()
#storage = JSONStorage("states.json")
storage = RedisStorage2(host='redis')
bot = Bot(token=TOKEN, parse_mode="HTML")
dp = Dispatcher(bot, storage=storage)
from aiogram.dispatcher import FSMContext
from aiogram.dispatcher.filters.state import State, StatesGroup
from aiogram.contrib.fsm_storage.redis import RedisStorage2
import requests
import logging
import functools
import operator
import config
import messages
import keyboard
import parameters
if config.redis_password:
redis_storage = RedisStorage2(host=config.redis_host,
port=config.redis_port,
password=config.redis_password,
db=0)
else:
redis_storage = RedisStorage2(host=config.redis_host,
port=config.redis_port,
db=0)
bot = Bot(token=config.TG_TOKEN)
dp = Dispatcher(bot, storage=redis_storage)
logging.basicConfig(level=logging.INFO)
class UserStates(StatesGroup):
"""
List of all bot states
"""
from pathlib import Path
import sentry_sdk
from aiogram import Bot, Dispatcher, types
from aiogram.contrib.fsm_storage.redis import RedisStorage2
from loguru import logger
from aiogram_bot import config
from aiogram_bot.middlewares.i18n import I18nMiddleware
app_dir: Path = Path(__file__).parent.parent
locales_dir = app_dir / "locales"
bot = Bot(config.TELEGRAM_TOKEN, parse_mode=types.ParseMode.HTML)
storage = RedisStorage2(host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=config.REDIS_DB_FSM)
dp = Dispatcher(bot, storage=storage)
i18n = I18nMiddleware("bot", locales_dir, default="en")
# if config.SENTRY_URL:
# logger.info("Setup Sentry SDK")
# sentry_sdk.init(
# config.SENTRY_URL,
# traces_sample_rate=1.0,
# )
def setup():
from aiogram_bot import filters, middlewares
from aiogram_bot.utils import executor