telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -1,27 +1,27 @@
-import re
-import typing
-
-import vbml
-
-from telegrinder.tools.global_context import GlobalContext, ctx_var
-
-
-class TelegrinderContext(GlobalContext):
-    """Basic type-hinted telegrinder context with context name `"telegrinder"`.
-
-    You can use this class or GlobalContext:
-    ```
-    from telegrinder.tools.global_context import GlobalContext, TelegrinderContext
-
-    ctx1 = TelegrinderContext()
-    ctx2 = GlobalContext("telegrinder")  # same, but without the type-hints
-    assert ctx1 == ctx2  # ok
-    ```"""
-
-    __ctx_name__ = "telegrinder"
-
-    vbml_pattern_flags: re.RegexFlag | None = None
-    vbml_patcher: typing.ClassVar[vbml.Patcher] = ctx_var(vbml.Patcher(), const=True)
-
-
-__all__ = ("TelegrinderContext",)
+import re
+
+import vbml
+
+from telegrinder.tools.global_context import GlobalContext, ctx_var
+
+
+class TelegrinderContext(GlobalContext):
+    """Basic type-hinted telegrinder context with context name `"telegrinder"`.
+
+    You can use this class or GlobalContext:
+    ```
+    from telegrinder.tools.global_context import GlobalContext, TelegrinderContext
+
+    ctx1 = TelegrinderContext()
+    ctx2 = GlobalContext("telegrinder")  # same, but without the type-hints
+    assert ctx1 == ctx2  # ok
+    ```
+    """
+
+    __ctx_name__ = "telegrinder"
+
+    vbml_pattern_flags: re.RegexFlag | None = None
+    vbml_patcher: vbml.Patcher = ctx_var(default=vbml.Patcher(), frozen=True)
+
+
+__all__ = ("TelegrinderContext",)

telegrinder/tools/i18n/__init__.py

@@ -1,12 +1,12 @@
-from .abc import ABCI18n, ABCTranslator, I18nEnum
-from .middleware import ABCTranslatorMiddleware
-from .simple import SimpleI18n, SimpleTranslator
-
-__all__ = (
+from .abc import ABCI18n, ABCTranslator, I18nEnum
+from .middleware import ABCTranslatorMiddleware
+from .simple import SimpleI18n, SimpleTranslator
+
+__all__ = (
     "ABCI18n",
     "ABCTranslator",
     "ABCTranslatorMiddleware",
     "I18nEnum",
     "SimpleI18n",
-    "SimpleTranslator",
-)
+    "SimpleTranslator",
+)

telegrinder/tools/i18n/abc.py

@@ -1,32 +1,32 @@
-import enum
-import typing
-from abc import ABC, abstractmethod
-
-
-class ABCI18n(ABC):
-    @abstractmethod
-    def get_translator_by_locale(self, locale: str) -> "ABCTranslator":
-        pass
-
-
-class ABCTranslator(ABC):
-    def __init__(self, locale: str, **kwargs: typing.Any) -> None:
-        self.locale = locale
-
-    @abstractmethod
-    def get(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
-        """This translates a key to actual human-readable string"""
-
-    def __call__(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
-        return self.get(__key, *args, **kwargs)
-
-
-class I18nEnum(enum.Enum):
-    I18N = "_"
-
-
-__all__ = (
+import enum
+import typing
+from abc import ABC, abstractmethod
+
+
+class ABCI18n(ABC):
+    @abstractmethod
+    def get_translator_by_locale(self, locale: str) -> "ABCTranslator":
+        pass
+
+
+class ABCTranslator(ABC):
+    def __init__(self, locale: str, **kwargs: typing.Any) -> None:
+        self.locale = locale
+
+    @abstractmethod
+    def get(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
+        """This translates a key to actual human-readable string"""
+
+    def __call__(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
+        return self.get(__key, *args, **kwargs)
+
+
+class I18nEnum(enum.Enum):
+    I18N = "_"
+
+
+__all__ = (
     "ABCI18n",
     "ABCTranslator",
-    "I18nEnum",
-)
+    "I18nEnum",
+)

telegrinder/tools/i18n/middleware/__init__.py

@@ -1,3 +1,3 @@
-from .abc import ABCTranslatorMiddleware
-
-__all__ = ("ABCTranslatorMiddleware",)
+from .abc import ABCTranslatorMiddleware
+
+__all__ = ("ABCTranslatorMiddleware",)

telegrinder/tools/i18n/middleware/abc.py

@@ -1,25 +1,22 @@
-import typing
-from abc import abstractmethod
-
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.tools.i18n import ABCI18n, I18nEnum
-
-T = typing.TypeVar("T", bound=BaseCute)
-
-
-class ABCTranslatorMiddleware(ABCMiddleware[T]):
-    def __init__(self, i18n: ABCI18n) -> None:
-        self.i18n = i18n
-
-    @abstractmethod
-    async def get_locale(self, event: T) -> str:
-        pass
-
-    async def pre(self, event: T, ctx: Context) -> bool:
-        ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(await self.get_locale(event))
-        return True
-
-
-__all__ = ("ABCTranslatorMiddleware",)
+from abc import abstractmethod
+
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware import ABCMiddleware
+from telegrinder.tools.i18n import ABCI18n, I18nEnum
+
+
+class ABCTranslatorMiddleware[Event: BaseCute](ABCMiddleware[Event]):
+    def __init__(self, i18n: ABCI18n) -> None:
+        self.i18n = i18n
+
+    @abstractmethod
+    async def get_locale(self, event: Event) -> str:
+        pass
+
+    async def pre(self, event: Event, ctx: Context) -> bool:
+        ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(await self.get_locale(event))
+        return True
+
+
+__all__ = ("ABCTranslatorMiddleware",)

telegrinder/tools/i18n/simple.py

@@ -1,43 +1,43 @@
-"""This is an implementation of GNU gettext (pyBabel)."""
-
-import gettext
-import os
-
-from telegrinder.tools.i18n.abc import ABCI18n, ABCTranslator
-
-
-class SimpleTranslator(ABCTranslator):
-    def __init__(self, locale: str, g: gettext.GNUTranslations) -> None:
-        self.g = g
-        super().__init__(locale)
-
-    def get(self, __key: str, *args: object, **kwargs: object) -> str:
-        return self.g.gettext(__key).format(*args, **kwargs)
-
-
-class SimpleI18n(ABCI18n):
-    def __init__(self, folder: str, domain: str, default_locale: str) -> None:
-        self.folder = folder
-        self.domain = domain
-        self.default_locale = default_locale
-        self.translators = self._load_translators()
-
-    def _load_translators(self) -> dict[str, gettext.GNUTranslations]:
-        result = {}
-        for name in os.listdir(self.folder):
-            if not os.path.isdir(os.path.join(self.folder, name)):
-                continue
-
-            mo_path = os.path.join(self.folder, name, "LC_MESSAGES", f"{self.domain}.mo")
-            if os.path.exists(mo_path):
-                with open(mo_path, "rb") as f:
-                    result[name] = gettext.GNUTranslations(f)
-            elif os.path.exists(mo_path[:-2] + "po"):
-                raise FileNotFoundError(".po files should be compiled first")
-        return result
-
-    def get_translator_by_locale(self, locale: str) -> "SimpleTranslator":
-        return SimpleTranslator(locale, self.translators.get(locale, self.translators[self.default_locale]))
-
-
-__all__ = ("SimpleI18n", "SimpleTranslator")
+"""This is an implementation of GNU gettext (pyBabel)."""
+
+import gettext
+import os
+
+from telegrinder.tools.i18n.abc import ABCI18n, ABCTranslator
+
+
+class SimpleTranslator(ABCTranslator):
+    def __init__(self, locale: str, g: gettext.GNUTranslations) -> None:
+        self.g = g
+        super().__init__(locale)
+
+    def get(self, __key: str, *args: object, **kwargs: object) -> str:
+        return self.g.gettext(__key).format(*args, **kwargs)
+
+
+class SimpleI18n(ABCI18n):
+    def __init__(self, folder: str, domain: str, default_locale: str) -> None:
+        self.folder = folder
+        self.domain = domain
+        self.default_locale = default_locale
+        self.translators = self._load_translators()
+
+    def _load_translators(self) -> dict[str, gettext.GNUTranslations]:
+        result = {}
+        for name in os.listdir(self.folder):
+            if not os.path.isdir(os.path.join(self.folder, name)):
+                continue
+
+            mo_path = os.path.join(self.folder, name, "LC_MESSAGES", f"{self.domain}.mo")
+            if os.path.exists(mo_path):
+                with open(mo_path, "rb") as f:
+                    result[name] = gettext.GNUTranslations(f)
+            elif os.path.exists(mo_path[:-2] + "po"):
+                raise FileNotFoundError(".po files should be compiled first")
+        return result
+
+    def get_translator_by_locale(self, locale: str) -> "SimpleTranslator":
+        return SimpleTranslator(locale, self.translators.get(locale, self.translators[self.default_locale]))
+
+
+__all__ = ("SimpleI18n", "SimpleTranslator")

telegrinder/tools/input_file_directory.py

@@ -0,0 +1,30 @@
+import dataclasses
+import pathlib
+
+from telegrinder.types.objects import InputFile
+
+
+@dataclasses.dataclass
+class InputFileDirectory:
+    directory: pathlib.Path
+    storage: dict[str, InputFile] = dataclasses.field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self.storage = self._load_files()
+
+    def _load_files(self) -> dict[str, InputFile]:
+        files = {}
+
+        for path in self.directory.rglob("*"):
+            if path.is_file():
+                relative_path = path.relative_to(self.directory)
+                files[str(relative_path)] = InputFile(path.name, path.read_bytes())
+
+        return files
+
+    def get(self, filename: str, /) -> InputFile:
+        assert filename in self.storage, f"File {filename!r} not found."
+        return self.storage[filename]
+
+
+__all__ = ("InputFileDirectory",)

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=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__ = (
+import dataclasses
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.option import Some
+
+from telegrinder.model import is_none
+from telegrinder.types.objects import (
+    InlineKeyboardMarkup,
+    ReplyKeyboardMarkup,
+    ReplyKeyboardRemove,
+)
+
+from .buttons import BaseButton, Button, InlineButton, RowButtons
+
+type DictStrAny = dict[str, typing.Any]
+type AnyMarkup = 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[KeyboardButton: BaseButton](ABC):
+    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 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]):
+            return self
+
+        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 not is_none(v)
+        }
+
+    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",
-)
+    "copy_keyboard",
+)