sonolus.py 0.1.9__tar.gz → 0.2.1__tar.gz

sonolus_py-0.2.1/.python-version

@@ -0,0 +1 @@
+3.13t

sonolus_py-0.2.1/.run/Python tests in tests.run.xml

@@ -0,0 +1,21 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="Python tests in tests" type="tests" factoryName="Autodetect" nameIsGenerated="true">
+    <module name="sonolus" />
+    <option name="ENV_FILES" value="" />
+    <option name="INTERPRETER_OPTIONS" value="" />
+    <option name="PARENT_ENVS" value="true" />
+    <envs>
+      <env name="PYTHON_JIT" value="1" />
+    </envs>
+    <option name="SDK_HOME" value="" />
+    <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+    <option name="IS_MODULE_SDK" value="true" />
+    <option name="ADD_CONTENT_ROOTS" value="true" />
+    <option name="ADD_SOURCE_ROOTS" value="true" />
+    <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+    <option name="_new_additionalArguments" value="&quot;-n 32 --cov sonolus --cov tests --cov-report xml&quot;" />
+    <option name="_new_target" value="&quot;$PROJECT_DIR$/tests&quot;" />
+    <option name="_new_targetType" value="&quot;PATH&quot;" />
+    <method v="2" />
+  </configuration>
+</component>

sonolus_py-0.2.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: sonolus.py
+Version: 0.2.1
+Summary: Sonolus engine development in Python
+License-File: LICENSE
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Sonolus.py
+Sonolus engine development in Python. See [docs](https://sonolus.py.qwewqa.xyz) for more information.

sonolus_py-0.2.1/README.md

@@ -0,0 +1,2 @@
+# Sonolus.py
+Sonolus engine development in Python. See [docs](https://sonolus.py.qwewqa.xyz) for more information.

{sonolus_py-0.1.9 → sonolus_py-0.2.1}/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.
 
@@ -126,6 +148,9 @@ def len(s: object) -> builtins.int:
 def map[T, S](function: Callable[[T], S], iterable: Iterable[T]) -> Iterator[S]:
     """Apply a function to every item of an iterable and return an iterator.
 
+    Unlike the standard Python map function, it is possible that the function may be called more than once on the
+    same item.
+
     Args:
         function: The function to apply.
         iterable: The iterable to process.

{sonolus_py-0.1.9 → sonolus_py-0.2.1}/docs/concepts/constructs.md

@@ -18,6 +18,8 @@ Most standard Python constructs are supported in Sonolus.py.
 
 ## Overview
 
+The following constructs are supported in Sonolus.py:  
+
 - Expressions:
     - Literals:
         - Numbers (excluding complex numbers): `0`, `1`, `1.0`, `1e3`, `0x1`, `0b1`, `0o1`
@@ -80,18 +82,20 @@ Some expressions can be evaluated at compile time:
 - Comparison: for compile time constant operands: `a == b`, `a != b`, `a > b`, `a < b`, `a >= b`, `a <= b`, ...
 - Variables assigned to compile time constants: `a = 1`, `b = a + 1`, ...
 
-The compiler can make additional inferences when compile time constants are used in certain contexts like control flow:
+Some values like array sizes must be compile-time constants.
+
+The compiler will eliminate branches known to be unreachable at compile time:
 
 ```python
-x = ...
+def f(a):
+    if isinstance(a, Num):
+        debug_log(a)
+    else:
+        debug_log(a.x + a.y)
 
-# This code works because the compiler knows which branch will be taken based on the type of 'x'
-if isinstance(x, Num):
-    debug_log(x)
-elif isinstance(x, Vec2):
-    debug_log(x.x + x.y)
-else:
-    debug_log(-1)
+# This works because `isinstance` is evaluated at compile time and only the first (if) branch is reachable.
+# The second (else) branch is eliminated, so we don't get an error that a does not have 'x' and 'y' attributes.
+f(123)
 ```
 
 ## Variables
@@ -385,7 +389,8 @@ def g(a):
 ```
 
 Function returns follow the same rules as variable access. If a function returns a non-num value, it most only
-return that value. There is no restriction of a function only returns a num.
+return that value. If the function always returns a num, it may have any number of returns. Similarly, if a function
+always returns None (`return None` or just `return`), it may have any number of returns.
 
 The following are allowed:
 
@@ -439,7 +444,7 @@ def k():
         return Vec2(1, 2)
 ```
 
-Most functions returning a non-num value should have a single `return` statement at the end.
+Outside of functions returning `None` or a num, most functions should have a single `return` statement at the end.
 
 ### Classes
 
@@ -475,8 +480,8 @@ Imports are supported at the module level, but not within functions.
 
 ### assert
 
-Assertions are supported. Since error handling is not supported, assertion failures will terminate the current
-callback when running in the Sonolus app.
+Assertions are supported. Assertion failures cannot be handled and will terminate the current
+callback when running in the Sonolus app. In debug mode, the game will also pause to indicate the error.
 
 ```python
 assert a > 0, 'a must be positive'

{sonolus_py-0.1.9 → sonolus_py-0.2.1}/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:
 
@@ -149,6 +153,7 @@ class Options:
 ```
 
 There are three types of options available:
+
 1. `slider_option`: A slider control for numeric values
 2. `toggle_option`: A toggle switch for boolean values
 3. `select_option`: A dropdown menu for selecting from predefined values
@@ -232,8 +237,8 @@ ui_config = UiConfig(
             ease=EaseType.NONE,
         ),
     ),
-    judgment_error_style=UiJudgmentErrorStyle.NONE,
-    judgment_error_placement=UiJudgmentErrorPlacement.BOTH,
+    judgment_error_style=UiJudgmentErrorStyle.LATE,
+    judgment_error_placement=UiJudgmentErrorPlacement.TOP,
     judgment_error_min=0.0,
 )
 ```

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

@@ -124,7 +124,8 @@ Array  # The Generic Array type
 Array[int, 3]  # A concrete Array type
 ```
 
-The element type of an array must be concrete (not generic) and the size must be a non-negative integer:
+The element type of an array must be concrete (not generic) and the size must be a non-negative compile-time 
+constant integer:
 
 ```python
 # Ok
@@ -242,6 +243,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.1.9 → sonolus_py-0.2.1}/docs/index.md

@@ -14,7 +14,7 @@ Sonolus.py is available on PyPI and can be installed using a package manager lik
     ```
 
 ## Getting Started
-...
+Coming soon!
 
 ## Documentation
 See [Concepts](concepts/index.md) for an overview of usage details.

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

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

sonolus_py-0.2.1/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.1}/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.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.9"
+version = "0.2.1"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -9,16 +9,7 @@ requires-python = ">=3.12"
 sonolus-py = "sonolus.build.cli:main"
 
 [tool.uv]
-dev-dependencies = [
-    "hypothesis>=6.115.3",
-    "pre-commit>=4.0.1",
-    "pytest-xdist>=3.6.1",
-    "pytest>=8.3.3",
-    "ruff>=0.6.9",
-    "pytest-cov>=6.0.0",
-    "tox>=4.23.2",
-    "tox-uv>=1.16.0",
-]
+default-groups = ["dev", "docs"]
 
 [tool.ruff]
 line-length = 120
@@ -37,6 +28,16 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
+dev = [
+    "hypothesis>=6.115.3",
+    "pre-commit>=4.0.1",
+    "pytest-xdist>=3.6.1",
+    "pytest>=8.3.3",
+    "ruff>=0.6.9",
+    "pytest-cov>=6.0.0",
+    "tox>=4.23.2",
+    "tox-uv>=1.16.0",
+]
 docs = [
     "mkdocs-material>=9.5.45",
     "mkdocs>=1.6.1",

{sonolus_py-0.1.9 → sonolus_py-0.2.1}/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.1}/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.1}/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.1/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