#!/usr/bin/env python

# pylint: disable=redefined-builtin

#

# A library that provides a Python interface to the Telegram Bot API

# Copyright (C) 2015-2026

# Leandro Toledo de Souza <devs@python-telegram-bot.org>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Lesser Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU Lesser Public License for more details.

#

# You should have received a copy of the GNU Lesser Public License

# along with this program. If not, see [http://www.gnu.org/licenses/].

"""This module contains an object that represents a Telegram Chat."""

import datetime as dtm

from collections.abc import Sequence

from html import escape

from typing import TYPE_CHECKING, Final

from telegram import constants

from telegram._chatpermissions import ChatPermissions

from telegram._forumtopic import ForumTopic

from telegram._menubutton import MenuButton

from telegram._reaction import ReactionType

from telegram._telegramobject import TelegramObject

from telegram._utils import enum

from telegram._utils.defaultvalue import DEFAULT_NONE

from telegram._utils.types import (

CorrectOptionIds,

FileInput,

JSONDict,

ODVInput,

TimePeriod,

)

from telegram._utils.usernames import get_full_name, get_link

from telegram.helpers import escape_markdown

from telegram.helpers import mention_html as helpers_mention_html

from telegram.helpers import mention_markdown as helpers_mention_markdown

if TYPE_CHECKING:

from telegram import (

Animation,

Audio,

ChatInviteLink,

ChatMember,

Contact,

Document,

Gift,

InlineKeyboardMarkup,

InputChecklist,

InputMediaAudio,

InputMediaDocument,

InputMediaLivePhoto,

InputMediaPhoto,

InputMediaVideo,

InputPaidMedia,

InputPollMedia,

InputPollOption,

LabeledPrice,

LinkPreviewOptions,

LivePhoto,

Location,

Message,

MessageEntity,

MessageId,

OwnedGifts,

PhotoSize,

ReplyParameters,

Sticker,

Story,

SuggestedPostParameters,

UserChatBoosts,

Venue,

Video,

VideoNote,

Voice,

)

from telegram._utils.types import ReplyMarkup

class _ChatBase(TelegramObject):

"""Base class for :class:`telegram.Chat` and :class:`telegram.ChatFullInfo`.

.. versionadded:: 21.3

"""

__slots__ = (

"first_name",

"id",

"is_direct_messages",

"is_forum",

"last_name",

"title",

"type",

"username",

)

def __init__(

self,

id: int,

type: str,

title: str | None = None,

username: str | None = None,

first_name: str | None = None,

last_name: str | None = None,

is_forum: bool | None = None,

is_direct_messages: bool | None = None,

*,

api_kwargs: JSONDict | None = None,

):

super().__init__(api_kwargs=api_kwargs)

# Required

self.id: int = id

self.type: str = enum.get_member(constants.ChatType, type, type)

# Optionals

self.title: str | None = title

self.username: str | None = username

self.first_name: str | None = first_name

self.last_name: str | None = last_name

self.is_forum: bool | None = is_forum

self.is_direct_messages: bool | None = is_direct_messages

self._id_attrs = (self.id,)

self._freeze()

SENDER: Final[str] = constants.ChatType.SENDER

""":const:`telegram.constants.ChatType.SENDER`

.. versionadded:: 13.5

"""

PRIVATE: Final[str] = constants.ChatType.PRIVATE

""":const:`telegram.constants.ChatType.PRIVATE`"""

GROUP: Final[str] = constants.ChatType.GROUP

""":const:`telegram.constants.ChatType.GROUP`"""

SUPERGROUP: Final[str] = constants.ChatType.SUPERGROUP

""":const:`telegram.constants.ChatType.SUPERGROUP`"""

CHANNEL: Final[str] = constants.ChatType.CHANNEL

""":const:`telegram.constants.ChatType.CHANNEL`"""

@property

def effective_name(self) -> str | None:

"""

:obj:`str`: Convenience property. Gives :attr:`~Chat.title` if not :obj:`None`,

else :attr:`~Chat.full_name` if not :obj:`None`.

.. versionadded:: 20.1

"""

if self.title is not None:

return self.title

if self.full_name is not None:

return self.full_name

return None

@property

def full_name(self) -> str | None:

"""

:obj:`str`: Convenience property. If :attr:`~Chat.first_name` is not :obj:`None`, gives

:attr:`~Chat.first_name` followed by (if available) :attr:`~Chat.last_name`.

Note:

:attr:`full_name` will always be :obj:`None`, if the chat is a (super)group or

channel.

.. versionadded:: 13.2

"""

return get_full_name(self)

@property

def link(self) -> str | None:

""":obj:`str`: Convenience property. If the chat has a :attr:`~Chat.username`, returns a

t.me link of the chat.

"""

return get_link(self)

def mention_markdown(self, name: str | None = None) -> str:

"""

Note:

:tg-const:`telegram.constants.ParseMode.MARKDOWN` is a legacy mode, retained by

Telegram for backward compatibility. You should use :meth:`mention_markdown_v2`

instead.

.. versionadded:: 20.0

Args:

name (:obj:`str`): The name used as a link for the chat. Defaults to

:attr:`~Chat.full_name`.

Returns:

:obj:`str`: The inline mention for the chat as markdown (version 1).

Raises:

:exc:`TypeError`: If the chat is a private chat and neither the :paramref:`name`

nor the :attr:`~Chat.first_name` is set, then throw an :exc:`TypeError`.

If the chat is a public chat and neither the :paramref:`name` nor the

:attr:`~Chat.title` is set, then throw an :exc:`TypeError`. If chat is a

private group chat, then throw an :exc:`TypeError`.

"""

if self.type == self.PRIVATE:

if name:

return helpers_mention_markdown(self.id, name)

if self.full_name:

return helpers_mention_markdown(self.id, self.full_name)

raise TypeError("Can not create a mention to a private chat without first name")

if self.username:

if name:

return f"[{name}]({self.link})"

if self.title:

return f"[{self.title}]({self.link})"

raise TypeError("Can not create a mention to a public chat without title")

raise TypeError("Can not create a mention to a private group chat")

def mention_markdown_v2(self, name: str | None = None) -> str:

"""

.. versionadded:: 20.0

Args:

name (:obj:`str`): The name used as a link for the chat. Defaults to

:attr:`~Chat.full_name`.

Returns:

:obj:`str`: The inline mention for the chat as markdown (version 2).

Raises:

:exc:`TypeError`: If the chat is a private chat and neither the :paramref:`name`

nor the :attr:`~Chat.first_name` is set, then throw an :exc:`TypeError`.

If the chat is a public chat and neither the :paramref:`name` nor the

:attr:`~Chat.title` is set, then throw an :exc:`TypeError`. If chat is a

private group chat, then throw an :exc:`TypeError`.

"""

if self.type == self.PRIVATE:

if name:

return helpers_mention_markdown(self.id, name, version=2)

if self.full_name:

return helpers_mention_markdown(self.id, self.full_name, version=2)

raise TypeError("Can not create a mention to a private chat without first name")

if self.username:

if name:

return f"[{escape_markdown(name, version=2)}]({self.link})"

if self.title:

return f"[{escape_markdown(self.title, version=2)}]({self.link})"

raise TypeError("Can not create a mention to a public chat without title")

raise TypeError("Can not create a mention to a private group chat")

def mention_html(self, name: str | None = None) -> str:

"""

.. versionadded:: 20.0

Args:

name (:obj:`str`): The name used as a link for the chat. Defaults to :attr:`full_name`.

Returns:

:obj:`str`: The inline mention for the chat as HTML.

Raises:

:exc:`TypeError`: If the chat is a private chat and neither the :paramref:`name`

nor the :attr:`~Chat.first_name` is set, then throw an :exc:`TypeError`.

If the chat is a public chat and neither the :paramref:`name` nor the

:attr:`~Chat.title` is set, then throw an :exc:`TypeError`.

If chat is a private group chat, then throw an :exc:`TypeError`.

"""

if self.type == self.PRIVATE:

if name:

return helpers_mention_html(self.id, name)

if self.full_name:

return helpers_mention_html(self.id, self.full_name)

raise TypeError("Can not create a mention to a private chat without first name")

if self.username:

if name:

return f'<a href="{self.link}">{escape(name)}</a>'

if self.title:

return f'<a href="{self.link}">{escape(self.title)}</a>'

raise TypeError("Can not create a mention to a public chat without title")

raise TypeError("Can not create a mention to a private group chat")

async def leave(

self,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.leave_chat(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see :meth:`telegram.Bot.leave_chat`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().leave_chat(

chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def get_administrators(

self,

return_bots: bool | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> tuple["ChatMember", ...]:

"""Shortcut for::

await bot.get_chat_administrators(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.get_chat_administrators`.

Returns:

tuple[:class:`telegram.ChatMember`]: A tuple of administrators in a chat. An Array of

:class:`telegram.ChatMember` objects that contains information about all

chat administrators except other bots. If the chat is a group or a supergroup

and no administrators were appointed, only the creator will be returned.

"""

return await self.get_bot().get_chat_administrators(

chat_id=self.id,

return_bots=return_bots,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def get_member_count(

self,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> int:

"""Shortcut for::

await bot.get_chat_member_count(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.get_chat_member_count`.

Returns:

:obj:`int`

"""

return await self.get_bot().get_chat_member_count(

chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def get_member(

self,

user_id: int,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> "ChatMember":

"""Shortcut for::

await bot.get_chat_member(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see :meth:`telegram.Bot.get_chat_member`.

Returns:

:class:`telegram.ChatMember`

"""

return await self.get_bot().get_chat_member(

chat_id=self.id,

user_id=user_id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def ban_member(

self,

user_id: int,

revoke_messages: bool | None = None,

until_date: int | dtm.datetime | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.ban_chat_member(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.ban_chat_member`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().ban_chat_member(

chat_id=self.id,

user_id=user_id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

until_date=until_date,

api_kwargs=api_kwargs,

revoke_messages=revoke_messages,

)

async def ban_sender_chat(

self,

sender_chat_id: int,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.ban_chat_sender_chat(chat_id=update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.ban_chat_sender_chat`.

.. versionadded:: 13.9

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().ban_chat_sender_chat(

chat_id=self.id,

sender_chat_id=sender_chat_id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def ban_chat(

self,

chat_id: str | int,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.ban_chat_sender_chat(

sender_chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.ban_chat_sender_chat`.

.. versionadded:: 13.9

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().ban_chat_sender_chat(

chat_id=chat_id,

sender_chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def unban_sender_chat(

self,

sender_chat_id: int,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.unban_chat_sender_chat(chat_id=update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.unban_chat_sender_chat`.

.. versionadded:: 13.9

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().unban_chat_sender_chat(

chat_id=self.id,

sender_chat_id=sender_chat_id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def unban_chat(

self,

chat_id: str | int,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.unban_chat_sender_chat(

sender_chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.unban_chat_sender_chat`.

.. versionadded:: 13.9

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().unban_chat_sender_chat(

chat_id=chat_id,

sender_chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def unban_member(

self,

user_id: int,

only_if_banned: bool | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.unban_chat_member(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see :meth:`telegram.Bot.unban_chat_member`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().unban_chat_member(

chat_id=self.id,

user_id=user_id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

only_if_banned=only_if_banned,

)

async def promote_member(

self,

user_id: int,

can_change_info: bool | None = None,

can_post_messages: bool | None = None,

can_edit_messages: bool | None = None,

can_delete_messages: bool | None = None,

can_invite_users: bool | None = None,

can_restrict_members: bool | None = None,

can_pin_messages: bool | None = None,

can_promote_members: bool | None = None,

is_anonymous: bool | None = None,

can_manage_chat: bool | None = None,

can_manage_video_chats: bool | None = None,

can_manage_topics: bool | None = None,

can_post_stories: bool | None = None,

can_edit_stories: bool | None = None,

can_delete_stories: bool | None = None,

can_manage_direct_messages: bool | None = None,

can_manage_tags: bool | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.promote_chat_member(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.promote_chat_member`.

.. versionadded:: 13.2

.. versionchanged:: 20.0

The argument ``can_manage_voice_chats`` was renamed to

:paramref:`~telegram.Bot.promote_chat_member.can_manage_video_chats` in accordance to

Bot API 6.0.

.. versionchanged:: 20.6

The arguments `can_post_stories`, `can_edit_stories` and `can_delete_stories` were

added.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().promote_chat_member(

chat_id=self.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_invite_users=can_invite_users,

can_restrict_members=can_restrict_members,

can_pin_messages=can_pin_messages,

can_promote_members=can_promote_members,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

is_anonymous=is_anonymous,

can_manage_chat=can_manage_chat,

can_manage_video_chats=can_manage_video_chats,

can_manage_topics=can_manage_topics,

can_post_stories=can_post_stories,

can_edit_stories=can_edit_stories,

can_delete_stories=can_delete_stories,

can_manage_direct_messages=can_manage_direct_messages,

can_manage_tags=can_manage_tags,

)

async def restrict_member(

self,

user_id: int,

permissions: ChatPermissions,

until_date: int | dtm.datetime | None = None,

use_independent_chat_permissions: bool | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.restrict_chat_member(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.restrict_chat_member`.

.. versionadded:: 13.2

.. versionadded:: 20.1

Added :paramref:`~telegram.Bot.restrict_chat_member.use_independent_chat_permissions`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().restrict_chat_member(

chat_id=self.id,

user_id=user_id,

permissions=permissions,

until_date=until_date,

use_independent_chat_permissions=use_independent_chat_permissions,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def set_permissions(

self,

permissions: ChatPermissions,

use_independent_chat_permissions: bool | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.set_chat_permissions(update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.set_chat_permissions`.

.. versionadded:: 20.1

Added :paramref:`~telegram.Bot.set_chat_permissions.use_independent_chat_permissions`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().set_chat_permissions(

chat_id=self.id,

permissions=permissions,

use_independent_chat_permissions=use_independent_chat_permissions,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def set_administrator_custom_title(

self,

user_id: int,

custom_title: str,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.set_chat_administrator_custom_title(

update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.set_chat_administrator_custom_title`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().set_chat_administrator_custom_title(

chat_id=self.id,

user_id=user_id,

custom_title=custom_title,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def set_photo(

self,

photo: FileInput,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.set_chat_photo(

chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.set_chat_photo`.

.. versionadded:: 20.0

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().set_chat_photo(

chat_id=self.id,

photo=photo,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def delete_photo(

self,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.delete_chat_photo(

chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.delete_chat_photo`.

.. versionadded:: 20.0

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().delete_chat_photo(

chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def set_title(

self,

title: str,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.set_chat_title(

chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.set_chat_title`.

.. versionadded:: 20.0

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().set_chat_title(

chat_id=self.id,

title=title,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def set_description(

self,

description: str | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.set_chat_description(

chat_id=update.effective_chat.id, *args, **kwargs

)

For the documentation of the arguments, please see

:meth:`telegram.Bot.set_chat_description`.

.. versionadded:: 20.0

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().set_chat_description(

chat_id=self.id,

description=description,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

async def pin_message(

self,

message_id: int,

disable_notification: ODVInput[bool] = DEFAULT_NONE,

business_connection_id: str | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.pin_chat_message(chat_id=update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.pin_chat_message`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().pin_chat_message(

chat_id=self.id,

message_id=message_id,

disable_notification=disable_notification,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

business_connection_id=business_connection_id,

)

async def unpin_message(

self,

message_id: int | None = None,

business_connection_id: str | None = None,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

api_kwargs: JSONDict | None = None,

) -> bool:

"""Shortcut for::

await bot.unpin_chat_message(chat_id=update.effective_chat.id, *args, **kwargs)

For the documentation of the arguments, please see

:meth:`telegram.Bot.unpin_chat_message`.

Returns:

:obj:`bool`: On success, :obj:`True` is returned.

"""

return await self.get_bot().unpin_chat_message(

chat_id=self.id,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

message_id=message_id,

business_connection_id=business_connection_id,

)