bTagScript 5.0.0__py3-none-any.whl

bTagScript/block/discord_blocks/embed_block.py

@@ -0,0 +1,248 @@
+import json
+from inspect import ismethod
+from typing import Optional, Union
+
+from discord import Colour, Embed
+
+from ...exceptions import BadColourArgument, EmbedParseError
+from ...interface import Block
+from ...interpreter import Context
+from ..helpers import helper_split, implicit_bool
+
+
+def string_to_color(argument: str) -> Colour:
+    """
+    Converts a string to a discord.Colour object
+    """
+    arg = argument.replace("0x", "").lower()
+
+    if arg[0] == "#":
+        arg = arg[1:]
+    try:
+        value = int(arg, base=16)
+        if not (0 <= value <= 0xFFFFFF):
+            raise BadColourArgument(arg)
+        return Colour(value=value)
+    except ValueError:
+        arg = arg.replace(" ", "_")
+        method = getattr(Colour, arg, None)
+        if arg.startswith("from_") or method is None or not ismethod(method):
+            raise BadColourArgument(arg)  # pylint: disable=raise-missing-from
+        return method()
+
+
+def set_color(embed: Embed, attribute: str, value: str) -> None:
+    """
+    Sets the colour of the embed given
+    """
+    value = string_to_color(value)
+    setattr(embed, attribute, value)
+
+
+def set_dynamic_url(embed: Embed, attribute: str, value: str) -> None:
+    """
+    Dynamically sets the url of the embed
+    """
+    method = getattr(embed, f"set_{attribute}")
+    method(url=value)
+
+
+def add_field(embed: Embed, _: str, payload: str) -> None:
+    """
+    Adds a field to the embed
+    """
+    parts = helper_split(payload, False)
+    if parts is None or len(parts) not in (2, 3):
+        raise EmbedParseError("`add_field` payload was not split by |")
+    name, value = parts[0], parts[1]
+    inline = False
+    if len(parts) == 3:
+        inline = implicit_bool(parts[2])
+        if inline is None:
+            raise EmbedParseError(
+                f"`inline` argument for `add_field` is not a boolean value ({parts[2]})"
+            )
+    embed.add_field(name=name, value=value, inline=inline)
+
+
+class EmbedBlock(Block):
+    """
+    An embed block will send an embed in the tag response.
+    There are two ways to use the embed block, either by using properly
+    formatted embed JSON from an embed generator or manually inputting
+    the accepted embed attributes.
+
+    **JSON**
+
+    Using JSON to create an embed offers complete embed customization.
+    Multiple embed generators are available online to visualize and generate
+    embed JSON.
+
+    **Usage:** ``{embed(<json>)}``
+
+    **Payload:** ``None``
+
+    **Parameter:** ``json``
+
+    .. tagscript::
+
+        {embed({"title":"Hello!", "description":"This is a test embed."})}
+        {embed({
+            "title":"Here's a random duck!",
+            "image":{"url":"https://random-d.uk/api/randomimg"},
+            "color":15194415
+        })}
+
+    **Manual**
+
+    The following embed attributes can be set manually:
+
+    *   ``title``
+    *   ``description``
+    *   ``color``
+    *   ``url``
+    *   ``thumbnail``
+    *   ``image``
+    *   ``field`` - (See below)
+
+    Adding a field to an embed requires the payload to be split by ``|``, into
+    either 2 or 3 parts. The first part is the name of the field, the second is
+    the text of the field, and the third optionally specifies whether the field
+    should be inline.
+
+    **Usage:** ``{embed(<attribute>):<value>}``
+
+    **Payload:** ``value``
+
+    **Parameter:** ``attribute``
+
+    .. tagscript::
+        {embed(color):#37b2cb}
+        {embed(title):Rules}
+        {embed(description):Follow these rules to ensure a good experience in our server!}
+        {embed(field):Rule 1|Respect everyone you speak to.|false}
+
+    Both methods can be combined to create an embed in a tag.
+    The following tagscript uses JSON to create an embed with fields and later
+    set the embed title.
+
+    :: tagscript::
+
+        {embed({{"fields":[{"name":"Field 1","value":"field description","inline":false}]})}
+        {embed(title):my embed title}
+    """
+
+    ACCEPTED_NAMES = ("embed",)
+
+    ATTRIBUTE_HANDLERS = {
+        "description": setattr,
+        "title": setattr,
+        "color": set_color,
+        "colour": set_color,
+        "url": setattr,
+        "thumbnail": set_dynamic_url,
+        "image": set_dynamic_url,
+        "field": add_field,
+    }
+
+    @staticmethod
+    def get_embed(ctx: Context) -> Embed:
+        """
+        Gets the embed object
+        """
+        return ctx.response.actions.get("embed", Embed())
+
+    @staticmethod
+    def value_to_color(value: Optional[Union[int, str]]) -> Colour:
+        """
+        Converts a value to a discord.Colour object
+        """
+        if value is None or isinstance(value, Colour):
+            return value
+        if isinstance(value, int):
+            return Colour(value)
+        elif isinstance(value, str):
+            return string_to_color(value)
+        else:
+            raise EmbedParseError("Received invalid type for color key (expected string or int)")
+
+    def text_to_embed(self, text: str) -> Embed:
+        """
+        Converts json to an embed
+        """
+        try:
+            data = json.loads(text)
+        except json.decoder.JSONDecodeError as error:
+            raise EmbedParseError(error) from error
+
+        if data.get("embed"):
+            data = data["embed"]
+        if data.get("timestamp"):
+            data["timestamp"] = data["timestamp"].strip("Z")
+
+        color = data.pop("color", data.pop("colour", None))
+
+        try:
+            embed = Embed.from_dict(data)
+        except Exception as error:
+            raise EmbedParseError(error) from error
+        else:
+            if color := self.value_to_color(color):
+                embed.color = color
+            return embed
+
+    @classmethod
+    def update_embed(cls, embed: Embed, attribute: str, value: str) -> Embed:
+        """
+        Update the embed with all attributes
+        """
+        handler = cls.ATTRIBUTE_HANDLERS[attribute]
+        try:
+            handler(embed, attribute, value)
+        except Exception as error:
+            raise EmbedParseError(error) from error
+        return embed
+
+    @staticmethod
+    def return_error(error: Exception) -> str:
+        """
+        Return an error message
+        """
+        return f"Embed Parse Error: {error}"
+
+    @staticmethod
+    def return_embed(ctx: Context, embed: Embed) -> str:
+        """
+        Returns the embed
+        """
+        try:
+            length = len(embed)
+        except Exception as error:  # pylint: disable=broad-except
+            return str(error)
+        if length > 6000:
+            return f"`MAX EMBED LENGTH REACHED ({length}/6000)`"
+        ctx.response.actions["embed"] = embed
+        return ""
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block
+        """
+        if not ctx.verb.parameter:
+            return self.return_embed(ctx, self.get_embed(ctx))
+
+        lowered = ctx.verb.parameter.lower()
+        try:
+            if ctx.verb.parameter.strip().startswith("{") and ctx.verb.parameter.strip().endswith(
+                "}"
+            ):
+                embed = self.text_to_embed(ctx.verb.parameter)
+            elif lowered in self.ATTRIBUTE_HANDLERS and ctx.verb.payload:
+                embed = self.get_embed(ctx)
+                embed = self.update_embed(embed, lowered, ctx.verb.payload)
+            else:
+                return
+        except EmbedParseError as error:
+            return self.return_error(error)
+
+        return self.return_embed(ctx, embed)

bTagScript/block/discord_blocks/override_block.py

@@ -0,0 +1,61 @@
+from typing import Optional
+
+from ...interface import Block
+from ...interpreter import Context
+
+
+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]}``
+
+    **Aliases:** ``bypass``
+
+    **Payload:** ``command``
+
+    **Parameter:** ``"admin", "mod", "permissions"``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {override}
+        overrides all commands and permissions
+
+        {override(admin)}
+        overrides commands that require the admin role
+
+        {bypass(permissions)}
+        {bypass(mod)}
+        overrides commands that require the mod role or have user permission requirements
+    """
+
+    ACCEPTED_NAMES = ("override", "bypass")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block and update response.actions with correct overrides
+        """
+        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 ""

bTagScript/block/discord_blocks/react_block.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+from ...interface import verb_required_block
+from ...interpreter import Context
+
+
+class ReactBlock(verb_required_block(True, payload=True)):
+    """
+    The react block will set the actions "react" key to a list of reactions.
+
+    .. note::
+
+        You must set the behaviour manually.
+
+    **Usage:** ``{react:<emojis>}``
+
+    **Aliases:** ``None``
+
+    **Payload:** ``emojis``
+
+    **Parameter:** ``None``
+
+    .. tagscript::
+
+        {react:💩}
+        {react:💩,:)}
+        {react:💩~:)~:D}
+    """
+
+    ACCEPTED_NAMES = ("react",)
+
+    def __init__(self, limit: int = 5) -> None:
+        """
+        Initialize the block
+
+        Limit is the maximum number of reactions the block will add
+        """
+        self.limit = limit
+        super().__init__()
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the reactions
+        """
+        reactions = ctx.verb.payload.strip().split("~" if "~" in ctx.verb.payload else ",")
+        if len(reactions) > self.limit:
+            return f"`Reaction Limit Reached ({self.limit})`"
+        ctx.response.actions["reactions"] = reactions
+        return ""

bTagScript/block/discord_blocks/redirect_block.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+from ...interface import verb_required_block
+from ...interpreter import Context
+
+
+class RedirectBlock(verb_required_block(True, parameter=True)):
+    """
+    Redirects the tag response to either the given channel, the author's DMs,
+    or uses a reply based on what is passed to the parameter.
+
+    **Usage:** ``{redirect(<"dm"|"reply"|channel>)}``
+
+    **Payload:** ``None``
+
+    **Parameter:** ``"dm", "reply", "channel"``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {redirect(dm)}
+        {redirect(reply)}
+        {redirect(#general)}
+        {redirect(626861902521434160)}
+    """
+
+    ACCEPTED_NAMES = ("redirect",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the redirect block and params
+        """
+        param = ctx.verb.parameter.strip()
+        if param.lower() == "dm":
+            target = "dm"
+        elif param.lower() == "reply":
+            target = "reply"
+        else:
+            target = param
+        ctx.response.actions["target"] = target
+        return ""

bTagScript/block/discord_blocks/requirement_blocks.py

@@ -0,0 +1,83 @@
+from typing import Optional
+
+from ...interface import verb_required_block
+from ...interpreter import Context
+
+
+class RequireBlock(verb_required_block(True, parameter=True)):
+    """
+    The require block will attempt to convert the given parameter into a channel
+    role or member, using name or ID. If the user running the tag is not in the
+    targeted channel or doesn't have the targeted role, the tag will stop processing
+    and it will send the response if one is given. Multiple role or channel
+    requirements can be given, and should be split by a ",".
+
+    **Usage:** ``{require(<role, channel, member>):[response]}``
+
+    **Aliases:** ``whitelist``
+
+    **Payload:** ``response``
+
+    **Parameter:** ``role, channel, member``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {require(Moderator)}
+        {require(#general, #bot-cmds):This tag can only be run in #general and #bot-cmds.}
+        {require(757425366209134764, 668713062186090506, 737961895356792882):You aren't allowed to use this tag.}
+    """
+
+    ACCEPTED_NAMES = ("require", "whitelist")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the requirements
+        """
+        actions = ctx.response.actions.get("requires")
+        if actions:
+            return None
+        ctx.response.actions["requires"] = {
+            "items": [i.strip() for i in ctx.verb.parameter.split(",")],
+            "response": ctx.verb.payload,
+        }
+        return ""
+
+
+class BlacklistBlock(verb_required_block(True, parameter=True)):
+    """
+    The blacklist block will attempt to convert the given parameter into a channel
+    or role, using name or ID. If the user running the tag is in the targeted
+    channel or has the targeted role, the tag will stop processing and
+    it will send the response if one is given. Multiple role or channel
+    requirements can be given, and should be split by a ",".
+
+    **Usage:** ``{blacklist(<role,channel>):[response]}``
+
+    **Payload:** ``response``
+
+    **Parameter:** ``role, channel``
+
+    **Examples:**
+
+    .. tagscript::
+        {blacklist(Muted)}
+        {blacklist(#support):This tag is not allowed in #support.}
+        {blacklist(Tag Blacklist, 668713062186090506):You are blacklisted from using tags.}
+    """
+
+    ACCEPTED_NAMES = ("blacklist",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the blacklists
+        """
+        actions = ctx.response.actions.get("blacklist")
+        if actions:
+            return None
+        ctx.response.actions["blacklist"] = {
+            "items": [i.strip() for i in ctx.verb.parameter.split(",")],
+            "response": ctx.verb.payload,
+        }
+        return ""

bTagScript/block/helpers.py

@@ -0,0 +1,121 @@
+"""
+Helpers for blocks, mainly for parsing expressions
+"""
+
+import re
+from typing import List, Optional
+
+__all__ = ("implicit_bool", "helper_parse_if", "helper_split", "helper_parse_list_if")
+
+SPLIT_REGEX = re.compile(r"(?<!\\)\|")
+BOOL_LOOKUP = {"true": True, "false": False}  # potentially add more bool values
+
+
+def implicit_bool(string: str) -> Optional[bool]:
+    """
+    Parse a string to a boolean.
+
+    >>> implicit_bool("true")
+    True
+    >>> implicit_bool("FALSE")
+    False
+    >>> implicit_bool("abc")
+    None
+
+    Parameters
+    ----------
+    string: str
+        The string to convert.
+
+    Returns
+    -------
+    bool
+        The boolean value of the string.
+    None
+        The string failed to parse.
+    """
+    return BOOL_LOOKUP.get(string.lower())
+
+
+def helper_parse_if(string: str) -> Optional[bool]:
+    """
+    Parse an expression string to a boolean.
+
+    >>> helper_parse_if("this == this")
+    True
+    >>> helper_parse_if("2>3")
+    False
+    >>> helper_parse_if("40 >= 40")
+    True
+    >>> helper_parse_if("False")
+    False
+    >>> helper_parse_if("1")
+    None
+
+    Parameters
+    ----------
+    string: str
+        The string to convert.
+
+    Returns
+    -------
+    bool
+        The boolean value of the expression.
+    None
+        The expression failed to parse.
+    """
+    value = implicit_bool(string)
+    if value is not None:
+        return value
+    try:
+        if "!=" in string:
+            spl = string.split("!=")
+            return spl[0].strip() != spl[1].strip()
+        if "==" in string:
+            spl = string.split("==")
+            return spl[0].strip() == spl[1].strip()
+        if ">=" in string:
+            spl = string.split(">=")
+            return float(spl[0].strip()) >= float(spl[1].strip())
+        if "<=" in string:
+            spl = string.split("<=")
+            return float(spl[0].strip()) <= float(spl[1].strip())
+        if ">" in string:
+            spl = string.split(">")
+            return float(spl[0].strip()) > float(spl[1].strip())
+        if "<" in string:
+            spl = string.split("<")
+            return float(spl[0].strip()) < float(spl[1].strip())
+    except:  # pylint: disable=bare-except
+        pass
+
+
+def helper_split(
+    split_string: str, easy: bool = True, *, maxsplit: int = None
+) -> Optional[List[str]]:
+    """
+    A helper method to universalize the splitting logic used in multiple
+    blocks and adapters. Please use this wherever a verb needs content to
+    be chopped at | , or ~!
+
+    >>> helper_split("this, should|work")
+    ["this, should", "work"]
+    """
+    args = (maxsplit,) if maxsplit is not None else ()
+    if "|" in split_string:
+        return SPLIT_REGEX.split(split_string, *args)
+    if easy and "~" in split_string:
+        return split_string.split("~", *args)
+    if easy and "," in split_string:
+        return split_string.split(",", *args)
+    return
+
+
+def helper_parse_list_if(if_string: str) -> Optional[List[str]]:
+    """
+    Returns a list of bool strings from a string.
+    """
+    split = helper_split(if_string, False)
+    if split is None:
+        return [helper_parse_if(if_string)]
+    return [helper_parse_if(item) for item in split]