Update fastapi_app.py

fastapi_app.py

@@ -1614,3 +1614,1088 @@ async def send_poll_endpoint(chat_id: int, question: str, options: list, is_anon
        await bot_instance.send_chat_action(chat_id, action_enum)
        return {"status": "Chat action sent successfully"}
 
+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("/get_chat")
+   async def get_chat_endpoint(chat_id: int):
+       chat = await bot_instance.get_chat(chat_id)
+       return {"chat": chat.dict()}
+
+   @app.post("/get_chat_member")
+   async def get_chat_member_endpoint(chat_id: int, user_id: int):
+       chat_member = await bot_instance.get_chat_member(chat_id, user_id)
+       return {"chat_member": chat_member.dict()}
+
+   @app.post("/get_chat_members_count")
+   async def get_chat_members_count_endpoint(chat_id: int):
+       count = await bot_instance.get_chat_members_count(chat_id)
+       return {"members_count": count}
+
+   @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("/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("/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_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("/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("/copy_message")
+   async def copy_message_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_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_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_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_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_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_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_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_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_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("/text_to_speech")
+   async def text_to_speech_endpoint(tts_request: TextToSpeechRequest):
+       audio = await convert(tts_request.text)
+       return {"audio_url": audio.name}
+
+   async def convert(text):
+       audio = BytesIO()
+       i = Translator().translate(text, dest="en")
+       lang = i.src
+       tts = gTTS(text, lang=lang)
+       audio.name = lang + ".mp3"
+       tts.write_to_fp(audio)
+       return audio
+
+   @app.post("/download_youtube_song")
+   async def download_youtube_song_endpoint(yt_request: YouTubeDownloadRequest):
+       try:
+           results = YoutubeSearch(yt_request.url, max_results=1).to_dict()
+           link = f"https://youtube.com{results[0]['url_suffix']}"
+           title = results[0]["title"][:40]
+           thumbnail = results[0]["thumbnails"][0]
+           thumb_name = f'thumb{title}.jpg'
+           thumb = requests.get(thumbnail, allow_redirects=True)
+           open(thumb_name, 'wb').write(thumb.content)
+           performer = f"[Mᴋɴ Bᴏᴛᴢ™]"
+           duration = results[0]["duration"]
+           url_suffix = results[0]["url_suffix"]
+           views = results[0]["views"]
+       except Exception as e:
+           logger.error(f"Error downloading YouTube song: {e}")
+           return {"error": str(e)}
+
+       ydl_opts = {"format": "bestaudio[ext=m4a]"}
+       try:
+           with YoutubeDL(ydl_opts) as ydl:
+               info_dict = ydl.extract_info(link, download=False)
+               audio_file = ydl.prepare_filename(info_dict)
+               ydl.process_info(info_dict)
+       except Exception as e:
+           logger.error(f"Error processing YouTube song: {e}")
+           return {"error": str(e)}
+
+       cap = "**BY›› [Mᴋɴ Bᴏᴛᴢ™](https://t.me/mkn_bots_updates)**"
+       secmul, dur, dur_arr = 1, 0, duration.split(':')
+       for i in range(len(dur_arr) - 1, -1, -1):
+           dur += (int(dur_arr[i]) * secmul)
+           secmul *= 60
+
+       return {"audio_file": audio_file, "caption": cap, "title": title, "duration": dur, "performer": performer, "thumb": thumb_name}
+
+   @app.post("/download_youtube_video")
+   async def download_youtube_video_endpoint(yt_request: YouTubeDownloadRequest):
+       url = yt_request.url
+       try:
+           search = SearchVideos(f"{url}", offset=1, mode="dict", max_results=1)
+           mi = search.result()
+           mio = mi["search_result"]
+           mo = mio[0]["link"]
+           thum = mio[0]["title"]
+           fridayz = mio[0]["id"]
+           mio[0]["channel"]
+           kekme = f"https://img.youtube.com/vi/{fridayz}/hqdefault.jpg"
+           await asyncio.sleep(0.6)
+           url = mo
+           sedlyf = wget.download(kekme)
+           opts = {
+               "format": "best",
+               "addmetadata": True,
+               "key": "FFmpegMetadata",
+               "prefer_ffmpeg": True,
+               "geo_bypass": True,
+               "nocheckcertificate": True,
+               "postprocessors": [{"key": "FFmpegVideoConvertor", "preferedformat": "mp4"}],
+               "outtmpl": "%(id)s.mp4",
+               "logtostderr": False,
+               "quiet": True,
+           }
+           with YoutubeDL(opts) as ytdl:
+               ytdl_data = ytdl.extract_info(url, download=True)
+       except Exception as e:
+           logger.error(f"Error downloading YouTube video: {e}")
+           return {"error": str(e)}
+
+       file_stark = f"{ytdl_data['id']}.mp4"
+       capy = f"""**𝚃𝙸𝚃𝙻𝙴 :** [{thum}]({mo})\n**𝚁𝙴𝚀𝚄𝙴𝚂𝚃𝙴𝙳 𝙱𝚈 :** {await bot_instance.get_me().mention}"""
+
+       return {"video_file": file_stark, "caption": capy, "title": ytdl_data["title"], "duration": int(ytdl_data["duration"]), "thumb": sedlyf}
+
+   @app.post("/carbon")
+   async def carbon_endpoint(carbon_request: CarbonRequest):
+       carbon_image = await make_carbon(carbon_request.text, True)
+       return {"carbon_url": carbon_image}
+
+   async def make_carbon(text, tele=False):
+       url = "https://carbonara.solopov.dev/api/cook"
+       async with aiohttp.ClientSession() as session:
+           async with session.post(url, json={"code": text}) as resp:
+               image = BytesIO(await resp.read())
+       image.name = "carbon.png"
+       if tele:
+           uf = upload_file(image)
+           image.close()
+           return f"https://graph.org{uf[0]}"
+       return image
+
+   @app.post("/font")
+   async def font_endpoint(font_request: FontRequest):
+       fonts = {
+           "typewriter": Fonts.typewriter,
+           "outline": Fonts.outline,
+           "serif": Fonts.serief,
+           "bold_cool": Fonts.bold_cool,
+           "cool": Fonts.cool,
+           "small_cap": Fonts.smallcap,
+           "script": Fonts.script,
+           "bold_script": Fonts.bold_script,
+           "tiny": Fonts.tiny,
+           "comic": Fonts.comic,
+           "san": Fonts.san,
+           "slant_san": Fonts.slant_san,
+           "slant": Fonts.slant,
+           "sim": Fonts.sim,
+           "circles": Fonts.circles,
+           "dark_circle": Fonts.dark_circle,
+           "gothic": Fonts.gothic,
+           "bold_gothic": Fonts.bold_gothic,
+           "cloud": Fonts.cloud,
+           "happy": Fonts.happy,
+           "sad": Fonts.sad,
+           "special": Fonts.special,
+           "square": Fonts.square,
+           "dark_square": Fonts.dark_square,
+           "andalucia": Fonts.andalucia,
+           "manga": Fonts.manga,
+           "stinky": Fonts.stinky,
+           "bubbles": Fonts.bubbles,
+           "underline": Fonts.underline,
+           "ladybug": Fonts.ladybug,
+           "rays": Fonts.rays,
+           "birds": Fonts.birds,
+           "slash": Fonts.slash,
+           "stop": Fonts.stop,
+           "skyline": Fonts.skyline,
+           "arrows": Fonts.arrows,
+           "rvnes": Fonts.rvnes,
+           "strike": Fonts.strike,
+           "frozen": Fonts.frozen
+       }
+       cls = fonts.get(font_request.style)
+       if not cls:
+           return {"error": "Invalid style"}
+       new_text = cls(font_request.text)
+       return {"new_text": new_text}
+
+   @app.post("/paste")
+   async def paste_endpoint(paste_request: PasteRequest):
+       paste_response = await p_paste(paste_request.text)
+       return paste_response
+
+   async def p_paste(code, extension=None):
+       siteurl = "https://pasty.lus.pm/api/v1/pastes"
+       data = {"content": code}
+       try:
+           response = requests.post(url=siteurl, data=json.dumps(data), headers={"User-Agent": "Mozilla/5.0", "content-type": "application/json"})
+       except Exception as e:
+           return {"error": str(e)}
+       if response.ok:
+           response = response.json()
+           purl = (
+               f"https://pasty.lus.pm/{response['id']}.{extension}"
+               if extension
+               else f"https://pasty.lus.pm/{response['id']}.txt"
+           )
+           return {
+               "url": purl,
+               "raw": f"https://pasty.lus.pm/{response['id']}/raw",
+               "bin": "Pasty",
+           }
+       return {"error": "Unable to reach pasty.lus.pm"}
+
+   @app.post("/share_text")
+   async def share_text_endpoint(share_request: ShareTextRequest):
+       share_url = f"https://t.me/share/url?url={quote(share_request.text)}"
+       return {"share_url": share_url}
+
+   @app.post("/telegraph_upload")
+   async def telegraph_upload_endpoint(upload_request: TelegraphUploadRequest):
+       try:
+           response = upload_file(upload_request.file_path)
+       except Exception as e:
+           logger.error(f"Error uploading to Telegraph: {e}")
+           return {"error": str(e)}
+       telegraph_url = f"https://graph.org{response[0]}"
+       return {"telegraph_url": telegraph_url}
+
+   @app.post("/group_manager_action")
+   async def group_manager_action_endpoint(action_request: GroupManagerAction):
+       chat_id = action_request.group_id
+       action = action_request.action
+       user_id = action_request.user_id
+       time_val = action_request.time
+
+       if action == "ban":
+           await bot_instance.ban_chat_member(chat_id, user_id)
+           return {"status": "User banned successfully"}
+       elif action == "unban":
+           await bot_instance.unban_chat_member(chat_id, user_id)
+           return {"status": "User unbanned successfully"}
+       elif action == "tban":
+           until_date_val = extract_time(time_val)
+           if until_date_val is None:
+               return {"error": "Invalid time type specified. Expected m, h, or d, Got it: {time_val[-1]}"}
+           await bot_instance.ban_chat_member(chat_id, user_id, until_date=until_date_val)
+           return {"status": "User temporarily banned successfully"}
+       elif action == "mute":
+
+
+
+
+
+
+
+
+
+
+
+
+
+await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions())
+           return {"status": "User muted successfully"}
+       elif action == "unmute":
+           await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions(can_send_messages=True))
+           return {"status": "User unmuted successfully"}
+       elif action == "tmute":
+           until_date_val = extract_time(time_val)
+           if until_date_val is None:
+               return {"error": "Invalid time type specified. Expected m, h, or d, Got it: {time_val[-1]}"}
+           await bot_instance.restrict_chat_member(chat_id, user_id, permissions=enums.ChatPermissions(), until_date=until_date_val)
+           return {"status": "User temporarily muted successfully"}
+       elif action == "pin":
+           await bot_instance.pin_chat_message(chat_id, action_request.message_id)
+           return {"status": "Message pinned successfully"}
+       elif action == "unpin":
+           await bot_instance.unpin_chat_message(chat_id, action_request.message_id)
+           return {"status": "Message unpinned successfully"}
+       elif action == "purge":
+           if action_request.message_id:
+               await purge_messages(bot_instance, chat_id, action_request.message_id)
+               return {"status": "Messages purged successfully"}
+           else:
+               return {"error": "Message ID is required for purge action"}
+       else:
+           return {"error": "Invalid action"}
+
+   async def purge_messages(client, chat_id, message_id):
+       try:
+           message_ids = []
+           count_del_etion_s = 0
+           if message_id:
+               for a_s_message_id in range(message_id, message_id + 100):
+                   message_ids.append(a_s_message_id)
+                   if len(message_ids) == 100:
+                       await client.delete_messages(chat_id=chat_id, message_ids=message_ids, revoke=True)
+                       count_del_etion_s += len(message_ids)
+                       message_ids = []
+               if len(message_ids) > 0:
+                   await client.delete_messages(chat_id=chat_id, message_ids=message_ids, revoke=True)
+                   count_del_etion_s += len(message_ids)
+       except Exception as e:
+           logger.error(f"Error purging messages: {e}")
+           return {"error": str(e)}
+
+   @app.post("/broadcast_messages")
+   async def broadcast_messages_endpoint(user_id: int, message_id: int):
+       b_msg = await bot_instance.get_messages(user_id, message_id)
+       sts = await send_message(bot_instance, user_id, "Broadcasting your messages...")
+       start_time = time.time()
+       total_users = await db.total_users_count()
+       done = 0
+       blocked = 0
+       deleted = 0
+       failed = 0
+       success = 0
+       async for user in db.get_all_users():
+           pti, sh = await broadcast_messages(int(user['id']), b_msg)
+           if pti:
+               success += 1
+           elif pti == False:
+               if sh == "Blocked":
+                   blocked += 1
+               elif sh == "Deleted":
+                   deleted += 1
+               elif sh == "Error":
+                   failed += 1
+           done += 1
+           if not done % 20:
+               await edit_message(bot_instance, sts, f"Broadcast in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")
+       time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+       await delete_message(bot_instance, sts)
+       await send_message(bot_instance, user_id, f"Broadcast completed:\nTime taken: {time_taken}\n\nTotal Users: {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")
+       return {"status": "Broadcast completed"}
+
+   async def broadcast_messages(user_id, message):
+       try:
+           await message.copy(chat_id=user_id)
+           return True, "Success"
+       except FloodWait as e:
+           await asyncio.sleep(e.value)
+           return await broadcast_messages(user_id, message)
+       except InputUserDeactivated:
+           await db.delete_user(int(user_id))
+           logger.info(f"{user_id}-Removed from Database, since deleted account.")
+           return False, "Deleted"
+       except UserIsBlocked:
+           logger.info(f"{user_id} -Blocked the bot.")
+           return False, "Blocked"
+       except PeerIdInvalid:
+           await db.delete_user(int(user_id))
+           logger.info(f"{user_id} - PeerIdInvalid")
+           return False, "Error"
+       except Exception as e:
+           return False, "Error"
+
+   @app.post("/clear_junk")
+   async def clear_junk_endpoint(user_id: int):
+       sts = await send_message(bot_instance, user_id, "Clearing junk users...")
+       start_time = time.time()
+       total_users = await db.total_users_count()
+       blocked = 0
+       deleted = 0
+       failed = 0
+       done = 0
+       async for user in db.get_all_users():
+           pti, sh = await clear_junk(int(user['id']), None)
+           if pti == False:
+               if sh == "Blocked":
+                   blocked += 1
+               elif sh == "Deleted":
+                   deleted += 1
+               elif sh == "Error":
+                   failed += 1
+           done += 1
+           if not done % 20:
+               await edit_message(bot_instance, sts, f"Clearing junk in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nBlocked: {blocked}\nDeleted: {deleted}")
+       time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+       await delete_message(bot_instance, sts)
+       await send_message(bot_instance, user_id, f"Clearing junk completed:\nTime taken: {time_taken}\n\nTotal Users: {total_users}\nCompleted: {done} / {total_users}\nBlocked: {blocked}\nDeleted: {deleted}")
+       return {"status": "Junk clearing completed"}
+
+   async def clear_junk(user_id, message):
+       try:
+           key = await message.copy(chat_id=user_id)
+           await key.delete(True)
+           return True, "Success"
+       except FloodWait as e:
+           await asyncio.sleep(e.value)
+           return await clear_junk(user_id, message)
+       except InputUserDeactivated:
+           await db.delete_user(int(user_id))
+           logger.info(f"{user_id}-Removed from Database, since deleted account.")
+           return False, "Deleted"
+       except UserIsBlocked:
+           logger.info(f"{user_id} -Blocked the bot.")
+           return False, "Blocked"
+       except PeerIdInvalid:
+           await db.delete_user(int(user_id))
+           logger.info(f"{user_id} - PeerIdInvalid")
+           return False, "Error"
+       except Exception as e:
+           return False, "Error"
+
+   @app.post("/group_broadcast")
+   async def group_broadcast_endpoint(user_id: int, message_id: int):
+       groups = await db.get_all_chats()
+       b_msg = await bot_instance.get_messages(user_id, message_id)
+       sts = await send_message(bot_instance, user_id, "Broadcasting to groups...")
+       start_time = time.time()
+       total_groups = await db.total_chat_count()
+       done = 0
+       failed = ""
+       success = 0
+       deleted = 0
+       async for group in groups:
+           pti, sh, ex = await broadcast_messages_group(int(group['id']), b_msg)
+           if pti == True:
+               if sh == "Success":
+                   success += 1
+           elif pti == False:
+               if sh == "deleted":
+                   deleted += 1
+                   failed += ex
+                   try:
+                       await bot_instance.leave_chat(int(group['id']))
+                   except Exception as e:
+                       logger.error(f"{e} > {group['id']}")
+           done += 1
+           if not done % 20:
+               await edit_message(bot_instance, sts, f"Broadcast in progress:\n\nTotal Groups {total_groups}\nCompleted: {done} / {total_groups}\nSuccess: {success}\nDeleted: {deleted}")
+       time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+       await delete_message(bot_instance, sts)
+       await send_message(bot_instance, user_id, f"Broadcast completed:\nTime taken: {time_taken}\n\nTotal Groups: {total_groups}\nCompleted: {done} / {total_groups}\nSuccess: {success}\nDeleted: {deleted}\n\nFailed reasons: {failed}")
+       return {"status": "Group broadcast completed"}
+
+   async def broadcast_messages_group(chat_id, message):
+       try:
+           await message.copy(chat_id=chat_id)
+           return True, "Success", 'mm'
+       except FloodWait as e:
+           await asyncio.sleep(e.value)
+           return await broadcast_messages_group(chat_id, message)
+       except Exception as e:
+           await db.delete_chat(int(chat_id))
+           logger.info(f"{chat_id} - PeerIdInvalid")
+           return False, "deleted", f'{e}\n\n'
+
+   @app.post("/junk_group")
+   async def junk_group_endpoint(user_id: int):
+       groups = await db.get_all_chats()
+       sts = await send_message(bot_instance, user_id, "Clearing junk groups...")
+       start_time = time.time()
+       total_groups = await db.total_chat_count()
+       done = 0
+       failed = ""
+       deleted = 0
+       async for group in groups:
+           pti, sh, ex = await junk_group(int(group['id']), None)
+           if pti == False:
+               if sh == "deleted":
+                   deleted += 1
+                   failed += ex
+                   try:
+                       await bot_instance.leave_chat(int(group['id']))
+                   except Exception as e:
+                       logger.error(f"{e} > {group['id']}")
+           done += 1
+           if not done % 20:
+               await edit_message(bot_instance, sts, f"Clearing junk in progress:\n\nTotal Groups {total_groups}\nCompleted: {done} / {total_groups}\nDeleted: {deleted}")
+       time_taken = datetime.timedelta(seconds=int(time.time() - start_time))
+       await delete_message(bot_instance, sts)
+       await send_message(bot_instance, user_id, f"Clearing junk completed:\nTime taken: {time_taken}\n\nTotal Groups: {total_groups}\nCompleted: {done} / {total_groups}\nDeleted: {deleted}\n\nFailed reasons: {failed}")
+       return {"status": "Junk group clearing completed"}
+
+   async def junk_group(chat_id, message):
+       try:
+           kk = await message.copy(chat_id=chat_id)
+           await kk.delete(True)
+           return True, "Success", 'mm'
+       except FloodWait as e:
+           await asyncio.sleep(e.value)
+           return await junk_group(chat_id, message)
+       except Exception as e:
+           await db.delete_chat(int(chat_id))
+           logger.info(f"{chat_id} - PeerIdInvalid")
+           return False, "deleted", f'{e}\n\n'
+
+   @app.post("/group_leave")
+   async def group_leave_endpoint(chat_id: int):
+       await bot_instance.leave_chat(chat_id)
+       return {"status": "Left the group successfully"}
+
+   @app.post("/group_disable")
+   async def group_disable_endpoint(chat_id: int, reason: str = "No Reason"):
+       await db.disable_chat(chat_id, reason)
+       temp.BANNED_CHATS.append(chat_id)
+       return {"status": "Group disabled successfully"}
+
+   @app.post("/group_enable")
+   async def group_enable_endpoint(chat_id: int):
+       await db.re_enable_chat(chat_id)
+       temp.BANNED_CHATS.remove(chat_id)
+       return {"status": "Group enabled successfully"}
+
+   @app.post("/get_user_info")
+   async def get_user_info_endpoint(user_id: int):
+       user_info = await bot_instance.get_users(user_id)
+       return {"user_info": user_info.dict()}
+
+   @app.post("/get_chat_info")
+   async def get_chat_info_endpoint(chat_id: int):
+       chat_info = await bot_instance.get_chat(chat_id)
+       return {"chat_info": chat_info.dict()}
+
+   @app.post("/send_telegram_message")
+   async def send_telegram_message_endpoint(chat_id: int, text: str):
+       message = await send_message(bot_instance, chat_id, text)
+       return {"message_id": message.id}
+
+   @app.post("/edit_telegram_message")
+   async def edit_telegram_message_endpoint(chat_id: int, message_id: int, text: str):
+       message = await bot_instance.get_messages(chat_id, message_id)
+       edited_message = await edit_message(bot_instance, message, text)
+       return {"edited_message_id": edited_message.id}
+
+   @app.post("/delete_telegram_message")
+   async def delete_telegram_message_endpoint(chat_id: int, message_id: int):
+       message = await bot_instance.get_messages(chat_id, message_id)
+       await delete_message(bot_instance, message)
+       return {"status": "Message deleted successfully"}
+
+   if __name__ == "__main__":
+       import uvicorn
+       uvicorn.run(app, host="0.0.0.0", port=8000)