telegrinder 0.1.dev166__py3-none-any.whl → 0.1.dev168__py3-none-any.whl

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -1,79 +1,23 @@
 import asyncio
 import datetime
 import typing
-from collections import deque
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.tools.limited_dict import LimitedDict
+from telegrinder.types import Update
 
 from .middleware import WaiterMiddleware
 from .short_state import Behaviour, EventModel, ShortState
 
-T = typing.TypeVar("T")
-
-Storage: typing.TypeAlias = dict[str, "ShortStateStorage"]
-Identificator: typing.TypeAlias = str | int
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.view.abc import ABCStateView, BaseStateView
 
+T = typing.TypeVar("T")
 
-class ShortStateStorage(dict[Identificator, ShortState[EventModel]]):
-    def __init__(self, *, maxlimit: int = 1000) -> None:
-        super().__init__()
-        self.maxlimit = maxlimit
-        self.queue: deque[Identificator] = deque(maxlen=maxlimit)
-    
-    def __repr__(self) -> str:
-        return "<{}: {}, (current={} | maxlimit={})>".format(
-            self.__class__.__name__,
-            super().__repr__(),
-            len(self.queue),
-            self.maxlimit,
-        )
-    
-    def __setitem__(self, key: Identificator, value: ShortState[EventModel], /) -> None:
-        self.add(key, value)
-    
-    def __delitem__(self, key: Identificator, /) -> None:
-        self.pop(key, None)
-
-    def add(self, id: Identificator, short_state: ShortState[EventModel]) -> None:
-        if len(self.queue) >= self.maxlimit:
-            self.pop(self.queue.popleft(), None)
-        if id not in self.queue:
-            self.queue.append(id)
-        super().__setitem__(id, short_state)
-
-    def clear(self) -> None:
-        self.queue.clear()
-        super().clear()
-    
-    def setdefault(self, id: Identificator, default: ShortState[EventModel]) -> ShortState[EventModel]:
-        if id in self:
-            return self[id]
-        self.add(id, default)
-        return default
-    
-    def pop(self, id: Identificator, default: T):  # type: ignore
-        if id in self.queue:
-            self.queue.remove(id)
-        return super().pop(id, default)
-    
-    def popitem(self) -> tuple[Identificator, ShortState[EventModel]]:
-        item = super().popitem()
-        self.queue.remove(item[0])
-        return item
-    
-    def update(
-        self,
-        mapping: typing.Mapping[Identificator, ShortState[EventModel]] | None = None,
-        /,
-        **kwargs: ShortState[EventModel],
-    ) -> None:
-        for key, value in (mapping if mapping is not None else kwargs).items():
-            self.add(key, value)
+Identificator: typing.TypeAlias = str | int
+Storage: typing.TypeAlias = dict[str, LimitedDict[Identificator, ShortState[EventModel]]]
 
 
 class WaiterMachine:
@@ -90,32 +34,27 @@ class WaiterMachine:
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
+        update: Update,
         **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
-            raise LookupError("No record of view {!r} found".format(view_name))
+            raise LookupError("No record of view {!r} found.".format(view_name))
 
         short_state = self.storage[view_name].pop(id, None)
         if short_state is None:
             raise LookupError(
                 "Waiter with identificator {} is not found for view {!r}".format(
-                    id,
-                    view_name,
+                    id, view_name
                 )
             )
 
-        waiters = typing.cast(
-            typing.Iterable[asyncio.Future[typing.Any]],
-            short_state.event._waiters,  # type: ignore
-        )
-        for future in waiters:
-            future.cancel()
-
+        short_state.cancel()
         await self.call_behaviour(
             state_view,
-            short_state.on_drop_behaviour,
             short_state.event,
+            update,
+            behaviour=short_state.on_drop_behaviour,
             **context,
         )
 
@@ -124,19 +63,24 @@ class WaiterMachine:
         state_view: "BaseStateView[EventModel]",
         linked: EventModel | tuple[ABCAPI, Identificator],
         *rules: ABCRule[EventModel],
-        default: Behaviour = None,
-        on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | float | None = None,
-        short_state_storage: ShortStateStorage[EventModel] | None = None,
+        default: Behaviour[EventModel] | None = None,
+        on_drop: Behaviour[EventModel] | None = None,
+        expiration: datetime.timedelta | float | None = None,
     ) -> tuple[EventModel, Context]:
         if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
-        api: ABCAPI; key: Identificator
-        api, key = linked if isinstance(linked, tuple) else (linked.ctx_api, state_view.get_state_key(linked))  # type: ignore
+        api: ABCAPI
+        key: Identificator
+        api, key = (
+            linked
+            if isinstance(linked, tuple)
+            else (linked.ctx_api, state_view.get_state_key(linked))
+        )  # type: ignore
         if not key:
             raise RuntimeError("Unable to get state key.")
 
+        view_name = state_view.__class__.__name__
         event = asyncio.Event()
         short_state = ShortState(
             key,
@@ -147,30 +91,41 @@ class WaiterMachine:
             default_behaviour=default,
             on_drop_behaviour=on_drop,
         )
-        view_name = state_view.__class__.__name__
+        
         if view_name not in self.storage:
             state_view.middlewares.insert(0, WaiterMiddleware(self, state_view))
-            self.storage[view_name] = short_state_storage or ShortStateStorage()
+            self.storage[view_name] = LimitedDict()
 
-        self.storage[view_name].add(key, short_state)
+        if (deleted_short_state := self.storage[view_name].set(key, short_state)) is not None:
+            deleted_short_state.cancel()
+        
         await event.wait()
-
-        e, ctx = getattr(event, "context")
         self.storage[view_name].pop(key, None)
-        return e, ctx
+        return getattr(event, "context")
 
     async def call_behaviour(
         self,
         view: "ABCStateView[EventModel]",
-        behaviour: Behaviour,
         event: asyncio.Event | EventModel,
+        update: Update,
+        behaviour: Behaviour[EventModel] | None = None,
         **context: typing.Any,
     ) -> None:
+        # TODO: support param view as a behaviour
+
         if behaviour is None:
             return
-        # TODO: add behaviour check
-        # TODO: support view as a behaviour
-        await behaviour.run(event, context)  # type: ignore
 
+        ctx = Context(**context)
+        if isinstance(event, asyncio.Event):
+            event, preset_ctx = typing.cast(
+                tuple[EventModel, Context],
+                getattr(event, "context"),
+            )
+            ctx.update(preset_ctx)
+
+        if await behaviour.check(event.api, update, ctx):
+            await behaviour.run(event, ctx)
+        
 
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -41,19 +41,20 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         short_state: "ShortState[EventType] | None" = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
-
+        
+        preset_context = Context(short_state=short_state)
         if (
             short_state.expiration_date is not None
             and datetime.datetime.now() >= short_state.expiration_date
         ):
-            await self.machine.drop(self.view, short_state.key)
+            await self.machine.drop(self.view, short_state.key, ctx.raw_update, **preset_context.copy())
             return True
 
         handler = FuncHandler(
             self.pass_runtime,
             list(short_state.rules),
             dataclass=None,
-            preset_context=Context(short_state=short_state),
+            preset_context=preset_context,
         )
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
@@ -63,14 +64,20 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
-                short_state.default_behaviour,
                 event,
+                ctx.raw_update,
+                behaviour=short_state.default_behaviour,
                 **handler.preset_context,
             )
 
         return False
 
-    async def pass_runtime(self, event: EventType, short_state: "ShortState[EventType]", ctx: Context) -> None:
+    async def pass_runtime(
+        self,
+        event: EventType,
+        short_state: "ShortState[EventType]",
+        ctx: Context,
+    ) -> None:
         setattr(short_state.event, "context", (event, ctx))
         short_state.event.set()
 

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -7,13 +7,15 @@ from telegrinder.api import ABCAPI
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
 
 if typing.TYPE_CHECKING:
     from .machine import Identificator
 
+T = typing.TypeVar("T", bound=Model)
 EventModel = typing.TypeVar("EventModel", bound=BaseCute)
 
-Behaviour: typing.TypeAlias = ABCHandler | None
+Behaviour: typing.TypeAlias = ABCHandler[T] | None
 
 
 @dataclasses.dataclass
@@ -26,14 +28,22 @@ class ShortState(typing.Generic[EventModel]):
     expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(
         default=None,
     )
-    default_behaviour: Behaviour | None = dataclasses.field(default=None)
-    on_drop_behaviour: Behaviour | None = dataclasses.field(default=None)
+    default_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour[EventModel] | None = dataclasses.field(default=None)
     expiration_date: datetime.datetime | None = dataclasses.field(init=False)
 
     def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
-        self.expiration_date = (
-            (datetime.datetime.now() - expiration) if expiration is not None else None
+        self.expiration_date = (datetime.datetime.now() - expiration) if expiration is not None else None
+    
+    def cancel(self) -> None:
+        """Cancel schedule waiters."""
+
+        waiters = typing.cast(
+            typing.Iterable[asyncio.Future[typing.Any]],
+            self.event._waiters,  # type: ignore
         )
+        for future in waiters:
+            future.cancel()
 
 
 __all__ = ("ShortState",)

telegrinder/bot/polling/polling.py

@@ -29,9 +29,7 @@ class Polling(ABCPolling):
             include_updates=include_updates,
             exclude_updates=exclude_updates,
         )
-        self.reconnection_timeout = (
-            5 if reconnection_timeout < 0 else reconnection_timeout
-        )
+        self.reconnection_timeout = 5 if reconnection_timeout < 0 else reconnection_timeout
         self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
         self._stop = False
@@ -62,9 +60,7 @@ class Polling(ABCPolling):
 
         if include_updates and exclude_updates:
             allowed_updates = [
-                x
-                for x in allowed_updates
-                if x in include_updates and x not in exclude_updates
+                x for x in allowed_updates if x in include_updates and x not in exclude_updates
             ]
         elif exclude_updates:
             allowed_updates = [x for x in allowed_updates if x not in exclude_updates]

telegrinder/bot/rules/adapter/event.py

@@ -45,9 +45,7 @@ class EventAdapter(ABCAdapter[Update, CuteT]):
                     AdapterError(f"Update is not an {self.event!r}."),
                 )
             return Ok(
-                self.cute_model.from_update(
-                    update_dct[self.event].unwrap(), bound_api=api
-                ),
+                self.cute_model.from_update(update_dct[self.event].unwrap(), bound_api=api),
             )
         event = update_dct[update.update_type.unwrap()].unwrap()
         if not update.update_type or not issubclass(event.__class__, self.event):

telegrinder/bot/rules/callback_data.py

@@ -17,7 +17,7 @@ from .markup import Markup, PatternLike, check_string
 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[MapDict] | MapDict"]
-CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type | Validator | CallbackMap"]]
+CallbackMap: typing.TypeAlias = list[tuple[str, "typing.Any | type[typing.Any] | Validator | CallbackMap"]]
 CallbackMapStrict: typing.TypeAlias = list[tuple[str, "Validator | CallbackMapStrict"]]
 
 
@@ -39,7 +39,7 @@ class CallbackQueryDataRule(CallbackQueryRule, abc.ABC, requires=[HasData()]):
 
 
 class CallbackDataMap(CallbackQueryDataRule):
-    def __init__(self, mapping: MapDict) -> None:
+    def __init__(self, mapping: MapDict, /) -> None:
         self.mapping = self.transform_to_callbacks(
             self.transform_to_map(mapping),
         )
@@ -84,12 +84,12 @@ class CallbackDataMap(CallbackQueryDataRule):
             result = validator(value)
             if inspect.isawaitable(result):
                 result = await result
-            return result  # type: ignore
+            return result
 
         return False
 
     @classmethod
-    async def match(cls, callback_data: dict, callback_map: CallbackMapStrict) -> bool:
+    async def match(cls, callback_data: dict[str, typing.Any], callback_map: CallbackMapStrict) -> bool:
         """Matches callback_data with callback_map recursively."""
 
         for key, validator in callback_map:
@@ -119,7 +119,7 @@ class CallbackDataMap(CallbackQueryDataRule):
 
 
 class CallbackDataEq(CallbackQueryDataRule):
-    def __init__(self, value: str):
+    def __init__(self, value: str, /) -> None:
         self.value = value
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -127,7 +127,7 @@ class CallbackDataEq(CallbackQueryDataRule):
 
 
 class CallbackDataJsonEq(CallbackQueryDataRule):
-    def __init__(self, d: dict[str, typing.Any]):
+    def __init__(self, d: dict[str, typing.Any], /) -> None:
         self.d = d
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -135,7 +135,7 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
 
 
 class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance]):
+    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance], /) -> None:
         self.model = model
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
@@ -146,7 +146,7 @@ class CallbackDataJsonModel(CallbackQueryDataRule):
 
 
 class CallbackDataMarkup(CallbackQueryDataRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike]):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /) -> None:
         self.patterns = Markup(patterns).patterns
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:

telegrinder/bot/rules/fuzzy.py

@@ -15,8 +15,7 @@ class FuzzyText(TextMessageRule):
 
     async def check(self, message: Message, ctx: Context) -> bool:
         match = max(
-            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio()
-            for text in self.texts
+            difflib.SequenceMatcher(a=message.text.unwrap(), b=text).ratio() for text in self.texts
         )
         if match < self.min_ratio:
             return False

telegrinder/bot/rules/is_from.py

@@ -42,7 +42,9 @@ class IsForward(MessageRule):
 
 
 class IsForwardType(MessageRule, requires=[IsForward()]):
-    def __init__(self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /) -> None:
+    def __init__(
+        self, fwd_type: typing.Literal["user", "hidden_user", "chat", "channel"], /
+    ) -> None:
         self.fwd_type = fwd_type
 
     async def check(self, message: Message, ctx: Context) -> bool:
@@ -80,8 +82,8 @@ class IsLanguageCode(ABCRule[T], requires=[HasFrom()]):
 
     async def check(self, event: UpdateCute, ctx: Context) -> bool:
         return (
-            get_from_user(event.incoming_update.unwrap())
-            .language_code.unwrap_or_none() in self.lang_codes
+            get_from_user(event.incoming_update.unwrap()).language_code.unwrap_or_none()
+            in self.lang_codes
         )
 
 
@@ -131,7 +133,7 @@ class IsDiceEmoji(MessageRule, requires=[HasDice()]):
         self.dice_emoji = dice_emoji
 
     async def check(self, message: Message, ctx: Context) -> bool:
-        return message.dice.unwrap().emoji == self.dice_emoji 
+        return message.dice.unwrap().emoji == self.dice_emoji
 
 
 __all__ = (

telegrinder/bot/rules/markup.py

@@ -28,8 +28,7 @@ class Markup(TextMessageRule):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [
-            vbml.Pattern(pattern) if isinstance(pattern, str) else pattern
-            for pattern in patterns
+            vbml.Pattern(pattern) if isinstance(pattern, str) else pattern for pattern in patterns
         ]
 
     async def check(self, message: Message, ctx: Context) -> bool:

telegrinder/bot/rules/mention.py

@@ -8,10 +8,7 @@ class HasMention(TextMessageRule):
     async def check(self, message: Message, ctx: Context) -> bool:
         if not message.entities.unwrap_or_none():
             return False
-        return any(
-            entity.type == MessageEntityType.MENTION
-            for entity in message.entities.unwrap()
-        )
+        return any(entity.type == MessageEntityType.MENTION for entity in message.entities.unwrap())
 
 
 __all__ = ("HasMention",)

telegrinder/bot/rules/regex.py

@@ -19,8 +19,7 @@ class Regex(TextMessageRule):
                 self.regexp.append(re.compile(regex))
             case _:
                 self.regexp.extend(
-                    re.compile(regexp) if isinstance(regexp, str) else regexp
-                    for regexp in regexp
+                    re.compile(regexp) if isinstance(regexp, str) else regexp for regexp in regexp
                 )
 
     async def check(self, message: Message, ctx: Context) -> bool:

telegrinder/bot/rules/rule_enum.py

@@ -21,9 +21,7 @@ class RuleEnum(ABCRule[T]):
     __enum__: list[RuleEnumState]
 
     def __init_subclass__(cls, *args, **kwargs):
-        new_attributes = (
-            set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
-        )
+        new_attributes = set(cls.__dict__) - set(RuleEnum.__dict__) - {"__enum__", "__init__"}
         enum_lst: list[RuleEnumState] = []
 
         self = cls.__new__(cls)

telegrinder/bot/rules/start.py

@@ -30,9 +30,7 @@ class StartCommand(
 
     async def check(self, _: Message, ctx: Context) -> bool:
         param: str | None = ctx.pop("param", None)
-        validated_param = (
-            self.validator(param) if self.validator and param is not None else param
-        )
+        validated_param = self.validator(param) if self.validator and param is not None else param
 
         if self.param_required and validated_param is None:
             return False

telegrinder/bot/scenario/checkbox.py

@@ -33,13 +33,13 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self,
         waiter_machine: WaiterMachine,
         chat_id: int,
-        msg: str,
+        message: str,
         *,
         ready_text: str = "Ready",
         max_in_row: int = 3,
     ) -> None:
         self.chat_id = chat_id
-        self.msg = msg
+        self.message = message
         self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
@@ -58,7 +58,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
             self.waiter_machine,
             self.ready,
             self.chat_id,
-            self.msg,
+            self.message,
         )
 
     def get_markup(self) -> InlineKeyboardMarkup:
@@ -69,11 +69,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 choice = choices.pop(0)
                 kb.add(
                     InlineButton(
-                        text=(
-                            choice.default_text
-                            if not choice.is_picked
-                            else choice.picked_text
-                        ),
+                        text=(choice.default_text if not choice.is_picked else choice.picked_text),
                         callback_data=self.random_code + "/" + choice.code,
                     )
                 )
@@ -105,7 +101,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 # Toggle choice
                 self.choices[i].is_picked = not self.choices[i].is_picked
                 await cb.edit_text(
-                    text=self.msg,
+                    text=self.message,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -122,7 +118,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         message = (
             await api.send_message(
                 chat_id=self.chat_id,
-                text=self.msg,
+                text=self.message,
                 parse_mode=self.PARSE_MODE,
                 reply_markup=self.get_markup(),
             )

telegrinder/bot/scenario/choice.py

@@ -1,6 +1,7 @@
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
 
 from .checkbox import Checkbox
 
@@ -22,9 +23,9 @@ class SingleChoice(Checkbox):
             if choice.code == code:
                 self.choices[i].is_picked = True
                 await cb.ctx_api.edit_message_text(
+                    text=self.message,
                     chat_id=cb.message.unwrap().v.chat.id,
                     message_id=cb.message.unwrap().v.message_id,
-                    text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -36,10 +37,10 @@ class SingleChoice(Checkbox):
         api: "API",
         view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[str, int]:
-        if len([choice for choice in self.choices if choice.is_picked]) != 1:
+        if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
             raise ValueError("Exactly one choice must be picked")
         choices, m_id = await super().wait(api, view)
-        return list(choices.keys())[list(choices.values()).index(True)], m_id
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
 __all__ = ("SingleChoice",)

telegrinder/client/aiohttp.py

@@ -42,9 +42,7 @@ class AiohttpClient(ABCClient):
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
-                connector=TCPConnector(
-                    ssl=ssl.create_default_context(cafile=certifi.where())
-                ),
+                connector=TCPConnector(ssl=ssl.create_default_context(cafile=certifi.where())),
                 json_serialize=self.json_processing_module.dumps,
                 **self.session_params,
             )

telegrinder/model.py

@@ -10,11 +10,11 @@ from fntypes.co import Nothing, Result, Some
 
 from .msgspec_utils import decoder, encoder, get_origin
 
-T = typing.TypeVar("T")
-
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
 
+T = typing.TypeVar("T")
+
 
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
@@ -25,7 +25,8 @@ MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
 
 @typing.overload
 def full_result(
-    result: Result[msgspec.Raw, "APIError"], full_t: type[T]
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: type[T],
 ) -> Result[T, "APIError"]: ...
 
 

telegrinder/modules.py

@@ -147,9 +147,7 @@ elif logging_module == "logging":
     for level, settings in LEVEL_SETTINGS.items():
         fmt = FORMAT
         for name, color in settings.items():
-            fmt = fmt.replace(f"<{name}>", COLORS[color]).replace(
-                f"</{name}>", COLORS["reset"]
-            )
+            fmt = fmt.replace(f"<{name}>", COLORS[color]).replace(f"</{name}>", COLORS["reset"])
         LEVEL_FORMATS[level] = fmt
 
     class TelegrinderLoggingFormatter(logging.Formatter):

telegrinder/msgspec_utils.py

@@ -66,9 +66,7 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
         union_types = tuple(t for t in union_types if t not in struct_fields_match_sums)
         reverse = False
 
-        if len(set(struct_fields_match_sums.values())) != len(
-            struct_fields_match_sums.values()
-        ):
+        if len(set(struct_fields_match_sums.values())) != len(struct_fields_match_sums.values()):
             struct_fields_match_sums = {
                 m: len(m.__struct_fields__) for m in struct_fields_match_sums
             }