flaremc 0.2.0__tar.gz → 0.2.2__tar.gz

{flaremc-0.2.0 → flaremc-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flaremc
-Version: 0.2.0
+Version: 0.2.2
 Summary: Flare datapack compiler framework
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{flaremc-0.2.0 → flaremc-0.2.2}/flare/__init__.py

@@ -1,7 +1,7 @@
 from .compiler import _flatten_and, _eval_to_bool_score, _compile_relational
 from .context import namespace, export, tick, push_context, runcommand, files, temp_obj, constant_obj, vars_obj, \
-    constants, _flare_assign, _flare_print, dbg, _flare_return
-from .control_flow import _flare_if, _flare_while, _flare_for, _flare_with
+    constants, _flare_assign, _flare_aug_assign, _flare_print, dbg, _flare_return
+from .control_flow import _flare_if, _flare_while, _flare_for, _flare_with, _flare_break, _flare_continue
 from .execute_modifiers import _as, at, positioned, aligned, facing, anchored, rotated, dimension, applyon, on, summon, \
     store, ExecuteChain, StoreExecuteChain
 from .math import round_, floor, ceil

{flaremc-0.2.0 → flaremc-0.2.2}/flare/cli.py

@@ -16,6 +16,8 @@ from watchdog.observers import Observer
 from . import context
 from .preprocessor import FlareTransformer, CallGraphAnalyzer, preprocess_minecraft_commands
 
+build_lock = threading.RLock()
+
 
 def init_project(path: str):
     p = Path(path)
@@ -42,7 +44,7 @@ def init_project(path: str):
     print(f"Created {json_path.absolute()}")
 
 
-def build_datapack(file_path: str):
+def _build_datapack_inner(file_path: str, cli_overrides: dict = None):
     p = Path(file_path).parent
     json_path = p / "flare.json"
 
@@ -50,13 +52,21 @@ def build_datapack(file_path: str):
         with open(json_path, "r") as f:
             config = json.load(f)
     else:
-        config = {"namespace": "flare", "pack_format": 15, "description": "A Flare datapack", "build_dir": "dist"}
+        config = {"namespace": "flare", "pack_format": 15, "description": "A Flare datapack", "build_dir": "dist",
+                  "validation_level": "strict", "minecraft_version": "1.20.4"}
+
+    if cli_overrides:
+        config.update(cli_overrides)
 
     namespace = config.get("namespace", "flare")
     build_dir = Path(config.get("build_dir", "dist"))
     if not build_dir.is_absolute():
         build_dir = p / build_dir
 
+    context.validation_level = config.get("validation_level", "strict")
+    context.minecraft_version = config.get("minecraft_version", "1.20.4")
+    context.nbt_schema_missing = config.get("nbt_schema_missing", "error")
+
     context.reset_context()
     context._current_namespace = namespace
 
@@ -85,11 +95,14 @@ def build_datapack(file_path: str):
 
         global_env = {"__name__": "__main__", "__file__": abs_path}
         exec(
-            "from flare import _flare_assign, _flare_if, _flare_while, _flare_for, _flare_with, runcommand, _flare_return\n"
+            "from flare import _flare_assign, _flare_aug_assign, _flare_if, _flare_while, _flare_for, _flare_with, runcommand, _flare_return, _flare_break, _flare_continue\n"
             "from flare.command_parser import interpolate_command\n"
             "from flare import _flare_print as print, selector, _as, at, positioned, aligned, facing, anchored, rotated, dimension, applyon, on, summon, store\n"
-            "from flare import nbt, score, fixed, nbtintarray, dbg, export, namespace",
-            global_env)
+            "from flare import nbt, score, fixed, tagged, ref, getscore, storage, array, byte, boolean, short, long, double\n"
+            "from flare import nbtbyte, nbtbool, nbtshort, nbtint, nbtlong, nbtfloat, nbtdouble, nbtstr, nbtlist, nbtdict, nbtbytearray, nbtintarray, nbtlongarray\n"
+            "from flare import round_, floor, ceil\n"
+            "from flare.math import *\n"
+            "from flare import dbg, export, namespace, tick", global_env)
 
         exec(compile(tree, abs_path, "exec"), global_env)
         sys.path.pop(0)
@@ -100,6 +113,9 @@ def build_datapack(file_path: str):
 
     new_modules = set(sys.modules.keys()) - old_modules
     watch_files = {os.path.abspath(file_path)}
+    if os.path.exists(p / "flare.json"):
+        watch_files.add(os.path.abspath(p / "flare.json"))
+
     for mod_name in new_modules:
         mod = sys.modules.get(mod_name)
         if mod and getattr(mod, "__file__", None):
@@ -157,6 +173,11 @@ def build_datapack(file_path: str):
     return True, watch_files, build_dir
 
 
+def build_datapack(file_path: str, cli_overrides: dict = None):
+    with build_lock:
+        return _build_datapack_inner(file_path, cli_overrides)
+
+
 class WatcherHandler(FileSystemEventHandler):
     def __init__(self, cli_args, watch_files):
         self.cli_args = cli_args
@@ -195,8 +216,27 @@ def main():
     parser.add_argument("--watch", action="store_true", help="Watch for file changes and rebuild")
     parser.add_argument("--run", nargs="?", const="-1", default=None,
                         help="Run the compiled datapack in mcemu. Optionally specify a timeout in seconds.")
-
-    args = parser.parse_args()
+    parser.add_argument("--nbt-schema-missing", choices=["error", "warning", "ignore"], default="error",
+                        help="Action when indexing an NBT path that does not exist in the attached schema.")
+
+    args, unknown_args = parser.parse_known_args()
+
+    cli_overrides = {}
+    if hasattr(args, 'nbt_schema_missing'):
+        cli_overrides["nbt_schema_missing"] = args.nbt_schema_missing
+    i = 0
+    while i < len(unknown_args):
+        arg = unknown_args[i]
+        if arg.startswith("--"):
+            key = arg[2:].replace("-", "_")
+            if i + 1 < len(unknown_args) and not unknown_args[i + 1].startswith("--"):
+                cli_overrides[key] = unknown_args[i + 1]
+                i += 2
+            else:
+                cli_overrides[key] = True
+                i += 1
+        else:
+            i += 1
 
     is_init = args.target == "init"
     if is_init:
@@ -220,7 +260,7 @@ def main():
         print(f"Error: Target file {file_path} not found.")
         return
 
-    success, watch_files, build_dir = build_datapack(file_path)
+    success, watch_files, build_dir = build_datapack(file_path, cli_overrides)
 
     emu_thread = None
     running = True
@@ -271,7 +311,7 @@ def main():
                         running = False
                         emu_thread.join()
 
-                    success, new_watch_files, build_dir = build_datapack(file_path)
+                    success, new_watch_files, build_dir = build_datapack(file_path, cli_overrides)
 
                     if success and new_watch_files != watch_files:
                         observer.unschedule_all()

{flaremc-0.2.0 → flaremc-0.2.2}/flare/command_parser.py

@@ -74,6 +74,15 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
                     output.append(val.addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
+                elif isinstance(val, dict) and output and output[-1].endswith("**"):
+                    output[-1] = output[-1][:-2]
+                    items = []
+                    for k, v in val.items():
+                        if isinstance(k, str) and not re.match(r'^[a-zA-Z0-9_\-\.]+$', k):
+                            k = json.dumps(k)
+                        v_str = json.dumps(v) if isinstance(v, (str, dict, list)) else str(v)
+                        items.append(f"{k}: {v_str}")
+                    output.append(", ".join(items))
                 else:
                     output.append(str(val))
             elif not is_key and ident in global_vars:
@@ -82,6 +91,15 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
                     output.append(val.addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
+                elif isinstance(val, dict) and output and output[-1].endswith("**"):
+                    output[-1] = output[-1][:-2]
+                    items = []
+                    for k, v in val.items():
+                        if isinstance(k, str) and not re.match(r'^[a-zA-Z0-9_\-\.]+$', k):
+                            k = json.dumps(k)
+                        v_str = json.dumps(v) if isinstance(v, (str, dict, list)) else str(v)
+                        items.append(f"{k}: {v_str}")
+                    output.append(", ".join(items))
                 else:
                     output.append(str(val))
             else:

{flaremc-0.2.0 → flaremc-0.2.2}/flare/compiler.py

@@ -1,7 +1,6 @@
 from . import context as ctx
 from .context import runcommand, temp_obj
-from .types import NBTType
-from .variables import score, nbt, BinaryOp, UnaryOp, getscore
+from .variables import score, BinaryOp, UnaryOp, getscore
 
 
 def _compile_relational(node, invert=False):
@@ -80,22 +79,8 @@ def _eval_to_bool_score(node):
 
 
 def _flatten_and(node, invert=False):
-    if not isinstance(node, (BinaryOp, UnaryOp)):
-        if isinstance(node, nbt) and (node.is_sequence() or node.type == NBTType.String):
-            node = BinaryOp(node.length(), 0, "ne")
-        else:
-            node = BinaryOp(node, 0, "ne")
-    if isinstance(node, UnaryOp) and node.op == "neg":
-        node = BinaryOp(node, 0, "ne")
-    if isinstance(node, UnaryOp) and node.op == "not":
-        return _flatten_and(node.operand, not invert)
-    if isinstance(node, BinaryOp):
-        if node.op == "and" and not invert:
-            return _flatten_and(node.left, invert) + _flatten_and(node.right, invert)
-        if node.op == "or" and invert:
-            return _flatten_and(node.left, invert) + _flatten_and(node.right, invert)
-        if node.op in ("eq", "ne", "lt", "le", "gt", "ge"):
-            return [_compile_relational(node, invert)]
+    if hasattr(node, "__branch__"):
+        return node.__branch__(invert)
 
     dest = _eval_to_bool_score(node)
     keyword = "unless" if invert else "if"

{flaremc-0.2.0 → flaremc-0.2.2}/flare/context.py

@@ -18,11 +18,16 @@ _constant_offset = 0
 _recursive_functions = set()
 _in_recursive_context = False
 return_types = {}
+has_returns = {}
 _logical_func = None
 
+validation_level = "strict"
+minecraft_version = "1.20.4"
+nbt_schema_missing = "error"
+
 
 def reset_context():
-    global files, current_file, _current_namespace, functions, constants, _temp_id, _func_id, _objective_offset, _constant_offset
+    global files, current_file, _current_namespace, functions, constants, _temp_id, _func_id, _objective_offset, _constant_offset, validation_level, minecraft_version, nbt_schema_missing, _recursive_functions, _in_recursive_context, return_types, _logical_func
     files = {"main": []}
     current_file = "main"
     _current_namespace = "flare"
@@ -91,13 +96,22 @@ def namespace(name: str):
     _current_namespace = name
 
 
-def __float_prec(x: float) -> int:
-    return len(str(x).split(".")[-1])
+from .validator import validate_command, FlareCommandValidationError
 
 
 def runcommand(command: str, local_vars=None, global_vars=None):
     if local_vars is not None and global_vars is not None:
         command = interpolate_command(command, local_vars, global_vars)
+
+    if validation_level != "none":
+        try:
+            validate_command(command, minecraft_version)
+        except FlareCommandValidationError as e:
+            if validation_level == "strict":
+                raise e
+            elif validation_level == "warning":
+                print(f"[Flare Compiler Warning] {e}")
+
     files[current_file].append(command)
 
 
@@ -117,11 +131,13 @@ def _flare_print(*args):
         if i > 0:
             components.append({"text": " "})
 
-        if hasattr(arg, '__icopy__') and getattr(type(arg), '__name__', '') in ("BinaryOp", "UnaryOp"):
-            arg = arg.__icopy__(f"{_current_namespace}_temp_print_{i}")
+        if hasattr(arg, "__icopy__") and getattr(type(arg), "__name__", "") in ("BinaryOp", "UnaryOp"):
+            global _temp_id
+            arg = arg.__icopy__(f"!print_{_temp_id}")
+            _temp_id += 1
 
         if isinstance(arg, score):
-            if getattr(arg, 'multiplier', 1.0) != 1.0:
+            if getattr(arg, "multiplier", 1.0) != 1.0:
                 scale_str = f"{arg.multiplier:.15f}".rstrip("0")
                 if scale_str.endswith("."):
                     scale_str += "0"
@@ -182,15 +198,15 @@ def export(func=None, *, append=False):
     for name, param in sig.parameters.items():
         anno = param.annotation
 
-        if hasattr(anno, '__name__') and anno.__name__ in ('score', 'fixed', '_PrecisionScore'):
+        if hasattr(anno, "__name__") and anno.__name__ in ("score", "fixed", "_PrecisionScore"):
             if is_recursive:
                 raise TypeError(
                     f"Recursive function '{func.__name__}' argument '{name}' needs a stack but it's a score.")
-            if anno.__name__ == '_PrecisionScore' or anno.__name__ == 'fixed':
+            if anno.__name__ == "_PrecisionScore" or anno.__name__ == "fixed":
                 kwargs[name] = anno(addr=f"{func.__name__}_{name} {vars_obj}")
             else:
                 kwargs[name] = score(addr=f"{func.__name__}_{name} {vars_obj}")
-        elif hasattr(anno, '__name__') and anno.__name__ in ('nbt', '_TypedNBT'):
+        elif hasattr(anno, "__name__") and anno.__name__ in ("nbt", "_TypedNBT"):
             if is_recursive:
                 kwargs[name] = anno(addr=f"storage flare:args {func.__name__}_{name}[-1]")
             else:
@@ -203,7 +219,8 @@ def export(func=None, *, append=False):
     if sig.return_annotation is not inspect.Signature.empty:
         return_types[func_name] = sig.return_annotation
     else:
-        return_types[func_name] = None
+        return_types[func_name] = "UNKNOWN"
+    has_returns[func_name] = False
 
     global _in_recursive_context, _logical_func
     prev_recursive = _in_recursive_context
@@ -247,26 +264,28 @@ def export(func=None, *, append=False):
                         base_addr = f"storage flare:args {func.__name__}_{arg_name}"
                         runcommand(f"data remove {base_addr}[-1]")
 
-            ret_anno = sig.return_annotation
-            if ret_anno is not inspect.Signature.empty:
-                if hasattr(ret_anno, '__name__') and ret_anno.__name__ in ('score', 'fixed', '_PrecisionScore'):
+            ret_anno = return_types.get(func_name, sig.return_annotation)
+            if ret_anno == "UNKNOWN":
+                return "UNKNOWN_RETURN"
+            elif ret_anno is not inspect.Signature.empty and ret_anno is not None:
+                if hasattr(ret_anno, "__name__") and ret_anno.__name__ in ("score", "fixed", "_PrecisionScore"):
                     temp_ret = score(addr=f"!ret{_temp_id} {temp_obj}")
                     _temp_id += 1
                     runcommand(
-                        f"scoreboard players operation {temp_ret.addr} = {func_name.replace(':', '_')}_ret {vars_obj}")
-                    if ret_anno.__name__ in ('fixed', '_PrecisionScore'):
+                        f"scoreboard players operation {temp_ret.addr} = {func_name.replace(":", "_")}_ret {vars_obj}")
+                    if ret_anno.__name__ in ("fixed", "_PrecisionScore"):
                         pass
                     return temp_ret
                 else:
                     temp_ret = nbt(addr=f"storage flare:temp !ret{_temp_id}")
                     _temp_id += 1
                     runcommand(
-                        f"data modify {temp_ret.addr} set from storage flare:returns {func_name.replace(':', '_')}")
+                        f"data modify {temp_ret.addr} set from storage flare:returns {func_name.replace(":", "_")}")
                     return temp_ret
 
     proxy = ProxyFunction()
 
-    func_globals = getattr(func, '__globals__', {})
+    func_globals = getattr(func, "__globals__", {})
     prev_func = func_globals.get(func.__name__)
     func_globals[func.__name__] = proxy
 
@@ -281,6 +300,13 @@ def export(func=None, *, append=False):
     else:
         func_globals.pop(func.__name__, None)
 
+    if return_types[func_name] == "UNKNOWN":
+        if has_returns.get(func_name, False):
+            raise TypeError(
+                f"Function {func_name} has returns but return type could not be auto-detected. Please add an explicit return type annotation.")
+        else:
+            return_types[func_name] = None
+
     return proxy
 
 
@@ -293,8 +319,11 @@ def _flare_assign(var_name, value, local_env, global_env):
         target = None
 
     if target is not None and hasattr(target, "__iset__"):
-        target.__iset__(value)
-        return target
+        try:
+            target.__iset__(value)
+            return target
+        except Exception:
+            pass
 
     if target is None and hasattr(value, "__icopy__"):
         if "is_recursive" in inspect.signature(value.__icopy__).parameters:
@@ -304,6 +333,35 @@ def _flare_assign(var_name, value, local_env, global_env):
     return value
 
 
+def _flare_aug_assign(var_name, op_name, value, _locals, _globals):
+    if var_name in _locals:
+        var = _locals[var_name]
+    elif var_name in _globals:
+        var = _globals[var_name]
+    else:
+        raise NameError(f"name '{var_name}' is not defined")
+
+    op_map = {"Add": "__iadd__", "Sub": "__isub__", "Mult": "__imul__", "Div": "__itruediv__", "Mod": "__imod__"}
+    method_name = op_map.get(op_name)
+
+    if hasattr(var, method_name):
+        getattr(var, method_name)(value)
+    else:
+        if op_name == "Add":
+            var += value
+        elif op_name == "Sub":
+            var -= value
+        elif op_name == "Mult":
+            var *= value
+        elif op_name == "Div":
+            var /= value
+        elif op_name == "Mod":
+            var %= value
+        _flare_assign(var_name, var, _locals, _globals)
+
+    return value
+
+
 def _flare_return(value):
     from .variables import score, nbt  # avoid circular import
     func_name = _logical_func
@@ -311,22 +369,45 @@ def _flare_return(value):
         raise Exception("Return outside of exported function")
     ret_anno = return_types.get(func_name, None)
 
-    if ret_anno is None:
+    if isinstance(value, str) and value == "UNKNOWN_RETURN":
+        has_returns[func_name] = True
+        return
+
+    ret_anno = return_types.get(func_name, None)
+
+    if ret_anno == "UNKNOWN":
+        if hasattr(value, "_best_leaf"):
+            leaf = value._best_leaf()
+        else:
+            leaf = value
+
+        if leaf is None:
+            ret_anno = type(None)
+        elif hasattr(type(leaf), "__name__") and type(leaf).__name__ in ("score", "fixed", "_PrecisionScore", "nbt",
+                                                                         "_TypedNBT"):
+            ret_anno = type(leaf)
+        else:
+            raise TypeError(f"Cannot auto-detect return type from value of type {type(leaf)}")
+        return_types[func_name] = ret_anno
+
+    has_returns[func_name] = True
+
+    if ret_anno is None or ret_anno == type(None):
         if value is not None:
             raise TypeError(f"Function {func_name} returned a value but has no return type annotation")
         return
 
-    if hasattr(ret_anno, '__name__') and ret_anno.__name__ in ('score', 'fixed', '_PrecisionScore'):
-        target = score(addr=f"{func_name.replace(':', '_')}_ret {vars_obj}")
+    if hasattr(ret_anno, "__name__") and ret_anno.__name__ in ("score", "fixed", "_PrecisionScore"):
+        target = score(addr=f"{func_name.replace(":", "_")}_ret {vars_obj}")
         target.__iset__(value)
     else:
         if inspect.isclass(ret_anno) and issubclass(ret_anno, nbt):
-            target = ret_anno(addr=f"storage flare:returns {func_name.replace(':', '_')}")
+            target = ret_anno(addr=f"storage flare:returns {func_name.replace(":", "_")}")
         else:
             datatype = None
-            if hasattr(ret_anno, '__origin__') or isinstance(ret_anno, type):
-                datatype = getattr(ret_anno, '__origin__', ret_anno)
-            target = nbt(addr=f"storage flare:returns {func_name.replace(':', '_')}", datatype=datatype)
+            if hasattr(ret_anno, "__origin__") or isinstance(ret_anno, type):
+                datatype = getattr(ret_anno, "__origin__", ret_anno)
+            target = nbt(addr=f"storage flare:returns {func_name.replace(":", "_")}", datatype=datatype)
         target.__iset__(value)
 
     runcommand("return 1")

{flaremc-0.2.0 → flaremc-0.2.2}/flare/control_flow.py

@@ -1,10 +1,16 @@
 from . import context as ctx
-from .execute_modifiers import ExecuteChain, _as
 from .compiler import _flatten_and
 from .context import push_context, runcommand, temp_obj
-from .types import NBTType
-from .variables import score, nbt
-from .variables import selector
+from .variables import score
+
+
+def _flare_break():
+    runcommand(f"scoreboard players set !break {temp_obj} 1")
+    runcommand("return 0")
+
+
+def _flare_continue():
+    runcommand("return 0")
 
 
 def _flare_if(*args):
@@ -107,12 +113,27 @@ def _flare_if(*args):
                 runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
 
 
-def _flare_while(cond_func, body_func):
+def _flare_while(cond_func, body_func, orelse_func=None, has_break=False, has_continue=False):
     func_name = f"{ctx._current_namespace}:while_{ctx._func_id}"
     ctx._func_id += 1
 
     with push_context(func_name):
-        body_func()
+        if has_break or has_continue:
+            func_body = f"{ctx._current_namespace}:while_body_{ctx._func_id}"
+            ctx._func_id += 1
+            with push_context(func_body):
+                body_func()
+
+            ret_body = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
+            ctx._temp_id += 1
+            runcommand(f"execute store result score {ret_body.addr} run function {func_body}")
+            runcommand(f"execute if score {ret_body.addr} matches 1 run return 1")
+
+            if has_break:
+                runcommand(f"execute if score !break {temp_obj} matches 1 run return 0")
+        else:
+            body_func()
+
         cond = cond_func()
         conds = _flatten_and(cond)
         prefix = f"execute {' '.join(conds)}"
@@ -122,6 +143,9 @@ def _flare_while(cond_func, body_func):
         runcommand(f"execute store result score {ret_temp.addr} {' '.join(conds)} run function {func_name}")
         runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
 
+    if has_break:
+        runcommand(f"scoreboard players set !break {temp_obj} 0")
+
     cond_init = cond_func()
     conds_init = _flatten_and(cond_init)
     prefix_init = f"execute {' '.join(conds_init)}"
@@ -130,91 +154,40 @@ def _flare_while(cond_func, body_func):
     runcommand(f"execute store result score {ret_temp_init.addr} {' '.join(conds_init)} run function {func_name}")
     runcommand(f"execute if score {ret_temp_init.addr} matches 1 run return 1")
 
+    if orelse_func:
+        if has_break:
+            orelse_name = f"{ctx._current_namespace}:while_else_{ctx._func_id}"
+            ctx._func_id += 1
+            with push_context(orelse_name):
+                orelse_func()
+            runcommand(f"execute if score !break {temp_obj} matches 0 run function {orelse_name}")
+        else:
+            orelse_func()
 
-def _flare_for(iterable, body_func):
-    if isinstance(iterable, nbt) and iterable.is_sequence():
-        elem_type = None
-        if iterable.type == NBTType.ByteArray:
-            elem_type = NBTType.Byte
-        elif iterable.type == NBTType.IntArray:
-            elem_type = NBTType.Int
-        elif iterable.type == NBTType.LongArray:
-            elem_type = NBTType.Long
-
-        temp_arr = nbt(addr=f"flare:temp !for_arr_{ctx._temp_id}", datatype=iterable.type)
-        temp_var = nbt(addr=f"{temp_arr.addr}[0]", datatype=elem_type)
-        ctx._temp_id += 1
-
-        temp_arr.__iset__(iterable)
-        length_score = temp_arr.length()
-
-        func_name = f"{ctx._current_namespace}:for_{ctx._func_id}"
-        ctx._func_id += 1
-
-        with push_context(func_name):
-            body_func(temp_var)
-            runcommand(f"data remove {temp_arr.addr}[0]")
-
-            length_score -= 1
-            ctx.files[func_name].append("return 0")
-            ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-            ctx._temp_id += 1
-            runcommand(
-                f"execute store result score {ret_temp.addr} if score {length_score.addr} matches 1.. run function {func_name}")
-            runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
-
-        ret_temp_init = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-        ctx._temp_id += 1
-        runcommand(
-            f"execute store result score {ret_temp_init.addr} if score {length_score.addr} matches 1.. run function {func_name}")
-        runcommand(f"execute if score {ret_temp_init.addr} matches 1 run return 1")
 
+def _flare_for(iterable, body_func, orelse_func=None, has_break=False, has_continue=False):
+    if hasattr(iterable, "__for__"):
+        iterable.__for__(body_func, orelse_func, has_break, has_continue)
     else:
-        if isinstance(iterable, selector):
-            _flare_with(iterable, lambda: body_func(selector("@s")))
-        else:
-            for item in iterable:
-                body_func(item)
+        for item in iterable:
+            body_func(item)
 
 
 def _flare_with(*args):
     body_func = args[-1]
     chains = args[:-1]
 
-    combined_fragments = ["execute"]
-    for chain in chains:
-        if isinstance(chain, selector):
-            chain = _as(chain)
-        if isinstance(chain, ExecuteChain):
-            if chain.fragments and chain.fragments[0] == "execute":
-                combined_fragments.extend(chain.fragments[1:])
-            else:
-                combined_fragments.extend(chain.fragments)
-        elif isinstance(chain, str):
-            combined_fragments.append(chain)
-
-    prefix = " ".join(combined_fragments)
-
-    func_name = f"{ctx._current_namespace}:with_{ctx._func_id}"
-    ctx._func_id += 1
-
-    with push_context(func_name):
-        body_func()
-
-    if ctx.files.get(func_name):
-        if len(ctx.files[func_name]) == 1:
-            cmd = ctx.files[func_name][0]
-            del ctx.files[func_name]
-            if cmd.startswith("execute "):
-                runcommand(f"{prefix} {cmd[8:]}")
-            else:
-                runcommand(f"{prefix} run {cmd}")
+    def wrap(idx):
+        if idx == len(chains):
+            body_func()
         else:
-            ctx.files[func_name].append("return 0")
-            ret_temp = score(addr=f"!ret{ctx._temp_id} {temp_obj}")
-            ctx._temp_id += 1
-            if prefix.startswith("execute "):
-                runcommand(f"execute store result score {ret_temp.addr} {prefix[8:]} run function {func_name}")
+            obj = chains[idx]
+            if hasattr(obj, "__with__"):
+                obj.__with__(lambda: wrap(idx + 1))
+            elif isinstance(obj, str):
+                from .execute_modifiers import ExecuteChain
+                ExecuteChain(obj).__with__(lambda: wrap(idx + 1))
             else:
-                runcommand(f"execute store result score {ret_temp.addr} run function {func_name}")
-            runcommand(f"execute if score {ret_temp.addr} matches 1 run return 1")
+                raise TypeError(f"Object of type {type(obj).__name__} does not support __with__")
+
+    wrap(0)