sonolus.py 0.10.9__tar.gz → 0.11.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.10.9
+Version: 0.11.0
 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.10.9 → sonolus_py-0.11.0}/docs/changelog/index.md

@@ -1,3 +1,10 @@
+### 0.11.0
+
+- Added basic support for set literals of numbers, with support for membership checks (`in`, `not in`) and iteration
+- Added support for membership checks (`in`, `not in`) of tuples
+- Fixed some instances where error messages for archetype declarations were not shown correctly
+- Reduced memory usage slightly
+
 ### 0.10.9
 
 - Added [`Vec2.normalize_or_zero()`][sonolus.script.vec.Vec2.normalize_or_zero]

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/docs/concepts/overview.md

@@ -195,6 +195,9 @@ assert record_1 == array_1[0] == MyRecord(4, 5.6)
 Sonolus.py has limited support for other types of values such as strings, tuples, and functions. These have restrictions
 such as not being valid as Record field types or Array element types.
 
+Support for `dict` is limited, and they are immutable and can only be accessed via compile-time constant keys. `set`
+literals of numeric values are supported, and they are immutable after creation.
+
 ## Modules
 
 Sonolus.py provides a number of built-in modules that can be used in Sonolus engines. These include:

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

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

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

@@ -65,7 +65,15 @@ def cfg_to_engine_node(entry: BasicBlock):
                     statements.append(FunctionNode(Op.SwitchWithDefault, args))
         block_statements.append(FunctionNode(Op.Execute, statements))
     block_statements.append(ConstantNode(value=0))
-    return FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+    result = FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+    for block in block_indexes:
+        # Clean up without relying on gc
+        del block.incoming
+        del block.outgoing
+        del block.phis
+        del block.statements
+        del block.test
+    return result
 
 
 def ir_to_engine_node(stmt) -> EngineNode:

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/sonolus/backend/optimize/liveness.py

@@ -24,15 +24,18 @@ class LivenessAnalysis(CompilerPass):
             block.live_phi_targets = set()
             block.array_defs_in = set()
             block.array_defs_out = None
+            last_live_set = set()
             for statement in block.statements:
-                statement.live = set()
+                if isinstance(statement, IRSet):
+                    last_live_set = set()
+                statement.live = last_live_set
                 statement.visited = False
                 statement.uses = self.get_uses(statement, set())
                 statement.defs = self.get_defs(statement)
                 statement.is_array_init = False  # True if this may be the first assignment to an array
                 statement.array_defs = self.get_array_defs(statement)
             if not isinstance(block.test, IRConst):
-                block.test.live = set()
+                block.test.live = last_live_set
                 block.test.uses = self.get_uses(block.test, set())
         self.preprocess_arrays(entry)
 

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/sonolus/backend/visitor.py

@@ -1006,7 +1006,9 @@ class Visitor(ast.NodeVisitor):
         return validate_value({self.visit(k): self.visit(v) for k, v in zip(node.keys, node.values, strict=True)})
 
     def visit_Set(self, node):
-        raise NotImplementedError("Set literals are not supported")
+        from sonolus.script.containers import FrozenNumSet
+
+        return self.handle_call(node, FrozenNumSet.of, *(self.visit(elt) for elt in node.elts))
 
     def visit_ListComp(self, node):
         raise NotImplementedError("List comprehensions are not supported")

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

@@ -3,6 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import Any, Protocol, Self
 
+from sonolus.backend.visitor import compile_and_call
 from sonolus.script.archetype import AnyArchetype, EntityRef
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
@@ -441,6 +442,55 @@ class ArraySet[T, Capacity](Record):
         self._values.clear()
 
 
+class FrozenNumSet[Size](Record):
+    _values: Array[Num, Size]
+
+    @classmethod
+    @meta_fn
+    def of(cls, *values: Num) -> Self:
+        if ctx():
+            try:
+                num_values = [Num._accept_(v) for v in values]
+            except TypeError:
+                raise TypeError("Only sets of numeric values are supported") from None
+            if all(v._is_py_() for v in num_values):
+                const_values = [v._as_py_() for v in num_values]
+                arr = Array[Num, len(const_values)]._with_value([Num(v) for v in sorted(const_values)])
+                return cls(arr)
+            else:
+                arr = Array[Num, len(values)](*values)
+                compile_and_call(arr.sort)
+        else:
+            arr = Array[Num, len(values)](*sorted(values))
+        return cls(arr)
+
+    def __len__(self) -> int:
+        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
+        else:
+            left = 0
+            right = len(self) - 1
+            while left <= right:
+                mid = (left + right) // 2
+                mid_value = self._values.get_unchecked(mid)
+                if mid_value == value:
+                    return True
+                elif mid_value < value:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+            return False
+
+    def __iter__(self) -> SonolusIterator[Num]:
+        return self._values.__iter__()
+
+
 class _ArrayMapEntry[K, V](Record):
     key: K
     value: V

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/sonolus/script/internal/context.py

@@ -551,7 +551,11 @@ def context_to_cfg(context: Context) -> BasicBlock:
             edge = FlowEdge(src=blocks[current], dst=blocks[target], cond=condition)
             blocks[current].outgoing.add(edge)
             blocks[target].incoming.add(edge)
-    return blocks[context]
+    result = blocks[context]
+    for current in tuple(iter_contexts(context)):
+        # Break cycles so memory can be cleaned without gc
+        del current.outgoing
+    return result
 
 
 def unique[T](iterable: Iterable[T]) -> list[T]:

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/sonolus/script/internal/impl.py

@@ -77,6 +77,10 @@ def try_validate_value(value: Any) -> Value | None:
             return TupleImpl._accept_(value)
         case dict():
             return DictImpl._accept_(value)
+        case set() | frozenset():
+            from sonolus.script.containers import FrozenNumSet
+
+            return FrozenNumSet.of(*value)
         case (
             PartialGeneric()
             | TypeVar()
@@ -90,11 +94,7 @@ def try_validate_value(value: Any) -> Value | None:
             | super()
         ):
             return BasicConstantValue.of(value)
-        case special_form if value in {
-            Literal,
-            Annotated,
-            Union,
-        }:
+        case special_form if value == Literal or value == Annotated or value == Union:  # noqa: PLR1714, SIM109
             return TypingSpecialFormConstant.of(special_form)
         case other_type if get_origin(value) in {Literal, Annotated, UnionType, tuple, type}:
             return BasicConstantValue.of(other_type)

{sonolus_py-0.10.9 → sonolus_py-0.11.0}/sonolus/script/internal/tuple_impl.py

@@ -91,6 +91,12 @@ class TupleImpl(TransientValue):
         other = TupleImpl._accept_(other)
         return TupleImpl._accept_(self.value + other.value)
 
+    def __contains__(self, item):
+        for element in self.value:  # noqa: SIM110
+            if element == item:
+                return True
+        return False
+
     @staticmethod
     @meta_fn
     def _is_tuple_impl(value: Any) -> bool:

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

@@ -138,3 +138,70 @@ def test_min_tuples(values_list):
         return min(values)
 
     assert run_and_validate(fn) == min(values)
+
+
+def test_tuple_contains_basic():
+    def fn():
+        t = (1, 2, 3, 4, 5)
+        return Array(
+            1 in t,
+            5 in t,
+            0 in t,
+            6 in t,
+            3 in t,
+        )
+
+    assert tuple(run_and_validate(fn)) == (True, True, False, False, True)
+
+
+def test_tuple_contains_empty():
+    def fn():
+        t = ()
+        return Array(
+            1 in t,
+            0 in t,
+        )
+
+    assert tuple(run_and_validate(fn)) == (False, False)
+
+
+def test_tuple_contains_single_element():
+    def fn():
+        t = (42,)
+        return Array(
+            42 in t,
+            0 in t,
+            1 in t,
+        )
+
+    assert tuple(run_and_validate(fn)) == (True, False, False)
+
+
+def test_tuple_contains_duplicates():
+    def fn():
+        t = (1, 2, 2, 3, 3, 3)
+        return Array(
+            1 in t,
+            2 in t,
+            3 in t,
+            4 in t,
+        )
+
+    assert tuple(run_and_validate(fn)) == (True, True, True, False)
+
+
+def test_tuple_contains_heterogeneous():
+    def fn():
+        t = ((1, 2), (3, 4), 5)
+        inner1 = (1, 2)
+        inner2 = (3, 4)
+        inner3 = (1, 3)
+        return Array(
+            5 in t,
+            0 in t,
+            inner1 == t[0],
+            inner2 == t[1],
+            inner3 == t[0],
+        )
+
+    assert tuple(run_and_validate(fn)) == (True, False, True, True, False)

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

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

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

@@ -581,7 +581,6 @@ class _BaseArchetype:
     def _init_fields(cls):
         if cls._field_init_done:
             return
-        cls._field_init_done = True
         for mro_entry in cls.mro()[1:]:
             if hasattr(mro_entry, "_field_init_done"):
                 mro_entry._init_fields()
@@ -706,6 +705,7 @@ class _BaseArchetype:
             [inspect.Parameter(name, inspect.Parameter.POSITIONAL_OR_KEYWORD) for name in cls._memory_fields_]
         )
         cls._post_init_fields()
+        cls._field_init_done = True
 
     @property
     @abstractmethod