sonolus.py 0.1.8__tar.gz → 0.1.9__tar.gz

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

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

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

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

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/backend/finalize.py

@@ -42,6 +42,7 @@ def cfg_to_engine_node(entry: BasicBlock):
                     for cond, target in targets.items():
                         if cond is None:
                             default = block_indexes[target]
+                            continue
                         args.append(ConstantNode(value=cond))
                         args.append(ConstantNode(value=block_indexes[target]))
                     args.append(ConstantNode(value=default))
@@ -55,7 +56,7 @@ def ir_to_engine_node(stmt) -> EngineNode:
     match stmt:
         case int() | float():
             return ConstantNode(value=float(stmt))
-        case IRConst(value=value):
+        case IRConst(value=int(value) | float(value)):
             return ConstantNode(value=value)
         case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
             return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/backend/optimize/copy_coalesce.py

@@ -39,20 +39,29 @@ class CopyCoalesce(CompilerPass):
         interference = self.get_interference(entry)
         copies = self.get_copies(entry)
 
-        mapping = {}
+        mapping: dict[TempBlock, set[TempBlock]] = {}
 
         for target, sources in copies.items():
             for source in sources:
-                if source in mapping:
-                    continue
                 if source in interference.get(target, set()):
                     continue
-                mapping[source] = mapping.get(target, target)
+                combined_mapping = mapping.get(target, {target}) | mapping.get(source, {source})
                 combined_interference = interference.get(target, set()) | interference.get(source, set())
-                interference[source] = combined_interference
-                interference[target] = combined_interference
+                for place in combined_mapping:
+                    mapping[place] = combined_mapping
+                    interference[place] = combined_interference
+                for place in combined_interference:
+                    interference[place].update(combined_mapping)
+
+        canonical_mapping = {}
+        for place, group in mapping.items():
+            if place in canonical_mapping:
+                continue
+            canonical = min(group)
+            for member in group:
+                canonical_mapping[member] = canonical
 
-        return mapping
+        return canonical_mapping
 
     def get_interference(self, entry: BasicBlock) -> dict[TempBlock, set[TempBlock]]:
         result = {}

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/backend/visitor.py

@@ -335,6 +335,8 @@ class Visitor(ast.NodeVisitor):
         has_next = self.ensure_boolean_num(self.handle_call(node, iterator.has_next))
         if has_next._is_py_() and not has_next._as_py_():
             # The loop will never run, continue after evaluating the condition
+            self.loop_head_ctxs.pop()
+            self.break_ctxs.pop()
             for stmt in node.orelse:
                 self.visit(stmt)
             return
@@ -348,13 +350,14 @@ class Visitor(ast.NodeVisitor):
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
+        self.loop_head_ctxs.pop()
+        break_ctxs = self.break_ctxs.pop()
+
         set_ctx(else_ctx)
         for stmt in node.orelse:
             self.visit(stmt)
         else_end_ctx = ctx()
 
-        self.loop_head_ctxs.pop()
-        break_ctxs = self.break_ctxs.pop()
         after_ctx = Context.meet([else_end_ctx, *break_ctxs])
         set_ctx(after_ctx)
 
@@ -365,11 +368,30 @@ class Visitor(ast.NodeVisitor):
         self.break_ctxs.append([])
         set_ctx(header_ctx)
         test = self.ensure_boolean_num(self.visit(node.test))
-        if test._is_py_() and not test._as_py_():
-            # The loop will never run, continue after evaluating the condition
-            for stmt in node.orelse:
-                self.visit(stmt)
-            return
+        if test._is_py_():
+            if test._as_py_():
+                # The loop will run until a break / return
+                body_ctx = ctx().branch(None)
+                set_ctx(body_ctx)
+                for stmt in node.body:
+                    self.visit(stmt)
+                ctx().branch_to_loop_header(header_ctx)
+
+                self.loop_head_ctxs.pop()
+                break_ctxs = self.break_ctxs.pop()
+
+                # Skip the else block
+
+                after_ctx = Context.meet([ctx().into_dead(), *break_ctxs])
+                set_ctx(after_ctx)
+                return
+            else:
+                # The loop will never run, continue after evaluating the condition
+                self.loop_head_ctxs.pop()
+                self.break_ctxs.pop()
+                for stmt in node.orelse:
+                    self.visit(stmt)
+                return
         ctx().test = test.ir()
         body_ctx = ctx().branch(None)
         else_ctx = ctx().branch(0)
@@ -379,13 +401,14 @@ class Visitor(ast.NodeVisitor):
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
+        self.loop_head_ctxs.pop()
+        break_ctxs = self.break_ctxs.pop()
+
         set_ctx(else_ctx)
         for stmt in node.orelse:
             self.visit(stmt)
         else_end_ctx = ctx()
 
-        self.loop_head_ctxs.pop()
-        break_ctxs = self.break_ctxs.pop()
         after_ctx = Context.meet([else_end_ctx, *break_ctxs])
         set_ctx(after_ctx)
 

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/build/compile.py

@@ -36,15 +36,14 @@ def compile_mode(
     if archetypes is not None:
         archetype_entries = []
         for archetype in archetypes:
+            archetype._init_fields()
             archetype_data = {
                 "name": archetype.name,
                 "hasInput": archetype.is_scored,
                 "imports": [{"name": name, "index": index} for name, index in archetype._imported_keys_.items()],
             }
             if mode == Mode.PLAY:
-                archetype_data["exports"] = [
-                    {"name": name, "index": index} for name, index in archetype._exported_keys_.items()
-                ]
+                archetype_data["exports"] = [*archetype._exported_keys_]
             for cb_name, cb_info in archetype._supported_callbacks_.items():
                 cb = getattr(archetype, cb_name)
                 if cb in archetype._default_callbacks_:

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/build/level.py

@@ -11,11 +11,12 @@ def package_level_data(
 def build_level_data(
     level_data: LevelData,
 ):
-    level_refs = {entity: i for i, entity in enumerate(level_data.entities)}
+    level_refs = {entity: f"{i}_{entity.name}" for i, entity in enumerate(level_data.entities)}
     return {
         "bgmOffset": level_data.bgm_offset,
         "entities": [
             {
+                "name": level_refs[entity],
                 "archetype": entity.name,
                 "data": entity._level_data_entries(level_refs),
             }

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/archetype.py

@@ -62,7 +62,9 @@ class _ArchetypeField(SonolusDescriptor):
                         result = _deref(ctx().blocks.EntityData, self.offset, self.type)
                     case _ArchetypeReferenceData(index=index):
                         result = _deref(
-                            ctx().blocks.EntityDataArray, self.offset + index * _ENTITY_DATA_SIZE, self.type
+                            ctx().blocks.EntityDataArray,
+                            Num._accept_(self.offset) + index * _ENTITY_DATA_SIZE,
+                            self.type,
                         )
                     case _ArchetypeLevelData(values=values):
                         result = values[self.name]
@@ -108,7 +110,9 @@ class _ArchetypeField(SonolusDescriptor):
                         target = _deref(ctx().blocks.EntityData, self.offset, self.type)
                     case _ArchetypeReferenceData(index=index):
                         target = _deref(
-                            ctx().blocks.EntityDataArray, self.offset + index * _ENTITY_DATA_SIZE, self.type
+                            ctx().blocks.EntityDataArray,
+                            Num._accept_(self.offset) + index * _ENTITY_DATA_SIZE,
+                            self.type,
                         )
                     case _ArchetypeLevelData(values=values):
                         target = values[self.name]
@@ -119,7 +123,7 @@ class _ArchetypeField(SonolusDescriptor):
                             raise TypeError(f"Expected {self.type}, got {type(value)}")
                         for k, v in value._to_flat_dict_(self.data_name).items():
                             index = instance._exported_keys_[k]
-                            ctx().add_statements(IRInstr(Op.ExportValue, [IRConst(index), Num._accept_(v).ir()]))
+                            ctx().add_statements(IRInstr(Op.ExportValue, [IRConst(index), Num(v).ir()]))
                         return
                     case _ArchetypeReferenceData():
                         raise RuntimeError("Exported fields of other entities are not accessible")
@@ -342,6 +346,7 @@ class _BaseArchetype:
     is_scored: ClassVar[bool] = False
 
     def __init__(self, *args, **kwargs):
+        self._init_fields()
         if ctx():
             raise RuntimeError("The Archetype constructor is only for defining level data")
         bound = self._data_constructor_signature_.bind_partial(*args, **kwargs)
@@ -354,10 +359,12 @@ class _BaseArchetype:
 
     @classmethod
     def _new(cls):
+        cls._init_fields()
         return object.__new__(cls)
 
     @classmethod
     def _for_compilation(cls):
+        cls._init_fields()
         result = cls._new()
         result._data_ = _ArchetypeSelfData()
         return result
@@ -369,6 +376,13 @@ class _BaseArchetype:
         result._data_ = _ArchetypeReferenceData(index=Num._accept_(index))
         return result
 
+    @classmethod
+    @meta_fn
+    def is_at(cls, index: Num) -> bool:
+        if not ctx():
+            raise RuntimeError("is_at is only available during compilation")
+        return entity_info_at(index).archetype_id == cls.id()
+
     @classmethod
     @meta_fn
     def id(cls):
@@ -396,6 +410,7 @@ class _BaseArchetype:
         Args:
             **kwargs: Entity memory values to inject by field name as defined in the Archetype.
         """
+        cls._init_fields()
         if not ctx():
             raise RuntimeError("Spawn is only allowed within a callback")
         archetype_id = cls.id()
@@ -408,16 +423,21 @@ class _BaseArchetype:
 
     @classmethod
     def schema(cls) -> ArchetypeSchema:
+        cls._init_fields()
         return {"name": cls.name or "unnamed", "fields": list(cls._imported_fields_)}
 
-    def _level_data_entries(self, level_refs: dict[Any, int] | None = None):
+    def _level_data_entries(self, level_refs: dict[Any, str] | None = None):
+        self._init_fields()
         if not isinstance(self._data_, _ArchetypeLevelData):
             raise RuntimeError("Entity is not level data")
         entries = []
         for name, value in self._data_.values.items():
             field_info = self._imported_fields_.get(name)
             for k, v in value._to_flat_dict_(field_info.data_name, level_refs).items():
-                entries.append({"name": k, "value": v})
+                if isinstance(v, str):
+                    entries.append({"name": k, "ref": v})
+                else:
+                    entries.append({"name": k, "value": v})
         return entries
 
     def __init_subclass__(cls, **kwargs):
@@ -430,7 +450,22 @@ class _BaseArchetype:
             raise TypeError("Cannot subclass Archetypes")
         if cls.name is None:
             cls.name = cls.__name__
-        field_specifiers = get_field_specifiers(cls, skip={"name", "is_scored"}).items()
+        cls._callbacks_ = []
+        for name in cls._supported_callbacks_:
+            cb = getattr(cls, name)
+            if cb in cls._default_callbacks_:
+                continue
+            cls._callbacks_.append(cb)
+        cls._field_init_done = False
+
+    @classmethod
+    def _init_fields(cls):
+        if cls._field_init_done:
+            return
+        cls._field_init_done = True
+        field_specifiers = get_field_specifiers(
+            cls, skip={"name", "is_scored", "_callbacks_", "_field_init_done"}
+        ).items()
         cls._imported_fields_ = {}
         cls._exported_fields_ = {}
         cls._memory_fields_ = {}
@@ -506,12 +541,6 @@ class _BaseArchetype:
         cls._spawn_signature_ = inspect.Signature(
             [inspect.Parameter(name, inspect.Parameter.POSITIONAL_OR_KEYWORD) for name in cls._memory_fields_]
         )
-        cls._callbacks_ = []
-        for name in cls._supported_callbacks_:
-            cb = getattr(cls, name)
-            if cb in cls._default_callbacks_:
-                continue
-            cls._callbacks_.append(cb)
 
 
 class PlayArchetype(_BaseArchetype):
@@ -796,20 +825,6 @@ class WatchArchetype(_BaseArchetype):
             case _:
                 raise RuntimeError("Result is only accessible from the entity itself")
 
-    @property
-    def target_time(self) -> float:
-        """The target time of this entity.
-
-        Only meaningful for scored entities. Determines when combo and score are updated.
-
-        Alias of `result.target_time`.
-        """
-        return self.result.target_time
-
-    @target_time.setter
-    def target_time(self, value: float):
-        self.result.target_time = value
-
 
 class PreviewArchetype(_BaseArchetype):
     """Base class for preview mode archetypes.
@@ -967,10 +982,16 @@ class EntityRef[A: _BaseArchetype](Record):
     def archetype(cls) -> type[A]:
         return cls.type_var_value(A)
 
+    def with_archetype(self, archetype: type[A]) -> EntityRef[A]:
+        return EntityRef[archetype](index=self.index)
+
     def get(self) -> A:
         return self.archetype().at(self.index)
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def is_valid(self) -> bool:
+        return self.index >= 0 and self.archetype().is_at(self.index)
+
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         ref = getattr(self, "_ref_", None)
         if ref is None:
             return [self.index]
@@ -979,6 +1000,19 @@ class EntityRef[A: _BaseArchetype](Record):
                 raise KeyError("Reference to entity not in level data")
             return [level_refs[ref]]
 
+    @classmethod
+    def _accepts_(cls, value: Any) -> bool:
+        return super()._accepts_(value) or (cls._type_args_ and cls.archetype() is Any and isinstance(value, EntityRef))
+
+    @classmethod
+    def _accept_(cls, value: Any) -> Self:
+        if not cls._accepts_(value):
+            raise TypeError(f"Expected {cls}, got {type(value)}")
+        result = value.with_archetype(cls.archetype())
+        if hasattr(value, "_ref_"):
+            result._ref_ = value._ref_
+        return result
+
 
 class StandardArchetypeName(StrEnum):
     """Standard archetype names."""

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

@@ -111,7 +111,7 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         iterator = iter(values)
         return cls(*(cls.element_type()._from_list_(iterator) for _ in range(cls.size())))
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         match self._value:
             case list():
                 return [entry for value in self._value for entry in value._to_list_(level_refs)]

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/bucket.py

@@ -80,6 +80,24 @@ class JudgmentWindow(Record):
             self.good * other,
         )
 
+    def __add__(self, other: float | int) -> JudgmentWindow:
+        """Add a scalar to the intervals."""
+        return JudgmentWindow(
+            self.perfect + other,
+            self.great + other,
+            self.good + other,
+        )
+
+    @property
+    def start(self) -> float:
+        """The start time of the good interval."""
+        return self.good.start
+
+    @property
+    def end(self) -> float:
+        """The end time of the good interval."""
+        return self.good.end
+
 
 class Judgment(IntEnum):
     """The judgment of a hit."""
@@ -147,10 +165,10 @@ class Bucket(Record):
 class _BucketSprite:
     id: int
     fallback_id: int | None
-    x: int
-    y: int
-    w: int
-    h: int
+    x: float
+    y: float
+    w: float
+    h: float
     rotation: float
 
     def to_dict(self):
@@ -185,10 +203,10 @@ def bucket_sprite(
     *,
     sprite: Sprite,
     fallback_sprite: Sprite | None = None,
-    x: int,
-    y: int,
-    w: int,
-    h: int,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
     rotation: float = 0,
 ) -> _BucketSprite:
     """Define a sprite for a bucket."""

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/internal/constant.py

@@ -97,7 +97,7 @@ class ConstantValue(Value):
     def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
         return cls()
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         return []
 
     @classmethod

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/internal/introspection.py

@@ -12,6 +12,13 @@ def get_field_specifiers(cls, *, skip: set[str] = frozenset(), globals=None, loc
         if class_value is not _missing and key not in skip:
             results[key] = Annotated[value, class_value]
     for key, value in cls.__dict__.items():
-        if key not in results and key not in skip and not key.startswith("__") and not callable(value):
+        if (
+            key not in results
+            and key not in skip
+            and not key.startswith("__")
+            and not callable(value)
+            and not hasattr(value, "__func__")
+            and not isinstance(value, property)
+        ):
             raise ValueError(f"Missing annotation for {cls.__name__}.{key}")
     return results

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/internal/transient.py

@@ -26,7 +26,7 @@ class TransientValue(Value):
     def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
         raise TypeError(f"{cls.__name__} cannot be constructed from list")
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         raise TypeError(f"{type(self).__name__} cannot be deconstructed to list")
 
     @classmethod

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/internal/value.py

@@ -66,7 +66,7 @@ class Value:
         raise NotImplementedError
 
     @abstractmethod
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         """Converts this value to a list of floats."""
         raise NotImplementedError
 
@@ -76,7 +76,9 @@ class Value:
         """Returns the keys to a flat representation of this value."""
         raise NotImplementedError
 
-    def _to_flat_dict_(self, prefix: str, level_refs: dict[Any, int] | None = None) -> dict[str, float | BlockPlace]:
+    def _to_flat_dict_(
+        self, prefix: str, level_refs: dict[Any, str] | None = None
+    ) -> dict[str, float | str | BlockPlace]:
         """Converts this value to a flat dictionary."""
         return dict(zip(self._flat_keys_(prefix), self._to_list_(level_refs), strict=False))
 

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/level.py

@@ -42,6 +42,25 @@ class Level:
         self.data = data
 
 
+type EntityListArg = list[PlayArchetype | EntityListArg]
+
+
+def flatten_entities(entities: EntityListArg):
+    """Flatten a list of entities.
+
+    Args:
+        entities: The list of entities.
+
+    Returns:
+        The flattened list of entities.
+    """
+    if isinstance(entities, list):
+        for entity in entities:
+            yield from flatten_entities(entity)
+    else:
+        yield entities
+
+
 class LevelData:
     """The data of a Sonolus level.
 
@@ -55,7 +74,7 @@ class LevelData:
 
     def __init__(self, bgm_offset: float, entities: list[PlayArchetype]) -> None:
         self.bgm_offset = bgm_offset
-        self.entities = entities
+        self.entities = [*flatten_entities(entities)]
 
 
 class BpmChange(PlayArchetype):

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/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, final, runtime_checkable, TypeGuard
+from typing import TYPE_CHECKING, Any, Self, TypeGuard, final, runtime_checkable
 
 from sonolus.backend.ir import IRConst, IRGet, IRPureInstr, IRSet
 from sonolus.backend.ops import Op
@@ -92,7 +92,7 @@ class _Num(Value, metaclass=_NumMeta):
         value = next(iter(values))
         return Num(value)
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         return [self.data]
 
     @classmethod

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/sonolus/script/record.py

@@ -186,7 +186,7 @@ class Record(GenericValue):
         iterator = iter(values)
         return cls(**{field.name: field.type._from_list_(iterator) for field in cls._fields})
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         result = []
         for field in self._fields:
             result.extend(self._value[field.name]._to_list_(level_refs))

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

@@ -879,3 +879,19 @@ def test_loop_with_aug_assign():
 
     for _ in range(100):
         validate_dual_run(fn)
+
+
+def test_break_in_nested_for_else():
+    def fn():
+        for _ in range(2):
+            for _ in range(2):
+                debug_log(1)
+            else:
+                debug_log(2)
+                break
+            debug_log(3)
+        else:
+            debug_log(4)
+        debug_log(5)
+
+    validate_dual_run(fn)

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/tests/script/test_interval.py

@@ -4,8 +4,8 @@ from hypothesis import strategies as st
 from sonolus.script.interval import Interval, remap, remap_clamped
 from tests.script.conftest import implies, is_close, validate_dual_run
 
-ints = st.integers(min_value=-999999, max_value=999999)
-floats = st.floats(min_value=-999999, max_value=999999, allow_infinity=False, allow_nan=False)
+ints = st.integers(min_value=-99999, max_value=99999)
+floats = st.floats(min_value=-99999, max_value=99999, allow_infinity=False, allow_nan=False)
 divisor_floats = floats.filter(lambda x: abs(x) > 1e-6)
 
 

{sonolus_py-0.1.8 → sonolus_py-0.1.9}/tests/script/test_quad.py

@@ -1,6 +1,5 @@
 # ruff: noqa: E741
 import itertools
-import math
 from datetime import timedelta
 
 from hypothesis import assume, given, settings
@@ -22,7 +21,7 @@ def vecs(draw):
 
 
 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)))
+    return 0.5 * abs(sum(p.x * q.y - p.y * q.x for p, q in zip(points, points[1:] + points[:1], strict=True)))
 
 
 @st.composite
@@ -254,41 +253,26 @@ def test_rect_as_quad(rect):
 
 
 @st.composite
-def points_with_expected_containment(draw):
-    """Generate a point and whether it should be inside a given quad."""
+def quad_and_point(draw):
     quad = draw(quads())
+    min_x = min(quad.bl.x, quad.tl.x, quad.tr.x, quad.br.x)
+    max_x = max(quad.bl.x, quad.tl.x, quad.tr.x, quad.br.x)
+    min_y = min(quad.bl.y, quad.tl.y, quad.tr.y, quad.br.y)
+    max_y = max(quad.bl.y, quad.tl.y, quad.tr.y, quad.br.y)
+    x = draw(st.floats(min_value=min_x, max_value=max_x))
+    y = draw(st.floats(min_value=min_y, max_value=max_y))
+    point = Vec2(x, y)
+    return quad, point
 
-    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())
+
+@given(quad_point=quad_and_point())
 @settings(deadline=timedelta(seconds=2))
-def test_quad_contains_point(quad_point_expected):
-    quad, point, expected = quad_point_expected
+def test_quad_contains_point(quad_point):
+    quad, point = quad_point
 
     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}"
+    # Don't have an easy way to validate the correct solution
+    # But this still checks that the compiled and Python versions are consistent
+    validate_dual_run(fn)