sonolus.py 0.8.0__py3-none-any.whl → 0.9.1__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,16 +68,31 @@ 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:
-        error(message)
+    assert_true(not value, message)
 
 
 def static_assert(value: int | float | bool, message: str | None = None):

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:
@@ -451,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
 

sonolus/script/project.py

@@ -8,6 +8,7 @@ from typing import ClassVar, TypedDict
 
 from sonolus.backend.optimize import optimize
 from sonolus.backend.optimize.passes import CompilerPass
+from sonolus.build.compile import CompileCache
 from sonolus.script.archetype import ArchetypeSchema
 from sonolus.script.engine import Engine
 from sonolus.script.level import ExternalLevelData, Level, LevelData
@@ -65,8 +66,20 @@ class Project:
         """
         from sonolus.build.cli import build_collection, run_server
 
-        build_collection(self, Path(build_dir), config)
-        run_server(Path(build_dir) / "site", port=port)
+        if config is None:
+            config = BuildConfig()
+
+        cache = CompileCache()
+        build_collection(self, Path(build_dir), config, cache=cache)
+        run_server(
+            Path(build_dir) / "site",
+            port=port,
+            project_module_name=None,
+            core_module_names=None,
+            build_dir=Path(build_dir),
+            config=config,
+            cache=cache,
+        )
 
     def build(self, build_dir: PathLike, config: BuildConfig | None = None):
         """Build the project.

sonolus/script/quad.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Protocol, Self, assert_never, overload
 
+from sonolus.script.internal.impl import perf_meta_fn
 from sonolus.script.record import Record
 from sonolus.script.values import zeros
 from sonolus.script.vec import Vec2, pnpoly
@@ -451,6 +452,7 @@ type QuadLike = _QuadLike | Quad
 """A type that can be used as a quad."""
 
 
+@perf_meta_fn
 def flatten_quad(quad: QuadLike) -> tuple[float, float, float, float, float, float, float, float]:
     bl = quad.bl
     tl = quad.tl

sonolus/script/record.py

@@ -171,6 +171,15 @@ class Record(GenericValue, metaclass=RecordMeta):
         result._value_ = kwargs
         return result
 
+    @classmethod
+    def _quick_construct(cls, **kwargs) -> Self:
+        result = object.__new__(cls)
+        for k, v in kwargs.items():
+            if isinstance(v, int | float):
+                kwargs[k] = Num._accept_(v)
+        result._value_ = kwargs
+        return result
+
     @classmethod
     def _size_(cls) -> int:
         return sum(field.type._size_() for field in cls._fields_)

sonolus/script/runtime.py

@@ -30,7 +30,7 @@ from sonolus.script.globals import (
     _watch_runtime_update,
 )
 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.num import Num
 from sonolus.script.quad import Quad, Rect
 from sonolus.script.record import Record
@@ -1154,9 +1154,10 @@ def canvas() -> _PreviewRuntimeCanvas:
     return _PreviewRuntimeCanvas  # type: ignore
 
 
+@perf_meta_fn
 def screen() -> Rect:
     """Get the screen boundaries as a rectangle."""
-    return Rect(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
+    return Rect._quick_construct(t=1, r=aspect_ratio(), b=-1, l=-aspect_ratio())
 
 
 def level_score() -> _LevelScore:

sonolus/script/sprite.py

@@ -6,6 +6,7 @@ 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.impl import perf_meta_fn
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.quad import QuadLike, flatten_quad
@@ -29,6 +30,7 @@ class Sprite(Record):
         """Check if the sprite is available."""
         return _has_skin_sprite(self.id)
 
+    @perf_meta_fn
     def draw(self, quad: QuadLike, z: float = 0.0, a: float = 1.0):
         """Draw the sprite.
 
@@ -39,6 +41,7 @@ class Sprite(Record):
         """
         _draw(self.id, *flatten_quad(quad), z, a)
 
+    @perf_meta_fn
     def draw_curved_b(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved bottom with a quadratic Bézier curve.
 
@@ -51,6 +54,7 @@ class Sprite(Record):
         """
         _draw_curved_b(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_t(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved top with a quadratic Bézier curve.
 
@@ -63,6 +67,7 @@ class Sprite(Record):
         """
         _draw_curved_t(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_l(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved left side with a quadratic Bézier curve.
 
@@ -75,6 +80,7 @@ class Sprite(Record):
         """
         _draw_curved_l(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_r(self, quad: QuadLike, cp: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved right side with a quadratic Bézier curve.
 
@@ -87,6 +93,7 @@ class Sprite(Record):
         """
         _draw_curved_r(self.id, *flatten_quad(quad), z, a, n, *cp.tuple)
 
+    @perf_meta_fn
     def draw_curved_bt(self, quad: QuadLike, cp1: Vec2, cp2: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved bottom and top with a cubic Bézier curve.
 
@@ -100,6 +107,7 @@ class Sprite(Record):
         """
         _draw_curved_bt(self.id, *flatten_quad(quad), z, a, n, *cp1.tuple, *cp2.tuple)
 
+    @perf_meta_fn
     def draw_curved_lr(self, quad: QuadLike, cp1: Vec2, cp2: Vec2, n: float, z: float = 0.0, a: float = 1.0):
         """Draw the sprite with a curved left and right side with a cubic Bézier curve.