telegrinder 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

telegrinder/tools/keyboard.py

@@ -1,132 +1,132 @@
-import dataclasses
-import typing
-from abc import ABC, abstractmethod
-from types import NoneType
-
-from fntypes.option import Nothing, Some
-
-from telegrinder.types.objects import (
-    InlineKeyboardMarkup,
-    ReplyKeyboardMarkup,
-    ReplyKeyboardRemove,
-)
-
-from .buttons import Button, InlineButton, KeyboardButton, RowButtons
-
-DictStrAny: typing.TypeAlias = dict[str, typing.Any]
-AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
-
-
-def copy_keyboard(keyboard: list[list[DictStrAny]]) -> list[list[DictStrAny]]:
-    return [row.copy() for row in keyboard]
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class KeyboardModel:
-    resize_keyboard: bool
-    one_time_keyboard: bool
-    selective: bool
-    is_persistent: bool
-    keyboard: list[list[DictStrAny]]
-
-
-class ABCMarkup(ABC, typing.Generic[KeyboardButton]):
-    BUTTON: type[KeyboardButton]
-    keyboard: list[list[DictStrAny]]
-
-    @abstractmethod
-    def dict(self) -> DictStrAny:
-        pass
-
-    @abstractmethod
-    def get_markup(self) -> AnyMarkup:
-        pass
-
-    @classmethod
-    def get_empty_markup(cls) -> AnyMarkup:
-        return cls().get_markup()
-
-    def add(self, row_or_button: RowButtons[KeyboardButton] | KeyboardButton) -> typing.Self:
-        if not len(self.keyboard):
-            self.row()
-
-        if isinstance(row_or_button, RowButtons):
-            self.keyboard[-1].extend(row_or_button.get_data())
-            if row_or_button.auto_row:
-                self.row()
-            return self
-
-        self.keyboard[-1].append(row_or_button.get_data())
-        return self
-
-    def row(self) -> typing.Self:
-        if len(self.keyboard) and not len(self.keyboard[-1]):
-            raise RuntimeError("Last row is empty!")
-
-        self.keyboard.append([])
-        return self
-
-    def format(self, **format_data: str) -> typing.Self:
-        copy_keyboard = self.__class__()
-        for row in self.keyboard:
-            for button in row:
-                copy_button = button.copy()
-                copy_button["text"] = copy_button["text"].format(**format_data)
-                copy_keyboard.add(self.BUTTON(**copy_button))
-            copy_keyboard.row()
-        return copy_keyboard
-
-    def merge(self, other: typing.Self) -> typing.Self:
-        self.keyboard.extend(copy_keyboard(other.keyboard))
-        return self
-
-
-@dataclasses.dataclass(kw_only=True, slots=True)
-class Keyboard(ABCMarkup[Button], KeyboardModel):
-    BUTTON = Button
-
-    keyboard: list[list[DictStrAny]] = dataclasses.field(
-        default_factory=lambda: [[]],
-        init=False,
-    )
-    resize_keyboard: bool = dataclasses.field(default=True)
-    one_time_keyboard: bool = dataclasses.field(default=False)
-    selective: bool = dataclasses.field(default=False)
-    is_persistent: bool = dataclasses.field(default=False)
-
-    def dict(self) -> DictStrAny:
-        self.keyboard = [row for row in self.keyboard if row]
-        return {
-            k: v.unwrap() if v and isinstance(v, Some) else v
-            for k, v in dataclasses.asdict(self).items()
-            if type(v) not in (NoneType, Nothing)
-        }
-
-    def get_markup(self) -> ReplyKeyboardMarkup:
-        return ReplyKeyboardMarkup(**self.dict())
-
-    def keyboard_remove(self, *, selective: bool = False) -> ReplyKeyboardRemove:
-        return ReplyKeyboardRemove(remove_keyboard=True, selective=Some(selective))
-
-
-class InlineKeyboard(ABCMarkup[InlineButton]):
-    BUTTON = InlineButton
-
-    def __init__(self) -> None:
-        self.keyboard = [[]]
-
-    def dict(self) -> DictStrAny:
-        self.keyboard = [row for row in self.keyboard if row]
-        return dict(inline_keyboard=self.keyboard)
-
-    def get_markup(self) -> InlineKeyboardMarkup:
-        return InlineKeyboardMarkup(**self.dict())
-
-
-__all__ = (
-    "ABCMarkup",
-    "InlineKeyboard",
-    "Keyboard",
-    "KeyboardModel",
-    "copy_keyboard",
-)
+import dataclasses
+import typing
+from abc import ABC, abstractmethod
+from types import NoneType
+
+from fntypes.option import Nothing, Some
+
+from telegrinder.types.objects import (
+    InlineKeyboardMarkup,
+    ReplyKeyboardMarkup,
+    ReplyKeyboardRemove,
+)
+
+from .buttons import Button, InlineButton, KeyboardButton, RowButtons
+
+DictStrAny: typing.TypeAlias = dict[str, typing.Any]
+AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
+
+
+def copy_keyboard(keyboard: list[list[DictStrAny]]) -> list[list[DictStrAny]]:
+    return [row.copy() for row in keyboard]
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class KeyboardModel:
+    resize_keyboard: bool
+    one_time_keyboard: bool
+    selective: bool
+    is_persistent: bool
+    keyboard: list[list[DictStrAny]]
+
+
+class ABCMarkup(ABC, typing.Generic[KeyboardButton]):
+    BUTTON: type[KeyboardButton]
+    keyboard: list[list[DictStrAny]]
+
+    @abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+    @classmethod
+    def get_empty_markup(cls) -> AnyMarkup:
+        return cls().get_markup()
+
+    def add(self, row_or_button: RowButtons[KeyboardButton] | KeyboardButton) -> typing.Self:
+        if not len(self.keyboard):
+            self.row()
+
+        if isinstance(row_or_button, RowButtons):
+            self.keyboard[-1].extend(row_or_button.get_data())
+            if row_or_button.auto_row:
+                self.row()
+            return self
+
+        self.keyboard[-1].append(row_or_button.get_data())
+        return self
+
+    def row(self) -> typing.Self:
+        if len(self.keyboard) and not len(self.keyboard[-1]):
+            raise RuntimeError("Last row is empty!")
+
+        self.keyboard.append([])
+        return self
+
+    def format(self, **format_data: str) -> typing.Self:
+        copy_keyboard = self.__class__()
+        for row in self.keyboard:
+            for button in row:
+                copy_button = button.copy()
+                copy_button["text"] = copy_button["text"].format(**format_data)
+                copy_keyboard.add(self.BUTTON(**copy_button))
+            copy_keyboard.row()
+        return copy_keyboard
+
+    def merge(self, other: typing.Self) -> typing.Self:
+        self.keyboard.extend(copy_keyboard(other.keyboard))
+        return self
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class Keyboard(ABCMarkup[Button], KeyboardModel):
+    BUTTON = Button
+
+    keyboard: list[list[DictStrAny]] = dataclasses.field(
+        default_factory=lambda: [[]],
+        init=False,
+    )
+    resize_keyboard: bool = dataclasses.field(default=True)
+    one_time_keyboard: bool = dataclasses.field(default=False)
+    selective: bool = dataclasses.field(default=False)
+    is_persistent: bool = dataclasses.field(default=False)
+
+    def dict(self) -> DictStrAny:
+        self.keyboard = [row for row in self.keyboard if row]
+        return {
+            k: v.unwrap() if v and isinstance(v, Some) else v
+            for k, v in dataclasses.asdict(self).items()
+            if type(v) not in (NoneType, Nothing)
+        }
+
+    def get_markup(self) -> ReplyKeyboardMarkup:
+        return ReplyKeyboardMarkup(**self.dict())
+
+    def keyboard_remove(self, *, selective: bool = False) -> ReplyKeyboardRemove:
+        return ReplyKeyboardRemove(remove_keyboard=True, selective=selective)
+
+
+class InlineKeyboard(ABCMarkup[InlineButton]):
+    BUTTON = InlineButton
+
+    def __init__(self) -> None:
+        self.keyboard = [[]]
+
+    def dict(self) -> DictStrAny:
+        self.keyboard = [row for row in self.keyboard if row]
+        return dict(inline_keyboard=self.keyboard)
+
+    def get_markup(self) -> InlineKeyboardMarkup:
+        return InlineKeyboardMarkup(**self.dict())
+
+
+__all__ = (
+    "ABCMarkup",
+    "InlineKeyboard",
+    "Keyboard",
+    "KeyboardModel",
+    "copy_keyboard",
+)

telegrinder/tools/limited_dict.py

@@ -1,37 +1,37 @@
-import typing
-from collections import UserDict, deque
-
-KT = typing.TypeVar("KT")
-VT = typing.TypeVar("VT")
-
-
-class LimitedDict(UserDict[KT, VT]):
-    def __init__(self, *, maxlimit: int = 1000) -> None:
-        super().__init__()
-        self.maxlimit = maxlimit
-        self.queue: deque[KT] = deque(maxlen=maxlimit)
-
-    def set(self, key: KT, value: VT, /) -> VT | None:
-        """Set item in the dictionary.
-        Returns a value that was deleted when the limit in the dictionary
-        was reached, otherwise None.
-        """
-
-        deleted_item = None
-        if len(self.queue) >= self.maxlimit:
-            deleted_item = self.pop(self.queue.popleft(), None)
-        if key not in self.queue:
-            self.queue.append(key)
-        super().__setitem__(key, value)
-        return deleted_item
-
-    def __setitem__(self, key: KT, value: VT, /) -> None:
-        self.set(key, value)
-
-    def __delitem__(self, key: KT) -> None:
-        if key in self.queue:
-            self.queue.remove(key)
-        return super().__delitem__(key)
-
-
-__all__ = ("LimitedDict",)
+import typing
+from collections import UserDict, deque
+
+KT = typing.TypeVar("KT")
+VT = typing.TypeVar("VT")
+
+
+class LimitedDict(UserDict[KT, VT]):
+    def __init__(self, *, maxlimit: int = 1000) -> None:
+        super().__init__()
+        self.maxlimit = maxlimit
+        self.queue: deque[KT] = deque(maxlen=maxlimit)
+
+    def set(self, key: KT, value: VT, /) -> VT | None:
+        """Set item in the dictionary.
+        Returns a value that was deleted when the limit in the dictionary
+        was reached, otherwise None.
+        """
+
+        deleted_item = None
+        if len(self.queue) >= self.maxlimit:
+            deleted_item = self.pop(self.queue.popleft(), None)
+        if key not in self.queue:
+            self.queue.append(key)
+        super().__setitem__(key, value)
+        return deleted_item
+
+    def __setitem__(self, key: KT, value: VT, /) -> None:
+        self.set(key, value)
+
+    def __delitem__(self, key: KT) -> None:
+        if key in self.queue:
+            self.queue.remove(key)
+        return super().__delitem__(key)
+
+
+__all__ = ("LimitedDict",)

telegrinder/tools/loop_wrapper/__init__.py

@@ -1,4 +1,4 @@
-from .abc import ABCLoopWrapper
-from .loop_wrapper import DelayedTask, Lifespan, LoopWrapper
-
-__all__ = ("ABCLoopWrapper", "DelayedTask", "Lifespan", "LoopWrapper")
+from .abc import ABCLoopWrapper
+from .loop_wrapper import DelayedTask, Lifespan, LoopWrapper
+
+__all__ = ("ABCLoopWrapper", "DelayedTask", "Lifespan", "LoopWrapper")

telegrinder/tools/loop_wrapper/abc.py

@@ -1,15 +1,15 @@
-import typing
-from abc import ABC, abstractmethod
-
-
-class ABCLoopWrapper(ABC):
-    @abstractmethod
-    def add_task(self, task: typing.Any) -> None:
-        pass
-
-    @abstractmethod
-    def run_event_loop(self) -> None:
-        pass
-
-
-__all__ = ("ABCLoopWrapper",)
+import typing
+from abc import ABC, abstractmethod
+
+
+class ABCLoopWrapper(ABC):
+    @abstractmethod
+    def add_task(self, task: typing.Any) -> None:
+        pass
+
+    @abstractmethod
+    def run_event_loop(self) -> None:
+        pass
+
+
+__all__ = ("ABCLoopWrapper",)