maxbot-api-client-python 1.1.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

maxbot_api_client_python/tools/helpers.py

@@ -1,10 +1,12 @@
-import aiofiles, asyncio, httpx, logging, mimetypes, os, time
+import aiofiles, asyncio, httpx, logging, mimetypes, os, time, re
+from aiofiles import tempfile
 from typing import Any, List, Optional
 from urllib.parse import urlparse
 from pathlib import Path
 
+from maxbot_api_client_python.exceptions import MaxBotError
 from maxbot_api_client_python.tools.uploads import Uploads
-from maxbot_api_client_python.client import Client, decode, adecode
+from maxbot_api_client_python.client import Client
 from maxbot_api_client_python.types.constants import AttachmentType, Paths, UploadType
 from maxbot_api_client_python.types.models import Message, SendFileReq, SendMessageReq, UploadFileReq, Attachment
 
@@ -15,66 +17,73 @@ class Helpers:
         self.client = client
         self.uploads = Uploads(client)
 
-    def SendFile(self, **kwargs) -> Optional[Message]:
+    def send_file(self, req: SendFileReq) -> Optional[Message]:
         """
         A helper that simplifies sending files to a chat.
         It automatically determines whether the provided file_source is a direct URL or a local file path.
 
         Example:
             # Sending a file via URL:
-            response = api.helpers.SendFile(
+            response = bot.helpers.send_file(SendFileReq(
                 chat_id=123456789,
                 text="Check out this image!",
                 file_source="https://example.com/image.png"
-            )
+            ))
 
             # Sending a local file:
-            response = api.helpers.SendFile(
+            response = bot.helpers.send_file(SendFileReq(
                 chat_id=123456789,
                 text="Here is the report.",
                 file_source="/local/path/to/report.pdf"
-            )
+            ))
         """
-        req = SendFileReq(**kwargs)
-        if self._is_url(req.file_source):
-            return self.sendFileByUrl(req)
-        return self.sendFileByUpload(req)
+        is_url = urlparse(req.file_source).scheme in ("http", "https")
+        if not is_url and not os.path.exists(req.file_source):
+            raise ValueError("Invalid file path or URL.")
+        
+        if urlparse(req.file_source).scheme in ("http", "https"):
+            return self._send_file_by_url(req)
+            
+        return self._send_file_by_upload(req)
 
-    def sendFileByUrl(self, req: SendFileReq) -> Optional[Message]:
+    def _send_file_by_url(self, req: SendFileReq) -> Optional[Message]:
         ext = self._get_extension(req.file_source)
         upload_type = self._determine_upload_type(ext)
 
         if upload_type == UploadType.IMAGE:
             attachment = Attachment(type=AttachmentType.IMAGE, payload={"url": req.file_source})
-            return self.sendFileInternal(req, attachment)
+            return self._send_file_internal(req, attachment)
 
         temp_path = None
         try:
             temp_path = self._download_temp_file(req.file_source)
-            req.file_source = temp_path
-            return self.sendFileByUpload(req)
+            req_copy = req.model_copy(update={"file_source": temp_path})
+            return self._send_file_by_upload(req_copy)
         except Exception as e:
             logger.error(f"File processing/upload error: {e}")
-            return None
+            raise
         finally:
-            if temp_path and os.path.exists(temp_path):
-                os.remove(temp_path)
+            if temp_path:
+                try:
+                    os.remove(temp_path)
+                except FileNotFoundError:
+                    pass
 
-    def sendFileByUpload(self, req: SendFileReq) -> Optional[Message]:
+    def _send_file_by_upload(self, req: SendFileReq) -> Optional[Message]:
         ext = self._get_extension(req.file_source)
         upload_type = self._determine_upload_type(ext)
 
         upload_req = UploadFileReq(type=upload_type, file_path=req.file_source)
-        upload_resp = self.uploads.UploadFile(**upload_req.model_dump_json(indent=4))
+        upload_resp = self.uploads.upload_file(upload_req)
 
         if not upload_resp or not upload_resp.token:
             logger.error("Upload failed: No token returned.")
             return None
 
         attachment = self._build_attachment_from_token(upload_type, upload_resp.token, Path(req.file_source).name)
-        return self.sendFileInternal(req, attachment)
+        return self._send_file_internal(req, attachment)
 
-    def sendFileInternal(self, req: SendFileReq, attachment: Attachment) -> Message:
+    def _send_file_internal(self, req: SendFileReq, attachment: Attachment) -> Message:
         attachments: List[Attachment] = req.attachments or []
         attachments.append(attachment)
 
@@ -89,13 +98,15 @@ class Helpers:
             disable_link_preview=req.disable_link_preview
         )
 
+        query, payload = self.client.split_request(request_data)
         last_err: Optional[Exception] = None
+        
         for _ in range(self.client.max_retries):
             try:
-                return decode(self.client, "POST", Paths.MESSAGES, Message, query=request_data.model_dump(exclude_none=True), payload=request_data)
-            except Exception as e:
+                return self.client.decode("POST", Paths.MESSAGES, Message, query=query, payload=payload)
+            except MaxBotError as e:
                 last_err = e
-                if "not.ready" in str(e).lower():
+                if e.status_code == 422 or "not.ready" in str(e.response).lower():
                     time.sleep(self.client.retry_delay_sec)
                     continue
                 break
@@ -104,73 +115,80 @@ class Helpers:
             raise last_err
         raise Exception("Unknown error in sendFileInternal")
 
-    async def SendFileAsync(self, **kwargs) -> Optional[Message]:
+    async def send_file_async(self, req: SendFileReq) -> Optional[Message]:
         """
-        Async version of SendFile.
+        Async version of send_file.
 
         Example:
         # Sending a local file asynchronously:
-        response = await api.helpers.SendFileAsync(
+        response = await bot.helpers.send_file_async(SendFileReq(
             chat_id=123456789,
             text="Here is the report.",
             file_source="/local/path/to/report.pdf"
-        )
+        ))
         """
-        req = SendFileReq(**kwargs)
-        if self._is_url(req.file_source):
-            return await self.sendFileByUrlAsync(req)
-        return await self.sendFileByUploadAsync(req)
+        if urlparse(req.file_source).scheme in ("http", "https"):
+            return await self._send_file_by_url_async(req)
+            
+        return await self._send_file_by_upload_async(req)
 
-    async def sendFileByUrlAsync(self, req: SendFileReq) -> Optional[Message]:
+    async def _send_file_by_url_async(self, req: SendFileReq) -> Optional[Message]:
         ext = self._get_extension(req.file_source)
         upload_type = self._determine_upload_type(ext)
 
         if upload_type == UploadType.IMAGE:
             attachment = Attachment(type=AttachmentType.IMAGE, payload={"url": req.file_source})
-            return await self.sendFileInternalAsync(req, attachment)
+            return await self._send_file_internal_async(req, attachment)
 
         temp_path = None
         try:
             temp_path = await self._download_temp_file_async(req.file_source)
-            req.file_source = temp_path
-            return await self.sendFileByUploadAsync(req)
+            req_copy = req.model_copy(update={"file_source": temp_path})
+            return await self._send_file_by_upload_async(req_copy)
         except Exception as e:
             logger.error(f"Async file processing/upload error: {e}")
-            return None
+            raise
         finally:
             if temp_path and os.path.exists(temp_path):
-                await asyncio.to_thread(os.remove, temp_path)
+                try:
+                    await aiofiles.os.remove(temp_path)
+                except OSError as e:
+                    logger.error(f"Failed to cleanup temp file: {e}")
 
-    async def sendFileByUploadAsync(self, req: SendFileReq) -> Optional[Message]:
+    async def _send_file_by_upload_async(self, req: SendFileReq) -> Optional[Message]:
         ext = self._get_extension(req.file_source)
         u_type = self._determine_upload_type(ext)
 
         upload_req = UploadFileReq(type=u_type, file_path=req.file_source)
-        upload_resp = await self.uploads.UploadFileAsync(**upload_req.model_dump())
+        upload_resp = await self.uploads.upload_file_async(upload_req)
 
         if not upload_resp or not upload_resp.token:
             return None
 
         attachment = self._build_attachment_from_token(u_type, upload_resp.token, Path(req.file_source).name)
-        return await self.sendFileInternalAsync(req, attachment)
+        return await self._send_file_internal_async(req, attachment)
 
-    async def sendFileInternalAsync(self, req: SendFileReq, attachment: Attachment) -> Message:
+    async def _send_file_internal_async(self, req: SendFileReq, attachment: Attachment) -> Message:
         attachments: List[Attachment] = req.attachments or []
         attachments.append(attachment)
 
         request_data = SendMessageReq(
-            **req.model_dump(exclude={"file_source", "attachments"}),
-            attachments=attachments
+            user_id=req.user_id,
+            chat_id=req.chat_id,
+            text=req.text,
+            format=req.format,
+            attachments=attachments,
+            notify=req.notify,
+            link=req.link,
+            disable_link_preview=req.disable_link_preview
         )
 
+        query, payload = self.client.split_request(request_data)
         last_err: Optional[Exception] = None
+        
         for _ in range(self.client.max_retries):
             try:
-                return await adecode(
-                    self.client, "POST", Paths.MESSAGES, Message, 
-                    query=request_data.model_dump(exclude_none=True), 
-                    payload=request_data
-                )
+                return await self.client.adecode("POST", Paths.MESSAGES, Message, query=query, payload=payload)
             except Exception as e:
                 last_err = e
                 if "not.ready" in str(e).lower():
@@ -181,13 +199,6 @@ class Helpers:
         if last_err:
             raise last_err
         raise Exception("Unknown error in sendFileInternalAsync")
-        
-    def _is_url(self, source: str) -> bool:
-        try:
-            result = urlparse(source)
-            return all([result.scheme, result.netloc])
-        except ValueError:
-            return False
 
     def _get_extension(self, source: str) -> str:
         parsed = urlparse(source)
@@ -202,6 +213,10 @@ class Helpers:
         if ext in {".mp3", ".ogg", ".wav"}:
             return UploadType.AUDIO
         return UploadType.FILE
+    
+    def _sanitize_filename(self, filename: str) -> str:
+        base = os.path.basename(filename)
+        return re.sub(r'[^a-zA-Z0-9.\-_]', '_', base)
 
     def _build_attachment_from_token(self, u_type: UploadType, token: str, filename: str) -> Attachment:
         payload: dict[str, Any] = {"token": token}
@@ -211,14 +226,16 @@ class Helpers:
 
     def _download_temp_file(self, url_str: str) -> str:
         headers = {"User-Agent": "maxbot-client/1.0"}
-        with httpx.Client() as client:
-            with client.stream("GET", url_str, headers=headers, follow_redirects=True) as resp:
+        with httpx.Client(follow_redirects=True, max_redirects=3) as client:
+            with client.stream("GET", url_str, headers=headers) as resp:
                 resp.raise_for_status() 
 
                 content_disp = resp.headers.get("Content-Disposition", "")
                 filename = None
                 if "filename=" in content_disp:
-                    filename = content_disp.split("filename=")[1].strip('"')
+                    raw_part = content_disp.split("filename=")[1].split(";")[0]
+                    raw_filename = raw_part.strip('"').strip("'")
+                    filename = self._sanitize_filename(raw_filename)
                 
                 if not filename:
                     content_type = resp.headers.get("Content-Type", "")
@@ -227,14 +244,17 @@ class Helpers:
                         filename = f"file{ext}"
 
                 if not filename:
-                    filename = Path(urlparse(url_str).path).name or "temp_file.bin"
-
-                temp_path = f"temp_{int(time.time())}_{filename}"
-
-                with open(temp_path, "wb") as f:
-                    for chunk in resp.iter_bytes(chunk_size=8192):
-                        f.write(chunk)
-                return temp_path
+                    filename = os.path.basename(Path(urlparse(url_str).path).name) or "temp_file.bin"
+
+                fd, temp_path = tempfile.mkstemp(prefix="temp_", suffix=f"_{os.path.basename(filename)}")
+                try:
+                    with os.fdopen(fd, "wb") as f:
+                        for chunk in resp.iter_bytes(chunk_size=8192):
+                            f.write(chunk)
+                    return temp_path
+                except Exception:
+                    os.remove(temp_path)
+                    raise
     
     async def _download_temp_file_async(self, url_str: str) -> str:
         headers = {"User-Agent": "maxbot-client/1.0"}
@@ -245,13 +265,15 @@ class Helpers:
                 content_type = resp.headers.get("Content-Type", "").split(";")[0]
                 extension = mimetypes.guess_extension(content_type) or ".bin"
 
-                url_path_name = Path(urlparse(url_str).path).name
+                url_path_name = os.path.basename(Path(urlparse(url_str).path).name)
                 if url_path_name == "uc" or not url_path_name:
                     filename = f"file{extension}"
                 else:
                     filename = url_path_name if "." in url_path_name else f"{url_path_name}{extension}"
 
-                temp_path = f"temp_{int(time.time())}_{filename}"
+                temp_file = tempfile.NamedTemporaryFile(prefix="temp_", suffix=f"_{os.path.basename(filename)}", delete=False)
+                temp_path = temp_file.name
+                temp_file.close()
 
                 async with aiofiles.open(temp_path, "wb") as f:
                     async for chunk in resp.aiter_bytes(chunk_size=8192):

maxbot_api_client_python/tools/messages.py

@@ -1,194 +1,200 @@
-from maxbot_api_client_python.client import Client, decode, adecode
+from typing import Any
+
+from maxbot_api_client_python.client import Client
 from maxbot_api_client_python.types.constants import Paths
-from maxbot_api_client_python.types import models
+from maxbot_api_client_python.types.models import (
+    AnswerCallbackReq, DeleteMessageReq, EditMessageReq, GetMessageReq, GetMessagesReq, 
+    GetVideoInfoReq, GetVideoInfoResp, Message, MessagesList, SendMessageReq, 
+    SendMessageResp, SimpleQueryResult, NewMessageBody
+)
 
 class Messages:
     def __init__(self, client: Client):
         self.client = client
 
-    def GetMessages(self, **kwargs) -> models.MessagesList:
+    def get_messages(self, req: GetMessagesReq) -> MessagesList:
         """
         Retrieves a list of messages.
         It can fetch messages belonging to a specific ChatID or by an exact list of MessageIDs.
 
         Example:
             # Fetch messages by Chat ID
-            response = api.messages.GetMessages(chat_id=123456)
+            response = bot.messages.get_messages(GetMessagesReq(chat_id=123456))
             
             # Fetch specific messages:
-            response = api.messages.GetMessages(message_ids=["mid:1", "mid:2"])
+            response = bot.messages.get_messages(GetMessagesReq(message_ids=["mid:1", "mid:2"]))
         """
-        req = models.GetMessagesReq(**kwargs)
-        return decode(self.client, "GET", Paths.MESSAGES, models.MessagesList, query=req.model_dump(exclude_none=True))
+        query, payload = self.client.split_request(req)
+        return self.client.decode("GET", Paths.MESSAGES, MessagesList, query=query, payload=payload)
 
-    def SendMessage(self, **kwargs) -> models.SendMessageResp:
+    def send_message(self, req: SendMessageReq) -> SendMessageResp:
         """
         Sends a text message or attachment to a specific user or chat.
         If Notify is False, no push notification will be sent to the user.
 
         Example:
-            response = api.messages.SendMessage(
+            response = bot.messages.send_message(SendMessageReq(
                 chat_id=123456,
                 text="Hello, world!",
                 notify=True
-            )
+            ))
         """
-        req = models.SendMessageReq(**kwargs)
-        return decode(self.client, "POST", Paths.MESSAGES, models.SendMessageResp, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("POST", Paths.MESSAGES, SendMessageResp, query=query, payload=payload)
 
-    def EditMessage(self, **kwargs) -> models.SimpleQueryResult:
+    def edit_message(self, req: EditMessageReq) -> SimpleQueryResult:
         """
         Modifies the content of a previously sent message.
 
         Example:
-            response = api.messages.EditMessage(
+            response = bot.messages.edit_message(EditMessageReq(
                 message_id="mid:987654321...",
                 text="Updated message text!",
                 format="HTML"
-            )
+            ))
         """
-        req = models.EditMessageReq(**kwargs)
-        return decode(self.client, "PUT", Paths.MESSAGES, models.SimpleQueryResult, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("PUT", Paths.MESSAGES, SimpleQueryResult, query=query, payload=payload)
 
-    def DeleteMessage(self, **kwargs) -> models.SimpleQueryResult:
+    def delete_message(self, req: DeleteMessageReq) -> SimpleQueryResult:
         """
         Removes a previously sent message by its ID.
 
         Example:
-            response = api.messages.DeleteMessage(
+            response = bot.messages.delete_message(DeleteMessageReq(
                 message_id="mid:987654321..."
-            )
+            ))
         """
-        req = models.DeleteMessageReq(**kwargs)
-        return decode(self.client, "DELETE", Paths.MESSAGES, models.SimpleQueryResult, query=req.model_dump(exclude_none=True))
+        query, payload = self.client.split_request(req)
+        return self.client.decode("DELETE", Paths.MESSAGES, SimpleQueryResult, query=query, payload=payload)
 
-    def GetMessage(self, **kwargs) -> models.Message:
+    def get_message(self, req: GetMessageReq) -> Message:
         """
         Retrieves full information about a message by its ID.
 
         Example:
-            response = api.messages.GetMessage(
+            response = bot.messages.get_message(GetMessageReq(
                 message_id="mid:987654321..."
-            )
+            ))
         """
-        req = models.GetMessageReq(**kwargs)
         path = f"{Paths.MESSAGES}/{req.message_id}"
-        return decode(self.client, "GET", path, models.Message)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("GET", path, Message, query=query, payload=payload)
 
-    def GetVideoInfo(self, **kwargs) -> models.GetVideoInfoResp:
+    def get_video_info(self, req: GetVideoInfoReq) -> GetVideoInfoResp:
         """
         Retrieves metadata and the processing status for an uploaded video.
 
         Example:
-            response = api.messages.GetVideoInfo(
+            response = bot.messages.get_video_info(GetVideoInfoReq(
                 video_token="vtok_abc123xyz..."
-            )
+            ))
         """
-        req = models.GetVideoInfoReq(**kwargs)
         path = f"{Paths.VIDEOS}/{req.video_token}"
-        return decode(self.client, "GET", path, models.GetVideoInfoResp)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("GET", path, GetVideoInfoResp, query=query, payload=payload)
 
-    def AnswerCallback(self, **kwargs) -> models.SimpleQueryResult:
+    def answer_callback(self, req: AnswerCallbackReq) -> SimpleQueryResult:
         """
         Acknowledges and responds to a user clicking an inline button.
 
         Example:
-            response = api.messages.AnswerCallback(
+            response = bot.messages.answer_callback(AnswerCallbackReq(
                 callback_id="cbk_12345...",
                 message=NewMessageBody(text="Action confirmed!")
-            )
+            ))
         """
-        req = models.AnswerCallbackReq(**kwargs)
-        return decode(self.client, "POST", Paths.ANSWERS, models.SimpleQueryResult, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("POST", Paths.ANSWERS, SimpleQueryResult, query=query, payload=payload)
 
-    async def GetMessagesAsync(self, **kwargs) -> models.MessagesList:
-        """Async version of GetMessages.
+    async def get_messages_async(self, req: GetMessagesReq) -> MessagesList:
+        """Async version of get_messages.
 
         Example:
             # Fetch messages by Chat ID
-            response = await api.messages.GetMessagesAsync(chat_id=123456)
+            response = await bot.messages.get_messages_async(GetMessagesReq(chat_id=123456))
             
             # Fetch specific messages:
-            response = await api.messages.GetMessagesAsync(message_ids=["mid:1", "mid:2"])
+            response = await bot.messages.get_messages_async(GetMessagesReq(message_ids=["mid:1", "mid:2"]))
         """
-        req = models.GetMessagesReq(**kwargs)
-        return await adecode(self.client, "GET", Paths.MESSAGES, models.MessagesList, query=req.model_dump(exclude_none=True))
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("GET", Paths.MESSAGES, MessagesList, query=query, payload=payload)
 
-    async def SendMessageAsync(self, **kwargs) -> models.SendMessageResp:
+    async def send_message_async(self, req: SendMessageReq) -> SendMessageResp:
         """
-        Async version of SendMessage.
+        Async version of send_message.
 
         Example:
-            response = await api.messages.SendMessageAsync(
+            response = await bot.messages.send_message_async(SendMessageReq(
                 chat_id=123456,
                 text="Hello, world!",
                 notify=True
-            )
+            ))
         """
-        req = models.SendMessageReq(**kwargs)
-        return await adecode(self.client, "POST", Paths.MESSAGES, models.SendMessageResp, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("POST", Paths.MESSAGES, SendMessageResp, query=query, payload=payload)
 
-    async def EditMessageAsync(self, **kwargs) -> models.SimpleQueryResult:
+    async def edit_message_async(self, req: EditMessageReq) -> SimpleQueryResult:
         """
-        Async version of EditMessage.
+        Async version of edit_message.
 
         Example:
-            response = await api.messages.EditMessageAsync(
+            response = await bot.messages.edit_message_async(EditMessageReq(
                 message_id="mid:987654321...",
                 text="Updated message text!",
                 format="HTML"
-            )
+            ))
         """
-        req = models.EditMessageReq(**kwargs)
-        return await adecode(self.client, "PUT", Paths.MESSAGES, models.SimpleQueryResult, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("PUT", Paths.MESSAGES, SimpleQueryResult, query=query, payload=payload)
 
-    async def DeleteMessageAsync(self, **kwargs) -> models.SimpleQueryResult:
+    async def delete_message_async(self, req: DeleteMessageReq) -> SimpleQueryResult:
         """
-        Async version of DeleteMessage.
+        Async version of delete_message.
 
         Example:
-            response = await api.messages.DeleteMessageAsync(
+            response = await bot.messages.delete_message_async(DeleteMessageReq(
                 message_id="mid:987654321..."
-            )
+            ))
         """
-        req = models.DeleteMessageReq(**kwargs)
-        return await adecode(self.client, "DELETE", Paths.MESSAGES, models.SimpleQueryResult, query=req.model_dump(exclude_none=True))
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("DELETE", Paths.MESSAGES, SimpleQueryResult, query=query, payload=payload)
 
-    async def GetMessageAsync(self, **kwargs) -> models.Message:
+    async def get_message_async(self, req: GetMessageReq) -> Message:
         """
-        Async version of GetMessage.
+        Async version of get_message.
 
         Example:
-            response = await api.messages.GetMessageAsync(
+            response = await bot.messages.get_message_async(GetMessageReq(
                 message_id="mid:987654321..."
-            )
+            ))
         """
-        req = models.GetMessageReq(**kwargs)
         path = f"{Paths.MESSAGES}/{req.message_id}"
-        return await adecode(self.client, "GET", path, models.Message)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("GET", path, Message, query=query, payload=payload)
 
-    async def GetVideoInfoAsync(self, **kwargs) -> models.GetVideoInfoResp:
+    async def get_video_info_async(self, req: GetVideoInfoReq) -> GetVideoInfoResp:
         """
-        Async version of GetVideoInfo.
+        Async version of get_video.
 
         Example:
-            response = await api.messages.GetVideoInfoAsync(
+            response = await bot.messages.get_video_info_async(GetVideoInfoReq(
                 video_token="vtok_abc123xyz..."
-            )
+            ))
         """
-        req = models.GetVideoInfoReq(**kwargs)
         path = f"{Paths.VIDEOS}/{req.video_token}"
-        return await adecode(self.client, "GET", path, models.GetVideoInfoResp)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("GET", path, GetVideoInfoResp, query=query, payload=payload)
 
-    async def AnswerCallbackAsync(self, **kwargs) -> models.SimpleQueryResult:
+    async def answer_callback_async(self, req: AnswerCallbackReq) -> SimpleQueryResult:
         """
-        Async version of AnswerCallback.
+        Async version of answer_callback.
 
         Example:
-            response = await api.messages.AnswerCallbackAsync(
+            response = await bot.messages.answer_callback_async(AnswerCallbackReq(
                 callback_id="cbk_12345...",
                 message=NewMessageBody(text="Action confirmed!")
-            )
+            ))
         """
-        req = models.AnswerCallbackReq(**kwargs)
-        return await adecode(self.client, "POST", Paths.ANSWERS, models.SimpleQueryResult, query=req.model_dump(exclude_none=True), payload=req)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("POST", Paths.ANSWERS, SimpleQueryResult, query=query, payload=payload)