minecraft-datapack-language 15.4.39__py3-none-any.whl → 15.4.40__py3-none-any.whl

minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '15.4.39'
-__version_tuple__ = version_tuple = (15, 4, 39)
+__version__ = version = '15.4.40'
+__version_tuple__ = version_tuple = (15, 4, 40)
 
 __commit_id__ = commit_id = None

minecraft_datapack_language/cli.py

@@ -7,6 +7,7 @@ import argparse
 import sys
 import os
 from pathlib import Path
+import shutil
 from .mdl_lexer import MDLLexer
 from .mdl_parser import MDLParser
 from .mdl_compiler import MDLCompiler
@@ -37,6 +38,7 @@ Examples:
     build_parser.add_argument('-o', '--output', required=True, help='Output directory for the datapack')
     build_parser.add_argument('--verbose', action='store_true', help='Show detailed output')
     build_parser.add_argument('--wrapper', help='Optional wrapper directory name for the datapack output')
+    build_parser.add_argument('--no-zip', action='store_true', help='Do not create a zip archive (zip is created by default)')
     
     # Check command
     check_parser = subparsers.add_parser('check', help='Check MDL files for syntax errors')
@@ -150,6 +152,14 @@ def build_command(args):
             output_dir = output_dir / args.wrapper
         compiler = MDLCompiler()
         output_path = compiler.compile(final_ast, str(output_dir))
+
+        # Zip the datapack by default unless disabled
+        if not getattr(args, 'no_zip', False):
+            base_name = str(Path(output_path))
+            # Create archive next to the output directory (base_name.zip)
+            archive_path = shutil.make_archive(base_name, 'zip', root_dir=str(Path(output_path)))
+            if args.verbose:
+                print(f"Created archive: {archive_path}")
         
         print(f"Successfully built datapack: {output_path}")
         return 0

minecraft_datapack_language/mdl_compiler.py

@@ -225,10 +225,11 @@ class MDLCompiler:
                     print(f"Tag {tag.tag_type}: {tag.name} -> {tag_file} (placeholder)")
             else:
                 # Write simple values list
-                values = [f"{self.current_namespace}:{tag.name}"]
-                # For item tags, the TagDeclaration.name may include namespace:name; use as-is
-                if ":" in tag.name:
-                    values = [tag.name]
+                # For item tags, the TagDeclaration.name may include namespace:name
+                # The output filename should be the local name (after ':') if present
+                name_for_file = tag.name.split(":", 1)[1] if ":" in tag.name else tag.name
+                tag_file = tag_dir / f"{name_for_file}.json"
+                values = [tag.name if ":" in tag.name else f"{self.current_namespace}:{tag.name}"]
                 tag_data = {"values": values}
                 with open(tag_file, 'w') as f:
                     json.dump(tag_data, f, indent=2)
@@ -249,11 +250,14 @@ class MDLCompiler:
         load_file = functions_dir / "load.mcfunction"
         with open(load_file, 'w') as f:
             f.write(load_content)
-        # Ensure minecraft load tag points to namespace:load when needed
+        # Ensure minecraft load tag points to namespace:load
         tags_fn_dir = self.output_dir / "data" / "minecraft" / self.dir_map.tags_function
         tags_fn_dir.mkdir(parents=True, exist_ok=True)
         load_tag_file = tags_fn_dir / "load.json"
-        values = [f"{self.current_namespace}:load"] if has_on_load else [f"{self.current_namespace}:load"]
+        # If there are explicit on_load hooks, include them; otherwise reference namespace:load
+        values = [f"{self.current_namespace}:load"]
+        if has_on_load:
+            values = [f"{hook.namespace}:{hook.name}" for hook in hooks if hook.hook_type == "on_load"]
         with open(load_tag_file, 'w') as f:
             json.dump({"values": values}, f, indent=2)
         

minecraft_datapack_language/python_api.py

@@ -129,33 +129,108 @@ class Namespace:
         self._functions: List[FunctionDeclaration] = []
         self._hooks: List = []
 
-    def function(self, name: str, *commands_or_builder: Union[str, Callable[["FunctionBuilder"], None]]):
-        builder = FunctionBuilder(self._pack, self, name)
-
-        # If a single callable is given, treat it as a builder lambda
+    def function(self, name: str, *commands_or_builder: Union[str, Callable["FunctionBuilder"], None]):
+        # Case 1: builder callable - use FunctionBuilder API directly
         if len(commands_or_builder) == 1 and callable(commands_or_builder[0]):
+            builder = FunctionBuilder(self._pack, self, name)
             commands_or_builder[0](builder)
-        else:
-            # Interpret simple strings: say "..."; exec ns:name; raw lines fall back to RawBlock
-            for cmd in commands_or_builder:
-                if not isinstance(cmd, str):
-                    continue
-                stripped = cmd.strip().rstrip(";")
-                if stripped.startswith("say "):
-                    msg = stripped[len("say ") :].strip()
-                    if msg.startswith("\"") and msg.endswith("\""):
-                        msg = msg[1:-1]
-                    builder.say(msg)
-                elif stripped.startswith("exec "):
-                    target = stripped[len("exec ") :].strip()
-                    # Optional scope in angle brackets e.g., util:helper<@s>
-                    scope = None
-                    if "<" in target and target.endswith(">"):
-                        scope = target[target.index("<") :]
-                        target = target[: target.index("<")]
-                    builder.exec(target, scope)
-                else:
-                    builder.raw(cmd)
+            func_node = FunctionDeclaration(namespace=self.name, name=name, scope=None, body=builder._body)
+            self._functions.append(func_node)
+            return func_node
+
+        # Case 2: string-based function body - try parsing as MDL source to build real AST
+        body_lines: List[str] = []
+        for cmd in commands_or_builder:
+            if isinstance(cmd, str):
+                body_lines.append(cmd)
+
+        if body_lines:
+            try:
+                from .mdl_parser import MDLParser
+                pack_decl = self._pack._pack
+
+                # Heuristic: attempt MDL parse only if there are control structures or var declarations
+                looks_like_mdl = any(
+                    l.strip().startswith(("var ", "if ", "while ", "on_load", "on_tick")) or
+                    l.strip().endswith("{") or l.strip() == "}" or "$" in l
+                    for l in body_lines
+                )
+                if looks_like_mdl:
+                    normalized: List[str] = []
+                    for line in body_lines:
+                        s = line.strip()
+                        if not s:
+                            continue
+                        if s.startswith("say "):
+                            msg = s[len("say ") :].strip()
+                            if not (msg.startswith('"') and msg.endswith('"')):
+                                msg = f'"{msg}"'
+                            normalized.append(f"say {msg};")
+                        elif s.startswith("exec "):
+                            if not s.endswith(";"):
+                                s = s + ";"
+                            normalized.append(s)
+                        elif s.startswith("var "):
+                            if not s.endswith(";"):
+                                s = s + ";"
+                            normalized.append(s)
+                        elif s.endswith("{") or s == "}" or s.endswith("}"):
+                            normalized.append(s)
+                        else:
+                            # Heuristic: detect assignment like name<scope> = expr
+                            try:
+                                import re as _re
+                                if _re.match(r'^[A-Za-z_][A-Za-z0-9_]*(<[^>]+>)?\s*=\s*', s):
+                                    if not s.endswith(";"):
+                                        s = s + ";"
+                                    normalized.append(s)
+                                else:
+                                    # Unknown command; wrap as single-line raw so parser accepts it
+                                    normalized.append(f"$!raw {s} raw!$")
+                            except Exception:
+                                normalized.append(f"$!raw {s} raw!$")
+
+                    src_lines = [
+                        f'pack "{pack_decl.name}" "{pack_decl.description}" {pack_decl.pack_format};',
+                        f'namespace "{self.name}";',
+                        f'function {self.name}:{name} {{'
+                    ]
+                    src_lines.extend(normalized)
+                    src_lines.append('}')
+                    source = "\n".join(src_lines)
+                    parser = MDLParser("<python_api>")
+                    ast = parser.parse(source)
+                    if ast.variables:
+                        self._pack._variables.extend(ast.variables)
+                    if ast.tags:
+                        self._pack._tags.extend(ast.tags)
+                    if ast.hooks:
+                        self._pack._hooks.extend([(h.hook_type, f"{h.namespace}:{h.name}", h.scope) for h in ast.hooks])
+                    if ast.functions:
+                        fn = ast.functions[0]
+                        self._functions.append(fn)
+                        return fn
+            except Exception:
+                pass
+
+        # Fallback: interpret simple strings
+        builder = FunctionBuilder(self._pack, self, name)
+        for cmd in body_lines:
+            stripped = cmd.strip().rstrip(";")
+            if stripped.startswith("say "):
+                msg = stripped[len("say ") :].strip()
+                if msg.startswith('"') and msg.endswith('"'):
+                    msg = msg[1:-1]
+                builder.say(msg)
+            elif stripped.startswith("exec "):
+                target = stripped[len("exec ") :].strip()
+                scope = None
+                if "<" in target and target.endswith(">"):
+                    scope = target[target.index("<") :]
+                    target = target[: target.index("<")]
+                builder.exec(target, scope)
+            else:
+                builder.raw(cmd)
 
         func_node = FunctionDeclaration(namespace=self.name, name=name, scope=None, body=builder._body)
         self._functions.append(func_node)

{minecraft_datapack_language-15.4.39.dist-info → minecraft_datapack_language-15.4.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.39
+Version: 15.4.40
 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-15.4.39.dist-info → minecraft_datapack_language-15.4.40.dist-info}/RECORD

@@ -1,18 +1,18 @@
 minecraft_datapack_language/__init__.py,sha256=0KVXBE4ScRaRUrf83aA2tVB-y8A_jplyaxVvtHH6Uw0,1199
-minecraft_datapack_language/_version.py,sha256=9Ufx0gE3v3XMp3BFsd82w98Wj5WJy1_7_P36vYE2gnA,708
+minecraft_datapack_language/_version.py,sha256=P2VVYhMLipXcQKyw7Y1OEvR4mKshcYtZAmzVwV3FZfs,708
 minecraft_datapack_language/ast_nodes.py,sha256=nbWrRz137MGMRpmnq8QkXNzrtlaCgyPEknytbkrS_M8,3899
-minecraft_datapack_language/cli.py,sha256=Vk35mPYm8saMUbBNRDTeoqKiLq9_do_ZeRatFWN2EQs,9824
+minecraft_datapack_language/cli.py,sha256=R4QZYtox-Da9B8pr_kCg_9qc9aI-ORTah7kMkhsI5tw,10373
 minecraft_datapack_language/dir_map.py,sha256=HmxFkuvWGkzHF8o_GFb4BpuMCRc6QMw8UbmcAI8JVdY,1788
-minecraft_datapack_language/mdl_compiler.py,sha256=mV5qZzqriObutwsaLPmddRQdLIGJg4jiTNKg1A98Fyk,41055
+minecraft_datapack_language/mdl_compiler.py,sha256=CaIHmsv4cjZa70PpderdgPlH6yNaB86WQhGyIaB0040,41396
 minecraft_datapack_language/mdl_errors.py,sha256=r0Gu3KhoX1YLPAVW_iO7Q_fPgaf_Dv9tOGSOdKNSzmw,16114
 minecraft_datapack_language/mdl_lexer.py,sha256=CjbEUpuuF4eU_ucA_WIhw6wSMcHGk2BchtQ0bLAGvwg,22033
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
 minecraft_datapack_language/mdl_parser.py,sha256=aQPKcmATM9BOMzO7vCXmMdxU1qjOJNLCSAKJopu5h3g,23429
-minecraft_datapack_language/python_api.py,sha256=ImYULwBvJ0Qb0Tf6LFyXv-gTPGZ8njX7_La0HJKuk-o,8677
+minecraft_datapack_language/python_api.py,sha256=Iao1jbdeW6ekeA80BZG6gNqHVjxQJEheB3DbpVsuTZQ,12304
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.39.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.39.dist-info/METADATA,sha256=5eHZsdPGNCYfRdfWqW0Vy465ScEkfMpMfRhACQ7b-CI,8360
-minecraft_datapack_language-15.4.39.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.39.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.39.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.39.dist-info/RECORD,,
+minecraft_datapack_language-15.4.40.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.40.dist-info/METADATA,sha256=KIF4J5dORym2e-a7jCryY_SRCkqq5tyPxtCgC5vVFBA,8360
+minecraft_datapack_language-15.4.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.40.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.40.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.40.dist-info/RECORD,,