dfpyre 0.8.9__tar.gz → 0.8.10__tar.gz

{dfpyre-0.8.9 → dfpyre-0.8.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.8.9
+Version: 0.8.10
 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.9 → dfpyre-0.8.10}/dfpyre/items.py

@@ -444,18 +444,21 @@ class Parameter:
         return f'{self.__class__.__name__}({self.name}, type: {raw_type})'
 
 
-def item_from_dict(item_dict: dict) -> Any:
-    item_id = item_dict['id']
-    item_data = item_dict['data']
+def item_from_dict(item_dict: dict, preserve_item_slots: bool) -> Any:
+    item_id = item_dict['item']['id']
+    item_data = item_dict['item']['data']
+    item_slot = item_dict['slot'] if preserve_item_slots else None
 
     if item_id == 'item':
-        return Item.from_snbt(item_data['item'])
+        item = Item.from_snbt(item_data['item'])
+        item.slot = item_slot
+        return item
     
     elif item_id == 'txt':
-        return String(item_data['name'])
+        return String(item_data['name'], item_slot)
     
     elif item_id == 'comp':
-        return Text(item_data['name'])
+        return Text(item_data['name'], item_slot)
     
     elif item_id == 'num':
         num_value = item_data['name']
@@ -463,30 +466,30 @@ def item_from_dict(item_dict: dict) -> Any:
             num_value = float(item_data['name'])
             if num_value % 1 == 0:
                 num_value = int(num_value)
-            return Number(num_value)
-        return Number(num_value)
+            return Number(num_value, item_slot)
+        return Number(num_value, item_slot)
     
     elif item_id == 'loc':
         item_loc = item_data['loc']
-        return Location(item_loc['x'], item_loc['y'], item_loc['z'], item_loc['pitch'], item_loc['yaw'])
+        return Location(item_loc['x'], item_loc['y'], item_loc['z'], item_loc['pitch'], item_loc['yaw'], item_slot)
     
     elif item_id == 'var':
-        return Variable(item_data['name'], item_data['scope'])
+        return Variable(item_data['name'], item_data['scope'], item_slot)
     
     elif item_id == 'snd':
-        return Sound(item_data['sound'], item_data['pitch'], item_data['vol'])
+        return Sound(item_data['sound'], item_data['pitch'], item_data['vol'], item_slot)
     
     elif item_id == 'part':
-        return Particle(item_data)
+        return Particle(item_data, item_slot)
     
     elif item_id == 'pot':
-        return Potion(item_data['pot'], item_data['dur'], item_data['amp'])
+        return Potion(item_data['pot'], item_data['dur'], item_data['amp'], item_slot)
     
     elif item_id == 'g_val':
-        return GameValue(item_data['type'], item_data['target'])
+        return GameValue(item_data['type'], item_data['target'], item_slot)
     
     elif item_id == 'vec':
-        return Vector(item_data['x'], item_data['y'], item_data['z'])
+        return Vector(item_data['x'], item_data['y'], item_data['z'], item_slot)
     
     elif item_id == 'pn_el':
         description = item_data.get('description') or ''
@@ -494,9 +497,10 @@ def item_from_dict(item_dict: dict) -> Any:
         param_type = ParameterType(PARAMETER_TYPE_LOOKUP.index(item_data['type']))
         if item_data['optional']:
             if 'default_value' in item_data:
-                return Parameter(item_data['name'], param_type, item_data['plural'], True, description, note, item_from_dict(item_data['default_value']))
-            return Parameter(item_data['name'], param_type, item_data['plural'], True, description, note)
-        return Parameter(item_data['name'], param_type, item_data['plural'], False, description, note)
+                default_value_item = item_from_dict(item_data['default_value'], preserve_item_slots)
+                return Parameter(item_data['name'], param_type, item_data['plural'], True, description, note, default_value_item, item_slot)
+            return Parameter(item_data['name'], param_type, item_data['plural'], True, description, note, slot=item_slot)
+        return Parameter(item_data['name'], param_type, item_data['plural'], False, description, note, slot=item_slot)
     
     elif item_id in {'bl_tag', 'hint'}:  # Ignore tags and hints
         return

{dfpyre-0.8.9 → dfpyre-0.8.10}/dfpyre/pyre.py

@@ -244,9 +244,12 @@ class DFTemplate:
 
 
     @staticmethod
-    def from_code(template_code: str):
+    def from_code(template_code: str, preserve_item_slots: bool=False):
         """
         Create a template object from an existing template code.
+
+        :param str template_code: The base64 string to create a template from.
+        :param bool preserve_item_slots: If True, the positions of items within chests will be saved.
         """
         template_dict = json.loads(df_decode(template_code))
         codeblocks: list[CodeBlock] = []
@@ -258,7 +261,7 @@ class DFTemplate:
                     if item_dict['item'].get('id') == 'bl_tag':
                         tag_data = item_dict['item']['data']
                         block_tags[tag_data['tag']] = tag_data['option']
-                    parsed_item = item_from_dict(item_dict['item'])
+                    parsed_item = item_from_dict(item_dict, preserve_item_slots)
                     if parsed_item is not None:
                         block_args.append(parsed_item)
             block_target = Target(TARGETS.index(block_dict['target'])) if 'target' in block_dict else DEFAULT_TARGET
@@ -329,7 +332,7 @@ class DFTemplate:
         return template_item.send_to_minecraft()
     
     
-    def generate_script(self, output_path: str, indent_size: int=4, literal_shorthand: bool=True, var_shorthand: bool=False):
+    def generate_script(self, output_path: str, indent_size: int=4, literal_shorthand: bool=True, var_shorthand: bool=False, preserve_slots: bool=False):
         """
         Generate an equivalent python script for this template.
 
@@ -337,8 +340,9 @@ class DFTemplate:
         :param int indent_size: The multiple of spaces to add when indenting lines.
         :param bool literal_shorthand: If True, `text` and `num` items will be written as strings and ints respectively.
         :param bool var_shorthand: If True, all variables will be written using variable shorthand.
+        :param bool preserve_slots: If True, the positions of items within chests will be saved.
         """
-        flags = GeneratorFlags(indent_size, literal_shorthand, var_shorthand)
+        flags = GeneratorFlags(indent_size, literal_shorthand, var_shorthand, preserve_slots)
         with open(output_path, 'w', encoding='utf-8') as f:
             f.write(generate_script(self, flags))
 

{dfpyre-0.8.9 → dfpyre-0.8.10}/dfpyre/scriptgen.py

@@ -37,39 +37,43 @@ class GeneratorFlags:
     indent_size: int
     literal_shorthand: bool
     var_shorthand: bool
+    preserve_slots: bool
 
 
-def item_to_string(class_name: str, i: Item):
+def item_to_string(class_name: str, i: Item, slot_argument: str):
     i.nbt.pop('DF_NBT', None)
     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}")'
-        return f'{class_name}("{stripped_id}", {i.get_count()})'
+            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()}""")'
 
 
 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 ''
+
     if isinstance(arg_item, Item):
-        return item_to_string(class_name, arg_item)
+        return item_to_string(class_name, arg_item, slot_argument)
     
     if isinstance(arg_item, String):
         value = arg_item.value.replace('\n', '\\n')
-        if flags.literal_shorthand:
+        if not has_slot and flags.literal_shorthand:
             return f'"{value}"'
-        return f'{class_name}("{value}")'
+        return f'{class_name}("{value}"{slot_argument})'
     
     if isinstance(arg_item, Text):
         value = arg_item.value.replace('\n', '\\n')
-        return f'{class_name}("{value}")'
+        return f'{class_name}("{value}"{slot_argument})'
     
     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 f'{class_name}("{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})'
+        return f'{class_name}({arg_item.value}{slot_argument})'
     
     if isinstance(arg_item, Location):
         loc_components = [arg_item.x, arg_item.y, arg_item.z]
@@ -77,28 +81,28 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             loc_components.append(arg_item.pitch)
         if arg_item.yaw != 0:
             loc_components.append(arg_item.yaw)
-        return f'{class_name}({", ".join(str(c) for c in loc_components)})'
+        return f'{class_name}({", ".join(str(c) for c in loc_components)}{slot_argument})'
     
     if isinstance(arg_item, Variable):
-        if flags.var_shorthand:
+        if not has_slot and flags.var_shorthand:
             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}")'
+            return f'{class_name}("{arg_item.name}"{slot_argument})'
+        return f'{class_name}("{arg_item.name}", "{arg_item.scope}"{slot_argument})'
     
     if isinstance(arg_item, Sound):
-        return f'{class_name}("{arg_item.name}", {arg_item.pitch}, {arg_item.vol})'
+        return f'{class_name}("{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})'
+        return f'{class_name}("{arg_item.name}", {arg_item.dur}, {arg_item.amp}{slot_argument})'
     
     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}")'
+            return f'{class_name}("{arg_item.name}"{slot_argument})'
+        return f'{class_name}("{arg_item.name}", "{arg_item.target}"{slot_argument})'
     
     if isinstance(arg_item, Parameter):
         param_type_class_name = arg_item.param_type.__class__.__name__
@@ -113,10 +117,10 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             param_args.append(f'description="{arg_item.description}"')
         if arg_item.note:
             param_args.append(f'note="{arg_item.note}"')
-        return f'{class_name}({", ".join(param_args)})'
+        return f'{class_name}({", ".join(param_args)}{slot_argument})'
     
     if isinstance(arg_item, Vector):
-        return f'{class_name}({arg_item.x}, {arg_item.y}, {arg_item.z})'
+        return f'{class_name}({arg_item.x}, {arg_item.y}, {arg_item.z}{slot_argument})'
 
 
 def add_script_line(flags: GeneratorFlags, script_lines: list[str], indent_level: int, line: str, add_comma: bool=True):

{dfpyre-0.8.9 → dfpyre-0.8.10}/pyproject.toml

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