def __init__(self, loop, config):
"""
:param loop: asyncio.EventLoop
:param config: config data
"""
self.logger = create_logger("broadcast")
self.loop = loop
self.bot = Bot(token=config.BOT["token"], loop=loop)
self.config = config
from aiogram.types import ParseMode
from aiogram.utils import executor, exceptions
from aiogram.utils.emoji import emojize
from aiogram.utils.markdown import text, hbold, quote_html
from aiogram.contrib.middlewares.logging import LoggingMiddleware
from contrib.logging import create_logger
from config import Config
from models import User, Serial
loop = asyncio.get_event_loop()
loop.run_until_complete(
asyncio.gather(User.init_manager(Config.RDB),
Serial.init_manager(Config.RDB)))
log = create_logger("bot")
logging.getLogger("aiogram").setLevel(logging.INFO)
bot = Bot(token=Config.BOT["token"], loop=loop)
# For example use simple MemoryStorage for Dispatcher.
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
dp.middleware.setup(LoggingMiddleware())
# States
NAME = "process_name"
VOICE = "process_voice"
@dp.callback_query_handler(
import time
import asyncio
import logging
import rethinkdb as r
from models import all_models
from contrib.logging import create_logger
from config import Config
logger = create_logger("rdb_init", logging.INFO)
async def connect():
while True:
print("Connection...")
try:
rdb_connection = await r.connect(**Config.RDB)
break
except r.errors.ReqlDriverError as e:
print("Connection fail", e)
time.sleep(0.02)
db_name = Config.RDB["db"]
if db_name not in await r.db_list().run(rdb_connection):
await r.db_create(db_name).run(rdb_connection)
logger.info("DB inited")
tables = await r.table_list().run(rdb_connection)
for model in all_models:
logger.info(f"Work with {model.table_name}")
import threading
import rethinkdb as r
from config import config
from models.message import Message
from contrib.logging import create_logger
log = create_logger("messages_refresh")
class MessagesRefresh:
def __init__(self, config):
self.config = config
self.rdb_connection = r.connect(**config["rdb"])
self._exit = threading.Event()
def is_run(self):
return not self._exit.is_set()
def sleep_service(self, seconds):
self._exit.wait(seconds)
def signal_handler(self, *args, **kwargs):
log.debug("Signal received")
self._exit.set()
def run(self):
log.info("Start Message refresh")
while self.is_run():
res = r.table(self.config["db_tables"]["messages"]).\
def __init__(self, config, loop=asyncio.get_event_loop(), session=None):
super().__init__(config, loop, session)
self.wait_time = config.PARSERS["serials"]["wait_time"]
self.logger = create_logger("serial_parser",
config.PARSERS["serials"]["log_level"])
import asyncio
import rethinkdb as r
from bs4 import BeautifulSoup
from models import Message, LastUpdateHash, User
from parsers.base import BaseParser
from contrib.mixins import RethinkConnectionMixin
from contrib.logging import create_logger
r.set_loop_type("asyncio")
log = create_logger("serials_update_parser")
class UpdateSerialParser(RethinkConnectionMixin, BaseParser):
_hash = None
def __init__(self, config, loop=asyncio.get_event_loop(), session=None):
super().__init__(config, loop, session)
self.base_url = f"{config.PARSERS['base_url']}/"
self.wait_time = config.PARSERS["updates"]["wait_time"]
async def fetch_today_updates(self):
raw_html = await self._bound_fetch(self.base_url)
if not raw_html:
return None
soup = BeautifulSoup(raw_html, "html.parser")
ul_element = soup.find("ul", class_="b-seriesupdate__block_list")
updates = []