bTagScript 5.0.0__py3-none-any.whl

bTagScript/block/comment_block.py

@@ -0,0 +1,33 @@
+from typing import Optional
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+class CommentBlock(Block):
+    """
+    The comment block is literally just for comments, it will not be
+    parsed, however it will be removed from your codes output.
+
+    **Usage:** ``{comment([other]):[text]}``
+
+    **Aliases:** /, Comment, comment, //
+
+    **Payload:** ``text``
+
+    **Parameter:** ``other``
+
+    .. tagscript::
+
+        {//:Comment!}
+
+        {Comment(Something):Comment!}
+    """
+
+    ACCEPTED_NAMES = ("/", "comment", "//")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Remove the block
+        """
+        return ""

bTagScript/block/control_block.py

@@ -0,0 +1,161 @@
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+from . import helper_parse_if, helper_parse_list_if, helper_split
+
+
+def parse_into_output(payload: str, result: Optional[bool]) -> Optional[str]:
+    """
+    Parse a payload into an output.
+    """
+    if result is None:
+        return
+    try:
+        output = helper_split(payload, False)
+        if output is not None and len(output) == 2:
+            if result:
+                return output[0]
+            return output[1]
+        elif result:
+            return payload
+        else:
+            return ""
+    except:  # pylint: disable=bare-except
+        return
+
+
+ImplicitPPRBlock = verb_required_block(True, payload=True, parameter=True)
+
+
+class AnyBlock(ImplicitPPRBlock):
+    """
+    The any block checks that any of the passed expressions are true.
+    Multiple expressions can be passed to the parameter by splitting them with ``|``.
+
+    The payload is a required message that must be split by ``|``.
+    If the expression evaluates true, then the message before the ``|`` is returned, else the message after is returned.
+
+    **Usage:** ``{any(<expression|expression|...>):<message>}``
+
+    **Aliases:** ``or``
+
+    **Payload:** ``message``
+
+    **Parameter:** ``expression``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {any(hi=={args}|hello=={args}|heyy=={args}):Hello {user}!|How rude.}
+        If {args} is hi
+        Hello _Leg3ndary#0001!
+
+        If {args} is what's up!
+        How rude.
+    """
+
+    ACCEPTED_NAMES = ("any", "or")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the any block
+        """
+        result = any(helper_parse_list_if(ctx.verb.parameter) or [])
+        return parse_into_output(ctx.verb.payload, result)
+
+
+class AllBlock(ImplicitPPRBlock):
+    """
+    The all block checks that all of the passed expressions are true.
+    Multiple expressions can be passed to the parameter by splitting them with ``|``.
+
+    The payload is a required message that must be split by ``|``.
+    If the expression evaluates true, then the message before the ``|`` is returned, else the message after is returned.
+
+    **Usage:** ``{all(<expression|expression|...>):<message>}``
+
+    **Aliases:** ``and``
+
+    **Payload:** ``message``
+
+    **Parameter:** ``expression``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {all({args}>=100|{args}<=1000):You picked {args}.|You must provide a number between 100 and 1000.}
+        # if {args} is 52
+        You must provide a number between 100 and 1000.
+
+        # if {args} is 282
+        You picked 282.
+    """
+
+    ACCEPTED_NAMES = ("all", "and")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process all the expressions
+        """
+        result = all(helper_parse_list_if(ctx.verb.parameter) or [])
+        return parse_into_output(ctx.verb.payload, result)
+
+
+class IfBlock(ImplicitPPRBlock):
+    """
+    The if block returns a message based on the passed expression to the parameter.
+    An expression is represented by two values compared with an operator.
+
+    The payload is a required message that must be split by ``|``.
+    If the expression evaluates true, then the message before the ``|`` is returned, else the message after is returned.
+
+    **Expression Operators:**
+
+    +----------+--------------------------+---------+---------------------------------------------+
+    | Operator | Check                    | Example | Description                                 |
+    +==========+==========================+=========+=============================================+
+    | ``==``   | equality                 | a==a    | value 1 is equal to value 2                 |
+    +----------+--------------------------+---------+---------------------------------------------+
+    | ``!=``   | inequality               | a!=b    | value 1 is not equal to value 2             |
+    +----------+--------------------------+---------+---------------------------------------------+
+    | ``>``    | greater than             | 5>3     | value 1 is greater than value 2             |
+    +----------+--------------------------+---------+---------------------------------------------+
+    | ``<``    | less than                | 4<8     | value 1 is less than value 2                |
+    +----------+--------------------------+---------+---------------------------------------------+
+    | ``>=``   | greater than or equality | 10>=10  | value 1 is greater than or equal to value 2 |
+    +----------+--------------------------+---------+---------------------------------------------+
+    | ``<=``   | less than or equality    | 5<=6    | value 1 is less than or equal to value 2    |
+    +----------+--------------------------+---------+---------------------------------------------+
+
+    **Usage:** ``{if(<expression>):<message>]}``
+
+    **Payload:** ``message``
+
+    **Parameter:** ``expression``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {if(63=={args}):You guessed it! The number I was thinking of was 63!|Too {if({args}<63):low|high}, try again.}
+        If args is 63
+        You guessed it! The number I was thinking of was 63!
+
+        If args is 73
+        Too low, try again.
+
+        If args is 14
+        Too high, try again.
+    """
+
+    ACCEPTED_NAMES = ("if",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the if block
+        """
+        result = helper_parse_if(ctx.verb.parameter)
+        return parse_into_output(ctx.verb.payload, result)

bTagScript/block/counting_blocks.py

@@ -0,0 +1,88 @@
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class CountBlock(verb_required_block(True, payload=True)):
+    """
+    The count block will count how much of text is in message.
+    This is case sensitive and will include substrings, if you
+    don't provide a parameter, it will count the spaces in the
+    message.
+
+
+    **Usage:** ``{count([text]):<message>}``
+
+    **Aliases:** ``None``
+
+    **Payload:** ``message``
+
+    **Parameter:** text
+
+    .. tagscript::
+
+        {count(Tag):TagScript}
+        1
+
+        {count(Tag):Tag Script TagScript}
+        2
+
+        {count(t):Hello World, Tag, Script}
+        1 as there's only one lowercase t in the entire string
+    """
+
+    ACCEPTED_NAMES = ("count",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Check the count of a string
+        """
+        if ctx.verb.parameter:
+            return str(ctx.verb.payload.count(ctx.verb.parameter))
+        return str(ctx.verb.payload.count(" "))
+
+
+class LengthBlock(verb_required_block(True, payload=True)):
+    """
+    The length block will check the length of the given String.
+    If a parameter is passed in, the block will check the length
+    based on what you passed in, w for word, s for spaces.
+    If you provide an invalid parameter, the block will return -1.
+
+    **Usage:** ``{length(["w", "s"]):<text>}``
+
+    **Aliases:** ``len``
+
+    **Payload:** ``text``
+
+    **Parameter:** ``"w", "s"``
+
+    .. tagscript::
+
+        {length:TagScript}
+        9
+
+        {len(w):Tag Script}
+        2
+
+        {len(s):Hello World, Tag, Script}
+        3
+
+        {len(space):Hello World, Tag, Script}
+        -1
+    """
+
+    ACCEPTED_NAMES = ("length", "len")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Check the length of a string
+        """
+        if ctx.verb.parameter:
+            if ctx.verb.parameter in ("w", "words", "word"):
+                return str(len(ctx.verb.payload.split(" ")))
+            if ctx.verb.parameter in ("s", "spaces", "space"):
+                return str(len(ctx.verb.payload.split(" ")) - 1)
+            return "-1"
+        return str(len(ctx.verb.payload))

bTagScript/block/digitshorthand_block.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from ..interface import Block
+from ..interpreter import Context
+from ..verb import Verb
+
+
+class DigitShorthandBlock(Block):
+    """
+    DigitShorthand Blocks are used to provide a shorthand for variables.
+    This is usually used for arguments, so you can set {1} == {args(1)}
+    {2} == {args(2)} etc.
+
+    .. tagscript::
+
+        Check the description.
+    """
+
+    def __init__(self, var_name: str) -> None:
+        """
+        Initialize the DigitShorthandBlock with the block you want to be digitted. If thats a word.
+        """
+        self.redirect_name = var_name
+
+    def will_accept(self, ctx: Context) -> bool:  # pylint: disable=arguments-differ
+        """
+        Check if the declaration is a digit
+        """
+        return ctx.verb.declaration.isdigit()
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the digital shorthand
+        """
+        blank = Verb()
+        blank.declaration = self.redirect_name
+        blank.parameter = ctx.verb.declaration
+        ctx.verb = blank

bTagScript/block/discord_blocks/__init__.py

@@ -0,0 +1,20 @@
+from .command_block import CommandBlock
+from .cooldown_block import CooldownBlock
+from .delete_block import DeleteBlock
+from .embed_block import EmbedBlock
+from .override_block import OverrideBlock
+from .react_block import ReactBlock
+from .redirect_block import RedirectBlock
+from .requirement_blocks import BlacklistBlock, RequireBlock
+
+__all__ = (
+    "CommandBlock",
+    "OverrideBlock",
+    "CooldownBlock",
+    "DeleteBlock",
+    "EmbedBlock",
+    "ReactBlock",
+    "RedirectBlock",
+    "BlacklistBlock",
+    "RequireBlock",
+)

bTagScript/block/discord_blocks/command_block.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+from ...interface import verb_required_block
+from ...interpreter import Context
+
+
+class CommandBlock(verb_required_block(True, payload=True)):
+    """
+    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:**
+
+    .. tagscript::
+
+        {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 = ("c", "com", "command")
+
+    def __init__(self, limit: int = 3) -> None:
+        """
+        Construct the command block.
+        """
+        self.limit = limit
+        super().__init__()
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block and update response.actions
+        """
+        command = ctx.verb.payload.strip()
+        actions = ctx.response.actions.get("commands")
+        if actions:
+            if len(actions) >= self.limit:
+                return f"<{ctx.verb.declaration} error: limit reached ({self.limit})>"
+        else:
+            ctx.response.actions["commands"] = []
+        ctx.response.actions["commands"].append(command)
+        return ""

bTagScript/block/discord_blocks/cooldown_block.py

@@ -0,0 +1,101 @@
+import time
+from typing import Any, Dict, Optional
+
+from discord.ext.commands import CooldownMapping
+
+from ...exceptions import CooldownExceeded
+from ...interface import verb_required_block
+from ...interpreter import Context
+from ..helpers import helper_split
+
+__all__ = ("CooldownBlock",)
+
+
+class CooldownBlock(verb_required_block(True, payload=True, parameter=True)):
+    """
+    The cooldown block implements cooldowns when running a tag.
+    The parameter requires 2 values to be passed: ``rate`` and ``per`` integers.
+    The ``rate`` is the number of times the tag can be used every ``per`` seconds.
+
+    The payload requires a ``key`` value, which is the key used to store the cooldown.
+    A key should be any string that is unique. If a channel's ID is passed as a key,
+    the tag's cooldown will be enforced on that channel. Running the tag in a separate channel
+    would have a different cooldown with the same ``rate`` and ``per`` values.
+
+    The payload also has an optional ``message`` value, which is the message to be sent when the
+    cooldown is exceeded. If no message is passed, the default message will be sent instead.
+    The cooldown message supports 2 blocks: ``key`` and ``retry_after``.
+
+    **Usage:** ``{cooldown(<rate>|<per>):<key>|[message]}``
+
+    **Payload:** ``key, message``
+
+    **Parameter:** ``rate, per``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {cooldown(1|10):{author(id)}}
+        the tag author used the tag more than once in 10 seconds
+        The bucket for 741074175875088424 has reached its cooldown. Retry in 3.25 seconds."
+
+        {cooldown(3|3):{channel(id)}|Slow down! This tag can only be used 3 times per 3 seconds per channel. Try again in **{retry_after}** seconds."}
+        the tag was used more than 3 times in 3 seconds in a channel
+        Slow down! This tag can only be used 3 times per 3 seconds per channel. Try again in **0.74** seconds.
+    """
+
+    ACCEPTED_NAMES = ("cooldown",)
+    COOLDOWNS: Dict[Any, CooldownMapping] = {}
+
+    @classmethod
+    def create_cooldown(cls, key: Any, rate: int, per: int) -> CooldownMapping:
+        """
+        Create a new cooldown for the given key.
+        """
+        cooldown = CooldownMapping.from_cooldown(rate, per, lambda x: x)
+        cls.COOLDOWNS[key] = cooldown
+        return cooldown
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the cooldown block.
+        """
+        verb = ctx.verb
+        try:
+            rate, per = helper_split(verb.parameter, maxsplit=1)
+            per = int(per)
+            rate = float(rate)
+        except (ValueError, TypeError):
+            return
+
+        if split := helper_split(verb.payload, False, maxsplit=1):
+            key, message = split
+        else:
+            key = verb.payload
+            message = None
+
+        cooldown_key = ctx.response.extras.get("cooldown_key")
+        if cooldown_key is None:
+            cooldown_key = ctx.original_message
+        try:
+            cooldown = self.COOLDOWNS[cooldown_key]
+            base = cooldown._cooldown  # pylint: disable=protected-access
+            if (rate, per) != (base.rate, base.per):
+                cooldown = self.create_cooldown(cooldown_key, rate, per)
+        except KeyError:
+            cooldown = self.create_cooldown(cooldown_key, rate, per)
+
+        current = time.time()
+        bucket = cooldown.get_bucket(key, current)
+        retry_after = bucket.update_rate_limit(current)
+        if retry_after:
+            retry_after = round(retry_after, 2)
+            if message:
+                message = message.replace("{key}", str(key)).replace(
+                    "{retry_after}", str(retry_after)
+                )
+            else:
+                message = f"The bucket for {key} has reached its cooldown. Retry in {retry_after} seconds."
+            raise CooldownExceeded(message, bucket, key, retry_after)
+        return ""

bTagScript/block/discord_blocks/delete_block.py

@@ -0,0 +1,47 @@
+from typing import Optional
+
+from ...interface import Block
+from ...interpreter import Context
+from .. import helper_parse_if
+
+
+class DeleteBlock(Block):
+    """
+    The delete block will delete the message if the condition provided in
+    the parameter is met, or if just the block is added, the message will
+    be deleted. Only one delete block will be processed, the rest,
+    removed, but ignored.
+
+    .. note::
+
+        This block will only set the actions "delete" key to True/False.
+        You must set the behaviour manually.
+
+    **Usage:** ``{delete(<expression>)}``
+
+    **Aliases:** ``del``
+
+    **Payload:** ``None``
+
+    **Parameter:** ``expression``
+
+    .. tagscript::
+
+        {delete}
+        {del(true==true)}
+    """
+
+    ACCEPTED_NAMES = ("delete", "del")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the delete
+        """
+        if "delete" in ctx.response.actions.keys():
+            return ""
+        if ctx.verb.parameter is None:
+            value = True
+        else:
+            value = helper_parse_if(ctx.verb.parameter)
+        ctx.response.actions["delete"] = value
+        return ""