sonolus.py 0.7.1__py3-none-any.whl → 0.9.0__py3-none-any.whl

sonolus/build/engine.py

@@ -9,7 +9,7 @@ from dataclasses import dataclass
 from pathlib import Path
 
 from sonolus.backend.mode import Mode
-from sonolus.build.compile import compile_mode
+from sonolus.build.compile import CompileCache, compile_mode
 from sonolus.script.archetype import _BaseArchetype
 from sonolus.script.bucket import Buckets
 from sonolus.script.effect import Effects
@@ -68,7 +68,11 @@ def no_gil() -> bool:
 def package_engine(
     engine: EngineData,
     config: BuildConfig | None = None,
+    cache: CompileCache | None = None,
 ):
+    if cache is None:
+        cache = CompileCache()
+
     config = config or BuildConfig()
     rom = ReadOnlyMemory()
     configuration = build_engine_configuration(engine.options, engine.ui)
@@ -76,7 +80,8 @@ def package_engine(
         # process_cpu_count is available in Python 3.13+
         from os import process_cpu_count
 
-        thread_pool = ThreadPoolExecutor(process_cpu_count() or 1)
+        # Need a worker for each mode (so +4) plus at least one to do work
+        thread_pool = ThreadPoolExecutor(4 + max(1, min(8, (process_cpu_count() or 1))))
     else:
         thread_pool = None
 
@@ -97,6 +102,7 @@ def package_engine(
                 rom=rom,
                 config=config,
                 thread_pool=thread_pool,
+                cache=cache,
             ),
             "watch": thread_pool.submit(
                 build_watch_mode,
@@ -109,6 +115,7 @@ def package_engine(
                 update_spawn=watch_mode.update_spawn,
                 config=config,
                 thread_pool=thread_pool,
+                cache=cache,
             ),
             "preview": thread_pool.submit(
                 build_preview_mode,
@@ -117,6 +124,7 @@ def package_engine(
                 rom=rom,
                 config=config,
                 thread_pool=thread_pool,
+                cache=cache,
             ),
             "tutorial": thread_pool.submit(
                 build_tutorial_mode,
@@ -131,6 +139,7 @@ def package_engine(
                 rom=rom,
                 config=config,
                 thread_pool=thread_pool,
+                cache=cache,
             ),
         }
 
@@ -148,6 +157,7 @@ def package_engine(
             rom=rom,
             config=config,
             thread_pool=None,
+            cache=cache,
         )
         watch_data = build_watch_mode(
             archetypes=watch_mode.archetypes,
@@ -159,6 +169,7 @@ def package_engine(
             update_spawn=watch_mode.update_spawn,
             config=config,
             thread_pool=None,
+            cache=cache,
         )
         preview_data = build_preview_mode(
             archetypes=preview_mode.archetypes,
@@ -166,6 +177,7 @@ def package_engine(
             rom=rom,
             config=config,
             thread_pool=None,
+            cache=cache,
         )
         tutorial_data = build_tutorial_mode(
             skin=tutorial_mode.skin,
@@ -179,6 +191,7 @@ def package_engine(
             rom=rom,
             config=config,
             thread_pool=None,
+            cache=cache,
         )
 
     return PackagedEngine(
@@ -270,6 +283,7 @@ def build_play_mode(
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
+    cache: CompileCache | None = None,
 ):
     return {
         **compile_mode(
@@ -280,6 +294,7 @@ def build_play_mode(
             passes=config.passes,
             thread_pool=thread_pool,
             validate_only=validate_only,
+            cache=cache,
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
@@ -299,6 +314,7 @@ def build_watch_mode(
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
+    cache: CompileCache | None = None,
 ):
     return {
         **compile_mode(
@@ -309,6 +325,7 @@ def build_watch_mode(
             passes=config.passes,
             thread_pool=thread_pool,
             validate_only=validate_only,
+            cache=cache,
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
@@ -324,6 +341,7 @@ def build_preview_mode(
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
+    cache: CompileCache | None = None,
 ):
     return {
         **compile_mode(
@@ -334,6 +352,7 @@ def build_preview_mode(
             passes=config.passes,
             thread_pool=thread_pool,
             validate_only=validate_only,
+            cache=cache,
         ),
         "skin": build_skin(skin),
     }
@@ -352,6 +371,7 @@ def build_tutorial_mode(
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
+    cache: CompileCache | None = None,
 ):
     return {
         **compile_mode(
@@ -366,6 +386,7 @@ def build_tutorial_mode(
             passes=config.passes,
             thread_pool=thread_pool,
             validate_only=validate_only,
+            cache=cache,
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),

sonolus/build/project.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import cast
 
 from sonolus.build.collection import Asset, Collection, Srl
+from sonolus.build.compile import CompileCache
 from sonolus.build.engine import package_engine, unpackage_data
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
@@ -19,7 +20,9 @@ BLANK_AUDIO = (
 )
 
 
-def build_project_to_collection(project: Project, config: BuildConfig | None):
+def build_project_to_collection(
+    project: Project, config: BuildConfig | None, cache: CompileCache | None = None
+) -> Collection:
     collection = load_resources_files_to_collection(project.resources)
     for src_engine, converter in project.converters.items():
         if src_engine is None:
@@ -31,7 +34,7 @@ def build_project_to_collection(project: Project, config: BuildConfig | None):
     if config.override_resource_level_engines:
         for level in collection.categories.get("levels", {}).values():
             level["item"]["engine"] = project.engine.name
-    add_engine_to_collection(collection, project, project.engine, config)
+    add_engine_to_collection(collection, project, project.engine, config, cache=cache)
     for level in project.levels:
         add_level_to_collection(collection, project, level)
     collection.name = f"{project.engine.name}"
@@ -63,8 +66,14 @@ def apply_converter_to_collection(
         level["data"] = new_data_srl
 
 
-def add_engine_to_collection(collection: Collection, project: Project, engine: Engine, config: BuildConfig | None):
-    packaged_engine = package_engine(engine.data, config)
+def add_engine_to_collection(
+    collection: Collection,
+    project: Project,
+    engine: Engine,
+    config: BuildConfig | None,
+    cache: CompileCache | None = None,
+):
+    packaged_engine = package_engine(engine.data, config, cache=cache)
     item = {
         "name": engine.name,
         "version": engine.version,

sonolus/script/array.py

@@ -11,7 +11,7 @@ from sonolus.script.debug import assert_unreachable
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.error import InternalError
 from sonolus.script.internal.generic import GenericValue
-from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.impl import meta_fn, perf_meta_fn, validate_value
 from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
@@ -188,6 +188,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         else:
             return cls._with_value([cls.element_type()._zero_() for _ in range(cls.size())])
 
+    @perf_meta_fn
     def __len__(self):
         return self.size()
 

sonolus/script/bucket.py

@@ -7,7 +7,7 @@ from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
 from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.impl import meta_fn, perf_meta_fn
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.interval import Interval
@@ -72,20 +72,22 @@ class JudgmentWindow(Record):
             *self.good.tuple,
         )
 
+    @perf_meta_fn
     def __mul__(self, other: float | int) -> JudgmentWindow:
         """Multiply the intervals by a scalar."""
-        return JudgmentWindow(
-            self.perfect * other,
-            self.great * other,
-            self.good * other,
+        return JudgmentWindow._quick_construct(
+            perfect=self.perfect * other,
+            great=self.great * other,
+            good=self.good * other,
         )
 
+    @perf_meta_fn
     def __add__(self, other: float | int) -> JudgmentWindow:
         """Add a scalar to the intervals."""
-        return JudgmentWindow(
-            self.perfect + other,
-            self.great + other,
-            self.good + other,
+        return JudgmentWindow._quick_construct(
+            perfect=self.perfect + other,
+            great=self.great + other,
+            good=self.good + other,
         )
 
     @property

sonolus/script/debug.py

@@ -68,15 +68,44 @@ def debug_pause():
     input("[DEBUG] Paused")
 
 
+@meta_fn
 def assert_true(value: int | float | bool, message: str | None = None):
-    message = message if message is not None else "Assertion failed"
-    if not value:
-        error(message)
+    if not ctx():
+        if not value:
+            raise AssertionError(message if message is not None else "Assertion failed")
+        return
+    value = Num._accept_(validate_value(value))
+    message = validate_value(message)
+    message = message._as_py_() or "Assertion failed"
+    if value._is_py_():
+        if value._as_py_():
+            return
+        else:
+            error(message)
+    else:
+        ctx().test = value.ir()
+        t_branch = ctx().branch(None)
+        f_branch = ctx().branch(0)
+        set_ctx(f_branch)
+        error(message)  # type: ignore
+        set_ctx(t_branch)
 
 
 def assert_false(value: int | float | bool, message: str | None = None):
-    message = message if message is not None else "Assertion failed"
-    if value:
+    assert_true(not value, message)
+
+
+def static_assert(value: int | float | bool, message: str | None = None):
+    message = message if message is not None else "Static assertion failed"
+    if not _is_static_true(value):
+        static_error(message)
+
+
+def try_static_assert(value: int | float | bool, message: str | None = None):
+    message = message if message is not None else "Static assertion failed"
+    if _is_static_false(value):
+        static_error(message)
+    if not value:
         error(message)
 
 
@@ -140,3 +169,21 @@ def visualize_cfg(
 
 def simulation_context() -> SimulationContext:
     return SimulationContext()
+
+
+@meta_fn
+def _is_static_true(value: int | float | bool) -> bool:
+    if ctx() is None:
+        return bool(value)
+    else:
+        value = validate_value(value)
+        return value._is_py_() and value._as_py_()
+
+
+@meta_fn
+def _is_static_false(value: int | float | bool) -> bool:
+    if ctx() is None:
+        return not bool(value)
+    else:
+        value = validate_value(value)
+        return value._is_py_() and not value._as_py_()

sonolus/script/effect.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
+from sonolus.script.array_like import ArrayLike
+from sonolus.script.debug import static_error
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.record import Record
@@ -92,6 +95,29 @@ class ScheduledLoopedEffectHandle(Record):
         _stop_looped_scheduled(self.id, end_time)
 
 
+class EffectGroup(Record, ArrayLike[Effect]):
+    """A group of effect clips.
+
+    Usage:
+        ```python
+        EffectGroup(start_id: int, size: int)
+        ```
+    """
+
+    start_id: int
+    size: int
+
+    def __len__(self) -> int:
+        return self.size
+
+    def __getitem__(self, index: int) -> Effect:
+        assert 0 <= index < self.size
+        return Effect(self.start_id + index)
+
+    def __setitem__(self, index: int, value: Effect) -> None:
+        static_error("EffectGroup is read-only")
+
+
 @native_function(Op.HasEffectClip)
 def _has_effect_clip(effect_id: int) -> bool:
     raise NotImplementedError
@@ -132,11 +158,21 @@ class EffectInfo:
     name: str
 
 
+@dataclass
+class EffectGroupInfo:
+    names: list[str]
+
+
 def effect(name: str) -> Any:
     """Define a sound effect clip with the given name."""
     return EffectInfo(name)
 
 
+def effect_group(names: Iterable[str]) -> Any:
+    """Define an effect group with the given names."""
+    return EffectGroupInfo(list(names))
+
+
 type Effects = NewType("Effects", Any)  # type: ignore
 
 
@@ -150,24 +186,45 @@ def effects[T](cls: type[T]) -> T | Effects:
         class Effects:
             miss: StandardEffect.MISS
             other: Effect = effect("other")
+            group_1: EffectGroup = effect_group(["one", "two", "three"])
+            group_2: EffectGroup = effect_group(f"name_{i}" for i in range(10))
         ```
     """
     if len(cls.__bases__) != 1:
         raise ValueError("Effects class must not inherit from any class (except object)")
     instance = cls()
     names = []
-    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+    i = 0
+    for name, annotation in get_field_specifiers(cls).items():
         if get_origin(annotation) is not Annotated:
-            raise TypeError(f"Invalid annotation for effects: {annotation}")
+            raise TypeError(f"Invalid annotation for effects: {annotation} on field {name}")
         annotation_type = annotation.__args__[0]
         annotation_values = annotation.__metadata__
-        if annotation_type is not Effect:
-            raise TypeError(f"Invalid annotation for effects: {annotation}, expected annotation of type Effect")
-        if len(annotation_values) != 1 or not isinstance(annotation_values[0], EffectInfo):
-            raise TypeError(f"Invalid annotation for effects: {annotation}, expected a single string annotation value")
-        effect_name = annotation_values[0].name
-        names.append(effect_name)
-        setattr(instance, name, Effect(i))
+        if len(annotation_values) != 1:
+            raise TypeError(f"Invalid annotation for effects: {annotation} on field {name}, too many annotation values")
+        effect_info = annotation_values[0]
+        match effect_info:
+            case EffectInfo(name=effect_name):
+                if annotation_type is not Effect:
+                    raise TypeError(f"Invalid annotation for effects: {annotation} on field {name}, expected Effect")
+                names.append(effect_name)
+                setattr(instance, name, Effect(i))
+                i += 1
+            case EffectGroupInfo(names=effect_names):
+                if annotation_type is not EffectGroup:
+                    raise TypeError(
+                        f"Invalid annotation for effects: {annotation} on field {name}, expected EffectGroup"
+                    )
+                start_id = i
+                count = len(effect_names)
+                names.extend(effect_names)
+                setattr(instance, name, EffectGroup(start_id, count))
+                i += count
+            case _:
+                raise TypeError(
+                    f"Invalid annotation for effects: {annotation} on field {name}, unknown effect info, "
+                    f"expected an effect() or effect_group() specifier"
+                )
     instance._effects_ = names
     instance._is_comptime_value_ = True
     return instance

sonolus/script/internal/impl.py

@@ -33,6 +33,10 @@ def meta_fn(fn=None):
     return decorator(fn)
 
 
+# To indicate this was used for performance reasons rather than functionality
+perf_meta_fn = meta_fn
+
+
 def validate_value[T](value: T) -> Value | T:
     result = try_validate_value(value)
     if result is None:
@@ -59,16 +63,16 @@ def try_validate_value(value: Any) -> Value | None:
         pass
 
     match value:
-        case Enum():
-            return validate_value(value.value)
         case Value():
             return value
+        case int() | float() | bool():
+            return Num._accept_(value)
+        case Enum():
+            return validate_value(value.value)
         case type():
             if value in {int, float, bool}:
                 return BasicConstantValue.of(Num)
             return BasicConstantValue.of(value)
-        case int() | float() | bool():
-            return Num._accept_(value)
         case tuple():
             return TupleImpl._accept_(value)
         case dict():

sonolus/script/interval.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from sonolus.backend.ops import Op
 from sonolus.script.array_like import ArrayLike
 from sonolus.script.debug import static_error
+from sonolus.script.internal.builtin_impls import _max, _min
+from sonolus.script.internal.impl import perf_meta_fn
 from sonolus.script.internal.native import native_function
 from sonolus.script.internal.range import range_or_tuple
 from sonolus.script.num import Num
@@ -66,6 +68,7 @@ class Interval(Record):
             case _:
                 static_error("Invalid type for interval check")
 
+    @perf_meta_fn
     def __add__(self, other: float | int) -> Interval:
         """Add a value to both ends of the interval.
 
@@ -75,8 +78,9 @@ class Interval(Record):
         Returns:
             A new interval with the value added to both ends.
         """
-        return Interval(self.start + other, self.end + other)
+        return Interval._quick_construct(start=self.start + other, end=self.end + other)
 
+    @perf_meta_fn
     def __sub__(self, other: float | int) -> Interval:
         """Subtract a value from both ends of the interval.
 
@@ -86,8 +90,9 @@ class Interval(Record):
         Returns:
             A new interval with the value subtracted from both ends.
         """
-        return Interval(self.start - other, self.end - other)
+        return Interval._quick_construct(start=self.start - other, end=self.end - other)
 
+    @perf_meta_fn
     def __mul__(self, other: float | int) -> Interval:
         """Multiply both ends of the interval by a value.
 
@@ -97,8 +102,9 @@ class Interval(Record):
         Returns:
             A new interval with both ends multiplied by the value.
         """
-        return Interval(self.start * other, self.end * other)
+        return Interval._quick_construct(start=self.start * other, end=self.end * other)
 
+    @perf_meta_fn
     def __truediv__(self, other: float | int) -> Interval:
         """Divide both ends of the interval by a value.
 
@@ -108,8 +114,9 @@ class Interval(Record):
         Returns:
             A new interval with both ends divided by the value.
         """
-        return Interval(self.start / other, self.end / other)
+        return Interval._quick_construct(start=self.start / other, end=self.end / other)
 
+    @perf_meta_fn
     def __floordiv__(self, other: float | int) -> Interval:
         """Divide both ends of the interval by a value and floor the result.
 
@@ -119,7 +126,7 @@ class Interval(Record):
         Returns:
             A new interval with both ends divided by the value and floored.
         """
-        return Interval(self.start // other, self.end // other)
+        return Interval._quick_construct(start=self.start // other, end=self.end // other)
 
     def __and__(self, other: Interval) -> Interval:
         """Get the intersection of two intervals.
@@ -222,14 +229,17 @@ def _num_lerp_clamped(a, b, x, /):
     return a + (b - a) * max(0, min(1, x))
 
 
+@perf_meta_fn
 def _generic_lerp[T](a: T, b: T, x: float, /) -> T:
     return a + (b - a) * x  # type: ignore
 
 
+@perf_meta_fn
 def _generic_lerp_clamped[T](a: T, b: T, x: float, /) -> T:
-    return a + (b - a) * max(0, min(1, x))  # type: ignore
+    return a + (b - a) * _max(0, _min(1, x))  # type: ignore
 
 
+@perf_meta_fn
 def lerp[T](a: T, b: T, x: float, /) -> T:
     """Linearly interpolate between two values.
 
@@ -248,6 +258,7 @@ def lerp[T](a: T, b: T, x: float, /) -> T:
             return _generic_lerp(a, b, x)
 
 
+@perf_meta_fn
 def lerp_clamped[T](a: T, b: T, x: float, /) -> T:
     """Linearly interpolate between two values, clamped to the interval.
 

sonolus/script/num.py

@@ -27,6 +27,8 @@ def _is_num(value: Any) -> TypeGuard[Num]:
 
 @final
 class _Num(Value, metaclass=_NumMeta):
+    __slots__ = ("data",)
+
     # This works for ints, floats, and bools
     # Since we don't support complex numbers, real is equal to the original number
     __match_args__ = ("real",)
@@ -34,16 +36,10 @@ class _Num(Value, metaclass=_NumMeta):
     data: DataValue
 
     def __init__(self, data: DataValue | IRExpr):
-        if isinstance(data, complex):
-            raise TypeError("Cannot create a Num from a complex number")
         if isinstance(data, int):
             data = float(data)
         if isinstance(data, IRConst | IRPureInstr | IRGet):
             data = ExprBackingValue(data)
-        if _is_num(data):
-            raise InternalError("Cannot create a Num from a Num")
-        if not isinstance(data, BlockPlace | BackingValue | float | int | bool):
-            raise TypeError(f"Cannot create a Num from {type(data)}")
         self.data = data
 
     def __str__(self) -> str:
@@ -131,6 +127,8 @@ class _Num(Value, metaclass=_NumMeta):
                 if isinstance(self.data.block, BlockData) and not ctx().is_writable(self.data):
                     # This block is immutable in the current callback, so no need to copy it in case it changes.
                     return Num(self.data)
+            if isinstance(self.data, int | float | bool):
+                return Num(self.data)
             place = ctx().alloc(size=1)
             ctx().add_statements(IRSet(place, self.ir()))
             return Num(place)
@@ -449,6 +447,12 @@ class _Num(Value, metaclass=_NumMeta):
         return 0
 
 
+def _create_num_raw(i: int) -> Num:
+    result = object.__new__(_Num)
+    result.data = float(i)
+    return result
+
+
 if TYPE_CHECKING:
     from typing import Protocol