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

maxbot_api_client_python/tools/subscriptions.py

@@ -1,101 +1,109 @@
-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 GetSubscriptionsResp, GetUpdatesReq, GetUpdatesResp, SimpleQueryResult, SubscribeReq, UnsubscribeReq
 
 class Subscriptions:
     def __init__(self, client: Client):
         self.client = client
 
-    def GetSubscriptions(self) -> models.GetSubscriptionsResp:
+    def get_subscriptions(self) -> GetSubscriptionsResp:
         """
         Returns a list of all subscriptions if your bot receives data via a Webhook.
 
         Example:
-            response = api.subscriptions.GetSubscriptions()
+            response = bot.subscriptions.get_subscriptions()
         """
-        return decode(self.client, "GET", Paths.SUBSCRIPTIONS, models.GetSubscriptionsResp)
+        return self.client.decode("GET", Paths.SUBSCRIPTIONS, GetSubscriptionsResp)
 
-    def Subscribe(self, **kwargs) -> models.SimpleQueryResult:
+    def subscribe(self, **kwargs: Any) -> SimpleQueryResult:
         """
         Configures the delivery of bot events via Webhook.
 
         Example:
-            response = api.subscriptions.Subscribe(
+            response = bot.subscriptions.subscribe(
                 url="https://webhook.site/endpoint"
             )
         """
-        req = models.SubscribeReq(**kwargs)
-        return decode(self.client, "POST", Paths.SUBSCRIPTIONS, models.SimpleQueryResult, payload=req)
+        req = SubscribeReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("POST", Paths.SUBSCRIPTIONS, SimpleQueryResult, query=query, payload=payload)
 
-    def Unsubscribe(self, **kwargs) -> models.SimpleQueryResult:
+    def unsubscribe(self, **kwargs: Any) -> SimpleQueryResult:
         """
         Unsubscribes the bot from receiving updates via Webhook.
 
         Example:
-            response = api.subscriptions.Unsubscribe(
+            response = bot.subscriptions.unsubscribe(
                 url="https://webhook.site/endpoint"
             )
         """
-        req = models.UnsubscribeReq(**kwargs)
-        return decode(self.client, "DELETE", Paths.SUBSCRIPTIONS, models.SimpleQueryResult, query=req.model_dump(exclude_none=True))
+        req = UnsubscribeReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("DELETE", Paths.SUBSCRIPTIONS, SimpleQueryResult, query=query, payload=payload)
 
-    def GetUpdates(self, **kwargs) -> models.GetUpdatesResp:
+    def get_updates(self, **kwargs: Any) -> GetUpdatesResp:
         """
         Fetches new events (incoming messages, bot additions, etc.) from the server.
         Use this method for long-polling. Provide a Marker to acknowledge previous 
         updates and fetch only new ones.
 
         Example:
-            response = api.subscriptions.GetUpdates(
+            response = bot.subscriptions.get_updates(
                 marker=123456789,
                 timeout=30  # seconds to wait for new updates
             )
         """
-        req = models.GetUpdatesReq(**kwargs)
-        return decode(self.client, "GET", Paths.UPDATES, models.GetUpdatesResp, query=req.model_dump(exclude_none=True))
+        req = GetUpdatesReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return self.client.decode("GET", Paths.UPDATES, GetUpdatesResp, query=query, payload=payload)
 
-    async def GetSubscriptionsAsync(self) -> models.GetSubscriptionsResp:
+    async def get_subscriptions_async(self) -> GetSubscriptionsResp:
         """
-        Async version of GetSubscriptions.
+        Async version of get_subscriptions.
 
         Example:
-            response = await api.subscriptions.GetSubscriptionsAsync()
+            response = await bot.subscriptions.get_subscriptions_async()
         """
-        return await adecode(self.client, "GET", Paths.SUBSCRIPTIONS, models.GetSubscriptionsResp)
+        return await self.client.adecode("GET", Paths.SUBSCRIPTIONS, GetSubscriptionsResp)
 
-    async def SubscribeAsync(self, **kwargs) -> models.SimpleQueryResult:
+    async def subscribe_async(self, **kwargs: Any) -> SimpleQueryResult:
         """
-        Async version of Subscribe.
+        Async version of subscribe.
 
         Example:
-            response = await api.subscriptions.SubscribeAsync(
+            response = await bot.subscriptions.subscribe_async(
                 url="https://webhook.site/endpoint"
             )
         """
-        req = models.SubscribeReq(**kwargs)
-        return await adecode(self.client, "POST", Paths.SUBSCRIPTIONS, models.SimpleQueryResult, payload=req)
+        req = SubscribeReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("POST", Paths.SUBSCRIPTIONS, SimpleQueryResult, query=query, payload=payload)
     
-    async def UnsubscribeAsync(self, **kwargs) -> models.SimpleQueryResult:
+    async def unsubscribe_async(self, **kwargs: Any) -> SimpleQueryResult:
         """
-        Async version of Unsubscribe.
+        Async version of unsubscribe.
 
         Example:
-            response = await api.subscriptions.UnsubscribeAsync(
+            response = await bot.subscriptions.unsubscribe_async(
                 url="https://webhook.site/endpoint"
             )
         """
-        req = models.UnsubscribeReq(**kwargs)
-        return await adecode(self.client, "DELETE", Paths.SUBSCRIPTIONS, models.SimpleQueryResult, query=req.model_dump(exclude_none=True))
+        req = UnsubscribeReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("DELETE", Paths.SUBSCRIPTIONS, SimpleQueryResult, query=query, payload=payload)
     
-    async def GetUpdatesAsync(self, **kwargs) -> models.GetUpdatesResp:
+    async def get_updates_async(self, **kwargs: Any) -> GetUpdatesResp:
         """
-        Async version of GetUpdates.
+        Async version of get_updates.
 
         Example:
-            response = await api.subscriptions.GetUpdatesAsync(
+            response = await bot.subscriptions.get_updates_async(
                 marker=123456789,
                 timeout=30  # seconds to wait for new updates
             )
         """
-        req = models.GetUpdatesReq(**kwargs)
-        return await adecode(self.client, "GET", Paths.UPDATES, models.GetUpdatesResp, query=req.model_dump(exclude_none=True))
+        req = GetUpdatesReq(**kwargs)
+        query, payload = self.client.split_request(req)
+        return await self.client.adecode("GET", Paths.UPDATES, GetUpdatesResp, query=query, payload=payload)

maxbot_api_client_python/tools/uploads.py

@@ -1,10 +1,10 @@
 import asyncio, logging
 
 from pathlib import Path
-from typing import Optional
-from tenacity import retry, stop_after_attempt, wait_exponential
+from typing import Any, Optional
+from tenacity import AsyncRetrying, retry, stop_after_attempt, wait_exponential
 
-from maxbot_api_client_python.client import Client, decode
+from maxbot_api_client_python.client import Client
 from maxbot_api_client_python.types.constants import Paths, UploadType
 from maxbot_api_client_python.types.models import UploadedInfo, UploadFileReq, PhotoAttachmentRequestPayload
 
@@ -20,13 +20,13 @@ class Uploads:
         reraise=True,
     )
 
-    def UploadFile(self, **kwargs) -> UploadedInfo:
+    def upload_file(self, **kwargs: Any) -> UploadedInfo:
         """
         Uploads a file to the server and returns the upload metadata.
         It seamlessly handles both STEP 1 (obtaining the URL) and STEP 2 (streaming the file).
 
         Example:
-            response = api.uploads.UploadFile(
+            response = bot.uploads.upload_file(
                 type=UploadType.IMAGE,
                 file_path="/path/to/image.png"
             )
@@ -57,35 +57,61 @@ class Uploads:
 
     def get_upload_url(self, upload_type: UploadType) -> PhotoAttachmentRequestPayload:
         """Internal helper: Obtains the target URL for uploading."""
-        return decode(self.client, "POST", Paths.UPLOADS, PhotoAttachmentRequestPayload, query={"type": upload_type.value})
+        return self.client.decode("POST", Paths.UPLOADS, PhotoAttachmentRequestPayload, query={"type": upload_type.value})
 
     def upload_multipart(self, upload_url: str, file_path: str) -> Optional[UploadedInfo]:
         """Internal helper: Streams the file to the obtained URL."""
         path = Path(file_path)
         try:
             with open(path, "rb") as f:
-                files = {"file": (path.name, f)}
-                return decode(self.client, "POST", upload_url, UploadedInfo, files=files)
+                safe_name = path.name[:255]
+                files = {"file": (safe_name, f)}
+                return self.client.decode("POST", upload_url, UploadedInfo, files=files)
         except OSError as e:
             logger.error(f"Failed to read file for upload: {e}")
             return None
 
-    async def UploadFileAsync(self, **kwargs) -> UploadedInfo:
+    async def upload_file_async(self, **kwargs: Any) -> UploadedInfo:
         """
-        Async version of UploadFile.
+        Async version of upload_file.
 
         Example:
-            response = await api.uploads.UploadFileAsync(
+            response = await bot.uploads.upload_file_async(
                 type=UploadType.IMAGE,
                 file_path="/path/to/image.png"
             )
         """
-        return await asyncio.to_thread(self.UploadFile, **kwargs)
+        req = UploadFileReq(**kwargs)
+        async for attempt in AsyncRetrying(
+            stop=stop_after_attempt(3), 
+            wait=wait_exponential(multiplier=1, min=2, max=10),
+            reraise=True
+        ):
+            with attempt:
+                init_resp = await self.get_upload_url_async(req.type) 
+                if init_resp.url:
+                    if not req.file_path:
+                        raise ValueError("file_path must be provided for multipart uploads.")
+                    
+                    multipart_resp = await self.upload_multipart_async(init_resp.url, req.file_path)
+                    
+                    if multipart_resp:
+                        if multipart_resp.token:
+                            return multipart_resp
+
+                        if multipart_resp.photos:
+                            first_photo = next(iter(multipart_resp.photos.values()), None)
+                            if first_photo and first_photo.token:
+                                multipart_resp.token = first_photo.token
+                                return multipart_resp
+
+                if init_resp.token:
+                    return UploadedInfo(token=init_resp.token)
+                
+                raise Exception("Server did not return token after upload")
 
     async def get_upload_url_async(self, upload_type: UploadType) -> PhotoAttachmentRequestPayload:
-        """Async version of get_upload_url."""
-        return await asyncio.to_thread(self.get_upload_url, upload_type)
+        return await self.client.adecode("POST", Paths.UPLOADS, PhotoAttachmentRequestPayload, query={"type": upload_type.value})
 
     async def upload_multipart_async(self, upload_url: str, file_path: str) -> Optional[UploadedInfo]:
-        """Async version of upload_multipart."""
         return await asyncio.to_thread(self.upload_multipart, upload_url, file_path)

maxbot_api_client_python/types/constants.py

@@ -87,7 +87,7 @@ class SenderAction(str, Enum):
 
 class ChatAdminPermission(str, Enum):
     READ_ALL_MESSAGES = "read_all_messages"
-    ADD_REMOVE_USERS = "add_remove_members"
+    ADD_REMOVE_MEMBERS = "add_remove_members"
     ADD_ADMINS = "add_admins"
     CHANGE_CHAT_PHOTO = "change_chat_info"
     PIN_MESSAGE = "pin_message"

maxbot_api_client_python/types/models.py

@@ -6,6 +6,14 @@ from maxbot_api_client_python.types.constants import (
     LinkedMessageType, SenderAction, ChatAdminPermission, ButtonType, UploadType
 )
 
+class Config(BaseModel):
+    base_url: str
+    token: str
+    timeout: int = 35
+    ratelimiter: int = 25
+    max_retries: int = 3
+    retry_delay_sec: int = 3
+
 class MaxBotModel(BaseModel):
     model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)
 
@@ -14,10 +22,9 @@ class APIError(MaxBotModel):
     message: str
 
 class SimpleQueryResult(MaxBotModel):
-    success: bool = Field(..., alias="success")
+    success: bool = Field(True, alias="success")
     message: str | None = Field(None, alias="message")
 
-
 class User(MaxBotModel):
     user_id: int
     first_name: str
@@ -59,7 +66,6 @@ class Recipient(MaxBotModel):
     chat_type: ChatType
     user_id: int | None = None
 
-
 class Image(MaxBotModel):
     url: str
 
@@ -76,7 +82,6 @@ class StickerData(MaxBotModel):
     url: str | None = None
     code: str | None = None
 
-
 class MediaPayload(MaxBotModel):
     url: str | None = None
     token: str | None = None
@@ -142,7 +147,6 @@ class Attachment(MaxBotModel):
     latitude: float | None = None
     longitude: float | None = None
 
-
 class BotPatch(MaxBotModel):
     name: str | None = None
     username: str | None = None
@@ -150,7 +154,6 @@ class BotPatch(MaxBotModel):
     commands: list[BotCommand] | None = None
     photo: PhotoAttachmentRequestPayload | None = None
 
-
 class MarkupElement(MaxBotModel):
     type: MarkupType
     from_: int = Field(alias="from")
@@ -195,7 +198,6 @@ class Message(MaxBotModel):
 class MessagesList(MaxBotModel):
     messages: list[Message]
 
-
 class Chat(MaxBotModel):
     chat_id: int
     type: ChatType
@@ -226,10 +228,9 @@ class ChatInfo(MaxBotModel):
     is_public: bool
     link: str | None = None
     description: str | None = None
-    dialog_with_user: list[DialogWithUser] | None = None
+    dialog_with_user: DialogWithUser | None = None
     chat_message_id: str | None = None
-    pinned_message: list[Message] | None = None
-
+    pinned_message: Message | None = None
 
 class Callback(MaxBotModel):
     timestamp: int
@@ -258,73 +259,89 @@ class Subscription(MaxBotModel):
     time: int
     update_types: list[UpdateType] | None = None
 
-
 class GetChatsReq(MaxBotModel):
-    count: int | None = Field(None, alias="count")
-    marker: int | None = Field(None, alias="marker")
+    count: int | None = Field(None, alias="count", json_schema_extra={"in_query": True})
+    marker: int | None = Field(None, alias="marker", json_schema_extra={"in_query": True})
 
 class GetChatsResp(MaxBotModel):
     chats: list[Chat]
     marker: int | None = None
 
 class GetChatReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    # API Path: GET /chats/{chatId}
+    # Path parameters strictly use camelCase.
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class EditChatReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    # API Path: PATCH /chats/{chatId}
+    # Path parameters strictly use camelCase.
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
     icon: Image | None = None
     title: str | None = None
     pin: str | None = None
     notify: bool | None = None
 
 class DeleteChatReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    # API Path: DELETE /chats/{chatId}
+    # Path parameters strictly use camelCase.
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class SendActionReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    # API Path: POST /chats/{chatId}/actions
+    # Path parameters strictly use camelCase.
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
     action: SenderAction
 
 class PinMessageReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
     message_id: str
     notify: bool | None = None
 
 class UnpinMessageReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class GetPinnedMessageReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class GetChatMembershipReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class LeaveChatReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class GetChatAdminsReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
 
 class GetChatAdminsResp(MaxBotModel):
     members: list[ChatMember]
     marker: int | None = None
 
+class GetChatMembersResp(MaxBotModel):
+    members: list[ChatMember]
+    marker: int | None = None
+    
 class SetChatAdminsReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
     admins: list[ChatAdmin]
     marker: int | None = None
 
 class DeleteAdminReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
-    user_id: int = Field(..., alias="userId")
+    # API Path: DELETE /chats/{chatId}/members/admins/{userId}
+    # Both path parameters require camelCase according to the API specification.
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
+    user_id: int = Field(..., alias="userId", json_schema_extra={"in_path": True})
 
 class GetChatMembersReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
-    user_ids: list[int] | None = Field(None, alias="user_ids")
-    marker: int | None = Field(None, alias="marker")
-    count: int | None = Field(None, alias="count")
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
+    user_ids: list[int] | None = Field(None, alias="user_ids", json_schema_extra={"in_query": True})
+    marker: int | None = Field(None, alias="marker", json_schema_extra={"in_query": True})
+    count: int | None = Field(None, alias="count", json_schema_extra={"in_query": True})
 
 class AddMembersReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
+    # API Path: POST /chats/{chatId}/members
+    # Path uses camelCase ('chatId'). 
+    # Payload array must be strictly serialized as 'user_ids' (snake_case).
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
     user_ids: list[int] | None = None
 
 class FailedUserDetails(MaxBotModel):
@@ -336,33 +353,28 @@ class AddMembersResp(SimpleQueryResult):
     failed_user_details: list[FailedUserDetails] | None = Field(None, alias="failed_user_details")
 
 class DeleteMemberReq(MaxBotModel):
-    chat_id: int = Field(..., alias="chatId")
-    user_id: int = Field(..., alias="userId")
-    block: bool | None = Field(None, alias="block")
-
-
-class GetMessagesReq(MaxBotModel):
-    chat_id: int | None = Field(None, alias="chat_id")
-    message_ids: list[str] | None = Field(None, alias="message_ids")
-    from_: int | None = Field(None, alias="from")
-    to: int | None = Field(None, alias="to")
-    count: int | None = Field(None, alias="count")
+    # API Path: DELETE /chats/{chatId}/members?user_id={user_id}&block=true
+    # Mixed conventions: Path parameter is camelCase ('chatId'), 
+    # but query parameters use snake_case ('user_id').
+    chat_id: int = Field(..., alias="chatId", json_schema_extra={"in_path": True})
+    user_id: int = Field(..., alias="user_id", json_schema_extra={"in_query": True})
+    block: bool | None = Field(None, alias="block", json_schema_extra={"in_query": True})
 
 class SendMessageReq(MaxBotModel):
-    user_id: int | None = Field(None, alias="user_id")
-    chat_id: int | None = Field(None, alias="chat_id")
+    user_id: int | None = Field(None, alias="user_id", json_schema_extra={"in_query": True})
+    chat_id: int | None = Field(None, alias="chat_id", json_schema_extra={"in_query": True})
     text: str | None = None
     format: Format | None = None
     notify: bool | None = None
     attachments: list[Attachment] | None = None
     link: NewMessageLink | None = None
-    disable_link_preview: bool | None = Field(None, alias="disable_link_preview")
+    disable_link_preview: bool | None = Field(None, alias="disable_link_preview", json_schema_extra={"in_query": True})
 
 class SendMessageResp(MaxBotModel):
     message: Message
 
 class EditMessageReq(MaxBotModel):
-    message_id: str = Field(..., alias="message_id")
+    message_id: str = Field(..., alias="message_id", json_schema_extra={"in_query": True})
     text: str | None = None
     attachments: list[Attachment] | None = None
     link: NewMessageLink | None = None
@@ -370,10 +382,17 @@ class EditMessageReq(MaxBotModel):
     format: Format | None = None
 
 class DeleteMessageReq(MaxBotModel):
-    message_id: str = Field(..., alias="message_id")
+    message_id: str = Field(..., alias="message_id", json_schema_extra={"in_query": True})
 
 class GetMessageReq(MaxBotModel):
-    message_id: str = Field(..., alias="message_id")
+    message_id: str = Field(..., alias="message_id", json_schema_extra={"in_path": True})
+
+class GetMessagesReq(MaxBotModel):
+    chat_id: int | None = Field(None, alias="chat_id", json_schema_extra={"in_query": True})
+    message_ids: list[str] | None = Field(None, alias="message_ids", json_schema_extra={"in_query": True})
+    from_: int | None = Field(None, alias="from", json_schema_extra={"in_query": True})
+    to: int | None = Field(None, alias="to", json_schema_extra={"in_query": True})
+    count: int | None = Field(None, alias="count", json_schema_extra={"in_query": True})
 
 class VideoUrls(MaxBotModel):
     mp4_1080: str | None = None
@@ -391,7 +410,7 @@ class VideoInfo(MaxBotModel):
     url: str
 
 class GetVideoInfoReq(MaxBotModel):
-    video_token: str = Field(..., alias="video_token")
+    video_token: str = Field(..., alias="video_token", json_schema_extra={"in_path": True})
 
 class GetVideoInfoResp(MaxBotModel):
     token: str
@@ -402,22 +421,21 @@ class GetVideoInfoResp(MaxBotModel):
     duration: int | None = None
 
 class AnswerCallbackReq(MaxBotModel):
-    callback_id: str = Field(..., alias="callback_id")
+    callback_id: str = Field(..., alias="callback_id", json_schema_extra={"in_query": True})
     message: NewMessageBody | None = None
     notification: str | None = None
 
 class SendFileReq(MaxBotModel):
-    user_id: int | None = Field(None, alias="user_id")
-    chat_id: int | None = Field(None, alias="chat_id")
+    user_id: int | None = Field(None, alias="userId", json_schema_extra={"in_query": True})
+    chat_id: int | None = Field(None, alias="chatId", json_schema_extra={"in_query": True})
     text: str | None = None
     format: Format | None = None
     notify: bool | None = None
-    file_source: str
+    file_source: str = Field(..., json_schema_extra={"in_path": True})
     link: NewMessageLink | None = None
-    disable_link_preview: bool | None = Field(None, alias="disable_link_preview")
+    disable_link_preview: bool | None = Field(None, alias="disable_link_preview", json_schema_extra={"in_query": True})
     attachments: list[Attachment] | None = None
 
-
 class GetSubscriptionsResp(MaxBotModel):
     subscriptions: list[Subscription]
 
@@ -427,26 +445,25 @@ class SubscribeReq(MaxBotModel):
     secret: str | None = None
 
 class UnsubscribeReq(MaxBotModel):
-    url: str = Field(..., alias="url")
+    url: str = Field(..., alias="url", json_schema_extra={"in_query": True})
 
 class GetUpdatesReq(MaxBotModel):
-    limit: int | None = Field(None, alias="limit")
-    timeout: int | None = Field(None, alias="timeout")
-    marker: int | None = Field(None, alias="marker")
-    types: list[UpdateType] | None = Field(None, alias="types")
+    limit: int | None = Field(None, alias="limit", json_schema_extra={"in_query": True})
+    timeout: int | None = Field(None, alias="timeout", json_schema_extra={"in_query": True})
+    marker: int | None = Field(None, alias="marker", json_schema_extra={"in_query": True})
+    types: list[UpdateType] | None = Field(None, alias="types", json_schema_extra={"in_query": True})
 
 class GetUpdatesResp(MaxBotModel):
     updates: list[Update]
     marker: int
 
-
 class UploadFileReq(MaxBotModel):
-    type: UploadType = Field(..., alias="type")
-    upload_url: str | None = None
-    file_path: str | None = None
+    type: UploadType = Field(..., alias="type", json_schema_extra={"in_query": True})
+    upload_url: str | None = Field(None, json_schema_extra={"in_path": True})
+    file_path: str | None = Field(None, json_schema_extra={"in_path": True})
 
 class UploadTypeReq(MaxBotModel):
-    type: UploadType = Field(..., alias="type")
+    type: UploadType = Field(..., alias="type", json_schema_extra={"in_query": True})
 
 class UploadFileMultipartReq(MaxBotModel):
     upload_url: str

maxbot_api_client_python/utils.py

@@ -37,7 +37,9 @@ def attach_sticker(url: str | None = None, code: str | None = None) -> Attachmen
     )
 
 def attach_contact(name: str, phone: str, contact_id: int | None = None) -> Attachment:
-    vcf_info = f"BEGIN:VCARD\nVERSION:3.0\nFN:{name}\nTEL:{phone}\nEND:VCARD"
+    safe_name = name.replace("\n", " ").replace("\r", "")
+    safe_phone = phone.replace("\n", "").replace("\r", "")
+    vcf_info = f"BEGIN:VCARD\nVERSION:3.0\nFN:{safe_name}\nTEL:{safe_phone}\nEND:VCARD"
     return Attachment(
         type=AttachmentType.CONTACT,
         payload=ContactAttachmentPayload(