sonolus.py 0.10.6__tar.gz → 0.10.8__tar.gz

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/.gitignore

@@ -16,6 +16,7 @@ test.py
 .hypothesis/
 
 !/sonolus/build/
+!/tests/build/
 
 .env
 

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.10.6
+Version: 0.10.8
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/doc_stubs/builtins.pyi

@@ -277,6 +277,17 @@ def round(number: builtins.int | builtins.float, ndigits: builtins.int = ...) ->
     """
     ...
 
+def type(obj: object) -> builtins.type:
+    """Return the type of an object.
+
+    Args:
+        obj: The object to get the type of.
+
+    Returns:
+        The type of the object.
+    """
+    ...
+
 def zip[T](*iterables: Iterable[T]) -> Iterator[tuple[T, ...]]:
     """Return an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument sequences.
 

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/docs/changelog/index.md

@@ -1,3 +1,14 @@
+### 0.10.8
+
+- Fixed issue when parameterizing the `type` built-in as a generic type
+
+### 0.10.7
+
+- Added support for the `type()` built-in function
+- Added the [`angle_diff()`][sonolus.script.vec.angle_diff] and 
+  [`signed_angle_diff()`][sonolus.script.vec.signed_angle_diff] functions
+- Added the [`sort_linked_entities()`][sonolus.script.containers.sort_linked_entities] function
+
 ### 0.10.6
 
 - Fixed the dev server becoming unresponsive after invalid command arguments
@@ -52,7 +63,7 @@
 
 - Changelog introduced
 - Fixed some errors when iterating over iterators that are statically determined to be empty
-- Added [`Rect.from_margin(...)`][sonolus.script.quad.Rect.from_margin]
+- Added [`Rect.from_margin()`][sonolus.script.quad.Rect.from_margin]
 - Added [`SpriteGroup`][sonolus.script.sprite.SpriteGroup], [`EffectGroup`][sonolus.script.effect.EffectGroup], and
   [`ParticleGroup`][sonolus.script.particle.ParticleGroup] for array-like access to sprites, effects, and particles
 - Added mid-edge properties like [`Quad.mt`][sonolus.script.quad.Quad.mt] and [`Rect.mb`][sonolus.script.quad.Rect.mb]

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.10.6"
+version = "0.10.8"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/sonolus/script/containers.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-from typing import Self
+from collections.abc import Callable
+from typing import Any, Protocol, Self
 
+from sonolus.script.archetype import AnyArchetype, EntityRef
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
@@ -643,3 +645,255 @@ class _ArrayMapEntryIterator[K, V, Capacity](Record, SonolusIterator):
             self._index += 1
             return Some(result)
         return Nothing
+
+
+class _LinkedListNodeRef[TKey, TValue](Protocol):
+    def get_value(self) -> TValue: ...
+
+    def get_next(self) -> Self: ...
+
+    def set_next(self, next_node: Self): ...
+
+    def set_prev(self, prev_node: Self):
+        # No-op for singly linked lists
+        return
+
+    def is_present(self) -> bool: ...
+
+    def set(self, other: Self): ...
+
+    def copy(self) -> Self: ...
+
+    def empty(self) -> Self: ...
+
+
+def _merge_linked_list_nodes[TNode: _LinkedListNodeRef](
+    a: TNode,
+    b: TNode,
+) -> TNode:
+    head = a.empty()
+    tail = a.empty()
+    left = a.copy()
+    right = b.copy()
+
+    while left.is_present() and right.is_present():
+        if left.get_value() <= right.get_value():
+            if not head.is_present():
+                head.set(left)
+                tail.set(left)
+            else:
+                tail.set_next(left)
+                tail.set(left)
+            left.set(left.get_next())
+        else:
+            if not head.is_present():
+                head.set(right)
+                tail.set(right)
+            else:
+                tail.set_next(right)
+                tail.set(right)
+            right.set(right.get_next())
+
+    while left.is_present():
+        if not head.is_present():
+            head.set(left)
+            tail.set(left)
+        else:
+            tail.set_next(left)
+            tail.set(left)
+        left.set(left.get_next())
+
+    while right.is_present():
+        if not head.is_present():
+            head.set(right)
+            tail.set(right)
+        else:
+            tail.set_next(right)
+            tail.set(right)
+        right.set(right.get_next())
+
+    if tail.is_present():
+        tail.set_next(a.empty())
+
+    return head
+
+
+def _merge_sort_linked_list_nodes[TNode: _LinkedListNodeRef](
+    head: TNode,
+) -> TNode:
+    # Calculate length
+    length = 0
+    node = head.copy()
+    while node.is_present():
+        length += 1
+        node.set(node.get_next())
+
+    # Trivial case
+    if length <= 1:
+        return head
+
+    # Bottom-up merge sort: start with sublists of size 1, then 2, 4, 8, etc.
+    size = 1
+    while size < length:
+        current = head.copy()
+        new_head = head.empty()
+        new_tail = head.empty()
+
+        # Process all pairs of sublists of the current size
+        while current.is_present():
+            # Extract the first sublist
+            left = current.copy()
+            prev = current.empty()
+            i = 0
+            while i < size and current.is_present():
+                prev.set(current)
+                current.set(current.get_next())
+                i += 1
+            if prev.is_present():
+                prev.set_next(prev.empty())
+
+            # We've made it to the end without a second sublist to merge, so just attach it to the end
+            if not current.is_present():
+                # Since size < length, we know a full iteration must have happened already, so new_tail is valid
+                new_tail.set_next(left)
+                break
+
+            # Extract the second sublist
+            right = current.copy()
+            prev = current.empty()
+            i = 0
+            while i < size and current.is_present():
+                prev.set(current)
+                current.set(current.get_next())
+                i += 1
+            if prev.is_present():
+                prev.set_next(prev.empty())
+
+            merged = _merge_linked_list_nodes(left, right)
+
+            # Append the merged result
+            if not new_head.is_present():
+                new_head.set(merged)
+                new_tail.set(merged)
+            else:
+                new_tail.set_next(merged)
+
+            # Move tail to the end of the merged section
+            while new_tail.get_next().is_present():
+                new_tail.set(new_tail.get_next())
+
+        # Update head for the next iteration
+        head.set(new_head)
+        size *= 2
+
+    return head
+
+
+class _EntityNodeRef[Archetype, GetValue, GetNextRef, GetPrevRef](Record):
+    index: int
+
+    def get_value(self) -> Any:
+        return self.get_value_fn(self.archetype.at(self.index))
+
+    def get_next(self) -> _EntityNodeRef:
+        next_ref = self.get_next_ref_fn(self.archetype.at(self.index))
+        return self.with_index(next_ref.index)
+
+    def set_next(self, next_node: _EntityNodeRef):
+        entity = self.archetype.at(self.index)
+        next_ref = self.get_next_ref_fn(entity)
+        next_ref.index = next_node.index
+
+    def set_prev(self, prev_node: _EntityNodeRef):
+        if self.get_prev_ref_fn is not None:
+            entity = self.archetype.at(self.index)
+            prev_ref = self.get_prev_ref_fn(entity)
+            prev_ref.index = prev_node.index
+
+    def is_present(self) -> bool:
+        return self.index > 0
+
+    def set(self, other: _EntityNodeRef):
+        self.index = other.index
+
+    def copy(self) -> _EntityNodeRef:
+        return self.with_index(self.index)
+
+    def empty(self) -> _EntityNodeRef:
+        return self.with_index(0)
+
+    def with_index(self, index: int) -> _EntityNodeRef:
+        return _EntityNodeRef[
+            self.archetype,
+            self.get_value_fn,
+            self.get_next_ref_fn,
+            self.get_prev_ref_fn,
+        ](index)
+
+    @property
+    def archetype(self):
+        return self.type_var_value(Archetype)
+
+    @property
+    def get_value_fn(self):
+        return self.type_var_value(GetValue)
+
+    @property
+    def get_next_ref_fn(self):
+        return self.type_var_value(GetNextRef)
+
+    @property
+    def get_prev_ref_fn(self):
+        return self.type_var_value(GetPrevRef)
+
+
+def sort_linked_entities[T: AnyArchetype](
+    head_ref: EntityRef[T],
+    /,
+    *,
+    get_value: Callable[[T], Any],
+    get_next_ref: Callable[[T], EntityRef[T]],
+    get_prev_ref: Callable[[T], EntityRef[T]] | None = None,
+) -> EntityRef[T]:
+    """Sort a linked list of entities using merge sort.
+
+    If get_prev_ref is provided, the backward links will be updated as well.
+
+    Usage:
+        ```python
+        class MyArchetype(PlayArchetype):
+            sort_key: int
+            next: EntityRef[MyArchetype]
+
+        def sort_my_archetype(head: EntityRef[MyArchetype]) -> EntityRef[MyArchetype]:
+            return sort_linked_entities(
+                head,
+                get_value=lambda e: e.sort_key,
+                get_next_ref=lambda e: e.next,
+            )
+        ```
+
+    Args:
+        head_ref: A reference to the head of the linked list.
+        get_value: A function that takes an entity and returns the value to sort by.
+        get_next_ref: A function that takes an entity and returns a reference to the next entity.
+        get_prev_ref: An optional function that takes an entity and returns a reference to the previous entity.
+
+    Returns:
+        A reference to the head of the sorted linked list.
+    """
+    archetype = head_ref.archetype()
+
+    sorted_head_index = _merge_sort_linked_list_nodes(
+        _EntityNodeRef[archetype, get_value, get_next_ref, get_prev_ref](head_ref.index)
+    ).index
+
+    if get_prev_ref is not None:
+        current_ref = _EntityNodeRef[archetype, get_value, get_next_ref, get_prev_ref](sorted_head_index)
+        prev_ref = current_ref.empty()
+        while current_ref.is_present():
+            current_ref.set_prev(prev_ref)
+            prev_ref.set(current_ref)
+            current_ref.set(current_ref.get_next())
+
+    return EntityRef[archetype](sorted_head_index)

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/sonolus/script/internal/builtin_impls.py

@@ -22,6 +22,7 @@ from sonolus.script.iterator import (
     _Zipper,
 )
 from sonolus.script.num import Num, _is_num
+from sonolus.script.record import Record
 
 _empty = object()
 
@@ -388,6 +389,18 @@ def _super(*args):
     return super(*(arg._as_py_() if arg._is_py_() else arg for arg in args))
 
 
+class _Type(Record):
+    @meta_fn
+    def __call__(self, value, /):
+        return type(value)
+
+    def __getitem__(self, item):
+        return self
+
+
+_type = _Type()
+
+
 @meta_fn
 def _assert_never(arg: Never, /):
     error("Expected code to be unreachable")
@@ -416,6 +429,7 @@ BUILTIN_IMPLS = {
     id(range): Range,
     id(reversed): _reversed,
     id(super): _super,
+    id(type): _type,
     id(zip): _zip,
     id(assert_never): _assert_never,
     **MATH_BUILTIN_IMPLS,  # Includes round

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/sonolus/script/vec.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from math import pi
+
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
 from sonolus.script.debug import assert_true
@@ -285,3 +287,22 @@ def pnpoly(vertices: ArrayLike[Vec2] | tuple[Vec2, ...], test: Vec2) -> bool:
         j = i
         i += 1
     return c
+
+
+def angle_diff(a: float, b: float, /) -> float:
+    """Return the smallest absolute difference between two angles in radians.
+
+    The result is in the range [0, π].
+    """
+    return abs((a - b + pi) % (2 * pi) - pi)
+
+
+def signed_angle_diff(a: float, b: float, /) -> float:
+    """Return the signed smallest difference between two angles in radians.
+
+    The result is in the range [-π, π). A positive result means a is counter-clockwise from b.
+    A negative result means a is clockwise from b.
+
+    If the two angles are exactly opposite, the result will be -π, but this should not be relied upon.
+    """
+    return (a - b + pi) % (2 * pi) - pi

sonolus_py-0.10.8/tests/build/test_dev_server.py

@@ -0,0 +1,151 @@
+from hypothesis import given
+from hypothesis import strategies as st
+
+from sonolus.build.dev_server import (
+    DecodeCommand,
+    ExitCommand,
+    HelpCommand,
+    RebuildCommand,
+    parse_dev_command,
+)
+
+
+def test_parse_rebuild_command_full():
+    result = parse_dev_command("rebuild")
+    assert isinstance(result, RebuildCommand)
+
+
+def test_parse_rebuild_command_alias():
+    result = parse_dev_command("r")
+    assert isinstance(result, RebuildCommand)
+
+
+def test_parse_rebuild_command_with_extra_args_invalid():
+    result = parse_dev_command("rebuild extra")
+    assert result is None
+
+
+def test_parse_rebuild_command_with_extra_args_invalid_alias():
+    result = parse_dev_command("r extra")
+    assert result is None
+
+
+def test_parse_decode_command_full():
+    result = parse_dev_command("decode 42")
+    assert isinstance(result, DecodeCommand)
+    assert result.message_code == 42
+
+
+def test_parse_decode_command_alias():
+    result = parse_dev_command("d 123")
+    assert isinstance(result, DecodeCommand)
+    assert result.message_code == 123
+
+
+def test_parse_decode_command_zero():
+    result = parse_dev_command("decode 0")
+    assert isinstance(result, DecodeCommand)
+    assert result.message_code == 0
+
+
+def test_parse_decode_command_negative():
+    result = parse_dev_command("decode -5")
+    assert isinstance(result, DecodeCommand)
+    assert result.message_code == -5
+
+
+def test_parse_decode_command_missing_arg():
+    result = parse_dev_command("decode")
+    assert result is None
+
+
+def test_parse_decode_command_missing_arg_alias():
+    result = parse_dev_command("d")
+    assert result is None
+
+
+def test_parse_decode_command_non_int_arg():
+    result = parse_dev_command("decode abc")
+    assert result is None
+
+
+def test_parse_decode_command_non_int_arg_alias():
+    result = parse_dev_command("d xyz")
+    assert result is None
+
+
+def test_parse_decode_command_extra_args():
+    result = parse_dev_command("decode 42 extra")
+    assert result is None
+
+
+def test_parse_help_command_full():
+    result = parse_dev_command("help")
+    assert isinstance(result, HelpCommand)
+
+
+def test_parse_help_command_alias():
+    result = parse_dev_command("h")
+    assert isinstance(result, HelpCommand)
+
+
+def test_parse_help_command_with_extra_args_invalid():
+    result = parse_dev_command("help extra")
+    assert result is None
+
+
+def test_parse_help_command_with_extra_args_invalid_alias():
+    result = parse_dev_command("h extra")
+    assert result is None
+
+
+def test_parse_quit_command_full():
+    result = parse_dev_command("quit")
+    assert isinstance(result, ExitCommand)
+
+
+def test_parse_quit_command_alias():
+    result = parse_dev_command("q")
+    assert isinstance(result, ExitCommand)
+
+
+def test_parse_quit_command_with_extra_args_invalid():
+    result = parse_dev_command("quit extra")
+    assert result is None
+
+
+def test_parse_quit_command_with_extra_args_invalid_alias():
+    result = parse_dev_command("q extra")
+    assert result is None
+
+
+def test_parse_unknown_command():
+    result = parse_dev_command("unknown")
+    assert result is None
+
+
+def test_parse_empty_command():
+    result = parse_dev_command("")
+    assert result is None
+
+
+def test_parse_whitespace_only():
+    result = parse_dev_command("   ")
+    assert result is None
+
+
+def test_parse_invalid_shell_syntax_unclosed_quote():
+    result = parse_dev_command('decode "unclosed')
+    assert result is None
+
+
+def test_parse_invalid_shell_syntax_unclosed_single_quote():
+    result = parse_dev_command("decode 'unclosed")
+    assert result is None
+
+
+@given(st.text())
+def test_parse_dev_command_arbitrary_strings(command_line):
+    # Should never throw
+    result = parse_dev_command(command_line)
+    assert result is None or hasattr(result, "execute")

sonolus_py-0.10.8/tests/script/test_linked_sort.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from hypothesis import given
+from hypothesis import strategies as st
+
+from sonolus.script.array import Array
+from sonolus.script.containers import _merge_sort_linked_list_nodes  # noqa: PLC2701
+from sonolus.script.record import Record
+from tests.script.conftest import run_and_validate
+
+
+class Node[T](Record):
+    value: T
+    next_index: int
+
+
+class NodeRef[T, Size](Record):
+    arr: Array[Node[T], Size]
+    index: int
+
+    def get_value(self) -> T:
+        return self.arr[self.index].value
+
+    def get_next(self) -> NodeRef:
+        next_index = self.arr[self.index].next_index
+        return NodeRef(self.arr, next_index)
+
+    def set_next(self, next_node: NodeRef) -> None:
+        self.arr[self.index].next_index = next_node.index
+
+    def set_prev(self, prev_node: NodeRef) -> None:
+        pass  # Not needed
+
+    def is_present(self) -> bool:
+        return self.index != -1
+
+    def set(self, other: NodeRef) -> None:
+        self.index = other.index
+
+    def copy(self) -> NodeRef:
+        return NodeRef(self.arr, self.index)
+
+    def empty(self) -> NodeRef:
+        return NodeRef(self.arr, -1)
+
+
+@given(
+    elts=st.lists(st.integers(min_value=-9999, max_value=9999), min_size=0, max_size=100),
+)
+def test_merge_sort_linked_list_nodes(elts: list[int]):
+    orig_values = Array[Node[int], len(elts)](
+        *(Node(value=elt, next_index=i + 1 if i + 1 < len(elts) else -1) for i, elt in enumerate(elts))
+    )
+
+    size = len(elts)
+
+    def fn():
+        values = +orig_values
+        head_ref = NodeRef(values, 0 if size > 0 else -1)
+
+        sorted_head_ref = _merge_sort_linked_list_nodes(head_ref)
+
+        results = +Array[int, size]
+        current_ref = sorted_head_ref.copy()
+        idx = 0
+        while current_ref.is_present():
+            results[idx] = current_ref.get_value()
+            current_ref.set(current_ref.get_next())
+            idx += 1
+        return results
+
+    assert list(run_and_validate(fn)) == sorted(elts)

{sonolus_py-0.10.6 → sonolus_py-0.10.8}/tests/script/test_record.py

@@ -265,3 +265,12 @@ def test_record_augmented_property_setter_with_explicit_implementation():
         return r.value.value
 
     assert run_and_validate(fn) == 3
+
+
+def test_type_of_generic_record():
+    def fn():
+        r = Generic(Pair(1, 2))
+        t = type(r)
+        return t(Pair(3, 4))
+
+    assert run_and_validate(fn) == Generic(Pair(3, 4))