dfpyre 0.7.11__py3-none-any.whl → 0.8.0__py3-none-any.whl

dfpyre/scriptgen.py

@@ -3,12 +3,10 @@ import re
 from dfpyre.items import *
 from dfpyre.actiondump import get_default_tags
 
-SCRIPT_START = '''from dfpyre import *
 
-t = DFTemplate()
-'''
+SCRIPT_START = '''from dfpyre import *\n\n'''
 
-TEMPLATE_METHOD_LOOKUP = {
+TEMPLATE_FUNCTION_LOOKUP = {
     'event': 'player_event',
     'entity_event': 'entity_event',
     'func': 'function',
@@ -30,6 +28,7 @@ TEMPLATE_METHOD_LOOKUP = {
 }
 
 TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
+CONTAINER_CODEBLOCKS = {'event', 'entity_event', 'func', 'process', 'if_player', 'if_entity', 'if_game', 'if_variable', 'else', 'repeat'}
 VAR_SCOPES = {'unsaved': 'g', 'saved': 's', 'local': 'l', 'line': 'i'}
 
 
@@ -40,7 +39,7 @@ class GeneratorFlags:
     var_shorthand: bool
 
 
-def item_to_string(class_name: str, i: item):
+def item_to_string(class_name: str, i: Item):
     i.nbt.data.pop('~DF_NBT', None)
     stripped_id = i.get_id().replace('minecraft:', '')
     if i.nbt.key_set() == {'~id', '~count'}:
@@ -52,27 +51,27 @@ def item_to_string(class_name: str, i: item):
 
 def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
     class_name = arg_item.__class__.__name__
-    if isinstance(arg_item, item):
+    if isinstance(arg_item, Item):
         return item_to_string(class_name, arg_item)
     
-    if isinstance(arg_item, string):
+    if isinstance(arg_item, String):
         value = arg_item.value.replace('\n', '\\n')
         return f'{class_name}("{value}")'
     
-    if isinstance(arg_item, text):
+    if isinstance(arg_item, Text):
         value = arg_item.value.replace('\n', '\\n')
         if flags.literal_shorthand:
             return f'"{value}"'
         return f'{class_name}("{value}")'
     
-    if isinstance(arg_item, num):
+    if isinstance(arg_item, Number):
         if not re.match(NUMBER_REGEX, str(arg_item.value)):
             return f'{class_name}("{arg_item.value}")' 
         if flags.literal_shorthand:
             return str(arg_item.value)
         return f'{class_name}({arg_item.value})'
     
-    if isinstance(arg_item, loc):
+    if isinstance(arg_item, Location):
         loc_components = [arg_item.x, arg_item.y, arg_item.z]
         if arg_item.pitch != 0:
             loc_components.append(arg_item.pitch)
@@ -80,28 +79,28 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             loc_components.append(arg_item.yaw)
         return f'{class_name}({", ".join(str(c) for c in loc_components)})'
     
-    if isinstance(arg_item, var):
+    if isinstance(arg_item, Variable):
         if flags.var_shorthand:
-            return f'"${VAR_SCOPES[arg_item.scope]}{arg_item.name}"'
+            return f'"${VAR_SCOPES[arg_item.scope]} {arg_item.name}"'
         if arg_item.scope == 'unsaved':
             return f'{class_name}("{arg_item.name}")'
         return f'{class_name}("{arg_item.name}", "{arg_item.scope}")'
     
-    if isinstance(arg_item, sound):
+    if isinstance(arg_item, Sound):
         return f'{class_name}("{arg_item.name}", {arg_item.pitch}, {arg_item.vol})'
     
-    if isinstance(arg_item, particle):
+    if isinstance(arg_item, Particle):
         return f'{class_name}({arg_item.particle_data})'
     
-    if isinstance(arg_item, potion):
+    if isinstance(arg_item, Potion):
         return f'{class_name}("{arg_item.name}", {arg_item.dur}, {arg_item.amp})'
     
-    if isinstance(arg_item, gamevalue):
+    if isinstance(arg_item, GameValue):
         if arg_item.target == 'Default':
             return f'{class_name}("{arg_item.name}")'
         return f'{class_name}("{arg_item.name}", "{arg_item.target}")'
     
-    if isinstance(arg_item, parameter):
+    if isinstance(arg_item, Parameter):
         param_type_class_name = arg_item.param_type.__class__.__name__
         param_args = [f'"{arg_item.name}"', f'{param_type_class_name}.{arg_item.param_type.name}']
         if arg_item.plural:
@@ -116,7 +115,7 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             param_args.append(f'note="{arg_item.note}"')
         return f'{class_name}({", ".join(param_args)})'
     
-    if isinstance(arg_item, vector):
+    if isinstance(arg_item, Vector):
         return f'{class_name}({arg_item.x}, {arg_item.y}, {arg_item.z})'
 
 
@@ -127,39 +126,62 @@ def add_script_line(flags: GeneratorFlags, script_lines: list[str], indent_level
     script_lines.append(added_line)
 
 
-# TODO: add tag values if not default
 def generate_script(template, flags: GeneratorFlags) -> str:
     indent_level = 0
     script_lines = []
     for codeblock in template.codeblocks:
-        if codeblock.name == 'bracket':
-            if codeblock.data['direct'] == 'open':
-                add_script_line(flags, script_lines, indent_level, 't.bracket(', False)
-                indent_level += 1
-            elif codeblock.data['direct'] == 'close':
+        # Handle closing brackets
+        if codeblock.type == 'bracket':
+            if codeblock.data['direct'] == 'close':
                 indent_level -= 1
-                add_script_line(flags, script_lines, indent_level, ')')
-            continue
-        if codeblock.name == 'else':
-            add_script_line(flags, script_lines, indent_level, 't.else_()')
+                add_script_line(flags, script_lines, indent_level, '])')
             continue
 
-        method_name = TEMPLATE_METHOD_LOOKUP[codeblock.data['block']]
-        method_args = [f'"{codeblock.name}"']
-        if codeblock.name == 'dynamic':
-            method_args[0] = f'"{codeblock.data["data"]}"'
+        # Get codeblock function and start its arguments with the action
+        function_name = TEMPLATE_FUNCTION_LOOKUP[codeblock.type]
+        function_args = [f'"{codeblock.action_name}"']
+
+        # Set function or process name if necessary
+        if codeblock.action_name == 'dynamic':
+            function_args[0] = f'"{codeblock.data["data"]}"'
         
+        # Convert argument objects to valid Python strings
         codeblock_args = [argument_item_to_string(flags, i) for i in codeblock.args]
         if codeblock_args:
-            method_args.extend(codeblock_args)
-        if method_name in TARGET_CODEBLOCKS and codeblock.target.name != 'SELECTION':
-            method_args.append(f'target=Target.{codeblock.target.name}')
+            function_args.extend(codeblock_args)
+        
+        # Add target if necessary
+        if function_name in TARGET_CODEBLOCKS and codeblock.target.name != 'SELECTION':
+            function_args.append(f'target=Target.{codeblock.target.name}')
+        
+        # Add tags
         if codeblock.tags:
-            default_tags = get_default_tags(codeblock.data.get('block'), codeblock.name)
+            default_tags = get_default_tags(codeblock.data.get('block'), codeblock.action_name)
             written_tags = {t: o for t, o in codeblock.tags.items() if default_tags[t] != o}
             if written_tags:
-                method_args.append(f'tags={str(written_tags)}')
+                function_args.append(f'tags={str(written_tags)}')
         
-        line = f't.{method_name}({", ".join(method_args)})'
-        add_script_line(flags, script_lines, indent_level, line)
+        # Add sub-action for repeat
+        if codeblock.data.get('subAction'):
+            function_args.append(f'sub_action="{codeblock.data["subAction"]}"')
+        
+        # Add inversion for NOT
+        if codeblock.data.get('attribute') == 'NOT':
+            function_args.append('inverted=True')
+
+        if codeblock.type in CONTAINER_CODEBLOCKS:
+            if codeblock.type == 'else':
+                line = f'{function_name}(['
+            elif codeblock.type in {'event', 'entity_event'}:
+                line = f'{function_name}({", ".join(function_args)}, ['  # omit `codeblocks=` when we don't need it
+            else:
+                line = f'{function_name}({", ".join(function_args)}, codeblocks=['
+            add_script_line(flags, script_lines, indent_level, line, False)
+            indent_level += 1
+        else:
+            line = f'{function_name}({", ".join(function_args)})'
+            add_script_line(flags, script_lines, indent_level, line)
+    
+    indent_level -= 1
+    add_script_line(flags, script_lines, indent_level, '])')  # add final closing brackets
     return SCRIPT_START + '\n'.join(script_lines)

dfpyre/util.py

@@ -26,3 +26,14 @@ def df_encode(json_string: str) -> str:
 
 def df_decode(encoded_string: str) -> str:
     return gzip.decompress(base64.b64decode(encoded_string)).decode('utf-8')
+
+
+def flatten(nested_list: list):
+    """
+    Flattens a list.
+    """
+    for item in nested_list:
+        if isinstance(item, list):
+            yield from flatten(item)
+        else:
+            yield item