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

sonolus/script/iterator.py

@@ -1,214 +1,167 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import Collection, Iterator
-
-from sonolus.script.num import Num
-from sonolus.script.record import Record
-from sonolus.script.values import copy
-
-
-class SonolusIterator[T](Iterator[T]):
-    @abstractmethod
-    def has_next(self) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def next(self) -> T:
-        raise NotImplementedError
-
-    def __next__(self) -> T:
-        if not self.has_next():
-            raise StopIteration
-        return self.next()
-
-
-class ArrayLike[T](Collection):
-    @abstractmethod
-    def size(self) -> int:
-        pass
-
-    @abstractmethod
-    def __getitem__(self, index: Num) -> T:
-        pass
-
-    @abstractmethod
-    def __setitem__(self, index: Num, value: T):
-        pass
-
-    def __len__(self) -> int:
-        return self.size()
-
-    def __iter__(self) -> SonolusIterator[T]:
-        return ArrayIterator(0, self)
-
-    def __contains__(self, value: T) -> bool:
-        i = 0
-        while i < self.size():
-            if self[i] == value:
-                return True
-            i += 1
-        return False
-
-    def reversed(self) -> ArrayLike[T]:
-        return ArrayReverser(self)
-
-    def iter(self) -> SonolusIterator[T]:
-        return self.__iter__()  # noqa: PLC2801
-
-    def enumerate(self, start: Num = 0) -> SonolusIterator[T]:
-        return ArrayEnumerator(0, start, self)
-
-    def index_of(self, value: T, start: Num = 0) -> Num:
-        i = start
-        while i < self.size():
-            if self[i] == value:
-                return i
-            i += 1
-        return -1
-
-    def last_index_of(self, value: T) -> Num:
-        i = self.size() - 1
-        while i >= 0:
-            if self[i] == value:
-                return i
-            i -= 1
-        return -1
-
-    def index_of_max(self) -> Num:
-        if self.size() == 0:
-            return -1
-        max_index = 0
-        i = 1
-        while i < self.size():
-            if self[i] > self[max_index]:
-                max_index = i
-            i += 1
-        return max_index
-
-    def index_of_min(self) -> Num:
-        if self.size() == 0:
-            return -1
-        min_index = 0
-        i = 1
-        while i < self.size():
-            if self[i] < self[min_index]:
-                min_index = i
-            i += 1
-        return min_index
-
-    def max(self) -> T:
-        return self[self.index_of_max()]
-
-    def min(self) -> T:
-        return self[self.index_of_min()]
-
-    def swap(self, i: Num, j: Num):
-        temp = copy(self[i])
-        self[i] = self[j]
-        self[j] = temp
-
-    def sort(self, *, reverse: bool = False):
-        if self.size() < 15:
-            _insertion_sort(self, 0, self.size(), reverse)
-        else:
-            _heap_sort(self, 0, self.size(), reverse)
-
-
-def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
-    i = start + 1
-    while i < end:
-        value = copy(array[i])
-        j = i - 1
-        while j >= start and (array[j] > value) != reverse:
-            array[j + 1] = array[j]
-            j -= 1
-        array[j + 1] = value
-        i += 1
-
-
-def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
-    while True:
-        left = index * 2 + 1
-        right = left + 1
-        largest = index
-        if left < end and (array[left] > array[largest]) != reverse:
-            largest = left
-        if right < end and (array[right] > array[largest]) != reverse:
-            largest = right
-        if largest == index:
-            break
-        array.swap(index, largest)
-        index = largest
-
-
-# Heap sort is simple to implement iteratively without dynamic memory allocation
-def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
-    i = end // 2 - 1
-    while i >= start:
-        _heapify(array, end, i, reverse)
-        i -= 1
-    i = end - 1
-    while i > start:
-        array.swap(start, i)
-        _heapify(array, i, start, reverse)
-        i -= 1
-
-
-class ArrayIterator[V: ArrayLike](Record, SonolusIterator):
-    i: int
-    array: V
-
-    def has_next(self) -> bool:
-        return self.i < self.array.size()
-
-    def next(self) -> V:
-        value = self.array[self.i]
-        self.i += 1
-        return value
-
-
-class ArrayReverser[V: ArrayLike](Record, ArrayLike):
-    array: V
-
-    def size(self) -> int:
-        return self.array.size()
-
-    def __getitem__(self, index: Num) -> V:
-        return self.array[self.size() - 1 - index]
-
-    def __setitem__(self, index: Num, value: V):
-        self.array[self.size() - 1 - index] = value
-
-    def reversed(self) -> ArrayLike[V]:
-        return self.array
-
-
-class Enumerator[V: SonolusIterator](Record, SonolusIterator):
-    i: int
-    offset: int
-    iterator: V
-
-    def has_next(self) -> bool:
-        return self.iterator.has_next()
-
-    def next(self):
-        value = self.iterator.next()
-        index = self.i + self.offset
-        self.i += 1
-        return index, value
-
-
-class ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
-    i: int
-    offset: int
-    array: V
-
-    def has_next(self) -> bool:
-        return self.i < self.array.size()
-
-    def next(self):
-        value = self.array[self.i]
-        index = self.i + self.offset
-        self.i += 1
-        return index, value
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Iterator
+from typing import Any
+
+from sonolus.script.internal.impl import meta_fn
+from sonolus.script.record import Record
+
+
+class SonolusIterator[T](Iterator[T]):
+    """Base class for Sonolus iterators.
+
+    This class is used to define custom iterators that can be used in Sonolus.py.
+
+    Inheritors must implement the `has_next`, `get`, and `advance` methods.
+    The `__next__` and `__iter__` methods are implemented by default.
+
+    Usage:
+        ```python
+        class MyIterator(Record, SonolusIterator):
+            def has_next(self) -> bool:
+                ...
+
+            def get(self) -> Any:
+                ...
+
+            def advance(self):
+                ...
+        ```
+    """
+
+    def next(self) -> T:
+        result = self.get()
+        self.advance()
+        return result
+
+    @abstractmethod
+    def has_next(self) -> bool:
+        """Return whether the iterator has more elements."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get(self) -> T:
+        """Return the next element of the iterator.
+
+        May be called multiple times before calling `advance`.
+
+        Must not be called if `has_next` returns `False`.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def advance(self):
+        """Advance the iterator to the next element.
+
+        Must not be called if `has_next` returns `False`.
+        """
+        raise NotImplementedError
+
+    def __next__(self) -> T:
+        if not self.has_next():
+            raise StopIteration
+        return self.next()
+
+    def __iter__(self) -> SonolusIterator[T]:
+        return self
+
+
+class _Enumerator[V: SonolusIterator](Record, SonolusIterator):
+    i: int
+    offset: int
+    iterator: V
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def get(self) -> tuple[int, Any]:
+        return self.i + self.offset, self.iterator.get()
+
+    def advance(self):
+        self.i += 1
+        self.iterator.advance()
+
+
+class _Zipper[T](Record, SonolusIterator):
+    # Can be a, Pair[a, b], Pair[a, Pair[b, c]], etc.
+    iterators: T
+
+    @meta_fn
+    def has_next(self) -> bool:
+        from sonolus.backend.visitor import compile_and_call
+
+        return compile_and_call(self._has_next, self._get_iterators())
+
+    def _get_iterators(self) -> tuple[SonolusIterator, ...]:
+        from sonolus.script.containers import Pair
+
+        iterators = []
+        v = self.iterators
+        while isinstance(v, Pair):
+            iterators.append(v.first)
+            v = v.second
+        iterators.append(v)
+        return tuple(iterators)
+
+    def _has_next(self, iterators: tuple[SonolusIterator, ...]) -> bool:
+        for iterator in iterators:  # noqa: SIM110
+            if not iterator.has_next():
+                return False
+        return True
+
+    @meta_fn
+    def get(self) -> tuple[Any, ...]:
+        from sonolus.backend.visitor import compile_and_call
+
+        return tuple(compile_and_call(iterator.get) for iterator in self._get_iterators())
+
+    @meta_fn
+    def advance(self):
+        from sonolus.backend.visitor import compile_and_call
+
+        for iterator in self._get_iterators():
+            compile_and_call(iterator.advance)
+
+
+class _EmptyIterator(Record, SonolusIterator):
+    def has_next(self) -> bool:
+        return False
+
+    def get(self) -> Any:
+        return None
+
+    def advance(self):
+        pass
+
+
+class _MappingIterator[T, Fn](Record, SonolusIterator):
+    fn: Fn
+    iterator: T
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def get(self) -> Any:
+        return self.fn(self.iterator.get())
+
+    def advance(self):
+        self.iterator.advance()
+
+
+class _FilteringIterator[T, Fn](Record, SonolusIterator):
+    fn: Fn
+    iterator: T
+
+    def has_next(self) -> bool:
+        while self.iterator.has_next():
+            if self.fn(self.iterator.get()):
+                return True
+            self.iterator.advance()
+        return False
+
+    def get(self) -> Any:
+        return self.iterator.get()
+
+    def advance(self):
+        self.iterator.advance()

sonolus/script/level.py

@@ -5,6 +5,19 @@ from sonolus.script.archetype import PlayArchetype, StandardArchetypeName, Stand
 
 
 class Level:
+    """A Sonolus level.
+
+    Args:
+        name: The name of the level.
+        title: The title of the level.
+        rating: The rating of the level.
+        artists: The artists of the level.
+        author: The author of the level.
+        cover: The cover of the level.
+        bgm: The background music of the level.
+        data: The data of the level.
+    """
+
     version = 1
 
     def __init__(
@@ -30,6 +43,13 @@ class Level:
 
 
 class LevelData:
+    """The data of a Sonolus level.
+
+    Args:
+        bgm_offset: The background music audio offset.
+        entities: The entities of the level.
+    """
+
     bgm_offset: float
     entities: list[PlayArchetype]
 
@@ -39,6 +59,8 @@ class LevelData:
 
 
 class BpmChange(PlayArchetype):
+    """The standard bpm change archetype."""
+
     name = StandardArchetypeName.BPM_CHANGE
 
     beat: StandardImport.BEAT
@@ -46,6 +68,8 @@ class BpmChange(PlayArchetype):
 
 
 class TimescaleChange(PlayArchetype):
+    """The standard timescale change archetype."""
+
     name = StandardArchetypeName.TIMESCALE_CHANGE
 
     beat: StandardImport.BEAT