telegrinder 0.1.dev19__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/client/aiohttp.py

@@ -2,11 +2,11 @@ import ssl
 import typing
 
 import aiohttp
+import certifi
+from aiohttp import ClientSession, TCPConnector
 
 from telegrinder.client.abc import ABCClient
-from aiohttp import ClientSession, TCPConnector
-from telegrinder.modules import json, JSONModule
-import certifi
+from telegrinder.modules import JSONModule, json
 
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
@@ -15,10 +15,10 @@ if typing.TYPE_CHECKING:
 class AiohttpClient(ABCClient):
     def __init__(
         self,
-        session: typing.Optional[ClientSession] = None,
-        json_processing_module: typing.Optional[JSONModule] = None,
-        timeout: typing.Optional[aiohttp.ClientTimeout] = None,
-        **session_params
+        session: ClientSession | None = None,
+        json_processing_module: JSONModule | None = None,
+        timeout: aiohttp.ClientTimeout | None = None,
+        **session_params,
     ):
         self.session = session
         self.json_processing_module = json_processing_module or json
@@ -29,8 +29,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict | None = None,
+        **kwargs,
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
@@ -41,7 +41,11 @@ class AiohttpClient(ABCClient):
                 **self.session_params,
             )
         async with self.session.request(
-            url=url, method=method, data=data, timeout=self.timeout, **kwargs
+            url=url,
+            method=method,
+            data=data,
+            timeout=self.timeout,
+            **kwargs,
         ) as response:
             await response.read()
             return response
@@ -50,32 +54,34 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict | None = None,
+        **kwargs,
     ) -> dict:
         response = await self.request_raw(url, method, data, **kwargs)
         return await response.json(
-            encoding="utf-8", loads=self.json_processing_module.loads, content_type=None
+            encoding="utf-8",
+            loads=self.json_processing_module.loads,
+            content_type=None,
         )
 
     async def request_text(
         self,
         url: str,
         method: str = "GET",
-        data: typing.Union[dict, aiohttp.FormData, None] = None,
-        **kwargs
+        data: dict | aiohttp.FormData | None = None,
+        **kwargs,
     ) -> str:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         return await response.text(encoding="utf-8")
 
     async def request_bytes(
         self,
         url: str,
         method: str = "GET",
-        data: typing.Union[dict, aiohttp.FormData, None] = None,
-        **kwargs
+        data: dict | aiohttp.FormData | None = None,
+        **kwargs,
     ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         if response._body is None:
             await response.read()
         return response._body
@@ -84,8 +90,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict | None = None,
+        **kwargs,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)
         return response._body
@@ -111,3 +117,6 @@ class AiohttpClient(ABCClient):
             if self.session._connector is not None and self.session._connector_owner:
                 self.session._connector.close()
             self.session._connector = None
+
+
+__all__ = ("AiohttpClient",)

telegrinder/model.py

@@ -1,65 +1,96 @@
-import msgspec
-from telegrinder.result import Result
-from telegrinder.modules import json
-from msgspec import Raw
 import typing
+from types import NoneType
+
+import msgspec
+from fntypes.co import Nothing, Result, Some
+
+from .msgspec_utils import decoder, encoder
+
+T = typing.TypeVar("T")
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
+    
 
-T = typing.TypeVar("T")
-encoder = msgspec.json.Encoder()
+MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
+    "omit_defaults": True,
+    "dict": True,
+    "rename": {"from_": "from"},
+}
 
 
+@typing.overload
 def full_result(
-    result: Result[msgspec.Raw, "APIError"], full_t: typing.Type[T]
+    result: Result[msgspec.Raw, "APIError"], full_t: type[T]
 ) -> Result[T, "APIError"]:
-    if not result.is_ok:
-        return result
-    return Result(True, value=msgspec.json.decode(result.value, type=full_t))
-
+    ...
 
-def convert(d: typing.Any) -> typing.Any:
-    if isinstance(d, Model):
-        return msgspec.json.encode(d).decode()
-    elif isinstance(d, dict):
-        return {k: convert(v) for k, v in d.items() if v is not None}
-    elif isinstance(d, list):
-        return json.dumps(d)
-    return d
 
+@typing.overload
+def full_result(
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: tuple[type[T], ...],
+) -> Result[T, "APIError"]:
+    ...
 
-model_config = {"rename": {"from_": "from"}, "omit_defaults": True}
 
+def full_result(
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: type[T] | tuple[type[T], ...],
+) -> Result[T, "APIError"]:
+    return result.map(lambda v: decoder.decode(v, type=full_t))  # type: ignore
 
-class Model(msgspec.Struct, **model_config):
-    _dict_cached: typing.Optional[dict] = None
 
-    def to_dict(self) -> dict:
-        if self._dict_cached is not None:
-            return self._dict_cached
-        self._dict_cached = {k: getattr(self, k) for k in self.__struct_fields__}
-        return self._dict_cached
+def convert(d: typing.Any, serialize: bool = True) -> typing.Any:
+    if isinstance(d, Model):
+        converted_dct = convert(d.to_dict(), serialize=False)
+        return encoder.encode(converted_dct) if serialize is True else converted_dct
+    
+    if isinstance(d, dict):
+        return {
+            k: convert(v, serialize=serialize)
+            for k, v in d.items()
+            if type(v) not in (NoneType, Nothing)
+        }
+    
+    if isinstance(d, list):
+        converted_lst = [convert(x, serialize=False) for x in d]
+        return encoder.encode(converted_lst) if serialize is True else converted_lst
+    
+    return d
 
 
-def get_params(params: dict) -> dict:
+def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return {
-        k: v for k, v in (
+        k: v.unwrap() if v and isinstance(v, Some) else v
+        for k, v in (
             *params.items(),
-            *params.pop("other").items()
+            *params.pop("other", {}).items(),
         )
-        if k != "self"
-        and v is not None
+        if k != "self" and type(v) not in (NoneType, Nothing)
     }
 
 
+class Model(msgspec.Struct, **MODEL_CONFIG):
+    def to_dict(
+        self,
+        *,
+        exclude_fields: set[str] | None = None,
+    ) -> dict[str, typing.Any]:  
+        exclude_fields = exclude_fields or set()
+        if "model_as_dict" not in self.__dict__:
+            self.__dict__["model_as_dict"] = msgspec.structs.asdict(self)
+        return {
+            key: value
+            for key, value in self.__dict__["model_as_dict"].items()
+            if key not in exclude_fields
+        }
+
+
 __all__ = (
+    "Model",
     "convert",
-    "model_config",
-    "encoder",
     "full_result",
-    "msgspec",
-    "Model",
-    "Raw",
     "get_params",
+    "MODEL_CONFIG",
 )

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 | list:
         ...
 
-    def dumps(self, o: typing.Union[dict, list]) -> str:
+    def dumps(self, o: dict | list) -> 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")