Третий коммит, добавление share, share_kb, а также ADMIN_ID

myenv/Lib/site-packages/aiogram/client/context_controller.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Any, Optional
+
+from pydantic import BaseModel, PrivateAttr
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from aiogram.client.bot import Bot
+
+
+class BotContextController(BaseModel):
+    _bot: Optional["Bot"] = PrivateAttr()
+
+    def model_post_init(self, __context: Any) -> None:
+        self._bot = __context.get("bot") if __context else None
+
+    def as_(self, bot: Optional["Bot"]) -> Self:
+        """
+        Bind object to a bot instance.
+
+        :param bot: Bot instance
+        :return: self
+        """
+        self._bot = bot
+        return self
+
+    @property
+    def bot(self) -> Optional["Bot"]:
+        """
+        Get bot instance.
+
+        :return: Bot instance
+        """
+        return self._bot

myenv/Lib/site-packages/aiogram/client/default.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Optional
+
+from aiogram.utils.dataclass import dataclass_kwargs
+
+if TYPE_CHECKING:
+    from aiogram.types import LinkPreviewOptions
+
+
+# @dataclass ??
+class Default:
+    # Is not a dataclass because of JSON serialization.
+
+    __slots__ = ("_name",)
+
+    def __init__(self, name: str) -> None:
+        self._name = name
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    def __str__(self) -> str:
+        return f"Default({self._name!r})"
+
+    def __repr__(self) -> str:
+        return f"<{self}>"
+
+
+@dataclass(**dataclass_kwargs(slots=True, kw_only=True))
+class DefaultBotProperties:
+    """
+    Default bot properties.
+    """
+
+    parse_mode: Optional[str] = None
+    """Default parse mode for messages."""
+    disable_notification: Optional[bool] = None
+    """Sends the message silently. Users will receive a notification with no sound."""
+    protect_content: Optional[bool] = None
+    """Protects content from copying."""
+    allow_sending_without_reply: Optional[bool] = None
+    """Allows to send messages without reply."""
+    link_preview: Optional[LinkPreviewOptions] = None
+    """Link preview settings."""
+    link_preview_is_disabled: Optional[bool] = None
+    """Disables link preview."""
+    link_preview_prefer_small_media: Optional[bool] = None
+    """Prefer small media in link preview."""
+    link_preview_prefer_large_media: Optional[bool] = None
+    """Prefer large media in link preview."""
+    link_preview_show_above_text: Optional[bool] = None
+    """Show link preview above text."""
+    show_caption_above_media: Optional[bool] = None
+    """Show caption above media."""
+
+    def __post_init__(self) -> None:
+        has_any_link_preview_option = any(
+            (
+                self.link_preview_is_disabled,
+                self.link_preview_prefer_small_media,
+                self.link_preview_prefer_large_media,
+                self.link_preview_show_above_text,
+            )
+        )
+
+        if has_any_link_preview_option and self.link_preview is None:
+            from ..types import LinkPreviewOptions
+
+            self.link_preview = LinkPreviewOptions(
+                is_disabled=self.link_preview_is_disabled,
+                prefer_small_media=self.link_preview_prefer_small_media,
+                prefer_large_media=self.link_preview_prefer_large_media,
+                show_above_text=self.link_preview_show_above_text,
+            )
+
+    def __getitem__(self, item: str) -> Any:
+        return getattr(self, item, None)

myenv/Lib/site-packages/aiogram/client/session/aiohttp.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+import asyncio
+import ssl
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+import certifi
+from aiohttp import BasicAuth, ClientError, ClientSession, FormData, TCPConnector
+from aiohttp.hdrs import USER_AGENT
+from aiohttp.http import SERVER_SOFTWARE
+
+from aiogram.__meta__ import __version__
+from aiogram.methods import TelegramMethod
+
+from ...exceptions import TelegramNetworkError
+from ...methods.base import TelegramType
+from ...types import InputFile
+from .base import BaseSession
+
+if TYPE_CHECKING:
+    from ..bot import Bot
+
+_ProxyBasic = Union[str, Tuple[str, BasicAuth]]
+_ProxyChain = Iterable[_ProxyBasic]
+_ProxyType = Union[_ProxyChain, _ProxyBasic]
+
+
+def _retrieve_basic(basic: _ProxyBasic) -> Dict[str, Any]:
+    from aiohttp_socks.utils import parse_proxy_url
+
+    proxy_auth: Optional[BasicAuth] = None
+
+    if isinstance(basic, str):
+        proxy_url = basic
+    else:
+        proxy_url, proxy_auth = basic
+
+    proxy_type, host, port, username, password = parse_proxy_url(proxy_url)
+    if isinstance(proxy_auth, BasicAuth):
+        username = proxy_auth.login
+        password = proxy_auth.password
+
+    return {
+        "proxy_type": proxy_type,
+        "host": host,
+        "port": port,
+        "username": username,
+        "password": password,
+        "rdns": True,
+    }
+
+
+def _prepare_connector(chain_or_plain: _ProxyType) -> Tuple[Type["TCPConnector"], Dict[str, Any]]:
+    from aiohttp_socks import ChainProxyConnector, ProxyConnector, ProxyInfo
+
+    # since tuple is Iterable(compatible with _ProxyChain) object, we assume that
+    # user wants chained proxies if tuple is a pair of string(url) and BasicAuth
+    if isinstance(chain_or_plain, str) or (
+        isinstance(chain_or_plain, tuple) and len(chain_or_plain) == 2
+    ):
+        chain_or_plain = cast(_ProxyBasic, chain_or_plain)
+        return ProxyConnector, _retrieve_basic(chain_or_plain)
+
+    chain_or_plain = cast(_ProxyChain, chain_or_plain)
+    infos: List[ProxyInfo] = []
+    for basic in chain_or_plain:
+        infos.append(ProxyInfo(**_retrieve_basic(basic)))
+
+    return ChainProxyConnector, {"proxy_infos": infos}
+
+
+class AiohttpSession(BaseSession):
+    def __init__(
+        self, proxy: Optional[_ProxyType] = None, limit: int = 100, **kwargs: Any
+    ) -> None:
+        """
+        Client session based on aiohttp.
+
+        :param proxy: The proxy to be used for requests. Default is None.
+        :param limit: The total number of simultaneous connections. Default is 100.
+        :param kwargs: Additional keyword arguments.
+        """
+        super().__init__(**kwargs)
+
+        self._session: Optional[ClientSession] = None
+        self._connector_type: Type[TCPConnector] = TCPConnector
+        self._connector_init: Dict[str, Any] = {
+            "ssl": ssl.create_default_context(cafile=certifi.where()),
+            "limit": limit,
+            "ttl_dns_cache": 3600,  # Workaround for https://github.com/aiogram/aiogram/issues/1500
+        }
+        self._should_reset_connector = True  # flag determines connector state
+        self._proxy: Optional[_ProxyType] = None
+
+        if proxy is not None:
+            try:
+                self._setup_proxy_connector(proxy)
+            except ImportError as exc:  # pragma: no cover
+                raise RuntimeError(
+                    "In order to use aiohttp client for proxy requests, install "
+                    "https://pypi.org/project/aiohttp-socks/"
+                ) from exc
+
+    def _setup_proxy_connector(self, proxy: _ProxyType) -> None:
+        self._connector_type, self._connector_init = _prepare_connector(proxy)
+        self._proxy = proxy
+
+    @property
+    def proxy(self) -> Optional[_ProxyType]:
+        return self._proxy
+
+    @proxy.setter
+    def proxy(self, proxy: _ProxyType) -> None:
+        self._setup_proxy_connector(proxy)
+        self._should_reset_connector = True
+
+    async def create_session(self) -> ClientSession:
+        if self._should_reset_connector:
+            await self.close()
+
+        if self._session is None or self._session.closed:
+            self._session = ClientSession(
+                connector=self._connector_type(**self._connector_init),
+                headers={
+                    USER_AGENT: f"{SERVER_SOFTWARE} aiogram/{__version__}",
+                },
+            )
+            self._should_reset_connector = False
+
+        return self._session
+
+    async def close(self) -> None:
+        if self._session is not None and not self._session.closed:
+            await self._session.close()
+
+            # Wait 250 ms for the underlying SSL connections to close
+            # https://docs.aiohttp.org/en/stable/client_advanced.html#graceful-shutdown
+            await asyncio.sleep(0.25)
+
+    def build_form_data(self, bot: Bot, method: TelegramMethod[TelegramType]) -> FormData:
+        form = FormData(quote_fields=False)
+        files: Dict[str, InputFile] = {}
+        for key, value in method.model_dump(warnings=False).items():
+            value = self.prepare_value(value, bot=bot, files=files)
+            if not value:
+                continue
+            form.add_field(key, value)
+        for key, value in files.items():
+            form.add_field(
+                key,
+                value.read(bot),
+                filename=value.filename or key,
+            )
+        return form
+
+    async def make_request(
+        self, bot: Bot, method: TelegramMethod[TelegramType], timeout: Optional[int] = None
+    ) -> TelegramType:
+        session = await self.create_session()
+
+        url = self.api.api_url(token=bot.token, method=method.__api_method__)
+        form = self.build_form_data(bot=bot, method=method)
+
+        try:
+            async with session.post(
+                url, data=form, timeout=self.timeout if timeout is None else timeout
+            ) as resp:
+                raw_result = await resp.text()
+        except asyncio.TimeoutError:
+            raise TelegramNetworkError(method=method, message="Request timeout error")
+        except ClientError as e:
+            raise TelegramNetworkError(method=method, message=f"{type(e).__name__}: {e}")
+        response = self.check_response(
+            bot=bot, method=method, status_code=resp.status, content=raw_result
+        )
+        return cast(TelegramType, response.result)
+
+    async def stream_content(
+        self,
+        url: str,
+        headers: Optional[Dict[str, Any]] = None,
+        timeout: int = 30,
+        chunk_size: int = 65536,
+        raise_for_status: bool = True,
+    ) -> AsyncGenerator[bytes, None]:
+        if headers is None:
+            headers = {}
+
+        session = await self.create_session()
+
+        async with session.get(
+            url, timeout=timeout, headers=headers, raise_for_status=raise_for_status
+        ) as resp:
+            async for chunk in resp.content.iter_chunked(chunk_size):
+                yield chunk
+
+    async def __aenter__(self) -> AiohttpSession:
+        await self.create_session()
+        return self

myenv/Lib/site-packages/aiogram/client/session/base.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import abc
+import datetime
+import json
+import secrets
+from enum import Enum
+from http import HTTPStatus
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Callable,
+    Dict,
+    Final,
+    Optional,
+    Type,
+    cast,
+)
+
+from pydantic import ValidationError
+
+from aiogram.exceptions import (
+    ClientDecodeError,
+    RestartingTelegram,
+    TelegramAPIError,
+    TelegramBadRequest,
+    TelegramConflictError,
+    TelegramEntityTooLarge,
+    TelegramForbiddenError,
+    TelegramMigrateToChat,
+    TelegramNotFound,
+    TelegramRetryAfter,
+    TelegramServerError,
+    TelegramUnauthorizedError,
+)
+
+from ...methods import Response, TelegramMethod
+from ...methods.base import TelegramType
+from ...types import InputFile, TelegramObject
+from ..default import Default
+from ..telegram import PRODUCTION, TelegramAPIServer
+from .middlewares.manager import RequestMiddlewareManager
+
+if TYPE_CHECKING:
+    from ..bot import Bot
+
+_JsonLoads = Callable[..., Any]
+_JsonDumps = Callable[..., str]
+
+DEFAULT_TIMEOUT: Final[float] = 60.0
+
+
+class BaseSession(abc.ABC):
+    """
+    This is base class for all HTTP sessions in aiogram.
+
+    If you want to create your own session, you must inherit from this class.
+    """
+
+    def __init__(
+        self,
+        api: TelegramAPIServer = PRODUCTION,
+        json_loads: _JsonLoads = json.loads,
+        json_dumps: _JsonDumps = json.dumps,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> None:
+        """
+
+        :param api: Telegram Bot API URL patterns
+        :param json_loads: JSON loader
+        :param json_dumps: JSON dumper
+        :param timeout: Session scope request timeout
+        """
+        self.api = api
+        self.json_loads = json_loads
+        self.json_dumps = json_dumps
+        self.timeout = timeout
+
+        self.middleware = RequestMiddlewareManager()
+
+    def check_response(
+        self, bot: Bot, method: TelegramMethod[TelegramType], status_code: int, content: str
+    ) -> Response[TelegramType]:
+        """
+        Check response status
+        """
+        try:
+            json_data = self.json_loads(content)
+        except Exception as e:
+            # Handled error type can't be classified as specific error
+            # in due to decoder can be customized and raise any exception
+
+            raise ClientDecodeError("Failed to decode object", e, content)
+
+        try:
+            response_type = Response[method.__returning__]  # type: ignore
+            response = response_type.model_validate(json_data, context={"bot": bot})
+        except ValidationError as e:
+            raise ClientDecodeError("Failed to deserialize object", e, json_data)
+
+        if HTTPStatus.OK <= status_code <= HTTPStatus.IM_USED and response.ok:
+            return response
+
+        description = cast(str, response.description)
+
+        if parameters := response.parameters:
+            if parameters.retry_after:
+                raise TelegramRetryAfter(
+                    method=method, message=description, retry_after=parameters.retry_after
+                )
+            if parameters.migrate_to_chat_id:
+                raise TelegramMigrateToChat(
+                    method=method,
+                    message=description,
+                    migrate_to_chat_id=parameters.migrate_to_chat_id,
+                )
+        if status_code == HTTPStatus.BAD_REQUEST:
+            raise TelegramBadRequest(method=method, message=description)
+        if status_code == HTTPStatus.NOT_FOUND:
+            raise TelegramNotFound(method=method, message=description)
+        if status_code == HTTPStatus.CONFLICT:
+            raise TelegramConflictError(method=method, message=description)
+        if status_code == HTTPStatus.UNAUTHORIZED:
+            raise TelegramUnauthorizedError(method=method, message=description)
+        if status_code == HTTPStatus.FORBIDDEN:
+            raise TelegramForbiddenError(method=method, message=description)
+        if status_code == HTTPStatus.REQUEST_ENTITY_TOO_LARGE:
+            raise TelegramEntityTooLarge(method=method, message=description)
+        if status_code >= HTTPStatus.INTERNAL_SERVER_ERROR:
+            if "restart" in description:
+                raise RestartingTelegram(method=method, message=description)
+            raise TelegramServerError(method=method, message=description)
+
+        raise TelegramAPIError(
+            method=method,
+            message=description,
+        )
+
+    @abc.abstractmethod
+    async def close(self) -> None:  # pragma: no cover
+        """
+        Close client session
+        """
+        pass
+
+    @abc.abstractmethod
+    async def make_request(
+        self,
+        bot: Bot,
+        method: TelegramMethod[TelegramType],
+        timeout: Optional[int] = None,
+    ) -> TelegramType:  # pragma: no cover
+        """
+        Make request to Telegram Bot API
+
+        :param bot: Bot instance
+        :param method: Method instance
+        :param timeout: Request timeout
+        :return:
+        :raise TelegramApiError:
+        """
+        pass
+
+    @abc.abstractmethod
+    async def stream_content(
+        self,
+        url: str,
+        headers: Optional[Dict[str, Any]] = None,
+        timeout: int = 30,
+        chunk_size: int = 65536,
+        raise_for_status: bool = True,
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        """
+        Stream reader
+        """
+        yield b""
+
+    def prepare_value(
+        self,
+        value: Any,
+        bot: Bot,
+        files: Dict[str, Any],
+        _dumps_json: bool = True,
+    ) -> Any:
+        """
+        Prepare value before send
+        """
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return value
+        if isinstance(value, Default):
+            default_value = bot.default[value.name]
+            return self.prepare_value(default_value, bot=bot, files=files, _dumps_json=_dumps_json)
+        if isinstance(value, InputFile):
+            key = secrets.token_urlsafe(10)
+            files[key] = value
+            return f"attach://{key}"
+        if isinstance(value, dict):
+            value = {
+                key: prepared_item
+                for key, item in value.items()
+                if (
+                    prepared_item := self.prepare_value(
+                        item, bot=bot, files=files, _dumps_json=False
+                    )
+                )
+                is not None
+            }
+            if _dumps_json:
+                return self.json_dumps(value)
+            return value
+        if isinstance(value, list):
+            value = [
+                prepared_item
+                for item in value
+                if (
+                    prepared_item := self.prepare_value(
+                        item, bot=bot, files=files, _dumps_json=False
+                    )
+                )
+                is not None
+            ]
+            if _dumps_json:
+                return self.json_dumps(value)
+            return value
+        if isinstance(value, datetime.timedelta):
+            now = datetime.datetime.now()
+            return str(round((now + value).timestamp()))
+        if isinstance(value, datetime.datetime):
+            return str(round(value.timestamp()))
+        if isinstance(value, Enum):
+            return self.prepare_value(value.value, bot=bot, files=files)
+        if isinstance(value, TelegramObject):
+            return self.prepare_value(
+                value.model_dump(warnings=False),
+                bot=bot,
+                files=files,
+                _dumps_json=_dumps_json,
+            )
+        if _dumps_json:
+            return self.json_dumps(value)
+        return value
+
+    async def __call__(
+        self,
+        bot: Bot,
+        method: TelegramMethod[TelegramType],
+        timeout: Optional[int] = None,
+    ) -> TelegramType:
+        middleware = self.middleware.wrap_middlewares(self.make_request, timeout=timeout)
+        return cast(TelegramType, await middleware(bot, method))
+
+    async def __aenter__(self) -> BaseSession:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.close()

myenv/Lib/site-packages/aiogram/client/session/middlewares/base.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Protocol
+
+from aiogram.methods import Response, TelegramMethod
+from aiogram.methods.base import TelegramType
+
+if TYPE_CHECKING:
+    from ...bot import Bot
+
+
+class NextRequestMiddlewareType(Protocol[TelegramType]):  # pragma: no cover
+    async def __call__(
+        self,
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        pass
+
+
+class RequestMiddlewareType(Protocol):  # pragma: no cover
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        pass
+
+
+class BaseRequestMiddleware(ABC):
+    """
+    Generic middleware class
+    """
+
+    @abstractmethod
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        """
+        Execute middleware
+
+        :param make_request: Wrapped make_request in middlewares chain
+        :param bot: bot for request making
+        :param method: Request method (Subclass of :class:`aiogram.methods.base.TelegramMethod`)
+
+        :return: :class:`aiogram.methods.Response`
+        """
+        pass

myenv/Lib/site-packages/aiogram/client/session/middlewares/manager.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from functools import partial
+from typing import Any, Callable, List, Optional, Sequence, Union, cast, overload
+
+from aiogram.client.session.middlewares.base import (
+    NextRequestMiddlewareType,
+    RequestMiddlewareType,
+)
+from aiogram.methods.base import TelegramType
+
+
+class RequestMiddlewareManager(Sequence[RequestMiddlewareType]):
+    def __init__(self) -> None:
+        self._middlewares: List[RequestMiddlewareType] = []
+
+    def register(
+        self,
+        middleware: RequestMiddlewareType,
+    ) -> RequestMiddlewareType:
+        self._middlewares.append(middleware)
+        return middleware
+
+    def unregister(self, middleware: RequestMiddlewareType) -> None:
+        self._middlewares.remove(middleware)
+
+    def __call__(
+        self,
+        middleware: Optional[RequestMiddlewareType] = None,
+    ) -> Union[
+        Callable[[RequestMiddlewareType], RequestMiddlewareType],
+        RequestMiddlewareType,
+    ]:
+        if middleware is None:
+            return self.register
+        return self.register(middleware)
+
+    @overload
+    def __getitem__(self, item: int) -> RequestMiddlewareType:
+        pass
+
+    @overload
+    def __getitem__(self, item: slice) -> Sequence[RequestMiddlewareType]:
+        pass
+
+    def __getitem__(
+        self, item: Union[int, slice]
+    ) -> Union[RequestMiddlewareType, Sequence[RequestMiddlewareType]]:
+        return self._middlewares[item]
+
+    def __len__(self) -> int:
+        return len(self._middlewares)
+
+    def wrap_middlewares(
+        self,
+        callback: NextRequestMiddlewareType[TelegramType],
+        **kwargs: Any,
+    ) -> NextRequestMiddlewareType[TelegramType]:
+        middleware = partial(callback, **kwargs)
+        for m in reversed(self._middlewares):
+            middleware = partial(m, middleware)
+        return cast(NextRequestMiddlewareType[TelegramType], middleware)

myenv/Lib/site-packages/aiogram/client/session/middlewares/request_logging.py

@@ -0,0 +1,37 @@
+import logging
+from typing import TYPE_CHECKING, Any, List, Optional, Type
+
+from aiogram import loggers
+from aiogram.methods import TelegramMethod
+from aiogram.methods.base import Response, TelegramType
+
+from .base import BaseRequestMiddleware, NextRequestMiddlewareType
+
+if TYPE_CHECKING:
+    from ...bot import Bot
+
+logger = logging.getLogger(__name__)
+
+
+class RequestLogging(BaseRequestMiddleware):
+    def __init__(self, ignore_methods: Optional[List[Type[TelegramMethod[Any]]]] = None):
+        """
+        Middleware for logging outgoing requests
+
+        :param ignore_methods: methods to ignore in logging middleware
+        """
+        self.ignore_methods = ignore_methods if ignore_methods else []
+
+    async def __call__(
+        self,
+        make_request: NextRequestMiddlewareType[TelegramType],
+        bot: "Bot",
+        method: TelegramMethod[TelegramType],
+    ) -> Response[TelegramType]:
+        if type(method) not in self.ignore_methods:
+            loggers.middlewares.info(
+                "Make request with method=%r by bot id=%d",
+                type(method).__name__,
+                bot.id,
+            )
+        return await make_request(bot, method)

myenv/Lib/site-packages/aiogram/client/telegram.py

@@ -0,0 +1,103 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Union
+
+
+class FilesPathWrapper(ABC):
+    @abstractmethod
+    def to_local(self, path: Union[Path, str]) -> Union[Path, str]:
+        pass
+
+    @abstractmethod
+    def to_server(self, path: Union[Path, str]) -> Union[Path, str]:
+        pass
+
+
+class BareFilesPathWrapper(FilesPathWrapper):
+    def to_local(self, path: Union[Path, str]) -> Union[Path, str]:
+        return path
+
+    def to_server(self, path: Union[Path, str]) -> Union[Path, str]:
+        return path
+
+
+class SimpleFilesPathWrapper(FilesPathWrapper):
+    def __init__(self, server_path: Path, local_path: Path) -> None:
+        self.server_path = server_path
+        self.local_path = local_path
+
+    @classmethod
+    def _resolve(
+        cls, base1: Union[Path, str], base2: Union[Path, str], value: Union[Path, str]
+    ) -> Path:
+        relative = Path(value).relative_to(base1)
+        return base2 / relative
+
+    def to_local(self, path: Union[Path, str]) -> Union[Path, str]:
+        return self._resolve(base1=self.server_path, base2=self.local_path, value=path)
+
+    def to_server(self, path: Union[Path, str]) -> Union[Path, str]:
+        return self._resolve(base1=self.local_path, base2=self.server_path, value=path)
+
+
+@dataclass(frozen=True)
+class TelegramAPIServer:
+    """
+    Base config for API Endpoints
+    """
+
+    base: str
+    """Base URL"""
+    file: str
+    """Files URL"""
+    is_local: bool = False
+    """Mark this server is
+    in `local mode <https://core.telegram.org/bots/api#using-a-local-bot-api-server>`_."""
+    wrap_local_file: FilesPathWrapper = BareFilesPathWrapper()
+    """Callback to wrap files path in local mode"""
+
+    def api_url(self, token: str, method: str) -> str:
+        """
+        Generate URL for API methods
+
+        :param token: Bot token
+        :param method: API method name (case insensitive)
+        :return: URL
+        """
+        return self.base.format(token=token, method=method)
+
+    def file_url(self, token: str, path: Union[str, Path]) -> str:
+        """
+        Generate URL for downloading files
+
+        :param token: Bot token
+        :param path: file path
+        :return: URL
+        """
+        return self.file.format(token=token, path=path)
+
+    @classmethod
+    def from_base(cls, base: str, **kwargs: Any) -> "TelegramAPIServer":
+        """
+        Use this method to auto-generate TelegramAPIServer instance from base URL
+
+        :param base: Base URL
+        :return: instance of :class:`TelegramAPIServer`
+        """
+        base = base.rstrip("/")
+        return cls(
+            base=f"{base}/bot{{token}}/{{method}}",
+            file=f"{base}/file/bot{{token}}/{{path}}",
+            **kwargs,
+        )
+
+
+PRODUCTION = TelegramAPIServer(
+    base="https://api.telegram.org/bot{token}/{method}",
+    file="https://api.telegram.org/file/bot{token}/{path}",
+)
+TEST = TelegramAPIServer(
+    base="https://api.telegram.org/bot{token}/test/{method}",
+    file="https://api.telegram.org/file/bot{token}/test/{path}",
+)