telegrinder 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

telegrinder/tools/i18n/middleware/abc.py

@@ -1,22 +0,0 @@
-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 +0,0 @@
-"""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/keyboard.py

@@ -1,132 +0,0 @@
-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",
-)

telegrinder/tools/loop_wrapper/__init__.py

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

telegrinder/tools/loop_wrapper/abc.py

@@ -1,20 +0,0 @@
-import typing
-from abc import ABC, abstractmethod
-
-
-class ABCLoopWrapper(ABC):
-    @property
-    @abstractmethod
-    def is_running(self) -> bool:
-        pass
-
-    @abstractmethod
-    def add_task(self, task: typing.Any, /) -> None:
-        pass
-
-    @abstractmethod
-    def run_event_loop(self) -> typing.NoReturn:
-        raise NotImplementedError
-
-
-__all__ = ("ABCLoopWrapper",)

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -1,169 +0,0 @@
-import asyncio
-import contextlib
-import datetime
-import typing
-
-from telegrinder.modules import logger
-from telegrinder.tools.lifespan import (
-    CoroutineFunc,
-    CoroutineTask,
-    DelayedTask,
-    Lifespan,
-    Task,
-    to_coroutine_task,
-)
-from telegrinder.tools.loop_wrapper.abc import ABCLoopWrapper
-from telegrinder.tools.magic import cancel_future
-
-
-class LoopWrapper(ABCLoopWrapper):
-    def __init__(
-        self,
-        *,
-        tasks: list[CoroutineTask[typing.Any]] | None = None,
-        lifespan: Lifespan | None = None,
-    ) -> None:
-        self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
-        self.lifespan = lifespan or Lifespan()
-        self._loop: asyncio.AbstractEventLoop | None = None
-
-    @property
-    def is_running(self) -> bool:
-        if self._loop is None:
-            return False
-        return self._loop.is_running()
-
-    @property
-    def loop(self) -> asyncio.AbstractEventLoop:
-        assert self._loop is not None, "Loop is not set."
-        return self._loop
-
-    def __repr__(self) -> str:
-        return "<{}: loop={!r} with tasks={!r}, lifespan={!r}>".format(
-            self.__class__.__name__,
-            self._loop,
-            self.tasks,
-            self.lifespan,
-        )
-
-    async def _run_tasks(self) -> None:
-        async with asyncio.TaskGroup() as tg:
-            while self.tasks:
-                tg.create_task(self.tasks.pop(0))
-
-    def run_event_loop(self) -> typing.NoReturn:  # type: ignore
-        if not self.tasks:
-            logger.warning("Run loop without tasks!")
-
-        try:
-            self._loop = asyncio.get_running_loop()
-        except RuntimeError:
-            self._loop = asyncio.get_event_loop()
-
-        self.lifespan.start()
-        self._loop.create_task(self._run_tasks())
-
-        tasks = asyncio.all_tasks(self._loop)
-        try:
-            while tasks:
-                tasks_results, _ = self._loop.run_until_complete(
-                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION),
-                )
-                for task_result in tasks_results:
-                    try:
-                        task_result.result()
-                    except BaseException:
-                        logger.exception("Traceback message below:")
-                tasks = asyncio.all_tasks(self._loop)
-        except KeyboardInterrupt:
-            print()  # blank print for ^C
-            logger.info("Caught KeyboardInterrupt, cancellation...")
-            self.complete_tasks(tasks)
-        finally:
-            self.lifespan.shutdown()
-            if self._loop.is_running():
-                self._loop.close()
-
-    def add_task(self, task: Task[..., typing.Any], /) -> None:
-        task = to_coroutine_task(task)
-
-        if self._loop is not None and self._loop.is_running():
-            self._loop.create_task(task)
-        else:
-            self.tasks.append(task)
-
-    def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]], /) -> None:
-        tasks = tasks | asyncio.all_tasks(self.loop)
-        with contextlib.suppress(asyncio.CancelledError, asyncio.InvalidStateError):
-            self.loop.run_until_complete(cancel_future(asyncio.gather(*tasks, return_exceptions=True)))
-
-    @typing.overload
-    def timer(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
-
-    @typing.overload
-    def timer(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float = 0,
-    ) -> typing.Callable[..., typing.Any]: ...
-
-    def timer(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float | datetime.timedelta = 0,
-    ) -> typing.Callable[..., typing.Any]:
-        if isinstance(seconds, datetime.timedelta):
-            seconds = seconds.total_seconds()
-
-        seconds += minutes * 60
-        seconds += hours * 60 * 60
-        seconds += days * 24 * 60 * 60
-
-        def decorator[Func: CoroutineFunc[..., typing.Any]](func: Func) -> Func:
-            self.add_task(DelayedTask(func, seconds, repeat=False))
-            return func
-
-        return decorator
-
-    @typing.overload
-    def interval(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
-
-    @typing.overload
-    def interval(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float = 0,
-    ) -> typing.Callable[..., typing.Any]: ...
-
-    def interval(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float | datetime.timedelta = 0,
-    ) -> typing.Callable[..., typing.Any]:
-        if isinstance(seconds, datetime.timedelta):
-            seconds = seconds.total_seconds()
-
-        seconds += minutes * 60
-        seconds += hours * 60 * 60
-        seconds += days * 24 * 60 * 60
-
-        def decorator[Func: CoroutineFunc[..., typing.Any]](func: Func) -> Func:
-            self.add_task(DelayedTask(func, seconds, repeat=True))
-            return func
-
-        return decorator
-
-
-__all__ = ("DelayedTask", "LoopWrapper", "to_coroutine_task")