dfpyre 0.4.6__py3-none-any.whl → 0.8.1__py3-none-any.whl

dfpyre/scriptgen.py

@@ -0,0 +1,193 @@
+import dataclasses
+import re
+from dfpyre.items import *
+from dfpyre.actiondump import get_default_tags
+
+
+SCRIPT_START = '''from dfpyre import *\n\n'''
+
+TEMPLATE_FUNCTION_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'}
+CONTAINER_CODEBLOCKS = {'event', 'entity_event', 'func', 'process', 'if_player', 'if_entity', 'if_game', 'if_var', 'else', 'repeat'}
+VAR_SCOPES = {'unsaved': 'g', 'saved': 's', 'local': 'l', 'line': 'i'}
+
+
+@dataclasses.dataclass
+class GeneratorFlags:
+    indent_size: int
+    literal_shorthand: bool
+    var_shorthand: bool
+
+
+def item_to_string(class_name: str, i: Item):
+    i.nbt.data.pop('~DF_NBT', None)
+    stripped_id = i.get_id().replace('minecraft:', '')
+    if i.nbt.key_set() == {'~id', '~count'}:
+        if i.get_count() == 1:
+            return f'{class_name}("{stripped_id}")'
+        return f'{class_name}("{stripped_id}", {i.get_count()})'
+    return f'{class_name}.from_nbt("""{i.get_nbt()}""")'
+
+
+def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
+    class_name = arg_item.__class__.__name__
+    if isinstance(arg_item, Item):
+        return item_to_string(class_name, arg_item)
+    
+    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, Number):
+        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, 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)})'
+    
+    if isinstance(arg_item, Variable):
+        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):
+        if arg_item.target == 'Default':
+            return f'{class_name}("{arg_item.name}")'
+        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(flags, 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 = []
+
+    def remove_comma_from_last_line():
+        script_lines[-1] = script_lines[-1][:-1]
+
+    for codeblock in template.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 start its arguments with the action
+        function_name = TEMPLATE_FUNCTION_LOOKUP[codeblock.type]
+        function_args = [f'"{codeblock.action_name}"']
+
+        # Set function or process name if necessary
+        if codeblock.action_name == 'dynamic':
+            function_args[0] = f'"{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)
+        
+        # Add target if necessary
+        if function_name in TARGET_CODEBLOCKS and codeblock.target.name != 'SELECTION':
+            function_args.append(f'target=Target.{codeblock.target.name}')
+        
+        # Add tags
+        if codeblock.tags:
+            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')
+
+        if codeblock.type in CONTAINER_CODEBLOCKS:
+            if codeblock.type == 'else':
+                line = f'{function_name}(['
+            elif codeblock.type in {'event', 'entity_event'}:
+                line = f'{function_name}({", ".join(function_args)}, ['  # omit `codeblocks=` when we don't need it
+            else:
+                line = f'{function_name}({", ".join(function_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
+    return SCRIPT_START + '\n'.join(script_lines)

dfpyre/style.py

@@ -1,22 +1,22 @@
 import re
 from mcitemlib.style import STYLE_CODE_REGEX, FORMAT_CODES, StyledString
 
-def isAmpersandCoded(s: str) -> bool:
+def is_ampersand_coded(s: str) -> bool:
     return bool(re.match(STYLE_CODE_REGEX, s))
 
 
-def ampersandToMinimessage(ampersand_code: str) -> str:
+def ampersand_to_minimessage(ampersand_code: str) -> str:
     ampersand_code = ampersand_code.replace('&r', '<reset>')  # bad but should work most of the time
-    styledString = StyledString.from_codes(ampersand_code)
-    formattedStringList = []
-    for substring in styledString.substrings:
-        formattedSubstringList = []
-        for styleType, value in substring.data.items():
-            if styleType in FORMAT_CODES.values() and value:
-                formattedSubstringList.append(f'<{styleType}>')
-            if styleType == 'color':
-                formattedSubstringList.append(f'<{value}>')
+    styled_string = StyledString.from_codes(ampersand_code)
+    formatted_string_list = []
+    for substring in styled_string.substrings:
+        formatted_substring_list = []
+        for style_type, value in substring.data.items():
+            if style_type in FORMAT_CODES.values() and value:
+                formatted_substring_list.append(f'<{style_type}>')
+            if style_type == 'color':
+                formatted_substring_list.append(f'<{value}>')
         
-        formattedSubstringList.append(substring.data['text'])
-        formattedStringList.append(''.join(formattedSubstringList))
-    return ''.join(formattedStringList)
+        formatted_substring_list.append(substring.data['text'])
+        formatted_string_list.append(''.join(formatted_substring_list))
+    return ''.join(formatted_string_list)

dfpyre/util.py

@@ -0,0 +1,39 @@
+import base64
+import gzip
+
+
+COL_WARN = '\x1b[33m'
+COL_RESET = '\x1b[0m'
+COL_SUCCESS = '\x1b[32m'
+COL_ERROR = '\x1b[31m'
+
+
+class PyreException(Exception):
+    pass
+
+
+def warn(message: str):
+    print(f'{COL_WARN}! WARNING ! {message}{COL_RESET}')
+
+
+def df_encode(json_string: str) -> str:
+    """
+    Encodes a stringified json.
+    """
+    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 flatten(nested_list: list):
+    """
+    Flattens a list.
+    """
+    for item in nested_list:
+        if isinstance(item, list):
+            yield from flatten(item)
+        else:
+            yield item

{dfpyre-0.4.6.dist-info → dfpyre-0.8.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