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

telegrinder/tools/adapter/abc.py

@@ -1,49 +0,0 @@
-import abc
-import dataclasses
-import inspect
-import typing
-
-from fntypes import Error, Nothing, Ok, Option, Some
-from fntypes.result import Result
-
-from telegrinder.modules import logger
-from telegrinder.tools.adapter.errors import AdapterError
-
-type AdaptResult[To] = Result[To, AdapterError] | typing.Awaitable[Result[To, AdapterError]]
-
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api.api import API
-    from telegrinder.bot.dispatch.context import Context
-    from telegrinder.model import Model
-
-
-class ABCAdapter[From: "Model", To](abc.ABC):
-    ADAPTED_VALUE_KEY: str | None = None
-
-    @abc.abstractmethod
-    def adapt(self, api: "API", update: From, context: "Context") -> AdaptResult[To]:
-        pass
-
-
-@dataclasses.dataclass(slots=True)
-class Event[To]:
-    obj: To
-
-
-async def run_adapter[T, U: "Model"](
-    adapter: "ABCAdapter[U, T]",
-    api: "API",
-    update: U,
-    context: "Context",
-) -> Option[T]:
-    adapt_result = adapter.adapt(api, update, context)
-    match await adapt_result if inspect.isawaitable(adapt_result) else adapt_result:
-        case Ok(value):
-            return Some(value)
-        case Error(err):
-            logger.debug("Adapter {!r} failed with error message: {!r}", adapter, str(err))
-            return Nothing()
-
-
-__all__ = ("ABCAdapter", "AdaptResult", "Event", "run_adapter")

telegrinder/tools/adapter/dataclass.py

@@ -1,56 +0,0 @@
-from fntypes.option import Nothing, Some
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.errors import AdapterError
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Update
-
-
-class DataclassAdapter[Dataclass](ABCAdapter[Update, Dataclass]):
-    ADAPTED_VALUE_KEY: str
-
-    def __init__(
-        self,
-        dataclass: type[Dataclass],
-        update_type: UpdateType | None = None,
-    ) -> None:
-        self.ADAPTED_VALUE_KEY = f"_adapted_dataclass_{dataclass.__name__}"
-        self.dataclass = dataclass
-        self.update_type = update_type
-
-    def __repr__(self) -> str:
-        return f"<Update -> {self.dataclass.__name__}>"
-
-    def adapt(self, api: API, update: Update, context: Context) -> Result[Dataclass, AdapterError]:
-        if self.ADAPTED_VALUE_KEY in context:
-            return Ok(context[self.ADAPTED_VALUE_KEY])
-
-        update_type = (self.update_type or update.update_type).value
-        try:
-            if self.dataclass is Update:
-                return Ok(update)  # type: ignore
-            elif issubclass(self.dataclass, UpdateCute):
-                dataclass = self.dataclass.from_update(update, bound_api=api)
-            else:
-                match getattr(update, update_type):
-                    case Some(val):
-                        dataclass = (
-                            self.dataclass.from_update(val, bound_api=api)
-                            if issubclass(self.dataclass, BaseCute)
-                            else self.dataclass(**val.to_dict())
-                        )
-                    case Nothing():
-                        return Error(AdapterError(f"Update has no event {update_type!r}."))
-        except Exception as e:
-            return Error(AdapterError(f"Cannot adapt Update to {self.dataclass!r}, error: {e!r}"))
-
-        context[self.ADAPTED_VALUE_KEY] = dataclass
-        return Ok(dataclass)  # type: ignore
-
-
-__all__ = ("DataclassAdapter",)

telegrinder/tools/adapter/errors.py

@@ -1,5 +0,0 @@
-class AdapterError(RuntimeError):
-    pass
-
-
-__all__ = ("AdapterError",)

telegrinder/tools/adapter/event.py

@@ -1,61 +0,0 @@
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.errors import AdapterError
-from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Model, Update
-
-
-class EventAdapter[ToEvent: BaseCute](ABCAdapter[Update, ToEvent]):
-    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
-
-    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToEvent]) -> None:
-        self.event = event
-        self.cute_model = cute_model
-
-    def __repr__(self) -> str:
-        raw_update_type = (
-            f"Update -> {self.event.__name__}" if isinstance(self.event, type) else f"Update.{self.event.value}"  # type: ignore
-        )
-        return "<{}: adapt {} -> {}>".format(
-            self.__class__.__name__,
-            raw_update_type,
-            self.cute_model.__name__,
-        )
-
-    def get_event(self, update: UpdateCute) -> Model | None:
-        if isinstance(self.event, UpdateType) and self.event == update.update_type:
-            return update.incoming_update
-
-        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
-            return event.unwrap()
-
-        return None
-
-    def adapt(self, api: API, update: Update, context: Context) -> Result[ToEvent, AdapterError]:
-        match RawUpdateAdapter().adapt(api, update, context):
-            case Ok(update_cute) if event := self.get_event(update_cute):
-                if self.ADAPTED_VALUE_KEY in context:
-                    return Ok(context[self.ADAPTED_VALUE_KEY])
-
-                adapted = (
-                    typing.cast(ToEvent, event)
-                    if isinstance(event, BaseCute)
-                    else self.cute_model.from_update(event, bound_api=api)
-                )
-                context[self.ADAPTED_VALUE_KEY] = adapted
-                return Ok(adapted)
-            case Error(_) as err:
-                return err
-            case _:
-                return Error(AdapterError(f"Update is not an {self.event!r}."))
-
-
-__all__ = ("EventAdapter",)

telegrinder/tools/adapter/node.py

@@ -1,46 +0,0 @@
-import typing_extensions as typing
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.msgspec_utils import repr_type
-from telegrinder.node.composer import NodeSession, compose_nodes
-from telegrinder.tools.adapter.abc import ABCAdapter, Event
-from telegrinder.tools.adapter.errors import AdapterError
-from telegrinder.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.node.base import IsNode
-
-
-class NodeAdapter(ABCAdapter[Update, Event[tuple["IsNode", ...]]]):
-    def __init__(self, *nodes: "IsNode") -> None:
-        self.nodes = nodes
-
-    def __repr__(self) -> str:
-        return "<{}: adapt Update -> ({})>".format(
-            self.__class__.__name__,
-            ", ".join(repr_type(node) for node in self.nodes),
-        )
-
-    async def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[Event[tuple[NodeSession, ...]], AdapterError]:
-        result = await compose_nodes(
-            nodes={f"node_{i}": typing.cast("IsNode", node) for i, node in enumerate(self.nodes)},
-            ctx=context,
-            data={Update: update, API: api},
-        )
-
-        match result:
-            case Ok(collection):
-                sessions: list[NodeSession] = list(collection.sessions.values())
-                return Ok(Event(tuple(sessions)))
-            case Error(err):
-                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
-
-
-__all__ = ("NodeAdapter",)

telegrinder/tools/adapter/raw_event.py

@@ -1,27 +0,0 @@
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.errors import AdapterError
-from telegrinder.types.objects import Update
-
-
-class RawEventAdapter(ABCAdapter[Update, Model]):
-    def __init__(self, event_model: type[Model], /) -> None:
-        self.event_model = event_model
-
-    def __repr__(self) -> str:
-        return "<{}: adapt Update -> {}>".format(
-            self.__class__.__name__,
-            self.event_model.__name__,
-        )
-
-    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
-        if isinstance(update.incoming_update, self.event_model):
-            return Ok(update.incoming_update)
-        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
-
-
-__all__ = ("RawEventAdapter",)

telegrinder/tools/adapter/raw_update.py

@@ -1,30 +0,0 @@
-from fntypes.result import Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.errors import AdapterError
-from telegrinder.types.objects import Update
-
-
-class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
-    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
-
-    def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[UpdateCute, AdapterError]:
-        if self.ADAPTED_VALUE_KEY not in context:
-            context[self.ADAPTED_VALUE_KEY] = (
-                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
-            )
-        return Ok(context[self.ADAPTED_VALUE_KEY])
-
-
-__all__ = ("RawUpdateAdapter",)

telegrinder/tools/callback_data_serilization/__init__.py

@@ -1,5 +0,0 @@
-from .abc import ABCDataSerializer
-from .json_ser import JSONSerializer
-from .msgpack_ser import MsgPackSerializer
-
-__all__ = ("ABCDataSerializer", "JSONSerializer", "MsgPackSerializer")

telegrinder/tools/error_handler/__init__.py

@@ -1,10 +0,0 @@
-from .abc import ABCErrorHandler
-from .error import CatcherError
-from .error_handler import Catcher, ErrorHandler
-
-__all__ = (
-    "ABCErrorHandler",
-    "Catcher",
-    "CatcherError",
-    "ErrorHandler",
-)

telegrinder/tools/error_handler/abc.py

@@ -1,30 +0,0 @@
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.api import API
-from telegrinder.bot.dispatch.context import Context
-
-type Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
-
-
-class ABCErrorHandler[Event](ABC):
-    @abstractmethod
-    def __call__(
-        self,
-        *args: typing.Any,
-        **kwargs: typing.Any,
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        """Decorator for registering callback as a catcher for the error handler."""
-
-    @abstractmethod
-    async def run(
-        self,
-        exception: BaseException,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> typing.Any:
-        """Run the error handler."""
-
-
-__all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error.py

@@ -1,9 +0,0 @@
-class CatcherError(BaseException):
-    __slots__ = ("exc", "message")
-
-    def __init__(self, exc: BaseException, message: str) -> None:
-        self.exc = exc
-        self.message = message
-
-
-__all__ = ("CatcherError",)

telegrinder/tools/error_handler/error_handler.py

@@ -1,179 +0,0 @@
-import dataclasses
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
-from telegrinder.tools.error_handler.abc import ABCErrorHandler
-from telegrinder.tools.error_handler.error import CatcherError
-from telegrinder.tools.magic import magic_bundle
-
-type FuncCatcher[Exc: BaseException] = typing.Callable[
-    typing.Concatenate[Exc, ...],
-    typing.Awaitable[typing.Any],
-]
-
-
-@dataclasses.dataclass(frozen=True, repr=False, slots=True)
-class Catcher[Event]:
-    func: FuncCatcher[BaseException]
-    exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
-        default_factory=lambda: [],
-        kw_only=True,
-    )
-    logging: bool = dataclasses.field(default=False, kw_only=True)
-    raise_exception: bool = dataclasses.field(default=False, kw_only=True)
-    ignore_errors: bool = dataclasses.field(default=False, kw_only=True)
-
-    def __repr__(self) -> str:
-        return "<Catcher: function={!r}, logging={}, raise_exception={}, ignore_errors={}>".format(
-            self.func.__name__,
-            self.logging,
-            self.raise_exception,
-            self.ignore_errors,
-        )
-
-    async def __call__(
-        self,
-        exception: BaseException,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        return await self.run(api, event, ctx, exception)
-
-    def match_exception(self, exception: BaseException) -> bool:
-        for exc in self.exceptions:
-            if isinstance(exc, type) and type(exception) is exc:
-                return True
-            if isinstance(exc, object) and type(exception) is type(exc):
-                return True if not exc.args else exc.args == exception.args
-
-        return False
-
-    async def run(
-        self,
-        api: API,
-        event: Event,
-        ctx: Context,
-        exception: BaseException,
-    ) -> Result[typing.Any, BaseException]:
-        if self.match_exception(exception):
-            logger.debug(
-                "Error handler caught an exception {!r}, running catcher {!r}...".format(
-                    exception,
-                    self.func.__name__,
-                )
-            )
-            return Ok(await self.func(exception, **magic_bundle(self.func, {"event": event, "api": api} | ctx)))
-
-        logger.debug("Failed to match exception {!r}.", exception.__class__.__name__)
-        return Error(exception)
-
-
-class ErrorHandler[Event](ABCErrorHandler[Event]):
-    def __init__(self, catcher: Catcher[Event] | None = None, /) -> None:
-        self.catcher = catcher
-
-    def __repr__(self) -> str:
-        return (
-            "<{}: exceptions=[{}], catcher={!r}>".format(
-                self.__class__.__name__,
-                ", ".join(e.__name__ if isinstance(e, type) else repr(e) for e in self.catcher.exceptions),
-                self.catcher,
-            )
-            if self.catcher is not None
-            else "<{}()>".format(self.__class__.__name__)
-        )
-
-    def __call__(
-        self,
-        *exceptions: type[BaseException] | BaseException,
-        logging: bool = False,
-        raise_exception: bool = False,
-        ignore_errors: bool = False,
-    ):
-        """Register the catcher.
-
-        :param logging: Logging the result of the catcher at the level `DEBUG`.
-        :param raise_exception: Raise an exception if the catcher has not started.
-        :param ignore_errors: Ignore errors that may occur.
-        """
-
-        def decorator[Func: FuncCatcher](catcher: Func, /) -> Func:
-            if not self.catcher:
-                self.catcher = Catcher(
-                    catcher,
-                    exceptions=list(exceptions),
-                    logging=logging,
-                    raise_exception=raise_exception,
-                    ignore_errors=ignore_errors,
-                )
-            return catcher
-
-        return decorator
-
-    def _process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
-        assert self.catcher is not None
-
-        if self.catcher.raise_exception:
-            raise error.exc from None
-        if self.catcher.logging:
-            logger.error(error.message)
-        if not self.catcher.ignore_errors:
-            return Error(error.exc)
-
-        return Ok(None)
-
-    async def suppress(
-        self,
-        exception: BaseException,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        assert self.catcher is not None
-
-        try:
-            return await self.catcher(exception, event, api, ctx)
-        except BaseException as exc:
-            return Error(
-                CatcherError(
-                    exc,
-                    "{!r} was occurred during the running catcher {!r}.".format(
-                        exc,
-                        self.catcher.func.__name__,
-                    ),
-                )
-            )
-
-    async def run(
-        self,
-        exception: BaseException,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> typing.Any:
-        if not self.catcher:
-            raise exception from None
-
-        match await self.suppress(exception, event, api, ctx):
-            case Ok(value):
-                if self.catcher.logging:
-                    logger.debug(
-                        "Catcher {!r} returned: {!r}",
-                        self.catcher.func.__name__,
-                        value,
-                    )
-                return value
-            case Error(exc):
-                if isinstance(exc, CatcherError):
-                    return self._process_catcher_error(exc).unwrap()
-                if self.catcher.ignore_errors:
-                    return None
-                raise exc from None
-
-
-__all__ = ("Catcher", "ErrorHandler")

telegrinder/tools/formatting/spec_html_formats.py

@@ -1,75 +0,0 @@
-import dataclasses
-import typing
-
-from telegrinder.types.enums import ProgrammingLanguage
-
-SpecialFormat: typing.TypeAlias = typing.Union[
-    "BlockQuote",
-    "Link",
-    "Mention",
-    "PreCode",
-    "TgEmoji",
-]
-
-
-def is_spec_format(obj: typing.Any) -> typing.TypeGuard[SpecialFormat]:
-    return dataclasses.is_dataclass(obj) and hasattr(obj, "__formatter_name__") and isinstance(obj, Base)
-
-
-@dataclasses.dataclass(repr=False)
-class Base:
-    __formatter_name__: typing.ClassVar[str] = dataclasses.field(init=False, repr=False)
-
-    def __repr__(self) -> str:
-        return f"<Special formatter {self.__class__.__name__!r} -> {self.__formatter_name__!r}>"
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class Mention(Base):
-    __formatter_name__ = "mention"
-
-    string: str
-    user_id: int
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class Link(Base):
-    __formatter_name__ = "link"
-
-    href: str
-    string: str | None = None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class PreCode(Base):
-    __formatter_name__ = "pre_code"
-
-    string: str
-    lang: str | ProgrammingLanguage | None = None
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class TgEmoji(Base):
-    __formatter_name__ = "tg_emoji"
-
-    string: str
-    emoji_id: int
-
-
-@dataclasses.dataclass(repr=False, slots=True)
-class BlockQuote(Base):
-    __formatter_name__ = "block_quote"
-
-    string: str
-    expandable: bool = False
-
-
-__all__ = (
-    "Base",
-    "BlockQuote",
-    "Link",
-    "Mention",
-    "PreCode",
-    "SpecialFormat",
-    "TgEmoji",
-)

telegrinder/tools/functional.py

@@ -1,8 +0,0 @@
-from fntypes import Nothing, Option, Some
-
-
-def from_optional[Value](value: Value | None, /) -> Option[Value]:
-    return Some(value) if value is not None else Nothing()
-
-
-__all__ = ("from_optional",)

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -1,27 +0,0 @@
-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 +0,0 @@
-from .abc import ABCI18n, ABCTranslator, I18nEnum
-from .middleware import ABCTranslatorMiddleware
-from .simple import SimpleI18n, SimpleTranslator
-
-__all__ = (
-    "ABCI18n",
-    "ABCTranslator",
-    "ABCTranslatorMiddleware",
-    "I18nEnum",
-    "SimpleI18n",
-    "SimpleTranslator",
-)

telegrinder/tools/i18n/abc.py

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

telegrinder/tools/i18n/middleware/__init__.py

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