minecraft-datapack-language 16.0.13__tar.gz → 16.0.15__tar.gz

{minecraft_datapack_language-16.0.13/minecraft_datapack_language.egg-info → minecraft_datapack_language-16.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.13
+Version: 16.0.15
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

minecraft_datapack_language-16.0.15/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "16.0.14"
+tag: "v16.0.14"
+updated_at: "2025-09-10T04:04:51Z"

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15}/docs/downloads.md

@@ -350,17 +350,19 @@ MDL is open source software licensed under the MIT License. See the [LICENSE](ht
 }
 
 [data-theme="dark"] .install-code {
-  background: #21262d;
+  background: #191d23 !important;
   border-color: #30363d;
 }
 
 .install-code code {
   font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
   color: #24292e;
+  border: 0;
 }
 
 [data-theme="dark"] .install-code code {
   color: #e6edf3;
+  background: inherit !important;
 }
 
 .releases-section {

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '16.0.13'
-__version_tuple__ = version_tuple = (16, 0, 13)
+__version__ = version = '16.0.15'
+__version_tuple__ = version_tuple = (16, 0, 15)
 
-__commit_id__ = commit_id = 'g6ec8279e5'
+__commit_id__ = commit_id = 'g86e8af6ba'

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15}/minecraft_datapack_language/mdl_compiler.py

@@ -819,12 +819,58 @@ class MDLCompiler:
         else:
             return str(expression)
     
+    def _normalize_operator(self, op_in: Any) -> Optional[str]:
+        """Normalize operator tokens/strings to Minecraft execute/scoreboard symbols.
+        Returns one of: '>', '>=', '<', '<=', '==', '!=' or None if unknown.
+        """
+        # Direct symbol passthrough
+        if op_in in ('>', '>=', '<', '<=', '==', '!='):
+            return op_in
+        # TokenType instances
+        try:
+            if op_in == TokenType.GREATER:
+                return '>'
+            if op_in == TokenType.GREATER_EQUAL:
+                return '>='
+            if op_in == TokenType.LESS:
+                return '<'
+            if op_in == TokenType.LESS_EQUAL:
+                return '<='
+            if op_in == TokenType.EQUAL:
+                return '=='
+            if op_in == TokenType.NOT_EQUAL:
+                return '!='
+        except Exception:
+            pass
+        # String names from bindings or parser
+        if isinstance(op_in, str):
+            upper = op_in.upper()
+            if upper == 'GREATER':
+                return '>'
+            if upper == 'GREATER_EQUAL':
+                return '>='
+            if upper == 'LESS':
+                return '<'
+            if upper == 'LESS_EQUAL':
+                return '<='
+            if upper == 'EQUAL' or upper == 'EQ':
+                return '=='
+            if upper == 'NOT_EQUAL' or upper == 'NE':
+                return '!='
+        return None
+    
     def _expression_to_condition(self, expression: Any) -> str:
         """Legacy: Convert expression to a naive condition string (internal use)."""
         if isinstance(expression, BinaryExpression):
             left = self._expression_to_value(expression.left)
             right = self._expression_to_value(expression.right)
-            return f"{left} {expression.operator} {right}"
+            op_sym = self._normalize_operator(expression.operator)
+            # Minecraft scoreboard uses '=' instead of '=='
+            if op_sym == '==':
+                op_text = '='
+            else:
+                op_text = op_sym if op_sym is not None else str(expression.operator)
+            return f"{left} {op_text} {right}"
         else:
             return self._expression_to_value(expression)
 
@@ -835,12 +881,18 @@ class MDLCompiler:
         # Default: generic expression string, no inversion
         invert_then = False
         
+        # Helpers local to this method to keep concerns contained
+        def unwrap(e: Any) -> Any:
+            while isinstance(e, ParenthesizedExpression):
+                e = e.expression
+            return e
+
         if isinstance(expression, BinaryExpression):
-            left = expression.left
-            right = expression.right
-            op = expression.operator
+            left = unwrap(expression.left)
+            right = unwrap(expression.right)
+            op_sym = self._normalize_operator(expression.operator)
             # Variable vs literal
-            if isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
+            if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
                 objective = self.variables.get(left.name, left.name)
                 scope = left.scope.strip("<>")
                 # Normalize number
@@ -850,41 +902,47 @@ class MDLCompiler:
                     v = None
                 if v is not None:
                     n = int(v) if float(v).is_integer() else v
-                    if op == TokenType.GREATER:
+                    if op_sym == ">":
                         rng = f"{int(n)+1}.." if isinstance(n, int) else f"{v+1}.."
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.GREATER_EQUAL:
+                    if op_sym == ">=":
                         rng = f"{int(n)}.."
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.LESS:
+                    if op_sym == "<":
                         rng = f"..{int(n)-1}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.LESS_EQUAL:
+                    if op_sym == "<=":
                         rng = f"..{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.EQUAL:
+                    if op_sym == "==":
                         rng = f"{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.NOT_EQUAL:
+                    if op_sym == "!=":
                         rng = f"{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", True)
+            # Literal vs variable (swap sides)
+            if op_sym and isinstance(left, LiteralExpression) and isinstance(left.value, (int, float)) and isinstance(right, VariableSubstitution):
+                # Swap by inverting the operator appropriately, then reuse logic
+                invert_map = {
+                    ">": "<",
+                    ">=": "<=",
+                    "<": ">",
+                    "<=": ">=",
+                    "==": "==",
+                    "!=": "!="
+                }
+                swapped = BinaryExpression(left=right, operator=invert_map.get(op_sym, op_sym), right=left)
+                return self._build_condition(swapped)
             # Variable vs variable
-            if isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
+            if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
                 lobj = self.variables.get(left.name, left.name)
                 lscope = left.scope.strip("<>")
                 robj = self.variables.get(right.name, right.name)
                 rscope = right.scope.strip("<>")
-                if op in (TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL, TokenType.EQUAL):
-                    comp_map = {
-                        TokenType.GREATER: ">",
-                        TokenType.GREATER_EQUAL: ">=",
-                        TokenType.LESS: "<",
-                        TokenType.LESS_EQUAL: "<=",
-                        TokenType.EQUAL: "="
-                    }
-                    comp = comp_map[op]
+                if op_sym in (">", ">=", "<", "<=", "=="):
+                    comp = op_sym if op_sym != "==" else "="
                     return (f"score {lscope} {lobj} {comp} {rscope} {robj}", False)
-                if op == TokenType.NOT_EQUAL:
+                if op_sym == "!=":
                     # Use equals with inversion
                     return (f"score {lscope} {lobj} = {rscope} {robj}", True)
         

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.13
+Version: 16.0.15
 Summary: Compile MDL language with explicit scoping into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15}/tests/run_all_tests.py

@@ -12,7 +12,11 @@ from pathlib import Path
 
 
 def run_test_suite(name, command, description=""):
-    """Run a test suite and return results."""
+    """Run a test suite and return results.
+
+    If command is a list, execute without a shell to avoid shell expansions.
+    If command is a string, execute via the shell (backward compatible).
+    """
     print(f"\n{'='*60}")
     print(f"Running {name}")
     if description:
@@ -22,7 +26,8 @@ def run_test_suite(name, command, description=""):
     start_time = time.time()
     
     try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        use_shell = isinstance(command, str)
+        result = subprocess.run(command, shell=use_shell, capture_output=True, text=True)
         duration = time.time() - start_time
         
         if result.returncode == 0:
@@ -64,11 +69,16 @@ def main():
         has_cov = importlib.util.find_spec("pytest_cov") is not None
     except Exception:
         has_cov = False
-    base_cmd = "python -m pytest tests/ -v"
-    cov_args = " --cov=minecraft_datapack_language --cov-report=term-missing --cov-report=html:htmlcov" if has_cov else ""
+    base_cmd = [sys.executable, "-m", "pytest", "tests/", "-v"]
+    if has_cov:
+        base_cmd += [
+            "--cov=minecraft_datapack_language",
+            "--cov-report=term-missing",
+            "--cov-report=html:htmlcov",
+        ]
     pytest_result = run_test_suite(
         "Pytest Suite",
-        f"{base_cmd}{cov_args}",
+        base_cmd,
         "Comprehensive pytest suite" + (" with coverage" if has_cov else "")
     )
     results.append(("Pytest", pytest_result))
@@ -87,7 +97,7 @@ def main():
         if test_path.exists():
             result = run_test_suite(
                 f"Pytest {test_file}",
-                f"python -m pytest -q tests/{test_file}",
+                [sys.executable, "-m", "pytest", "-q", f"tests/{test_file}"],
                 description
             )
             results.append((test_file, result))
@@ -100,7 +110,11 @@ def main():
     # Test complex scenarios
     complex_result = run_test_suite(
         "Complex Scenarios Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; var num counter<@s> = 0; var num health<@s> = 20; var num bonus<@s> = 5; function test:complex_math<@s> { counter<@s> = ($counter<@s>$ + $health<@s>$) * $bonus<@s>$; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Complex expressions compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; var num counter<@s> = 0; var num health<@s> = 20; var num bonus<@s> = 5; function test:complex_math<@s> { counter<@s> = ($counter<@s>$ + $health<@s>$) * $bonus<@s>$; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Complex expressions compilation successful')",
+        ],
         "Test complex mathematical expressions compilation"
     )
     results.append(("Complex Expressions", complex_result))
@@ -108,7 +122,11 @@ def main():
     # Test control flow
     control_result = run_test_suite(
         "Control Flow Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; var num health<@s> = 20; function test:health_check<@s> { if $health<@s>$ < 10 { say \\\"Health is low!\\\"; } else { say \\\"Health is good!\\\"; } }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Control flow compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; var num health<@s> = 20; function test:health_check<@s> { if $health<@s>$ < 10 { say \"Health is low!\"; } else { say \"Health is good!\"; } }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Control flow compilation successful')",
+        ],
         "Test if/else control flow compilation"
     )
     results.append(("Control Flow", control_result))
@@ -116,7 +134,11 @@ def main():
     # Test function execution
     function_result = run_test_suite(
         "Function Execution Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; function test:helper<@s> { say \\\"Helper function!\\\"; } function test:main<@s> { exec test:helper<@s>; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Function execution compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; function test:helper<@s> { say \"Helper function!\"; } function test:main<@s> { exec test:helper<@s>; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Function execution compilation successful')",
+        ],
         "Test function execution with scopes"
     )
     results.append(("Function Execution", function_result))
@@ -125,7 +147,11 @@ def main():
     print("\nTesting Python bindings...")
     api_result = run_test_suite(
         "Python Bindings Basic",
-        "python -c \"from minecraft_datapack_language import Pack; import tempfile, shutil; from pathlib import Path; td=tempfile.mkdtemp(); p=Pack('Test','Test pack',82); ns=p.namespace('test'); ns.function('hello','say Hello World!'); p.build(td); output=Path(td)/'data'/'test'/'function'/'hello.mcfunction'; assert output.exists(); print('Python API test successful'); shutil.rmtree(td)\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language import Pack; import tempfile, shutil; from pathlib import Path; td=tempfile.mkdtemp(); p=Pack('Test','Test pack',82); ns=p.namespace('test'); ns.function('hello','say Hello World!'); p.build(td); output=Path(td)/'data'/'test'/'function'/'hello.mcfunction'; assert output.exists(); print('Python API test successful'); shutil.rmtree(td)",
+        ],
         "Test basic Python bindings functionality"
     )
     results.append(("Python Bindings", api_result))
@@ -134,7 +160,7 @@ def main():
     print("\nTesting CLI...")
     cli_result = run_test_suite(
         "CLI Help",
-        "python -m minecraft_datapack_language.cli --help",
+        [sys.executable, "-m", "minecraft_datapack_language.cli", "--help"],
         "Test CLI help command"
     )
     results.append(("CLI Help", cli_result))

{minecraft_datapack_language-16.0.13 → minecraft_datapack_language-16.0.15}/tests/test_python_bindings.py

@@ -56,3 +56,56 @@ def test_bindings_complex_expression():
         # Temp ops are inlined now; footer removed
         assert 'temp_' in text
 
+
+def test_bindings_equality_and_inequality_symbols():
+    p = Pack("Bindings3", "desc", 82)
+    ns = p.namespace("cmp")
+
+    def build(fb):
+        fb.declare_var("a", "<@s>", 1)
+        fb.declare_var("b", "<@s>", 1)
+        # Use symbol operators that previously leaked into output
+        cond_eq = binop(var_read("a", "<@s>"), "==", var_read("b", "<@s>"))
+        fb.if_(cond_eq, lambda t: t.say("eq"), lambda e: e.say("neq"))
+        cond_ne = binop(var_read("a", "<@s>"), "!=", var_read("b", "<@s>"))
+        fb.if_(cond_ne, lambda t: t.say("ne_true"), lambda e: e.say("ne_false"))
+
+    ns.function("main", build)
+
+    with tempfile.TemporaryDirectory() as td:
+        p.build(td)
+        func = Path(td) / 'data' / 'cmp' / 'function'
+        main = (func / 'main.mcfunction').read_text()
+        # Equality should map to '=' and inequality should invert the execute
+        assert 'execute if score @s a = @s b' in main
+        assert 'execute unless score @s a = @s b' in main
+        # Ensure invalid raw operators are not present
+        assert '==' not in main
+        assert '!=' not in main
+
+
+def test_bindings_equality_literal_and_not_equal_word():
+    p = Pack("Bindings4", "desc", 82)
+    ns = p.namespace("lit")
+
+    def build(fb):
+        fb.declare_var("x", "<@s>", 5)
+        # Symbol equality against literal and word-form NOT_EQUAL
+        cond_eq = binop(var_read("x", "<@s>"), "==", num(5))
+        fb.if_(cond_eq, lambda t: t.say("is5"))
+        cond_ne = binop(var_read("x", "<@s>"), "NOT_EQUAL", num(7))
+        fb.if_(cond_ne, lambda t: t.say("not7"))
+
+    ns.function("main", build)
+
+    with tempfile.TemporaryDirectory() as td:
+        p.build(td)
+        func = Path(td) / 'data' / 'lit' / 'function'
+        main = (func / 'main.mcfunction').read_text()
+        # Equality to literal uses matches N
+        assert 'execute if score @s x matches 5' in main
+        # Not equal to literal uses unless matches N
+        assert 'execute unless score @s x matches 7' in main
+        # Ensure invalid raw operators are not present
+        assert '==' not in main
+        assert '!=' not in main

minecraft_datapack_language-16.0.13/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "16.0.12"
-tag: "v16.0.12"
-updated_at: "2025-09-09T04:08:38Z"