telegrinder 0.1.dev164__tar.gz → 0.1.dev165__tar.gz

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev164
+Version: 0.1.dev165
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev164"
+version = "0.1.dev165"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/__init__.py

@@ -1,3 +1,37 @@
+"""Telegrinder
+
+Framework for effective and reliable telegram bot building.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on msgspec
+* Both low-level and high-level API
+
+Basic example:
+
+```python
+from telegrinder import API, Message, Telegrinder, Token
+from telegrinder.modules import logger
+from telegrinder.rules import Text
+
+api = API(token=Token("123:token"))
+bot = Telegrinder(api)
+logger.set_level("INFO")
+
+
+@bot.on.message(Text("/start"))
+async def start(message: Message):
+    me = (await api.get_me()).unwrap()
+    await message.answer(
+        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
+    )
+
+
+bot.run_forever()
+```
+"""
+
 import typing
 
 from .api import ABCAPI, API, APIError, APIResponse, Token
@@ -58,6 +92,7 @@ from .tools import (
     Keyboard,
     KeyboardSetBase,
     KeyboardSetYAML,
+    Lifespan,
     LoopWrapper,
     ParseMode,
     RowButtons,
@@ -123,6 +158,7 @@ __all__ = (
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
+    "Lifespan",
     "LoopWrapper",
     "Message",
     "MessageCute",

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/bot/bot.py

@@ -24,6 +24,15 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         self.dispatch = typing.cast(DispatchT, dispatch or Dispatch())
         self.polling = typing.cast(PollingT, polling or Polling(api))
         self.loop_wrapper = typing.cast(LoopWrapperT, loop_wrapper or LoopWrapper())
+    
+    def __repr__(self) -> str:
+        return "<{}: api={!r}, dispatch={!r}, polling={!r}, loop_wrapper={!r}>".format(
+            self.__class__.__name__,
+            self.api,
+            self.dispatch,
+            self.polling,
+            self.loop_wrapper,
+        )
 
     @property
     def on(self) -> DispatchT:

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/bot/cute_types/message.py

@@ -80,7 +80,7 @@ async def execute_method_answer(
         params["link_preview_options"] = compose_link_preview_options(
             **link_preview_options
         )
-
+        
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
         lambda x: (

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/bot/dispatch/return_manager/abc.py

@@ -43,6 +43,12 @@ class ABCReturnManager(ABC, typing.Generic[EventT]):
 
 
 class BaseReturnManager(ABCReturnManager[EventT]):
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
+        )
+
     @property
     def managers(self) -> list[Manager]:
         return [

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/bot/polling/polling.py

@@ -33,6 +33,20 @@ class Polling(ABCPolling):
         self.max_reconnetions = 10 if max_reconnetions < 0 else max_reconnetions
         self.offset = offset
         self._stop = False
+    
+    def __repr__(self) -> str:
+        return (
+            "<{}: with api={!r}, stopped={}, offset={}, allowed_updates={!r}, "
+            "max_reconnetions={}, reconnection_timeout={}>"
+        ).format(
+            self.__class__.__name__,
+            self.api,
+            self._stop,
+            self.offset,
+            self.allowed_updates,
+            self.max_reconnetions,
+            self.reconnection_timeout,
+        )
 
     def get_allowed_updates(
         self,

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/bot/rules/markup.py

@@ -24,7 +24,7 @@ def check_string(patterns: list[vbml.Pattern], s: str, ctx: Context) -> bool:
 
 
 class Markup(TextMessageRule):
-    def __init__(self, patterns: PatternLike | list[PatternLike]):
+    def __init__(self, patterns: PatternLike | list[PatternLike], /):
         if not isinstance(patterns, list):
             patterns = [patterns]
         self.patterns = [

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/model.py

@@ -57,6 +57,10 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
 
 
 class Model(msgspec.Struct, **MODEL_CONFIG):
+    @classmethod
+    def from_bytes(cls, data: bytes) -> typing.Self:
+        return decoder.decode(data, type=cls)
+
     def to_dict(
         self,
         *,
@@ -76,6 +80,12 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
 class DataConverter:
     files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
 
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.converters),
+        )
+
     @property
     def converters(self) -> dict[type[typing.Any], typing.Callable[..., typing.Any]]:
         return {

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/msgspec_utils.py

@@ -51,8 +51,7 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.Validation
 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]
+    value_type, = typing.get_args(tp) or (typing.Any,)
     return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
 
 
@@ -123,6 +122,12 @@ class Decoder:
             Variative: variative_dec_hook,
             datetime: lambda t, obj: t.fromtimestamp(obj),
         }
+    
+    def __repr__(self) -> str:
+        return "<{}: dec_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.dec_hooks,
+        )
 
     def add_dec_hook(self, t: T):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
@@ -216,6 +221,12 @@ class Encoder:
             datetime: lambda date: int(date.timestamp()),
         }
 
+    def __repr__(self) -> str:
+        return "<{}: enc_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.enc_hooks,
+        )
+
     def add_dec_hook(self, t: type[T]):
         def decorator(func: EncHook[T]) -> EncHook[T]:
             encode_hook = self.enc_hooks.setdefault(get_origin(t), func)

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/node/composer.py

@@ -27,7 +27,7 @@ class NodeSession:
             self.generator = None
 
     def __repr__(self) -> str:
-        return f"<NodeSession: {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
 
 
 class NodeCollection:

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/tools/__init__.py

@@ -66,7 +66,7 @@ from .keyboard import (
     Keyboard,
     RowButtons,
 )
-from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
 from .magic import magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
 
@@ -99,6 +99,7 @@ __all__ = (
     "KeyboardSetBase",
     "KeyboardSetYAML",
     "Link",
+    "Lifespan",
     "LoopWrapper",
     "Mention",
     "ParseMode",

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/tools/formatting/html.py

@@ -200,11 +200,8 @@ def bold(string: str) -> TagFormat:
     return TagFormat(string, tag="b")
 
 
-def channel_boost_link(channel_username: str, string: str | None = None):
-    return link(
-        get_channel_boost_link(channel_username),
-        string or f"t.me/{channel_username}?boost",
-    )
+def channel_boost_link(channel_id: str | int, string: str | None = None):
+    return link(get_channel_boost_link(channel_id), string)
 
 
 def code_inline(string: str) -> TagFormat:
@@ -234,15 +231,12 @@ def spoiler(string: str) -> TagFormat:
     return TagFormat(string, tag="tg-spoiler")
 
 
-def start_bot_link(bot_username: str, data: str, string: str | None = None) -> TagFormat:
-    return link(
-        get_start_bot_link(bot_username, data),
-        string or f"t.me/{bot_username}?start={data}"
-    )
+def start_bot_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
+    return link(get_start_bot_link(bot_id, data), string)
 
 
-def start_group_link(bot_username: str, data: str, string: str | None = None) -> TagFormat:
-    return link(get_start_group_link(bot_username, data), string)
+def start_group_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
+    return link(get_start_group_link(bot_id, data), string)
 
 
 def strike(string: str) -> TagFormat:

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/tools/formatting/links.py

@@ -6,16 +6,22 @@ def get_resolve_domain_link(username: str) -> str:
     return f"tg://resolve?domain={username}"
 
 
-def get_start_bot_link(bot_username: str, data: str) -> str:
-    return get_resolve_domain_link(bot_username) + f"&start={data}"
+def get_start_bot_link(bot_id: str | int, data: str) -> str:
+    if isinstance(bot_id, int):
+        return get_mention_link(bot_id) + f"&start={data}"
+    return get_resolve_domain_link(bot_id) + f"&start={data}"
 
 
-def get_start_group_link(bot_username: str, data: str) -> str:
-    return get_resolve_domain_link(bot_username) + f"&startgroup={data}"
+def get_start_group_link(bot_id: str | int, data: str) -> str:
+    if isinstance(bot_id, int):
+        return get_mention_link(bot_id) + f"&startgroup={data}"
+    return get_resolve_domain_link(bot_id) + f"&startgroup={data}"
 
 
-def get_channel_boost_link(channel_username: str) -> str:
-    return get_resolve_domain_link(channel_username) + "&boost"
+def get_channel_boost_link(channel_id: str | int) -> str:
+    if isinstance(channel_id, int):
+        return get_mention_link(channel_id) + "&boost"
+    return get_resolve_domain_link(channel_id) + "&boost"
 
 
 def get_invite_chat_link(invite_link: str) -> str:

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/tools/formatting/spec_html_formats.py

@@ -3,14 +3,13 @@ import typing
 
 from telegrinder.types.enums import ProgrammingLanguage
 
-SpecialFormat = typing.Union[
+SpecialFormat: typing.TypeAlias = typing.Union[
     "ChannelBoostLink",
     "InviteChatLink",
     "Link",
     "Mention",
     "PreCode",
     "ResolveDomain",
-    "SpecialFormat",
     "StartBotLink",
     "StartGroupLink",
     "TgEmoji",
@@ -38,7 +37,7 @@ class BaseSpecFormat:
 class ChannelBoostLink(BaseSpecFormat):
     __formatter_name__ = "channel_boost_link"
 
-    channel_username: str
+    channel_id: str | int
     string: str | None = None
 
 
@@ -86,7 +85,7 @@ class TgEmoji(BaseSpecFormat):
 class StartBotLink(BaseSpecFormat):
     __formatter_name__ = "start_bot_link"
 
-    bot_username: str
+    bot_id: str | int
     data: str
     string: str | None
 
@@ -95,7 +94,7 @@ class StartBotLink(BaseSpecFormat):
 class StartGroupLink(BaseSpecFormat):
     __formatter_name__ = "start_group_link"
 
-    bot_username: str
+    bot_id: str | int
     data: str
     string: str | None = None
 

{telegrinder-0.1.dev164 → telegrinder-0.1.dev165}/telegrinder/tools/global_context/global_context.py

@@ -199,8 +199,8 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
             self.set_context_variables(variables)
 
     def __repr__(self) -> str:
-        return "<{!r} -> ({})>".format(
-            f"{self.__class__.__name__}@{self.ctx_name}",
+        return "<{} -> ({})>".format(
+            f"{self.__class__.__name__}@{self.ctx_name!r}",
             ", ".join(repr(var) for var in self),
         )
 

telegrinder-0.1.dev165/telegrinder/tools/loop_wrapper/__init__.py

@@ -0,0 +1,4 @@
+from .abc import ABCLoopWrapper
+from .loop_wrapper import DelayedTask, Lifespan, LoopWrapper
+
+__all__ = ("ABCLoopWrapper", "DelayedTask", "Lifespan", "LoopWrapper")

telegrinder-0.1.dev165/telegrinder/tools/loop_wrapper/abc.py

@@ -0,0 +1,15 @@
+import typing
+from abc import ABC, abstractmethod
+
+
+class ABCLoopWrapper(ABC):
+    @abstractmethod
+    def add_task(self, task: typing.Any) -> None:
+        pass
+
+    @abstractmethod
+    def run_event_loop(self) -> None:
+        pass
+
+
+__all__ = ("ABCLoopWrapper",)

telegrinder-0.1.dev165/telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -0,0 +1,178 @@
+import asyncio
+import contextlib
+import dataclasses
+import typing
+
+from telegrinder.modules import logger
+
+from .abc import ABCLoopWrapper
+
+T = typing.TypeVar("T")
+P = typing.ParamSpec("P")
+CoroFunc = typing.TypeVar("CoroFunc", bound="CoroutineFunc")
+
+CoroutineTask: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, T]
+CoroutineFunc: typing.TypeAlias = typing.Callable[P, CoroutineTask[T]]
+Task: typing.TypeAlias = typing.Union[CoroutineFunc, CoroutineTask, "DelayedTask"]
+
+
+def run_tasks(tasks: list[CoroutineTask[typing.Any]], loop: asyncio.AbstractEventLoop) -> None:
+    while len(tasks) != 0:
+        loop.run_until_complete(tasks.pop(0))
+
+
+def to_coroutine_task(task: Task) -> CoroutineTask:
+    if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
+        task = task()
+    elif not asyncio.iscoroutine(task):
+        raise TypeError("Task should be coroutine or coroutine function.")   
+    return task     
+
+
+@dataclasses.dataclass
+class DelayedTask(typing.Generic[CoroFunc]):
+    handler: CoroFunc
+    seconds: float
+    repeat: bool = dataclasses.field(default=False, kw_only=True)
+    _cancelled: bool = dataclasses.field(default=False, init=False, repr=False)
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._cancelled
+
+    async def __call__(self, *args, **kwargs) -> None:
+        while not self.is_cancelled:
+            await asyncio.sleep(self.seconds)
+            if self.is_cancelled:
+                break
+            await self.handler(*args, **kwargs)
+            if not self.repeat:
+                break
+
+    def cancel(self) -> None:
+        if not self._cancelled:
+            self._cancelled = True
+
+
+@dataclasses.dataclass(kw_only=True)
+class Lifespan:
+    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(self, task_or_func: Task) -> Task:
+        task_or_func = to_coroutine_task(task_or_func)
+        self.startup_tasks.append(task_or_func)
+        return task_or_func
+    
+    def on_shutdown(self, task_or_func: Task) -> Task:
+        task_or_func = to_coroutine_task(task_or_func)
+        self.shutdown_tasks.append(task_or_func)
+        return task_or_func
+    
+    def start(self, loop: asyncio.AbstractEventLoop) -> None:
+        run_tasks(self.startup_tasks, loop)
+    
+    def shutdown(self, loop: asyncio.AbstractEventLoop) -> None:
+        run_tasks(self.shutdown_tasks, loop)
+
+
+class LoopWrapper(ABCLoopWrapper):
+    def __init__(
+        self,
+        *,
+        tasks: list[CoroutineTask[typing.Any]] | None = None,
+        lifespan: Lifespan | None = None,
+    ) -> None:
+        self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
+        self.lifespan = lifespan or Lifespan()
+        self._loop = asyncio.new_event_loop()
+    
+    def __repr__(self) -> str:
+        return "<{}: loop={!r} with tasks={!r}, lifespan={!r}>".format(
+            self.__class__.__name__,
+            self._loop,
+            self.tasks,
+            self.lifespan,
+        )
+        
+    def run_event_loop(self) -> None:
+        if not self.tasks:
+            logger.warning("You run loop with 0 tasks!")
+
+        self.lifespan.start(self._loop)
+        run_tasks(self.tasks, self._loop)
+        tasks = asyncio.all_tasks(self._loop)
+        
+        try:
+            while tasks:
+                tasks_results, _ = self._loop.run_until_complete(
+                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION),
+                )
+                for task_result in tasks_results:
+                    try:
+                        task_result.result()
+                    except BaseException as ex:
+                        logger.exception(ex)
+                tasks = asyncio.all_tasks(self._loop)
+        except KeyboardInterrupt:
+            print()  # blank print for ^C
+            logger.info("Caught KeyboardInterrupt, cancellation...")
+            self.complete_tasks(tasks)
+        finally:
+            self.lifespan.shutdown(self._loop)
+            if self._loop.is_running():
+                self._loop.close()
+        
+    def add_task(self, task: Task) -> None:
+        task = to_coroutine_task(task)
+
+        if self._loop and self._loop.is_running():
+            self._loop.create_task(task)
+        else:
+            self.tasks.append(task)
+    
+    def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]]) -> None:
+        tasks = tasks | asyncio.all_tasks(self._loop)
+        task_to_cancel = asyncio.gather(*tasks, return_exceptions=True)
+        task_to_cancel.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            self._loop.run_until_complete(task_to_cancel)
+
+    def timer(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float = 0,
+    ):
+        seconds += minutes * 60
+        seconds += hours * 60 * 60
+        seconds += days * 24 * 60 * 60
+
+        def decorator(func: CoroFunc) -> CoroFunc:
+            self.add_task(DelayedTask(func, seconds, repeat=False))
+            return func
+
+        return decorator
+
+    def interval(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float = 0,
+    ):
+        seconds += minutes * 60
+        seconds += hours * 60 * 60
+        seconds += days * 24 * 60 * 60
+
+        def decorator(func: CoroFunc) -> CoroFunc:
+            self.add_task(DelayedTask(func, seconds, repeat=True))
+            return func
+
+        return decorator
+
+
+__all__ = ("DelayedTask", "Lifespan", "LoopWrapper", "to_coroutine_task")

telegrinder-0.1.dev165/telegrinder/verification_utils.py

@@ -0,0 +1,31 @@
+import hashlib
+import hmac
+import typing
+
+from telegrinder.api.abc import Token
+
+
+def verify_webapp_request(secret_token: str, request_headers: typing.Mapping[str, typing.Any]) -> bool:
+    """Verifies update request is from telegram."""
+
+    return request_headers.get("X-Telegram-Bot-Api-Secret-Token") == secret_token
+
+
+def webapp_validate_request(
+    bot_token: Token,
+    request_query_params: typing.Mapping[str, typing.Any],
+) -> bool:
+    """Verifies authentity of webapp request by counting hash of its parameters."""
+
+    items = sorted(request_query_params.items(), key=lambda kv: kv[0])
+    data_check_string = "\n".join(f"{k}={param}" for k, param in items if k != "hash")
+    secret = hmac.new(
+        "WebAppData".encode(),
+        bot_token.encode(),
+        hashlib.sha256,
+    ).digest()
+    data_chk = hmac.new(secret, data_check_string.encode(), hashlib.sha256)
+    return data_chk.hexdigest() == request_query_params.get("hash")
+
+
+__all__ = ("verify_webapp_request", "webapp_validate_request")

telegrinder-0.1.dev164/telegrinder/tools/loop_wrapper/__init__.py

@@ -1,4 +0,0 @@
-from .abc import ABCLoopWrapper
-from .loop_wrapper import DelayedTask, LoopWrapper
-
-__all__ = ("ABCLoopWrapper", "DelayedTask", "LoopWrapper")

telegrinder-0.1.dev164/telegrinder/tools/loop_wrapper/abc.py

@@ -1,18 +0,0 @@
-import typing
-from abc import ABC, abstractmethod
-
-CoroutineTask: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typing.Any]
-CoroutineFunc: typing.TypeAlias = typing.Callable[..., CoroutineTask]
-
-
-class ABCLoopWrapper(ABC):
-    @abstractmethod
-    def add_task(self, task: CoroutineFunc | CoroutineTask) -> None:
-        pass
-
-    @abstractmethod
-    def run_event_loop(self) -> None:
-        pass
-
-
-__all__ = ("ABCLoopWrapper",)

telegrinder-0.1.dev164/telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -1,132 +0,0 @@
-import asyncio
-import contextlib
-import dataclasses
-import typing
-
-from telegrinder.modules import logger
-
-from .abc import ABCLoopWrapper, CoroutineFunc, CoroutineTask
-
-
-@dataclasses.dataclass
-class DelayedTask:
-    handler: CoroutineFunc
-    seconds: float
-    repeat: bool = dataclasses.field(default=False, kw_only=True)
-    _cancelled: bool = dataclasses.field(default=False, init=False, repr=False)
-
-    @property
-    def is_cancelled(self) -> bool:
-        return self._cancelled
-
-    async def __call__(self, *args, **kwargs) -> None:
-        while not self.is_cancelled:
-            await asyncio.sleep(self.seconds)
-            if self.is_cancelled:
-                break
-            await self.handler(*args, **kwargs)
-            if not self.repeat:
-                break
-
-    def cancel(self) -> None:
-        if not self._cancelled:
-            self._cancelled = True
-
-
-class LoopWrapper(ABCLoopWrapper):
-    def __init__(self, tasks: list[CoroutineTask] | None = None):
-        self.on_startup: list[CoroutineTask] = []
-        self.on_shutdown: list[CoroutineTask] = []
-        self.tasks = tasks or []
-        self._loop = asyncio.new_event_loop()
-        
-    def run_event_loop(self) -> None:
-        if not self.tasks:
-            logger.warning("You run loop with 0 tasks!")
-
-        for startup_task in self.on_startup:
-            self._loop.run_until_complete(startup_task)
-        for task in self.tasks:
-            self._loop.create_task(task)
-        
-        self.tasks.clear()
-        tasks = asyncio.all_tasks(self._loop)
-        try:
-            while tasks:
-                tasks_results, _ = self._loop.run_until_complete(
-                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
-                )
-                for task_result in tasks_results:
-                    try:
-                        task_result.result()
-                    except BaseException as ex:
-                        logger.exception(ex)
-                tasks = asyncio.all_tasks(self._loop)
-        except KeyboardInterrupt:
-            print()  # blank print for ^C
-            logger.info("KeyboardInterrupt")
-            self.complete_tasks(tasks)
-        finally:
-            for shutdown_task in self.on_shutdown:
-                self._loop.run_until_complete(shutdown_task)
-            if self._loop.is_running():
-                self._loop.close()
-        
-    def add_task(self, task: CoroutineFunc | CoroutineTask | DelayedTask):
-        if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
-            task = task()
-        elif not asyncio.iscoroutine(task):
-            raise TypeError("Task should be coroutine or coroutine function.")
-
-        if self._loop and self._loop.is_running():
-            self._loop.create_task(task)
-        else:
-            self.tasks.append(task)
-    
-    def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]]) -> None:
-        tasks = tasks | asyncio.all_tasks(self._loop)
-        task_to_cancel = asyncio.gather(*tasks, return_exceptions=True)
-        task_to_cancel.cancel()
-        with contextlib.suppress(asyncio.CancelledError):
-            self._loop.run_until_complete(task_to_cancel)
-
-    def timer(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float = 0,
-    ) -> typing.Callable[[typing.Callable], DelayedTask]:
-        seconds += minutes * 60
-        seconds += hours * 60 * 60
-        seconds += days * 24 * 60 * 60
-
-        def decorator(func: typing.Callable) -> DelayedTask:
-            delayed_task = DelayedTask(func, seconds, repeat=False)
-            self.add_task(delayed_task)
-            return delayed_task
-
-        return decorator
-
-    def interval(
-        self,
-        *,
-        days: int = 0,
-        hours: int = 0,
-        minutes: int = 0,
-        seconds: float = 0,
-    ) -> typing.Callable[[typing.Callable], DelayedTask]:
-        seconds += minutes * 60
-        seconds += hours * 60 * 60
-        seconds += days * 24 * 60 * 60
-
-        def decorator(func: typing.Callable) -> DelayedTask:
-            delayed_task = DelayedTask(func, seconds, repeat=True)
-            self.add_task(delayed_task)
-            return delayed_task
-
-        return decorator
-
-
-__all__ = ("DelayedTask", "LoopWrapper")