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

sonolus/backend/utils.py

@@ -23,29 +23,48 @@ 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] = []
+        self.current_fn = None
 
     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)
+        outer_fn = self.current_fn
+        self.current_fn = node
+        self.generic_visit(node)
+        self.current_fn = outer_fn
 
     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)
+        outer_fn = self.current_fn
+        self.current_fn = node
+        self.generic_visit(node)
+        self.current_fn = outer_fn
 
+    # Visitors have high overhead, so we detect generators here rather than in a separate pass.
 
-def find_function(tree: ast.Module, line: int):
-    visitor = FindFunction(line)
+    def visit_Yield(self, node):
+        self.current_fn.has_yield = True
+
+    def visit_YieldFrom(self, node):
+        self.current_fn.has_yield = True
+
+
+@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):
@@ -61,27 +80,3 @@ def scan_writes(node: ast.AST) -> set[str]:
     visitor = ScanWrites()
     visitor.visit(node)
     return set(visitor.writes)
-
-
-class HasDirectYield(ast.NodeVisitor):
-    def __init__(self):
-        self.started = False
-        self.has_yield = False
-
-    def visit_Yield(self, node: ast.Yield):
-        self.has_yield = True
-
-    def visit_YieldFrom(self, node: ast.YieldFrom):
-        self.has_yield = True
-
-    def visit_FunctionDef(self, node: ast.FunctionDef):
-        if self.started:
-            return
-        self.started = True
-        self.generic_visit(node)
-
-
-def has_yield(node: ast.AST) -> bool:
-    visitor = HasDirectYield()
-    visitor.visit(node)
-    return visitor.has_yield

sonolus/backend/visitor.py

@@ -11,7 +11,7 @@ from types import FunctionType, MethodType, MethodWrapperType
 from typing import Any, Never
 
 from sonolus.backend.excepthook import install_excepthook
-from sonolus.backend.utils import get_function, has_yield, scan_writes
+from sonolus.backend.utils import get_function, scan_writes
 from sonolus.script.debug import assert_true
 from sonolus.script.internal.builtin_impls import BUILTIN_IMPLS, _bool, _float, _int, _len
 from sonolus.script.internal.constant import ConstantValue
@@ -39,6 +39,8 @@ def compile_and_call[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.k
 def compile_and_call_at_definition[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs) -> R:
     if not ctx():
         return fn(*args, **kwargs)
+    if ctx().no_eval:
+        return compile_and_call(fn, *args, **kwargs)
     source_file, node = get_function(fn)
     location_args = {
         "lineno": node.lineno,
@@ -261,11 +263,26 @@ 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")
-        if has_yield(node) or isinstance(node, ast.GeneratorExp):
+        # has_yield is set by the find_function visitor
+        if getattr(node, "has_yield", False) or isinstance(node, ast.GeneratorExp):
             return_ctx = Context.meet([*self.return_ctxs, ctx()])
             result_binding = return_ctx.scope.get_binding("$return")
             if not isinstance(result_binding, ValueBinding):
@@ -323,7 +340,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 +354,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 +520,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 +1009,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")
@@ -1395,6 +1426,9 @@ class Visitor(ast.NodeVisitor):
         self, node: ast.stmt | ast.expr, fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs
     ) -> R:
         """Executes the given function at the given node for a better traceback."""
+        if ctx().no_eval:
+            return fn(*args, **kwargs)
+
         location_args = {
             "lineno": node.lineno,
             "col_offset": node.col_offset,

sonolus/build/cli.py

@@ -166,13 +166,13 @@ def main():
     def add_common_arguments(parser):
         optimization_group = parser.add_mutually_exclusive_group()
         optimization_group.add_argument(
-            "-o0", "--optimize-minimal", action="store_true", help="Use minimal optimization passes"
+            "-O0", "--optimize-minimal", action="store_true", help="Use minimal optimization passes"
         )
         optimization_group.add_argument(
-            "-o1", "--optimize-fast", action="store_true", help="Use fast optimization passes"
+            "-O1", "--optimize-fast", action="store_true", help="Use fast optimization passes"
         )
         optimization_group.add_argument(
-            "-o2", "--optimize-standard", action="store_true", help="Use standard optimization passes"
+            "-O2", "--optimize-standard", action="store_true", help="Use standard optimization passes"
         )
 
         build_components = parser.add_argument_group("build components")

sonolus/build/compile.py

@@ -21,6 +21,7 @@ from sonolus.script.internal.context import (
     ctx,
     using_ctx,
 )
+from sonolus.script.internal.error import CompilationError
 from sonolus.script.num import _is_num
 
 
@@ -140,7 +141,21 @@ def callback_to_cfg(
     name: str,
     archetype: type[_BaseArchetype] | None = None,
 ) -> BasicBlock:
-    callback_state = CallbackContextState(name)
+    try:
+        # Default to no_eval=True for performance unless there's an error.
+        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=True)
+    except CompilationError:
+        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=False)
+
+
+def _callback_to_cfg(
+    global_state: GlobalContextState,
+    callback: Callable,
+    name: str,
+    archetype: type[_BaseArchetype] | None,
+    no_eval: bool,
+) -> BasicBlock:
+    callback_state = CallbackContextState(name, no_eval=no_eval)
     context = Context(global_state, callback_state)
     with using_ctx(context):
         if archetype is not None:

sonolus/script/archetype.py

@@ -190,7 +190,8 @@ def imported(*, name: str | None = None) -> Any:
 
     In watch mode, data may also be loaded from a corresponding exported field in play mode.
 
-    Imported fields may only be updated in the `preprocess` callback, and are read-only in other callbacks.
+    Imported fields may only be updated in the [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess]
+    callback, and are read-only in other callbacks.
 
     Usage:
         ```python
@@ -205,10 +206,12 @@ def imported(*, name: str | None = None) -> Any:
 def entity_data() -> Any:
     """Declare a field as entity data.
 
-    Entity data is accessible from other entities, but may only be updated in the `preprocess` callback
+    Entity data is accessible from other entities, but may only be updated in the
+    [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess] callback
     and is read-only in other callbacks.
 
-    It functions like `imported` and shares the same underlying storage, except that it is not loaded from a level.
+    It functions like [`imported`][sonolus.script.archetype.imported] and shares the same underlying storage,
+    except that it is not loaded from a level.
 
     Usage:
         ```python
@@ -242,7 +245,8 @@ def entity_memory() -> Any:
     Entity memory is private to the entity and is not accessible from other entities. It may be read or updated in any
     callback associated with the entity.
 
-    Entity memory fields may also be set when an entity is spawned using the `spawn()` method.
+    Entity memory fields may also be set when an entity is spawned using the
+    [`spawn()`][sonolus.script.archetype.PlayArchetype.spawn] method.
 
     Usage:
         ```python
@@ -260,7 +264,9 @@ def shared_memory() -> Any:
     Shared memory is accessible from other entities.
 
     Shared memory may be read in any callback, but may only be updated by sequential callbacks
-    (`preprocess`, `update_sequential`, and `touch`).
+    ([`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess],
+    [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential],
+    and [`touch`][sonolus.script.archetype.PlayArchetype.touch]).
 
     Usage:
         ```python
@@ -688,7 +694,7 @@ class PlayArchetype(_BaseArchetype):
     def spawn_order(self) -> float:
         """Return the spawn order of the entity.
 
-        Runs when the level is loaded after `preprocess`.
+        Runs when the level is loaded after [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess].
         """
 
     def should_spawn(self) -> bool:
@@ -709,13 +715,15 @@ class PlayArchetype(_BaseArchetype):
         Runs first each frame.
 
         This is where logic affecting shared memory should be placed.
-        Other logic should be placed in `update_parallel` for better performance.
+        Other logic should typically be placed in
+        [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel]
+        for better performance.
         """
 
     def update_parallel(self):
         """Perform parallel actions for this frame.
 
-        Runs after `touch` each frame.
+        Runs after [`touch`][sonolus.script.archetype.PlayArchetype.touch] each frame.
 
         This is where most gameplay logic should be placed.
         """
@@ -723,7 +731,7 @@ class PlayArchetype(_BaseArchetype):
     def touch(self):
         """Handle user input.
 
-        Runs after `update_sequential` each frame.
+        Runs after [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential] each frame.
         """
 
     def terminate(self):
@@ -863,13 +871,14 @@ class WatchArchetype(_BaseArchetype):
         Runs first each frame.
 
         This is where logic affecting shared memory should be placed.
-        Other logic should be placed in `update_parallel` for better performance.
+        Other logic should typically be placed in
+        [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel] for better performance.
         """
 
     def update_parallel(self):
         """Parallel update callback.
 
-        Runs after `touch` each frame.
+        Runs after [`touch`][sonolus.script.archetype.PlayArchetype.touch] each frame.
 
         This is where most gameplay logic should be placed.
         """
@@ -1094,7 +1103,7 @@ class WatchEntityInput(Record):
 class EntityRef[A: _BaseArchetype](Record):
     """Reference to another entity.
 
-    May be used with `Any` to reference an unknown archetype.
+    May be used with `typing.Any` to reference an unknown archetype.
 
     Usage:
         ```python

sonolus/script/array.py

@@ -16,7 +16,7 @@ from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 Dim = Literal
-"""Shorthand for `Literal` intended for use in array dimensions for type checker compatibility."""
+"""Shorthand for `typing.Literal` intended for use in array dimensions for type checker compatibility."""
 
 
 class ArrayMeta(ABCMeta):

sonolus/script/containers.py

@@ -33,7 +33,7 @@ class Box[T](Record):
         x: T = ...
         y: T = ...
         box = Box(x)
-        box.value = y  # Works regardless of whether x is a Num or not
+        box.value = y  # Works regardless of whether x is a Num, array, or record
         ```
     """
 
@@ -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/easing.py

@@ -1,4 +1,3 @@
-# ruff: noqa: E501
 import math
 
 from sonolus.backend.ops import Op

sonolus/script/effect.py

@@ -38,7 +38,8 @@ class Effect(Record):
     def schedule(self, time: float, distance: float = 0) -> None:
         """Schedule the effect clip to play at a specific time.
 
-        This is not suitable for real-time effects such as responses to user input. Use `play` instead.
+        This is not suitable for real-time effects such as responses to user input.
+        Use [`play`][sonolus.script.effect.Effect.play] instead.
 
         This may be called in preprocess to schedule effects upfront.
 
@@ -61,7 +62,8 @@ class Effect(Record):
     def schedule_loop(self, start_time: float) -> ScheduledLoopedEffectHandle:
         """Schedule the effect clip to play in a loop until stopped.
 
-        This is not suitable for real-time effects such as responses to user input. Use `loop` instead.
+        This is not suitable for real-time effects such as responses to user input.
+        Use [`loop`][sonolus.script.effect.Effect.loop] instead.
 
         Returns:
             A handle to stop the loop.

sonolus/script/globals.py

@@ -235,7 +235,10 @@ def _tutorial_instruction[T](cls: type[T]) -> T:
 def level_memory[T](cls: type[T]) -> T:
     """Define level memory.
 
-    Level memory may be modified during gameplay in sequential callbacks (`preprocess`, `update_sequential`, `touch`).
+    Level memory may be modified during gameplay in sequential callbacks
+    ([`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess],
+    [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential],
+    [`touch`][sonolus.script.archetype.PlayArchetype.touch]).
 
     Usage:
         ```python
@@ -265,7 +268,7 @@ def level_memory[T](cls: type[T]) -> T:
 def level_data[T](cls: type[T]) -> T:
     """Define level data.
 
-    Level data may only be modified during preprocessing.
+    Level data may only be modified during [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess].
 
     Usage:
         ```python

sonolus/script/internal/context.py

@@ -61,10 +61,12 @@ class GlobalContextState:
 class CallbackContextState:
     callback: str
     used_names: dict[str, int]
+    no_eval: bool
 
-    def __init__(self, callback: str):
+    def __init__(self, callback: str, no_eval: bool = False):
         self.callback = callback
         self.used_names = {}
+        self.no_eval = no_eval
 
 
 class Context:
@@ -111,6 +113,10 @@ class Context:
     def used_names(self) -> dict[str, int]:
         return self.callback_state.used_names
 
+    @property
+    def no_eval(self) -> bool:
+        return self.callback_state.no_eval
+
     def check_readable(self, place: BlockPlace):
         if debug_config().unchecked_reads:
             return

sonolus/script/internal/native.py

@@ -32,7 +32,7 @@ def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]
             if ctx():
                 bound_args = signature.bind(*args)
                 bound_args.apply_defaults()
-                return native_call(op, *(Num._accept_(arg) for arg in bound_args.args))
+                return native_call(op, *bound_args.args)
             return fn(*args)  # type: ignore
 
         return wrapper

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
@@ -12,7 +14,8 @@ class SonolusIterator[T]:
 
     This class is used to define custom iterators that can be used in Sonolus.py.
 
-    Inheritors must implement the `next` method, which should return a `Maybe[T]`.
+    Inheritors must implement the [`next`][sonolus.script.iterator.SonolusIterator.next] method,
+    which should return a [`Maybe[T]`][sonolus.script.maybe.Maybe].
 
     Usage:
         ```python
@@ -26,6 +29,7 @@ class SonolusIterator[T]:
 
     @meta_fn
     def next(self) -> Maybe[T]:
+        """Return the next item from the iterator as a [`Maybe`][sonolus.script.maybe.Maybe]."""
         raise NotImplementedError
 
     def __next__(self) -> T:
@@ -114,3 +118,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`][sonolus.script.maybe.Maybe]."""
+    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,19 +4,21 @@ 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):
     """A type that either has a value or is empty.
 
-    Maybe has special behavior when returned from a function: it may be returned from multiple places
-    in a function, provided that all but one return statement returns the literal `Nothing`.
+    `Maybe` has special behavior when returned from a function: unlike records and arrays, it may be returned from
+    multiple places in a function, provided that all but one return statement returns the literal
+    [`Nothing`][sonolus.script.maybe.Nothing].
 
-    This type is not intended for other uses, such as being stored in a Record, Array, or Archetype.
+    Storing values of this type in a Record, Array, or Archetype is not supported.
 
     Usage:
         ```python
@@ -38,13 +40,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 +66,106 @@ 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`][sonolus.script.maybe.Nothing].
+
+        Args:
+            fn: A function that takes the contained value and returns a new value.
+
+        Returns:
+            A [`Maybe`][sonolus.script.maybe.Maybe] instance containing the result of the function if the value
+            is present, otherwise [`Nothing`][sonolus.script.maybe.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`][sonolus.script.maybe.Maybe] using the provided function.
+
+        If the value is not present, returns [`Nothing`][sonolus.script.maybe.Nothing].
+
+        Args:
+            fn: A function that takes the contained value and returns a new [`Maybe`][sonolus.script.maybe.Maybe].
+
+        Returns:
+            A [`Maybe`][sonolus.script.maybe.Maybe] instance containing the result of the function if the value
+            is present, otherwise [`Nothing`][sonolus.script.maybe.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)
@@ -121,13 +219,13 @@ class Maybe[T](TransientValue):
 
 
 def Some[T](value: T) -> Maybe[T]:  # noqa: N802
-    """Create a `Maybe` instance with a value.
+    """Create a [`Maybe`][sonolus.script.maybe.Maybe] instance with a value.
 
     Args:
         value: The contained value.
 
     Returns:
-        A `Maybe` instance that contains the provided value.
+        A [`Maybe`][sonolus.script.maybe.Maybe] instance that contains the provided value.
     """
     return Maybe(present=True, value=value)
 
@@ -136,4 +234,11 @@ 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."""
+"""The empty [`Maybe`][sonolus.script.maybe.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/script/sprite.py

@@ -291,7 +291,7 @@ def skin[T](cls: type[T]) -> T | Skin:
         ```python
         @skin
         class Skin:
-            render_mode: RenderMode
+            render_mode: RenderMode = RenderMode.LIGHTWEIGHT
 
             note: StandardSprite.NOTE_HEAD_RED
             other: Sprite = skin_sprite("other")

sonolus/script/stream.py

@@ -63,7 +63,8 @@ class _StreamDataField(SonolusDescriptor):
 def streams[T](cls: type[T]) -> T:
     """Decorator to define streams and stream groups.
 
-    Streams and stream groups are declared by annotating class attributes with `Stream` or `StreamGroup`.
+    Streams and stream groups are declared by annotating class attributes with
+    [`Stream`][sonolus.script.stream.Stream] or [`StreamGroup`][sonolus.script.stream.StreamGroup].
 
     Other types are also supported in the form of data fields. They may be used to store additional data to export from
     Play to Watch mode.
@@ -180,8 +181,8 @@ class _SparseStreamBacking(BackingValue):
 class Stream[T](Record):
     """Represents a stream.
 
-    Most users should use [`@streams`][sonolus.script.stream.streams] to declare streams and stream groups rather than
-    using this class directly.
+    Most users should use [`@streams`][sonolus.script.stream.streams] to declare streams and stream groups, rather than
+    creating instances of this class directly.
 
     If used directly, it is important that streams do not overlap. No other streams should have an offset in
     `range(self.offset, self.offset + max(1, sizeof(self.element_type())))`, or they will overlap and interfere
@@ -285,12 +286,12 @@ class Stream[T](Record):
         return previous_key < key
 
     def next_key_inclusive(self, key: int | float) -> int | float:
-        """Like `next_key`, but returns the key itself if it is in the stream."""
+        """Like [`next_key`][sonolus.script.stream.Stream.next_key], but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.next_key(key)
 
     def previous_key_inclusive(self, key: int | float) -> int | float:
-        """Like `previous_key`, but returns the key itself if it is in the stream."""
+        """Like [`previous_key`][sonolus.script.stream.Stream.previous_key], but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.previous_key(key)
 

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

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

{sonolus_py-0.4.0.dist-info → sonolus_py-0.4.2.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=DDgYUVHh4h_eSY65v2KcxUaLSBYGYS6oHar5gTdV7QU,2356
+sonolus/backend/visitor.py,sha256=6QjQ9tYOCP2a8-8WPgm8EB-hzwV5pcwLap3eDDrFG8I,62364
 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
@@ -26,41 +26,41 @@ sonolus/backend/optimize/passes.py,sha256=YyFKy6qCwcR_Ua2_SXpcBODfvBbm_ygVYcqloO
 sonolus/backend/optimize/simplify.py,sha256=RDNVTKfC7ByRyxY5z30_ShimOAKth_pKlVFV_36pDG4,14082
 sonolus/backend/optimize/ssa.py,sha256=raQO0furQQRPYb8iIBKfNrJlj-_5wqtI4EWNfLZ8QFo,10834
 sonolus/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonolus/build/cli.py,sha256=jzJVdPdEn0uaEbv5B7BuQZioytAeG9P2vDXwiRTXA8s,10113
+sonolus/build/cli.py,sha256=-_lTN8zT7nQB2lySM8itAEPVutcEQI-TJ13BcPIfGb4,10113
 sonolus/build/collection.py,sha256=kOVnpQC_KHAsyTM4nAplSh6QE16CgO-H6PP1GItWm78,12187
-sonolus/build/compile.py,sha256=hF8CnaqMQqak4OyEQvxJLo_mpzZDQipMa14syZsWLEA,5976
+sonolus/build/compile.py,sha256=B7w6Uqa4HlZPNklNhhjJoq9ncXMVXLCYabGLxtxWGV4,6521
 sonolus/build/engine.py,sha256=zUl0KfRygqNhIM8BABNJkKG-0zXFwcYwck-5hJy59yk,13338
 sonolus/build/level.py,sha256=yXsQtnabkJK0vuVmZ_Wr1jx37jFLgInCS7lTlXjkv9Q,706
 sonolus/build/node.py,sha256=gnX71RYDUOK_gYMpinQi-bLWO4csqcfiG5gFmhxzSec,1330
 sonolus/build/project.py,sha256=mv2OuzgIDG-E9G4SIRiUDL5XiPCd1i81wVl1p7itFHA,6329
 sonolus/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonolus/script/archetype.py,sha256=vNNX6YGi_CUQcjf0xG1Rkpz9kUd_84hEPuY1Ew9uFxA,41666
-sonolus/script/array.py,sha256=lnobVrrEOE6PgPasq3DovrshlDKPbX8kKUsGmJz2oK0,12360
+sonolus/script/archetype.py,sha256=HJeKJ_vj7xUYaCAmNdGYO45rhFMSLMwOLyvpKjulfVY,42418
+sonolus/script/array.py,sha256=9uOUHZIDMyMT9q3APcXJWXWt97yG-AZoRlxwrvSY6SU,12367
 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=WX0qRnr6gNtn3C0q7MwMyrzvY-C0Bd1tzLGxSkUwL9U,18680
 sonolus/script/debug.py,sha256=_Hg1cXQJ8fBXMiwhmoPb2X9CKcQ8QO26WNa59K518og,4305
-sonolus/script/easing.py,sha256=7zaDKIfM_whUpb4FBz1DAF4NNG2vk_nDjl8kL2Y90aU,11396
-sonolus/script/effect.py,sha256=pqfsOhmGVDMkifumkRr9rD2trWZU6Rw-_gTApNIaz7g,5854
+sonolus/script/easing.py,sha256=txf0OPFP5v7cOFDvJKCyKLK-d2uKIOu56ntLEHfD9QI,11377
+sonolus/script/effect.py,sha256=mhl58IgHUl7GI6kDdwK6l_KWVXYWxxpAcfOjSkdrLj4,5944
 sonolus/script/engine.py,sha256=etI9dJsQ7V9YZICVNZg54WqpLijPxG8eTPHiV-_EiG8,10687
-sonolus/script/globals.py,sha256=FOv8uiLM5U6X-yMLCXukMvLgV3rs-xVJbobST_MhLcU,9782
+sonolus/script/globals.py,sha256=USwh_TuyZh1qORPVLk6x9qe3ca9iLhf5gnqT773gVvY,10007
 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=_ICY_yX7FG0Zbgs3NhVnaIBdVDpAeXjxJ_CQtq30l7Y,3774
+sonolus/script/level.py,sha256=vnotMbdr_4-MJUsTXMbvWiw2MlMjMHme3q0XRdNFXRg,6349
+sonolus/script/maybe.py,sha256=VYvTWgEfPzoXqI3i3zXhc4dz0pWBVoHmW8FtWH0GQvM,8194
 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
+sonolus/script/sprite.py,sha256=pgFQvzWB-uy9MsOfV8QabXKjnNgx5vN6md9uNYztHco,16297
+sonolus/script/stream.py,sha256=q3uJUfUP9fx0Go7qXQopl9DMh_RJkT-96p5WlAo4x0M,24693
 sonolus/script/text.py,sha256=wxujIgKYcCfl2AD2_Im8g3vh0lDEHYwTSRZg9wsBPEU,13402
 sonolus/script/timing.py,sha256=ZR0ypV2PIoDCMHHGOMfCeezStCsBQdzomdqaz5VKex0,2981
 sonolus/script/transform.py,sha256=w5mr7hTuNYU0eTAdnN_wTVibaQa0mZrkl-W-kgewJxQ,21345
@@ -71,7 +71,7 @@ sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtU
 sonolus/script/internal/builtin_impls.py,sha256=vzyaSTsxoZoE6a-aBBHn4aIfjGxxYzojEnOog3-HETI,12686
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
 sonolus/script/internal/constant.py,sha256=3ycbGkDJVUwcrCZ96vLjAoAARgsvaqDM8rJ_YCrLrvo,4289
-sonolus/script/internal/context.py,sha256=8wLclCnLyDJt7BGbSqMD6rngYt9jI2JYji6XV8cbCAw,16742
+sonolus/script/internal/context.py,sha256=qn8xp5BB1C3IaUS8jsSUfkMUJgPzeaIV7K4FY9mHHQo,16903
 sonolus/script/internal/descriptor.py,sha256=XRFey-EjiAm_--KsNl-8N0Mi_iyQwlPh68gDp0pKf3E,392
 sonolus/script/internal/dict_impl.py,sha256=alu_wKGSk1kZajNf64qbe7t71shEzD4N5xNIATH8Swo,1885
 sonolus/script/internal/error.py,sha256=ZNnsvQVQAnFKzcvsm6-sste2lo-tP5pPI8sD7XlAZWc,490
@@ -79,15 +79,15 @@ sonolus/script/internal/generic.py,sha256=F0-cCiRNGTaUJvYlpmkiOsU3Xge_XjoBpBwBhH
 sonolus/script/internal/impl.py,sha256=I3IlPZZZtXVJb044cpULg5FDYUjiLtAucnsA6w_0xUk,3233
 sonolus/script/internal/introspection.py,sha256=MfdXo3GFHNZT2-vAKuvsE54V-5TOfbg4vU9dBI6sLqo,1032
 sonolus/script/internal/math_impls.py,sha256=nHSLgA7Tcx7jY1p07mYBCeSRmVx713bwdNayCIcaXSE,2652
-sonolus/script/internal/native.py,sha256=WrZ3sVYfrc9plFxJJSWCqwq3ymruw3WhET_UjmhKj38,1628
+sonolus/script/internal/native.py,sha256=DQxmzxgLG_UsLpXhIEtBdO7eIeDFprU78UBDC4OZzw0,1597
 sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z50pI,1695
 sonolus/script/internal/range.py,sha256=YeqB1TPh7JdvW6kDuA5tpQL5psVxYQjepBZs7RNcP5Y,3426
 sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDwIJMVsHle0kvzd500,4818
 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.2.dist-info/METADATA,sha256=rV2d-Y0jxrhlOQfcrYRAVAKiuobluI5omhDztt5mmLo,302
+sonolus_py-0.4.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.4.2.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.4.2.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.4.2.dist-info/RECORD,,