telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.1__py3-none-any.whl

telegrinder/tools/magic.py

@@ -1,59 +1,106 @@
+from __future__ import annotations
+
+import asyncio
+import dataclasses
 import enum
-import types
-import typing
+import inspect
+from collections import OrderedDict
 from functools import wraps
 
+import typing_extensions as typing
+from fntypes import Result
+
+from telegrinder.model import get_params
+
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
     from telegrinder.node.polymorphic import Polymorphic
 
-    T = typing.TypeVar("T", bound=ABCRule)
-    F = typing.TypeVar(
-        "F",
-        bound=typing.Callable[typing.Concatenate[typing.Callable[..., typing.Any], ...], typing.Any],
-    )
-
-Impl: typing.TypeAlias = type[classmethod]
-FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
+type Impl = type[classmethod]
+type Function = typing.Callable[..., typing.Any]
+type Executor[T] = typing.Callable[
+    [T, str, dict[str, typing.Any]],
+    typing.Awaitable[Result[typing.Any, typing.Any]],
+]
 
 TRANSLATIONS_KEY: typing.Final[str] = "_translations"
+MORPH_IMPLEMENTATIONS_KEY = "__morph_implementations__"
 IMPL_MARK: typing.Final[str] = "_is_impl"
+CONTEXT_KEYS: typing.Final[tuple[str, ...]] = ("ctx", "context")
+
+
+class FuncParams(typing.TypedDict, total=True):
+    args: list[tuple[str, typing.Any | inspect.Parameter.empty]]
+    kwargs: list[tuple[str, typing.Any | inspect.Parameter.empty]]
+    var_args: typing.NotRequired[str]
+    var_kwargs: typing.NotRequired[str]
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class Shortcut[T]:
+    method_name: str
+    executor: Executor[T] | None = dataclasses.field(default=None, kw_only=True)
+    custom_params: set[str] = dataclasses.field(default_factory=lambda: set[str](), kw_only=True)
 
 
 def cache_magic_value(mark_key: str, /):
-    def inner(func: "F") -> "F":
+    def inner[Func: typing.Callable[..., typing.Any]](func: Func) -> Func:
         @wraps(func)
-        def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
-            if mark_key not in args[0].__dict__:
-                args[0].__dict__[mark_key] = func(*args, **kwargs)
-            return args[0].__dict__[mark_key]
+        def wrapper(
+            f: Function | None = None,
+            /,
+            *args: typing.Any,
+            **kwargs: typing.Any,
+        ) -> typing.Any:
+            if f is not None and mark_key not in f.__dict__:
+                f.__dict__[mark_key] = func(f, *args, **kwargs)
+            return f.__dict__[mark_key]
 
         return wrapper  # type: ignore
 
     return inner
 
 
-def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:
+def resolve_arg_names(func: Function, start_idx: int = 1) -> tuple[str, ...]:
     return func.__code__.co_varnames[start_idx : func.__code__.co_argcount]
 
 
-@cache_magic_value("__default_args__")
-def get_default_args(func: FuncType) -> dict[str, typing.Any]:
-    kwdefaults = func.__kwdefaults__
-    if kwdefaults:
-        return kwdefaults
-
+@cache_magic_value("__default_arguments__")
+def get_default_args(func: Function, /) -> dict[str, typing.Any]:
     defaults = func.__defaults__
+    kwdefaults = {} if not func.__kwdefaults__ else func.__kwdefaults__.copy()
     if not defaults:
-        return {}
+        return kwdefaults
+    return {
+        k: defaults[i] for i, k in enumerate(resolve_arg_names(func, start_idx=0)[-len(defaults) :])
+    } | kwdefaults
+
+
+@cache_magic_value("__function_parameters__")
+def get_func_parameters(func: Function, /) -> FuncParams:
+    func_params: FuncParams = {"args": [], "kwargs": []}
+
+    for k, p in inspect.signature(func).parameters.items():
+        if k in ("self", "cls"):
+            continue
+
+        match p.kind:
+            case p.POSITIONAL_OR_KEYWORD | p.POSITIONAL_ONLY:
+                func_params["args"].append((k, p.default))
+            case p.KEYWORD_ONLY:
+                func_params["kwargs"].append((k, p.default))
+            case p.VAR_POSITIONAL:
+                func_params["var_args"] = k
+            case p.VAR_KEYWORD:
+                func_params["var_kwargs"] = k
 
-    return {k: defaults[i] for i, k in enumerate(resolve_arg_names(func, start_idx=0)[-len(defaults) :])}
+    return func_params
 
 
-def get_annotations(func: FuncType, *, return_type: bool = False) -> dict[str, typing.Any]:
-    annotations = func.__annotations__
-    if not return_type and "return" in func.__annotations__:
-        annotations.pop("return")
+def get_annotations(func: Function, *, return_type: bool = False) -> dict[str, typing.Any]:
+    annotations = func.__annotations__.copy()
+    if not return_type:
+        annotations.pop("return", None)
     return annotations
 
 
@@ -64,70 +111,106 @@ def to_str(s: str | enum.Enum) -> str:
 
 
 @typing.overload
-def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]: ...
+def magic_bundle(
+    function: Function,
+    kw: dict[str, typing.Any],
+    *,
+    start_idx: int = 1,
+    omit_defaults: bool = False,
+) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
-def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]: ...
+def magic_bundle(
+    function: Function,
+    kw: dict[enum.Enum, typing.Any],
+    *,
+    start_idx: int = 1,
+    omit_defaults: bool = False,
+) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
 def magic_bundle(
-    handler: FuncType,
+    function: Function,
     kw: dict[str, typing.Any],
     *,
     start_idx: int = 1,
-    bundle_ctx: bool = True,
+    bundle_ctx: bool = False,
+    omit_defaults: bool = False,
 ) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
 def magic_bundle(
-    handler: FuncType,
+    function: Function,
     kw: dict[enum.Enum, typing.Any],
     *,
     start_idx: int = 1,
-    bundle_ctx: bool = True,
+    bundle_ctx: bool = False,
+    omit_defaults: bool = False,
 ) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
 def magic_bundle(
-    handler: FuncType,
-    kw: dict[type, typing.Any],
+    function: Function,
+    kw: dict[type[typing.Any], typing.Any],
     *,
+    start_idx: int = 1,
     typebundle: typing.Literal[True] = True,
+    omit_defaults: bool = False,
 ) -> dict[str, typing.Any]: ...
 
 
 def magic_bundle(
-    handler: FuncType,
+    function: Function,
     kw: dict[typing.Any, typing.Any],
     *,
     start_idx: int = 1,
-    bundle_ctx: bool = True,
+    bundle_ctx: bool = False,
     typebundle: bool = False,
+    omit_defaults: bool = False,
 ) -> dict[str, typing.Any]:
+    # Bundle considering the function annotations
     if typebundle:
-        types = get_annotations(handler, return_type=False)
-        bundle: dict[str, typing.Any] = {}
-        for name, type in types.items():
-            bundle[name] = kw[type]
-        return bundle
-
-    names = resolve_arg_names(handler, start_idx=start_idx)
-    args = get_default_args(handler)
-    args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
-    if "ctx" in names and bundle_ctx:
-        args["ctx"] = kw
+        return {name: kw[t] for name, t in get_annotations(function, return_type=False).items() if t in kw}
+
+    names = resolve_arg_names(function, start_idx=start_idx)
+    # Determine if the function is only have the **kwargs parameter, then bundle all kw
+    if "var_kwargs" in get_func_parameters(function) and not names:
+        return {to_str(k): v for k, v in kw.items()}
+
+    # Bundle considering the function parameters and defaults (if do not omit defaults)
+    defaults = {} if omit_defaults else get_default_args(function)
+    args = defaults | {n: v for k, v in kw.items() if (n := to_str(k)) in names}
+
+    # Bundle a context if context key specified in `names`
+    if bundle_ctx:
+        for key in CONTEXT_KEYS:
+            if key in names:
+                args[key] = kw
+                break
+
     return args
 
 
-def get_cached_translation(rule: "T", locale: str) -> "T | None":
+def join_dicts[Key: typing.Hashable, Value](
+    left_dict: dict[Key, typing.Any],
+    right_dict: dict[typing.Any, Value],
+) -> dict[Key, Value]:
+    return {key: right_dict[type_key] for key, type_key in left_dict.items()}
+
+
+def get_cached_translation[Rule: ABCRule](rule: Rule, locale: str) -> Rule | None:
     return getattr(rule, TRANSLATIONS_KEY, {}).get(locale)
 
 
-def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None:
+def cache_translation[Rule: ABCRule](
+    base_rule: Rule,
+    locale: str,
+    translated_rule: Rule,
+) -> None:
     translations = getattr(base_rule, TRANSLATIONS_KEY, {})
     translations[locale] = translated_rule
     setattr(base_rule, TRANSLATIONS_KEY, translations)
@@ -139,30 +222,123 @@ def impl(method: typing.Callable[..., typing.Any]):
     return classmethod(method)
 
 
-def get_impls(cls: type["Polymorphic"]) -> list[typing.Callable[..., typing.Any]]:
-    moprh_impls = getattr(cls, "__morph_impls__", None)
+def get_polymorphic_implementations(cls: type[Polymorphic], /) -> list[typing.Callable[..., typing.Any]]:
+    moprh_impls = getattr(cls, MORPH_IMPLEMENTATIONS_KEY, None)
     if moprh_impls is not None:
         return moprh_impls
-    impls = [
-        func.__func__
-        for func in vars(cls).values()
-        if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
-    ]
-    setattr(cls, "__morph_impls__", impls)
+
+    impls = []
+    for cls_ in cls.mro():
+        impls += [
+            obj.__func__
+            for obj in vars(cls_).values()
+            if isinstance(obj, classmethod) and getattr(obj.__func__, IMPL_MARK, False)
+        ]
+
+    setattr(cls, MORPH_IMPLEMENTATIONS_KEY, impls)
     return impls
 
 
+def shortcut[T](
+    method_name: str,
+    *,
+    executor: Executor[T] | None = None,
+    custom_params: set[str] | None = None,
+):
+    """Decorate a cute method as a shortcut."""
+
+    def wrapper[F: typing.Callable[..., typing.Any]](func: F) -> F:
+        @wraps(func)
+        async def inner(
+            self: T,
+            *args: typing.Any,
+            **kwargs: typing.Any,
+        ) -> typing.Any:
+            if executor is None:
+                return await func(self, *args, **kwargs)
+
+            params: dict[str, typing.Any] = OrderedDict()
+            func_params = get_func_parameters(func)
+
+            for index, (arg, default) in enumerate(func_params["args"]):
+                if len(args) > index:
+                    params[arg] = args[index]
+                elif default is not inspect.Parameter.empty:
+                    params[arg] = default
+
+            if var_args := func_params.get("var_args"):
+                params[var_args] = args[len(func_params["args"]) :]
+
+            for kwarg, default in func_params["kwargs"]:
+                params[kwarg] = (
+                    kwargs.pop(kwarg, default) if default is not inspect.Parameter.empty else kwargs.pop(kwarg)
+                )
+
+            if var_kwargs := func_params.get("var_kwargs"):
+                params[var_kwargs] = kwargs.copy()
+
+            return await executor(self, method_name, get_params(params))
+
+        inner.__shortcut__ = Shortcut(  # type: ignore
+            method_name=method_name,
+            executor=executor,
+            custom_params=custom_params or set(),
+        )
+        return inner  # type: ignore
+
+    return wrapper
+
+
+# Source code: https://github.com/facebookincubator/later/blob/main/later/task.py#L75
+async def cancel_future(fut: asyncio.Future[typing.Any], /) -> None:
+    if fut.done():
+        return
+
+    fut.cancel()
+    exc: asyncio.CancelledError | None = None
+
+    while not fut.done():
+        shielded = asyncio.shield(fut)
+        try:
+            await asyncio.wait([shielded])
+        except asyncio.CancelledError as ex:
+            exc = ex
+        finally:
+            # Insure we handle the exception/value that may exist on the shielded task
+            # This will prevent errors logged to the asyncio logger
+            if shielded.done() and not shielded.cancelled() and not shielded.exception():
+                shielded.result()
+
+    if fut.cancelled():
+        if exc is None:
+            return
+        raise exc from None
+
+    ex = fut.exception()
+    if ex is not None:
+        raise ex from None
+
+    raise asyncio.InvalidStateError(
+        f"Task did not raise CancelledError on cancel: {fut!r} had result {fut.result()!r}",
+    )
+
+
 __all__ = (
+    "Shortcut",
     "TRANSLATIONS_KEY",
     "cache_magic_value",
     "cache_translation",
+    "cancel_future",
     "get_annotations",
     "get_cached_translation",
     "get_default_args",
     "get_default_args",
-    "get_impls",
+    "get_func_parameters",
+    "get_polymorphic_implementations",
     "impl",
+    "join_dicts",
     "magic_bundle",
     "resolve_arg_names",
+    "shortcut",
     "to_str",
 )

telegrinder/tools/state_storage/abc.py

@@ -1,22 +1,19 @@
 import abc
+import dataclasses
 import enum
-import typing
-from dataclasses import dataclass
 
-from fntypes import Option
+from fntypes.option import Option
 
 from telegrinder.bot.rules.state import State, StateMeta
 
-Payload = typing.TypeVar("Payload")
 
-
-@dataclass(frozen=True, slots=True)
-class StateData(typing.Generic[Payload]):
+@dataclasses.dataclass(frozen=True, slots=True)
+class StateData[Payload]:
     key: str | enum.Enum
     payload: Payload
 
 
-class ABCStateStorage(abc.ABC, typing.Generic[Payload]):
+class ABCStateStorage[Payload](abc.ABC):
     @abc.abstractmethod
     async def get(self, user_id: int) -> Option[StateData[Payload]]: ...
 
@@ -28,7 +25,6 @@ class ABCStateStorage(abc.ABC, typing.Generic[Payload]):
 
     def State(self, key: str | StateMeta | enum.Enum = StateMeta.ANY, /) -> State[Payload]:  # noqa: N802
         """Can be used as a shortcut to get a state rule dependant on current storage."""
-
         return State(storage=self, key=key)
 
 

telegrinder/tools/state_storage/memory.py

@@ -5,7 +5,7 @@ from fntypes.option import Option
 from telegrinder.tools.functional import from_optional
 from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
 
-Payload: typing.TypeAlias = dict[str, typing.Any]
+type Payload = dict[str, typing.Any]
 
 
 class MemoryStateStorage(ABCStateStorage[Payload]):

telegrinder/tools/strings.py

@@ -0,0 +1,13 @@
+import re
+
+PATTERN = re.compile(r"[^ a-z A-Z 0-9 \s]")
+
+
+def to_pascal_case(string: str, /) -> str:
+    return "".join(
+        "".join(char.capitalize() for char in sub_str)
+        for sub_str in (char.split() for char in PATTERN.split(string))
+    )
+
+
+__all__ = ("to_pascal_case",)

telegrinder/types/__init__.py

@@ -2,6 +2,7 @@ from telegrinder.types.enums import *
 from telegrinder.types.objects import *
 
 __all__ = (
+    "AffiliateInfo",
     "Animation",
     "Audio",
     "BackgroundFill",
@@ -68,6 +69,7 @@ __all__ = (
     "ChosenInlineResult",
     "Contact",
     "ContentType",
+    "CopyTextButton",
     "Currency",
     "DefaultAccentColor",
     "Dice",
@@ -88,6 +90,8 @@ __all__ = (
     "GameHighScore",
     "GeneralForumTopicHidden",
     "GeneralForumTopicUnhidden",
+    "Gift",
+    "Gifts",
     "Giveaway",
     "GiveawayCompleted",
     "GiveawayCreated",
@@ -199,6 +203,7 @@ __all__ = (
     "PollOption",
     "PollType",
     "PreCheckoutQuery",
+    "PreparedInlineMessage",
     "ProgrammingLanguage",
     "ProximityAlertTriggered",
     "ReactionCount",
@@ -235,9 +240,12 @@ __all__ = (
     "TextQuote",
     "TopicIconColor",
     "TransactionPartner",
+    "TransactionPartnerAffiliateProgram",
+    "TransactionPartnerChat",
     "TransactionPartnerFragment",
     "TransactionPartnerOther",
     "TransactionPartnerTelegramAds",
+    "TransactionPartnerTelegramApi",
     "TransactionPartnerUser",
     "Update",
     "UpdateType",

telegrinder/types/enums.py

@@ -52,7 +52,8 @@ class ChatAction(str, enum.Enum):
     - find_location for location data,
     - record_video_note or upload_video_note for video notes.
 
-    Docs: https://core.telegram.org/bots/api#sendchataction"""
+    Docs: https://core.telegram.org/bots/api#sendchataction
+    """
 
     TYPING = "typing"
     UPLOAD_PHOTO = "upload_photo"
@@ -77,7 +78,8 @@ class ReactionEmoji(str, enum.Enum):
     `✍`, `🤗`, `🫡`, `🎅`, `🎄`, `☃`, `💅`, `🤪`, `🗿`, `🆒`, `💘`, `🙉`, `🦄`, `😘`, `💊`,
     `🙊`, `😎`, `👾`, `🤷‍♂`, `🤷`, `🤷‍♀`, `😡`.
 
-    Docs: https://core.telegram.org/bots/api#reactiontypeemoji"""
+    Docs: https://core.telegram.org/bots/api#reactiontypeemoji
+    """
 
     THUMBS_UP = "👍"
     THUMBS_DOWN = "👎"
@@ -194,7 +196,8 @@ class TopicIconColor(int, enum.Enum):
 
 class ChatBoostSourceType(str, enum.Enum):
     """Type of ChatBoostSourceType
-    Docs: https://core.telegram.org/bots/api#chatboostsource"""
+    Docs: https://core.telegram.org/bots/api#chatboostsource
+    """
 
     PREMIUM = "premium"
     GIFT_CODE = "gift_code"
@@ -263,7 +266,8 @@ class ContentType(str, enum.Enum):
 
 class Currency(str, enum.Enum):
     """Type of Currency.
-    Docs: https://core.telegram.org/bots/payments#supported-currencies"""
+    Docs: https://core.telegram.org/bots/payments#supported-currencies
+    """
 
     AED = "AED"
     AFN = "AFN"
@@ -357,7 +361,8 @@ class Currency(str, enum.Enum):
 
 class InlineQueryResultType(str, enum.Enum):
     """Type of InlineQueryResultType.
-    Docs: https://core.telegram.org/bots/api#inlinequeryresult"""
+    Docs: https://core.telegram.org/bots/api#inlinequeryresult
+    """
 
     AUDIO = "audio"
     DOCUMENT = "document"
@@ -425,7 +430,8 @@ class UpdateType(str, enum.Enum):
 
 class BotCommandScopeType(str, enum.Enum):
     """Type of BotCommandScope.
-    Represents the scope to which bot commands are applied."""
+    Represents the scope to which bot commands are applied.
+    """
 
     DEFAULT = "default"
     ALL_PRIVATE_CHATS = "all_private_chats"
@@ -469,17 +475,17 @@ class DiceEmoji(str, enum.Enum):
 
 
 class MessageEntityType(str, enum.Enum):
-    """Type of the entity.
-    Currently, can be `mention` (`@username`), `hashtag`
-    (`#hashtag`), `cashtag` (`$USD`), `bot_command` (`/start@jobs_bot`),
-    `url` (`https://telegram.org`), `email` (`do-not-reply@telegram.org`),
-    `phone_number` (`+1-212-555-0123`), `bold` (**bold text**), `italic`
-    (*italic text*), `underline` (underlined text), `strikethrough` (strikethrough
-    text), `spoiler` (spoiler message), `code` (monowidth string), `pre`
-    (monowidth block), `text_link` (for clickable text URLs), `text_mention`
-    (for users [without usernames](https://telegram.org/blog/edit#new-mentions)),
-    `custom_emoji` (for inline custom emoji stickers), `blockquote` (blockquote)
-    [docs](https://core.telegram.org/bots/api#messageentity)"""
+    """Type of the entity. Currently, can be `mention` (@username), `hashtag`
+    (#hashtag or #hashtag@chatusername), `cashtag` ($USD or $USD@chatusername),
+    `bot_command` (/start@jobs_bot), `url` (https://telegram.org), `email`
+    (do-not-reply@telegram.org), `phone_number` (+1-212-555-0123),
+    `bold` (bold text), `italic` (italic text), `underline` (underlined
+    text), `strikethrough` (strikethrough text), `spoiler` (spoiler message),
+    `blockquote` (block quotation), `expandable_blockquote` (collapsed-by-default
+    block quotation), `code` (monowidth string), `pre` (monowidth block),
+    `text_link` (for clickable text URLs), `text_mention` (for users without
+    usernames), `custom_emoji` (for inline custom emoji stickers).
+    """
 
     MENTION = "mention"
     HASHTAG = "hashtag"
@@ -512,7 +518,8 @@ class PollType(str, enum.Enum):
 class StickerType(str, enum.Enum):
     """Type of the sticker, currently one of `regular`, `mask`, `custom_emoji`.
     The type of the sticker is independent from its format, which is determined
-    by the fields `is_animated` and `is_video`."""
+    by the fields `is_animated` and `is_video`.
+    """
 
     REGULAR = "regular"
     MASK = "mask"
@@ -521,7 +528,8 @@ class StickerType(str, enum.Enum):
 
 class MessageOriginType(str, enum.Enum):
     """Type of MessageOriginType
-    Docs: https://core.telegram.org/bots/api#messageorigin"""
+    Docs: https://core.telegram.org/bots/api#messageorigin
+    """
 
     USER = "user"
     HIDDEN_USER = "hidden_user"
@@ -539,7 +547,8 @@ class StickerSetStickerType(str, enum.Enum):
 
 class MaskPositionPoint(str, enum.Enum):
     """The part of the face relative to which the mask should be placed. One of `forehead`,
-    `eyes`, `mouth`, or `chin`."""
+    `eyes`, `mouth`, or `chin`.
+    """
 
     FOREHEAD = "forehead"
     EYES = "eyes"
@@ -552,7 +561,8 @@ class InlineQueryChatType(str, enum.Enum):
     either `sender` for a private chat with the inline query sender, `private`,
     `group`, `supergroup`, or `channel`. The chat type should be always known
     for requests sent from official clients and most third-party clients,
-    unless the request was sent from a secret chat."""
+    unless the request was sent from a secret chat.
+    """
 
     SENDER = "sender"
     PRIVATE = "private"

telegrinder/types/input_file.py

@@ -0,0 +1,51 @@
+import pathlib
+import secrets
+import typing
+
+from telegrinder.msgspec_utils import encoder
+
+type Files = dict[str, tuple[str, bytes]]
+
+
+class InputFile:
+    """Object `InputFile`, see the [documentation](https://core.telegram.org/bots/api#inputfile).
+
+    This object represents the contents of a file to be uploaded. Must be posted using `multipart/form-data` in the usual way that files are uploaded via the browser.
+    """
+
+    __slots__ = ("filename", "data")
+
+    filename: str
+    """File name."""
+
+    data: bytes
+    """Bytes of file."""
+
+    def __init__(self, filename: str, data: bytes) -> None:
+        self.filename = filename
+        self.data = data
+
+    def __repr__(self) -> str:
+        return "{}(filename={!r}, data={!r})".format(
+            self.__class__.__name__,
+            self.filename,
+            (self.data[:30] + b"...") if len(self.data) > 30 else self.data,
+        )
+
+    @classmethod
+    def from_path(cls, path: str | pathlib.Path, /) -> typing.Self:
+        path = pathlib.Path(path)
+        return cls(path.name, path.read_bytes())
+
+    def _to_multipart(self, files: Files, /) -> str:
+        attach_name = secrets.token_urlsafe(16)
+        files[attach_name] = (self.filename, self.data)
+        return f"attach://{attach_name}"
+
+
+@encoder.add_enc_hook(InputFile)
+def encode_inputfile(inputfile: InputFile, files: Files) -> str:
+    return inputfile._to_multipart(files)
+
+
+__all__ = ("InputFile",)