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

telegrinder/tools/global_context/global_context.py

@@ -6,9 +6,9 @@ import typing_extensions as typing
 from fntypes.co import Error, Nothing, Ok, Option, Result, Some
 
 from telegrinder.modules import logger
-from telegrinder.msgspec_utils import msgspec_convert
-
-from .abc import ABCGlobalContext, CtxVar, CtxVariable, GlobalCtxVar
+from telegrinder.msgspec_utils import convert
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.global_context.abc import NODEFAULT, ABCGlobalContext, CtxVar, CtxVariable, GlobalCtxVar
 
 T = typing.TypeVar("T")
 F = typing.TypeVar("F", bound=typing.Callable)
@@ -23,7 +23,7 @@ else:
 def type_check(value: object, value_type: type[T]) -> typing.TypeGuard[T]:
     if value_type in (typing.Any, object):
         return True
-    match msgspec_convert(value, value_type):
+    match convert(value, value_type):
         case Ok(v):
             return type(value) is type(v)
         case Error(_):
@@ -35,7 +35,9 @@ def is_dunder(name: str) -> bool:
 
 
 def get_orig_class(obj: T) -> type[T]:
-    return getattr(obj, "__orig_class__", obj.__class__)
+    if "__orig_class__" not in obj.__dict__:
+        return type(obj)
+    return obj.__dict__["__orig_class__"]
 
 
 def root_protection(func: F) -> F:
@@ -65,19 +67,82 @@ def root_protection(func: F) -> F:
     return wrapper  # type: ignore
 
 
-def ctx_var(*, default: T, frozen: bool = False) -> T:
+@typing.overload
+def ctx_var() -> typing.Any: ...
+
+
+@typing.overload
+def ctx_var(
+    *,
+    init: bool = ...,
+    const: bool = ...,
+) -> typing.Any: ...
+
+
+@typing.overload
+def ctx_var(
+    *,
+    default: typing.Any,
+    init: bool = ...,
+    const: bool = ...,
+) -> typing.Any: ...
+
+
+@typing.overload
+def ctx_var(
+    *,
+    default_factory: typing.Callable[[], typing.Any],
+    init: bool = ...,
+    const: bool = ...,
+) -> typing.Any: ...
+
+
+def ctx_var(
+    *,
+    default: typing.Any = NODEFAULT,
+    default_factory: typing.Any = NODEFAULT,
+    const: bool = False,
+    **_: typing.Any,
+) -> typing.Any:
     """Example:
     ```
     class MyCtx(GlobalContext):
+        __ctx_name__ = "my_ctx"
+
         name: str
-        URL: str = ctx_var("https://google.com", frozen=True)
+        URL: typing.Final[str] = ctx_var(default="https://google.com", init=False, const=True)
 
-    ctx = MyCtx(name=ctx_var("Alex", frozen=True))
+    ctx = MyCtx(name="John")
     ctx.URL  #: 'https://google.com'
     ctx.URL = '...'  #: type checking error & exception 'TypeError'
     ```
     """
-    return typing.cast(T, CtxVar(default, const=frozen))
+    return CtxVar(value=default, factory=default_factory, const=const)
+
+
+def runtime_init[T: ABCGlobalContext](cls: type[T], /) -> type[T]:
+    r'''Initialization the global context at runtime.
+
+    ```python
+    @runtime_init
+    class Box(ABCGlobalContext):
+        __ctx_name__ = "box"
+
+        cookies: list[Cookie] = ctx_var(default_factory=lambda: [ChocolateCookie()], init=False)
+        """
+        init=False means that when calling the class constructor it will not be necessary
+        to pass this field to the class constructor, because it will already be initialized.
+        """
+
+    box = Box()  # So, this global context has already been initialized, so calling the class
+                 # immediately returns an initialized instance of this class from the memory storage.
+
+    box.cookies.append(OatmealCookie())
+    print(box.cookies)  # [<ChocolateCookie>, <OatmealCookie>]
+    ```
+    '''
+    cls()  # Init an instance of the global context.
+    return cls
 
 
 @dataclasses.dataclass(frozen=True, eq=False, slots=True)
@@ -98,7 +163,7 @@ class Storage:
     )
 
     def __repr__(self) -> str:
-        return "<ContextStorage: %s>" % ", ".join("ctx @" + repr(x) for x in self._storage)
+        return "<Storage: %s>" % ", ".join(repr(x) for x in self._storage)
 
     @property
     def storage(self) -> dict[str, "GlobalContext"]:
@@ -118,28 +183,39 @@ class Storage:
 @typing.dataclass_transform(
     kw_only_default=True,
     order_default=True,
+    frozen_default=False,
     field_specifiers=(ctx_var,),
 )
 class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, GlobalCtxVar[CtxValueT]]):
-    """GlobalContext.
+    """This is class to store the context globally.
 
+    `GlobalContext` is a dictionary with additional methods for working with context.
+
+    Example:
     ```
     ctx = GlobalContext()
     ctx["client"] = Client()
-    ctx.address = CtxVar("128.0.0.7:8888", const=True)
+    ctx.host = CtxVar("128.0.0.7:8888", const=True)
 
     def request():
         data = {"user": "root_user", "password": "secret_password"}
-        ctx.client.request(ctx.address + "/login", data)
+        ctx.client.request(ctx.host + "/login", data)
+    ```
+
     """
 
     __ctx_name__: str | None
+    """Global context name."""
+
     __storage__: typing.ClassVar[Storage] = Storage()
+    """Storage memory; this is the storage where all initialized global contexts are stored."""
+
     __root_attributes__: typing.ClassVar[tuple[RootAttr, ...]] = (
-        RootAttr("__ctx_name__"),
-        RootAttr("__root_attributes__"),
-        RootAttr("__storage__"),
+        RootAttr(name="__ctx_name__"),
+        RootAttr(name="__root_attributes__"),
+        RootAttr(name="__storage__"),
     )
+    """The sequence of root attributes of this class including this attribute."""
 
     def __new__(
         cls,
@@ -148,13 +224,15 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         **variables: typing.Any | CtxVar[CtxValueT],
     ) -> typing.Self:
         """Create or get from storage a new `GlobalContext` object."""
-        if not issubclass(GlobalContext, cls):
+        if cls is not GlobalContext:
             defaults = {}
             for name in cls.__annotations__:
                 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:
+
+                    default_ = defaults[name]
+                    if isinstance(default_, CtxVar) and default_.const:
                         variables.pop(name, None)
 
             variables = defaults | variables
@@ -184,36 +262,55 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
             self.set_context_variables(variables)
 
     def __repr__(self) -> str:
-        return "<{} -> ({})>".format(
-            f"{self.__class__.__name__}@{self.ctx_name!r}",
-            ", ".join(repr(var) for var in self),
+        return "<{} contains variables: {{ {} }}>".format(
+            f"{fullname(self)}@{self.ctx_name}",
+            ", ".join(var_name for var_name in self),
         )
 
-    def __eq__(self, __value: "GlobalContext") -> bool:
+    def __eq__(self, __value: object) -> bool:
         """Returns True if the names of context stores
         that use self and __value instances are equivalent.
         """
-        return isinstance(__value, GlobalContext) and self.__ctx_name__ == __value.__ctx_name__
+        if not isinstance(__value, type(self)):
+            return NotImplemented
+        return self.__ctx_name__ == __value.__ctx_name__ and self == __value
 
-    def __setitem__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
+    def __setitem__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]) -> None:
         if is_dunder(__name):
-            raise NameError("Cannot set a context variable with dunder name.")
+            raise NameError("Cannot set a context variable with a dunder name.")
+
         var = self.get(__name)
-        if var and var.unwrap().const:
+        if var and (var.value.const and var.value.value is not NODEFAULT):
             raise TypeError(f"Unable to set variable {__name!r}, because it's a constant.")
-        dict.__setitem__(self, __name, GlobalCtxVar.collect(__name, __value))
+
+        dict.__setitem__(
+            self,
+            __name,
+            GlobalCtxVar.from_var(
+                name=__name,
+                ctx_value=__value,
+                const=var.map(lambda var: var.const).unwrap_or(False),
+            ),
+        )
 
     def __getitem__(self, __name: str) -> CtxValueT:
-        return self.get(__name).unwrap().value  # type: ignore
+        value = self.get(__name).unwrap().value
+        if value is NODEFAULT:
+            raise NameError(f"Variable {__name!r} is not defined in {self.ctx_name!r}.")
+        return value
 
-    def __delitem__(self, __name: str):
+    def __delitem__(self, __name: str) -> None:
         var = self.get(__name).unwrap()
         if var.const:
             raise TypeError(f"Unable to delete variable {__name!r}, because it's a constant.")
+
+        if var.value is NODEFAULT:
+            raise NameError(f"Variable {__name!r} is not defined in {self.ctx_name!r}.")
+
         dict.__delitem__(self, __name)
 
     @root_protection
-    def __setattr__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
+    def __setattr__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]) -> None:
         """Setting a context variable."""
         if is_dunder(__name):
             return object.__setattr__(self, __name, __value)
@@ -235,14 +332,12 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
     @property
     def ctx_name(self) -> str:
-        """Context name."""
-        return self.__ctx_name__ or "<Unnamed ctx at %#x>" % id(self)
+        """Global context name."""
+        return self.__ctx_name__ or "<Unnamed global context at %#x>" % id(self)
 
     @classmethod
     def is_root_attribute(cls, name: str) -> bool:
-        """Returns True if exists root attribute
-        otherwise False.
-        """
+        """Returns True if name is a root attribute."""
         return name in cls.__root_attributes__
 
     def set_context_variables(self, variables: typing.Mapping[str, CtxValueT | CtxVariable[CtxValueT]]) -> None:
@@ -314,11 +409,14 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         """Get context variable by name."""
         var_value_type = typing.Any if var_value_type is object else var_value_type
         generic_types = typing.get_args(get_orig_class(self))
+
         if generic_types and var_value_type is object:
             var_value_type = generic_types[0]
+
         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__,
@@ -350,6 +448,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.")
+
         del self[old_var_name]
         self[new_var_name] = var.value
         return Ok(_())
@@ -360,6 +459,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         """
         if not self:
             return
+
         if include_consts:
             logger.warning(
                 "Constants from the global context {!r} have been cleaned up!",
@@ -375,9 +475,11 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         """Delete context by `ctx_name`."""
         if not self.__ctx_name__:
             return Error("Cannot delete unnamed context.")
+
         ctx = self.__storage__.get(self.ctx_name).unwrap()
         dict.clear(ctx)
         self.__storage__.delete(self.ctx_name)
+
         logger.warning(f"Global context {self.ctx_name!r} has been deleted!")
         return Ok(_())
 
@@ -391,8 +493,5 @@ __all__ = (
     "RootAttr",
     "Storage",
     "ctx_var",
-    "get_orig_class",
-    "is_dunder",
-    "root_protection",
-    "type_check",
+    "runtime_init",
 )

telegrinder/tools/keyboard/__init__.py

@@ -0,0 +1,39 @@
+from telegrinder.tools.keyboard.base import ABCKeyboard, ABCStaticKeyboard, BaseKeyboard, BaseStaticKeyboard
+from telegrinder.tools.keyboard.buttons.base import (
+    BaseButton,
+    BaseStaticButton,
+)
+from telegrinder.tools.keyboard.buttons.buttons import (
+    Button,
+    InlineButton,
+)
+from telegrinder.tools.keyboard.buttons.static_buttons import (
+    StaticButton,
+    StaticInlineButton,
+)
+from telegrinder.tools.keyboard.buttons.tools import RowButtons
+from telegrinder.tools.keyboard.data import KeyboardModel
+from telegrinder.tools.keyboard.keyboard import InlineKeyboard, Keyboard
+from telegrinder.tools.keyboard.static_keyboard import (
+    StaticInlineKeyboard,
+    StaticKeyboard,
+)
+
+__all__ = (
+    "ABCKeyboard",
+    "ABCStaticKeyboard",
+    "BaseButton",
+    "BaseKeyboard",
+    "BaseStaticButton",
+    "BaseStaticKeyboard",
+    "Button",
+    "InlineButton",
+    "InlineKeyboard",
+    "Keyboard",
+    "KeyboardModel",
+    "RowButtons",
+    "StaticButton",
+    "StaticInlineButton",
+    "StaticInlineKeyboard",
+    "StaticKeyboard",
+)

telegrinder/tools/keyboard/abc.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import abc
+import typing
+
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.keyboard.buttons.base import BaseButton, BaseStaticButton
+from telegrinder.tools.keyboard.buttons.tools import RowButtons
+
+if typing.TYPE_CHECKING:
+    from telegrinder.types.objects import InlineKeyboardMarkup, ReplyKeyboardMarkup
+
+type DictStrAny = dict[str, typing.Any]
+type AnyMarkup = ReplyKeyboardMarkup | InlineKeyboardMarkup
+type RawKeyboard = list[list[DictStrAny]]
+type Button = DictStrAny | list[DictStrAny] | BaseButton | RowButtons[BaseButton]
+
+KEYBOARD_BUTTON_CLASS_KEY: typing.Final[str] = "_button_class"
+NO_VALUE: typing.Final[object] = object()
+
+
+def _has_under(name: str, /) -> bool:
+    return name.startswith("_")
+
+
+def _get_buttons(cls_: type[ABCStaticKeyboard], /) -> dict[str, BaseStaticButton]:
+    button_class = cls_.get_button_class()
+    return {k: v for k, v in dict(vars(cls_)).items() if isinstance(v, button_class)}
+
+
+def copy_keyboard(keyboard: RawKeyboard, /) -> RawKeyboard:
+    return [row.copy() for row in keyboard if row]
+
+
+class ABCKeyboard(abc.ABC):
+    keyboard: RawKeyboard
+
+    @abc.abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abc.abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+    @abc.abstractmethod
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        pass
+
+    def add(self, button: Button, /) -> typing.Self:
+        if not self.keyboard:
+            self.row()
+
+        if isinstance(button, RowButtons):
+            self.keyboard[-1].extend(button.get_data())
+            if button.auto_row:
+                self.row()
+            return self
+
+        if isinstance(button, list):
+            self.keyboard[-1].extend(button)
+            return self
+
+        self.keyboard[-1].append(button if isinstance(button, dict) else 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_text(self, **format_data: typing.Any) -> typing.Self:
+        copy_keyboard = self.copy()
+
+        for row in self.keyboard:
+            for button in row:
+                button["text"] = button["text"].format(**format_data)
+
+        return copy_keyboard
+
+    def merge(self, other: typing.Self, /) -> typing.Self:
+        self.keyboard.extend(copy_keyboard(other.keyboard))
+        return self
+
+    def merge_to_last_row(self, other: typing.Self, /) -> typing.Self:
+        kb_len = len(other.keyboard)
+
+        for index, row in enumerate(copy_keyboard(other.keyboard), start=1):
+            for button in row:
+                self.keyboard[-1].append(button)
+
+            if index < kb_len:
+                self.keyboard.append([])
+
+        return self
+
+
+class StaticKeyboardMeta(type):
+    if not typing.TYPE_CHECKING:
+
+        def __getattr__(cls, name, /):
+            if not _has_under(name):
+                buttons = _get_buttons(cls)
+                if name in buttons:
+                    return buttons[name]
+            return super().__getattribute__(name)
+
+    def __setattr__(cls, name: str, value: typing.Any, /) -> None:
+        if not _has_under(name) and name in _get_buttons(cls):  # type: ignore
+            raise AttributeError(f"Cannot reassing attribute {name!r}.")
+        return super().__setattr__(name, value)
+
+    def __delattr__(cls, name: str, /) -> None:
+        if not _has_under(name) and name in _get_buttons(cls):  # type: ignore
+            raise AttributeError(f"Cannot delete attribute {name!r}.")
+        return super().__delattr__(name)
+
+
+class ABCStaticKeyboardMeta(abc.ABCMeta, StaticKeyboardMeta):
+    pass
+
+
+class ABCStaticKeyboard(metaclass=ABCStaticKeyboardMeta):
+    __keyboard__: typing.Any
+
+    @abc.abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abc.abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+    @classmethod
+    def get_button_class(cls) -> type[BaseStaticButton]:
+        sentinel = object()
+        button_class = getattr(cls, KEYBOARD_BUTTON_CLASS_KEY, sentinel)
+
+        if button_class not in (sentinel, NO_VALUE):
+            return typing.cast("type[BaseStaticButton]", button_class)
+
+        if button_class is not NO_VALUE:
+            for obj in cls.__dict__.values():
+                if isinstance(obj, BaseStaticButton):
+                    button_class = type(obj)
+                    setattr(cls, KEYBOARD_BUTTON_CLASS_KEY, button_class)
+                    return button_class
+
+        setattr(cls, KEYBOARD_BUTTON_CLASS_KEY, NO_VALUE)
+        raise ValueError(f"Static keyboard {fullname(cls)!r} has no static buttons.")
+
+    @classmethod
+    def get_buttons(cls) -> dict[str, BaseStaticButton]:
+        return _get_buttons(cls)
+
+
+__all__ = ("ABCKeyboard", "ABCStaticKeyboard")

telegrinder/tools/keyboard/base.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import abc
+import typing
+
+from telegrinder.tools.keyboard.abc import ABCKeyboard, ABCStaticKeyboard, AnyMarkup, DictStrAny
+from telegrinder.tools.keyboard.buttons.base import BaseButton
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.buttons.base import BaseStaticButton
+
+KEYBOARD_BUTTONS_KEY: typing.Final[str] = "_buttons"
+NO_VALUE: typing.Final[object] = object()
+
+
+def _is_implemented[T: ABCKeyboard](
+    value: object,
+    kb_class: type[T],
+    /,
+) -> typing.TypeGuard[T | BaseButton]:
+    return isinstance(value, BaseButton | kb_class)
+
+
+class BaseKeyboard(ABCKeyboard, abc.ABC):
+    @abc.abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abc.abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+    @abc.abstractmethod
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        pass
+
+    def __and__(self, other: object, /) -> typing.Self:
+        if not _is_implemented(other, type(self)):
+            return NotImplemented
+        return self.add(other) if isinstance(other, BaseButton) else self.merge(other)
+
+    def __or__(self, other: object, /) -> typing.Self:
+        if not _is_implemented(other, type(self)):
+            return NotImplemented
+
+        kb = self.row()
+        return kb.add(other) if isinstance(other, BaseButton) else kb.merge_to_last_row(other)
+
+
+class BaseStaticKeyboard(ABCStaticKeyboard, abc.ABC):
+    __max_in_row__: int
+
+    @classmethod
+    def get_buttons(cls) -> dict[str, BaseStaticButton]:
+        if (buttons := cls._get_secret_value(KEYBOARD_BUTTONS_KEY)) is not NO_VALUE:
+            return buttons
+        return cls._set_secret_value(KEYBOARD_BUTTONS_KEY, super().get_buttons())
+
+    @classmethod
+    def _set_secret_value[V](cls, key: str, value: V, /) -> V:
+        setattr(cls, key, value)
+        return value
+
+    @classmethod
+    def _get_secret_value(cls, key: str, /) -> typing.Any:
+        return getattr(cls, key, NO_VALUE)
+
+    @abc.abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abc.abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+
+__all__ = ("BaseKeyboard", "BaseStaticKeyboard")

telegrinder/tools/keyboard/buttons/__init__.py

@@ -0,0 +1,14 @@
+from telegrinder.tools.keyboard.buttons.base import BaseButton, BaseStaticButton
+from telegrinder.tools.keyboard.buttons.buttons import Button, InlineButton
+from telegrinder.tools.keyboard.buttons.static_buttons import StaticButton, StaticInlineButton
+from telegrinder.tools.keyboard.buttons.tools import RowButtons
+
+__all__ = (
+    "BaseButton",
+    "BaseStaticButton",
+    "Button",
+    "InlineButton",
+    "RowButtons",
+    "StaticButton",
+    "StaticInlineButton",
+)

telegrinder/tools/keyboard/buttons/base.py

@@ -0,0 +1,18 @@
+import dataclasses
+import typing
+
+from telegrinder.tools.fullname import fullname
+
+
+class BaseButton:
+    def get_data(self) -> dict[str, typing.Any]:
+        assert dataclasses.is_dataclass(self), f"{fullname(self)} is not a dataclass."
+        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None}
+
+
+@dataclasses.dataclass(kw_only=True)
+class BaseStaticButton(BaseButton):
+    row: bool = dataclasses.field(default=False, repr=False)
+
+
+__all__ = ("BaseButton", "BaseStaticButton")