sonolus.py 0.1.9__py3-none-any.whl → 0.2.1__py3-none-any.whl

sonolus/script/engine.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import json
 from collections.abc import Callable
-from typing import Any
+from os import PathLike
+from pathlib import Path
+from typing import Any, Literal
 
-from sonolus.build.collection import Asset
+from sonolus.build.collection import Asset, load_asset
 from sonolus.script.archetype import PlayArchetype, PreviewArchetype, WatchArchetype, _BaseArchetype
 from sonolus.script.bucket import Buckets, EmptyBuckets
 from sonolus.script.effect import Effects, EmptyEffects
@@ -13,12 +16,52 @@ from sonolus.script.instruction import (
     TutorialInstructionIcons,
     TutorialInstructions,
 )
+from sonolus.script.metadata import AnyText, Tag, as_localization_text
 from sonolus.script.options import EmptyOptions, Options
 from sonolus.script.particle import EmptyParticles, Particles
 from sonolus.script.sprite import EmptySkin, Skin
 from sonolus.script.ui import UiConfig
 
 
+class ExportedEngine:
+    """An exported Sonolus.py engine."""
+
+    def __init__(
+        self,
+        *,
+        item: dict,
+        thumbnail: bytes,
+        play_data: bytes,
+        watch_data: bytes,
+        preview_data: bytes,
+        tutorial_data: bytes,
+        rom: bytes | None = None,
+        configuration: bytes,
+    ) -> None:
+        self.item = item
+        self.thumbnail = thumbnail
+        self.play_data = play_data
+        self.watch_data = watch_data
+        self.preview_data = preview_data
+        self.tutorial_data = tutorial_data
+        self.rom = rom
+        self.configuration = configuration
+
+    def write_to_dir(self, path: PathLike):
+        """Write the exported engine to a directory."""
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+        (path / "item.json").write_text(json.dumps(self.item, ensure_ascii=False), encoding="utf-8")
+        (path / "thumbnail").write_bytes(self.thumbnail)
+        (path / "playData").write_bytes(self.play_data)
+        (path / "watchData").write_bytes(self.watch_data)
+        (path / "previewData").write_bytes(self.preview_data)
+        (path / "tutorialData").write_bytes(self.tutorial_data)
+        if self.rom is not None:
+            (path / "rom").write_bytes(self.rom)
+        (path / "configuration").write_bytes(self.configuration)
+
+
 class Engine:
     """A Sonolus.py engine.
 
@@ -33,34 +76,79 @@ class Engine:
         particle: The default particle for the engine.
         thumbnail: The thumbnail for the engine.
         data: The engine's modes and configurations.
+        tags: The tags of the engine.
+        description: The description of the engine.
+        meta: Additional metadata of the engine.
     """
 
-    version = 12
+    version: Literal[13] = 13
 
     def __init__(
         self,
         *,
         name: str,
-        title: str | None = None,
-        subtitle: str = "Sonolus.py Engine",
-        author: str = "Unknown",
+        title: AnyText | None = None,
+        subtitle: AnyText = "Sonolus.py Engine",
+        author: AnyText = "Unknown",
         skin: str | None = None,
         background: str | None = None,
         effect: str | None = None,
         particle: str | None = None,
         thumbnail: Asset | None = None,
         data: EngineData,
+        tags: list[Tag] | None = None,
+        description: AnyText | None = None,
+        meta: Any = None,
     ) -> None:
         self.name = name
-        self.title = title or name
-        self.subtitle = subtitle
-        self.author = author
+        self.title = as_localization_text(title or name)
+        self.subtitle = as_localization_text(subtitle)
+        self.author = as_localization_text(author)
         self.skin = skin
         self.background = background
         self.effect = effect
         self.particle = particle
         self.thumbnail = thumbnail
         self.data = data
+        self.tags = tags or []
+        self.description = as_localization_text(description) if description is not None else None
+        self.meta = meta
+
+    def export(self) -> ExportedEngine:
+        """Export the engine in a sonolus-pack compatible format.
+
+        Returns:
+            An exported engine.
+        """
+        from sonolus.build.engine import package_engine
+        from sonolus.build.project import BLANK_PNG
+
+        item = {
+            "version": self.version,
+            "title": self.title,
+            "subtitle": self.subtitle,
+            "author": self.author,
+            "tags": [tag.as_dict() for tag in self.tags],
+            "skin": self.skin,
+            "background": self.background,
+            "effect": self.effect,
+            "particle": self.particle,
+        }
+        packaged = package_engine(self.data)
+        if self.description is not None:
+            item["description"] = self.description
+        if self.meta is not None:
+            item["meta"] = self.meta
+        return ExportedEngine(
+            item=item,
+            thumbnail=load_asset(self.thumbnail) if self.thumbnail is not None else BLANK_PNG,
+            play_data=packaged.play_data,
+            watch_data=packaged.watch_data,
+            preview_data=packaged.preview_data,
+            tutorial_data=packaged.tutorial_data,
+            rom=packaged.rom,
+            configuration=packaged.configuration,
+        )
 
 
 def default_callback() -> Any:
@@ -190,6 +278,30 @@ class TutorialMode:
         self.update = update
 
 
+def empty_play_mode() -> PlayMode:
+    """Create an empty play mode."""
+    return PlayMode()
+
+
+def empty_watch_mode() -> WatchMode:
+    """Create an empty watch mode."""
+    return WatchMode(update_spawn=default_callback)
+
+
+def empty_preview_mode() -> PreviewMode:
+    """Create an empty preview mode."""
+    return PreviewMode()
+
+
+def empty_tutorial_mode() -> TutorialMode:
+    """Create an empty tutorial mode."""
+    return TutorialMode(
+        preprocess=default_callback,
+        navigate=default_callback,
+        update=default_callback,
+    )
+
+
 class EngineData:
     """A Sonolus.py engine's modes and configurations.
 
@@ -214,11 +326,7 @@ class EngineData:
     ) -> None:
         self.ui = ui or UiConfig()
         self.options = options
-        self.play = play or PlayMode()
-        self.watch = watch or WatchMode(update_spawn=default_callback)
-        self.preview = preview or PreviewMode()
-        self.tutorial = tutorial or TutorialMode(
-            preprocess=default_callback,
-            navigate=default_callback,
-            update=default_callback,
-        )
+        self.play = play or empty_play_mode()
+        self.watch = watch or empty_watch_mode()
+        self.preview = preview or empty_preview_mode()
+        self.tutorial = tutorial or empty_tutorial_mode()

sonolus/script/internal/builtin_impls.py

@@ -52,9 +52,11 @@ def _enumerate(iterable, start=0):
     from sonolus.backend.visitor import compile_and_call
 
     iterable = validate_value(iterable)
-    if not hasattr(iterable, "__iter__"):
+    if isinstance(iterable, TupleImpl):
+        return TupleImpl._accept_(tuple((start + i, value) for i, value in enumerate(iterable._as_py_(), start=start)))
+    elif not hasattr(iterable, "__iter__"):
         raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
-    if isinstance(iterable, ArrayLike):
+    elif isinstance(iterable, ArrayLike):
         return compile_and_call(iterable._enumerate_, start)
     else:
         iterator = compile_and_call(iterable.__iter__)
@@ -232,10 +234,27 @@ _int._type_mapping_ = Num
 _float._type_mapping_ = Num
 _bool._type_mapping_ = Num
 
+
+def _any(iterable):
+    for value in iterable:  # noqa: SIM110
+        if value:
+            return True
+    return False
+
+
+def _all(iterable):
+    for value in iterable:  # noqa: SIM110
+        if not value:
+            return False
+    return True
+
+
 # classmethod, property, staticmethod are supported as decorators, but not within functions
 
 BUILTIN_IMPLS = {
     id(abs): _abs,
+    id(all): _all,
+    id(any): _any,
     id(bool): _bool,
     id(callable): _callable,
     id(enumerate): _enumerate,

sonolus/script/internal/constant.py

@@ -3,7 +3,7 @@ from typing import Any, ClassVar, Self
 
 from sonolus.backend.place import BlockPlace
 from sonolus.script.internal.impl import meta_fn
-from sonolus.script.internal.value import Value
+from sonolus.script.internal.value import DataValue, Value
 
 
 class _Missing:
@@ -94,10 +94,10 @@ class ConstantValue(Value):
         return self.value()
 
     @classmethod
-    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+    def _from_list_(cls, values: Iterable[DataValue]) -> Self:
         return cls()
 
-    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         return []
 
     @classmethod
@@ -107,7 +107,7 @@ class ConstantValue(Value):
     def _get_(self) -> Self:
         return self
 
-    def _set_(self, value: Any) -> Self:
+    def _set_(self, value: Any):
         if value is not self:
             raise ValueError(f"{type(self).__name__} is immutable")
 
@@ -122,6 +122,10 @@ class ConstantValue(Value):
     def _alloc_(cls) -> Self:
         return cls()
 
+    @classmethod
+    def _zero_(cls) -> Self:
+        return cls()
+
     @meta_fn
     def __eq__(self, other):
         return self is other

sonolus/script/internal/context.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
+from threading import Lock
 from typing import Any, Self
 
 from sonolus.backend.blocks import BlockData, PlayBlock
@@ -25,6 +26,7 @@ class GlobalContextState:
     environment_mappings: dict[_GlobalInfo, int]
     environment_offsets: dict[Block, int]
     mode: Mode
+    lock: Lock
 
     def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None, rom: ReadOnlyMemory | None = None):
         self.archetypes = archetypes or {}
@@ -33,6 +35,7 @@ class GlobalContextState:
         self.environment_mappings = {}
         self.environment_offsets = {}
         self.mode = mode
+        self.lock = Lock()
 
 
 class CallbackContextState:
@@ -88,10 +91,6 @@ class Context:
     def used_names(self) -> dict[str, int]:
         return self.callback_state.used_names
 
-    @property
-    def const_mappings(self) -> dict[Any, int]:
-        return self.global_state.const_mappings
-
     def check_readable(self, place: BlockPlace):
         if not self.callback:
             return
@@ -204,22 +203,25 @@ class Context:
                         )
 
     def map_constant(self, value: Any) -> int:
-        if value not in self.const_mappings:
-            self.const_mappings[value] = len(self.const_mappings)
-        return self.const_mappings[value]
+        with self.global_state.lock:
+            const_mappings = self.global_state.const_mappings
+            if value not in const_mappings:
+                const_mappings[value] = len(const_mappings)
+            return const_mappings[value]
 
     def get_global_base(self, value: _GlobalInfo | _GlobalPlaceholder) -> BlockPlace:
-        block = value.blocks.get(self.global_state.mode)
-        if block is None:
-            raise RuntimeError(f"Global {value.name} is not available in '{self.global_state.mode.name}' mode")
-        if value not in self.global_state.environment_mappings:
-            if value.offset is None:
-                offset = self.global_state.environment_offsets.get(block, 0)
-                self.global_state.environment_mappings[value] = offset
-                self.global_state.environment_offsets[block] = offset + value.size
-            else:
-                self.global_state.environment_mappings[value] = value.offset
-        return BlockPlace(block, self.global_state.environment_mappings[value])
+        with self.global_state.lock:
+            block = value.blocks.get(self.global_state.mode)
+            if block is None:
+                raise RuntimeError(f"Global {value.name} is not available in '{self.global_state.mode.name}' mode")
+            if value not in self.global_state.environment_mappings:
+                if value.offset is None:
+                    offset = self.global_state.environment_offsets.get(block, 0)
+                    self.global_state.environment_mappings[value] = offset
+                    self.global_state.environment_offsets[block] = offset + value.size
+                else:
+                    self.global_state.environment_mappings[value] = value.offset
+            return BlockPlace(block, self.global_state.environment_mappings[value])
 
     @classmethod
     def meet(cls, contexts: list[Context]) -> Context:
@@ -257,19 +259,22 @@ def using_ctx(value: Context | None):
 class ReadOnlyMemory:
     values: list[float]
     indexes: dict[tuple[float, ...], int]
+    _lock: Lock
 
     def __init__(self):
         self.values = []
         self.indexes = {}
+        self._lock = Lock()
 
     def __getitem__(self, item: tuple[float, ...]) -> BlockPlace:
-        if item not in self.indexes:
-            index = len(self.values)
-            self.indexes[item] = index
-            self.values.extend(item)
-        else:
-            index = self.indexes[item]
-        return BlockPlace(self.block, index)
+        with self._lock:
+            if item not in self.indexes:
+                index = len(self.values)
+                self.indexes[item] = index
+                self.values.extend(item)
+            else:
+                index = self.indexes[item]
+            return BlockPlace(self.block, index)
 
     @property
     def block(self) -> Block:

sonolus/script/internal/math_impls.py

@@ -93,7 +93,8 @@ def _ln(x: float) -> float:
 def _log(x: float, base: float | None = None) -> float:
     if base is None:
         return _ln(x)
-    return _ln(x) / _ln(base)
+    else:
+        return _ln(x) / _ln(base)
 
 
 @native_function(Op.Rem)

sonolus/script/internal/transient.py

@@ -2,7 +2,7 @@ from collections.abc import Iterable
 from typing import Any, Self
 
 from sonolus.backend.place import BlockPlace
-from sonolus.script.internal.value import Value
+from sonolus.script.internal.value import DataValue, Value
 
 
 class TransientValue(Value):
@@ -23,10 +23,10 @@ class TransientValue(Value):
         raise TypeError(f"{cls.__name__} cannot be dereferenced")
 
     @classmethod
-    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+    def _from_list_(cls, values: Iterable[DataValue]) -> Self:
         raise TypeError(f"{cls.__name__} cannot be constructed from list")
 
-    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         raise TypeError(f"{type(self).__name__} cannot be deconstructed to list")
 
     @classmethod
@@ -49,3 +49,7 @@ class TransientValue(Value):
     @classmethod
     def _alloc_(cls) -> Self:
         raise TypeError(f"{cls.__name__} is not allocatable")
+
+    @classmethod
+    def _zero_(cls) -> Self:
+        raise TypeError(f"{cls.__name__} does not have a zero value")

sonolus/script/internal/value.py

@@ -1,10 +1,23 @@
 from abc import abstractmethod
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from typing import Any, Self
 
+from sonolus.backend.ir import IRConst, IRExpr, IRStmt
 from sonolus.backend.place import BlockPlace
 
 
+class BackingValue:
+    def read(self) -> IRExpr:
+        raise NotImplementedError()
+
+    def write(self, value: IRExpr) -> IRStmt:
+        raise NotImplementedError()
+
+
+type DataValue = BlockPlace | BackingValue | float | int | bool
+type BackingSource = Callable[[IRExpr], BackingValue]
+
+
 class Value:
     """Base class for values."""
 
@@ -59,15 +72,20 @@ class Value:
         """
         raise NotImplementedError
 
+    @classmethod
+    def _from_backing_source_(cls, source: BackingSource) -> Self:
+        """Creates a value from a backing source."""
+        return cls._from_list_(source(IRConst(i)) for i in range(cls._size_()))
+
     @classmethod
     @abstractmethod
-    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
-        """Creates a value from a list of floats."""
+    def _from_list_(cls, values: Iterable[DataValue]) -> Self:
+        """Creates a value from a list of data values."""
         raise NotImplementedError
 
     @abstractmethod
-    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
-        """Converts this value to a list of floats."""
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
+        """Converts this value to a list of data values."""
         raise NotImplementedError
 
     @classmethod
@@ -76,9 +94,7 @@ class Value:
         """Returns the keys to a flat representation of this value."""
         raise NotImplementedError
 
-    def _to_flat_dict_(
-        self, prefix: str, level_refs: dict[Any, str] | None = None
-    ) -> dict[str, float | str | BlockPlace]:
+    def _to_flat_dict_(self, prefix: str, level_refs: dict[Any, str] | None = None) -> dict[str, DataValue | str]:
         """Converts this value to a flat dictionary."""
         return dict(zip(self._flat_keys_(prefix), self._to_list_(level_refs), strict=False))
 
@@ -96,12 +112,12 @@ class Value:
             v: Num
 
         a = 1
-        b = X(a) # (1) _get() is called on a
-        c = b.v # (2) _get() is called on the value for v
+        b = X(a) # (1) _get_() is called on a
+        c = b.v # (2) _get_() is called on the value for v
 
         # (1) prevents this from changing the value of a
         # (2) prevents this from changing the value of c
-        # Thus, both calls to _get() are necessary to ensure values behave immutably.
+        # Thus, both calls to _get_() are necessary to ensure values behave immutably.
         b.v = 2
         ```
         """
@@ -138,6 +154,12 @@ class Value:
         """Allocates a new value which may be uninitialized."""
         raise NotImplementedError
 
+    @classmethod
+    @abstractmethod
+    def _zero_(cls) -> Self:
+        """Returns a zero-initialized value of this type."""
+        raise NotImplementedError
+
     def __imatmul__(self, other):
         self._copy_from_(other)
         return self

sonolus/script/interval.py

@@ -1,7 +1,7 @@
 from typing import Self
 
 from sonolus.backend.ops import Op
-from sonolus.script.debug import error
+from sonolus.script.debug import static_error
 from sonolus.script.internal.native import native_function
 from sonolus.script.num import Num
 from sonolus.script.record import Record
@@ -19,6 +19,11 @@ class Interval(Record):
     start: float
     end: float
 
+    @classmethod
+    def zero(cls) -> Self:
+        """Get an empty interval."""
+        return cls(0, 0)
+
     @property
     def length(self) -> float:
         """The length of the interval.
@@ -29,7 +34,7 @@ class Interval(Record):
 
     @property
     def is_empty(self) -> bool:
-        """Whether the interval has length of zero or less."""
+        """Whether the has a start greater than its end."""
         return self.start > self.end
 
     @property
@@ -57,7 +62,7 @@ class Interval(Record):
             case Num(value):
                 return self.start <= value <= self.end
             case _:
-                error("Invalid type for interval check")
+                static_error("Invalid type for interval check")
 
     def __add__(self, other: float | int) -> Self:
         """Add a value to both ends of the interval.

sonolus/script/iterator.py

@@ -165,3 +165,20 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
 
     def advance(self):
         self.iterator.advance()
+
+
+class _ChainingIterator[T](Record, SonolusIterator):
+    iterator: T
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def get(self) -> Any:
+        return self.iterator.get().get()
+
+    def advance(self):
+        self.iterator.get().advance()
+        while not self.iterator.get().has_next():
+            self.iterator.advance()
+            if not self.iterator.has_next():
+                break