sonolus.py 0.3.3__tar.gz → 0.4.0__tar.gz

sonolus_py-0.4.0/.gitattributes

@@ -0,0 +1 @@
+tests/regressions/data/* linguist-generated=true

{sonolus_py-0.3.3 → sonolus_py-0.4.0}/.github/workflows/publish.yaml

@@ -13,7 +13,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v3
         with:
-          version: 0.7.16
+          version: 0.8.3
       - name: Install Python
         run: |
           uv python install 3.12 3.13 3.14

sonolus_py-0.4.0/.python-version

@@ -0,0 +1 @@
+3.14.0rc1

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

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

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

@@ -31,6 +31,20 @@ def any(iterable: Iterable[builtins.bool]) -> builtins.bool:
     """
     ...
 
+def sum(
+    iterable: Iterable[builtins.int | builtins.float], /, start: builtins.int | builtins.float = 0
+) -> builtins.int | builtins.float:
+    """Return the sum of a 'start' value (default: 0) and an iterable of numbers.
+
+    Args:
+        iterable: The iterable of numbers to sum.
+        start: The starting value to add to the sum.
+
+    Returns:
+        The total sum.
+    """
+    ...
+
 def abs(x: builtins.int | builtins.float) -> builtins.int | builtins.float:
     """Return the absolute value of a number.
 
@@ -134,6 +148,17 @@ def issubclass(cls: type, classinfo: type | tuple[type, ...]) -> builtins.bool:
     """
     ...
 
+def iter[T](iterable: Iterable[T]) -> Iterator[T]:
+    """Return an iterator for the given iterable.
+
+    Args:
+        iterable: The iterable to convert to an iterator.
+
+    Returns:
+        An iterator over the elements of the iterable.
+    """
+    ...
+
 def len(s: object) -> builtins.int:
     """Return the number of items in a container.
 
@@ -148,9 +173,6 @@ 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.
@@ -173,6 +195,24 @@ 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.
+    """
+
 @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.
@@ -201,6 +241,25 @@ 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.
+    """
+    ...
+
 @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.
@@ -216,6 +275,19 @@ def min[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) ->
     """
     ...
 
+def next[T](iterator: Iterator[T]) -> T:
+    """Retrieve the next item from an iterator.
+
+    Errors if the iterator is exhausted.
+
+    Args:
+        iterator: The iterator to retrieve the next item from.
+
+    Returns:
+        The next item from the iterator.
+    """
+    ...
+
 @overload
 def range(stop: builtins.int) -> builtins.range:
     """Return an immutable sequence of numbers from 0 to stop.

{sonolus_py-0.3.3 → sonolus_py-0.4.0}/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.4.0}/docs/concepts/builtins.md

@@ -1,5 +1,6 @@
 # Builtins
 Sonolus.py comes with support for a number of built-in functions.
+The supported functions and parameters are listed below.
 
 - `abs(x)`
 - `bool(object)`
@@ -10,11 +11,13 @@ Sonolus.py comes with support for a number of built-in functions.
 - `int(x)` (for a num argument)
 - `isinstance(object, classinfo)`
 - `issubclass(class, classinfo)`
+- `iter(iterable)`
 - `len(s)`
-- `map(function, iterable)` (note: may differ from standard Python behavior, see 
-  [`map`](../reference/builtins.md#doc_stubs.builtins.map))
-- `max(iterable, *, key=None)`, `max(arg1, arg2, *args, key=None)`
-- `min(iterable, *, key=None)`, `min(arg1, arg2, *args, key=None)`
+- `map(function, iterable)`
+- `max(iterable, *, default=..., key=None)`, `max(arg1, arg2, *args, key=None)`
+- `min(iterable, *, default=..., key=None)`, `min(arg1, arg2, *args, key=None)`
+- `next(iterator)`
+- `sum(iterable, start=0)`
 - `range(stop)`, `range(start, stop[, step])`
 - `reversed(seq)`
 - `round(number[, ndigits])`
@@ -38,6 +41,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.4.0}/docs/concepts/cli.md

@@ -15,6 +15,13 @@ To build the project, run the following command in the root directory of your pr
 sonolus-py build
 ```
 
+## Checking for errors without building
+To check for errors, run the following command in the root directory of your project:
+
+```bash
+sonolus-py check
+```
+
 ## Outputting the level schema
 To output the level schema of the project, run the following command in the root directory of your project:
 
@@ -25,4 +32,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.4.0}/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
 
@@ -38,6 +40,7 @@ The following constructs are supported in Sonolus.py:
     - Variables: `a`, `b`, `c`
     - Lambda: `lambda a, b: a + b`
     - Assignment Expression: `(a := b)`
+    - Generator Expression: `(x for x in iterable if condition)`
 - Statements:
     - Simple Statements:
         - Assignments:
@@ -53,6 +56,7 @@ The following constructs are supported in Sonolus.py:
         - Break: `break`
         - Continue: `continue`
         - Return: `return <value>`
+        - Yield: `yield <value>`, `yield from <iterable>`
         - Import: `import <module>`, `from <module> import <name>` (only outside of functions)
     - Compound Statements:
         - If: `if <condition>:`, `elif <condition>:`, `else:`

{sonolus_py-0.3.3 → sonolus_py-0.4.0}/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.
 
@@ -114,6 +118,16 @@ a2 = Array[int, 0]()
 a3 = +Array[int, 3]  # Create a zero-initialized array
 ```
 
+For type checker compatibility, `Literal` or [`Dim`][sonolus.script.array.Dim] can also be used to specify the size of
+the array:
+
+```python
+from sonolus.script.array import Dim
+
+a1 = Array[int, Dim(3)](1, 2, 3)
+a2 = Array[int, Literal[3]](1, 2, 3)
+```
+
 If at least one element is provided, the element type and size can be inferred:
 
 ```python
@@ -609,18 +623,14 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
     fn: Fn
     iterator: T
 
-    def has_next(self) -> bool:
-        while self.iterator.has_next():
-            if self.fn(self.iterator.get()):
-                return True
-            self.iterator.advance()
-        return False
-
-    def get(self) -> Any:
-        return self.iterator.get()
-
-    def advance(self):
-        self.iterator.advance()
+    def next(self) -> Maybe[T]:
+        while True:
+            value = self.iterator.next()
+            if value.is_nothing:
+                return Nothing
+            inside = value.get()
+            if self.fn(inside):
+                return Some(inside)
 
 
 def my_filter[T, Fn](iterable: T, fn: Fn) -> T:

sonolus_py-0.4.0/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.4.0/docs/overview.md

@@ -0,0 +1,252 @@
+# 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.
+
+## Language
+
+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.
+
+### Syntax
+
+Most Python syntax is supported, but there are a few limitations. The primary restrictions are:
+
+- 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
+
+record_1 = MyRecord(1, b=2.3)
+```
+
+Records may also be generic:
+
+```python
+class MyGenericRecord[T](Record):
+    value: T
+
+record_1 = MyGenericRecord[int](123)
+record_2 = MyGenericRecord(MyRecord(4, 5.6))  # Type arguments are inferred
+```
+
+Record arguments are retained by reference, so modifying the original record will also modify the record in the array:
+
+```python
+record_1 = MyRecord(1, 2.3)
+record_2 = MyGenericRecord(record_1)
+record_2.value.a = 789  # This also affects `record_1` since they're the same object.
+assert record_1.a == record_2.value.a == 789
+```
+
+### Array
+
+[`Array`](reference/sonolus.script.array.md) is a type that represents a fixed-size array of elements of a 
+specific type:
+
+```python
+array_1 = Array[int, 3](1, 2, 3)
+array_2 = Array(4, 5, 6)  # Type arguments are inferred
+```
+
+When given record or array values as arguments, the array constructor will copy them:
+
+```python
+record_1 = MyRecord(1, 2.5)
+array_1 = Array(record_1)
+array_1[0].a = 789  # This has no effect on `record_1` since it was copied.
+assert record_1.a == 1
+```
+
+### Operations
+
+This section is an overview of the operations available for records and arrays. For full details see the
+[Record documentation](reference/sonolus.script.record.md) and [Array documentation](reference/sonolus.script.array.md).
+
+Records and arrays come with the `==` and `!=` operators predefined to compare their values for equality:
+
+```python
+assert MyRecord(1, 2.3) == MyRecord(1, 2.3)
+assert Array(1, 2, 3) != Array(4, 5, 6)
+```
+
+The unary `+` operator makes a copy of a record or array, creating a new instance with the same values:
+
+```python
+record_2 = +record_1
+array_2 = +array_1
+```
+
+Similarly, a new zero initialized value can be created using the unary `+` operator on a record or array type:
+
+```python
+record_1 = +MyRecord
+record_2 = +Array[int, 3]
+```
+
+Records and arrays can be mutated in-place using the `@=` operator:
+
+```python
+record_1 @= MyRecord(1, 2.3) 
+array_1 @= Array(4, 5, 6)
+```
+
+Record fields and array elements of numeric types can be set using the `=` operator:
+
+```python
+record_1.a = 123
+array_1[1] = 456
+```
+
+Setting a record field that's a record or array using the `=` operator will modify the field in-place:
+
+```python
+record_1 = MyRecord(1, 2.3)
+record_2 = MyGenericRecord(record_1)
+record_2.value = MyRecord(4, 5.6)  # This modifies `record_1` in-place.
+assert record_1 == record_2.value == MyRecord(4, 5.6)
+```
+
+Setting an array element that's a record or array using the `=` operator will also modify the element in-place:
+
+```python
+array_1 = Array(MyRecord(1, 2.3))
+record_1 = array_1[0]
+array_1[0] = MyRecord(4, 5.6)  # This modifies `record_1` in-place.
+assert record_1 == array_1[0] == MyRecord(4, 5.6)
+```
+
+### 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.
+    - [Maybe](reference/sonolus.script.maybe.md): Optional function return values.
+    - [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.4.0/docs/reference/sonolus.script.maybe.md

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

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

@@ -70,6 +70,7 @@ markdown_extensions:
       alternate_style: true
 nav:
   - index.md
+  - Overview: overview.md
   - Concepts:
       - concepts/index.md
       - concepts/types.md
@@ -97,6 +98,7 @@ nav:
       - reference/sonolus.script.interval.md
       - reference/sonolus.script.iterator.md
       - reference/sonolus.script.level.md
+      - reference/sonolus.script.maybe.md
       - reference/sonolus.script.metadata.md
       - reference/sonolus.script.num.md
       - reference/sonolus.script.options.md

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

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.3.3"
+version = "0.4.0"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -18,7 +18,7 @@ target-version = "py312"
 [tool.ruff.lint]
 preview = true
 select = ["F", "E", "W", "I", "N", "D", "UP", "YTT", "B", "A", "COM", "C4", "DTZ", "PIE", "PT", "Q", "SLOT", "SIM", "PTH", "PL", "PERF", "FURB", "LOG", "RUF"]
-ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005", "B903"]
+ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005", "B903", "FURB118"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -29,6 +29,7 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
+    "uv>=0.8.3",
     "hypothesis>=6.115.3",
     "pre-commit>=4.0.1",
     "pytest-xdist>=3.6.1",
@@ -37,6 +38,7 @@ dev = [
     "pytest-cov>=6.0.0",
     "tox>=4.23.2",
     "tox-uv>=1.16.0",
+    "ty"
 ]
 docs = [
     "mkdocs-material>=9.5.45",
@@ -61,3 +63,9 @@ deps = [
 ]
 uv_python_preference = "managed"
 commands = [["pytest", "tests", "-n", "auto"]]
+
+[tool.ty.environment]
+root = ["./sonolus"]
+
+[tool.ty.src]
+include = ["sonolus/script"]