sonolus.py 0.1.9__tar.gz → 0.2.0__tar.gz

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

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.1.9
+Version: 0.2.0
 Summary: Sonolus engine development in Python
+License-File: LICENSE
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/doc_stubs/builtins.pyi

@@ -9,6 +9,28 @@ from typing import (
     overload,
 )
 
+def all(iterable: Iterable[builtins.bool]) -> builtins.bool:
+    """Return True if all elements of the iterable are true.
+
+    Args:
+        iterable: The iterable to evaluate.
+
+    Returns:
+        True if all elements are true, False otherwise.
+    """
+    ...
+
+def any(iterable: Iterable[builtins.bool]) -> builtins.bool:
+    """Return True if any element of the iterable is true.
+
+    Args:
+        iterable: The iterable to evaluate.
+
+    Returns:
+        True if any element is true, False otherwise.
+    """
+    ...
+
 def abs(x: builtins.int | builtins.float) -> builtins.int | builtins.float:
     """Return the absolute value of a number.
 

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/docs/concepts/resources.md

@@ -4,11 +4,13 @@
 Skins are defined with the `@skin` decorator:
 
 ```python
-from sonolus.script.sprite import skin, StandardSprite, sprite, Sprite
+from sonolus.script.sprite import skin, StandardSprite, sprite, Sprite, RenderMode
 
 
 @skin
 class Skin:
+    render_mode: RenderMode = RenderMode.DEFAULT
+
     note: StandardSprite.NOTE_HEAD_RED
     other: Sprite = sprite("other")
 ```
@@ -17,6 +19,8 @@ Standard sprites are defined by annotating the field with the corresponding valu
 
 Custom sprites are defined by annotating the field with `Sprite` and calling `skin_sprite` with the sprite name.
 
+To set the render mode for the skin, set the `render_mode` field to the desired value from `RenderMode`.
+
 ## Sound Effects
 Sound effects are defined with the `@effects` decorator:
 

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/docs/concepts/types.md

@@ -242,6 +242,20 @@ assert not isinstance(a, Array[int, 2])
 assert not isinstance(a, Array[Pair, 3])
 ```
 
+### Enums
+
+There is limited support for enums containing `Num` values. Methods on enums are not supported. 
+When used as a type, any enum class is treated as `Num` and no enforcement is done on the values.
+
+```python
+class MyEnum(IntEnum):
+    A = 1
+    B = 2
+    
+a = Array[MyEnum, 2](MyEnum.A, MyEnum.B)
+b = Array[MyEnum, 2](1, 2)
+```
+
 ## Record
 
 `Record` is the base class for user-defined types in Sonolus.py. It functions similarly to dataclasses.

sonolus_py-0.2.0/docs/reference/sonolus.script.metadata.md

@@ -0,0 +1,3 @@
+# sonolus.script.metadata
+
+::: sonolus.script.metadata

sonolus_py-0.2.0/docs/reference/sonolus.script.printing.md

@@ -0,0 +1,3 @@
+# sonolus.script.printing
+
+::: sonolus.script.printing

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/mkdocs.yml

@@ -96,10 +96,11 @@ nav:
       - reference/sonolus.script.interval.md
       - reference/sonolus.script.iterator.md
       - reference/sonolus.script.level.md
+      - reference/sonolus.script.metadata.md
       - reference/sonolus.script.num.md
       - reference/sonolus.script.options.md
       - reference/sonolus.script.particle.md
-      - reference/sonolus.script.print.md
+      - reference/sonolus.script.printing.md
       - reference/sonolus.script.project.md
       - reference/sonolus.script.quad.md
       - reference/sonolus.script.record.md

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

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

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/sonolus/backend/optimize/constant_evaluation.py

@@ -315,8 +315,8 @@ class SparseConditionalConstantPropagation(CompilerPass):
                             return 1
                         return functools.reduce(operator.pow, args)
                     case Op.Log:
-                        assert len(args) == 2
-                        return math.log(args[0], args[1])
+                        assert len(args) == 1
+                        return math.log(args[0])
                     case Op.Ceil:
                         assert len(args) == 1
                         return math.ceil(args[0])

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

@@ -12,13 +12,21 @@ from sonolus.backend.optimize.passes import run_passes
 from sonolus.backend.optimize.simplify import CoalesceFlow, NormalizeSwitch, RewriteToSwitch
 from sonolus.backend.optimize.ssa import FromSSA, ToSSA
 
-MINIMAL_PASSES = [
+MINIMAL_PASSES = (
     CoalesceFlow(),
     UnreachableCodeElimination(),
     AllocateBasic(),
-]
+)
 
-STANDARD_PASSES = [
+FAST_PASSES = (
+    CoalesceFlow(),
+    UnreachableCodeElimination(),
+    AdvancedDeadCodeElimination(),
+    CoalesceFlow(),
+    Allocate(),
+)
+
+STANDARD_PASSES = (
     CoalesceFlow(),
     UnreachableCodeElimination(),
     DeadCodeElimination(),
@@ -37,7 +45,7 @@ STANDARD_PASSES = [
     CoalesceFlow(),
     NormalizeSwitch(),
     Allocate(),
-]
+)
 
 
 def optimize_and_allocate(cfg: BasicBlock):

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/sonolus/backend/optimize/passes.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections import deque
+from collections.abc import Sequence
 
 from sonolus.backend.optimize.flow import BasicBlock
 
@@ -35,7 +36,7 @@ class CompilerPass(ABC):
         pass
 
 
-def run_passes(entry: BasicBlock, passes: list[CompilerPass]) -> BasicBlock:
+def run_passes(entry: BasicBlock, passes: Sequence[CompilerPass]) -> BasicBlock:
     active_passes = set()
     queue = deque(passes)
     while queue:

sonolus_py-0.2.0/sonolus/backend/place.py

@@ -0,0 +1,163 @@
+from collections.abc import Iterator
+from typing import Self
+
+from sonolus.backend.blocks import Block
+
+type Place = BlockPlace | SSAPlace
+type BlockValue = Block | int | TempBlock | Place
+type IndexValue = int | Place
+
+
+class TempBlock:
+    __slots__ = ("__hash", "name", "size")
+
+    def __init__(self, name: str, size: int = 1):
+        self.name = name
+        self.size = size
+        self.__hash = hash(name)  # Precompute hash based on name alone
+
+    def __repr__(self):
+        return f"TempBlock(name={self.name!r}, size={self.size!r})"
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def __getitem__(self, item) -> "BlockPlace":
+        return BlockPlace(self, item)
+
+    def __iter__(self) -> "Iterator[BlockPlace]":
+        for i in range(self.size):
+            yield self[i]
+
+    def __eq__(self, other):
+        return isinstance(other, TempBlock) and self.name == other.name and self.size == other.size
+
+    def __lt__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+
+class BlockPlace:
+    __slots__ = ("__hash", "block", "index", "offset")
+
+    def __init__(self, block: BlockValue, index: IndexValue = 0, offset: int = 0):
+        self.block = block
+        self.index = index
+        self.offset = offset
+        self.__hash = hash((block, index, offset))
+
+    def __repr__(self):
+        return f"BlockPlace(block={self.block!r}, index={self.index!r}, offset={self.offset!r})"
+
+    def __str__(self):
+        if isinstance(self.block, TempBlock) and self.block.size == 1 and self.index == 0 and self.offset == 0:
+            return f"{self.block}"
+        elif isinstance(self.index, int):
+            return f"{self.block}[{self.index + self.offset}]"
+        elif self.offset == 0:
+            return f"{self.block}[{self.index}]"
+        else:
+            return f"{self.block}[{self.index} + {self.offset}]"
+
+    def add_offset(self, offset: int) -> Self:
+        return BlockPlace(self.block, self.index, self.offset + offset)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, BlockPlace)
+            and self.block == other.block
+            and self.index == other.index
+            and self.offset == other.offset
+        )
+
+    def __lt__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __iter__(self):
+        yield self.block
+        yield self.index
+        yield self.offset
+
+
+class SSAPlace:
+    __slots__ = ("__hash", "name", "num")
+
+    def __init__(self, name: str, num: int):
+        self.name = name
+        self.num = num
+        self.__hash = hash((name, num))
+
+    def __repr__(self):
+        return f"SSAPlace(name={self.name!r}, num={self.num!r})"
+
+    def __str__(self):
+        return f"{self.name}.{self.num}"
+
+    def __eq__(self, other):
+        return isinstance(other, SSAPlace) and self.name == other.name and self.num == other.num
+
+    def __lt__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __iter__(self):
+        yield self.name
+        yield self.num

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

@@ -172,7 +172,9 @@ class Visitor(ast.NodeVisitor):
     bound_args: inspect.BoundArguments
     used_names: dict[str, int]
     return_ctxs: list[Context]  # Contexts at return statements, which will branch to the exit
-    loop_head_ctxs: list[Context]  # Contexts at loop heads, from outer to inner
+    loop_head_ctxs: list[
+        Context | list[Context]
+    ]  # Contexts at loop heads, from outer to inner. Contains a list for unrolled (tuple) loops
     break_ctxs: list[list[Context]]  # Contexts at break statements, from outer to inner
     active_ctx: Context | None  # The active context for use in nested functions=
     parent: Self | None  # The parent visitor for use in nested functions
@@ -203,6 +205,8 @@ class Visitor(ast.NodeVisitor):
             case ast.FunctionDef(body=body):
                 ctx().scope.set_value("$return", validate_value(None))
                 for stmt in body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             case ast.Lambda(body=body):
                 result = self.visit(body)
@@ -318,11 +322,21 @@ class Visitor(ast.NodeVisitor):
         iterable = self.visit(node.iter)
         if isinstance(iterable, TupleImpl):
             # Unroll the loop
+            break_ctxs = []
             for value in iterable.value:
                 set_ctx(ctx().branch(None))
+                self.loop_head_ctxs.append([])
+                self.break_ctxs.append([])
                 self.handle_assign(node.target, validate_value(value))
                 for stmt in node.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
+                continue_ctxs = [*self.loop_head_ctxs.pop(), ctx()]
+                break_ctxs.extend(self.break_ctxs.pop())
+                set_ctx(Context.meet(continue_ctxs))
+            if break_ctxs:
+                set_ctx(Context.meet([*break_ctxs, ctx()]))
             return
         iterator = self.handle_call(node, iterable.__iter__)
         if not isinstance(iterator, SonolusIterator):
@@ -338,6 +352,8 @@ class Visitor(ast.NodeVisitor):
             self.loop_head_ctxs.pop()
             self.break_ctxs.pop()
             for stmt in node.orelse:
+                if not ctx().live:
+                    break
                 self.visit(stmt)
             return
         ctx().test = has_next.ir()
@@ -347,6 +363,8 @@ class Visitor(ast.NodeVisitor):
         set_ctx(body_ctx)
         self.handle_assign(node.target, self.handle_call(node, iterator.next))
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
@@ -355,6 +373,8 @@ class Visitor(ast.NodeVisitor):
 
         set_ctx(else_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         else_end_ctx = ctx()
 
@@ -374,6 +394,8 @@ class Visitor(ast.NodeVisitor):
                 body_ctx = ctx().branch(None)
                 set_ctx(body_ctx)
                 for stmt in node.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
                 ctx().branch_to_loop_header(header_ctx)
 
@@ -390,6 +412,8 @@ class Visitor(ast.NodeVisitor):
                 self.loop_head_ctxs.pop()
                 self.break_ctxs.pop()
                 for stmt in node.orelse:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
                 return
         ctx().test = test.ir()
@@ -398,6 +422,8 @@ class Visitor(ast.NodeVisitor):
 
         set_ctx(body_ctx)
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
@@ -406,6 +432,8 @@ class Visitor(ast.NodeVisitor):
 
         set_ctx(else_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         else_end_ctx = ctx()
 
@@ -418,9 +446,13 @@ class Visitor(ast.NodeVisitor):
         if test._is_py_():
             if test._as_py_():
                 for stmt in node.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             else:
                 for stmt in node.orelse:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             return
 
@@ -431,11 +463,15 @@ class Visitor(ast.NodeVisitor):
 
         set_ctx(true_ctx)
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         true_end_ctx = ctx()
 
         set_ctx(false_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         false_end_ctx = ctx()
 
@@ -462,6 +498,8 @@ class Visitor(ast.NodeVisitor):
             if guard._is_py_():
                 if guard._as_py_():
                     for stmt in case.body:
+                        if not ctx().live:
+                            break
                         self.visit(stmt)
                     end_ctxs.append(ctx())
                 else:
@@ -473,6 +511,8 @@ class Visitor(ast.NodeVisitor):
                 guard_false_ctx = ctx().branch(0)
                 set_ctx(guard_true_ctx)
                 for stmt in case.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
                 end_ctxs.append(ctx())
                 false_ctx = Context.meet([false_ctx, guard_false_ctx])
@@ -633,7 +673,11 @@ class Visitor(ast.NodeVisitor):
         set_ctx(ctx().into_dead())
 
     def visit_Continue(self, node):
-        ctx().branch_to_loop_header(self.loop_head_ctxs[-1])
+        loop_head = self.loop_head_ctxs[-1]
+        if isinstance(loop_head, list):
+            loop_head.append(ctx())
+        else:
+            ctx().branch_to_loop_header(loop_head)
         set_ctx(ctx().into_dead())
 
     def visit_BoolOp(self, node) -> Value:
@@ -982,7 +1026,11 @@ class Visitor(ast.NodeVisitor):
             if isinstance(target, ConstantValue):
                 # Unwrap so we can access fields
                 target = target._as_py_()
-            descriptor = type(target).__dict__.get(key)
+            descriptor = None
+            for cls in type.mro(type(target)):
+                descriptor = cls.__dict__.get(key, None)
+                if descriptor is not None:
+                    break
             match descriptor:
                 case property(fget=getter):
                     return self.handle_call(node, getter, target)

{sonolus_py-0.1.9 → sonolus_py-0.2.0}/sonolus/build/cli.py

@@ -10,10 +10,11 @@ import sys
 from pathlib import Path
 from time import perf_counter
 
+from sonolus.backend.optimize.optimize import FAST_PASSES, MINIMAL_PASSES, STANDARD_PASSES
 from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
 from sonolus.build.project import build_project_to_collection, get_project_schema
-from sonolus.script.project import Project
+from sonolus.script.project import BuildConfig, Project
 
 
 def find_default_module() -> str | None:
@@ -63,29 +64,29 @@ def import_project(module_path: str) -> Project | None:
         return project
     except Exception as e:
         print(f"Error: Failed to import project: {e}")
-        return None
+        raise e from None
 
 
-def build_project(project: Project, build_dir: Path):
+def build_project(project: Project, build_dir: Path, config: BuildConfig):
     dist_dir = build_dir / "dist"
     levels_dir = dist_dir / "levels"
     shutil.rmtree(dist_dir, ignore_errors=True)
     dist_dir.mkdir(parents=True, exist_ok=True)
     levels_dir.mkdir(parents=True, exist_ok=True)
 
-    package_engine(project.engine.data).write(dist_dir / "engine")
+    package_engine(project.engine.data, config).write(dist_dir / "engine")
 
     for level in project.levels:
         level_path = levels_dir / level.name
         level_path.write_bytes(package_level_data(level.data))
 
 
-def build_collection(project: Project, build_dir: Path):
+def build_collection(project: Project, build_dir: Path, config: BuildConfig):
     site_dir = build_dir / "site"
     shutil.rmtree(site_dir, ignore_errors=True)
     site_dir.mkdir(parents=True, exist_ok=True)
 
-    collection = build_project_to_collection(project)
+    collection = build_project_to_collection(project, config)
     collection.write(site_dir)
 
 
@@ -125,10 +126,55 @@ def run_server(base_dir: Path, port: int = 8000):
             httpd.shutdown()
 
 
+def get_config(args: argparse.Namespace) -> BuildConfig:
+    if hasattr(args, "optimize_minimal") and args.optimize_minimal:
+        optimization_passes = MINIMAL_PASSES
+    elif hasattr(args, "optimize_fast") and args.optimize_fast:
+        optimization_passes = FAST_PASSES
+    elif hasattr(args, "optimize_standard") and args.optimize_standard:
+        optimization_passes = STANDARD_PASSES
+    else:
+        optimization_passes = FAST_PASSES if args.command == "dev" else STANDARD_PASSES
+
+    if any(hasattr(args, attr) and getattr(args, attr) for attr in ["play", "watch", "preview", "tutorial"]):
+        build_play = hasattr(args, "play") and args.play
+        build_watch = hasattr(args, "watch") and args.watch
+        build_preview = hasattr(args, "preview") and args.preview
+        build_tutorial = hasattr(args, "tutorial") and args.tutorial
+    else:
+        build_play = build_watch = build_preview = build_tutorial = True
+
+    return BuildConfig(
+        passes=optimization_passes,
+        build_play=build_play,
+        build_watch=build_watch,
+        build_preview=build_preview,
+        build_tutorial=build_tutorial,
+    )
+
+
 def main():
     parser = argparse.ArgumentParser(description="Sonolus project build and development tools")
     subparsers = parser.add_subparsers(dest="command", required=True)
 
+    def add_common_arguments(parser):
+        optimization_group = parser.add_mutually_exclusive_group()
+        optimization_group.add_argument(
+            "-o0", "--optimize-minimal", action="store_true", help="Use minimal optimization passes"
+        )
+        optimization_group.add_argument(
+            "-o1", "--optimize-fast", action="store_true", help="Use fast optimization passes"
+        )
+        optimization_group.add_argument(
+            "-o2", "--optimize-standard", action="store_true", help="Use standard optimization passes"
+        )
+
+        build_components = parser.add_argument_group("build components")
+        build_components.add_argument("--play", action="store_true", help="Build play component")
+        build_components.add_argument("--watch", action="store_true", help="Build watch component")
+        build_components.add_argument("--preview", action="store_true", help="Build preview component")
+        build_components.add_argument("--tutorial", action="store_true", help="Build tutorial component")
+
     build_parser = subparsers.add_parser("build")
     build_parser.add_argument(
         "module",
@@ -137,6 +183,7 @@ def main():
         help="Module path (e.g., 'module.name'). If omitted, will auto-detect if only one module exists.",
     )
     build_parser.add_argument("--build-dir", type=str, default="./build")
+    add_common_arguments(build_parser)
 
     dev_parser = subparsers.add_parser("dev")
     dev_parser.add_argument(
@@ -147,6 +194,7 @@ def main():
     )
     dev_parser.add_argument("--build-dir", type=str, default="./build")
     dev_parser.add_argument("--port", type=int, default=8000)
+    add_common_arguments(dev_parser)
 
     schema_parser = subparsers.add_parser("schema")
     schema_parser.add_argument(
@@ -161,7 +209,8 @@ def main():
     if not args.module:
         default_module = find_default_module()
         if default_module:
-            print(f"Using auto-detected module: {default_module}")
+            if args.command != "schema":
+                print(f"Using auto-detected module: {default_module}")
             args.module = default_module
         else:
             parser.error("Module argument is required when multiple or no modules are found")
@@ -173,13 +222,15 @@ def main():
     if args.command == "build":
         build_dir = Path(args.build_dir)
         start_time = perf_counter()
-        build_project(project, build_dir)
+        config = get_config(args)
+        build_project(project, build_dir, config)
         end_time = perf_counter()
         print(f"Project built successfully to '{build_dir.resolve()}' in {end_time - start_time:.2f}s")
     elif args.command == "dev":
         build_dir = Path(args.build_dir)
         start_time = perf_counter()
-        build_collection(project, build_dir)
+        config = get_config(args)
+        build_collection(project, build_dir, config)
         end_time = perf_counter()
         print(f"Build finished in {end_time - start_time:.2f}s")
         run_server(build_dir / "site", port=args.port)