bTagScript 5.0.0__py3-none-any.whl

bTagScript/__init__.py

@@ -0,0 +1,66 @@
+"""
+This work is licensed under the Creative Commons Attribution 4.0 International License. To view a copy of this license,
+visit http://creativecommons.org/licenses/by/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
+
+This fork was made by _Leg3ndary and contains everything he thought should be added to tagscript. Hope you enjoy!
+"""
+
+from collections import namedtuple
+
+from .adapter import *
+from .block import *
+from .exceptions import *
+from .interface import *
+from .interpreter import *
+from .utils import *
+from .verb import Verb
+
+__version__ = "5.0.0"
+
+
+class VersionInfo(namedtuple("VersionInfo", "major minor micro")):
+    """
+    Version information.
+
+    Attributes
+    ----------
+    major: int
+        Major version number.
+    minor: int
+        Minor version number.
+    micro: int
+        Micro version number.
+    """
+
+    __slots__ = ()
+
+    def __str__(self):
+        """
+        Returns a string representation of the version information.
+
+        Returns
+        -------
+        str
+            String representation of the version information.
+        """
+        return "{major}.{minor}.{micro}".format(**self._asdict())
+
+    @classmethod
+    def from_str(cls, version):
+        """
+        Returns a VersionInfo instance from a string.
+
+        Parameters
+        ----------
+        version: str
+            String representation of the version information.
+
+        Returns
+        -------
+        VersionInfo
+            Version information.
+        """
+        return cls(*map(int, version.split(".")))
+
+
+version_info = VersionInfo.from_str(__version__)

bTagScript/adapter/__init__.py

@@ -0,0 +1,16 @@
+from .discord_adapters import *
+from .function_adapter import FunctionAdapter
+from .int_adapter import IntAdapter
+from .object_adapter import SafeObjectAdapter
+from .string_adapter import StringAdapter
+
+__all__ = (
+    "SafeObjectAdapter",
+    "StringAdapter",
+    "IntAdapter",
+    "FunctionAdapter",
+    "AttributeAdapter",
+    "MemberAdapter",
+    "ChannelAdapter",
+    "GuildAdapter",
+)

bTagScript/adapter/discord_adapters.py

@@ -0,0 +1,275 @@
+from random import choice
+from typing import Union
+
+from discord import Guild, Member, TextChannel, Thread
+
+from ..interface import Adapter
+from ..utils import escape_content
+from ..verb import Verb
+
+__all__ = (
+    "AttributeAdapter",
+    "MemberAdapter",
+    "ChannelAdapter",
+    "GuildAdapter",
+)
+
+
+class AttributeAdapter(Adapter):
+    """
+    Base attribute adapter for discord.py objects
+    """
+
+    __slots__ = ("object", "_attributes", "_methods")
+
+    def __init__(self, base: Union[TextChannel, Member, Guild]) -> None:
+        """
+        Init for the attribute adapter
+        """
+        self.object = base
+        self._attributes = {
+            "id": base.id,
+            "created_at": base.created_at,
+            "timestamp": int(base.created_at.timestamp()),
+            "name": getattr(base, "name", str(base)),
+        }
+        self._methods = {}
+        self.update_attributes()
+        self.update_methods()
+
+    def __repr__(self) -> str:
+        """
+        printable repr
+        """
+        return f"<{type(self).__qualname__} object={self.object!r}>"
+
+    def update_attributes(self) -> None:
+        """
+        Update attributes for the block
+        """
+
+    def update_methods(self) -> None:
+        """
+        Update methods for the block
+        """
+
+    def get_value(self, ctx: Verb) -> str:
+        """
+        Get the value for the adapter
+        """
+        should_escape = False
+
+        if ctx.parameter is None:
+            return_value = str(self.object)
+        else:
+            try:
+                value = self._attributes[ctx.parameter]
+            except KeyError:
+                if method := self._methods.get(ctx.parameter):
+                    value = method()
+                else:
+                    return
+
+            if isinstance(value, tuple):
+                value, should_escape = value
+
+            return_value = str(value) if value is not None else None
+
+        return escape_content(return_value) if should_escape else return_value
+
+
+class MemberAdapter(AttributeAdapter):
+    """
+    The ``{author}`` block with no parameters returns the tag invoker's full username
+    and discriminator, but passing the attributes listed below to the block payload
+    will return that attribute instead.
+
+    **Aliases:** ``user``
+
+    **Usage:** ``{author([attribute])``
+
+    **Payload:** None
+
+    **Parameter:** attribute, None
+
+    Attributes
+    ----------
+    id
+        The author's Discord ID.
+    name
+        The author's username.
+    nick
+        The author's nickname, if they have one, else their username.
+    avatar
+        A link to the author's avatar, which can be used in embeds.
+    discriminator
+        The author's discriminator.
+    created_at
+        The author's account creation date.
+    timestamp
+        The author's account creation date as a UTC timestamp.
+    joined_at
+        The date the author joined the server.
+    mention
+        A formatted text that pings the author.
+    bot
+        Whether or not the author is a bot.
+    color
+        The author's top role's color as a hex code.
+    top_role
+        The author's top role.
+    boost
+        If the user boosted, this will be the the UTC timestamp of when they did, if not, this will be empty.
+    timed_out
+        If the user is timed out, this will be the the UTC timestamp of when they'll be "untimed-out", if not timed out, this will be empty.
+    banner
+        The users banner url
+    roleids
+        A list of the author's role IDs, split by spaces.
+    """
+
+    def update_attributes(self) -> None:
+        """
+        Update the adapter with all it's needed attributes
+        """
+        additional_attributes = {
+            "color": self.object.color,
+            "colour": self.object.color,
+            "nick": self.object.display_name,
+            "avatar": (self.object.display_avatar.url, False),
+            "discriminator": self.object.discriminator,
+            "joined_at": getattr(self.object, "joined_at", ""),
+            "mention": self.object.mention,
+            "bot": self.object.bot,
+            "top_role": getattr(self.object, "top_role", ""),
+            "boost": getattr(self.object, "premium_since", ""),
+            "timed_out": getattr(self.object, "timed_out_until", ""),
+            "banner": self.object.banner.url if self.object.banner else "",
+        }
+        if roleids := getattr(self.object, "_roles", None):
+            additional_attributes["roleids"] = " ".join(str(r) for r in roleids)
+        self._attributes.update(additional_attributes)
+
+
+class ChannelAdapter(AttributeAdapter):
+    """
+    The ``{channel}`` block with no parameters returns the channel's full name
+    but passing the attributes listed below to the block payload
+    will return that attribute instead.
+
+    **Usage:** ``{channel([attribute])``
+
+    **Payload:** None
+
+    **Parameter:** attribute, None
+
+    Attributes
+    ----------
+    id
+        The channel's ID.
+    name
+        The channel's name.
+    created_at
+        The channel's creation date.
+    timestamp
+        The channel's creation date as a UTC timestamp.
+    nsfw
+        Whether the channel is nsfw.
+    mention
+        A formatted text that pings the channel.
+    topic
+        The channel's topic.
+    slowmode
+        The channel's slowmode in seconds, 0 if disabled
+    """
+
+    def update_attributes(self) -> None:
+        """
+        Update block attributes
+        """
+        if isinstance(self.object, TextChannel):
+            additional_attributes = {
+                "channel_type": "textchannel",
+                "nsfw": self.object.nsfw,
+                "mention": self.object.mention,
+                "topic": self.object.topic or None,
+                "slowmode": self.object.slowmode_delay,
+            }
+            self._attributes.update(additional_attributes)
+        elif isinstance(self.object, Thread):
+            pass
+
+
+class GuildAdapter(AttributeAdapter):
+    """
+    The ``{server}`` block with no parameters returns the server's name
+    but passing the attributes listed below to the block payload
+    will return that attribute instead.
+
+    **Aliases:** ``guild``
+
+    **Usage:** ``{server([attribute])``
+
+    **Payload:** None
+
+    **Parameter:** attribute, None
+
+    Attributes
+    ----------
+    id
+        The server's ID.
+    name
+        The server's name.
+    icon
+        A link to the server's icon, which can be used in embeds.
+    created_at
+        The server's creation date.
+    timestamp
+        The server's creation date as a UTC timestamp.
+    member_count
+        The server's member count.
+    bots
+        The number of bots in the server.
+    humans
+        The number of humans in the server.
+    description
+        The server's description if one is set, or "No description".
+    random
+        A random member from the server.
+    """
+
+    def update_attributes(self) -> None:
+        """
+        Update block attributes
+        """
+        guild = self.object
+        bots = 0
+        humans = 0
+        for m in guild.members:
+            if m.bot:
+                bots += 1
+            else:
+                humans += 1
+        member_count = guild.member_count
+        additional_attributes = {
+            "icon": guild.icon.url if guild.icon else "",
+            "member_count": member_count,
+            "members": member_count,
+            "bots": bots,
+            "humans": humans,
+            "description": guild.description or "No description",
+        }
+        self._attributes.update(additional_attributes)
+
+    def update_methods(self) -> None:
+        """
+        Update methods for the block
+        """
+        additional_methods = {"random": self.random_member}
+        self._methods.update(additional_methods)
+
+    def random_member(self) -> None:
+        """
+        Return a random member
+        """
+        return choice(self.object.members)

bTagScript/adapter/function_adapter.py

@@ -0,0 +1,33 @@
+from typing import Callable
+
+from ..interface import Adapter
+from ..verb import Verb
+
+
+class FunctionAdapter(Adapter):
+    """
+    Function adapter...
+
+    Would be cool to have functions in tagscript
+    """
+
+    __slots__ = ("fn",)
+
+    def __init__(self, function_pointer: Callable[[], str]) -> None:
+        """
+        Construct the adapter
+        """
+        self.fn = function_pointer
+        super().__init__()
+
+    def __repr__(self) -> str:
+        """
+        String repr
+        """
+        return f"<{type(self).__qualname__} fn={self.fn!r}>"
+
+    def get_value(self, ctx: Verb) -> str:
+        """
+        Run the function and get the value
+        """
+        return str(self.fn())

bTagScript/adapter/int_adapter.py

@@ -0,0 +1,30 @@
+from ..interface import Adapter
+from ..verb import Verb
+
+
+class IntAdapter(Adapter):
+    """
+    IntAdapter
+
+    This will be useful in the future if types are ever introduced.
+    """
+
+    __slots__ = ("integer",)
+
+    def __init__(self, integer: int) -> None:
+        """
+        Construct the int adapter
+        """
+        self.integer: int = int(integer)
+
+    def __repr__(self) -> str:
+        """
+        String repr
+        """
+        return f"<{type(self).__qualname__} integer={repr(self.integer)}>"
+
+    def get_value(self, ctx: Verb) -> str:
+        """
+        Get the value of the int into string, not sure why this even exists
+        """
+        return str(self.integer)

bTagScript/adapter/object_adapter.py

@@ -0,0 +1,41 @@
+from inspect import ismethod
+
+from ..interface import Adapter
+from ..verb import Verb
+
+
+class SafeObjectAdapter(Adapter):
+    """
+    Object adapter, though again this will likely not be used
+    """
+
+    __slots__ = ("object",)
+
+    def __init__(self, base) -> None:
+        """
+        Construct the safe object adapter.
+        """
+        self.object = base
+
+    def __repr__(self) -> str:
+        """
+        String repr"""
+        return f"<{type(self).__qualname__} object={repr(self.object)}>"
+
+    def get_value(self, ctx: Verb) -> str:
+        """
+        Get the value safely
+        """
+        if ctx.parameter is None:
+            return str(self.object)
+        if ctx.parameter.startswith("_") or "." in ctx.parameter:
+            return None
+        try:
+            attribute = getattr(self.object, ctx.parameter)
+        except AttributeError:
+            return None
+        if ismethod(attribute):
+            return None
+        if isinstance(attribute, float):
+            attribute = int(attribute)
+        return str(attribute)

bTagScript/adapter/string_adapter.py

@@ -0,0 +1,69 @@
+from ..interface import Adapter
+from ..utils import escape_content
+from ..verb import Verb
+
+
+class StringAdapter(Adapter):
+    """
+    String adapter, allows blocks to be parsed, used basically only for variables
+    """
+
+    __slots__ = ("string", "escape_content")
+
+    def __init__(self, string: str, *, escape: bool = False) -> None:
+        """
+        Construction for string adapter
+        """
+        self.string: str = str(string)
+        self.escape_content = escape
+
+    def __repr__(self) -> str:
+        """
+        String repr
+        """
+        return f"<{type(self).__qualname__} string={repr(self.string)}>"
+
+    def get_value(self, ctx: Verb) -> str:
+        """
+        Get the value given the verb
+        """
+        return self.return_value(self.handle_ctx(ctx))
+
+    def handle_ctx(self, ctx: Verb) -> str:
+        """
+        Transform any parsing data the block may have
+        """
+        if ctx.parameter is None:
+            return self.string
+
+        try:
+            index = None
+            splitter = " " if ctx.payload is None else ctx.payload
+            if ctx.parameter.isdigit():
+                index = int(ctx.parameter) - 1
+
+            if ctx.parameter.startswith("-") and ctx.parameter.split("-", 1)[-1].isdigit():
+                index = int(ctx.parameter)
+
+            if index is not None:
+                return self.string.split(splitter)[index]
+
+            index = (
+                int(ctx.parameter.replace("+", "")) - 1
+                if int(ctx.parameter.replace("+", "")) > 0
+                else int(ctx.parameter.replace("+", ""))
+            )
+            splitter = " " if ctx.payload is None else ctx.payload
+            if ctx.parameter.startswith("+"):
+                return splitter.join(self.string.split(splitter)[: index + 1])
+            if ctx.parameter.endswith("+"):
+                return splitter.join(self.string.split(splitter)[index:])
+            return self.string.split(splitter)[index]
+        except:  # pylint: disable=bare-except
+            return self.string
+
+    def return_value(self, string: str) -> str:
+        """
+        Return the value, escaped
+        """
+        return escape_content(string) if self.escape_content else string

bTagScript/block/__init__.py

@@ -0,0 +1,67 @@
+# isort: off
+from .helpers import *
+
+# isort: on
+from .break_block import BreakBlock
+from .case_block import LowerBlock, UpperBlock
+from .comment_block import CommentBlock
+from .control_block import AllBlock, AnyBlock, IfBlock
+from .counting_blocks import CountBlock, LengthBlock
+from .digitshorthand_block import DigitShorthandBlock
+from .discord_blocks import (
+    BlacklistBlock,
+    CommandBlock,
+    CooldownBlock,
+    DeleteBlock,
+    EmbedBlock,
+    OverrideBlock,
+    ReactBlock,
+    RedirectBlock,
+    RequireBlock,
+)
+from .math_blocks import MathBlock, OrdinalAbbreviationBlock
+from .random_block import RandomBlock
+from .range_block import RangeBlock
+from .replace_block import PythonBlock, ReplaceBlock
+from .stop_block import StopBlock
+from .strf_block import StrfBlock
+from .url_blocks import URLDecodeBlock, URLEncodeBlock
+from .util_blocks.debug_block import DebugBlock
+from .var_block import VarBlock
+from .vargetter_blocks import LooseVariableGetterBlock, StrictVariableGetterBlock
+
+__all__ = (
+    "BreakBlock",
+    "CommentBlock",
+    "AllBlock",
+    "AnyBlock",
+    "IfBlock",
+    "CountBlock",
+    "LengthBlock",
+    "BlacklistBlock",
+    "CommandBlock",
+    "CooldownBlock",
+    "DeleteBlock",
+    "EmbedBlock",
+    "OverrideBlock",
+    "ReactBlock",
+    "RedirectBlock",
+    "RequireBlock",
+    "MathBlock",
+    "OrdinalAbbreviationBlock",
+    "RandomBlock",
+    "RangeBlock",
+    "PythonBlock",
+    "ReplaceBlock",
+    "StopBlock",
+    "StrfBlock",
+    "URLDecodeBlock",
+    "URLEncodeBlock",
+    "DebugBlock",
+    "VarBlock",
+    "LooseVariableGetterBlock",
+    "StrictVariableGetterBlock",
+    "DigitShorthandBlock",
+    "UpperBlock",
+    "LowerBlock",
+)

bTagScript/block/break_block.py

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

bTagScript/block/case_block.py

@@ -0,0 +1,62 @@
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class UpperBlock(verb_required_block(True, payload=True)):
+    """
+    The Upper block will do exactly as it and will make the payload uppercase. The
+    block alone will not do anything.
+
+    **Usage:** ``{upper:<string>}``
+
+    **Aliases:** ``upper``
+
+    **Payload:** ``string``
+
+    **Parameter:** ``None``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {upper:I love strawberries!} -> I LOVE STRAWBERRIES!
+    """
+
+    ACCEPTED_NAMES = ("upper",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block and break the tag.
+        """
+        return ctx.verb.payload.upper()
+
+
+class LowerBlock(verb_required_block(True, payload=True)):
+    """
+    The Lower block will make the payload lowercase. The block alone will
+    not do anything.
+
+    **Usage:** ``{lower:<string>}``
+
+    **Aliases:** ``lower``
+
+    **Payload:** ``string``
+
+    **Parameter:** ``None``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {lower:I LOVE STRAWBERRIES!} -> i love strawberries!
+    """
+
+    ACCEPTED_NAMES = ("lower",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block and break the tag.
+        """
+        return ctx.verb.payload.lower()