AdvancedTagscript 3.2.3__py3-none-any.whl

TagScriptEngine/adapter/redbotadapters.py

@@ -0,0 +1,161 @@
+import datetime
+from typing import Any, Dict, Optional, Tuple, cast
+
+import discord
+
+from ..verb import Verb
+from ..interface import SimpleAdapter
+from ..utils import escape_content
+
+try:
+    import redbot  # noqa: F401
+except ModuleNotFoundError:
+    _has_redbot = False
+else:
+    _has_redbot = True
+
+    from redbot.core.bot import Red
+    from redbot.core.commands import Command
+    from redbot.core.utils.chat_formatting import humanize_number, humanize_list
+    
+
+__all__: Tuple[str, ...] = ("RedCommandAdapter", "RedBotAdapter")
+
+
+class RedCommandAdapter(SimpleAdapter["Command"]):
+    if not _has_redbot:
+        raise ImportError("A Red-DiscordBot instance is required to use this.", name="redbot")
+
+    def __init__(self, base: Command, *, signature: Optional[str] = None) -> None:
+        super().__init__(base=base)
+        self.signature: Optional[str] = signature
+
+    def update_attributes(self) -> None:
+        command: Command = self.object
+        self._attributes.update(
+            {
+                "name": command.name,
+                "cog_name": getattr(command, "cog_name", None),
+                "description": getattr(command, "description", None),
+                "aliases": humanize_list(list(getattr(command, "aliases", []))) or "None",
+                "qualified_name": command.qualified_name,
+                "signature": self.signature,
+            }
+        )
+
+    def get_value(self, ctx: Verb) -> str:
+        should_escape: bool = False
+        if ctx.parameter is None:
+            return_value: str = self.object.qualified_name
+        else:
+            try:
+                value: Any = self._attributes[ctx.parameter]
+            except KeyError:
+                return  # type: ignore
+            if isinstance(value, tuple):
+                value, should_escape = value
+            return_value: str = str(value) if value is not None else None  # type: ignore
+        return escape_content(return_value) if should_escape else return_value
+
+
+class RedBotAdapter(SimpleAdapter["Red"]):
+    """
+    The ``{bot}`` block with no parameters returns the bot's name & discriminator,
+    but passing the attributes listed below to the block payload will return that attribute instead.
+
+    **Usage:** ``{bot([attribute])}``
+
+    **Payload:** None
+
+    **Parameter:** attribute, None
+
+    Attributes
+    ----------
+    id
+        The bot's Discord ID.
+    name
+        The bot's username.
+    discriminator
+        The bot's discriminator.
+    nick
+        The bot's nickname, if they have one, else their username.
+    created_at
+        The bot's creation date.
+    timestamp
+        The bot's creation date as a UTC timestamp.
+    mention
+        A formatted text that pings the bot.
+    verified
+        If the bot is verified or not.
+    shard_count (*)
+        The bot's total shard count.
+    servers (*)
+        Total server/guild count of the bot.
+    channels (*)
+        Total number of channels visible to the bot.
+    visible_users (*)
+        Total number of users visible to the bot.
+    total_users (*)
+        The bot's total user count.
+    unique_users (*)
+        The bot's unique user count.
+    percentage_chunked (*)
+        Percentage of chunked guilds the bot has.
+
+    .. warning::
+        Attributes denoting `(*)` can only be used by the bot owner.
+    """
+
+    if not _has_redbot:
+        raise ImportError("A Red-DiscordBot instance is required to use this.")
+
+    def __init__(self, base: Red, *, owner: bool = True) -> None:
+        super().__init__(base=base)
+        self.is_owner: bool = owner
+
+    def update_attributes(self) -> None:
+        self.user: discord.ClientUser = cast(discord.ClientUser, self.object.user)
+        created_at: datetime.datetime = getattr(
+            self.user, "created_at", None
+        ) or discord.utils.snowflake_time(self.user.id)
+        self._attributes.update(
+            {
+                "id": self.user.id,
+                "name": self.user.name,
+                "discriminator": self.user.discriminator,
+                "nick": self.user.display_name,
+                "mention": self.user.display_avatar.url,
+                "created_at": created_at,
+                "timestamp": int(created_at.timestamp()),
+                "verified": self.user.verified,
+            }
+        )
+        if self.is_owner:
+            visible_users: int = sum(len(g.members) for g in self.object.guilds)
+            total_users: int = sum(
+                g.member_count if g.member_count else 0 for g in self.object.guilds
+            )
+            owner_attributes: Dict[str, Any] = {
+                "shard_count": humanize_number(self.object.bot.shard_count),
+                "servers": humanize_number(len(self.object.guilds)),
+                "channels": humanize_number(sum(len(g.channels) for g in self.object.guilds)),
+                "visible_users": humanize_number(visible_users),
+                "total_users": humanize_number(total_users),
+                "unique_users": humanize_number(len(self.object.users)),
+                "percentage_chunked": visible_users / total_users * 100,
+            }
+            self._attributes.update(owner_attributes)
+
+    def get_value(self, ctx: Verb) -> str:
+        should_escape: bool = False
+        if ctx.parameter is None:
+            return_value: str = "{0.name}#{0.discriminator}".format(self.user)
+        else:
+            try:
+                value: Any = self._attributes[ctx.parameter]
+            except KeyError:
+                return  # type: ignore
+            if isinstance(value, tuple):
+                value, should_escape = value
+            return_value: str = str(value) if value is not None else None  # type: ignore
+        return escape_content(return_value) if should_escape else return_value

TagScriptEngine/adapter/stringadapter.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from ..interface import Adapter
+from ..utils import escape_content
+from ..verb import Verb
+
+
+__all__: Tuple[str, ...] = ("StringAdapter",)
+
+
+class StringAdapter(Adapter):
+    __slots__: Tuple[str, ...] = ("string", "escape_content")
+
+    def __init__(self, string: str, *, escape: bool = False) -> None:
+        self.string: str = str(string)
+        self.escape_content = escape
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__qualname__} string={repr(self.string)}>"
+
+    def get_value(self, ctx: Verb) -> str:
+        return self.return_value(self.handle_ctx(ctx))
+
+    def handle_ctx(self, ctx: Verb) -> str:
+        if ctx.parameter is None:
+            return self.string
+        try:
+            if "+" not in ctx.parameter:
+                index = int(ctx.parameter) - 1
+                splitter = " " if ctx.payload is None else ctx.payload
+                return self.string.split(splitter)[index]
+            else:
+                index = int(ctx.parameter.replace("+", "")) - 1
+                splitter = " " if ctx.payload is None else ctx.payload
+                if ctx.parameter.startswith("+"):
+                    return splitter.join(self.string.split(splitter)[: index + 1])
+                elif ctx.parameter.endswith("+"):
+                    return splitter.join(self.string.split(splitter)[index:])
+                else:
+                    return self.string.split(splitter)[index]
+        except Exception:
+            return self.string
+
+    def return_value(self, string: str) -> str:
+        return escape_content(string) if self.escape_content else string

TagScriptEngine/block/__init__.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+# isort: off
+from .helpers import (
+    implicit_bool as implicit_bool,
+    helper_parse_if as helper_parse_if,
+    helper_parse_list_if as helper_parse_list_if,
+    helper_split as helper_split,
+    easier_helper_split as easier_helper_split,
+)
+
+# isort: on
+from .allowedmentions import (
+    AllowedMentionsBlock as AllowedMentionsBlock,
+)
+from .assign import (
+    AssignmentBlock as AssignmentBlock,
+)
+from .breakblock import (
+    BreakBlock as BreakBlock,
+)
+from .command import (
+    CommandBlock as CommandBlock,
+    OverrideBlock as OverrideBlock,
+    SequentialGather as SequentialGather,
+)
+from .control import (
+    AllBlock as AllBlock,
+    AnyBlock as AnyBlock,
+    IfBlock as IfBlock,
+)
+from .cooldown import (
+    CooldownBlock as CooldownBlock,
+)
+from .embedblock import (
+    EmbedBlock as EmbedBlock,
+)
+from .fiftyfifty import (
+    FiftyFiftyBlock as FiftyFiftyBlock,
+)
+from .loosevariablegetter import (
+    LooseVariableGetterBlock as LooseVariableGetterBlock,
+)
+from .mathblock import (
+    MathBlock as MathBlock,
+)
+from .randomblock import (
+    RandomBlock as RandomBlock,
+)
+from .range import (
+    RangeBlock as RangeBlock,
+)
+from .redirect import (
+    RedirectBlock as RedirectBlock,
+)
+from .replaceblock import (
+    PythonBlock as PythonBlock,
+    ReplaceBlock as ReplaceBlock,
+)
+from .require_blacklist import (
+    BlacklistBlock as BlacklistBlock,
+    RequireBlock as RequireBlock,
+)
+from .shortcutredirect import (
+    ShortCutRedirectBlock as ShortCutRedirectBlock,
+)
+from .stopblock import (
+    StopBlock as StopBlock,
+)
+from .strf import (
+    StrfBlock as StrfBlock,
+)
+from .strictvariablegetter import (
+    StrictVariableGetterBlock as StrictVariableGetterBlock,
+)
+from .substr import (
+    SubstringBlock as SubstringBlock,
+)
+from .urlencodeblock import (
+    URLEncodeBlock as URLEncodeBlock,
+)
+from .case import (
+    UpperBlock as UpperBlock,
+    LowerBlock as LowerBlock,
+)
+from .count import (
+    CountBlock as CountBlock,
+    LengthBlock as LengthBlock,
+)
+
+__all__: Tuple[str, ...] = (
+    "implicit_bool",
+    "helper_parse_if",
+    "helper_parse_list_if",
+    "helper_split",
+    "easier_helper_split",
+    "AllowedMentionsBlock",
+    "AllBlock",
+    "AnyBlock",
+    "AssignmentBlock",
+    "BlacklistBlock",
+    "BreakBlock",
+    "SequentialGather",
+    "CommandBlock",
+    "CooldownBlock",
+    "EmbedBlock",
+    "FiftyFiftyBlock",
+    "IfBlock",
+    "LooseVariableGetterBlock",
+    "MathBlock",
+    "OverrideBlock",
+    "PythonBlock",
+    "RandomBlock",
+    "RangeBlock",
+    "RedirectBlock",
+    "ReplaceBlock",
+    "RequireBlock",
+    "ShortCutRedirectBlock",
+    "StopBlock",
+    "StrfBlock",
+    "StrictVariableGetterBlock",
+    "SubstringBlock",
+    "URLEncodeBlock",
+    "UpperBlock",
+    "LowerBlock",
+    "CountBlock",
+    "LengthBlock",
+)

TagScriptEngine/block/allowedmentions.py

@@ -0,0 +1,60 @@
+from typing import Dict, List, Optional, Tuple, Union
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+class AllowedMentionsBlock(Block):
+    """
+    The ``{allowedmentions}`` block attempts to enable mentioning of roles.
+    Passing no parameter enables mentioning of all roles within the message
+    content. However passing a role name or ID to the block parameter allows
+    mentioning of that specific role only. Multiple role name or IDs can be
+    included, separated by a comma ",". By default, mentioning is only
+    triggered if the execution author has "manage server" permissions. However,
+    using the "override" keyword as a payload allows mentioning to be triggered
+    by anyone.
+
+    **Usage:** ``{allowedmentions(<role, None>):["override", None]}``
+
+    **Aliases:** ``mentions``
+
+    **Payload:** "override", None
+
+    **Parameter:** role, None
+
+    **Examples:** ::
+
+        {allowedmentions}
+        {allowedmentions:override}
+        {allowedmentions(@Admin, Moderator):override}
+        {allowedmentions(763522431151112265, 812949167190048769)}
+        {mentions(763522431151112265, 812949167190048769):override}
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("allowedmentions", "mentions")
+    PAYLOADS: Tuple[str, ...] = ("override",)
+
+    @classmethod
+    def will_accept(cls, ctx: Context) -> bool:
+        if ctx.verb.payload and ctx.verb.payload not in cls.PAYLOADS:
+            return False
+        return super().will_accept(ctx)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        actions: Optional[Dict[str, Union[bool, List[str]]]] = ctx.response.actions.get(
+            "allowed_mentions", None
+        )
+        if actions:
+            return None
+        if not (param := ctx.verb.parameter):
+            ctx.response.actions["allowed_mentions"] = {
+                "mentions": True,
+                "override": True if ctx.verb.payload else False,
+            }
+            return ""
+        ctx.response.actions["allowed_mentions"] = {
+            "mentions": [r.strip() for r in param.split(",")],
+            "override": True if ctx.verb.payload else False,
+        }
+        return ""

TagScriptEngine/block/assign.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from ..adapter import StringAdapter
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("AssignmentBlock",)
+
+
+class AssignmentBlock(verb_required_block(False, parameter=True)):  # type: ignore
+    """
+    Variables are useful for choosing a value and referencing it later in a tag.
+    Variables can be referenced using brackets as any other block.
+
+    **Usage:** ``{=(<name>):<value>}``
+
+    **Aliases:** ``assign, let, var``
+
+    **Payload:** value
+
+    **Parameter:** name
+
+    **Examples:** ::
+
+        {=(prefix):!}
+        The prefix here is `{prefix}`.
+        # The prefix here is `!`.
+
+        {assign(day):Monday}
+        {if({day}==Wednesday):It's Wednesday my dudes!|The day is {day}.}
+        # The day is Monday.
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("=", "assign", "let", "var")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        if ctx.verb.parameter is None:
+            return None
+        ctx.response.variables[ctx.verb.parameter] = StringAdapter(str(ctx.verb.payload))
+        return ""

TagScriptEngine/block/breakblock.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple, cast
+
+from ..interface import Block
+from ..interpreter import Context
+from . import helper_parse_if
+
+
+__all__: Tuple[str, ...] = ("BreakBlock",)
+
+
+class BreakBlock(Block):
+    """
+    The break block will force the tag output to only be the payload of this block, if the passed
+    expresssion evaluates true.
+    If no message is provided to the payload, the tag output will be empty.
+
+    This differs from the `StopBlock` as the stop block stops all tagscript processing and returns
+    its message while the break block continues to process blocks. If command blocks exist after
+    the break block, they will still execute.
+
+    **Usage:** ``{break(<expression>):[message]}``
+
+    **Aliases:** ``short, shortcircuit``
+
+    **Payload:**  message
+
+    **Parameter:**  expression
+
+    **Examples:** ::
+
+        {break({args}==):You did not provide any input.}
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("break", "shortcircuit", "short")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        if helper_parse_if(cast(str, ctx.verb.parameter)):
+            ctx.response.body = ctx.verb.payload if ctx.verb.payload != None else ""  # noqa: E711
+        return ""

TagScriptEngine/block/case.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("UpperBlock", "LowerBlock")
+
+
+class UpperBlock(Block):
+    """Converts the given text to uppercase.
+
+    **Usage:**  ``{upper([text]))}``
+
+    **Aliases:**  ``uppercase, upper``
+
+    **Payload:**  None
+
+    **Parameter:**  text
+
+    **Examples:**  ::
+
+        The text is {lower(ThIs Is A TeXt)}!
+        # The text is THIS IS A TEXT!
+
+        You have entered {lower({args})}!
+        # You have entered HELLO WORLD!
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("upper", "uppercase")
+
+    def process(self, ctx: Context) -> str:
+        text = str(ctx.verb.parameter).upper()
+        return "" if text == "NONE" else text
+
+
+class LowerBlock(Block):
+    """Converts the given text to lowercase.
+
+    **Usage:**  ``{lower([text])}``
+
+    **Aliases:**  ``lowercase, lower``
+
+    **Payload:**  None
+
+    **Parameter:**  text
+
+    **Examples:**  ::
+
+        The text is {lower(ThIs Is A TeXt)}!
+        # The text is this is a text!
+
+        You have entered {lower({args})}!
+        # You have entered hello world!
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("lower", "lowercase")
+
+    def process(self, ctx: Context) -> str:
+        text = str(ctx.verb.parameter).lower()
+        return "" if text == "none" else text

TagScriptEngine/block/command.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import asyncio
+from types import TracebackType
+from typing import Any, Awaitable, Generator, Iterator, List, Optional, Tuple, Type, TypeVar
+
+from ..interface import Block, verb_required_block
+from ..interpreter import Context
+
+T = TypeVar("T")
+
+
+__all__: Tuple[str, ...] = ("CommandBlock", "OverrideBlock", "SequentialGather")
+
+
+class CommandBlock(verb_required_block(True, payload=True)):  # type: ignore
+    """
+    Run a command as if the tag invoker had ran it. Only 3 command
+    blocks can be used in a tag.
+
+    **Usage:** ``{command:<command>}``
+
+    **Aliases:** ``c, com, command``
+
+    **Payload:** command
+
+    **Parameter:** None
+
+    **Examples:** ::
+
+        {c:ping}
+        # invokes ping command
+
+        {c:ban {target(id)} Chatflood/spam}
+        # invokes ban command on the pinged user with the reason as "Chatflood/spam"
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("c", "com", "command")
+
+    def __init__(self, limit: int = 3):
+        self.limit = limit
+        super().__init__()
+
+    def process(self, ctx: Context) -> Optional[str]:
+        command = ctx.verb.payload.strip()  # type: ignore
+        actions = ctx.response.actions.get("commands")
+        if actions:
+            if len(actions) >= self.limit:
+                return f"`COMMAND LIMIT REACHED ({self.limit})`"
+        else:
+            ctx.response.actions["commands"] = []
+        ctx.response.actions["commands"].append(command)
+        return ""
+
+
+class OverrideBlock(Block):
+    """
+    Override a command's permission requirements. This can override
+    mod, admin, or general user permission requirements when running commands
+    with the :ref:`Command Block`. Passing no parameter will default to overriding
+    all permissions.
+
+    In order to add a tag with the override block, the tag author must have ``Manage
+    Server`` permissions.
+
+    This will not override bot owner commands or command checks.
+
+    **Usage:** ``{override(["admin"|"mod"|"permissions"]):[command]}``
+
+    **Payload:** command
+
+    **Parameter:** "admin", "mod", "permissions"
+
+    **Examples:** ::
+
+        {override}
+        # overrides all commands and permissions
+
+        {override(admin)}
+        # overrides commands that require the admin role
+
+        {override(permissions)}
+        {override(mod)}
+        # overrides commands that require the mod role or have user permission requirements
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("override",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        param = ctx.verb.parameter
+        if not param:
+            ctx.response.actions["overrides"] = {"admin": True, "mod": True, "permissions": True}
+            return ""
+
+        param = param.strip().lower()
+        if param not in ("admin", "mod", "permissions"):
+            return None
+        overrides = ctx.response.actions.get(
+            "overrides", {"admin": False, "mod": False, "permissions": False}
+        )
+        overrides[param] = True
+        ctx.response.actions["overrides"] = overrides
+        return ""
+
+
+class SequentialGather(Awaitable[T]):
+    """
+    Use this to run commands sequentially.
+
+    Parameters
+    ----------
+    awaitables : Tuple[Awaitable[T]]
+        the awaitables to be run sequentially.
+
+    Returns
+    -------
+    `List[T]`
+        the result object.
+    """
+
+    def __init__(self, *awaitables: Awaitable[T]) -> None:
+        self.__awaitables: Tuple[Awaitable[T], ...] = awaitables
+        self.__iterator: Iterator[Awaitable[T]] = iter(self.__awaitables)
+        self.__results: List[T] = []
+        self.__lock: asyncio.Lock = asyncio.Lock()
+
+    def __await__(self) -> Generator[Any, None, List[T]]:
+        return self.__aenter__().__await__()
+
+    async def __aenter__(self) -> List[T]:
+        async with self.__lock:
+            for coro in self.__iterator:
+                await asyncio.sleep(0.10)
+                result: T = await coro
+                self.__results.append(result)
+        return self.__results
+
+    async def __aexit__(
+        self, exc_type: Type[BaseException], exc_value: BaseException, traceback: TracebackType
+    ) -> None:
+        pass