sonolus.py 0.1.3__tar.gz → 0.1.5__tar.gz

sonolus_py-0.1.5/.github/workflows/publish.yaml

@@ -0,0 +1,52 @@
+name: Publish to PyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: 0.5.2
+      - name: Install Python
+        run: |
+          uv python install
+      - name: Install project
+        run: |
+          uv sync --all-extras --dev
+      - name: Run tests
+        run: |
+          uv run pytest tests -n auto
+      - name: Build
+        run: |
+          uv build
+      - name: Store distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+  publish:
+    name: Publish
+    if: startsWith(github.ref, 'refs/tags/')
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/sonolus.py
+    permissions:
+      id-token: write
+    steps:
+      - name: Download distribution packages
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

{sonolus_py-0.1.3 → sonolus_py-0.1.5}/.gitignore

@@ -18,3 +18,8 @@ test.py
 !/sonolus/build/
 
 .env
+
+site/
+
+.coverage
+coverage.xml

{sonolus_py-0.1.3 → sonolus_py-0.1.5}/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Kyle Chang
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Kyle Chang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{sonolus_py-0.1.3 → sonolus_py-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.3
+Version: 0.1.5
 Summary: Sonolus engine development in Python
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

sonolus_py-0.1.5/doc_stubs/builtins.pyi

@@ -0,0 +1,252 @@
+# ruff: noqa
+import builtins
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    Sequence,
+    overload,
+)
+
+def abs(x: builtins.int | builtins.float) -> builtins.int | builtins.float:
+    """Return the absolute value of a number.
+
+    Args:
+        x: A number.
+
+    Returns:
+        The absolute value of x.
+    """
+    ...
+
+def bool(x: builtins.int | builtins.float | builtins.bool) -> builtins.bool:
+    """Convert a value to a Boolean.
+
+    Args:
+        x: The value to convert.
+
+    Returns:
+        The Boolean value of x.
+    """
+    ...
+
+def callable(obj: object) -> bool:
+    """Check if the object appears callable.
+
+    Args:
+        obj: The object to check.
+
+    Returns:
+        True if the object appears callable, False otherwise.
+    """
+    ...
+
+def enumerate[T](iterable: Iterable[T], start: int = 0) -> Iterator[tuple[int, T]]:
+    """Return an enumerate object.
+
+    Args:
+        iterable: The iterable to enumerate.
+        start: The starting index.
+
+    Returns:
+        An enumerate object.
+    """
+    ...
+
+def filter[T](function: Callable[[T], builtins.bool] | None, iterable: Iterable[T]) -> Iterator[T]:
+    """Construct an iterator from those elements of iterable for which function returns true.
+
+    Args:
+        function: A function that tests if each element should be included. If None, returns the elements that are true.
+        iterable: The iterable to filter.
+
+    Returns:
+        An iterator yielding the filtered elements.
+    """
+    ...
+
+def float(x: builtins.int | builtins.float) -> builtins.float:
+    """Convert a number to a floating point number.
+
+    Args:
+        x: The number to convert.
+
+    Returns:
+        The floating point representation of x.
+    """
+    ...
+
+def int(x: builtins.int | builtins.float) -> builtins.int:
+    """Convert a number to an integer.
+
+    Args:
+        x: The number to convert.
+
+    Returns:
+        The integer representation of x.
+    """
+    ...
+
+def isinstance(obj: object, classinfo: type | tuple[type, ...]) -> builtins.bool:
+    """Check if an object is an instance of a class or of a subclass thereof.
+
+    Args:
+        obj: The object to check.
+        classinfo: A type or a tuple of types.
+
+    Returns:
+        True if the object is an instance of classinfo, False otherwise.
+    """
+    ...
+
+def issubclass(cls: type, classinfo: type | tuple[type, ...]) -> builtins.bool:
+    """Check if a class is a subclass of another class or a tuple of classes.
+
+    Args:
+        cls: The class to check.
+        classinfo: A class or a tuple of classes.
+
+    Returns:
+        True if cls is a subclass of classinfo, False otherwise.
+    """
+    ...
+
+def len(s: object) -> builtins.int:
+    """Return the number of items in a container.
+
+    Args:
+        s: The container object.
+
+    Returns:
+        The number of items in s.
+    """
+    ...
+
+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.
+
+    Args:
+        function: The function to apply.
+        iterable: The iterable to process.
+
+    Returns:
+        An iterator with the results.
+    """
+    ...
+
+@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.
+    """
+    ...
+
+@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.
+
+    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.
+
+    Returns:
+        The largest item.
+    """
+    ...
+
+@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.
+    """
+    ...
+
+@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.
+
+    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.
+
+    Returns:
+        The smallest item.
+    """
+    ...
+
+@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.
+    """
+    ...
+
+@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.
+
+    Args:
+        start: Start value.
+        stop: Stop value.
+        step: Step value.
+
+    Returns:
+        The range object.
+    """
+    ...
+
+def reversed[T](seq: Sequence[T]) -> Iterator[T]:
+    """Return a reverse iterator.
+
+    Args:
+        seq: The sequence to reverse.
+
+    Returns:
+        An iterator over the reversed sequence.
+    """
+    ...
+
+def round(number: builtins.int | builtins.float, ndigits: builtins.int = ...) -> builtins.float:
+    """Round a number to a given precision in decimal digits.
+
+    Args:
+        number: The number to round.
+        ndigits: The number of decimal digits to round to.
+
+    Returns:
+        The rounded number.
+    """
+    ...
+
+def zip[T](*iterables: Iterable[T]) -> Iterator[tuple[T, ...]]:
+    """Return an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument sequences.
+
+    Args:
+        *iterables: Iterables to aggregate.
+
+    Returns:
+        An iterator of aggregated tuples.
+    """
+    ...

sonolus_py-0.1.5/doc_stubs/math.pyi

@@ -0,0 +1,156 @@
+# ruff: noqa
+def sin(x: float) -> float:
+    """Compute the sine of x.
+
+    Args:
+        x: The angle in radians.
+
+    Returns:
+        The sine of x.
+    """
+    ...
+
+def cos(x: float) -> float:
+    """Compute the cosine of x.
+
+    Args:
+        x: The angle in radians.
+
+    Returns:
+        The cosine of x.
+    """
+    ...
+
+def tan(x: float) -> float:
+    """Compute the tangent of x.
+
+    Args:
+        x: The angle in radians.
+
+    Returns:
+        The tangent of x.
+    """
+    ...
+
+def asin(x: float) -> float:
+    """Compute the arcsine of x.
+
+    Args:
+        x: A value between -1 and 1.
+
+    Returns:
+        The arcsine of x in radians.
+    """
+    ...
+
+def acos(x: float) -> float:
+    """Compute the arccosine of x.
+
+    Args:
+        x: A value between -1 and 1.
+
+    Returns:
+        The arccosine of x in radians.
+    """
+    ...
+
+def atan(x: float) -> float:
+    """Compute the arctangent of x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The arctangent of x in radians.
+    """
+    ...
+
+def atan2(y: float, x: float) -> float:
+    """Compute the arctangent of y / x considering the quadrant.
+
+    Args:
+        y: The y-coordinate.
+        x: The x-coordinate.
+
+    Returns:
+        The arctangent of y / x in radians.
+    """
+    ...
+
+def sinh(x: float) -> float:
+    """Compute the hyperbolic sine of x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The hyperbolic sine of x.
+    """
+    ...
+
+def cosh(x: float) -> float:
+    """Compute the hyperbolic cosine of x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The hyperbolic cosine of x.
+    """
+    ...
+
+def tanh(x: float) -> float:
+    """Compute the hyperbolic tangent of x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The hyperbolic tangent of x.
+    """
+    ...
+
+def floor(x: float) -> int:
+    """Return the largest integer less than or equal to x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The floor of x.
+    """
+    ...
+
+def ceil(x: float) -> int:
+    """Return the smallest integer greater than or equal to x.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The ceiling of x.
+    """
+    ...
+
+def trunc(x: float) -> int:
+    """Truncate x to the nearest integer towards zero.
+
+    Args:
+        x: A numeric value.
+
+    Returns:
+        The truncated integer value of x.
+    """
+    ...
+
+def log(x: float, base: float = ...) -> float:
+    """Compute the logarithm of x to the given base.
+
+    Args:
+        x: The number for which to compute the logarithm.
+        base: The base of the logarithm. If omitted, returns the natural logarithm of x.
+
+    Returns:
+        The logarithm of x to the specified base.
+    """
+    ...

sonolus_py-0.1.5/doc_stubs/num.pyi

@@ -0,0 +1,5 @@
+class Num(int, bool, float):
+    """Common type for numbers and booleans.
+
+    See the relevant [concepts page](../concepts/types.md#num) for more information.
+    """

sonolus_py-0.1.5/doc_stubs/random.pyi

@@ -0,0 +1,97 @@
+# ruff: noqa
+from typing import (
+    Any,
+    Sequence,
+    overload,
+    MutableSequence,
+)
+
+@overload
+def randrange(stop: int) -> int:
+    """Return a randomly selected element from range(stop).
+
+    Args:
+        stop: The end of the range.
+
+    Returns:
+        A randomly selected integer from the range.
+    """
+    ...
+
+@overload
+def randrange(start: int, stop: int, step: int = ...) -> int:
+    """Return a randomly selected element from range(start, stop, step).
+
+    Args:
+        start: The start of the range.
+        stop: The end of the range.
+        step: The step size.
+
+    Returns:
+        A randomly selected integer from the range.
+    """
+    ...
+
+def randrange(start: int, stop: int = ..., step: int = ...) -> int:
+    """Return a randomly selected element from range(start, stop, step).
+
+    Args:
+        start: The start of the range.
+        stop: The end of the range.
+        step: The step size.
+
+    Returns:
+        A randomly selected integer from the range.
+    """
+    ...
+
+def randint(a: int, b: int) -> int:
+    """Return a random integer N such that a <= N <= b.
+
+    Args:
+        a: The lower bound.
+        b: The upper bound.
+
+    Returns:
+        A randomly selected integer between a and b, inclusive.
+    """
+    ...
+
+def choice[T](seq: Sequence[T]) -> T:
+    """Return a randomly selected element from a non-empty sequence.
+
+    Args:
+        seq: The sequence to choose from.
+
+    Returns:
+        A randomly selected element from the sequence.
+    """
+    ...
+
+def shuffle(seq: MutableSequence[Any]) -> None:
+    """Shuffle the sequence in place.
+
+    Args:
+        seq: The mutable sequence to shuffle.
+    """
+    ...
+
+def random() -> float:
+    """Return a random floating point number in the range [0.0, 1.0).
+
+    Returns:
+        A random float between 0.0 (inclusive) and 1.0 (exclusive).
+    """
+    ...
+
+def uniform(a: float, b: float) -> float:
+    """Return a random floating point number N such that a <= N <= b.
+
+    Args:
+        a: The lower bound.
+        b: The upper bound.
+
+    Returns:
+        A random float between a and b.
+    """
+    ...

sonolus_py-0.1.5/docs/CNAME

@@ -0,0 +1 @@
+sonolus.py.qwewqa.xyz

sonolus_py-0.1.5/docs/concepts/builtins.md

@@ -0,0 +1,49 @@
+# Builtins
+Sonolus.py comes with support for a number of built-in functions.
+
+- `abs(x)`
+- `bool(object)` (for a num argument)
+- `callable(object)`
+- `enumerate(iterable, start=0)`
+- `filter(function, iterable)`
+- `float(x)` (for a num argument)
+- `int(x)` (for a num argument)
+- `isinstance(object, classinfo)`
+- `issubclass(class, classinfo)`
+- `len(s)`
+- `map(function, iterable)`
+- `max(iterable, *, key=None)`, `max(arg1, arg2, *args, key=None)`
+- `min(iterable, *, key=None)`, `min(arg1, arg2, *args, key=None)`
+- `range(stop)`, `range(start, stop[, step])`
+- `reversed(seq)`
+- `round(number[, ndigits])`
+- `zip(*iterables)`
+
+## Standard library modules
+Sonolus.py also comes with support for some standard library modules.
+
+### math
+- `sin(x)`
+- `cos(x)`
+- `tan(x)`
+- `asin(x)`
+- `acos(x)`
+- `atan(x)`
+- `atan2(y, x)`
+- `sinh(x)`
+- `cosh(x)`
+- `tanh(x)`
+- `floor(x)`
+- `ceil(x)`
+- `trunc(x)`
+- `log(x[, base])`
+
+### random
+- `randrange(stop)`, `random.randrange(start, stop[, step])`
+- `randint(a, b)`
+- `choice(seq)`
+- `shuffle(seq)`
+- `random()` (does not include 1)
+- `uniform(a, b)` (may include `b` where Python normally doesn't)
+
+Creating `Random` instances is not supported.

sonolus_py-0.1.5/docs/concepts/cli.md

@@ -0,0 +1,16 @@
+# Command Line
+The Sonolus.py CLI provides commands to run and build Sonolus scripts.
+
+## Starting a development server
+To start a development server, run the following command in the root directory of your project:
+
+```bash
+sonolus-py dev
+```
+
+## Building the project
+To build the project, run the following command in the root directory of your project:
+
+```bash
+sonolus-py build
+```