dfpyre 0.8.17__tar.gz → 0.8.19__tar.gz

{dfpyre-0.8.17 → dfpyre-0.8.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.8.17
+Version: 0.8.19
 Summary: A package for creating and modifying code templates for the DiamondFire Minecraft server.
 Home-page: https://github.com/Amp63/pyre
 License: MIT

{dfpyre-0.8.17 → dfpyre-0.8.19}/dfpyre/actiondump.py

@@ -97,7 +97,7 @@ def parse_actiondump() -> ActiondumpResult:
 
 
 def get_default_tags(codeblock_type: str|None, codeblock_action: str|None) -> dict[str, str]:
-    if codeblock_type is None or codeblock_action is None:
+    if not codeblock_type or not codeblock_action:
         return {}
     return {t['name']: t['default'] for t in CODEBLOCK_DATA[codeblock_type][codeblock_action]['tags']}
 

{dfpyre-0.8.17 → dfpyre-0.8.19}/dfpyre/scriptgen.py

@@ -49,12 +49,22 @@ def item_to_string(class_name: str, i: Item, slot_argument: str):
     stripped_id = i.get_id().replace('minecraft:', '')
     if set(i.nbt.keys()) == {'id', 'count'}:
         if i.get_count() == 1:
-            return f'{class_name}("{stripped_id}"{slot_argument})'
-        return f'{class_name}("{stripped_id}", {i.get_count()}{slot_argument})'
-    return f'{class_name}.from_snbt("""{i.get_snbt()}""")'
+            return f"{class_name}('{stripped_id}'{slot_argument})"
+        return f"{class_name}('{stripped_id}', {i.get_count()}{slot_argument})"
+    
+    snbt_string = i.get_snbt().replace('\\"', '\\\\"')
+    return f'{class_name}.from_snbt("""{snbt_string}""")'
+
+
+def escape(s: str) -> str:
+    return s.replace('\n', '\\n').replace("\'", "\\'")
+
+
+def str_literal(s: str) -> str:
+    return "'" + escape(s) + "'"
 
 
-def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
+def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str: 
     class_name = arg_item.__class__.__name__
     has_slot = arg_item.slot is not None and flags.preserve_slots
     slot_argument = f', slot={arg_item.slot}' if has_slot else ''
@@ -63,18 +73,18 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
         return item_to_string(class_name, arg_item, slot_argument)
     
     if isinstance(arg_item, String):
-        value = arg_item.value.replace('\n', '\\n')
+        literal = str_literal(arg_item.value)
         if not has_slot and flags.literal_shorthand:
-            return f'"{value}"'
-        return f'{class_name}("{value}"{slot_argument})'
+            return literal
+        return f"{class_name}({literal}{slot_argument})"
     
     if isinstance(arg_item, Text):
-        value = arg_item.value.replace('\n', '\\n')
-        return f'{class_name}("{value}"{slot_argument})'
+        literal = str_literal(arg_item.value)
+        return f"{class_name}('{literal}'{slot_argument})"
     
     if isinstance(arg_item, Number):
         if not is_number(str(arg_item.value)):  # Probably a math expression
-            return f'{class_name}("{arg_item.value}"{slot_argument})' 
+            return f"{class_name}({str_literal(arg_item.value)}{slot_argument})"
         if not has_slot and flags.literal_shorthand:
             return str(arg_item.value)
         return f'{class_name}({arg_item.value}{slot_argument})'
@@ -88,29 +98,31 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
         return f'{class_name}({", ".join(str(c) for c in loc_components)}{slot_argument})'
     
     if isinstance(arg_item, Variable):
+        name = escape(arg_item.name)
         if not has_slot and flags.var_shorthand:
-            return f'"${VAR_SCOPES[arg_item.scope]} {arg_item.name}"'
+            return f"'${VAR_SCOPES[arg_item.scope]} {name}'"
         if arg_item.scope == 'unsaved':
-            return f'{class_name}("{arg_item.name}"{slot_argument})'
-        return f'{class_name}("{arg_item.name}", "{arg_item.scope}"{slot_argument})'
+            return f"{class_name}('{name}'{slot_argument})"
+        return f"{class_name}('{name}', '{arg_item.scope}'{slot_argument})"
     
     if isinstance(arg_item, Sound):
-        return f'{class_name}("{arg_item.name}", {arg_item.pitch}, {arg_item.vol}{slot_argument})'
+        return f"{class_name}({str_literal(arg_item.name)}, {arg_item.pitch}, {arg_item.vol}{slot_argument})"
     
     if isinstance(arg_item, Particle):
         return f'{class_name}({arg_item.particle_data})'
     
     if isinstance(arg_item, Potion):
-        return f'{class_name}("{arg_item.name}", {arg_item.dur}, {arg_item.amp}{slot_argument})'
+        return f"{class_name}({str_literal(arg_item.name)}, {arg_item.dur}, {arg_item.amp}{slot_argument})"
     
     if isinstance(arg_item, GameValue):
+        name = str_literal(arg_item.name)
         if arg_item.target == 'Default':
-            return f'{class_name}("{arg_item.name}"{slot_argument})'
-        return f'{class_name}("{arg_item.name}", "{arg_item.target}"{slot_argument})'
+            return f"{class_name}({name}{slot_argument})"
+        return f"{class_name}({name}, '{arg_item.target}'{slot_argument})"
     
     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}']
+        param_args = [str_literal(arg_item.name), f'{param_type_class_name}.{arg_item.param_type.name}']
         if arg_item.plural:
             param_args.append('plural=True')
         if arg_item.optional:
@@ -118,9 +130,9 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             if arg_item.default_value is not None:
                 param_args.append(f'default_value={argument_item_to_string(flags, arg_item.default_value)}')
         if arg_item.description:
-            param_args.append(f'description="{arg_item.description}"')
+            param_args.append(f"description={str_literal(arg_item.description)}")
         if arg_item.note:
-            param_args.append(f'note="{arg_item.note}"')
+            param_args.append(f"note={str_literal(arg_item.note)}")
         return f'{class_name}({", ".join(param_args)}{slot_argument})'
     
     if isinstance(arg_item, Vector):
@@ -151,7 +163,8 @@ def generate_script(template, flags: GeneratorFlags) -> str:
         script_lines.append(IMPORT_STATEMENT + '\n')
         
     def remove_comma_from_last_line():
-        script_lines[-1] = script_lines[-1][:-1]
+        if script_lines[-1].endswith(','):
+            script_lines[-1] = script_lines[-1][:-1]
     
     def get_var_assignment_snippet() -> str:
         first_block_data = template.codeblocks[0].data
@@ -174,7 +187,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
 
         # Get codeblock function and start its arguments with the action
         function_name = TEMPLATE_FUNCTION_LOOKUP[codeblock.type]
-        function_args = [f'"{codeblock.action_name}"']
+        function_args = [f"'{codeblock.action_name}'"]
 
         # Add variable assignment if necessary
         var_assignment_snippet = ''
@@ -184,7 +197,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
 
         # Set function or process name if necessary
         if codeblock.action_name == 'dynamic':
-            function_args[0] = f'"{codeblock.data["data"]}"'
+            function_args[0] = str_literal(codeblock.data["data"])
         
         # Convert argument objects to valid Python strings
         codeblock_args = [argument_item_to_string(flags, i) for i in codeblock.args]
@@ -204,18 +217,18 @@ def generate_script(template, flags: GeneratorFlags) -> str:
         
         # Add sub-action for repeat
         if codeblock.data.get('subAction'):
-            function_args.append(f'sub_action="{codeblock.data["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')
 
-        # Create and add the final line
+        # Create and add the line
         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
+                line = f'{var_assignment_snippet}{function_name}({", ".join(function_args)}, ['  # omit `codeblocks=` when we don't need it
             else:
                 line = f'{var_assignment_snippet}{function_name}({", ".join(function_args)}, codeblocks=['
             add_script_line(flags, script_lines, indent_level, line, False)

{dfpyre-0.8.17 → dfpyre-0.8.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfpyre"
-version = "0.8.17"
+version = "0.8.19"
 description = "A package for creating and modifying code templates for the DiamondFire Minecraft server."
 authors = ["Amp"]
 readme = "README.md"