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

sonolus/script/internal/native.py

@@ -1,38 +1,40 @@
-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, 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):
-        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
+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, _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):
+        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) < sum(1 for p in signature.parameters.values() if p.default == inspect.Parameter.empty):
+                raise TypeError(f"Expected {len(signature.parameters)} arguments, got {len(args)}")
+            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 fn(*args)
+
+        return wrapper
+
+    return decorator

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"

sonolus/script/internal/value.py

@@ -66,7 +66,7 @@ class Value:
         raise NotImplementedError
 
     @abstractmethod
-    def _to_list_(self) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
         """Converts this value to a list of floats."""
         raise NotImplementedError
 
@@ -76,9 +76,9 @@ class Value:
         """Returns the keys to a flat representation of this value."""
         raise NotImplementedError
 
-    def _to_flat_dict_(self, prefix: str) -> dict[str, float | BlockPlace]:
+    def _to_flat_dict_(self, prefix: str, level_refs: dict[Any, int] | None = None) -> dict[str, float | BlockPlace]:
         """Converts this value to a flat dictionary."""
-        return dict(zip(self._flat_keys_(prefix), self._to_list_(), strict=False))
+        return dict(zip(self._flat_keys_(prefix), self._to_list_(level_refs), strict=False))
 
     @abstractmethod
     def _get_(self) -> Self: