bTagScript 5.0.0__py3-none-any.whl

bTagScript/block/math_blocks.py

@@ -0,0 +1,257 @@
+from __future__ import division
+
+import math
+import operator
+from typing import Optional as Optional_
+
+from pyparsing import (
+    CaselessLiteral,
+    Combine,
+    Forward,
+    Group,
+    Literal,
+    Optional,
+    Word,
+    ZeroOrMore,
+    alphas,
+    nums,
+    oneOf,
+)
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+class NumericStringParser(object):
+    """
+    Most of this code comes from the fourFn.py pyparsing example
+
+    """
+
+    def pushFirst(self, strg: str, loc, toks) -> None:  # pylint: disable=unused-argument
+        """
+        Parse actions that push the first element of the matched tokens
+        """
+        self.exprStack.append(toks[0])
+
+    def pushUMinus(self, strg: str, loc, toks) -> None:  # pylint: disable=unused-argument
+        """
+        Parse actions that push the last element of the matched tokens??
+        """
+        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 ]*
+        """
+        self.exprStack = []
+        point = Literal(".")
+        e = CaselessLiteral("E")
+        fnumber = Combine(
+            Word("+-" + nums, nums)
+            + Optional(point + Optional(Word(nums)))
+            + Optional(e + Word("+-" + nums, nums))
+        )
+        ident = Word(alphas, alphas + nums + "_$")
+        mod = Literal("%")
+        plus = Literal("+")
+        minus = Literal("-")
+        mult = Literal("*")
+        iadd = Literal("+=")
+        imult = Literal("*=")
+        idiv = Literal("/=")
+        isub = Literal("-=")
+        div = Literal("/")
+        lpar = Literal("(").suppress()
+        rpar = Literal(")").suppress()
+        addop = plus | minus
+        multop = mult | div | mod
+        iop = iadd | isub | imult | idiv
+        expop = Literal("^")
+        pi = CaselessLiteral("PI")
+        expr = Forward()
+        atom = (
+            (
+                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()
+        factor << atom + ZeroOrMore(  # pylint: disable=expression-not-assigned
+            (expop + factor).setParseAction(self.pushFirst)
+        )
+        term = factor + ZeroOrMore((multop + factor).setParseAction(self.pushFirst))
+        expr << term + ZeroOrMore(  # pylint: disable=expression-not-assigned
+            (addop + term).setParseAction(self.pushFirst)
+        )
+        final = 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 = final
+        # map operator symbols to corresponding arithmetic operations
+        epsilon = 1e-12
+        self.opn = {
+            "+": operator.add,
+            "-": operator.sub,
+            "+=": operator.iadd,
+            "-=": operator.isub,
+            "*": operator.mul,
+            "*=": operator.imul,
+            "/": operator.truediv,
+            "/=": operator.itruediv,
+            "^": operator.pow,
+            "%": operator.mod,
+        }
+        self.fn = {
+            "sin": math.sin,
+            "cos": math.cos,
+            "tan": math.tan,
+            "exp": math.exp,
+            "abs": abs,
+            "trunc": lambda a: int(a),  # pylint: disable=unnecessary-lambda
+            "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):
+        """
+        Evaluate the expression on the input data in the stack.
+        """
+        op = s.pop()
+        final = None
+        if op == "unary -":
+            final = -self.evaluateStack(s) # pylint: disable=invalid-unary-operand-type
+        elif op in self.opn:
+            op2 = self.evaluateStack(s)
+            op1 = self.evaluateStack(s)
+            final = self.opn[op](op1, op2)
+        elif op == "PI":
+            final = math.pi  # 3.1415926535
+        elif op == "E":
+            final = math.e  # 2.718281828
+        elif op in self.fn:
+            final = self.fn[op](self.evaluateStack(s))
+        elif op[0].isalpha():
+            final = 0
+        if final is not None:
+            return final
+        return float(op)
+
+    def eval(self, num_string: str, parseAll: bool = True) -> float:
+        """
+        Evaluate the expression on the input data.
+        """
+        self.exprStack = []
+        self.bnf.parseString(num_string, parseAll)
+        return self.evaluateStack(self.exprStack[:])
+
+
+NSP = NumericStringParser()
+
+
+class MathBlock(Block):
+    """
+    A math block is a block that contains a math expression.
+    If the block fails to parse if will return the declaration
+    plus error like so: `<math error>`, <+ error> etc.
+
+    **Usage:** ``{math:<expression>}``
+
+    **Aliases:** ``math, m, +, calc``
+
+    **Payload:** ``expression``
+
+    **Parameter:** None
+
+    **Examples:**
+
+    .. tagscript::
+
+        {m:2+3}
+        5.0
+
+        {math:7(2+3)}
+        42.0
+
+        {math:trunc(7(2+3))}
+        42
+    """
+
+    ACCEPTED_NAMES = ("math", "m", "+", "calc")
+
+    def process(self, ctx: Context) -> Optional_[str]:
+        """
+        Try and process the block into a float
+        """
+        try:
+            return str(NSP.eval(ctx.verb.payload.strip(" ")))
+        except:  # pylint: disable=bare-except
+            return f"<{ctx.verb.declaration} error>"
+
+
+class OrdinalAbbreviationBlock(Block):
+    """
+    The ordinalabbreviation block returns the ordinal abbreviation of a number.
+    If a parameter is provided, it must be, one of, c, comma, indicator, i
+    Comma being adding commas every 3 digits, indicator, meaning the ordinal indicator.
+    (The st of 1st, nd of 2nd, etc.)
+
+    The number may be positive or negative, if the payload is invalid, the
+    declaration plus error is returned.
+
+    **Usage:** ``{ord(["c", "comma", "i", "indicator"]):<number>}``
+
+    **Aliases:** ``None``
+
+    **Payload:** ``number``
+
+    **Parameter:** ``"c", "comma", "i", "indicator"``
+
+    .. tagscript::
+
+        {ord:1000}
+        1,000th
+
+        {ord(c):1213123}
+        1,213,123
+
+        {ord(i):2022}
+        2022nd
+    """
+
+    ACCEPTED_NAMES = ("ord",)
+
+    def process(self, ctx: Context) -> str:
+        """
+        Process the ordinal abbreviation block
+        """
+        num = ctx.verb.payload.split("-", 1)[-1]
+        if num.isdigit():
+            comma = f"{int(num):,}"
+            if ctx.verb.parameter in ["c", "comma"]:
+                return comma
+            i = int(ctx.verb.payload.split("-", 1)[-1])
+            indicator = "tsnrhtdd"[
+                (i // 10 % 10 != 1) * (i % 10 < 4) * i % 10 :: 4
+            ]  # I stole this from stack overflow
+            if ctx.verb.parameter in ["i", "indicator"]:
+                return f"{ctx.verb.payload}{indicator}"  # concatenation is slower?
+            return f"{comma}{indicator}"
+        return f"<{ctx.verb.declaration} error>"

bTagScript/block/random_block.py

@@ -0,0 +1,65 @@
+import random
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class RandomBlock(verb_required_block(True, payload=True)):
+    """
+    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.
+    You can weight options differently by adding a weight and | before
+    the item.
+
+    **Usage:** ``{random([seed]):<list>}``
+
+    **Aliases:** ``#, rand``
+
+    **Payload:** ``list``
+
+    **Parameter:** ``seed``
+
+    **Examples:**
+
+    .. tagscript::
+
+        {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
+
+        {#:5|Cool,3|Lame}
+        5 to 3 chances of being cool vs lame
+    """
+
+    ACCEPTED_NAMES = ("random", "#", "rand")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the randomness woo
+        """
+        if "~" in ctx.verb.payload:
+            spl = ctx.verb.payload.split("~")
+        else:
+            spl = ctx.verb.payload.split(",")
+
+        choices = []
+        weights = []
+        for choice in spl:
+            weight, sep, remainder = choice.partition("|")
+            if sep and weight.isdigit():
+                choices.append(remainder)
+                weights.append(int(weight))
+            else:
+                choices.append(choice)
+                weights.append(1)
+        rng = random.Random(ctx.verb.parameter) if ctx.verb.parameter is not None else random
+        return rng.choices(choices, weights, k=1)[0]

bTagScript/block/range_block.py

@@ -0,0 +1,54 @@
+import random
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class RangeBlock(verb_required_block(True, payload=True)):
+    """
+    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``
+
+    **Examples:**
+
+    .. tagscript::
+
+        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 = ("rangef", "range")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the range block
+        """
+        try:
+            spl = ctx.verb.payload.split("-")
+            rng = random.Random(ctx.verb.parameter) if ctx.verb.parameter is not None else random
+            if ctx.verb.declaration.lower() == "rangef":
+                lower = int(float(spl[0]) * 10)
+                upper = int(float(spl[1]) * 10)
+                return str(rng.randint(lower, upper) / 10)
+            lower = int(float(spl[0]))
+            upper = int(float(spl[1]))
+            return str(rng.randint(lower, upper))
+        except:  # pylint: disable=bare-except
+            return None

bTagScript/block/replace_block.py

@@ -0,0 +1,110 @@
+from typing import Optional
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class ReplaceBlock(verb_required_block(True, payload=True, parameter=True)):
+    """
+    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:** ``sub``
+
+    **Payload:** message
+
+    **Parameter:** original, new
+
+    .. tagscript::
+
+        {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 = ("replace", "sub")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Replace the characters in the payload
+        """
+        try:
+            before, after = ctx.verb.parameter.split(",", 1)
+        except ValueError:
+            return None
+
+        return ctx.verb.payload.replace(before, after)
+
+
+class PythonBlock(verb_required_block(True, payload=True, parameter=True)):
+    """
+    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:**
+
+    .. tagscript::
+
+        {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:
+        """
+        Check if we can accept
+        """
+        dec = ctx.verb.declaration.lower()
+        return dec in ("contains", "in", "index")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block
+        """
+        dec = ctx.verb.declaration.lower()
+        if dec == "contains":
+            return str(bool(ctx.verb.parameter in ctx.verb.payload.split())).lower()
+        if dec == "in":
+            return str(bool(ctx.verb.parameter in ctx.verb.payload)).lower()
+        try:
+            return str(ctx.verb.payload.strip().split().index(ctx.verb.parameter))
+        except ValueError:
+            return "-1"

bTagScript/block/stop_block.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from ..exceptions import StopError
+from ..interface import verb_required_block
+from ..interpreter import Context
+from . import helper_parse_if
+
+
+class StopBlock(verb_required_block(True, parameter=True)):
+    """
+    The stop block stops tag processing if the given parameter is true.
+    If a message is passed to the payload it will return that message.
+
+    **Usage:** ``{stop(<bool>):[string]}``
+
+    **Aliases:** ``halt``
+
+    **Payload:** ``string``
+
+    **Parameter:** ``bool``
+
+    **Example:**
+
+    .. tagscript::
+
+        {stop(=={args}):You must provide arguments for this tag.}
+        enforces providing arguments for a tag
+    """
+
+    ACCEPTED_NAMES = ("stop", "halt")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the stop block
+        """
+        if helper_parse_if(ctx.verb.parameter):
+            raise StopError("" if ctx.verb.payload is None else ctx.verb.payload)
+        return ""

bTagScript/block/strf_block.py

@@ -0,0 +1,70 @@
+from datetime import datetime, timezone
+from typing import Optional
+
+from ..interface import Block
+from ..interpreter import Context
+
+
+class StrfBlock(Block):
+    """
+    The strf block converts and formats timestamps based on `strftime formatting spec <https://strftime.org/>`_.
+    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.
+
+    **Usage:** ``{strf([timestamp]):<format>}``
+
+    **Aliases:** ``unix``
+
+    **Payload:** ``format``
+
+    **Parameter:** ``timestamp``
+
+    **Example:**
+
+    .. tagscript::
+
+        {strf:%Y-%m-%d}
+        2021-07-11
+
+        {strf({user(timestamp)}):%c}
+        Fri Jun 29 21:10:28 2018
+
+        {strf(1420070400):%A %d, %B %Y}
+        Thursday 01, January 2015
+
+        {strf(2019-10-09T01:45:00.805000):%H:%M %d-%B-%Y}
+        01:45 09-October-2019
+
+        {unix}
+        1629182008
+    """
+
+    ACCEPTED_NAMES = ("strf", "unix")
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the strf block
+        """
+        if ctx.verb.declaration.lower() == "unix":
+            return str(int(datetime.now(timezone.utc).timestamp()))
+        if not ctx.verb.payload:
+            return None
+        if ctx.verb.parameter:
+            if ctx.verb.parameter.isdigit():
+                try:
+                    t = datetime.fromtimestamp(int(ctx.verb.parameter))
+                except:  # pylint: disable=bare-except
+                    return None
+            else:
+                try:
+                    t = datetime.fromisoformat(ctx.verb.parameter)
+                    # converts datetime.__str__ to datetime
+                except ValueError:
+                    return None
+        else:
+            t = datetime.now()
+        if not t.tzinfo:
+            t = t.replace(tzinfo=timezone.utc)
+        return t.strftime(ctx.verb.payload)

bTagScript/block/url_blocks.py

@@ -0,0 +1,76 @@
+from typing import Optional
+from urllib.parse import quote, quote_plus, unquote, unquote_plus
+
+from ..interface import verb_required_block
+from ..interpreter import Context
+
+
+class URLDecodeBlock(verb_required_block(True, payload=True)):
+    """
+    This block will decode a given url into a string
+    with non-url compliant characters replaced. Using ``+`` as the parameter
+    will replace spaces with ``+`` rather than ``%20``.
+
+    **Usage:** ``{urldecode(["+"]):<string>}``
+
+    **Payload:** string
+
+    **Parameter:** "+", None
+
+    **Examples:**
+
+    .. tagscript::
+
+        {urldecode:covid-19%20sucks}
+        covid-19 sucks
+
+        {urldecode(+):im+stuck+at+home+writing+docs}
+        im stuck at home writing docs
+
+    This block is just the reverse of the urlencode block
+    """
+
+    ACCEPTED_NAMES = ("urldecode",)
+
+    def process(self, ctx: Context) -> Optional[str]:
+        """
+        Process the block
+        """
+        method = unquote_plus if ctx.verb.parameter == "+" else unquote
+        return method(ctx.verb.payload)
+
+
+class URLEncodeBlock(verb_required_block(True, payload=True)):
+    """
+    This block will encode a given string into a properly formatted url
+    with non-url compliant characters replaced. Using ``+`` as the parameter
+    will replace spaces with ``+`` rather than ``%20``.
+
+    **Usage:** ``{urlencode(["+"]):<string>}``
+
+    **Payload:** string
+
+    **Parameter:** "+", None
+
+    **Example:**
+
+    .. tagscript::
+
+        {urlencode:covid-19 sucks}
+        covid-19%20sucks
+
+        {urlencode(+):im stuck at home writing docs}
+        im+stuck+at+home+writing+docs
+
+        You can use this to search up blocks
+        Eg if {args} is command block
+
+        <https://btagscript.readthedocs.io/en/latest/search.html?q={urlencode(+):{args}}&check_keywords=yes&area=default>
+        <https://btagscript.readthedocs.io/en/latest/search.html?q=command+block&check_keywords=yes&area=default>
+    """
+
+    ACCEPTED_NAMES = ("urlencode",)
+
+    def process(self, ctx: Context) -> str:
+        method = quote_plus if ctx.verb.parameter == "+" else quote
+        return method(ctx.verb.payload)

bTagScript/block/util_blocks/__init__.py

@@ -0,0 +1,3 @@
+from .debug_block import DebugBlock
+
+__all__ = ("DebugBlock",)