telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/modules.py

@@ -1,39 +1,78 @@
-import logging
+import os
 import typing
 
 from choicelib import choice_in_order
-from typing_extensions import Protocol
 
 
-class JSONModule(Protocol):
-    def loads(self, s: str) -> typing.Union[dict, list]:
+class JSONModule(typing.Protocol):
+    def loads(self, s: str) -> dict[str, typing.Any] | list[typing.Any]:
         ...
 
-    def dumps(self, o: typing.Union[dict, list]) -> str:
+    def dumps(self, o: dict[str, typing.Any] | list[typing.Any]) -> str:
         ...
 
 
+class LoggerModule(typing.Protocol):
+    def debug(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def info(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def warning(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def error(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def critical(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def exception(self, __msg: object, *args: object, **kwargs: object):
+        ...
+
+    def set_level(
+        self,
+        level: typing.Literal[
+            "DEBUG",
+            "INFO",
+            "WARNING",
+            "ERROR",
+            "CRITICAL",
+            "EXCEPTION",
+        ],
+    ) -> None:
+        ...
+
+
+logger: LoggerModule
 json: JSONModule = choice_in_order(
-    ["ujson", "hyperjson", "orjson"], do_import=True, default="json"
+    ["ujson", "hyperjson", "orjson"], do_import=True, default="telegrinder.msgspec_json"
 )
-
 logging_module = choice_in_order(["loguru"], default="logging")
+logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()
 
 if logging_module == "loguru":
     import os
     import sys
 
-    if not os.environ.get("LOGURU_AUTOINIT"):
-        os.environ["LOGURU_AUTOINIT"] = "0"
     from loguru import logger  # type: ignore
 
-    if not logger._core.handlers:  # type: ignore
-        log_format = (
-            "<level>{level: <8}</level> | "
-            "{time:YYYY-MM-DD HH:mm:ss} | "
-            "{name}:{function}:{line} > <level>{message}</level>"
-        )
-        logger.add(sys.stderr, format=log_format, enqueue=True, colorize=True)
+    os.environ.setdefault("LOGURU_AUTOINIT", "0")
+    log_format = (
+        "<level>{level: <8}</level> | "
+        "<lg>{time:YYYY-MM-DD HH:mm:ss}</lg> | "
+        "<le>{name}</le>:<le>{function}</le>:"
+        "<le>{line}</le> > <lw>{message}</lw>"
+    )
+    logger.remove()  # type: ignore
+    handler_id = logger.add(  # type: ignore
+        sink=sys.stderr,
+        format=log_format,
+        enqueue=True,
+        colorize=True,
+        level=logging_level,
+    )
 
 elif logging_module == "logging":
     """
@@ -41,8 +80,111 @@ elif logging_module == "logging":
     About:
     https://docs.python.org/3/howto/logging-cookbook.html#use-of-alternative-formatting-styles
     """
+
     import inspect
     import logging
+    import sys
+
+    import colorama
+
+    colorama.just_fix_windows_console()  # init & fix console
+
+    FORMAT = (
+        "<white>{name: <4} |</white> <level>{levelname: <8}</level>"
+        " <white>|</white> <green>{asctime}</green> <white>|</white> <level_module>"
+        "{module}</level_module><white>:</white><level_func>"
+        "{funcName}</level_func><white>:</white><level_lineno>"
+        "{lineno}</level_lineno><white> > </white><level_message>"
+        "{message}</level_message>"
+    )
+    COLORS = {
+        "red": colorama.Fore.LIGHTRED_EX,
+        "green": colorama.Fore.LIGHTGREEN_EX,
+        "blue": colorama.Fore.LIGHTBLUE_EX,
+        "white": colorama.Fore.LIGHTWHITE_EX,
+        "yellow": colorama.Fore.LIGHTYELLOW_EX,
+        "magenta": colorama.Fore.LIGHTMAGENTA_EX,
+        "cyan": colorama.Fore.LIGHTCYAN_EX,
+        "reset": colorama.Style.RESET_ALL,
+    }
+    LEVEL_SETTINGS = {
+        "INFO": {
+            "level": "green",
+            "level_module": "blue",
+            "level_func": "cyan",
+            "level_lineno": "green",
+            "level_message": "white",
+        },
+        "DEBUG": {
+            "level": "blue",
+            "level_module": "yellow",
+            "level_func": "green",
+            "level_lineno": "cyan",
+            "level_message": "blue",
+        },
+        "WARNING": {
+            "level": "yellow",
+            "level_module": "red",
+            "level_func": "green",
+            "level_lineno": "red",
+            "level_message": "yellow",
+        },
+        "ERROR": {
+            "level": "red",
+            "level_module": "magenta",
+            "level_func": "yellow",
+            "level_lineno": "green",
+            "level_message": "red",
+        },
+        "CRITICAL": {
+            "level": "cyan",
+            "level_module": "yellow",
+            "level_func": "yellow",
+            "level_lineno": "yellow",
+            "level_message": "cyan",
+        },
+    }
+    FORMAT = (
+        FORMAT
+        .replace("<white>", COLORS["white"])
+        .replace("</white>", COLORS["reset"])
+        .replace("<green>", COLORS["green"])
+        .replace("</green>", COLORS["reset"])
+    )
+    LEVEL_FORMATS: dict[str, str] = {}
+    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"])
+            )
+        LEVEL_FORMATS[level] = fmt
+
+
+    class TelegrinderLoggingFormatter(logging.Formatter):
+        def format(self, record: logging.LogRecord) -> str:  
+            if not record.funcName or record.funcName == "<module>":
+                record.funcName = "\b"
+            frame = next(
+                (
+                    frame
+                    for frame in inspect.stack()
+                    if frame.filename == record.pathname
+                    and frame.lineno == record.lineno
+                ),
+                None,
+            )
+            if frame:
+                module = inspect.getmodule(frame.frame)
+                record.module = module.__name__ if module else "<module>"
+            return logging.Formatter(
+                LEVEL_FORMATS.get(record.levelname),
+                datefmt="%Y-%m-%d %H:%M:%S",
+                style="{",
+            ).format(record)
+
 
     class LogMessage:
         def __init__(self, fmt, args, kwargs):
@@ -50,15 +192,16 @@ elif logging_module == "logging":
             self.args = args
             self.kwargs = kwargs
 
-        def __str__(self):
-            return self.fmt.format(*self.args)
+        def __str__(self) -> str:
+            return self.fmt.format(*self.args, **self.kwargs)
 
-    class StyleAdapter(logging.LoggerAdapter):
+    class TelegrinderLoggingStyleAdapter(logging.LoggerAdapter):
         def __init__(self, logger, extra=None):
             super().__init__(logger, extra or {})
 
         def log(self, level, msg, *args, **kwargs):
             if self.isEnabledFor(level):
+                kwargs.setdefault("stacklevel", 2)
                 msg, args, kwargs = self.proc(msg, args, kwargs)
                 self.logger._log(level, msg, args, **kwargs)
 
@@ -68,9 +211,34 @@ elif logging_module == "logging":
                 for key in inspect.getfullargspec(self.logger._log).args[1:]
                 if key in kwargs
             }
+            
             if isinstance(msg, str):
                 msg = LogMessage(msg, args, kwargs)
-                args = ()
+                args = tuple()
             return msg, args, log_kwargs
 
-    logger = StyleAdapter(logging.getLogger("telegrinder"))  # type: ignore
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(TelegrinderLoggingFormatter())
+    logger = logging.getLogger("telegrinder")  # type: ignore
+    logger.setLevel(logging.getLevelName(logging_level))  # type: ignore
+    logger.addHandler(handler)  # type: ignore
+    logger = TelegrinderLoggingStyleAdapter(logger)  # type: ignore
+
+
+def _set_logger_level(level):
+    level = level.upper()
+    if logging_module == "logging":
+        import logging
+
+        logging.getLogger("telegrinder").setLevel(logging.getLevelName(level))
+    elif logging_module == "loguru":
+        import loguru  # type: ignore
+        
+        if handler_id in loguru.logger._core.handlers:  # type: ignore
+            loguru.logger._core.handlers[handler_id]._levelno = loguru.logger.level(level).no  # type: ignore
+
+
+setattr(logger, "set_level", staticmethod(_set_logger_level))  # type: ignore
+
+
+__all__ = ("json", "logger")

telegrinder/msgspec_json.py

@@ -0,0 +1,14 @@
+import typing
+
+from .msgspec_utils import decoder, encoder
+
+
+def loads(s: str | bytes) -> dict[str, typing.Any] | list[typing.Any]:
+    return decoder.decode(s, type=dict[str, typing.Any] | list[typing.Any])  # type: ignore
+
+
+def dumps(o: dict[str, typing.Any] | list[typing.Any]) -> str:
+    return encoder.encode(o)
+
+
+__all__ = ("dumps", "loads")

telegrinder/msgspec_utils.py

@@ -0,0 +1,227 @@
+import typing
+
+import fntypes.option
+import msgspec
+from fntypes.co import Error, Ok, Result, Variative
+
+T = typing.TypeVar("T")
+Ts = typing.TypeVarTuple("Ts")
+
+if typing.TYPE_CHECKING:
+    import types
+    from datetime import datetime
+
+    from fntypes.option import Option
+else:
+    from datetime import datetime as dt
+
+    Value = typing.TypeVar("Value")
+
+    datetime = type("datetime", (dt,), {})
+
+    class OptionMeta(type):
+        def __instancecheck__(cls, __instance: typing.Any) -> bool:
+            return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
+
+
+    class Option(typing.Generic[Value], metaclass=OptionMeta):
+        pass
+
+DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], object]
+EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
+
+Nothing: typing.Final[fntypes.option.Nothing] = fntypes.option.Nothing()
+
+
+def get_origin(t: type[T]) -> type[T]:
+    return typing.cast(T, typing.get_origin(t)) or t
+
+
+def repr_type(t: type) -> str:
+    return getattr(t, "__name__", repr(get_origin(t)))
+
+
+def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.ValidationError]:
+    try:
+        return Ok(decoder.convert(obj, type=t, strict=True))
+    except msgspec.ValidationError as exc:
+        return Error(exc)
+
+
+def datetime_dec_hook(tp: type[datetime], obj: int | float) -> datetime:
+    return tp.fromtimestamp(obj)
+
+
+def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
+    if obj is None:
+        return Nothing
+    generic_args = typing.get_args(tp)
+    value_type: typing.Any | type[typing.Any] = typing.Any if not generic_args else generic_args[0]
+    return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
+
+
+def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
+    union_types = typing.get_args(tp)
+    
+    if isinstance(obj, dict):
+        struct_fields_match_sums: dict[type[msgspec.Struct], int] = {
+            m: sum(1 for k in obj if k in m.__struct_fields__)
+            for m in union_types
+            if issubclass(get_origin(m), msgspec.Struct)
+        }
+        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()):
+            struct_fields_match_sums = {m: len(m.__struct_fields__) for m in struct_fields_match_sums}
+            reverse = True
+
+        union_types = (
+            *sorted(struct_fields_match_sums, key=lambda k: struct_fields_match_sums[k], reverse=reverse),
+            *union_types,
+        )
+    
+    for t in union_types:
+        match msgspec_convert(obj, t):
+            case Ok(value):
+                return tp(value)
+
+    raise TypeError(
+        "Object of type `{}` does not belong to types `{}`".format(
+            repr_type(type(obj)),
+            " | ".join(map(repr_type, union_types)),
+        )
+    )
+
+
+def datetime_enc_hook(obj: datetime) -> int:
+    return int(obj.timestamp())
+
+
+def option_enc_hook(obj: Option[typing.Any]) -> typing.Any | None:
+    return obj.value if isinstance(obj, fntypes.option.Some) else None
+
+
+def variative_enc_hook(obj: Variative[typing.Any]) -> typing.Any:
+    return obj.v
+
+
+class Decoder:
+    def __init__(self) -> None:
+        self.dec_hooks: dict[
+            typing.Union[type[typing.Any], "types.UnionType"], DecHook[typing.Any]
+        ] = {
+            Option: option_dec_hook,
+            Variative: variative_dec_hook,
+            datetime: datetime_dec_hook,
+        }
+
+    def add_dec_hook(self, tp: type[T]):
+        def decorator(func: DecHook[T]) -> DecHook[T]:
+            return self.dec_hooks.setdefault(get_origin(tp), func)
+        
+        return decorator
+    
+    def dec_hook(self, tp: type[typing.Any], obj: object) -> object:
+        origin_type = t if isinstance((t := get_origin(tp)), type) else type(t)
+        if origin_type not in self.dec_hooks:
+            raise TypeError(
+                f"Unknown type `{repr_type(origin_type)}`. "
+                "You can implement decode hook for this type."
+            )
+        return self.dec_hooks[origin_type](tp, obj)
+    
+    def convert(
+        self,
+        obj: object,
+        *,
+        type: type[T] = dict,
+        strict: bool = True,
+        from_attributes: bool = False,
+        builtin_types: typing.Iterable[type] | None = None,
+        str_keys: bool = False,
+    ) -> T:
+        return msgspec.convert(
+            obj,
+            type,
+            strict=strict,
+            from_attributes=from_attributes,
+            dec_hook=self.dec_hook,
+            builtin_types=builtin_types,
+            str_keys=str_keys,
+        )
+
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T] = dict,
+        strict: bool = True,
+    ) -> T:
+        return msgspec.json.decode(
+            buf,
+            type=type,
+            strict=strict,
+            dec_hook=self.dec_hook,
+        )
+
+
+class Encoder:
+    def __init__(self) -> None:
+        self.enc_hooks: dict[type, EncHook] = {
+            fntypes.option.Some: option_enc_hook,
+            fntypes.option.Nothing: option_enc_hook,
+            Variative: variative_enc_hook,
+            datetime: datetime_enc_hook,
+        }
+
+    def add_dec_hook(self, tp: type[T]):
+        def decorator(func: EncHook[T]) -> EncHook[T]:
+            return self.enc_hooks.setdefault(get_origin(tp), func)
+        
+        return decorator
+    
+    def enc_hook(self, obj: object) -> object:
+        origin_type = get_origin(type(obj))
+        if origin_type not in self.enc_hooks:
+            raise NotImplementedError(
+                "Not implemented encode hook for "
+                f"object of type `{repr_type(origin_type)}`."
+            )
+        return self.enc_hooks[origin_type](obj)
+    
+    @typing.overload
+    def encode(self, obj: typing.Any) -> str:
+        ...
+
+    @typing.overload
+    def encode(self, obj: typing.Any, *, as_str: bool = False) -> bytes:
+        ...
+
+    def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
+        buf = msgspec.json.encode(obj, enc_hook=self.enc_hook)
+        return buf.decode() if as_str else buf
+
+
+decoder: typing.Final[Decoder] = Decoder()
+encoder: typing.Final[Encoder] = Encoder()
+
+
+__all__ = (
+    "Decoder",
+    "Encoder",
+    "Option",
+    "Nothing",
+    "get_origin",
+    "repr_type",
+    "msgspec_convert",
+    "datetime_dec_hook",
+    "datetime_enc_hook",
+    "option_dec_hook",
+    "option_enc_hook",
+    "variative_dec_hook",
+    "variative_enc_hook",
+    "datetime",
+    "decoder",
+    "encoder",
+)

telegrinder/node/__init__.py

@@ -0,0 +1,31 @@
+from .attachment import Attachment, Audio, Photo, Video
+from .base import ComposeError, DataNode, Node, ScalarNode
+from .composer import NodeCollection, NodeSession, compose_node
+from .container import ContainerNode
+from .message import MessageNode
+from .rule import RuleContext
+from .source import Source
+from .text import Text
+from .tools import generate
+from .update import UpdateNode
+
+__all__ = (
+    "Node",
+    "DataNode",
+    "ScalarNode",
+    "Attachment",
+    "Photo",
+    "Video",
+    "Text",
+    "Audio",
+    "UpdateNode",
+    "compose_node",
+    "ComposeError",
+    "MessageNode",
+    "Source",
+    "NodeSession",
+    "NodeCollection",
+    "ContainerNode",
+    "generate",
+    "RuleContext",
+)

telegrinder/node/attachment.py

@@ -0,0 +1,71 @@
+import dataclasses
+import typing
+
+from fntypes.option import Nothing
+
+import telegrinder.types
+from telegrinder.msgspec_utils import Option
+
+from .base import ComposeError, DataNode, ScalarNode
+from .message import MessageNode
+
+
+@dataclasses.dataclass
+class Attachment(DataNode):
+    attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
+    _: dataclasses.KW_ONLY
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(default_factory=lambda: Nothing())
+    document: Option[telegrinder.types.Document] = dataclasses.field(default_factory=lambda: Nothing())
+    photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(default_factory=lambda: Nothing())
+    poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing())
+    video: Option[telegrinder.types.Video] = dataclasses.field(default_factory=lambda: Nothing())
+
+    @classmethod
+    async def compose(cls, message: MessageNode) -> "Attachment":
+        for attachment_type in ("audio", "document", "photo", "poll", "video"):
+            if (attachment := getattr(message, attachment_type, None)) is not None:
+                return cls(attachment_type, **{attachment_type: attachment})
+        return cls.compose_error("No attachment found in message")
+
+
+@dataclasses.dataclass
+class Photo(DataNode):
+    sizes: list[telegrinder.types.PhotoSize]
+
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> typing.Self:
+        return cls(attachment.photo.expect(ComposeError("Attachment is not an photo")))
+
+
+class Video(ScalarNode, telegrinder.types.Video):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
+        return attachment.video.expect(ComposeError("Attachment is not an video"))
+
+
+class Audio(ScalarNode, telegrinder.types.Audio):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
+        return attachment.audio.expect(ComposeError("Attachment is not an audio"))
+
+
+class Document(ScalarNode, telegrinder.types.Document):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
+        return attachment.document.expect(ComposeError("Attachment is not an document"))
+
+
+class Poll(ScalarNode, telegrinder.types.Poll):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
+        return attachment.poll.expect(ComposeError("Attachment is not an poll"))
+
+
+__all__ = (
+    "Attachment",
+    "Audio",
+    "Document",
+    "Photo",
+    "Poll",
+    "Video",
+)

telegrinder/node/base.py

@@ -0,0 +1,93 @@
+import abc
+import inspect
+import typing
+
+ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
+
+
+class ComposeError(BaseException):
+    pass
+
+
+class Node(abc.ABC):
+    node: str = "node"
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+    @classmethod
+    def compose_error(cls, error: str | None = None) -> typing.NoReturn:
+        raise ComposeError(error)
+
+    @classmethod
+    def get_sub_nodes(cls) -> dict[str, type[typing.Self]]:
+        parameters = inspect.signature(cls.compose).parameters
+        
+        sub_nodes = {}
+        for name, param in parameters.items():
+            if param.annotation is inspect._empty:
+                continue
+            node = param.annotation
+            sub_nodes[name] = node
+        return sub_nodes
+    
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+    
+    @classmethod
+    def is_generator(cls) -> bool:
+        return inspect.isasyncgenfunction(cls.compose)
+
+
+class DataNode(Node, abc.ABC):
+    node = "data"
+
+    @typing.dataclass_transform()
+    @classmethod
+    @abc.abstractmethod
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+
+class ScalarNodeProto(Node, abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+
+SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
+
+
+if typing.TYPE_CHECKING:
+
+    class ScalarNode(ScalarNodeProto, abc.ABC): 
+        pass
+    
+else:
+
+    def create_node(cls, bases, dct):
+        dct.update(cls.__dict__)
+        return type(cls.__name__, bases, dct)
+
+    def create_class(name, bases, dct):
+        return type(
+            "Scalar", 
+            (SCALAR_NODE,), 
+            {"as_node": classmethod(lambda cls: create_node(cls, bases, dct))},
+        )
+
+    class ScalarNode(ScalarNodeProto, abc.ABC, metaclass=create_class):
+        pass
+
+
+__all__ = (
+    "ScalarNode",
+    "SCALAR_NODE",
+    "DataNode",
+    "Node",
+    "ComposeError",
+)