from pyexcel_xls import get_data
from pyexcel_xlsx import save_data
import os

def convert_xls_to_xlsx(xls_path):
    # Получаем имя файла без расширения
    file_name = os.path.splitext(xls_path)[0]
    xlsx_path = file_name + '.xlsx'

    # Читаем данные из .xls файла
    xls_data = get_data(xls_path)

    # Сохраняем данные в .xlsx формате
    save_data(xlsx_path, xls_data)

    return xlsx_path

if file_path.endswith('.xls'):
    print("Конвертация .xls в .xlsx...")
    file_path = convert_xls_to_xlsx(file_path)
    print(f"Файл сконвертирован: {file_path}")

https://api.telegram.org/botBOT_TOKEN/getMe  

{
  "ok": true,
  "result": {
    "id": 929198812,
    "is_bot": true,
    "first_name": "my_test",
    "username": "my_test_bot",
    "can_join_groups": true,
    "can_read_all_group_messages": false,
    "supports_inline_queries": false,
    "can_connect_to_business": false,
    "has_main_web_app": false
  }
}

alive_users = 0  
all_count_user_in_db = 100  # Например, общее число пользователей  

for user_id in users:  
    try:  
        chat = await bot.get_chat(chat_id=user_id)  
        alive_users += 1  
    except TelegramBadRequest as e:  
        # Пользователь заблокировал бота или чат недоступен  
        print(f"Ошибка при проверке пользователя {user_id}: {e}")  
    except Exception as e:  
        # Обработка других непредвиденных ошибок  
        print(f"Неожиданная ошибка для пользователя {user_id}: {e}")  

await message.answer(  
    f"📊 В базе данных: {all_count_user_in_db} пользователей.\n"  
    f"✅ Доступны: {alive_users}.\n"  
    f"🚫 Недоступны: {all_count_user_in_db - alive_users}."  
)  

from typing import Callable, Dict, Any, Awaitable
from aiogram import BaseMiddleware
from aiogram.types import Message, CallbackQuery

from bot.dao.database import async_session_maker


class BaseDatabaseMiddleware(BaseMiddleware):
    async def __call__(
            self,
            handler: Callable[[Message | CallbackQuery, Dict[str, Any]], Awaitable[Any]],
            event: Message | CallbackQuery,
            data: Dict[str, Any]
    ) -> Any:
        async with async_session_maker() as session:
            self.set_session(data, session)
            try:
                result = await handler(event, data)
                await self.after_handler(session)
                return result
            except Exception as e:
                await session.rollback()
                raise e
            finally:
                await session.close()

    def set_session(self, data: Dict[str, Any], session) -> None:
        """Метод для установки сессии в словарь данных."""
        raise NotImplementedError("Этот метод должен быть реализован в подклассах.")

    async def after_handler(self, session) -> None:
        """Метод для выполнения действий после вызова хендлера (например, коммит)."""
        pass


class DatabaseMiddlewareWithoutCommit(BaseDatabaseMiddleware):
    def set_session(self, data: Dict[str, Any], session) -> None:
        data['session_without_commit'] = session


class DatabaseMiddlewareWithCommit(BaseDatabaseMiddleware):
    def set_session(self, data: Dict[str, Any], session) -> None:
        data['session_with_commit'] = session

    async def after_handler(self, session) -> None:
        await session.commit()

dp.update.middleware.register(DatabaseMiddlewareWithoutCommit())
dp.update.middleware.register(DatabaseMiddlewareWithCommit())

@user_router.callback_query(F.data == "catalog")
async def page_catalog(call: CallbackQuery, session_without_commit: AsyncSession):
    await call.answer("Загрузка каталога...")
    catalog_data = await CategoryDao.find_all(session=session_without_commit)

    await call.message.edit_text(
        text="Выберите категорию товаров:",
        reply_markup=catalog_kb(catalog_data)
    )

@user_router.message(CommandStart())
async def cmd_start(message: Message, session_with_commit: AsyncSession):
    user_id = message.from_user.id
    user_info = await UserDAO.find_one_or_none(
        session=session_with_commit,
        filters=TelegramIDModel(telegram_id=user_id)
    )

    if user_info:
        return await message.answer(
            f"👋 Привет, {message.from_user.full_name}! Выберите необходимое действие",
            reply_markup=main_user_kb(user_id)
        )

    values = UserModel(
        telegram_id=user_id,
        username=message.from_user.username,
        first_name=message.from_user.first_name,
        last_name=message.from_user.last_name,
    )
    await UserDAO.add(session=session_with_commit, values=values)
    await message.answer(f"🎉 <b>Благодарим за регистрацию!</b>. Теперь выберите необходимое действие.",
                         reply_markup=main_user_kb(user_id))