AdvancedTagScript 3.2.5__tar.gz → 3.3.0__tar.gz

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/AdvancedTagScript.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AdvancedTagScript
-Version: 3.2.5
+Version: 3.3.0
 Summary: An easy drop in user-provided Templating system.
 Home-page: https://github.com/cool-aid-man/TagScriptEngine
 Author: cool-aid-man, inthedark.org, PhenoM4n4n

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/AdvancedTagScript.egg-info/SOURCES.txt

@@ -32,12 +32,15 @@ TagScriptEngine/block/command.py
 TagScriptEngine/block/control.py
 TagScriptEngine/block/cooldown.py
 TagScriptEngine/block/count.py
+TagScriptEngine/block/cycleblock.py
 TagScriptEngine/block/embedblock.py
 TagScriptEngine/block/fiftyfifty.py
 TagScriptEngine/block/helpers.py
 TagScriptEngine/block/joinblock.py
+TagScriptEngine/block/listblock.py
 TagScriptEngine/block/loosevariablegetter.py
 TagScriptEngine/block/mathblock.py
+TagScriptEngine/block/ordblock.py
 TagScriptEngine/block/randomblock.py
 TagScriptEngine/block/range.py
 TagScriptEngine/block/redirect.py

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AdvancedTagScript
-Version: 3.2.5
+Version: 3.3.0
 Summary: An easy drop in user-provided Templating system.
 Home-page: https://github.com/cool-aid-man/TagScriptEngine
 Author: cool-aid-man, inthedark.org, PhenoM4n4n

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/__init__.py

@@ -24,7 +24,6 @@ from .block import (
     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,
     AllowedMentionsBlock as AllowedMentionsBlock,
     AllBlock as AllBlock,
     AnyBlock as AnyBlock,
@@ -57,6 +56,9 @@ from .block import (
     LengthBlock as LengthBlock,
     CooldownBlock as CooldownBlock,
     JoinBlock as JoinBlock,
+    ListBlock as ListBlock,
+    CycleBlock as CycleBlock,
+    OrdinalBlock as OrdinalBlock,
 
 )
 from .interface import (
@@ -100,7 +102,6 @@ __all__: Tuple[str, ...] = (
     "helper_parse_if",
     "helper_parse_list_if",
     "helper_split",
-    "easier_helper_split",
     "AllowedMentionsBlock",
     "AllBlock",
     "AnyBlock",
@@ -133,6 +134,9 @@ __all__: Tuple[str, ...] = (
     "CountBlock",
     "LengthBlock",
     "JoinBlock",
+    "ListBlock",
+    "CycleBlock",
+    "OrdinalBlock",
 
     "SafeObjectAdapter",
     "StringAdapter",
@@ -177,7 +181,7 @@ __all__: Tuple[str, ...] = (
 )
 
 
-__version__: Final[str] = "3.2.5"
+__version__: Final[str] = "3.3.0"
 
 
 class VersionNamedTuple(NamedTuple):

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/adapter/redbotadapters.py

@@ -103,7 +103,7 @@ class RedBotAdapter(SimpleAdapter["Red"]):
         Percentage of chunked guilds the bot has.
 
     .. warning::
-        Attributes denoting `(*)` can only be used by the bot owner.
+        Attributes denoting ``(*)`` can only be used by the bot owner.
     """
 
     if not _has_redbot:

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/block/__init__.py

@@ -3,13 +3,12 @@ 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,
-)
+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,
+)
 
 # isort: on
 from .allowedmentions import (
@@ -92,14 +91,22 @@ from .count import (
 from .joinblock import (
     JoinBlock as JoinBlock,
 )
+from .listblock import (
+    ListBlock as ListBlock,
+)
+from .cycleblock import (
+    CycleBlock as CycleBlock,
+)
+from .ordblock import (
+    OrdinalBlock as OrdinalBlock,
+)
 
 __all__: Tuple[str, ...] = (
     "implicit_bool",
-    "helper_parse_if",
-    "helper_parse_list_if",
-    "helper_split",
-    "easier_helper_split",
-    "AllowedMentionsBlock",
+    "helper_parse_if",
+    "helper_parse_list_if",
+    "helper_split",
+    "AllowedMentionsBlock",
     "AllBlock",
     "AnyBlock",
     "AssignmentBlock",
@@ -131,4 +138,7 @@ __all__: Tuple[str, ...] = (
     "CountBlock",
     "LengthBlock",
     "JoinBlock",
+    "ListBlock",
+    "CycleBlock",
+    "OrdinalBlock",
 )

advancedtagscript-3.3.0/TagScriptEngine/block/assign.py

@@ -0,0 +1,217 @@
+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 storing a value and referencing it later in a tag.
+    Variables can be referenced using brackets as any other block.
+
+    .. note::
+        - Variables are not parsed by default. You must use the ``parse`` method to parse a variable.
+        - They are one of the most versatile and powerful features of TagScript.
+        - By default, a tag cannot store data between invocations. This is where ``variables`` come in.
+        - They are the only way to **store** data. And later **retrieve** it within the same invocation.
+
+    **Usage:** ``{=(<name>):<value>}``
+
+    **Aliases:** ``assign, let, var``
+
+    **Payload:** value
+
+    **Parameter:** name
+
+    **Examples:**
+    
+    .. code-block:: yaml
+
+        {=(message1):Hi there! How are you?}
+        {=(message2):It's a beautiful day today!}
+        {=(message3):Did you know that TagScript is a powerful tool?}
+
+        Now, call the variables by their names:
+        {message1} # Hi there! How are you?
+        {message2} # It's a beautiful day today!
+        {message3} # Did you know that TagScript is a powerful tool?
+        
+        More example:
+        {=(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.
+
+    .. caution::
+        - You can name variables with **anything** ``except`` existing block names or aliases.
+        - They will ``not`` reference the value in payload, if the name is same as an existing block name or alias.
+    
+    ----
+    
+    .. important:: How Argument Parsing Works - In Detail
+
+    - A variable is essentially a string that can be treated as a sequence of elements (words, numbers, etc.) when accessed.
+      These **elements** are split using ``delimiters`` (spaces by default) and are indexed sequentially starting from ``1``.
+    - A delimiter is a sequence of one or more characters that are used to split a string into a sequence of elements.
+    - Once a variable is assigned, its value can be referenced and ``parsed`` (split and indexed)
+      to extract ``specific`` parts. Let's take a look at **how** it works.
+    - Parsing out of bounds index will return the whole string.
+    
+    ----
+    
+    .. rubric:: **Basic Argument Parsing**
+    
+    Example
+        - "Coolaid is setting up the table. So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves"
+
+    - So, our ``argument`` or ``args`` in short, would be:
+
+    .. code-block:: yaml
+
+        {=(args):Coolaid is setting up the table. So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves}
+
+    .. note:: ``args`` is just a variable name, perhaps the most common name, but you can name it anything.
+
+    - Since, the default delimiter is ``space``, so you can access the ``each element`` as follows:
+
+    .. code-block:: yaml
+
+        {args(1)}  -> Coolaid
+        {args(2)}  -> is
+        {args(3)}  -> setting
+        {args(4)}  -> up
+        {args(5)}  -> the
+        {args(6)}  -> table.
+
+        {args(31)} -> Would return the whole string since it doesn't exist (indexing 31st element is out of bounds).
+
+    - ``0`` is special and returns the ``last`` element:
+
+    .. code-block:: yaml
+
+        {args(0)}  -> gloves
+    
+    - Negative indices allow you to access elements from the end of the sequence:
+
+    .. code-block:: yaml
+
+        {args(-1)}  -> work
+        {args(-2)}  -> of
+        {args(-3)}  -> pair
+        {args(-4)}  -> a
+        {args(-5)}  -> and
+        {args(-6)}  -> level,
+
+    .. rubric:: Prefix Range Access (``+n``)
+    
+    - Prefixing an index with ``+`` returns all elements from the start up to and including that position:
+
+    .. code-block:: yaml
+
+        {args(+3)}   -> Coolaid is setting
+        {args(+7)}   -> Coolaid is setting up the table. So,
+        {args(+13)}  -> Coolaid is setting up the table. So, he grabbed - a cordless drill,
+
+    .. rubric:: Suffix Range Access (``n+``)
+
+    - Suffixing an index with ``+`` returns all elements from that position (counting from the start) to the end:
+
+    .. code-block:: yaml
+
+        {args(3+)}   -> setting up the table. So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves
+        {args(7+)}   -> So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves
+        {args(13+)}  -> drill, some screws, a spirit level, and a pair of work gloves
+
+    .. rubric:: Negative Range Access (``-n+``)
+
+    - Appending ``+`` to an negative-index returns a range — all elements from that position to the end:
+    - Negative indices are **first** resolved from the end of the sequence,
+      then range access continues forward to the end.
+
+    .. code-block:: yaml
+
+        {args(-1+)}   -> work gloves # Since {args(0)} == gloves
+        {args(-11+)}  -> drill, some screws, a spirit level, and a pair of work gloves
+
+    .. tip::
+        - ``+n``   → from start → n
+        - ``n+``   → from n → end (index resolved first)
+        - ``-n``   → nth element from end
+        - ``-n+``  → nth element from end → then forward to end (index resolved first)
+    
+    -----
+    
+    .. rubric:: **Advanced Argument Parsing**
+
+    A **custom delimiter** can be passed as the payload to change how
+    the value is split. The syntax is ``{variable(index):delimiter}``:
+
+    .. code-block:: yaml
+
+        # Using the same argument as before.
+        {=(args):Coolaid is setting up the table. So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves}
+
+        1st Example:
+        {args(1):.}  -> Coolaid is setting up the table
+        {args(2):.}  -> So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves
+        {args(3):.}  -> Would return the entire string since there is no 3rd element.
+
+        2nd Example:
+        {args(1):-}  -> Coolaid is setting up the table. So, he grabbed
+        {args(2):-}  -> a cordless drill, some screws, a spirit level, and a pair of work gloves
+
+    .. note::
+        - In the 1st example, the custom delimiter is ``.``, hence the string is split by ``.`` leaving 2 elements.
+        - In the 2nd example, the custom delimiter is ``-``, hence the string is split by ``-`` leaving 2 elements.
+        - Since in both the examples, there are ``2 elements``, so ``args(3)`` would  return the entire string.
+          Because the index ``3rd`` element is out of bounds.
+
+    .. rubric:: **Nested Variables**
+    
+    - Variables can be **nested** to perform multi-level parsing:
+
+    .. code-block:: yaml
+
+        {=(raw):A - B, C, D}
+        {=(part):{raw(2):-}} 
+        
+        # "{raw(2):-}" splits "raw" by "-" and returns the 2nd element -> "B, C, D" (1st element is "A")
+        # Therefore, "part" == "B, C, D"
+        
+        {part(1):,}  -> B
+        {part(2):,}  -> C
+
+        Another Example:
+        # What if you want to parse through the things that Coolaid grabbed?
+        # If you look closely the "-" delimiter is placed conveniently to separate the items. So, we'll use it:
+    
+        {=(args):Coolaid is setting up the table. So, he grabbed - a cordless drill, some screws, a spirit level, and a pair of work gloves}
+        {=(items):{args(2):-}}
+        
+        # "{args(2):-}" splits "args" by "-" and returns the 2nd element -> "a cordless drill, ... and a pair of work gloves"
+        # Therefore, "items" == "a cordless drill, some screws, a spirit level, and a pair of work gloves"
+        
+        Items:
+        {items(1):,}  -> a cordless drill
+        {items(2):,}  -> some screws
+        {items(3):,}  -> a spirit level
+        {items(4):,}  -> and a pair of work gloves
+
+    """
+
+    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 ""

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/block/case.py

@@ -25,6 +25,7 @@ class UpperBlock(Block):
         The text is {upper(ThIs Is A TeXt)}!
         # The text is THIS IS A TEXT!
 
+        {=(args):Hello World}
         You have entered {upper({args})}!
         # You have entered HELLO WORLD!
     """
@@ -52,6 +53,7 @@ class LowerBlock(Block):
         The text is {lower(ThIs Is A TeXt)}!
         # The text is this is a text!
 
+        {=(args):HELLO WORLD}
         You have entered {lower({args})}!
         # You have entered hello world!
     """

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/block/command.py

@@ -114,7 +114,7 @@ class SequentialGather(Awaitable[T]):
 
     Returns
     -------
-    `List[T]`
+    ``List[T]``
         the result object.
     """
 

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/block/cooldown.py

@@ -28,6 +28,9 @@ class CooldownBlock(verb_required_block(True, payload=True, parameter=True)):  #
     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``.
 
+    .. note::
+        - Delimiter for the parameter (``<rate>`` and ``<per>``): ``|`` or ``~``. Where ``|`` takes priority over ``~``.
+
     **Usage:** ``{cooldown(<rate>|<per>):<key>|[message]}``
 
     **Payload:** key, message

advancedtagscript-3.3.0/TagScriptEngine/block/cycleblock.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("CycleBlock",)
+
+
+class CycleBlock(verb_required_block(True, payload=True, parameter=True)):  # type: ignore
+    """
+    The cycle block returns the element in the payload that corresponds to the
+    index value in the parameter. If the index is out of bounds, it loops around
+    using modulo (``index % list_length``).
+
+    List and Cycle blocks are another way to parse through a list of values in
+    TagScript. They both strictly use either commas ``,`` or tildes ``~`` as the
+    delimiters for the list placed in the block's payload. Use tildes when elements
+    contain commas. These blocks only function in Tags.
+
+    Cycles use ``0`` as the index for the first element. Negative values allow
+    for backward parsing. The block will return an error message if the value in
+    the parameter is not a number.
+
+    **Usage:** ``{cycle(<index>):<elem>,<elem2>,...}``
+
+    **Aliases:** ``None``
+
+    **Payload:** list of elements (comma or tilde separated)
+
+    **Parameter:** index
+
+    **Examples:**
+    
+    .. code-block:: yaml
+
+        {cycle(1):Cake,Candy,Chips,Cookies,Donut}
+        # Candy
+
+        {cycle(13):Cake,Candy,Chips,Cookies,Donut}
+        # Cookies
+        # (The list has 5 elements. 13 modulo 5 = 3. Index 3 is "Cookies".)
+
+        {cycle(3):0,1,2}
+        # 0
+        # (3 modulo 3 = 0. Index 0 is "0".)
+
+        Negative indices:
+        {cycle(-1):Apple,Banana,Cherry}
+        # Cherry
+
+        {cycle(-69):Charlie,Aid,Bob,Dave,Eve,Phen,Steve,Tom,Wendy,Xavier}
+        # Aid
+        # (-69 modulo 10 = 1. Index 1 is "Aid".)
+
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("cycle",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        try:
+            index = int(cast(str, ctx.verb.parameter))
+        except (ValueError, TypeError):
+            return "Invalid index: parameter must be a number."
+
+        payload = cast(str, ctx.verb.payload)
+        if "~" in payload:
+            items = payload.split("~")
+        else:
+            items = payload.split(",")
+
+        return items[index % len(items)]

{advancedtagscript-3.2.5 → advancedtagscript-3.3.0}/TagScriptEngine/block/embedblock.py

@@ -8,10 +8,9 @@ from discord import Colour, Embed
 
 from ..interface import Block
 from ..interpreter import Context
-from .helpers import helper_split, easier_helper_split, implicit_bool
+from .helpers import helper_split, implicit_bool
 from ..utils import truncate
 from ..exceptions import BadColourArgument, EmbedParseError
-from .._warnings import removal
 
 try:
     import orjson  # noqa: F401
@@ -59,8 +58,10 @@ def set_dynamic_url(embed: Embed, attribute: str, value: str) -> None:
 
 
 def add_field(embed: Embed, _: str, payload: str) -> None:
-    if (data := easier_helper_split(payload, maxsplit=3)) is None:  # type: ignore
-        raise EmbedParseError("`add_field` payload was not split by |")
+    if (data := helper_split(payload, maxsplit=2, double_semicolon=True)) is None:  # type: ignore
+        raise EmbedParseError(
+            "`add_field` payload was not split by `;;` (double semicolon), `|` (pipe), or `~` (tilde)"
+        )
     try:
         name, value, _inline = data
         inline = implicit_bool(_inline)
@@ -69,7 +70,10 @@ def add_field(embed: Embed, _: str, payload: str) -> None:
                 "`inline` argument for `add_field` is not a boolean value (_inline)"
             )
     except ValueError:
-        name, value = cast(List[str], helper_split(payload, 2))  # type: ignore
+        name, value = cast(
+            List[str],
+            helper_split(payload, maxsplit=1, double_semicolon=True),
+        )
         inline = False
     name = truncate(name, max=FIELD_LIMITS["field.name"])
     value = truncate(value, max=FIELD_LIMITS["field.value"])
@@ -77,7 +81,7 @@ def add_field(embed: Embed, _: str, payload: str) -> None:
 
 
 def set_footer(embed: Embed, _: str, payload: str) -> None:
-    data = easier_helper_split(payload, maxsplit=2)  # type: ignore
+    data = helper_split(payload, maxsplit=1, double_semicolon=True)  # type: ignore
     if data is None:
         embed.set_footer(text=truncate(payload, max=FIELD_LIMITS["footer.text"]))
     else:
@@ -85,6 +89,15 @@ def set_footer(embed: Embed, _: str, payload: str) -> None:
         embed.set_footer(text=truncate(text, max=FIELD_LIMITS["footer.text"]), icon_url=icon_url)
 
 
+def set_author(embed: Embed, _: str, payload: str) -> None:
+    data = helper_split(payload, maxsplit=1, double_semicolon=True)  # type: ignore
+    if data is None:
+        embed.set_author(name=truncate(payload, max=FIELD_LIMITS["author.name"]))
+    else:
+        name, icon_url = data
+        embed.set_author(name=truncate(name, max=FIELD_LIMITS["author.name"]), icon_url=icon_url)
+
+
 # Discord embed field character limits
 # https://docs.discord.com/developers/resources/message#embed-object-embed-limits
 FIELD_LIMITS: Dict[str, int] = {
@@ -110,19 +123,41 @@ class EmbedBlock(Block):
     Multiple embed generators are available online to visualize and generate
     embed JSON.
 
+    .. important::
+        - `Embed Limits are: <https://docs.discord.com/developers/resources/message#embed-object-embed-limits>`_
+            - Title: 256 characters
+            - Description: 4096 characters
+            - Footer: 2048 characters
+            - Author: 256 characters
+            - Field name: 256 characters
+            - Field value: 1024 characters
+        - The total length of the embed must not exceed 6000 characters.
+
     **Usage:** ``{embed(<json>)}``
 
     **Payload:** None
 
     **Parameter:** json
 
-    **Examples:** ::
+    **Examples:** 
+    
+    .. code-block:: yaml
 
+        Example 1:
         {embed({"title":"Hello!", "description":"This is a test embed."})}
+
+        Example 2:
         {embed({
             "title":"Here's a random duck!",
             "image":{"url":"https://random-d.uk/api/randomimg"},
-            "color":15194415
+            "color":15194415,
+            "fields": [
+                {
+                    "name": "Fun Fact",
+                    "value": "Ducks are birds that are well-adapted to life in and around water.",
+                    "inline": false
+                }
+            ]
         })}
 
     **Manual**
@@ -135,11 +170,12 @@ class EmbedBlock(Block):
     *   ``url``
     *   ``thumbnail``
     *   ``image``
+    *   ``author``
     *   ``footer``
     *   ``field`` - (See below)
 
-    Adding a field to an embed requires the payload to be split by ``|``,
-    ``;`` or ``,`` into either 2 or 3 parts. The first part is the name
+    Adding a field to an embed requires the payload to be split by ``;;``,
+    ``|`` or ``~`` 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.
 
@@ -155,16 +191,22 @@ class EmbedBlock(Block):
         {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}
+        {embed(author):Mod Team|{author(avatar)}}
         {embed(footer):Thanks for reading!|{guild(icon)}}
 
     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.
 
-    ::
+    .. caution::
+        - The ``JSON`` block acts as a base for the embed.
+        - Since blocks are processed in **order**, the ``JSON`` block **must** come **before** any manual attribute blocks.
+        - The manual attributes are used to ``modify`` or ``add`` to the embed created by the ``JSON`` block.
 
-        {embed(title):my embed title}
-        {embed({{
+    .. code-block:: yaml
+
+        {embed({
+            "description": "This is a test description.",
             "fields": [
                 {
                     "name": "Field 1",
@@ -173,6 +215,8 @@ class EmbedBlock(Block):
                 }
             ]
         })}
+        {embed(title):My embed title}
+
     """
 
     ACCEPTED_NAMES: Tuple[str, ...] = ("embed",)
@@ -186,23 +230,10 @@ class EmbedBlock(Block):
         "thumbnail": set_dynamic_url,
         "image": set_dynamic_url,
         "field": add_field,
+        "author": set_author,
         "footer": set_footer,
     }
 
-    @removal(
-        name="EmbedBlock",
-        reason=(
-            "One of EmbedBlock's trait is scheduled to be removed in the next minor release, "
-            "A minor exception handling which would restrict the embed from getting sent and "
-            "would raise TagScriptEngine.exceptions.EmbedParseError incase it had more than "
-            "6000 characters, to know more about the limitations of discord embeds refer to the "
-            "[Official Discord API Docs](https://discord.com/developers/docs/resources/channel#embed-object-embed-limits)."
-        ),
-        version="3.2.0",
-    )
-    def __init__(self) -> None:
-        super().__init__()
-
     @staticmethod
     def get_embed(ctx: Context) -> Embed:
         return ctx.response.actions.get("embed", Embed())