dfpyre 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

dfpyre/items.py

@@ -4,19 +4,28 @@ Contains class definitions for code items.
 
 from enum import Enum
 import re
-from typing import Literal, Dict, Any
+from typing import Literal, Any
 from dfpyre.style import is_ampersand_coded, ampersand_to_minimessage
+from dfpyre.util import PyreException, warn
 from mcitemlib.itemlib import Item as NbtItem
 
 
 NUMBER_REGEX = r'-?\d*\.?\d+'
+VAR_SHORTHAND_CHAR = '$'
+VAR_SCOPES = {'g': 'unsaved', 's': 'saved', 'l': 'local', 'i': 'line'}
 
 
-class PyreException(Exception):
-    pass
+def convert_argument(arg: Any):
+    if type(arg) in {int, float}:
+        return num(arg)
+    elif isinstance(arg, str):
+        if len(arg) > 2 and arg[0] == VAR_SHORTHAND_CHAR and arg[1] in VAR_SCOPES:
+            return var(arg[2:], VAR_SCOPES[arg[1]])
+        return text(arg)
+    return arg
 
 
-def _add_slot(d: Dict, slot: int|None):
+def _add_slot(d: dict, slot: int|None):
     if slot is not None:
         d['slot'] = slot
 
@@ -32,6 +41,9 @@ class item(NbtItem):
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.get_id()}, {self.get_count()})'
+
 
 class string:
     """
@@ -46,6 +58,9 @@ class string:
         formatted_dict = {"item": {"id": self.type, "data": {"name": self.value}}}
         _add_slot(formatted_dict, slot)
         return formatted_dict
+    
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}("{self.value}")'
 
 
 class text:
@@ -64,6 +79,9 @@ class text:
       _add_slot(formatted_dict, slot)
       return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}("{self.value}")'
+
 
 class num:
     """
@@ -79,6 +97,9 @@ class num:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.value})'
+
 
 class loc:
     """
@@ -110,6 +131,9 @@ class loc:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.x}, {self.y}, {self.z}, {self.pitch}, {self.yaw})'
+
 
 class var:
     """
@@ -126,6 +150,9 @@ class var:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.scope}, "{self.name}")'
+
 
 class sound:
     """
@@ -143,6 +170,9 @@ class sound:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(pitch: {self.pitch}, volume: {self.vol})'
+
 
 class particle:
     """
@@ -157,6 +187,9 @@ class particle:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.particle_data})'
+
 
 class potion:
     """
@@ -174,6 +207,9 @@ class potion:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}(effect: {self.name}, duration: {self.dur}, amplifier: {self.amp})'
+
 
 class gamevalue:
     """
@@ -190,6 +226,9 @@ class gamevalue:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.name}, target: {self.target})'
+
 
 class vector:
     """
@@ -207,6 +246,9 @@ class vector:
         _add_slot(formatted_dict, slot)
         return formatted_dict
 
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self.x}, {self.y}, {self.z})'
+
 
 PARAMETER_TYPE_LOOKUP = ['txt', 'comp', 'num', 'loc', 'vec', 'snd', 'part', 'pot', 'item', 'any', 'var', 'list', 'dict']
 
@@ -241,7 +283,7 @@ class parameter:
         self.optional = optional
         self.description = description
         self.note = note
-        self.default_value = default_value
+        self.default_value = convert_argument(default_value)
       
     
     def format(self, slot: int):
@@ -259,10 +301,19 @@ class parameter:
             formatted_dict['item']['data']['description'] = self.description
         if self.note:
             formatted_dict['item']['data']['note'] = self.note
-        if self.default_value is not None and not self.plural and self.optional:
-            formatted_dict['item']['data']['default_value'] = self.default_value.format(None)['item']
+        if self.default_value is not None:
+            if not self.optional:
+                warn(f'For parameter "{self.name}": Default value cannot be set if optional is False.')
+            elif self.plural:
+                warn(f'For parameter "{self.name}": Default value cannot be set while plural is True.')
+            else:
+                formatted_dict['item']['data']['default_value'] = self.default_value.format(None)['item']
         
         return formatted_dict
+    
+    def __repr__(self) -> str:
+        raw_type = str(self.param_type).partition('.')[2]
+        return f'{self.__class__.__name__}({self.name}, type: {raw_type})'
 
 
 def _some_or(value: Any, none_value: Any):
@@ -274,7 +325,7 @@ def _some_or(value: Any, none_value: Any):
     return value
 
 
-def item_from_dict(item_dict: Dict) -> object:
+def item_from_dict(item_dict: dict) -> object:
     item_id = item_dict['id']
     item_data = item_dict['data']
 

dfpyre/pyre.py

@@ -4,25 +4,18 @@ A package for externally creating code templates for the DiamondFire Minecraft s
 By Amp
 """
 
-import base64
-import gzip
 import json
-import os
 from difflib import get_close_matches
 import datetime
-from typing import Tuple, List, Dict
+from typing import Tuple
 from enum import Enum
 import socket
 from mcitemlib.itemlib import Item as NbtItem
+from dfpyre.util import *
 from dfpyre.items import *
 from dfpyre.scriptgen import generate_script, GeneratorFlags
+from dfpyre.actiondump import CODEBLOCK_DATA, get_default_tags
 
-COL_WARN = '\x1b[33m'
-COL_RESET = '\x1b[0m'
-COL_SUCCESS = '\x1b[32m'
-COL_ERROR = '\x1b[31m'
-
-CODEBLOCK_DATA_PATH = os.path.join(os.path.dirname(__file__), 'data/data.json')
 
 VARIABLE_TYPES = {'txt', 'comp', 'num', 'item', 'loc', 'var', 'snd', 'part', 'pot', 'g_val', 'vec', 'pn_el'}
 TEMPLATE_STARTERS = {'event', 'entity_event', 'func', 'process'}
@@ -31,9 +24,6 @@ SINGLE_NAME_CODEBLOCKS = {'func', 'process', 'call_func', 'start_process', 'else
 TARGETS = ['Selection', 'Default', 'Killer', 'Damager', 'Shooter', 'Victim', 'AllPlayers', 'Projectile', 'AllEntities', 'AllMobs', 'LastEntity']
 TARGET_CODEBLOCKS = {'player_action', 'entity_action', 'if_player', 'if_entity'}
 
-VAR_SHORTHAND_CHAR = '$'
-VAR_SCOPES = {'g': 'unsaved', 's': 'saved', 'l': 'local', 'i': 'line'}
-
 CODECLIENT_URL = 'ws://localhost:31375'
 
 
@@ -57,54 +47,59 @@ DEFAULT_TARGET = Target.SELECTION
 
 
 class CodeBlock:
-    def __init__(self, name: str, args: Tuple=(), target: Target=DEFAULT_TARGET, data: Dict={}):
+    def __init__(self, name: str, args: Tuple=(), target: Target=DEFAULT_TARGET, data: dict={}, tags: dict[str, str]={}):
         self.name = name
         self.args = args
         self.target = target
         self.data = data
+        self.tags = tags
     
     def __repr__(self) -> str:
         if self.name in SINGLE_NAME_CODEBLOCKS:
             if self.name == 'else':
                 return 'CodeBlock(else)'
             return f'CodeBlock({self.name}, {self.data["data"]})'
-        elif 'block' in self.data:
+        if 'block' in self.data:
             return f'CodeBlock({self.data["block"]}, {self.name})'
         return f'CodeBlock(bracket, {self.data["type"]}, {self.data["direct"]})'
 
-
-def _warn(message):
-    print(f'{COL_WARN}! WARNING ! {message}{COL_RESET}')
+    def build(self, include_tags: bool=True) -> dict:
+        """
+        Builds a properly formatted block from a CodeBlock object.
+        """
+        built_block = self.data.copy()
+        codeblock_type = self.data.get('block')
+        
+        # add target if necessary ('Selection' is the default when 'target' is blank)
+        if codeblock_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]
+        
+        # check for unrecognized name, add tags
+        if codeblock_type is not None:  # for brackets
+            if self.name not in CODEBLOCK_DATA[codeblock_type]:
+                _warn_unrecognized_name(codeblock_type, self.name)
+            elif include_tags:
+                tags = _get_codeblock_tags(codeblock_type, self.name, self.tags)
+                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
+    
+        # if final_args:
+        built_block['args'] = {'items': final_args}
+        return built_block
 
 
 def _warn_unrecognized_name(codeblock_type: str, codeblock_name: str):
-    close = get_close_matches(codeblock_name, TAGDATA[codeblock_type].keys())
+    close = get_close_matches(codeblock_name, CODEBLOCK_DATA[codeblock_type].keys())
     if close:
-        _warn(f'Code block name "{codeblock_name}" not recognized. Did you mean "{close[0]}"?')
+        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.')
+        warn(f'Code block name "{codeblock_name}" not recognized. Try spell checking or retyping without spaces.')
 
 
-def _load_codeblock_data() -> Tuple:
-    tag_data = {}
-    if os.path.exists(CODEBLOCK_DATA_PATH):
-        with open(CODEBLOCK_DATA_PATH, 'r') as f:
-            tag_data = json.load(f)
-    else:
-        _warn('data.json not found -- Item tags and error checking will not work.')
-        return ({}, set(), set())
-    
-    del tag_data['meta']
-
-    all_names = [x for l in [d.keys() for d in tag_data.values()] for x in l]  # flatten list
-    return (
-        tag_data,
-        set(tag_data['extras'].keys()),
-        set(all_names)
-    )
-
-TAGDATA, TAGDATA_EXTRAS_KEYS, ALL_CODEBLOCK_NAMES = _load_codeblock_data()
-
 def _add_inverted(data, inverted):
     """
     If inverted is true, add 'inverted': 'NOT' to data.
@@ -113,36 +108,48 @@ def _add_inverted(data, inverted):
         data['inverted'] = 'NOT'
 
 
-def _convert_data_types(args):
-    converted_args = []
-    for value in args:
-        if type(value) in {int, float}:
-            converted_args.append(num(value))
-        elif type(value) is str:
-            if len(value) > 2 and value[0] == VAR_SHORTHAND_CHAR and value[1] in VAR_SCOPES:
-                var_object = var(value[2:], VAR_SCOPES[value[1]])
-                converted_args.append(var_object)
-            else:
-                converted_args.append(text(value))
+def _convert_args(args):
+    return tuple(map(convert_argument, args))
+
+
+def _check_applied_tags(tags: list[dict], 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_formatted = {t['name']: t for t in tags}
+    for name, option in applied_tags.items():
+        if name not in tags_formatted:
+            tag_names_joined = '\n'.join(map(lambda s: '    - '+s, tags_formatted.keys()))
+            warn(f'Tag "{name}" does not exist for action "{codeblock_name}". Available tags:\n{tag_names_joined}')
+        elif option not in tags_formatted[name]['options']:
+            options_joined = '\n'.join(map(lambda s: '    - '+s, tags_formatted[name]['options']))
+            warn(f'Tag "{name}" does not have the option "{option}". Available tag options:\n{options_joined}')
         else:
-            converted_args.append(value)
-    return tuple(converted_args)
+            valid_tags[name] = option
+    return valid_tags
 
 
-def _reformat_codeblock_tags(tags, codeblock_type: str, codeblock_name: str):
+def _reformat_codeblock_tags(tags: list[dict], codeblock_type: str, codeblock_name: str, applied_tags: dict[str, str]):
     """
-    Turns data.json tag items into DiamondFire formatted tag items
+    Turns tag objects into DiamondFire formatted tag items
     """
+    
+    valid_applied_tags = _check_applied_tags(tags, applied_tags, codeblock_name)
     reformatted_tags = []
     for tag_item in tags:
-        action_value = codeblock_name if 'action' not in tag_item else tag_item['action']
+        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 = {
             'item': {
                 'id': 'bl_tag',
                 'data': {
-                    'option': tag_item['option'],
-                    'tag': tag_item['tag'],
-                    'action': action_value,
+                    'option': tag_option,
+                    'tag': tag_name,
+                    'action': codeblock_name,
                     'block': codeblock_type
                 }
             },
@@ -152,56 +159,15 @@ def _reformat_codeblock_tags(tags, codeblock_type: str, codeblock_name: str):
     return reformatted_tags
 
 
-def _get_codeblock_tags(codeblock_type: str, codeblock_name: str):
+def _get_codeblock_tags(codeblock_type: str, codeblock_name: str, applied_tags: dict[str, str]):
     """
     Get tags for the specified codeblock type and name
     """
-    tags = None
-    if codeblock_type in TAGDATA_EXTRAS_KEYS:
-        tags = TAGDATA['extras'][codeblock_type]
-    else:
-        tags = TAGDATA[codeblock_type].get(codeblock_name)
-    return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name)
-
-
-def _build_block(codeblock: CodeBlock, include_tags: bool):
-    """
-    Builds a properly formatted block from a CodeBlock object.
-    """
-    built_block = codeblock.data.copy()
-    codeblock_type = codeblock.data.get('block')
-    
-    # add target if necessary ('Selection' is the default when 'target' is blank)
-    if codeblock_type in TARGET_CODEBLOCKS and codeblock.target != DEFAULT_TARGET:
-        built_block['target'] = codeblock.target.get_string_value()
-    
-    # add items into args
-    final_args = [arg.format(slot) for slot, arg in enumerate(codeblock.args) if arg.type in VARIABLE_TYPES]
-    
-    # check for unrecognized name, add tags
-    if codeblock_type is not None:  # for brackets
-        if codeblock_type not in TAGDATA_EXTRAS_KEYS and codeblock.name not in ALL_CODEBLOCK_NAMES:
-            _warn_unrecognized_name(codeblock_type, codeblock.name)
-        elif include_tags:
-            tags = _get_codeblock_tags(codeblock_type, codeblock.name)
-            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
-
-
-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')
+    action_data = CODEBLOCK_DATA[codeblock_type][codeblock_name]
+    if 'deprecatedNote' in action_data:
+        warn(f'Action "{codeblock_name}" is deprecated: {action_data["deprecatedNote"]}')
+    tags = action_data['tags']
+    return _reformat_codeblock_tags(tags, codeblock_type, codeblock_name, applied_tags)
 
 
 def _get_template_item(template_code: str, name: str, author: str) -> NbtItem:
@@ -231,7 +197,7 @@ class DFTemplate:
     Represents a DiamondFire code template.
     """
     def __init__(self, name: str=None, author: str='pyre'):
-        self.codeblocks: List[CodeBlock] = []
+        self.codeblocks: list[CodeBlock] = []
         self.bracket_stack: list[str] = []
         self.name = name
         self.author = author
@@ -246,12 +212,16 @@ class DFTemplate:
         """
         Create a template object from an existing template code.
         """
-        template_dict = json.loads(_df_decode(template_code))
+        template_dict = json.loads(df_decode(template_code))
         template = DFTemplate()
         for block_dict in template_dict['blocks']:
+            block_tags = get_default_tags(block_dict.get('block'), block_dict.get('action'))
             if 'args' in block_dict:
                 args = []
                 for item_dict in block_dict['args']['items']:
+                    if item_dict['item'].get('id') == 'bl_tag':
+                        tag_data = item_dict['item']['data']
+                        block_tags[tag_data['tag']] = tag_data['option']
                     parsed_item = item_from_dict(item_dict['item'])
                     if parsed_item is not None:
                         args.append(parsed_item)
@@ -262,7 +232,11 @@ class DFTemplate:
                 codeblock_name = block_dict['block']
             elif 'action' in block_dict:
                 codeblock_name = block_dict['action']
-            codeblock = CodeBlock(codeblock_name, args, target, block_dict)
+            
+            if codeblock_name == 'bracket' or block_dict['block'] == 'else':
+                codeblock = CodeBlock(codeblock_name, data=block_dict)
+            else:
+                codeblock = CodeBlock(codeblock_name, args, target, block_dict, tags=block_tags)
             template.codeblocks.append(codeblock)
         
         return template
@@ -296,16 +270,16 @@ class DFTemplate:
         :param bool include_tags: If True, include item tags in code blocks. Otherwise omit them.
         :return: String containing encoded template data.
         """
-        template_dict_blocks = [_build_block(codeblock, include_tags) for codeblock in self.codeblocks]
+        template_dict_blocks = [codeblock.build(include_tags) 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:
-            _warn('Template does not start with an event, function, or process.')
+            warn('Template does not start with an event, function, or process.')
 
         self._set_template_name(first_block)
 
         json_string = json.dumps(template_dict, separators=(',', ':'))
-        return _df_encode(json_string)
+        return df_encode(json_string)
     
 
     def build_and_send(self, method: Literal['recode', 'codeclient'], include_tags: bool=True) -> int:
@@ -350,78 +324,79 @@ class DFTemplate:
         self._add_codeblock(cmd, index)
     
 
-    def function(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock('func', args, data={'id': 'block', 'block': 'func', 'data': name})
+    def function(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock('dynamic', args, data={'id': 'block', 'block': 'func', 'data': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def process(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock('process', args, data={'id': 'block', 'block': 'process', 'data': name})
+    def process(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock('dynamic', args, data={'id': 'block', 'block': 'process', 'data': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
     def call_function(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock('call_func', args, data={'id': 'block', 'block': 'call_func', 'data': name})
+        args = _convert_args(args)
+        cmd = CodeBlock('dynamic', args, data={'id': 'block', 'block': 'call_func', 'data': name})
         self._add_codeblock(cmd, index)    
 
-    def start_process(self, name: str, index: int|None=None):
-        cmd = CodeBlock('start_process', data={'id': 'block', 'block': 'start_process', 'data': name})
+
+    def start_process(self, name: str, tags: dict[str, str]={}, index: int|None=None):
+        cmd = CodeBlock('dynamic', data={'id': 'block', 'block': 'start_process', 'data': name}, tags=tags)
         self._add_codeblock(cmd, index)
 
 
-    def player_action(self, name: str, *args, target: Target=DEFAULT_TARGET, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'player_action', 'action': name})
+    def player_action(self, name: str, *args, target: Target=DEFAULT_TARGET, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'player_action', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def game_action(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'game_action', 'action': name})
+    def game_action(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'game_action', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def entity_action(self, name: str, *args, target: Target=DEFAULT_TARGET, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'entity_action', 'action': name})
+    def entity_action(self, name: str, *args, target: Target=DEFAULT_TARGET, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, target=target, data={'id': 'block', 'block': 'entity_action', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def if_player(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False, index: int|None=None):
-        args = _convert_data_types(args)
+    def if_player(self, name: str, *args, target: Target=DEFAULT_TARGET, tags: dict[str, str]={}, inverted: bool=False, index: int|None=None):
+        args = _convert_args(args)
         data = {'id': 'block', 'block': 'if_player', 'action': name}
         _add_inverted(data, inverted)
-        cmd = CodeBlock(name, args, target=target, data=data)
+        cmd = CodeBlock(name, args, target=target, data=data, tags=tags)
         self._add_codeblock(cmd, index)
         self._openbracket(index)
     
 
-    def if_variable(self, name: str, *args, inverted: bool=False, index: int|None=None):
-        args = _convert_data_types(args)
+    def if_variable(self, name: str, *args, tags: dict[str, str]={}, inverted: bool=False, index: int|None=None):
+        args = _convert_args(args)
         data = {'id': 'block', 'block': 'if_var', 'action': name}
         _add_inverted(data, inverted)
-        cmd = CodeBlock(name, args, data=data)
+        cmd = CodeBlock(name, args, data=data, tags=tags)
         self._add_codeblock(cmd, index)
         self._openbracket(index)
     
 
-    def if_game(self, name: str, *args, inverted: bool=False, index: int|None=None):
-        args = _convert_data_types(args)
+    def if_game(self, name: str, *args, tags: dict[str, str]={}, inverted: bool=False, index: int|None=None):
+        args = _convert_args(args)
         data = {'id': 'block', 'block': 'if_game', 'action': name}
         _add_inverted(data, inverted)
-        cmd = CodeBlock(name, args, data=data)
+        cmd = CodeBlock(name, args, data=data, tags=tags)
         self._add_codeblock(cmd, index)
         self._openbracket(index)
     
 
-    def if_entity(self, name: str, *args, target: Target=DEFAULT_TARGET, inverted: bool=False, index: int|None=None):
-        args = _convert_data_types(args)
+    def if_entity(self, name: str, *args, target: Target=DEFAULT_TARGET, tags: dict[str, str]={}, inverted: bool=False, index: int|None=None):
+        args = _convert_args(args)
         data = {'id': 'block', 'block': 'if_entity', 'action': name}
         _add_inverted(data, inverted)
-        cmd = CodeBlock(name, args, target=target, data=data)
+        cmd = CodeBlock(name, args, target=target, data=data, tags=tags)
         self._add_codeblock(cmd, index)
         self._openbracket(index)
 
@@ -432,37 +407,37 @@ class DFTemplate:
         self._openbracket(index)
     
 
-    def repeat(self, name: str, *args, sub_action: str=None, index: int|None=None):
-        args = _convert_data_types(args)
+    def repeat(self, name: str, *args, tags: dict[str, str]={}, sub_action: str=None, index: int|None=None):
+        args = _convert_args(args)
         data = {'id': 'block', 'block': 'repeat', 'action': name}
         if sub_action is not None:
             data['subAction'] = sub_action
-        cmd = CodeBlock(name, args, data=data)
+        cmd = CodeBlock(name, args, data=data, tags=tags)
         self._add_codeblock(cmd, index)
         self._openbracket(index, 'repeat')
 
 
     def bracket(self, *args, index: int|None=None):
-        args = _convert_data_types(args)
+        args = _convert_args(args)
         cmd = CodeBlock('bracket', data={'id': 'bracket', 'direct': 'close', 'type': self.bracket_stack.pop()})
         self._add_codeblock(cmd, index)
     
 
-    def control(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'control', 'action': name})
+    def control(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'control', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def select_object(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'select_obj', 'action': name})
+    def select_object(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'select_obj', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
 
-    def set_variable(self, name: str, *args, index: int|None=None):
-        args = _convert_data_types(args)
-        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'set_var', 'action': name})
+    def set_variable(self, name: str, *args, tags: dict[str, str]={}, index: int|None=None):
+        args = _convert_args(args)
+        cmd = CodeBlock(name, args, data={'id': 'block', 'block': 'set_var', 'action': name}, tags=tags)
         self._add_codeblock(cmd, index)
     
     
@@ -476,6 +451,6 @@ class DFTemplate:
         :param bool var_shorthand: If True, all variables will be written using variable shorthand.
         """
         flags = GeneratorFlags(indent_size, literal_shorthand, var_shorthand)
-        with open(output_path, 'w') as f:
+        with open(output_path, 'w', encoding='utf-8') as f:
             f.write(generate_script(self, flags))