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

dfpyre/__init__.py

@@ -1 +1,3 @@
-from dfpyre.pyre import *
+from dfpyre.core.template import *
+from dfpyre.export.action_classes import *
+from dfpyre.export.block_functions import *

dfpyre/core/actiondump.py

@@ -0,0 +1,277 @@
+import os
+import json
+from typing import Literal
+from dataclasses import dataclass
+from dfpyre.util.util import warn
+
+
+ACTIONDUMP_PATH = os.path.join(os.path.dirname(__file__), '../data/actiondump_min.json')
+DEPRECATED_ACTIONS_PATH = os.path.join(os.path.dirname(__file__), '../data/deprecated_actions.json')
+
+CODEBLOCK_ID_LOOKUP = {
+    'PLAYER ACTION': 'player_action',
+    'ENTITY ACTION': 'entity_action',
+    'GAME ACTION': 'game_action',
+    'SET VARIABLE': 'set_var',
+    'IF PLAYER': 'if_player',
+    'IF ENTITY': 'if_entity',
+    'IF GAME': 'if_game',
+    'IF VARIABLE': 'if_var',
+    'REPEAT': 'repeat',
+    'SELECT OBJECT': 'select_obj',
+    'CONTROL': 'control',
+    'PLAYER EVENT': 'event',
+    'ENTITY EVENT': 'entity_event',
+    'FUNCTION': 'func',
+    'CALL FUNCTION': 'call_func',
+    'PROCESS': 'process',
+    'START PROCESS': 'start_process',
+}
+
+
+VariableType = Literal['VARIABLE', 'NUMBER', 'TEXT', 'COMPONENT', 'ANY_TYPE', 'DICT', 'LIST', 'LOCATION', 'NONE', 'SOUND', 'PARTICLE', 'VECTOR', 'POTION', 'ITEM']
+
+
+@dataclass
+class CodeblockDataEntry:
+    name: str
+    id: str
+    description: str
+    examples: list[str]
+
+
+@dataclass
+class TagOption:
+    name: str
+    description: str | None
+
+
+@dataclass
+class ActionTag:
+    name: str
+    options: list[TagOption]
+    default: str
+    slot: int
+
+
+@dataclass
+class ActionArgument:
+    type: VariableType
+    plural: bool
+    optional: bool
+    description: str | None
+    notes: str | None
+
+
+@dataclass
+class ActionDataEntry:
+    tags: list[ActionTag]
+    required_rank: Literal['None', 'Noble', 'Emperor', 'Mythic', 'Overlord']
+    arguments: list[tuple[ActionArgument, ...]]
+    return_values: list[VariableType]
+    description: str | None
+    is_deprecated: bool
+    deprecated_note: str | None
+
+
+@dataclass
+class ActiondumpResult:
+    codeblock_data: dict[str, CodeblockDataEntry]
+    action_data: dict[str, dict[str, ActionDataEntry]]
+    game_values: dict[str, VariableType]
+    sound_names: list[str]
+    potion_names: list[str]
+
+
+def get_action_tags(action_data: dict) -> list[ActionTag]:
+    action_tags = []
+    for tag_data in action_data['tags']:
+        options: list[TagOption] = []
+        for option in tag_data['options']:
+            option_desc = option['icon']['description']
+            if option_desc:
+                option_desc = ' '.join(option_desc)
+            else:
+                option_desc = None
+            options.append(TagOption(name=option['name'], description=option_desc))
+        
+        converted_tag = ActionTag(
+            name=tag_data['name'],
+            options=options,
+            default=tag_data['defaultOption'],
+            slot=tag_data['slot']
+        )
+        action_tags.append(converted_tag)
+    return action_tags
+
+
+def get_action_args(action_data: dict) -> list[ActionArgument]:
+    icon = action_data['icon']
+    if 'arguments' not in icon:
+        return []
+    
+    parsed_arguments: list[ActionArgument] = []
+    argument_union_list: list[ActionArgument] = []
+    add_to_union = False
+    arguments = icon['arguments']
+    for arg_data in arguments:
+        if 'type' not in arg_data:
+            if arg_data.get('text') == 'OR':
+                add_to_union = True
+            continue
+
+        if argument_union_list and not add_to_union:
+            parsed_arguments.append(tuple(argument_union_list))
+            argument_union_list = []
+        
+        arg_description = arg_data['description']
+        if arg_description:
+            arg_description = ' '.join(arg_description)
+        else:
+            arg_description = None
+        
+        arg_notes = arg_data['notes']
+        if arg_notes:
+            arg_notes = ' '.join(arg_notes[0])
+        else:
+            arg_notes = None
+
+        argument_union_list.append(ActionArgument(
+            type=arg_data['type'],
+            plural=arg_data['plural'],
+            optional=arg_data['optional'],
+            description=arg_description,
+            notes=arg_notes
+        ))
+        add_to_union = False
+    
+    if argument_union_list:
+        parsed_arguments.append(tuple(argument_union_list))
+    
+    return parsed_arguments
+
+
+def get_action_return_values(action_data: dict) -> list[VariableType]:
+    icon = action_data['icon']
+    if 'arguments' not in icon:
+        return []
+    
+    parsed_return_values: list[VariableType] = []
+    return_values = icon['returnValues']
+    for value_data in return_values:
+        if 'type' not in value_data:
+            continue
+        parsed_return_values.append(value_data['type'])
+
+    return parsed_return_values
+
+
+def parse_codeblock_data(raw_codeblock_data: list[dict]) -> dict[str, CodeblockDataEntry]:
+    parsed_data: dict[str, CodeblockDataEntry] = {}
+    for raw_data in raw_codeblock_data:
+        identifier = raw_data['identifier']
+        description = ' '.join(raw_data['item']['description'])
+        parsed_codeblock = CodeblockDataEntry(
+            name=raw_data['name'],
+            id=identifier,
+            description=description,
+            examples=raw_data['item']['example']
+        )
+        parsed_data[identifier] = parsed_codeblock
+    
+    return parsed_data
+
+
+def parse_action_data(raw_action_data: list[dict]):
+    all_action_data = {n: {} for n in CODEBLOCK_ID_LOOKUP.values()}
+    all_action_data['else'] = dict()
+
+    with open(DEPRECATED_ACTIONS_PATH, 'r', encoding='utf-8') as f:
+        all_deprecated_actions: dict = json.loads(f.read())
+
+    for action_data in raw_action_data:
+        action_tags = get_action_tags(action_data)
+        
+        required_rank = action_data['icon']['requiredRank']
+        
+        action_arguments = get_action_args(action_data)
+        action_return_values = get_action_return_values(action_data)
+
+        action_description = action_data['icon']['description']
+        if action_description:
+            action_description = ' '.join(action_description)
+        else:
+            action_description = None
+        
+        dep_note = action_data['icon']['deprecatedNote']
+        if dep_note:
+            dep_note = ' '.join(dep_note)
+        else:
+            dep_note = None
+        
+        codeblock_type = CODEBLOCK_ID_LOOKUP[action_data['codeblockName']]
+
+        deprecated_actions = all_deprecated_actions.get(codeblock_type) or {}
+        action_name = action_data['name']
+        is_deprecated = action_name in deprecated_actions
+        
+        parsed_action_data = ActionDataEntry(
+            tags=action_tags,
+            required_rank=required_rank,
+            arguments=action_arguments,
+            return_values=action_return_values,
+            description=action_description,
+            is_deprecated=is_deprecated,
+            deprecated_note=dep_note
+        )
+        all_action_data[codeblock_type][action_name] = parsed_action_data
+    
+    return all_action_data
+
+
+def parse_actiondump() -> ActiondumpResult:
+    if not os.path.isfile(ACTIONDUMP_PATH):
+        warn('Actiondump not found -- Item tags and error checking will not work.')
+        return ActiondumpResult(codeblock_data={}, action_data={}, game_values=[], sound_names=[], potion_names=[])
+    
+    with open(ACTIONDUMP_PATH, 'r', encoding='utf-8') as f:
+        actiondump: dict = json.loads(f.read())
+
+    codeblock_data = parse_codeblock_data(actiondump['codeblocks'])
+    all_action_data = parse_action_data(actiondump['actions'])
+        
+    game_values: dict[str, VariableType] = {}
+    for game_value in actiondump['gameValues']:
+        icon = game_value['icon']
+        game_values[icon['name']] = icon['returnType']
+
+    sound_names: list[str] = []
+    for sound in actiondump['sounds']:
+        sound_names.append(sound['icon']['name'])
+    
+    potion_names: list[str] = []
+    for potion in actiondump['potions']:
+        potion_names.append(potion['icon']['name'])
+    
+    return ActiondumpResult(
+        codeblock_data=codeblock_data,
+        action_data=all_action_data,
+        game_values=game_values,
+        sound_names=sound_names,
+        potion_names=potion_names
+    )
+
+
+ACTIONDUMP = parse_actiondump()
+ACTION_DATA = ACTIONDUMP.action_data
+
+
+def get_default_tags(codeblock_type: str|None, codeblock_action: str|None) -> dict[str, str]:
+    if not codeblock_type or not codeblock_action:
+        return {}
+    if codeblock_type not in ACTION_DATA:
+        return {}
+    if codeblock_action not in ACTION_DATA[codeblock_type]:
+        return {}
+    
+    return {t.name: t.default for t in ACTION_DATA[codeblock_type][codeblock_action].tags}

dfpyre/core/codeblock.py

@@ -0,0 +1,207 @@
+from typing import Literal
+from enum import Enum
+from difflib import get_close_matches
+from dfpyre.util.util import warn, flatten
+from dfpyre.core.items import convert_literals
+from dfpyre.core.actiondump import ACTION_DATA, ActionTag
+
+
+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'}
+EVENT_CODEBLOCKS = {'event', 'entity_event'}
+CONDITIONAL_CODEBLOCKS = {'if_player', 'if_var', 'if_game', 'if_entity'}
+TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
+TARGETS = ['Selection', 'Default', 'Killer', 'Damager', 'Shooter', 'Victim', 'AllPlayers', 'Projectile', 'AllEntities', 'AllMobs', 'LastEntity']
+
+
+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 _warn_unrecognized_name(codeblock_type: str, codeblock_name: str):
+    close = get_close_matches(codeblock_name, ACTION_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[ActionTag], 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_lookup = {t.name: t for t in tags}
+
+    for name, option in applied_tags.items():
+        option_strings = [o.name for o in tags_lookup[name].options]
+
+        if name not in tags_lookup:
+            tag_names_joined = '\n'.join(map(lambda s: '    - '+s, tags_lookup.keys()))
+            warn(f'Tag "{name}" does not exist for action "{codeblock_name}". Available tags:\n{tag_names_joined}')
+        elif option not in option_strings:
+            options_joined = '\n'.join(map(lambda s: '    - '+s, option_strings))
+            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[ActionTag], 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 = ACTION_DATA[codeblock_type][codeblock_name]
+    if action_data.is_deprecated:
+        warn(f'Action "{codeblock_name}" is deprecated: {action_data.deprecated_note}')
+    tags = action_data.tags
+    return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name, applied_tags)
+
+
+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 = [convert_literals(a) for a in flatten(args) if a is not None]
+        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":
+        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":
+        return cls(codeblock_type, 'dynamic', args=args, data={'id': 'block', 'block': codeblock_type, 'data': data_value}, tags=tags)
+
+    @classmethod
+    def new_event(cls, codeblock_type: str, action_name: str, ls_cancel: bool):
+        data = {'id': 'block', 'block': codeblock_type, 'action': action_name}
+        if ls_cancel:
+            data['attribute'] = 'LS-CANCEL'
+        return cls(codeblock_type, action_name, data=data)
+
+    @classmethod
+    def new_conditional(cls, codeblock_type: str, action_name: str, args: tuple, tags: dict[str, str], inverted: bool, target: Target=DEFAULT_TARGET) -> "CodeBlock":
+        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_subaction_block(cls, codeblock_type: str, action_name: str, args: tuple, tags: dict[str, str], sub_action: str|None, inverted: bool) -> "CodeBlock":
+        data = {'id': 'block', 'block': codeblock_type, 'action': action_name}
+        if sub_action is not None:
+            data['subAction'] = sub_action
+            if inverted:
+                data['attribute'] = 'NOT'
+        return cls(codeblock_type, 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 get_length(self) -> int:
+        """
+        Returns the width of this codeblock in Minecraft blocks.
+        """
+        if self.type in CONDITIONAL_CODEBLOCKS or self.type in {'repeat', 'else'}:
+            return 1
+        if self.type == 'bracket' and self.data['direct'] == 'open':
+            return 1
+        return 2
+
+
+    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 ACTION_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