expr-dice-roller 0.0.1__tar.gz

expr_dice_roller-0.0.1/LICENSE

@@ -0,0 +1,9 @@
+ The MIT License (MIT)
+
+Copyright © 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

expr_dice_roller-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: expr_dice_roller
+Version: 0.0.1
+Summary: Unofficial port of dice-roller/rpg-dice-roller to Python.
+Author: HellishBro
+Project-URL: Homepage, https://github.com/HellishBro/dice_roller
+Keywords: dice,expressions
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Requires-Dist: build>=1.4.0
+Requires-Dist: setuptools>=77.0.3
+Dynamic: license-file

expr_dice_roller-0.0.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "expr_dice_roller"
+version = "0.0.1"
+authors = [
+    { name = "HellishBro" }
+]
+license-files = [
+    "LICENSE"
+]
+keywords = [
+    "dice", "expressions"
+]
+description = "Unofficial port of dice-roller/rpg-dice-roller to Python."
+dependencies = [
+    "build>=1.4.0",
+    "setuptools>=77.0.3",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/HellishBro/dice_roller"

expr_dice_roller-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

expr_dice_roller-0.0.1/src/expr_dice_roller/__init__.py

@@ -0,0 +1,45 @@
+from lexer import Lexer
+from parser import Parser
+from evaluator import Evaluator, Printer, Environment
+from dataclasses import dataclass
+
+__all__ = ["format_expression", "EvaluationResult", "evaluate"]
+
+def format_expression(expression: str) -> str:
+    t = Parser(Lexer(expression).lex()).expression()
+    if t:
+        return Printer().visit(t)
+    return ""
+
+@dataclass
+class EvaluationResult:
+    environment: Environment
+    representation: str
+    value: float | None
+
+def evaluate(expression: str, environment: Environment | None = None, assign_last_eval: bool = False) -> EvaluationResult:
+    t = Parser(Lexer(expression).lex()).expression()
+    if t:
+        expr_eval = Evaluator(environment)
+        rep, val = expr_eval.visit(t)
+        if assign_last_eval:
+            expr_eval.environment.assign("_", val)
+        if isinstance(val, (float, int)):
+            val = int(val) if val.is_integer() else val
+        else:
+            val = None
+        return EvaluationResult(expr_eval.environment, rep, val)
+    return EvaluationResult(environment, "", None)
+
+if __name__ == "__main__":
+    env = None
+
+    while True:
+        inp = input("> ")
+        try:
+            print(format_expression(inp))
+            res = evaluate(inp, env, True)
+            env = res.environment
+            print(res.representation, "=", res.value)
+        except ValueError as e:
+            print(e)

expr_dice_roller-0.0.1/src/expr_dice_roller/dice_roller.py

@@ -0,0 +1,100 @@
+from dataclasses import dataclass
+from random import randint
+import modifiers as mods
+from modifiers import MAX_ITERATIONS
+
+
+@dataclass
+class Predicate:
+    predicate: str
+    comp: float
+
+    def meet(self, value: int) -> bool:
+        if self.predicate == "<>":
+            return value != self.comp
+        elif self.predicate == "=":
+            return value == self.comp
+        elif self.predicate == ">":
+            return value > self.comp
+        elif self.predicate == ">=":
+            return value >= self.comp
+        elif self.predicate == "<":
+            return value < self.comp
+        elif self.predicate == "<=":
+            return value <= self.comp
+        return False
+
+
+class Roll:
+    def __init__(self, value: int):
+        self.value = value
+        self.rep = "{}"
+        self.value_override = None
+
+    def __repr__(self) -> str:
+        return self.rep.replace("{}", str(self.value))
+
+    def reroll(self, new_roll):
+        self.value = new_roll.value
+
+
+@dataclass
+class Dice:
+    count: int | None
+    side: int
+    drop_high: int | None = None
+    drop_low: int | None = None
+    keep_high: int | None = None
+    keep_low: int | None = None
+    minimum: int | None = None
+    maximum: int | None = None
+    explode: Predicate | bool | None = None
+    penetrate: Predicate | bool | None = None
+    reroll: Predicate | bool | None = None
+    reroll_once: bool = False
+    success: Predicate | None = None
+    failure: Predicate | None = None
+
+    def roll_once(self) -> Roll:
+        if self.side == 0: return Roll(0)
+        if self.side >= 1: return Roll(randint(1, self.side))
+        return Roll(randint(self.side, -1))
+
+class RollResult:
+    def __init__(self, rolls: list[Roll]):
+        self.rolls = rolls
+
+    @property
+    def value(self) -> int:
+        return sum(roll.value_override if roll.value_override is not None else roll.value for roll in self.rolls)
+
+    def __repr__(self) -> str:
+        return "[" + ", ".join(repr(roll) for roll in self.rolls) + "]"
+
+
+class DiceRoller:
+    def __init__(self, dice: Dice):
+        self.dice = dice
+
+    def roll(self) -> RollResult:
+        res = RollResult([])
+        count = self.dice.count if self.dice.count is not None else 1
+        if count > 127:
+            raise ValueError(f"{count} exceeds the dice limit.")
+
+        for _ in range(count):
+            res.rolls.append(self.dice.roll_once())
+
+        modifiers: list[type[mods.Mod]] = []
+        if self.dice.minimum: modifiers.append(mods.Min)
+        if self.dice.maximum: modifiers.append(mods.Max)
+        if self.dice.explode: modifiers.append(mods.Explode)
+        if self.dice.penetrate: modifiers.append(mods.Penetrate)
+        if self.dice.reroll: modifiers.append(mods.ReRoll)
+        if self.dice.keep_high or self.dice.keep_low: modifiers.append(mods.Keep)
+        if self.dice.drop_high or self.dice.drop_low: modifiers.append(mods.Drop)
+        if self.dice.success or self.dice.failure: modifiers.append(mods.Success)
+        for modifier in modifiers:
+            modifier(self.dice).run(res)
+
+        return res

expr_dice_roller-0.0.1/src/expr_dice_roller/evaluator.py

@@ -0,0 +1,304 @@
+from lexer import TT
+from parser import Expr, BinOp, Unary, Number, Dice, Grouping, Predicate, FuncCall, Variable, Function
+from dice_roller import Dice as DDice, DiceRoller, Predicate as DPredicate
+
+class IEvaluator:
+    def __init__(self, environment=None):
+        self.environment = environment or Environment()
+
+    def enter(self):
+        self.environment = self.environment.enter()
+
+    def exit(self):
+        self.environment = self.environment.exit()
+
+    def visit(self, node: Expr):
+        return getattr(self, "visit_" + node.__class__.__name__)(node)
+
+class EvalFunc:
+    def __init__(self, parameters: list[str], body: Expr, definition: Function):
+        self.parameters = parameters
+        self.body = body
+        self.definition = definition
+
+    def call(self, evaluator: IEvaluator, arguments: list[float]) -> float:
+        evaluator.enter()
+        for param, arg in zip(self.parameters, arguments):
+            evaluator.environment.assign(param, arg)
+        _, val = evaluator.visit(self.body)
+        evaluator.exit()
+        return val
+
+    def __str__(self) -> str:
+        return Printer().visit_Function(self.definition)
+
+
+class Environment:
+    def __init__(self):
+        self.parent: Environment | None = None
+        self.variables: dict[str, float | EvalFunc] = {}
+
+    def enter(self):
+        new_env = Environment()
+        new_env.parent = self
+        return new_env
+
+    def get(self, name: str) -> float | EvalFunc:
+        if self.parent is None:
+            return self.variables.get(name, 0)
+        return self.variables.get(name, self.parent.get(name))
+
+    def assign(self, name: str, value: float | EvalFunc):
+        self.variables[name] = value
+
+    def exit(self):
+        p = self.parent
+        self.parent = None
+        return p
+
+
+ReprValue = tuple[str, float | EvalFunc]
+class Evaluator(IEvaluator):
+    def __init__(self, environment=None):
+        super().__init__(environment)
+        self.function_depth = 0
+
+    def visit_BinOp(self, node: BinOp) -> ReprValue:
+        left_repr, left_val = self.visit(node.left)
+        right_repr, right_val = self.visit(node.right)
+        left_val = self._float(left_val)
+        right_val = self._float(right_val)
+        operator = node.operator
+        op = ""
+        res = 0
+        if operator.tt == TT.PLUS:
+            res = left_val + right_val
+            op = "+"
+        elif operator.tt == TT.MINUS:
+            res = left_val - right_val
+            op = "-"
+        elif operator.tt == TT.STAR:
+            res = left_val * right_val
+            op = "*"
+        elif operator.tt == TT.DIV:
+            res = left_val / right_val
+            op = "/"
+        elif operator.tt == TT.CARET:
+            res = left_val ** right_val
+            op = "^"
+        return f"{left_repr} {op} {right_repr}", res
+
+    def visit_Unary(self, node: Unary) -> ReprValue:
+        val_repr, val = self.visit(node.value)
+        val = self._float(val)
+        operator = node.operator
+        op = ""
+        res = 0
+        if operator.tt == TT.PLUS:
+            res = abs(val)
+            op = "+"
+        elif operator.tt == TT.MINUS:
+            res = -val
+            op = "-"
+        return f"{op}{val_repr}", res
+
+    def visit_Number(self, node: Number) -> ReprValue:
+        d = self._float(node.value.data)
+        return f"{d:g}", d
+
+    def visit_Grouping(self, node: Grouping) -> ReprValue:
+        rep, res = self.visit(node.value)
+        return f"({rep})", res
+
+    def visit_Predicate(self, node: Predicate) -> DPredicate:
+        return DPredicate({
+            TT.NEQ: "<>",
+            TT.EQ: "=",
+            TT.GT: ">",
+            TT.LT: "<",
+            TT.GE: ">=",
+            TT.LE: "<="
+        }[node.predicate.tt], self._float(self.visit(node.comp)[1]))
+
+    def visit_Function(self, node: Function) -> ReprValue:
+        func = EvalFunc([param.name.data for param in node.parameters], node.body, node)
+        self.environment.assign(node.name.name.data, func)
+        return self.visit(node.name)
+
+    def visit_Variable(self, node: Variable) -> ReprValue:
+        return node.name.data, self.environment.get(node.name.data)
+
+    def visit_FuncCall(self, node: FuncCall) -> ReprValue:
+        rep, func = self.visit(node.function)
+        rep_args = [self.visit(arg) for arg in node.arguments]
+        reps = [rep_arg[0] for rep_arg in rep_args]
+        args = [rep_arg[1] for rep_arg in rep_args]
+        rep += "(" + ", ".join(reps) + ")"
+        if not hasattr(func, "call"):
+            n = node.function.name.name.data if isinstance(node.function.name, Variable) else node.function.name.data
+            raise ValueError(f"{n} is not a defined function.")
+
+        if self.function_depth > 100:
+            raise ValueError(f"Max function depth limit reached.")
+        self.function_depth += 1
+        value = func.call(self, args)
+        self.function_depth -= 1
+        return rep, value
+
+    @staticmethod
+    def _float(value) -> float:
+        if isinstance(value, (int, float, str)):
+            return float(value)
+        raise ValueError(f"{value} cannot be interpreted as a number.")
+
+    @staticmethod
+    def _int(value) -> int | None:
+        if isinstance(value, (int, float)):
+            if value.is_integer():
+                return int(value)
+            else:
+                raise ValueError(f"{value} is not an integer.")
+        elif value is None: return None
+        raise ValueError("Functions cannot be interpreted as an integer.")
+
+    def visit_Dice(self, node: Dice) -> ReprValue:
+        count = self.visit(node.count)[1] if node.count else None
+        sides = self.visit(node.side)[1] if node.side != "%" else 100
+        drop_high = self.visit(node.drop_high)[1] if node.drop_high else None
+        drop_low = self.visit(node.drop_low)[1] if node.drop_low else None
+        keep_high = self.visit(node.keep_high)[1] if node.keep_high else None
+        keep_low = self.visit(node.keep_low)[1] if node.keep_low else None
+        minimum = self.visit(node.minimum)[1] if node.minimum else None
+        maximum = self.visit(node.maximum)[1] if node.maximum else None
+        explode = self.visit(node.explode) if isinstance(node.explode, Predicate) else node.explode
+        penetrate = self.visit(node.penetrate) if isinstance(node.penetrate, Predicate) else node.penetrate
+        reroll = self.visit(node.reroll) if isinstance(node.reroll, Predicate) else node.reroll
+        success = self.visit(node.success) if isinstance(node.success, Predicate) else None
+        failure = self.visit(node.failure) if isinstance(node.failure, Predicate) else None
+        ddice = DDice(
+            self._int(count),
+            self._int(sides),
+            self._int(drop_high),
+            self._int(drop_low),
+            self._int(keep_high),
+            self._int(keep_low),
+            self._int(minimum),
+            self._int(maximum),
+
+            explode,
+            penetrate,
+            reroll,
+            node.reroll_once,
+
+            success,
+            failure
+        )
+        roll_result = DiceRoller(ddice).roll()
+        return repr(roll_result), roll_result.value
+
+class Printer(IEvaluator):
+    def visit_BinOp(self, node: BinOp) -> str:
+        left = self.visit(node.left)
+        right = self.visit(node.right)
+        operator = node.operator
+        op = ""
+        if operator.tt == TT.PLUS:
+            op = "+"
+        elif operator.tt == TT.MINUS:
+            op = "-"
+        elif operator.tt == TT.STAR:
+            op = "*"
+        elif operator.tt == TT.DIV:
+            op = "/"
+        elif operator.tt == TT.CARET:
+            op = "^"
+        return f"{left} {op} {right}"
+
+    def visit_Unary(self, node: Unary) -> str:
+        val = self.visit(node.value)
+        operator = node.operator
+        op = ""
+        if operator.tt == TT.PLUS:
+            op = "+"
+        elif operator.tt == TT.MINUS:
+            op = "-"
+        return f"{op}{val}"
+
+    def visit_Number(self, node: Number) -> str:
+        return f"{float(node.value.data):g}"
+
+    def visit_Grouping(self, node: Grouping) -> str:
+        rep = self.visit(node.value)
+        return f"({rep})"
+
+    def visit_Predicate(self, node: Predicate) -> str:
+        return {
+            TT.NEQ: "<>",
+            TT.EQ: "=",
+            TT.GT: ">",
+            TT.LT: "<",
+            TT.GE: ">=",
+            TT.LE: "<="
+        }[node.predicate.tt] + self.visit(node.comp)
+
+    def visit_Function(self, node: Function) -> str:
+        return f"{node.name.name.data}({', '.join(param.name.data for param in node.parameters)}) = {self.visit(node.body)}"
+
+    def visit_Variable(self, node: Variable) -> str:
+        return node.name.data
+
+    def visit_FuncCall(self, node: FuncCall) -> str:
+        rep = self.visit(node.function)
+        if isinstance(node.function, Function):
+            rep = f"({rep})"
+        reps = [self.visit(arg) for arg in node.arguments]
+        rep += "(" + ", ".join(reps) + ")"
+        return rep
+
+
+    def visit_Dice(self, node: Dice) -> str:
+        count = self.visit(node.count) if node.count else ""
+        sides = self.visit(node.side) if node.side != "%" else "%"
+        drop_high = self.visit(node.drop_high) if node.drop_high else None
+        drop_low = self.visit(node.drop_low) if node.drop_low else None
+        keep_high = self.visit(node.keep_high) if node.keep_high else None
+        keep_low = self.visit(node.keep_low) if node.keep_low else None
+        minimum = self.visit(node.minimum) if node.minimum else None
+        maximum = self.visit(node.maximum) if node.maximum else None
+        explode = self.visit(node.explode) if isinstance(node.explode, Predicate) else node.explode
+        penetrate = self.visit(node.penetrate) if isinstance(node.penetrate, Predicate) else node.penetrate
+        reroll = self.visit(node.reroll) if isinstance(node.reroll, Predicate) else node.reroll
+        success = self.visit(node.success) if isinstance(node.success, Predicate) else None
+        failure = self.visit(node.failure) if isinstance(node.failure, Predicate) else None
+        rep = f"{count}d{sides}"
+        if success:
+            rep += success
+            if failure:
+                rep += f"f{failure}"
+        if minimum is not None:
+            rep += f"min{minimum}"
+        if maximum is not None:
+            rep += f"max{maximum}"
+        if explode is not None:
+            rep += "!"
+            if explode is not True:
+                rep += explode
+        if penetrate is not None:
+            rep += "!p"
+            if penetrate is not True:
+                rep += penetrate
+        if reroll is not None:
+            rep += "r"
+            if node.reroll_once:
+                rep += "o"
+            if reroll is not True:
+                rep += reroll
+        if keep_high:
+            rep += f"kh{keep_high}"
+        if keep_low:
+            rep += f"kl{keep_low}"
+        if drop_high:
+            rep += f"dh{drop_high}"
+        if drop_low:
+            rep += f"dl{drop_low}"
+        return rep

expr_dice_roller-0.0.1/src/expr_dice_roller/lexer.py

@@ -0,0 +1,153 @@
+from typing import Any
+from enum import Enum, auto
+
+class TT(Enum):
+    NUMBER = auto() # int or float
+    NAME = auto() # any string of characters not recognized by the lexer
+
+    D = auto() # literal d (dice or drop)
+    DL = auto() # literal dl (drop low)
+    DH = auto() # literal dh (drop high)
+    K = auto() # literal k (keep)
+    KL = auto() # literal kl (keep low)
+    KH = auto() # literal kh (keep high)
+    MIN = auto() # literal min (min)
+    MAX = auto() # literal max (max)
+    R = auto() # literal r (reroll)
+    RO = auto() # literal ro (reroll once)
+    F = auto() # literal f (failure)
+
+    PLUS = auto() # +
+    MINUS = auto() # -
+    STAR = auto() # *
+    DIV = auto() # /
+    CARET = auto() # ^
+
+    PERCENT = auto() # %
+
+    COMMA = auto() # ,
+
+    BANG = auto() # literal ! (explode)
+    BANG_P = auto() # literal !p (penetrate)
+    GT = auto() # >
+    GE = auto() # >=
+    LT = auto() # <
+    LE = auto() # <=
+    EQ = auto() # =
+    NEQ = auto() # <> or !=
+
+    LPAREN = auto() # (
+    RPAREN = auto() # )
+
+    ERROR = auto()
+
+class Token:
+    def __init__(self, tt: TT, pos: int, data: Any):
+        self.tt = tt
+        self.pos = pos
+        self.data = data
+
+    def __repr__(self) -> str:
+        return f"Token({self.tt!r}, {self.pos!r}, {self.data!r})"
+
+
+NAME_TTs = TT.NAME, TT.DL, TT.DH, TT.K, TT.KL, TT.KH, TT.MIN, TT.MAX, TT.R, TT.RO, TT.F
+
+class Lexer:
+    def __init__(self, sequence: str):
+        self.sequence = sequence
+        self.pos = 0
+        self.start_pos = 0
+        self.tokens = []
+
+    def add_token(self, tt: TT, data: Any | None = None):
+        self.tokens.append(Token(tt, self.start_pos, data or self.sequence[self.start_pos:self.pos]))
+
+    def at_end(self) -> bool:
+        return self.pos >= len(self.sequence)
+
+    def peek(self) -> str: return self.sequence[self.pos] if not self.at_end() else "\0"
+
+    def advance(self) -> str:
+        char = self.peek()
+        self.pos += 1
+        return char
+
+    def number(self, start: str):
+        decimal = start == "."
+        tt = TT.NUMBER
+        dat = None
+        while self.peek() in "1234567890.":
+            if decimal and self.peek() == ".":
+                tt = TT.ERROR
+                dat = "Invalid number literal."
+            elif self.peek() == "." and not decimal:
+                decimal = True
+            self.advance()
+        self.add_token(tt, dat)
+
+    def name(self):
+        stop_characters = " \n\t\0()+-*/=,<>^!1234567890.%"
+        while self.peek() not in stop_characters:
+            self.advance()
+        n = self.sequence[self.start_pos:self.pos]
+        self.add_token({
+            "d": TT.D,
+            "dl": TT.DL,
+            "dh": TT.DH,
+            "k": TT.K,
+            "kl": TT.KL,
+            "kh": TT.KH,
+            "min": TT.MIN,
+            "max": TT.MAX,
+            "r": TT.R,
+            "ro": TT.RO,
+            "f": TT.F
+        }.get(n, TT.NAME))
+
+
+    def token(self):
+        char = self.advance()
+        if char == "#":
+            while self.advance() not in "\n\0":
+                pass
+            return
+
+        if char in " \n\t": return
+        if char in "1234567890.":
+            self.number(char)
+        elif char in "+-*/()=,^%":
+            mapping  = {"+": TT.PLUS, "-": TT.MINUS, "*": TT.STAR, "/": TT.DIV, "(": TT.LPAREN, ")": TT.RPAREN, "=": TT.EQ, ",": TT.COMMA, "^": TT.CARET, "%": TT.PERCENT}
+            self.add_token(mapping[char])
+        elif char == ">":
+            if self.peek() == "=":
+                self.advance()
+                self.add_token(TT.GE)
+            else:
+                self.add_token(TT.GT)
+        elif char == "<":
+            if self.peek() == "=":
+                self.advance()
+                self.add_token(TT.LE)
+            elif self.peek() == ">":
+                self.advance()
+                self.add_token(TT.NEQ)
+            else:
+                self.add_token(TT.LT)
+        elif char == "!":
+            if self.peek() == "=":
+                self.advance()
+                self.add_token(TT.NEQ)
+            elif self.peek() == "p":
+                self.advance()
+                self.add_token(TT.BANG_P)
+            else:
+                self.add_token(TT.BANG)
+        else:
+            self.name()
+
+    def lex(self) -> list[Token]:
+        while not self.at_end():
+            self.start_pos = self.pos
+            self.token()
+        return self.tokens

expr_dice_roller-0.0.1/src/expr_dice_roller/modifiers.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from dice_roller import RollResult, Dice
+
+MAX_ITERATIONS = 100
+
+class Mod:
+    def __init__(self, dice: Dice):
+        self.dice = dice
+
+    def run(self, res: RollResult): pass
+
+class Min(Mod):
+    def run(self, res: RollResult):
+        for roll in res.rolls:
+            if roll.value < self.dice.minimum:
+                roll.value = self.dice.minimum
+                roll.rep += "^"
+
+class Max(Mod):
+    def run(self, res: RollResult):
+        for roll in res.rolls:
+            if roll.value > self.dice.maximum:
+                roll.value = self.dice.maximum
+                roll.rep += "v"
+
+class Explode(Mod):
+    def run(self, res: RollResult):
+        new_rolls = []
+        pred = self.dice.explode
+        for roll in res.rolls:
+            subrolls = [roll]
+            for i in range(MAX_ITERATIONS):
+                if (pred is True and subrolls[i].value == self.dice.side) or (pred is not True and pred.meet(subrolls[i].value)):
+                    subrolls[i].rep += "!"
+                    subrolls.append(self.dice.roll_once())
+                else:
+                    break
+            new_rolls.extend(subrolls)
+        res.rolls = new_rolls
+
+class Penetrate(Mod):
+    def run(self, res: RollResult):
+        new_rolls = []
+        for roll in res.rolls:
+            subrolls = [roll]
+            pred = self.dice.penetrate
+            for i in range(MAX_ITERATIONS):
+                if (pred is True and subrolls[i].value == self.dice.side) or (pred is not True and pred.meet(subrolls[i].value)):
+                    subrolls[i].rep += "!p"
+                    new_roll = self.dice.roll_once()
+                    new_roll.value -= 1
+                    subrolls.append(new_roll)
+                else:
+                    break
+            new_rolls.extend(subrolls)
+        res.rolls = new_rolls
+
+class ReRoll(Mod):
+    def run(self, res: RollResult):
+        pred = self.dice.reroll
+        for roll in res.rolls:
+            for i in range(MAX_ITERATIONS):
+                if (pred is True and roll.value == 1) or pred.meet(roll.value):
+                    roll.reroll(self.dice.roll_once())
+                    if i == 1:
+                        roll.rep += "r"
+                        if self.dice.reroll_once:
+                            roll.rep += "o"
+                            break
+
+class Keep(Mod):
+    def run(self, res: RollResult):
+        sorted_values = sorted(res.rolls, key=lambda r: r.value)
+        invalidate_indices = [*range(len(res.rolls))]
+        if self.dice.keep_high:
+            del invalidate_indices[max(len(res.rolls) - self.dice.keep_high, 0):]
+        if self.dice.keep_low:
+            del invalidate_indices[:max(self.dice.keep_low, 0)]
+
+        for index in set(invalidate_indices):
+            dice = sorted_values[index]
+            dice.value_override = 0
+            dice.rep += "d"
+
+class Drop(Mod):
+    def run(self, res: RollResult):
+        sorted_values = sorted(res.rolls, key=lambda r: r.value)
+        invalidate_indices = []
+        if self.dice.drop_low:
+            invalidate_indices = [*range(self.dice.drop_low)]
+        if self.dice.drop_high:
+            invalidate_indices = [*range(max(len(res.rolls) - self.dice.drop_high, 0), len(res.rolls))]
+        if len(invalidate_indices) > len(sorted_values):
+            invalidate_indices = [*range(len(sorted_values))]
+
+        for index in set(invalidate_indices):
+            dice = sorted_values[index]
+            if dice.value_override != 0:
+                dice.value_override = 0
+                dice.rep += "d"
+
+class Success(Mod):
+    def run(self, res: RollResult):
+        for roll in res.rolls:
+            if self.dice.success.meet(roll.value):
+                roll.value_override = 1
+                roll.rep += "*"
+            elif self.dice.failure and self.dice.failure.meet(roll.value):
+                roll.value_override = -1
+                roll.rep += "_"
+            else:
+                roll.value_override = 0

expr_dice_roller-0.0.1/src/expr_dice_roller/parser.py

@@ -0,0 +1,257 @@
+from typing import Literal
+
+from lexer import TT, Token, NAME_TTs
+from dataclasses import dataclass
+
+class Expr: pass
+
+@dataclass
+class BinOp(Expr):
+    left: Expr
+    operator: Token
+    right: Expr
+
+@dataclass
+class Unary(Expr):
+    operator: Token
+    value: Expr
+
+@dataclass
+class Grouping(Expr):
+    value: Expr
+
+@dataclass
+class Number(Expr):
+    value: Token
+
+@dataclass
+class Predicate(Expr):
+    predicate: Token
+    comp: Expr
+
+@dataclass
+class Variable(Expr):
+    name: Token
+
+@dataclass
+class Function:
+    name: Variable
+    parameters: list[Variable]
+    body: Expr
+
+@dataclass
+class FuncCall(Expr):
+    function: Variable | Function
+    arguments: list[Expr]
+
+
+@dataclass
+class Dice(Expr):
+    count: Expr | None
+    side: Expr | Literal['%']
+    drop_high: Expr | None = None
+    drop_low: Expr | None = None
+    keep_high: Expr | None = None
+    keep_low: Expr | None = None
+    minimum: Expr | None = None
+    maximum: Expr | None = None
+
+    explode: Predicate | bool | None = None
+    penetrate: Predicate | bool | None = None
+    reroll: Predicate | bool | None = None
+    reroll_once: bool = False
+
+    success: Predicate | None = None
+    failure: Predicate | None = None
+
+
+class Parser:
+    def __init__(self, tokens: list[Token]):
+        self.tokens = tokens
+        self.position = 0
+
+    def at_end(self) -> bool: return self.position >= len(self.tokens)
+
+    def peek(self, lookahead: int = 0) -> Token:
+        return self.tokens[self.position + lookahead] if not self.at_end() else Token(TT.ERROR, -1, "End of statement.")
+
+    def advance(self) -> Token:
+        current = self.peek()
+        self.position += 1
+        return current
+
+    def match(self, *tt: TT) -> Token | None:
+        if self.peek().tt in tt:
+            return self.advance()
+        return None
+
+    def match_name(self) -> Token | None:
+        return self.match(
+            *NAME_TTs
+        )
+
+    def expect(self, *tt: TT) -> Token:
+        if match := self.match(*tt):
+            return match
+        raise ValueError(f"Expected one of the following: {tt}.")
+
+
+    def binop(self, next_func, operators: list[TT]) -> Expr:
+        value = next_func()
+        while operator := self.match(*operators):
+            right = next_func()
+            value = BinOp(value, operator, right)
+        return value
+
+
+    def expression(self) -> Expr:
+        return self.add_or_sub()
+
+    def add_or_sub(self) -> Expr:
+        return self.binop(self.mult_or_div, [TT.PLUS, TT.MINUS])
+
+    def mult_or_div(self) -> Expr:
+        return self.binop(self.unary, [TT.STAR, TT.DIV])
+
+    def unary(self) -> Expr:
+        if operator := self.match(TT.MINUS, TT.PLUS):
+            return Unary(operator, self.expo())
+        return self.expo()
+
+    def expo(self) -> Expr:
+        value = self.primitive()
+        while token := self.match(TT.CARET):
+            if isinstance(value, BinOp):
+                value = BinOp(value.left, value.operator, BinOp(value.right, token, self.primitive()))
+            else:
+                value = BinOp(value, token, self.primitive())
+        return value
+
+    def primitive(self) -> Expr:
+        n = self.atom_optional()
+        if self.match(TT.D): # dice
+            if self.peek().tt == TT.PERCENT:
+                self.advance()
+                sides = '%'
+            else:
+                sides = self.atom()
+            dice = Dice(n, sides)
+            while self.dice_modifier(dice):
+                pass
+            return dice
+        return n
+
+    def predicate(self) -> Predicate | None:
+        if operator := self.match(TT.NEQ, TT.EQ, TT.GT, TT.GE, TT.LT, TT.LE):
+            val = self.atom()
+            return Predicate(operator, val)
+        return None
+
+    def dice_modifier(self, dice: Dice) -> bool:
+        if self.match(TT.D, TT.DL):
+            if not dice.drop_low:
+                dice.drop_low = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: drop low.")
+        elif self.match(TT.DH):
+            if not dice.drop_high:
+                dice.drop_high = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: drop high.")
+        elif self.match(TT.K, TT.KH):
+            if not dice.keep_high:
+                dice.keep_high = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: keep high.")
+        elif self.match(TT.KL):
+            if not dice.keep_low:
+                dice.keep_low = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: keep low.")
+        elif self.match(TT.MIN):
+            if not dice.minimum:
+                dice.minimum = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: minimum.")
+        elif self.match(TT.MAX):
+            if not dice.maximum:
+                dice.maximum = self.atom()
+            else: raise ValueError(f"Dice have duplicate field: maximum.")
+        elif op := self.match(TT.BANG, TT.BANG_P):
+            if not dice.explode and not dice.penetrate:
+                if op.tt == TT.BANG:
+                    dice.explode = self.predicate() or True
+                else:
+                    dice.penetrate = self.predicate() or True
+            else: raise ValueError(f"Dice have duplicate field: explode/penetrate.")
+        elif op := self.match(TT.R, TT.RO):
+            if not dice.reroll:
+                if op.tt == TT.RO:
+                    dice.reroll_once = True
+                dice.reroll = self.predicate() or True
+            else: raise ValueError(f"Dice have duplicate field: reroll.")
+
+        elif pred := self.predicate():
+            if not dice.success:
+                dice.success = pred
+                if self.match(TT.F):
+                    dice.failure = self.predicate()
+            else: raise ValueError(f"Dice have duplicate field: success.")
+        else:
+            return False
+        return True
+
+    def paramslist(self) -> list[Variable]:
+        lst = []
+        while n := self.match_name():
+            lst.append(Variable(n))
+            self.match(TT.COMMA)
+        self.expect(TT.RPAREN)
+        return lst
+
+    def argslist(self) -> list[Expr]:
+        lst = []
+        while self.peek().tt != TT.RPAREN:
+            expr = self.expression()
+            lst.append(expr)
+            self.match(TT.COMMA)
+        self.expect(TT.RPAREN)
+
+        return lst
+
+    def atom(self) -> Expr:
+        r = self.atom_optional()
+        if r is None:
+            self.expect(TT.NUMBER)
+        return r
+
+    def atom_optional(self) -> Expr | Function | None:
+        if name := self.match_name():
+            var = Variable(name)
+            if self.match(TT.LPAREN):
+                position = self.position
+                args_list = self.argslist()
+                if self.peek().tt == TT.EQ:
+                    self.position = position
+                    params_list = self.paramslist()
+                    self.expect(TT.EQ)
+                    body = self.expression()
+                    return Function(var, params_list, body)
+
+                return FuncCall(var, args_list)
+            return var
+
+        if self.match(TT.LPAREN):
+            val = self.expression()
+            self.expect(TT.RPAREN)
+            if isinstance(val, Function) and self.match(TT.LPAREN):
+                position = self.position
+                args_list = self.argslist()
+                if self.peek().tt == TT.EQ:
+                    self.position = position
+                    params_list = self.paramslist()
+                    self.expect(TT.EQ)
+                    body = self.expression()
+                    return Function(val.name, params_list, body)
+                return FuncCall(val, args_list)
+            return Grouping(val)
+
+        if n := self.match(TT.NUMBER):
+            return Number(n)
+
+        return None

expr_dice_roller-0.0.1/src/expr_dice_roller.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: expr_dice_roller
+Version: 0.0.1
+Summary: Unofficial port of dice-roller/rpg-dice-roller to Python.
+Author: HellishBro
+Project-URL: Homepage, https://github.com/HellishBro/dice_roller
+Keywords: dice,expressions
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Requires-Dist: build>=1.4.0
+Requires-Dist: setuptools>=77.0.3
+Dynamic: license-file

expr_dice_roller-0.0.1/src/expr_dice_roller.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+pyproject.toml
+src/expr_dice_roller/__init__.py
+src/expr_dice_roller/dice_roller.py
+src/expr_dice_roller/evaluator.py
+src/expr_dice_roller/lexer.py
+src/expr_dice_roller/modifiers.py
+src/expr_dice_roller/parser.py
+src/expr_dice_roller.egg-info/PKG-INFO
+src/expr_dice_roller.egg-info/SOURCES.txt
+src/expr_dice_roller.egg-info/dependency_links.txt
+src/expr_dice_roller.egg-info/requires.txt
+src/expr_dice_roller.egg-info/top_level.txt

expr_dice_roller-0.0.1/src/expr_dice_roller.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

expr_dice_roller-0.0.1/src/expr_dice_roller.egg-info/requires.txt

@@ -0,0 +1,2 @@
+build>=1.4.0
+setuptools>=77.0.3

expr_dice_roller-0.0.1/src/expr_dice_roller.egg-info/top_level.txt

@@ -0,0 +1 @@
+expr_dice_roller