Update fastapi_app.py

fastapi_app.py

@@ -820,4 +820,797 @@ async def send_dice_endpoint(chat_id: int):
     return {"message_id": message.id}
 
 @app.post("/send_poll")
-async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anonymous: bool = False, type: str = "regular", allows_multiple_answers: bool = False, correct_option_id: int = None, explanation: str =
+async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anonymous: bool = False, type: str = "regular", allows_multiple_answers: bool = False, correct_option_id: int = None, explanation: str = None, explanation_parse_mode: str = None, open_period: int = None, close_date: int = None, is_closed: bool = False):
+       message = await bot_instance.send_poll(
+           chat_id,
+           question,
+           options,
+           is_anonymous=is_anonymous,
+           type=type,
+           allows_multiple_answers=allows_multiple_answers,
+           correct_option_id=correct_option_id,
+           explanation=explanation,
+           explanation_parse_mode=explanation_parse_mode,
+           open_period=open_period,
+           close_date=close_date,
+           is_closed=is_closed
+       )
+       return {"message_id": message.id}
+
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/create_chat_invite_link")
+   async def create_chat_invite_link_endpoint(chat_id: int, name: str = None, expire_date: int = None, member_limit: int = None, creates_join_request: bool = False):
+       invite_link = await bot_instance.create_chat_invite_link(
+           chat_id,
+           name=name,
+           expire_date=expire_date,
+           member_limit=member_limit,
+           creates_join_request=creates_join_request
+       )
+       return {"invite_link": invite_link.invite_link}
+
+   @app.post("/set_chat_photo")
+   async def set_chat_photo_endpoint(chat_id: int, photo_url: str):
+       response = requests.get(photo_url)
+       photo = BytesIO(response.content)
+       photo.name = "photo.jpg"
+       await bot_instance.set_chat_photo(chat_id, photo)
+       return {"status": "Chat photo set successfully"}
+
+   @app.post("/delete_chat_photo")
+   async def delete_chat_photo_endpoint(chat_id: int):
+       await bot_instance.delete_chat_photo(chat_id)
+       return {"status": "Chat photo deleted successfully"}
+
+   @app.post("/set_chat_title")
+   async def set_chat_title_endpoint(chat_id: int, title: str):
+       await bot_instance.set_chat_title(chat_id, title)
+       return {"status": "Chat title set successfully"}
+
+   @app.post("/set_chat_description")
+   async def set_chat_description_endpoint(chat_id: int, description: str):
+       await bot_instance.set_chat_description(chat_id, description)
+       return {"status": "Chat description set successfully"}
+
+   @app.post("/pin_chat_message")
+   async def pin_chat_message_endpoint(chat_id: int, message_id: int, disable_notification: bool = False):
+       await bot_instance.pin_chat_message(chat_id, message_id, disable_notification=disable_notification)
+       return {"status": "Message pinned successfully"}
+
+   @app.post("/unpin_chat_message")
+   async def unpin_chat_message_endpoint(chat_id: int, message_id: int):
+       await bot_instance.unpin_chat_message(chat_id, message_id)
+       return {"status": "Message unpinned successfully"}
+
+   @app.post("/unpin_all_chat_messages")
+   async def unpin_all_chat_messages_endpoint(chat_id: int):
+       await bot_instance.unpin_all_chat_messages(chat_id)
+       return {"status": "All messages unpinned successfully"}
+
+   @app.post("/restrict_chat_member")
+   async def restrict_chat_member_endpoint(chat_id: int, user_id: int, permissions: dict, until_date: int = None):
+       chat_permissions = enums.ChatPermissions(**permissions)
+       await bot_instance.restrict_chat_member(chat_id, user_id, chat_permissions, until_date=until_date)
+       return {"status": "Chat member restricted successfully"}
+
+   @app.post("/promote_chat_member")
+   async def promote_chat_member_endpoint(chat_id: int, user_id: int, can_change_info: bool = False, can_post_messages: bool = False, can_edit_messages: bool = False, can_delete_messages: bool = False, can_manage_video_chats: bool = False, can_restrict_members: bool = False, can_promote_members: bool = False, can_invite_users: bool = False, can_pin_messages: bool = False, can_manage_chat: bool = False):
+       await bot_instance.promote_chat_member(
+           chat_id,
+           user_id,
+           can_change_info=can_change_info,
+           can_post_messages=can_post_messages,
+           can_edit_messages=can_edit_messages,
+           can_delete_messages=can_delete_messages,
+           can_manage_video_chats=can_manage_video_chats,
+           can_restrict_members=can_restrict_members,
+           can_promote_members=can_promote_members,
+           can_invite_users=can_invite_users,
+           can_pin_messages=can_pin_messages,
+           can_manage_chat=can_manage_chat
+       )
+       return {"status": "Chat member promoted successfully"}
+
+   @app.post("/kick_chat_member")
+   async def kick_chat_member_endpoint(chat_id: int, user_id: int):
+       await bot_instance.kick_chat_member(chat_id, user_id)
+       return {"status": "Chat member kicked successfully"}
+
+   @app.post("/unban_chat_member")
+   async def unban_chat_member_endpoint(chat_id: int, user_id: int):
+       await bot_instance.unban_chat_member(chat_id, user_id)
+       return {"status": "Chat member unbanned successfully"}
+
+   @app.post("/set_chat_administrator_custom_title")
+   async def set_chat_administrator_custom_title_endpoint(chat_id: int, user_id: int, custom_title: str):
+       await bot_instance.set_chat_administrator_custom_title(chat_id, user_id, custom_title)
+       return {"status": "Custom title set successfully"}
+
+   @app.post("/set_chat_permissions")
+   async def set_chat_permissions_endpoint(chat_id: int, permissions: dict):
+       chat_permissions = enums.ChatPermissions(**permissions)
+       await bot_instance.set_chat_permissions(chat_id, chat_permissions)
+       return {"status": "Chat permissions set successfully"}
+
+   @app.post("/set_chat_sticker_set")
+   async def set_chat_sticker_set_endpoint(chat_id: int, sticker_set_name: str):
+       await bot_instance.set_chat_sticker_set(chat_id, sticker_set_name)
+       return {"status": "Chat sticker set set successfully"}
+
+   @app.post("/delete_chat_sticker_set")
+   async def delete_chat_sticker_set_endpoint(chat_id: int):
+       await bot_instance.delete_chat_sticker_set(chat_id)
+       return {"status": "Chat sticker set deleted successfully"}
+
+   @app.post("/approve_chat_join_request")
+   async def approve_chat_join_request_endpoint(chat_id: int, user_id: int):
+       await bot_instance.approve_chat_join_request(chat_id, user_id)
+       return {"status": "Join request approved successfully"}
+
+   @app.post("/decline_chat_join_request")
+   async def decline_chat_join_request_endpoint(chat_id: int, user_id: int):
+       await bot_instance.decline_chat_join_request(chat_id, user_id)
+       return {"status": "Join request declined successfully"}
+
+   @app.post("/ban_chat_sender_chat")
+   async def ban_chat_sender_chat_endpoint(chat_id: int, sender_chat_id: int):
+       await bot_instance.ban_chat_sender_chat(chat_id, sender_chat_id)
+       return {"status": "Sender chat banned successfully"}
+
+   @app.post("/unban_chat_sender_chat")
+   async def unban_chat_sender_chat_endpoint(chat_id: int, sender_chat_id: int):
+       await bot_instance.unban_chat_sender_chat(chat_id, sender_chat_id)
+       return {"status": "Sender chat unbanned successfully"}
+
+   @app.post("/set_chat_menu_button")
+   async def set_chat_menu_button_endpoint(chat_id: int, menu_button: dict = None):
+       if menu_button:
+           menu_button_obj = types.MenuButton(**menu_button)
+       else:
+           menu_button_obj = None
+       await bot_instance.set_chat_menu_button(chat_id, menu_button_obj)
+       return {"status": "Chat menu button set successfully"}
+
+   @app.post("/get_chat_menu_button")
+   async def get_chat_menu_button_endpoint(chat_id: int):
+       menu_button = await bot_instance.get_chat_menu_button(chat_id)
+       return {"menu_button": menu_button}
+
+   @app.post("/set_my_commands")
+   async def set_my_commands_endpoint(commands: list):
+       bot_commands = [types.BotCommand(command=cmd["command"], description=cmd["description"]) for cmd in commands]
+       await bot_instance.set_my_commands(bot_commands)
+       return {"status": "Commands set successfully"}
+
+   @app.post("/get_my_commands")
+   async def get_my_commands_endpoint():
+       commands = await bot_instance.get_my_commands()
+       return {"commands": [cmd.dict() for cmd in commands]}
+
+   @app.post("/answer_callback_query")
+   async def answer_callback_query_endpoint(callback_query_id: str, text: str = None, show_alert: bool = False, url: str = None, cache_time: int = 0):
+       await bot_instance.answer_callback_query(callback_query_id, text=text, show_alert=show_alert, url=url, cache_time=cache_time)
+       return {"status": "Callback query answered successfully"}
+
+   @app.post("/send_copy")
+   async def send_copy_endpoint(chat_id: int, from_chat_id: int, message_id: int, caption: str = None, parse_mode: str = None, caption_entities: list = None, reply_to_message_id: int = None, allow_sending_without_reply: bool = False, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.copy_message(
+           chat_id,
+           from_chat_id,
+           message_id,
+           caption=caption,
+           parse_mode=parse_mode,
+           caption_entities=caption_entities,
+           reply_to_message_id=reply_to_message_id,
+           allow_sending_without_reply=allow_sending_without_reply,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/forward_messages")
+   async def forward_messages_endpoint(chat_id: int, from_chat_id: int, message_ids: list, disable_notification: bool = False):
+       messages = await bot_instance.forward_messages(
+           chat_id,
+           from_chat_id,
+           message_ids,
+           disable_notification=disable_notification
+       )
+       return {"messages": [msg.id for msg in messages]}
+
+   @app.post("/send_sticker")
+   async def send_sticker_endpoint(chat_id: int, sticker_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(sticker_url)
+       sticker = BytesIO(response.content)
+       sticker.name = "sticker.webp"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_sticker(
+           chat_id,
+           sticker,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_animation")
+   async def send_animation_endpoint(chat_id: int, animation_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(animation_url)
+       animation = BytesIO(response.content)
+       animation.name = "animation.gif"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_animation(
+           chat_id,
+           animation,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_video_note")
+   async def send_video_note_endpoint(chat_id: int, video_note_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(video_note_url)
+       video_note = BytesIO(response.content)
+       video_note.name = "video_note.mp4"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_video_note(
+           chat_id,
+           video_note,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_voice")
+   async def send_voice_endpoint(chat_id: int, voice_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(voice_url)
+       voice = BytesIO(response.content)
+       voice.name = "voice.ogg"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_voice(
+           chat_id,
+           voice,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_video")
+   async def send_video_endpoint(chat_id: int, video_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(video_url)
+       video = BytesIO(response.content)
+       video.name = "video.mp4"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_video(
+           chat_id,
+           video,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_document")
+   async def send_document_endpoint(chat_id: int, document_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(document_url)
+       document = BytesIO(response.content)
+       document.name = "document.pdf"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_document(
+           chat_id,
+           document,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_photo")
+   async def send_photo_endpoint(chat_id: int, photo_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(photo_url)
+       photo = BytesIO(response.content)
+       photo.name = "photo.jpg"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_photo(
+           chat_id,
+           photo,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_audio")
+   async def send_audio_endpoint(chat_id: int, audio_url: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       response = requests.get(audio_url)
+       audio = BytesIO(response.content)
+       audio.name = "audio.mp3"
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_audio(
+           chat_id,
+           audio,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_location")
+   async def send_location_endpoint(chat_id: int, latitude: float, longitude: float, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_location(
+           chat_id,
+           latitude,
+           longitude,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_contact")
+   async def send_contact_endpoint(chat_id: int, phone_number: str, first_name: str, last_name: str = None, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_contact(
+           chat_id,
+           phone_number,
+           first_name,
+           last_name=last_name,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_dice")
+   async def send_dice_endpoint(chat_id: int, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_dice(
+           chat_id,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_game")
+   async def send_game_endpoint(chat_id: int, game_short_name: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_game(
+           chat_id,
+           game_short_name,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_media_group")
+   async def send_media_group_endpoint(chat_id: int, media: list, reply_to_message_id: int = None, reply_markup: dict = None):
+       media_group = [types.InputMediaPhoto(media=media_item["media"]) if media_item["type"] == "photo" else types.InputMediaVideo(media=media_item["media"]) for media_item in media]
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       messages = await bot_instance.send_media_group(
+           chat_id,
+           media_group,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"messages": [msg.id for msg in messages]}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_invoice")
+   async def send_invoice_endpoint(chat_id: int, title: str, description: str, payload: str, provider_token: str, currency: str, prices: list, start_parameter: str = None, provider_data: str = None, photo_url: str = None, photo_size: int = None, photo_width: int = None, photo_height: int = None, need_name: bool = False, need_phone_number: bool = False, need_email: bool = False, need_shipping_address: bool = False, send_phone_number_to_provider: bool = False, send_email_to_provider: bool = False, is_flexible: bool = False, disable_notification: bool = False, protect_content: bool = False, reply_to_message_id: int = None, allow_sending_without_reply: bool = False, reply_markup: dict = None):
+       prices_obj = [types.LabeledPrice(label=price["label"], amount=price["amount"]) for price in prices]
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_invoice(
+           chat_id,
+           title,
+           description,
+           payload,
+           provider_token,
+           currency,
+           prices_obj,
+           start_parameter=start_parameter,
+           provider_data=provider_data,
+           photo_url=photo_url,
+           photo_size=photo_size,
+           photo_width=photo_width,
+           photo_height=photo_height,
+           need_name=need_name,
+           need_phone_number=need_phone_number,
+           need_email=need_email,
+           need_shipping_address=need_shipping_address,
+           send_phone_number_to_provider=send_phone_number_to_provider,
+           send_email_to_provider=send_email_to_provider,
+           is_flexible=is_flexible,
+           disable_notification=disable_notification,
+           protect_content=protect_content,
+           reply_to_message_id=reply_to_message_id,
+           allow_sending_without_reply=allow_sending_without_reply,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_game")
+   async def send_game_endpoint(chat_id: int, game_short_name: str, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_game(
+           chat_id,
+           game_short_name,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_poll")
+   async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anonymous: bool = False, type: str = "regular", allows_multiple_answers: bool = False, correct_option_id: int = None, explanation: str = None, explanation_parse_mode: str = None, open_period: int = None, close_date: int = None, is_closed: bool = False):
+       message = await bot_instance.send_poll(
+           chat_id,
+           question,
+           options,
+           is_anonymous=is_anonymous,
+           type=type,
+           allows_multiple_answers=allows_multiple_answers,
+           correct_option_id=correct_option_id,
+           explanation=explanation,
+           explanation_parse_mode=explanation_parse_mode,
+           open_period=open_period,
+           close_date=close_date,
+           is_closed=is_closed
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_dice")
+   async def send_dice_endpoint(chat_id: int, reply_to_message_id: int = None, reply_markup: dict = None):
+       reply_markup_obj = InlineKeyboardMarkup(**reply_markup) if reply_markup else None
+       message = await bot_instance.send_dice(
+           chat_id,
+           reply_to_message_id=reply_to_message_id,
+           reply_markup=reply_markup_obj
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_poll")
+   async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anonymous: bool = False, type: str = "regular", allows_multiple_answers: bool = False, correct_option_id: int = None, explanation: str = None, explanation_parse_mode: str = None, open_period: int = None, close_date: int = None, is_closed: bool = False):
+       message = await bot_instance.send_poll(
+           chat_id,
+           question,
+           options,
+           is_anonymous=is_anonymous,
+           type=type,
+           allows_multiple_answers=allows_multiple_answers,
+           correct_option_id=correct_option_id,
+           explanation=explanation,
+           explanation_parse_mode=explanation_parse_mode,
+           open_period=open_period,
+           close_date=close_date,
+           is_closed=is_closed
+       )
+       return {"message_id": message.id}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+
+   @app.post("/send_chat_action")
+   async def send_chat_action_endpoint(chat_id: int, action: str):
+       actions = {
+           "typing": enums.ChatAction.TYPING,
+           "upload_photo": enums.ChatAction.UPLOAD_PHOTO,
+           "record_video": enums.ChatAction.RECORD_VIDEO,
+           "upload_video": enums.ChatAction.UPLOAD_VIDEO,
+           "record_voice": enums.ChatAction.RECORD_VOICE,
+           "upload_voice": enums.ChatAction.UPLOAD_VOICE,
+           "upload_document": enums.ChatAction.UPLOAD_DOCUMENT,
+           "find_location": enums.ChatAction.FIND_LOCATION,
+           "record_video_note": enums.ChatAction.RECORD_VIDEO_NOTE,
+           "upload_video_note": enums.ChatAction.UPLOAD_VIDEO_NOTE,
+           "playing": enums.ChatAction.PLAYING
+       }
+       action_enum = actions.get(action)
+       if not action_enum:
+           return {"error": "Invalid action"}
+       await bot_instance.send_chat_action(chat_id, action_enum)
+       return {"status": "Chat action sent successfully"}
+