flaremc 0.2.2__tar.gz → 0.2.4__tar.gz

flaremc-0.2.4/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: flaremc
+Version: 0.2.4
+Summary: Flare datapack compiler framework
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcemu
+Requires-Dist: watchdog
+Dynamic: license-file
+
+<div align="center">
+  <img src="docs/public/assets/icon_transparent.png" width="200" alt="Flare Logo">
+  <h1>Flare 🔥</h1>
+  <p><b>Programmatic Minecraft Datapacks in Python</b></p>
+  <p>Write Minecraft logic using full Python power: scores, NBT, execute chains, recursion, and more. Compile to optimized datapacks instantly.</p>
+</div>
+
+<br>
+
+**Read the full documentation at: [flare.oguzhanumutlu.com](https://flare.oguzhanumutlu.com)**
+
+---
+
+## What is Flare?
+
+Flare is a modern framework for building Minecraft datapacks natively in Python. It bridges the gap between Python's high-level elegance and Minecraft's native `mcfunction` performance. You can use standard Python syntax, variables, and math, and Flare automatically translates and compiles your logic into highly-optimized, scoreboard-driven datapacks.
+
+## Installation
+
+```bash
+pip install flaremc
+```
+
+## Quick Start: Advanced Math & NBT
+
+With Flare, writing advanced datapack logic is incredibly clean. Below is a quick example of defining variables, doing advanced floating-point math natively in Minecraft, running terminal commands, and interacting with NBT.
+
+```python
+from flare import namespace, score, math, nbt, expand
+
+# Define your datapack namespace
+namespace("my_pack")
+
+# Declare a scoreboard variable and initialize it to 10
+x = score(10)
+
+# Compute math dynamically using native scoreboard approximations (Taylor series, CORDIC, etc.)
+# All complex math compiles to highly optimized raw scoreboard operations!
+result = math.sin(x) * math.sqrt(x)
+
+# Print the dynamic float result back to the game seamlessly
+print(f"The result is: {result}")
+
+# Interact seamlessly with Minecraft's NBT environment
+player_data = @a.Data[dict]
+
+# Flare smartly manages conditional blocks and inlines commands when appropriate
+if expand(x > 5):
+    say "X is greater than 5!"
+    kill @e[type=zombie, distance=..10]
+```
+
+## Compile & Run
+
+To compile your datapack to a `.mcfunction` structure, simply run:
+
+```bash
+flare main.py
+```
+
+To compile and immediately run it using the built-in emulator:
+
+```bash
+flare main.py --run
+```
+
+## Documentation
+
+Ready to unleash the full power of Python in Minecraft? 
+
+Check out the interactive playground and full documentation at **[flare.oguzhanumutlu.com](https://flare.oguzhanumutlu.com)**!

flaremc-0.2.4/README.md

@@ -0,0 +1,71 @@
+<div align="center">
+  <img src="docs/public/assets/icon_transparent.png" width="200" alt="Flare Logo">
+  <h1>Flare 🔥</h1>
+  <p><b>Programmatic Minecraft Datapacks in Python</b></p>
+  <p>Write Minecraft logic using full Python power: scores, NBT, execute chains, recursion, and more. Compile to optimized datapacks instantly.</p>
+</div>
+
+<br>
+
+**Read the full documentation at: [flare.oguzhanumutlu.com](https://flare.oguzhanumutlu.com)**
+
+---
+
+## What is Flare?
+
+Flare is a modern framework for building Minecraft datapacks natively in Python. It bridges the gap between Python's high-level elegance and Minecraft's native `mcfunction` performance. You can use standard Python syntax, variables, and math, and Flare automatically translates and compiles your logic into highly-optimized, scoreboard-driven datapacks.
+
+## Installation
+
+```bash
+pip install flaremc
+```
+
+## Quick Start: Advanced Math & NBT
+
+With Flare, writing advanced datapack logic is incredibly clean. Below is a quick example of defining variables, doing advanced floating-point math natively in Minecraft, running terminal commands, and interacting with NBT.
+
+```python
+from flare import namespace, score, math, nbt, expand
+
+# Define your datapack namespace
+namespace("my_pack")
+
+# Declare a scoreboard variable and initialize it to 10
+x = score(10)
+
+# Compute math dynamically using native scoreboard approximations (Taylor series, CORDIC, etc.)
+# All complex math compiles to highly optimized raw scoreboard operations!
+result = math.sin(x) * math.sqrt(x)
+
+# Print the dynamic float result back to the game seamlessly
+print(f"The result is: {result}")
+
+# Interact seamlessly with Minecraft's NBT environment
+player_data = @a.Data[dict]
+
+# Flare smartly manages conditional blocks and inlines commands when appropriate
+if expand(x > 5):
+    say "X is greater than 5!"
+    kill @e[type=zombie, distance=..10]
+```
+
+## Compile & Run
+
+To compile your datapack to a `.mcfunction` structure, simply run:
+
+```bash
+flare main.py
+```
+
+To compile and immediately run it using the built-in emulator:
+
+```bash
+flare main.py --run
+```
+
+## Documentation
+
+Ready to unleash the full power of Python in Minecraft? 
+
+Check out the interactive playground and full documentation at **[flare.oguzhanumutlu.com](https://flare.oguzhanumutlu.com)**!

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

@@ -1,16 +1,18 @@
 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_aug_assign, _flare_print, dbg, _flare_return
-from .control_flow import _flare_if, _flare_while, _flare_for, _flare_with, _flare_break, _flare_continue
+    constants, _flare_assign, _flare_aug_assign, _flare_print, dbg, _flare_return, _flare_in, _flare_notin
+from .control_flow import _flare_if, _flare_while, _flare_for, _flare_with, _flare_break, _flare_continue, expand
 from .execute_modifiers import _as, at, positioned, aligned, facing, anchored, rotated, dimension, applyon, on, summon, \
     store, ExecuteChain, StoreExecuteChain
 from .math import round_, floor, ceil
 from .types import NBTType, byte, boolean, short, long, double, array
 from .variables import score, nbt, fixed, tagged, ref, getscore, storage, nbtbyte, nbtbool, nbtshort, nbtint, nbtlong, \
-    nbtfloat, nbtdouble, nbtstr, nbtlist, nbtdict, nbtbytearray, nbtintarray, nbtlongarray, selector
+    nbtfloat, nbtdouble, nbtstr, nbtlist, nbtdict, nbtbytearray, nbtintarray, nbtlongarray, selector, bigscore, \
+    bigfixed, float64, float32, complex
 
 __all__ = ["round_", "floor", "ceil", "namespace", "export", "tick", "score", "nbt", "fixed", "tagged", "ref",
            "getscore", "storage", "_flare_print", "dbg", "nbtbyte", "nbtbool", "nbtshort", "nbtint", "nbtlong",
            "nbtfloat", "nbtdouble", "nbtstr", "nbtlist", "nbtdict", "nbtbytearray", "nbtintarray", "nbtlongarray",
            "selector", "_as", "at", "positioned", "aligned", "facing", "anchored", "rotated", "dimension", "applyon",
-           "on", "summon", "store", "ExecuteChain", "StoreExecuteChain", "array"]
+           "on", "summon", "store", "ExecuteChain", "StoreExecuteChain", "array", "bigscore", "bigfixed", "float32",
+           "float64", "complex", "byte", "boolean", "short", "long", "double", "expand"]

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

@@ -95,7 +95,8 @@ def _build_datapack_inner(file_path: str, cli_overrides: dict = None):
 
         global_env = {"__name__": "__main__", "__file__": abs_path}
         exec(
-            "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 import _flare_assign, _flare_aug_assign, _flare_if, _flare_while, _flare_for, _flare_with, runcommand, _flare_return, _flare_break, _flare_continue, _flare_in, _flare_notin\n"
+            "from flare import context as ctx\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, tagged, ref, getscore, storage, array, byte, boolean, short, long, double\n"
@@ -153,8 +154,14 @@ def _build_datapack_inner(file_path: str, cli_overrides: dict = None):
         if ":" in filename:
             ns, name = filename.split(":", 1)
             file_p = build_dir / "data" / ns / "functions" / f"{name}.mcfunction"
+            is_top_level = "generated_" not in name and "while_" not in name and name not in ("main", "load")
         else:
             file_p = build_dir / "data" / context._current_namespace / "functions" / f"{filename}.mcfunction"
+            is_top_level = "generated_" not in filename and "while_" not in filename and filename not in ("main",
+                                                                                                          "load")
+
+        if is_top_level and lines and lines[-1] in ("return 1", "return 0"):
+            lines.pop()
 
         file_p.parent.mkdir(parents=True, exist_ok=True)
         with open(file_p, "w") as f:

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

@@ -71,7 +71,7 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
             elif not is_key and ident in local_vars:
                 val = local_vars[ident]
                 if hasattr(val, "addr"):
-                    output.append(val.addr)
+                    output.append(val._addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
                 elif isinstance(val, dict) and output and output[-1].endswith("**"):
@@ -88,7 +88,7 @@ def interpolate_command(command: str, local_vars: dict, global_vars: dict) -> st
             elif not is_key and ident in global_vars:
                 val = global_vars[ident]
                 if hasattr(val, "addr"):
-                    output.append(val.addr)
+                    output.append(val._addr)
                 elif hasattr(val, "target"):
                     output.append(val.target)
                 elif isinstance(val, dict) and output and output[-1].endswith("**"):

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

@@ -1,6 +1,7 @@
 from . import context as ctx
 from .context import runcommand, temp_obj
 from .variables import score, BinaryOp, UnaryOp, getscore
+from .variables.core import addr
 
 
 def _compile_relational(node, invert=False):
@@ -19,8 +20,7 @@ def _compile_relational(node, invert=False):
         if isinstance(left, (int, float)):
             left = getscore(left)
         else:
-            t = score(addr=f"!c{ctx._temp_id} {temp_obj}")
-            ctx._temp_id += 1
+            t = score(addr=f"!c{ctx.next_temp_id()} {temp_obj}")
             if isinstance(left, (BinaryOp, UnaryOp)):
                 left._eval_into(t)
             else:
@@ -29,52 +29,52 @@ def _compile_relational(node, invert=False):
 
     if not isinstance(right, score):
         if isinstance(right, (int, float)):
-            right = getscore(right, left.multiplier)
+            right = getscore(right, left._multiplier)
         else:
-            t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
-            ctx._temp_id += 1
+            t = score(addr=f"!c{ctx.next_temp_id()} {temp_obj}", multiplier=left._multiplier)
             if isinstance(right, (BinaryOp, UnaryOp)):
                 right._eval_into(t)
             else:
                 t.__iset__(right)
             right = t
 
-    if left.multiplier != right.multiplier:
-        t = score(addr=f"!c{ctx._temp_id} {temp_obj}", multiplier=left.multiplier)
-        ctx._temp_id += 1
+    if left._multiplier != right._multiplier:
+        t = score(addr=f"!c{ctx.next_temp_id()} {temp_obj}", multiplier=left._multiplier)
         t.__iset__(right)
         right = t
 
-    return f"{keyword} score {left.addr} {mcop} {right.addr}"
+    return f"{keyword} score {addr(left)} {mcop} {addr(right)}"
 
 
 def _eval_to_bool_score(node):
-    dest = score(addr=f"!b{ctx._temp_id} {temp_obj}")
-    ctx._temp_id += 1
-    runcommand(f"scoreboard players set {dest.addr} 0")
+    dest = score(addr=f"!b{ctx.next_temp_id()} {temp_obj}")
+    runcommand(f"scoreboard players set {addr(dest)} 0")
 
     if isinstance(node, BinaryOp) and node.op == "or":
         left_conds = _flatten_and(node.left)
-        runcommand(f"execute {' '.join(left_conds)} run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute {' '.join(left_conds)} run scoreboard players set {addr(dest)} 1")
         right_conds = _flatten_and(node.right)
         runcommand(
-            f"execute if score {dest.addr} matches 0 {' '.join(right_conds)} run scoreboard players set {dest.addr} 1")
+            f"execute if score {addr(dest)} matches 0 {' '.join(right_conds)} run scoreboard players set {addr(dest)} 1")
         return dest
 
     if isinstance(node, UnaryOp) and node.op == "not":
         sub_dest = _eval_to_bool_score(node.operand)
-        runcommand(f"execute if score {sub_dest.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute if score {addr(sub_dest)} matches 0 run scoreboard players set {addr(dest)} 1")
         return dest
 
     if isinstance(node, (BinaryOp, UnaryOp)):
-        t = score(addr=f"!b{ctx._temp_id} {temp_obj}")
-        ctx._temp_id += 1
+        t = score(addr=f"!b{ctx.next_temp_id()} {temp_obj}")
         node._eval_into(t)
-        runcommand(f"execute unless score {t.addr} matches 0 run scoreboard players set {dest.addr} 1")
+        runcommand(f"execute unless score {addr(t)} matches 0 run scoreboard players set {addr(dest)} 1")
+        return dest
+
+    if hasattr(type(node), "_eval_into") or hasattr(node, "_addr"):
+        runcommand(f"execute unless score {addr(node)} matches 0 run scoreboard players set {addr(dest)} 1")
         return dest
 
     if node:
-        runcommand(f"scoreboard players set {dest.addr} 1")
+        runcommand(f"scoreboard players set {addr(dest)} 1")
     return dest
 
 
@@ -84,4 +84,4 @@ def _flatten_and(node, invert=False):
 
     dest = _eval_to_bool_score(node)
     keyword = "unless" if invert else "if"
-    return [f"{keyword} score {dest.addr} matches 1"]
+    return [f"{keyword} score {addr(dest)} matches 1"]

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

@@ -8,9 +8,39 @@ current_file = "main"
 _current_namespace = "flare"
 functions = {}
 constants = {}
-constant_obj = "__flare__constant__"
-vars_obj = "__flare__vars__"
-temp_obj = "__flare__temp__"
+
+
+class DynamicVar:
+    def __init__(self, fmt):
+        self.fmt = fmt
+
+    def __str__(self):
+        return self.fmt.format(ns=_current_namespace)
+
+    def __format__(self, format_spec):
+        return format(str(self), format_spec)
+
+    def __add__(self, other):
+        return str(self) + other
+
+    def __radd__(self, other):
+        return other + str(self)
+
+    def __hash__(self):
+        return hash(str(self))
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+
+constant_obj = DynamicVar("__{ns}__constant__")
+vars_obj = DynamicVar("__{ns}__vars__")
+temp_obj = DynamicVar("__{ns}__temp__")
+temp_storage = DynamicVar("{ns}:__flare_temp__")
+vars_storage = DynamicVar("{ns}:__flare_vars__")
+args_storage = DynamicVar("{ns}:__flare_args__")
+returns_storage = DynamicVar("{ns}:__flare_returns__")
+
 _temp_id = 0
 _func_id = 0
 _objective_offset = 0
@@ -26,6 +56,20 @@ minecraft_version = "1.20.4"
 nbt_schema_missing = "error"
 
 
+def next_temp_id():
+    global _temp_id
+    got = _temp_id
+    _temp_id += 1
+    return got
+
+
+def next_func_id():
+    global _func_id
+    got = _func_id
+    _func_id += 1
+    return got
+
+
 def reset_context():
     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": []}
@@ -91,9 +135,11 @@ def push_context(name: str):
     return _ContextManager(name)
 
 
-def namespace(name: str):
+def namespace(name: str | None = None):
     global _current_namespace
-    _current_namespace = name
+    if name is not None:
+        _current_namespace = name
+    return _current_namespace
 
 
 from .validator import validate_command, FlareCommandValidationError
@@ -138,28 +184,28 @@ def _flare_print(*args):
 
         if isinstance(arg, score):
             if getattr(arg, "multiplier", 1.0) != 1.0:
-                scale_str = f"{arg.multiplier:.15f}".rstrip("0")
+                scale_str = f"{arg._multiplier:.15f}".rstrip("0")
                 if scale_str.endswith("."):
                     scale_str += "0"
                 runcommand(
-                    f"execute store result storage flare:temp __flare_debug_{i} double {scale_str} run scoreboard players get {arg.addr}")
-                components.append({"nbt": f"__flare_debug_{i}", "storage": "flare:temp"})
+                    f"execute store result storage {temp_storage} __flare_debug_{i} double {scale_str} run scoreboard players get {addr(arg)}")
+                components.append({"nbt": f"__flare_debug_{i}", "storage": str(temp_storage)})
             else:
-                name, obj = arg.addr.split(" ", 1)
+                name, obj = arg._addr.split(" ", 1)
                 components.append({"score": {"name": name, "objective": obj}})
         elif isinstance(arg, nbt):
-            nbt_comp = {"nbt": arg.path or "{}"}
-            if arg.path == "":
+            nbt_comp = {"nbt": arg._path or "{}"}
+            if arg._path == "":
                 nbt_comp["nbt"] = "{}"
 
-            if arg.target_type == "storage":
-                nbt_comp["storage"] = arg.target
-            elif arg.target_type == "entity":
-                nbt_comp["entity"] = arg.target
-            elif arg.target_type == "block":
-                nbt_comp["block"] = arg.target
+            if arg._target_type == "storage":
+                nbt_comp["storage"] = arg._target
+            elif arg._target_type == "entity":
+                nbt_comp["entity"] = arg._target
+            elif arg._target_type == "block":
+                nbt_comp["block"] = arg._target
 
-            if arg.path == "":
+            if arg._path == "":
                 nbt_comp["nbt"] = "{}"
 
             components.append(nbt_comp)
@@ -178,15 +224,21 @@ def _flare_print(*args):
     runcommand(f"tellraw @a {cmd_text}")
 
 
-def export(func=None, *, append=False):
+def export(func=None, *, name=None, append=False):
     from flare import score  # avoid circular import
+
+    if isinstance(func, str):
+        name = func
+        func = None
+
     if func is None:
         def wrapper(f):
-            return export(f, append=append)
+            return export(f, name=name, append=append)
 
         return wrapper
 
-    func_name = f"{_current_namespace}:{func.__name__}"
+    actual_name = name if name is not None else func.__name__
+    func_name = f"{_current_namespace}:{actual_name}"
     if func_name in files and not append:
         raise ValueError(f"Function {func_name} already exists. Use @export(append=True) to append.")
 
@@ -208,9 +260,9 @@ def export(func=None, *, append=False):
                 kwargs[name] = score(addr=f"{func.__name__}_{name} {vars_obj}")
         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]")
+                kwargs[name] = anno(addr=f"storage {args_storage} {func.__name__}_{name}[-1]")
             else:
-                kwargs[name] = anno(addr=f"storage flare:args {func.__name__}_{name}")
+                kwargs[name] = anno(addr=f"storage {args_storage} {func.__name__}_{name}")
         elif anno is not inspect.Signature.empty:
             raise TypeError(f"Argument '{name}' must be typed as score or nbt, not {anno}")
         else:
@@ -235,24 +287,25 @@ def export(func=None, *, append=False):
             global _temp_id
             bound = sig.bind(*args, **call_kwargs)
             bound.apply_defaults()
+            from .variables.core import addr
             for arg_name, arg_val in bound.arguments.items():
                 target = kwargs[arg_name]
 
                 if is_recursive and isinstance(target, nbt):
-                    base_addr = f"storage flare:args {func.__name__}_{arg_name}"
+                    base_addr = f"storage {args_storage} {func.__name__}_{arg_name}"
                     if isinstance(arg_val, (int, float, str)):
                         runcommand(f"data modify {base_addr} append value {json.dumps(arg_val)}")
                     elif isinstance(arg_val, nbt):
-                        runcommand(f"data modify {base_addr} append from {arg_val.addr}")
+                        runcommand(f"data modify {base_addr} append from {addr(arg_val)}")
                     elif isinstance(arg_val, score):
                         runcommand(f"data modify {base_addr} append value 0")
                         runcommand(
-                            f"execute store result {base_addr}[-1] int {1 / arg_val.multiplier} run scoreboard players get {arg_val.addr}")
+                            f"execute store result {base_addr}[-1] int {1 / arg_val._multiplier} run scoreboard players get {addr(arg_val)}")
                     elif hasattr(type(arg_val), "_eval_into"):
-                        temp = nbt(addr=f"storage flare:temp !t{_temp_id}", datatype=target.type)
+                        temp = nbt(addr=f"storage {temp_storage} !t{_temp_id}", datatype=target._type)
                         _temp_id += 1
                         arg_val._eval_into(temp)
-                        runcommand(f"data modify {base_addr} append from {temp.addr}")
+                        runcommand(f"data modify {base_addr} append from {addr(temp)}")
                 else:
                     target.__iset__(arg_val)
 
@@ -261,7 +314,7 @@ def export(func=None, *, append=False):
             if is_recursive:
                 for arg_name in bound.arguments.keys():
                     if isinstance(kwargs[arg_name], nbt):
-                        base_addr = f"storage flare:args {func.__name__}_{arg_name}"
+                        base_addr = f"storage {args_storage} {func.__name__}_{arg_name}"
                         runcommand(f"data remove {base_addr}[-1]")
 
             ret_anno = return_types.get(func_name, sig.return_annotation)
@@ -272,15 +325,15 @@ def export(func=None, *, append=False):
                     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}")
+                        f"scoreboard players operation {addr(temp_ret)} = {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_ret = nbt(addr=f"storage {temp_storage} !ret{_temp_id}")
                     _temp_id += 1
                     runcommand(
-                        f"data modify {temp_ret.addr} set from storage flare:returns {func_name.replace(":", "_")}")
+                        f"data modify {addr(temp_ret)} set from storage {returns_storage} {func_name.replace(':', '_')}")
                     return temp_ret
 
     proxy = ProxyFunction()
@@ -310,6 +363,18 @@ def export(func=None, *, append=False):
     return proxy
 
 
+def _flare_in(item, container):
+    if hasattr(container, "__in__"):
+        return container.__in__(item)
+    return item in container
+
+def _flare_notin(item, container):
+    if hasattr(container, "__notin__"):
+        return container.__notin__(item)
+    if hasattr(container, "__in__"):
+        return ~container.__in__(item)
+    return item not in container
+
 def _flare_assign(var_name, value, local_env, global_env):
     if var_name in local_env:
         target = local_env[var_name]
@@ -402,12 +467,12 @@ def _flare_return(value):
         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 {returns_storage} {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)
+            target = nbt(addr=f"storage {returns_storage} {func_name.replace(':', '_')}", datatype=datatype)
         target.__iset__(value)
 
     runcommand("return 1")