AdvancedTagScript 3.2.4__py3-none-any.whl

TagScriptEngine/block/helpers.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+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] = {
+    "true": True,
+    "false": False,
+    "enable": True,
+    "disable": False,
+    "yes": True,
+    "no": False,
+    "on": True,
+    "off": False,
+    "y": True,
+    "n": False,
+    "t": True,
+    "f": False,
+    "1": True,
+    "0": False,
+}
+
+
+def implicit_bool(string: str) -> Optional[bool]:
+    """
+    Parse a string to a boolean.
+
+    >>> implicit_bool("true")
+    True
+    >>> implicit_bool("FALSE")
+    False
+    >>> implicit_bool("abc")
+    None
+
+    Parameters
+    ----------
+    string: str
+        The string to convert.
+
+    Returns
+    -------
+    bool
+        The boolean value of the string.
+    None
+        The string failed to parse.
+    """
+    return BOOL_LOOKUP.get(string.lower())
+
+
+def helper_parse_if(string: str) -> Optional[bool]:
+    """
+    Parse an expression string to a boolean.
+
+    >>> helper_parse_if("this == this")
+    True
+    >>> helper_parse_if("2>3")
+    False
+    >>> helper_parse_if("40 >= 40")
+    True
+    >>> helper_parse_if("False")
+    False
+    >>> helper_parse_if("1")
+    None
+
+    Parameters
+    ----------
+    string: str
+        The string to convert.
+
+    Returns
+    -------
+    bool
+        The boolean value of the expression.
+    None
+        The expression failed to parse.
+    """
+    value = implicit_bool(string)
+    if value is not None:
+        return value
+    try:
+        if "!=" in string:
+            spl = string.split("!=")
+            return spl[0].strip() != spl[1].strip()
+        if "==" in string:
+            spl = string.split("==")
+            return spl[0].strip() == spl[1].strip()
+        if ">=" in string:
+            spl = string.split(">=")
+            return float(spl[0].strip()) >= float(spl[1].strip())
+        if "<=" in string:
+            spl = string.split("<=")
+            return float(spl[0].strip()) <= float(spl[1].strip())
+        if ">" in string:
+            spl = string.split(">")
+            return float(spl[0].strip()) > float(spl[1].strip())
+        if "<" in string:
+            spl = string.split("<")
+            return float(spl[0].strip()) < float(spl[1].strip())
+    except 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_parse_list_if(if_string):
+    split = helper_split(if_string, False)
+    if split is None:
+        return [helper_parse_if(if_string)]
+    return [helper_parse_if(item) for item in split]

TagScriptEngine/block/loosevariablegetter.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("LooseVariableGetterBlock",)
+
+
+class LooseVariableGetterBlock(Block):
+    """
+    The loose variable block represents the adapters for any seeded or defined variables.
+    This variable implementation is considered "loose" since it checks whether the variable is
+    valid during :meth:`process`, rather than :meth:`will_accept`.
+
+    **Usage:** ``{<variable_name>([parameter]):[payload]}``
+
+    **Aliases:** This block is valid for any inputted declaration.
+
+    **Payload:** Depends on the variable's underlying adapter.
+
+    **Parameter:** Depends on the variable's underlying adapter.
+
+    **Examples:** ::
+
+        {=(var):This is my variable.}
+        {var}
+        # This is my variable.
+    """
+
+    def will_accept(self, ctx: Context) -> bool:  # type: ignore
+        return True
+
+    def process(self, ctx: Context) -> Optional[str]:
+        if ctx.verb.declaration in ctx.response.variables:
+            return ctx.response.variables[ctx.verb.declaration].get_value(ctx.verb)
+        else:
+            return None

TagScriptEngine/block/mathblock.py

@@ -0,0 +1,164 @@
+from __future__ import division, annotations
+
+import math
+import operator
+from typing import Any, Callable, Dict, List, Tuple, cast, Optional as TypingOptional
+
+from pyparsing import (
+    CaselessLiteral,
+    Combine,
+    Forward,
+    Group,
+    Literal,
+    Optional,
+    ParserElement,
+    Word,
+    ZeroOrMore,
+    alphas,
+    nums,
+    oneOf,
+)
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("MathBlock",)
+
+
+class NumericStringParser(object):
+    """
+    Most of this code comes from the fourFn.py pyparsing example
+
+    """
+
+    def pushFirst(self, strg: Any, loc: Any, toks: Any) -> Any:
+        self.exprStack.append(toks[0])
+
+    def pushUMinus(self, strg: Any, loc: Any, toks: Any) -> Any:
+        if toks and toks[0] == "-":
+            self.exprStack.append("unary -")
+
+    def __init__(self) -> None:
+        """
+        expop   :: '^'
+        multop  :: '*' | '/'
+        addop   :: '+' | '-'
+        integer :: ['+' | '-'] '0'..'9'+
+        atom    :: PI | E | real | fn '(' expr ')' | '(' expr ')'
+        factor  :: atom [ expop factor ]*
+        term    :: factor [ multop factor ]*
+        expr    :: term [ addop term ]*
+        """
+        point: Literal = Literal(".")
+        e: CaselessLiteral = CaselessLiteral("E")
+        fnumber: Combine = Combine(
+            Word("+-" + nums, nums)
+            + Optional(point + Optional(Word(nums)))
+            + Optional(e + Word("+-" + nums, nums))
+        )
+        ident: Word = Word(alphas, alphas + nums + "_$")
+        mod: Literal = Literal("%")
+        plus: Literal = Literal("+")
+        minus: Literal = Literal("-")
+        mult: Literal = Literal("*")
+        iadd: Literal = Literal("+=")
+        imult: Literal = Literal("*=")
+        idiv: Literal = Literal("/=")
+        isub: Literal = Literal("-=")
+        div: Literal = Literal("/")
+        lpar: ParserElement = Literal("(").suppress()
+        rpar: ParserElement = Literal(")").suppress()
+        addop: ParserElement = plus | minus
+        multop: ParserElement = mult | div | mod
+        iop: ParserElement = iadd | isub | imult | idiv
+        expop: Literal = Literal("^")
+        pi: CaselessLiteral = CaselessLiteral("PI")
+        expr: Forward = Forward()
+        atom: ParserElement = (
+            (
+                Optional(oneOf("- +"))
+                + (ident + lpar + expr + rpar | pi | e | fnumber).setParseAction(self.pushFirst)
+            )
+            | Optional(oneOf("- +")) + Group(lpar + expr + rpar)
+        ).setParseAction(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 )
+        # general_term = term + ZeroOrMore( addop_term ) | OneOrMore( addop_term)
+        # expr <<  general_term
+        self.bnf: ParserElement = final
+        # map operator symbols to corresponding arithmetic operations
+        epsilon: float = 1e-12
+        self.opn: Dict[str, Callable[[Any, Any], Any]] = {
+            "+": operator.add,
+            "-": operator.sub,
+            "+=": operator.iadd,
+            "-=": operator.isub,
+            "*": operator.mul,
+            "*=": operator.imul,
+            "/": operator.truediv,
+            "/=": operator.itruediv,
+            "^": operator.pow,
+            "%": operator.mod,
+        }
+        self.fn: Dict[str, Any] = {
+            "sin": math.sin,
+            "cos": math.cos,
+            "tan": math.tan,
+            "sinh": math.sinh,
+            "cosh": math.cosh,
+            "tanh": math.tanh,
+            "exp": math.exp,
+            "abs": abs,
+            "trunc": lambda a: int(a),
+            "round": round,
+            "sgn": lambda a: abs(a) > epsilon and ((a > 0) - (a < 0)) or 0,
+            "log": lambda a: math.log(a, 10),
+            "ln": math.log,
+            "log2": math.log2,
+            "sqrt": math.sqrt,
+        }
+
+    def evaluateStack(self, s: List[Any]) -> Any:
+        op = s.pop()
+        if op == "unary -":
+            return -self.evaluateStack(s)
+        if op in self.opn:
+            op2 = self.evaluateStack(s)
+            op1 = self.evaluateStack(s)
+            return self.opn[op](op1, op2)
+        elif op == "PI":
+            return math.pi  # 3.1415926535
+        elif op == "E":
+            return math.e  # 2.718281828
+        elif op in self.fn:
+            return self.fn[op](self.evaluateStack(s))
+        elif op[0].isalpha():
+            return 0
+        else:
+            return float(op)
+
+    def eval(self, num_string: str, parseAll: bool = True) -> Any:
+        self.exprStack = []
+        results = self.bnf.parseString(num_string, parseAll)  # noqa: F841
+        return self.evaluateStack(self.exprStack[:])
+
+
+NSP: NumericStringParser = NumericStringParser()
+
+
+class MathBlock(Block):
+    ACCEPTED_NAMES: Tuple[str, ...] = ("math", "m", "+", "calc")
+
+    def process(self, ctx: Context) -> TypingOptional[str]:
+        try:
+            return str(NSP.eval(cast(str, ctx.verb.payload).strip(" ")))
+        except Exception:
+            return None

TagScriptEngine/block/randomblock.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import random
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("RandomBlock",)
+
+
+class RandomBlock(verb_required_block(True, payload=True)):  # type: ignore
+    """
+    Pick a random item from a list of strings, split by either ``~``
+    or ``,``. An optional seed can be provided to the parameter to
+    always choose the same item when using that seed.
+
+    **Usage:** ``{random([seed]):<list>}``
+
+    **Aliases:** ``#, rand``
+
+    **Payload:** list
+
+    **Parameter:** seed, None
+
+    **Examples:** ::
+
+        {random:Carl,Harold,Josh} attempts to pick the lock!
+        # Possible Outputs:
+        # Josh attempts to pick the lock!
+        # Carl attempts to pick the lock!
+        # Harold attempts to pick the lock!
+
+        {=(insults):You're so ugly that you went to the salon and it took 3 hours just to get an estimate.~I'll never forget the first time we met, although I'll keep trying.~You look like a before picture.}
+        {=(insult):{#:{insults}}}
+        {insult}
+        # Assigns a random insult to the insult variable
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("random", "#", "rand")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        spl = []
+        if "~" in (payload := cast(str, ctx.verb.payload)):
+            spl = payload.split("~")
+        else:
+            spl = payload.split(",")
+        random.seed(ctx.verb.parameter)
+
+        return random.choice(spl)

TagScriptEngine/block/range.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import random
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("RangeBlock",)
+
+
+class RangeBlock(verb_required_block(True, payload=True)):  # type: ignore
+    """
+    The range block picks a random number from a range of numbers seperated by ``-``.
+    The number range is inclusive, so it can pick the starting/ending number as well.
+    Using the rangef block will pick a number to the tenth decimal place.
+
+    An optional seed can be provided to the parameter to always choose the same item when using that seed.
+
+    **Usage:** ``{range([seed]):<lowest-highest>}``
+
+    **Aliases:** ``rangef``
+
+    **Payload:** number
+
+    **Parameter:** seed, None
+
+    **Examples:** ::
+
+        Your lucky number is {range:10-30}!
+        # Your lucky number is 14!
+        # Your lucky number is 25!
+
+        {=(height):{rangef:5-7}}
+        I am guessing your height is {height}ft.
+        # I am guessing your height is 5.3ft.
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("rangef", "range")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        try:
+            spl = cast(str, ctx.verb.payload).split("-")
+            random.seed(ctx.verb.parameter)
+            if cast(str, ctx.verb.declaration).lower() == "rangef":
+                lower: float = float(spl[0])
+                upper: float = float(spl[1])
+                base: float = random.randint(int(lower) * 10, int(upper) * 10) / 10
+                return str(base)
+            else:
+                lower = int(float(spl[0]))
+                upper = int(float(spl[1]))
+                return str(random.randint(lower, upper))
+        except Exception:
+            return None

TagScriptEngine/block/redirect.py

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

TagScriptEngine/block/replaceblock.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple, cast
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+__all__: Tuple[str, ...] = ("ReplaceBlock", "PythonBlock")
+
+
+class ReplaceBlock(verb_required_block(True, payload=True, parameter=True)):  # type: ignore
+    """
+    The replace block will replace specific characters in a string.
+    The parameter should split by a ``,``, containing the characters to find
+    before the command and the replacements after.
+
+    **Usage:** ``{replace(<original,new>):<message>}``
+
+    **Aliases:** ``None``
+
+    **Payload:** message
+
+    **Parameter:** original, new
+
+    **Examples:** ::
+
+        {replace(o,i):welcome to the server}
+        # welcime ti the server
+
+        {replace(1,6):{args}}
+        # if {args} is 1637812
+        # 6637862
+
+        {replace(, ):Test}
+        # T e s t
+    """
+
+    ACCEPTED_NAMES: Tuple[str, ...] = ("replace",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        try:
+            before, after = cast(str, ctx.verb.parameter).split(",", 1)
+        except ValueError:
+            return
+
+        return cast(str, ctx.verb.payload).replace(before, after)
+
+
+class PythonBlock(verb_required_block(True, payload=True, parameter=True)):  # type: ignore
+    """
+    The in block serves three different purposes depending on the alias that is used.
+
+    The ``in`` alias checks if the parameter is anywhere in the payload.
+
+    ``contain`` strictly checks if the parameter is the payload, split by whitespace.
+
+    ``index`` finds the location of the parameter in the payload, split by whitespace.
+    If the parameter string is not found in the payload, it returns 1.
+
+    index is used to return the value of the string form the given list of
+
+    **Usage:** ``{in(<string>):<payload>}``
+
+    **Aliases:** ``index``, ``contains``
+
+    **Payload:** payload
+
+    **Parameter:** string
+
+    **Examples:** ::
+
+        {in(apple pie):banana pie apple pie and other pie}
+        # true
+        {in(mute):How does it feel to be muted?}
+        # true
+        {in(a):How does it feel to be muted?}
+        # false
+
+        {contains(mute):How does it feel to be muted?}
+        # false
+        {contains(muted?):How does it feel to be muted?}
+        # false
+
+        {index(food):I love to eat food. everyone does.}
+        # 4
+        {index(pie):I love to eat food. everyone does.}
+        # -1
+    """
+
+    def will_accept(self, ctx: Context) -> bool:  # type: ignore
+        dec = cast(str, ctx.verb.declaration).lower()
+        return dec in ("contains", "in", "index")
+
+    def process(self, ctx: Context) -> str:
+        dec: str = cast(str, ctx.verb.declaration).lower()
+        if dec == "contains":
+            return str(bool(ctx.verb.parameter in cast(str, ctx.verb.payload).split())).lower()
+        elif dec == "in":
+            return str(bool(cast(str, ctx.verb.parameter) in cast(str, ctx.verb.payload))).lower()
+        else:
+            try:
+                return str(
+                    cast(str, ctx.verb.payload)
+                    .strip()
+                    .split()
+                    .index(cast(str, ctx.verb.parameter))
+                )
+            except ValueError:
+                return "-1"