__slots__ = ("token",)

# small helper to make .format_map work without knowing which exact insertion name is used

def __init__(self, token: str):

self.token = token

super().__init__()

def __missing__(self, key: str) -> str:

if key in _SUPPORTED_INSERTIONS:

return self.token

if callable(value):

return value(token)

if any(insertion in value for insertion in _INSERTION_STRINGS):

return value.format_map(_TokenDict(token))

"""This object represents a Telegram Bot.

Instances of this class can be used as asyncio context managers, where

.. code:: python

async with bot:

# code

is roughly equivalent to

.. code:: python

try:

await bot.initialize()

# code

finally:

await bot.shutdown()

.. seealso:: :meth:`__aenter__` and :meth:`__aexit__`.

Note:

* Most bot methods have the argument ``api_kwargs`` which allows passing arbitrary keywords

to the Telegram API. This can be used to access new features of the API before they are

incorporated into PTB. The limitations to this argument are the same as the ones

described in :meth:`do_api_request`.

* Bots should not be serialized since if you for e.g. change the bots token, then your

serialized instance will not reflect that change. Trying to pickle a bot instance will

raise :exc:`pickle.PicklingError`. Trying to deepcopy a bot instance will raise

:exc:`TypeError`.

Examples:

:any:`Raw API Bot <examples.rawapibot>`

.. seealso:: :wiki:`Your First Bot <Extensions---Your-first-Bot>`,

:wiki:`Builder Pattern <Builder-Pattern>`

.. versionadded:: 13.2

Objects of this class are comparable in terms of equality. Two objects of this class are

considered equal, if their :attr:`bot` is equal.

.. versionchanged:: 20.0

* Removed the deprecated methods ``kick_chat_member``, ``kickChatMember``,

``get_chat_members_count`` and ``getChatMembersCount``.

* Removed the deprecated property ``commands``.

* Removed the deprecated ``defaults`` parameter. If you want to use

:class:`telegram.ext.Defaults`, please use the subclass :class:`telegram.ext.ExtBot`

instead.

* Attempting to pickle a bot instance will now raise :exc:`pickle.PicklingError`.

* Attempting to deepcopy a bot instance will now raise :exc:`TypeError`.

* The following are now keyword-only arguments in Bot methods:

``location``, ``filename``, ``venue``, ``contact``,

``{read, write, connect, pool}_timeout``, ``api_kwargs``. Use a named argument for those,

and notice that some positional arguments changed position as a result.

* For uploading files, file paths are now always accepted. If :paramref:`local_mode` is

:obj:`False`, the file contents will be read in binary mode and uploaded. Otherwise,

the file path will be passed in the

`file URI scheme <https://en.wikipedia.org/wiki/File_URI_scheme>`_.

.. versionchanged:: 20.5

Removed deprecated methods ``set_sticker_set_thumb`` and ``setStickerSetThumb``.

Use :meth:`set_sticker_set_thumbnail` and :meth:`setStickerSetThumbnail` instead.

Args:

token (:obj:`str`): Bot's unique authentication token.

base_url (:obj:`str` | Callable[[:obj:`str`], :obj:`str`], optional): Telegram Bot API

service URL. If the string contains ``{token}``, it will be replaced with the bot's

token. If a callable is passed, it will be called with the bot's token as the only

argument and must return the base URL. Otherwise, the token will be appended to the

string. Defaults to ``"https://api.telegram.org/bot"``.

Tip:

Customizing the base URL can be used to run a bot against

:wiki:`Local Bot API Server <Local-Bot-API-Server>` or using Telegrams

`test environment \

<https://core.telegram.org/bots/features#dedicated-test-environment>`_.

Example:

``"https://api.telegram.org/bot{token}/test"``

.. versionchanged:: 21.11

Supports callable input and string formatting.

base_file_url (:obj:`str`, optional): Telegram Bot API file URL.

If the string contains ``{token}``, it will be replaced with the bot's

token. If a callable is passed, it will be called with the bot's token as the only

argument and must return the base URL. Otherwise, the token will be appended to the

string. Defaults to ``"https://api.telegram.org/bot"``.

Tip:

Customizing the base URL can be used to run a bot against

:wiki:`Local Bot API Server <Local-Bot-API-Server>` or using Telegrams

`test environment \

<https://core.telegram.org/bots/features#dedicated-test-environment>`_.

Example:

``"https://api.telegram.org/file/bot{token}/test"``

.. versionchanged:: 21.11

Supports callable input and string formatting.

request (:class:`telegram.request.BaseRequest`, optional): Pre initialized

:class:`telegram.request.BaseRequest` instances. Will be used for all bot methods

*except* for :meth:`get_updates`. If not passed, an instance of

:class:`telegram.request.HTTPXRequest` will be used.

get_updates_request (:class:`telegram.request.BaseRequest`, optional): Pre initialized

:class:`telegram.request.BaseRequest` instances. Will be used exclusively for

:meth:`get_updates`. If not passed, an instance of

:class:`telegram.request.HTTPXRequest` will be used.

private_key (:obj:`bytes`, optional): Private key for decryption of telegram passport data.

private_key_password (:obj:`bytes`, optional): Password for above private key.

local_mode (:obj:`bool`, optional): Set to :obj:`True`, if the :paramref:`base_url` is

the URI of a `Local Bot API Server <https://core.telegram.org/bots/api#using-a-local\

-bot-api-server>`_ that runs with the ``--local`` flag. Currently, the only effect of

this is that files are uploaded using their local path in the

`file URI scheme <https://en.wikipedia.org/wiki/File_URI_scheme>`_.

Defaults to :obj:`False`.

.. versionadded:: 20.0.

.. include:: inclusions/bot_methods.rst

.. |removed_thumb_arg| replace:: Removed deprecated argument ``thumb``. Use

``thumbnail`` instead.

"""

# This is a class variable since we want to override the logger name in ExtBot

# without having to change all places where this is used

_LOGGER = get_logger(__name__)

__slots__ = (

"_base_file_url",

"_base_url",

"_bot_initialized",

"_bot_user",

"_local_mode",

"_private_key",

"_request",

"_requests_initialized",

"_token",

)

def __init__(

self,

token: str,

base_url: BaseUrl = "https://api.telegram.org/bot",

base_file_url: BaseUrl = "https://api.telegram.org/file/bot",

request: BaseRequest | None = None,

get_updates_request: BaseRequest | None = None,

private_key: bytes | None = None,

private_key_password: bytes | None = None,

local_mode: bool = False,

):

super().__init__(api_kwargs=None)

if not token:

raise InvalidToken("You must pass the token you received from https://t.me/Botfather!")

self._token: str = token

self._base_url: str = _parse_base_url(base_url, self._token)

self._base_file_url: str = _parse_base_url(base_file_url, self._token)

self._LOGGER.debug("Set Bot API URL: %s", self._base_url)

self._LOGGER.debug("Set Bot API File URL: %s", self._base_file_url)

self._local_mode: bool = local_mode

self._bot_user: User | None = None

self._private_key: bytes | None = None

self._requests_initialized: bool = False

self._bot_initialized: bool = False

self._request: tuple[BaseRequest, BaseRequest] = (

(

HTTPXRequest(connection_pool_size=1)

if get_updates_request is None

else get_updates_request

),

HTTPXRequest() if request is None else request,

)

# this section is about issuing a warning when using HTTP/2 and connect to a self-hosted

# bot api instance, which currently only supports HTTP/1.1. Checking if a custom base url

# is set is the best way to do that.

warning_string = ""

if (

isinstance(self._request[0], HTTPXRequest)

and self._request[0].http_version == "2"

and not self.base_url.startswith("https://api.telegram.org/bot")

):

warning_string = "get_updates_request"

if (

isinstance(self._request[1], HTTPXRequest)

and self._request[1].http_version == "2"

and not self.base_url.startswith("https://api.telegram.org/bot")

):

if warning_string:

warning_string += " and request"

else:

warning_string = "request"

if warning_string:

self._warn(

f"You set the HTTP version for the {warning_string} HTTPXRequest instance to "

"HTTP/2. The self hosted bot api instances only support HTTP/1.1. You should "

"either run a HTTP proxy in front of it which supports HTTP/2 or use HTTP/1.1.",

PTBUserWarning,

stacklevel=2,

)

if private_key:

if not CRYPTO_INSTALLED:

raise RuntimeError(

"To use Telegram Passports, PTB must be installed via `pip install "

'"python-telegram-bot[passport]"`.'

)

self._private_key = serialization.load_pem_private_key(

private_key, password=private_key_password, backend=default_backend()

)

self._freeze()

async def __aenter__(self: BT) -> BT:

"""

|async_context_manager| :meth:`initializes <initialize>` the Bot.

Returns:

The initialized Bot instance.

Raises:

:exc:`Exception`: If an exception is raised during initialization, :meth:`shutdown`

is called in this case.

"""

try:

await self.initialize()

except Exception:

await self.shutdown()

raise

return self

async def __aexit__(

self,

exc_type: type[BaseException] | None,

exc_val: BaseException | None,

exc_tb: TracebackType | None,

) -> None:

"""|async_context_manager| :meth:`shuts down <shutdown>` the Bot."""

# Make sure not to return `True` so that exceptions are not suppressed

# https://docs.python.org/3/reference/datamodel.html?#object.__aexit__

await self.shutdown()

def __reduce__(self) -> NoReturn:

"""Customizes how :func:`copy.deepcopy` processes objects of this type. Bots can not

be pickled and this method will always raise an exception.

.. versionadded:: 20.0

Raises:

:exc:`pickle.PicklingError`

"""

raise pickle.PicklingError("Bot objects cannot be pickled!")

def __deepcopy__(self, memodict: dict[int, object]) -> NoReturn:

"""Customizes how :func:`copy.deepcopy` processes objects of this type. Bots can not

be deepcopied and this method will always raise an exception.

.. versionadded:: 20.0

Raises:

:exc:`TypeError`

"""

raise TypeError("Bot objects cannot be deepcopied!")

def __eq__(self, other: object) -> bool:

"""Defines equality condition for the :class:`telegram.Bot` object.

Two objects of this class are considered to be equal if their attributes

:attr:`bot` are equal.

Returns:

:obj:`True` if both attributes :attr:`bot` are equal. :obj:`False` otherwise.

"""

if isinstance(other, Bot):

return self.bot == other.bot

return super().__eq__(other)

def __hash__(self) -> int:

"""See :meth:`telegram.TelegramObject.__hash__`"""

if self._bot_user is None:

return super().__hash__()

return hash((self.bot, Bot))

def __repr__(self) -> str:

"""Give a string representation of the bot in the form ``Bot[token=...]``.

As this class doesn't implement :meth:`object.__str__`, the default implementation

will be used, which is equivalent to :meth:`__repr__`.

Returns:

:obj:`str`

"""

return build_repr_with_selected_attrs(self, token=self.token)

@property

def token(self) -> str:

""":obj:`str`: Bot's unique authentication token.

.. versionadded:: 20.0

"""

return self._token

@property

def base_url(self) -> str:

""":obj:`str`: Telegram Bot API service URL, built from :paramref:`Bot.base_url` and

:paramref:`Bot.token`.

.. versionadded:: 20.0

"""

return self._base_url

@property

def base_file_url(self) -> str:

""":obj:`str`: Telegram Bot API file URL, built from :paramref:`Bot.base_file_url` and

:paramref:`Bot.token`.

.. versionadded:: 20.0

"""

return self._base_file_url

@property

def local_mode(self) -> bool:

""":obj:`bool`: Whether this bot is running in local mode.

.. versionadded:: 20.0

"""

return self._local_mode

# Proper type hints are difficult because:

# 1. cryptography doesn't have a nice base class, so it would get lengthy

# 2. we can't import cryptography if it's not installed

@property

def private_key(self) -> Any | None:

"""Deserialized private key for decryption of telegram passport data.

.. versionadded:: 20.0

"""

return self._private_key

@property

def request(self) -> BaseRequest:

"""The :class:`~telegram.request.BaseRequest` object used by this bot.

Warning:

Requests to the Bot API are made by the various methods of this class. This attribute

should *not* be used manually.

"""

return self._request[1]

@property

def bot(self) -> User:

""":class:`telegram.User`: User instance for the bot as returned by :meth:`get_me`.

Warning:

This value is the cached return value of :meth:`get_me`. If the bots profile is

changed during runtime, this value won't reflect the changes until :meth:`get_me` is

called again.

.. seealso:: :meth:`initialize`

"""

if self._bot_user is None:

raise RuntimeError(

f"{self.__class__.__name__} is not properly initialized. Call "

f"`{self.__class__.__name__}.initialize` before accessing this property."

)

return self._bot_user

@property

def id(self) -> int:

""":obj:`int`: Unique identifier for this bot. Shortcut for the corresponding attribute of

:attr:`bot`.

"""

return self.bot.id

@property

def first_name(self) -> str:

""":obj:`str`: Bot's first name. Shortcut for the corresponding attribute of

:attr:`bot`.

"""

return self.bot.first_name

@property

def last_name(self) -> str:

""":obj:`str`: Optional. Bot's last name. Shortcut for the corresponding attribute of

:attr:`bot`.

"""

return self.bot.last_name # type: ignore

@property

def username(self) -> str:

""":obj:`str`: Bot's username. Shortcut for the corresponding attribute of

:attr:`bot`.

"""

return self.bot.username # type: ignore

@property

def link(self) -> str:

""":obj:`str`: Convenience property. Returns the t.me link of the bot."""

return f"https://t.me/{self.username}"

@property

def can_join_groups(self) -> bool:

""":obj:`bool`: Bot's :attr:`telegram.User.can_join_groups` attribute. Shortcut for the

corresponding attribute of :attr:`bot`.

"""

return self.bot.can_join_groups # type: ignore

@property

def can_read_all_group_messages(self) -> bool:

""":obj:`bool`: Bot's :attr:`telegram.User.can_read_all_group_messages` attribute.

Shortcut for the corresponding attribute of :attr:`bot`.

"""

return self.bot.can_read_all_group_messages # type: ignore

@property

def supports_inline_queries(self) -> bool:

""":obj:`bool`: Bot's :attr:`telegram.User.supports_inline_queries` attribute.

Shortcut for the corresponding attribute of :attr:`bot`.

"""

return self.bot.supports_inline_queries # type: ignore

@property

def name(self) -> str:

""":obj:`str`: Bot's @username. Shortcut for the corresponding attribute of :attr:`bot`."""

return f"@{self.username}"

@classmethod

def _warn(

cls,

message: str | PTBUserWarning,

category: type[Warning] = PTBUserWarning,

stacklevel: int = 0,

) -> None:

"""Convenience method to issue a warning. This method is here mostly to make it easier

for ExtBot to add 1 level to all warning calls.

"""

warn(message=message, category=category, stacklevel=stacklevel + 1)

def _parse_file_input(

self,

file_input: "FileInput| TelegramObject",

tg_type: type["TelegramObject"] | None = None,

filename: str | None = None,

attach: bool = False,

) -> "str| InputFile| Any":

return parse_file_input(

file_input=file_input,

tg_type=tg_type,

filename=filename,

attach=attach,

local_mode=self._local_mode,

)

def _insert_defaults(self, data: dict[str, object]) -> None:

"""This method is here to make ext.Defaults work. Because we need to be able to tell

e.g. `send_message(chat_id, text)` from `send_message(chat_id, text, parse_mode=None)`, the

default values for `parse_mode` etc are not `None` but `DEFAULT_NONE`. While this *could*

be done in ExtBot instead of Bot, shortcuts like `Message.reply_text` need to work for both

Bot and ExtBot, so they also have the `DEFAULT_NONE` default values.

This makes it necessary to convert `DefaultValue(obj)` to `obj` at some point between

`Message.reply_text` and the request to TG. Doing this here in a centralized manner is a

rather clean and minimally invasive solution, i.e. the link between tg and tg.ext is as

small as possible.

See also _insert_defaults_for_ilq

ExtBot overrides this method to actually insert default values.

If in the future we come up with a better way of making `Defaults` work, we can cut this

link as well.

"""

# We

# 1) set the correct parse_mode for all InputMedia objects

# 2) replace all DefaultValue instances with the corresponding normal value.

for key, val in data.items():

# 1)

if isinstance(val, InputMedia):

# Copy object as not to edit it in-place

new = copy.copy(val)

with new._unfrozen():

new.parse_mode = DefaultValue.get_value(new.parse_mode)

data[key] = new

elif (

key == "media"

and isinstance(val, Sequence)

and not isinstance(val[0], InputPaidMedia)

):

# Copy objects as not to edit them in-place

copy_list = [copy.copy(media) for media in val]

for media in copy_list:

with media._unfrozen():

media.parse_mode = DefaultValue.get_value(media.parse_mode)

data[key] = copy_list

# 2)

else:

data[key] = DefaultValue.get_value(val)

async def _post(

self,

endpoint: str,

data: JSONDict | 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,

) -> Any:

# We know that the return type is Union[bool, JSONDict, list[JSONDict]], but it's hard

# to tell mypy which methods expects which of these return values and `Any` saves us a

# lot of `type: ignore` comments

if data is None:

data = {}

if api_kwargs:

data.update(api_kwargs)

# Insert is in-place, so no return value for data

self._insert_defaults(data)

# Drop any None values because Telegram doesn't handle them well

data = {key: value for key, value in data.items() if value is not None}

return await self._do_post(

endpoint=endpoint,

data=data,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

)

async def _do_post(

self,

endpoint: str,

data: JSONDict,

*,

read_timeout: ODVInput[float] = DEFAULT_NONE,

write_timeout: ODVInput[float] = DEFAULT_NONE,

connect_timeout: ODVInput[float] = DEFAULT_NONE,

pool_timeout: ODVInput[float] = DEFAULT_NONE,

) -> bool | JSONDict | list[JSONDict]:

# This also converts datetimes into timestamps.

# We don't do this earlier so that _insert_defaults (see above) has a chance to convert

# to the default timezone in case this is called by ExtBot

request_data = RequestData(

parameters=[RequestParameter.from_input(key, value) for key, value in data.items()],

)

request = self._request[0] if endpoint == "getUpdates" else self._request[1]

self._LOGGER.debug("Calling Bot API endpoint `%s` with parameters `%s`", endpoint, data)

result = await request.post(

url=f"{self._base_url}/{endpoint}",

request_data=request_data,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

)

self._LOGGER.debug(

"Call to Bot API endpoint `%s` finished with return value `%s`", endpoint, result

)

return result

async def _send_message(

self,

endpoint: str,

data: JSONDict,

disable_notification: ODVInput[bool] = DEFAULT_NONE,

reply_markup: "ReplyMarkup | None" = None,

protect_content: ODVInput[bool] = DEFAULT_NONE,

message_thread_id: int | None = None,

caption: str | None = None,

parse_mode: ODVInput[str] = DEFAULT_NONE,

caption_entities: Sequence["MessageEntity"] | None = None,

link_preview_options: ODVInput["LinkPreviewOptions"] = None,

reply_parameters: "ReplyParameters | None" = None,

business_connection_id: str | None = None,

message_effect_id: str | None = None,

allow_paid_broadcast: bool | None = None,

direct_messages_topic_id: int | None = None,

suggested_post_parameters: "SuggestedPostParameters | None" = None,

*,

allow_sending_without_reply: ODVInput[bool] = DEFAULT_NONE,

reply_to_message_id: int | 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,

) -> Any:

"""Protected method to send or edit messages of any type.

It is here to reduce repetition of if-else closes in the different bot methods,

i.e. this method takes care of adding its parameters to `data` if appropriate.

Depending on the bot method, returns either `True` or the message.

However, it's hard to tell mypy which methods expects which of these return values and

using `Any` instead saves us a lot of `type: ignore` comments

"""

# We don't check if (DEFAULT_)None here, so that _post is able to insert the defaults

# correctly, if necessary:

if allow_sending_without_reply is not DEFAULT_NONE and reply_parameters is not None:

raise ValueError(

"`allow_sending_without_reply` and `reply_parameters` are mutually exclusive."

)

if reply_to_message_id is not None and reply_parameters is not None:

raise ValueError(

"`reply_to_message_id` and `reply_parameters` are mutually exclusive."

)

if reply_to_message_id is not None:

reply_parameters = ReplyParameters(

message_id=reply_to_message_id,

allow_sending_without_reply=allow_sending_without_reply,

)

data.update(

{

"allow_paid_broadcast": allow_paid_broadcast,

"business_connection_id": business_connection_id,

"caption": caption,

"caption_entities": caption_entities,

"direct_messages_topic_id": direct_messages_topic_id,

"disable_notification": disable_notification,

"link_preview_options": link_preview_options,

"message_thread_id": message_thread_id,

"message_effect_id": message_effect_id,

"parse_mode": parse_mode,

"protect_content": protect_content,

"reply_markup": reply_markup,

"reply_parameters": reply_parameters,

"suggested_post_parameters": suggested_post_parameters,

}

)

result = await self._post(

endpoint,

data,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

if result is True:

return result

return Message.de_json(result, self)

async def initialize(self) -> None:

"""Initialize resources used by this class. Currently calls :meth:`get_me` to

cache :attr:`bot` and calls :meth:`telegram.request.BaseRequest.initialize` for

the request objects used by this bot.

.. seealso:: :meth:`shutdown`

.. versionadded:: 20.0

"""

if self._requests_initialized and self._bot_initialized:

self._LOGGER.debug("This Bot is already initialized.")

return

# Initialize request objects if not already done

if not self._requests_initialized:

await asyncio.gather(self._request[0].initialize(), self._request[1].initialize())

self._requests_initialized = True

# Initialize bot user

# Since the bot is to be initialized only once, we can also use it for

# verifying the token passed and raising an exception if it's invalid.

try:

await self.get_me()

self._bot_initialized = True

except InvalidToken as exc:

raise InvalidToken(f"The token `{self._token}` was rejected by the server.") from exc

async def shutdown(self) -> None:

"""Stop & clear resources used by this class. Currently just calls

:meth:`telegram.request.BaseRequest.shutdown` for the request objects used by this bot.

.. seealso:: :meth:`initialize`

.. versionadded:: 20.0

"""

if not self._requests_initialized:

self._LOGGER.debug("This Bot is already shut down. Returning.")

return

await asyncio.gather(self._request[0].shutdown(), self._request[1].shutdown())

self._requests_initialized = False

self._bot_initialized = False

async def do_api_request(

self,

endpoint: str,

api_kwargs: JSONDict | None = None,

return_type: type[TelegramObject] | 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,

) -> Any:

"""Do a request to the Telegram API.

This method is here to make it easier to use new API methods that are not yet supported

by this library.

Hint:

Since PTB does not know which arguments are passed to this method, some caution is

necessary in terms of PTBs utility functionalities. In particular

* passing objects of any class defined in the :mod:`telegram` module is supported

* when uploading files, a :class:`telegram.InputFile` must be passed as the value for

the corresponding argument. Passing a file path or file-like object will not work.

File paths will work only in combination with :paramref:`~Bot.local_mode`.

* when uploading files, PTB can still correctly determine that

a special write timeout value should be used instead of the default

:paramref:`telegram.request.HTTPXRequest.write_timeout`.

* insertion of default values specified via :class:`telegram.ext.Defaults` will not

work (only relevant for :class:`telegram.ext.ExtBot`).

* The only exception is :class:`telegram.ext.Defaults.tzinfo`, which will be correctly

applied to :class:`datetime.datetime` objects.

.. versionadded:: 20.8

Args:

endpoint (:obj:`str`): The API endpoint to use, e.g. ``getMe`` or ``get_me``.

api_kwargs (:obj:`dict`, optional): The keyword arguments to pass to the API call.

If not specified, no arguments are passed.

return_type (:class:`telegram.TelegramObject`, optional): If specified, the result of

the API call will be deserialized into an instance of this class or tuple of

instances of this class. If not specified, the raw result of the API call will be

returned.

Returns:

The result of the API call. If :paramref:`return_type` is not specified, this is a

:obj:`dict` or :obj:`bool`, otherwise an instance of :paramref:`return_type` or a

tuple of :paramref:`return_type`.

Raises:

:class:`telegram.error.TelegramError`

"""

if hasattr(self, endpoint):

self._warn(

(

f"Please use 'Bot.{endpoint}' instead of "

f"'Bot.do_api_request(\"{endpoint}\", ...)'"

),

stacklevel=2,

)

camel_case_endpoint = to_camel_case(endpoint)

try:

result = await self._post(

camel_case_endpoint,

api_kwargs=api_kwargs,

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

)

except InvalidToken as exc:

# TG returns 404 Not found for

# 1) malformed tokens

# 2) correct tokens but non-existing method, e.g. api.tg.org/botTOKEN/unkonwnMethod

# 2) is relevant only for Bot.do_api_request, that's why we have special handling for

# that here rather than in BaseRequest._request_wrapper

if self._bot_initialized:

raise EndPointNotFound(

f"Endpoint '{camel_case_endpoint}' not found in Bot API"

) from exc

raise InvalidToken(

"Either the bot token was rejected by Telegram or the endpoint "

f"'{camel_case_endpoint}' does not exist."

) from exc

if return_type is None or isinstance(result, bool):

return result

if isinstance(result, list):

return return_type.de_list(result, self)

return return_type.de_json(result, self)

async def get_me(

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,

) -> User:

"""A simple method for testing your bot's auth token. Requires no parameters.

Returns:

:class:`telegram.User`: A :class:`telegram.User` instance representing that bot if the

credentials are valid, :obj:`None` otherwise.

Raises:

:class:`telegram.error.TelegramError`

"""

result = await self._post(

"getMe",

read_timeout=read_timeout,

write_timeout=write_timeout,

connect_timeout=connect_timeout,

pool_timeout=pool_timeout,

api_kwargs=api_kwargs,

)

self._bot_user = User.de_json(result, self)

return self._bot_user