sonolus.py 0.1.6__tar.gz → 0.1.8__tar.gz

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/.github/workflows/publish.yaml

@@ -16,13 +16,13 @@ jobs:
           version: 0.5.2
       - name: Install Python
         run: |
-          uv python install
+          uv python install 3.12 3.13
       - name: Install project
         run: |
           uv sync --all-extras --dev
       - name: Run tests
         run: |
-          uv run pytest tests -n auto
+          uv run tox
       - name: Build
         run: |
           uv build

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.6
+Version: 0.1.8
 Summary: Sonolus engine development in Python
-Requires-Python: >=3.13
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 
 # Sonolus.py

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/pyproject.toml

@@ -1,9 +1,9 @@
 [project]
 name = "sonolus.py"
-version = "0.1.6"
+version = "0.1.8"
 description = "Sonolus engine development in Python"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.12"
 
 [project.scripts]
 sonolus-py = "sonolus.build.cli:main"
@@ -16,6 +16,8 @@ dev-dependencies = [
     "pytest>=8.3.3",
     "ruff>=0.6.9",
     "pytest-cov>=6.0.0",
+    "tox>=4.23.2",
+    "tox-uv>=1.16.0",
 ]
 
 [tool.ruff]
@@ -43,3 +45,16 @@ docs = [
 
 [tool.hatch.build.targets.wheel]
 packages = ["sonolus"]
+
+[tool.tox]
+requires = ["tox>=4.19"]
+env_list = ["py312", "py313"]
+
+[tool.tox.env_run_base]
+description = "Run tests"
+deps = [
+    "hypothesis>=6.115.3",
+    "pytest-xdist>=3.6.1",
+    "pytest>=8.3.3",
+]
+commands = [["pytest", "tests", "-n", "auto"]]

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/sonolus/script/array.py

@@ -60,7 +60,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
                 raise ValueError(f"{cls.__name__} constructor should be used with {cls.size()} values, got {len(args)}")
             parameterized_cls = cls
         if ctx():
-            place = ctx().alloc(size=parameterized_cls.size())
+            place = ctx().alloc(size=parameterized_cls._size_())
             result: parameterized_cls = parameterized_cls._from_place_(place)
             result._copy_from_(parameterized_cls._with_value(values))
             return result

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/sonolus/script/internal/context.py

@@ -182,10 +182,18 @@ class Context:
             return
         assert len(self.outgoing) == 0
         self.outgoing[None] = header
+        values = {}
+        # First do a pass through and copy every value
         for name, target_value in header.loop_variables.items():
             with using_ctx(self):
                 if type(target_value)._is_value_type_():
                     value = self.scope.get_value(name)
+                    values[name] = value._get_()  # _get_() will make a copy on value types
+        # Then actually set them
+        for name, target_value in header.loop_variables.items():
+            with using_ctx(self):
+                if type(target_value)._is_value_type_():
+                    value = values[name]
                     value = type(target_value)._accept_(value)
                     target_value._set_(value)
                 else:

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/sonolus/script/num.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import operator
 from collections.abc import Callable, Iterable
-from typing import TYPE_CHECKING, Any, Self, TypeIs, final, runtime_checkable
+from typing import TYPE_CHECKING, Any, Self, final, runtime_checkable, TypeGuard
 
 from sonolus.backend.ir import IRConst, IRGet, IRPureInstr, IRSet
 from sonolus.backend.ops import Op
@@ -19,7 +19,7 @@ class _NumMeta(type):
         return isinstance(instance, float | int | bool) or _is_num(instance)
 
 
-def _is_num(value: Any) -> TypeIs[Num]:
+def _is_num(value: Any) -> TypeGuard[Num]:
     """Check if a value is a precisely Num instance."""
     return type.__instancecheck__(Num, value)  # type: ignore # noqa: PLC2801
 

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/sonolus/script/quad.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Protocol, Self
 
 from sonolus.script.record import Record
-from sonolus.script.vec import Vec2
+from sonolus.script.vec import Vec2, pnpoly
 
 
 class Quad(Record):
@@ -95,6 +95,17 @@ class Quad(Record):
         """Rotate the quad by the given angle about its center and return a new quad."""
         return self.rotate_about(angle, self.center)
 
+    def contains_point(self, point: Vec2, /) -> bool:
+        """Check if the quad contains the given point.
+
+        Args:
+            point: The point to check.
+
+        Returns:
+            True if the point is inside the quad, False otherwise.
+        """
+        return pnpoly((self.bl, self.tl, self.tr, self.br), point)
+
 
 class Rect(Record):
     """A rectangle defined by its top, right, bottom, and left edges.
@@ -225,6 +236,17 @@ class Rect(Record):
             l=self.l + shrinkage.x,
         )
 
+    def contains_point(self, point: Vec2, /) -> bool:
+        """Check if the rectangle contains the given point.
+
+        Args:
+            point: The point to check.
+
+        Returns:
+            True if the point is inside the rectangle, False otherwise.
+        """
+        return self.l <= point.x <= self.r and self.b <= point.y <= self.t
+
 
 class QuadLike(Protocol):
     """A protocol for types that can be used as quads."""

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/sonolus/script/vec.py

@@ -1,6 +1,8 @@
 from math import atan2, cos, sin
 from typing import Self
 
+from sonolus.script.array import Array
+from sonolus.script.array_like import ArrayLike
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 
@@ -194,3 +196,30 @@ class Vec2(Record):
             A new vector with inverted direction.
         """
         return Vec2(x=-self.x, y=-self.y)
+
+
+def pnpoly(vertices: ArrayLike[Vec2] | tuple[Vec2, ...], test: Vec2) -> bool:
+    """Check if a point is inside a polygon.
+
+    No guaranteed behavior for points on the edges or very close to the edges.
+
+    Args:
+        vertices: The vertices of the polygon.
+        test: The point to test.
+
+    Returns:
+        Whether the point is inside the polygon.
+    """
+    if isinstance(vertices, tuple):
+        vertices = Array(*vertices)
+    i = 0
+    j = len(vertices) - 1
+    c = False
+    while i < len(vertices):
+        if (vertices[i].y > test.y) != (vertices[j].y > test.y) and test.x < (vertices[j].x - vertices[i].x) * (
+            test.y - vertices[i].y
+        ) / (vertices[j].y - vertices[i].y) + vertices[i].x:
+            c = not c
+        j = i
+        i += 1
+    return c

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/tests/script/conftest.py

@@ -16,6 +16,7 @@ from sonolus.script.internal.context import GlobalContextState
 from sonolus.script.internal.error import CompilationError
 from sonolus.script.internal.impl import meta_fn
 from sonolus.script.num import Num
+from sonolus.script.vec import Vec2
 
 settings.register_profile(
     "standard",
@@ -119,5 +120,7 @@ def implies(a: bool, b: bool) -> bool:
     return True
 
 
-def is_close(a: float, b: float, rel_tol: float = 1e-8, abs_tol: float = 1e-8) -> bool:
+def is_close(a: float | Vec2, b: float | Vec2, rel_tol: float = 1e-8, abs_tol: float = 1e-8) -> bool:
+    if isinstance(a, Vec2):
+        return is_close(a.x, b.x, rel_tol, abs_tol) and is_close(a.y, b.y, rel_tol, abs_tol)
     return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

{sonolus_py-0.1.6 → sonolus_py-0.1.8}/tests/script/test_flow.py

@@ -866,3 +866,16 @@ def test_for_empty():
         debug_log(4)
 
     validate_dual_run(fn)
+
+
+def test_loop_with_aug_assign():
+    def fn():
+        a = 0
+        b = 0
+        while a < 5:
+            debug_log(a + b)
+            b = a
+            a += 1
+
+    for _ in range(100):
+        validate_dual_run(fn)

sonolus_py-0.1.8/tests/script/test_quad.py

@@ -0,0 +1,294 @@
+# ruff: noqa: E741
+import itertools
+import math
+from datetime import timedelta
+
+from hypothesis import assume, given, settings
+from hypothesis import strategies as st
+
+from sonolus.script.quad import Quad, Rect
+from sonolus.script.vec import Vec2
+from tests.script.conftest import is_close, validate_dual_run
+
+floats = st.floats(min_value=-9, max_value=9, allow_nan=False, allow_infinity=False)
+nonzero_floats = floats.filter(lambda x: abs(x) > 1e-2)
+
+
+@st.composite
+def vecs(draw):
+    x = draw(floats)
+    y = draw(floats)
+    return Vec2(x, y)
+
+
+def _area(points: list[Vec2]) -> float:
+    return 0.5 * abs(sum(p.x * q.y - p.y * q.x for p, q in zip(points, points[1:] + points[:1], strict=False)))
+
+
+@st.composite
+def quads(draw):
+    points = [draw(vecs()) for _ in range(4)]
+    for p1, p2 in itertools.combinations(points, 2):
+        assume((p1 - p2).magnitude > 1e-2)
+    centroid = sum(points, Vec2(0, 0)) / 4
+    points = sorted(points, key=lambda p: (p - centroid).angle)
+    assume(_area(points) > 1e-2)
+    return Quad(*points)
+
+
+@st.composite
+def rects(draw):
+    l = draw(floats)
+    r = draw(floats)
+    if l > r:
+        l, r = r, l
+
+    b = draw(floats)
+    t = draw(floats)
+    if b > t:
+        b, t = t, b
+
+    return Rect(t=t, r=r, b=b, l=l)
+
+
+@given(
+    quad=quads(),
+    translation=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_translate(quad, translation):
+    def fn():
+        return quad.translate(translation)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl + translation)
+    assert is_close(result.tl, quad.tl + translation)
+    assert is_close(result.tr, quad.tr + translation)
+    assert is_close(result.br, quad.br + translation)
+
+
+@given(
+    quad=quads(),
+    factor=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_scale(quad, factor):
+    def fn():
+        return quad.scale(factor)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl * factor)
+    assert is_close(result.tl, quad.tl * factor)
+    assert is_close(result.tr, quad.tr * factor)
+    assert is_close(result.br, quad.br * factor)
+
+
+@given(
+    quad=quads(),
+    factor=vecs(),
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_scale_about(quad, factor, pivot):
+    def fn():
+        return quad.scale_about(factor, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, (quad.bl - pivot) * factor + pivot)
+    assert is_close(result.tl, (quad.tl - pivot) * factor + pivot)
+    assert is_close(result.tr, (quad.tr - pivot) * factor + pivot)
+    assert is_close(result.br, (quad.br - pivot) * factor + pivot)
+
+
+@given(
+    quad=quads(),
+    angle=floats,
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_rotate(quad, angle):
+    def fn():
+        return quad.rotate(angle)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl.rotate(angle))
+    assert is_close(result.tl, quad.tl.rotate(angle))
+    assert is_close(result.tr, quad.tr.rotate(angle))
+    assert is_close(result.br, quad.br.rotate(angle))
+
+
+@given(
+    quad=quads(),
+    angle=floats,
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_quad_rotate_about(quad, angle, pivot):
+    def fn():
+        return quad.rotate_about(angle, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, quad.bl.rotate_about(angle, pivot))
+    assert is_close(result.tl, quad.tl.rotate_about(angle, pivot))
+    assert is_close(result.tr, quad.tr.rotate_about(angle, pivot))
+    assert is_close(result.br, quad.br.rotate_about(angle, pivot))
+
+
+@given(quad=quads())
+@settings(deadline=timedelta(seconds=2))
+def test_quad_center(quad):
+    def fn():
+        return quad.center
+
+    result = validate_dual_run(fn)
+    expected = (quad.bl + quad.tr + quad.tl + quad.br) / 4
+    assert is_close(result, expected)
+
+
+# Rect Tests
+@given(
+    rect=rects(),
+    translation=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_translate(rect, translation):
+    def fn():
+        return rect.translate(translation)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t + translation.y)
+    assert is_close(result.r, rect.r + translation.x)
+    assert is_close(result.b, rect.b + translation.y)
+    assert is_close(result.l, rect.l + translation.x)
+
+
+@given(
+    rect=rects(),
+    factor=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_scale(rect, factor):
+    def fn():
+        return rect.scale(factor)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t * factor.y)
+    assert is_close(result.r, rect.r * factor.x)
+    assert is_close(result.b, rect.b * factor.y)
+    assert is_close(result.l, rect.l * factor.x)
+
+
+@given(
+    rect=rects(),
+    factor=vecs(),
+    pivot=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_scale_about(rect, factor, pivot):
+    def fn():
+        return rect.scale_about(factor, pivot)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, (rect.t - pivot.y) * factor.y + pivot.y)
+    assert is_close(result.r, (rect.r - pivot.x) * factor.x + pivot.x)
+    assert is_close(result.b, (rect.b - pivot.y) * factor.y + pivot.y)
+    assert is_close(result.l, (rect.l - pivot.x) * factor.x + pivot.x)
+
+
+@given(
+    rect=rects(),
+    expansion=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_expand(rect, expansion):
+    def fn():
+        return rect.expand(expansion)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.t, rect.t + expansion.y)
+    assert is_close(result.r, rect.r + expansion.x)
+    assert is_close(result.b, rect.b - expansion.y)
+    assert is_close(result.l, rect.l - expansion.x)
+
+
+@given(
+    rect=rects(),
+    point=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_contains_point(rect, point):
+    def fn():
+        return rect.contains_point(point)
+
+    result = validate_dual_run(fn)
+    expected = rect.l <= point.x <= rect.r and rect.b <= point.y <= rect.t
+    assert is_close(result, expected)
+
+
+@given(
+    center=vecs(),
+    dimensions=vecs(),
+)
+@settings(deadline=timedelta(seconds=2))
+def test_rect_from_center(center, dimensions):
+    def fn():
+        return Rect.from_center(center, dimensions)
+
+    result = validate_dual_run(fn)
+    assert is_close(result.center.x, center.x)
+    assert is_close(result.center.y, center.y)
+    assert is_close(result.w, dimensions.x)
+    assert is_close(result.h, dimensions.y)
+
+
+@given(rect=rects())
+@settings(deadline=timedelta(seconds=2))
+def test_rect_as_quad(rect):
+    def fn():
+        return rect.as_quad()
+
+    result = validate_dual_run(fn)
+    assert is_close(result.bl, rect.bl)
+    assert is_close(result.tl, rect.tl)
+    assert is_close(result.tr, rect.tr)
+    assert is_close(result.br, rect.br)
+
+
+@st.composite
+def points_with_expected_containment(draw):
+    """Generate a point and whether it should be inside a given quad."""
+    quad = draw(quads())
+
+    is_inside = draw(st.booleans())
+
+    if is_inside:
+        margin = 1.001
+        a = draw(st.floats(min_value=0, max_value=1)) + margin
+        b = draw(st.floats(min_value=0, max_value=1)) + margin
+        c = draw(st.floats(min_value=0, max_value=1)) + margin
+        d = draw(st.floats(min_value=0, max_value=1)) + margin
+        total = a + b + c + d
+        a /= total
+        b /= total
+        c /= total
+        d /= total
+        # Not totally uniform, but good enough for testing
+        point = quad.bl * a + quad.tl * b + quad.tr * c + quad.br * d
+    else:
+        diam = max((quad.tl - quad.br).magnitude, (quad.tr - quad.bl).magnitude)
+        angle = draw(st.floats(min_value=0, max_value=2 * math.pi))
+        scale = draw(st.floats(min_value=1, max_value=2))
+        point = quad.center + Vec2(math.cos(angle), math.sin(angle)) * scale * (diam + 0.001)
+
+    return quad, point, is_inside
+
+
+@given(quad_point_expected=points_with_expected_containment())
+@settings(deadline=timedelta(seconds=2))
+def test_quad_contains_point(quad_point_expected):
+    quad, point, expected = quad_point_expected
+
+    def fn():
+        return quad.contains_point(point)
+
+    result = validate_dual_run(fn)
+    assert result == expected, f"Expected point {point} to be {'inside' if expected else 'outside'} quad {quad}"