sonolus.py 0.1.0__py3-none-any.whl

sonolus/script/internal/native.py

@@ -0,0 +1,38 @@
+import functools
+import inspect
+from collections.abc import Callable
+
+from sonolus.backend.ir import IRInstr, IRPureInstr, IRSet
+from sonolus.backend.ops import Op
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.num import Num
+
+
+def native_call(op: Op, *args: Num) -> Num:
+    if not ctx():
+        raise RuntimeError("Unexpected native call")
+    args = tuple(validate_value(arg) for arg in args)
+    if not all(isinstance(arg, Num) for arg in args):
+        raise RuntimeError("All arguments must be of type Num")
+    result = ctx().alloc(size=1)
+    ctx().add_statements(IRSet(result, (IRPureInstr if op.pure else IRInstr)(op, [arg.ir() for arg in args])))
+    return Num._from_place_(result)
+
+
+def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def decorator(fn: Callable[P, Num]) -> Callable[P, Num]:
+        signature = inspect.signature(fn)
+
+        @functools.wraps(fn)
+        @meta_fn
+        def wrapper(*args: Num) -> Num:
+            if len(args) != len(signature.parameters):
+                raise TypeError(f"Expected {len(signature.parameters)} arguments, got {len(args)}")
+            if ctx():
+                return native_call(op, *args)
+            return fn(*args)
+
+        return wrapper
+
+    return decorator

sonolus/script/internal/value.py

@@ -0,0 +1,144 @@
+from abc import abstractmethod
+from collections.abc import Iterable
+from typing import Any, Self
+
+from sonolus.backend.place import BlockPlace
+
+
+class Value:
+    """Base class for values."""
+
+    @classmethod
+    def _is_concrete_(cls) -> bool:
+        """Returns whether this type is concrete (i.e. can be instantiated)."""
+        return False
+
+    @classmethod
+    @abstractmethod
+    def _size_(cls) -> int:
+        """Returns the size of this value."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _is_value_type_(cls) -> bool:
+        """Returns whether this is a value type.
+
+        If this is true, the value behaves immutably and _set_ is supported.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _from_place_(cls, place: BlockPlace) -> Self:
+        """Creates a value from a place."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _accepts_(cls, value: Any) -> bool:
+        """Returns whether this value can accept the given value."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _accept_(cls, value: Any) -> Self:
+        """Accepts the given value."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _is_py_(self) -> bool:
+        """Returns whether this value is a valid Python value."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _as_py_(self) -> Any:
+        """Returns the Python equivalent of this value.
+
+        Will fail if _is_py_ returns false.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+        """Creates a value from a list of floats."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _to_list_(self) -> list[float | BlockPlace]:
+        """Converts this value to a list of floats."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _flat_keys_(cls, prefix: str) -> list[str]:
+        """Returns the keys to a flat representation of this value."""
+        raise NotImplementedError
+
+    def _to_flat_dict_(self, prefix: str) -> dict[str, float | BlockPlace]:
+        """Converts this value to a flat dictionary."""
+        return dict(zip(self._flat_keys_(prefix), self._to_list_(), strict=False))
+
+    @abstractmethod
+    def _get_(self) -> Self:
+        """Implements access to the value.
+
+        This is used when accessing a value from a record or array (and when storing into a record).
+        For value (immutable) types, this makes a copy to preserve the appearance of immutability.
+        For mutable types, this returns self.
+
+        For instance:
+        ```
+        class X(Record):
+            v: Num
+
+        a = 1
+        b = X(a) # (1) _get() is called on a
+        c = b.v # (2) _get() is called on the value for v
+
+        # (1) prevents this from changing the value of a
+        # (2) prevents this from changing the value of c
+        # Thus, both calls to _get() are necessary to ensure values behave immutably.
+        b.v = 2
+        ```
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _set_(self, value: Self):
+        """Implements assignment (=).
+
+        This is only supported by value types.
+        This method must not change the active context like by branching.
+
+        In some places, = might instead call assign_, such as when setting the value of a record field
+        with a reference type.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _copy_from_(self, value: Self):
+        """Implements copy assignment (@=).
+
+        This is only supported by mutable reference types.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def _copy_(self) -> Self:
+        """Returns a deep copy of this value."""
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def _alloc_(cls) -> Self:
+        """Allocates a new value which may be uninitialized."""
+        raise NotImplementedError
+
+    def __imatmul__(self, other):
+        self._copy_from_(other)
+        return self
+
+
+Value.__imatmul__._meta_fn_ = True

sonolus/script/interval.py

@@ -0,0 +1,98 @@
+from typing import Self
+
+from sonolus.backend.ops import Op
+from sonolus.script.debug import error
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Interval(Record):
+    """A closed interval."""
+
+    start: float
+    end: float
+
+    @property
+    def length(self) -> float:
+        return self.end - self.start
+
+    @property
+    def is_empty(self) -> bool:
+        return self.start > self.end
+
+    @property
+    def mid(self) -> float:
+        return (self.start + self.end) / 2
+
+    @property
+    def tuple(self):
+        return self.start, self.end
+
+    def __contains__(self, item: Self | float | int) -> bool:
+        match item:
+            case Interval(start, end):
+                return self.start <= start and end <= self.end
+            case float() | int() as value:
+                return self.start <= value <= self.end
+            case _:
+                error("Invalid type for interval check")
+
+    def __add__(self, other: float | int) -> Self:
+        return Interval(self.start + other, self.end + other)
+
+    def __sub__(self, other: float | int) -> Self:
+        return Interval(self.start - other, self.end - other)
+
+    def __mul__(self, other: float | int) -> Self:
+        return Interval(self.start * other, self.end * other)
+
+    def __truediv__(self, other: float | int) -> Self:
+        return Interval(self.start / other, self.end / other)
+
+    def __floordiv__(self, other: float | int) -> Self:
+        return Interval(self.start // other, self.end // other)
+
+    def __and__(self, other: Self) -> Self:
+        return Interval(max(self.start, other.start), min(self.end, other.end))
+
+    def lerp(self, x: float, /) -> float:
+        return lerp(self.start, self.end, x)
+
+    def lerp_clamped(self, x: float, /) -> float:
+        return lerp_clamped(self.start, self.end, x)
+
+    def unlerp(self, x: float, /) -> float:
+        return unlerp(self.start, self.end, x)
+
+    def unlerp_clamped(self, x: float, /) -> float:
+        return unlerp_clamped(self.start, self.end, x)
+
+
+@native_function(Op.Lerp)
+def lerp(a, b, x, /):
+    return a + (b - a) * x
+
+
+@native_function(Op.LerpClamped)
+def lerp_clamped(a, b, x, /):
+    return a + (b - a) * max(0, min(1, x))
+
+
+@native_function(Op.Unlerp)
+def unlerp(a, b, x, /):
+    return (x - a) / (b - a)
+
+
+@native_function(Op.UnlerpClamped)
+def unlerp_clamped(a, b, x, /):
+    return max(0, min(1, (x - a) / (b - a)))
+
+
+@native_function(Op.Remap)
+def remap(a, b, c, d, x, /):
+    return c + (d - c) * (x - a) / (b - a)
+
+
+@native_function(Op.RemapClamped)
+def remap_clamped(a, b, c, d, x, /):
+    return c + (d - c) * max(0, min(1, (x - a) / (b - a)))

sonolus/script/iterator.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Collection, Iterator
+
+from sonolus.script.num import Num
+from sonolus.script.record import Record
+from sonolus.script.values import copy
+
+
+class SonolusIterator[T](Iterator[T]):
+    @abstractmethod
+    def has_next(self) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def next(self) -> T:
+        raise NotImplementedError
+
+    def __next__(self) -> T:
+        if not self.has_next():
+            raise StopIteration
+        return self.next()
+
+
+class ArrayLike[T](Collection):
+    @abstractmethod
+    def size(self) -> int:
+        pass
+
+    @abstractmethod
+    def __getitem__(self, index: Num) -> T:
+        pass
+
+    @abstractmethod
+    def __setitem__(self, index: Num, value: T):
+        pass
+
+    def __len__(self) -> int:
+        return self.size()
+
+    def __iter__(self) -> SonolusIterator[T]:
+        return ArrayIterator(0, self)
+
+    def __contains__(self, value: T) -> bool:
+        i = 0
+        while i < self.size():
+            if self[i] == value:
+                return True
+            i += 1
+        return False
+
+    def reversed(self) -> ArrayLike[T]:
+        return ArrayReverser(self)
+
+    def iter(self) -> SonolusIterator[T]:
+        return self.__iter__()  # noqa: PLC2801
+
+    def enumerate(self, start: Num = 0) -> SonolusIterator[T]:
+        return ArrayEnumerator(0, start, self)
+
+    def index_of(self, value: T, start: Num = 0) -> Num:
+        i = start
+        while i < self.size():
+            if self[i] == value:
+                return i
+            i += 1
+        return -1
+
+    def last_index_of(self, value: T) -> Num:
+        i = self.size() - 1
+        while i >= 0:
+            if self[i] == value:
+                return i
+            i -= 1
+        return -1
+
+    def index_of_max(self) -> Num:
+        if self.size() == 0:
+            return -1
+        max_index = 0
+        i = 1
+        while i < self.size():
+            if self[i] > self[max_index]:
+                max_index = i
+            i += 1
+        return max_index
+
+    def index_of_min(self) -> Num:
+        if self.size() == 0:
+            return -1
+        min_index = 0
+        i = 1
+        while i < self.size():
+            if self[i] < self[min_index]:
+                min_index = i
+            i += 1
+        return min_index
+
+    def max(self) -> T:
+        return self[self.index_of_max()]
+
+    def min(self) -> T:
+        return self[self.index_of_min()]
+
+    def swap(self, i: Num, j: Num):
+        temp = copy(self[i])
+        self[i] = self[j]
+        self[j] = temp
+
+    def sort(self, *, reverse: bool = False):
+        if self.size() < 15:
+            _insertion_sort(self, 0, self.size(), reverse)
+        else:
+            _heap_sort(self, 0, self.size(), reverse)
+
+
+def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+    i = start + 1
+    while i < end:
+        value = copy(array[i])
+        j = i - 1
+        while j >= start and (array[j] > value) != reverse:
+            array[j + 1] = array[j]
+            j -= 1
+        array[j + 1] = value
+        i += 1
+
+
+def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
+    while True:
+        left = index * 2 + 1
+        right = left + 1
+        largest = index
+        if left < end and (array[left] > array[largest]) != reverse:
+            largest = left
+        if right < end and (array[right] > array[largest]) != reverse:
+            largest = right
+        if largest == index:
+            break
+        array.swap(index, largest)
+        index = largest
+
+
+# Heap sort is simple to implement iteratively without dynamic memory allocation
+def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+    i = end // 2 - 1
+    while i >= start:
+        _heapify(array, end, i, reverse)
+        i -= 1
+    i = end - 1
+    while i > start:
+        array.swap(start, i)
+        _heapify(array, i, start, reverse)
+        i -= 1
+
+
+class ArrayIterator[V: ArrayLike](Record, SonolusIterator):
+    i: int
+    array: V
+
+    def has_next(self) -> bool:
+        return self.i < self.array.size()
+
+    def next(self) -> V:
+        value = self.array[self.i]
+        self.i += 1
+        return value
+
+
+class ArrayReverser[V: ArrayLike](Record, ArrayLike):
+    array: V
+
+    def size(self) -> int:
+        return self.array.size()
+
+    def __getitem__(self, index: Num) -> V:
+        return self.array[self.size() - 1 - index]
+
+    def __setitem__(self, index: Num, value: V):
+        self.array[self.size() - 1 - index] = value
+
+
+class Enumerator[V: SonolusIterator](Record, SonolusIterator):
+    i: int
+    offset: int
+    iterator: V
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def next(self):
+        value = self.iterator.next()
+        index = self.i + self.offset
+        self.i += 1
+        return index, value
+
+
+class ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
+    i: int
+    offset: int
+    array: V
+
+    def has_next(self) -> bool:
+        return self.i < self.array.size()
+
+    def next(self):
+        value = self.array[self.i]
+        index = self.i + self.offset
+        self.i += 1
+        return index, value

sonolus/script/level.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from sonolus.build.collection import Asset
+from sonolus.script.archetype import PlayArchetype, StandardImport
+
+
+class Level:
+    version = 1
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        title: str | None = None,
+        rating: int = 0,
+        artists: str = "Unknown",
+        author: str = "Unknown",
+        cover: Asset | None = None,
+        bgm: Asset | None = None,
+        data: LevelData,
+    ) -> None:
+        self.name = name
+        self.title = title or name
+        self.rating = rating
+        self.artists = artists
+        self.author = author
+        self.cover = cover
+        self.bgm = bgm
+        self.data = data
+
+
+class LevelData:
+    bgm_offset: float
+    entities: list[PlayArchetype]
+
+    def __init__(self, bgm_offset: float, entities: list[PlayArchetype]) -> None:
+        self.bgm_offset = bgm_offset
+        self.entities = entities
+
+
+class BpmChange(PlayArchetype):
+    name = "#BPM_CHANGE"
+
+    beat: StandardImport.Beat
+    bpm: StandardImport.Bpm
+
+
+class TimescaleChange(PlayArchetype):
+    name = "#TIMESCALE_CHANGE"
+
+    beat: StandardImport.Beat
+    timescale: StandardImport.Timescale

sonolus/script/math.py

@@ -0,0 +1,92 @@
+import math
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+
+
+@native_function(Op.Sin)
+def sin(x: float) -> float:
+    return math.sin(x)
+
+
+@native_function(Op.Cos)
+def cos(x: float) -> float:
+    return math.cos(x)
+
+
+@native_function(Op.Tan)
+def tan(x: float) -> float:
+    return math.tan(x)
+
+
+@native_function(Op.Arcsin)
+def asin(x: float) -> float:
+    return math.asin(x)
+
+
+@native_function(Op.Arccos)
+def acos(x: float) -> float:
+    return math.acos(x)
+
+
+@native_function(Op.Arctan)
+def atan(x: float) -> float:
+    return math.atan(x)
+
+
+@native_function(Op.Arctan2)
+def atan2(y: float, x: float) -> float:
+    return math.atan2(y, x)
+
+
+@native_function(Op.Sinh)
+def sinh(x: float) -> float:
+    return math.sinh(x)
+
+
+@native_function(Op.Cosh)
+def cosh(x: float) -> float:
+    return math.cosh(x)
+
+
+@native_function(Op.Tanh)
+def tanh(x: float) -> float:
+    return math.tanh(x)
+
+
+@native_function(Op.Floor)
+def floor(x: float) -> float:
+    return math.floor(x)
+
+
+@native_function(Op.Ceil)
+def ceil(x: float) -> float:
+    return math.ceil(x)
+
+
+@native_function(Op.Trunc)
+def trunc(x: float) -> float:
+    return math.trunc(x)
+
+
+@native_function(Op.Round)
+def _round(x: float) -> float:
+    return round(x)
+
+
+MATH_BUILTIN_IMPLS = {
+    id(math.sin): sin,
+    id(math.cos): cos,
+    id(math.tan): tan,
+    id(math.asin): asin,
+    id(math.acos): acos,
+    id(math.atan): atan,
+    id(math.atan2): atan2,
+    id(math.sinh): sinh,
+    id(math.cosh): cosh,
+    id(math.tanh): tanh,
+    id(math.floor): floor,
+    id(math.ceil): ceil,
+    id(math.trunc): trunc,
+    id(round): _round,
+}