dfpyre 0.5.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

dfpyre/items.py

@@ -3,15 +3,24 @@ Contains class definitions for code items.
 """
 
 from enum import Enum
-from typing import Literal, Dict
+import re
+from typing import Literal, Dict, Any
 from dfpyre.style import is_ampersand_coded, ampersand_to_minimessage
 from mcitemlib.itemlib import Item as NbtItem
 
 
+NUMBER_REGEX = r'-?\d*\.?\d+'
+
+
+class PyreException(Exception):
+    pass
+
+
 def _add_slot(d: Dict, slot: int|None):
     if slot is not None:
         d['slot'] = slot
 
+
 class item(NbtItem):
     """
     Represents a Minecraft item.
@@ -62,7 +71,7 @@ class num:
     """
     type = 'num'
 
-    def __init__(self, num: int|float):
+    def __init__(self, num: int|float|str):
         self.value = num
     
     def format(self, slot: int|None):
@@ -140,34 +149,11 @@ class particle:
     Represents a DiamondFire particle object.
     """
     type = 'part'
-    def __init__(self, name: str='Cloud', amount: int=1, horizontal: float=0.0, vertical: float=0.0, 
-                 x: float=1.0, y: float=0.0, z: float=0.0, motionVariation: float=100):
-        self.name = name
-        self.amount = amount
-        self.horizontal = horizontal
-        self.vertical = vertical
-        self.x = x
-        self.y = y
-        self.z = z
-        self.motionVariation = motionVariation
+    def __init__(self, particle_data: dict):
+        self.particle_data = particle_data
     
     def format(self, slot: int|None):
-        formatted_dict = {"item": {"id": self.type,
-            "data": {
-                "particle": self.name,
-                "cluster": {
-                    "amount": self.amount,
-                    "horizontal": self.horizontal,
-                    "vertical": self.vertical
-                },
-                "data": {
-                    "x": self.x,
-                    "y": self.y,
-                    "z": self.z,
-                    "motionVariation": self.motionVariation
-                }
-            }
-        }}
+        formatted_dict = {"item": {"id": self.type, "data": self.particle_data}}
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
@@ -276,4 +262,61 @@ class parameter:
         if self.default_value is not None and not self.plural and self.optional:
             formatted_dict['item']['data']['default_value'] = self.default_value.format(None)['item']
         
-        return formatted_dict
+        return formatted_dict
+
+
+def _some_or(value: Any, none_value: Any):
+    """
+    Returns `none_value` if `value` is None, otherwise returns `value`.
+    """
+    if value is None:
+        return none_value
+    return value
+
+
+def item_from_dict(item_dict: Dict) -> object:
+    item_id = item_dict['id']
+    item_data = item_dict['data']
+
+    if item_id == 'item':
+        return item.from_nbt(item_data['item'])
+    elif item_id == 'txt':
+        return string(item_data['name'])
+    elif item_id == 'comp':
+        return text(item_data['name'])
+    elif item_id == 'num':
+        num_value = item_data['name']
+        if re.match(NUMBER_REGEX, num_value):
+            num_value = float(item_data['name'])
+            if num_value % 1 == 0:
+                num_value = int(num_value)
+            return num(num_value)
+        return num(num_value)
+    elif item_id == 'loc':
+        item_loc = item_data['loc']
+        return loc(item_loc['x'], item_loc['y'], item_loc['z'], item_loc['pitch'], item_loc['yaw'])
+    elif item_id == 'var':
+        return var(item_data['name'], item_data['scope'])
+    elif item_id == 'snd':
+        return sound(item_data['sound'], item_data['pitch'], item_data['vol'])
+    elif item_id == 'part':
+        return particle(item_data)
+    elif item_id == 'pot':
+        return potion(item_data['pot'], item_data['dur'], item_data['amp'])
+    elif item_id == 'g_val':
+        return gamevalue(item_data['type'], item_data['target'])
+    elif item_id == 'vec':
+        return vector(item_data['x'], item_data['y'], item_data['z'])
+    elif item_id == 'pn_el':
+        description = _some_or(item_data.get('description'), '')
+        note = _some_or(item_data.get('note'), '')
+        param_type = ParameterType(PARAMETER_TYPE_LOOKUP.index(item_data['type']))
+        if item_data['optional']:
+            param = parameter(item_data['name'], param_type, item_data['plural'], True, description, note, item_from_dict(item_data['default_value']))
+        else:
+            param = parameter(item_data['name'], param_type, item_data['plural'], False, description, note)
+        return param
+    elif item_id == 'bl_tag':
+        return
+    else:
+        raise PyreException(f'Unrecognized item id `{item_id}`')

dfpyre/pyre.py

@@ -2,7 +2,6 @@
 A package for externally creating code templates for the DiamondFire Minecraft server.
 
 By Amp
-2/24/2024
 """
 
 import base64
@@ -13,8 +12,10 @@ from difflib import get_close_matches
 import datetime
 from typing import Tuple, List, Dict
 from enum import Enum
+import socket
 from mcitemlib.itemlib import Item as NbtItem
 from dfpyre.items import *
+from dfpyre.scriptgen import generate_script, GeneratorFlags
 
 COL_WARN = '\x1b[33m'
 COL_RESET = '\x1b[0m'
@@ -25,6 +26,7 @@ CODEBLOCK_DATA_PATH = os.path.join(os.path.dirname(__file__), 'data/data.json')
 
 VARIABLE_TYPES = {'txt', 'comp', 'num', 'item', 'loc', 'var', 'snd', 'part', 'pot', 'g_val', 'vec', 'pn_el'}
 TEMPLATE_STARTERS = {'event', 'entity_event', 'func', 'process'}
+SINGLE_NAME_CODEBLOCKS = {'func', 'process', 'call_func', 'start_process', 'else'}
 
 TARGETS = ['Selection', 'Default', 'Killer', 'Damager', 'Shooter', 'Victim', 'AllPlayers', 'Projectile', 'AllEntities', 'AllMobs', 'LastEntity']
 TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
@@ -60,6 +62,15 @@ class CodeBlock:
         self.args = args
         self.target = target
         self.data = data
+    
+    def __repr__(self) -> str:
+        if self.name in SINGLE_NAME_CODEBLOCKS:
+            if self.name == 'else':
+                return 'CodeBlock(else)'
+            return f'CodeBlock({self.name}, {self.data["data"]})'
+        elif 'block' in self.data:
+            return f'CodeBlock({self.data["block"]}, {self.name})'
+        return f'CodeBlock(bracket, {self.data["type"]}, {self.data["direct"]})'
 
 
 def _warn(message):
@@ -108,7 +119,7 @@ def _convert_data_types(args):
         if type(value) in {int, float}:
             converted_args.append(num(value))
         elif type(value) is str:
-            if value[0] == VAR_SHORTHAND_CHAR and value[1] in VAR_SCOPES:
+            if len(value) > 2 and value[0] == VAR_SHORTHAND_CHAR and value[1] in VAR_SCOPES:
                 var_object = var(value[2:], VAR_SCOPES[value[1]])
                 converted_args.append(var_object)
             else:
@@ -157,12 +168,12 @@ def _build_block(codeblock: CodeBlock, include_tags: bool):
     """
     Builds a properly formatted block from a CodeBlock object.
     """
-    final_block = codeblock.data.copy()
+    built_block = codeblock.data.copy()
     codeblock_type = codeblock.data.get('block')
     
     # add target if necessary ('Selection' is the default when 'target' is blank)
     if codeblock_type in TARGET_CODEBLOCKS and codeblock.target != DEFAULT_TARGET:
-        final_block['target'] = codeblock.target.get_string_value()
+        built_block['target'] = codeblock.target.get_string_value()
     
     # add items into args
     final_args = [arg.format(slot) for slot, arg in enumerate(codeblock.args) if arg.type in VARIABLE_TYPES]
@@ -177,16 +188,20 @@ def _build_block(codeblock: CodeBlock, include_tags: bool):
                 final_args = final_args[:(27-len(tags))]  # trim list if over 27 elements
             final_args.extend(tags)  # add tags to end
     
-    final_block['args'] = {'items': final_args}
-    return final_block
+    built_block['args'] = {'items': final_args}
+    return built_block
 
 
-def _df_encode(jsonString: str) -> str:
+def _df_encode(json_string: str) -> str:
     """
     Encodes a stringified json.
     """
-    encodedString = gzip.compress(jsonString.encode('utf-8'))
-    return base64.b64encode(encodedString).decode('utf-8')
+    encoded_string = gzip.compress(json_string.encode('utf-8'))
+    return base64.b64encode(encoded_string).decode('utf-8')
+
+
+def _df_decode(encoded_string: str) -> str:
+    return gzip.decompress(base64.b64decode(encoded_string)).decode('utf-8')
 
 
 def _get_template_item(template_code: str, name: str, author: str) -> NbtItem:
@@ -217,9 +232,50 @@ class DFTemplate:
     """
     def __init__(self, name: str=None, author: str='pyre'):
         self.codeblocks: List[CodeBlock] = []
-        self.closebracket = None
+        self.bracket_stack: list[str] = []
         self.name = name
         self.author = author
+    
+
+    def __repr__(self) -> str:
+        return f'DFTemplate(name: {self.name}, author: {self.author}, codeblocks: {len(self.codeblocks)})'
+
+
+    @staticmethod
+    def from_code(template_code: str):
+        """
+        Create a template object from an existing template code.
+        """
+        template_dict = json.loads(_df_decode(template_code))
+        template = DFTemplate()
+        for block_dict in template_dict['blocks']:
+            if 'args' in block_dict:
+                args = []
+                for item_dict in block_dict['args']['items']:
+                    parsed_item = item_from_dict(item_dict['item'])
+                    if parsed_item is not None:
+                        args.append(parsed_item)
+            target = Target(TARGETS.index(block_dict['target'])) if 'target' in block_dict else DEFAULT_TARGET
+
+            codeblock_name = 'bracket'
+            if 'block' in block_dict and block_dict['block'] in SINGLE_NAME_CODEBLOCKS:
+                codeblock_name = block_dict['block']
+            elif 'action' in block_dict:
+                codeblock_name = block_dict['action']
+            codeblock = CodeBlock(codeblock_name, args, target, block_dict)
+            template.codeblocks.append(codeblock)
+        
+        return template
+
+
+    @staticmethod
+    def receive_from_recode():
+        print('Waiting for item to be sent...')
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.connect(('localhost', 31372))
+        received = s.recv(8192)
+        print(received)
+        s.close()
 
 
     def _set_template_name(self, first_block):
@@ -237,7 +293,7 @@ class DFTemplate:
         """
         Build this template.
 
-        :param bool includeTags: If True, include item tags in code blocks. Otherwise omit them.
+        :param bool include_tags: If True, include item tags in code blocks. Otherwise omit them.
         :return: String containing encoded template data.
         """
         template_dict_blocks = [_build_block(codeblock, include_tags) for codeblock in self.codeblocks]
@@ -248,21 +304,19 @@ class DFTemplate:
 
         self._set_template_name(first_block)
 
-        print(f'{COL_SUCCESS}Template built successfully.{COL_RESET}')
-
         json_string = json.dumps(template_dict, separators=(',', ':'))
         return _df_encode(json_string)
     
 
-    def build_and_send(self, method: Literal['recode', 'codeclient'], includeTags: bool=True) -> int:
+    def build_and_send(self, method: Literal['recode', 'codeclient'], include_tags: bool=True) -> int:
         """
         Builds this template and sends it to DiamondFire automatically.
         
-        :param bool includeTags: If True, include item tags in code blocks. Otherwise omit them.
+        :param bool include_tags: If True, include item tags in code blocks. Otherwise omit them.
         """
-        templateCode = self.build(includeTags)
-        templateItem = _get_template_item(templateCode, self.name, self.author)
-        return templateItem.send_to_minecraft(method)
+        template_code = self.build(include_tags)
+        template_item = _get_template_item(template_code, self.name, self.author)
+        return template_item.send_to_minecraft(method, 'pyre')
     
 
     def clear(self):
@@ -272,134 +326,156 @@ class DFTemplate:
         self.__init__()
     
 
-    def _openbracket(self, btype: Literal['norm', 'repeat']='norm'):
-        bracket = CodeBlock('Bracket', data={'id': 'bracket', 'direct': 'open', 'type': btype})
-        self.codeblocks.append(bracket)
-        self.closebracket = btype
+    def _add_codeblock(self, codeblock: CodeBlock, index: int|None):
+        if index is None:
+            self.codeblocks.append(codeblock)
+        else:
+            self.codeblocks.insert(index, codeblock)
+    
+
+    def _openbracket(self, index: int|None, btype: Literal['norm', 'repeat']='norm'):
+        bracket = CodeBlock('bracket', data={'id': 'bracket', 'direct': 'open', 'type': btype})
+        self._add_codeblock(bracket, index+1)
+        self.bracket_stack.append(btype)
     
 
     # command methods
-    def player_event(self, name: str):
+    def player_event(self, name: str, index: int|None=None):
         cmd = CodeBlock(name, data={'id': 'block', 'block': 'event', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def entity_event(self, name: str):
+    def entity_event(self, name: str, index: int|None=None):
         cmd = CodeBlock(name, data={'id': 'block', 'block': 'entity_event', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def function(self, name: str, *args):
+    def function(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
-        cmd = CodeBlock('function', args, data={'id': 'block', 'block': 'func', 'data': name})
-        self.codeblocks.append(cmd)
+        cmd = CodeBlock('func', args, data={'id': 'block', 'block': 'func', 'data': name})
+        self._add_codeblock(cmd, index)
     
 
-    def process(self, name: str):
-        cmd = CodeBlock('process', data={'id': 'block', 'block': 'process', 'data': name})
-        self.codeblocks.append(cmd)
+    def process(self, name: str, *args, index: int|None=None):
+        args = _convert_data_types(args)
+        cmd = CodeBlock('process', args, data={'id': 'block', 'block': 'process', 'data': name})
+        self._add_codeblock(cmd, index)
     
 
-    def call_function(self, name: str, *args):
+    def call_function(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock('call_func', args, data={'id': 'block', 'block': 'call_func', 'data': name})
-        self.codeblocks.append(cmd)
-    
+        self._add_codeblock(cmd, index)    
 
-    def start_process(self, name: str):
+    def start_process(self, name: str, index: int|None=None):
         cmd = CodeBlock('start_process', data={'id': 'block', 'block': 'start_process', 'data': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
 
 
-    def player_action(self, name: str, *args, target: Target=DEFAULT_TARGET):
+    def player_action(self, name: str, *args, target: Target=DEFAULT_TARGET, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'player_action', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def game_action(self, name: str, *args):
+    def game_action(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'game_action', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def entity_action(self, name: str, *args, target: Target=DEFAULT_TARGET):
+    def entity_action(self, name: str, *args, target: Target=DEFAULT_TARGET, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'entity_action', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def if_player(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False):
+    def if_player(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False, index: int|None=None):
         args = _convert_data_types(args)
         data = {'id': 'block', 'block': 'if_player', 'action': name}
         _add_inverted(data, inverted)
         cmd = CodeBlock(name, args, target=target, data=data)
-        self.codeblocks.append(cmd)
-        self._openbracket()
+        self._add_codeblock(cmd, index)
+        self._openbracket(index)
     
 
-    def if_variable(self, name: str, *args, inverted: bool=False):
+    def if_variable(self, name: str, *args, inverted: bool=False, index: int|None=None):
         args = _convert_data_types(args)
         data = {'id': 'block', 'block': 'if_var', 'action': name}
         _add_inverted(data, inverted)
         cmd = CodeBlock(name, args, data=data)
-        self.codeblocks.append(cmd)
-        self._openbracket()
+        self._add_codeblock(cmd, index)
+        self._openbracket(index)
     
 
-    def if_game(self, name: str, *args, inverted: bool=False):
+    def if_game(self, name: str, *args, inverted: bool=False, index: int|None=None):
         args = _convert_data_types(args)
         data = {'id': 'block', 'block': 'if_game', 'action': name}
         _add_inverted(data, inverted)
         cmd = CodeBlock(name, args, data=data)
-        self.codeblocks.append(cmd)
-        self._openbracket()
+        self._add_codeblock(cmd, index)
+        self._openbracket(index)
     
 
-    def if_entity(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False):
+    def if_entity(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False, index: int|None=None):
         args = _convert_data_types(args)
         data = {'id': 'block', 'block': 'if_entity', 'action': name}
         _add_inverted(data, inverted)
         cmd = CodeBlock(name, args, target=target, data=data)
-        self.codeblocks.append(cmd)
-        self._openbracket()
+        self._add_codeblock(cmd, index)
+        self._openbracket(index)
 
 
-    def else_(self):
+    def else_(self, index: int|None=None):
         cmd = CodeBlock('else', data={'id': 'block', 'block': 'else'})
-        self.codeblocks.append(cmd)
-        self._openbracket()
+        self._add_codeblock(cmd, index)
+        self._openbracket(index)
     
 
-    def repeat(self, name: str, *args, sub_action: str=None):
+    def repeat(self, name: str, *args, sub_action: str=None, index: int|None=None):
         args = _convert_data_types(args)
         data = {'id': 'block', 'block': 'repeat', 'action': name}
         if sub_action is not None:
             data['subAction'] = sub_action
         cmd = CodeBlock(name, args, data=data)
-        self.codeblocks.append(cmd)
-        self._openbracket('repeat')
+        self._add_codeblock(cmd, index)
+        self._openbracket(index, 'repeat')
 
 
-    def bracket(self, *args):
+    def bracket(self, *args, index: int|None=None):
         args = _convert_data_types(args)
-        cmd = CodeBlock('Bracket', data={'id': 'bracket', 'direct': 'close', 'type': self.closebracket})
-        self.codeblocks.append(cmd)
+        cmd = CodeBlock('bracket', data={'id': 'bracket', 'direct': 'close', 'type': self.bracket_stack.pop()})
+        self._add_codeblock(cmd, index)
     
 
-    def control(self, name: str, *args):
+    def control(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'control', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def select_object(self, name: str, *args):
+    def select_object(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'select_obj', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
     
 
-    def set_variable(self, name: str, *args):
+    def set_variable(self, name: str, *args, index: int|None=None):
         args = _convert_data_types(args)
         cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'set_var', 'action': name})
-        self.codeblocks.append(cmd)
+        self._add_codeblock(cmd, index)
+    
+    
+    def generate_script(self, output_path: str, indent_size: int=4, literal_shorthand: bool=True, var_shorthand: bool=False):
+        """
+        Generate an equivalent python script for this template.
+
+        :param str output_path: The file path to write the script to.
+        :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.
+        """
+        flags = GeneratorFlags(indent_size, literal_shorthand, var_shorthand)
+        with open(output_path, 'w') as f:
+            f.write(generate_script(self, flags))
+        

dfpyre/scriptgen.py

@@ -0,0 +1,146 @@
+import dataclasses
+import re
+from dfpyre.items import *
+
+SCRIPT_START = '''from dfpyre import *
+t = DFTemplate()
+'''
+
+TEMPLATE_METHOD_LOOKUP = {
+    'event': 'player_event',
+    'entity_event': 'entity_event',
+    'func': 'function',
+    'process': 'process',
+    'call_func': 'call_function',
+    'start_process': 'start_process',
+    'player_action': 'player_action',
+    'game_action': 'game_action',
+    'entity_action': 'entity_action',
+    'if_player': 'if_player',
+    'if_var': 'if_variable',
+    'if_game': 'if_game',
+    'if_entity': 'if_entity',
+    'else': 'else_',
+    'repeat': 'repeat',
+    'control': 'control',
+    'select_obj': 'select_object',
+    'set_var': 'set_variable'
+}
+
+TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
+SINGLE_NAME_CODEBLOCKS = {'func', 'process', 'call_func', 'start_process'}
+VAR_SCOPES = {'unsaved': 'g', 'saved': 's', 'local': 'l', 'line': 'i'}
+
+
+@dataclasses.dataclass
+class GeneratorFlags:
+    indent_size: int
+    literal_shorthand: bool
+    var_shorthand: bool
+
+
+def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
+    class_name = arg_item.__class__.__name__
+    if isinstance(arg_item, item):
+        return f'{class_name}.from_nbt("""{arg_item.get_nbt()}""")'
+    
+    if isinstance(arg_item, string):
+        value = arg_item.value.replace('\n', '\\n')
+        return f'{class_name}("{value}")'
+    
+    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 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):
+        loc_components = [arg_item.x, arg_item.y, arg_item.z]
+        if arg_item.pitch != 0:
+            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)})'
+    
+    if isinstance(arg_item, var):
+        if 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}")'
+    
+    if isinstance(arg_item, sound):
+        return f'{class_name}("{arg_item.name}", {arg_item.pitch}, {arg_item.vol})'
+    
+    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})'
+    
+    if isinstance(arg_item, gamevalue):
+        return f'{class_name}("{arg_item.name}", "{arg_item.target}")'
+    
+    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:
+            param_args.append('plural=True')
+        if arg_item.optional:
+            param_args.append('optional=True')
+            if arg_item.default_value is not None:
+                param_args.append(f'default_value={argument_item_to_string(arg_item.default_value)}')
+        if arg_item.description:
+            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)})'
+    
+    if isinstance(arg_item, vector):
+        return f'{class_name}({arg_item.x}, {arg_item.y}, {arg_item.z})'
+
+
+def add_script_line(flags: GeneratorFlags, script_lines: list[str], indent_level: int, line: str, add_comma: bool=True):
+    added_line = ' '*flags.indent_size*indent_level + line
+    if add_comma and indent_level > 0:
+        added_line += ','
+    script_lines.append(added_line)
+
+
+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':
+                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_()')
+            continue
+
+        method_name = TEMPLATE_METHOD_LOOKUP[codeblock.data['block']]
+        method_args = [f'"{codeblock.name}"']
+        if codeblock.name in SINGLE_NAME_CODEBLOCKS:
+            method_args[0] = f'"{codeblock.data["data"]}"'
+        
+        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}')
+        
+        line = f't.{method_name}({", ".join(method_args)})'
+        add_script_line(flags, script_lines, indent_level, line)
+    return SCRIPT_START + '\n'.join(script_lines)

{dfpyre-0.5.0.dist-info → dfpyre-0.6.1.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Amp
+Copyright (c) 2024 Amp
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{dfpyre-0.5.0.dist-info → dfpyre-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.5.0
+Version: 0.6.1
 Summary: A package for external creation of code templates for the DiamondFire Minecraft server.
 Home-page: https://github.com/Amp63/pyre
 License: MIT
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: mcitemlib (>=0.1.2,<0.2.0)
+Requires-Dist: mcitemlib (>=0.2.4,<0.3.0)
 Project-URL: Repository, https://github.com/Amp63/pyre
 Description-Content-Type: text/markdown
 
@@ -70,6 +70,8 @@ pip install dfpyre
 
 ## Extras
 
+- [Importing from Code](#importing-from-code)
+- [Script Generation](#script-generation)
 - [Method List](#method-list)
 
 ___
@@ -279,7 +281,7 @@ t.player_action('PlaySound', sound('Grass Place'))
 Represents a diamondfire particle item:
 
 ```py
-particle(name='Cloud', amount=10, horizontal=1.0, vertical=0.5, x=1.0, y=0.0, z=0.0, motionVariation=100)
+particle({'particle':'Cloud','cluster':{'amount':1,'horizontal':0.0,'vertical':0.0},'data':{'x':1.0,'y':0.0,'z':0.0,'motionVariation':100}})
 ```
 
 Example:
@@ -289,7 +291,8 @@ Example:
 from dfpyre import *
 t = DFTemplate()
 t.player_event('Join')
-t.player_action('Particle', particle('Cloud'), loc(5, 50, 5))
+part = particle({'particle':'Cloud','cluster':{'amount':1,'horizontal':0.0,'vertical':0.0},'data':{'x':1.0,'y':0.0,'z':0.0,'motionVariation':100}})
+t.player_action('Particle', part, loc(5, 50, 5))
 ```
 
 Currently, the particle object does not support colors.
@@ -441,6 +444,31 @@ t = DFTemplate()
 t.player_event('Join')
 t.call_function('doStuff')
 ```
+ 
+### Importing from Code
+
+You can import existing templates from their built code using the `from_code` method:
+
+```py
+from dfpyre import *
+template_code = 'H4sIAGVyIGYC/3WOMQ7CMAxFz4LnDsw5AhITI6qQSaw2IrGrxkJCVe5eh3boAJP9n/Kfs8AziX8VcPcFYgC3Zej26YDexGoZvUZhAxeJ3PI8WMtKSrnV+1q7P4op4Yfmx244qG7E4Uql4EA/jNv2Jc3qJU/2KqBiY4yZjI6UkpzAjkNJouDO1X7S1xUDaGUl2QAAAA=='
+
+t = DFTemplate.from_code(template_code)
+# add onto the template from here
+```
+
+
+### Script Generation
+
+You can also generate an equivalent python script for a template from a template object:
+
+```py
+from dfpyre import *
+template_code = 'H4sIAGVyIGYC/3WOMQ7CMAxFz4LnDsw5AhITI6qQSaw2IrGrxkJCVe5eh3boAJP9n/Kfs8AziX8VcPcFYgC3Zej26YDexGoZvUZhAxeJ3PI8WMtKSrnV+1q7P4op4Yfmx244qG7E4Uql4EA/jNv2Jc3qJU/2KqBiY4yZjI6UkpzAjkNJouDO1X7S1xUDaGUl2QAAAA=='
+
+t = DFTemplate.from_code(template_code)
+t.generate_script('my_template.py')    # generated python script will be written to my_template.py
+```
 
 ### Method List
 

dfpyre-0.6.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+dfpyre/__init__.py,sha256=apPsSxJ1Tztfl71MoORoSmDfX7LyKLYlLwOGeLQUitw,25
+dfpyre/data/data.json,sha256=M4EHXKkh7Cx7y3BQ6c3csvmNmSqP2oE4txLI9MZcDDA,30347
+dfpyre/items.py,sha256=t9KsvhPOEe36_E7CNdgxNmEKtOF6nMvNZURyYFiXJb4,9215
+dfpyre/pyre.py,sha256=OHsdTP9kTzuLXakhqS2ncl5frw75akl3zQ9oQ45NqHs,17616
+dfpyre/scriptgen.py,sha256=TG_qYp2GChkwCD0f9WVCJOORDDL4RueuJeRkddB4YJw,5568
+dfpyre/style.py,sha256=mLW1CFvvi8_9fk8JaH10I5S4WI0YBdQIXHtI3G_4sR8,980
+dfpyre-0.6.1.dist-info/LICENSE,sha256=_vuDskB0ja2c-Fgm7Gt8Q8cO9NsLNpZAVyvmZwX7E6o,1060
+dfpyre-0.6.1.dist-info/METADATA,sha256=tvnWndGOuItw_G-dzsxRPGXkvPiTn7zLuADsHWGJ87w,11344
+dfpyre-0.6.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+dfpyre-0.6.1.dist-info/RECORD,,

dfpyre-0.5.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-dfpyre/__init__.py,sha256=apPsSxJ1Tztfl71MoORoSmDfX7LyKLYlLwOGeLQUitw,25
-dfpyre/data/data.json,sha256=M4EHXKkh7Cx7y3BQ6c3csvmNmSqP2oE4txLI9MZcDDA,30347
-dfpyre/items.py,sha256=L2e9b9BZQrI7AIBw46puENReDQRlWgHnw7T9NBG1Vcs,7688
-dfpyre/pyre.py,sha256=5UryjtwsNRxl6mGknsKm8iM2DP49-B-tqwkr9LdoRJ8,13805
-dfpyre/style.py,sha256=mLW1CFvvi8_9fk8JaH10I5S4WI0YBdQIXHtI3G_4sR8,980
-dfpyre-0.5.0.dist-info/LICENSE,sha256=atkly29RNUY2evLoPyurzCJeQnhP-VCAD-JZEbq3mno,1060
-dfpyre-0.5.0.dist-info/METADATA,sha256=RpuPps-V4FruPh1p0L7wroEDwZfC5lP6ITgl14334Cs,10142
-dfpyre-0.5.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-dfpyre-0.5.0.dist-info/RECORD,,