dfpyre 0.8.16__tar.gz → 0.8.18__tar.gz

{dfpyre-0.8.16 → dfpyre-0.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.8.16
+Version: 0.8.18
 Summary: A package for creating and modifying code templates for the DiamondFire Minecraft server.
 Home-page: https://github.com/Amp63/pyre
 License: MIT

{dfpyre-0.8.16 → dfpyre-0.8.18}/dfpyre/items.py

@@ -9,18 +9,26 @@ import websocket
 from mcitemlib.itemlib import Item as NbtItem, MCItemlibException
 from amulet_nbt import DoubleTag, StringTag, CompoundTag
 from dfpyre.style import is_ampersand_coded, ampersand_to_minimessage
-from dfpyre.util import PyreException, warn, COL_SUCCESS, COL_ERROR, COL_RESET
+from dfpyre.util import PyreException, warn, is_number, COL_SUCCESS, COL_ERROR, COL_RESET
 from dfpyre.action_literals import GAME_VALUE_NAME, SOUND_NAME, POTION_NAME
 
 
-NUMBER_REGEX = r'^-?\d*\.?\d+$'
+VAR_ITEM_TYPES = [
+    'String', 'Str', 'Text', 'Number', 'Num', 'Item', 'Location', 'Loc', 
+    'Variable', 'Var', 'Sound', 'Snd', 'Particle', 'Potion', 'Pot', 'GameValue',
+    'Vector', 'Vec', 'ParameterType', 'Parameter'
+]
+
+__all__ = ['convert_literals', 'item_from_dict', 'VAR_ITEM_TYPES'] + VAR_ITEM_TYPES
+
+
 VAR_SHORTHAND_REGEX = r'^\$([gsli]) (.+)$'
 VAR_SCOPES = {'g': 'unsaved', 's': 'saved', 'l': 'local', 'i': 'line'}
 
 CODECLIENT_URL = 'ws://localhost:31375'
 
 
-def convert_argument(arg: Any):
+def convert_literals(arg: Any):
     if type(arg) in {int, float}:
         return Number(arg)
     elif isinstance(arg, str):
@@ -420,7 +428,7 @@ class Parameter:
         self.optional = optional
         self.description = description
         self.note = note
-        self.default_value = convert_argument(default_value)
+        self.default_value = convert_literals(default_value)
         self.slot = slot
     
     def format(self, slot: int):
@@ -473,7 +481,7 @@ class _Tag:
         return f'{self.__class__.__name__}({self.tag_data})'
 
 
-def item_from_dict(item_dict: dict, preserve_item_slots: bool) -> Any:
+def item_from_dict(item_dict: dict, preserve_item_slots: bool):
     item_id = item_dict['item']['id']
     item_data = item_dict['item']['data']
     item_slot = item_dict['slot'] if preserve_item_slots else None
@@ -491,7 +499,7 @@ def item_from_dict(item_dict: dict, preserve_item_slots: bool) -> Any:
     
     elif item_id == 'num':
         num_value = item_data['name']
-        if re.match(NUMBER_REGEX, num_value):
+        if is_number(num_value):
             num_value = float(item_data['name'])
             if num_value % 1 == 0:
                 num_value = int(num_value)

{dfpyre-0.8.16 → dfpyre-0.8.18}/dfpyre/pyre.py

@@ -7,13 +7,20 @@ By Amp
 import json
 from difflib import get_close_matches
 import datetime
+import platform
 from enum import Enum
-from amulet_nbt import CompoundTag
-from dfpyre.util import *
+from amulet_nbt import CompoundTag, StringTag, DoubleTag
+from dfpyre.util import df_encode, df_decode, flatten
 from dfpyre.items import *
-from dfpyre.scriptgen import generate_script, GeneratorFlags
 from dfpyre.actiondump import CODEBLOCK_DATA, get_default_tags
 from dfpyre.action_literals import *
+from dfpyre.scriptgen import generate_script, GeneratorFlags
+
+__all__ = [
+    'Target', 'CodeBlock', 'DFTemplate',
+    'player_event', 'entity_event', 'function', 'process', 'call_function', 'start_process', 'player_action', 'game_action',
+    'entity_action', 'if_player', 'if_variable', 'if_game', 'if_entity', 'else_', 'repeat', 'control', 'select_object', 'set_variable'
+] + VAR_ITEM_TYPES
 
 
 VARIABLE_TYPES = {'txt', 'comp', 'num', 'item', 'loc', 'var', 'snd', 'part', 'pot', 'g_val', 'vec', 'pn_el', 'bl_tag'}
@@ -25,6 +32,8 @@ 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
@@ -46,7 +55,7 @@ DEFAULT_TARGET = Target.SELECTION
 
 
 def _convert_args(args):
-    return tuple(map(convert_argument, args))
+    return tuple(map(convert_literals, args))
 
 
 class CodeBlock:
@@ -106,7 +115,7 @@ class CodeBlock:
         return f'CodeBlock(bracket, {self.data["type"]}, {self.data["direct"]})'
 
 
-    def build(self, include_tags: bool=True) -> dict:
+    def build(self) -> dict:
         """
         Builds a properly formatted block from a CodeBlock object.
         """
@@ -125,16 +134,15 @@ class CodeBlock:
             if self.action_name not in CODEBLOCK_DATA[self.type]:
                 _warn_unrecognized_name(self.type, self.action_name)
             
-            elif include_tags:
-                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
+            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
@@ -205,30 +213,6 @@ def _get_codeblock_tags(codeblock_type: str, codeblock_name: str, applied_tags:
     return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name, applied_tags)
 
 
-def _generate_template_item(template_code: str, name: str, author: str) -> Item:
-    now = datetime.datetime.now()
-
-    template_item = Item('yellow_shulker_box')
-    template_item.set_name(f'&x&f&f&5&c&0&0>> &x&f&f&c&7&0&0{name}')
-    template_item.set_lore([
-        f'&8Author: {author}',
-        f'&8Date: {now.strftime("%Y-%m-%d")}',
-        '',
-        '&7This template was generated by &6pyre&7.',
-        '&7https://github.com/Amp63/pyre'
-    ])
-    
-    custom_data_tag = CompoundTag({
-        'PublicBukkitValues': CompoundTag({
-            'hypercube:codetemplatedata': StringTag(f'{{"author":"{author}","name":"{name}","version": 1,"code":"{template_code}"}}'),
-            'hypercube:pyre_creation_timestamp': DoubleTag(now.timestamp())
-        })
-    })
-    template_item.set_component('minecraft:custom_data', custom_data_tag)
-
-    return template_item
-
-
 class DFTemplate:
     """
     Represents a DiamondFire code template.
@@ -251,12 +235,13 @@ class DFTemplate:
 
 
     @staticmethod
-    def from_code(template_code: str, preserve_item_slots: bool=True):
+    def from_code(template_code: str, preserve_item_slots: bool=True, author: str='pyre'):
         """
         Create a template object from an existing template code.
 
         :param str template_code: The base64 string to create a template from.
         :param bool preserve_item_slots: If True, the positions of items within chests will be saved.
+        :param str author: The author of this template.
         """
         template_dict = json.loads(df_decode(template_code))
         codeblocks: list[CodeBlock] = []
@@ -285,14 +270,41 @@ class DFTemplate:
                 codeblock = CodeBlock.new_action(codeblock_type, block_dict['action'], block_args, block_tags, block_target)
             codeblocks.append(codeblock)
         
-        return DFTemplate(codeblocks)
+        return DFTemplate(codeblocks, author)
+
+
+    def generate_template_item(self) -> Item:
+        template_code = self.build()
+
+        now = datetime.datetime.now()
+        name = self._get_template_name()
+        
+        template_item = Item('yellow_shulker_box')
+        template_item.set_name(f'&x&f&f&5&c&0&0>> &x&f&f&c&7&0&0{name}')
+        template_item.set_lore([
+            f'&8Author: {self.author}',
+            f'&8Date: {now.strftime(DATE_FORMAT_STR)}',
+            '',
+            '&7This template was generated by &6pyre&7.',
+            '&7https://github.com/Amp63/pyre'
+        ])
+        
+        custom_data_tag = CompoundTag({
+            'PublicBukkitValues': CompoundTag({
+                'hypercube:codetemplatedata': StringTag(f'{{"author":"{self.author}","name":"{name}","version": 1,"code":"{template_code}"}}'),
+                'hypercube:pyre_creation_timestamp': DoubleTag(now.timestamp())
+            })
+        })
+        template_item.set_component('minecraft:custom_data', custom_data_tag)
+
+        return template_item
 
     
-    def insert(self, insert_codeblocks: CodeBlock|list[CodeBlock], index: int=-1) -> "DFTemplate":
+    def insert(self, insert_codeblocks: CodeBlock|list[CodeBlock], index: int=-1):
         """
         Insert `insert_codeblocks` into this template at `index`.
 
-        :param CodeBlock|list[CodeBlock] insert_codeblocks: The block(s) to insert
+        :param CodeBlock|list[CodeBlock] insert_codeblocks: The block(s) to insert.
         :param int index: The index to insert at.
         :return: self
         """
@@ -311,14 +323,13 @@ class DFTemplate:
         return self
 
 
-    def build(self, include_tags: bool=True) -> str:
+    def build(self) -> str:
         """
         Build this template.
 
-        :param bool include_tags: If True, include item tags in code blocks. Otherwise omit them.
         :return: String containing encoded template data.
         """
-        template_dict_blocks = [codeblock.build(include_tags) for codeblock in self.codeblocks]
+        template_dict_blocks = [codeblock.build() for codeblock in self.codeblocks]
         template_dict = {'blocks': template_dict_blocks}
         first_block = template_dict_blocks[0]
         if first_block['block'] not in TEMPLATE_STARTERS:
@@ -328,14 +339,11 @@ class DFTemplate:
         return df_encode(json_string)
     
 
-    def build_and_send(self, include_tags: bool=True) -> int:
+    def build_and_send(self) -> int:
         """
         Builds this template and sends it to DiamondFire automatically.
-        
-        :param bool include_tags: If True, include item tags in code blocks. Otherwise omit them.
         """
-        template_code = self.build(include_tags)
-        template_item = _generate_template_item(template_code, self._get_template_name(), self.author)
+        template_item = self.generate_template_item()
         return template_item.send_to_minecraft()
     
     

{dfpyre-0.8.16 → dfpyre-0.8.18}/dfpyre/scriptgen.py

@@ -1,5 +1,6 @@
 import dataclasses
 import re
+from dfpyre.util import is_number
 from dfpyre.items import *
 from dfpyre.actiondump import get_default_tags
 
@@ -48,9 +49,11 @@ def item_to_string(class_name: str, i: Item, slot_argument: str):
     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})'
-    return f'{class_name}.from_snbt("""{i.get_snbt()}""")'
+            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 argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
@@ -64,16 +67,16 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
     if isinstance(arg_item, String):
         value = arg_item.value.replace('\n', '\\n')
         if not has_slot and flags.literal_shorthand:
-            return f'"{value}"'
-        return f'{class_name}("{value}"{slot_argument})'
+            return f"'{value}'"
+        return f"{class_name}('{value}'{slot_argument})"
     
     if isinstance(arg_item, Text):
         value = arg_item.value.replace('\n', '\\n')
-        return f'{class_name}("{value}"{slot_argument})'
+        return f"{class_name}('{value}'{slot_argument})"
     
     if isinstance(arg_item, Number):
-        if not re.match(NUMBER_REGEX, str(arg_item.value)):
-            return f'{class_name}("{arg_item.value}"{slot_argument})' 
+        if not is_number(str(arg_item.value)):  # Probably a math expression
+            return f"{class_name}('{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})'
@@ -88,28 +91,28 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
     
     if isinstance(arg_item, Variable):
         if not has_slot and flags.var_shorthand:
-            return f'"${VAR_SCOPES[arg_item.scope]} {arg_item.name}"'
+            return f"'${VAR_SCOPES[arg_item.scope]} {arg_item.name}'"
         if arg_item.scope == 'unsaved':
-            return f'{class_name}("{arg_item.name}"{slot_argument})'
-        return f'{class_name}("{arg_item.name}", "{arg_item.scope}"{slot_argument})'
+            return f"{class_name}('{arg_item.name}'{slot_argument})"
+        return f"{class_name}('{arg_item.name}', '{arg_item.scope}'{slot_argument})"
     
     if isinstance(arg_item, Sound):
-        return f'{class_name}("{arg_item.name}", {arg_item.pitch}, {arg_item.vol}{slot_argument})'
+        return f"{class_name}('{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}("{arg_item.name}", {arg_item.dur}, {arg_item.amp}{slot_argument})'
+        return f"{class_name}('{arg_item.name}', {arg_item.dur}, {arg_item.amp}{slot_argument})"
     
     if isinstance(arg_item, GameValue):
         if arg_item.target == 'Default':
-            return f'{class_name}("{arg_item.name}"{slot_argument})'
-        return f'{class_name}("{arg_item.name}", "{arg_item.target}"{slot_argument})'
+            return f"{class_name}('{arg_item.name}'{slot_argument})"
+        return f"{class_name}('{arg_item.name}', '{arg_item.target}'{slot_argument})"
     
     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}']
+        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:
@@ -117,9 +120,9 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
             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}"')
+            param_args.append(f"description='{arg_item.description}'")
         if arg_item.note:
-            param_args.append(f'note="{arg_item.note}"')
+            param_args.append(f"note='{arg_item.note}'")
         return f'{class_name}({", ".join(param_args)}{slot_argument})'
     
     if isinstance(arg_item, Vector):
@@ -173,7 +176,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
 
         # Get codeblock function and start its arguments with the action
         function_name = TEMPLATE_FUNCTION_LOOKUP[codeblock.type]
-        function_args = [f'"{codeblock.action_name}"']
+        function_args = [f"'{codeblock.action_name}'"]
 
         # Add variable assignment if necessary
         var_assignment_snippet = ''
@@ -183,7 +186,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
 
         # Set function or process name if necessary
         if codeblock.action_name == 'dynamic':
-            function_args[0] = f'"{codeblock.data["data"]}"'
+            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]
@@ -203,7 +206,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
         
         # Add sub-action for repeat
         if codeblock.data.get('subAction'):
-            function_args.append(f'sub_action="{codeblock.data["subAction"]}"')
+            function_args.append(f"sub_action='{codeblock.data["subAction"]}'")
         
         # Add inversion for NOT
         if codeblock.data.get('attribute') == 'NOT':
@@ -214,7 +217,7 @@ def generate_script(template, flags: GeneratorFlags) -> str:
             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
+                line = f'{var_assignment_snippet}{function_name}({", ".join(function_args)}, ['  # omit `codeblocks=` when we don't need it
             else:
                 line = f'{var_assignment_snippet}{function_name}({", ".join(function_args)}, codeblocks=['
             add_script_line(flags, script_lines, indent_level, line, False)

{dfpyre-0.8.16 → dfpyre-0.8.18}/dfpyre/util.py

@@ -1,5 +1,6 @@
 import base64
 import gzip
+import re
 
 
 COL_WARN = '\x1b[33m'
@@ -7,6 +8,8 @@ COL_RESET = '\x1b[0m'
 COL_SUCCESS = '\x1b[32m'
 COL_ERROR = '\x1b[31m'
 
+NUMBER_REGEX = re.compile(r'^-?\d*\.?\d+$')
+
 
 class PyreException(Exception):
     pass
@@ -16,6 +19,10 @@ def warn(message: str):
     print(f'{COL_WARN}! WARNING ! {message}{COL_RESET}')
 
 
+def is_number(s: str) -> bool:
+    return bool(NUMBER_REGEX.match(s))
+
+
 def df_encode(json_string: str) -> str:
     """
     Encodes a stringified json.

{dfpyre-0.8.16 → dfpyre-0.8.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfpyre"
-version = "0.8.16"
+version = "0.8.18"
 description = "A package for creating and modifying code templates for the DiamondFire Minecraft server."
 authors = ["Amp"]
 readme = "README.md"