sonolus.py 0.6.6__tar.gz → 0.7.0__tar.gz

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/PKG-INFO

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

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/pyproject.toml

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

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/build/engine.py

@@ -182,11 +182,11 @@ def package_engine(
         )
 
     return PackagedEngine(
-        configuration=package_output(configuration),
-        play_data=package_output(play_data),
-        watch_data=package_output(watch_data),
-        preview_data=package_output(preview_data),
-        tutorial_data=package_output(tutorial_data),
+        configuration=package_data(configuration),
+        play_data=package_data(play_data),
+        watch_data=package_data(watch_data),
+        preview_data=package_data(preview_data),
+        tutorial_data=package_data(tutorial_data),
         rom=package_rom(rom),
     )
 
@@ -410,6 +410,11 @@ def package_rom(rom: ReadOnlyMemory) -> bytes:
     return gzip.compress(bytes(output))
 
 
-def package_output(value: JsonValue) -> bytes:
+def package_data(value: JsonValue) -> bytes:
     json_data = json.dumps(value, separators=(",", ":")).encode("utf-8")
     return gzip.compress(json_data)
+
+
+def unpackage_data(data: bytes) -> JsonValue:
+    json_data = gzip.decompress(data)
+    return json.loads(json_data)

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/build/level.py

@@ -1,11 +1,11 @@
-from sonolus.build.engine import JsonValue, package_output
+from sonolus.build.engine import JsonValue, package_data
 from sonolus.script.level import LevelData
 
 
 def package_level_data(
     level_data: LevelData,
 ) -> bytes:
-    return package_output(build_level_data(level_data))
+    return package_data(build_level_data(level_data))
 
 
 def build_level_data(

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/build/project.py

@@ -1,10 +1,12 @@
+from collections.abc import Callable
 from pathlib import Path
+from typing import cast
 
 from sonolus.build.collection import Asset, Collection, Srl
-from sonolus.build.engine import package_engine
+from sonolus.build.engine import package_engine, unpackage_data
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
-from sonolus.script.level import Level
+from sonolus.script.level import ExternalLevelData, ExternalLevelDataDict, Level, LevelData, parse_external_level_data
 from sonolus.script.project import BuildConfig, Project, ProjectSchema
 
 BLANK_PNG = (
@@ -19,6 +21,13 @@ BLANK_AUDIO = (
 
 def build_project_to_collection(project: Project, config: BuildConfig | None):
     collection = load_resources_files_to_collection(project.resources)
+    for src_engine, converter in project.converters.items():
+        if src_engine is None:
+            continue
+        apply_converter_to_collection(collection, src_engine, converter)
+    fallback_converter = project.converters.get(None)
+    if fallback_converter is not None:
+        apply_converter_to_collection(collection, None, fallback_converter)
     if config.override_resource_level_engines:
         for level in collection.categories.get("levels", {}).values():
             level["item"]["engine"] = project.engine.name
@@ -29,6 +38,29 @@ def build_project_to_collection(project: Project, config: BuildConfig | None):
     return collection
 
 
+def apply_converter_to_collection(
+    self, src_engine: str | None, converter: Callable[[ExternalLevelData], LevelData]
+) -> None:
+    for level_details in self.categories.get("levels", {}).values():
+        level = level_details["item"]
+        if (
+            src_engine is not None
+            and level["engine"] != src_engine
+            and not (isinstance(level["engine"], dict) and level["engine"].get("name") == src_engine)
+        ):
+            continue
+        packaged_data_srl = level.get("data")
+        packaged_data = self.repository.get(packaged_data_srl["hash"])
+        data = unpackage_data(packaged_data)
+        if not (isinstance(data, dict) and "bgmOffset" in data and "entities" in data):
+            raise ValueError(f"Level data for level '{level['name']}' is not valid")
+        parsed_data = parse_external_level_data(cast(ExternalLevelDataDict, data))
+        new_data = converter(parsed_data)
+        packaged_new_data = package_level_data(new_data)
+        new_data_srl = self.add_asset(packaged_new_data)
+        level["data"] = new_data_srl
+
+
 def add_engine_to_collection(collection: Collection, project: Project, engine: Engine, config: BuildConfig | None):
     packaged_engine = package_engine(engine.data, config)
     item = {

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/script/archetype.py

@@ -23,6 +23,7 @@ from sonolus.script.internal.value import BackingValue, DataValue, Value
 from sonolus.script.num import Num
 from sonolus.script.pointer import _backing_deref, _deref
 from sonolus.script.record import Record
+from sonolus.script.timing import TimescaleEase
 from sonolus.script.values import zeros
 
 _ENTITY_MEMORY_SIZE = 64
@@ -1226,6 +1227,12 @@ class EntityRef[A: _BaseArchetype](Record):
         """Return a new reference with the given archetype type."""
         return EntityRef[archetype](index=self.index)
 
+    @meta_fn
+    def __eq__(self, other: Any) -> bool:
+        if not ctx() and hasattr(self, "_ref_") and hasattr(other, "_ref_"):
+            return self._ref_ is other._ref_
+        return super().__eq__(other)
+
     @meta_fn
     def get(self) -> A:
         """Get the entity."""
@@ -1361,10 +1368,10 @@ class StandardImport:
     TIMESCALE_GROUP = Annotated[EntityRef[Any], imported(name=StandardImportName.TIMESCALE_GROUP)]
     """The timescale group, for timescale change markers."""
 
-    TIMESCALE_EASE = Annotated[float, imported(name=StandardImportName.TIMESCALE_EASE)]
+    TIMESCALE_EASE = Annotated[TimescaleEase, imported(name=StandardImportName.TIMESCALE_EASE)]
     """The timescale ease type, for timescale change markers."""
 
-    JUDGMENT = Annotated[int, imported(name=StandardImportName.JUDGMENT)]
+    JUDGMENT = Annotated[Judgment, imported(name=StandardImportName.JUDGMENT)]
     """The judgment of the entity.
 
     Automatically set in watch mode for archetypes with a corresponding scored play mode archetype.

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/script/internal/generic.py

@@ -16,6 +16,9 @@ def validate_type_arg(arg: Any) -> Any:
     if not arg._is_py_():
         raise TypeError(f"Expected a compile-time constant type argument, got {arg}")
     result = arg._as_py_()
+    if isinstance(result, type) and issubclass(result, Enum):
+        # E.g. if this is an IntEnum subclass, we call it on IntEnum, and then int, which gets us the result we want
+        result = validate_type_arg(result.__mro__[1])
     if hasattr(result, "_type_mapping_"):
         return result._type_mapping_
     if get_origin(result) is Annotated:
@@ -27,10 +30,6 @@ def validate_type_arg(arg: Any) -> Any:
 
 def validate_type_spec(spec: Any) -> PartialGeneric | TypeVar | type[Value]:
     spec = validate_type_arg(spec)
-    if isinstance(spec, type) and issubclass(spec, Enum):
-        # For values like IntEnum subclasses, this will call validate_type_spec(IntEnum),
-        # which in turn will call it on int, so this works.
-        spec = validate_type_spec(spec.__mro__[1])
     if isinstance(spec, PartialGeneric | TypeVar) or (isinstance(spec, type) and issubclass(spec, Value)):
         return spec
     if typing.get_origin(spec) is UnionType:

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/script/level.py

@@ -4,7 +4,7 @@ import json
 from collections.abc import Iterator
 from os import PathLike
 from pathlib import Path
-from typing import Any
+from typing import Any, NamedTuple, NotRequired, TypedDict
 
 from sonolus.build.collection import Asset, load_asset
 from sonolus.script.archetype import PlayArchetype, StandardArchetypeName, StandardImport
@@ -196,3 +196,51 @@ class TimescaleChange(PlayArchetype):
 
     beat: StandardImport.BEAT
     timescale: StandardImport.TIMESCALE
+
+
+class ExternalLevelDataDict(TypedDict):
+    bgmOffset: float
+    entities: list[ExternalEntityDataDict]
+
+
+class ExternalEntityDataDict(TypedDict):
+    name: NotRequired[str]
+    archetype: str
+    data: NotRequired[list[ExternalEntityDataValueDict]]
+
+
+class ExternalEntityDataValueDict(TypedDict):
+    name: str
+    value: NotRequired[int | float]
+    ref: NotRequired[str]
+
+
+class ExternalLevelData(NamedTuple):
+    """Level data parsed from an external source."""
+
+    bgm_offset: float
+    entities: list[ExternalEntityData]
+
+
+class ExternalEntityData(NamedTuple):
+    """Entity data parsed from an external source."""
+
+    archetype: str
+    data: dict[str, Any]
+
+
+def parse_external_level_data(raw_data: ExternalLevelDataDict) -> ExternalLevelData:
+    bgm_offset = raw_data["bgmOffset"]
+    raw_entities = raw_data["entities"]
+    entity_name_to_index = {e["name"]: i for i, e in enumerate(raw_entities) if "name" in e}
+    entities = []
+    for raw_entity in raw_entities:
+        archetype = raw_entity["archetype"]
+        data = {}
+        for entry in raw_entity.get("data", []):
+            if "value" in entry:
+                data[entry["name"]] = entry["value"]
+            elif "ref" in entry:
+                data[entry["name"]] = entity_name_to_index.get(entry["ref"], 0)
+        entities.append(ExternalEntityData(archetype=archetype, data=data))
+    return ExternalLevelData(bgm_offset=bgm_offset, entities=entities)

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/sonolus/script/project.py

@@ -10,7 +10,7 @@ from sonolus.backend.optimize import optimize
 from sonolus.backend.optimize.passes import CompilerPass
 from sonolus.script.archetype import ArchetypeSchema
 from sonolus.script.engine import Engine
-from sonolus.script.level import Level
+from sonolus.script.level import ExternalLevelData, Level, LevelData
 
 
 class Project:
@@ -20,6 +20,7 @@ class Project:
         engine: The engine of the project.
         levels: The levels of the project.
         resources: The path to the resources of the project.
+        converters: A dictionary mapping engine names to converter functions, for converting loaded levels.
     """
 
     def __init__(
@@ -27,6 +28,7 @@ class Project:
         engine: Engine,
         levels: Iterable[Level] | Callable[[], Iterable[Level]] | None = None,
         resources: PathLike | None = None,
+        converters: dict[str | None, Callable[[ExternalLevelData], LevelData]] | None = None,
     ):
         self.engine = engine
         match levels:
@@ -40,6 +42,7 @@ class Project:
                 raise TypeError(f"Invalid type for levels: {type(levels)}. Expected Iterable or Callable.")
         self._levels = None
         self.resources = Path(resources or "resources")
+        self.converters = converters or {}
 
     def with_levels(self, levels: Iterable[Level] | Callable[[], Iterable[Level]] | None) -> Project:
         """Create a new project with the specified levels.

{sonolus_py-0.6.6 → sonolus_py-0.7.0}/uv.lock

@@ -696,7 +696,7 @@ wheels = [
 
 [[package]]
 name = "sonolus-py"
-version = "0.6.6"
+version = "0.7.0"
 source = { editable = "." }
 
 [package.dev-dependencies]