sonolus.py 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

sonolus/script/internal/introspection.py

@@ -4,11 +4,14 @@ from typing import Annotated
 _missing = object()
 
 
-def get_field_specifiers(cls, *, globals=None, locals=None, eval_str=True):  # noqa: A002
+def get_field_specifiers(cls, *, skip: set[str] = frozenset(), globals=None, locals=None, eval_str=True):  # noqa: A002
     """Like inspect.get_annotations, but also turns class attributes into Annotated."""
     results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
     for key, value in results.items():
         class_value = getattr(cls, key, _missing)
-        if class_value is not _missing:
+        if class_value is not _missing and key not in skip:
             results[key] = Annotated[value, class_value]
+    for key, value in cls.__dict__.items():
+        if key not in results and key not in skip and not key.startswith("__") and not callable(value):
+            raise ValueError(f"Missing annotation for {cls.__name__}.{key}")
     return results

sonolus/script/{math.py → internal/math_impls.py}

@@ -5,67 +5,67 @@ from sonolus.script.internal.native import native_function
 
 
 @native_function(Op.Sin)
-def sin(x: float) -> float:
+def _sin(x: float) -> float:
     return math.sin(x)
 
 
 @native_function(Op.Cos)
-def cos(x: float) -> float:
+def _cos(x: float) -> float:
     return math.cos(x)
 
 
 @native_function(Op.Tan)
-def tan(x: float) -> float:
+def _tan(x: float) -> float:
     return math.tan(x)
 
 
 @native_function(Op.Arcsin)
-def asin(x: float) -> float:
+def _asin(x: float) -> float:
     return math.asin(x)
 
 
 @native_function(Op.Arccos)
-def acos(x: float) -> float:
+def _acos(x: float) -> float:
     return math.acos(x)
 
 
 @native_function(Op.Arctan)
-def atan(x: float) -> float:
+def _atan(x: float) -> float:
     return math.atan(x)
 
 
 @native_function(Op.Arctan2)
-def atan2(y: float, x: float) -> float:
+def _atan2(y: float, x: float) -> float:
     return math.atan2(y, x)
 
 
 @native_function(Op.Sinh)
-def sinh(x: float) -> float:
+def _sinh(x: float) -> float:
     return math.sinh(x)
 
 
 @native_function(Op.Cosh)
-def cosh(x: float) -> float:
+def _cosh(x: float) -> float:
     return math.cosh(x)
 
 
 @native_function(Op.Tanh)
-def tanh(x: float) -> float:
+def _tanh(x: float) -> float:
     return math.tanh(x)
 
 
 @native_function(Op.Floor)
-def floor(x: float) -> float:
+def _floor(x: float) -> float:
     return math.floor(x)
 
 
 @native_function(Op.Ceil)
-def ceil(x: float) -> float:
+def _ceil(x: float) -> float:
     return math.ceil(x)
 
 
 @native_function(Op.Trunc)
-def trunc(x: float) -> float:
+def _trunc(x: float) -> float:
     return math.trunc(x)
 
 
@@ -90,7 +90,7 @@ def _ln(x: float) -> float:
     return math.log(x)
 
 
-def log(x: float, base: float | None = None) -> float:
+def _log(x: float, base: float | None = None) -> float:
     if base is None:
         return _ln(x)
     return _ln(x) / _ln(base)
@@ -103,19 +103,19 @@ def _remainder(x: float, y: float) -> float:
 
 
 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(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,
-    id(math.log): log,
+    id(math.log): _log,
 }

sonolus/script/internal/native.py

@@ -6,14 +6,14 @@ 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, is_num
+from sonolus.script.num import Num, _is_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(is_num(arg) for arg in args):
+    if not all(_is_num(arg) 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])))
@@ -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, *bound_args.args)
+                return native_call(op, *(Num._accept_(arg) for arg in bound_args.args))
             return fn(*args)
 
         return wrapper

sonolus/script/internal/random.py

@@ -0,0 +1,67 @@
+import random as pyrand
+from collections.abc import MutableSequence, Sequence
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+from sonolus.script.values import copy
+
+
+@native_function(Op.Random)
+def _random_float(a: float, b: float) -> float:
+    """Returns a random float between a and b, inclusive."""
+    return pyrand.uniform(a, b)
+
+
+@native_function(Op.RandomInteger)
+def _random_integer(a: int, b: int) -> int:
+    """Returns a random integer between a (inclusive) and b (exclusive)."""
+    return pyrand.randrange(a, b)
+
+
+def _randrange(start: int, stop: int | None = None, step: int = 1) -> int:
+    if stop is None:
+        stop = start
+        start = 0
+    range_len = (stop - start + step - 1) // step
+    return start + step * _random_integer(0, range_len)
+
+
+def _randint(a: int, b: int) -> int:
+    return _random_integer(a, b + 1)
+
+
+def _choice[T](seq: Sequence[T]) -> T:
+    return seq[_randrange(len(seq))]
+
+
+def _swap(seq: MutableSequence, i: int, j: int) -> None:
+    temp = copy(seq[i])
+    seq[i] = seq[j]
+    seq[j] = temp
+
+
+def _shuffle[T: MutableSequence](seq: T) -> None:
+    i = len(seq) - 1
+    while i > 0:
+        j = _randrange(i + 1)
+        _swap(seq, i, j)
+        i -= 1
+
+
+def _random() -> float:
+    # The end needs to exclude 1, and Sonolus uses 32-bit floats.
+    return _random_float(0.0, 0.99999994)
+
+
+def _uniform(a: float, b: float) -> float:
+    return _random_float(a, b)
+
+
+RANDOM_BUILTIN_IMPLS = {
+    id(pyrand.randrange): _randrange,
+    id(pyrand.randint): _randint,
+    id(pyrand.choice): _choice,
+    id(pyrand.shuffle): _shuffle,
+    id(pyrand.random): _random,
+    id(pyrand.uniform): _uniform,
+}

sonolus/script/internal/range.py

@@ -0,0 +1,81 @@
+from sonolus.script.array_like import ArrayLike
+from sonolus.script.iterator import SonolusIterator
+from sonolus.script.num import Num
+from sonolus.script.record import Record
+
+
+class Range(Record, ArrayLike[Num]):
+    start: int
+    stop: int
+    step: int
+
+    def __new__(cls, start: Num, stop: Num | None = None, step: Num = 1):
+        if stop is None:
+            start, stop = 0, start
+        return super().__new__(cls, start, stop, step)
+
+    def __iter__(self) -> SonolusIterator:
+        return RangeIterator(self.start, self.stop, self.step)
+
+    def __contains__(self, item):
+        if self.step > 0:
+            return self.start <= item < self.stop and (item - self.start) % self.step == 0
+        else:
+            return self.stop < item <= self.start and (self.start - item) % -self.step == 0
+
+    def __len__(self) -> int:
+        if self.step > 0:
+            diff = self.stop - self.start
+            if diff <= 0:
+                return 0
+            return (diff + self.step - 1) // self.step
+        else:
+            diff = self.start - self.stop
+            if diff <= 0:
+                return 0
+            return (diff - self.step - 1) // -self.step
+
+    def __getitem__(self, index: Num) -> Num:
+        return self.start + index * self.step
+
+    def __setitem__(self, index: Num, value: Num):
+        raise TypeError("Range does not support item assignment")
+
+    @property
+    def last(self) -> Num:
+        return self[len(self) - 1]
+
+    def __eq__(self, other):
+        if not isinstance(other, Range):
+            return False
+        len_self = len(self)
+        len_other = len(other)
+        if len_self != len_other:
+            return False
+        if len_self == 0:
+            return True
+        return self.start == other.start and self.last == other.last
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        raise TypeError("Range is not hashable")
+
+
+class RangeIterator(Record, SonolusIterator):
+    value: int
+    stop: int
+    step: int
+
+    def has_next(self) -> bool:
+        if self.step > 0:
+            return self.value < self.stop
+        else:
+            return self.value > self.stop
+
+    def get(self) -> int:
+        return self.value
+
+    def advance(self):
+        self.value += self.step

sonolus/script/internal/transient.py

@@ -0,0 +1,51 @@
+from collections.abc import Iterable
+from typing import Any, Self
+
+from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.value import Value
+
+
+class TransientValue(Value):
+    @classmethod
+    def _is_concrete_(cls) -> bool:
+        return True
+
+    @classmethod
+    def _size_(cls) -> int:
+        return 0
+
+    @classmethod
+    def _is_value_type_(cls) -> bool:
+        return False
+
+    @classmethod
+    def _from_place_(cls, place: BlockPlace) -> Self:
+        raise TypeError(f"{cls.__name__} cannot be dereferenced")
+
+    @classmethod
+    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+        raise TypeError(f"{cls.__name__} cannot be constructed from list")
+
+    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+        raise TypeError(f"{type(self).__name__} cannot be deconstructed to list")
+
+    @classmethod
+    def _flat_keys_(cls, prefix: str) -> list[str]:
+        raise TypeError(f"{cls.__name__} cannot be flattened")
+
+    def _get_(self) -> Self:
+        return self
+
+    def _set_(self, value: Self) -> None:
+        if value is not self:
+            raise TypeError(f"{type(self).__name__} is immutable")
+
+    def _copy_from_(self, value: Self):
+        raise TypeError(f"{type(self).__name__} is immutable")
+
+    def _copy_(self) -> Self:
+        raise TypeError(f"{type(self).__name__} cannot be copied")
+
+    @classmethod
+    def _alloc_(cls) -> Self:
+        raise TypeError(f"{cls.__name__} is not allocatable")

sonolus/script/internal/tuple_impl.py

@@ -0,0 +1,113 @@
+# ruff: noqa: B905
+from typing import Any, Self
+
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.transient import TransientValue
+
+
+class TupleImpl(TransientValue):
+    value: tuple
+
+    def __init__(self, value: tuple):
+        self.value = value
+
+    @meta_fn
+    def __getitem__(self, item):
+        item = validate_value(item)
+        if not item._is_py_():
+            raise TypeError(f"Cannot index tuple with non compile-time constant {item}")
+        item = item._as_py_()
+        if not isinstance(item, int | float):
+            raise TypeError(f"Cannot index tuple with {item}")
+        if int(item) != item:
+            raise TypeError(f"Cannot index tuple with non-integer {item}")
+        if not (0 <= item < len(self.value)):
+            raise IndexError(f"Tuple index out of range: {item}")
+        return self.value[int(item)]
+
+    @meta_fn
+    def __len__(self):
+        return len(self.value)
+
+    def __eq__(self, other):
+        if not isinstance(other, tuple):
+            return False
+        if len(self) != len(other):
+            return False
+        for a, b in zip(self, other):  # noqa: SIM110
+            if a != b:
+                return False
+        return True
+
+    def __ne__(self, other):
+        if not isinstance(other, tuple):
+            return True
+        if len(self) != len(other):
+            return True
+        for a, b in zip(self, other):  # noqa: SIM110
+            if a != b:
+                return True
+        return False
+
+    def __lt__(self, other):
+        if not isinstance(other, tuple):
+            return NotImplemented
+        for a, b in zip(self.value, other.value):
+            if a != b:
+                return a < b
+        return len(self.value) < len(other.value)
+
+    def __le__(self, other):
+        if not isinstance(other, tuple):
+            return NotImplemented
+        for a, b in zip(self.value, other.value):
+            if a != b:
+                return a < b
+        return len(self.value) <= len(other.value)
+
+    def __gt__(self, other):
+        if not isinstance(other, tuple):
+            return NotImplemented
+        for a, b in zip(self.value, other.value):
+            if a != b:
+                return a > b
+        return len(self.value) > len(other.value)
+
+    def __ge__(self, other):
+        if not isinstance(other, tuple):
+            return NotImplemented
+        for a, b in zip(self.value, other.value):
+            if a != b:
+                return a > b
+        return len(self.value) >= len(other.value)
+
+    def __hash__(self):
+        return hash(self.value)
+
+    @meta_fn
+    def __add__(self, other) -> Self:
+        other = TupleImpl._accept_(other)
+        return TupleImpl._accept_(self.value + other.value)
+
+    @classmethod
+    def _accepts_(cls, value: Any) -> bool:
+        return isinstance(value, cls | tuple)
+
+    @classmethod
+    def _accept_(cls, value: Any) -> Self:
+        if not cls._accepts_(value):
+            raise TypeError(f"Cannot accept {value} as {cls.__name__}")
+        if isinstance(value, cls):
+            return value
+        else:
+            return cls(tuple(validate_value(item) for item in value))
+
+    def _is_py_(self) -> bool:
+        return all(item._is_py_() for item in self.value)
+
+    def _as_py_(self) -> tuple:
+        return tuple(item._as_py_() for item in self.value)
+
+
+TupleImpl.__name__ = "tuple"
+TupleImpl.__qualname__ = "tuple"