smart-bot-factory 1.1.1__py3-none-any.whl

smart_bot_factory/admin/timeout_checker.py

@@ -0,0 +1,547 @@
+"""
+Модуль для проверки корректности таймаутов диалогов админов
+"""
+
+import asyncio
+import logging
+import os
+import sys
+from datetime import datetime, timezone, timedelta
+from pathlib import Path
+from typing import Optional
+
+from ..admin.admin_manager import AdminManager
+from ..config import Config
+from ..core.conversation_manager import ConversationManager
+from ..integrations.supabase_client import SupabaseClient
+
+logger = logging.getLogger(__name__)
+
+
+def setup_bot_environment(bot_name: str = "growthmed-october-24") -> Optional[Path]:
+    """Настраивает окружение для указанного бота с автоопределением BOT_ID"""
+    root_dir = Path(os.getcwd())  # Используем текущую директорию как корневую
+    config_dir = root_dir / "bots" / bot_name
+
+    logger.info(f"🔍 Ищем конфигурацию бота в: {config_dir}")
+
+    # Сохраняем оригинальный путь для возврата
+    original_cwd = os.getcwd()
+
+    if not config_dir.exists():
+        logger.error(f"❌ Папка конфигурации не найдена: {config_dir}")
+        logger.info("   Доступные боты:")
+        bots_dir = root_dir / "bots"
+        if bots_dir.exists():
+            for bot_dir in bots_dir.iterdir():
+                if bot_dir.is_dir():
+                    logger.info(f"     - {bot_dir.name}")
+        return None
+
+    # Проверяем наличие промптов
+    prompts_dir = config_dir / "prompts"
+    if not prompts_dir.exists():
+        logger.error(f"❌ Папка с промптами не найдена: {prompts_dir}")
+        return None
+
+    logger.info(f"✅ Найдена папка промптов: {prompts_dir}")
+
+    # Устанавливаем BOT_ID из имени бота
+    os.environ["BOT_ID"] = bot_name
+    logger.info(f"🤖 Автоматически установлен BOT_ID: {bot_name}")
+
+    # Загружаем .env из конфигурации бота
+    env_file = config_dir / ".env"
+    if env_file.exists():
+        logger.info(f"🔧 Загружаем .env из: {env_file}")
+        from dotenv import load_dotenv
+
+        load_dotenv(env_file)
+    else:
+        logger.error(f"❌ Файл .env не найден: {env_file}")
+        return None
+
+    # Сохраняем текущую директорию и меняем её
+    original_cwd = os.getcwd()
+    os.chdir(str(config_dir))
+    logger.info(f"📁 Изменена рабочая директория: {os.getcwd()}")
+
+    # Проверяем что промпты доступны относительно новой директории
+    local_prompts = Path("prompts")
+    if local_prompts.exists():
+        logger.info(
+            f"✅ Промпты доступны из рабочей директории: {local_prompts.absolute()}"
+        )
+    else:
+        logger.error(
+            f"❌ Промпты не найдены в рабочей директории: {local_prompts.absolute()}"
+        )
+        os.chdir(original_cwd)  # Восстанавливаем директорию
+        return None
+
+    return config_dir
+
+
+async def debug_timeout_issue(bot_name: str = "growthmed-october-24") -> bool:
+    """
+    Диагностирует проблему с таймаутом диалогов
+
+    Args:
+        bot_name: Имя бота для диагностики
+
+    Returns:
+        bool: True если диагностика прошла успешно, False если найдены проблемы
+    """
+    logger.info("🔍 Диагностика проблемы с таймаутом диалогов\n")
+    logger.info(f"🚀 Диагностика для бота: {bot_name}")
+    logger.info(f"🤖 Bot ID будет автоопределен как: {bot_name}\n")
+
+    # Настраиваем окружение для бота (автоматически устанавливает BOT_ID)
+    config_dir = setup_bot_environment(bot_name)
+    if not config_dir:
+        return False
+
+    # Инициализируем конфигурацию
+    config = Config()
+    logger.info("📋 Конфигурация:")
+    logger.info(f"   BOT_ID: {config.BOT_ID}")
+    logger.info(
+        f"   ADMIN_SESSION_TIMEOUT_MINUTES: {config.ADMIN_SESSION_TIMEOUT_MINUTES}"
+    )
+    logger.info(f"   PROMT_FILES_DIR: {config.PROMT_FILES_DIR}")
+    logger.info(f"   Найдено промпт-файлов: {len(config.PROMPT_FILES)}")
+    logger.info("")
+
+    # Проверяем часовые пояса
+    logger.info("🕐 Временные зоны:")
+    now_naive = datetime.now()
+    now_utc = datetime.now(timezone.utc)
+    logger.info(f"   datetime.now() (локальное): {now_naive}")
+    logger.info(f"   datetime.now(timezone.utc): {now_utc}")
+    logger.info(
+        f"   Разница: {(now_naive.replace(tzinfo=timezone.utc) - now_utc).total_seconds() / 3600:.1f} часов"
+    )
+    logger.info("")
+
+    # Проверяем активные диалоги в БД
+    try:
+        supabase_client = SupabaseClient(config.SUPABASE_URL, config.SUPABASE_KEY)
+        await supabase_client.initialize()
+
+        response = (
+            supabase_client.client.table("admin_user_conversations")
+            .select("id", "admin_id", "user_id", "started_at", "auto_end_at")
+            .eq("status", "active")
+            .execute()
+        )
+
+        conversations = response.data
+
+        logger.info(f"📊 Активные диалоги в БД: {len(conversations)}")
+
+        problems_found = 0
+
+        for i, conv in enumerate(conversations, 1):
+            logger.info(f"\n{i}. Диалог ID: {conv['id']}")
+            logger.info(
+                f"   Админ: {conv['admin_id']}, Пользователь: {conv['user_id']}"
+            )
+
+            # Парсим времена
+            started_at = conv["started_at"]
+            auto_end_at = conv["auto_end_at"]
+
+            logger.info(f"   started_at (сырое): {started_at}")
+            logger.info(f"   auto_end_at (сырое): {auto_end_at}")
+
+            try:
+                # Парсим как делает код
+                if started_at.endswith("Z"):
+                    start_time = datetime.fromisoformat(
+                        started_at.replace("Z", "+00:00")
+                    )
+                elif "+" in started_at or started_at.count(":") >= 3:
+                    start_time = datetime.fromisoformat(started_at)
+                else:
+                    naive_time = datetime.fromisoformat(started_at)
+                    start_time = naive_time.replace(tzinfo=timezone.utc)
+
+                if auto_end_at.endswith("Z"):
+                    end_time = datetime.fromisoformat(
+                        auto_end_at.replace("Z", "+00:00")
+                    )
+                elif "+" in auto_end_at or auto_end_at.count(":") >= 3:
+                    end_time = datetime.fromisoformat(auto_end_at)
+                else:
+                    naive_time = datetime.fromisoformat(auto_end_at)
+                    end_time = naive_time.replace(tzinfo=timezone.utc)
+
+                logger.info(f"   start_time (парсед): {start_time}")
+                logger.info(f"   end_time (парсед): {end_time}")
+
+                # Вычисляем длительность диалога
+                planned_duration = end_time - start_time
+                planned_minutes = int(planned_duration.total_seconds() / 60)
+                logger.info(f"   Запланированная длительность: {planned_minutes} минут")
+
+                # Проверяем соответствие конфигу
+                expected = config.ADMIN_SESSION_TIMEOUT_MINUTES
+                if planned_minutes == expected:
+                    logger.info(f"   ✅ Соответствует конфигу ({expected} мин)")
+                else:
+                    logger.error(
+                        f"   ❌ НЕ соответствует конфигу! Ожидалось {expected} мин, получили {planned_minutes} мин"
+                    )
+                    problems_found += 1
+
+                # Вычисляем текущее время до автозавершения
+                now_utc = datetime.now(timezone.utc)
+
+                # Приводим к UTC
+                if end_time.tzinfo != timezone.utc:
+                    end_time_utc = end_time.astimezone(timezone.utc)
+                else:
+                    end_time_utc = end_time
+
+                remaining = end_time_utc - now_utc
+                remaining_minutes = max(0, int(remaining.total_seconds() / 60))
+
+                logger.info(f"   now_utc: {now_utc}")
+                logger.info(f"   end_time_utc: {end_time_utc}")
+                logger.info(f"   Оставшееся время: {remaining_minutes} минут")
+
+                # Вычисляем сколько уже прошло
+                if start_time.tzinfo != timezone.utc:
+                    start_time_utc = start_time.astimezone(timezone.utc)
+                else:
+                    start_time_utc = start_time
+
+                elapsed = now_utc - start_time_utc
+                elapsed_minutes = max(0, int(elapsed.total_seconds() / 60))
+                logger.info(f"   Прошло времени: {elapsed_minutes} минут")
+
+                # Проверяем математику
+                total_check = elapsed_minutes + remaining_minutes
+                logger.info(
+                    f"   Проверка: {elapsed_minutes} + {remaining_minutes} = {total_check} мин (должно быть ~{planned_minutes})"
+                )
+
+                if abs(total_check - planned_minutes) > 2:
+                    logger.warning(
+                        "   ⚠️ ПРОБЛЕМА: сумма не сходится! Возможная проблема с timezone"
+                    )
+                    problems_found += 1
+
+            except Exception as e:
+                logger.error(f"   ❌ Ошибка парсинга времени: {e}")
+                problems_found += 1
+
+        if not conversations:
+            logger.info("   Нет активных диалогов для анализа")
+            logger.info("   💡 Создайте диалог командой /чат USER_ID для тестирования")
+
+        return problems_found == 0
+
+    except Exception as e:
+        logger.error(f"❌ Ошибка подключения к БД: {e}")
+        return False
+
+
+async def test_conversation_creation(config: Config) -> bool:
+    """
+    Тестирует создание нового диалога с правильным таймаутом
+
+    Args:
+        config: Конфигурация бота
+
+    Returns:
+        bool: True если тест прошел успешно, False если найдены проблемы
+    """
+    logger.info(f"\n{'='*50}")
+    logger.info("🧪 ТЕСТ СОЗДАНИЯ ДИАЛОГА")
+    logger.info(f"{'='*50}")
+
+    timeout_minutes = config.ADMIN_SESSION_TIMEOUT_MINUTES
+    logger.info(f"📋 Конфигурация таймаута: {timeout_minutes} минут")
+
+    # Эмулируем создание диалога
+    now_utc = datetime.now(timezone.utc)
+    auto_end_utc = now_utc + timedelta(minutes=timeout_minutes)
+
+    logger.info(f"🕐 now_utc: {now_utc}")
+    logger.info(f"⏰ auto_end_utc: {auto_end_utc}")
+    logger.info(
+        f"📏 Разница: {int((auto_end_utc - now_utc).total_seconds() / 60)} минут"
+    )
+
+    # Проверяем ISO формат
+    auto_end_iso = auto_end_utc.isoformat()
+    logger.info(f"📝 ISO формат: {auto_end_iso}")
+
+    # Проверяем парсинг обратно
+    try:
+        if auto_end_iso.endswith("Z"):
+            parsed_back = datetime.fromisoformat(auto_end_iso.replace("Z", "+00:00"))
+        elif "+" in auto_end_iso:
+            parsed_back = datetime.fromisoformat(auto_end_iso)
+        else:
+            parsed_back = datetime.fromisoformat(auto_end_iso).replace(
+                tzinfo=timezone.utc
+            )
+
+        logger.info(f"🔄 Парсед обратно: {parsed_back}")
+
+        # Проверяем что время совпадает
+        if abs((parsed_back - auto_end_utc).total_seconds()) < 1:
+            logger.info("✅ Парсинг работает корректно")
+            return True
+        else:
+            logger.error("❌ Проблема с парсингом времени")
+            return False
+
+    except Exception as e:
+        logger.error(f"❌ Ошибка парсинга: {e}")
+        return False
+
+
+async def check_timeouts(bot_name: str = "growthmed-october-24") -> bool:
+    """
+    Проверяет корректность таймаутов диалогов админов
+
+    Args:
+        bot_name: Имя бота для проверки
+
+    Returns:
+        bool: True если все таймауты корректны, False если найдены проблемы
+    """
+    logger.info("🔍 Проверка таймаутов диалогов админов\n")
+    logger.info(f"🚀 Проверка для бота: {bot_name}")
+    logger.info(f"🤖 Bot ID будет автоопределен как: {bot_name}\n")
+
+    # Настраиваем окружение для бота (автоматически устанавливает BOT_ID)
+    config_dir = setup_bot_environment(bot_name)
+    if not config_dir:
+        logger.error("❌ Не удалось настроить окружение бота")
+        return False
+
+    logger.info(f"📁 Текущая рабочая директория: {os.getcwd()}")
+    logger.info("📂 Содержимое рабочей директории:")
+    for item in Path(".").iterdir():
+        if item.is_dir():
+            logger.info(f"   📁 {item.name}/")
+        else:
+            logger.info(f"   📄 {item.name}")
+    logger.info("")
+
+    # Инициализация
+    try:
+        logger.info("⚙️ Инициализация конфигурации...")
+        config = Config()
+        logger.info("✅ Конфигурация загружена")
+
+        logger.info("🔗 Подключение к Supabase...")
+        supabase_client = SupabaseClient(config.SUPABASE_URL, config.SUPABASE_KEY)
+        await supabase_client.initialize()
+        logger.info("✅ Supabase подключен")
+
+        logger.info("👑 Инициализация менеджеров...")
+        admin_manager = AdminManager(config, supabase_client)
+        conversation_manager = ConversationManager(supabase_client, admin_manager)
+        logger.info("✅ Менеджеры инициализированы\n")
+
+    except Exception as e:
+        logger.error(f"❌ Ошибка инициализации: {e}")
+        logger.exception("Стек ошибки:")
+        return False
+
+    logger.info("⚙️ Конфигурация:")
+    logger.info(f"   BOT_ID: {config.BOT_ID}")
+    logger.info(
+        f"   ADMIN_SESSION_TIMEOUT_MINUTES: {config.ADMIN_SESSION_TIMEOUT_MINUTES}"
+    )
+    logger.info(f"   PROMT_FILES_DIR: {config.PROMT_FILES_DIR}")
+    logger.info(f"   Найдено промпт-файлов: {len(config.PROMPT_FILES)}")
+    logger.info(f"   Админов: {len(config.ADMIN_TELEGRAM_IDS)}")
+    logger.info(f"   Сейчас UTC: {datetime.now(timezone.utc)}")
+    logger.info("")
+
+    # Получаем активные диалоги
+    try:
+        logger.info("📊 Получение активных диалогов...")
+        conversations = await conversation_manager.get_active_conversations()
+        logger.info(f"✅ Получено {len(conversations)} диалогов")
+    except Exception as e:
+        logger.error(f"❌ Ошибка получения диалогов: {e}")
+        return False
+
+    if not conversations:
+        logger.info("💬 Нет активных диалогов")
+        logger.info("💡 Создайте диалог командой /чат USER_ID для тестирования")
+
+        # Показываем пример создания тестового диалога
+        logger.info("\n🧪 Пример создания тестового диалога:")
+        logger.info(f"1. Запустите бота: python {bot_name}.py")
+        logger.info("2. Как админ выполните: /чат 123456789")
+        logger.info("3. Затем проверьте: /чаты")
+        return True  # Нет диалогов = нет проблем
+
+    logger.info(f"📊 Найдено {len(conversations)} активных диалогов:")
+    logger.info("")
+
+    problems_found = 0
+
+    for i, conv in enumerate(conversations, 1):
+        logger.info(f"{i}. Диалог ID: {conv['id']}")
+        logger.info(f"   👤 Пользователь: {conv['user_id']}")
+        logger.info(f"   👑 Админ: {conv['admin_id']}")
+
+        # Анализируем времена
+        started_at_str = conv["started_at"]
+        auto_end_str = conv["auto_end_at"]
+
+        logger.info(f"   🕐 started_at (сырое): {started_at_str}")
+        logger.info(f"   ⏰ auto_end_at (сырое): {auto_end_str}")
+
+        try:
+            # Парсим время начала с правильной обработкой timezone
+            if started_at_str.endswith("Z"):
+                start_time = datetime.fromisoformat(
+                    started_at_str.replace("Z", "+00:00")
+                )
+            elif "+" in started_at_str or started_at_str.count(":") >= 3:
+                start_time = datetime.fromisoformat(started_at_str)
+            else:
+                naive_time = datetime.fromisoformat(started_at_str)
+                start_time = naive_time.replace(tzinfo=timezone.utc)
+
+            # Парсим время автозавершения с правильной обработкой timezone
+            if auto_end_str.endswith("Z"):
+                auto_end = datetime.fromisoformat(auto_end_str.replace("Z", "+00:00"))
+            elif "+" in auto_end_str or auto_end_str.count(":") >= 3:
+                auto_end = datetime.fromisoformat(auto_end_str)
+            else:
+                naive_time = datetime.fromisoformat(auto_end_str)
+                auto_end = naive_time.replace(tzinfo=timezone.utc)
+
+            logger.info(f"   📅 start_time (parsed): {start_time}")
+            logger.info(f"   ⏰ auto_end (parsed): {auto_end}")
+
+            # Планируемая длительность
+            planned_duration = auto_end - start_time
+            planned_minutes = int(planned_duration.total_seconds() / 60)
+            logger.info(f"   📏 Планируемая длительность: {planned_minutes} минут")
+
+            # Текущее время в UTC
+            now_utc = datetime.now(timezone.utc)
+
+            # Приводим все к UTC для корректных расчетов
+            if start_time.tzinfo != timezone.utc:
+                start_time_utc = start_time.astimezone(timezone.utc)
+            else:
+                start_time_utc = start_time
+
+            if auto_end.tzinfo != timezone.utc:
+                auto_end_utc = auto_end.astimezone(timezone.utc)
+            else:
+                auto_end_utc = auto_end
+
+            # Прошло времени
+            elapsed = now_utc - start_time_utc
+            elapsed_minutes = max(0, int(elapsed.total_seconds() / 60))
+            logger.info(f"   ⏱️ Прошло времени: {elapsed_minutes} минут")
+
+            # Оставшееся время
+            remaining = auto_end_utc - now_utc
+            remaining_minutes = max(0, int(remaining.total_seconds() / 60))
+            logger.info(f"   ⏰ Осталось времени: {remaining_minutes} минут")
+
+            # Проверяем корректность конфигурации
+            expected_timeout = config.ADMIN_SESSION_TIMEOUT_MINUTES
+            if (
+                abs(planned_minutes - expected_timeout) <= 2
+            ):  # допускаем погрешность 2 минуты
+                logger.info(
+                    f"   ✅ Таймаут корректный (ожидался {expected_timeout} мин)"
+                )
+            else:
+                logger.error(
+                    f"   ❌ ОШИБКА: ожидался {expected_timeout} мин, получили {planned_minutes} мин"
+                )
+                problems_found += 1
+
+            # Проверяем математику
+            total_check = elapsed_minutes + remaining_minutes
+            logger.info(
+                f"   🔢 Проверка: {elapsed_minutes} + {remaining_minutes} = {total_check} мин"
+            )
+
+            if abs(total_check - planned_minutes) > 2:
+                logger.warning(
+                    "   ⚠️ ПРОБЛЕМА: сумма не сходится! Возможна проблема с timezone"
+                )
+                problems_found += 1
+            else:
+                logger.info("   ✅ Математика сходится")
+
+        except Exception as e:
+            logger.error(f"   ❌ Ошибка парсинга: {e}")
+            problems_found += 1
+            logger.exception("   Стек ошибки:")
+
+        logger.info("")
+
+    # Тестируем функцию форматирования
+    logger.info("🧪 Тестирование format_active_conversations:")
+    try:
+        formatted_text = conversation_manager.format_active_conversations(conversations)
+        logger.info(formatted_text)
+    except Exception as e:
+        logger.error(f"❌ Ошибка форматирования: {e}")
+        problems_found += 1
+
+    # Итоговый результат
+    logger.info(f"\n{'='*50}")
+    logger.info("📊 ИТОГОВЫЙ РЕЗУЛЬТАТ:")
+    if problems_found == 0:
+        logger.info("✅ Все таймауты корректны!")
+    else:
+        logger.error(f"❌ Найдено {problems_found} проблем")
+        logger.info("💡 Запустите fix_existing_timeouts.py для исправления")
+    logger.info(f"{'='*50}")
+
+    return problems_found == 0
+
+
+def main():
+    """Точка входа для запуска из командной строки"""
+    # Убираем лишние логи для чистого вывода
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    logger.info("🔍 Утилита проверки таймаутов диалогов")
+    logger.info("Использование:")
+    logger.info("  python -m smart_bot_factory.timeout_checker [bot_name]")
+    logger.info("  python -m smart_bot_factory.timeout_checker growthmed-october-24")
+    logger.info("")
+
+    if len(sys.argv) > 1 and sys.argv[1] in ["-h", "--help", "help"]:
+        return
+
+    # Определяем какого бота проверять
+    bot_name = "growthmed-october-24"  # по умолчанию
+    if len(sys.argv) > 1:
+        bot_name = sys.argv[1]
+
+    try:
+        success = asyncio.run(check_timeouts(bot_name))
+        if not success:
+            sys.exit(1)
+    except KeyboardInterrupt:
+        logger.info("\n⏹️ Прервано пользователем")
+    except Exception as e:
+        logger.error(f"\n💥 Критическая ошибка: {e}")
+        logger.exception("Стек ошибки:")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

smart_bot_factory/aiogram_calendar/__init__.py

@@ -0,0 +1,14 @@
+from .common import get_user_locale
+from .dialog_calendar import DialogCalendar
+from .schemas import (CalendarLabels, DialogCalendarCallback,
+                      SimpleCalendarCallback)
+from .simple_calendar import SimpleCalendar
+
+__all__ = [
+    "SimpleCalendar",
+    "DialogCalendar",
+    "SimpleCalendarCallback",
+    "DialogCalendarCallback",
+    "CalendarLabels",
+    "get_user_locale",
+]

smart_bot_factory/aiogram_calendar/common.py

@@ -0,0 +1,64 @@
+import calendar
+import locale
+from datetime import datetime
+
+from aiogram.types import User
+
+from .schemas import CalendarLabels
+
+
+async def get_user_locale(from_user: User) -> str:
+    "Always returns ru_RU locale for consistent Russian language support"
+    return "ru_RU"
+
+
+class GenericCalendar:
+
+    def __init__(
+        self,
+        locale: str = None,  # оставляем для обратной совместимости
+        cancel_btn: str = None,
+        today_btn: str = None,
+        show_alerts: bool = False,
+    ) -> None:
+        """Initialize calendar with Russian language by default
+
+        Parameters:
+        locale (str): Ignored, always uses Russian
+        cancel_btn (str): label for button Cancel to cancel date input
+        today_btn (str): label for button Today to set calendar back to todays date
+        show_alerts (bool): defines how the date range error would shown (defaults to False)
+        """
+        self._labels = CalendarLabels()
+
+        if cancel_btn:
+            self._labels.cancel_caption = cancel_btn
+        if today_btn:
+            self._labels.today_caption = today_btn
+
+        self.min_date = None
+        self.max_date = None
+        self.show_alerts = show_alerts
+
+    def set_dates_range(self, min_date: datetime, max_date: datetime):
+        """Sets range of minimum & maximum dates"""
+        self.min_date = min_date
+        self.max_date = max_date
+
+    async def process_day_select(self, data, query):
+        """Checks selected date is in allowed range of dates"""
+        date = datetime(int(data.year), int(data.month), int(data.day))
+        if self.min_date and self.min_date > date:
+            await query.answer(
+                f'Дата должна быть позже {self.min_date.strftime("%d/%m/%Y")}',
+                show_alert=self.show_alerts,
+            )
+            return False, None
+        elif self.max_date and self.max_date < date:
+            await query.answer(
+                f'Дата должна быть раньше {self.max_date.strftime("%d/%m/%Y")}',
+                show_alert=self.show_alerts,
+            )
+            return False, None
+        await query.message.delete_reply_markup()  # removing inline keyboard
+        return True, date