dfpyre 0.8.5__tar.gz → 0.8.7__tar.gz

{dfpyre-0.8.5 → dfpyre-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dfpyre
-Version: 0.8.5
+Version: 0.8.7
 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.3.4,<0.4.0)
+Requires-Dist: mcitemlib (>=0.4.1,<0.5.0)
 Project-URL: Repository, https://github.com/Amp63/pyre
 Description-Content-Type: text/markdown
 

{dfpyre-0.8.5 → dfpyre-0.8.7}/dfpyre/items.py

@@ -5,15 +5,19 @@ Class definitions for code items.
 from enum import Enum
 import re
 from typing import Literal, Any
-from dfpyre.style import is_ampersand_coded, ampersand_to_minimessage
-from dfpyre.util import PyreException, warn
+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_WARN, COL_ERROR, COL_RESET
 
 
 NUMBER_REGEX = r'^-?\d*\.?\d+$'
 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):
     if type(arg) in {int, float}:
@@ -38,12 +42,13 @@ class String:
     """
     type = 'txt'
 
-    def __init__(self, value: str):
+    def __init__(self, value: str, slot: int|None=None):
         self.value = value
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type, "data": {"name": self.value}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
     
     def __repr__(self) -> str:
@@ -58,14 +63,15 @@ class Text:
     """
     type = 'comp'
 
-    def __init__(self, value: str):
+    def __init__(self, value: str, slot: int|None=None):
         if is_ampersand_coded(value):
             value = ampersand_to_minimessage(value)
         self.value = value
+        self.slot = slot
     
     def format(self, slot: int|None):
       formatted_dict = {"item": {"id": self.type, "data": {"name": self.value}}}
-      _add_slot(formatted_dict, slot)
+      _add_slot(formatted_dict, self.slot or slot)
       return formatted_dict
 
     def __repr__(self) -> str:
@@ -78,12 +84,13 @@ class Number:
     """
     type = 'num'
 
-    def __init__(self, num: int|float|str):
+    def __init__(self, num: int|float|str, slot: int|None=None):
         self.value = num
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type, "data": {"name": str(self.value)}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -98,9 +105,13 @@ class Item(NbtItem):
     """
     type = 'item'
 
+    def __init__(self, item_id: str, count: int=1, slot: int | None=None):
+        super().__init__(item_id, count)
+        self.slot = slot
+
     def format(self, slot: int|None):
-        formatted_dict = {"item": {"id": self.type, "data": {"item": self.get_nbt()}}}
-        _add_slot(formatted_dict, slot)
+        formatted_dict = {"item": {"id": self.type, "data": {"item": self.get_snbt()}}}
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -111,50 +122,87 @@ class Item(NbtItem):
         Add a DiamondFire custom tag to this item.
         """
         if isinstance(tag_value, String):
-            tag_value = tag_value.value
+            tag = StringTag(tag_value.value)
+        elif isinstance(tag_value, str):
+            tag = StringTag(tag_value)
         elif isinstance(tag_value, Number):
-            tag_value = float(tag_value.value)
-        elif isinstance(tag_value, int):
-            tag_value = float(tag_value)
+            tag = DoubleTag(float(tag_value.value))
+        elif isinstance(tag_value, (int, float)):
+            tag = DoubleTag(float(tag_value))
         
         try:
-            item_tags = self.get_custom_data('PublicBukkitValues')
+            custom_data_tag = self.get_component('minecraft:custom_data')
+            if 'PublicBukkitValues' in custom_data_tag:
+                pbv_tag = custom_data_tag['PublicBukkitValues']
+            else:
+                pbv_tag = CompoundTag()
         except MCItemlibException:
-            item_tags = {}
+            custom_data_tag = CompoundTag()
+            pbv_tag = CompoundTag()
         
-        item_tags[f'hypercube:{tag_name}'] = tag_value
-        self.set_custom_data('PublicBukkitValues', item_tags)
+        custom_data_tag['PublicBukkitValues'] = pbv_tag
+        
+        pbv_tag[f'hypercube:{tag_name}'] = tag
+        self.set_component('minecraft:custom_data', custom_data_tag)
     
     def get_tag(self, tag_name: str) -> str|float|None:
         """
         Get a DiamondFire custom tag from this item.
         """
         try:
-            item_tags = self.get_custom_data('PublicBukkitValues')
+            custom_data_tag = self.get_component('minecraft:custom_data')
         except MCItemlibException:
             return None
         
-        try:
-            return item_tags[f'hypercube:{tag_name}']
-        except KeyError:
+        if 'PublicBukkitValues' not in custom_data_tag:
             return None
+        
+        pbv_tag = custom_data_tag['PublicBukkitValues']
+        df_tag_value = pbv_tag.get(f'hypercube:{tag_name}')
+        if df_tag_value is None:
+            return None
+        
+        if isinstance(df_tag_value, DoubleTag):
+            return float(df_tag_value)
+        if isinstance(df_tag_value, StringTag):
+            return str(df_tag_value)
     
-    def remove_tag(self, tag_name: str) -> bool:
+    def remove_tag(self, tag_name: str):
         """
         Remove a DiamondFire custom tag from this item.
-
-        :return: `True` on success, `False` on fail
         """
-        try:
-            item_tags = self.get_custom_data('PublicBukkitValues')
-        except MCItemlibException:
-            return False
+        custom_data_tag = self.get_component('minecraft:custom_data')
+        pbv_tag = custom_data_tag['PublicBukkitValues']
+        del pbv_tag[f'hypercube:{tag_name}']
 
+        return True
+    
+    def send_to_minecraft(self):
+        """
+        Sends this item to Minecraft automatically.
+        """
         try:
-            del item_tags[f'hypercube:{tag_name}']
-            return True
-        except KeyError:
-            return False
+            ws = websocket.WebSocket()
+            ws.connect(CODECLIENT_URL)
+            print(f'{COL_SUCCESS}Connected.{COL_RESET}')
+
+            command = f'give {self.get_snbt()}'
+            ws.send(command)
+            ws.close()
+
+            print(f'{COL_SUCCESS}Item sent to client successfully.{COL_RESET}')
+            return 0
+            
+        except Exception as e:
+            if isinstance(e, ConnectionRefusedError):
+                print(f'{COL_ERROR}Could not connect to CodeClient API. Possible problems:')
+                print(f'    - Minecraft is not open')
+                print(f'    - CodeClient is not installed (get it here: https://modrinth.com/mod/codeclient)')
+                print(f'    - CodeClient API is not enabled (enable it in CodeClient general settings){COL_RESET}')
+                return 1
+            
+            print(f'Connection failed: {e}')
+            return 2
 
 
 class Location:
@@ -163,12 +211,13 @@ class Location:
     """
     type = 'loc'
 
-    def __init__(self, x: float=0, y: float=0, z: float=0, pitch: float=0, yaw: float=0):
+    def __init__(self, x: float=0, y: float=0, z: float=0, pitch: float=0, yaw: float=0, slot: int | None=None):
         self.x = float(x)
         self.y = float(y)
         self.z = float(z)
         self.pitch = float(pitch)
         self.yaw = float(yaw)
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict =  {"item": {
@@ -184,7 +233,7 @@ class Location:
                 }
             }
         }}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -199,16 +248,18 @@ class Variable:
     """
     type = 'var'
 
-    def __init__(self, name: str, scope: Literal['unsaved', 'game', 'saved', 'local', 'line']='unsaved'):
+    def __init__(self, name: str, scope: Literal['unsaved', 'game', 'saved', 'local', 'line']='unsaved', slot: int | None=None):
         self.name = name
 
         if scope == 'game':
             scope = 'unsaved'
         self.scope = scope
+        
+        self.slot = slot
 
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type,"data": {"name": self.name, "scope": self.scope}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -223,14 +274,15 @@ class Sound:
     """
     type = 'snd'
 
-    def __init__(self, name: str, pitch: float=1.0, vol: float=2.0):
+    def __init__(self, name: str, pitch: float=1.0, vol: float=2.0, slot: int | None=None):
         self.name = name
         self.pitch = pitch
         self.vol = vol
+        self.slot = slot
 
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type,"data": {"sound": self.name, "pitch": self.pitch, "vol": self.vol}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -244,12 +296,13 @@ class Particle:
     Represents a DiamondFire particle object.
     """
     type = 'part'
-    def __init__(self, particle_data: dict):
+    def __init__(self, particle_data: dict, slot: int | None=None):
         self.particle_data = particle_data
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type, "data": self.particle_data}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -262,14 +315,15 @@ class Potion:
     """
     type = 'pot'
 
-    def __init__(self, name: str, dur: int=1000000, amp: int=0):
+    def __init__(self, name: str, dur: int=1000000, amp: int=0, slot: int | None=None):
         self.name = name
         self.dur = dur
         self.amp = amp
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type,"data": {"pot": self.name, "dur": self.dur, "amp": self.amp}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -284,13 +338,14 @@ class GameValue:
     """
     type = 'g_val'
 
-    def __init__(self, name: str, target: str='Default'):
+    def __init__(self, name: str, target: str='Default', slot: int | None=None):
         self.name = name
         self.target = target
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type, "data": {"type": self.name, "target": self.target}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -303,14 +358,15 @@ class Vector:
     """
     type = 'vec'
 
-    def __init__(self, x: float=0.0, y: float=0.0, z: float=0.0):
+    def __init__(self, x: float=0.0, y: float=0.0, z: float=0.0, slot: int | None=None):
         self.x = float(x)
         self.y = float(y)
         self.z = float(z)
+        self.slot = slot
     
     def format(self, slot: int|None):
         formatted_dict = {"item": {"id": self.type, "data": {"x": self.x, "y": self.y, "z": self.z}}}
-        _add_slot(formatted_dict, slot)
+        _add_slot(formatted_dict, self.slot or slot)
         return formatted_dict
 
     def __repr__(self) -> str:
@@ -319,6 +375,7 @@ class Vector:
 Vec = Vector  # Vector alias
 
 
+
 PARAMETER_TYPE_LOOKUP = ['txt', 'comp', 'num', 'loc', 'vec', 'snd', 'part', 'pot', 'item', 'any', 'var', 'list', 'dict']
 
 class ParameterType(Enum):
@@ -345,7 +402,8 @@ class Parameter:
     """
     type = 'pn_el'
 
-    def __init__(self, name: str, param_type: ParameterType, plural: bool=False, optional: bool=False, description: str="", note: str="", default_value=None):
+    def __init__(self, name: str, param_type: ParameterType, plural: bool=False, optional: bool=False, 
+                 description: str="", note: str="", default_value=None, slot: int | None=None):
         self.name = name
         self.param_type = param_type
         self.plural = plural
@@ -353,7 +411,7 @@ class Parameter:
         self.description = description
         self.note = note
         self.default_value = convert_argument(default_value)
-      
+        self.slot = slot
     
     def format(self, slot: int):
         formatted_dict = {"item": {
@@ -363,9 +421,10 @@ class Parameter:
                 "type": self.param_type.get_string_value(),
                 "plural": self.plural,
                 "optional": self.optional,
-            }},
-            "slot": slot
+            }}
         }
+        _add_slot(formatted_dict, self.slot or slot)
+
         if self.description:
             formatted_dict['item']['data']['description'] = self.description
         if self.note:
@@ -390,7 +449,7 @@ def item_from_dict(item_dict: dict) -> Any:
     item_data = item_dict['data']
 
     if item_id == 'item':
-        return Item.from_nbt(item_data['item'])
+        return Item.from_snbt(item_data['item'])
     
     elif item_id == 'txt':
         return String(item_data['name'])

{dfpyre-0.8.5 → dfpyre-0.8.7}/dfpyre/pyre.py

@@ -8,7 +8,7 @@ import json
 from difflib import get_close_matches
 import datetime
 from enum import Enum
-from mcitemlib.itemlib import Item as NbtItem
+from amulet_nbt import CompoundTag
 from dfpyre.util import *
 from dfpyre.items import *
 from dfpyre.scriptgen import generate_script, GeneratorFlags
@@ -162,7 +162,7 @@ def _check_applied_tags(tags: list[dict], applied_tags: dict[str, str], codebloc
 
 def _reformat_codeblock_tags(tags: list[dict], codeblock_type: str, codeblock_action: str, applied_tags: dict[str, str]):
     """
-    Turns tag objects into DiamondFire formatted tag items
+    Turns tag objects into DiamondFire formatted tag items.
     """
 
     def format_tag(option: str, name: str):
@@ -189,7 +189,7 @@ def _reformat_codeblock_tags(tags: list[dict], codeblock_type: str, codeblock_ac
 
 def _get_codeblock_tags(codeblock_type: str, codeblock_name: str, applied_tags: dict[str, str]):
     """
-    Get tags for the specified codeblock type and name
+    Get tags for the specified codeblock type and name.
     """
     action_data = CODEBLOCK_DATA[codeblock_type][codeblock_name]
     if 'deprecatedNote' in action_data:
@@ -198,10 +198,10 @@ def _get_codeblock_tags(codeblock_type: str, codeblock_name: str, applied_tags:
     return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name, applied_tags)
 
 
-def _get_template_item(template_code: str, name: str, author: str) -> NbtItem:
+def _generate_template_item(template_code: str, name: str, author: str) -> Item:
     now = datetime.datetime.now()
 
-    template_item = NbtItem('yellow_shulker_box')
+    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}',
@@ -211,11 +211,13 @@ def _get_template_item(template_code: str, name: str, author: str) -> NbtItem:
         '&7https://github.com/Amp63/pyre'
     ])
     
-    pbv_tag = {
-        'hypercube:codetemplatedata': f'{{"author":"{author}","name":"{name}","version": 1,"code":"{template_code}"}}',
-        'hypercube:pyre_creation_timestamp': now.timestamp()
-    }
-    template_item.set_custom_data('PublicBukkitValues', pbv_tag, raw=True)
+    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
 
@@ -316,15 +318,15 @@ class DFTemplate:
         return df_encode(json_string)
     
 
-    def build_and_send(self, method: Literal['recode', 'codeclient'], include_tags: bool=True) -> int:
+    def build_and_send(self, include_tags: bool=True) -> 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 = _get_template_item(template_code, self._get_template_name(), self.author)
-        return template_item.send_to_minecraft(method, 'pyre')
+        template_item = _generate_template_item(template_code, self._get_template_name(), self.author)
+        return template_item.send_to_minecraft()
     
     
     def generate_script(self, output_path: str, indent_size: int=4, literal_shorthand: bool=True, var_shorthand: bool=False):

{dfpyre-0.8.5 → dfpyre-0.8.7}/dfpyre/scriptgen.py

@@ -40,13 +40,13 @@ class GeneratorFlags:
 
 
 def item_to_string(class_name: str, i: Item):
-    i.nbt.data.pop('~DF_NBT', None)
+    i.nbt.pop('DF_NBT', None)
     stripped_id = i.get_id().replace('minecraft:', '')
-    if i.nbt.key_set() == {'~id', '~count'}:
+    if set(i.nbt.keys()) == {'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()}""")'
+    return f'{class_name}.from_snbt("""{i.get_snbt()}""")'
 
 
 def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
@@ -56,12 +56,12 @@ def argument_item_to_string(flags: GeneratorFlags, arg_item: object) -> str:
     
     if isinstance(arg_item, String):
         value = arg_item.value.replace('\n', '\\n')
+        if flags.literal_shorthand:
+            return f'"{value}"'
         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):

{dfpyre-0.8.5 → dfpyre-0.8.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dfpyre"
-version = "0.8.5"
+version = "0.8.7"
 description = "A package for creating and modifying code templates for the DiamondFire Minecraft server."
 authors = ["Amp"]
 readme = "README.md"
@@ -12,7 +12,7 @@ exclude = ['examples', 'extra']
 
 [tool.poetry.dependencies]
 python = "^3.10"
-mcitemlib = "^0.3.4"
+mcitemlib = "^0.4.1"
 
 
 [build-system]