telegrinder 0.1.dev158__py3-none-any.whl → 0.1.dev160__py3-none-any.whl

telegrinder/bot/dispatch/view/abc.py

@@ -16,6 +16,12 @@ from telegrinder.msgspec_utils import Option
 from telegrinder.types.objects import Update
 
 EventType = typing.TypeVar("EventType", bound=BaseCute)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
+
+FuncType: typing.TypeAlias = typing.Callable[
+    typing.Concatenate[EventType, ...],
+    typing.Coroutine[typing.Any, typing.Any, typing.Any],
+]
 
 
 class ABCView(ABC):
@@ -40,7 +46,7 @@ class ABCStateView(ABCView, typing.Generic[EventType]):
     def __repr__(self) -> str:
         return "<{!r}: {}>".format(
             self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
+            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items()),
         )
 
 
@@ -55,21 +61,19 @@ class BaseView(ABCView, typing.Generic[EventType]):
         for base in cls.__dict__.get("__orig_bases__", ()):
             if issubclass(typing.get_origin(base) or base, ABCView):
                 for generic_type in typing.get_args(base):
-                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
+                    if issubclass(
+                        typing.get_origin(generic_type) or generic_type, BaseCute
+                    ):
                         return Some(generic_type)
         return Nothing()
-    
+
     @classmethod
-    def get_event_raw(cls, update: Update) -> Option[Model]:
-        match cls.get_event_type():
-            case Some(event_type):
-                for field in update.__struct_fields__:
-                    event_raw = getattr(update, field)
-                    if isinstance(event_raw, Some | Nothing):
-                        event_raw = event_raw.unwrap_or_none()
-                    if event_raw is not None and issubclass(event_type, event_raw.__class__):
-                        return Some(event_raw)
-        return Nothing()
+    def get_raw_event(cls, update: Update) -> Option[Model]:
+        match update.update_type:
+            case Some(update_type):
+                return getattr(update, update_type.value)
+            case _:
+                return Nothing()
 
     def __call__(
         self,
@@ -77,13 +81,8 @@ class BaseView(ABCView, typing.Generic[EventType]):
         is_blocking: bool = True,
         error_handler: ErrorHandlerT | None = None,
     ):
-        def wrapper(
-            func: typing.Callable[
-                typing.Concatenate[EventType, ...],
-                typing.Coroutine,
-            ]
-        ):
-            func_handler = FuncHandler(
+        def wrapper(func: FuncType[EventType]):
+            func_handler = FuncHandler[EventType, FuncType[EventType], ErrorHandlerT](
                 func,
                 [*self.auto_rules, *rules],
                 is_blocking,
@@ -94,22 +93,34 @@ class BaseView(ABCView, typing.Generic[EventType]):
             return func_handler
 
         return wrapper
-    
+
     def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[ABCMiddleware[EventType]]):
+        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
             self.middlewares.append(cls(*args, **kwargs))
             return cls
-        
+
         return wrapper
-    
+
     async def check(self, event: Update) -> bool:
-        return bool(self.get_event_raw(event))
-        
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.get_event_type().expect(
+                    "{!r} has no event type in generic.".format(self.__class__.__name__),
+                ),
+                e.__class__,
+            ):
+                return True
+            case _:
+                return False
+
     async def process(self, event: Update, api: ABCAPI) -> bool:
-        event_raw = self.get_event_raw(event).unwrap()
-        event_type = self.get_event_type().unwrap()
         return await process_inner(
-            event_type(**event_raw.to_dict(), api=api),
+            self.get_event_type()
+            .unwrap()
+            .from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
             event,
             self.middlewares,
             self.handlers,

telegrinder/bot/polling/polling.py

@@ -71,16 +71,14 @@ class Polling(ABCPolling):
     async def listen(self) -> typing.AsyncGenerator[list[Update], None]:
         logger.debug("Listening polling")
         reconn_counter = 0
-        
+
         while not self._stop:
             try:
                 updates = await self.get_updates()
                 reconn_counter = 0
                 if not updates:
                     continue
-                updates_list: list[Update] = decoder.decode(
-                    updates, type=list[Update]
-                )
+                updates_list: list[Update] = decoder.decode(updates, type=list[Update])
                 if updates_list:
                     yield updates_list
                     self.offset = updates_list[-1].update_id + 1
@@ -100,16 +98,14 @@ class Polling(ABCPolling):
                     self.stop()
                     exit(9)
                 else:
-                    logger.warning("Server disconnected, waiting 5 seconds to reconnetion...")
+                    logger.warning(
+                        "Server disconnected, waiting 5 seconds to reconnetion...",
+                    )
                     reconn_counter += 1
                     await asyncio.sleep(self.reconnection_timeout)
             except aiohttp.ClientConnectorError:
-                logger.error(
-                    "Client connection failed, polling stopping! "
-                    "Please, check your internet connection."
-                )
-                self.stop()
-                exit(3)
+                logger.error("Client connection failed, attempted to reconnect...")
+                await asyncio.sleep(self.reconnection_timeout)
             except BaseException as e:
                 logger.exception(e)
 

telegrinder/bot/rules/abc.py

@@ -19,7 +19,7 @@ Update: typing.TypeAlias = UpdateCute
 def with_caching_translations(func):
     """Should be used as decorator for .translate method. Caches rule translations."""
 
-    async def wrapper(self: "ABCRule", translator: ABCTranslator):
+    async def wrapper(self: "ABCRule[typing.Any]", translator: ABCTranslator):
         if translation := get_cached_translation(self, translator.locale):
             return translation
         translation = await func(self, translator)

telegrinder/bot/rules/adapter/event.py

@@ -14,14 +14,20 @@ CuteT = typing.TypeVar("CuteT", bound=BaseCute)
 
 
 class EventAdapter(ABCAdapter[Update, CuteT]):
-    def __init__(self, event_name: str, model: type[CuteT]):
+    def __init__(self, event_name: str, model: type[CuteT]) -> None:
         self.event_name = event_name
         self.model = model
     
     def __repr__(self) -> str:
-        return "<{}: adapt Update.{} -> {}>".format(
+        raw_update_type = Update.__annotations__.get(self.event_name, "Unknown")
+        raw_update_type = (
+            typing.get_args(raw_update_type)[0].__forward_arg__
+            if typing.get_args(raw_update_type)
+            else raw_update_type
+        )
+        return "<{}: adapt {} -> {}>".format(
             self.__class__.__name__,
-            self.event_name,
+            raw_update_type,
             self.model.__name__,
         )
 
@@ -29,14 +35,14 @@ class EventAdapter(ABCAdapter[Update, CuteT]):
         update_dct = update.to_dict()
         if self.event_name not in update_dct:
             return Error(
-                AdapterError(f"Update is not of event type {self.event_name!r}.")
+                AdapterError(f"Update is not of event type {self.event_name!r}."),
             )
         if update_dct[self.event_name] is Nothing:
             return Error(
-                AdapterError(f"Update is not an {self.event_name!r}.")
+                AdapterError(f"Update is not an {self.event_name!r}."),
             )
         return Ok(
-            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api)
+            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api),
         )
 
 

telegrinder/bot/rules/callback_data.py

@@ -14,18 +14,10 @@ from telegrinder.tools.buttons import DataclassInstance
 from .abc import ABCRule
 from .markup import Markup, PatternLike, check_string
 
-if typing.TYPE_CHECKING:
+T = typing.TypeVar("T")
 
-    T = typing.TypeVar("T")
-    Ref: typing.TypeAlias = typing.Annotated[T, ...]
-else:
-
-    class Ref:
-        def __class_getitem__(cls, code: str) -> typing.ForwardRef:
-            return typing.ForwardRef(code)
-
-
-CallbackQuery = CallbackQueryCute
+Ref: typing.TypeAlias = typing.Annotated[T, ...]
+CallbackQuery: typing.TypeAlias = CallbackQueryCute
 Validator: typing.TypeAlias = typing.Callable[[typing.Any], bool | typing.Awaitable[bool]]
 MapDict: typing.TypeAlias = dict[
     str, typing.Any | type[typing.Any] | Validator | list[Ref["MapDict"]] | Ref["MapDict"]

telegrinder/bot/rules/inline.py

@@ -1,4 +1,5 @@
 import abc
+import typing
 
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
@@ -8,7 +9,7 @@ from telegrinder.types.enums import ChatType
 
 from .markup import Markup, PatternLike, check_string
 
-InlineQuery = InlineQueryCute
+InlineQuery: typing.TypeAlias = InlineQueryCute
 
 
 class InlineQueryRule(ABCRule[InlineQuery], abc.ABC):

telegrinder/bot/rules/markup.py

@@ -1,3 +1,5 @@
+import typing
+
 import vbml
 
 from telegrinder.bot.dispatch.context import Context
@@ -6,7 +8,7 @@ from telegrinder.tools.global_context import TelegrinderCtx
 from .abc import Message
 from .text import TextMessageRule
 
-PatternLike = str | vbml.Pattern
+PatternLike: typing.TypeAlias = str | vbml.Pattern
 global_ctx = TelegrinderCtx()
 
 

telegrinder/bot/rules/message_entities.py

@@ -1,10 +1,12 @@
+import typing
+
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import MessageEntityType
 from telegrinder.types.objects import MessageEntity
 
 from .abc import Message, MessageRule
 
-Entity = str | MessageEntityType
+Entity: typing.TypeAlias = str | MessageEntityType
 
 
 class HasEntities(MessageRule):

telegrinder/bot/rules/regex.py

@@ -6,7 +6,7 @@ from telegrinder.bot.dispatch.context import Context
 from .abc import Message
 from .text import TextMessageRule
 
-PatternLike = str | typing.Pattern[str]
+PatternLike: typing.TypeAlias = str | typing.Pattern[str]
 
 
 class Regex(TextMessageRule):

telegrinder/client/__init__.py

@@ -1,4 +1,4 @@
-from .abc import ABCClient, ClientData
+from .abc import ABCClient
 from .aiohttp import AiohttpClient
 
-__all__ = ("ABCClient", "AiohttpClient", "ClientData")
+__all__ = ("ABCClient", "AiohttpClient")

telegrinder/client/abc.py

@@ -1,35 +1,49 @@
 import typing
 from abc import ABC, abstractmethod
 
-ClientData = typing.Any
-
 
 class ABCClient(ABC):
     @abstractmethod
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
         pass
 
     @abstractmethod
     async def request_text(
-        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> str:
         pass
 
     @abstractmethod
     async def request_json(
-        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
-    ) -> dict:
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
         pass
 
     @abstractmethod
     async def request_content(
-        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         pass
 
     @abstractmethod
     async def request_bytes(
-        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         pass
 
@@ -39,14 +53,23 @@ class ABCClient(ABC):
 
     @classmethod
     @abstractmethod
-    def get_form(cls, data: dict) -> typing.Any:
+    def get_form(
+        cls,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> typing.Any:
         pass
 
-    async def __aenter__(self) -> "ABCClient":
+    async def __aenter__(self) -> typing.Self:
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException],
+        exc_val: typing.Any,
+        exc_tb: typing.Any,
+    ) -> None:
         await self.close()
 
 
-__all__ = ("ABCClient", "ClientData")
+__all__ = ("ABCClient",)

telegrinder/client/aiohttp.py

@@ -1,3 +1,4 @@
+import secrets
 import ssl
 import typing
 
@@ -18,19 +19,27 @@ class AiohttpClient(ABCClient):
         session: ClientSession | None = None,
         json_processing_module: JSONModule | None = None,
         timeout: aiohttp.ClientTimeout | None = None,
-        **session_params,
-    ):
+        **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)
-
+    
+    def __repr__(self) -> str:
+        return "<{}: session={!r}, timeout={}, closed={}>".format(
+            self.__class__.__name__,
+            self.session,
+            self.timeout,
+            False if self.session is None else self.session.closed,
+        )
+    
     async def request_raw(
         self,
         url: str,
         method: str = "GET",
-        data: dict | None = None,
-        **kwargs,
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
@@ -54,9 +63,9 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | None = None,
-        **kwargs,
-    ) -> dict:
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
         response = await self.request_raw(url, method, data, **kwargs)
         return await response.json(
             encoding="utf-8",
@@ -68,8 +77,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | aiohttp.FormData | None = None,
-        **kwargs,
+        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        **kwargs: typing.Any,
     ) -> str:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         return await response.text(encoding="utf-8")
@@ -78,8 +87,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | aiohttp.FormData | None = None,
-        **kwargs,
+        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         if response._body is None:
@@ -90,8 +99,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | None = None,
-        **kwargs,
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)
         return response._body
@@ -101,18 +110,22 @@ class AiohttpClient(ABCClient):
             await self.session.close()
 
     @classmethod
-    def get_form(cls, data: dict) -> aiohttp.formdata.FormData:
+    def get_form(
+        cls,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> aiohttp.formdata.FormData:
+        files = files or {}
         form = aiohttp.formdata.FormData(quote_fields=False)
         for k, v in data.items():
-            params = {}
-            if isinstance(v, tuple):
-                params["filename"], v = v[0], v[1]
-            else:
-                v = str(v)
-            form.add_field(k, v, **params)
+            form.add_field(k, str(v))
+        
+        for n, f in files.items():
+            form.add_field(n, f[1], filename=f[0])
+        
         return form
 
-    def __del__(self):
+    def __del__(self) -> None:
         if self.session and not self.session.closed:
             if self.session._connector is not None and self.session._connector_owner:
                 self.session._connector.close()