botbaleirp 0.0.1__tar.gz

botbaleirp-0.0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: botbaleirp
+Version: 0.0.1
+Summary: کتابخانه کامل پایتون برای API بازوی بله
+Author: Mohammad Latifi
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

botbaleirp-0.0.1/botbaleirp/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.0.1"
+__author__ = "Mohammad Latifi"
+
+from .bot import Bot
+from .bale_types import *
+from .errors import *
+from .utils import *

botbaleirp-0.0.1/botbaleirp/bale_types.py

@@ -0,0 +1,215 @@
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Any
+
+@dataclass
+class User:
+    id: int
+    is_bot: bool
+    first_name: str
+    last_name: Optional[str] = None
+    username: Optional[str] = None
+    language_code: Optional[str] = None
+
+@dataclass
+class Chat:
+    id: int
+    type: str
+    title: Optional[str] = None
+    username: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+
+@dataclass
+class MessageEntity:
+    type: str
+    offset: int
+    length: int
+
+@dataclass
+class PhotoSize:
+    file_id: str
+    file_unique_id: str
+    width: int
+    height: int
+    file_size: Optional[int] = None
+
+@dataclass
+class Document:
+    file_id: str
+    file_unique_id: str
+    thumbnail: Optional[PhotoSize] = None
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+@dataclass
+class Audio:
+    file_id: str
+    file_unique_id: str
+    duration: int
+    title: Optional[str] = None
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+@dataclass
+class Video:
+    file_id: str
+    file_unique_id: str
+    width: int
+    height: int
+    duration: int
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+@dataclass
+class Voice:
+    file_id: str
+    file_unique_id: str
+    duration: int
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+@dataclass
+class Animation:
+    file_id: str
+    file_unique_id: str
+    width: int
+    height: int
+    duration: int
+    thumbnail: Optional[PhotoSize] = None
+    file_name: Optional[str] = None
+    mime_type: Optional[str] = None
+    file_size: Optional[int] = None
+
+@dataclass
+class Contact:
+    phone_number: str
+    first_name: str
+    last_name: Optional[str] = None
+    user_id: Optional[int] = None
+
+@dataclass
+class Location:
+    longitude: float
+    latitude: float
+
+@dataclass
+class Invoice:
+    title: str
+    description: str
+    total_amount: int
+
+@dataclass
+class SuccessfulPayment:
+    currency: str
+    total_amount: int
+    invoice_payload: str
+    telegram_payment_charge_id: str
+    provider_payment_charge_id: str
+
+@dataclass
+class PreCheckoutQuery:
+    id: str
+    from_user: User
+    currency: str
+    total_amount: int
+    invoice_payload: str
+
+    @classmethod
+    def from_dict(cls, data):
+        data['from_user'] = User(**data.pop('from'))
+        return cls(**data)
+
+@dataclass
+class CallbackQuery:
+    id: str
+    from_user: User
+    message: Optional['Message'] = None
+    data: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data):
+        data['from_user'] = User(**data.pop('from'))
+        if data.get('message'):
+            data['message'] = Message.from_dict(data['message'])
+        return cls(**data)
+
+@dataclass
+class Message:
+    message_id: int
+    date: int
+    chat: Chat
+    from_user: Optional[User] = None
+    text: Optional[str] = None
+    caption: Optional[str] = None
+    photo: Optional[List[PhotoSize]] = None
+    video: Optional[Video] = None
+    audio: Optional[Audio] = None
+    voice: Optional[Voice] = None
+    document: Optional[Document] = None
+    animation: Optional[Animation] = None
+    contact: Optional[Contact] = None
+    location: Optional[Location] = None
+    reply_to_message: Optional['Message'] = None
+    entities: Optional[List[MessageEntity]] = None
+    new_chat_members: Optional[List[User]] = None
+    left_chat_member: Optional[User] = None
+    invoice: Optional[Invoice] = None
+    successful_payment: Optional[SuccessfulPayment] = None
+
+    @classmethod
+    def from_dict(cls, data):
+        if data.get('from'):
+            data['from_user'] = User(**data.pop('from'))
+        if data.get('chat'):
+            data['chat'] = Chat(**data['chat'])
+        if data.get('reply_to_message'):
+            data['reply_to_message'] = cls.from_dict(data['reply_to_message'])
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+@dataclass
+class Update:
+    update_id: int
+    message: Optional[Message] = None
+    edited_message: Optional[Message] = None
+    callback_query: Optional[CallbackQuery] = None
+    pre_checkout_query: Optional[PreCheckoutQuery] = None
+
+    @classmethod
+    def from_dict(cls, data):
+        if data.get('message'):
+            data['message'] = Message.from_dict(data['message'])
+        if data.get('callback_query'):
+            data['callback_query'] = CallbackQuery.from_dict(data['callback_query'])
+        if data.get('pre_checkout_query'):
+            data['pre_checkout_query'] = PreCheckoutQuery.from_dict(data['pre_checkout_query'])
+        return cls(**data)
+
+@dataclass
+class File:
+    file_id: str
+    file_unique_id: str
+    file_size: Optional[int] = None
+    file_path: Optional[str] = None
+
+@dataclass
+class ChatMember:
+    status: str
+    user: User
+
+    @classmethod
+    def from_dict(cls, data):
+        data['user'] = User(**data['user'])
+        return cls(**data)
+
+@dataclass
+class ChatFullInfo(Chat):
+    bio: Optional[str] = None
+    description: Optional[str] = None
+    invite_link: Optional[str] = None
+
+@dataclass
+class MessageId:
+    message_id: int

botbaleirp-0.0.1/botbaleirp/bot.py

@@ -0,0 +1,340 @@
+import json
+import time
+from typing import Dict, Any, Optional, List, Union, BinaryIO, Callable
+import requests
+from . import bale_types as types
+from .errors import BaleAPIError, BaleNetworkError
+from .utils import prepare_upload_file
+
+class Bot:
+    BASE_URL = "https://tapi.bale.ai/bot{}"
+
+    def __init__(self, token: str):
+        self.token = token
+        self.session = requests.Session()
+        self._offset = None
+
+    def _request(self, method: str, params: Dict = None, files: Dict = None) -> Any:
+        url = self.BASE_URL.format(self.token) + f"/{method}"
+        try:
+            if files:
+                resp = self.session.post(url, data=params, files=files)
+            elif method in ('getMe', 'getUpdates', 'getWebhookInfo', 'deleteWebhook'):
+                resp = self.session.get(url, params=params)
+            else:
+                resp = self.session.post(url, json=params)
+            resp.raise_for_status()
+            data = resp.json()
+            if not data.get('ok'):
+                raise BaleAPIError(data.get('description', 'Unknown error'),
+                                   data.get('error_code'), data.get('parameters'))
+            return data.get('result')
+        except requests.exceptions.RequestException as e:
+            raise BaleNetworkError(str(e))
+
+    # ----------------------- دریافت آپدیت -----------------------
+    def get_updates(self, offset: Optional[int] = None, limit: int = 100, timeout: int = 0) -> List[types.Update]:
+        if offset is None and self._offset is not None:
+            offset = self._offset
+        params = {'limit': limit, 'timeout': timeout}
+        if offset:
+            params['offset'] = offset
+        result = self._request('getUpdates', params)
+        updates = [types.Update.from_dict(u) for u in result]
+        if updates:
+            self._offset = updates[-1].update_id + 1
+        return updates
+
+    def start_polling(self, callback: Callable[[types.Update], None], interval: float = 0.5):
+        self._offset = None
+        while True:
+            try:
+                for update in self.get_updates():
+                    callback(update)
+            except KeyboardInterrupt:
+                break
+            except Exception as e:
+                print(f"Polling error: {e}")
+                time.sleep(interval)
+            time.sleep(interval)
+
+    def set_webhook(self, url: str) -> bool:
+        return self._request('setWebhook', {'url': url}) is True
+
+    def delete_webhook(self) -> bool:
+        return self._request('deleteWebhook') is True
+
+    def get_webhook_info(self) -> Dict:
+        return self._request('getWebhookInfo')
+
+    # ----------------------- اطلاعات بازو -----------------------
+    def get_me(self) -> types.User:
+        return types.User(**self._request('getMe'))
+
+    # ----------------------- ارسال پیام -----------------------
+    def send_message(self, chat_id: Union[int, str], text: str,
+                     reply_to_message_id: int = None, reply_markup: Dict = None) -> types.Message:
+        params = {'chat_id': chat_id, 'text': text}
+        if reply_to_message_id: params['reply_to_message_id'] = reply_to_message_id
+        if reply_markup: params['reply_markup'] = reply_markup
+        return types.Message.from_dict(self._request('sendMessage', params))
+
+    def forward_message(self, chat_id: Union[int, str], from_chat_id: Union[int, str],
+                        message_id: int) -> types.Message:
+        params = {'chat_id': chat_id, 'from_chat_id': from_chat_id, 'message_id': message_id}
+        return types.Message.from_dict(self._request('forwardMessage', params))
+
+    def copy_message(self, chat_id: Union[int, str], from_chat_id: Union[int, str],
+                     message_id: int) -> types.MessageId:
+        params = {'chat_id': chat_id, 'from_chat_id': from_chat_id, 'message_id': message_id}
+        return types.MessageId(**self._request('copyMessage', params))
+
+    def send_photo(self, chat_id: Union[int, str], photo: Union[str, bytes, BinaryIO],
+                   caption: str = None, reply_to_message_id: int = None,
+                   reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(photo)
+        params = {'chat_id': chat_id, 'caption': caption,
+                  'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'photo': (name, data)}
+        else:
+            params['photo'] = data
+        return types.Message.from_dict(self._request('sendPhoto', params, files))
+
+    def send_audio(self, chat_id: Union[int, str], audio: Union[str, bytes, BinaryIO],
+                   caption: str = None, reply_to_message_id: int = None,
+                   reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(audio)
+        params = {'chat_id': chat_id, 'caption': caption,
+                  'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'audio': (name, data)}
+        else:
+            params['audio'] = data
+        return types.Message.from_dict(self._request('sendAudio', params, files))
+
+    def send_document(self, chat_id: Union[int, str], document: Union[str, bytes, BinaryIO],
+                      caption: str = None, reply_to_message_id: int = None,
+                      reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(document)
+        params = {'chat_id': chat_id, 'caption': caption,
+                  'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'document': (name, data)}
+        else:
+            params['document'] = data
+        return types.Message.from_dict(self._request('sendDocument', params, files))
+
+    def send_video(self, chat_id: Union[int, str], video: Union[str, bytes, BinaryIO],
+                   caption: str = None, reply_to_message_id: int = None,
+                   reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(video)
+        params = {'chat_id': chat_id, 'caption': caption,
+                  'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'video': (name, data)}
+        else:
+            params['video'] = data
+        return types.Message.from_dict(self._request('sendVideo', params, files))
+
+    def send_animation(self, chat_id: Union[int, str], animation: Union[str, bytes, BinaryIO],
+                       reply_to_message_id: int = None, reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(animation)
+        params = {'chat_id': chat_id, 'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'animation': (name, data)}
+        else:
+            params['animation'] = data
+        return types.Message.from_dict(self._request('sendAnimation', params, files))
+
+    def send_voice(self, chat_id: Union[int, str], voice: Union[str, bytes, BinaryIO],
+                   caption: str = None, reply_to_message_id: int = None,
+                   reply_markup: Dict = None) -> types.Message:
+        name, data = prepare_upload_file(voice)
+        params = {'chat_id': chat_id, 'caption': caption,
+                  'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        files = None
+        if name and data:
+            files = {'voice': (name, data)}
+        else:
+            params['voice'] = data
+        return types.Message.from_dict(self._request('sendVoice', params, files))
+
+    def send_media_group(self, chat_id: Union[int, str], media: List[Dict],
+                         reply_to_message_id: int = None) -> List[types.Message]:
+        params = {'chat_id': chat_id, 'media': json.dumps(media), 'reply_to_message_id': reply_to_message_id}
+        result = self._request('sendMediaGroup', params)
+        return [types.Message.from_dict(msg) for msg in result]
+
+    def send_location(self, chat_id: Union[int, str], latitude: float, longitude: float,
+                      horizontal_accuracy: float = None, reply_to_message_id: int = None,
+                      reply_markup: Dict = None) -> types.Message:
+        params = {'chat_id': chat_id, 'latitude': latitude, 'longitude': longitude,
+                  'horizontal_accuracy': horizontal_accuracy, 'reply_to_message_id': reply_to_message_id,
+                  'reply_markup': reply_markup}
+        return types.Message.from_dict(self._request('sendLocation', {k: v for k, v in params.items() if v}))
+
+    def send_contact(self, chat_id: Union[int, str], phone_number: str, first_name: str,
+                     last_name: str = None, reply_to_message_id: int = None,
+                     reply_markup: Dict = None) -> types.Message:
+        params = {'chat_id': chat_id, 'phone_number': phone_number, 'first_name': first_name,
+                  'last_name': last_name, 'reply_to_message_id': reply_to_message_id, 'reply_markup': reply_markup}
+        return types.Message.from_dict(self._request('sendContact', {k: v for k, v in params.items() if v}))
+
+    def send_chat_action(self, chat_id: Union[int, str], action: str) -> bool:
+        return self._request('sendChatAction', {'chat_id': chat_id, 'action': action}) is True
+
+    # ----------------------- فایل -----------------------
+    def get_file(self, file_id: str) -> types.File:
+        return types.File(**self._request('getFile', {'file_id': file_id}))
+
+    def download_file(self, file_path: str, destination: str = None) -> Optional[bytes]:
+        url = f"https://tapi.bale.ai/file/bot{self.token}/{file_path}"
+        resp = self.session.get(url)
+        resp.raise_for_status()
+        if destination:
+            with open(destination, 'wb') as f:
+                f.write(resp.content)
+            return None
+        return resp.content
+
+    # ----------------------- پاسخ به callback -----------------------
+    def answer_callback_query(self, callback_query_id: str, text: str = None, show_alert: bool = False) -> bool:
+        params = {'callback_query_id': callback_query_id, 'text': text, 'show_alert': show_alert}
+        return self._request('answerCallbackQuery', {k: v for k, v in params.items() if v}) is True
+
+    def ask_review(self, user_id: int, delay_seconds: int = 0) -> bool:
+        return self._request('askReview', {'user_id': user_id, 'delay_seconds': delay_seconds}) is True
+
+    # ----------------------- مدیریت گروه -----------------------
+    def ban_chat_member(self, chat_id: Union[int, str], user_id: int) -> bool:
+        return self._request('banChatMember', {'chat_id': chat_id, 'user_id': user_id}) is True
+
+    def unban_chat_member(self, chat_id: Union[int, str], user_id: int, only_if_banned: bool = True) -> bool:
+        return self._request('unbanChatMember', {'chat_id': chat_id, 'user_id': user_id, 'only_if_banned': only_if_banned}) is True
+
+    def promote_chat_member(self, chat_id: Union[int, str], user_id: int,
+                            can_change_info=False, can_post_messages=False, can_edit_messages=False,
+                            can_delete_messages=False, can_manage_video_chats=False,
+                            can_invite_users=False, can_restrict_members=False) -> bool:
+        params = {'chat_id': chat_id, 'user_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_invite_users': can_invite_users, 'can_restrict_members': can_restrict_members}
+        return self._request('promoteChatMember', {k: v for k, v in params.items() if v}) is True
+
+    def set_chat_photo(self, chat_id: Union[int, str], photo: Union[str, bytes, BinaryIO]) -> bool:
+        name, data = prepare_upload_file(photo)
+        if not name or not isinstance(data, (bytes, BinaryIO)):
+            raise ValueError("فقط آپلود فایل محلی پشتیبانی می‌شود")
+        return self._request('setChatPhoto', {'chat_id': chat_id}, files={'photo': (name, data)}) is True
+
+    def delete_chat_photo(self, chat_id: Union[int, str]) -> bool:
+        return self._request('deleteChatPhoto', {'chat_id': chat_id}) is True
+
+    def leave_chat(self, chat_id: Union[int, str]) -> bool:
+        return self._request('leaveChat', {'chat_id': chat_id}) is True
+
+    def get_chat(self, chat_id: Union[int, str]) -> types.ChatFullInfo:
+        return types.ChatFullInfo(**self._request('getChat', {'chat_id': chat_id}))
+
+    def get_chat_administrators(self, chat_id: Union[int, str]) -> List[types.ChatMember]:
+        result = self._request('getChatAdministrators', {'chat_id': chat_id})
+        return [types.ChatMember.from_dict(admin) for admin in result]
+
+    def get_chat_members_count(self, chat_id: Union[int, str]) -> int:
+        return self._request('getChatMembersCount', {'chat_id': chat_id})
+
+    def get_chat_member(self, chat_id: Union[int, str], user_id: int) -> types.ChatMember:
+        return types.ChatMember.from_dict(self._request('getChatMember', {'chat_id': chat_id, 'user_id': user_id}))
+
+    def pin_chat_message(self, chat_id: Union[int, str], message_id: int) -> bool:
+        return self._request('pinChatMessage', {'chat_id': chat_id, 'message_id': message_id}) is True
+
+    def unpin_chat_message(self, chat_id: Union[int, str], message_id: int) -> bool:
+        return self._request('unpinChatMessage', {'chat_id': chat_id, 'message_id': message_id}) is True
+
+    def unpin_all_chat_messages(self, chat_id: Union[int, str]) -> bool:
+        return self._request('unpinAllChatMessages', {'chat_id': chat_id}) is True
+
+    def set_chat_title(self, chat_id: Union[int, str], title: str) -> bool:
+        return self._request('setChatTitle', {'chat_id': chat_id, 'title': title}) is True
+
+    def set_chat_description(self, chat_id: Union[int, str], description: str) -> bool:
+        return self._request('setChatDescription', {'chat_id': chat_id, 'description': description}) is True
+
+    def create_chat_invite_link(self, chat_id: Union[int, str]) -> str:
+        return self._request('createChatInviteLink', {'chat_id': chat_id})
+
+    def revoke_chat_invite_link(self, chat_id: Union[int, str], invite_link: str) -> str:
+        return self._request('revokeChatInviteLink', {'chat_id': chat_id, 'invite_link': invite_link})
+
+    def export_chat_invite_link(self, chat_id: Union[int, str]) -> str:
+        return self._request('exportChatInviteLink', {'chat_id': chat_id})
+
+    # ----------------------- ویرایش پیام -----------------------
+    def edit_message_text(self, chat_id: Union[int, str], message_id: int, text: str,
+                          reply_markup: Dict = None) -> types.Message:
+        params = {'chat_id': chat_id, 'message_id': message_id, 'text': text, 'reply_markup': reply_markup}
+        return types.Message.from_dict(self._request('editMessageText', {k: v for k, v in params.items() if v}))
+
+    def edit_message_caption(self, chat_id: Union[int, str], message_id: int, caption: str,
+                             reply_markup: Dict = None) -> types.Message:
+        params = {'chat_id': chat_id, 'message_id': message_id, 'caption': caption, 'reply_markup': reply_markup}
+        return types.Message.from_dict(self._request('editMessageCaption', {k: v for k, v in params.items() if v}))
+
+    def edit_message_reply_markup(self, chat_id: Union[int, str], message_id: int,
+                                  reply_markup: Dict) -> types.Message:
+        params = {'chat_id': chat_id, 'message_id': message_id, 'reply_markup': reply_markup}
+        return types.Message.from_dict(self._request('editMessageReplyMarkup', params))
+
+    def delete_message(self, chat_id: Union[int, str], message_id: int) -> bool:
+        return self._request('deleteMessage', {'chat_id': chat_id, 'message_id': message_id}) is True
+
+    # ----------------------- پرداخت -----------------------
+    def send_invoice(self, chat_id: Union[int, str], title: str, description: str,
+                     payload: str, provider_token: str, prices: List[Dict],
+                     photo_url: str = None, reply_to_message_id: int = None) -> types.Message:
+        params = {'chat_id': chat_id, 'title': title, 'description': description, 'payload': payload,
+                  'provider_token': provider_token, 'prices': json.dumps(prices), 'photo_url': photo_url,
+                  'reply_to_message_id': reply_to_message_id}
+        return types.Message.from_dict(self._request('sendInvoice', {k: v for k, v in params.items() if v}))
+
+    def create_invoice_link(self, title: str, description: str, payload: str,
+                            provider_token: str, prices: List[Dict]) -> str:
+        params = {'title': title, 'description': description, 'payload': payload,
+                  'provider_token': provider_token, 'prices': json.dumps(prices)}
+        return self._request('createInvoiceLink', params)
+
+    def answer_pre_checkout_query(self, pre_checkout_query_id: str, ok: bool,
+                                  error_message: str = None) -> bool:
+        params = {'pre_checkout_query_id': pre_checkout_query_id, 'ok': ok, 'error_message': error_message}
+        return self._request('answerPreCheckoutQuery', {k: v for k, v in params.items() if v}) is True
+
+    def inquire_transaction(self, transaction_id: str) -> Dict:
+        return self._request('inquireTransaction', {'transaction_id': transaction_id})
+
+    # ----------------------- استیکر -----------------------
+    def upload_sticker_file(self, user_id: int, sticker: Union[str, bytes, BinaryIO]) -> types.File:
+        name, data = prepare_upload_file(sticker)
+        params = {'user_id': user_id}
+        files = None
+        if name and data:
+            files = {'sticker': (name, data)}
+        else:
+            params['sticker'] = data
+        return types.File(**self._request('uploadStickerFile', params, files))
+
+    def create_new_sticker_set(self, user_id: int, name: str, title: str,
+                               stickers: List[Dict]) -> bool:
+        params = {'user_id': user_id, 'name': name, 'title': title, 'stickers': json.dumps(stickers)}
+        return self._request('createNewStickerSet', params) is True
+
+    def add_sticker_to_set(self, user_id: int, name: str, sticker: Dict) -> bool:
+        params = {'user_id': user_id, 'name': name, 'sticker': json.dumps(sticker)}
+        return self._request('addStickerToSet', params) is True

botbaleirp-0.0.1/botbaleirp/errors.py

@@ -0,0 +1,11 @@
+class BaleError(Exception):
+    def __init__(self, message, error_code=None, parameters=None):
+        super().__init__(message)
+        self.error_code = error_code
+        self.parameters = parameters
+
+class BaleAPIError(BaleError):
+    pass
+
+class BaleNetworkError(BaleError):
+    pass

botbaleirp-0.0.1/botbaleirp/utils.py

@@ -0,0 +1,26 @@
+import os
+from typing import List, Dict, Union, Any
+
+def make_reply_keyboard(buttons: List[List[str]], resize_keyboard=True, one_time_keyboard=False):
+    return {
+        "keyboard": [[{"text": btn} for btn in row] for row in buttons],
+        "resize_keyboard": resize_keyboard,
+        "one_time_keyboard": one_time_keyboard
+    }
+
+def make_inline_keyboard(buttons: List[List[Dict[str, str]]]):
+    return {"inline_keyboard": buttons}
+
+def remove_keyboard():
+    return {"remove_keyboard": True}
+
+def prepare_upload_file(file_input):
+    if isinstance(file_input, str):
+        if file_input.startswith(('http://', 'https://')):
+            return None, file_input
+        if os.path.isfile(file_input):
+            return os.path.basename(file_input), open(file_input, 'rb')
+        return None, file_input
+    elif isinstance(file_input, bytes):
+        return "file.bin", file_input
+    raise ValueError("نوع فایل پشتیبانی نمی‌شود")

botbaleirp-0.0.1/botbaleirp.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: botbaleirp
+Version: 0.0.1
+Summary: کتابخانه کامل پایتون برای API بازوی بله
+Author: Mohammad Latifi
+Requires-Python: >=3.7
+Requires-Dist: requests>=2.25.0
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

botbaleirp-0.0.1/botbaleirp.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+setup.py
+botbaleirp/__init__.py
+botbaleirp/bale_types.py
+botbaleirp/bot.py
+botbaleirp/errors.py
+botbaleirp/utils.py
+botbaleirp.egg-info/PKG-INFO
+botbaleirp.egg-info/SOURCES.txt
+botbaleirp.egg-info/dependency_links.txt
+botbaleirp.egg-info/requires.txt
+botbaleirp.egg-info/top_level.txt

botbaleirp-0.0.1/botbaleirp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

botbaleirp-0.0.1/botbaleirp.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.25.0

botbaleirp-0.0.1/botbaleirp.egg-info/top_level.txt

@@ -0,0 +1 @@
+botbaleirp

botbaleirp-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

botbaleirp-0.0.1/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup
+
+setup(
+    name="botbaleirp",
+    version="0.0.1",
+    author="Mohammad Latifi",
+    description="کتابخانه کامل پایتون برای API بازوی بله",
+    packages=["botbaleirp"],
+    install_requires=["requests>=2.25.0"],
+    python_requires=">=3.7",
+)