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

telegrinder/tools/error_handler/error_handler.py

@@ -9,30 +9,31 @@ from telegrinder.modules import logger
 from telegrinder.tools.magic import magic_bundle
 
 from .abc import ABCErrorHandler, EventT, Handler
+from .error import CatcherError
 
 F = typing.TypeVar("F", bound="FuncCatcher")
 ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
 FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, repr=False)
 class Catcher(typing.Generic[EventT]):
-    func: FuncCatcher
+    func: FuncCatcher[BaseException]
     _: dataclasses.KW_ONLY
     exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
-        default_factory=lambda: []
+        default_factory=lambda: [],
     )
     logging: bool = dataclasses.field(default=False)
     raise_exception: bool = dataclasses.field(default=False)
     ignore_errors: bool = dataclasses.field(default=False)
 
-    def match_exception(self, exception: BaseException) -> bool:
-        for exc in self.exceptions:
-            if isinstance(exc, type) and type(exception) == exc:
-                return True
-            if isinstance(exc, object) and type(exception) == type(exc):
-                return True if not exc.args else exc.args == exception.args
-        return False        
+    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,
@@ -40,66 +41,93 @@ class Catcher(typing.Generic[EventT]):
         event: EventT,
         api: ABCAPI,
         ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
+    ) -> Result[typing.Any, BaseException]:
         try:
-            result = Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
+            return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
         except BaseException as exc:
+            return await self.process_exception(api, event, ctx, exc, handler.__name__)
+
+    async def process_exception(
+        self,
+        api: ABCAPI,
+        event: EventT,
+        ctx: Context,
+        exception: BaseException,
+        handler_name: str,
+    ) -> Result[typing.Any, BaseException]:
+        if self.match_exception(exception):
             logger.debug(
-                "Exception {!r} occurred while running handler {!r}. Matching  "
-                "exceptions it with exception that can be caught by the catcher {!r}...",
-                exc.__class__.__name__,
-                handler.__name__,
-                self.func.__name__,
-            )
-            
-            if self.match_exception(exc):
-                logger.debug(
-                    "Catcher {!r} caught an exception in handler {!r}, "
-                    "running catcher...".format(
-                        self.func.__name__,
-                        handler.__name__,
-                    )
+                "Catcher {!r} caught an exception in handler {!r}, "
+                "running catcher...".format(
+                    self.func.__name__,
+                    handler_name,
                 )
-                result = Ok(
-                    await self.func(
-                        exc,
-                        **magic_bundle(
-                            self.func,
-                            {"event": event, "api": api} | ctx  # type: ignore
-                        )
-                    )
+            )
+            return Ok(
+                await self.func(
+                    exception,
+                    **magic_bundle(self.func, {"event": event, "api": api} | ctx),  # type: ignore
                 )
-            else:
-                logger.debug("Failed to match exception {!r}!", exc.__class__.__name__)
-                result = Error(exc)
-        
-        logger.debug(
-            "Catcher {!r} {} with result: {!r}",
-            self.func.__name__,
-            "completed" if result else "failed",
-            result,
-        )
-        return result
+            )
+        logger.debug("Failed to match exception {!r}!", exception.__class__.__name__)
+        return Error(exception)
     
+    def match_exception(self, exception: BaseException) -> bool:
+        for exc in self.exceptions:
+            if isinstance(exc, type) and type(exception) == exc:
+                return True
+            if isinstance(exc, object) and type(exception) == type(exc):
+                return True if not exc.args else exc.args == exception.args
+        return False
+
 
 class ErrorHandler(ABCErrorHandler[EventT]):
-    def __init__(self, __catcher: Catcher[EventT] | None = None):
-        self.catcher = __catcher
+    def __init__(self, catcher: Catcher[EventT] | None = None, /) -> None:
+        self.catcher = catcher
     
     def __repr__(self) -> str:
-        return f"<ErrorHandler: {self.catcher!r}>"
+        return (
+            "<ErrorHandler: exceptions_handled=[{}], catcher={!r}>".format(
+                ", ".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 "<ErrorHandler: No catcher>"
+        )
     
-    def catch(
+    async def __call__(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        assert self.catcher is not None
+
+        try:
+            return await self.catcher(handler, event, api, ctx)
+        except BaseException as exc:
+            return Error(CatcherError(
+                exc,
+                "Exception {!r} was occurred during the running catcher {!r}.".format(
+                    repr(exc), self.catcher.func.__name__
+                )
+            ))
+    
+    def register_catcher(
         self,
         *exceptions: type[BaseException] | BaseException,
         logging: bool = False,
         raise_exception: bool = False,
         ignore_errors: bool = False,
     ):
-        """Catch an exception while the handler is running.
+        """Register the catcher.
         :param logging: Error logging in stderr.
         :param raise_exception: Raise an exception if the catcher hasn't started.
-        :param ignore_errors: Ignore errors that may occur in the catcher.
+        :param ignore_errors: Ignore errors that may occur.
         """
 
         def decorator(func: F) -> F:
@@ -113,6 +141,18 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                 )
             return func
         return decorator
+    
+    def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
+        assert self.catcher is not None
+        
+        if self.catcher.raise_exception:
+            raise error.exc from None
+        if not self.catcher.ignore_errors:
+            return Error(error.error)
+        if self.catcher.logging:
+            logger.error(error.error)
+        
+        return Ok(None)
 
     async def run(
         self,
@@ -124,33 +164,12 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
         
-        ok_none = Ok(None)
-        
-        try:
-            result = await self.catcher(handler, event, api, ctx)
-        except BaseException as e:
-            error_msg = "Exception {} was occurred during the running catcher {!r}.".format(
-                repr(e.__class__.__name__)
-                if not e.args
-                else f"{e.__class__.__name__!r}: {str(e)!r}",
-                self.catcher.func.__name__,
-            )
-            result = ok_none
-            
-            if not self.catcher.ignore_errors:
-                return Error(error_msg)
-            if self.catcher.logging:
-                logger.error(error_msg)
-           
-        if self.catcher.raise_exception and not result:
-            return result
-        
-        if self.catcher.logging and not result:
-            logger.error(
-                "Catcher {!r} failed with error: {!r}",
-                self.catcher.func.__name__,
-                result.error,
-            )
-            return ok_none
-        
-        return result or ok_none
+        match await self(handler, event, api, ctx):
+            case Ok(_) as ok:
+                return ok
+            case Error(exc) as err:
+                if isinstance(exc, CatcherError):
+                    return self.process_catcher_error(exc)              
+                if self.catcher.ignore_errors:
+                    return Ok(None)
+                return err

telegrinder/tools/global_context/global_context.py

@@ -23,7 +23,11 @@ else:
 
 
 def type_check(value: object, value_type: type[T]) -> typing.TypeGuard[T]:
-    return True if value_type is object else bool(msgspec_convert(value, value_type))
+    return (
+        True
+        if value_type in (typing.Any, object)
+        else bool(msgspec_convert(value, value_type))
+    )
 
 
 def is_dunder(name: str) -> bool:
@@ -44,23 +48,23 @@ def root_protection(func: F) -> F:
         )
 
     @wraps(func)
-    def wrapper(self: "GlobalContext", __name: str, *args) -> typing.Any:
-        if self.is_root_attribute(__name) and __name in (
+    def wrapper(self: "GlobalContext", name: str, /, *args) -> typing.Any:
+        if self.is_root_attribute(name) and name in (
             self.__dict__ | self.__class__.__dict__
         ):
-            root_attr = self.get_root_attribute(__name).unwrap()
+            root_attr = self.get_root_attribute(name).unwrap()
             if all((not root_attr.can_be_rewritten, not root_attr.can_be_read)):
                 raise AttributeError(
-                    f"Unable to set, get, delete root attribute {__name!r}."
+                    f"Unable to set, get, delete root attribute {name!r}."
                 )
             if func.__name__ == "__setattr__" and not root_attr.can_be_rewritten:
-                raise AttributeError(f"Unable to set root attribute {__name!r}.")
+                raise AttributeError(f"Unable to set root attribute {name!r}.")
             if func.__name__ == "__getattr__" and not root_attr.can_be_read:
-                raise AttributeError(f"Unable to get root attribute {__name!r}.")
+                raise AttributeError(f"Unable to get root attribute {name!r}.")
             if func.__name__ == "__delattr__":
-                raise AttributeError(f"Unable to delete root attribute {__name!r}.")
+                raise AttributeError(f"Unable to delete root attribute {name!r}.")
 
-        return func(self, __name, *args)  # type: ignore
+        return func(self, name, *args)  # type: ignore
 
     return wrapper  # type: ignore
 
@@ -77,7 +81,7 @@ def ctx_var(value: T, *, const: bool = False) -> T:
     ctx.URL = '...'  #: type checking error & exception 'TypeError'
     ```
     """
-    
+
     return typing.cast(T, CtxVar(value, const=const))
 
 
@@ -116,7 +120,9 @@ class Storage:
         return Some(ctx) if ctx is not None else Nothing()
 
     def delete(self, ctx_name: str) -> None:
-        assert self._storage.pop(ctx_name, None) is not None, f"Context {ctx_name!r} is not defined in storage."
+        assert (
+            self._storage.pop(ctx_name, None) is not None
+        ), f"Context {ctx_name!r} is not defined in storage."
 
 
 @typing.dataclass_transform(
@@ -126,7 +132,7 @@ class Storage:
 )
 class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, GlobalCtxVar[CtxValueT]]):
     """GlobalContext.
-    
+
     ```
     ctx = GlobalContext()
     ctx["client"] = Client()
@@ -136,7 +142,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         data = {"user": "root_user", "password": "secret_password"}
         ctx.client.request(ctx.address + "/login", data)
     """
-    
+
     __ctx_name__: str | None
     __storage__: typing.ClassVar[Storage] = Storage()
     __root_attributes__: typing.ClassVar[tuple[RootAttr, ...]] = (
@@ -156,16 +162,13 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         if not issubclass(GlobalContext, cls):
             defaults = {}
             for name in cls.__annotations__:
-                if (
-                    name in cls.__dict__
-                    and name not in cls.__root_attributes__
-                ):
+                if name in cls.__dict__ and name not in cls.__root_attributes__:
                     defaults[name] = getattr(cls, name)
                     delattr(cls, name)
                     if isinstance(defaults[name], CtxVar) and defaults[name].const:
                         variables.pop(name, None)
-    
-            variables = defaults | variables 
+
+            variables = defaults | variables
 
         ctx_name = getattr(cls, "__ctx_name__", ctx_name)
         if ctx_name is None:
@@ -175,7 +178,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         else:
             ctx = dict.__new__(cls, ctx_name)
             cls.__storage__.set(ctx_name, ctx)
-        
+
         ctx.set_context_variables(variables)
         return ctx  # type: ignore
 
@@ -189,22 +192,25 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
         if not hasattr(self, "__ctx_name__"):
             self.__ctx_name__ = ctx_name
-        
+
         if variables and not self:
             self.set_context_variables(variables)
-                
+
     def __repr__(self) -> str:
         return "<{!r} -> ({})>".format(
             f"{self.__class__.__name__}@{self.ctx_name}",
             ", ".join(repr(var) for var in self),
         )
-    
+
     def __eq__(self, __value: "GlobalContext") -> bool:
         """Returns True if the names of context stores
         that use self and __value instances are equivalent."""
 
-        return self.__ctx_name__ == __value.__ctx_name__
-    
+        return (
+            isinstance(__value, GlobalContext)
+            and self.__ctx_name__ == __value.__ctx_name__
+        )
+
     def __setitem__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
         if is_dunder(__name):
             raise NameError("Cannot set a context variable with dunder name.")
@@ -217,7 +223,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     def __getitem__(self, __name: str) -> CtxValueT:
         return self.get(__name).unwrap().value
-    
+
     def __delitem__(self, __name: str):
         var = self.get(__name).unwrap()
         if var.const:
@@ -263,9 +269,11 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
         return name in cls.__root_attributes__
 
-    def set_context_variables(self, variables: typing.Mapping[str, CtxValueT | CtxVariable[CtxValueT]]) -> None:    
+    def set_context_variables(
+        self, variables: typing.Mapping[str, CtxValueT | CtxVariable[CtxValueT]]
+    ) -> None:
         """Set context variables from mapping."""
-        
+
         for name, var in variables.items():
             self[name] = var
 
@@ -277,83 +285,74 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
                 if rattr.name == name:
                     return Some(rattr)
         return Nothing()
-        
+
     def items(self) -> list[tuple[str, GlobalCtxVar[CtxValueT]]]:
         """Return context variables as set-like items."""
 
         return list(dict.items(self))
-    
+
     def keys(self) -> list[str]:
         """Returns context variable names as keys."""
 
         return list(dict.keys(self))
-    
+
     def values(self) -> list[GlobalCtxVar[CtxValueT]]:
         """Returns context variables as values."""
 
         return list(dict.values(self))
-    
+
     def update(self, other: typing.Self) -> None:
         """Update context."""
 
         dict.update(dict(other.items()))
-    
+
     def copy(self) -> typing.Self:
         """Copy context. Returns copied context without ctx_name."""
 
         return self.__class__(**self.dict())
-    
+
     def dict(self) -> dict[str, GlobalCtxVar[CtxValueT]]:
         """Returns context as dict."""
 
         return {name: deepcopy(var) for name, var in self.items()}
-    
+
     @typing.overload
-    def pop(self, var_name: str) -> Option[GlobalCtxVar[CtxValueT]]:
-        ...
-    
+    def pop(self, var_name: str) -> Option[GlobalCtxVar[CtxValueT]]: ...
+
     @typing.overload
     def pop(
         self,
         var_name: str,
         var_value_type: type[T],
-    ) -> Option[GlobalCtxVar[T]]:
-        ...
-    
+    ) -> Option[GlobalCtxVar[T]]: ...
+
     def pop(
-        self,
-        var_name: str,
-        var_value_type: type[T] = object
+        self, var_name: str, var_value_type: type[T] = object
     ) -> Option[GlobalCtxVar[T]]:
-        """Pop context variable by name.
-        Returns Option[GlobalCtxVar[T]] object.
-        """
+        """Pop context variable by name."""
 
         val = self.get(var_name, var_value_type)
         if val:
             del self[var_name]
             return val
         return Nothing()
-    
+
     @typing.overload
-    def get(self, var_name: str) -> Option[GlobalCtxVar[CtxValueT]]:
-        ...
-    
+    def get(self, var_name: str) -> Option[GlobalCtxVar[CtxValueT]]: ...
+
     @typing.overload
     def get(
         self,
         var_name: str,
         var_value_type: type[T],
-    ) -> Option[GlobalCtxVar[T]]:
-        ...
-    
+    ) -> Option[GlobalCtxVar[T]]: ...
+
     def get(
         self,
         var_name: str,
         var_value_type: type[T] = object,
     ) -> Option[GlobalCtxVar[T]]:
-        """Get context variable by name.
-        Returns `GlobalCtxVar[value_type]` object."""
+        """Get context variable by name."""
 
         generic_types = typing.get_args(get_orig_class(self))
         if generic_types and var_value_type is object:
@@ -361,27 +360,27 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         var = dict.get(self, var_name)
         if var is None:
             return Nothing()
-        assert type_check(var.value, var_value_type), (
-            "Context variable value type of {!r} does not correspond to the expected type {!r}.".format(
-                type(var.value).__name__,
+        assert type_check(
+            var.value, var_value_type
+        ), "Context variable value type of {!r} does not correspond to the expected type {!r}.".format(
+            type(var.value).__name__,
+            (
                 getattr(var_value_type, "__name__")
                 if isinstance(var_value_type, type)
-                else repr(var_value_type),
-            )
+                else repr(var_value_type)
+            ),
         )
         return Some(var)
 
     @typing.overload
-    def get_value(self, var_name: str) -> Option[CtxValueT]:
-        ...
+    def get_value(self, var_name: str) -> Option[CtxValueT]: ...
 
     @typing.overload
     def get_value(
         self,
         var_name: str,
         var_value_type: type[T],
-    ) -> Option[T]:
-        ...
+    ) -> Option[T]: ...
 
     def get_value(
         self,
@@ -398,8 +397,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         var = self.get(old_var_name).unwrap()
         if var.const:
             return Error(
-                f"Unable to rename variable {old_var_name!r}, "
-                "because it's a constant."
+                f"Unable to rename variable {old_var_name!r}, " "because it's a constant."
             )
         del self[old_var_name]
         self[new_var_name] = var.value

telegrinder/tools/kb_set/yaml.py

@@ -8,7 +8,7 @@ from telegrinder.tools.keyboard import InlineKeyboard, Keyboard
 
 from .base import KeyboardSetBase, KeyboardSetError
 
-PathLike = str | os.PathLike[str]
+PathLike: typing.TypeAlias = str | os.PathLike[str]
 
 
 class KeyboardSetYAML(KeyboardSetBase):
@@ -27,7 +27,7 @@ class KeyboardSetYAML(KeyboardSetBase):
                 encoding="UTF-8",
             ),
             yaml.Loader,
-        ) 
+        )
         for name, hint in typing.get_type_hints(cls).items():
             g = re.match(r"(?:kb_|keyboard_)(.+)", name.lower())
             if not g:
@@ -47,7 +47,7 @@ class KeyboardSetYAML(KeyboardSetBase):
                     "Keyboard should be dict with field buttons which must be a list, "
                     "check documentation."
                 )
-            
+
             buttons = kb_config.pop("buttons")
             new_keyboard: Keyboard | InlineKeyboard = hint(**kb_config)
             for button in buttons: