sonolus.py 0.4.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

sonolus/backend/utils.py

@@ -23,29 +23,33 @@ def get_tree_from_file(file: str | Path) -> ast.Module:
 class FindFunction(ast.NodeVisitor):
     def __init__(self, line):
         self.line = line
-        self.node: ast.FunctionDef | None = None
+        self.results: list[ast.FunctionDef | ast.Lambda] = []
 
     def visit_FunctionDef(self, node: ast.FunctionDef):
-        if node.lineno == self.line or (
-            node.decorator_list and (node.decorator_list[-1].end_lineno <= self.line <= node.lineno)
-        ):
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        self.generic_visit(node)
 
     def visit_Lambda(self, node: ast.Lambda):
-        if node.lineno == self.line:
-            if self.node is not None:
-                raise ValueError("Multiple functions defined on the same line are not supported")
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        self.generic_visit(node)
 
 
-def find_function(tree: ast.Module, line: int):
-    visitor = FindFunction(line)
+@cache
+def get_functions(tree: ast.Module) -> list[ast.FunctionDef | ast.Lambda]:
+    visitor = FindFunction(0)
     visitor.visit(tree)
-    return visitor.node
+    return visitor.results
+
+
+def find_function(tree: ast.Module, line: int):
+    for node in get_functions(tree):
+        if node.lineno == line or (
+            isinstance(node, ast.FunctionDef)
+            and node.decorator_list
+            and (node.decorator_list[-1].end_lineno <= line <= node.lineno)
+        ):
+            return node
+    raise ValueError("Function not found")
 
 
 class ScanWrites(ast.NodeVisitor):

sonolus/backend/visitor.py

@@ -261,7 +261,21 @@ class Visitor(ast.NodeVisitor):
                 result = self.visit(body)
                 ctx().scope.set_value("$return", result)
             case ast.GeneratorExp(elt=elt, generators=generators):
-                self.construct_genexpr(generators, elt)
+                first_generator = generators[0]
+                iterable = self.visit(first_generator.iter)
+                if isinstance(iterable, TupleImpl):
+                    initial_iterator = iterable
+                else:
+                    if not hasattr(iterable, "__iter__"):
+                        raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                    initial_iterator = self.handle_call(first_generator.iter, iterable.__iter__)
+                    if not isinstance(initial_iterator, SonolusIterator):
+                        raise ValueError("Unsupported iterator")
+                # The initial iterator is evaluated eagerly in Python
+                before_ctx = ctx().branch_with_scope(None, before_ctx.scope.copy())
+                start_ctx = before_ctx.branch_with_scope(None, Scope())
+                set_ctx(start_ctx)
+                self.construct_genexpr(generators, elt, initial_iterator)
                 ctx().scope.set_value("$return", validate_value(None))
             case _:
                 raise NotImplementedError("Unsupported syntax")
@@ -323,7 +337,9 @@ class Visitor(ast.NodeVisitor):
         set_ctx(after_ctx.branch_with_scope(None, before_ctx.scope.copy()))
         return result_binding.value
 
-    def construct_genexpr(self, generators: Iterable[ast.comprehension], elt: ast.expr):
+    def construct_genexpr(
+        self, generators: Iterable[ast.comprehension], elt: ast.expr, initial_iterator: Value | None = None
+    ):
         if not generators:
             # Note that there may effectively be multiple yields in an expression since
             # tuples are unrolled.
@@ -335,14 +351,22 @@ class Visitor(ast.NodeVisitor):
             set_ctx(resume_ctx)
             return
         generator, *others = generators
-        iterable = self.visit(generator.iter)
+        if initial_iterator is not None:
+            iterable = initial_iterator
+        else:
+            iterable = self.visit(generator.iter)
         if isinstance(iterable, TupleImpl):
             for value in iterable.value:
                 set_ctx(ctx().branch(None))
                 self.handle_assign(generator.target, validate_value(value))
                 self.construct_genexpr(others, elt)
         else:
-            iterator = self.handle_call(generator.iter, iterable.__iter__)
+            if initial_iterator is not None:
+                iterator = initial_iterator
+            else:
+                if not hasattr(iterable, "__iter__"):
+                    raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                iterator = self.handle_call(generator.iter, iterable.__iter__)
             if not isinstance(iterator, SonolusIterator):
                 raise ValueError("Unsupported iterator")
             header_ctx = ctx().branch(None)
@@ -493,6 +517,8 @@ class Visitor(ast.NodeVisitor):
             if break_ctxs:
                 set_ctx(Context.meet([*break_ctxs, ctx()]))
             return
+        if not hasattr(iterable, "__iter__"):
+            raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
         iterator = self.handle_call(node, iterable.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Unsupported iterator")
@@ -980,6 +1006,8 @@ class Visitor(ast.NodeVisitor):
                 self.resume_ctxs.append(resume_ctx)
                 set_ctx(resume_ctx)
             return validate_value(None)
+        if not hasattr(value, "__iter__"):
+            raise TypeError(f"Object of type '{type(value).__name__}' is not iterable")
         iterator = self.handle_call(node, value.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Expected a SonolusIterator")

sonolus/script/containers.py

@@ -337,7 +337,7 @@ class ArrayPointer[T](Record, ArrayLike[T]):
             raise TypeError("ArrayPointer values cannot be accessed outside of a context")
         return _deref(
             # Allows a compile time constant block so we can warn based on callback read/write access
-            (self._value["block"]._is_py_() and self._value["block"]._as_py_()) or self.block,
+            (self._value_["block"]._is_py_() and self._value_["block"]._as_py_()) or self.block,
             self.offset + Num._accept_(item) * Num._accept_(self.element_type()._size_()),
             self.element_type(),
         )

sonolus/script/iterator.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import Any
 
+from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn
 from sonolus.script.maybe import Maybe, Nothing, Some
 from sonolus.script.record import Record
@@ -114,3 +116,16 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
             inside = value.get_unsafe()
             if self.fn(inside):
                 return Some(inside)
+
+
+@meta_fn
+def maybe_next[T](iterator: Iterator[T]) -> Maybe[T]:
+    """Get the next item from an iterator as a `Maybe` if it exists or `Nothing` otherwise."""
+    from sonolus.backend.visitor import compile_and_call
+
+    if not isinstance(iterator, SonolusIterator):
+        raise TypeError("Iterator must be an instance of SonolusIterator.")
+    if ctx():
+        return compile_and_call(iterator.next)
+    else:
+        return iterator.next()

sonolus/script/level.py

@@ -145,7 +145,7 @@ class Level:
         )
 
 
-type EntityListArg = list[PlayArchetype | EntityListArg]
+type EntityListArg = list[list[PlayArchetype] | PlayArchetype] | PlayArchetype
 
 
 def flatten_entities(entities: EntityListArg) -> Iterator[PlayArchetype]:
@@ -175,7 +175,7 @@ class LevelData:
     bgm_offset: float
     entities: list[PlayArchetype]
 
-    def __init__(self, bgm_offset: float, entities: list[PlayArchetype]) -> None:
+    def __init__(self, bgm_offset: float, entities: EntityListArg) -> None:
         self.bgm_offset = bgm_offset
         self.entities = [*flatten_entities(entities)]
 

sonolus/script/maybe.py

@@ -4,10 +4,11 @@ from collections.abc import Callable
 from typing import Any
 
 from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.transient import TransientValue
 from sonolus.script.internal.value import Value
 from sonolus.script.num import Num
+from sonolus.script.values import copy, zeros
 
 
 class Maybe[T](TransientValue):
@@ -38,13 +39,16 @@ class Maybe[T](TransientValue):
 
     def __init__(self, *, present: bool, value: T):
         self._present = Num._accept_(present)
-        self._value = value
+        self._value = validate_value(value)
 
     @property
     @meta_fn
     def is_some(self) -> bool:
         """Check if the value is present."""
         if ctx():
+            if self._present._is_py_():
+                # Makes this a compile time constant.
+                return self._present
             return self._present._get_readonly_()
         else:
             return self._present._as_py_()
@@ -61,13 +65,104 @@ class Maybe[T](TransientValue):
 
     @meta_fn
     def get_unsafe(self) -> T:
-        return self._value
+        if ctx():
+            return self._value
+        else:
+            return self._value._as_py_()
 
     def map[R](self, fn: Callable[[T], R], /) -> Maybe[R]:
+        """Map the contained value to a new value using the provided function.
+
+        If the value is not present, returns `Nothing`.
+
+        Args:
+            fn: A function that takes the contained value and returns a new value.
+
+        Returns:
+            A `Maybe` instance containing the result of the function if the value is present, otherwise `Nothing`.
+        """
         if self.is_some:
             return Some(fn(self.get_unsafe()))
         return Nothing
 
+    def flat_map[R](self, fn: Callable[[T], Maybe[R]], /) -> Maybe[R]:
+        """Flat map the contained value to a new `Maybe` using the provided function.
+
+        If the value is not present, returns `Nothing`.
+
+        Args:
+            fn: A function that takes the contained value and returns a new `Maybe`.
+
+        Returns:
+            A `Maybe` instance containing the result of the function if the value is present, otherwise `Nothing`.
+        """
+        if self.is_some:
+            return fn(self.get_unsafe())
+        return Nothing
+
+    def or_default(self, default: T) -> T:
+        """Return a copy of the contained value if present, otherwise return a copy of the given default value.
+
+        Args:
+            default: The default value to return if the contained value is not present.
+
+        Returns:
+            A copy of the contained value if present, otherwise a copy of the default value.
+        """
+        result = _box(copy(default))
+        if self.is_some:
+            result.value = self.get_unsafe()
+        return result.value
+
+    @meta_fn
+    def or_else(self, fn: Callable[[], T], /) -> T:
+        """Return a copy of the contained value if present, otherwise return a copy of the result of the given function.
+
+        Args:
+            fn: A function that returns a value to use if the contained value is not present.
+
+        Returns:
+            A copy of the contained value if present, otherwise a copy of the result of calling the function.
+        """
+        from sonolus.backend.visitor import compile_and_call
+
+        if ctx():
+            if self.is_some._is_py_():  # type: ignore
+                if self.is_some._as_py_():  # type: ignore
+                    return copy(self.get_unsafe())
+                else:
+                    return copy(compile_and_call(fn))
+            else:
+                return compile_and_call(self._or_else, fn)
+        elif self.is_some:
+            return copy(self.get_unsafe())
+        else:
+            return copy(fn())
+
+    def _or_else(self, fn: Callable[[], T], /) -> T:
+        result = _box(zeros(self.contained_type))
+        if self.is_some:
+            result.value = self.get_unsafe()
+        else:
+            result.value = fn()
+        return result.value
+
+    @property
+    def tuple(self) -> tuple[bool, T]:
+        """Return whether the value is present and a copy of the contained value if present as a tuple.
+
+        If the value is not present, the tuple will contain `False` and a zero initialized value of the contained type.
+        """
+        result_value = _box(zeros(self.contained_type))
+        if self.is_some:
+            result_value.value = self.get_unsafe()
+        return self.is_some, result_value.value
+
+    @property
+    @meta_fn
+    def contained_type(self):
+        return type(self._value)
+
     @classmethod
     def _accepts_(cls, value: Any) -> bool:
         return isinstance(value, cls)
@@ -137,3 +232,10 @@ Nothing: Maybe[Any] = Maybe(present=False, value=None)  # type: ignore
 # Note: has to come after the definition to hide the definition in the docs.
 Nothing: Maybe[Any]
 """The empty `Maybe` instance."""
+
+
+@meta_fn
+def _box(value):
+    from sonolus.script.containers import Box
+
+    return Box(value)

sonolus/script/num.py

@@ -453,14 +453,14 @@ if TYPE_CHECKING:
     from typing import Protocol
 
     @runtime_checkable
-    class Num[T](Protocol, int, bool, float):
-        def __add__(self, other: T, /) -> Num | int | bool | float: ...
-        def __sub__(self, other: T, /) -> Num | int | bool | float: ...
-        def __mul__(self, other: T, /) -> Num | int | bool | float: ...
-        def __truediv__(self, other: T, /) -> Num | int | bool | float: ...
-        def __floordiv__(self, other: T, /) -> Num | int | bool | float: ...
-        def __mod__(self, other: T, /) -> Num | int | bool | float: ...
-        def __pow__(self, other: T, /) -> Num | int | bool | float: ...
+    class Num(Protocol, int, bool, float):
+        def __add__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __sub__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __mul__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __truediv__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __floordiv__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __mod__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __pow__(self, other: Any, /) -> Num | int | bool | float: ...
 
         def __neg__(self, /) -> Num | int | bool | float: ...
         def __pos__(self, /) -> Num | int | bool | float: ...
@@ -468,10 +468,10 @@ if TYPE_CHECKING:
 
         def __eq__(self, other: Any, /) -> bool: ...
         def __ne__(self, other: Any, /) -> bool: ...
-        def __lt__(self, other: T, /) -> bool: ...
-        def __le__(self, other: T, /) -> bool: ...
-        def __gt__(self, other: T, /) -> bool: ...
-        def __ge__(self, other: T, /) -> bool: ...
+        def __lt__(self, other: Any, /) -> bool: ...
+        def __le__(self, other: Any, /) -> bool: ...
+        def __gt__(self, other: Any, /) -> bool: ...
+        def __ge__(self, other: Any, /) -> bool: ...
 
         def __hash__(self, /) -> int: ...
 

sonolus/script/project.py

@@ -41,7 +41,7 @@ class Project:
         self._levels = None
         self.resources = Path(resources or "resources")
 
-    def with_levels(self, levels: list[Level]) -> Project:
+    def with_levels(self, levels: Iterable[Level] | Callable[[], Iterable[Level]] | None) -> Project:
         """Create a new project with the specified levels.
 
         Args:

sonolus/script/record.py

@@ -62,13 +62,13 @@ class Record(GenericValue, metaclass=RecordMeta):
         ```
     """
 
-    _value: dict[str, Value]
-    _fields: ClassVar[list[_RecordField] | None] = None
-    _constructor_signature: ClassVar[inspect.Signature]
+    _value_: dict[str, Value]
+    _fields_: ClassVar[list[_RecordField] | None] = None
+    _constructor_signature_: ClassVar[inspect.Signature]
 
     @classmethod
     def _validate_type_args_(cls, args: tuple[Any, ...]) -> tuple[Any, ...]:
-        if cls._fields is None:
+        if cls._fields_ is None:
             raise TypeError("Base Record class cannot have type arguments")
         return super()._validate_type_args_(args)
 
@@ -80,16 +80,16 @@ class Record(GenericValue, metaclass=RecordMeta):
         if is_parameterizing:
             fields = []
             offset = 0
-            for generic_field in cls._fields:
+            for generic_field in cls._fields_:
                 resolved_type = validate_and_resolve_type(generic_field.type, cls._type_vars_to_args_)
                 resolved_type = validate_concrete_type(resolved_type)
                 field = _RecordField(generic_field.name, resolved_type, generic_field.index, offset)
                 fields.append(field)
                 setattr(cls, field.name, field)
                 offset += resolved_type._size_()
-            cls._fields = fields
+            cls._fields_ = fields
             return
-        is_inheriting_from_existing_record_class = cls._fields is not None
+        is_inheriting_from_existing_record_class = cls._fields_ is not None
         if is_inheriting_from_existing_record_class and not is_parameterizing:
             # The main reason this is disallowed is that subclasses wouldn't be substitutable for their parent classes
             # Assignment of a subclass instance to a variable of the parent class would either be disallowed or would
@@ -124,8 +124,8 @@ class Record(GenericValue, metaclass=RecordMeta):
             )
 
         cls._parameterized_ = {}
-        cls._fields = fields
-        cls._constructor_signature = inspect.Signature(params)
+        cls._fields_ = fields
+        cls._constructor_signature_ = inspect.Signature(params)
 
         _add_inplace_ops(cls)
 
@@ -139,13 +139,13 @@ class Record(GenericValue, metaclass=RecordMeta):
 
     def __new__(cls, *args, **kwargs):
         # We override __new__ to allow changing to the parameterized version
-        if cls._constructor_signature is None:
+        if cls._constructor_signature_ is None:
             raise TypeError(f"Cannot instantiate {cls.__name__}")
-        bound = cls._constructor_signature.bind(*args, **kwargs)
+        bound = cls._constructor_signature_.bind(*args, **kwargs)
         bound.apply_defaults()
         values = {}
         type_vars = {}
-        for field in cls._fields:
+        for field in cls._fields_:
             value = bound.arguments[field.name]
             value = accept_and_infer_types(field.type, value, type_vars)
             values[field.name] = value._get_()
@@ -158,7 +158,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         else:
             parameterized = cls[type_args]
         result: cls = object.__new__(parameterized)  # type: ignore
-        result._value = values
+        result._value_ = values
         return result
 
     def __init__(self, *args, **kwargs):
@@ -168,12 +168,12 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _raw(cls, **kwargs) -> Self:
         result = object.__new__(cls)
-        result._value = kwargs
+        result._value_ = kwargs
         return result
 
     @classmethod
     def _size_(cls) -> int:
-        return sum(field.type._size_() for field in cls._fields)
+        return sum(field.type._size_() for field in cls._fields_)
 
     @classmethod
     def _is_value_type_(cls) -> bool:
@@ -182,18 +182,18 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _from_backing_source_(cls, source: BackingSource) -> Self:
         result = object.__new__(cls)
-        result._value = {
+        result._value_ = {
             field.name: field.type._from_backing_source_(
                 lambda offset, field_offset=field.offset: source((Num(offset) + Num(field_offset)).ir())  # type: ignore
             )
-            for field in cls._fields
+            for field in cls._fields_
         }
         return result
 
     @classmethod
     def _from_place_(cls, place: BlockPlace) -> Self:
         result = object.__new__(cls)
-        result._value = {field.name: field.type._from_place_(place.add_offset(field.offset)) for field in cls._fields}
+        result._value_ = {field.name: field.type._from_place_(place.add_offset(field.offset)) for field in cls._fields_}
         return result
 
     @classmethod
@@ -207,7 +207,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         return value
 
     def _is_py_(self) -> bool:
-        return all(value._is_py_() for value in self._value.values())
+        return all(value._is_py_() for value in self._value_.values())
 
     def _as_py_(self) -> Self:
         if not self._is_py_():
@@ -217,18 +217,18 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _from_list_(cls, values: Iterable[DataValue]) -> Self:
         iterator = iter(values)
-        return cls(**{field.name: field.type._from_list_(iterator) for field in cls._fields})
+        return cls(**{field.name: field.type._from_list_(iterator) for field in cls._fields_})
 
     def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         result = []
-        for field in self._fields:
-            result.extend(self._value[field.name]._to_list_(level_refs))
+        for field in self._fields_:
+            result.extend(self._value_[field.name]._to_list_(level_refs))
         return result
 
     @classmethod
     def _flat_keys_(cls, prefix: str) -> list[str]:
         result = []
-        for field in cls._fields:
+        for field in cls._fields_:
             result.extend(field.type._flat_keys_(f"{prefix}.{field.name}"))
         return result
 
@@ -240,33 +240,33 @@ class Record(GenericValue, metaclass=RecordMeta):
 
     def _copy_from_(self, value: Any):
         value = self._accept_(value)
-        for field in self._fields:
+        for field in self._fields_:
             field.__set__(self, field.__get__(value))
 
     def _copy_(self) -> Self:
-        return type(self)._raw(**{field.name: self._value[field.name]._copy_() for field in self._fields})
+        return type(self)._raw(**{field.name: self._value_[field.name]._copy_() for field in self._fields_})
 
     @classmethod
     def _alloc_(cls) -> Self:
         # Compared to using the constructor, this avoids unnecessary _get_ calls
         result = object.__new__(cls)
-        result._value = {field.name: field.type._alloc_() for field in cls._fields}
+        result._value_ = {field.name: field.type._alloc_() for field in cls._fields_}
         return result
 
     @classmethod
     def _zero_(cls) -> Self:
         result = object.__new__(cls)
-        result._value = {field.name: field.type._zero_() for field in cls._fields}
+        result._value_ = {field.name: field.type._zero_() for field in cls._fields_}
         return result
 
     def __str__(self):
         return f"{self.__class__.__name__}({
-            ', '.join(f'{field.name}={field.get_internal(self)}' for field in self._fields)
+            ', '.join(f'{field.name}={field.get_internal(self)}' for field in self._fields_)
         })"
 
     def __repr__(self):
         return f"{self.__class__.__name__}({
-            ', '.join(f'{field.name}={field.get_internal(self)!r}' for field in self._fields)
+            ', '.join(f'{field.name}={field.get_internal(self)!r}' for field in self._fields_)
         })"
 
     @meta_fn
@@ -274,7 +274,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         if not isinstance(other, type(self)):
             return False
         result: Num = Num._accept_(True)
-        for field in self._fields:
+        for field in self._fields_:
             result = result.and_(field.__get__(self) == field.__get__(other))
         return result
 
@@ -283,12 +283,12 @@ class Record(GenericValue, metaclass=RecordMeta):
         if not isinstance(other, type(self)):
             return True
         result: Num = Num._accept_(False)
-        for field in self._fields:
+        for field in self._fields_:
             result = result.or_(field.__get__(self) != field.__get__(other))
         return result
 
     def __hash__(self):
-        return hash(tuple(field.__get__(self) for field in self._fields))
+        return hash(tuple(field.__get__(self) for field in self._fields_))
 
     @meta_fn
     def __pos__(self) -> Self:
@@ -317,12 +317,12 @@ class _RecordField(SonolusDescriptor):
         self.offset = offset
 
     def get_internal(self, instance: Record) -> Value:
-        return instance._value[self.name]
+        return instance._value_[self.name]
 
     def __get__(self, instance: Record | None, owner=None):
         if instance is None:
             return self
-        result = instance._value[self.name]._get_readonly_()
+        result = instance._value_[self.name]._get_readonly_()
         if ctx():
             return result
         else:
@@ -331,9 +331,9 @@ class _RecordField(SonolusDescriptor):
     def __set__(self, instance: Record, value):
         value = self.type._accept_(value)
         if self.type._is_value_type_():
-            instance._value[self.name]._set_(value)
+            instance._value_[self.name]._set_(value)
         else:
-            instance._value[self.name]._copy_from_(value)
+            instance._value_[self.name]._copy_from_(value)
 
 
 _ops_to_inplace_ops = {

{sonolus_py-0.4.0.dist-info → sonolus_py-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.4.0
+Version: 0.4.1
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.12

{sonolus_py-0.4.0.dist-info → sonolus_py-0.4.1.dist-info}/RECORD

@@ -10,8 +10,8 @@ sonolus/backend/mode.py,sha256=NkcPZJm8dn83LX35uP24MtQOCnfRDFZ280dHeEEfauE,613
 sonolus/backend/node.py,sha256=eEzPP14jzWJp2xrZCAaPlNtokxdoqg0bSM7xQiwx1j8,1254
 sonolus/backend/ops.py,sha256=5weB_vIxbkwCSJuzYZyKUk7vVXsSIEDJYRlvE-2ke8A,10572
 sonolus/backend/place.py,sha256=7qwV732hZ4WP-9GNN8FQSEKssPJZELip1wLXTWfop7Y,4717
-sonolus/backend/utils.py,sha256=QM0VMYfDmkqRkaSq0y0DagKPTMbD-NTOnMKFNoQQLHk,2387
-sonolus/backend/visitor.py,sha256=sxg64PLxakHaA7w6eGD5XMGBDXxJM5Hjp1ZE5-FZ1m0,60570
+sonolus/backend/utils.py,sha256=c8zje-7-lmRHW14YbVZPGbLbvN9pe3eFqTRus5i2NR8,2441
+sonolus/backend/visitor.py,sha256=NIs3OPBhGoHjoApem2MSLxqKwhA8xvuVSxKJlG3HrMI,62160
 sonolus/backend/optimize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/backend/optimize/allocate.py,sha256=CuumoMphkpQlGRNeKLHT4FBGE0XVj5pwhfNdrqiLFSs,7535
 sonolus/backend/optimize/constant_evaluation.py,sha256=OyjlgHIT6oPKCyBtNzEpo1nWYjr-_mwYUo8FrNV4eO4,21331
@@ -38,7 +38,7 @@ sonolus/script/archetype.py,sha256=vNNX6YGi_CUQcjf0xG1Rkpz9kUd_84hEPuY1Ew9uFxA,4
 sonolus/script/array.py,sha256=lnobVrrEOE6PgPasq3DovrshlDKPbX8kKUsGmJz2oK0,12360
 sonolus/script/array_like.py,sha256=jFOfXkniTLrIK4ER6HO_tUyKn_TvwjyM4B3SDd9cUS8,9678
 sonolus/script/bucket.py,sha256=5VU-Bh7qYifl6NcgZFCo7eAEgi3iGTX-PUTmXiPCJaQ,7535
-sonolus/script/containers.py,sha256=O1Pjfpz9RmbdSTBi5yqzyoxfhnl_Zk0fiSTUfHBO0lE,18667
+sonolus/script/containers.py,sha256=FDz3cJlxUdxtXe_vbmuonob1xnb_QzH66uVF--bfDu0,18669
 sonolus/script/debug.py,sha256=_Hg1cXQJ8fBXMiwhmoPb2X9CKcQ8QO26WNa59K518og,4305
 sonolus/script/easing.py,sha256=7zaDKIfM_whUpb4FBz1DAF4NNG2vk_nDjl8kL2Y90aU,11396
 sonolus/script/effect.py,sha256=pqfsOhmGVDMkifumkRr9rD2trWZU6Rw-_gTApNIaz7g,5854
@@ -46,18 +46,18 @@ sonolus/script/engine.py,sha256=etI9dJsQ7V9YZICVNZg54WqpLijPxG8eTPHiV-_EiG8,1068
 sonolus/script/globals.py,sha256=FOv8uiLM5U6X-yMLCXukMvLgV3rs-xVJbobST_MhLcU,9782
 sonolus/script/instruction.py,sha256=iBjY7nCNDT3w0SBJKlix3Z-85e7eE2qKeHp6C2Nq7KA,6753
 sonolus/script/interval.py,sha256=dj6F2wn5uP6I6_mcZn-wIREgRUQbsLzhvhzB0oEyAdU,11290
-sonolus/script/iterator.py,sha256=LqXi6062G-vLa3taxFz3IsWwFsFrOwfxx7_0aWDi4as,3070
-sonolus/script/level.py,sha256=wR23xk-NOcW_JMRb3R12sqIXCLSZL-7cM3y7IpMF1J0,6333
-sonolus/script/maybe.py,sha256=p2fGgdtNlnozkJ80pOLoo9-M0dp2iKRtLT5RXf-JF4U,4199
+sonolus/script/iterator.py,sha256=ESZ3opzDTXmkRMxF8itp9_bywXDiufn9cRtgWAw9m-w,3601
+sonolus/script/level.py,sha256=vnotMbdr_4-MJUsTXMbvWiw2MlMjMHme3q0XRdNFXRg,6349
+sonolus/script/maybe.py,sha256=UfF26g6BF_KGuHYGuEeuxeGKSmIH-fYAVHi9I-adp9E,7785
 sonolus/script/metadata.py,sha256=ttRK27eojHf3So50KQJ-8yj3udZoN1bli5iD-knaeLw,753
-sonolus/script/num.py,sha256=uGNBnpE3AAGA1yo0_SADZ57raWowpcsE0DEopgjpohI,16022
+sonolus/script/num.py,sha256=924kWWZusW7oaWuvtQzdAMzkb4ZItWSJwNj3W9XrqZU,16041
 sonolus/script/options.py,sha256=KlOud4QOf_lW1o6avKXbkjcMCDPkhLcEwt5PW7ZCH3s,9435
 sonolus/script/particle.py,sha256=XczhwTJvU3dMOXXTxJI_5Mskro2LgVlNgrCSwYreO0Q,8369
 sonolus/script/pointer.py,sha256=FoOfyD93r0G5d_2BaKfeOT9SqkOP3hq6sqtOs_Rb0c8,1511
 sonolus/script/printing.py,sha256=mNYu9QWiacBBGZrnePZQMVwbbguoelUps9GiOK_aVRU,2096
-sonolus/script/project.py,sha256=IyWMM-Sf7-Kd0AHzlAUyJBKBWRRX2rOpjlN7b8UOTE8,3966
+sonolus/script/project.py,sha256=2XVUXcW49iiTfljvcFuYqtFzqhQIRvD7H7OwH1Mm98w,4009
 sonolus/script/quad.py,sha256=XoAjaUqR60zIrC_CwheZs7HwS-DRS58yUmlj9GIjX7k,11179
-sonolus/script/record.py,sha256=JiRvI_uZjJ-DWzfbsOHDfrOUxO3ZlRPxJP90Hc0z9hM,12673
+sonolus/script/record.py,sha256=-Ff60wBoF1v4-MJWzCNI9n5K3os6WphswZpdTBezeRs,12713
 sonolus/script/runtime.py,sha256=rJZM_KbKmnwpjhDEpR0DrM6EMSEu46apIErWA_pfLJA,33321
 sonolus/script/sprite.py,sha256=mMDTXckn58YR8mrx3fzdBaduQ8cn9YTtTVruXXK1ow0,16272
 sonolus/script/stream.py,sha256=4b0AV5MRPo4wzTHmaN95jwODxPVt6WuN3QxmGccdwRU,24517
@@ -86,8 +86,8 @@ sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDw
 sonolus/script/internal/transient.py,sha256=y2AWABqF1aoaP6H4_2u4MMpNioC4OsZQCtPyNI0txqo,1634
 sonolus/script/internal/tuple_impl.py,sha256=DPNdmmRmupU8Ah4_XKq6-PdT336l4nt15_uCJKQGkkk,3587
 sonolus/script/internal/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.4.0.dist-info/METADATA,sha256=5YcGXNkUzFc1F27UWp_AeCbWPjEuOLJviTkIoVgdTxw,302
-sonolus_py-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.4.0.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.4.0.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.4.0.dist-info/RECORD,,
+sonolus_py-0.4.1.dist-info/METADATA,sha256=WBzfeJ7FRbh942MqkM1vjS7k98pHoZ52YsseEMn9OlY,302
+sonolus_py-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.4.1.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.4.1.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.4.1.dist-info/RECORD,,