app/services/Bybit/functions/Futures.py

@@ -1,13 +1,15 @@
 import asyncio
 import time
-import logging
+import logging.config
 from pybit import exceptions
 from pybit.unified_trading import HTTP
-
+from logger_helper.logger_helper import LOGGING_CONFIG
 import app.services.Bybit.functions.price_symbol as price_symbol
 import app.services.Bybit.functions.balance as balance_g
 import app.telegram.database.requests as rq
 
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("futures")
 
 async def info_access_open_deal(message, symbol, trade_mode, margin_mode, leverage, qty):
     human_margin_mode = 'Isolated' if margin_mode == 'ISOLATED_MARGIN' else 'Cross'
@@ -44,6 +46,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
     symbol = await rq.get_symbol(tg_id)
 
     data_main_stgs = await rq.get_user_main_settings(tg_id)
+    order_type = data_main_stgs.get('entry_order_type', 'Market')
+    limit_price = None
+    if order_type == 'Limit':
+        limit_price = await rq.get_limit_price(tg_id)
     data_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
 
     bybit_margin_mode = 'ISOLATED_MARGIN' if margin_mode == 'Isolated' else 'REGULAR_MARGIN'
@@ -51,8 +57,8 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
     client = HTTP(api_key=api_key, api_secret=secret_key)
 
     try:
-        balance = await balance_g.get_balance(tg_id)
+        balance = await balance_g.get_balance(tg_id, message)
-        price = await price_symbol.get_price(tg_id, message)
+        price = await price_symbol.get_price(tg_id)
 
         # Установка маржинального режима
         client.set_margin_mode(setMarginMode=bybit_margin_mode)
@@ -109,9 +115,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
             category='linear',
             symbol=symbol,
             side=side,
-            orderType="Market",
+            orderType=order_type,
             qty=next_quantity,
             leverage=int(data_main_stgs['size_leverage']),
+            price=limit_price if order_type == 'Limit' else None,
             takeProfit=takeProfit,
             stopLoss=loss_profit,
             orderLinkId=f"deal_{symbol}_{int(time.time())}"
@@ -125,11 +132,11 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
             await message.answer(f"Ошибка открытия ордера: {response.get('ret_msg', 'неизвестная ошибка')}")
 
     except exceptions.InvalidRequestError as e:
-        logging.error(f"InvalidRequestError: {e}")
+        logger.error(f"InvalidRequestError: {e}")
         await message.answer('Ошибка: неверно указана торговая пара или параметры.')
     except Exception as e:
-        logging.error(f"Ошибка при совершении сделки: {e}")
+        logger.error(f"Ошибка при совершении сделки: {e}")
-        await message.answer('⚠️ Ошибка при совершении сделки')
+
 
 
 async def trading_cycle(tg_id, message):
@@ -179,7 +186,7 @@ async def get_active_positions(message, api_key, secret_key, symbol):
                     if pos.get('size') and float(pos['size']) > 0:
                         active_positions.append(pos)
         except Exception as e:
-            logging.error(f"Ошибка при получении позиций: {e}")
+            logger.error(f"Ошибка при получении позиций: {e}")
             await message.answer('⚠️ Ошибка при получении позиций')
 
     for sym in symbols:
@@ -228,7 +235,7 @@ async def close_user_trade(tg_id: int, symbol: str) -> bool:
         )
         return response['ret_code'] == 0
     except Exception as e:
-        logging.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}")
+        logger.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}")
 
         return False
 

app/services/Bybit/functions/functions.py

@@ -1,8 +1,8 @@
 import asyncio
-
+import logging.config
 from aiogram import F, Router
-
+from logger_helper.logger_helper import LOGGING_CONFIG
-from app.services.Bybit.functions import Futures, func_min_qty
+from app.services.Bybit.functions import Futures, min_qty
 from app.services.Bybit.functions.Futures import open_position, close_user_trade, get_active_positions, trading_cycle
 from app.services.Bybit.functions.balance import get_balance
 import app.telegram.Keyboards.inline_keyboards as inline_markup
@@ -15,6 +15,11 @@ from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.state import State, StatesGroup
 from aiogram.fsm.context import FSMContext
 
+from app.services.Bybit.functions.get_valid_symbol import get_valid_symbols
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("functions")
+
 router_functions_bybit_trade = Router()
 
 
@@ -30,6 +35,10 @@ class TradeSetup(StatesGroup):
     waiting_for_timer = State()
     waiting_for_positive_percent = State()
 
+class state_limit_price(StatesGroup):
+    price = State()
+
+
 
 @router_functions_bybit_trade.callback_query(F.data.in_(['clb_start_trading', 'clb_back_to_main', 'back_to_main']))
 async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMContext):
@@ -48,7 +57,8 @@ async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMConte
 Как начать торговлю?
 
 1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.  
-2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT).  
+2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT). 
+3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю. 
 '''
         await callback.message.edit_text(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
 
@@ -69,7 +79,8 @@ async def start_bybit_trade_message(message, state):
 Как начать торговлю?
 
 1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.  
-2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT).  
+2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).
+3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.  
 '''
 
         await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
@@ -80,17 +91,23 @@ async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMCon
     await state.set_state(state_update_symbol.symbol)
 
     await callback.message.answer(
-        text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ')
+        text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ',
+        reply_markup=inline_markup.cancel)
 
 
 @router_functions_bybit_trade.message(state_update_symbol.symbol)
 async def update_symbol_for_trade(message: Message, state: FSMContext):
+    user_input = message.text.strip().upper()
+
+    exists = await get_valid_symbols(message.from_user.id, user_input)
+
+    if not exists:
+        await message.answer("Введена некорректная торговая пара или такой пары нет в списке. Попробуйте снова.")
+        return
+
     await state.update_data(symbol=message.text)
-
-    data = await state.get_data()
-
     await message.answer('Пара была успешно обновлена')
-    await rq.update_symbol(message.from_user.id, data['symbol'])
+    await rq.update_symbol(message.from_user.id, user_input)
     await start_bybit_trade_message(message, state)
 
     await state.clear()
@@ -111,15 +128,47 @@ async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext):
         await callback.answer("Ошибка выбора", show_alert=True)
         return
 
+    if order_type == 'Limit':
+        await state.set_state(state_limit_price.price)
+        await callback.message.answer("Введите цену лимитного ордера:", reply_markup=inline_markup.cancel)
+        await callback.answer()
+        return
+
     try:
         await state.update_data(entry_order_type=order_type)
         await rq.update_entry_order_type(callback.from_user.id, order_type)
-        await callback.answer("Тип входа в позицию был успешно обновлен")
+        await callback.message.answer(f"Выбран тип входа в позицию: {order_type}",
+                              reply_markup=inline_markup.start_trading_markup)
+        await callback.answer()
     except Exception as e:
-        await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию")
+        logger.error(f"Произошла ошибка при обновлении типа входа в позицию: {e}")
+        await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию",
+                                      reply_markup=inline_markup.back_to_main)
     await state.clear()
 
 
+@router_functions_bybit_trade.message(state_limit_price.price)
+async def set_limit_price(message: Message, state: FSMContext):
+    try:
+        price = float(message.text)
+        if price <= 0:
+            await message.answer("Цена должна быть положительным числом. Попробуйте снова.", reply_markup=inline_markup.cancel)
+            return
+    except ValueError:
+        await message.answer("Некорректный формат цены. Введите число.", reply_markup=inline_markup.cancel)
+        return
+
+    await state.update_data(entry_order_type='Limit', limit_price=price)
+    data = await state.get_data()
+
+    await rq.update_entry_order_type(message.from_user.id, 'Limit')
+    await rq.update_limit_price(message.from_user.id, price)
+
+    await message.answer(f"Цена лимитного ордера установлена: {price}", reply_markup=inline_markup.start_trading_markup)
+    await state.clear()
+
+
+
 @router_functions_bybit_trade.callback_query(F.data == "clb_my_deals")
 async def show_my_trades_callback(callback: CallbackQuery):
     tg_id = callback.from_user.id
@@ -227,7 +276,8 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
     try:
         positions_resp = client.get_positions(category='linear', symbol=symbol)
         positions = positions_resp.get('result', {}).get('list', [])
-    except Exception:
+    except Exception as e:
+        logger.error(f"Ошибка при получении позиций: {e}")
         positions = []
 
     for pos in positions:
@@ -253,7 +303,10 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
     await message.answer("Начинаю торговлю с использованием текущих настроек...")
 
     # Открываем позицию (вызывает Futures.open_position)
-    await open_position(tg_id, message, side=side, margin_mode=margin_mode)
+    success = await open_position(tg_id, message, side=side, margin_mode=margin_mode)
+    if not success:
+        await message.answer('⚠️ Ошибка при совершении сделки', reply_markup=inline_markup.back_to_main)
+        return
 
 
     # Проверяем таймер и информируем пользователя
@@ -271,3 +324,9 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
 
     await callback.answer()
 
+
+@router_functions_bybit_trade.callback_query(F.data == "clb_cancel")
+async def cancel(callback: CallbackQuery, state: FSMContext):
+    await state.clear()
+    await callback.message.answer("Отменено!", reply_markup=inline_markup.back_to_main)
+    await callback.answer()

app/telegram/database/models.py

@@ -80,6 +80,7 @@ class User_Main_Settings(Base):
     martingale_step = mapped_column(Integer(), default=1)
     maximal_quantity = mapped_column(Integer(), default=10)
     entry_order_type = mapped_column(String(10), default='Market')
+    limit_order_price = mapped_column(String(20), nullable=True)
 
 
 class User_Risk_Management_Settings(Base):

app/telegram/database/requests.py

@@ -1,8 +1,10 @@
-import logging
+import logging.config
+from logger_helper.logger_helper import LOGGING_CONFIG
 from datetime import datetime, timedelta
 from typing import Any
 
-logger = logging.getLogger(__name__)
+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
@@ -17,10 +19,11 @@ 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
+import app.telegram.functions.functions as func  # functions
 
 from sqlalchemy import select, delete, update
 
+
 # SET_DB
 async def save_tg_id_new_user(tg_id):
     async with async_session() as session:
@@ -29,10 +32,11 @@ async def save_tg_id_new_user(tg_id):
         if not user:
             session.add(UTi(tg_id=tg_id))
 
-            logger.info("Новый пользователь был добавлен в бд")
+            logger.info("Новый пользователь был добавлен в бд %s", tg_id)
 
         await session.commit()
 
+
 async def set_new_user_bybit_api(tg_id):
     async with async_session() as session:
         user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id))
@@ -42,10 +46,9 @@ async def set_new_user_bybit_api(tg_id):
                 tg_id=tg_id,
             ))
 
-            logger.info(f"Bybit был успешно подключен")
-
         await session.commit()
 
+
 async def set_new_user_symbol(tg_id):
     async with async_session() as session:
         user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id))
@@ -55,10 +58,11 @@ async def set_new_user_symbol(tg_id):
                 tg_id=tg_id
             ))
 
-            logger.info(f"Symbol был успешно добавлен")
+            logger.info(f"Symbol был успешно добавлен %s", tg_id)
 
         await session.commit()
 
+
 async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None:
     async with async_session() as session:
         settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
@@ -70,10 +74,11 @@ async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -
                 margin_type=margin_type,
             ))
 
-            logger.info("Основные настройки нового пользователя были заполнены")
+            logger.info("Основные настройки нового пользователя были заполнены%s", tg_id)
 
         await session.commit()
 
+
 async def set_new_user_default_risk_management_settings(tg_id) -> None:
     async with async_session() as session:
         settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
@@ -83,10 +88,11 @@ async def set_new_user_default_risk_management_settings(tg_id) -> None:
                 tg_id=tg_id
             ))
 
-            logger.info("Риск-Менеджмент настройки нового пользователя были заполнены")
+            logger.info("Риск-Менеджмент настройки нового пользователя были заполнены %s", tg_id)
 
         await session.commit()
 
+
 async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
     async with async_session() as session:
         settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id))
@@ -97,10 +103,11 @@ async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
                 trigger=trigger
             ))
 
-            logger.info("Условные настройки нового пользователя были заполнены")
+            logger.info("Условные настройки нового пользователя были заполнены %s", tg_id)
 
         await session.commit()
 
+
 async def set_new_user_default_additional_settings(tg_id) -> None:
     async with async_session() as session:
         settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id))
@@ -110,31 +117,36 @@ async def set_new_user_default_additional_settings(tg_id) -> None:
                 tg_id=tg_id,
             ))
 
-            logger.info("Дополнительные настройки нового пользователя были заполнены")
+            logger.info("Дополнительные настройки нового пользователя были заполнены %s", tg_id)
 
         await session.commit()
 
+
 # GET_DB
 async def check_user(tg_id):
     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):
     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):
     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)
@@ -149,6 +161,7 @@ async def update_user_trades(tg_id, **kwargs):
         await session.execute(query)
         await session.commit()
 
+
 async def delete_user_trade(tg_id: int, symbol: str):
     async with async_session() as session:
         await session.execute(
@@ -158,27 +171,31 @@ async def delete_user_trade(tg_id: int, symbol: str):
         )
         await session.commit()
 
+
 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))
 
         if user:
-            logger.info("Получение основных настроек пользователя")
+            logger.info("Получение основных настроек пользователя %s", tg_id)
 
             trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id))
             margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id))
@@ -198,12 +215,13 @@ async def get_user_main_settings(tg_id):
 
             return data
 
+
 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))
 
         if user:
-            logger.info("Получение риск-менеджмента настроек пользователя")
+            logger.info("Получение риск-менеджмента настроек пользователя %s", tg_id)
 
             price_profit = await session.scalar(select(URMS.price_profit).where(URMS.tg_id == tg_id))
             price_loss = await session.scalar(select(URMS.price_loss).where(URMS.tg_id == tg_id))
@@ -219,87 +237,99 @@ async def get_user_risk_management_settings(tg_id):
 
             return data
 
-#UPDATE_SYMBOL
+
+# 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.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))
+        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))
+        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("Изменен трейд мод")
+            logger.info("Изменен трейд мод %s", tg_id)
-            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode = mode))
+            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))
 
         if type:
-            logger.info("Изменен тип маржи")
+            logger.info("Изменен тип маржи %s", tg_id)
-            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type = type))
+            await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type=type))
 
             await session.commit()
 
+
 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))
+        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage=num))
 
         await session.commit()
 
+
 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))
+        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num))
 
         await session.commit()
 
+
 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))
+        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num))
 
         await session.commit()
 
+
 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.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))
+        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit=num))
 
         await session.commit()
 
+
 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))
+        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss=num))
 
         await session.commit()
 
+
 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))
+        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num))
 
         await session.commit()
 
@@ -323,40 +353,66 @@ async def get_entry_order_type(tg_id: object) -> str | None | Any:
         return order_type or 'Market'
 
 
+async def get_limit_price(tg_id):
+    async with async_session() as session:
+        result = await session.execute(
+            select(UMS.limit_order_price)
+            .where(UMS.tg_id == tg_id)
+        )
+        price = result.scalar_one_or_none()
+        if price:
+            try:
+                return float(price)
+            except ValueError:
+                return None
+        return None
+
+
+async def update_limit_price(tg_id, price):
+    async with async_session() as session:
+        await session.execute(
+            update(UMS)
+            .where(UMS.tg_id == tg_id)
+            .values(limit_order_price=str(price))
+        )
+        await session.commit()
+
+
 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))
+        await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee=num))
 
         await session.commit()
 
+
 async def get_user_timer(tg_id):
-        async with async_session() as session:
+    async with async_session() as session:
-            result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
+        result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
-            user_timer = result.scalars().first()
+        user_timer = result.scalars().first()
 
-            if not user_timer:
+        if not user_timer:
-                logging.info(f"No timer found for user {tg_id}")
+            logging.info(f"No timer found for user {tg_id}")
-                return None
+            return None
 
-            timer_minutes = user_timer.timer_minutes
+        timer_minutes = user_timer.timer_minutes
-            timer_start = user_timer.timer_start
+        timer_start = user_timer.timer_start
-            timer_end = user_timer.timer_end
+        timer_end = user_timer.timer_end
 
-            logging.info(f"Timer data for tg_id={tg_id}: "
+        logging.info(f"Timer data for tg_id={tg_id}: "
-                         f"timer_minutes={timer_minutes}, "
+                     f"timer_minutes={timer_minutes}, "
-                         f"timer_start={timer_start}, "
+                     f"timer_start={timer_start}, "
-                         f"timer_end={timer_end}")
+                     f"timer_end={timer_end}")
 
-            remaining = None
+        remaining = None
-            if timer_end:
+        if timer_end:
-                remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60))
+            remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60))
 
-            return {
+        return {
-                "timer_minutes": timer_minutes,
+            "timer_minutes": timer_minutes,
-                "timer_start": timer_start,
+            "timer_start": timer_start,
-                "timer_end": timer_end,
+            "timer_end": timer_end,
-                "remaining_minutes": remaining
+            "remaining_minutes": remaining
-            }
+        }
 
 
 async def update_user_timer(tg_id, minutes: int):
@@ -397,8 +453,9 @@ async def get_martingale_step(tg_id):
         user_settings = result.scalars().first()
         return user_settings.martingale_step
 
+
 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))
+        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step))
 
         await session.commit()

app/telegram/functions/functions.py

@@ -28,5 +28,3 @@ async def check_profile_message(message, username):
     
 async def settings_message(message):
     await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup)
-
-

app/telegram/handlers/handlers.py

@@ -1,4 +1,4 @@
-import logging
+import logging.config
 
 from aiogram import F, Router
 from aiogram.filters import CommandStart, Command
@@ -14,6 +14,11 @@ import app.telegram.functions.additional_settings.settings as func_additional_se
 import app.telegram.database.requests as rq
 import app.telegram.Keyboards.inline_keyboards as inline_markup
 import app.telegram.Keyboards.reply_keyboards as reply_markup
+from logger_helper.logger_helper import LOGGING_CONFIG
+
+logging.config.dictConfig(LOGGING_CONFIG)
+logger = logging.getLogger("handlers")
+
 
 router = Router()
 
@@ -143,7 +148,7 @@ async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext):
             case 'clb_change_maximum_quantity':
                 await func_main_settings.maximum_quantity_message(callback.message, state)
     except Exception as e:
-        logging.error(f"Error callback in main_settings match-case: {e}")
+        logger.error(f"Error callback in main_settings match-case: {e}")
 
 
 list_risk_management_settings = ['clb_change_price_profit',
@@ -168,7 +173,7 @@ async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMCo
             case 'commission_fee':
                 await func_rmanagement_settings.commission_fee_message(callback.message, state)
     except Exception as e:
-        logging.error(f"Error callback in risk_management match-case: {e}")
+        logger.error(f"Error callback in risk_management match-case: {e}")
 
 
 list_condition_settings = ['clb_change_trigger',
@@ -202,7 +207,7 @@ async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext)
             case 'clb_change_ai_analytics':
                 await func_condition_settings.ai_analytics_message(callback.message, state)
     except Exception as e:
-        logging.error(f"Error callback in main_settings match-case: {e}")
+        logger.error(f"Error callback in main_settings match-case: {e}")
 
 
 list_additional_settings = ['clb_change_save_pattern',
@@ -224,4 +229,4 @@ async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext
             case 'clb_change_notifications':
                 await func_additional_settings.notifications_message(callback.message, state)
     except Exception as e:
-        logging.error(f"Error callback in additional_settings match-case: {e}")
+        logger.error(f"Error callback in additional_settings match-case: {e}")