dfpyre 0.4.2__py3-none-any.whl → 0.10.5__py3-none-any.whl

dfpyre/scripts/action_gen.py

@@ -0,0 +1,222 @@
+"""
+Generates Codeblock classes with static methods for each action.
+"""
+
+from dataclasses import dataclass
+from dfpyre.core.actiondump import ACTIONDUMP, ActionArgument, ActionTag, TagOption
+from dfpyre.util.util import flatten
+from dfpyre.gen.action_class_data import (
+    INDENT, CODEBLOCK_LOOKUP, PARAM_NAME_REPLACEMENTS, PARAM_TYPE_LOOKUP, TEMPLATE_OVERRIDES, OUTPUT_PATH, IMPORTS, CLASS_ALIASES,
+    get_method_name_and_aliases, to_valid_identifier
+)
+
+
+@dataclass
+class ParameterData:
+    name: str
+    types: str
+    description: str
+    notes: str
+    is_optional: bool
+    has_none: bool
+
+    def get_param_string(self) -> str:
+        param_str = f'{self.name}: {self.types}'
+        if self.has_none or self.is_optional:
+            param_str += '=None'
+        return param_str
+
+    def get_docstring(self) -> str:
+        docstring = f':param {self.types} {self.name}: {self.description}'
+        if self.is_optional:
+            docstring += ' (optional)'
+        if self.notes:
+            docstring += f' ({self.notes})'
+        return docstring
+
+    def __eq__(self, value):
+        return self is value
+
+
+def parse_parameters(action_arguments: list[tuple[ActionArgument, ...]]) -> list[ParameterData]:
+    parameter_list: list[ParameterData] = []
+    prev_optional_exists = False
+
+    for arg_union in action_arguments:
+        if len(arg_union) == 1:
+            param_name = arg_union[0].type.lower()
+            if param_name in PARAM_NAME_REPLACEMENTS:
+                param_name = PARAM_NAME_REPLACEMENTS[param_name]
+        else:
+            param_name = f'arg'
+
+        is_optional = arg_union[0].optional
+        has_none = 'NONE' in (arg.type for arg in arg_union)
+        
+        param_types_list = list(flatten(PARAM_TYPE_LOOKUP[arg.type] for arg in arg_union))
+        if is_optional:
+            param_types_list.append('None')
+            prev_optional_exists = True
+        elif prev_optional_exists:
+            # If a previous optional param exists, all subsequent params must be
+            # optional as well, so we set `has_none` to True to add `=None` to future params.
+            has_none = True
+        
+        param_types_dedup = list(dict.fromkeys(param_types_list))
+        param_types = ' | '.join(param_types_dedup)
+
+        if arg_union[0].plural:
+            param_name += 's'
+            plural_param_types = ' | '.join(t for t in param_types_dedup if t != 'None')  # Doesn't make sense to have a list of None
+            param_types = f'list[{plural_param_types}] | {param_types}'
+
+        param_description = ' OR '.join(arg.description for arg in arg_union if arg.description)
+        param_notes = ' OR '.join(arg.notes for arg in arg_union if arg.notes)
+
+        param = ParameterData(param_name, param_types, param_description, param_notes, is_optional, has_none)
+        parameter_list.append(param)
+    
+    # Add numbers to params with duplicate names
+    param_names = [p.name for p in parameter_list]
+    param_name_lookup = {p.name: [q for q in parameter_list if p.name == q.name] for p in parameter_list}
+    for param in parameter_list:
+        if param_names.count(param.name) > 1:
+            params_with_name = param_name_lookup[param.name]
+            param_index = params_with_name.index(param)
+            param.name += str(param_index + 1)
+
+    return parameter_list
+
+
+@dataclass
+class TagData:
+    name: str
+    options: list[TagOption]
+    default: str
+
+    def get_varname(self) -> str:
+        return to_valid_identifier(self.name.lower())
+
+    def get_param_string(self) -> str:
+        options_list = ', '.join(f'"{o.name}"' for o in self.options)
+        tag_type = f'Literal[{options_list}]'
+        return f'{self.get_varname()}: {tag_type}="{self.default}"'
+
+    def get_docstring(self) -> str:
+        docstring_lines = [f':param str {self.get_varname()}: {self.name}']
+        docstring_lines += [f'{INDENT*2}- {o.name}: {o.description}' for o in self.options if o.description]
+        if len(docstring_lines) > 1:
+            docstring_lines.insert(1, '')
+        return '\n'.join(docstring_lines)
+
+
+def parse_tags(action_tags: list[ActionTag]) -> list[TagData]:
+    return [TagData(t.name, t.options, t.default) for t in action_tags]
+
+
+def generate_actions():
+    generated_lines: list[str] = IMPORTS.copy()
+    generated_lines += ['']
+    
+    for codeblock_type, actions in ACTIONDUMP.action_data.items():
+        codeblock_data = CODEBLOCK_LOOKUP.get(codeblock_type)
+        if codeblock_data is None:
+            continue
+            
+        class_name, method_template = codeblock_data
+
+        class_docstring = ACTIONDUMP.codeblock_data[codeblock_type].description
+        class_def_lines = [
+            f'class {class_name}:',
+            f'{INDENT}"""',
+            f'{INDENT}{class_docstring}',
+            f'{INDENT}"""',
+            ''
+        ]
+        generated_lines += class_def_lines
+
+        for action_name, action_data in actions.items():
+            if action_data.is_deprecated:
+                # Skip deprecated actions
+                continue
+            
+            method_data = get_method_name_and_aliases(codeblock_type, action_name)
+            if method_data is None:
+                continue
+            method_name, method_aliases = method_data
+
+            template_overrides = TEMPLATE_OVERRIDES.get(codeblock_type)
+            if template_overrides:
+                override_template = template_overrides.get(action_name)
+                if override_template is not None:
+                    method_template = override_template
+            
+            action_description = action_data.description or ''
+            if action_description:
+                action_description = f'{INDENT}{action_description}\n\n'
+            
+            # Get tag data
+            tags = parse_tags(action_data.tags)
+
+            tag_parameter_list = ', '.join(t.get_param_string() for t in tags)
+            if tag_parameter_list:
+                tag_parameter_list = f'{tag_parameter_list}, '
+            
+            tag_values = ', '.join(f"'{t.name}': {t.get_varname()}" for t in tags)
+
+            # Get parameter data
+            parameters = parse_parameters(action_data.arguments)
+
+            parameter_list = ', '.join(p.get_param_string() for p in parameters)
+            if parameter_list:
+                parameter_list += ', '
+            
+            parameter_names = ', '.join(p.name for p in parameters)
+            if parameter_names:
+                parameter_names += ','
+
+            docstring_list = [p.get_docstring() for p in parameters] + [t.get_docstring() for t in tags]
+            parameter_docstrings = '\n'.join(INDENT + s for s in docstring_list)
+
+            if parameter_docstrings:
+                parameter_docstrings += '\n'
+            
+            if action_description or parameter_docstrings:
+                # Fix indentation
+                parameter_docstrings += INDENT
+
+            method_code = method_template.format(
+                method_name = method_name,
+                parameter_list = parameter_list,
+                parameter_names = parameter_names,
+                parameter_docstrings = parameter_docstrings,
+                tag_parameter_list = tag_parameter_list,
+                tag_values = tag_values,
+                codeblock_type = codeblock_type,
+                action_name = action_name,
+                action_description = action_description
+            )
+
+            method_lines = [f'@staticmethod']
+            method_lines += method_code.split('\n')
+
+            for alias in method_aliases:
+                method_lines += [f'{alias} = {method_name}']
+            
+            method_lines = [INDENT + l for l in method_lines]
+            method_lines += ['']
+            generated_lines += method_lines
+        
+        class_aliases = CLASS_ALIASES.get(codeblock_type) or []
+        for alias in class_aliases:
+            alias_def = f'{alias} = {class_name}'
+            generated_lines.append(alias_def)
+
+    
+    with open(OUTPUT_PATH, 'w') as f:
+        f.write('\n'.join(generated_lines) + '\n')
+        
+
+if __name__ == '__main__':
+    generate_actions()
+    print(f'Wrote Codeblock action classes to {OUTPUT_PATH}.')

dfpyre/scripts/action_literal_gen.py

@@ -0,0 +1,43 @@
+"""
+Generates `Literal` objects containing action names for each codeblock type.
+This allows action names to be autocompleted if the user's IDE supports it.
+"""
+
+from datetime import datetime, timezone
+from dfpyre.core.actiondump import ACTIONDUMP
+
+
+OUTPUT_PATH = 'dfpyre/gen/action_literals.py'
+
+
+def generate_action_literals():
+    generated_lines: list[str] = [
+        f'# Auto generated by pyre {datetime.now(timezone.utc).isoformat()}',
+        'from typing import Literal\n'
+    ]
+    for codeblock_type, actions in ACTIONDUMP.action_data.items():
+        if len(actions) == 1:
+            continue
+
+        filtered_actions = [a for a, d in actions.items() if not d.is_deprecated]  # Omit deprecated actions
+        if not filtered_actions:
+            continue
+        action_list = str(filtered_actions)
+        literal_line = f'{codeblock_type.upper()}_ACTION = Literal{action_list}'
+        generated_lines.append(literal_line)
+    
+    game_value_names = list(ACTIONDUMP.game_values.keys())
+    generated_lines += [
+        f'GAME_VALUE_NAME = Literal{str(game_value_names)}',
+        f'SOUND_NAME = Literal{str(ACTIONDUMP.sound_names)}',
+        f'POTION_NAME = Literal{str(ACTIONDUMP.potion_names)}',
+        'SUBACTION = IF_PLAYER_ACTION | IF_ENTITY_ACTION | IF_GAME_ACTION | IF_VAR_ACTION'
+    ]
+    
+    with open(OUTPUT_PATH, 'w') as f:
+        f.write('\n'.join(generated_lines) + '\n')
+
+
+if __name__ == '__main__':
+    generate_action_literals()
+    print(f'Wrote codeblock action Literals to {OUTPUT_PATH}.')

dfpyre/tool/scriptgen.py

@@ -0,0 +1,274 @@
+import dataclasses
+from dfpyre.util.util import is_number
+from dfpyre.core.items import *
+from dfpyre.core.actiondump import get_default_tags
+from dfpyre.core.codeblock import CodeBlock, CONDITIONAL_CODEBLOCKS, TARGET_CODEBLOCKS, EVENT_CODEBLOCKS
+from dfpyre.gen.action_class_data import get_method_name_and_aliases, to_valid_identifier
+
+
+IMPORT_STATEMENT = 'from dfpyre import *'
+
+CODEBLOCK_FUNCTION_LOOKUP = {
+    'event': 'PlayerEvent',
+    'entity_event': 'EntityEvent',
+    'func': 'Function',
+    'process': 'Process',
+    'call_func': 'CallFunction',
+    'start_process': 'StartProcess',
+    'player_action': 'PlayerAction',
+    'game_action': 'GameAction',
+    'entity_action': 'EntityAction',
+    'if_player': 'IfPlayer',
+    'if_var': 'IfVariable',
+    'if_game': 'IfGame',
+    'if_entity': 'IfEntity',
+    'else': 'Else',
+    'repeat': 'Repeat',
+    'control': 'Control',
+    'select_obj': 'SelectObject',
+    'set_var': 'SetVariable'
+}
+
+NO_ACTION_BLOCKS = {'func', 'process', 'call_func', 'start_process', 'else'}
+CONTAINER_CODEBLOCKS = {'event', 'entity_event', 'func', 'process', 'if_player', 'if_entity', 'if_game', 'if_var', 'else', 'repeat'}
+VAR_SCOPE_LOOKUP = {'unsaved': 'g', 'saved': 's', 'local': 'l', 'line': 'i'}
+
+
+@dataclasses.dataclass
+class GeneratorFlags:
+    indent_size: int
+    literal_shorthand: bool
+    var_shorthand: bool
+    preserve_slots: bool
+    assign_variable: bool
+    include_import: bool
+    build_and_send: bool
+
+
+def item_to_string(class_name: str, i: Item, slot_argument: str):
+    i.nbt.pop('DF_NBT')
+    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})"
+    
+    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: CodeItem) -> 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, slot_argument)
+    
+    if isinstance(arg_item, String):
+        literal = str_literal(arg_item.value)
+        if not has_slot and flags.literal_shorthand:
+            return literal
+        return f"{class_name}({literal}{slot_argument})"
+    
+    if isinstance(arg_item, Text):
+        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}({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})'
+    
+    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)
+        if arg_item.yaw != 0:
+            loc_components.append(arg_item.yaw)
+        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_SCOPE_LOOKUP[arg_item.scope]} {name}'"
+        if arg_item.scope == 'unsaved':
+            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}({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}({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}({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 = [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:
+            param_args.append('optional=True')
+            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={str_literal(arg_item.description)}")
+        if 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):
+        return f'{class_name}({arg_item.x}, {arg_item.y}, {arg_item.z}{slot_argument})'
+
+
+def string_to_python_name(string: str) -> str:
+    """Converts `string` into a valid python identifier."""
+    string = string.strip()
+    if string[0].isnumeric():
+        string = '_' + string
+    return ''.join(c if c.isalnum() else '_' for c in string)
+
+
+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(codeblocks: list[CodeBlock], flags: GeneratorFlags) -> str:
+    indent_level = 0
+    script_lines = []
+    variable_assigned = False
+
+    if flags.include_import:
+        script_lines.append(IMPORT_STATEMENT + '\n')
+        
+    def remove_comma_from_last_line():
+        if script_lines[-1].endswith(','):
+            script_lines[-1] = script_lines[-1][:-1]
+    
+    def get_var_assignment_snippet() -> str:
+        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'
+        else:
+            var_name = first_block_data['block'] + '_' + first_block_data['action']
+        return f'{string_to_python_name(var_name)} = '
+
+
+    for codeblock in codeblocks:
+        # Handle closing brackets
+        if codeblock.type == 'bracket':
+            if codeblock.data['direct'] == 'close':
+                remove_comma_from_last_line()
+                indent_level -= 1
+                add_script_line(flags, script_lines, indent_level, '])')
+            continue
+
+        # Get codeblock function and set the action method
+        function_name = CODEBLOCK_FUNCTION_LOOKUP[codeblock.type]
+        if codeblock.type in NO_ACTION_BLOCKS:
+            function_args = [str_literal(codeblock.action_name)]
+        else:
+            method_data = get_method_name_and_aliases(codeblock.type, codeblock.action_name)
+            if method_data is None:
+                raise PyreException(f'scriptgen: Failed to get method data of {codeblock.action_name}')
+
+            function_name += f'.{method_data[0]}'
+            function_args = []
+
+        # Add variable assignment if necessary
+        var_assignment_snippet = ''
+        if flags.assign_variable and not variable_assigned:
+            var_assignment_snippet = get_var_assignment_snippet()
+            variable_assigned = True
+
+        # Set function or process name if necessary
+        if codeblock.action_name == 'dynamic':
+            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]
+        if codeblock_args:
+            function_args.extend(codeblock_args)
+        
+        sub_action = codeblock.data.get('subAction')
+        
+        # Add tags
+        if codeblock.tags:
+            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)
+            
+            for tag, option in codeblock.tags.items():
+                if default_tags[tag] != option:
+                    tag_param_name = to_valid_identifier(tag.lower())
+                    function_args.append(f"{tag_param_name}='{option}'")
+        
+        # Add sub-action for repeat and select object
+        if sub_action is not None:
+            function_args.append(f"sub_action='{sub_action}'")
+        
+        # Add target if necessary
+        if codeblock.type in TARGET_CODEBLOCKS and codeblock.target.name != 'SELECTION':
+            function_args.append(f'target=Target.{codeblock.target.name}')
+        
+        codeblock_attribute = codeblock.data.get('attribute')
+        # Add inversion for NOT
+        if codeblock_attribute == 'NOT':
+            function_args.append('inverted=True')
+        
+        # Add LS Cancel
+        elif codeblock_attribute == 'LS-CANCEL':
+            function_args.append('ls_cancel=True')
+
+        # Create and add the line
+        if codeblock.type in CONTAINER_CODEBLOCKS:
+            if codeblock.type == 'else':
+                line = f'{function_name}(['
+            elif codeblock.type in EVENT_CODEBLOCKS and codeblock_attribute is None:
+                line = f'{var_assignment_snippet}{function_name}(['  # omit `codeblocks=` when we don't need it
+            else:
+                joined_args = ', '.join(function_args) + ', ' if function_args else ''
+                line = f'{var_assignment_snippet}{function_name}({joined_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)
+    
+    remove_comma_from_last_line()
+    indent_level -= 1
+    add_script_line(flags, script_lines, indent_level, '])')  # add final closing brackets
+
+    # Add `.build_and_send()` if necessary
+    if flags.build_and_send:
+        script_lines[-1] += '.build_and_send()'
+    
+    return '\n'.join(script_lines)