Telegram bot klienti (Bot API): metodlar ma'lumotnomasi

Bot API'ning close metodini chaqiradi: botni bir lokal Bot API serveridan boshqasiga ko'chirishdan oldin joriy nusxani yopadi. Nomi close_bot, chunki SDK klientlarida close() HTTP sessiyani yopadi.

await bot.close_bot(*, token: Optional[str] = None) -> bool

• ▸Avval webhook'ni o'chiring — aks holda server qayta ishga tushganda bot yana ishga tushishi mumkin.
• ▸Bot ishga tushgandan keyingi dastlabki 10 daqiqada Telegram 429 xatosini qaytaradi.

Berilgan scope va til uchun buyruqlar ro'yxatini o'chiradi (deleteMyCommands). Shundan keyin foydalanuvchilar yuqoriroq darajadagi ro'yxatni (masalan, standart scope'ni) ko'radi.

await bot.delete_my_commands(
    *,
    scope: Optional[dict] = None,
    language_code: Optional[str] = None,
    token: Optional[str] = None,
) -> bool

Tokenni TELEGRAM_BOT_TOKEN muhit o'zgaruvchisidan o'qib klient yaratadi; qolgan argumentlar (timeout, retry, license_key, session) konstruktorga uzatiladi. Token kodga tushmasligi uchun shu yo'l tavsiya etiladi.

Telegram.from_env(**kwargs) -> Telegram

• ▸O'zgaruvchi bo'sh bo'lsa ham klient yaratiladi — ConfigurationError birinchi so'rovda ko'tariladi (agar o'sha chaqiruvga token= berilmagan bo'lsa).

Bot profilini (getMe) dict ko'rinishida qaytaradi: id, username, can_join_groups, can_read_all_group_messages va boshqalar. Token ishlayotganini tekshirishning eng oddiy yo'li.

await bot.get_me(*, token: Optional[str] = None) -> dict

• ▸can_read_all_group_messages — true bo'lsa privacy mode o'chirilgan.
• ▸HTTP 401 yoki "Unauthorized" javobini SDK AuthError ga aylantiradi.

me = await bot.get_me()

Berilgan scope va language_code uchun o'rnatilgan buyruqlarni qaytaradi (getMyCommands). Bo'sh ro'yxat — bu kombinatsiya uchun buyruq o'rnatilmagan.

await bot.get_my_commands(
    *,
    scope: Optional[dict] = None,
    language_code: Optional[str] = None,
    token: Optional[str] = None,
) -> list

Botni Telegram'ning bulutli Bot API serveridan chiqaradi (logOut). Faqat botni o'zingizning (lokal) Bot API serveringizga ko'chirishdan oldin kerak.

await bot.log_out(*, token: Optional[str] = None) -> bool

• ▸Chaqiruvdan keyin bot 10 daqiqa davomida bulutli serverga qayta kira olmaydi.
• ▸SDK so'rovlarni faqat https://api.telegram.org ga yuboradi, ya'ni lokal serverga o'tgach bu klient u bilan ishlamaydi.
• ▸Kabinet Playground'idagi universal chaqiruvda logOut va close bloklangan.

Bot menyusida ko'rinadigan buyruqlar ro'yxatini o'rnatadi (setMyCommands), kerak bo'lsa scope (masalan, faqat guruh adminlari) va language_code bo'yicha alohida. Format: [{"command": "start", "description": "..."}].

await bot.set_my_commands(
    commands: list,
    *,
    scope: Optional[dict] = None,
    language_code: Optional[str] = None,
    token: Optional[str] = None,
) -> bool

• ▸Ko'pi bilan 100 ta buyruq; buyruq 1–32 belgi (kichik lotin harflari, raqam, _), tavsif 1–256 belgi.
• ▸Telegram foydalanuvchiga eng aniq mos ro'yxatni ko'rsatadi: avval chat + til, oxirida standart scope.

Webhook'ni o'chiradi (deleteWebhook), shundan keyin get_updates yoki poll bilan ishlash mumkin. drop_pending_updates=True hali yetkazilmagan yangilanishlarni tashlab yuboradi.

await bot.delete_webhook(
    *,
    drop_pending_updates: Optional[bool] = None,
    token: Optional[str] = None,
) -> bool

await bot.delete_webhook()

Yangi yangilanishlarni long polling bilan oladi (getUpdates) va Update dict'lari ro'yxatini qaytaradi. Qayta ishlangan hodisalarni tasdiqlash uchun keyingi so'rovda offset = oxirgi update_id + 1 bering.

await bot.get_updates(
    *,
    offset: Optional[int] = None,
    limit: Optional[int] = None,
    timeout: int = 30,
    allowed_updates: Optional[list[str]] = None,
    token: Optional[str] = None,
) -> list

• ▸Webhook o'rnatilgan bo'lsa ishlamaydi; Telegram yetkazilmagan yangilanishlarni ko'pi bilan 24 soat saqlaydi.
• ▸SDK timeout ni klient timeout'idan 10 soniya kam qilib cheklaydi (standart 30 s klient → 20 s kutish); uzoqroq kutish uchun Telegram(token=..., timeout=90).
• ▸limit — 1–100 (standart 100).

updates = await bot.get_updates(limit=50, timeout=0)

Webhook holatini qaytaradi (getWebhookInfo): url, pending_update_count, last_error_date, last_error_message, max_connections, allowed_updates. Hodisalar kelmay qolsa birinchi shu yerga qarang.

await bot.get_webhook_info(*, token: Optional[str] = None) -> dict

• ▸Bot getUpdates ishlatayotgan bo'lsa url bo'sh satr bo'ladi.

info = await bot.get_webhook_info()

SDK yordamchisi: getUpdates ustidagi cheksiz async for oqimi, offset avtomatik suriladi. Ochiq HTTPS manzili bo'lmagan skript va worker'lar uchun.

bot.poll(
    *,
    allowed_updates: Optional[list[str]] = None,
    timeout: int = 30,
    token: Optional[str] = None,
) -> AsyncIterator[dict]

• ▸RateLimitError da retry_after (yoki 5 s) kutadi; boshqa API xatolarida socialift.telegram logger'iga ogohlantirish yozib, 5 s dan keyin qayta urinadi — noto'g'ri token yoki o'rnatilgan webhook siklni to'xtatmaydi, shuning uchun avval get_me() va get_webhook_info() ni tekshiring.
• ▸offset faqat xotirada saqlanadi: qayta ishga tushirilganda oxirgi tasdiqlanmagan paket yana kelishi mumkin — update_id bo'yicha dublikatni filtrlang.

Telegram'ga yangilanishlarni url manzilingizga HTTPS POST so'rovlari bilan yuborishni buyuradi (setWebhook). Har doim secret_token bering — kelgan so'rovni verify_webhook bilan tekshirasiz.

await bot.set_webhook(
    url: str,
    *,
    secret_token: Optional[str] = None,
    allowed_updates: Optional[list[str]] = None,
    drop_pending_updates: Optional[bool] = None,
    max_connections: Optional[int] = None,
    certificate: Union[bytes, socialift.telegram.InputFile, NoneType] = None,
    token: Optional[str] = None,
    ip_address: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Portlar: 443, 80, 88, 8443. secret_token — 1–256 belgi, faqat A-Z, a-z, 0-9, _ va -.
• ▸Webhook o'rnatilgan paytda get_updates va poll yangilanish olmaydi.
• ▸Standart holatda chat_member, message_reaction va message_reaction_count kelmaydi — ularni allowed_updates da aniq so'rang; parametr berilmasa oldingi sozlama saqlanadi.

await bot.set_webhook("https://siz.uz/tg", secret_token="...", allowed_updates=["message"])

Kelgan webhook so'rovidagi X-Telegram-Bot-Api-Secret-Token sarlavhasi set_webhook da berilgan secret_token ga tengligini tekshiradi va True/False qaytaradi. Sinxron statik metod, tarmoqqa murojaat qilmaydi.

Telegram.verify_webhook(headers, secret_token: str) -> bool

• ▸Bot API webhook tanasiga imzo qo'ymaydi (Meta'dagi X-Hub-Signature-256 kabi) — tekshiruv faqat shu sarlavha orqali, shuning uchun secret_token siz manzilni bilgan har kim soxta hodisa yubora oladi.
• ▸Taqqoslash doimiy vaqtda; bo'sh secret_token doim False beradi. Xuddi shu funksiya: socialift.webhooks.verify_telegram_request.
• ▸Framework'ning registrga sezgir bo'lmagan headers obyektini bering; oddiy dict'da faqat aynan X-Telegram-Bot-Api-Secret-Token va to'liq kichik harfli yozuv topiladi.

Xabarni asl manbaga havolasiz nusxalaydi (copyMessage) va to'liq Message emas, faqat yangi message_id (MessageId) qaytaradi. caption media izohini almashtiradi; berilmasa asl izoh qoladi.

await bot.copy_message(
    chat_id: Union[int, str],
    from_chat_id: Union[int, str],
    message_id: int,
    *,
    caption: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Servis, pullik media, giveaway, giveaway g'oliblari va invoice xabarlarini nusxalab bo'lmaydi.
• ▸Viktorina (quiz) faqat bot to'g'ri javoblarni (correct_option_ids) bilsa nusxalanadi.

1–100 ta xabarni asl manbaga havolasiz nusxalaydi (copyMessages), albom guruhlanishi saqlanadi. MessageId ro'yxatini qaytaradi.

await bot.copy_messages(
    chat_id: Union[int, str],
    from_chat_id: Union[int, str],
    message_ids: Iterable[int],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> list

• ▸ID'lar qat'iy o'sish tartibida; topilmagan yoki nusxalab bo'lmaydigan xabarlar tashlab ketiladi.

Bitta xabarni "Forwarded from" belgisi bilan boshqa chatga uzatadi (forwardMessage) va yangi Message'ni qaytaradi. Manba ko'rinmasligi kerak bo'lsa copy_message ishlating.

await bot.forward_message(
    chat_id: Union[int, str],
    from_chat_id: Union[int, str],
    message_id: int,
    *,
    message_thread_id: Optional[int] = None,
    disable_notification: Optional[bool] = None,
    protect_content: Optional[bool] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Servis xabarlar va himoyalangan (protected) kontentli xabarlarni forward qilib bo'lmaydi.
• ▸Bu o'ramda **extra yo'q — yangi parametrlar uchun call("forwardMessage", ...).

Bir so'rovda 1–100 ta xabarni uzatadi (forwardMessages) va MessageId obyektlari ro'yxatini (faqat ID) qaytaradi. Albom guruhlanishi saqlanadi.

await bot.forward_messages(
    chat_id: Union[int, str],
    from_chat_id: Union[int, str],
    message_ids: Iterable[int],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> list

• ▸ID'lar qat'iy o'sish tartibida bo'lishi shart.
• ▸Topilmagan yoki forward qilib bo'lmaydigan xabarlar xato bermay tashlab ketiladi.

SDK qisqartmasi: reply_parameters={"message_id": message_id} bilan send_message — yangi xabar ko'rsatilgan xabarga javob sifatida chiqadi. send_message ning boshqa argumentlari o'zgarishsiz uzatiladi.

await bot.reply(
    chat_id: Union[int, str],
    message_id: int,
    text: str,
    **kwargs: Any,
) -> dict

• ▸reply_parameters ni o'zingiz bermang — u allaqachon o'rnatilgan, takroriy argument Python'da TypeError beradi.

Bot javob tayyorlayotganda chatda "yozmoqda…", "rasm yubormoqda…" kabi holatni ko'rsatadi (sendChatAction). Standart amal — typing.

await bot.send_chat_action(
    chat_id: Union[int, str],
    action: str = 'typing',
    *,
    message_thread_id: Optional[int] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Holat 5 soniya yoki undan kam turadi va botdan xabar kelganda o'chadi — uzoq jarayonda takrorlang.
• ▸Amallar: typing, upload_photo, record_video, upload_video, record_voice, upload_voice, upload_document, choose_sticker, find_location, record_video_note, upload_video_note.

Telefon kontakti kartasini yuboradi (sendContact): phone_number, first_name, ixtiyoriy last_name. Yuborilgan Message'ni qaytaradi.

await bot.send_contact(
    chat_id: Union[int, str],
    phone_number: str,
    first_name: str,
    *,
    last_name: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

Tasodifiy qiymatli animatsion emoji yuboradi (sendDice): zar, dart, basketbol, futbol, bouling yoki slot-mashina. Natija qaytgan Message'dagi dice.value da.

await bot.send_dice(
    chat_id: Union[int, str],
    *,
    emoji: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Qiymatlar: 🎲 🎯 🎳 uchun 1–6, 🏀 ⚽ uchun 1–5, 🎰 uchun 1–64; standart emoji — 🎲.

Xaritadagi nuqtani yuboradi (sendLocation). live_period berilsa — jonli joylashuv bo'ladi va uni yangilab turish mumkin.

await bot.send_location(
    chat_id: Union[int, str],
    latitude: float,
    longitude: float,
    *,
    live_period: Optional[int] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸live_period — 60–86400 soniya yoki cheksiz tahrirlanadigan jonli joylashuv uchun 0x7FFFFFFF.
• ▸Jonli joylashuvni yangilash: call("editMessageLiveLocation", ...).

Foydalanuvchi, guruh yoki kanalga matnli xabar yuboradi (sendMessage) va yuborilgan Message dict'ini qaytaradi. chat_id — raqamli ID yoki ommaviy kanal/supergroup'ning @username'i.

await bot.send_message(
    chat_id: Union[int, str],
    text: str,
    *,
    parse_mode: Optional[str] = None,
    entities: Optional[list] = None,
    link_preview_options: Optional[dict] = None,
    disable_notification: Optional[bool] = None,
    protect_content: Optional[bool] = None,
    message_thread_id: Optional[int] = None,
    reply_parameters: Optional[dict] = None,
    reply_markup: Optional[dict] = None,
    business_connection_id: Optional[str] = None,
    message_effect_id: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Matn — entity'lar ajratilgandan keyin 1–4096 belgi; parse_mode: HTML, MarkdownV2 yoki eski Markdown.
• ▸Guruh supergroup'ga aylanganda ID o'zgaradi: eski ID bilan so'rov ApiError beradi, yangi ID exc.payload["parameters"]["migrate_to_chat_id"] da.
• ▸message_thread_id — forum mavzusi; imzoda yo'q parametrlar (masalan, allow_paid_broadcast) **extra orqali beriladi.

await bot.send_message("@mening_kanalim", "Salom!", parse_mode="HTML")

So'rovnoma yuboradi (sendPoll) — oddiy yoki type="quiz" bilan viktorina. poll obyekti bor Message'ni qaytaradi.

await bot.send_poll(
    chat_id: Union[int, str],
    question: str,
    options: list,
    *,
    is_anonymous: Optional[bool] = None,
    allows_multiple_answers: Optional[bool] = None,
    type: Optional[str] = None,
    correct_option_id: Optional[int] = None,
    token: Optional[str] = None,
    correct_option_ids: Optional[Sequence[int]] = None,
    **extra: Any,
) -> dict

• ▸Savol — 1–300 belgi; options — 1–12 ta, rasmiy formati InputPollOption: [{"text": "Ha"}, {"text": "Yo'q"}].
• ▸Bot API 9.6 dan viktorina correct_option_id o'rniga correct_option_ids (ro'yxat) oladi — uni **extra orqali bering: correct_option_ids=[0].
• ▸So'rovnomalar standart holatda anonim (is_anonymous — true).

Joy (venue) yuboradi (sendVenue) — nomi (title) va manzili (address) bo'lgan xarita nuqtasi. Yuborilgan Message'ni qaytaradi.

await bot.send_venue(
    chat_id: Union[int, str],
    latitude: float,
    longitude: float,
    title: str,
    address: str,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

Xabarga bot reaksiyasini qo'yadi (setMessageReaction), masalan reaction=[{"type": "emoji", "emoji": "👍"}]; is_big=True katta animatsiya bilan.

await bot.set_reaction(
    chat_id: Union[int, str],
    message_id: int,
    *,
    reaction: Optional[list] = None,
    is_big: Optional[bool] = None,
    token: Optional[str] = None,
) -> bool

• ▸Bot (premium bo'lmagan foydalanuvchi sifatida) bitta xabarga ko'pi bilan bitta reaksiya qo'ya oladi va pullik reaksiyalardan foydalana olmaydi.
• ▸Custom emoji reaksiyasi faqat xabarda allaqachon bo'lsa yoki chat adminlari ruxsat bergan bo'lsa ishlaydi.

Bot yuborgan so'rovnomani yopadi (stopPoll) va natijalari bilan yakuniy Poll obyektini qaytaradi.

await bot.stop_poll(
    chat_id: Union[int, str],
    message_id: int,
    *,
    reply_markup: Optional[dict] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

SDK yordamchisi: getFile ni chaqirib, faylni yuklab oladi va tarkibini bytes sifatida qaytaradi. Foydalanuvchi botga yuborgan rasm yoki hujjatni saqlash uchun qulay.

await bot.download(file_id: str, *, token: Optional[str] = None) -> bytes

• ▸Bulutli Bot API'ning 20 MB limiti amal qiladi; fayl to'liq xotiraga o'qiladi.
• ▸HTTP xatosida ApiError ko'tariladi, url dagi token <token> bilan yashirilgan.

Fayl metama'lumotini qaytaradi (getFile), jumladan yuklab olish uchun kerak bo'lgan file_path. Baytlarni bir qadamda olish uchun download() qulayroq.

await bot.get_file(file_id: str, *, token: Optional[str] = None) -> dict

• ▸Yuklab olish havolasi kamida 1 soat amal qiladi; muddati o'tsa getFile ni qayta chaqiring.
• ▸Bulutli Bot API orqali bot 20 MB gacha faylni yuklab oladi.
• ▸Asl fayl nomi va MIME turi saqlanmasligi mumkin — ularni kelgan xabardan o'zingiz saqlang.

Foydalanuvchining profil rasmlarini qaytaradi (getUserProfilePhotos): total_count va photos (har rasm bir necha o'lchamda). Sahifalash uchun offset va limit (1–100, standart 100).

await bot.get_user_profile_photos(
    user_id: int,
    *,
    offset: Optional[int] = None,
    limit: Optional[int] = None,
    token: Optional[str] = None,
) -> dict

GIF yoki ovozsiz H.264/MPEG-4 AVC videoni animatsiya sifatida yuboradi (sendAnimation). Yuklanganda 50 MB gacha.

await bot.send_animation(
    chat_id: Union[int, str],
    animation: Union[str, bytes, socialift.telegram.InputFile],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

Musiqa faylini yuboradi (sendAudio) — Telegram uni pleyerda ko'rsatadi. Format: .MP3 yoki .M4A, yuklanganda 50 MB gacha; ovozli xabar uchun send_voice.

await bot.send_audio(
    chat_id: Union[int, str],
    audio: Union[str, bytes, socialift.telegram.InputFile],
    *,
    caption: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

Istalgan faylni hujjat sifatida yuboradi (sendDocument) va document obyekti bor Message'ni qaytaradi. Yuklanganda 50 MB gacha.

await bot.send_document(
    chat_id: Union[int, str],
    document: Union[str, bytes, socialift.telegram.InputFile],
    *,
    caption: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Havola orqali faqat .PDF va .ZIP fayllar ishlashi kafolatlangan.
• ▸Xom bytes berilsa SDK fayl nomi sifatida parametr nomini (document) qo'yadi; to'g'ri nom uchun InputFile(content=..., filename="hisobot.pdf") ishlating.

with open("hisobot.pdf", "rb") as f:
    await bot.send_document("@kanal", f.read(), caption="Hisobot")

2–10 ta rasm, video, hujjat yoki audiodan albom yuboradi (sendMediaGroup) va Message'lar ro'yxatini qaytaradi. Baytlarni yuklash uchun elementda "media": "attach://nom" yozing va nom=InputFile(...) ni qo'shimcha argument qilib bering.

await bot.send_media_group(
    chat_id: Union[int, str],
    media: list,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> list

• ▸Hujjat va audio faqat o'z turidagi elementlar bilan guruhlanadi.
• ▸Element — InputMedia* dict, masalan {"type": "photo", "media": "<file_id yoki URL>", "caption": "..."}.

Rasm yuboradi (sendPhoto): file_id, HTTP(S) havola, bytes yoki InputFile — fayl berilsa SDK o'zi multipart yuklashga o'tadi. has_spoiler=True rasmni spoiler ostida yashiradi.

await bot.send_photo(
    chat_id: Union[int, str],
    photo: Union[str, bytes, socialift.telegram.InputFile],
    *,
    caption: Optional[str] = None,
    parse_mode: Optional[str] = None,
    has_spoiler: Optional[bool] = None,
    reply_markup: Optional[dict] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Yuklanganda 10 MB gacha, havola orqali 5 MB gacha; eni + bo'yi ≤ 10000, tomonlar nisbati ≤ 20.
• ▸Izoh (caption) — 0–1024 belgi.
• ▸Javobdagi file_id bilan xuddi shu faylni qayta yuklamasdan yuborish mumkin (u faqat shu bot uchun amal qiladi).

Stiker yuboradi (sendSticker): statik .WEBP, animatsion .TGS yoki video .WEBM. Yuborilgan Message'ni qaytaradi.

await bot.send_sticker(
    chat_id: Union[int, str],
    sticker: Union[str, bytes, socialift.telegram.InputFile],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Havola orqali faqat .WEBP stikerlarni yuborish mumkin.

MPEG4 video yuboradi (sendVideo); boshqa formatlarni hujjat sifatida yuborish mumkin. duration, width, height, supports_streaming va thumbnail ixtiyoriy.

await bot.send_video(
    chat_id: Union[int, str],
    video: Union[str, bytes, socialift.telegram.InputFile],
    *,
    caption: Optional[str] = None,
    duration: Optional[int] = None,
    width: Optional[int] = None,
    height: Optional[int] = None,
    supports_streaming: Optional[bool] = None,
    thumbnail: Union[str, bytes, socialift.telegram.InputFile, NoneType] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Yuklanganda 50 MB gacha, havola orqali 20 MB gacha.
• ▸thumbnail — JPEG, 200 kB dan kichik, ko'pi bilan 320×320; faqat video fayl sifatida yuklanganda hisobga olinadi.

Dumaloq video xabar yuboradi (sendVideoNote) — kvadrat MPEG4 video, 1 daqiqagacha.

await bot.send_video_note(
    chat_id: Union[int, str],
    video_note: Union[str, bytes, socialift.telegram.InputFile],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Havola orqali yuborib bo'lmaydi — file_id yoki yuklanadigan fayl (bytes/InputFile) bering.

Ijro etiladigan ovozli xabar yuboradi (sendVoice). Bot API OPUS kodekli .OGG, .MP3 yoki .M4A qabul qiladi; boshqa formatlar audio yoki hujjat bo'lib yuborilishi mumkin.

await bot.send_voice(
    chat_id: Union[int, str],
    voice: Union[str, bytes, socialift.telegram.InputFile],
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Yuklanganda 50 MB gacha; havola orqali fayl audio/ogg va ko'pi bilan 1 MB bo'lishi kerak (1–20 MB lik fayl hujjat bo'lib boradi).

Bitta xabarni, jumladan servis xabarni o'chiradi (deleteMessage). Muvaffaqiyatda True qaytaradi.

await bot.delete_message(
    chat_id: Union[int, str],
    message_id: int,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Faqat 48 soatdan kam vaqt oldin yuborilgan xabarni o'chirish mumkin.
• ▸Shaxsiy chatda bot o'z xabarini ham, kelgan xabarni ham o'chira oladi; guruhda boshqalarning xabarini faqat admin sifatida, supergroup va kanalda esa can_delete_messages huquqi bilan.
• ▸Supergroup, kanal yoki forum mavzusi yaratilgani haqidagi servis xabarlar o'chirilmaydi.

Bir so'rovda 1–100 ta xabarni o'chiradi (deleteMessages); cheklovlar delete_message bilan bir xil. True qaytaradi.

await bot.delete_messages(
    chat_id: Union[int, str],
    message_ids: Iterable[int],
    *,
    token: Optional[str] = None,
) -> bool

• ▸Topilmagan xabarlar tashlab ketiladi.

await bot.delete_messages("@kanal", [41, 42])

Media xabarning izohini (caption) o'zgartiradi (editMessageCaption). Xabarni ko'rsatish usuli edit_message_text bilan bir xil.

await bot.edit_message_caption(
    *,
    caption: Optional[str] = None,
    chat_id: Union[int, str, NoneType] = None,
    message_id: Optional[int] = None,
    inline_message_id: Optional[str] = None,
    parse_mode: Optional[str] = None,
    reply_markup: Optional[dict] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> Any

• ▸Izoh — 0–1024 belgi; Message yoki inline xabar uchun True qaytaradi.

Xabardagi mediani (animatsiya, audio, hujjat, rasm, video) almashtiradi yoki matnli xabarni media xabarga aylantiradi (editMessageMedia). media — InputMedia dict, masalan {"type": "photo", "media": "<file_id yoki URL>"}.

await bot.edit_message_media(
    media: dict,
    *,
    chat_id: Union[int, str, NoneType] = None,
    message_id: Optional[int] = None,
    inline_message_id: Optional[str] = None,
    reply_markup: Optional[dict] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> Any

• ▸Albomda audio faqat audioga, hujjat faqat hujjatga, rasm/video esa rasm yoki videoga almashtiriladi.
• ▸Bu o'ram qo'shimcha argument olmaydi, shuning uchun yangi faylni attach:// bilan yuklash: call("editMessageMedia", ..., media={"type": "photo", "media": "attach://p"}, p=InputFile(...)).
• ▸Inline xabarda yangi fayl yuklab bo'lmaydi — file_id yoki URL ishlating.

Xabar matniga tegmasdan faqat inline klaviaturasini (reply_markup) almashtiradi (editMessageReplyMarkup) — masalan, callback'dan keyin tugmalarni yangilash uchun.

await bot.edit_message_reply_markup(
    *,
    reply_markup: Optional[dict] = None,
    chat_id: Union[int, str, NoneType] = None,
    message_id: Optional[int] = None,
    inline_message_id: Optional[str] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> Any

• ▸Message yoki inline xabar uchun True qaytaradi.

Xabar matnini tahrirlaydi (editMessageText). Xabar chat_id + message_id yoki inline rejimda yuborilgan bo'lsa inline_message_id bilan ko'rsatiladi.

await bot.edit_message_text(
    text: str,
    *,
    chat_id: Union[int, str, NoneType] = None,
    message_id: Optional[int] = None,
    inline_message_id: Optional[str] = None,
    parse_mode: Optional[str] = None,
    reply_markup: Optional[dict] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> Any

• ▸Tahrirlangan Message'ni, inline xabar uchun esa True qaytaradi.
• ▸Bot yubormagan va inline klaviaturasi yo'q business xabarlarni faqat 48 soat ichida tahrirlash mumkin.

await bot.edit_message_text("Yangi matn", chat_id="@kanal", message_id=42)

Xabarni chatda qadaydi (pinChatMessage); disable_notification=True — a'zolarga bildirishnomasiz.

await bot.pin_message(
    chat_id: Union[int, str],
    message_id: int,
    *,
    disable_notification: Optional[bool] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Guruhda bot can_pin_messages, kanalda can_edit_messages huquqli admin bo'lishi kerak; shaxsiy chatda huquq kerak emas.

await bot.pin_message("@kanal", 42, disable_notification=True)

Chatdagi barcha qadalgan xabarlarni olib tashlaydi (unpinAllChatMessages).

await bot.unpin_all_messages(
    chat_id: Union[int, str],
    *,
    token: Optional[str] = None,
) -> bool

• ▸Guruhda can_pin_messages, kanalda can_edit_messages huquqi kerak; shaxsiy chatda — kerak emas.

Xabarni qadalganlar ro'yxatidan olib tashlaydi (unpinChatMessage). message_id berilmasa — yuborilgan sanasi bo'yicha eng oxirgi qadalgan xabar.

await bot.unpin_message(
    chat_id: Union[int, str],
    *,
    message_id: Optional[int] = None,
    token: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Huquqlar pin_message dagidek: guruhda can_pin_messages, kanalda can_edit_messages.

await bot.unpin_message("@kanal", message_id=42)

Foydalanuvchini ban qiladi (banChatMember): supergroup va kanalda ban olinmaguncha u taklif havolasi orqali ham qaytolmaydi. revoke_messages=True uning guruhdagi xabarlarini o'chiradi (supergroup va kanalda doim shunday).

await bot.ban_member(
    chat_id: Union[int, str],
    user_id: int,
    *,
    until_date: Optional[int] = None,
    revoke_messages: Optional[bool] = None,
    token: Optional[str] = None,
) -> bool

• ▸until_date — unix vaqt; hozirdan 30 soniyadan kam yoki 366 kundan ko'p bo'lsa ban abadiy (faqat supergroup va kanal uchun).
• ▸Shunchaki chiqarib yuborish (qaytishi mumkin) uchun: ban_member, so'ng unban_member.
• ▸Bot tegishli huquqli admin bo'lishi kerak.

await bot.ban_member("@guruh", 123456789)
await bot.unban_member("@guruh", 123456789)

Chat rasmini o'chiradi (deleteChatPhoto). Shaxsiy chatlarda ishlamaydi; bot tegishli huquqli admin bo'lishi kerak.

await bot.delete_chat_photo(
    chat_id: Union[int, str],
    *,
    token: Optional[str] = None,
) -> bool

SDK yordamchisi: barcha admin huquqlarini False qilib promoteChatMember ni chaqiradi va foydalanuvchini adminlikdan tushiradi.

await bot.demote_member(
    chat_id: Union[int, str],
    user_id: int,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Bot can_promote_members huquqiga ega bo'lishi kerak va faqat o'zi (bevosita yoki bilvosita) tayinlagan adminlarni tushira oladi.

Chat haqida dolzarb to'liq ma'lumotni qaytaradi (getChat, ChatFullInfo): turi, nomi, tavsifi, qadalgan xabar, ruxsatlar va boshqalar. @username dan raqamli id ni bilishning ham qulay yo'li.

await bot.get_chat(chat_id: Union[int, str], *, token: Optional[str] = None) -> dict

chat = await bot.get_chat("@kanal")

Chat adminlari ro'yxatini ChatMember dict'lari sifatida qaytaradi (getChatAdministrators): holati, huquqlari, custom_title.

await bot.get_chat_administrators(
    chat_id: Union[int, str],
    *,
    token: Optional[str] = None,
    return_bots: Optional[bool] = None,
    **extra: Any,
) -> list

• ▸Boshqa botlar standart holatda ro'yxatga kirmaydi; ularni olish uchun call("getChatAdministrators", chat_id=..., return_bots=True) — bu o'ram qo'shimcha argument olmaydi.
• ▸Bot API barcha a'zolar ro'yxatini beradigan metodga ega emas; buning uchun akkaunt klienti TelegramAccount.participants.

admins = await bot.get_chat_administrators("@guruh")

Bitta a'zoning holatini qaytaradi (getChatMember): creator, administrator, member, restricted, left yoki kicked, huquqlari bilan. Ko'pincha kanalga obuna bo'lganini tekshirish uchun ishlatiladi.

await bot.get_chat_member(
    chat_id: Union[int, str],
    user_id: int,
    *,
    token: Optional[str] = None,
) -> dict

• ▸Boshqa foydalanuvchilar uchun faqat bot shu chatda admin bo'lsa ishlashi kafolatlangan.

member = await bot.get_chat_member("@guruh", 123456789)

Chatdagi a'zolar sonini butun son sifatida qaytaradi (getChatMemberCount).

await bot.get_chat_member_count(
    chat_id: Union[int, str],
    *,
    token: Optional[str] = None,
) -> int

Botni guruh, supergroup yoki kanaldan chiqaradi (leaveChat).

await bot.leave_chat(chat_id: Union[int, str], *, token: Optional[str] = None) -> bool

Foydalanuvchini admin qiladi yoki huquqlarini o'zgartiradi (promoteChatMember); huquqlar keyword argument sifatida: can_delete_messages=True, can_restrict_members=True va h.k.

await bot.promote_member(
    chat_id: Union[int, str],
    user_id: int,
    *,
    token: Optional[str] = None,
    **rights: Any,
) -> bool

• ▸Supergroup va kanalda ishlaydi; bot tegishli huquqli admin bo'lishi va faqat o'zida bor huquqlarni berishi mumkin (can_promote_members).
• ▸Barcha huquqlarga False berish — adminlikdan tushirish; buni demote_member qiladi.

Supergroup a'zosini permissions dict'i bilan cheklaydi (restrictChatMember) — masalan, {"can_send_messages": False} bilan ovozini o'chirish. Cheklovni olib tashlash uchun barcha ruxsatlarga True bering.

await bot.restrict_member(
    chat_id: Union[int, str],
    user_id: int,
    permissions: dict,
    *,
    until_date: Optional[int] = None,
    use_independent_chat_permissions: Optional[bool] = None,
    token: Optional[str] = None,
) -> bool

• ▸until_date: hozirdan 30 soniyadan kam yoki 366 kundan ko'p bo'lsa cheklov abadiy.
• ▸Bot tegishli huquqli admin bo'lishi kerak.

Bot tayinlagan supergroup adminiga maxsus unvon (custom title) o'rnatadi (setChatAdministratorCustomTitle).

await bot.set_admin_title(
    chat_id: Union[int, str],
    user_id: int,
    custom_title: str,
    *,
    token: Optional[str] = None,
) -> bool

• ▸0–16 belgi, emoji mumkin emas.

Guruh, supergroup yoki kanal tavsifini o'zgartiradi (setChatDescription), 0–255 belgi.

await bot.set_chat_description(
    chat_id: Union[int, str],
    description: str,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Bot tegishli huquqli admin bo'lishi kerak.

await bot.set_chat_title("@kanal", "Yangi nom")
await bot.set_chat_description("@kanal", "Tavsif")

Guruh yoki supergroup'ning barcha oddiy a'zolari uchun standart ruxsatlarni o'rnatadi (setChatPermissions), masalan {"can_send_messages": False} — chat faqat o'qish uchun.

await bot.set_chat_permissions(
    chat_id: Union[int, str],
    permissions: dict,
    *,
    use_independent_chat_permissions: Optional[bool] = None,
    token: Optional[str] = None,
) -> bool

• ▸Bot can_restrict_members huquqli admin bo'lishi kerak.
• ▸use_independent_chat_permissions=True bo'lmasa, can_send_other_messages va can_add_web_page_previews media ruxsatlarini, can_send_polls esa can_send_messages ni ham yoqadi.

Chatga yangi rasm o'rnatadi (setChatPhoto). Faqat yuklanadigan fayl (bytes yoki InputFile) qabul qilinadi — file_id yoki URL emas.

await bot.set_chat_photo(
    chat_id: Union[int, str],
    photo: Union[bytes, socialift.telegram.InputFile],
    *,
    token: Optional[str] = None,
) -> bool

• ▸Shaxsiy chatlarda ishlamaydi; bot tegishli huquqli admin bo'lishi kerak.

Chat nomini o'zgartiradi (setChatTitle), 1–128 belgi. Shaxsiy chatlarda ishlamaydi.

await bot.set_chat_title(
    chat_id: Union[int, str],
    title: str,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Bot tegishli huquqli admin bo'lishi kerak.

await bot.set_chat_title("@kanal", "Yangi nom")
await bot.set_chat_description("@kanal", "Tavsif")

Supergroup yoki kanalda ban'ni olib tashlaydi (unbanChatMember); foydalanuvchi avtomatik qaytmaydi, lekin havola orqali qo'shila oladi.

await bot.unban_member(
    chat_id: Union[int, str],
    user_id: int,
    *,
    only_if_banned: bool = True,
    token: Optional[str] = None,
) -> bool

• ▸SDK'da only_if_banned=True standart (Bot API'da — false): ban'da bo'lmagan hozirgi a'zo adashib chiqarib yuborilmaydi.
• ▸only_if_banned=False da Telegram a'zo hali chatda bo'lsa uni chiqaradi — natijada u chatda emas, lekin qo'shila oladi.

await bot.ban_member("@guruh", 123456789)
await bot.unban_member("@guruh", 123456789)

Qo'shilish so'rovini tasdiqlaydi (approveChatJoinRequest) — masalan, creates_join_request=True havolasidan kelgan chat_join_request yangilanishiga javoban.

await bot.approve_join_request(
    chat_id: Union[int, str],
    user_id: int,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Bot can_invite_users huquqli admin bo'lishi kerak; shu huquqsiz chat_join_request yangilanishlari ham kelmaydi.

Qo'shimcha taklif havolasini yaratadi (createChatInviteLink) — name, expire_date, member_limit yoki creates_join_request bilan — va ChatInviteLink dict qaytaradi. Masalan, har reklama kampaniyasi uchun alohida havola.

await bot.create_invite_link(
    chat_id: Union[int, str],
    *,
    name: Optional[str] = None,
    expire_date: Optional[int] = None,
    member_limit: Optional[int] = None,
    creates_join_request: Optional[bool] = None,
    token: Optional[str] = None,
) -> dict

• ▸name — 0–32 belgi, member_limit — 1–99999; creates_join_request=True bilan member_limit berilmaydi.
• ▸Bot tegishli huquqli admin bo'lishi kerak.

link = await bot.create_invite_link("@guruh", name="Reklama", member_limit=100)

Qo'shilish so'rovini rad etadi (declineChatJoinRequest).

await bot.decline_join_request(
    chat_id: Union[int, str],
    user_id: int,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Bot can_invite_users huquqli admin bo'lishi kerak.

Bot yaratgan asosiy bo'lmagan havolani tahrirlaydi (editChatInviteLink): name, expire_date, member_limit, creates_join_request keyword argument sifatida. Yangilangan ChatInviteLink'ni qaytaradi.

await bot.edit_invite_link(
    chat_id: Union[int, str],
    invite_link: str,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

Yangi asosiy taklif havolasini yaratadi va satr sifatida qaytaradi (exportChatInviteLink). Avval yaratilgan asosiy havola bekor qilinadi.

await bot.export_invite_link(
    chat_id: Union[int, str],
    *,
    token: Optional[str] = None,
) -> str

• ▸Bot boshqa adminlar yaratgan havolalardan foydalana olmaydi. Mavjud havolalarni buzmaydigan qo'shimcha havola uchun create_invite_link.
• ▸Bot tegishli huquqli admin bo'lishi kerak.

Bot yaratgan taklif havolasini bekor qiladi va uni qaytaradi (revokeChatInviteLink). Asosiy havola bekor qilinsa, Telegram avtomatik yangisini yaratadi.

await bot.revoke_invite_link(
    chat_id: Union[int, str],
    invite_link: str,
    *,
    token: Optional[str] = None,
) -> dict

Forum supergroup'da yoki foydalanuvchi bilan shaxsiy chatda mavzu yaratadi (createForumTopic) va message_thread_id bor ForumTopic dict qaytaradi. icon_color va icon_custom_emoji_id — **extra orqali.

await bot.create_forum_topic(
    chat_id: Union[int, str],
    name: str,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> dict

• ▸Nom — 1–128 belgi.
• ▸Supergroup'da bot can_manage_topics huquqli admin bo'lishi kerak.
• ▸Mavzuga yozish: send_message(..., message_thread_id=...).

Forum mavzusini undagi barcha xabarlar bilan birga o'chiradi (deleteForumTopic).

await bot.delete_forum_topic(
    chat_id: Union[int, str],
    message_thread_id: int,
    *,
    token: Optional[str] = None,
) -> bool

• ▸Supergroup'da bot can_delete_messages huquqli admin bo'lishi kerak.

Mavzu nomini (name) yoki ikonkasini (icon_custom_emoji_id) o'zgartiradi (editForumTopic); berilmagan maydonlar o'zgarmaydi.

await bot.edit_forum_topic(
    chat_id: Union[int, str],
    message_thread_id: int,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Supergroup'da can_manage_topics huquqi kerak, agar mavzuni botning o'zi yaratmagan bo'lsa.

Inline tugma bosilishiga javob beradi (answerCallbackQuery): ixtiyoriy qisqa bildirishnoma (text) yoki oyna (show_alert=True). Har bir callback_query uchun, matnsiz bo'lsa ham, chaqiring.

await bot.answer_callback_query(
    callback_query_id: str,
    *,
    text: Optional[str] = None,
    show_alert: Optional[bool] = None,
    url: Optional[str] = None,
    cache_time: Optional[int] = None,
    token: Optional[str] = None,
) -> bool

• ▸Javob berilmaguncha Telegram ilovalari tugmada yuklanish indikatorini ko'rsatib turadi.
• ▸text — 0–200 belgi; cache_time (soniya) standart 0.

Inline so'rovga (istalgan chatda @bot_nomi so'rov yozilganda) natijalarni yuboradi (answerInlineQuery). results — InlineQueryResult dict'lari ro'yxati; cache_time, is_personal, next_offset — **extra orqali.

await bot.answer_inline_query(
    inline_query_id: str,
    results: list,
    *,
    token: Optional[str] = None,
    **extra: Any,
) -> bool

• ▸Bir so'rovga ko'pi bilan 50 ta natija; serverdagi cache_time standart 300 soniya.
• ▸Inline rejim @BotFather'da /setinline bilan yoqiladi.

Bot API'ning istalgan metodini nomi bo'yicha chaqiradi va result ni qaytaradi — alohida o'rami yo'q metodlar uchun, masalan await bot.call("getChatMenuButton", chat_id=...). None qiymatli argumentlar tashlanadi, bytes/InputFile bo'lsa so'rov avtomatik multipart bo'ladi.

await bot.call(method: str, *, token: Optional[str] = None, **params: Any) -> Any

• ▸Xatolar: 401 → AuthError, 403 → PermissionError, 404 yoki tavsifda "not found" → NotFoundError, 429 → RateLimitError; qolganlari ApiError, xom javob exc.payload da.
• ▸ApiError.url da token <token> bilan almashtiriladi.
• ▸O'ralmagan metodlar atribut sifatida ham ishlaydi: bot.get_chat_menu_button(chat_id=1) → getChatMenuButton (faqat keyword argumentlar).

commands = await bot.call("getMyCommands")

Istalgan HTTP so'rovni yuboradi va JSON javobni qaytaradi — SDK'da hali alohida metodi yo'q endpoint uchun. Token va imzo parametrlarini (access_token, Meta uchun appsecret_proof — socialift.crypto.appsecret_proof) o'zingiz params yoki headers ga qo'shasiz.

await bot.request(
    method: str,
    url: str,
    *,
    params: Optional[Mapping[str, Any]] = None,
    data: Optional[Any] = None,
    json: Optional[Any] = None,
    headers: Optional[Mapping[str, str]] = None,
) -> Any

• ▸params dagi None qiymatlar yuborilmaydi.
• ▸Limit (RateLimitError) va vaqtinchalik server xatolarida (HTTP 429, 500, 502, 503, 504) RetryPolicy bo'yicha qayta uriniladi; Retry-After sarlavhasi bo'lsa, shuncha kutiladi. Tarmoq uzilishi TransportError bo'lib chiqadi.

request("GET", ...) ning qisqa shakli.

await bot.get(url: str, **kw) -> Any

request("POST", ...) ning qisqa shakli.

await bot.post(url: str, **kw) -> Any

request("DELETE", ...) ning qisqa shakli.

await bot.delete(url: str, **kw) -> Any

Meta'ning kursorli sahifalashi (paging.next) bo'yicha yurib, barcha data elementlarini bitta ro'yxatga yig'ib qaytaradi.

await bot.paginate(
    url: str,
    *,
    params: Optional[Mapping[str, Any]] = None,
    max_items: int = 500,
    page_size: int = 100,
) -> list[dict]

• ▸max_items (standart 500) — himoya chegarasi: yirik akkauntda ro'yxat o'n minglab yozuv bo'lishi mumkin. page_size — bitta so'rovdagi limit.

SDK o'zi yaratgan HTTP sessiyasini yopadi (tashqaridan berilgan sessiyaga tegmaydi). async with Client(...) ishlatilsa, o'zi chaqiriladi.

await bot.close() -> None