dfpyre 0.8.20__py3-none-any.whl → 0.9.0__py3-none-any.whl

dfpyre/pyre.py

@@ -5,16 +5,16 @@ By Amp
 """
 
 import json
-from difflib import get_close_matches
 import datetime
 import platform
-from enum import Enum
 from amulet_nbt import CompoundTag, StringTag, DoubleTag
 from dfpyre.util import df_encode, df_decode, flatten
 from dfpyre.items import *
-from dfpyre.actiondump import CODEBLOCK_DATA, get_default_tags
+from dfpyre.codeblock import CodeBlock, Target, TARGETS, DEFAULT_TARGET, CONDITIONAL_CODEBLOCKS, TEMPLATE_STARTERS
+from dfpyre.actiondump import get_default_tags
 from dfpyre.action_literals import *
 from dfpyre.scriptgen import generate_script, GeneratorFlags
+from dfpyre.slice import slice_template
 
 __all__ = [
     'Target', 'CodeBlock', 'DFTemplate',
@@ -23,196 +23,13 @@ __all__ = [
 ] + VAR_ITEM_TYPES
 
 
-VARIABLE_TYPES = {'txt', 'comp', 'num', 'item', 'loc', 'var', 'snd', 'part', 'pot', 'g_val', 'vec', 'pn_el', 'bl_tag'}
-TEMPLATE_STARTERS = {'event', 'entity_event', 'func', 'process'}
 DYNAMIC_CODEBLOCKS = {'func', 'process', 'call_func', 'start_process'}
 
-TARGETS = ['Selection', 'Default', 'Killer', 'Damager', 'Shooter', 'Victim', 'AllPlayers', 'Projectile', 'AllEntities', 'AllMobs', 'LastEntity']
-TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
-
 CODECLIENT_URL = 'ws://localhost:31375'
 
 DATE_FORMAT_STR = "%b %#d, %Y" if platform.system() == "Windows" else "%b %-d, %Y"
 
 
-class Target(Enum):
-    SELECTION = 0
-    DEFAULT = 1
-    KILLER = 2
-    DAMAGER = 3
-    SHOOTER = 4
-    VICTIM = 5
-    ALL_PLAYERS = 6
-    PROJECTILE = 7
-    ALL_ENTITIES = 8
-    ALL_MOBS = 9
-    LAST_ENTITY = 10
-
-    def get_string_value(self):
-        return TARGETS[self.value]
-
-DEFAULT_TARGET = Target.SELECTION
-
-
-def _convert_args(args):
-    return tuple(map(convert_literals, args))
-
-
-class CodeBlock:
-    def __init__(self, codeblock_type: str, action_name: str, args: tuple=(), target: Target=DEFAULT_TARGET, data: dict={}, tags: dict[str, str]={}):
-        self.type = codeblock_type
-        self.action_name = action_name
-        self.args = args
-        self.target = target
-        self.data = data
-        self.tags = tags
-    
-
-    @classmethod
-    def new_action(cls, codeblock_type: str, action_name: str, args: tuple, tags: dict[str, str], target: Target=DEFAULT_TARGET) -> "CodeBlock":
-        args = _convert_args(args)
-        return cls(codeblock_type, action_name, args=args, data={'id': 'block', 'block': codeblock_type, 'action': action_name}, tags=tags, target=target)
-
-    @classmethod
-    def new_data(cls, codeblock_type: str, data_value: str, args: tuple, tags: dict[str, str]) -> "CodeBlock":
-        args = _convert_args(args)
-        return cls(codeblock_type, 'dynamic', args=args, data={'id': 'block', 'block': codeblock_type, 'data': data_value}, tags=tags)
-
-    @classmethod
-    def new_conditional(cls, codeblock_type: str, action_name: str, args: tuple, tags: dict[str, str], inverted: bool, target: Target=DEFAULT_TARGET) -> "CodeBlock":
-        args = _convert_args(args)
-        data = {'id': 'block', 'block': codeblock_type, 'action': action_name}
-        if inverted:
-            data['attribute'] = 'NOT'
-        return cls(codeblock_type, action_name, args=args, data=data, tags=tags, target=target)
-
-    @classmethod
-    def new_repeat(cls, action_name: str, args: tuple, tags: dict[str, str], sub_action: str|None, inverted: bool) -> "CodeBlock":
-        args = _convert_args(args)
-        data = {'id': 'block', 'block': 'repeat', 'action': action_name}
-        if inverted:
-            data['attribute'] = 'NOT'
-        if sub_action is not None:
-            data['subAction'] = sub_action
-        return cls('repeat', action_name, args=args, data=data, tags=tags)
-
-    @classmethod
-    def new_else(cls) -> "CodeBlock":
-        return cls('else', 'else', data={'id': 'block', 'block': 'else'})
-
-    @classmethod
-    def new_bracket(cls, direction: Literal['open', 'close'], bracket_type: Literal['norm', 'repeat']) -> "CodeBlock":
-        return cls('bracket', 'bracket', data={'id': 'bracket', 'direct': direction, 'type': bracket_type})
-
-
-    def __repr__(self) -> str:
-        if self.action_name == 'dynamic':
-            return f'CodeBlock({self.data["block"]}, {self.data["data"]})'
-        if self.action_name == 'else':
-            return 'CodeBlock(else)'
-        if 'block' in self.data:
-            return f'CodeBlock({self.data["block"]}, {self.action_name})'
-        return f'CodeBlock(bracket, {self.data["type"]}, {self.data["direct"]})'
-
-
-    def build(self) -> dict:
-        """
-        Builds a properly formatted block from a CodeBlock object.
-        """
-        built_block = self.data.copy()
-        
-        # add target if necessary ('Selection' is the default when 'target' is blank)
-        if self.type in TARGET_CODEBLOCKS and self.target != DEFAULT_TARGET:
-            built_block['target'] = self.target.get_string_value()
-        
-        # add items into args
-        final_args = [arg.format(slot) for slot, arg in enumerate(self.args) if arg.type in VARIABLE_TYPES]
-        already_applied_tags: dict[str, dict] = {a['item']['data']['tag']: a for a in final_args if a['item']['id'] == 'bl_tag'}
-        
-        # check for unrecognized name, add tags
-        if self.type not in {'bracket', 'else'}:
-            if self.action_name not in CODEBLOCK_DATA[self.type]:
-                _warn_unrecognized_name(self.type, self.action_name)
-            
-            tags = _get_codeblock_tags(self.type, self.action_name, self.tags)
-            for i, tag_data in enumerate(tags):
-                already_applied_tag_data = already_applied_tags.get(tag_data['item']['data']['tag'])
-                if already_applied_tag_data is not None:
-                    tags[i] = already_applied_tag_data
-            
-            if len(final_args) + len(tags) > 27:
-                final_args = final_args[:(27-len(tags))]  # trim list if over 27 elements
-            final_args.extend(tags)  # add tags to end
-
-        built_block['args'] = {'items': final_args}
-        return built_block
-
-
-def _warn_unrecognized_name(codeblock_type: str, codeblock_name: str):
-    close = get_close_matches(codeblock_name, CODEBLOCK_DATA[codeblock_type].keys())
-    if close:
-        warn(f'Code block name "{codeblock_name}" not recognized. Did you mean "{close[0]}"?')
-    else:
-        warn(f'Code block name "{codeblock_name}" not recognized. Try spell checking or retyping without spaces.')
-
-
-def _check_applied_tags(tags: list[dict], applied_tags: dict[str, str], codeblock_name: str) -> dict[str, str]:
-    if len(applied_tags) > 0 and len(tags) == 0:
-        warn(f'Action "{codeblock_name}" does not have any tags, but still received {len(applied_tags)}.')
-        return {}
-    
-    valid_tags = {}
-    tags_formatted = {t['name']: t for t in tags}
-    for name, option in applied_tags.items():
-        if name not in tags_formatted:
-            tag_names_joined = '\n'.join(map(lambda s: '    - '+s, tags_formatted.keys()))
-            warn(f'Tag "{name}" does not exist for action "{codeblock_name}". Available tags:\n{tag_names_joined}')
-        elif option not in tags_formatted[name]['options']:
-            options_joined = '\n'.join(map(lambda s: '    - '+s, tags_formatted[name]['options']))
-            warn(f'Tag "{name}" does not have the option "{option}". Available tag options:\n{options_joined}')
-        else:
-            valid_tags[name] = option
-    return valid_tags
-
-
-def _reformat_codeblock_tags(tags: list[dict], codeblock_type: str, codeblock_action: str, applied_tags: dict[str, str]) -> list[dict]:
-    """
-    Turns tag objects into DiamondFire formatted tag items.
-    """
-
-    def format_tag(option: str, name: str):
-        return {
-            'item': {
-                'id': 'bl_tag',
-                'data': {'option': option, 'tag': name, 'action': codeblock_action, 'block': codeblock_type}
-            },
-            'slot': tag_item['slot']
-        }
-    
-    valid_applied_tags = _check_applied_tags(tags, applied_tags, codeblock_action)
-    reformatted_tags = []
-    for tag_item in tags:
-        tag_name = tag_item['name']
-        tag_option = tag_item['default']
-        if tag_name in valid_applied_tags:
-            tag_option = valid_applied_tags[tag_name]
-
-        new_tag_item = format_tag(tag_option, tag_name)
-        reformatted_tags.append(new_tag_item)
-    return reformatted_tags
-
-
-def _get_codeblock_tags(codeblock_type: str, codeblock_name: str, applied_tags: dict[str, str]) -> list[dict]:
-    """
-    Get tags for the specified codeblock type and name.
-    """
-    action_data = CODEBLOCK_DATA[codeblock_type][codeblock_name]
-    if 'deprecatedNote' in action_data:
-        warn(f'Action "{codeblock_name}" is deprecated: {action_data["deprecatedNote"]}')
-    tags = action_data['tags']
-    return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name, applied_tags)
-
-
 class DFTemplate:
     """
     Represents a DiamondFire code template.
@@ -256,8 +73,8 @@ class DFTemplate:
                     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
 
+            codeblock_target = Target(TARGETS.index(block_dict['target'])) if 'target' in block_dict else DEFAULT_TARGET
             codeblock_type = block_dict.get('block')
 
             if codeblock_type is None:
@@ -267,7 +84,15 @@ class DFTemplate:
             elif codeblock_type in DYNAMIC_CODEBLOCKS:
                 codeblock = CodeBlock.new_data(codeblock_type, block_dict['data'], block_args, block_tags)
             elif 'action' in block_dict:
-                codeblock = CodeBlock.new_action(codeblock_type, block_dict['action'], block_args, block_tags, block_target)
+                codeblock_action = block_dict['action']
+                inverted = block_dict.get('attribute') == 'NOT'
+                sub_action = block_dict.get('subAction')
+                if sub_action is not None:
+                    codeblock = CodeBlock.new_subaction_block(codeblock_type, codeblock_action, block_args, block_tags, sub_action, inverted)
+                elif codeblock_type in CONDITIONAL_CODEBLOCKS:
+                    codeblock = CodeBlock.new_conditional(codeblock_type, codeblock_action, block_args, block_tags, inverted, codeblock_target)
+                else:
+                    codeblock = CodeBlock.new_action(codeblock_type, codeblock_action, block_args, block_tags, codeblock_target)
             codeblocks.append(codeblock)
         
         return DFTemplate(codeblocks, author)
@@ -362,7 +187,12 @@ class DFTemplate:
         :param bool build_and_send: If True, `.build_and_send()` will be added to the end of the generated template.
         """
         flags = GeneratorFlags(indent_size, literal_shorthand, var_shorthand, preserve_slots, assign_variable, include_import, build_and_send)
-        return generate_script(self, flags)
+        return generate_script(self.codeblocks, flags)
+    
+    
+    def slice(self, target_length: int) -> list['DFTemplate']:
+        sliced_templates = slice_template(self.codeblocks, target_length, self._get_template_name())
+        return [DFTemplate(t, self.author) for t in sliced_templates]
 
 
 def _assemble_template(starting_block: CodeBlock, codeblocks: list[CodeBlock], author: str|None) -> DFTemplate:
@@ -570,7 +400,7 @@ def else_(codeblocks: list[CodeBlock]=[]) -> list[CodeBlock]:
     ]
 
 
-def repeat(action_name: REPEAT_ACTION, *args, tags: dict[str, str]={}, sub_action: REPEAT_SUBACTION|None=None, inverted: bool=False, codeblocks: list[CodeBlock]=[]) -> CodeBlock:
+def repeat(action_name: REPEAT_ACTION, *args, tags: dict[str, str]={}, sub_action: SUBACTION|None=None, inverted: bool=False, codeblocks: list[CodeBlock]=[]) -> CodeBlock:
     """
     Represents a Repeat codeblock.
 
@@ -582,7 +412,7 @@ def repeat(action_name: REPEAT_ACTION, *args, tags: dict[str, str]={}, sub_actio
     :param list[CodeBlock] codeblocks: The list of codeblocks inside the brackets.
     """
     return [
-        CodeBlock.new_repeat(action_name, args, tags, sub_action, inverted),
+        CodeBlock.new_subaction_block('repeat', action_name, args, tags, sub_action, inverted),
         CodeBlock.new_bracket('open', 'repeat')
     ] + list(codeblocks) + [
         CodeBlock.new_bracket('close', 'repeat')
@@ -600,15 +430,17 @@ def control(action_name: CONTROL_ACTION, *args, tags: dict[str, str]={}) -> Code
     return CodeBlock.new_action('control', action_name, args, tags)
 
 
-def select_object(action_name: SELECT_OBJ_ACTION, *args, tags: dict[str, str]={}) -> CodeBlock:
+def select_object(action_name: SELECT_OBJ_ACTION, *args, tags: dict[str, str]={}, sub_action: SUBACTION|None=None, inverted: bool=False) -> CodeBlock:
     """
     Represents a Select Object codeblock.
 
     :param str action_name: The name of the action.
     :param tuple args: The argument items to include.
     :param dict[str, str] tags: The tags to include.
+    :param str|None sub_action: The sub-action to use. (Not relevant for all actions)
+    :param bool inverted: Whether the sub-action condition should be inverted.
     """
-    return CodeBlock.new_action('select_obj', action_name, args, tags) 
+    return CodeBlock.new_subaction_block('select_obj', action_name, args, tags, sub_action, inverted) 
 
 
 def set_variable(action_name: SET_VAR_ACTION, *args, tags: dict[str, str]={}) -> CodeBlock:

dfpyre/scriptgen.py

@@ -1,8 +1,8 @@
 import dataclasses
-import re
 from dfpyre.util import is_number
 from dfpyre.items import *
 from dfpyre.actiondump import get_default_tags
+from dfpyre.codeblock import CodeBlock
 
 
 IMPORT_STATEMENT = 'from dfpyre import *'
@@ -30,6 +30,7 @@ TEMPLATE_FUNCTION_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_var', 'else', 'repeat'}
+CONDITIONAL_CODEBLOCKS = {'if_player', 'if_var', 'if_game', 'if_entity'}
 VAR_SCOPES = {'unsaved': 'g', 'saved': 's', 'local': 'l', 'line': 'i'}
 
 
@@ -154,7 +155,7 @@ def add_script_line(flags: GeneratorFlags, script_lines: list[str], indent_level
     script_lines.append(added_line)
 
 
-def generate_script(template, flags: GeneratorFlags) -> str:
+def generate_script(codeblocks: list[CodeBlock], flags: GeneratorFlags) -> str:
     indent_level = 0
     script_lines = []
     variable_assigned = False
@@ -167,7 +168,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
             script_lines[-1] = script_lines[-1][:-1]
     
     def get_var_assignment_snippet() -> str:
-        first_block_data = template.codeblocks[0].data
+        first_block_data = codeblocks[0].data
         if 'data' in first_block_data:
             name = first_block_data['data']
             var_name = name if name else 'unnamed_template'
@@ -176,7 +177,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
         return f'{string_to_python_name(var_name)} = '
 
 
-    for codeblock in template.codeblocks:
+    for codeblock in codeblocks:
         # Handle closing brackets
         if codeblock.type == 'bracket':
             if codeblock.data['direct'] == 'close':
@@ -208,17 +209,26 @@ def generate_script(template, flags: GeneratorFlags) -> str:
         if function_name in TARGET_CODEBLOCKS and codeblock.target.name != 'SELECTION':
             function_args.append(f'target=Target.{codeblock.target.name}')
         
+        # Add sub-action for repeat and select object
+        sub_action = codeblock.data.get('subAction')
+        if sub_action is not None:
+            function_args.append(f"sub_action='{sub_action}'")
+        
         # Add tags
         if codeblock.tags:
-            default_tags = get_default_tags(codeblock.data.get('block'), codeblock.action_name)
+            default_tags = codeblock.tags
+            if sub_action is not None:
+                for conditional_block_type in CONDITIONAL_CODEBLOCKS:
+                    default_tags = get_default_tags(conditional_block_type, sub_action)
+                    if default_tags:
+                        break
+            else:
+                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:
                 function_args.append(f'tags={str(written_tags)}')
         
-        # 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')

dfpyre/slice.py

@@ -0,0 +1,200 @@
+from typing import Iterator
+from dataclasses import dataclass
+from collections import deque
+from dfpyre.codeblock import CodeBlock, CONDITIONAL_CODEBLOCKS, TEMPLATE_STARTERS
+from dfpyre.items import Variable, Parameter, ParameterType
+
+
+BRACKET_CODEBLOCKS = CONDITIONAL_CODEBLOCKS
+BRACKET_CODEBLOCKS.add('repeat')
+
+
+@dataclass
+class TemplateChunk:
+    length: int
+    start_index: int
+    end_index: int
+    contents1: list['TemplateChunk'] | None  # Inside brackets
+    contents2: list['TemplateChunk'] | None  # Inside `else` brackets
+
+
+def get_referenced_line_vars(codeblocks: list[CodeBlock]) -> set[str]:
+    referenced_vars = set()
+    for codeblock in codeblocks:
+        for argument in codeblock.args:
+            if isinstance(argument, Variable) and argument.scope == 'line':
+                referenced_vars.add(argument.name)
+    return referenced_vars
+
+
+def find_closing_bracket(codeblocks: list[CodeBlock], start_index: int) -> int:
+    """
+    Returns the index of the cooresponding closing bracket assuming 
+    that `start_index` is the index of the first codeblock inside the brackets.
+    """
+    nested_level = 1
+    for i in range(start_index, len(codeblocks)):
+        codeblock = codeblocks[i]
+        if codeblock.type != 'bracket':
+            continue
+
+        direction = codeblock.data['direct']
+        if direction == 'open':
+            nested_level += 1
+        else:  # Closed
+            nested_level -= 1
+        
+        if nested_level == 0:
+            return i
+    
+    return -1
+
+
+def get_bracket_ranges(codeblocks: list[CodeBlock], start_index: int):
+    bracket_range_end = find_closing_bracket(codeblocks, start_index)
+
+    if len(codeblocks) >= bracket_range_end and codeblocks[bracket_range_end+1].type == 'else':
+        else_range_start = bracket_range_end+3  # Add 3 to move inside `else` brackets
+        else_range_end = find_closing_bracket(codeblocks, else_range_start)
+        else_range = (else_range_start, else_range_end)
+    else:
+        else_range = None
+
+    bracket_range = (start_index, bracket_range_end)
+    return (bracket_range, else_range)
+
+
+def get_template_length(codeblocks: list[CodeBlock]) -> int:
+    return sum(b.get_length() for b in codeblocks)
+
+
+def get_template_chunks(codeblocks: list[CodeBlock], start_index: int, end_index: int) -> list[TemplateChunk]:
+    chunks: list[TemplateChunk] = []
+
+    index = start_index
+    while index < end_index:
+        codeblock = codeblocks[index]
+        if codeblock.type == 'bracket' or codeblock.type in TEMPLATE_STARTERS:
+            index += 1
+            continue
+
+        if codeblock.type in BRACKET_CODEBLOCKS:
+            bracket_range, else_range = get_bracket_ranges(codeblocks, index+2)
+            inside_bracket = codeblocks[bracket_range[0]:bracket_range[1]]
+            inside_bracket_length = get_template_length(inside_bracket)
+            chunk_contents1 = get_template_chunks(codeblocks, bracket_range[0], bracket_range[1])
+            if else_range is None:
+                chunk_length = inside_bracket_length + 4
+                chunk_end_index = bracket_range[1] + 1
+                chunk_contents2 = None
+            else:
+                inside_else = codeblocks[else_range[0]:else_range[1]]
+                inside_else_length = get_template_length(inside_else)
+                chunk_length = inside_bracket_length + inside_else_length + 8
+                chunk_end_index = else_range[1] + 1
+                chunk_contents2 = get_template_chunks(codeblocks, else_range[0], else_range[1])
+            
+            chunk = TemplateChunk(length=chunk_length, start_index=index, end_index=chunk_end_index, contents1=chunk_contents1, contents2=chunk_contents2)
+            chunks.append(chunk)
+            index = chunk_end_index-1
+        
+        else:
+            chunk = TemplateChunk(length=2, start_index=index, end_index=index+1, contents1=None, contents2=None)
+            chunks.append(chunk)
+        
+        index += 1
+
+    return chunks
+
+
+def extract_one_template(codeblocks: list[CodeBlock], target_length: int, extracted_template_name: str) -> tuple[list[CodeBlock], list[CodeBlock]]:
+    chunks = get_template_chunks(codeblocks, 0, len(codeblocks))
+    current_slice_length = 2
+    current_slice_start = -1
+    current_slice_end = -1
+
+    slices: dict[tuple[int, int], int] = {}
+
+    chunks_to_iterate: deque[list[TemplateChunk]] = deque()
+    chunks_to_iterate.append(chunks)
+
+    def save_current_slice():
+        nonlocal current_slice_start, current_slice_end, current_slice_length, slices
+        current_slice_range = (current_slice_start, current_slice_end)
+        slices[current_slice_range] = current_slice_length
+        current_slice_length = 2
+        current_slice_start = -1
+        current_slice_end = -1
+
+    while chunks_to_iterate:
+        current_chunks = chunks_to_iterate.pop()
+        for chunk in reversed(current_chunks):
+            if chunk.contents1:
+                chunks_to_iterate.append(chunk.contents1)
+            if chunk.contents2:
+                chunks_to_iterate.append(chunk.contents2)
+            
+            if current_slice_start == -1:
+                current_slice_start = chunk.start_index
+            if current_slice_end == -1:
+                current_slice_end = chunk.end_index
+            
+            # Check if chunk is too long
+            if chunk.length > target_length - 2:
+                save_current_slice()
+                continue
+            
+            new_slice_length = current_slice_length + chunk.length
+            if new_slice_length <= target_length:
+                current_slice_length = new_slice_length
+                current_slice_start = chunk.start_index
+            else:
+                current_slice_range = (current_slice_start, current_slice_end)
+                slices[current_slice_range] = current_slice_length
+                current_slice_length = chunk.length + 2
+                current_slice_start = chunk.start_index
+                current_slice_end = chunk.end_index
+    
+        save_current_slice()
+    
+    sliced_range = max(slices.items(), key=lambda kv: kv[1])[0]  # Extract the longest slice
+    extracted_codeblocks = codeblocks[sliced_range[0]:sliced_range[1]]
+    del codeblocks[sliced_range[0]:sliced_range[1]]
+
+    original_line_vars = get_referenced_line_vars(codeblocks)
+    extracted_line_vars = get_referenced_line_vars(extracted_codeblocks)
+    param_line_vars = set.intersection(original_line_vars, extracted_line_vars)
+    function_parameters = []
+    function_call_args = []
+    for line_var in param_line_vars:
+        function_parameters.append(Parameter(line_var, ParameterType.VAR))
+        function_call_args.append(Variable(line_var, 'line'))
+    
+    function_codeblock = CodeBlock.new_data('func', extracted_template_name, tuple(function_parameters), tags={'Is Hidden': 'True'})
+    extracted_codeblocks.insert(0, function_codeblock)
+
+    call_function_codeblock = CodeBlock.new_data('call_func', extracted_template_name, tuple(function_call_args), {})
+    codeblocks.insert(sliced_range[0], call_function_codeblock)
+
+    return codeblocks, extracted_codeblocks
+
+
+def slice_template(codeblocks: list[CodeBlock], target_length: int, template_name: str) -> list[list[CodeBlock]]:
+    template_length = get_template_length(codeblocks)
+    if template_length < target_length:
+        return [codeblocks]
+
+    codeblocks = codeblocks.copy()
+
+    sliced_templates: list[list[CodeBlock]] = []
+
+    # Extract single templates until the original template meets the target length
+    template_number = 1 
+    while get_template_length(codeblocks) > target_length:
+        extracted_template_name = template_name + '_' + str(template_number)
+        codeblocks, extracted_codeblocks = extract_one_template(codeblocks, target_length, extracted_template_name)
+        sliced_templates.append(extracted_codeblocks)
+        template_number += 1
+
+    sliced_templates.insert(0, codeblocks)
+    return sliced_templates

{dfpyre-0.8.20.dist-info → dfpyre-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.8.20
+Version: 0.9.0
 Summary: A package for creating and modifying 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.4.3,<0.5.0)
+Requires-Dist: mcitemlib (>=0.4.5,<0.5.0)
 Project-URL: Repository, https://github.com/Amp63/pyre
 Description-Content-Type: text/markdown
 

dfpyre-0.9.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+dfpyre/__init__.py,sha256=apPsSxJ1Tztfl71MoORoSmDfX7LyKLYlLwOGeLQUitw,25
+dfpyre/action_literals.py,sha256=0aYS5v8pj3tyQVoiW_ueKBDQ0nY5VduPp4HeW_kpFio,55600
+dfpyre/actiondump.py,sha256=l6_h811AnKkeI6WrrRlS-vDOgenh6XU9qvEuPf2DpSs,3720
+dfpyre/codeblock.py,sha256=NwUapwVP1qrnFaN4WlKov4MTJW9_l2ujNhY1P0pzboU,8577
+dfpyre/data/actiondump_min.json,sha256=zdUYVuua6a93wxFewHWXBHYRuuvwDZK6c3J2558BAIg,2642808
+dfpyre/items.py,sha256=zdT_b7D38ofFVEYtjHb6x6IU0XMJJCJPuQUXW5MNsm0,17681
+dfpyre/pyre.py,sha256=WQhIXmrd7A1APcRobjmT5eBGHNf7V12qlcPvI1QM7R8,19331
+dfpyre/scriptgen.py,sha256=UNUbRVAUlO0gCGoo17Qpiaa5XOXTVZIEHGN2ckEdXaM,10231
+dfpyre/slice.py,sha256=azKC5H7sxXvKSa1uFHQNoS2MGLqgl-_0ftD8F9fRn_Y,7980
+dfpyre/style.py,sha256=mLW1CFvvi8_9fk8JaH10I5S4WI0YBdQIXHtI3G_4sR8,980
+dfpyre/util.py,sha256=_ndjGyn_pvMfEBmUjt0ARjYvGZfZz7Av-KSYPmvx0N0,934
+dfpyre-0.9.0.dist-info/LICENSE,sha256=_vuDskB0ja2c-Fgm7Gt8Q8cO9NsLNpZAVyvmZwX7E6o,1060
+dfpyre-0.9.0.dist-info/METADATA,sha256=acAZkSAbA6FfFckEiOdA6eQy1hljGo62p_T1V0ZBwjo,11948
+dfpyre-0.9.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+dfpyre-0.9.0.dist-info/RECORD,,

dfpyre-0.8.20.dist-info/RECORD

@@ -1,13 +0,0 @@
-dfpyre/__init__.py,sha256=apPsSxJ1Tztfl71MoORoSmDfX7LyKLYlLwOGeLQUitw,25
-dfpyre/action_literals.py,sha256=bwdLVDi2sU_4HUmvyOJtCguPOWJga_fQTPLtzPm4Mr4,52084
-dfpyre/actiondump.py,sha256=5Q4RmT_DyVbPvkF0AFzMAqtqR1bmqu91yed_pRK5MkU,3571
-dfpyre/data/actiondump_min.json,sha256=ZF_Aa6uB1khzsINAEAljCOIMmfh_5ihmBygZSP_bHrs,2482346
-dfpyre/items.py,sha256=zdT_b7D38ofFVEYtjHb6x6IU0XMJJCJPuQUXW5MNsm0,17681
-dfpyre/pyre.py,sha256=T-rnvCgIucWKFdhcRuBM_5NTaszuZ4M2VIcu44jrLIY,26047
-dfpyre/scriptgen.py,sha256=NABQKGgnoWZCkV42Av_4Is8CdVCWUt6Wk9-r-F44Als,9742
-dfpyre/style.py,sha256=mLW1CFvvi8_9fk8JaH10I5S4WI0YBdQIXHtI3G_4sR8,980
-dfpyre/util.py,sha256=_ndjGyn_pvMfEBmUjt0ARjYvGZfZz7Av-KSYPmvx0N0,934
-dfpyre-0.8.20.dist-info/LICENSE,sha256=_vuDskB0ja2c-Fgm7Gt8Q8cO9NsLNpZAVyvmZwX7E6o,1060
-dfpyre-0.8.20.dist-info/METADATA,sha256=M0RBjcjMhSPG1nVP5ZGuirKmFMpzrBDpBwRgfQRqr08,11949
-dfpyre-0.8.20.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-dfpyre-0.8.20.dist-info/RECORD,,