multibotkit 0.1.34__py3-none-any.whl → 0.2.0__py3-none-any.whl

multibotkit/helpers/viber.py

@@ -179,14 +179,14 @@ are required"
 
     def sync_set_webhook(self, webhook_data: SetWebhook):
         url = self.VIBER_BASE_URL + "set_webhook"
-        data = webhook_data.dict(exclude_none=True)
+        data = webhook_data.model_dump(exclude_none=True)
         data["auth_token"] = self.token
         r = self._perform_sync_request(url=url, data=data)
         return r
 
     async def async_set_webhook(self, webhook_data: SetWebhook):
         url = self.VIBER_BASE_URL + "set_webhook"
-        data = webhook_data.dict(exclude_none=True)
+        data = webhook_data.model_dump(exclude_none=True)
         data["auth_token"] = self.token
         r = await self._perform_async_request(url=url, data=data)
         return r
@@ -238,7 +238,7 @@ are required"
         )
 
         url = self.VIBER_BASE_URL + "send_message"
-        data = message.dict(exclude_none=True)
+        data = message.model_dump(exclude_none=True)
         data["auth_token"] = self.token
         r = self._perform_sync_request(url=url, data=data)
         return r
@@ -280,7 +280,7 @@ are required"
         )
 
         url = self.VIBER_BASE_URL + "send_message"
-        data = message.dict(exclude_none=True)
+        data = message.model_dump(exclude_none=True)
         data["auth_token"] = self.token
         r = await self._perform_async_request(url=url, data=data)
         return r

multibotkit/helpers/vk.py

@@ -67,7 +67,7 @@ class VKHelper(BaseHelper):
             template=template,
         )
 
-        data = message.dict(exclude_none=True)
+        data = message.model_dump(exclude_none=True)
         if data.get("keyboard"):
             data["keyboard"] = json.dumps(data["keyboard"], ensure_ascii=False)
         if data.get("template"):
@@ -101,7 +101,7 @@ but not both"
             attachment=attachment,
             template=template,
         )
-        data = message.dict(exclude_none=True)
+        data = message.model_dump(exclude_none=True)
         if data.get("keyboard"):
             data["keyboard"] = json.dumps(data["keyboard"], ensure_ascii=False)
         if data.get("template"):

multibotkit/helpers/yandexmessenger.py

@@ -0,0 +1,408 @@
+from json import JSONDecodeError
+from typing import IO, List, Optional, Union
+
+import httpx
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from multibotkit.helpers.base_helper import BaseHelper
+from multibotkit.schemas.yandexmessenger.incoming import Update
+from multibotkit.schemas.yandexmessenger.outgoing import (
+    GetUpdatesParams,
+    InlineKeyboard,
+    SendFileParams,
+    SendImageParams,
+    SendTextParams,
+    SetWebhookParams,
+)
+
+
+class YandexMessengerHelper(BaseHelper):
+    """
+    Sync и async функции для Yandex Messenger Bot API.
+
+    Базовый URL: https://botapi.messenger.yandex.net/bot/v1/
+    Авторизация: Authorization: OAuth <token>
+    """
+
+    def __init__(self, token: str):
+        self.token = token
+        self.base_url = "https://botapi.messenger.yandex.net/bot/v1/"
+        self.headers = {"Authorization": f"OAuth {self.token}"}
+
+    @retry(
+        retry=retry_if_exception_type(httpx.HTTPError)
+        | retry_if_exception_type(JSONDecodeError),
+        reraise=True,
+        stop=stop_after_attempt(5),
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+    )
+    def _perform_sync_request(
+        self,
+        url: str,
+        data: Optional[dict] = None,
+        use_json: bool = True,
+        files: Optional[dict] = None,
+    ):
+        """Переопределение для добавления OAuth заголовка"""
+        if use_json:
+            r = httpx.post(url=url, json=data, headers=self.headers)
+        else:
+            r = httpx.post(url=url, data=data, files=files, headers=self.headers)
+        return r.json()
+
+    @retry(
+        retry=retry_if_exception_type(httpx.HTTPError)
+        | retry_if_exception_type(JSONDecodeError),
+        reraise=True,
+        stop=stop_after_attempt(5),
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+    )
+    async def _perform_async_request(
+        self,
+        url: str,
+        data: Optional[dict] = None,
+        use_json: bool = True,
+        files: Optional[dict] = None,
+    ):
+        """Переопределение для добавления OAuth заголовка"""
+        async with httpx.AsyncClient() as client:
+            if use_json:
+                r = await client.post(url=url, json=data, headers=self.headers)
+            else:
+                r = await client.post(
+                    url=url, data=data, files=files, headers=self.headers
+                )
+        return r.json()
+
+    def sync_send_text(
+        self,
+        text: str,
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        payload_id: Optional[str] = None,
+        reply_message_id: Optional[int] = None,
+        disable_notification: Optional[bool] = None,
+        important: Optional[bool] = None,
+        disable_web_page_preview: Optional[bool] = None,
+        thread_id: Optional[int] = None,
+        inline_keyboard: Optional[InlineKeyboard] = None,
+    ) -> dict:
+        """
+        Синхронная отправка текстового сообщения.
+
+        Args:
+            text: Текст сообщения (до 6000 символов)
+            chat_id: ID чата (для group/channel)
+            login: Login пользователя (для private)
+            payload_id: Уникальный ID для дедупликации
+            reply_message_id: ID сообщения для ответа
+            disable_notification: Отключить уведомление
+            important: Отметить как важное
+            disable_web_page_preview: Отключить превью ссылок
+            thread_id: ID треда
+            inline_keyboard: Inline клавиатура
+
+        Returns:
+            dict с полями {"ok": true, "message_id": integer}
+        """
+        url = self.base_url + "messages/sendText/"
+        params = SendTextParams(
+            text=text,
+            chat_id=chat_id,
+            login=login,
+            payload_id=payload_id,
+            reply_message_id=reply_message_id,
+            disable_notification=disable_notification,
+            important=important,
+            disable_web_page_preview=disable_web_page_preview,
+            thread_id=thread_id,
+            inline_keyboard=inline_keyboard,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        # Сериализация inline_keyboard если есть
+        if inline_keyboard:
+            data["inline_keyboard"] = inline_keyboard.model_dump(exclude_none=True)[
+                "buttons"
+            ]
+
+        return self._perform_sync_request(url, data)
+
+    async def async_send_text(
+        self,
+        text: str,
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        payload_id: Optional[str] = None,
+        reply_message_id: Optional[int] = None,
+        disable_notification: Optional[bool] = None,
+        important: Optional[bool] = None,
+        disable_web_page_preview: Optional[bool] = None,
+        thread_id: Optional[int] = None,
+        inline_keyboard: Optional[InlineKeyboard] = None,
+    ) -> dict:
+        """Асинхронная версия sync_send_text"""
+        url = self.base_url + "messages/sendText/"
+        params = SendTextParams(
+            text=text,
+            chat_id=chat_id,
+            login=login,
+            payload_id=payload_id,
+            reply_message_id=reply_message_id,
+            disable_notification=disable_notification,
+            important=important,
+            disable_web_page_preview=disable_web_page_preview,
+            thread_id=thread_id,
+            inline_keyboard=inline_keyboard,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        if inline_keyboard:
+            data["inline_keyboard"] = inline_keyboard.model_dump(exclude_none=True)
+
+        return await self._perform_async_request(url, data)
+
+    def sync_send_image(
+        self,
+        image: Union[str, IO],
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        thread_id: Optional[int] = None,
+    ) -> dict:
+        """
+        Синхронная отправка изображения.
+
+        Args:
+            image: Путь к файлу, file_id или IO объект
+            chat_id: ID чата (для group/channel)
+            login: Login пользователя (для private)
+            thread_id: ID треда
+
+        Returns:
+            dict с полями {"ok": true, "message_id": integer}
+        """
+        url = self.base_url + "messages/sendImage/"
+        params = SendImageParams(
+            chat_id=chat_id,
+            login=login,
+            thread_id=thread_id,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        # Обработка различных типов image
+        if isinstance(image, str):
+            # Если это путь к файлу с расширением
+            if image.endswith((".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp")):
+                with open(image, "rb") as f:
+                    files = {"image": f}
+                    return self._perform_sync_request(
+                        url, data, use_json=False, files=files
+                    )
+            else:
+                # Если это file_id - отправляем как JSON
+                data["image"] = image
+                return self._perform_sync_request(url, data)
+        else:
+            # Если это IO объект
+            files = {"image": image}
+            return self._perform_sync_request(url, data, use_json=False, files=files)
+
+    async def async_send_image(
+        self,
+        image: Union[str, IO],
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        thread_id: Optional[int] = None,
+    ) -> dict:
+        """Асинхронная версия sync_send_image"""
+        url = self.base_url + "messages/sendImage/"
+        params = SendImageParams(
+            chat_id=chat_id,
+            login=login,
+            thread_id=thread_id,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        if isinstance(image, str):
+            if image.endswith((".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp")):
+                with open(image, "rb") as f:
+                    content = f.read()
+                files = {"image": content}
+                return await self._perform_async_request(
+                    url, data, use_json=False, files=files
+                )
+            else:
+                data["image"] = image
+                return await self._perform_async_request(url, data)
+        else:
+            files = {"image": image}
+            return await self._perform_async_request(
+                url, data, use_json=False, files=files
+            )
+
+    def sync_send_file(
+        self,
+        document: Union[str, IO],
+        filename: Optional[str] = None,
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        thread_id: Optional[int] = None,
+    ) -> dict:
+        """
+        Синхронная отправка файла.
+
+        Args:
+            document: Путь к файлу, file_id или IO объект
+            filename: Имя файла (для IO объектов)
+            chat_id: ID чата (для group/channel)
+            login: Login пользователя (для private)
+            thread_id: ID треда
+
+        Returns:
+            dict с полями {"ok": true, "message_id": integer}
+        """
+        url = self.base_url + "messages/sendFile/"
+        params = SendFileParams(
+            chat_id=chat_id,
+            login=login,
+            thread_id=thread_id,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        if isinstance(document, str):
+            # Если это путь к файлу
+            if not document.startswith(("http://", "https://")):
+                # Локальный файл
+                fname = filename or document.split("/")[-1]
+                with open(document, "rb") as f:
+                    files = {"document": (fname, f)}
+                    return self._perform_sync_request(
+                        url, data, use_json=False, files=files
+                    )
+            else:
+                # file_id или URL
+                data["document"] = document
+                return self._perform_sync_request(url, data)
+        else:
+            # IO объект
+            fname = filename or "file"
+            files = {"document": (fname, document)}
+            return self._perform_sync_request(url, data, use_json=False, files=files)
+
+    async def async_send_file(
+        self,
+        document: Union[str, IO],
+        filename: Optional[str] = None,
+        chat_id: Optional[str] = None,
+        login: Optional[str] = None,
+        thread_id: Optional[int] = None,
+    ) -> dict:
+        """Асинхронная версия sync_send_file"""
+        url = self.base_url + "messages/sendFile/"
+        params = SendFileParams(
+            chat_id=chat_id,
+            login=login,
+            thread_id=thread_id,
+        )
+        data = params.model_dump(exclude_none=True)
+
+        if isinstance(document, str):
+            if not document.startswith(("http://", "https://")):
+                fname = filename or document.split("/")[-1]
+                with open(document, "rb") as f:
+                    content = f.read()
+                files = {"document": (fname, content)}
+                return await self._perform_async_request(
+                    url, data, use_json=False, files=files
+                )
+            else:
+                data["document"] = document
+                return await self._perform_async_request(url, data)
+        else:
+            fname = filename or "file"
+            files = {"document": (fname, document)}
+            return await self._perform_async_request(
+                url, data, use_json=False, files=files
+            )
+
+    def sync_get_updates(
+        self,
+        limit: Optional[int] = 100,
+        offset: Optional[int] = 0,
+    ) -> dict:
+        """
+        Синхронное получение обновлений (long polling).
+
+        Args:
+            limit: Количество обновлений (1-1000, по умолчанию 100)
+            offset: Смещение для пагинации
+
+        Returns:
+            dict с полями {"ok": true, "updates": [...]}
+        """
+        url = self.base_url + "messages/getUpdates/"
+        params = GetUpdatesParams(limit=limit, offset=offset)
+        data = params.model_dump(exclude_none=True)
+
+        return self._perform_sync_request(url, data)
+
+    async def async_get_updates(
+        self,
+        limit: Optional[int] = 100,
+        offset: Optional[int] = 0,
+    ) -> dict:
+        """Асинхронная версия sync_get_updates"""
+        url = self.base_url + "messages/getUpdates/"
+        params = GetUpdatesParams(limit=limit, offset=offset)
+        data = params.model_dump(exclude_none=True)
+
+        return await self._perform_async_request(url, data)
+
+    def sync_set_webhook(
+        self,
+        webhook_url: Optional[str] = None,
+    ) -> dict:
+        """
+        Синхронная установка webhook.
+
+        Args:
+            webhook_url: URL для webhook (None для отключения)
+
+        Returns:
+            dict с результатом операции
+        """
+        url = self.base_url + "self/update/"
+        params = SetWebhookParams(webhook_url=webhook_url)
+        data = params.model_dump(exclude_none=True)
+
+        return self._perform_sync_request(url, data)
+
+    async def async_set_webhook(
+        self,
+        webhook_url: Optional[str] = None,
+    ) -> dict:
+        """Асинхронная версия sync_set_webhook"""
+        url = self.base_url + "self/update/"
+        params = SetWebhookParams(webhook_url=webhook_url)
+        data = params.model_dump(exclude_none=True)
+
+        return await self._perform_async_request(url, data)
+
+    def parse_updates(self, response: dict) -> List[Update]:
+        """
+        Парсинг ответа getUpdates в список Update объектов.
+
+        Args:
+            response: dict ответ от getUpdates
+
+        Returns:
+            List[Update]
+        """
+        if response.get("ok") and "updates" in response:
+            return [Update.model_validate(update) for update in response["updates"]]
+        return []

multibotkit/schemas/telegram/incoming.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Optional, List
 
-from pydantic import Field
+from pydantic import ConfigDict, Field
 from pydantic.main import BaseModel
 
 
@@ -237,10 +237,12 @@ class WebAppData(BaseModel):
 
 
 class Message(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     message_id: int = Field(..., title="Unique message identifier inside this chat")
     date: int = Field(..., title="Date the message was sent in Unix time")
     from_: Optional[User] = Field(
-        None, title="Sender, empty for messages sent to channels"
+        None, title="Sender, empty for messages sent to channels", alias="from"
     )
     chat: Optional[Chat] = Field(None, title="Conversation the message belongs to")
     text: Optional[str] = Field(None, title="The actual UTF-8 text of the message")
@@ -284,13 +286,12 @@ the location",
         None, title="Service message: data sent by a Web App"
     )
 
-    class Config:
-        fields = {"from_": "from"}
-
 
 class CallbackQuery(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     id: str = Field(..., title="Unique identifier for this query")
-    from_: Optional[User] = Field(None, title="Sender data")
+    from_: Optional[User] = Field(None, title="Sender data", alias="from")
     message: Optional[Message] = Field(
         None, title="Message with the callback button that originated the query"
     )
@@ -311,9 +312,6 @@ which the message with the callback button was sent",
 unique identifier for the game",
     )
 
-    class Config:
-        fields = {"from_": "from"}
-
 
 class ChatMember(BaseModel):
     status: str = Field(..., title="The member's status in the chat")
@@ -368,9 +366,11 @@ class ChatInviteLink(BaseModel):
 
 
 class ChatMemberUpdated(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     date: int = Field(..., title="Date the change was done in Unix time")
     from_: User = Field(
-        ..., title="Performer of the action, which resulted in the change"
+        ..., title="Performer of the action, which resulted in the change", alias="from"
     )
     chat: Chat = Field(..., title="Chat the user belongs to")
     old_chat_member: ChatMember = Field(
@@ -393,13 +393,12 @@ class ChatMemberUpdated(BaseModel):
         title="Optional. True, if the user joined the chat via a chat folder invite link",
     )
 
-    class Config:
-        fields = {"from_": "from"}
-
 
 class ChatJoinRequest(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     chat: Chat = Field(..., title="	Chat to which the request was sent")
-    from_: User = Field(..., title="User that sent the join request")
+    from_: User = Field(..., title="User that sent the join request", alias="from")
     user_chat_id: int = Field(
         ...,
         title="Identifier of a private chat with the user who sent the join request.",
@@ -414,9 +413,6 @@ class ChatJoinRequest(BaseModel):
         title="Chat invite link that was used by the user to send the join request",
     )
 
-    class Config:
-        fields = {"from_": "from"}
-
 
 class Update(BaseModel):
     update_id: int = Field(..., title="Id of incoming bot update")

multibotkit/schemas/yandexmessenger/incoming.py

@@ -0,0 +1,77 @@
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ChatType(str, Enum):
+    """Типы чатов в Yandex Messenger"""
+
+    private = "private"
+    group = "group"
+    channel = "channel"
+
+
+class Sender(BaseModel):
+    """
+    Отправитель сообщения.
+    Либо login (для пользователей), либо id (для ботов/каналов).
+    """
+
+    login: Optional[str] = Field(None, title="Login пользователя")
+    id: Optional[str] = Field(None, title="ID отправителя (для ботов/каналов)")
+    display_name: Optional[str] = Field(None, title="Отображаемое имя")
+    robot: Optional[bool] = Field(None, title="Является ли отправитель роботом")
+
+
+class Chat(BaseModel):
+    """
+    Информация о чате.
+    Для private чатов id отсутствует.
+    """
+
+    type: ChatType = Field(..., title="Тип чата: private/group/channel")
+    id: Optional[str] = Field(
+        None, title="ID чата (для group/channel, отсутствует для private)"
+    )
+
+
+class Image(BaseModel):
+    """Изображение в сообщении"""
+
+    file_id: str = Field(..., title="ID файла для повторного использования")
+    width: int = Field(..., title="Ширина изображения в пикселях")
+    height: int = Field(..., title="Высота изображения в пикселях")
+    size: Optional[int] = Field(
+        None, title="Размер файла в байтах (опционально для оригиналов)"
+    )
+    name: Optional[str] = Field(None, title="Имя файла (опционально для оригиналов)")
+
+
+class File(BaseModel):
+    """Файл в сообщении"""
+
+    id: str = Field(..., title="ID файла")
+    name: str = Field(..., title="Имя файла")
+    size: int = Field(..., title="Размер файла в байтах")
+
+
+class Update(BaseModel):
+    """
+    Входящее обновление от Yandex Messenger.
+    Соответствует структуре getUpdates response и webhook payload.
+    """
+
+    update_id: int = Field(..., title="Уникальный ID обновления")
+    message_id: int = Field(..., title="ID сообщения")
+    timestamp: int = Field(..., title="Unix timestamp сообщения")
+    from_: Sender = Field(..., title="Отправитель сообщения", alias="from")
+    chat: Chat = Field(..., title="Информация о чате")
+    text: Optional[str] = Field(None, title="Текст сообщения (до 6000 символов)")
+    callback_data: Optional[dict] = Field(
+        None, title="Данные переданные по нажатию кнопки"
+    )
+    images: Optional[List[Image]] = Field(None, title="Массив изображений (если есть)")
+    file: Optional[File] = Field(None, title="Прикрепленный файл")
+
+    model_config = ConfigDict(populate_by_name=True)