sonolus.py 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

sonolus/backend/ops.py

@@ -180,6 +180,12 @@ class Op(StrEnum):
     StackSetPointer = ("StackSetPointer", True, False, False)
     StopLooped = ("StopLooped", True, False, False)
     StopLoopedScheduled = ("StopLoopedScheduled", True, False, False)
+    # Streams are immutable when they're readable, so we can treat read operations as pure.
+    StreamGetNextKey = ("StreamGetNextKey", False, True, False)
+    StreamGetPreviousKey = ("StreamGetPreviousKey", False, True, False)
+    StreamGetValue = ("StreamGetValue", False, True, False)
+    StreamHas = ("StreamHas", False, True, False)
+    StreamSet = ("StreamSet", True, False, False)
     Subtract = ("Subtract", False, True, False)
     Switch = ("Switch", False, True, True)
     SwitchInteger = ("SwitchInteger", False, True, True)

sonolus/script/archetype.py

@@ -679,7 +679,7 @@ class PlayArchetype(_BaseArchetype):
     def should_spawn(self) -> bool:
         """Return whether the entity should be spawned.
 
-        Runs when this entity is first in the spawn queue.
+        Runs each frame while the entity is the first entity in the spawn queue.
         """
 
     def initialize(self):

sonolus/script/array.py

@@ -12,7 +12,7 @@ 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.value import DataValue, Value
+from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 
@@ -27,16 +27,14 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         ```
     """
 
-    _value: list[T] | BlockPlace
+    _value: list[T] | BlockPlace | BackingSource
 
     @classmethod
-    @meta_fn
     def element_type(cls) -> type[T] | type[Value]:
         """Return the type of elements in this array type."""
         return cls.type_var_value(T)
 
     @classmethod
-    @meta_fn
     def size(cls) -> int:
         """Return the size of this array type.
 
@@ -85,6 +83,10 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
     def _is_value_type_(cls) -> bool:
         return False
 
+    @classmethod
+    def _from_backing_source_(cls, source: BackingSource) -> Self:
+        return cls._with_value(source)
+
     @classmethod
     def _from_place_(cls, place: BlockPlace) -> Self:
         return cls._with_value(place)
@@ -124,6 +126,8 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
                     ._from_place_(self._value.add_offset(i * self.element_type()._size_()))
                     ._to_list_()
                 ]
+            case backing_source if callable(backing_source):
+                return [backing_source(IRConst(i)) for i in range(self.size() * self.element_type()._size_())]
             case _:
                 assert_unreachable()
 
@@ -135,7 +139,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         return self
 
     def _set_(self, value: Self):
-        raise TypeError("Array does not support set_")
+        raise TypeError("Array does not support _set_")
 
     def _copy_from_(self, value: Self):
         if not isinstance(value, type(self)):
@@ -150,6 +154,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
             result._copy_from_(self)
             return result
         else:
+            assert isinstance(self._value, list)
             return self._with_value([value._copy_() for value in self._value])
 
     @classmethod
@@ -186,22 +191,36 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
                     return self._value[const_index]._get_()
                 else:
                     return self._value[const_index]._get_()._as_py_()
-            else:
+            elif isinstance(self._value, BlockPlace):
                 return (
                     self.element_type()
                     ._from_place_(self._value.add_offset(const_index * self.element_type()._size_()))
                     ._get_()
                 )
+            elif callable(self._value):
+                return self.element_type()._from_backing_source_(
+                    lambda offset: self._value((Num(offset) + Num(const_index * self.element_type()._size_())).ir())
+                )
+            else:
+                raise InternalError("Unexpected array value")
         else:
             if not ctx():
                 raise InternalError("Unexpected non-constant index")
-            base = ctx().rom[tuple(self._to_list_())] if isinstance(self._value, list) else self._value
-            place = BlockPlace(
-                block=base.block,
-                index=(Num(base.index) + index * self.element_type()._size_()).index(),
-                offset=base.offset,
-            )
-            return self.element_type()._from_place_(place)._get_()
+            if isinstance(self._value, list | BlockPlace):
+                base = ctx().rom[tuple(self._to_list_())] if isinstance(self._value, list) else self._value
+                place = BlockPlace(
+                    block=base.block,
+                    index=(Num(base.index) + index * self.element_type()._size_()).index(),
+                    offset=base.offset,
+                )
+                return self.element_type()._from_place_(place)._get_()
+            elif callable(self._value):
+                base_offset = index * Num(self.element_type()._size_())
+                return self.element_type()._from_backing_source_(
+                    lambda offset: self._value((Num(offset) + base_offset).ir())
+                )
+            else:
+                raise InternalError("Unexpected array value")
 
     @meta_fn
     def __setitem__(self, index: Num, value: T):
@@ -210,17 +229,25 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         if ctx():
             if isinstance(self._value, list):
                 raise ValueError("Cannot mutate a compile time constant array")
-            base = self._value
-            place = (
-                base.add_offset(int(index._as_py_()) * self.element_type()._size_())
-                if index._is_py_()
-                else BlockPlace(
-                    block=base.block,
-                    index=(Num(base.index) + index * self.element_type()._size_()).index(),
-                    offset=base.offset,
+            elif isinstance(self._value, BlockPlace):
+                base = self._value
+                place = (
+                    base.add_offset(int(index._as_py_()) * self.element_type()._size_())
+                    if index._is_py_()
+                    else BlockPlace(
+                        block=base.block,
+                        index=(Num(base.index) + index * self.element_type()._size_()).index(),
+                        offset=base.offset,
+                    )
+                )
+                dst = self.element_type()._from_place_(place)
+            elif callable(self._value):
+                base_offset = index * Num(self.element_type()._size_())
+                dst = self.element_type()._from_backing_source_(
+                    lambda offset: self._value((Num(offset) + base_offset).ir())
                 )
-            )
-            dst = self.element_type()._from_place_(place)
+            else:
+                raise InternalError("Unexpected array value")
             if self.element_type()._is_value_type_():
                 dst._set_(value)
             else:
@@ -259,11 +286,13 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         return hash(tuple(self[i] for i in range(self.size())))
 
     def __str__(self):
-        if isinstance(self._value, BlockPlace):
+        if isinstance(self._value, BlockPlace) or callable(self._value):
             return f"{type(self).__name__}({self._value}...)"
-        return f"{type(self).__name__}({", ".join(str(self[i]) for i in range(self.size()))})"
+        else:
+            return f"{type(self).__name__}({", ".join(str(self[i]) for i in range(self.size()))})"
 
     def __repr__(self):
-        if isinstance(self._value, BlockPlace):
+        if isinstance(self._value, BlockPlace) or callable(self._value):
             return f"{type(self).__name__}({self._value}...)"
-        return f"{type(self).__name__}({", ".join(repr(self[i]) for i in range(self.size()))})"
+        else:
+            return f"{type(self).__name__}({", ".join(repr(self[i]) for i in range(self.size()))})"

sonolus/script/array_like.py

@@ -188,6 +188,7 @@ class ArrayLike[T](Sequence, ABC):
         if len(self) < 15 or key is not None:
             if key is None:
                 key = _identity
+            # May be worth adding a block sort variant for better performance on large arrays in the future
             _insertion_sort(self, 0, len(self), key, reverse)
         else:
             # Heap sort is unstable, so if there's a key, we can't rely on it

sonolus/script/bucket.py

@@ -20,7 +20,7 @@ class JudgmentWindow(Record):
     """The window for judging the accuracy of a hit.
 
     Usage:
-        ```
+        ```python
         JudgmentWindow(perfect: Interval, great: Interval, good: Interval)
         ```
     """
@@ -62,7 +62,7 @@ class JudgmentWindow(Record):
             target: The target time of the hit.
 
         Returns:
-            The judgment of the hit.
+            The [`Judgment`][sonolus.script.bucket.Judgment] of the hit.
         """
         return _judge(
             actual,
@@ -133,7 +133,9 @@ class Bucket(Record):
     """A bucket for entity judgment results.
 
     Usage:
-        ```Bucket(id: int)```
+        ```python
+        Bucket(id: int)
+        ```
     """
 
     id: int

sonolus/script/internal/constant.py

@@ -18,6 +18,8 @@ _MISSING = _Missing()
 
 
 class ConstantValue(Value):
+    """Wraps a python constant value usable in Sonolus scripts."""
+
     _parameterized_: ClassVar[dict[Any, type[Self]]] = {}
     _value: ClassVar[Any] = _MISSING
     instance: ClassVar[Self | _Missing] = _MISSING
@@ -139,5 +141,5 @@ class ConstantValue(Value):
         return hash(self.value())
 
 
-class MiscConstantValue(ConstantValue):
+class BasicConstantValue(ConstantValue):
     """For constants without any special behavior."""

sonolus/script/internal/generic.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import typing
 from enum import Enum
+from types import UnionType
 from typing import Annotated, Any, ClassVar, Literal, Self, TypeVar, get_origin
 
 from sonolus.script.internal.impl import meta_fn, validate_value
@@ -31,6 +33,11 @@ def validate_type_spec(spec: Any) -> PartialGeneric | TypeVar | type[Value]:
         spec = validate_type_spec(spec.__mro__[1])
     if isinstance(spec, PartialGeneric | TypeVar) or (isinstance(spec, type) and issubclass(spec, Value)):
         return spec
+    if typing.get_origin(spec) is UnionType:
+        args = typing.get_args(spec)
+        validated_args = {validate_type_arg(arg) for arg in args}
+        if len(validated_args) == 1:
+            return validated_args.pop()
     raise TypeError(f"Invalid type spec: {spec}")
 
 

sonolus/script/internal/impl.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from enum import Enum
-from types import FunctionType, MethodType, ModuleType, NoneType, NotImplementedType, UnionType
+from types import EllipsisType, FunctionType, MethodType, ModuleType, NoneType, NotImplementedType, UnionType
 from typing import TYPE_CHECKING, Annotated, Any, Literal, TypeVar, get_origin, overload
 
 if TYPE_CHECKING:
@@ -42,7 +42,7 @@ def validate_value(value: Any) -> Value:
 
 def try_validate_value(value: Any) -> Value | None:
     from sonolus.script.globals import _GlobalPlaceholder
-    from sonolus.script.internal.constant import MiscConstantValue
+    from sonolus.script.internal.constant import BasicConstantValue
     from sonolus.script.internal.dict_impl import DictImpl
     from sonolus.script.internal.generic import PartialGeneric
     from sonolus.script.internal.tuple_impl import TupleImpl
@@ -65,8 +65,8 @@ def try_validate_value(value: Any) -> Value | None:
             return value
         case type():
             if value in {int, float, bool}:
-                return MiscConstantValue.of(Num)
-            return MiscConstantValue.of(value)
+                return BasicConstantValue.of(Num)
+            return BasicConstantValue.of(value)
         case int() | float() | bool():
             return Num._accept_(value)
         case tuple():
@@ -78,17 +78,18 @@ def try_validate_value(value: Any) -> Value | None:
             | TypeVar()
             | FunctionType()
             | MethodType()
-            | NotImplementedType()
             | str()
-            | NoneType()
             | ModuleType()
+            | NoneType()
+            | NotImplementedType()
+            | EllipsisType()
         ):
-            return MiscConstantValue.of(value)
+            return BasicConstantValue.of(value)
         case other_type if get_origin(value) in {Literal, Annotated, UnionType, tuple}:
-            return MiscConstantValue.of(other_type)
+            return BasicConstantValue.of(other_type)
         case _GlobalPlaceholder():
             return value.get()
         case comptime_value if getattr(comptime_value, "_is_comptime_value_", False):
-            return MiscConstantValue.of(comptime_value)
+            return BasicConstantValue.of(comptime_value)
         case _:
             return None

sonolus/script/internal/value.py

@@ -14,6 +14,19 @@ class BackingValue:
         raise NotImplementedError()
 
 
+class ExprBackingValue(BackingValue):
+    """A backing value that is backed by an expression."""
+
+    def __init__(self, expr: IRExpr):
+        self._expr = expr
+
+    def read(self) -> IRExpr:
+        return self._expr
+
+    def write(self, value: IRExpr) -> IRStmt:
+        raise RuntimeError("Value is read-only, cannot write to it")
+
+
 type DataValue = BlockPlace | BackingValue | float | int | bool
 type BackingSource = Callable[[IRExpr], BackingValue]
 

sonolus/script/num.py

@@ -5,13 +5,13 @@ import operator
 from collections.abc import Callable, Iterable
 from typing import TYPE_CHECKING, Any, Self, TypeGuard, final, runtime_checkable
 
-from sonolus.backend.ir import IRConst, IRGet, IRPureInstr, IRSet
+from sonolus.backend.ir import IRConst, IRExpr, IRGet, IRPureInstr, IRSet
 from sonolus.backend.ops import Op
 from sonolus.backend.place import BlockPlace
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.error import InternalError
 from sonolus.script.internal.impl import meta_fn
-from sonolus.script.internal.value import BackingValue, DataValue, Value
+from sonolus.script.internal.value import BackingValue, DataValue, ExprBackingValue, Value
 
 
 class _NumMeta(type):
@@ -32,11 +32,13 @@ class _Num(Value, metaclass=_NumMeta):
 
     data: DataValue
 
-    def __init__(self, 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):
@@ -112,10 +114,11 @@ class _Num(Value, metaclass=_NumMeta):
             return Num(self.data)
 
     def _set_(self, value: Self):
+        value = Num._accept_(value)
         if ctx():
             match self.data:
                 case BackingValue():
-                    ctx().add_statements(self.data.write(value))
+                    self.data.write(value.ir())
                 case BlockPlace():
                     ctx().check_writable(self.data)
                     ctx().add_statements(IRSet(self.data, value.ir()))

sonolus/script/particle.py

@@ -91,6 +91,7 @@ class _ParticleInfo:
 
 
 def particle(name: str) -> Any:
+    """Define a particle with the given name."""
     return _ParticleInfo(name)
 
 

sonolus/script/quad.py

@@ -11,7 +11,7 @@ class Quad(Record):
     """A quad defined by its four corners.
 
     Usage:
-        ```
+        ```python
         Quad(bl: Vec2, tl: Vec2, tr: Vec2, br: Vec2)
         ```
     """
@@ -160,7 +160,7 @@ class Rect(Record):
     """A rectangle defined by its top, right, bottom, and left edges.
 
     Usage:
-        ```
+        ```python
         Rect(t: float, r: float, b: float, l: float)
         ```
     """
@@ -223,7 +223,7 @@ class Rect(Record):
         return Vec2((self.l + self.r) / 2, (self.t + self.b) / 2)
 
     def as_quad(self) -> Quad:
-        """Convert the rectangle to a quad."""
+        """Convert the rectangle to a [`Quad`][sonolus.script.quad.Quad]."""
         return Quad(
             bl=self.bl,
             tl=self.tl,

sonolus/script/record.py

@@ -16,7 +16,7 @@ from sonolus.script.internal.generic import (
     validate_type_spec,
 )
 from sonolus.script.internal.impl import meta_fn
-from sonolus.script.internal.value import DataValue, Value
+from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 
@@ -157,6 +157,17 @@ class Record(GenericValue):
     def _is_value_type_(cls) -> bool:
         return False
 
+    @classmethod
+    def _from_backing_source_(cls, source: BackingSource) -> Self:
+        result = object.__new__(cls)
+        result._value = {
+            field.name: field.type._from_backing_source_(
+                lambda offset, field_offset=field.offset: source((Num(offset) + Num(field_offset)).ir())
+            )
+            for field in cls._fields
+        }
+        return result
+
     @classmethod
     def _from_place_(cls, place: BlockPlace) -> Self:
         result = object.__new__(cls)
@@ -203,7 +214,7 @@ class Record(GenericValue):
         return self
 
     def _set_(self, value: Self):
-        raise TypeError("Record does not support set_")
+        raise TypeError("Record does not support _set_")
 
     def _copy_from_(self, value: Self):
         value = self._accept_(value)

sonolus/script/stream.py

@@ -0,0 +1,553 @@
+from __future__ import annotations
+
+from typing import cast, dataclass_transform
+
+from sonolus.backend.ir import IRExpr, IRInstr, IRPureInstr, IRConst
+from sonolus.backend.mode import Mode
+from sonolus.backend.ops import Op
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.descriptor import SonolusDescriptor
+from sonolus.script.internal.impl import meta_fn
+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.num import Num
+from sonolus.script.record import Record
+from sonolus.script.values import sizeof
+
+
+class _StreamField(SonolusDescriptor):
+    offset: int
+    type_: type[Stream] | type[StreamGroup]
+
+    def __init__(self, offset: int, type_: type[Stream] | type[StreamGroup]):
+        self.offset = offset
+        self.type_ = type_
+
+    def __get__(self, instance, owner):
+        _check_can_read_or_write_stream()
+        return self.type_(self.offset)
+
+    def __set__(self, instance, value):
+        raise AttributeError("Cannot set attribute")
+
+
+class _StreamDataField(SonolusDescriptor):
+    offset: int
+    type_: type[Value]
+
+    def __init__(self, offset: int, type_: type[Value]):
+        self.offset = offset
+        self.type_ = type_
+
+    def _get(self):
+        return self.type_._from_backing_source_(lambda offset: _SparseStreamBacking(self.offset, Num(offset)))
+
+    def __get__(self, instance, owner):
+        _check_can_read_or_write_stream()
+        return self._get()._get_()
+
+    def __set__(self, instance, value):
+        _check_can_write_stream()
+        if self.type_._is_value_type_():
+            self._get()._set_(value)
+        else:
+            self._get()._copy_from_(value)
+
+
+@dataclass_transform()
+def streams[T](cls: type[T]) -> T:
+    """Decorator to define streams and stream groups.
+
+    Streams and stream groups are declared by annotating class attributes with `Stream` or `StreamGroup`.
+
+    Other types are also supported in the form of data fields. They may be used to store additional data to export from
+    Play to Watch mode.
+
+    In either case, data is write-only in Play mode and read-only in Watch mode.
+
+    This should only be used once in most projects, as multiple decorated classes will overlap with each other and
+    interfere when both are used at the same time.
+
+    For backwards compatibility, new streams and stream groups should be added to the end of existing ones, and
+    lengths and element types of existing streams and stream groups should not be changed. Otherwise, old replays may
+    not work on new versions of the engine.
+
+    Usage:
+        ```python
+        @streams
+        class Streams:
+            stream_1: Stream[Num]  # A stream of Num values
+            stream_2: Stream[Vec2]  # A stream of Vec2 values
+            group_1: StreamGroup[Num, 10]  # A group of 10 Num streams
+            group_2: StreamGroup[Vec2, 5]  # A group of 5 Vec2 streams
+
+            data_field_1: Num  # A data field of type Num
+            data_field_2: Vec2  # A data field of type Vec2
+        ```
+    """
+    if len(cls.__bases__) != 1:
+        raise ValueError("Options class must not inherit from any class (except object)")
+    instance = cls()
+    entries = []
+    # Offset 0 is unused so we can tell when a stream object is uninitialized since it'll have offset 0.
+    offset = 1
+    for name, annotation in get_field_specifiers(cls).items():
+        if issubclass(annotation, Stream | StreamGroup):
+            annotation = cast(type[Stream | StreamGroup], annotation)
+            if annotation is Stream or annotation is StreamGroup:
+                raise TypeError(f"Invalid annotation for streams: {annotation}. Must have type arguments.")
+            setattr(cls, name, _StreamField(offset, annotation))
+            # Streams store their data across several backing streams
+            entries.append((name, offset, annotation))
+            offset += annotation.backing_size()
+        elif issubclass(annotation, Value) and annotation._is_concrete_():
+            setattr(cls, name, _StreamDataField(offset, annotation))
+            # Data fields store their data in a single backing stream at different offsets in the same stream
+            entries.append((name, offset, annotation))
+            offset += 1
+    instance._streams_ = entries
+    instance._is_comptime_value_ = True
+    return instance
+
+
+@meta_fn
+def _check_can_read_stream() -> None:
+    if not ctx() or ctx().global_state.mode != Mode.WATCH:
+        raise RuntimeError("Stream read operations are only allowed in watch mode.")
+
+
+@meta_fn
+def _check_can_write_stream() -> None:
+    if not ctx() or ctx().global_state.mode != Mode.PLAY:
+        raise RuntimeError("Stream write operations are only allowed in play mode.")
+
+
+@meta_fn
+def _check_can_read_or_write_stream() -> None:
+    if not ctx() or ctx().global_state.mode not in {Mode.PLAY, Mode.WATCH}:
+        raise RuntimeError("Stream operations are only allowed in play and watch modes.")
+
+
+class _StreamBacking(BackingValue):
+    id: Num
+    index: Num
+
+    def __init__(self, stream_id: int, index: Num):
+        super().__init__()
+        self.id = Num._accept_(stream_id)
+        self.index = Num._accept_(index)
+
+    def read(self) -> IRExpr:
+        """Read the value from the stream."""
+        _check_can_read_stream()
+        return IRPureInstr(Op.StreamGetValue, [self.id.ir(), self.index.ir()])
+
+    def write(self, value: IRExpr) -> None:
+        """Write the value to the stream."""
+        _check_can_write_stream()
+        ctx().add_statement(IRInstr(Op.StreamSet, [self.id.ir(), self.index.ir(), value]))
+
+
+class _SparseStreamBacking(BackingValue):
+    id: Num
+    index: Num
+
+    def __init__(self, stream_id: int, index: Num):
+        super().__init__()
+        self.id = Num._accept_(stream_id)
+        self.index = Num._accept_(index)
+
+    def read(self) -> IRExpr:
+        """Read the value from the stream."""
+        _check_can_read_stream()
+        return IRPureInstr(Op.StreamGetValue, [self.id.ir(), self.index.ir()])
+
+    def write(self, value: IRExpr) -> None:
+        """Write the value to the stream."""
+        _check_can_write_stream()
+        ctx().add_statements(
+            IRInstr(Op.StreamSet, [self.id.ir(), self.index.ir(), value]),
+            IRInstr(Op.StreamSet, [self.id.ir(), (self.index - 0.5).ir(), IRConst(0)]),
+            IRInstr(Op.StreamSet, [self.id.ir(), (self.index + 0.5).ir(), IRConst(0)]),
+        )
+
+
+class Stream[T](Record, BackingValue):
+    """Represents a stream.
+
+    Most users should use `@stream` to declare streams and stream groups rather than using this class directly.
+
+    If used directly, it is important that streams do not overlap. No other streams should have an offset in
+    `range(self.offset, self.offset + max(1, sizeof(self.element_type())))`, or they will overlap and interfere
+    with each other.
+
+    Usage:
+        Declaring a stream:
+        ```python
+        @streams
+        class Streams:
+            my_stream_1: Stream[Num]  # A stream of Num values
+            my_stream_2: Stream[Vec2]  # A stream of Vec2 values
+        ```
+
+        Directly creating a stream (advanced usage):
+        ```python
+        stream = Stream[Num](offset=0)
+        ```
+    """
+
+    offset: int
+
+    @classmethod
+    def element_type(cls) -> type[T] | type[Value]:
+        """Return the type of elements in this array type."""
+        return cls.type_var_value(T)
+
+    @classmethod
+    @meta_fn
+    def backing_size(cls) -> int:
+        """Return the number of underlying single-value streams backing this stream."""
+        return max(1, sizeof(cls.element_type()))
+
+    def __contains__(self, item: int | float) -> bool:
+        """Check if the stream contains the key."""
+        _check_can_read_stream()
+        return _stream_has(self.offset, item)
+
+    @meta_fn
+    def __getitem__(self, key: int | float) -> T:
+        """Get the value corresponding to the key.
+
+        If the key is not in the stream, interpolates linearly between surrounding values.
+        If the stream is empty, returns the zero value of the element type.
+        """
+        # This is allowed in Play mode since a stream value may be accessed just to write to it without reading.
+        _check_can_read_or_write_stream()
+        return self.element_type()._from_backing_source_(lambda offset: _StreamBacking(self.offset + Num(offset), key))
+
+    @meta_fn
+    def __setitem__(self, key: int | float, value: T) -> None:
+        """Set the value corresponding to the key."""
+        _check_can_write_stream()
+        if not self.element_type()._accepts_(value):
+            raise TypeError(f"Cannot set value of type {type(value)} to stream of type {self.element_type()}.")
+        if self.element_type()._size_() == 0:
+            # 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_()):
+                _stream_set(self.offset + i, key, Num(v))
+
+    def next_key(self, key: int | float) -> int:
+        """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.
+        """
+        _check_can_read_stream()
+        return _stream_get_next_key(self.offset, key)
+
+    def previous_key(self, key: int | float) -> int:
+        """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.
+        """
+        _check_can_read_stream()
+        return _stream_get_previous_key(self.offset, key)
+
+    def has_next_key(self, key: int | float) -> bool:
+        """Check if there is a next key after the given key in the stream."""
+        _check_can_read_stream()
+        next_key = self.next_key(key)
+        return next_key > key
+
+    def has_previous_key(self, key: int | float) -> bool:
+        """Check if there is a previous key before the given key in the stream."""
+        _check_can_read_stream()
+        previous_key = self.previous_key(key)
+        return previous_key < key
+
+    def next_key_inclusive(self, key: int | float) -> int:
+        """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:
+        """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)
+
+    def get_next(self, key: int | float) -> T:
+        """Get the value corresponding to the next key.
+
+        If there is no next key, returns the value at the given key. Equivalent to `self[self.next_key(key)]`.
+        """
+        _check_can_read_stream()
+        return self[self.next_key(key)]
+
+    def get_previous(self, key: int | float) -> T:
+        """Get the value corresponding to the previous key.
+
+        If there is no previous key, returns the value at the given key. Equivalent to `self[self.previous_key(key)]`.
+        """
+        _check_can_read_stream()
+        return self[self.previous_key(key)]
+
+    def get_next_inclusive(self, key: int | float) -> T:
+        """Get the value corresponding to the next key, or the value at the given key if it is in the stream.
+
+        Equivalent to `self[self.next_key_inclusive(key)]`.
+        """
+        _check_can_read_stream()
+        return self[self.next_key_inclusive(key)]
+
+    def iter_items_from(self, start: int | float, /) -> SonolusIterator[tuple[int | float, T]]:
+        """Iterate over the items in the stream in ascending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for key, value in stream.iter_items_from(0):
+            do_something(key, value)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamAscIterator(self, self.next_key_inclusive(start))
+
+    def iter_items_from_desc(self, start: int | float, /) -> SonolusIterator[tuple[int | float, T]]:
+        """Iterate over the items in the stream in descending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for key, value in stream.iter_items_from_desc(0):
+            do_something(key, value)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamDescIterator(self, self.previous_key_inclusive(start))
+
+    def iter_keys_from(self, start: int | float, /) -> SonolusIterator[int | float]:
+        """Iterate over the keys in the stream in ascending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for key in stream.iter_keys_from(0):
+            do_something(key)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamAscKeyIterator(self, self.next_key_inclusive(start))
+
+    def iter_keys_from_desc(self, start: int | float, /) -> SonolusIterator[int | float]:
+        """Iterate over the keys in the stream in descending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for key in stream.iter_keys_from_desc(0):
+            do_something(key)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamDescKeyIterator(self, self.previous_key_inclusive(start))
+
+    def iter_values_from(self, start: int | float, /) -> SonolusIterator[T]:
+        """Iterate over the values in the stream in ascending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for value in stream.iter_values_from(0):
+            do_something(value)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamAscValueIterator(self, self.next_key_inclusive(start))
+
+    def iter_values_from_desc(self, start: int | float, /) -> SonolusIterator[T]:
+        """Iterate over the values in the stream in descending order starting from the given key.
+
+        If the key is in the stream, it will be included in the iteration.
+
+        Usage:
+        ```python
+        stream = ...
+        for value in stream.iter_values_from_desc(0):
+            do_something(value)
+        ```
+        """
+        _check_can_read_stream()
+        return _StreamDescValueIterator(self, self.previous_key_inclusive(start))
+
+
+class StreamGroup[T, Size](Record):
+    """Represents a group of streams.
+
+    Most users should use `@stream` to declare stream groups rather than using this class directly.
+
+    Usage:
+        Declaring a stream group:
+        ```python
+        @streams
+        class Streams:
+            my_group_1: StreamGroup[Num, 10]  # A group of 10 Num streams
+            my_group_2: StreamGroup[Vec2, 5]  # A group of 5 Vec2 streams
+        ```
+    """
+
+    offset: int
+
+    @classmethod
+    def size(cls) -> Size:
+        """Return the size of the group."""
+        return cls.type_var_value(Size)
+
+    @classmethod
+    def element_type(cls) -> type[T] | type[Value]:
+        """Return the type of elements in this group."""
+        return cls.type_var_value(T)
+
+    @classmethod
+    @meta_fn
+    def backing_size(cls) -> int:
+        """Return the number of underlying single-value streams backing this stream."""
+        return max(1, sizeof(cls.element_type())) * cls.size()
+
+    def __contains__(self, item: int) -> bool:
+        """Check if the group contains the stream with the given index."""
+        _check_can_read_or_write_stream()
+        return 0 <= item < self.size()
+
+    def __getitem__(self, index: int) -> Stream[T]:
+        """Get the stream at the given index."""
+        _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)
+
+
+class _StreamAscIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.next_key(self.current_key) > self.current_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(self.current_key)
+
+
+class _StreamDescIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.previous_key(self.current_key) < self.current_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.previous_key(self.current_key)
+
+
+class _StreamAscKeyIterator[T](Record, SonolusIterator[int | float]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.next_key(self.current_key) > self.current_key
+
+    def get(self) -> int | float:
+        return self.current_key
+
+    def advance(self):
+        self.current_key = self.stream.next_key(self.current_key)
+
+
+class _StreamDescKeyIterator[T](Record, SonolusIterator[int | float]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.previous_key(self.current_key) < self.current_key
+
+    def get(self) -> int | float:
+        return self.current_key
+
+    def advance(self):
+        self.current_key = self.stream.previous_key(self.current_key)
+
+
+class _StreamAscValueIterator[T](Record, SonolusIterator[T]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.next_key(self.current_key) > self.current_key
+
+    def get(self) -> T:
+        return self.stream[self.current_key]
+
+    def advance(self):
+        self.current_key = self.stream.next_key(self.current_key)
+
+
+class _StreamDescValueIterator[T](Record, SonolusIterator[T]):
+    stream: Stream[T]
+    current_key: int | float
+
+    def has_next(self) -> bool:
+        return self.stream.previous_key(self.current_key) < self.current_key
+
+    def get(self) -> T:
+        return self.stream[self.current_key]
+
+    def advance(self):
+        self.current_key = self.stream.previous_key(self.current_key)
+
+
+@native_function(Op.StreamGetNextKey)
+def _stream_get_next_key(stream_id: int, key: int | float) -> int:
+    """Get the next key in the stream, or the key unchanged if it is the last key or the stream is empty."""
+    raise NotImplementedError
+
+
+@native_function(Op.StreamGetPreviousKey)
+def _stream_get_previous_key(stream_id: int, key: int | float) -> int:
+    """Get the previous key in the stream, or the key unchanged if it is the first key or the stream is empty."""
+    raise NotImplementedError
+
+
+@native_function(Op.StreamGetValue)
+def _stream_get_value(stream_id: int, key: int | float) -> float:
+    """Get the value of the key in the stream."""
+    raise NotImplementedError
+
+
+@native_function(Op.StreamHas)
+def _stream_has(stream_id: int, key: int | float) -> bool:
+    """Check if the stream has the key."""
+    raise NotImplementedError
+
+
+@native_function(Op.StreamSet)
+def _stream_set(stream_id: int, key: int | float, value: float) -> None:
+    """Set the value of the key in the stream."""
+    raise NotImplementedError

sonolus/script/transform.py

@@ -10,7 +10,7 @@ class Transform2d(Record):
     """A transformation matrix for 2D points.
 
     Usage:
-        ```
+        ```python
         Transform2d.new()
         ```
     """
@@ -368,7 +368,7 @@ class Transform2d(Record):
         return other.compose(self)
 
     def transform_vec(self, v: Vec2) -> Vec2:
-        """Transform a Vec2 and return a new Vec2.
+        """Transform a [`Vec2`][sonolus.script.vec.Vec2] and return a new [`Vec2`][sonolus.script.vec.Vec2].
 
         Args:
             v: The vector to transform.
@@ -382,7 +382,7 @@ class Transform2d(Record):
         return Vec2(x / w, y / w)
 
     def transform_quad(self, quad: QuadLike) -> Quad:
-        """Transform a Quad and return a new Quad.
+        """Transform a [`Quad`][sonolus.script.quad.Quad] and return a new [`Quad`][sonolus.script.quad.Quad].
 
         Args:
             quad: The quad to transform.

sonolus/script/values.py

@@ -1,6 +1,7 @@
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.generic import validate_concrete_type
 from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.num import Num
 
 
 @meta_fn
@@ -37,3 +38,13 @@ def swap[T](a: T, b: T):
     temp = copy(a)
     a @= b
     b @= temp
+
+
+@meta_fn
+def sizeof(type_: type, /) -> int:
+    """Return the size of the given type."""
+    type_ = validate_concrete_type(type_)
+    if ctx():
+        return Num(type_._size_())
+    else:
+        return type_._size_()

{sonolus_py-0.2.1.dist-info → sonolus_py-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.2.1
+Version: 0.3.1
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.12

{sonolus_py-0.2.1.dist-info → sonolus_py-0.3.1.dist-info}/RECORD

@@ -8,7 +8,7 @@ sonolus/backend/interpret.py,sha256=B0jqlLmEGoyO2mxpcvwRwV17Tq_gOE9wLNt26Q5QOfs,
 sonolus/backend/ir.py,sha256=TCDLMvlX2S8emFDQwFVeD2OUC4fnhbrMObgYtoa_7PQ,2845
 sonolus/backend/mode.py,sha256=NkcPZJm8dn83LX35uP24MtQOCnfRDFZ280dHeEEfauE,613
 sonolus/backend/node.py,sha256=H8qgnNyIseR-DhfgtcbDX03SUmhAJSSrYAlUEJTkkUo,999
-sonolus/backend/ops.py,sha256=ekkHSdgRubIYLSYFk0wTUuBvyf3TKdApM4AyR_koTQ8,10122
+sonolus/backend/ops.py,sha256=7DERBPU6z9Bz3i6UxyLdFTXYcCpvRZVNWw4ZQ-Djwnk,10510
 sonolus/backend/place.py,sha256=jABvLNNE-2pklTcb9WnyfHK8c-tYxn0ObsoLp5LYd5I,4703
 sonolus/backend/utils.py,sha256=9-mmCUwGlNdjp51jKrNBN2dGxCAXVV2PdJn031kaXHM,1717
 sonolus/backend/visitor.py,sha256=GvAEx8D3_YijTMUYBmir0IvDPAEpK1ObAuQOAcAMKm0,48157
@@ -34,10 +34,10 @@ sonolus/build/level.py,sha256=AjvK4725nqDcg7oGn5kWocBdG-AcirXpku74T7c2epA,673
 sonolus/build/node.py,sha256=gnX71RYDUOK_gYMpinQi-bLWO4csqcfiG5gFmhxzSec,1330
 sonolus/build/project.py,sha256=DhNqgHnm73qKUOhrg1JPlWEL0Vg7VxcGUbNokpMWzVE,6315
 sonolus/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonolus/script/archetype.py,sha256=I-K9uT4l6S5w4toDplzG8v01w0KTM4TsZZPgiZgwOrA,40098
-sonolus/script/array.py,sha256=l-KdtHvxF4NpCSZAw4t7MG4N5aZ_gOTGkemDobC6mQY,9791
-sonolus/script/array_like.py,sha256=nCIt_TxV7Ck6ovbSXyViqUkxsO9BksFOjUhpwF0uuxA,8444
-sonolus/script/bucket.py,sha256=oaaB7OXtBWzr8sLzPOpm8-GMhs7FzEhYrI1uVcM0DHM,7453
+sonolus/script/archetype.py,sha256=s9ucFQKIihYkxDlN1eA4SIOWzzIxVrDQSTBeCbllKJ0,40120
+sonolus/script/array.py,sha256=cZcDd_UqTdDFP3fD_r6qdOCtdKSZyVvsDQtcr0hTmMs,11483
+sonolus/script/array_like.py,sha256=gnpjSUZVTxe13ILcSWHAm3tGVMl6tmNUEzJZg8kH_zo,8552
+sonolus/script/bucket.py,sha256=YFSyKS4ZngxerBlKwFBSCRAVewgQdwZ1-NqfPKcPZxI,7519
 sonolus/script/containers.py,sha256=QUFUk1lDwM2AzIPH6uHkZtZXT2D4_xT3P6pJIp6i7Ew,17640
 sonolus/script/debug.py,sha256=aYyFm8DuoifK0L0pY4G7ZZEEeSqbig90Yogy6Z_M8Yg,3135
 sonolus/script/easing.py,sha256=7zaDKIfM_whUpb4FBz1DAF4NNG2vk_nDjl8kL2Y90aU,11396
@@ -49,32 +49,33 @@ sonolus/script/interval.py,sha256=IYNgJx0ngREnEVu_yMAu0MrA_Q7mZuToT8U3fbdb3Sc,91
 sonolus/script/iterator.py,sha256=OHnIOKRchzVCMaN33Tubo6EzqV61ZYUxDWIJ2S5G6iQ,4590
 sonolus/script/level.py,sha256=wR23xk-NOcW_JMRb3R12sqIXCLSZL-7cM3y7IpMF1J0,6333
 sonolus/script/metadata.py,sha256=ttRK27eojHf3So50KQJ-8yj3udZoN1bli5iD-knaeLw,753
-sonolus/script/num.py,sha256=FpMi-w_rdkozZSFxraNQ4IkOzQpTr4YAH3hbqMIFYy8,14612
+sonolus/script/num.py,sha256=Eniv447z8LIAkiZK9Cr_35ZXPnb7Dvy_3c9yq1INoYs,14768
 sonolus/script/options.py,sha256=ZD9I898wMrpPQ8IyuDoYef804rZzhSvPoC_0bxovIec,8245
-sonolus/script/particle.py,sha256=K06ArT9tstRNdbuGIviDmDDWcK3-ieA53LHg0Xvizow,8304
+sonolus/script/particle.py,sha256=oeVQF01xOeW2BEn04ZK1ZOP2HGvQzxBJCpITFjy9woQ,8353
 sonolus/script/pointer.py,sha256=IH2_a0XE76uG_UyYM9jAYIf7qZ5LhUNc9ksXDIvAPZA,1511
 sonolus/script/printing.py,sha256=mNYu9QWiacBBGZrnePZQMVwbbguoelUps9GiOK_aVRU,2096
 sonolus/script/project.py,sha256=jLndgGJHdkqFYe-lDl_IzTjQ4gOSuy80en8WoSWXnB8,3340
-sonolus/script/quad.py,sha256=7uhBwRSvA4tZ_JFjc3Y9n8C9AwQirX5E8MAA0QaHCak,10067
-sonolus/script/record.py,sha256=EV4wywagBl3RU40Bqo9DRdx7Ta8xBgwKtgKlDF02X0o,11332
+sonolus/script/quad.py,sha256=TwmQEsa7_UDSly4uXjN9RRQBVu7Qc_-rpDvhy6cy3KQ,10109
+sonolus/script/record.py,sha256=ouS5f7HVjH60esC0ryVOJL4q7Lt48CHokspgdf2kiH4,11742
 sonolus/script/runtime.py,sha256=MIGqDqNitlI6vFtZ2SP32D6LCLJ3RAuGKSxKKl-1tJw,20303
 sonolus/script/sprite.py,sha256=CMcRAZ2hejXnaBmY2_n1_rj6hGOgPP5zEW-BpyaEVOY,16256
+sonolus/script/stream.py,sha256=5LmQXRmNUiYln67krgocXhiS09dU5BXQuo29CqJk1TE,19989
 sonolus/script/text.py,sha256=wxujIgKYcCfl2AD2_Im8g3vh0lDEHYwTSRZg9wsBPEU,13402
 sonolus/script/timing.py,sha256=ZR0ypV2PIoDCMHHGOMfCeezStCsBQdzomdqaz5VKex0,2981
-sonolus/script/transform.py,sha256=hH6KSRQC8vV-Z10CRCrGewMYqQwUMH3mQIEmniuC2Zw,10760
+sonolus/script/transform.py,sha256=iFY51p6Q0_VlAjlGCDxB14Vj5NlvAB_9VNzDjHeaxDs,10884
 sonolus/script/ui.py,sha256=DYPGWIjHj1IFPxW1zaEuIUQx0b32FJPXtiwCvrtJ6oo,7528
-sonolus/script/values.py,sha256=bwh_9ikxuKyrO_m3_lTKIvZDze4j88Fz-_HT_jB657g,1032
+sonolus/script/values.py,sha256=kyjJ9ODkBi_eJE-t4WYt0wGkbSMNMRkTqpUPZzVVPOU,1289
 sonolus/script/vec.py,sha256=4ntfJ96zxKR-nVZluUgHd-Ud4vNfButfiv7EsroZxfE,7002
 sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtUwu-Ms8,136
 sonolus/script/internal/builtin_impls.py,sha256=w9QqxJQ2YR5pVy820qWmAy0utbsW4hcSzMvA_yNgsvg,8186
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
-sonolus/script/internal/constant.py,sha256=XljC1bXpjmQsekFFDNbaCLoHLPXzDeE17QDHf-rY70Q,3835
+sonolus/script/internal/constant.py,sha256=k4kIBoy-c74UbfUR7GKzyTT6syhE-lSRJfw0nGuc8ZY,3904
 sonolus/script/internal/context.py,sha256=xW7yFWr13yf77Uk4C_F7v9Kp4ZP1o30uZuBkvK1KyLA,14157
 sonolus/script/internal/descriptor.py,sha256=XRFey-EjiAm_--KsNl-8N0Mi_iyQwlPh68gDp0pKf3E,392
 sonolus/script/internal/dict_impl.py,sha256=alu_wKGSk1kZajNf64qbe7t71shEzD4N5xNIATH8Swo,1885
 sonolus/script/internal/error.py,sha256=ZNnsvQVQAnFKzcvsm6-sste2lo-tP5pPI8sD7XlAZWc,490
-sonolus/script/internal/generic.py,sha256=YU1hUJoBcGc0OSrFStK5JI6CikOwSmd_IR20pCuT82k,7310
-sonolus/script/internal/impl.py,sha256=HKQVoHknw5t43Wmj_G1vFjGSmnFpOj1FUYnhbUM3rHc,2969
+sonolus/script/internal/generic.py,sha256=F0-cCiRNGTaUJvYlpmkiOsU3Xge_XjoBpBwBhH_qS_s,7577
+sonolus/script/internal/impl.py,sha256=0uIZ9UtZYqKbsvp2XKo-aVIzkiA8MRbiPIOt0OMmxVo,3018
 sonolus/script/internal/introspection.py,sha256=SL2zaYjid0kkcj6ZbFLIwhgh7WKZBaAHhlbSJGr6PWs,974
 sonolus/script/internal/math_impls.py,sha256=Xk7tLMnV2npzPJWtHlspONQHt09Gh2YLdHhAjx4jkdE,2320
 sonolus/script/internal/native.py,sha256=XKlNnWSJ-lxbwVGWhGj_CSSoWsVN18imqT5sAsDJT1w,1551
@@ -82,9 +83,9 @@ sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z
 sonolus/script/internal/range.py,sha256=lrTanQFHU7RuQxSSPwDdoC30Y8FnHGxcP1Ahditu3zU,2297
 sonolus/script/internal/transient.py,sha256=d6iYhM9f6DPUX5nkYQGm-x0b9XEfZUmB4AtUNnyhixo,1636
 sonolus/script/internal/tuple_impl.py,sha256=vjXmScLVdeTkDn3t9fgIRqtW31iwngnaP2rmA6nlsLw,3431
-sonolus/script/internal/value.py,sha256=St7OqBX-Tad_qBfu6aWMFU4lDXRyFnvzzkb-yFmOzg0,5042
-sonolus_py-0.2.1.dist-info/METADATA,sha256=OZkz271-5AHDS0iRKllUD5f3Wb5FL9s7BQghhIhI6Nw,302
-sonolus_py-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.2.1.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.2.1.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.2.1.dist-info/RECORD,,
+sonolus/script/internal/value.py,sha256=gQVNQD_xGpgrN4-UXFDmWRZCJCe8wPZ_wYv4QoPRJkM,5379
+sonolus_py-0.3.1.dist-info/METADATA,sha256=txzVSPgkG_eIzWqlChZcQ5RTrh6l6Juk_m8-UmFgOG8,302
+sonolus_py-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.3.1.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.3.1.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.3.1.dist-info/RECORD,,