maxibot 0.98.1__py3-none-any.whl

maxibot/apihelper.py

@@ -0,0 +1,241 @@
+import requests
+from typing import Dict, Any, List, Optional
+
+from maxibot.core.network.client import Client
+
+
+proxy = None
+ignore_warnings = True
+
+
+class Api:
+    """
+    Клиент для рабты с api MAX
+    """
+    def __init__(self, token: str):
+        """
+        Docstring for __init__
+
+        :param token: Токен бота
+        :type token: str
+        """
+        if ignore_warnings:
+            requests.packages.urllib3.disable_warnings()
+        self.client = Client(token=token, proxy=proxy)
+
+    def get_my_info(self) -> Dict[str, Any]:
+        """
+        Получает информацию о текущем боте
+
+        :return: Информация о боте
+        :rtype: Dict[str, Any]
+        """
+        return self.client.request("GET", "/me")
+
+    def get_updates(self, allowed_updates: List[str], extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Получает новые обновления от API через лонгполлинг
+
+        :param allowed_updates: Список типов обновлений, которые нужно получать
+        :param extra: Дополнительные параметры запроса
+
+        :return: Список обновлений
+        :rtype: Dict[str, Any]
+        """
+        params = extra or {}
+
+        if allowed_updates:
+            params["types"] = ",".join(allowed_updates)
+
+        return self.client.request("GET", "/updates", params=params)
+
+    def get_message(self, msg_id: str):
+        """
+        Получает сообщение по `msg_id`
+        """
+        return self.client.request("GET", f"/messages/{msg_id}")
+
+    def send_message(
+        self,
+        chat_id: str = None,
+        msg_id: str = None,
+        text: str = None,
+        method: str = "POST",
+        attachments: Optional[List[Dict[str, Any]]] = None,
+        parse_mode: str = "markdown",
+        notify: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Отправляет/удаляет/обновляет сообщение в чате
+
+        :param chat_id: Идентификатор чата
+        :type chat_id: str
+
+        :param text: Текст сообщения
+        :type text: str
+
+        :param attachments: Вложения сообщения
+        :type text: Optional[List[Dict[str, Any]]]
+
+        :return: Информация об отправленном сообщении
+        :rtype: Dict[str, Any]
+        """
+        # query параметры запроса
+        if chat_id:
+            params = {"chat_id": chat_id}
+        elif msg_id and method in ("DELETE", "PUT"):
+            params = {"message_id": msg_id}
+
+        data = {}
+        if text:
+            data = {"text": text}
+
+        if attachments:
+            data["attachments"] = attachments
+
+        if parse_mode:
+            data["format"] = parse_mode
+
+        if notify:
+            data["notify"] = notify
+
+        return self.client.request(method, "/messages", params=params, data=data)
+
+    def get_upload_file_url(self, type_attach: str):
+        """
+        Апи метод для получения url загрузки файла.
+
+        :param type_attach: Тип файла, который требуется загрузить
+        :type type_attach: str
+
+        :return: Json с url для загрузки файла
+        :rtype: Dict[str: Any]
+        """
+        return self.client.request("POST", f"/uploads?type={type_attach}")
+
+    def load_file(self, url: str, files: Dict, content_types: str = None):
+        """
+        Апи метод для получения url загрузки файла.
+
+        :param type_attach: Тип файла, который требуется загрузить
+        :type type_attach: str
+
+        :return: Json с url для загрузки файла
+        :rtype: Dict[str: Any]
+        """
+        return self.client.request(method="POST", url=url, files=files, content_types=content_types)
+
+    def answer_callback(
+            self,
+            callback_id: str,
+            text: Optional[str] = None,
+            notification: Optional[str] = None,
+            attachments: Optional[List[Dict[str, Any]]] = None,
+            link: Optional[Dict[str, Any]] = None,
+            notify: bool = True,
+            format: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Метод позволяет отправить уведомление пользователю и/или обновить
+        исходное сообщение после нажатия на inline-кнопку.
+
+        :param callback_id: Уникальный идентификатор callback-запроса.
+                            Получается из поля `callback.callback_id` в обновлении
+        :type callback_id: str
+
+        :param text: Новый текст сообщения. Если указан, сообщение будет обновлено
+        :type text: Optional[str]
+
+        :param notification: Текст всплывающего уведомления для пользователя. 
+                             Пользователь увидит это уведомление как всплывающее сообщение
+                             Пока не очень работает, в тесте :)
+        :type notification: Optional[str]
+
+        :param attachments: Новые вложения сообщения. Если указаны, сообщение будет обновлено.
+                            Для полной замены вложений передайте новый список.
+                            Чтобы удалить все вложения, передайте пустой список.
+        :type attachments: Optional[List[Dict[str, Any]]]
+
+        :param link: Ссылка на сообщение для reply/forward формата.
+                     Должен содержать поля `type` ("reply" или "forward") и `mid`
+        :type link: Optional[Dict[str, Any]]
+
+        :param notify: Отправлять ли системное уведомление в чат об изменении сообщения.
+                       По умолчанию True - участники увидят "Сообщение было изменено"
+        :type notify: bool
+
+        :param format: Формат текста сообщения. Доступные значения: "markdown", "html"
+        :type format: Optional[str]
+
+        :return: Ответ от MAX API
+        :rtype: Dict[str, Any]
+
+        :raises HTTPError: При ошибке HTTP запроса
+
+        Примеры использования:
+
+        1. Только уведомление:
+        api.answer_callback(
+            callback_id="callback123",
+            notification="Действие выполнено!"
+        )
+
+        2. Обновление сообщения с уведомлением:
+        api.answer_callback(
+            callback_id="callback123",
+            text="**Сообщение обновлено!**",
+            notification="Обновление выполнено",
+            format="markdown",
+            notify=False  # Не показывать "Сообщение было изменено" в чате
+        )
+
+        3, 4. Пока в тесте
+        3. Обновление с новыми вложениями:
+        api.answer_callback(
+            callback_id="callback123",
+            text="Вот новые вложения:",
+            attachments=[
+                {
+                    "type": "photo",
+                    "payload": {"url": "https://example.com/photo.jpg"}
+                }
+            ],
+            notification="Фотография добавлена"
+        )
+
+        4. Удаление всех вложений (оставить только текст):
+        api.answer_callback(
+            callback_id="callback123",
+            text="Вложения удалены",
+            attachments=[],  # Пустой список удалит все вложения
+            notification="Вложения удалены"
+        )
+        """
+        params = {"callback_id": callback_id}
+        data: Dict[str, Any] = {}
+
+        # Если нужно изменить сообщение (text, attachments, link, format)
+        if text is not None or attachments is not None or link is not None or format is not None:
+            msg: Dict[str, Any] = {"notify": notify}
+            if text is not None:
+                msg["text"] = text
+            if attachments is not None:
+                msg["attachments"] = attachments
+            if link is not None:
+                msg["link"] = link
+            if format is not None:
+                msg["format"] = format
+            data["message"] = msg
+
+        # Если нужно отправить уведомление
+        if notification is not None:
+            data["notification"] = notification
+
+        print(f"Answer params: {params}")
+        print(f"Answer data: {data}")
+
+        # Если data пустой, отправляем пустой объект
+        if not data:
+            data = {}
+
+        return self.client.request("POST", "/answers", params=params, data=data)

maxibot/core/attachments/photo.py

@@ -0,0 +1,45 @@
+from typing import Any, Union
+
+from ...apihelper import Api
+
+
+class Photo:
+    """
+    Класс формирования объекта attachments для метода MaxiBot.send_photo
+    """
+
+    def __init__(self, photo: Union[Any, str], api: Api):
+        try:
+            self.api = api
+            self.photo = photo
+            upload_url = self._get_upload_url().get("url")
+            if not upload_url:
+                return []
+            load_file_result = self._load_file_to_max(url=upload_url)
+            self.token_dict = list(list(load_file_result.values())[0].values())[0]
+        except Exception:
+            return []
+
+    def _get_upload_url(self, type_attach: str = "image"):
+        """
+        Шаг 1.
+        Метод получения url для загрузки фото
+        """
+        return self.api.get_upload_file_url(type_attach=type_attach)
+
+    def _load_file_to_max(self, url: str):
+        """
+        Шаг 2.
+        Метод загрузки файла по url для загрузки фото
+        """
+        files = {"data": self.photo}
+        return self.api.load_file(url=url, files=files)
+
+    def to_dict(self):
+        """
+        Метод формирования необходимого для API MAX форматат attachments для image
+        """
+        return {
+            "type": "image",
+            "payload": self.token_dict
+        }

maxibot/core/network/client.py

@@ -0,0 +1,118 @@
+import requests
+import json
+
+from typing import Dict, Any, Optional
+
+
+class Client:
+    """
+    Класс низкоуровневых запросов к API MAX
+    """
+    # BASE_URL = "https://botapi.max.ru"
+    BASE_URL = "https://platform-api.max.ru"
+
+    def __init__(self, token: str, proxy: Optional[dict] = {"https": "", "http": ""}):
+        """
+        Инициализация клиента
+
+        :param token: Description
+        :type token: str
+        """
+        self.token = token
+        self.proxy = proxy
+        self.session = requests.Session()
+
+    def _make_url(self, path: str) -> str:
+        """
+        Метод формирует полную ссылку к API запросу
+
+        :param path: API метод
+        :type path: str
+        :return: Полный URL запроса к API
+        :rtype: str
+        """
+        url = f"{self.BASE_URL}{path}"
+        # if "?" in url:
+        #     url += f"&access_token={self.token}"
+        # else:
+        #     url += f"?access_token={self.token}"
+        return url
+
+    def request(
+        self,
+        method: str,
+        path: str = None,
+        url: str = None,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[Dict[str, Any]] = None,
+        content_types: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Главные метод по отправке запроса к API MAX
+
+        :param method: HTTP-метод (GET, POST, PUT, DELETE)
+        :type method: str
+
+        :param path: Путь к методу API
+        :type path: str
+
+        :param params: Параметры запроса
+        :type params: Optional[Dict[str, Any]]
+
+        :param data: Данные для отправки в теле запроса
+        :type data: Optional[Dict[str, Any]]
+
+        :param files: Файлы для отправкиescription
+        :type files: Optional[Dict[str, Any]]
+
+        :return: Ответ API MAX на заданный метод
+        :rtype: Dict[str, Any]
+        """
+        url = self._make_url(path) if not url else url
+        header = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 "
+                          "(KHTML, like Gecko) Chrome/41.0.2272.101 Safari/537.36",
+            "Authorization": self.token
+        }
+        if content_types:
+            header["Content-Type"] = content_types
+        if data and not files:
+            header["Content-Type"] = "application/json"
+            data = json.dumps(data)
+        # print(f"Request: {method} {url}")
+        # if params:
+        # print(f"Params: {params}")
+        # if data:
+        # print(f"Data: {data}")
+
+        response = self.session.request(
+            method=method,
+            url=url,
+            params=params,
+            data=data,
+            files=files,
+            headers=header,
+            verify=False,
+            proxies=self.proxy,
+            timeout=60
+        )
+        try:
+            response.raise_for_status()
+            result = response.json()
+            # print(f"Response: {result}")
+            return result
+        except requests.exceptions.HTTPError as e:
+            error_text = f"HTTP error: {e}"
+            try:
+                error_json = response.json()
+                error_text = f"{error_text}, API response: {error_json}"
+            except Exception:
+                error_text = f"{error_text}, Response text: {response.text}"
+
+            print(error_text)
+            # raise Exception(error_text)
+            return error_text
+        except Exception as e:
+            print(f"Request error: {e}")
+            raise

maxibot/core/network/polling.py

@@ -0,0 +1,75 @@
+import asyncio
+import traceback
+
+from typing import Callable, List, Optional, Dict, Any
+
+# from api import Api
+
+
+class Polling:
+    """
+    Класс получения обновлений из API MAX через поллинг
+    """
+
+    def __init__(self, api, allowed_updates: Optional[List[str]] = None):
+        """
+        Инициализация класса
+
+        :param api: Клиент АПИ
+        :type api: Api
+
+        :param allowed_updates: Клиент АПИ
+        :type allowed_updates: Optional[List[str]]
+        """
+        self.api = api
+        self.allowed_updates = allowed_updates
+        self.is_running = False
+        self.marker = None
+
+    def stop(self):
+        """
+        Метод остановки поллинга
+        """
+        self.is_running = False
+
+    async def loop(self, handler: Callable[[Dict[str, Any]], None]):
+        """
+        Главный цикл поллинга
+
+        :param handler: Description
+        :type handler: Callable[[Dict[str, Any]], None]
+        """
+        self.is_running = True
+        print("Starting polling loop")
+
+        while self.is_running:
+            try:
+                updates_data = await self._get_updates()
+                if "marker" in updates_data.keys():
+                    self.marker = updates_data["marker"]
+                updates = updates_data.get("updates", [])
+                for update in updates:
+                    try:
+                        handler(update)
+                    except Exception:
+                        print(f"Error handling update {traceback.format_exc()}")
+
+            except Exception:
+                print(f"Some error in get updates {traceback.format_exc()}")
+
+    async def _get_updates(self) -> Dict[str, Any]:
+        """
+        Метод получения обновлений по боту из API MAX
+
+        :return: Description
+        :rtype: Dict[str, Any]
+        """
+        params = {}
+        if self.marker is not None:
+            params["marker"] = self.marker
+        updates_data = await asyncio.to_thread(
+            self.api.get_updates,
+            self.allowed_updates or [],
+            params
+        )
+        return updates_data