bolt_compute 0.0.3__py3-none-any.whl

bolt_compute-0.0.3.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.5
+Name: bolt_compute
+Version: 0.0.3
+Summary: Add your description here
+Requires-Python: >=3.14
+Requires-Dist: beet>=0.116.0
+Requires-Dist: bolt>=0.50.1
+Description-Content-Type: text/markdown
+
+# Bolt Compute
+
+A [beet](https://github.com/mcbeet/beet) plugin that allows to use expressions instead of inline [number providers](https://minecraft.wiki/w/Number_provider).
+
+
+## Installation
+
+In a beet project, use `uv add bolt_compute` and add the module in the require phase in your beet config:
+
+```yaml
+require:
+  - bolt
+  - bolt_compute # <-- Add this line
+pipeline:
+  - mecha
+```
+
+## Usage
+
+Any place where the `compute` command/subcommand is used, you can use the `bolt` subcommand to use an expression instead of a number provider. For example, instead of:
+
+```mcfunction 
+compute default {type:"minecraft:sum",operands:[1,1]}
+data modify storage namespace:path path set compute default {type:"minecraft:sum",operands:[1,1]}
+```
+You can use:
+
+```mcfunction
+compute bolt (1 + 1)
+data modify storage namespace:path path set compute bolt (1 + 1)
+```
+
+### Literals values
+
+Bolt compute supports the following literal values:
+```mcfunction
+compute bolt (storage namespace:path path) # compute default {type:"minecraft:storage",storage:"namespace:path",path:"path"}
+
+x = 1 # bolt variable assignment
+compute bolt (x + 1) # compute default {type:"minecraft:sum",operands:[1,1]}
+
+y = "namespace:path_to_number_provider"
+compute bolt (y * y) # compute default {type:"minecraft:product",operands:["namespace:path_to_number_provider","namespace:path_to_number_provider"]}
+
+```
+
+### Operators
+
+`+`, `-`, `*`, are supported, as well as parentheses for grouping.
+
+### Functions
+
+Built-in functions are supported, such as : 
+- `average` expect a list using square brackets, e.g. `average([1,2,3])`
+- `binomial` expect N and P, can be expressions, e.g. `binomial(10, 0.5)`
+- `conditional` currently not implemented
+- `maximum` expect a list using square brackets, e.g. `maximum([1,2,3])`
+- `minimum` expect a list using square brackets, e.g. `minimum([1,2,3])`
+- `uniform` expect two number providers, can be expressions, e.g. `uniform(1, 10)`
+- `sum` expect a list using square brackets, e.g. `sum([1,2,3])`
+- `product` expect a list using square brackets, e.g. `product([1,2,3])`
+
+### Multiline expressions
+
+Expressions can be multiline, for example:
+
+```mcfunction
+x = 1
+y = 2
+compute bolt (
+    x + y
+)
+```
+
+### Full example
+
+```mcfunction
+
+x = "namespace:path_to_number_provider"
+y = 256*256
+
+data modify storage example:main result_bolt set compute bolt (
+    (storage example:main prod1)*(storage example:main prod2)*(storage example:main prod3)*2
+    *
+    2485*52+
+    maximum([0,1,(storage example:main prod2),1])+(143)-
+    (y*x) + x
+)
+```
+
+More examples can be found in the [examples](examples) folder.

bolt_compute-0.0.3.dist-info/RECORD

@@ -0,0 +1,4 @@
+bolt_compute.py,sha256=U20K8rZsyDkTgUqnRCuXTcmoLqHs96MZthy8irmLzzQ,17718
+bolt_compute-0.0.3.dist-info/METADATA,sha256=i0-hn6UyBplikmiHOd_5bTNy6Om9y7XXID2xSJgBQ_4,2821
+bolt_compute-0.0.3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+bolt_compute-0.0.3.dist-info/RECORD,,

bolt_compute-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bolt_compute.py

@@ -0,0 +1,502 @@
+from dataclasses import dataclass
+from typing import Any, Callable, Generator, Literal, Optional, Self, Type, TypedDict, overload
+
+from beet import Context
+from beet.core.utils import JsonDict, required_field
+from bolt import AstCall, AstFormatString, AstIdentifier, AstValue
+from mecha import AbstractNode, AstNbtPath, AstNbtPathKey, AstNbtPathSubscript, AstNode, AstNumber, AstResourceLocation, Mecha, CommandTree, MultilineParser, NbtPathParser, Rule, delegate, rule
+from mecha.utils import QuoteHelper, number_to_string
+from bolt.pattern import STRING_PATTERN, RESOURCE_LOCATION_PATTERN
+from tokenstream import TokenStream, Token, set_location, InvalidSyntax
+
+FUNCTION_OVERRIDES = [
+    "average",
+    "binomial",
+    "conditional",
+    "maximum",
+    "minimum",
+    "uniform",
+    "sum",
+    "product",
+]
+
+def iter_compute_tree(tree: CommandTree):
+    if tree.children:
+        compute = tree.children["compute"]
+        if compute.children:
+            yield compute
+
+
+        data = tree.children["data"]
+        if data.children:
+            modify = data.children["modify"]
+            if modify.children:
+                childs = [
+                    "block",
+                    "entity",
+                    "storage",
+                ]
+                for c in childs:
+                    child = modify.children[c]
+                    if child.children:
+                        target = child.children["target"]
+                        if target.children:
+                            targetPath = target.children["targetPath"]
+                            if targetPath.children:
+                                for o in [
+                                    "append",
+                                    "merge",
+                                    "prepend",
+                                    "set",
+                                ]:
+                                    operation = targetPath.children[o]
+                                    if operation.children:
+                                        compute = operation.children["compute"]
+                                        yield compute
+                                insert = targetPath.children["insert"]
+                                if insert.children:
+                                    index = insert.children["index"]
+                                    if index.children:
+                                        compute = index.children["compute"]
+                                        yield compute
+                                        
+@dataclass
+class MutableDepth:
+    value: int
+
+@dataclass(frozen=True, slots=True)
+class AstComputeStorage(AstNode):
+    """Ast bolt compute storage node."""
+    storage: AstComputeResourceLocation = required_field()
+    path: AstNbtPath = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        storage: AstComputeResourceLocation,
+        path: AstNbtPath,
+        depth: int,
+    ) -> AstComputeStorage:
+        """Return a bool node from the given value."""
+        return AstComputeStorage(storage=storage, path=path, depth=MutableDepth(depth))
+
+@dataclass(frozen=True, slots=True)
+class AstComputeBoltValue(AstNode):
+    value: AstNode = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        value: AstNode,
+        depth: int,
+    ) -> Self:
+        return cls(value=value, depth=MutableDepth(depth))
+
+@dataclass(frozen=True, slots=True)
+class AstComputeListCall(AstNode):
+    type: str = required_field()
+    operands: list[ValueType] = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        type: str,
+        operands: list[ValueType],
+        depth: int,
+    ) -> Self:
+        """Return a bool node from the given value."""
+        return cls(type=type, operands=operands, depth=MutableDepth(depth))
+
+@dataclass(frozen=True, slots=True)
+class AstComputeBinomial(AstNode):
+    n: ValueType = required_field()
+    p: ValueType = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        n: ValueType,
+        p: ValueType,
+        depth: int,
+    ) -> Self:
+        return cls(n=n, p=p, depth=MutableDepth(depth))
+
+@dataclass(frozen=True, slots=True)
+class AstComputeUniform(AstNode):
+    minimum: ValueType = required_field()
+    maximum: ValueType = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        minimum: ValueType,
+        maximum: ValueType,
+        depth: int,
+    ) -> Self:
+        return cls(minimum=minimum, maximum=maximum, depth=MutableDepth(depth))
+
+
+
+
+@dataclass(frozen=True, slots=True)
+class AstComputeNumber(AstNode):
+    value: AstNumber = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(
+        cls,
+        value: Any,
+        depth: int,
+    ) -> Self:
+        """Return a bool node from the given value."""
+        return cls(value=AstNumber.from_value(value), depth=MutableDepth(depth))
+
+
+
+type AstComputeSource = AstComputeStorage # future AstScoreStorage
+
+type ValueType = AstComputeOperation | AstComputeResourceLocation | AstComputeNumber | AstComputeSource | AstComputeBoltValue
+type Operation = Literal["+", "-", "/", "*"]
+
+@dataclass(frozen=True, slots=True)
+class AstBoltComputeRoot(AstNode):
+    children: AstComputeOperation = required_field()
+
+@dataclass(frozen=True, slots=True)
+class AstComputeResourceLocation(AstNode): 
+    resource_location: AstResourceLocation = required_field()
+    depth: MutableDepth = required_field()
+
+    @classmethod
+    def from_value(cls, value: Any, depth: int) -> "AstComputeResourceLocation": 
+        return AstComputeResourceLocation(resource_location=AstResourceLocation.from_value(value), depth=MutableDepth(depth))
+
+@dataclass(frozen=True, slots=True)
+class AstComputeOperation(AstNode):
+    """Ast bolt compute node."""
+
+    lvalue: ValueType = required_field()
+    operation: Optional[Operation] = required_field()
+    rvalue: Optional[ValueType] = required_field()
+
+    depth: MutableDepth = required_field()
+
+    parser = "bolt_compute:parse_operation"
+
+    @classmethod
+    def from_value(
+        cls,
+        lvalue: ValueType,
+        operation: Optional[Operation] = None,
+        rvalue: Optional[ValueType] = None,
+        depth: int = 0,
+    ) -> AstComputeOperation:
+        """Return a bool node from the given value."""
+        return AstComputeOperation(lvalue=lvalue, operation=operation, rvalue=rvalue, depth=MutableDepth(depth))
+
+
+def parse_operation(stream: TokenStream, depth: int) -> AstComputeOperation:
+    """Parse operations with correct precedence: additive (lower) then multiplicative (higher)."""
+    return parse_additive(stream, depth)
+
+
+def parse_additive(stream: TokenStream, depth: int) -> AstComputeOperation:
+    """Parse additive operations (+, -) - lowest precedence."""
+    lvalue = parse_multiplicative(stream, depth)
+    
+    while True:
+        with stream.alternative():
+            token = stream.expect("additive")
+            rvalue = parse_multiplicative(stream, depth+1)
+            op: Operation = token.value  # pyright: ignore[reportAssignmentType]
+            lvalue = AstComputeOperation.from_value(lvalue, op, rvalue, depth=depth)
+            lvalue.lvalue.depth.value +=1
+            continue
+        break
+    
+    return lvalue
+
+
+def parse_multiplicative(stream: TokenStream, depth: int) -> AstComputeOperation:
+    """Parse multiplicative operations (*, /) - highest precedence."""
+    lvalue = parse_primary(stream, depth)
+    
+    while True:
+        with stream.alternative():
+            token = stream.expect("multiplicative")
+            rvalue = parse_primary(stream, depth+1)
+            op: Operation = token.value  # pyright: ignore[reportAssignmentType]
+            lvalue = AstComputeOperation.from_value(lvalue, op, rvalue, depth=depth)
+            lvalue.lvalue.depth.value +=1
+            continue
+        break
+    
+    return lvalue
+
+
+def parse_primary(stream: TokenStream, depth: int) -> ValueType:
+    """Parse primary expressions (literals, parenthesized expressions, function calls)."""
+    with stream.checkpoint() as commit:
+        stream.expect("oparent")
+        result = parse_additive(stream, depth=depth)
+        stream.expect("cparent")
+        commit()
+        return result
+    
+    return parse_literal(stream, depth=depth)
+
+def parse_list(stream: TokenStream, depth: int):
+    """Parse a comma-separated list of expressions inside brackets."""
+    stream.expect("obracket")
+    values: list[ValueType] = []
+    while True:
+        with stream.checkpoint() as commit:
+            stream.expect("cbracket")
+            commit()
+            break
+        values.append(parse_operation(stream, depth=depth+1))
+        follow = stream.expect_any("comma", "cbracket")
+        match follow:
+            case Token("cbracket"):
+                break
+            case Token("comma"):
+                ...
+    return values
+
+
+def parse_literal(stream: TokenStream, depth: int = 0) -> ValueType:
+    bolt_expression_parser = delegate("bolt:primary")
+    with stream.checkpoint() as commit:
+        bolt_node: AstNode = bolt_expression_parser(stream)
+        # parse and return value type
+        if isinstance(bolt_node, AstValue):
+            if isinstance(bolt_node.value, (float, int)):
+                commit()
+                return AstComputeNumber.from_value(bolt_node.value, depth=depth)
+            elif isinstance(bolt_node.value, str):
+                commit()
+                return AstComputeResourceLocation.from_value(bolt_node.value, depth=depth)
+        elif isinstance(bolt_node, AstIdentifier):
+            commit()
+            return AstComputeBoltValue.from_value(bolt_node, depth=depth)
+        elif isinstance(bolt_node, AstFormatString):
+            commit()
+            return AstComputeBoltValue.from_value(bolt_node, depth=depth)
+        elif isinstance(bolt_node, AstCall):
+            if isinstance(bolt_node.value, AstIdentifier) and bolt_node.value.value in FUNCTION_OVERRIDES:
+                raise InvalidSyntax(f"Python built-in sum collide with bolt_compute sum")
+            commit()
+            return AstComputeBoltValue.from_value(bolt_node, depth=depth)
+        
+        raise NotImplementedError(bolt_node)
+
+    stream.crop()
+    token = stream.expect_any("oparent", "number", "quotes", "storage", "call")
+    match token:
+        case Token("oparent"):
+            return parse_operation(stream, depth=depth+1)
+        case Token("number"):
+            return AstComputeNumber.from_value(token.value, depth=depth)
+        case Token("quotes"):
+            res: AstResourceLocation = delegate("resource_location")(stream)
+            stream.expect("quotes")
+            return AstComputeResourceLocation.from_value(res, depth=depth)
+        case Token("storage"):
+            storage: AstComputeResourceLocation = delegate("resource_location")(stream)
+            parser = delegate("nbt_path")
+            path: AstNbtPath = parser(stream)
+            return AstComputeStorage.from_value(storage, path, depth=depth)
+        case Token("call"):
+            if token.value in ["maximum", "minimum", "average", "sum", "product"]:
+                stream.expect("oparent")
+                values = parse_list(stream, depth+1)
+                if len(values) == 0:
+                    raise InvalidSyntax(f"Function {token.value} require at least one argument")
+                stream.expect("cparent")
+                return AstComputeListCall.from_value(token.value, values, depth)
+            elif token.value == "binomial":
+                stream.expect("oparent")
+                N = parse_literal(stream, depth=depth+1)
+                stream.expect("comma")
+                P = parse_literal(stream, depth=depth+1)
+                cparent, comma = stream.expect("cparent", "comma")
+                if comma: stream.expect("cparent")
+                return AstComputeBinomial.from_value(N, P, depth)
+            elif token.value == "uniform":
+                stream.expect("oparent")
+                minimum = parse_literal(stream, depth=depth+1)
+                stream.expect("comma")
+                maximum = parse_literal(stream, depth=depth+1)
+                cparent, comma = stream.expect("cparent", "comma")
+                if comma: stream.expect("cparent")
+                return AstComputeUniform.from_value(minimum, maximum, depth)
+
+            raise NotImplementedError(token.value)
+
+    raise NotImplementedError("UNREACHABLE")
+
+
+
+def operation_parser(stream: TokenStream):
+    """Parse operation."""
+    with stream.syntax(
+        bolt="bolt"
+    ):
+        stream.expect("bolt")
+    with stream.syntax(
+        oparent=r"\(",
+        cparent=r"\)",
+        obracket=r"\[",
+        cbracket=r"\]",
+        comma=r",",
+        equal=r"=",
+        additive=r"\+|\-",
+        multiplicative=r"\*|\/",
+        number=r"[+-]?([0-9]*[.])?[0-9]+",
+        storage=r"storage",
+        call="|".join(FUNCTION_OVERRIDES),
+        quotes=r'"',
+        resource=RESOURCE_LOCATION_PATTERN,
+        name=r'[a-z]([a-z0-9]+)?'
+    ):
+        stream.expect("oparent")
+        operation = parse_operation(stream, depth=0)
+        stream.expect("cparent", "end")
+    return AstBoltComputeRoot(children=operation)
+
+
+
+@rule(AstComputeOperation)
+def serialize_operation(node: AstComputeOperation, result: list[str]):
+    if node.lvalue and not node.rvalue:
+        assert node.operation is None
+        yield node.lvalue
+    elif node.lvalue and node.rvalue:
+        assert node.operation is not None
+        match node.operation:
+            case "+":
+                result.append('{type:"minecraft:sum",operands:[')
+                yield node.lvalue
+                result.append(',')
+                yield node.rvalue
+                result.append(']}')
+            case "-":
+                result.append('{type:"minecraft:sum",operands:[')
+                yield node.lvalue
+                result.append(',')
+                result.append('{type:"minecraft:product",operands:[-1')
+                result.append(',')
+                yield node.rvalue
+                result.append(']}')
+                result.append(']}')
+            case "*":
+                result.append('{type:"minecraft:product",operands:[')
+                yield node.lvalue
+                result.append(',')
+                yield node.rvalue
+                result.append(']}')
+            case _:
+                raise NotImplementedError()
+
+@rule(AstBoltComputeRoot)
+def serialize_root(node: AstBoltComputeRoot, result: list[str]):
+    result.append("default")
+    result.append(" ")
+    yield node.children
+
+@rule(AstComputeResourceLocation)
+def serialize_resource_location(node: AstComputeResourceLocation, result: list[str]):
+    if node.depth.value != 0: result.append('"')
+    result.append(node.resource_location.get_canonical_value())
+    if node.depth.value != 0: result.append('"')
+
+@rule(AstComputeStorage)
+def serialize_storage(node: AstComputeStorage, result: list[str]):
+    result.append('{type:"minecraft:storage",storage:"')
+    yield node.storage
+    result.append('",path:"')
+    yield node.path
+    result.append('"}')
+
+
+@rule(AstComputeBoltValue)
+def serialize_bolt_value(node: AstComputeBoltValue, result: list[str]):
+    if isinstance(node.value, (float, int)):
+        yield AstComputeNumber.from_value(node.value, node.depth.value)
+    elif isinstance(node.value, str): 
+        a = AstComputeResourceLocation.from_value(node.value, node.depth.value)
+        yield a
+
+
+@rule(AstComputeListCall)
+def serialize_list_call(node: AstComputeListCall, result: list[str]):
+    result.append('{type:"minecraft:')
+    result.append(node.type)
+    result.append('",operands:[')
+    sep = ""
+    for children in node.operands:
+        result.append(sep)
+        sep = ","
+        yield children
+    result.append(']}')
+
+
+
+
+@rule(AstComputeNumber)
+def serialize_compute_number(node: AstComputeNumber, result: list[str]): 
+    if node.depth.value == 0: result.append('{type:"minecraft:constant",value:')
+    yield node.value
+    if node.depth.value == 0: result.append('}')
+
+@rule(AstComputeBinomial)
+def serialize_compute_binomial(node: AstComputeBinomial, result: list[str]): 
+    result.append('{type:"minecraft:binomial",n:')
+    yield node.n
+    result.append(',p:')
+    yield node.p
+    result.append('}')
+
+@rule(AstComputeUniform)
+def serialize_compute_uniform(node: AstComputeUniform, result: list[str]): 
+    result.append('{type:"minecraft:uniform",min:')
+    yield node.minimum
+    result.append(',max:')
+    yield node.maximum
+    result.append('}')
+
+def beet_default(ctx: Context):
+    mc = ctx.inject(Mecha)
+    mc.spec.parsers["command:argument:minecraft:number_provider"] = MultilineParser(delegate("resource_location_or_nbt"))
+    rules = [
+        serialize_operation,
+        serialize_resource_location,
+        serialize_root,
+        serialize_storage,
+        serialize_bolt_value,
+        serialize_compute_number,
+        serialize_list_call,
+        serialize_compute_binomial,
+        serialize_compute_uniform,
+    ]
+    for r in rules:
+        mc.serialize.add_rule(r)
+
+    for compute in iter_compute_tree(mc.spec.tree):
+        if compute.children:
+            compute.children["bolt"] = CommandTree(**{
+                "type": "argument",
+                "executable": True,
+                "parser": "bolt_compute:operation_parser"
+            })
+
+    mc.spec.parsers["command:argument:bolt_compute:operation_parser"] = MultilineParser(operation_parser)
+
+        
+    mc.spec.update()