sonolus.py 0.3.3__tar.gz → 0.3.4__tar.gz

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/PKG-INFO

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

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/doc_stubs/math.pyi

@@ -154,3 +154,36 @@ def log(x: float, base: float = ...) -> float:
         The logarithm of x to the specified base.
     """
     ...
+
+def sqrt(x: float) -> float:
+    """Compute the square root of x.
+
+    Args:
+        x: A non-negative numeric value.
+
+    Returns:
+        The square root of x.
+    """
+    ...
+
+def degrees(x: float) -> float:
+    """Convert radians to degrees.
+
+    Args:
+        x: An angle in radians.
+
+    Returns:
+        The angle in degrees.
+    """
+    ...
+
+def radians(x: float) -> float:
+    """Convert degrees to radians.
+
+    Args:
+        x: An angle in degrees.
+
+    Returns:
+        The angle in radians.
+    """
+    ...

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/docs/concepts/builtins.md

@@ -38,6 +38,9 @@ Sonolus.py also comes with support for some standard library modules.
 - `ceil(x)`
 - `trunc(x)`
 - `log(x[, base])`
+- `sqrt(x)`
+- `degrees(x)`
+- `radians(x)`
 - `pi`
 - `e`
 - `tau`

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/docs/concepts/cli.md

@@ -25,4 +25,4 @@ sonolus-py schema
 ## Programmatic usage
 The same functionality can be accessed programmatically as methods of a project.
 
-See [Project][sonolus.script.project.Project] for more information.
+See [Project](../reference/sonolus.script.project.md) for more information.

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/docs/concepts/constructs.md

@@ -1,6 +1,8 @@
 # Constructs
 
-Most standard Python constructs are supported in Sonolus.py.
+Sonolus.py functions as a compiler from Python to Sonolus nodes. While most standard Python constructs are supported,
+there are some limitations compared to standard Python. The following sections outline what Sonolus.py supports and 
+how it differs from standard Python.
 
 ## Key Differences
 

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/docs/concepts/types.md

@@ -11,8 +11,12 @@ the constants `None`, `Ellipsis`, and `NotImplemented`.
 `Num` is the numeric and boolean type in Sonolus.py. It is interchangeable with `int`, `float`, and `bool`.
 Sonolus.py will treat any of these types as `Num`, but it's recommended to use what's appropriate for clarity.
 
+Typically, `Num` isn't directly used in code since `int`, `float`, and `bool` are more specific and easier to read.
+The main exception is for instance checking (`isinstance` or `match` patterns), where `Num` is the only supported
+way to check for numeric or boolean values.
+
 The Sonolus app uses 32-bit floating-point numbers for all numeric values, so precision may be lower compared to Python
-when running on Sonolus.
+when running within Sonolus.
 
 NaN and values outside the range of 32-bit floating-point numbers are not supported.
 

sonolus_py-0.3.4/docs/index.md

@@ -0,0 +1,27 @@
+# Sonolus.py
+Sonolus.py is a Python library for creating Sonolus engines.
+
+## Installation
+Sonolus.py is available on PyPI and can be installed using a package manager like pip.
+
+=== "pip"
+    ```bash
+    pip install sonolus.py
+    ```
+=== "uv"
+    ```bash
+    uv add sonolus.py
+    ```
+
+## Getting Started
+Example Projects:
+
+- [pydori](https://github.com/qwewqa/pydori): A Bandori-like engine designed to be an example project for Sonolus.py.
+
+New Project Template: [sonolus.py-template-project](https://github.com/qwewqa/sonolus.py-template-project)
+
+## Documentation
+
+- [Overview](overview.md): High-level overview of Sonolus.py.
+- [Concepts](concepts/index.md): Detailed information on concepts and usage.
+- [Reference](reference/index.md): Detailed information on included classes and functions.

sonolus_py-0.3.4/docs/overview.md

@@ -0,0 +1,174 @@
+# Overview
+
+Sonolus.py is a Python library for creating Sonolus engines. This page provides an overview of the key functionality 
+available in the library. For more detailed information, see the [Concepts](concepts/index.md) and 
+[Reference](reference/index.md) sections.
+
+## Features
+Sonolus.py functions by compiling Python code into Sonolus nodes. As such, it supports a subset of Python including
+most syntax and a portion of the standard library. Additionally, Sonolus.py provides its own library of types and
+functions that are specifically designed for use in Sonolus engines.
+
+### Language
+
+#### Syntax
+Most Python syntax is supported, but there are a few limitations:
+
+- Destructuring assignment with the `*` operator is unsupported.
+- Sequence (list and array) `match` patterns with the `*` operator are unsupported.
+- Mapping (dict) `match` patterns are unsupported.
+- Within functions, `import` statements are unsupported.
+- The `global` and `nonlocal` keywords are unsupported.
+- Exception related statements (`try`, `except`, `finally`, `raise`) are unsupported.
+
+#### Compile Time Evaluation
+Sonolus.py will evaluate some expressions at compile time such as basic arithmetic operations on constants,
+boolean logical operations (`and`, `or`, `not`) on constants, and type checks (`isinstance`, `issubclass`).
+
+In control flow constructs like `if` and `match`, Sonolus.py may determine some branches to be unreachable at compile 
+and eliminate them without evaluating them. This allows code like the following to compile successfully:
+
+```python
+a = 1
+if isinstance(a, Vec2):
+    # This branch is eliminated at compile time.
+    # If it were not, compilation would fail because `a` has no attribute `x`.
+    debug_log(a.x)
+else:
+    debug_log(a)
+```
+
+#### Variables
+Numeric (`int`, `float`, `bool`) variables are fully supported and can be freely assigned and modified.
+
+All other variables have the restriction that if the compiler finds multiple possible values for a variable, it may
+not be accessed. For example, the following code will not compile:
+
+```python
+if random() < 0.5:
+    a = Vec2(1, 2)
+else:
+    a = Vec2(3, 4)
+# This will not compile because `a` could have been defined in either branch.
+debug_log(a.x)
+```
+
+#### Function Returns
+Similar to variables, functions returning `int`, `float`, or `bool` can have any number of return statements. Functions
+returning `None` may also have any number of `return` or `return None` statements.
+
+Functions returning any other type must have exactly one `return` statement, and it must be the only exit point of the 
+function. It is ok, however, for a function to have other `return` statements that are eliminated at compile time. 
+For example, the following code will compile successfully:
+
+```python
+def fn(a: int | Vec2):
+    if isinstance(a, Vec2):
+        return a.x + a.y
+    else:
+        return a * 2
+
+fn(123)
+```
+
+### Types
+
+#### Numbers
+Sonolus.py supports `int`, `float`, and `bool` types and most of the standard operations such as mathematical operations
+(`+`, `-`, `*`, `/`, `//`, `%`), comparisons (`<`, `<=`, `>`, `>=`, `==`, `!=`), and boolean operations 
+(`and`, `or`, `not`).
+
+#### Record
+[`Record`](reference/sonolus.script.record.md) is the main way to define custom types in Sonolus.py. It functions similarly to a data class and
+provides a way to define a type with named fields:
+
+```python
+class MyRecord(Record):
+    a: int
+    b: float
+
+my_record = MyRecord(1, b=2.5)
+my_zero_record = +MyRecord  # Short for MyRecord(0, 0.0)
+my_record_copy = +my_record  # Create a copy of my_record with the same values
+my_record.a = 123  # Modify a field of the record
+```
+
+Records may also be generic:
+
+```python
+class MyGenericRecord[T](Record):
+    value: T
+
+my_generic_record = MyGenericRecord[int](42)
+my_generic_record_2 = MyGenericRecord(MyRecord(1, 3.5))  # Type arguments are inferred
+```
+
+#### Array
+[`Array`](reference/sonolus.script.array.md) is a type that represents a fixed-size array of elements of a specific type.
+
+```python
+my_array = Array[int, 3](1, 2, 3)
+my_array_2 = Array(4, 5, 6)  # Type arguments are inferred
+my_zero_array = +Array[int, 3]  # Short for Array[int, 3](0, 0, 0)
+my_array_copy = +my_array  # Create a copy of my_array with the same values
+my_array[2] = 10  # Modify an element of the array
+```
+
+#### Other Types
+Sonolus.py has limited support for other types of values such as strings, tuples, and functions. These have restrictions
+such as not being valid as Record field types or Array element types.
+
+### Modules
+Sonolus.py provides a number of built-in modules that can be used in Sonolus engines. These include:
+
+- Project
+    - [Project](reference/sonolus.script.project.md): Configuration for a Sonolus.py project.
+    - [Engine](reference/sonolus.script.engine.md): Configuration for a Sonolus.py engine.
+    - [Level](reference/sonolus.script.level.md): Configuration for a Sonolus.py level.
+    - [Archetype](reference/sonolus.script.archetype.md): Engine archetypes and their configuration.
+- Core Types
+    - [Array](reference/sonolus.script.array.md): Fixed-size arrays.
+    - [Num](reference/sonolus.script.num.md): Numeric values (int, float, bool).
+    - [Record](reference/sonolus.script.record.md): User-defined types with named fields.
+- Engine Resources
+    - [Bucket](reference/sonolus.script.bucket.md): Judgment buckets.
+    - [Effect](reference/sonolus.script.effect.md): Sound effects.
+    - [Instruction](reference/sonolus.script.instruction.md): Tutorial instructions.
+    - [Options](reference/sonolus.script.options.md): Engine options.
+    - [Particle](reference/sonolus.script.particle.md): Particle effects.
+    - [Sprite](reference/sonolus.script.sprite.md): Sprites and skins.
+    - [UI](reference/sonolus.script.ui.md): Engine ui configuration.
+- Sonolus Runtime
+    - [Globals](reference/sonolus.script.globals.md): Level data and level memory definition.
+    - [Runtime](reference/sonolus.script.runtime.md): Runtime functions like time and ui configuration.
+    - [Stream](reference/sonolus.script.stream.md): Data streams recorded in play mode and used in watch mode.
+    - [Text](reference/sonolus.script.text.md): Standard Sonolus text constants.
+    - [Timing](reference/sonolus.script.timing.md): Beat and timescale related functions.
+- Python Builtins
+    - [builtins](reference/builtins.md): Supported Python builtins.
+    - [math](reference/math.md): Supported math functions.
+    - [random](reference/random.md): Supported random functions.
+- Utilities
+    - [ArrayLike](reference/sonolus.script.array_like.md): Mixin for array functionality.
+    - [Containers](reference/sonolus.script.containers.md): Additional container types like `VarArray` and `ArrayMap`.
+    - [Debug](reference/sonolus.script.debug.md): Debugging utilities.
+    - [Easing](reference/sonolus.script.easing.md): Easing functions for animations.
+    - [Interval](reference/sonolus.script.interval.md): Mathematical intervals.
+    - [Iterator](reference/sonolus.script.iterator.md): Iterators over collections.
+    - [Printing](reference/sonolus.script.printing.md): Preview mode number printing.
+    - [Quad](reference/sonolus.script.quad.md): Quadrilaterals.
+    - [Transform](reference/sonolus.script.transform.md): Transformations like translation, rotation, and scaling.
+    - [Values](reference/sonolus.script.values.md): Generic utilities for working with values.
+    - [Vec](reference/sonolus.script.vec.md): The Vec2 type and related functions.
+
+For more details, see the [Reference](reference/index.md) section.
+
+## Getting Started
+
+Before making a new Sonolus.py engine, it may be helpful to look at some existing projects to see how they use
+the library:
+
+- [pydori](https://github.com/qwewqa/pydori): A Bandori-like engine designed to be an example project for Sonolus.py.
+
+If you're starting a new project, you'll probably want to use the
+[new project template](https://github.com/qwewqa/sonolus.py-template-project).

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/mkdocs.yml

@@ -70,6 +70,7 @@ markdown_extensions:
       alternate_style: true
 nav:
   - index.md
+  - Overview: overview.md
   - Concepts:
       - concepts/index.md
       - concepts/types.md

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/pyproject.toml

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

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/archetype.py

@@ -312,7 +312,7 @@ class StandardImport:
 def callback[T: Callable](*, order: int = 0) -> Callable[[T], T]:
     """Annotate a callback with its order.
 
-    Callbacks are execute from lowest to highest order. By default, callbacks have an order of 0.
+    Callbacks are executed from lowest to highest order. By default, callbacks have an order of 0.
 
     Usage:
         ```python
@@ -338,9 +338,9 @@ class _ArchetypeSelfData:
 
 
 class _ArchetypeReferenceData:
-    index: Num
+    index: int
 
-    def __init__(self, index: Num):
+    def __init__(self, index: int):
         self.index = index
 
 
@@ -416,21 +416,21 @@ class _BaseArchetype:
 
     @classmethod
     @meta_fn
-    def at(cls, index: Num) -> Self:
+    def at(cls, index: int) -> Self:
         result = cls._new()
         result._data_ = _ArchetypeReferenceData(index=Num._accept_(index))
         return result
 
     @classmethod
     @meta_fn
-    def is_at(cls, index: Num) -> bool:
+    def is_at(cls, index: int) -> 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):
+    def id(cls) -> int:
         if not ctx():
             raise RuntimeError("Archetype id is only available during compilation")
         result = ctx().global_state.archetypes.get(cls)
@@ -992,7 +992,7 @@ class PreviewArchetype(_BaseArchetype):
 
 
 @meta_fn
-def entity_info_at(index: Num) -> PlayEntityInfo | WatchEntityInfo | PreviewEntityInfo:
+def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEntityInfo:
     """Retrieve entity info of the entity at the given index.
 
     Available in play, watch, and preview mode.
@@ -1047,24 +1047,24 @@ class PreviewEntityInfo(Record):
 class ArchetypeLife(Record):
     """How an entity contributes to life."""
 
-    perfect_increment: Num
+    perfect_increment: int
     """Life increment for a perfect judgment."""
 
-    great_increment: Num
+    great_increment: int
     """Life increment for a great judgment."""
 
-    good_increment: Num
+    good_increment: int
     """Life increment for a good judgment."""
 
-    miss_increment: Num
+    miss_increment: int
     """Life increment for a miss judgment."""
 
     def update(
         self,
-        perfect_increment: Num | None = None,
-        great_increment: Num | None = None,
-        good_increment: Num | None = None,
-        miss_increment: Num | None = None,
+        perfect_increment: int | None = None,
+        great_increment: int | None = None,
+        good_increment: int | None = None,
+        miss_increment: int | None = None,
     ):
         """Update the life increments."""
         if perfect_increment is not None:

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/array.py

@@ -31,6 +31,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         array_1 = Array(1, 2, 3)
         array_2 = Array[int, 0]()
         array_3 = +Array[int, 3]  # Create a zero-initialized array
+        array_4 = +array_1  # Create a copy of array_1
         ```
     """
 
@@ -186,7 +187,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         return self.size()
 
     @meta_fn
-    def __getitem__(self, index: Num) -> T:
+    def __getitem__(self, index: int) -> T:
         index: Num = Num._accept_(get_positive_index(index, self.size()))
         if index._is_py_() and 0 <= index._as_py_() < self.size():
             const_index = index._as_py_()
@@ -230,7 +231,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
                 raise InternalError("Unexpected array value")
 
     @meta_fn
-    def __setitem__(self, index: Num, value: T):
+    def __setitem__(self, index: int, value: T):
         index: Num = Num._accept_(get_positive_index(index, self.size()))
         value = self.element_type()._accept_(value)
         if ctx():

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/array_like.py

@@ -26,10 +26,10 @@ class ArrayLike[T]:
             def __len__(self) -> int:
                 ...
 
-            def __getitem__(self, index: Num) -> T:
+            def __getitem__(self, index: int) -> T:
                 ...
 
-            def __setitem__(self, index: Num, value: T):
+            def __setitem__(self, index: int, value: T):
                 ...
         ```
     """
@@ -41,7 +41,7 @@ class ArrayLike[T]:
         """Return the length of the array."""
 
     @abstractmethod
-    def __getitem__(self, index: Num) -> T:
+    def __getitem__(self, index: int) -> T:
         """Return the item at the given index.
 
         Args:
@@ -49,7 +49,7 @@ class ArrayLike[T]:
         """
 
     @abstractmethod
-    def __setitem__(self, index: Num, value: T):
+    def __setitem__(self, index: int, value: T):
         """Set the value of the item at the given index.
 
         Args:
@@ -78,10 +78,10 @@ class ArrayLike[T]:
         """Return a reversed view of the array."""
         return _ArrayReverser(self)
 
-    def _enumerate_(self, start: Num = 0) -> SonolusIterator[T]:
+    def _enumerate_(self, start: int = 0) -> SonolusIterator[T]:
         return _ArrayEnumerator(0, start, self)
 
-    def index(self, value: T, start: Num = 0, stop: Num | None = None) -> Num:
+    def index(self, value: T, start: int = 0, stop: int | None = None) -> int:
         """Return the index of the value in the array equal to the given value.
 
         Args:
@@ -98,7 +98,7 @@ class ArrayLike[T]:
             i += 1
         return -1
 
-    def count(self, value: T) -> Num:
+    def count(self, value: T) -> int:
         """Return the number of elements in the array equal to the given value.
 
         Args:
@@ -112,7 +112,7 @@ class ArrayLike[T]:
             i += 1
         return count
 
-    def last_index(self, value: T) -> Num:
+    def last_index(self, value: T) -> int:
         """Return the last index of the value in the array equal to the given value.
 
         Args:
@@ -125,7 +125,7 @@ class ArrayLike[T]:
             i -= 1
         return -1
 
-    def index_of_max(self, *, key: Callable[T, Any] | None = None) -> Num:
+    def index_of_max(self, *, key: Callable[[T], Any] | None = None) -> int:
         """Return the index of the maximum value in the array.
 
         Args:
@@ -143,7 +143,7 @@ class ArrayLike[T]:
             i += 1
         return max_index
 
-    def index_of_min(self, *, key: Callable[T, Any] | None = None) -> Num:
+    def index_of_min(self, *, key: Callable[[T], Any] | None = None) -> int:
         """Return the index of the minimum value in the array.
 
         Args:
@@ -161,17 +161,17 @@ class ArrayLike[T]:
             i += 1
         return min_index
 
-    def _max_(self, key: Callable[T, Any] | None = None) -> T:
+    def _max_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_max(key=key)
         assert index != -1
         return self[index]
 
-    def _min_(self, key: Callable[T, Any] | None = None) -> T:
+    def _min_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_min(key=key)
         assert index != -1
         return self[index]
 
-    def swap(self, i: Num, j: Num, /):
+    def swap(self, i: int, j: int, /):
         """Swap the values at the given indices.
 
         Args:
@@ -182,7 +182,7 @@ class ArrayLike[T]:
         self[i] = self[j]
         self[j] = temp
 
-    def sort(self, *, key: Callable[T, Any] | None = None, reverse: bool = False):
+    def sort(self, *, key: Callable[[T], Any] | None = None, reverse: bool = False):
         """Sort the values in the array in place.
 
         Args:
@@ -216,7 +216,7 @@ def _identity[T](value: T) -> T:
     return value
 
 
-def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, key: Callable[T, Any], reverse: bool):
+def _insertion_sort[T](array: ArrayLike[T], start: int, end: int, key: Callable[[T], Any], reverse: bool):
     i = start + 1
     if reverse:
         while i < end:
@@ -234,7 +234,7 @@ def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, key: Callable[
             i += 1
 
 
-def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
+def _heapify[T](array: ArrayLike[T], end: int, index: int, reverse: bool):
     while True:
         left = index * 2 + 1
         right = left + 1
@@ -249,7 +249,7 @@ def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
         index = largest
 
 
-def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+def _heap_sort[T](array: ArrayLike[T], start: int, end: int, reverse: bool):
     i = end // 2 - 1
     while i >= start:
         _heapify(array, end, i, reverse)
@@ -281,10 +281,10 @@ class _ArrayReverser[V: ArrayLike](Record, ArrayLike):
     def __len__(self) -> int:
         return len(self.array)
 
-    def __getitem__(self, index: Num) -> V:
+    def __getitem__(self, index: int) -> V:
         return self.array[len(self) - 1 - index]
 
-    def __setitem__(self, index: Num, value: V):
+    def __setitem__(self, index: int, value: V):
         self.array[len(self) - 1 - index] = value
 
     def reversed(self) -> ArrayLike[V]:
@@ -307,7 +307,7 @@ class _ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
 
 
 @meta_fn
-def get_positive_index(index: Num, length: Num) -> Num:
+def get_positive_index(index: int, length: int) -> int:
     """Get the positive index for the given index in the array of the given length.
 
     This is used to convert negative indixes relative to the end of the array to positive indices.

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/debug.py

@@ -57,7 +57,7 @@ def static_error(message: str | None = None) -> Never:
 
 
 @meta_fn
-def debug_log(value: Num):
+def debug_log(value: int | float | bool):
     """Log a value in debug mode."""
     if debug_log_callback.get(None):
         return debug_log_callback.get()(value)
@@ -66,7 +66,7 @@ def debug_log(value: Num):
 
 
 @native_function(Op.DebugLog)
-def _debug_log(value: Num):
+def _debug_log(value: int | float | bool):
     print(f"[DEBUG] {value}")
     return 0
 
@@ -77,13 +77,13 @@ def debug_pause():
     input("[DEBUG] Paused")
 
 
-def assert_true(value: Num, message: str | None = None):
+def assert_true(value: int | float | bool, message: str | None = None):
     message = message if message is not None else "Assertion failed"
     if not value:
         error(message)
 
 
-def assert_false(value: Num, message: str | None = None):
+def assert_false(value: int | float | bool, message: str | None = None):
     message = message if message is not None else "Assertion failed"
     if value:
         error(message)

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/engine.py

@@ -217,7 +217,7 @@ class WatchMode:
 
         for archetype in self.archetypes:
             if not issubclass(archetype, WatchArchetype):
-                raise ValueError(f"archetype {archetype} is not a PlayArchetype")
+                raise ValueError(f"archetype {archetype} is not a WatchArchetype")
 
 
 class PreviewMode:
@@ -239,7 +239,7 @@ class PreviewMode:
 
         for archetype in self.archetypes:
             if not issubclass(archetype, PreviewArchetype):
-                raise ValueError(f"archetype {archetype} is not a BaseArchetype")
+                raise ValueError(f"archetype {archetype} is not a PreviewArchetype")
 
 
 class TutorialMode:

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/instruction.py

@@ -97,7 +97,7 @@ def instructions[T](cls: type[T]) -> T | TutorialInstructions:
         annotation_values = annotation.__metadata__
         if annotation_type is not Instruction:
             raise TypeError(
-                f"Invalid annotation for instruction: {annotation}, expected annotation of type InstructionText"
+                f"Invalid annotation for instruction: {annotation}, expected annotation of type Instruction"
             )
         if len(annotation_values) != 1 or not isinstance(annotation_values[0], _InstructionTextInfo):
             raise TypeError(f"Invalid annotation for instruction: {annotation}, expected a single annotation value")

{sonolus_py-0.3.3 → sonolus_py-0.3.4}/sonolus/script/internal/math_impls.py

@@ -97,6 +97,22 @@ def _log(x: float, base: float | None = None) -> float:
         return _ln(x) / _ln(base)
 
 
+def _sqrt(x: float) -> float:
+    return x**0.5
+
+
+@native_function(Op.Degree)
+def _degrees(x: float) -> float:
+    """Convert radians to degrees."""
+    return math.degrees(x)
+
+
+@native_function(Op.Radian)
+def _radians(x: float) -> float:
+    """Convert degrees to radians."""
+    return math.radians(x)
+
+
 @native_function(Op.Rem)
 def _remainder(x: float, y: float) -> float:
     # This is different from math.remainder in Python's math package, which could be confusing
@@ -119,4 +135,5 @@ MATH_BUILTIN_IMPLS = {
     id(math.trunc): _trunc,
     id(round): _round,
     id(math.log): _log,
+    id(math.sqrt): _sqrt,
 }