sonolus.py 0.11.0__tar.gz → 0.11.1__tar.gz

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.11.0
+Version: 0.11.1
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/docs/changelog/index.md

@@ -1,3 +1,8 @@
+### 0.11.1
+
+- Memory usage no longer increases indefinitely when rebuilding with changes in the dev server
+- [`EntityRef`][sonolus.script.archetype.EntityRef] now throws an error when converted to a boolean
+
 ### 0.11.0
 
 - Added basic support for set literals of numbers, with support for membership checks (`in`, `not in`) and iteration

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.11.0"
+version = "0.11.1"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/backend/finalize.py

@@ -1,7 +1,7 @@
 from math import isfinite, isinf, isnan
 
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_reverse_postorder
 from sonolus.backend.place import BlockPlace
@@ -18,18 +18,18 @@ def cfg_to_engine_node(entry: BasicBlock):
         }
         match outgoing:
             case {**other} if not other:
-                statements.append(ConstantNode(value=len(block_indexes)))
+                statements.append(len(block_indexes))
             case {None: target, **other} if not other:
-                statements.append(ConstantNode(value=block_indexes[target]))
+                statements.append(block_indexes[target])
             case {0: f_branch, None: t_branch, **other} if not other:
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(block.test),
-                            ConstantNode(value=block_indexes[t_branch]),
-                            ConstantNode(value=block_indexes[f_branch]),
-                        ],
+                            block_indexes[t_branch],
+                            block_indexes[f_branch],
+                        ),
                     )
                 )
             case {None: default_branch, **other} if len(other) == 1:
@@ -37,11 +37,11 @@ def cfg_to_engine_node(entry: BasicBlock):
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(IRPureInstr(Op.Equal, args=[block.test, IRConst(cond)])),
-                            ConstantNode(value=block_indexes[cond_branch]),
-                            ConstantNode(value=block_indexes[default_branch]),
-                        ],
+                            block_indexes[cond_branch],
+                            block_indexes[default_branch],
+                        ),
                     )
                 )
             case dict() as targets:
@@ -49,23 +49,23 @@ def cfg_to_engine_node(entry: BasicBlock):
                 default = len(block_indexes)
                 conds = [cond for cond in targets if cond is not None]
                 if min(conds) == 0 and max(conds) == len(conds) - 1 and all(int(cond) == cond for cond in conds):
-                    args.extend(ConstantNode(value=block_indexes[targets[cond]]) for cond in range(len(conds)))
+                    args.extend(block_indexes[targets[cond]] for cond in range(len(conds)))
                     if None in targets:
                         default = block_indexes[targets[None]]
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, args))
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, tuple(args)))
                 else:
                     for cond, target in targets.items():
                         if cond is None:
                             default = block_indexes[target]
                             continue
-                        args.append(ConstantNode(value=cond))
-                        args.append(ConstantNode(value=block_indexes[target]))
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchWithDefault, args))
-        block_statements.append(FunctionNode(Op.Execute, statements))
-    block_statements.append(ConstantNode(value=0))
-    result = FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+                        args.append(cond)
+                        args.append(block_indexes[target])
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchWithDefault, tuple(args)))
+        block_statements.append(FunctionNode(Op.Execute, tuple(statements)))
+    block_statements.append(0)
+    result = FunctionNode(Op.Block, (FunctionNode(Op.JumpLoop, tuple(block_statements)),))
     for block in block_indexes:
         # Clean up without relying on gc
         del block.incoming
@@ -81,32 +81,30 @@ def ir_to_engine_node(stmt) -> EngineNode:
         case int(value) | float(value) | IRConst(value=int(value) | float(value)):
             value = float(value)
             if value.is_integer():
-                return ConstantNode(value=int(value))
+                return int(value)
             elif isfinite(value):
-                return ConstantNode(value=value)
+                return value
             elif isinf(value):
                 # Read values from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=1 if value > 0 else 2)])
+                return FunctionNode(Op.Get, args=(3000, 1 if value > 0 else 2))
             elif isnan(value):
                 # Read value from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=0)])
+                return FunctionNode(Op.Get, args=(3000, 0))
             else:
                 raise ValueError(f"Invalid constant value: {value}")
         case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
-            return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])
+            return FunctionNode(func=op, args=tuple(ir_to_engine_node(arg) for arg in args))
         case IRGet(place=place):
             return ir_to_engine_node(place)
         case BlockPlace() as place:
             if place.offset == 0:
                 index = ir_to_engine_node(place.index)
             elif place.index == 0:
-                index = ConstantNode(value=place.offset)
+                index = place.offset
             else:
-                index = FunctionNode(
-                    func=Op.Add, args=[ir_to_engine_node(place.index), ConstantNode(value=place.offset)]
-                )
-            return FunctionNode(func=Op.Get, args=[ir_to_engine_node(place.block), index])
+                index = FunctionNode(func=Op.Add, args=(ir_to_engine_node(place.index), place.offset))
+            return FunctionNode(func=Op.Get, args=(ir_to_engine_node(place.block), index))
         case IRSet(place=place, value=value):
-            return FunctionNode(func=Op.Set, args=[*ir_to_engine_node(place).args, ir_to_engine_node(value)])
+            return FunctionNode(func=Op.Set, args=(*ir_to_engine_node(place).args, ir_to_engine_node(value)))
         case _:
             raise TypeError(f"Unsupported IR statement: {stmt}")

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/backend/interpret.py

@@ -2,7 +2,7 @@ import math
 import operator
 import random
 
-from sonolus.backend.node import ConstantNode, EngineNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 
 
@@ -24,8 +24,8 @@ class Interpreter:
         self.log = []
 
     def run(self, node: EngineNode) -> float:
-        if isinstance(node, ConstantNode):
-            return node.value
+        if not isinstance(node, FunctionNode):
+            return node
         func = node.func
         args = node.args
         match func:

sonolus_py-0.11.1/sonolus/backend/node.py

@@ -0,0 +1,26 @@
+import textwrap
+from typing import NamedTuple
+
+from sonolus.backend.ops import Op
+
+type EngineNode = int | float | FunctionNode
+
+
+class FunctionNode(NamedTuple):
+    func: Op
+    args: tuple[EngineNode, ...]
+
+
+def format_engine_node(node: EngineNode) -> str:
+    if isinstance(node, FunctionNode):
+        match len(node.args):
+            case 0:
+                return f"{node.func.name}()"
+            case 1:
+                return f"{node.func.name}({format_engine_node(node.args[0])})"
+            case _:
+                return f"{node.func.name}(\n{
+                    textwrap.indent('\n'.join(format_engine_node(arg) for arg in node.args), '  ')
+                }\n)"
+    else:
+        return str(node)

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/build/compile.py

@@ -32,9 +32,11 @@ class CompileCache:
         self._cache = {}
         self._lock = Lock()
         self._event = Event()
+        self._accessed_hashes = set()
 
     def get(self, entry_hash: int) -> EngineNode | None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             if entry_hash not in self._cache:
                 self._cache[entry_hash] = None  # Mark as being compiled
                 return None
@@ -47,10 +49,21 @@ class CompileCache:
 
     def set(self, entry_hash: int, node: EngineNode) -> None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             self._cache[entry_hash] = node
             self._event.set()
             self._event.clear()
 
+    def reset_accessed(self) -> None:
+        with self._lock:
+            self._accessed_hashes.clear()
+
+    def prune_unaccessed(self) -> None:
+        with self._lock:
+            unaccessed_hashes = set(self._cache.keys()) - self._accessed_hashes
+            for h in unaccessed_hashes:
+                del self._cache[h]
+
 
 def compile_mode(
     mode: Mode,

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/build/dev_server.py

@@ -119,6 +119,7 @@ class RebuildCommand:
         print("Rebuilding...")
         try:
             start_time = perf_counter()
+            server_state.cache.reset_accessed()
             server_state.project_state = ProjectContextState.from_build_config(server_state.config)
             server_state.project = project_module.project
             build_collection(
@@ -128,6 +129,7 @@ class RebuildCommand:
                 cache=server_state.cache,
                 project_state=server_state.project_state,
             )
+            server_state.cache.prune_unaccessed()
             end_time = perf_counter()
             print(f"Rebuild completed in {end_time - start_time:.2f} seconds")
         except CompilationError:

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/build/node.py

@@ -1,7 +1,7 @@
 from threading import Lock
 from typing import TypedDict
 
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 
 
 class ValueOutputNode(TypedDict):
@@ -32,19 +32,17 @@ class OutputNodeGenerator:
             return self.indexes[node]
 
         match node:
-            case ConstantNode(value):
-                index = len(self.nodes)
-                self.nodes.append({"value": value})
-                self.indexes[node] = index
-                return index
             case FunctionNode(func, args):
                 arg_indexes = [self._add(arg) for arg in args]
                 index = len(self.nodes)
                 self.nodes.append({"func": func.value, "args": arg_indexes})
                 self.indexes[node] = index
                 return index
-            case _:
-                raise ValueError("Invalid node")
+            case constant:
+                index = len(self.nodes)
+                self.nodes.append({"value": constant})
+                self.indexes[node] = index
+                return index
 
     def get(self):
         return self.nodes

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/script/archetype.py

@@ -12,6 +12,7 @@ from sonolus.backend.ir import IRConst, IRExpr, IRInstr, IRPureInstr, IRStmt
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
 from sonolus.script.bucket import Bucket, Judgment
+from sonolus.script.debug import static_error
 from sonolus.script.internal.callbacks import PLAY_CALLBACKS, PREVIEW_CALLBACKS, WATCH_ARCHETYPE_CALLBACKS, CallbackInfo
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.descriptor import SonolusDescriptor
@@ -1210,6 +1211,8 @@ class EntityRef[A: _BaseArchetype](Record):
 
     Usage:
         ```python
+        ref = EntityRef[MyArchetype](index=123)
+
         class MyArchetype(PlayArchetype):
             ref_1: EntityRef[OtherArchetype] = imported()
             ref_2: EntityRef[Any] = imported()
@@ -1238,6 +1241,12 @@ class EntityRef[A: _BaseArchetype](Record):
             return hash(id(self._ref_))
         return super().__hash__()
 
+    @meta_fn
+    def __bool__(self):
+        if ctx():
+            static_error("EntityRef cannot be used in a boolean context. Check index directly instead.")
+        return True
+
     @meta_fn
     def get(self) -> A:
         """Get the entity."""

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/sonolus/script/containers.py

@@ -468,11 +468,8 @@ class FrozenNumSet[Size](Record):
         return len(self._values)
 
     def __contains__(self, value: Num) -> bool:
-        if len(self) < 15:
-            for i in range(len(self)):  # noqa: SIM110
-                if self._values.get_unchecked(i) == value:
-                    return True
-            return False
+        if len(self) < 8:
+            return value in self._as_tuple()
         else:
             left = 0
             right = len(self) - 1
@@ -490,6 +487,10 @@ class FrozenNumSet[Size](Record):
     def __iter__(self) -> SonolusIterator[Num]:
         return self._values.__iter__()
 
+    @meta_fn
+    def _as_tuple(self) -> tuple[Num, ...]:
+        return tuple(self._values.get_unchecked(i) for i in range(Num._accept_(len(self))._as_py_()))
+
 
 class _ArrayMapEntry[K, V](Record):
     key: K

sonolus_py-0.11.1/tests/script/test_frozen_num_set.py

@@ -0,0 +1,226 @@
+# ruff: noqa: FURB171
+import random
+
+from hypothesis import given
+from hypothesis import strategies as st
+
+from sonolus.script.array import Array
+from sonolus.script.debug import assert_true
+from tests.script.conftest import run_and_validate
+
+nums = st.one_of(
+    st.integers(min_value=-999, max_value=999),
+    st.floats(min_value=-999.0, max_value=999.0, allow_nan=False, allow_infinity=False),
+)
+
+
+@st.composite
+def set_and_present_value(draw, fixed_size: int | None = None):
+    values = draw(
+        st.sets(
+            nums, min_size=1 if fixed_size is None else fixed_size, max_size=20 if fixed_size is None else fixed_size
+        )
+    )
+    value = draw(st.sampled_from(list(values)))
+    return values, value
+
+
+@st.composite
+def set_and_missing_value(draw, fixed_size: int | None = None):
+    values = draw(
+        st.sets(
+            nums, min_size=1 if fixed_size is None else fixed_size, max_size=20 if fixed_size is None else fixed_size
+        )
+    )
+    missing = draw(nums.filter(lambda x: x not in values))
+    return values, missing
+
+
+def test_contains_basic():
+    def fn():
+        assert_true(2 in {1, 2, 3, 4, 5})
+        assert_true(5 in {1, 2, 3, 4, 5})
+        assert_true(6 not in {1, 2, 3, 4, 5})
+        assert_true(0 not in {1, 2, 3, 4, 5})
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_contains_out_of_order():
+    def fn():
+        assert_true(3 in {5, 1, 4, 2, 3})
+        assert_true(1 in {5, 1, 4, 2, 3})
+        assert_true(6 not in {5, 1, 4, 2, 3})
+        assert_true(0 not in {5, 1, 4, 2, 3})
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_contains_non_literal_contents():
+    def fn():
+        a = 5 * (random.random() != -1)
+        b = 4 * (random.random() != -1)
+        c = 3 * (random.random() != -1)
+        d = 2 * (random.random() != -1)
+        e = 1 * (random.random() != -1)
+        test_set = {a, b, c, d, e}
+        assert_true(2 in test_set)
+        assert_true(5 in test_set)
+        assert_true(6 not in test_set)
+        assert_true(0 not in test_set)
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_defined_outside():
+    test_set = {10, 20, 30, 40, 50}
+
+    def fn():
+        assert_true(10 in test_set)
+        assert_true(30 in test_set)
+        assert_true(50 in test_set)
+        assert_true(5 not in test_set)
+        assert_true(60 not in test_set)
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_defined_outside_frozenset():
+    test_set = frozenset({10, 20, 30, 40, 50})
+
+    def fn():
+        assert_true(10 in test_set)
+        assert_true(30 in test_set)
+        assert_true(50 in test_set)
+        assert_true(5 not in test_set)
+        assert_true(60 not in test_set)
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_empty():
+    empty_set = set()
+
+    def fn():
+        assert_true(0 not in empty_set)
+        assert_true(1 not in empty_set)
+        assert_true(0.0 not in empty_set)
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_single_element_set():
+    def fn():
+        assert_true(42 in {42})
+        assert_true(0 not in {42})
+        assert_true(41 not in {42})
+        assert_true(43 not in {42})
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_negative_numbers():
+    def fn():
+        assert_true(-5 in {-10, -5, 0, 5, 10})
+        assert_true(-10 in {-10, -5, 0, 5, 10})
+        assert_true(0 in {-10, -5, 0, 5, 10})
+        assert_true(-3 not in {-10, -5, 0, 5, 10})
+        assert_true(-15 not in {-10, -5, 0, 5, 10})
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+@given(set_and_present_value())
+def test_set_contains_present(args):
+    value_set, value = args
+
+    def fn():
+        return value in value_set
+
+    assert run_and_validate(fn)
+
+
+@given(set_and_missing_value())
+def test_set_contains_missing(args):
+    value_set, missing = args
+
+    def fn():
+        return missing in value_set
+
+    assert not run_and_validate(fn)
+
+
+@given(set_and_present_value(fixed_size=20))
+def test_dyn_set_contains_present(args):
+    value_set, value = args
+
+    def fn():
+        values = +Array[float, 20]
+        for i, v in enumerate(value_set):
+            values[i] = v * (random.random() != -1)
+        return value in {
+            values[0],
+            values[1],
+            values[2],
+            values[3],
+            values[4],
+            values[5],
+            values[6],
+            values[7],
+            values[8],
+            values[9],
+            values[10],
+            values[11],
+            values[12],
+            values[13],
+            values[14],
+            values[15],
+            values[16],
+            values[17],
+            values[18],
+            values[19],
+        }
+
+    assert run_and_validate(fn)
+
+
+@given(set_and_missing_value(fixed_size=20))
+def test_dyn_set_contains_missing(args):
+    value_set, missing = args
+
+    def fn():
+        values = +Array[float, 20]
+        for i, v in enumerate(value_set):
+            values[i] = v * (random.random() != -1)
+        return missing in {
+            values[0],
+            values[1],
+            values[2],
+            values[3],
+            values[4],
+            values[5],
+            values[6],
+            values[7],
+            values[8],
+            values[9],
+            values[10],
+            values[11],
+            values[12],
+            values[13],
+            values[14],
+            values[15],
+            values[16],
+            values[17],
+            values[18],
+            values[19],
+        }
+
+    assert not run_and_validate(fn)

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/tests/script/test_tuple.py

@@ -199,9 +199,9 @@ def test_tuple_contains_heterogeneous():
         return Array(
             5 in t,
             0 in t,
-            inner1 == t[0],
-            inner2 == t[1],
-            inner3 == t[0],
+            inner1 in t,
+            inner2 in t,
+            inner3 in t,
         )
 
     assert tuple(run_and_validate(fn)) == (True, False, True, True, False)

{sonolus_py-0.11.0 → sonolus_py-0.11.1}/uv.lock

@@ -727,7 +727,7 @@ wheels = [
 
 [[package]]
 name = "sonolus-py"
-version = "0.11.0"
+version = "0.11.1"
 source = { editable = "." }
 
 [package.dev-dependencies]

sonolus_py-0.11.0/sonolus/backend/node.py

@@ -1,48 +0,0 @@
-import textwrap
-from dataclasses import dataclass, field
-
-from sonolus.backend.ops import Op
-
-type EngineNode = ConstantNode | FunctionNode
-
-
-@dataclass(slots=True)
-class ConstantNode:
-    value: float
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash(self.value)
-
-    def __hash__(self):
-        return hash(self.value)
-
-
-@dataclass(slots=True)
-class FunctionNode:
-    func: Op
-    args: list[EngineNode]
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash((self.func, tuple(self.args)))
-
-    def __hash__(self):
-        return self._hash
-
-
-def format_engine_node(node: EngineNode) -> str:
-    if isinstance(node, ConstantNode):
-        return str(node.value)
-    elif isinstance(node, FunctionNode):
-        match len(node.args):
-            case 0:
-                return f"{node.func.name}()"
-            case 1:
-                return f"{node.func.name}({format_engine_node(node.args[0])})"
-            case _:
-                return f"{node.func.name}(\n{
-                    textwrap.indent('\n'.join(format_engine_node(arg) for arg in node.args), '  ')
-                }\n)"
-    else:
-        raise ValueError(f"Invalid engine node: {node}")