maxbot-chatbot-python 1.1.0__py3-none-any.whl

maxbot_chatbot_python/__init__.py

@@ -0,0 +1,13 @@
+from maxbot_chatbot_python.bot import Bot
+from maxbot_chatbot_python.state import MapStateManager, Scene, State
+from maxbot_chatbot_python.notification import Notification
+from maxbot_chatbot_python.router import Router
+
+__all__ = [
+    "Bot", 
+    "MapStateManager", 
+    "Scene", 
+    "State",
+    "Notification", 
+    "Router"
+]

maxbot_chatbot_python/bot.py

@@ -0,0 +1,42 @@
+import asyncio
+from maxbot_chatbot_python.router import Router
+from maxbot_chatbot_python.notification import Notification
+
+class Bot:
+    def __init__(self, api_client):
+        self.api = api_client
+        self.router = Router()
+        self.state_manager = None
+        self.marker = 0
+
+    async def start_polling(self):
+        print("Bot is running. Start polling...")
+
+        while True:
+            try:
+                resp = await self.api.subscriptions.GetUpdatesAsync(
+                    marker=self.marker,
+                    timeout=25
+                )
+
+                if getattr(resp, 'marker', 0) != 0:
+                    self.marker = resp.marker
+
+                updates = getattr(resp, 'updates', [])
+                for update in updates:
+                    asyncio.create_task(self.process_update(update))
+
+            except asyncio.CancelledError:
+                print("Stop polling...")
+                break
+            except Exception as e:
+                print(f"Error receiving updates: {e}")
+                await asyncio.sleep(2)
+
+    async def process_update(self, update):
+        notif = Notification(
+            update=update, 
+            bot_api=self.api, 
+            state_manager=self.state_manager
+        )
+        await self.router.publish(notif)

maxbot_chatbot_python/notification.py

@@ -0,0 +1,214 @@
+import asyncio, logging
+
+from maxbot_api_client_python import utils
+from maxbot_api_client_python.types.models import Attachment, KeyboardButton
+
+logger = logging.getLogger(__name__)
+
+class Notification:
+    def __init__(self, update, bot_api, state_manager=None):
+        self.update = update
+        self.bot_api = bot_api
+        self.state_manager = state_manager
+        self.state_id = "global"
+        self.create_state_id()
+
+    async def send(self, **kwargs):
+        """
+        Internal method to send a constructed message request to the chat and log it.
+        """
+        if "chat_id" not in kwargs or kwargs["chat_id"] == 0:
+            kwargs["chat_id"] = self.chat_id()
+
+        try:
+            await self.bot_api.messages.SendMessageAsync(**kwargs)
+            logger.info(f"Reply sent to {kwargs['chat_id']}")
+        except Exception as e:
+            logger.error(f"Sending reply error: {e}, target_id: {kwargs['chat_id']}")
+            raise
+
+    def type(self) -> str:
+        """Returns the type of the incoming update."""
+        if hasattr(self.update, 'update_type'):
+            return self.update.update_type
+        elif isinstance(self.update, dict):
+            return self.update.get('update_type')
+        return "unknown"
+
+    @property
+    def _is_message(self) -> bool:
+        return self.type() in ("message_created", "message_edited") and self.update.message is not None
+
+    @property
+    def _is_callback(self) -> bool:
+        return self.type() == "message_callback" and self.update.callback is not None
+
+    def text(self) -> str:
+        if self._is_message and self.update.message.body:
+            return self.update.message.body.text
+        if self._is_callback:
+            return self.update.callback.payload
+        raise ValueError(f"Text is not applicable or missing for type: {self.type()}")
+
+    def sender_name(self) -> str:
+        if self._is_message and self.update.message.sender:
+            return self.update.message.sender.first_name
+        if self._is_callback and self.update.callback.user:
+            return self.update.callback.user.first_name
+        raise ValueError(f"Sender name not found for type: {self.type()}")
+
+    def sender_id(self) -> int:
+        if self._is_message and self.update.message.sender:
+            return self.update.message.sender.user_id
+        if self._is_callback and self.update.callback.user:
+            return self.update.callback.user.user_id
+        raise ValueError(f"Sender ID not found for type: {self.type()}")
+
+    def chat_id(self) -> int:
+        if self._is_message:
+            chat_id = getattr(self.update.message.recipient, 'chat_id', 0) if self.update.message.recipient else 0
+            return chat_id if chat_id != 0 else getattr(self.update.message.sender, 'user_id', 0)
+            
+        if self._is_callback:
+            if getattr(self.update, 'chat_id', 0):
+                return self.update.chat_id
+            if getattr(self.update.callback, 'chat_id', 0):
+                return getattr(self.update.callback, 'chat_id')
+            if getattr(self.update, 'message', None) and getattr(self.update.message.recipient, 'chat_id', 0):
+                return self.update.message.recipient.chat_id
+            if self.update.callback.user:
+                return self.update.callback.user.user_id
+                
+        raise ValueError(f"Chat ID not found for type: {self.type()}")
+
+    async def reply(self, text: str, format_type: str | None = "markdown"):
+        await self.send(
+            chat_id=0,
+            text=text,
+            format=format_type if format_type else None,
+            notify=True
+        )
+
+    async def reply_with_media(self, text: str, format_type: str | None, file_source: str, keyboard: list[list[KeyboardButton]] | None = None):
+        target_id = self.chat_id()
+        kwargs = {
+            "chat_id": target_id,
+            "text": text,
+            "format": format_type if format_type else None,
+            "file_source": file_source,
+            "notify": True
+        }
+        
+        if keyboard:
+            kwargs["attachments"] = [utils.attach_keyboard(keyboard)]
+
+        for i in range(5):
+            try:
+                await self.bot_api.helpers.SendFileAsync(**kwargs)
+                logger.info(f"Media reply sent successfully to {target_id}")
+                return
+            except Exception as e:
+                err_str = str(e)
+                if "not.ready" in err_str or "not.found" in err_str:
+                    logger.info(f"File is processing, attempt {i+1}/5")
+                    await asyncio.sleep(3)
+                    continue
+                logger.error(f"Sending media reply error: {e}")
+                raise e
+
+    async def reply_with_contact(self, name: str, phone: str, contact_id: int | None = None):
+        await self.send(
+            chat_id=0,
+            attachments=[utils.attach_contact(name, phone, contact_id)],
+            notify=True
+        )
+
+    async def reply_with_location(self, lat: float, lon: float):
+        await self.send(
+            chat_id=0,
+            attachments=[utils.attach_location(lat, lon)],
+            notify=True
+        )
+
+    async def reply_with_keyboard(self, text: str, format_type: str | None, buttons: list[list[KeyboardButton]]):
+        await self.send(
+            chat_id=0,
+            text=text,
+            format=format_type if format_type else None,
+            attachments=[utils.attach_keyboard(buttons)],
+            notify=True
+        )
+
+    async def reply_with_sticker(self, url: str, code: str):
+        await self.send(
+            chat_id=0,
+            attachments=[utils.attach_sticker(url, code)],
+            notify=True
+        )
+
+    async def reply_with_share(self, text: str, url: str, title: str, desc: str):
+        await self.send(
+            chat_id=0,
+            text=text,
+            attachments=[utils.attach_share(url, title, desc)],
+            notify=True
+        )
+
+    async def reply_with_attachments(self, text: str, format_type: str | None, attachments: list[Attachment]):
+        await self.send(
+            chat_id=0,
+            text=text,
+            format=format_type if format_type else None,
+            attachments=attachments,
+            notify=True
+        )
+
+    async def answer_callback(self, text: str = ""):
+        if not self._is_callback:
+            raise ValueError("cannot answer callback: update is not a callback")
+
+        try:
+            await self.bot_api.messages.AnswerCallbackAsync(
+                callback_id=self.update.callback.callback_id,
+                notification=text if text else " "
+            )
+        except Exception as e:
+            logger.error(f"AnswerCallback error: {e}")
+            raise
+
+    async def show_action(self, action: str):
+        try:
+            chat_id = self.chat_id()
+            if chat_id == 0:
+                raise ValueError("missing chat ID")
+                
+            res = await self.bot_api.chats.SendActionAsync(
+                chat_id=chat_id,
+                action=action
+            )
+            
+            if res and not getattr(res, 'success', True):
+                logger.warning(f"API rejected the action {action}: {res}")
+            else:
+                logger.info(f"Action {action} sent successfully to {chat_id}")
+                
+        except Exception as e:
+            logger.error(f"Failed to send action {action} due to API error {e}")
+            raise
+
+    def create_state_id(self):
+        try:
+            chat_id = self.chat_id()
+            if chat_id:
+                self.state_id = f"chat_{chat_id}"
+        except ValueError:
+            self.state_id = "global"
+
+    def activate_next_scene(self, scene):
+        if self.state_manager:
+            self.state_manager.activate_next_scene(self.state_id, scene)
+
+    def get_current_scene(self):
+        if self.state_manager:
+            return self.state_manager.get_current_scene(self.state_id)
+        return None

maxbot_chatbot_python/router.py

@@ -0,0 +1,105 @@
+class Router:
+    def __init__(self):
+        self.handlers = {}
+        self.commands = {}
+        self.callbacks = {}
+
+    def command(self, cmd: str):
+        """
+        Decorator to register a handler for a specific text command (e.g., /start).
+
+        Example:
+            @router.command("/help")
+            async def handle_help(notification):
+                await notification.reply("Commands list...")
+        """
+        def decorator(func):
+            self.commands[cmd] = func
+            return func
+        return decorator
+
+    def callback(self, payload: str):
+        """
+        Decorator to register a handler for a specific callback payload from buttons.
+
+        Example:
+            @router.callback("settings_press")
+            async def handle_settings(notification):
+                await notification.answer_callback("Opening settings...")
+        """
+        def decorator(func):
+            self.callbacks[payload] = func
+            return func
+        return decorator
+
+    def register(self, update_type: str):
+        """
+        Decorator to register a generic handler for a specific update type.
+
+        Example:
+            @router.register("message_created")
+            async def on_message(notification):
+                print("Process message")
+        """
+        def decorator(func):
+            if update_type not in self.handlers:
+                self.handlers[update_type] = []
+            self.handlers[update_type].append(func)
+            return func
+        return decorator
+
+    async def publish(self, notification):
+        """
+        Processes an incoming notification and routes it to the first matching handler.
+        Order: Commands -> Callbacks -> Update Type Handlers.
+        """
+        u_type = notification.type()
+        try:
+            chat_id = notification.chat_id()
+            sender_id = notification.sender_id()
+        except ValueError:
+            chat_id, sender_id = 0, 0
+
+        match u_type:
+            case "message_created":
+                try:
+                    text = notification.text()
+                    if text and text.startswith("/"):
+                        cmd = text.split(" ", 1)[0]
+                        print(f"Received new command | chat_id: {chat_id}, user_id: {sender_id}, command: {cmd}")
+                        if cmd in self.commands:
+                            await self.commands[cmd](notification)
+                            return
+                    else:
+                        print(f"Received new message | chat_id: {chat_id}, user_id: {sender_id}, text: {text}")
+                except Exception:
+                    pass
+
+            case "message_callback":
+                try:
+                    payload = notification.text()
+                    print(f"Received new callback | chat_id: {chat_id}, user_id: {sender_id}, callback: {payload}")
+                    if payload in self.callbacks:
+                        await self.callbacks[payload](notification)
+                        return
+                except Exception:
+                    pass
+        
+            case "bot_added" | "bot_started" | "bot_stopped":
+                print(f"Bot status updated | type: {u_type}, chat_id: {chat_id}")
+                
+            case "user_added" | "user_removed":
+                print(f"User membership changed | type: {u_type}, chat_id: {chat_id}")
+                
+            case "dialog_muted" | "dialog_unmuted" | "dialog_cleared" | "dialog_removed":
+                print(f"Dialog state updated | type: {u_type}, chat_id: {chat_id}")
+                
+            case "message_edited" | "message_removed":
+                print(f"Message modified | type: {u_type}, chat_id: {chat_id}")
+                
+            case "chat_title_changed":
+                print(f"Chat settings modified | type: {u_type}, chat_id: {chat_id}")
+
+        if u_type in self.handlers:
+            for func in self.handlers[u_type]:
+                await func(notification)

maxbot_chatbot_python/state.py

@@ -0,0 +1,65 @@
+from typing import Any
+
+class Scene:
+    async def start(self, app):
+        pass
+
+class State:
+    def get_data(self) -> dict[str, Any]: pass
+    def set_data(self, data: dict[str, Any]): pass
+    def update_data(self, data: dict[str, Any]): pass
+    def get_scene(self) -> Scene | None: pass
+    def set_scene(self, scene: Scene): pass
+
+class MapState(State):
+    def __init__(self, data: dict[str, Any], scene: Scene | None):
+        self.data = data.copy()
+        self.scene = scene
+
+    def get_data(self) -> dict[str, Any]: return self.data
+    def set_data(self, data: dict[str, Any]): self.data = data
+    def update_data(self, data: dict[str, Any]): self.data.update(data)
+    def get_scene(self) -> Scene | None: return self.scene
+    def set_scene(self, scene: Scene): self.scene = scene
+
+class MapStateManager:
+    def __init__(self, init_data: dict[str, Any]):
+        self.states: dict[str, State] = {}
+        self.init_data = init_data
+        self.start_scene: Scene | None = None
+
+    def get_start_scene(self) -> Scene | None:
+        return self.start_scene
+
+    def set_start_scene(self, start_scene: Scene):
+        self.start_scene = start_scene
+
+    def get(self, state_id: str) -> State | None:
+        return self.states.get(state_id)
+
+    def create(self, state_id: str) -> State:
+        self.states[state_id] = MapState(self.init_data, self.start_scene)
+        return self.states[state_id]
+
+    def delete(self, state_id: str):
+        self.states.pop(state_id, None)
+
+    def get_state_data(self, state_id: str) -> dict[str, Any] | None:
+        state = self.get(state_id)
+        return state.get_data() if state else None
+
+    def set_state_data(self, state_id: str, new_state_data: dict[str, Any]):
+        state = self.get(state_id)
+        if state: state.set_data(new_state_data)
+
+    def update_state_data(self, state_id: str, new_state_data: dict[str, Any]):
+        state = self.get(state_id)
+        if state: state.update_data(new_state_data)
+
+    def activate_next_scene(self, state_id: str, scene: Scene):
+        state = self.get(state_id)
+        if state: state.set_scene(scene)
+
+    def get_current_scene(self, state_id: str) -> Scene | None:
+        state = self.get(state_id)
+        return state.get_scene() if state else None

maxbot_chatbot_python-1.1.0.dist-info/METADATA

@@ -0,0 +1,237 @@
+Metadata-Version: 2.4
+Name: maxbot-chatbot-python
+Version: 1.1.0
+Summary: Python SDK and Chatbot Framework for MAX API
+Home-page: https://github.com/green-api/maxbot-chatbot-python
+Author: Green-API
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: maxbot-api-client-python>=1.1.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# maxbot-chatbot-python
+
+`maxbot-chatbot-python` — это асинхронный фреймворк для создания масштабируемых ботов для **MAX BOT API** на языке **Python**.  
+
+Построенная на основе [`maxbot_api_client_python`](https://github.com/green-api/maxbot-api-client-python), эта библиотека предоставляет чистый маршрутизатор, автоматическое получение обновлений (*Long Polling*) и надежный менеджер состояний (*FSM*) для построения многошаговых диалоговых сценариев.  
+
+Для использования библиотеки требуется получить токен бота в консоли разработчика **MAX API**.  
+Ознакомиться с инструкцией можно [по ссылке](https://green-api.com/max-bot-api/docs/before-start/). 
+
+## API
+
+Документацию по **REST API MAX** можно найти по ссылке [dev.max.ru/docs-api](https://dev.max.ru/docs-api). Библиотека является оберткой для REST API, поэтому документация по указанной выше ссылке также применима к используемым здесь моделям.
+
+Документацию по **MAX BOT API** можно найти по ссылке [green-api.com/max-bot-api/docs](https://green-api.com/max-bot-api/docs/).
+
+## Поддержка
+
+[![Support](https://img.shields.io/badge/support@green--api.com-D14836?style=for-the-badge&logo=gmail&logoColor=white)](mailto:support@green-api.com)
+[![Support](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/greenapi_support_ru_bot)
+[![Support](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge&logo=whatsapp&logoColor=white)](https://wa.me/77780739095)
+
+## Руководства и новости
+
+[![Guides](https://img.shields.io/badge/YouTube-%23FF0000.svg?style=for-the-badge&logo=YouTube&logoColor=white)](https://www.youtube.com/@green-api)
+[![News](https://img.shields.io/badge/Telegram-2CA5E0?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/green_api)
+[![News](https://img.shields.io/badge/WhatsApp-25D366?style=for-the-badge&logo=whatsapp&logoColor=white)](https://whatsapp.com/channel/0029VaHUM5TBA1f7cG29nO1C)
+
+## Установка
+
+**Убедитесь, что у вас установлен Python версии 3.12 или выше.**
+
+```bash
+python --version
+```
+
+**Установите библиотеку:**
+
+```bash
+pip install maxbot-chatbot-python
+```
+
+---
+
+## Использование и примеры
+
+**Параметры конфигурации:** 
+
+- `base_url` - Базовый URL-адрес серверов платформы MaxBot. Все методы API будут маршрутизироваться по этому корневому адресу. Актуальный адрес указан в [официальной документации](https://dev.max.ru/docs-api).   
+- `token` - Уникальный секретный ключ авторизации (API-ключ) вашего бота. Получить его можно в личном кабинете после [регистрации или создании бота](https://green-api.com/max-bot-api/docs/before-start/) на платформе [business.max.ru](https://business.max.ru/).    
+- `ratelimiter` - Встроенный ограничитель частоты запросов. Он контролирует количество исходящих запросов в секунду (RPS), защищая бота от блокировки со стороны сервера за превышение лимитов. Рекомендуемое значение — не менее 25.   
+- `timeout` - Максимальное время ожидания ответа от сервера (в секундах). Если сервер не ответит в течение этого времени, запрос будет завершен с ошибкой. Оптимальное значение — 30 секунд.    
+
+### Инициализация бота
+
+Использование асинхронного контекстного менеджера (`async with API(...)`) гарантирует безопасное закрытие сетевых соединений при остановке бота.
+
+```python
+import asyncio
+
+from maxbot_api_client_python import API, Config
+from maxbot_chatbot_python import Bot, MapStateManager
+
+async def main():
+    cfg = Config(
+        base_url="https://platform-api.max.ru/", 
+        token="YOUR_BOT_TOKEN", 
+        ratelimiter=25,
+        timeout=35
+    )
+
+    async with API(cfg) as api_client:
+        bot = Bot(api_client)
+        bot.state_manager = MapStateManager(init_data={})
+
+        polling_task = asyncio.create_task(bot.start_polling())
+
+        try:
+            await polling_task
+        except asyncio.CancelledError:
+            pass
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Bot stopped by user")
+```
+
+### Маршрутизация команд, сообщений и коллбэков
+
+Встроенный **маршрутизатор** (`Router`) позволяет легко обрабатывать конкретные команды (начинающиеся со слэша `/`) и нажатия на **inline-кнопки** (коллбэки).
+
+```python
+@bot.router.command("/start")
+async def start_command(notification):
+    await notification.reply("Hello! Welcome to the MAX Bot.")
+
+@bot.router.register("message_created")
+async def ping_handler(notification):
+    try:
+        if notification.text() == "ping":
+            await notification.reply("pong")
+    except ValueError:
+        pass
+
+@bot.router.callback("accept_rules")
+async def rules_callback(notification):
+    await notification.reply("*Thank you for accepting the rules!*", format_type="markdown")
+    await notification.answer_callback("Success!")
+```
+
+### Управление состояниями и Сцены (FSM)
+
+Для сложных многошаговых диалогов (например, регистрация или анкетирование) используйте **Менеджер состояний** (`StateManager`) и **Сцены** (`Scene`).
+
+```python
+from maxbot_chatbot_python import Scene
+
+class RegistrationScene(Scene):
+    async def start(self, notification):
+        try:
+            text = notification.text()
+        except ValueError:
+            return
+
+        if text == "/start":
+            await notification.reply("Let's register! What is your *login*?", "markdown")
+            return 
+        
+        if len(text) >= 4:
+            if notification.state_manager:
+                notification.state_manager.update_state_data(notification.state_id, {"login": text})
+            
+            await notification.reply(f"**Login** `{text}` accepted. Now enter your **password**:", "markdown")
+            notification.activate_next_scene(PasswordScene())
+        else:
+            await notification.reply("Login must be **at least 4 characters long**.", "markdown")
+
+class PasswordScene(Scene):
+    async def start(self, notification):
+        try:
+            password = notification.text()
+        except ValueError:
+            return
+
+        state_data = notification.state_manager.get_state_data(notification.state_id)
+        login = state_data.get("login", "Unknown")
+
+        await notification.reply(f"Success! Profile created.\nLogin: `{login}`\nPass: `{password}`", "markdown")
+
+        notification.activate_next_scene(RegistrationScene())
+
+@bot.router.register("message_created")
+async def fsm_handler(notification):
+    current_scene = notification.get_current_scene()
+    if current_scene:
+        await current_scene.start(notification)
+```
+
+### Ответ с медиафайлами
+
+Обертка `Notification` содержит готовые асинхронные методы для отправки файлов, геолокаций, стикеров и статусов набора текста.
+
+```python
+@bot.router.command("/photo")
+async def send_photo(notification):
+    await notification.show_action("sending_photo")
+
+    await notification.reply_with_media(
+        text="Check out this image!", 
+        format_type="markdown", 
+        file_source="https://storage.yandexcloud.net/sw-prod-03-test/ChatBot/corgi.jpg"
+    )
+```
+
+### Эхо-бот 
+
+```python
+import asyncio
+
+from maxbot_api_client_python import API, Config
+from maxbot_chatbot_python import Bot, MapStateManager
+
+async def main():
+    cfg = Config(
+        base_url="https://platform-api.max.ru/", 
+        token="YOUR_BOT_TOKEN",
+        ratelimiter=25
+    )
+
+    async with API(cfg) as api_client:
+        bot = Bot(api_client)
+        bot.state_manager = MapStateManager(init_data={})
+
+        @bot.router.register("message_created")
+        async def echo_handler(notification):
+            try:
+                text = notification.text()
+                await notification.reply(f"**Echo:** {text}", "markdown")
+            except Exception as e:
+                print(f"Error handling message: {e}")
+
+        polling_task = asyncio.create_task(bot.start_polling())
+
+        try:
+            await polling_task
+        except asyncio.CancelledError:
+            pass
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Bot stopped by user (KeyboardInterrupt)")
+```
+```

maxbot_chatbot_python-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+maxbot_chatbot_python/__init__.py,sha256=dtPlQZLMPkDYDUMJ4gdi3K8tuvf9B8WKMx7UH6iY1dk,343
+maxbot_chatbot_python/bot.py,sha256=iPupJZuVaZhZJdJBcMa9_NJUWE6mGBuj9yrpMVeAmyY,1341
+maxbot_chatbot_python/notification.py,sha256=wc4CK3IIetB_6sidHHgZ37e73hb1xWVKqypImpGxzCM,8225
+maxbot_chatbot_python/router.py,sha256=RLADmGdIZFExHI9Fl3bRr4tRgxfdJrSA1zp-Y6LXZJo,4103
+maxbot_chatbot_python/state.py,sha256=7zSAvTdLxu_iu_LdapbXI5ySucGsBloUhmgGJCEYNQs,2342
+maxbot_chatbot_python-1.1.0.dist-info/licenses/LICENSE,sha256=v1Mdo-KDvHFJnCaCcCPm4pR4JiovXR-v1BcS2YCvFLg,1085
+maxbot_chatbot_python-1.1.0.dist-info/METADATA,sha256=Hd-Q32ieAdO_lh_-OKkd5GoYkNkt8HLRDqJCbjSn-mA,10620
+maxbot_chatbot_python-1.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+maxbot_chatbot_python-1.1.0.dist-info/top_level.txt,sha256=MlT4FWJq3fIKUuZfOBfb4tJF51Bqcm0RrJiSutboQns,22
+maxbot_chatbot_python-1.1.0.dist-info/RECORD,,

maxbot_chatbot_python-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maxbot_chatbot_python-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GREEN-API
+
+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.

maxbot_chatbot_python-1.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+maxbot_chatbot_python