telegrinder 0.1.dev164__py3-none-any.whl → 0.1.dev166__py3-none-any.whl

telegrinder/tools/formatting/html.py

@@ -49,7 +49,9 @@ class StringFormatter(string.Formatter):
             )
         return fmt
 
-    def get_spec_formatter(self, value: SpecialFormat) -> typing.Callable[..., "TagFormat"]:
+    def get_spec_formatter(
+        self, value: SpecialFormat
+    ) -> typing.Callable[..., "TagFormat"]:
         return globals()[value.__formatter_name__]
 
     def check_formats(self, value: typing.Any, fmts: list[str]) -> "TagFormat":
@@ -78,11 +80,15 @@ class StringFormatter(string.Formatter):
         with suppress(ValueError):
             return HTMLFormatter(
                 format(
-                    value.formatting()
-                    if isinstance(value, TagFormat)
-                    else self.get_spec_formatter(value)(**value.__dict__).formatting()
-                    if is_spec_format(value)
-                    else value,
+                    (
+                        value.formatting()
+                        if isinstance(value, TagFormat)
+                        else (
+                            self.get_spec_formatter(value)(**value.__dict__).formatting()
+                            if is_spec_format(value)
+                            else value
+                        )
+                    ),
                     fmt,
                 )
             )
@@ -200,11 +206,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 +237,14 @@ 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/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/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
 
 
@@ -77,7 +76,7 @@ class PreCode(BaseSpecFormat):
 @dataclasses.dataclass(repr=False)
 class TgEmoji(BaseSpecFormat):
     __formatter_name__ = "tg_emoji"
-    
+
     string: str
     emoji_id: int
 
@@ -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/tools/global_context/abc.py

@@ -35,7 +35,11 @@ class GlobalCtxVar(typing.Generic[T]):
 
     @classmethod
     def collect(cls, name: str, ctx_value: T | CtxVariable[T]) -> typing.Self:
-        ctx_value = CtxVar(ctx_value) if not isinstance(ctx_value, CtxVar | GlobalCtxVar) else ctx_value
+        ctx_value = (
+            CtxVar(ctx_value)
+            if not isinstance(ctx_value, CtxVar | GlobalCtxVar)
+            else ctx_value
+        )
         params = ctx_value.__dict__
         params["name"] = name
         return cls(**params)

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/tools/global_context/telegrinder_ctx.py

@@ -7,7 +7,7 @@ from telegrinder.tools.global_context import GlobalContext, ctx_var
 
 class TelegrinderCtx(GlobalContext):
     """Basic type-hinted telegrinder context with context name `"telegrinder"`.
-    
+
     You can use this class or GlobalContext:
     ```
     from telegrinder.tools.global_context import GlobalContext, TelegrinderCtx

telegrinder/tools/i18n/base.py

@@ -1,4 +1,5 @@
 import enum
+import typing
 from abc import ABC, abstractmethod
 
 
@@ -9,14 +10,14 @@ class ABCI18n(ABC):
 
 
 class ABCTranslator(ABC):
-    def __init__(self, locale: str, **kwargs):
+    def __init__(self, locale: str, **kwargs: typing.Any) -> None:
         self.locale = locale
 
     @abstractmethod
-    def get(self, __key: str, *args, **kwargs) -> str:
+    def get(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
         """This translates a key to actual human-readable string"""
 
-    def __call__(self, __key: str, *args, **kwargs):
+    def __call__(self, __key: str, *args: typing.Any, **kwargs: typing.Any) -> str:
         return self.get(__key, *args, **kwargs)
 
 

telegrinder/tools/i18n/simple.py

@@ -20,9 +20,7 @@ class SimpleI18n(ABCI18n):
             if not os.path.isdir(os.path.join(self.folder, name)):
                 continue
 
-            mo_path = os.path.join(
-                self.folder, name, "LC_MESSAGES", f"{self.domain}.mo"
-            )
+            mo_path = os.path.join(self.folder, name, "LC_MESSAGES", f"{self.domain}.mo")
             if os.path.exists(mo_path):
                 with open(mo_path, "rb") as f:
                     result[name] = gettext.GNUTranslations(f)

telegrinder/tools/keyboard.py

@@ -46,7 +46,7 @@ class ABCMarkup(ABC, typing.Generic[ButtonT]):
     def add(self, row_or_button: RowButtons[ButtonT] | ButtonT) -> typing.Self:
         if not len(self.keyboard):
             self.row()
-        
+
         if isinstance(row_or_button, RowButtons):
             self.keyboard[-1].extend(row_or_button.get_data())
             if row_or_button.auto_row:

telegrinder/tools/loop_wrapper/__init__.py

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

telegrinder/tools/loop_wrapper/abc.py

@@ -1,13 +1,10 @@
 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:
+    def add_task(self, task: typing.Any) -> None:
         pass
 
     @abstractmethod

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -5,12 +5,36 @@ import typing
 
 from telegrinder.modules import logger
 
-from .abc import ABCLoopWrapper, CoroutineFunc, CoroutineTask
+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 tasks:
+        loop.run_until_complete(tasks.pop(0))
+
+
+def to_coroutine_task(task: Task) -> CoroutineTask[typing.Any]:
+    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:
-    handler: CoroutineFunc
+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)
@@ -33,28 +57,64 @@ class DelayedTask:
             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] | None = None):
-        self.on_startup: list[CoroutineTask] = []
-        self.on_shutdown: list[CoroutineTask] = []
-        self.tasks = tasks or []
+    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!")
 
-        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()
+        self.lifespan.start(self._loop)
+        while self.tasks:
+            self._loop.create_task(self.tasks.pop(0))
         tasks = asyncio.all_tasks(self._loop)
+
         try:
             while tasks:
                 tasks_results, _ = self._loop.run_until_complete(
-                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
+                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION),
                 )
                 for task_result in tasks_results:
                     try:
@@ -64,25 +124,21 @@ class LoopWrapper(ABCLoopWrapper):
                 tasks = asyncio.all_tasks(self._loop)
         except KeyboardInterrupt:
             print()  # blank print for ^C
-            logger.info("KeyboardInterrupt")
+            logger.info("Caught KeyboardInterrupt, cancellation...")
             self.complete_tasks(tasks)
         finally:
-            for shutdown_task in self.on_shutdown:
-                self._loop.run_until_complete(shutdown_task)
+            self.lifespan.shutdown(self._loop)
             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.")
+
+    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)
@@ -97,15 +153,14 @@ class LoopWrapper(ABCLoopWrapper):
         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
+        def decorator(func: CoroFunc) -> CoroFunc:
+            self.add_task(DelayedTask(func, seconds, repeat=False))
+            return func
 
         return decorator
 
@@ -116,17 +171,16 @@ class LoopWrapper(ABCLoopWrapper):
         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
+        def decorator(func: CoroFunc) -> CoroFunc:
+            self.add_task(DelayedTask(func, seconds, repeat=True))
+            return func
 
         return decorator
 
 
-__all__ = ("DelayedTask", "LoopWrapper")
+__all__ = ("DelayedTask", "Lifespan", "LoopWrapper", "to_coroutine_task")

telegrinder/tools/magic.py

@@ -28,7 +28,7 @@ def to_str(s: str | enum.Enum) -> str:
 
 
 def magic_bundle(
-    handler: FuncType, 
+    handler: FuncType,
     kw: dict[str | enum.Enum, typing.Any],
     *,
     start_idx: int = 1,

telegrinder/types/__init__.py

@@ -1,2 +1,208 @@
 from telegrinder.types.enums import *
 from telegrinder.types.objects import *
+
+__all__ = (
+    "Animation",
+    "Audio",
+    "BackgroundFill",
+    "BackgroundFillFreeformGradient",
+    "BackgroundFillGradient",
+    "BackgroundFillSolid",
+    "BackgroundType",
+    "BackgroundTypeChatTheme",
+    "BackgroundTypeFill",
+    "BackgroundTypePattern",
+    "BackgroundTypeWallpaper",
+    "Birthdate",
+    "BotCommand",
+    "BotCommandScope",
+    "BotCommandScopeAllChatAdministrators",
+    "BotCommandScopeAllGroupChats",
+    "BotCommandScopeAllPrivateChats",
+    "BotCommandScopeChat",
+    "BotCommandScopeChatAdministrators",
+    "BotCommandScopeChatMember",
+    "BotCommandScopeDefault",
+    "BotDescription",
+    "BotName",
+    "BotShortDescription",
+    "BusinessConnection",
+    "BusinessIntro",
+    "BusinessLocation",
+    "BusinessMessagesDeleted",
+    "BusinessOpeningHours",
+    "BusinessOpeningHoursInterval",
+    "CallbackGame",
+    "CallbackQuery",
+    "Chat",
+    "ChatAdministratorRights",
+    "ChatBackground",
+    "ChatBoost",
+    "ChatBoostAdded",
+    "ChatBoostRemoved",
+    "ChatBoostSource",
+    "ChatBoostSourceGiftCode",
+    "ChatBoostSourceGiveaway",
+    "ChatBoostSourcePremium",
+    "ChatBoostUpdated",
+    "ChatFullInfo",
+    "ChatInviteLink",
+    "ChatJoinRequest",
+    "ChatLocation",
+    "ChatMember",
+    "ChatMemberAdministrator",
+    "ChatMemberBanned",
+    "ChatMemberLeft",
+    "ChatMemberMember",
+    "ChatMemberOwner",
+    "ChatMemberRestricted",
+    "ChatMemberUpdated",
+    "ChatPermissions",
+    "ChatPhoto",
+    "ChatShared",
+    "ChosenInlineResult",
+    "Contact",
+    "Dice",
+    "Document",
+    "EncryptedCredentials",
+    "EncryptedPassportElement",
+    "ExternalReplyInfo",
+    "File",
+    "ForceReply",
+    "ForumTopic",
+    "ForumTopicClosed",
+    "ForumTopicCreated",
+    "ForumTopicEdited",
+    "ForumTopicReopened",
+    "Game",
+    "GameHighScore",
+    "GeneralForumTopicHidden",
+    "GeneralForumTopicUnhidden",
+    "Giveaway",
+    "GiveawayCompleted",
+    "GiveawayCreated",
+    "GiveawayWinners",
+    "InaccessibleMessage",
+    "InlineKeyboardButton",
+    "InlineKeyboardMarkup",
+    "InlineQuery",
+    "InlineQueryResult",
+    "InlineQueryResultArticle",
+    "InlineQueryResultAudio",
+    "InlineQueryResultCachedAudio",
+    "InlineQueryResultCachedDocument",
+    "InlineQueryResultCachedGif",
+    "InlineQueryResultCachedMpeg4Gif",
+    "InlineQueryResultCachedPhoto",
+    "InlineQueryResultCachedSticker",
+    "InlineQueryResultCachedVideo",
+    "InlineQueryResultCachedVoice",
+    "InlineQueryResultContact",
+    "InlineQueryResultDocument",
+    "InlineQueryResultGame",
+    "InlineQueryResultGif",
+    "InlineQueryResultLocation",
+    "InlineQueryResultMpeg4Gif",
+    "InlineQueryResultPhoto",
+    "InlineQueryResultVenue",
+    "InlineQueryResultVideo",
+    "InlineQueryResultVoice",
+    "InlineQueryResultsButton",
+    "InputContactMessageContent",
+    "InputFile",
+    "InputInvoiceMessageContent",
+    "InputLocationMessageContent",
+    "InputMedia",
+    "InputMediaAnimation",
+    "InputMediaAudio",
+    "InputMediaDocument",
+    "InputMediaPhoto",
+    "InputMediaVideo",
+    "InputMessageContent",
+    "InputPollOption",
+    "InputSticker",
+    "InputTextMessageContent",
+    "InputVenueMessageContent",
+    "Invoice",
+    "KeyboardButton",
+    "KeyboardButtonPollType",
+    "KeyboardButtonRequestChat",
+    "KeyboardButtonRequestUsers",
+    "LabeledPrice",
+    "LinkPreviewOptions",
+    "Location",
+    "LoginUrl",
+    "MaskPosition",
+    "MaybeInaccessibleMessage",
+    "MenuButton",
+    "MenuButtonCommands",
+    "MenuButtonDefault",
+    "MenuButtonWebApp",
+    "Message",
+    "MessageAutoDeleteTimerChanged",
+    "MessageEntity",
+    "MessageId",
+    "MessageOrigin",
+    "MessageOriginChannel",
+    "MessageOriginChat",
+    "MessageOriginHiddenUser",
+    "MessageOriginUser",
+    "MessageReactionCountUpdated",
+    "MessageReactionUpdated",
+    "Model",
+    "OrderInfo",
+    "PassportData",
+    "PassportElementError",
+    "PassportElementErrorDataField",
+    "PassportElementErrorFile",
+    "PassportElementErrorFiles",
+    "PassportElementErrorFrontSide",
+    "PassportElementErrorReverseSide",
+    "PassportElementErrorSelfie",
+    "PassportElementErrorTranslationFile",
+    "PassportElementErrorTranslationFiles",
+    "PassportElementErrorUnspecified",
+    "PassportFile",
+    "PhotoSize",
+    "Poll",
+    "PollAnswer",
+    "PollOption",
+    "PreCheckoutQuery",
+    "ProximityAlertTriggered",
+    "ReactionCount",
+    "ReactionType",
+    "ReactionTypeCustomEmoji",
+    "ReactionTypeEmoji",
+    "ReplyKeyboardMarkup",
+    "ReplyKeyboardRemove",
+    "ReplyParameters",
+    "ResponseParameters",
+    "SentWebAppMessage",
+    "SharedUser",
+    "ShippingAddress",
+    "ShippingOption",
+    "ShippingQuery",
+    "Sticker",
+    "StickerSet",
+    "Story",
+    "SuccessfulPayment",
+    "SwitchInlineQueryChosenChat",
+    "TextQuote",
+    "Update",
+    "User",
+    "UserChatBoosts",
+    "UserProfilePhotos",
+    "UsersShared",
+    "Venue",
+    "Video",
+    "VideoChatEnded",
+    "VideoChatParticipantsInvited",
+    "VideoChatScheduled",
+    "VideoChatStarted",
+    "VideoNote",
+    "Voice",
+    "WebAppData",
+    "WebAppInfo",
+    "WebhookInfo",
+    "WriteAccessAllowed",
+)