sonolus.py 0.4.0__tar.gz → 0.4.1__tar.gz

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/PKG-INFO

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

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/doc_stubs/builtins.pyi

@@ -183,95 +183,48 @@ def map[T, S](function: Callable[[T], S], iterable: Iterable[T]) -> Iterator[S]:
     ...
 
 @overload
-def max[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the largest item in an iterable or the largest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The largest item.
-    """
-    ...
-
+def max[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T: ...
 @overload
 def max(
     iterable: Iterable[builtins.int | builtins.float],
     *,
     default: builtins.int | builtins.float = ...,
     key: Callable[[builtins.int | builtins.float], Any] | None = ...,
-) -> builtins.int | builtins.float:
-    """Return the largest item in an iterable or the largest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        default: The default value to return if the iterable is empty.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The largest item, or the default value if the iterable is empty.
-    """
-
+) -> builtins.int | builtins.float: ...
 @overload
-def max[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the largest item in an iterable or the largest of two or more arguments.
+def max[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T: ...
+def max(*args, **kwargs):
+    """Return the largest item in an iterable or the largest of multiple arguments.
 
-    Args:
-        arg1: First argument.
-        arg2: Second argument.
-        *args: Additional arguments.
-        key: A function of one argument that is used to extract a comparison key from each element.
+    When called with a single iterable, returns the largest item from that iterable.
+    When called with multiple arguments, returns the largest argument.
 
-    Returns:
-        The largest item.
+    Use the `key` parameter to specify a function that transforms each element
+    before comparison. Use the `default` parameter to specify a value to return
+    if the iterable is empty (supported only for numeric values).
     """
     ...
 
 @overload
-def min[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The smallest item.
-    """
-    ...
-
+def min[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T: ...
 @overload
 def min(
     iterable: Iterable[builtins.int | builtins.float],
     *,
     default: builtins.int | builtins.float = ...,
     key: Callable[[builtins.int | builtins.float], Any] | None = ...,
-) -> builtins.int | builtins.float:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        default: The default value to return if the iterable is empty.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The smallest item, or the default value if the iterable is empty.
-    """
-    ...
-
+) -> builtins.int | builtins.float: ...
 @overload
-def min[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
+def min[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T: ...
+def min(*args, **kwargs):
+    """Return the smallest item in an iterable or the smallest of multiple arguments.
 
-    Args:
-        arg1: First argument.
-        arg2: Second argument.
-        *args: Additional arguments.
-        key: A function of one argument that is used to extract a comparison key from each element.
+    When called with a single iterable, returns the smallest item from that iterable.
+    When called with multiple arguments, returns the smallest argument.
 
-    Returns:
-        The smallest item.
+    Use the `key` parameter to specify a function that transforms each element
+    before comparison. Use the `default` parameter to specify a value to return
+    if the iterable is empty (supported only for numeric values).
     """
     ...
 
@@ -289,28 +242,15 @@ def next[T](iterator: Iterator[T]) -> T:
     ...
 
 @overload
-def range(stop: builtins.int) -> builtins.range:
-    """Return an immutable sequence of numbers from 0 to stop.
-
-    Args:
-        stop: Stop value.
-
-    Returns:
-        The range object.
-    """
-    ...
-
+def range(stop: builtins.int) -> builtins.range: ...
 @overload
-def range(start: builtins.int, stop: builtins.int, step: builtins.int = ...) -> builtins.range:
-    """Return an immutable sequence of numbers from start to stop by step.
+def range(start: builtins.int, stop: builtins.int, step: builtins.int = ...) -> builtins.range: ...
+def range(*args) -> builtins.range:
+    """Return an immutable sequence of numbers.
 
-    Args:
-        start: Start value.
-        stop: Stop value.
-        step: Step value.
-
-    Returns:
-        The range object.
+    When called with one argument, creates a sequence from 0 to that number (exclusive).
+    When called with two arguments, creates a sequence from the first to the second (exclusive).
+    When called with three arguments, the third argument specifies the step size.
     """
     ...
 

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/docs/concepts/constructs.md

@@ -33,12 +33,12 @@ The following constructs are supported in Sonolus.py:
         - Binary: `+`, `-`, `*`, `/`, `//`, `%`, `**`, `&`, `|`, `^`, `<<`, `>>`
         - Comparison: `==`, `!=`, `>`, `<`, `>=`, `<=`, `is`, `is not`, `in`, `not in`
         - Logical: `and`, `or` (for [`Num`](types.md#num) arguments only)
-        - Ternary: `a if <condition> else b` (for [`Num`](types.md#num) conditions only)
+        - Ternary: `a if <condition> else b`
         - Attribute: `a.b`
         - Indexing: `a[b]`
         - Call: `f(a, b, c)`
     - Variables: `a`, `b`, `c`
-    - Lambda: `lambda a, b: a + b`
+    - Lambda: `lambda a, b: a + b` (if not on the same line as another lambda or function definition)
     - Assignment Expression: `(a := b)`
     - Generator Expression: `(x for x in iterable if condition)`
 - Statements:

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/pyproject.toml

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

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/backend/utils.py

@@ -23,29 +23,33 @@ def get_tree_from_file(file: str | Path) -> ast.Module:
 class FindFunction(ast.NodeVisitor):
     def __init__(self, line):
         self.line = line
-        self.node: ast.FunctionDef | None = None
+        self.results: list[ast.FunctionDef | ast.Lambda] = []
 
     def visit_FunctionDef(self, node: ast.FunctionDef):
-        if node.lineno == self.line or (
-            node.decorator_list and (node.decorator_list[-1].end_lineno <= self.line <= node.lineno)
-        ):
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        self.generic_visit(node)
 
     def visit_Lambda(self, node: ast.Lambda):
-        if node.lineno == self.line:
-            if self.node is not None:
-                raise ValueError("Multiple functions defined on the same line are not supported")
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        self.generic_visit(node)
 
 
-def find_function(tree: ast.Module, line: int):
-    visitor = FindFunction(line)
+@cache
+def get_functions(tree: ast.Module) -> list[ast.FunctionDef | ast.Lambda]:
+    visitor = FindFunction(0)
     visitor.visit(tree)
-    return visitor.node
+    return visitor.results
+
+
+def find_function(tree: ast.Module, line: int):
+    for node in get_functions(tree):
+        if node.lineno == line or (
+            isinstance(node, ast.FunctionDef)
+            and node.decorator_list
+            and (node.decorator_list[-1].end_lineno <= line <= node.lineno)
+        ):
+            return node
+    raise ValueError("Function not found")
 
 
 class ScanWrites(ast.NodeVisitor):

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/backend/visitor.py

@@ -261,7 +261,21 @@ class Visitor(ast.NodeVisitor):
                 result = self.visit(body)
                 ctx().scope.set_value("$return", result)
             case ast.GeneratorExp(elt=elt, generators=generators):
-                self.construct_genexpr(generators, elt)
+                first_generator = generators[0]
+                iterable = self.visit(first_generator.iter)
+                if isinstance(iterable, TupleImpl):
+                    initial_iterator = iterable
+                else:
+                    if not hasattr(iterable, "__iter__"):
+                        raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                    initial_iterator = self.handle_call(first_generator.iter, iterable.__iter__)
+                    if not isinstance(initial_iterator, SonolusIterator):
+                        raise ValueError("Unsupported iterator")
+                # The initial iterator is evaluated eagerly in Python
+                before_ctx = ctx().branch_with_scope(None, before_ctx.scope.copy())
+                start_ctx = before_ctx.branch_with_scope(None, Scope())
+                set_ctx(start_ctx)
+                self.construct_genexpr(generators, elt, initial_iterator)
                 ctx().scope.set_value("$return", validate_value(None))
             case _:
                 raise NotImplementedError("Unsupported syntax")
@@ -323,7 +337,9 @@ class Visitor(ast.NodeVisitor):
         set_ctx(after_ctx.branch_with_scope(None, before_ctx.scope.copy()))
         return result_binding.value
 
-    def construct_genexpr(self, generators: Iterable[ast.comprehension], elt: ast.expr):
+    def construct_genexpr(
+        self, generators: Iterable[ast.comprehension], elt: ast.expr, initial_iterator: Value | None = None
+    ):
         if not generators:
             # Note that there may effectively be multiple yields in an expression since
             # tuples are unrolled.
@@ -335,14 +351,22 @@ class Visitor(ast.NodeVisitor):
             set_ctx(resume_ctx)
             return
         generator, *others = generators
-        iterable = self.visit(generator.iter)
+        if initial_iterator is not None:
+            iterable = initial_iterator
+        else:
+            iterable = self.visit(generator.iter)
         if isinstance(iterable, TupleImpl):
             for value in iterable.value:
                 set_ctx(ctx().branch(None))
                 self.handle_assign(generator.target, validate_value(value))
                 self.construct_genexpr(others, elt)
         else:
-            iterator = self.handle_call(generator.iter, iterable.__iter__)
+            if initial_iterator is not None:
+                iterator = initial_iterator
+            else:
+                if not hasattr(iterable, "__iter__"):
+                    raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                iterator = self.handle_call(generator.iter, iterable.__iter__)
             if not isinstance(iterator, SonolusIterator):
                 raise ValueError("Unsupported iterator")
             header_ctx = ctx().branch(None)
@@ -493,6 +517,8 @@ class Visitor(ast.NodeVisitor):
             if break_ctxs:
                 set_ctx(Context.meet([*break_ctxs, ctx()]))
             return
+        if not hasattr(iterable, "__iter__"):
+            raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
         iterator = self.handle_call(node, iterable.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Unsupported iterator")
@@ -980,6 +1006,8 @@ class Visitor(ast.NodeVisitor):
                 self.resume_ctxs.append(resume_ctx)
                 set_ctx(resume_ctx)
             return validate_value(None)
+        if not hasattr(value, "__iter__"):
+            raise TypeError(f"Object of type '{type(value).__name__}' is not iterable")
         iterator = self.handle_call(node, value.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Expected a SonolusIterator")

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/containers.py

@@ -337,7 +337,7 @@ class ArrayPointer[T](Record, ArrayLike[T]):
             raise TypeError("ArrayPointer values cannot be accessed outside of a context")
         return _deref(
             # Allows a compile time constant block so we can warn based on callback read/write access
-            (self._value["block"]._is_py_() and self._value["block"]._as_py_()) or self.block,
+            (self._value_["block"]._is_py_() and self._value_["block"]._as_py_()) or self.block,
             self.offset + Num._accept_(item) * Num._accept_(self.element_type()._size_()),
             self.element_type(),
         )

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/iterator.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Iterator
 from typing import Any
 
+from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn
 from sonolus.script.maybe import Maybe, Nothing, Some
 from sonolus.script.record import Record
@@ -114,3 +116,16 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
             inside = value.get_unsafe()
             if self.fn(inside):
                 return Some(inside)
+
+
+@meta_fn
+def maybe_next[T](iterator: Iterator[T]) -> Maybe[T]:
+    """Get the next item from an iterator as a `Maybe` if it exists or `Nothing` otherwise."""
+    from sonolus.backend.visitor import compile_and_call
+
+    if not isinstance(iterator, SonolusIterator):
+        raise TypeError("Iterator must be an instance of SonolusIterator.")
+    if ctx():
+        return compile_and_call(iterator.next)
+    else:
+        return iterator.next()

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/level.py

@@ -145,7 +145,7 @@ class Level:
         )
 
 
-type EntityListArg = list[PlayArchetype | EntityListArg]
+type EntityListArg = list[list[PlayArchetype] | PlayArchetype] | PlayArchetype
 
 
 def flatten_entities(entities: EntityListArg) -> Iterator[PlayArchetype]:
@@ -175,7 +175,7 @@ class LevelData:
     bgm_offset: float
     entities: list[PlayArchetype]
 
-    def __init__(self, bgm_offset: float, entities: list[PlayArchetype]) -> None:
+    def __init__(self, bgm_offset: float, entities: EntityListArg) -> None:
         self.bgm_offset = bgm_offset
         self.entities = [*flatten_entities(entities)]
 

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/maybe.py

@@ -4,10 +4,11 @@ from collections.abc import Callable
 from typing import Any
 
 from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.transient import TransientValue
 from sonolus.script.internal.value import Value
 from sonolus.script.num import Num
+from sonolus.script.values import copy, zeros
 
 
 class Maybe[T](TransientValue):
@@ -38,13 +39,16 @@ class Maybe[T](TransientValue):
 
     def __init__(self, *, present: bool, value: T):
         self._present = Num._accept_(present)
-        self._value = value
+        self._value = validate_value(value)
 
     @property
     @meta_fn
     def is_some(self) -> bool:
         """Check if the value is present."""
         if ctx():
+            if self._present._is_py_():
+                # Makes this a compile time constant.
+                return self._present
             return self._present._get_readonly_()
         else:
             return self._present._as_py_()
@@ -61,13 +65,104 @@ class Maybe[T](TransientValue):
 
     @meta_fn
     def get_unsafe(self) -> T:
-        return self._value
+        if ctx():
+            return self._value
+        else:
+            return self._value._as_py_()
 
     def map[R](self, fn: Callable[[T], R], /) -> Maybe[R]:
+        """Map the contained value to a new value using the provided function.
+
+        If the value is not present, returns `Nothing`.
+
+        Args:
+            fn: A function that takes the contained value and returns a new value.
+
+        Returns:
+            A `Maybe` instance containing the result of the function if the value is present, otherwise `Nothing`.
+        """
         if self.is_some:
             return Some(fn(self.get_unsafe()))
         return Nothing
 
+    def flat_map[R](self, fn: Callable[[T], Maybe[R]], /) -> Maybe[R]:
+        """Flat map the contained value to a new `Maybe` using the provided function.
+
+        If the value is not present, returns `Nothing`.
+
+        Args:
+            fn: A function that takes the contained value and returns a new `Maybe`.
+
+        Returns:
+            A `Maybe` instance containing the result of the function if the value is present, otherwise `Nothing`.
+        """
+        if self.is_some:
+            return fn(self.get_unsafe())
+        return Nothing
+
+    def or_default(self, default: T) -> T:
+        """Return a copy of the contained value if present, otherwise return a copy of the given default value.
+
+        Args:
+            default: The default value to return if the contained value is not present.
+
+        Returns:
+            A copy of the contained value if present, otherwise a copy of the default value.
+        """
+        result = _box(copy(default))
+        if self.is_some:
+            result.value = self.get_unsafe()
+        return result.value
+
+    @meta_fn
+    def or_else(self, fn: Callable[[], T], /) -> T:
+        """Return a copy of the contained value if present, otherwise return a copy of the result of the given function.
+
+        Args:
+            fn: A function that returns a value to use if the contained value is not present.
+
+        Returns:
+            A copy of the contained value if present, otherwise a copy of the result of calling the function.
+        """
+        from sonolus.backend.visitor import compile_and_call
+
+        if ctx():
+            if self.is_some._is_py_():  # type: ignore
+                if self.is_some._as_py_():  # type: ignore
+                    return copy(self.get_unsafe())
+                else:
+                    return copy(compile_and_call(fn))
+            else:
+                return compile_and_call(self._or_else, fn)
+        elif self.is_some:
+            return copy(self.get_unsafe())
+        else:
+            return copy(fn())
+
+    def _or_else(self, fn: Callable[[], T], /) -> T:
+        result = _box(zeros(self.contained_type))
+        if self.is_some:
+            result.value = self.get_unsafe()
+        else:
+            result.value = fn()
+        return result.value
+
+    @property
+    def tuple(self) -> tuple[bool, T]:
+        """Return whether the value is present and a copy of the contained value if present as a tuple.
+
+        If the value is not present, the tuple will contain `False` and a zero initialized value of the contained type.
+        """
+        result_value = _box(zeros(self.contained_type))
+        if self.is_some:
+            result_value.value = self.get_unsafe()
+        return self.is_some, result_value.value
+
+    @property
+    @meta_fn
+    def contained_type(self):
+        return type(self._value)
+
     @classmethod
     def _accepts_(cls, value: Any) -> bool:
         return isinstance(value, cls)
@@ -137,3 +232,10 @@ Nothing: Maybe[Any] = Maybe(present=False, value=None)  # type: ignore
 # Note: has to come after the definition to hide the definition in the docs.
 Nothing: Maybe[Any]
 """The empty `Maybe` instance."""
+
+
+@meta_fn
+def _box(value):
+    from sonolus.script.containers import Box
+
+    return Box(value)

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/num.py

@@ -453,14 +453,14 @@ if TYPE_CHECKING:
     from typing import Protocol
 
     @runtime_checkable
-    class Num[T](Protocol, int, bool, float):
-        def __add__(self, other: T, /) -> Num | int | bool | float: ...
-        def __sub__(self, other: T, /) -> Num | int | bool | float: ...
-        def __mul__(self, other: T, /) -> Num | int | bool | float: ...
-        def __truediv__(self, other: T, /) -> Num | int | bool | float: ...
-        def __floordiv__(self, other: T, /) -> Num | int | bool | float: ...
-        def __mod__(self, other: T, /) -> Num | int | bool | float: ...
-        def __pow__(self, other: T, /) -> Num | int | bool | float: ...
+    class Num(Protocol, int, bool, float):
+        def __add__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __sub__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __mul__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __truediv__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __floordiv__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __mod__(self, other: Any, /) -> Num | int | bool | float: ...
+        def __pow__(self, other: Any, /) -> Num | int | bool | float: ...
 
         def __neg__(self, /) -> Num | int | bool | float: ...
         def __pos__(self, /) -> Num | int | bool | float: ...
@@ -468,10 +468,10 @@ if TYPE_CHECKING:
 
         def __eq__(self, other: Any, /) -> bool: ...
         def __ne__(self, other: Any, /) -> bool: ...
-        def __lt__(self, other: T, /) -> bool: ...
-        def __le__(self, other: T, /) -> bool: ...
-        def __gt__(self, other: T, /) -> bool: ...
-        def __ge__(self, other: T, /) -> bool: ...
+        def __lt__(self, other: Any, /) -> bool: ...
+        def __le__(self, other: Any, /) -> bool: ...
+        def __gt__(self, other: Any, /) -> bool: ...
+        def __ge__(self, other: Any, /) -> bool: ...
 
         def __hash__(self, /) -> int: ...
 

{sonolus_py-0.4.0 → sonolus_py-0.4.1}/sonolus/script/project.py

@@ -41,7 +41,7 @@ class Project:
         self._levels = None
         self.resources = Path(resources or "resources")
 
-    def with_levels(self, levels: list[Level]) -> Project:
+    def with_levels(self, levels: Iterable[Level] | Callable[[], Iterable[Level]] | None) -> Project:
         """Create a new project with the specified levels.
 
         Args: