sonolus.py 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

sonolus/script/stream.py

@@ -13,6 +13,7 @@ from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.internal.value import BackingValue, Value
 from sonolus.script.iterator import SonolusIterator
+from sonolus.script.maybe import Maybe, Nothing, Some
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 from sonolus.script.runtime import prev_time, time
@@ -48,7 +49,7 @@ class _StreamDataField(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         _check_can_read_or_write_stream()
-        return self._get()._get_()
+        return self._get()._get_readonly_()
 
     def __set__(self, instance, value):
         _check_can_write_stream()
@@ -136,7 +137,7 @@ class _StreamBacking(BackingValue):
     id: Num
     index: Num
 
-    def __init__(self, stream_id: int, index: Num):
+    def __init__(self, stream_id: int, index: Num | int | float):
         super().__init__()
         self.id = Num._accept_(stream_id)
         self.index = Num._accept_(index)
@@ -240,10 +241,10 @@ class Stream[T](Record):
             # We still need to store something to preserve the key, so this is a special case.
             _stream_set(self.offset, key, 0)
         else:
-            for i, v in enumerate(value._to_list_()):
+            for i, v in enumerate(cast(Value, value)._to_list_()):
                 _stream_set(self.offset + i, key, Num(v))
 
-    def next_key(self, key: int | float) -> int:
+    def next_key(self, key: int | float) -> int | float:
         """Get the next key, or the key unchanged if it is the last key or the stream is empty.
 
         If the key is in the stream and there is a next key, returns the next key.
@@ -251,13 +252,13 @@ class Stream[T](Record):
         _check_can_read_stream()
         return _stream_get_next_key(self.offset, key)
 
-    def next_key_or_default(self, key: int | float, default: int | float) -> int:
+    def next_key_or_default(self, key: int | float, default: int | float) -> int | float:
         """Get the next key, or the default value if there is no next key."""
         _check_can_read_stream()
         next_key = self.next_key(key)
         return next_key if next_key > key else default
 
-    def previous_key(self, key: int | float) -> int:
+    def previous_key(self, key: int | float) -> int | float:
         """Get the previous key, or the key unchanged if it is the first key or the stream is empty.
 
         If the key is in the stream and there is a previous key, returns the previous key.
@@ -265,7 +266,7 @@ class Stream[T](Record):
         _check_can_read_stream()
         return _stream_get_previous_key(self.offset, key)
 
-    def previous_key_or_default(self, key: int | float, default: int | float) -> int:
+    def previous_key_or_default(self, key: int | float, default: int | float) -> int | float:
         """Get the previous key, or the default value if there is no previous key."""
         _check_can_read_stream()
         previous_key = self.previous_key(key)
@@ -283,12 +284,12 @@ class Stream[T](Record):
         previous_key = self.previous_key(key)
         return previous_key < key
 
-    def next_key_inclusive(self, key: int | float) -> int:
+    def next_key_inclusive(self, key: int | float) -> int | float:
         """Like `next_key`, but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.next_key(key)
 
-    def previous_key_inclusive(self, key: int | float) -> int:
+    def previous_key_inclusive(self, key: int | float) -> int | float:
         """Like `previous_key`, but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.previous_key(key)
@@ -508,21 +509,20 @@ class StreamGroup[T, Size](Record):
         _check_can_read_or_write_stream()
         assert index in self
         # Size 0 elements still need 1 stream to preserve the key.
-        return Stream[self.type_var_value(T)](max(1, sizeof(self.element_type())) * index + self.offset)
+        t = self.type_var_value(T)
+        return Stream[t](max(1, sizeof(self.element_type())) * index + self.offset)
 
 
 class _StreamAscIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
@@ -530,42 +530,36 @@ class _StreamBoundedAscIterator[T](Record, SonolusIterator[tuple[int | float, T]
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamAscKeyIterator[T](Record, SonolusIterator[int | float]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream:
+            result = self.current_key
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscKeyIterator[T](Record, SonolusIterator[int | float]):
@@ -573,42 +567,36 @@ class _StreamBoundedAscKeyIterator[T](Record, SonolusIterator[int | float]):
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = self.current_key
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescKeyIterator[T](Record, SonolusIterator[int | float]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream:
+            result = self.current_key
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamAscValueIterator[T](Record, SonolusIterator[T]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscValueIterator[T](Record, SonolusIterator[T]):
@@ -616,28 +604,24 @@ class _StreamBoundedAscValueIterator[T](Record, SonolusIterator[T]):
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescValueIterator[T](Record, SonolusIterator[T]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 @native_function(Op.StreamGetNextKey)

sonolus/script/transform.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 from math import cos, sin
-from typing import Self
 
 from sonolus.script.interval import lerp, remap
 from sonolus.script.quad import Quad, QuadLike
@@ -27,7 +28,7 @@ class Transform2d(Record):
     a22: float
 
     @classmethod
-    def new(cls) -> Self:
+    def new(cls) -> Transform2d:
         """Create a new identity transform.
 
         Returns:
@@ -56,7 +57,7 @@ class Transform2d(Record):
         b20: float,
         b21: float,
         b22: float,
-    ) -> Self:
+    ) -> Transform2d:
         # Multiply by b on the left (b @ a)
         a00 = self.a00 * b00 + self.a10 * b01 + self.a20 * b02
         a01 = self.a01 * b00 + self.a11 * b01 + self.a21 * b02
@@ -79,7 +80,7 @@ class Transform2d(Record):
             a22,
         )
 
-    def translate(self, translation: Vec2, /) -> Self:
+    def translate(self, translation: Vec2, /) -> Transform2d:
         """Translate along the x and y axes and return a new transform.
 
         Args:
@@ -100,7 +101,7 @@ class Transform2d(Record):
             1,
         )
 
-    def scale(self, factor: Vec2, /) -> Self:
+    def scale(self, factor: Vec2, /) -> Transform2d:
         """Scale about the origin and return a new transform.
 
         Args:
@@ -121,7 +122,7 @@ class Transform2d(Record):
             1,
         )
 
-    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Transform2d:
         """Scale about the pivot and return a new transform.
 
         Args:
@@ -133,7 +134,7 @@ class Transform2d(Record):
         """
         return self.translate(-pivot).scale(factor).translate(pivot)
 
-    def rotate(self, angle: float, /) -> Self:
+    def rotate(self, angle: float, /) -> Transform2d:
         """Rotate about the origin and return a new transform.
 
         Args:
@@ -156,7 +157,7 @@ class Transform2d(Record):
             1,
         )
 
-    def rotate_about(self, angle: float, /, pivot: Vec2) -> Self:
+    def rotate_about(self, angle: float, /, pivot: Vec2) -> Transform2d:
         """Rotate about the pivot and return a new transform.
 
         Args:
@@ -168,7 +169,7 @@ class Transform2d(Record):
         """
         return self.translate(-pivot).rotate(angle).translate(pivot)
 
-    def shear_x(self, m: float, /) -> Self:
+    def shear_x(self, m: float, /) -> Transform2d:
         """Shear along the x-axis and return a new transform.
 
         Args:
@@ -189,7 +190,7 @@ class Transform2d(Record):
             1,
         )
 
-    def shear_y(self, m: float, /) -> Self:
+    def shear_y(self, m: float, /) -> Transform2d:
         """Shear along the y-axis and return a new transform.
 
         Args:
@@ -210,7 +211,7 @@ class Transform2d(Record):
             1,
         )
 
-    def simple_perspective_x(self, x: float, /) -> Self:
+    def simple_perspective_x(self, x: float, /) -> Transform2d:
         """Apply perspective along the x-axis with vanishing point at the given x coordinate and return a new transform.
 
         Args:
@@ -231,7 +232,7 @@ class Transform2d(Record):
             1,
         )
 
-    def simple_perspective_y(self, y: float, /) -> Self:
+    def simple_perspective_y(self, y: float, /) -> Transform2d:
         """Apply perspective along the y-axis with vanishing point at the given y coordinate and return a new transform.
 
         Args:
@@ -252,7 +253,7 @@ class Transform2d(Record):
             1,
         )
 
-    def perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> Self:
+    def perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> Transform2d:
         """Apply a perspective transformation along the x-axis and return a new transform.
 
         Args:
@@ -268,7 +269,7 @@ class Transform2d(Record):
             .translate(Vec2(foreground_x, 0))
         )
 
-    def perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> Self:
+    def perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> Transform2d:
         """Apply a perspective transformation along the y-axis and return a new transform.
 
         Args:
@@ -284,7 +285,7 @@ class Transform2d(Record):
             .translate(Vec2(0, foreground_y))
         )
 
-    def inverse_perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> Self:
+    def inverse_perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> Transform2d:
         """Apply the inverse of a perspective transformation along the x-axis and return a new transform.
 
         Args:
@@ -300,7 +301,7 @@ class Transform2d(Record):
             .simple_perspective_x(-vanishing_point.x + foreground_x)
         )
 
-    def inverse_perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> Self:
+    def inverse_perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> Transform2d:
         """Apply the inverse of a perspective transformation along the y-axis and return a new transform.
 
         Args:
@@ -316,7 +317,7 @@ class Transform2d(Record):
             .simple_perspective_y(-vanishing_point.y + foreground_y)
         )
 
-    def normalize(self) -> Self:
+    def normalize(self) -> Transform2d:
         """Normalize the transform to have a 1 in the bottom right corner and return a new transform.
 
         This may fail in some special cases involving perspective transformations where the bottom right corner is 0.
@@ -336,7 +337,7 @@ class Transform2d(Record):
             1,
         )
 
-    def compose(self, other: Self, /) -> Self:
+    def compose(self, other: Transform2d, /) -> Transform2d:
         """Compose with another transform which is applied after this transform and return a new transform.
 
         Args:
@@ -357,7 +358,7 @@ class Transform2d(Record):
             other.a22,
         )
 
-    def compose_before(self, other: Self, /) -> Self:
+    def compose_before(self, other: Transform2d, /) -> Transform2d:
         """Compose with another transform which is applied before this transform and return a new transform.
 
         Args:
@@ -412,7 +413,7 @@ class InvertibleTransform2d(Record):
     inverse: Transform2d
 
     @classmethod
-    def new(cls) -> Self:
+    def new(cls) -> InvertibleTransform2d:
         """Create a new identity transform.
 
         Returns:
@@ -423,7 +424,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new(),
         )
 
-    def translate(self, translation: Vec2, /) -> Self:
+    def translate(self, translation: Vec2, /) -> InvertibleTransform2d:
         """Translate along the x and y axes and return a new transform.
 
         Args:
@@ -437,7 +438,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().translate(-translation).compose(self.inverse),
         )
 
-    def scale(self, factor: Vec2, /) -> Self:
+    def scale(self, factor: Vec2, /) -> InvertibleTransform2d:
         """Scale about the origin and return a new transform.
 
         Args:
@@ -451,7 +452,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().scale(Vec2.one() / factor).compose(self.inverse),
         )
 
-    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> InvertibleTransform2d:
         """Scale about the pivot and return a new transform.
 
         Args:
@@ -466,7 +467,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().scale_about(Vec2.one() / factor, pivot).compose(self.inverse),
         )
 
-    def rotate(self, angle: float, /) -> Self:
+    def rotate(self, angle: float, /) -> InvertibleTransform2d:
         """Rotate about the origin and return a new transform.
 
         Args:
@@ -480,7 +481,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().rotate(-angle).compose(self.inverse),
         )
 
-    def rotate_about(self, angle: float, /, pivot: Vec2) -> Self:
+    def rotate_about(self, angle: float, /, pivot: Vec2) -> InvertibleTransform2d:
         """Rotate about the pivot and return a new transform.
 
         Args:
@@ -495,7 +496,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().rotate_about(-angle, pivot).compose(self.inverse),
         )
 
-    def shear_x(self, m: float, /) -> Self:
+    def shear_x(self, m: float, /) -> InvertibleTransform2d:
         """Shear along the x-axis and return a new transform.
 
         Args:
@@ -509,7 +510,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().shear_x(-m).compose(self.inverse),
         )
 
-    def shear_y(self, m: float, /) -> Self:
+    def shear_y(self, m: float, /) -> InvertibleTransform2d:
         """Shear along the y-axis and return a new transform.
 
         Args:
@@ -523,7 +524,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().shear_y(-m).compose(self.inverse),
         )
 
-    def simple_perspective_x(self, x: float, /) -> Self:
+    def simple_perspective_x(self, x: float, /) -> InvertibleTransform2d:
         """Apply perspective along the x-axis with vanishing point at the given x coordinate and return a new transform.
 
         Args:
@@ -537,7 +538,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().simple_perspective_x(-x).compose(self.inverse),
         )
 
-    def simple_perspective_y(self, y: float, /) -> Self:
+    def simple_perspective_y(self, y: float, /) -> InvertibleTransform2d:
         """Apply perspective along the y-axis with vanishing point at the given y coordinate and return a new transform.
 
         Args:
@@ -551,7 +552,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().simple_perspective_y(-y).compose(self.inverse),
         )
 
-    def perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> Self:
+    def perspective_x(self, foreground_x: float, vanishing_point: Vec2, /) -> InvertibleTransform2d:
         """Apply a perspective transformation along the x-axis and return a new transform.
 
         Args:
@@ -566,7 +567,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().inverse_perspective_x(foreground_x, vanishing_point).compose(self.inverse),
         )
 
-    def perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> Self:
+    def perspective_y(self, foreground_y: float, vanishing_point: Vec2, /) -> InvertibleTransform2d:
         """Apply a perspective transformation along the y-axis and return a new transform.
 
         Args:
@@ -581,7 +582,7 @@ class InvertibleTransform2d(Record):
             inverse=Transform2d.new().inverse_perspective_y(foreground_y, vanishing_point).compose(self.inverse),
         )
 
-    def normalize(self) -> Self:
+    def normalize(self) -> InvertibleTransform2d:
         """Normalize the transform to have a 1 in the bottom right corner and return a new transform.
 
         This may fail in some special cases involving perspective transformations where the bottom right corner is 0.
@@ -594,7 +595,7 @@ class InvertibleTransform2d(Record):
             inverse=self.inverse.normalize(),
         )
 
-    def compose(self, other: Self, /) -> Self:
+    def compose(self, other: InvertibleTransform2d, /) -> InvertibleTransform2d:
         """Compose with another invertible transform which is applied after this transform and return a new transform.
 
         Args:
@@ -608,7 +609,7 @@ class InvertibleTransform2d(Record):
             inverse=other.inverse.compose(self.inverse),
         )
 
-    def compose_before(self, other: Self, /) -> Self:
+    def compose_before(self, other: InvertibleTransform2d, /) -> InvertibleTransform2d:
         """Compose with another invertible transform which is applied before this transform and return a new transform.
 
         Args:

sonolus/script/values.py

@@ -5,25 +5,25 @@ from sonolus.script.num import Num
 
 
 @meta_fn
-def alloc[T](type_: type[T]) -> T:
+def alloc[T](type_: type[T]) -> T:  # type: ignore
     """Return an uninitialized instance of the given type.
 
     Use this carefully as reading from uninitialized memory can lead to unexpected behavior.
     """
     type_ = validate_concrete_type(type_)
     if ctx():
-        return type_._alloc_()
+        return type_._alloc_()  # type: ignore
     else:
-        return type_._alloc_()._as_py_()
+        return type_._alloc_()._as_py_()  # type: ignore
 
 
 @meta_fn
-def zeros[T](type_: type[T]) -> T:
+def zeros[T](type_: type[T]) -> T:  # type: ignore
     """Make a new instance of the given type initialized with zeros.
 
     Generally works the same as the unary `+` operator on record and array types.
     """
-    return validate_concrete_type(type_)._zero_()
+    return validate_concrete_type(type_)._zero_()  # type: ignore
 
 
 @meta_fn
@@ -32,18 +32,18 @@ def copy[T](value: T) -> T:
 
     Generally works the same as the unary `+` operator on records and arrays.
     """
-    value = validate_value(value)
+    value = validate_value(value)  # type: ignore
     if ctx():
-        return value._copy_()
+        return value._copy_()  # type: ignore
     else:
-        return value._copy_()._as_py_()
+        return value._copy_()._as_py_()  # type: ignore
 
 
 def swap[T](a: T, b: T):
     """Swap the values of the two provided mutable values."""
     temp = copy(a)
-    a @= b
-    b @= temp
+    a @= b  # type: ignore
+    b @= temp  # type: ignore
 
 
 @meta_fn