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

smart_bot_factory/services/telegram_integration.py

@@ -1,246 +0,0 @@
-"""
-Интеграция с 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

@@ -1,19 +0,0 @@
-"""
-Инструменты 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

@@ -1,140 +0,0 @@
-"""
-Декораторы для инструментов 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

@@ -1,125 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/licenses/LICENSE

@@ -1,21 +0,0 @@
-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.