init

shared/config_helper.py

@@ -0,0 +1,35 @@
+import sys
+
+from pydantic import ValidationError
+from pydantic_settings import BaseSettings
+
+RED = '\033[91m'
+YELLOW = '\033[33m'
+RESET = '\033[0m'
+BOLD = '\033[1m'
+
+
+def load_settings(settings_class: type[BaseSettings]) -> BaseSettings:
+    try:
+        return settings_class()
+    except ValidationError as e:
+        print(f'{RED}{BOLD}Missing environment variables:{RESET}')
+
+        missing = set()
+        for err in e.errors():
+            if err['type'] == 'missing' and len(err['loc']) == 1:
+                field = settings_class.model_fields.get(str(err['loc'][0]))
+                if field and hasattr(field.annotation, 'model_fields'):
+                    for name, info in field.annotation.model_fields.items():
+                        if info.is_required():
+                            missing.add(f'{err["loc"][0]}__{name}'.upper())
+                else:
+                    missing.add('__'.join(str(loc).upper() for loc in err['loc']))
+            else:
+                missing.add('__'.join(str(loc).upper() for loc in err['loc']))
+
+        for field in sorted(missing):
+            print(f'  {YELLOW}{field}{RESET}')
+
+        print(f'\n{RED}Check .env file or set required variables{RESET}')
+        sys.exit(1)

shared/logger/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ['LoggerConfig', 'init']
+
+from .logger import LoggerConfig, init

shared/logger/console_formatter.py

@@ -0,0 +1,62 @@
+import logging
+from datetime import datetime
+
+
+class ColoredConsoleFormatter(logging.Formatter):
+    TIME_COLOR = '\033[38;2;89;89;89m'
+    RESET = '\033[0m'
+    BOLD = '\033[1m'
+    DARK_CYAN = '\033[36m'
+    DARK_YELLOW = '\033[33m'
+    RED = '\033[91m'
+
+    LEVEL_COLORS = {
+        logging.DEBUG: '\033[36m',
+        logging.INFO: '\033[32m',
+        logging.WARNING: '\033[33m',
+        logging.ERROR: RED,
+        logging.CRITICAL: '\033[35m',
+    }
+
+    LEVEL_NAMES = {
+        logging.DEBUG: 'DBG',
+        logging.INFO: 'INF',
+        logging.WARNING: 'WRN',
+        logging.ERROR: 'ERR',
+        logging.CRITICAL: 'CRT',
+    }
+
+    def format(self, record: logging.LogRecord) -> str:
+        timestamp = f'{self.TIME_COLOR}{datetime.fromtimestamp(record.created).strftime("%H:%M:%S")}{self.RESET}'
+
+        level_name = self.LEVEL_NAMES.get(record.levelno, record.levelname[:3])
+        level_color = self.LEVEL_COLORS.get(record.levelno, '')
+        level = f'{level_color}{level_name}{self.RESET}'
+
+        message_color = self.RED if record.levelno >= logging.ERROR else ''
+        message = f'{message_color}{self.BOLD}{record.getMessage()}{self.RESET}'
+
+        # Add extra fields
+        extra_parts = []
+        for key, value in record.__dict__.items():
+            if key not in ['name', 'msg', 'args', 'created', 'filename', 'funcName', 'levelname',
+                          'levelno', 'lineno', 'module', 'msecs', 'message', 'pathname', 'process',
+                          'processName', 'relativeCreated', 'thread', 'threadName', 'exc_info',
+                          'exc_text', 'stack_info', 'app_name', 'app_version', 'taskName',
+                          'color_message']:
+                value_color = self.RED if key == 'error' else self.DARK_YELLOW
+                extra_parts.append(f'{self.DARK_CYAN}{key}{self.RESET}={value_color}{value}{self.RESET}')
+
+        if extra_parts:
+            message += f' {" ".join(extra_parts)}'
+
+        if record.levelno >= logging.WARNING:
+            location = f'{self.TIME_COLOR}{record.module}:{record.lineno}{self.RESET}'
+            result = f'{timestamp} {level} {location} {message}'
+        else:
+            result = f'{timestamp} {level} {message}'
+
+        if record.exc_info:
+            result += '\n' + self.formatException(record.exc_info)
+
+        return result

shared/logger/json_formatter.py

@@ -0,0 +1,54 @@
+import json
+import logging
+from datetime import UTC, datetime
+
+
+class JSONFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        log_data = {
+            'timestamp': datetime.fromtimestamp(record.created, UTC).isoformat(),
+            'level': record.levelname,
+            'message': record.getMessage(),
+            'module': record.module,
+            'package': record.name,
+            'app_name': record.app_name,
+            'app_version': record.app_version,
+        }
+
+        if record.levelno >= logging.ERROR:
+            log_data['location'] = f'{record.pathname}:{record.lineno}'
+
+        if record.exc_info:
+            log_data['error_type'] = record.exc_info[0].__name__
+            log_data['error_message'] = str(record.exc_info[1])
+            log_data['traceback'] = self.formatException(record.exc_info)
+
+        for key, value in record.__dict__.items():
+            if key not in {
+                'name',
+                'msg',
+                'args',
+                'created',
+                'filename',
+                'funcName',
+                'levelname',
+                'levelno',
+                'lineno',
+                'module',
+                'msecs',
+                'message',
+                'pathname',
+                'process',
+                'processName',
+                'relativeCreated',
+                'thread',
+                'threadName',
+                'exc_info',
+                'exc_text',
+                'stack_info',
+                'app_name',
+                'app_version',
+            }:
+                log_data[key] = value
+
+        return json.dumps(log_data, ensure_ascii=False)

shared/logger/logger.py

@@ -0,0 +1,55 @@
+import logging
+import subprocess
+import sys
+
+import pydantic
+from pydantic.fields import Field
+
+from .console_formatter import ColoredConsoleFormatter
+from .json_formatter import JSONFormatter
+
+
+def get_git_commit() -> str:
+    try:
+        return subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], text=True).strip()
+    except Exception:
+        return 'unknown'
+
+
+class LoggerConfig(pydantic.BaseModel):
+    APP_NAME: str
+    APP_VERSION: str = Field(default_factory=get_git_commit)
+    LEVEL: int = logging.INFO
+    PRETTY_CONSOLE: bool = False
+
+
+def init(config: LoggerConfig) -> None:
+    root_logger = logging.getLogger()
+    root_logger.setLevel(config.LEVEL)
+    root_logger.handlers.clear()
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setLevel(config.LEVEL)
+
+    formatter = ColoredConsoleFormatter() if config.PRETTY_CONSOLE else JSONFormatter()
+    handler.setFormatter(formatter)
+    root_logger.addHandler(handler)
+
+    for logger_name in ['uvicorn', 'uvicorn.access', 'uvicorn.error']:
+        uvicorn_logger = logging.getLogger(logger_name)
+        uvicorn_logger.handlers = [handler]
+        uvicorn_logger.propagate = False
+
+    old_factory = logging.getLogRecordFactory()
+
+    def record_factory(*args, **kwargs) -> logging.LogRecord:
+        record = old_factory(*args, **kwargs)
+        record.app_name = config.APP_NAME
+        record.app_version = config.APP_VERSION
+        return record
+
+    logging.setLogRecordFactory(record_factory)
+
+    logging.info(
+        'Logger initialized', extra={'app': config.APP_NAME, 'version': config.APP_VERSION}
+    )

shared/postgres/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ('DatabaseConfig', 'DatabaseHelper')
+
+from .postgres_helper import DatabaseConfig, DatabaseHelper

shared/postgres/postgres_helper.py

@@ -0,0 +1,117 @@
+import logging
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+import pydantic
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+
+class DatabaseConfig(pydantic.BaseModel):
+    URL: pydantic.PostgresDsn
+    ECHO: bool = False
+    ECHO_POOL: bool = False
+    POOL_SIZE: int = 50
+    MAX_OVERFLOW: int = 10
+
+
+class DatabaseHelper:
+    def __init__(self, config: DatabaseConfig, migrations_path: str = 'migration/versions') -> None:
+        self.config = config
+        self.migrations_path = migrations_path
+        self.engine: AsyncEngine | None = None
+        self.session_factory: async_sessionmaker[AsyncSession] | None = None
+
+    async def connect(self) -> None:
+        if self.engine is not None:
+            logging.warning('Database already connected')
+            return
+
+        self.engine = create_async_engine(
+            url=str(self.config.URL),
+            echo=self.config.ECHO,
+            echo_pool=self.config.ECHO_POOL,
+            pool_size=self.config.POOL_SIZE,
+            max_overflow=self.config.MAX_OVERFLOW,
+        )
+
+        self.session_factory = async_sessionmaker(
+            bind=self.engine,
+            autoflush=False,
+            autocommit=False,
+            expire_on_commit=False,
+        )
+
+        await self.ping()
+        await self._check_migrations()
+
+        logging.info('Database initialized')
+
+    async def ping(self) -> None:
+        try:
+            async with self.session_getter() as session:
+                await session.execute(text('SELECT 1'))
+        except Exception as e:
+            logging.error(f'Database ping failed: {e}')
+
+    async def close(self) -> None:
+        if self.engine is None:
+            logging.warning('Database already closed')
+            return
+
+        await self.engine.dispose()
+        self.engine = None
+        self.session_factory = None
+
+        logging.info('Database closed')
+
+    @asynccontextmanager
+    async def session_getter(self) -> AsyncGenerator[AsyncSession]:
+        """Контекстный менеджер для получения сессии"""
+        if self.session_factory is None:
+            raise RuntimeError('Database not connected. Call connect() first.')
+
+        async with self.session_factory() as session:
+            yield session
+
+    async def _check_migrations(self) -> None:
+        migrations_dir = Path(self.migrations_path)
+        if not migrations_dir.exists():
+            return
+
+        latest_file = next(
+            (
+                f
+                for f in sorted(migrations_dir.glob('*.py'), reverse=True)
+                if f.name != '__init__.py'
+            ),
+            None,
+        )
+        if not latest_file:
+            return
+
+        latest_version = latest_file.stem.split('_')[0]
+
+        async with self.session_getter() as session:
+            result = await session.execute(
+                text(
+                    "SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = 'alembic_version')"
+                )
+            )
+            if not result.scalar():
+                logging.error('Migrations not applied. Run: alembic upgrade head')
+                return
+
+            result = await session.execute(text('SELECT version_num FROM alembic_version'))
+            current_version = result.scalar()
+
+            if current_version != latest_version:
+                logging.warning(
+                    f'Database version {current_version} is outdated (latest: {latest_version}). Run: alembic upgrade head'
+                )

shared/telegram/__init__.py

@@ -0,0 +1,3 @@
+from shared.telegram.telegram_bot import TelegramConfig, TelegramHelper
+
+__all__ = ['TelegramHelper', 'TelegramConfig']

shared/telegram/telegram_bot.py

@@ -0,0 +1,50 @@
+import asyncio
+import logging
+
+import pydantic
+from aiogram import Bot, Dispatcher, Router
+
+
+class TelegramConfig(pydantic.BaseModel):
+    TOKEN: str
+    DROP_PENDING_UPDATES: bool = True
+
+
+class TelegramHelper:
+    def __init__(self, config: TelegramConfig, *routers: Router) -> None:
+        self.bot: Bot = Bot(token=config.TOKEN)
+        self.dispatcher: Dispatcher = Dispatcher()
+        self._polling_task: asyncio.Task | None = None
+        self._drop_pending_updates: bool = config.DROP_PENDING_UPDATES
+
+        for router in routers:
+            self.dispatcher.include_router(router)
+
+        logging.info('Telegram bot initialized')
+
+    async def start_polling(self) -> None:
+        """Start bot polling in background"""
+        if self._polling_task is not None:
+            logging.warning('Bot polling already started')
+            return
+
+        self._polling_task = asyncio.create_task(
+            self.dispatcher.start_polling(self.bot, drop_pending_updates=self._drop_pending_updates)
+        )
+
+        logging.info('Telegram bot polling started')
+
+    async def stop_polling(self) -> None:
+        """Stop bot polling and cleanup"""
+        if self._polling_task is None:
+            logging.warning('Bot polling not started')
+            return
+
+        self._polling_task.cancel()
+
+        if self.bot.session is not None:
+            await self.bot.session.close()
+
+        self._polling_task = None
+
+        logging.info('Telegram bot stopped')