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

smart_bot_factory/services/telegram_integration.py

@@ -0,0 +1,246 @@
+"""
+Интеграция с Telegram API через существующие функции
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+from aiogram import Bot
+from aiogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.media_group import MediaGroupBuilder
+from aiogram.types import FSInputFile
+
+logger = logging.getLogger(__name__)
+
+class TelegramIntegration:
+    """Интеграция с Telegram API через существующие функции из bot_utils.py"""
+    
+    def __init__(self, bot_token: str):
+        """
+        Инициализация интеграции
+        
+        Args:
+            bot_token: Токен Telegram бота
+        """
+        self.bot = Bot(token=bot_token)
+        self._bot_token = bot_token
+    
+    async def send_message(
+        self, 
+        user_id: int, 
+        text: str, 
+        parse_mode: Optional[str] = None,
+        reply_markup: Optional[InlineKeyboardMarkup] = None,
+        files_list: List[str] = None,
+        directories_list: List[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Отправляет сообщение пользователю через существующую функцию send_message
+        
+        Args:
+            user_id: ID пользователя в Telegram
+            text: Текст сообщения
+            parse_mode: Режим парсинга (Markdown, HTML, None)
+            reply_markup: Клавиатура для сообщения
+            files_list: Список файлов для отправки
+            directories_list: Список каталогов для отправки
+            
+        Returns:
+            Результат отправки
+        """
+        try:
+            # Создаем фиктивное сообщение для использования существующей функции
+            from aiogram.types import User, Chat
+            from aiogram.types import Message as MessageType
+            
+            # Создаем фиктивного пользователя
+            fake_user = User(
+                id=user_id,
+                is_bot=False,
+                first_name="User"
+            )
+            
+            # Создаем фиктивный чат
+            fake_chat = Chat(
+                id=user_id,
+                type="private"
+            )
+            
+            # Создаем фиктивное сообщение
+            fake_message = MessageType(
+                message_id=1,
+                from_user=fake_user,
+                chat=fake_chat,
+                date=0,
+                content_type="text",
+                text=""
+            )
+            
+            # Импортируем существующую функцию
+            from ..integrations import send_message
+            
+            # Используем существующую функцию
+            await send_message(
+                fake_message, 
+                text, 
+                files_list=files_list or [], 
+                directories_list=directories_list or [],
+                **({"parse_mode": parse_mode} if parse_mode else {}),
+                **({"reply_markup": reply_markup} if reply_markup else {})
+            )
+            
+            return {
+                "status": "success",
+                "user_id": user_id,
+                "text": text,
+                "message": "Сообщение отправлено через существующую функцию"
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки сообщения пользователю {user_id}: {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "user_id": user_id
+            }
+    
+    async def send_document(
+        self,
+        user_id: int,
+        document_path: str,
+        caption: Optional[str] = None,
+        parse_mode: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Отправляет документ пользователю
+        
+        Args:
+            user_id: ID пользователя в Telegram
+            document_path: Путь к документу
+            caption: Подпись к документу
+            parse_mode: Режим парсинга
+            
+        Returns:
+            Результат отправки
+        """
+        try:
+            document = FSInputFile(document_path)
+            message = await self.bot.send_document(
+                chat_id=user_id,
+                document=document,
+                caption=caption,
+                parse_mode=parse_mode
+            )
+            
+            return {
+                "status": "success",
+                "message_id": message.message_id,
+                "user_id": user_id,
+                "document_path": document_path
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки документа пользователю {user_id}: {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "user_id": user_id
+            }
+    
+    async def send_photo(
+        self,
+        user_id: int,
+        photo_path: str,
+        caption: Optional[str] = None,
+        parse_mode: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Отправляет фото пользователю
+        
+        Args:
+            user_id: ID пользователя в Telegram
+            photo_path: Путь к фото
+            caption: Подпись к фото
+            parse_mode: Режим парсинга
+            
+        Returns:
+            Результат отправки
+        """
+        try:
+            photo = FSInputFile(photo_path)
+            message = await self.bot.send_photo(
+                chat_id=user_id,
+                photo=photo,
+                caption=caption,
+                parse_mode=parse_mode
+            )
+            
+            return {
+                "status": "success",
+                "message_id": message.message_id,
+                "user_id": user_id,
+                "photo_path": photo_path
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки фото пользователю {user_id}: {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "user_id": user_id
+            }
+    
+    async def send_chat_action(self, user_id: int, action: str) -> Dict[str, Any]:
+        """
+        Отправляет действие чата (typing, uploading_photo, etc.)
+        
+        Args:
+            user_id: ID пользователя в Telegram
+            action: Действие (typing, uploading_photo, uploading_document, etc.)
+            
+        Returns:
+            Результат отправки действия
+        """
+        try:
+            await self.bot.send_chat_action(chat_id=user_id, action=action)
+            
+            return {
+                "status": "success",
+                "user_id": user_id,
+                "action": action
+            }
+            
+        except Exception as e:
+            logger.error(f"Ошибка отправки действия пользователю {user_id}: {e}")
+            return {
+                "status": "error",
+                "error": str(e),
+                "user_id": user_id
+            }
+    
+    def create_keyboard(self, buttons: List[List[Dict[str, str]]]) -> InlineKeyboardMarkup:
+        """
+        Создает клавиатуру из кнопок
+        
+        Args:
+            buttons: Список рядов кнопок [[{"text": "Кнопка", "callback_data": "data"}], ...]
+            
+        Returns:
+            InlineKeyboardMarkup
+        """
+        keyboard_buttons = []
+        
+        for row in buttons:
+            row_buttons = []
+            for button in row:
+                row_buttons.append(InlineKeyboardButton(
+                    text=button["text"],
+                    callback_data=button.get("callback_data", "")
+                ))
+            keyboard_buttons.append(row_buttons)
+        
+        return InlineKeyboardMarkup(inline_keyboard=keyboard_buttons)
+    
+    async def close(self):
+        """Закрывает сессию бота"""
+        if self.bot:
+            await self.bot.session.close()

smart_bot_factory/tools/__init__.py

@@ -0,0 +1,19 @@
+"""
+Инструменты AI для Smart Bot Factory
+"""
+
+from .decorators import (
+    ai_tool,
+    get_ai_tools,
+    get_openai_tools_schema,
+    get_tools_for_prompt,
+    execute_ai_tool
+)
+
+__all__ = [
+    'ai_tool',
+    'get_ai_tools',
+    'get_openai_tools_schema',
+    'get_tools_for_prompt',
+    'execute_ai_tool'
+]

smart_bot_factory/tools/decorators.py

@@ -0,0 +1,140 @@
+"""
+Декораторы для инструментов AI (Function Calling)
+"""
+
+import json
+import logging
+from typing import Callable, Any, Dict, List, Optional
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+# Глобальный реестр инструментов AI
+_ai_tools: Dict[str, Dict[str, Any]] = {}
+
+def ai_tool(name: str, description: str, parameters_schema: Dict[str, Any]):
+    """
+    Декоратор для регистрации инструмента AI (Function Calling)
+    
+    Args:
+        name: Название инструмента
+        description: Описание инструмента для AI
+        parameters_schema: JSON Schema параметров
+    
+    Example:
+        @ai_tool(
+            name="book_appointment",
+            description="Записать пользователя на прием к врачу",
+            parameters_schema={
+                "type": "object",
+                "properties": {
+                    "user_id": {"type": "integer", "description": "ID пользователя"},
+                    "service": {"type": "string", "description": "Название услуги"},
+                    "datetime": {"type": "string", "description": "Дата и время"}
+                },
+                "required": ["user_id", "service", "datetime"]
+            }
+        )
+        async def book_appointment(user_id: int, service: str, datetime: str):
+            # Логика записи на прием
+            return {"status": "success", "appointment_id": "123"}
+    """
+    def decorator(func: Callable) -> Callable:
+        _ai_tools[name] = {
+            'handler': func,
+            'description': description,
+            'parameters_schema': parameters_schema,
+            'name': func.__name__
+        }
+        
+        logger.info(f"🔧 Зарегистрирован AI инструмент '{name}': {func.__name__}")
+        
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                logger.info(f"🤖 AI вызывает инструмент '{name}'")
+                result = await func(*args, **kwargs)
+                logger.info(f"✅ AI инструмент '{name}' выполнен успешно")
+                return result
+            except Exception as e:
+                logger.error(f"❌ Ошибка в AI инструменте '{name}': {e}")
+                raise
+        
+        return wrapper
+    return decorator
+
+def get_ai_tools() -> Dict[str, Dict[str, Any]]:
+    """Возвращает все зарегистрированные AI инструменты"""
+    return _ai_tools.copy()
+
+def get_openai_tools_schema() -> List[Dict[str, Any]]:
+    """
+    Возвращает схему инструментов в формате OpenAI Function Calling
+    """
+    tools = []
+    for tool_name, tool_info in _ai_tools.items():
+        tools.append({
+            "type": "function",
+            "function": {
+                "name": tool_name,
+                "description": tool_info['description'],
+                "parameters": tool_info['parameters_schema']
+            }
+        })
+    
+    return tools
+
+def get_tools_for_prompt() -> str:
+    """
+    Возвращает описание всех AI инструментов для добавления в промпт
+    """
+    if not _ai_tools:
+        return ""
+    
+    prompt_parts = ["ДОСТУПНЫЕ ИНСТРУМЕНТЫ AI:"]
+    
+    for tool_name, tool_info in _ai_tools.items():
+        prompt_parts.append(f"- {tool_name}: {tool_info['description']}")
+        
+        # Добавляем информацию о параметрах
+        required_params = tool_info['parameters_schema'].get('required', [])
+        if required_params:
+            prompt_parts.append(f"  Обязательные параметры: {', '.join(required_params)}")
+    
+    return "\n".join(prompt_parts)
+
+async def execute_ai_tool(tool_name: str, arguments: Dict[str, Any]) -> Any:
+    """Выполняет AI инструмент по имени с аргументами"""
+    if tool_name not in _ai_tools:
+        raise ValueError(f"AI инструмент '{tool_name}' не найден")
+    
+    tool_info = _ai_tools[tool_name]
+    handler = tool_info['handler']
+    
+    # Валидируем аргументы по схеме
+    _validate_tool_arguments(tool_name, arguments, tool_info['parameters_schema'])
+    
+    return await handler(**arguments)
+
+def _validate_tool_arguments(tool_name: str, arguments: Dict[str, Any], schema: Dict[str, Any]):
+    """Валидирует аргументы инструмента по JSON Schema"""
+    required_params = schema.get('required', [])
+    
+    # Проверяем обязательные параметры
+    for param in required_params:
+        if param not in arguments:
+            raise ValueError(f"Отсутствует обязательный параметр '{param}' для инструмента '{tool_name}'")
+    
+    # Проверяем типы параметров
+    properties = schema.get('properties', {})
+    for param_name, param_value in arguments.items():
+        if param_name in properties:
+            param_schema = properties[param_name]
+            expected_type = param_schema.get('type')
+            
+            if expected_type == 'integer' and not isinstance(param_value, int):
+                raise ValueError(f"Параметр '{param_name}' должен быть integer для инструмента '{tool_name}'")
+            elif expected_type == 'string' and not isinstance(param_value, str):
+                raise ValueError(f"Параметр '{param_name}' должен быть string для инструмента '{tool_name}'")
+            elif expected_type == 'boolean' and not isinstance(param_value, bool):
+                raise ValueError(f"Параметр '{param_name}' должен быть boolean для инструмента '{tool_name}'")

smart_bot_factory-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: smart-bot-factory
+Version: 0.1.0
+Summary: Библиотека для создания умных чат-ботов
+Author-email: Kopatych <kopatych@example.com>
+License: MIT
+License-File: LICENSE
+Keywords: chatbot,cli,openai,supabase,telegram
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: aiofiles>=23.0.0
+Requires-Dist: aiogram>=3.4.1
+Requires-Dist: click>=8.0.0
+Requires-Dist: openai>=1.12.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: pytz>=2023.3
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: supabase>=2.3.4
+Description-Content-Type: text/markdown
+
+# Smart Bot Factory
+
+Библиотека для создания умных чат-ботов с использованием OpenAI, Telegram и Supabase.
+
+## Установка
+
+```bash
+pip install smart-bot-factory
+```
+
+## Быстрый старт
+
+1. Создайте нового бота:
+```bash
+sbf create my-bot
+```
+
+2. Настройте конфигурацию в `bots/my-bot/.env`
+
+3. Запустите бота:
+```bash
+sbf run my-bot
+```
+
+## Возможности
+
+- 🤖 Интеграция с OpenAI GPT для умных ответов
+- 📱 Поддержка Telegram Bot API через aiogram
+- 💾 Хранение данных в Supabase
+- 🔄 Система событий и обработчиков
+- ⏰ Планировщик задач
+- 🧪 Встроенная система тестирования
+- 📝 Управление промптами
+- 🛠️ Удобный CLI интерфейс
+
+## CLI команды
+
+```bash
+# Создать нового бота
+sbf create my-bot
+
+# Запустить бота
+sbf run my-bot
+
+# Показать список ботов
+sbf list
+
+# Управление промптами
+sbf prompts my-bot --list
+sbf prompts my-bot --edit welcome_message
+sbf prompts my-bot --add new_prompt
+
+# Запустить тесты
+sbf test my-bot
+```
+
+## Пример использования
+
+```python
+from smart_bot_factory import BotBuilder, event_handler, schedule_task
+
+# Обработчик события
+@event_handler("book_appointment", "Запись на прием")
+async def handle_booking(user_id: int, event_data: dict):
+    # Логика обработки записи на прием
+    return {"status": "success"}
+
+# Запланированная задача
+@schedule_task("send_reminder", "Отправка напоминания")
+async def send_reminder(user_id: int, message: str):
+    # Логика отправки напоминания
+    return {"status": "sent"}
+
+# Запуск бота
+async def main():
+    bot = BotBuilder("my-bot")
+    await bot.build()
+    await bot.start()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Требования
+
+- Python 3.9+
+- OpenAI API ключ
+- Telegram Bot Token
+- Supabase проект
+
+## Лицензия
+
+MIT

smart_bot_factory-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+smart_bot_factory/__init__.py,sha256=K8NaQbzJRtSH69ZRqg33C-G7KHWfy4bC1lYz9BJdEco,682
+smart_bot_factory/cli.py,sha256=jiYWmjAsWmUyReYX7hsCwC73h7Ee1mo-R9VWkpKF0AM,25542
+smart_bot_factory/core/__init__.py,sha256=inF93r4_Dmddkj1LnBgum9t6QFVU0BQHzUP5HLPZ8s0,103
+smart_bot_factory/core/bot_builder.py,sha256=VhgYwZPev7zMLTv7pqEOOssJZGhLRV4zcEU8dQ_97N4,17727
+smart_bot_factory/events/__init__.py,sha256=0CXtlpKSx_FfI_PlhjaZGKuS90_W_kJ1cI_Y8vYOhGA,602
+smart_bot_factory/events/decorators.py,sha256=7CTnx_43hFUTmWUFSrFjPiFJY4w-7_-bdj0wpjX88mc,9378
+smart_bot_factory/integrations/__init__.py,sha256=OaW31B0PdDwV5yrVrE2RRDOQ9PgOLk8JcLqDCuOiwKg,3788
+smart_bot_factory/integrations/bot_utils_integration.py,sha256=i8JY3ybGvAhP9mKFNhf9vJdUD54bS5LbRXpjDfN-d8s,9769
+smart_bot_factory/services/__init__.py,sha256=N-mB1AqREqRriUURTP1mWFtFMOpYSMvSbGpMJmnpFHc,288
+smart_bot_factory/services/message_sender.py,sha256=MxfT9dLOpdKvS52dhWcCJRTIYXAjPNaSi72sa6ds0yM,9336
+smart_bot_factory/services/telegram_integration.py,sha256=Khul3Zze6gUv8Jg0FCy8ObcIW6rrnVH1ylov6XRnp78,8905
+smart_bot_factory/tools/__init__.py,sha256=MEEHtoK5mdlnhpan3_GZqt_eIXJqeADuNyljgbEaPy8,344
+smart_bot_factory/tools/decorators.py,sha256=618PaQpQRMKDktCed_dAvDRaffAbhAEH193fNKCeC8M,6201
+smart_bot_factory-0.1.0.dist-info/METADATA,sha256=7utCRN8K98XElbp1JfmYumG1q5c54Pcll7Yz6ZX9cBA,3488
+smart_bot_factory-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smart_bot_factory-0.1.0.dist-info/entry_points.txt,sha256=ybKEAI0WSb7WoRiey7QE-HHfn88UGV7nxLDxXq7b7SU,50
+smart_bot_factory-0.1.0.dist-info/licenses/LICENSE,sha256=U7oalxgqok6_z5dMIGmENJY5j6sDnGeQtzcStVQUl6M,1086
+smart_bot_factory-0.1.0.dist-info/RECORD,,

smart_bot_factory-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

smart_bot_factory-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sbf = smart_bot_factory.cli:cli

smart_bot_factory-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kopatych
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.