telegrinder 0.2.0.post2__py3-none-any.whl → 0.2.2__py3-none-any.whl

telegrinder/bot/dispatch/view/base.py

@@ -0,0 +1,200 @@
+import typing
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+from fntypes.option import Nothing, Some
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
+from telegrinder.msgspec_utils import Option
+from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.types.objects import Update
+
+Event = typing.TypeVar("Event", bound=BaseCute)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
+
+FuncType: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[Event, ...],
+    typing.Coroutine[typing.Any, typing.Any, typing.Any],
+]
+
+
+def get_event_model_class(view: "BaseView[Event]") -> Option[type[Event]]:
+    for base in view.__class__.__bases__ + (view.__class__,):
+        if "__orig_bases__" not in base.__dict__:
+            continue
+
+        for orig_base in base.__dict__["__orig_bases__"]:
+            origin_base = typing.get_origin(orig_base) or orig_base
+            if not isinstance(origin_base, type) and not issubclass(origin_base, object):
+                continue
+
+            for generic_type in typing.get_args(orig_base):
+                orig_generic_type = typing.get_origin(generic_type) or generic_type
+                if isinstance(orig_generic_type, type) and issubclass(orig_generic_type, BaseCute):
+                    return Some(generic_type)
+
+    return Nothing()
+
+
+class BaseView(ABCView, typing.Generic[Event]):
+    auto_rules: list[ABCRule]
+    handlers: list[ABCHandler[Event]]
+    middlewares: list[ABCMiddleware[Event]]
+    return_manager: ABCReturnManager[Event] | None = None
+
+    @staticmethod
+    def get_raw_event(update: Update) -> Option[Model]:
+        return getattr(update, update.update_type.value)
+
+    @cached_property
+    def event_model_class(self) -> Option[type[Event]]:
+        return get_event_model_class(self)
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+
+    @typing.overload
+    @classmethod
+    def to_handler(
+        cls,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @classmethod
+    def to_handler(  # type: ignore
+        cls,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[Event]):
+            return FuncHandler(
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+
+        return wrapper
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    @typing.overload
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule,
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[
+        [FuncType[Event]],
+        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
+    ]: ...
+
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule,
+        error_handler: ABCErrorHandler | None = None,
+        is_blocking: bool = True,
+    ):
+        def wrapper(func: FuncType[Event]):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking=is_blocking,
+                dataclass=None,
+                error_handler=error_handler or ErrorHandler(),
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+
+    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
+        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
+            self.middlewares.append(cls(*args, **kwargs))
+            return cls
+
+        return wrapper
+
+    async def check(self, event: Update) -> bool:
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.event_model_class.expect(
+                    "{!r} has no event model class in generic.".format(self.__class__.__qualname__),
+                ),
+                e.__class__,
+            ) and (self.handlers or self.middlewares):
+                return True
+            case _:
+                return False
+
+    async def process(self, event: Update, api: API) -> bool:
+        return await process_inner(
+            api,
+            self.event_model_class.unwrap().from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+    def load(self, external: typing.Self) -> None:
+        self.auto_rules.extend(external.auto_rules)
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+
+class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
+    @abstractmethod
+    def get_state_key(self, event: Event) -> int | None:
+        pass

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,6 +1,6 @@
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
+from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class CallbackQueryView(BaseStateView[CallbackQueryCute]):

telegrinder/bot/dispatch/view/chat_join_request.py

@@ -1,5 +1,5 @@
-from telegrinder.bot.cute_types import ChatJoinRequestCute
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class ChatJoinRequestView(BaseStateView[ChatJoinRequestCute]):

telegrinder/bot/dispatch/view/chat_member.py

@@ -1,7 +1,7 @@
 import typing
 
-from telegrinder.bot.cute_types import ChatMemberUpdatedCute
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.dispatch.view.base import BaseStateView
 from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
@@ -28,7 +28,6 @@ class ChatMemberView(BaseStateView[ChatMemberUpdatedCute]):
     def get_state_key(self, event: ChatMemberUpdatedCute) -> int | None:
         return event.chat_id
 
-
     async def check(self, event: Update) -> bool:
         return not (
             self.update_type is not None

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,6 +1,6 @@
-from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
+from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class InlineQueryView(BaseStateView[InlineQueryCute]):

telegrinder/bot/dispatch/view/message.py

@@ -1,9 +1,10 @@
 import typing
 
-from telegrinder.bot.cute_types import MessageCute
-from telegrinder.bot.dispatch.return_manager import MessageReturnManager
-from telegrinder.bot.dispatch.view.abc import BaseStateView
-from telegrinder.types import Update, UpdateType
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
+from telegrinder.bot.dispatch.view.base import BaseStateView
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 MessageUpdateType: typing.TypeAlias = typing.Literal[
     UpdateType.MESSAGE,

telegrinder/bot/dispatch/view/raw.py

@@ -1,10 +1,11 @@
 import typing
 
-from telegrinder.api import API
-from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.view.abc import ABCEventRawView, BaseView, ErrorHandlerT
+from telegrinder.bot.dispatch.view.abc import ABCEventRawView
+from telegrinder.bot.dispatch.view.base import BaseView, ErrorHandlerT
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.enums import UpdateType

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -2,9 +2,10 @@ import asyncio
 import datetime
 import typing
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
+from telegrinder.bot.dispatch.view.abc import ABCStateView
+from telegrinder.bot.dispatch.view.base import BaseStateView
 from telegrinder.bot.dispatch.waiter_machine.middleware import WaiterMiddleware
 from telegrinder.bot.dispatch.waiter_machine.short_state import (
     Behaviour,
@@ -45,13 +46,13 @@ class WaiterMachine:
 
     async def drop(
         self,
-        state_view: "ABCStateView[EventModel]",
+        state_view: "ABCStateView[EventModel] | str",
         id: Identificator,
         event: EventModel,
         update: Update,
         **context: typing.Any,
     ) -> None:
-        view_name = state_view.__class__.__name__
+        view_name = state_view if isinstance(state_view, str) else state_view.__class__.__name__
         if view_name not in self.storage:
             raise LookupError("No record of view {!r} found.".format(view_name))
 
@@ -61,13 +62,24 @@ class WaiterMachine:
 
         short_state.cancel()
         await self.call_behaviour(
-            state_view,
             event,
             update,
             behaviour=short_state.on_drop_behaviour,
             **context,
         )
 
+    async def drop_all(self) -> None:
+        """Drops all waiters in storage."""
+
+        for view_name in self.storage:
+            for ident, short_state in self.storage[view_name].items():
+                if short_state.context:
+                    await self.drop(
+                        view_name, ident, short_state.context.event, short_state.context.context.raw_update
+                    )
+                else:
+                    short_state.cancel()
+
     async def wait(
         self,
         state_view: "BaseStateView[EventModel]",
@@ -114,7 +126,6 @@ class WaiterMachine:
 
     async def call_behaviour(
         self,
-        view: "ABCStateView[EventModel]",
         event: EventModel,
         update: Update,
         behaviour: Behaviour[EventModel] | None = None,
@@ -147,7 +158,7 @@ class WaiterMachine:
             now = datetime.datetime.now()
             for ident, short_state in self.storage.get(view_name, {}).copy().items():
                 if short_state.expiration_date is not None and now > short_state.expiration_date:
-                    assert short_state.context
+                    assert short_state.context  # FIXME: why???
                     await self.drop(
                         view,
                         ident,

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -25,12 +25,6 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         self.view = view
 
     async def pre(self, event: EventType, ctx: Context) -> bool:
-        if not self.view or not hasattr(self.view, "get_state_key"):
-            raise RuntimeError(
-                "WaiterMiddleware cannot be used inside a view which doesn't "
-                "provide get_state_key (ABCStateView interface)."
-            )
-
         view_name = self.view.__class__.__name__
         if view_name not in self.machine.storage:
             return True
@@ -59,7 +53,6 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
 
         # before running the handler we check if the user wants to exit waiting
         if short_state.exit_behaviour is not None and await self.machine.call_behaviour(
-            self.view,
             event,
             ctx.raw_update,
             behaviour=short_state.exit_behaviour,
@@ -87,7 +80,6 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
-                self.view,
                 event,
                 ctx.raw_update,
                 behaviour=short_state.default_behaviour,

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -3,7 +3,7 @@ import dataclasses
 import datetime
 import typing
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler

telegrinder/bot/polling/polling.py

@@ -5,7 +5,7 @@ import aiohttp
 import msgspec
 from fntypes.result import Error, Ok
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.api.error import InvalidTokenError
 from telegrinder.bot.polling.abc import ABCPolling
 from telegrinder.modules import logger
@@ -72,7 +72,10 @@ class Polling(ABCPolling):
     async def get_updates(self) -> msgspec.Raw | None:
         raw_updates = await self.api.request_raw(
             "getUpdates",
-            {"offset": self.offset, "allowed_updates": self.allowed_updates},
+            {
+                "offset": self.offset,
+                "allowed_updates": self.allowed_updates,
+            },
         )
         match raw_updates:
             case Ok(value):

telegrinder/bot/rules/__init__.py

@@ -53,6 +53,7 @@ from telegrinder.bot.rules.node import NodeRule
 from telegrinder.bot.rules.regex import Regex
 from telegrinder.bot.rules.rule_enum import RuleEnum
 from telegrinder.bot.rules.start import StartCommand
+from telegrinder.bot.rules.state import State, StateMeta
 from telegrinder.bot.rules.text import HasText, Text
 from telegrinder.bot.rules.update import IsUpdateType
 
@@ -82,7 +83,6 @@ __all__ = (
     "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "IsInteger",
     "IntegerInRange",
     "InviteLinkByCreator",
     "InviteLinkName",
@@ -95,6 +95,7 @@ __all__ = (
     "IsForward",
     "IsForwardType",
     "IsGroup",
+    "IsInteger",
     "IsLanguageCode",
     "IsPremium",
     "IsPrivate",
@@ -106,11 +107,13 @@ __all__ = (
     "Markup",
     "MessageEntities",
     "MessageRule",
+    "NodeRule",
     "NotRule",
     "OrRule",
     "Regex",
     "RuleEnum",
     "StartCommand",
+    "State",
+    "StateMeta",
     "Text",
-    "NodeRule",
 )

telegrinder/bot/rules/abc.py

@@ -118,12 +118,13 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
         ctx: Context,
         node_col: "NodeCollection | None" = None,
     ) -> bool:
+        bound_check_rule = self.check
         kw = {}
         node_col_values = node_col.values if node_col is not None else {}
-        temp_ctx = get_default_args(self.check) | ctx
+        temp_ctx = get_default_args(bound_check_rule) | ctx
 
-        for i, (k, v) in enumerate(get_annotations(self.check).items()):
-            if (isinstance(adapted_value, Event) and not i) or (
+        for i, (k, v) in enumerate(get_annotations(bound_check_rule).items()):
+            if (isinstance(adapted_value, Event) and i == 0) or (  # First arg is Event
                 isinstance(v, type) and isinstance(adapted_value, v)
             ):
                 kw[k] = adapted_value if not isinstance(adapted_value, Event) else adapted_value.obj
@@ -140,14 +141,14 @@ class ABCRule(ABC, typing.Generic[AdaptTo]):
                     "because it cannot be resolved."
                 )
 
-        return await self.check(**kw)
+        return await bound_check_rule(**kw)
 
     async def translate(self, translator: ABCTranslator) -> typing.Self:
         return self
 
 
 class AndRule(ABCRule):
-    def __init__(self, *rules: ABCRule[AdaptTo]) -> None:
+    def __init__(self, *rules: ABCRule) -> None:
         self.rules = rules
 
     async def check(self, event: Update, ctx: Context) -> bool:

telegrinder/bot/rules/adapter/__init__.py

@@ -7,8 +7,8 @@ from telegrinder.bot.rules.adapter.raw_update import RawUpdateAdapter
 __all__ = (
     "ABCAdapter",
     "AdapterError",
+    "Event",
     "EventAdapter",
     "NodeAdapter",
     "RawUpdateAdapter",
-    "Event",
 )

telegrinder/bot/rules/integer.py

@@ -17,4 +17,4 @@ class IntegerInRange(ABCRule):
         return integer in self.rng
 
 
-__all__ = ("IsInteger", "IntegerInRange")
+__all__ = ("IntegerInRange", "IsInteger")

telegrinder/bot/rules/is_from.py

@@ -107,21 +107,40 @@ class IsSticker(MessageRule):
         return bool(message.sticker)
 
 
+class IsVideoNote(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.video_note)
+
+
+class IsDocument(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.document)
+
+
+class IsPhoto(MessageRule):
+    async def check(self, message: Message) -> bool:
+        return bool(message.photo)
+
+
 __all__ = (
     "IsBot",
     "IsChat",
     "IsChatId",
     "IsDice",
     "IsDiceEmoji",
+    "IsDocument",
     "IsForum",
     "IsForward",
     "IsForwardType",
     "IsGroup",
     "IsLanguageCode",
+    "IsPhoto",
     "IsPremium",
     "IsPrivate",
     "IsReply",
+    "IsSticker",
     "IsSuperGroup",
     "IsUser",
     "IsUserId",
+    "IsVideoNote",
 )

telegrinder/bot/rules/state.py

@@ -0,0 +1,37 @@
+import dataclasses
+import enum
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.source import Source
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.state_storage.abc import ABCStateStorage
+
+Payload = typing.TypeVar("Payload")
+
+
+class StateMeta(enum.Enum):
+    NO_STATE = enum.auto()
+    ANY = enum.auto()
+
+
+@dataclasses.dataclass(frozen=True, slots=True, repr=False)
+class State(ABCRule, typing.Generic[Payload]):
+    storage: "ABCStateStorage[Payload]"
+    key: str | StateMeta | enum.Enum
+
+    async def check(self, source: Source, ctx: Context) -> bool:
+        state = await self.storage.get(source.from_user.id)
+        if not state:
+            return self.key == StateMeta.NO_STATE
+
+        if self.key != StateMeta.ANY and self.key != state.unwrap().key:
+            return False
+
+        ctx["state"] = state.unwrap()
+        return True
+
+
+__all__ = ("State", "StateMeta")

telegrinder/bot/scenario/checkbox.py

@@ -2,16 +2,16 @@ import dataclasses
 import secrets
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
 from telegrinder.bot.scenario.abc import ABCScenario
-from telegrinder.tools import InlineButton, InlineKeyboard
+from telegrinder.tools.keyboard import InlineButton, InlineKeyboard
 from telegrinder.tools.parse_mode import ParseMode
 from telegrinder.types.objects import InlineKeyboardMarkup
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import BaseStateView
+    from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 @dataclasses.dataclass(slots=True)

telegrinder/bot/scenario/choice.py

@@ -1,11 +1,11 @@
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.scenario.checkbox import Checkbox
 
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.abc import BaseStateView
+    from telegrinder.bot.dispatch.view.base import BaseStateView
 
 
 class Choice(Checkbox):

telegrinder/client/aiohttp.py

@@ -5,8 +5,8 @@ import aiohttp
 import certifi
 from aiohttp import ClientSession, TCPConnector
 
+import telegrinder.msgspec_json as json
 from telegrinder.client.abc import ABCClient
-from telegrinder.modules import JSONModule, json
 
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
@@ -16,12 +16,10 @@ class AiohttpClient(ABCClient):
     def __init__(
         self,
         session: ClientSession | None = None,
-        json_processing_module: JSONModule | None = None,
         timeout: aiohttp.ClientTimeout | None = None,
         **session_params: typing.Any,
     ) -> None:
         self.session = session
-        self.json_processing_module = json_processing_module or json
         self.session_params = session_params
         self.timeout = timeout or aiohttp.ClientTimeout(total=0)
 
@@ -43,7 +41,7 @@ class AiohttpClient(ABCClient):
         if not self.session:
             self.session = ClientSession(
                 connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
-                json_serialize=self.json_processing_module.dumps,
+                json_serialize=json.dumps,
                 **self.session_params,
             )
         async with self.session.request(
@@ -65,8 +63,8 @@ class AiohttpClient(ABCClient):
     ) -> dict[str, typing.Any]:
         response = await self.request_raw(url, method, data, **kwargs)
         return await response.json(
-            encoding="utf-8",
-            loads=self.json_processing_module.loads,
+            encoding="UTF-8",
+            loads=json.loads,
             content_type=None,
         )
 
@@ -78,7 +76,7 @@ class AiohttpClient(ABCClient):
         **kwargs: typing.Any,
     ) -> str:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
-        return await response.text(encoding="utf-8")
+        return await response.text(encoding="UTF-8")
 
     async def request_bytes(
         self,