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

telegrinder/tools/{buttons.py → keyboard/buttons/buttons.py}

@@ -1,9 +1,14 @@
+from __future__ import annotations
+
 import dataclasses
+import types
 import typing
 
 import msgspec
 
 from telegrinder.msgspec_utils import encoder
+from telegrinder.tools.callback_data_serialization import ABCDataSerializer, JSONSerializer
+from telegrinder.tools.keyboard.buttons.base import BaseButton
 from telegrinder.types.objects import (
     CallbackGame,
     CopyTextButton,
@@ -15,34 +20,70 @@ from telegrinder.types.objects import (
     WebAppInfo,
 )
 
-from .callback_data_serilization import ABCDataSerializer, JSONSerializer
-
 if typing.TYPE_CHECKING:
     from _typeshed import DataclassInstance
 
+    from telegrinder.tools.keyboard.abc import ABCKeyboard
+    from telegrinder.tools.keyboard.keyboard import InlineKeyboard, Keyboard
+
 type CallbackData = str | bytes | dict[str, typing.Any] | DataclassInstance | msgspec.Struct
 
 
-@dataclasses.dataclass
-class BaseButton:
-    def get_data(self) -> dict[str, typing.Any]:
-        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None}
+def _get_keyboard_class(name: str, /) -> type[ABCKeyboard]:
+    from telegrinder.tools.keyboard.keyboard import InlineKeyboard, Keyboard  # noqa
+
+    return locals()[name]
+
+
+def _magic_keyboard(
+    name_keyboard: str,
+    button: BaseButton,
+    other: typing.Any,
+    /,
+    *,
+    row: bool = False,
+) -> ABCKeyboard | types.NotImplementedType:
+    keyboard_type: type[typing.Any] = _get_keyboard_class(name_keyboard)
+    if not isinstance(other, keyboard_type | type(button)):
+        return NotImplemented
+
+    keyboard: ABCKeyboard = keyboard_type().add(button)
+    if row:
+        keyboard = keyboard.row()
 
+    return keyboard.merge_to_last_row(other) if isinstance(other, keyboard_type) else keyboard.add(other)
 
-class RowButtons[KeyboardButton: BaseButton]:
-    buttons: list[KeyboardButton]
-    auto_row: bool
 
-    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
-        self.buttons = list(buttons)
-        self.auto_row = auto_row
+class ConvertButtonMixin[T: ABCKeyboard]:
+    if typing.TYPE_CHECKING:
+        as_keyboard: type[T]
+    else:
+        KEYBOARD_CLASS_KEY = "__keyboard_class__"
 
-    def get_data(self) -> list[dict[str, typing.Any]]:
-        return [b.get_data() for b in self.buttons]
+        @classmethod
+        def get_keyboard_class(cls):
+            if (kb_cls := getattr(cls, cls.KEYBOARD_CLASS_KEY, None)) is not None:
+                return kb_cls
+
+            arg = None
+            for base in cls.__orig_bases__:
+                origin = typing.get_origin(base) or base
+                if issubclass(origin, ConvertButtonMixin):
+                    arg = typing.get_origin(arg := typing.get_args(base)[0]) or arg
+
+            assert arg is not None
+            kb_cls_name = arg.__forward_arg__ if isinstance(arg, typing.ForwardRef) else arg.__name__
+            kb_cls = _get_keyboard_class(kb_cls_name)
+            setattr(cls, cls.KEYBOARD_CLASS_KEY, kb_cls)
+            return kb_cls
+
+        def as_keyboard(self, *args, **kwargs):
+            keyboard = self.get_keyboard_class()(*args, **kwargs)
+            return keyboard.add(self)
 
 
 @dataclasses.dataclass
-class Button(BaseButton):
+class Button(BaseButton, ConvertButtonMixin["Keyboard"]):
     text: str
     request_contact: bool = dataclasses.field(default=False, kw_only=True)
     request_location: bool = dataclasses.field(default=False, kw_only=True)
@@ -57,9 +98,15 @@ class Button(BaseButton):
     )
     web_app: WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
+    def __and__(self, other: object, /) -> Keyboard:
+        return _magic_keyboard("Keyboard", self, other)
+
+    def __or__(self, other: object, /) -> Keyboard:
+        return _magic_keyboard("Keyboard", self, other, row=True)
+
 
 @dataclasses.dataclass
-class InlineButton(BaseButton):
+class InlineButton(BaseButton, ConvertButtonMixin["InlineKeyboard"]):
     text: str
     url: str | None = dataclasses.field(default=None, kw_only=True)
     login_url: LoginUrl | None = dataclasses.field(default=None, kw_only=True)
@@ -86,7 +133,7 @@ class InlineButton(BaseButton):
             or dataclasses.is_dataclass(self.callback_data)
         ):
             callback_data_serializer = callback_data_serializer or JSONSerializer(
-                self.callback_data.__class__,
+                type(self.callback_data),
             )
 
         if callback_data_serializer is not None:
@@ -100,10 +147,11 @@ class InlineButton(BaseButton):
         if isinstance(self.web_app, str):
             self.web_app = WebAppInfo(url=self.web_app)
 
+    def __and__(self, other: object, /) -> InlineKeyboard:
+        return _magic_keyboard("InlineKeyboard", self, other)
 
-__all__ = (
-    "BaseButton",
-    "Button",
-    "InlineButton",
-    "RowButtons",
-)
+    def __or__(self, other: object, /) -> InlineKeyboard:
+        return _magic_keyboard("InlineKeyboard", self, other, row=True)
+
+
+__all__ = ("Button", "InlineButton")

telegrinder/tools/keyboard/buttons/static_buttons.py

@@ -0,0 +1,56 @@
+import dataclasses
+import types
+import typing
+
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.bot.rules.payload import PayloadJsonEqRule, PayloadMarkupRule, PayloadModelRule
+from telegrinder.bot.rules.text import Text
+from telegrinder.tools.callback_data_serialization import ABCDataSerializer
+from telegrinder.tools.keyboard.buttons.base import BaseStaticButton
+from telegrinder.tools.keyboard.buttons.buttons import Button, InlineButton
+
+
+@dataclasses.dataclass
+class StaticButtonMixin(BaseStaticButton):
+    __and__: typing.ClassVar[None] = None
+    __or__: typing.ClassVar[None] = None
+
+
+@dataclasses.dataclass
+class StaticButton(StaticButtonMixin, Button, Text):
+    if not typing.TYPE_CHECKING:
+
+        def __init__(self, text, **kwargs):
+            self.row = kwargs.pop("row", False)
+            Button.__init__(self, text=text, **kwargs)
+            Text.__init__(self, text)
+
+
+@dataclasses.dataclass
+class StaticInlineButton(StaticButtonMixin, InlineButton, ABCRule):
+    if not typing.TYPE_CHECKING:
+
+        def __init__(self, *args, **kwargs):
+            self.row = kwargs.pop("row", False)
+            InlineButton.__init__(self, *args, **kwargs)
+
+        check = lambda self, *args, **kwargs: False
+    else:
+
+        def check(self, *args: typing.Any, **kwargs: typing.Any) -> bool: ...
+
+    def __post_init__(self, callback_data_serializer: ABCDataSerializer[typing.Any] | None) -> None:
+        if isinstance(self.callback_data, str):
+            self.check = PayloadMarkupRule(self.callback_data).check
+        elif isinstance(self.callback_data, dict):
+            self.check = PayloadJsonEqRule(self.callback_data).check
+        elif not isinstance(self.callback_data, (bytes, types.NoneType)):
+            self.check = PayloadModelRule(
+                type(self.callback_data),
+                serializer=type(callback_data_serializer) if callback_data_serializer else None,
+            ).check
+
+        super().__post_init__(callback_data_serializer)
+
+
+__all__ = ("StaticButton", "StaticInlineButton")

telegrinder/tools/keyboard/buttons/tools.py

@@ -0,0 +1,18 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.buttons.base import BaseButton
+
+
+class RowButtons[KeyboardButton: BaseButton]:
+    buttons: typing.Iterable[KeyboardButton]
+
+    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
+        self.buttons = buttons
+        self.auto_row = auto_row
+
+    def get_data(self) -> list[dict[str, typing.Any]]:
+        return [b.get_data() for b in self.buttons]
+
+
+__all__ = ("RowButtons",)

telegrinder/tools/keyboard/data.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.abc import DictStrAny
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class KeyboardModel:
+    keyboard: typing.Iterable[typing.Iterable[DictStrAny]] = dataclasses.field(default_factory=lambda: [[]])
+    resize_keyboard: bool = dataclasses.field(default=True)
+    one_time_keyboard: bool = dataclasses.field(default=False)
+    selective: bool = dataclasses.field(default=False)
+    is_persistent: bool = dataclasses.field(default=False)
+    input_field_placeholder: str | None = dataclasses.field(default=None)
+
+
+__all__ = ("KeyboardModel",)

telegrinder/tools/keyboard/keyboard.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+from copy import deepcopy
+
+from telegrinder.tools.keyboard.base import BaseKeyboard, DictStrAny
+from telegrinder.tools.keyboard.data import KeyboardModel
+from telegrinder.types.objects import (
+    InlineKeyboardMarkup,
+    ReplyKeyboardMarkup,
+    ReplyKeyboardRemove,
+)
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.abc import RawKeyboard
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class KeyboardModelMixin(KeyboardModel if typing.TYPE_CHECKING else object):
+    keyboard_model: KeyboardModel = dataclasses.field(init=False)
+
+    if not typing.TYPE_CHECKING:
+        keyboard_model = dataclasses.field(
+            default_factory=lambda: KeyboardModel(keyboard=[[]]),
+            repr=False,
+        )
+
+    @property
+    def keyboard(self) -> RawKeyboard:
+        return self.keyboard_model.keyboard  # type: ignore
+
+    @property
+    def is_persistent(self) -> bool:
+        return self.keyboard_model.is_persistent
+
+    @property
+    def one_time_keyboard(self) -> bool:
+        return self.keyboard_model.one_time_keyboard
+
+    @property
+    def resize_keyboard(self) -> bool:
+        return self.keyboard_model.resize_keyboard
+
+    @property
+    def is_selective(self) -> bool:
+        return self.keyboard_model.selective
+
+    @property
+    def input_field_placeholder(self) -> str | None:
+        return self.keyboard_model.input_field_placeholder
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class Keyboard(KeyboardModelMixin, BaseKeyboard):
+    if not typing.TYPE_CHECKING:
+
+        def __init__(self, **kwargs):
+            super().__init__(keyboard_model=kwargs.pop("keyboard_model", None) or KeyboardModel(**kwargs))
+
+    def dict(self) -> DictStrAny:
+        return dataclasses.asdict(self.keyboard_model) | {"keyboard": [row for row in self.keyboard if row]}
+
+    def get_markup(self) -> ReplyKeyboardMarkup:
+        return ReplyKeyboardMarkup.from_dict(self.dict())
+
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        return dataclasses.replace(
+            self,
+            keyboard_model=dataclasses.replace(
+                self.keyboard_model,
+                keyboard=deepcopy(self.keyboard_model.keyboard),
+                **with_changes,
+            ),
+        )
+
+    def get_keyboard_remove(self) -> ReplyKeyboardRemove:
+        return ReplyKeyboardRemove.from_data(
+            remove_keyboard=True,
+            selective=self.keyboard_model.selective,
+        )
+
+    def resize(self) -> typing.Self:
+        return self.copy(resize_keyboard=True)
+
+    def one_time(self) -> typing.Self:
+        return self.copy(one_time_keyboard=True)
+
+    def selective(self) -> typing.Self:
+        return self.copy(selective=True)
+
+    def persistent(self) -> typing.Self:
+        return self.copy(is_persistent=True)
+
+    def no_resize(self) -> typing.Self:
+        return self.copy(resize_keyboard=False)
+
+    def no_one_time(self) -> typing.Self:
+        return self.copy(one_time_keyboard=False)
+
+    def no_selective(self) -> typing.Self:
+        return self.copy(selective=False)
+
+    def no_persistent(self) -> typing.Self:
+        return self.copy(is_persistent=False)
+
+    def placeholder(self, value: str | None, /) -> typing.Self:
+        return self.copy(input_field_placeholder=value)
+
+
+@dataclasses.dataclass(frozen=True)
+class InlineKeyboard(BaseKeyboard):
+    keyboard: RawKeyboard = dataclasses.field(init=False)
+
+    if not typing.TYPE_CHECKING:
+        keyboard = dataclasses.field(
+            default_factory=lambda: [[]],
+            repr=False,
+        )
+
+    def dict(self) -> DictStrAny:
+        return dict(inline_keyboard=[row for row in self.keyboard if row])
+
+    def get_markup(self) -> InlineKeyboardMarkup:
+        return InlineKeyboardMarkup.from_dict(self.dict())
+
+    def copy(self, **_: typing.Any) -> typing.Self:
+        return dataclasses.replace(self, keyboard=deepcopy(self.keyboard))
+
+
+__all__ = ("InlineKeyboard", "Keyboard")

telegrinder/tools/keyboard/static_keyboard.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+
+from telegrinder.tools.keyboard.abc import DictStrAny
+from telegrinder.tools.keyboard.base import BaseStaticKeyboard
+from telegrinder.tools.keyboard.data import KeyboardModel
+from telegrinder.types.objects import InlineKeyboardMarkup, ReplyKeyboardMarkup, ReplyKeyboardRemove
+
+type RawKeyboard = typing.Iterable[typing.Iterable[DictStrAny]]
+
+
+def create_keyboard(cls_: type[BaseStaticKeyboard], /) -> RawKeyboard:
+    buttons = cls_.get_buttons()
+    max_in_row = cls_.__max_in_row__
+    keyboard = [[]]
+
+    for button in buttons.values():
+        keyboard[-1].append(button.get_data())
+
+        if (button.row is True or len(keyboard[-1]) >= max_in_row) and keyboard[-1]:
+            keyboard.append([])
+
+    return tuple(tuple(x) for x in keyboard if x)
+
+
+class StaticKeyboard(BaseStaticKeyboard):
+    __keyboard__: KeyboardModel
+
+    def __init_subclass__(
+        cls,
+        *,
+        resize_keyboard: bool = True,
+        one_time_keyboard: bool = False,
+        selective: bool = False,
+        is_persistent: bool = False,
+        input_field_placeholder: str | None = None,
+        max_in_row: int = 3,
+    ) -> None:
+        cls.__max_in_row__ = max_in_row
+        cls.__keyboard__ = KeyboardModel(
+            keyboard=create_keyboard(cls),
+            resize_keyboard=resize_keyboard,
+            one_time_keyboard=one_time_keyboard,
+            selective=selective,
+            is_persistent=is_persistent,
+            input_field_placeholder=input_field_placeholder,
+        )
+
+    @classmethod
+    def dict(cls) -> DictStrAny:
+        return dataclasses.asdict(cls.__keyboard__)
+
+    @classmethod
+    def get_markup(cls) -> ReplyKeyboardMarkup:
+        return ReplyKeyboardMarkup.from_dict(cls.dict())
+
+    @classmethod
+    def get_keyboard_remove(cls) -> ReplyKeyboardRemove:
+        return ReplyKeyboardRemove.from_data(
+            remove_keyboard=True,
+            selective=cls.__keyboard__.selective,
+        )
+
+
+class StaticInlineKeyboard(BaseStaticKeyboard):
+    __keyboard__: RawKeyboard
+
+    def __init_subclass__(cls, *, max_in_row: int = 3) -> None:
+        cls.__max_in_row__ = max_in_row
+        cls.__keyboard__ = create_keyboard(cls)
+
+    @classmethod
+    def dict(cls) -> DictStrAny:
+        return dict(inline_keyboard=cls.__keyboard__)
+
+    @classmethod
+    def get_markup(cls) -> InlineKeyboardMarkup:
+        return InlineKeyboardMarkup.from_dict(cls.dict())
+
+
+__all__ = ("StaticInlineKeyboard", "StaticKeyboard")

telegrinder/tools/lifespan.py

@@ -3,20 +3,15 @@ import dataclasses
 import datetime
 import typing
 
+from telegrinder.modules import logger
+from telegrinder.tools.aio import run_task
+from telegrinder.tools.fullname import fullname
+
 type CoroutineTask[T] = typing.Coroutine[typing.Any, typing.Any, T]
 type CoroutineFunc[**P, T] = typing.Callable[P, CoroutineTask[T]]
 type Task[**P, T] = CoroutineFunc[P, T] | CoroutineTask[T] | DelayedTask[typing.Callable[P, CoroutineTask[T]]]
 
 
-def run_tasks(
-    tasks: list[CoroutineTask[typing.Any]],
-    /,
-) -> None:
-    loop = asyncio.get_event_loop()
-    while tasks:
-        loop.run_until_complete(tasks.pop(0))
-
-
 def to_coroutine_task[**P, T](task: Task[P, T], /) -> CoroutineTask[T]:
     if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
         task = task()
@@ -25,12 +20,17 @@ def to_coroutine_task[**P, T](task: Task[P, T], /) -> CoroutineTask[T]:
     return task
 
 
-@dataclasses.dataclass(slots=True)
-class DelayedTask[Handler: CoroutineFunc[..., typing.Any]]:
-    handler: Handler
+@dataclasses.dataclass
+class DelayedTask[Function: CoroutineFunc[..., typing.Any]]:
+    _cancelled: bool = dataclasses.field(default=False, init=False, repr=False)
+    _task: asyncio.Task[typing.Any] | None = dataclasses.field(default=None, init=False, repr=False)
+
+    function: Function
     seconds: float | datetime.timedelta
     repeat: bool = dataclasses.field(default=False, kw_only=True)
-    _cancelled: bool = dataclasses.field(default=False, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self.function.cancel = self.cancel
 
     @property
     def is_cancelled(self) -> bool:
@@ -38,68 +38,104 @@ class DelayedTask[Handler: CoroutineFunc[..., typing.Any]]:
 
     @property
     def delay(self) -> float:
-        return self.seconds if isinstance(self.seconds, int | float) else self.seconds.total_seconds()
+        return float(self.seconds) if isinstance(self.seconds, int | float) else self.seconds.total_seconds()
 
     async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
-        while not self.is_cancelled:
+        self._task = self._task or asyncio.current_task()
+        stopped = False
+
+        while not self._cancelled and not stopped:
             await asyncio.sleep(self.delay)
-            if self.is_cancelled:
-                break
             try:
-                await self.handler(*args, **kwargs)
+                await self.function(*args, **kwargs)
+            except BaseException:
+                logger.exception(
+                    "Delayed task for function `{}` caught an exception, traceback message below:",
+                    fullname(self.function),
+                )
             finally:
-                if not self.repeat:
-                    break
+                stopped = not self.repeat
 
-    def cancel(self) -> None:
+    def cancel(self) -> bool:
         if not self._cancelled:
-            self._cancelled = True
+            self._cancelled = True if self._task is None else self._task.cancel()
+            self._task = None
+
+        return self._cancelled
 
 
-@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+@dataclasses.dataclass(kw_only=True, slots=True, repr=False)
 class Lifespan:
+    _started: bool = dataclasses.field(default=False, init=False)
     startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
     shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
 
-    def on_startup[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
-        self.startup_tasks.append(to_coroutine_task(task))
-        return task
+    def __repr__(self) -> str:
+        return "<{}: started={}>".format(fullname(self), self._started)
 
-    def on_shutdown[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
-        self.shutdown_tasks.append(to_coroutine_task(task))
-        return task
+    def __add__(self, other: object, /) -> typing.Self:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
 
-    def start(self) -> None:
-        run_tasks(self.startup_tasks)
+        return self.__class__(
+            startup_tasks=self.startup_tasks + other.startup_tasks,
+            shutdown_tasks=self.shutdown_tasks + other.shutdown_tasks,
+        )
 
-    def shutdown(self) -> None:
-        run_tasks(self.shutdown_tasks)
+    def __iadd__(self, other: object, /) -> typing.Self:
+        if not isinstance(other, self.__class__):
+            return NotImplemented
+
+        self.startup_tasks.extend(other.startup_tasks)
+        self.shutdown_tasks.extend(other.shutdown_tasks)
+        return self
 
     def __enter__(self) -> None:
         self.start()
 
-    def __exit__(self) -> None:
+    def __exit__(self, *args: typing.Any) -> None:
         self.shutdown()
 
     async def __aenter__(self) -> None:
-        for task in self.startup_tasks:
-            await task
+        await self._start()
 
-    async def __aexit__(self, *args) -> None:
-        for task in self.shutdown_tasks:
-            await task
+    async def __aexit__(self, *args: typing.Any) -> None:
+        await self._shutdown()
 
-    def __add__(self, other: typing.Self, /) -> typing.Self:
-        return self.__class__(
-            startup_tasks=self.startup_tasks + other.startup_tasks,
-            shutdown_tasks=self.shutdown_tasks + other.shutdown_tasks,
-        )
+    @property
+    def started(self) -> bool:
+        return self._started
+
+    @staticmethod
+    async def _run_tasks(tasks: list[CoroutineTask[typing.Any]], /) -> None:
+        while tasks:
+            await tasks.pop(0)
+
+    async def _start(self) -> None:
+        if not self._started:
+            logger.debug("Running lifespan startup tasks")
+            self._started = True
+            await self._run_tasks(self.startup_tasks)
+
+    async def _shutdown(self) -> None:
+        if self._started:
+            logger.debug("Running lifespan shutdown tasks")
+            self._started = False
+            await self._run_tasks(self.shutdown_tasks)
+
+    def start(self) -> None:
+        run_task(self._start())
+
+    def shutdown(self) -> None:
+        run_task(self._shutdown())
+
+    def on_startup[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
+        self.startup_tasks.append(to_coroutine_task(task))
+        return task
+
+    def on_shutdown[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
+        self.shutdown_tasks.append(to_coroutine_task(task))
+        return task
 
 
-__all__ = (
-    "CoroutineTask",
-    "DelayedTask",
-    "Lifespan",
-    "run_tasks",
-    "to_coroutine_task",
-)
+__all__ = ("CoroutineTask", "DelayedTask", "Lifespan", "run_task", "to_coroutine_task")

telegrinder/tools/limited_dict.py

@@ -13,17 +13,20 @@ class LimitedDict[Key, Value](UserDict[Key, Value]):
         was reached, otherwise None.
         """
         deleted_item = None
+
         if len(self.queue) >= self.maxlimit:
             deleted_item = self.pop(self.queue.popleft(), None)
+
         if key not in self.queue:
             self.queue.append(key)
+
         super().__setitem__(key, value)
         return deleted_item
 
     def __setitem__(self, key: Key, value: Value, /) -> None:
         self.set(key, value)
 
-    def __delitem__(self, key: Key) -> None:
+    def __delitem__(self, key: Key, /) -> None:
         if key in self.queue:
             self.queue.remove(key)
         return super().__delitem__(key)