Added documentation, added websocket and tasks

app/telegram/database/requests.py

@@ -3,29 +3,37 @@ from logger_helper.logger_helper import LOGGING_CONFIG
 from datetime import datetime, timedelta
 from typing import Any
 
+from app.telegram.database.models import (
+    async_session,
+    User_Telegram_Id as UTi,
+    User_Main_Settings as UMS,
+    User_Bybit_API as UBA,
+    User_Symbol,
+    User_Risk_Management_Settings as URMS,
+    User_Condition_Settings as UCS,
+    User_Additional_Settings as UAS,
+    Trading_Mode,
+    Margin_type,
+    Trigger,
+    USER_DEALS,
+    UserTimer,
+)
+
+from sqlalchemy import select, update
+
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("requests")
 
-from app.telegram.database.models import async_session
-from app.telegram.database.models import User_Telegram_Id as UTi
-from app.telegram.database.models import User_Main_Settings as UMS
-from app.telegram.database.models import User_Bybit_API as UBA
-from app.telegram.database.models import User_Symbol
-from app.telegram.database.models import User_Risk_Management_Settings as URMS
-from app.telegram.database.models import User_Condition_Settings as UCS
-from app.telegram.database.models import User_Additional_Settings as UAS
-from app.telegram.database.models import Trading_Mode
-from app.telegram.database.models import Margin_type
-from app.telegram.database.models import Trigger
-from app.telegram.database.models import USER_DEALS, UserTimer
 
-import app.telegram.functions.functions as func  # functions
+# --- Функции сохранения в БД ---
 
-from sqlalchemy import select, delete, update
+async def save_tg_id_new_user(tg_id) -> None:
+    """
+    Сохраняет Telegram ID нового пользователя в базу, если такого ещё нет.
 
-
-# SET_DB
-async def save_tg_id_new_user(tg_id):
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
 
@@ -37,26 +45,33 @@ async def save_tg_id_new_user(tg_id):
         await session.commit()
 
 
-async def set_new_user_bybit_api(tg_id):
+async def set_new_user_bybit_api(tg_id) -> None:
+    """
+    Создаёт запись API пользователя Bybit, если её ещё нет.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id))
 
         if not user:
-            session.add(UBA(
-                tg_id=tg_id,
-            ))
-
+            session.add(UBA(tg_id=tg_id))
         await session.commit()
 
 
-async def set_new_user_symbol(tg_id):
+async def set_new_user_symbol(tg_id) -> None:
+    """
+    Создаёт запись торгового символа пользователя, если её нет.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id))
 
         if not user:
-            session.add(User_Symbol(
-                tg_id=tg_id
-            ))
+            session.add(User_Symbol(tg_id=tg_id))
 
             logger.info(f"Symbol был успешно добавлен %s", tg_id)
 
@@ -64,6 +79,14 @@ async def set_new_user_symbol(tg_id):
 
 
 async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None:
+    """
+    Создаёт основные настройки пользователя по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+        trading_mode (str): Режим торговли.
+        margin_type (str): Тип маржи.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
 
@@ -80,6 +103,12 @@ async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -
 
 
 async def set_new_user_default_risk_management_settings(tg_id) -> None:
+    """
+    Создаёт настройки риск-менеджмента по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
 
@@ -94,6 +123,13 @@ async def set_new_user_default_risk_management_settings(tg_id) -> None:
 
 
 async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
+    """
+    Создаёт условные настройки по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+        trigger (Any): Значение триггера по умолчанию.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id))
 
@@ -109,6 +145,12 @@ async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
 
 
 async def set_new_user_default_additional_settings(tg_id) -> None:
+    """
+    Создаёт дополнительные настройки по умолчанию.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+    """
     async with async_session() as session:
         settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id))
 
@@ -122,32 +164,46 @@ async def set_new_user_default_additional_settings(tg_id) -> None:
         await session.commit()
 
 
-# GET_DB
+# --- Функции получения данных из БД ---
+
 async def check_user(tg_id):
+    """
+    Проверяет наличие пользователя в базе.
+
+    Args:
+        tg_id (int): Telegram ID пользователя.
+
+    Returns:
+        Optional[UTi]: Пользователь или None.
+    """
     async with async_session() as session:
         user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
         return user
 
 
 async def get_bybit_api_key(tg_id):
+    """Получить API ключ Bybit пользователя."""
     async with async_session() as session:
         api_key = await session.scalar(select(UBA.api_key).where(UBA.tg_id == tg_id))
         return api_key
 
 
 async def get_bybit_secret_key(tg_id):
+    """Получить секретный ключ Bybit пользователя."""
     async with async_session() as session:
         secret_key = await session.scalar(select(UBA.secret_key).where(UBA.tg_id == tg_id))
         return secret_key
 
 
 async def get_symbol(tg_id):
+    """Получить символ пользователя."""
     async with async_session() as session:
         symbol = await session.scalar(select(User_Symbol.symbol).where(User_Symbol.tg_id == tg_id))
         return symbol
 
 
 async def get_user_trades(tg_id):
+    """Получить сделки пользователя."""
     async with async_session() as session:
         query = select(USER_DEALS.symbol, USER_DEALS.side).where(USER_DEALS.tg_id == tg_id)
         result = await session.execute(query)
@@ -155,14 +211,63 @@ async def get_user_trades(tg_id):
         return trades
 
 
+async def get_entry_order_type(tg_id: object) -> str | None | Any:
+    """Получить тип входного ордера пользователя."""
+    async with async_session() as session:
+        order_type = await session.scalar(
+            select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
+        )
+        # Если в базе не установлен тип — возвращаем значение по умолчанию
+        return order_type or 'Market'
+
+
+# --- Функции обновления данных ---
+
 async def update_user_trades(tg_id, **kwargs):
+    """Обновить сделки пользователя."""
     async with async_session() as session:
         query = update(USER_DEALS).where(USER_DEALS.tg_id == tg_id).values(**kwargs)
         await session.execute(query)
         await session.commit()
 
 
+async def update_symbol(tg_id: int, symbol: str) -> None:
+    """Обновить торговый символ пользователя."""
+    async with async_session() as session:
+        await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol))
+        await session.commit()
+
+
+async def update_api_key(tg_id: int, api: str) -> None:
+    """Обновить API ключ пользователя."""
+    async with async_session() as session:
+        await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api))
+        await session.commit()
+
+
+async def update_secret_key(tg_id: int, api: str) -> None:
+    """Обновить секретный ключ пользователя."""
+    async with async_session() as session:
+        await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))
+        await session.commit()
+
+
+# --- Более мелкие обновления и запросы по настройкам ---
+
+async def update_trade_mode_user(tg_id, trading_mode) -> None:
+    """Обновить режим торговли пользователя."""
+    async with async_session() as session:
+        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))
+
+        if mode:
+            logger.info("Изменён торговый режим для пользователя %s", tg_id)
+            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode))
+
+            await session.commit()
+
+
 async def delete_user_trade(tg_id: int, symbol: str):
+    """Удалить сделку пользователя."""
     async with async_session() as session:
         await session.execute(
             USER_DEALS.__table__.delete().where(
@@ -173,24 +278,28 @@ async def delete_user_trade(tg_id: int, symbol: str):
 
 
 async def get_for_registration_trading_mode():
+    """Получить режим торговли по умолчанию."""
     async with async_session() as session:
         mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.id == 1))
         return mode
 
 
 async def get_for_registration_margin_type():
+    """Получить тип маржи по умолчанию."""
     async with async_session() as session:
         type = await session.scalar(select(Margin_type.type).where(Margin_type.id == 1))
         return type
 
 
 async def get_for_registration_trigger():
+    """Получить триггер по умолчанию."""
     async with async_session() as session:
         trigger = await session.scalar(select(Trigger.trigger).where(Trigger.id == 1))
         return trigger
 
 
 async def get_user_main_settings(tg_id):
+    """Получить основные настройки пользователя."""
     async with async_session() as session:
         user = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
 
@@ -223,6 +332,7 @@ async def get_user_main_settings(tg_id):
 
 
 async def get_user_risk_management_settings(tg_id):
+    """Получить риск-менеджмента настройки пользователя."""
     async with async_session() as session:
         user = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
 
@@ -244,41 +354,8 @@ async def get_user_risk_management_settings(tg_id):
             return data
 
 
-# UPDATE_SYMBOL
-async def update_symbol(tg_id, symbol) -> None:
-    async with async_session() as session:
-        await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol))
-
-        await session.commit()
-
-
-async def update_api_key(tg_id, api):
-    async with async_session() as session:
-        api_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api))
-
-        await session.commit()
-
-
-async def update_secret_key(tg_id, api):
-    async with async_session() as session:
-        secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))
-
-        await session.commit()
-
-
-# UPDATE_MAIN_SETTINGS_DB
-async def update_trade_mode_user(tg_id, trading_mode) -> None:
-    async with async_session() as session:
-        mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))
-
-        if mode:
-            logger.info("Изменен трейд мод %s", tg_id)
-            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode))
-
-            await session.commit()
-
-
 async def update_margin_type(tg_id, margin_type) -> None:
+    """Обновить тип маржи пользователя."""
     async with async_session() as session:
         type = await session.scalar(select(Margin_type.type).where(Margin_type.type == margin_type))
 
@@ -290,6 +367,7 @@ async def update_margin_type(tg_id, margin_type) -> None:
 
 
 async def update_size_leverange(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage=num))
 
@@ -297,6 +375,7 @@ async def update_size_leverange(tg_id, num):
 
 
 async def update_starting_quantity(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num))
 
@@ -304,6 +383,7 @@ async def update_starting_quantity(tg_id, num):
 
 
 async def update_martingale_factor(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num))
 
@@ -311,15 +391,17 @@ async def update_martingale_factor(tg_id, num):
 
 
 async def update_maximal_quantity(tg_id, num):
+    """Обновить размер левеража пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity=num))
 
         await session.commit()
 
 
-# UPDATE_RISK_MANAGEMENT_SETTINGS_DB
+# ОБНОВЛЕНИЕ НАСТРОЕК РИСК-МЕНЕДЖМЕНТА
 
 async def update_price_profit(tg_id, num):
+    """Обновить цену тейк-профита (прибыль) пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit=num))
 
@@ -327,6 +409,7 @@ async def update_price_profit(tg_id, num):
 
 
 async def update_price_loss(tg_id, num):
+    """Обновить цену тейк-лосса (убыток) пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss=num))
 
@@ -334,6 +417,7 @@ async def update_price_loss(tg_id, num):
 
 
 async def update_max_risk_deal(tg_id, num):
+    """Обновить максимальную сумму риска пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num))
 
@@ -341,6 +425,7 @@ async def update_max_risk_deal(tg_id, num):
 
 
 async def update_entry_order_type(tg_id, order_type):
+    """Обновить тип входного ордера пользователя."""
     async with async_session() as session:
         await session.execute(
             update(UMS)
@@ -350,16 +435,8 @@ async def update_entry_order_type(tg_id, order_type):
         await session.commit()
 
 
-async def get_entry_order_type(tg_id: object) -> str | None | Any:
-    async with async_session() as session:
-        order_type = await session.scalar(
-            select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
-        )
-        # Если в базе не установлен тип — возвращаем значение по умолчанию
-        return order_type or 'Market'
-
-
 async def get_limit_price(tg_id):
+    """Получить лимитную цену пользователя как float, либо None."""
     async with async_session() as session:
         result = await session.execute(
             select(UMS.limit_order_price)
@@ -375,6 +452,7 @@ async def get_limit_price(tg_id):
 
 
 async def update_limit_price(tg_id, price):
+    """Обновить лимитную цену пользователя."""
     async with async_session() as session:
         await session.execute(
             update(UMS)
@@ -385,6 +463,7 @@ async def update_limit_price(tg_id, price):
 
 
 async def update_commission_fee(tg_id, num):
+    """Обновить комиссию пользователя."""
     async with async_session() as session:
         await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee=num))
 
@@ -392,6 +471,7 @@ async def update_commission_fee(tg_id, num):
 
 
 async def get_user_timer(tg_id):
+    """Получить данные о таймере пользователя."""
     async with async_session() as session:
         result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
         user_timer = result.scalars().first()
@@ -422,38 +502,39 @@ async def get_user_timer(tg_id):
 
 
 async def update_user_timer(tg_id, minutes: int):
+    """Обновить данные о таймере пользователя."""
     async with async_session() as session:
         try:
-            async with async_session() as session:
-                timer_start = None
-                timer_end = None
+            timer_start = None
+            timer_end = None
 
-                if minutes > 0:
-                    timer_start = datetime.utcnow()
-                    timer_end = timer_start + timedelta(minutes=minutes)
+            if minutes > 0:
+                timer_start = datetime.utcnow()
+                timer_end = timer_start + timedelta(minutes=minutes)
 
-                result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
-                user_timer = result.scalars().first()
+            result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
+            user_timer = result.scalars().first()
 
-                if user_timer:
-                    user_timer.timer_minutes = minutes
-                    user_timer.timer_start = timer_start
-                    user_timer.timer_end = timer_end
-                else:
-                    user_timer = UserTimer(
-                        tg_id=tg_id,
-                        timer_minutes=minutes,
-                        timer_start=timer_start,
-                        timer_end=timer_end
-                    )
-                    session.add(user_timer)
+            if user_timer:
+                user_timer.timer_minutes = minutes
+                user_timer.timer_start = timer_start
+                user_timer.timer_end = timer_end
+            else:
+                user_timer = UserTimer(
+                    tg_id=tg_id,
+                    timer_minutes=minutes,
+                    timer_start=timer_start,
+                    timer_end=timer_end
+                )
+                session.add(user_timer)
 
-                await session.commit()
+            await session.commit()
         except Exception as e:
             logging.error(f"Ошибка обновления таймера пользователя {tg_id}: {e}")
 
 
 async def get_martingale_step(tg_id):
+    """Получить шаг мартингейла пользователя."""
     async with async_session() as session:
         result = await session.execute(select(UMS).where(UMS.tg_id == tg_id))
         user_settings = result.scalars().first()
@@ -461,6 +542,7 @@ async def get_martingale_step(tg_id):
 
 
 async def update_martingale_step(tg_id, step):
+    """Обновить шаг мартингейла пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step))