AdvancedTagScript 3.2.5__py3-none-any.whl → 3.3.0__py3-none-any.whl

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):

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:

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",
 )

TagScriptEngine/block/assign.py

@@ -12,9 +12,15 @@ __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 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``
@@ -23,8 +29,20 @@ class AssignmentBlock(verb_required_block(False, parameter=True)):  # type: igno
 
     **Parameter:** name
 
-    **Examples:** ::
+    **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 `!`.
@@ -32,6 +50,162 @@ class AssignmentBlock(verb_required_block(False, parameter=True)):  # type: igno
         {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")

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!
     """

TagScriptEngine/block/command.py

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

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

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)]

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())

TagScriptEngine/block/helpers.py

@@ -4,17 +4,15 @@ import re
 from typing import Dict, List, Optional, Tuple
 
 
-__all__: Tuple[str, ...] = (
-    "implicit_bool",
-    "helper_parse_if",
-    "helper_split",
-    "easier_helper_split",
-    "helper_parse_list_if",
-)
-
-SPLIT_REGEX: re.Pattern[str] = re.compile(r"(?<!\\)\|")
-EASIER_SPLIT_REGEX: re.Pattern[str] = re.compile(r"/[\~;]/")
-BOOL_LOOKUP: Dict[str, bool] = {
+__all__: Tuple[str, ...] = (
+    "implicit_bool",
+    "helper_parse_if",
+    "helper_split",
+    "helper_parse_list_if",
+)
+
+SPLIT_REGEX: re.Pattern[str] = re.compile(r"(?<!\\)\|")
+BOOL_LOOKUP: Dict[str, bool] = {
     "true": True,
     "false": False,
     "enable": True,
@@ -110,51 +108,32 @@ def helper_parse_if(string: str) -> Optional[bool]:
     except Exception:
         pass
 
-
-def helper_split(
-    split_string: str, easy: bool = True, *, maxsplit: Optional[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:
-        if "~" in split_string:
-            return split_string.split("~", *args)
-        if "," in split_string:
-            return split_string.split(",", *args)
-    return
-
-
-def easier_helper_split(
-    split_string: str, *, maxsplit: Optional[int] = None
-) -> Optional[List[str]]:
-    """
-    A helper method to universalize the splitting logic used in blocks
-    and adapters. Please use this wherever a verb needs content to be
-    chopped at `|`, `,` or `;`.
-
-    >>> easier_helper_split("this, should|work")
-    ["this, should", "work"]
-
-    >>> easier_helper_split("this, should;work~as well")
-    ["this, should", "work", "as well"]
-    """
-    args = (maxsplit,) if maxsplit is not None else ()
-    if "|" in split_string:
-        return SPLIT_REGEX.split(split_string, *args)
-    if "~" in split_string:
-        return EASIER_SPLIT_REGEX.split(split_string, *args)
-    if ";" in split_string:
-        return EASIER_SPLIT_REGEX.split(split_string, *args)
-    return
+
+def helper_split(
+    split_string: str,
+    easy: bool = True,
+    *,
+    maxsplit: Optional[int] = None,
+    double_semicolon: bool = False,
+) -> 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 ``~``. Embed parsing can also opt into ``;;``
+    taking priority over the other delimiters.
+
+    >>> helper_split("this, should|work")
+    ["this, should", "work"]
+    """
+    args = (maxsplit,) if maxsplit is not None else ()
+    if double_semicolon and ";;" in split_string:
+        return split_string.split(";;", *args)
+    if "|" in split_string:
+        return SPLIT_REGEX.split(split_string, *args)
+    if easy:
+        if "~" in split_string:
+            return split_string.split("~", *args)
+    return
 
 
 def helper_parse_list_if(if_string):

TagScriptEngine/block/joinblock.py

@@ -33,8 +33,8 @@ class JoinBlock(verb_required_block(False, payload=True, parameter=True)):  # ty
         {join():an example sentence}
         # anexamplesentence
 
-        {join(-):one two three}
-        # one-two-three
+        {join(-):cool aid man}
+        # cool-aid-man
     """
 
     ACCEPTED_NAMES: Tuple[str, ...] = ("join",)

TagScriptEngine/block/listblock.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("ListBlock",)
+
+
+class ListBlock(verb_required_block(True, payload=True, parameter=True)):  # type: ignore
+    """
+    The list block returns the element in the payload that corresponds to the
+    index value in the parameter. The block returns null if the index is out of bounds.
+
+    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.
+
+    Lists 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:** ``{list(<index>):<elem>,<elem2>,...}``
+
+    **Aliases:** ``None``
+
+    **Payload:** list of elements (comma or tilde separated)
+
+    **Parameter:** index
+
+    **Examples:** ::
+
+        {list(0):Pizza~Burger~Pie~Chips~Lasagna}
+        # Pizza
+
+        {list(3):Pizza~Burger~Pie~Chips~Lasagna}
+        # Chips
+
+        {list(-1):Apple,Banana,Cherry}
+        # Cherry
+
+        {list(10):Apple,Banana,Cherry}
+        # (returns null — index out of bounds)
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("list",)
+
+    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(",")
+
+        try:
+            return items[index]
+        except IndexError:
+            return None

TagScriptEngine/block/mathblock.py

@@ -16,7 +16,7 @@ from pyparsing import (
     ZeroOrMore,
     alphas,
     nums,
-    oneOf,
+    one_of,
 )
 
 from ..interface import Block
@@ -77,20 +77,20 @@ class NumericStringParser(object):
         expr: Forward = Forward()
         atom: ParserElement = (
             (
-                Optional(oneOf("- +"))
-                + (ident + lpar + expr + rpar | pi | e | fnumber).setParseAction(self.pushFirst)
+                Optional(one_of("- +"))
+                + (ident + lpar + expr + rpar | pi | e | fnumber).set_parse_action(self.pushFirst)
             )
-            | Optional(oneOf("- +")) + Group(lpar + expr + rpar)
-        ).setParseAction(self.pushUMinus)
+            | Optional(one_of("- +")) + Group(lpar + expr + rpar)
+        ).set_parse_action(self.pushUMinus)
         # by defining exponentiation as "atom [ ^ factor ]..." instead of
         # "atom [ ^ atom ]...", we get right-to-left exponents, instead of left-to-right
         # that is, 2^3^2 = 2^(3^2), not (2^3)^2.
         factor: Forward = Forward()
-        factor << atom + ZeroOrMore((expop + factor).setParseAction(self.pushFirst))  # type: ignore
-        term: ParserElement = factor + ZeroOrMore((multop + factor).setParseAction(self.pushFirst))
-        expr << term + ZeroOrMore((addop + term).setParseAction(self.pushFirst))  # type: ignore
-        final: ParserElement = expr + ZeroOrMore((iop + expr).setParseAction(self.pushFirst))
-        # addop_term = ( addop + term ).setParseAction( self.pushFirst )
+        factor << atom + ZeroOrMore((expop + factor).set_parse_action(self.pushFirst))  # type: ignore
+        term: ParserElement = factor + ZeroOrMore((multop + factor).set_parse_action(self.pushFirst))
+        expr << term + ZeroOrMore((addop + term).set_parse_action(self.pushFirst))  # type: ignore
+        final: ParserElement = expr + ZeroOrMore((iop + expr).set_parse_action(self.pushFirst))
+        # addop_term = ( addop + term ).set_parse_action( self.pushFirst )
         # general_term = term + ZeroOrMore( addop_term ) | OneOrMore( addop_term)
         # expr <<  general_term
         self.bnf: ParserElement = final
@@ -145,9 +145,9 @@ class NumericStringParser(object):
         else:
             return float(op)
 
-    def eval(self, num_string: str, parseAll: bool = True) -> Any:
+    def eval(self, num_string: str, parse_all: bool = True) -> Any:
         self.exprStack = []
-        results = self.bnf.parseString(num_string, parseAll)  # noqa: F841
+        results = self.bnf.parse_string(num_string, parse_all)  # noqa: F841
         return self.evaluateStack(self.exprStack[:])
 
 
@@ -155,6 +155,71 @@ NSP: NumericStringParser = NumericStringParser()
 
 
 class MathBlock(Block):
+    """
+    The math block performs mathematical calculations from the given payload expression.
+
+    Supports standard arithmetic operators, exponentiation, modulo, in-place operators,
+    mathematical functions, and constants.
+
+    **Supported Operators:**
+
+    +----------+---------------------+
+    | Operator | Description         |
+    +==========+=====================+
+    | ``+``    | Addition            |
+    +----------+---------------------+
+    | ``-``    | Subtraction         |
+    +----------+---------------------+
+    | ``*``    | Multiplication      |
+    +----------+---------------------+
+    | ``/``    | Division            |
+    +----------+---------------------+
+    | ``^``    | Exponentiation      |
+    +----------+---------------------+
+    | ``%``    | Modulo              |
+    +----------+---------------------+
+    | ``+=``   | In-place addition   |
+    +----------+---------------------+
+    | ``-=``   | In-place subtraction|
+    +----------+---------------------+
+    | ``*=``   | In-place multiply   |
+    +----------+---------------------+
+    | ``/=``   | In-place division   |
+    +----------+---------------------+
+
+    **Supported Functions:**
+    ``sin``, ``cos``, ``tan``, ``sinh``, ``cosh``, ``tanh``,
+    ``exp``, ``abs``, ``trunc``, ``round``, ``sgn``,
+    ``log`` (base 10), ``ln`` (natural), ``log2``, ``sqrt``
+
+    **Constants:** ``PI``, ``E``
+
+    **Usage:** ``{math:<expression>}``
+
+    **Aliases:** ``m, +, calc``
+
+    **Payload:** expression
+
+    **Parameter:** None
+
+    **Examples:** ::
+
+        {math:2+3}
+        # 5
+
+        {m:round(7/3)}
+        # 2
+
+        {calc:sin(PI/2)}
+        # 1.0
+
+        {+:7*6}
+        # 42
+
+        {m:sqrt(144)}
+        # 12.0
+    """
+
     ACCEPTED_NAMES: Tuple[str, ...] = ("math", "m", "+", "calc")
 
     def process(self, ctx: Context) -> TypingOptional[str]:

TagScriptEngine/block/ordblock.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("OrdBlock",)
+
+
+def _ordinal(n: int) -> str:
+    """Return the ordinal string for an integer (e.g. 1 -> '1st')."""
+    if 11 <= abs(n) % 100 <= 13:
+        suffix = "th"
+    else:
+        suffix = {1: "st", 2: "nd", 3: "rd"}.get(abs(n) % 10, "th")
+    return f"{n}{suffix}"
+
+
+class OrdinalBlock(verb_required_block(True, payload=True)):  # type: ignore
+    """
+    The ordinal block returns the number in the payload with the correct ordinal
+    abbreviation following it.
+
+    **Usage:** ``{ordinal:<number>}``
+
+    **Aliases:** ``ord``
+
+    **Payload:** number
+
+    **Parameter:** None
+
+    **Examples:** ::
+
+        {ordinal:101}
+        # 101st
+
+        {ord:22}
+        # 22nd
+
+        {ordinal:3}
+        # 3rd
+
+        {ord:456}
+        # 456th
+
+        {ordinal:11}
+        # 11th
+
+        {ord:12}
+        # 12th
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("ordinal", "ord")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        try:
+            number = int(cast(str, ctx.verb.payload).strip())
+        except (ValueError, TypeError):
+            return None
+        return _ordinal(number)

TagScriptEngine/block/strf.py

@@ -16,7 +16,7 @@ class StrfBlock(Block):
     Two types of timestamps are supported: ISO and epoch.
     If a timestamp isn't passed, the current UTC time is used.
 
-    Invoking this block with ``unix`` will return the current Unix timestamp.
+    Invoking this block with :ref:`unix` will return the current Unix timestamp.
 
     **Usage:** ``{strf([timestamp]):<format>}``
 

TagScriptEngine/block/substr.py

@@ -10,6 +10,61 @@ __all__: Tuple[str, ...] = ("SubstringBlock",)
 
 
 class SubstringBlock(verb_required_block(True, parameter=True)):  # type: ignore
+    """
+    The substring block extracts a specific portion of the payload text using ``0``-based indexing.
+    It supports both a single starting index and a specific range of characters.
+
+    .. important::
+    
+        **Behavior:**
+        
+        - If a single ``index`` is provided, it returns all characters from that position to the end 
+          (counting from the start).
+        - From ``nth`` position (index) to end.
+
+        - If a range is provided using ``-`` (e.g., ``0-5``), it returns the characters from 
+          the ``start`` index to the ``end`` index but **without** including the ``end`` th index.
+
+    **Usage:** ``{substr(<start[-end]>):<text>}``
+
+    **Aliases:** ``substring``
+
+    **Payload:** text (to extract from)
+
+    **Parameter:** A single integer for start, or a hyphenated range (``start-end``).
+
+    **Examples:**
+
+    .. code-block:: yaml
+
+        {substr(7):Hello, World!}
+        # World!
+        Explanation:
+        # - Skips up to index 7 ("Hello, ") and starts at "W" (index 7). As 7th index is inclusive.
+
+        {substr(1-4):Hello}
+        # ell
+        Explanation: 
+        # - Skips the first character ("H" at index 0) and starts at "e" (index 1).
+        # - Stops at index 4 (exclusive), so it doesn't include "o" (index 4).
+
+        {substr(7-12):Hello, World!}
+        # World
+
+        {substr(7):TagScript is powerful}
+        # pt is powerful
+        Explanation:
+        # - Skips up to index 7 ("TagScri") and starts at "pt" (index 7).
+        # - Indexing: T(0)a(1)g(2)S(3)c(4)r(5)i(6)p(7). So at 7 it starts at pt.
+
+    .. note::
+
+        - For Single Index: Starting index is ``inclusive`` to the end of the string.
+        - For Range: Starting index is ``inclusive``, while the ending index is ``exclusive``.
+        - Negative indices are not supported.
+
+    """
+
     ACCEPTED_NAMES: Tuple[str, ...] = ("substr", "substring")
 
     def process(self, ctx: Context) -> Optional[str]:

TagScriptEngine/interpreter.py

@@ -416,11 +416,11 @@ class Interpreter(_Interpreter):
 
 class AsyncInterpreter(Interpreter):
     """
-    An asynchronous subclass of `Interpreter` that allows blocks to implement asynchronous methods.
+    An asynchronous subclass of :class:`Interpreter` that allows blocks to implement asynchronous methods.
     Synchronous blocks are still supported.
 
-    This subclass has no additional attributes from the `Interpreter` class.
-    See `Interpreter` for full documentation.
+    This subclass has no additional attributes from the :class:`Interpreter` class.
+    See :class:`Interpreter` for full documentation.
     """
 
     async def _get_acceptors(self, ctx: Context) -> List[Block]:  # type: ignore
@@ -482,8 +482,8 @@ class AsyncInterpreter(Interpreter):
         """
         Asynchronously process a given TagScript string.
 
-        This method has no additional attributes from the `Interpreter` class.
-        See `Interpreter.process` for full documentation.
+        This method has no additional attributes from the :class:`Interpreter` class.
+        See :meth:`Interpreter.process` for full documentation.
         """
         response = Response(variables=seed_variables, extra_kwargs=kwargs)
         node_ordered_list = build_node_tree(message)

{advancedtagscript-3.2.5.dist-info → advancedtagscript-3.3.0.dist-info}/METADATA

@@ -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.dist-info → advancedtagscript-3.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-TagScriptEngine/__init__.py,sha256=X27OiTa2SvbM_SmT0rETVxgXJD_baJ6HLqE6X9AnKeE,6068
+TagScriptEngine/__init__.py,sha256=v1jE2WhSkANRnPWLj4UieHunkkCnO6aNEaACln7u2dI,6143
 TagScriptEngine/_warnings.py,sha256=pfMXaEVGpIue0eqgzZ6HkLXEka1UGl61-yuH9uEnVe4,2662
 TagScriptEngine/exceptions.py,sha256=lhvskKi2AySE5pul_iAA251jdMv-92QkjodR4X-G27Y,2833
-TagScriptEngine/interpreter.py,sha256=oiyKNXgZCsMmcCTkRnszVIqG_to7PmQKomCn_pX5sb8,16604
+TagScriptEngine/interpreter.py,sha256=5kF0kEqaZf5Hyu8tkmDDLEy7y-qvd6xiUJ3GwpDDh44,16638
 TagScriptEngine/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TagScriptEngine/utils.py,sha256=Kq7_w6nuJizPYZDJIzXZ51b1ea92_7Vm_YDKbQci7F4,1697
 TagScriptEngine/verb.py,sha256=nk5IenRRGuwzIY7cMyGQn7aVYvmGcNTszztAQTSHP54,5047
@@ -10,23 +10,26 @@ TagScriptEngine/adapter/discordadapters.py,sha256=l_6HijmmGDRX7lhahskH6mTteJFpS7
 TagScriptEngine/adapter/functionadapter.py,sha256=lQlWm0dO-41bTQ2etFpWRaGnG22V1HMy9aiB8FnFZOU,591
 TagScriptEngine/adapter/intadapter.py,sha256=jENx5ah8k0U1PjJccV0NiYFsWFU9ZXTFgz3f-qx30SA,548
 TagScriptEngine/adapter/objectadapter.py,sha256=7bW-Qd6gujq2ALdK3p0ONoCSPWCTv6srkkDNjzkvDEU,1017
-TagScriptEngine/adapter/redbotadapters.py,sha256=AFCu4QZGSHAMwyDFHBPT9XS5aaWVzj9Hu-pwI87DXi8,5934
+TagScriptEngine/adapter/redbotadapters.py,sha256=9a0EDSmelI-RJF6Mgpti1fogsNIAvNoC3F40aTKGKgk,5936
 TagScriptEngine/adapter/stringadapter.py,sha256=VaJzkm1b8b7w1T90DjR3gOH0DIsZlWtcFe1YG7DOqBQ,1710
-TagScriptEngine/block/__init__.py,sha256=JPyfutqST14cpSE8YgeY9PsM9cY2s5CkoNBMf3h5bmE,3070
+TagScriptEngine/block/__init__.py,sha256=zfoPTCTBDIuOkcjKnNL8gYIRKOi4c4gkYNwNJPvYctQ,3223
 TagScriptEngine/block/allowedmentions.py,sha256=WMGWi1Fe0U_vUBsc4uyiX1XfQjGkhpdlyvq3HhCCLd4,2219
-TagScriptEngine/block/assign.py,sha256=l3DO41BVoXZbGSHsscSdNiSLddT7ggt1bPQoJdM1Iuo,1202
+TagScriptEngine/block/assign.py,sha256=lgJY_hUIjrKPm4N9vWr_rxhrKejGrMRbBG3oasb0hAI,8657
 TagScriptEngine/block/breakblock.py,sha256=nt3T7fDhTxH0jpO8lu0_3oC4XwVuKKg9cmkdLsZwzL8,1288
-TagScriptEngine/block/case.py,sha256=KAayT5RGLOMV7g6glu9AV9DijErdT-2ph7yIleGLjZw,1441
-TagScriptEngine/block/command.py,sha256=1ljbZd_Mgg6Woqi6giz26coCRej-jyh4ENY_cdTwjK8,4307
+TagScriptEngine/block/case.py,sha256=SF4uaAWyC9AiBzoI5SPDCaRx6wrY-_0IQDI1T_mZFvk,1503
+TagScriptEngine/block/command.py,sha256=3xKo5H3K8F7BpxeHJp9I80n0QWvk_GHQCQpKnvQ7ZxQ,4309
 TagScriptEngine/block/control.py,sha256=tALrHN0vbEXheMhoQOI_C0X_WjL3c-Qqd2zEd0rAZrE,5699
-TagScriptEngine/block/cooldown.py,sha256=F4HmFoIlxIhDWw8Z8PFZqP1FoEEBmAW4aipByZKZocY,4022
+TagScriptEngine/block/cooldown.py,sha256=7s7oXy2euN_w7TcfytHdNSt4duYowrqNcWuTJC3oxL4,4161
 TagScriptEngine/block/count.py,sha256=URa5xadQ56X7uaBkhMew6KyMdlZDwuj3xKjIH_PK37U,2135
-TagScriptEngine/block/embedblock.py,sha256=NbudZCln0lEKO8WD5Zmh3W56E5jzmwBMezEaIbGcyqU,11008
+TagScriptEngine/block/cycleblock.py,sha256=61AhV3aNMVFGgymOuoWm79WzKjPvu_S8MU9f172lb9U,2308
+TagScriptEngine/block/embedblock.py,sha256=57DUs_DXHygvWflh-ReqvyrujQGQdzv5rXtkCSn4KGk,12110
 TagScriptEngine/block/fiftyfifty.py,sha256=QjQP96vpQPRVpuVcF5iI1kTCkM54vUBpKgK2TEZU6vQ,827
-TagScriptEngine/block/helpers.py,sha256=Zevy0tWzDAUKSD9hc6-nW7WTreRhqENgalfySwqhF7U,4386
-TagScriptEngine/block/joinblock.py,sha256=-TlxO-q8clBZIu0TJg7qT2i2ti6nLAVsev_zz0lGrI4,1096
+TagScriptEngine/block/helpers.py,sha256=DD71FBptjtSTlt-mHd4EqnLNn8x7gS3jCpqRudVIbdI,3596
+TagScriptEngine/block/joinblock.py,sha256=gD4NdvJJ7YN8SIu3QrOw6hABAt-cHDQNNQkmiLMKqAg,1094
+TagScriptEngine/block/listblock.py,sha256=r90w1oeJjH_t39cKBT96xW8mnRXLfvyLe8KOz2p6bHw,2045
 TagScriptEngine/block/loosevariablegetter.py,sha256=ym6u9HTWKN-Cgk6OQH5FVIiGnxsND2g5o4r3kRBGH9M,1231
-TagScriptEngine/block/mathblock.py,sha256=r69oCNUAjcGNO0QFBG7w9XCv7mvMrq__GoyhR7pW6fA,5802
+TagScriptEngine/block/mathblock.py,sha256=g15LG_KEh9w8BiXNRkWcx-8K73Ic2pbiZEVZ7WrHyms,7616
+TagScriptEngine/block/ordblock.py,sha256=_FOe4eI5gBm_8Ek1ZTW25lO-2lasOh8oT4Temp4WmiI,1361
 TagScriptEngine/block/randomblock.py,sha256=udC7mCGYrtN_Exg1XZZvqvvi8KkGNnRyTkuh-6rbeSo,1594
 TagScriptEngine/block/range.py,sha256=3dz6jgTIBloZyXgN7eXGsB7SBjK3Y-OJROmHOeOaJT4,1836
 TagScriptEngine/block/redirect.py,sha256=BobWl6xKqVV4FZlihmJoLPwI_i0P6Sn6G6fWFf9d8CE,1140
@@ -34,15 +37,15 @@ TagScriptEngine/block/replaceblock.py,sha256=NXx6wdgI4r3MOw-E5oIbtrMEc9BdxpM9Rip
 TagScriptEngine/block/require_blacklist.py,sha256=3jFK8Ap_ataHZrqF3MWrmXrBI5CkIXq8G6QMEq0QQXY,2810
 TagScriptEngine/block/shortcutredirect.py,sha256=2F20L_7hYMxJY9s02XwxJQIWXaBQM_dwBNZKsOJQsk8,683
 TagScriptEngine/block/stopblock.py,sha256=C10JCaajiVetEwnP_1T7SwhT8UmBQzWCPpdtDF16nZY,1091
-TagScriptEngine/block/strf.py,sha256=54oVyt8zVlnBWa9iSXtV7szc4eFcY-hUpjRSewzkm7M,2050
+TagScriptEngine/block/strf.py,sha256=VfSqKYzXA6zdpX1hOncqpFOBaSi5Tq4emF_rsLj7AxQ,2053
 TagScriptEngine/block/strictvariablegetter.py,sha256=XMwqGad3iy5esB2aTiD5v1EaCLGDFMvB1RF11G0-l2M,1251
-TagScriptEngine/block/substr.py,sha256=QNtoOIBBC-tD2v4vT1NzmrSA5THJ_pOqQLezxWED8ek,835
+TagScriptEngine/block/substr.py,sha256=50bRdll_7WTlCgmLlo9pr6nyvsqNq0xZyc3dhLCXKVg,2724
 TagScriptEngine/block/urlencodeblock.py,sha256=sWqdSBk-uTZZjebKhAFmlROvnQvLcjvyISPTiWb4nwM,1396
 TagScriptEngine/interface/__init__.py,sha256=37lAOMONKmWDLiC5Ox9Y3TNQUQbzW54oUugbQe0e9gc,341
 TagScriptEngine/interface/adapter.py,sha256=4jBBz7hc-8fsRSZ5DWOrUxrhXqS0SvJCdW57TZl8sQo,1967
 TagScriptEngine/interface/block.py,sha256=S0hWRH6uqBz_cYRIh3LGMyo63UK6gNidtf6EiLUKL0c,3653
-advancedtagscript-3.2.5.dist-info/licenses/LICENSE,sha256=NvdimESU3jrNgd_8E4i-eTecQ_jGegRrrWk1v2gOnHY,252
-advancedtagscript-3.2.5.dist-info/METADATA,sha256=oAjLywIMfGdHeRzKxJJkHQn-I11q8ya5haXYGylIe_Y,3565
-advancedtagscript-3.2.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-advancedtagscript-3.2.5.dist-info/top_level.txt,sha256=6lY4lZDvWxraERrit1lvDsCCDdfo9e83kk_tBemAJCo,16
-advancedtagscript-3.2.5.dist-info/RECORD,,
+advancedtagscript-3.3.0.dist-info/licenses/LICENSE,sha256=NvdimESU3jrNgd_8E4i-eTecQ_jGegRrrWk1v2gOnHY,252
+advancedtagscript-3.3.0.dist-info/METADATA,sha256=Jk7KqEwJRIWH9XZrCbZCELDLF2vl121n3jMSaRc4-J0,3565
+advancedtagscript-3.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+advancedtagscript-3.3.0.dist-info/top_level.txt,sha256=6lY4lZDvWxraERrit1lvDsCCDdfo9e83kk_tBemAJCo,16
+advancedtagscript-3.3.0.dist-info/RECORD,,