sonolus.py 0.5.0__tar.gz → 0.5.2__tar.gz

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/PKG-INFO

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

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/pyproject.toml

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

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/sonolus/backend/visitor.py

@@ -1126,8 +1126,6 @@ class Visitor(ast.NodeVisitor):
             if first_param_name is not None:
                 first_param_value = self.get_name(first_param_name)
                 args = (validate_value(class_value), validate_value(first_param_value))
-            else:
-                args = (validate_value(class_value),)
         return self.handle_call(node, fn, *args, **kwargs)
 
     def visit_FormattedValue(self, node):

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/sonolus/build/compile.py

@@ -74,10 +74,12 @@ def compile_mode(
             return cb_info.name, node_index
 
     all_futures = {}
-    archetype_entries = []
+    base_archetype_entries = {}
 
     if archetypes is not None:
-        for archetype in archetypes:
+        base_archetypes = {getattr(a, "_derived_base_", a) for a in archetypes}
+
+        for archetype in base_archetypes:
             archetype._init_fields()
 
             archetype_data = {
@@ -109,7 +111,7 @@ def compile_mode(
                     cb_name, result_data = process_callback(cb_info, cb, archetype)
                     archetype_data[cb_name] = result_data
 
-            archetype_entries.append(archetype_data)
+            base_archetype_entries[archetype] = archetype_data
 
     if global_callbacks is not None and thread_pool is not None:
         for cb_info, cb in global_callbacks:
@@ -129,7 +131,10 @@ def compile_mode(
             results[cb_name] = node_index
 
     if archetypes is not None:
-        results["archetypes"] = archetype_entries
+        results["archetypes"] = [
+            {**base_archetype_entries[getattr(a, "_derived_base_", a)], "name": a.name, "hasInput": a.is_scored}
+            for a in archetypes
+        ]
 
     results["nodes"] = nodes.get()
     return results

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/sonolus/script/archetype.py

@@ -183,6 +183,68 @@ class _ArchetypeField(SonolusDescriptor):
             target._copy_from_(value)
 
 
+class _NameDescriptor(SonolusDescriptor):
+    def __init__(self, name: str):
+        self.name = name
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self.name
+        elif ctx():
+            raise RuntimeError("Cannot access archetype name in from self in a callback, use ArchetypeClass.name")
+        else:
+            return self.name
+
+    def __set__(self, instance, value):
+        raise AttributeError("Archetype name is read-only and cannot be set")
+
+
+class _IsScoredDescriptor(SonolusDescriptor):
+    def __init__(self, value: bool):
+        self.value = value
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self.value
+        elif ctx():
+            raise RuntimeError("Cannot access is_scored from self in a callback, use ArchetypeClass.is_scored")
+        else:
+            return self.value
+
+    def __set__(self, instance, value):
+        raise AttributeError("is_scored is read-only and cannot be set")
+
+
+class _IdDescriptor(SonolusDescriptor):
+    def __get__(self, instance, owner):
+        if not ctx():
+            raise RuntimeError("Archetype id is only available during compilation")
+        if instance is None:
+            result = ctx().global_state.archetypes.get(owner)
+            if result is None:
+                raise RuntimeError("Archetype is not registered")
+            return result
+        else:
+            return instance._info.archetype_id
+
+    def __set__(self, instance, value):
+        raise AttributeError("Archetype id is read-only and cannot be set")
+
+
+class _KeyDescriptor(SonolusDescriptor):
+    def __init__(self, value: int | float):
+        self.value = value
+
+    def __get__(self, instance, owner):
+        if instance is not None and ctx():
+            return ctx().global_state.keys[instance.id]
+        else:
+            return self.value
+
+    def __set__(self, instance, value):
+        raise AttributeError("Archetype key is read-only and cannot be set")
+
+
 def imported(*, name: str | None = None) -> Any:
     """Declare a field as imported.
 
@@ -387,6 +449,28 @@ class _BaseArchetype:
 
     _data_: _ArchetypeData
 
+    id: int = 0
+    """The id of the archetype or entity.
+
+    If accessed on an entity, always returns the runtime archetype id of the entity, even if it doesn't match the type
+    that was used to access it.
+
+    E.g. if an entity of archetype `A` is accessed via [`EntityRef[B]`][sonolus.script.archetype.EntityRef], the id will
+    still be the id of `A`.
+    """
+
+    key: int | float = -1
+    """An optional key for the archetype.
+
+    May be useful to identify an archetype in an inheritance hierarchy without needing to check id.
+
+    If accessed on an entity, always returns the runtime key of the entity, even if it doesn't match the type
+    that was used to access it.
+
+    E.g. if an entity of archetype `A` is accessed via [`EntityRef[B]`][sonolus.script.archetype.EntityRef], the key
+    will still be the key of `A`.
+    """
+
     name: ClassVar[str | None] = None
     """The name of the archetype.
 
@@ -433,17 +517,7 @@ class _BaseArchetype:
     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) -> int:
-        if not ctx():
-            raise RuntimeError("Archetype id is only available during compilation")
-        result = ctx().global_state.archetypes.get(cls)
-        if result is None:
-            raise RuntimeError("Archetype is not registered")
-        return result
+        return entity_info_at(index).archetype_id == cls.id
 
     @classmethod
     @meta_fn
@@ -465,7 +539,7 @@ class _BaseArchetype:
         cls._init_fields()
         if not ctx():
             raise RuntimeError("Spawn is only allowed within a callback")
-        archetype_id = cls.id()
+        archetype_id = cls.id
         bound = cls._spawn_signature_.bind_partial(**kwargs)
         bound.apply_defaults()
         data = []
@@ -497,7 +571,7 @@ class _BaseArchetype:
         return entries
 
     def __init_subclass__(cls, **kwargs):
-        if cls.__module__ == _BaseArchetype.__module__:
+        if cls.__module__ == _BaseArchetype.__module__ and not getattr(cls, "_is_derived_", False):
             if cls._supported_callbacks_ is None:
                 raise TypeError("Cannot directly subclass Archetype, use the Archetype subclass for your mode")
             cls._default_callbacks_ = {getattr(cls, cb_info.py_name) for cb_info in cls._supported_callbacks_.values()}
@@ -511,6 +585,11 @@ class _BaseArchetype:
                 continue
             cls._callbacks_.append(cb)
         cls._field_init_done = False
+        cls.id = _IdDescriptor()
+        cls._key_ = cls.key
+        cls.key = _KeyDescriptor(cls.key)
+        cls.name = _NameDescriptor(cls.name)
+        cls.is_scored = _IsScoredDescriptor(cls.is_scored)
 
     @classmethod
     def _init_fields(cls):
@@ -521,7 +600,19 @@ class _BaseArchetype:
             if hasattr(mro_entry, "_field_init_done"):
                 mro_entry._init_fields()
         field_specifiers = get_field_specifiers(
-            cls, skip={"name", "is_scored", "_callbacks_", "_field_init_done"}
+            cls,
+            skip={
+                "id",
+                "key",
+                "name",
+                "is_scored",
+                "_key_",
+                "_derived_base_",
+                "_is_derived_",
+                "_default_callbacks_",
+                "_callbacks_",
+                "_field_init_done",
+            },
         ).items()
         if not hasattr(cls, "_imported_fields_"):
             cls._imported_fields_ = {}
@@ -656,6 +747,41 @@ class _BaseArchetype:
     def _post_init_fields(cls):
         pass
 
+    @classmethod
+    def derive[T](cls: type[T], name: str, is_scored: bool, key: int | float | None = None) -> type[T]:
+        """Derive a new archetype class from this archetype.
+
+        Roughly equivalent to returning:
+        ```python
+        class Derived(cls):
+            name = <name>
+            is_scored = <is_scored>
+            key = <key>  # Only set if key is not None
+        ```
+
+        This is used to create a new archetype with the same fields and callbacks, but with a different name and
+        whether it is scored. Compared to manually subclassing, this method also enables faster compilation when
+        the same base archetype has multiple derived archetypes by compiling callbacks only once for the base archetype.
+
+        Args:
+            name: The name of the new archetype.
+            is_scored: Whether the new archetype is scored.
+            key: A key that can be accessed via the `key` property of the new archetype.
+
+        Returns:
+            A new archetype class with the same fields and callbacks as this archetype, but with the given name and
+            whether it is scored.
+        """
+        if getattr(cls, "_is_derived_", False):
+            raise RuntimeError("Cannot derive from a derived archetype")
+        cls_dict = {"name": name, "is_scored": is_scored, "_is_derived_": True, "_derived_base_": cls}
+        if key is not None:
+            if not isinstance(key, (int, float)):
+                raise TypeError(f"Key must be an int or float, got {type(key)}")
+            cls_dict["key"] = key
+        new_cls = type(name, (cls,), cls_dict)
+        return new_cls
+
 
 class PlayArchetype(_BaseArchetype):
     """Base class for play mode archetypes.
@@ -807,7 +933,7 @@ class PlayArchetype(_BaseArchetype):
             raise RuntimeError("Calling life is only allowed within a callback")
         match self._data_:
             case _ArchetypeSelfData() | _ArchetypeReferenceData():
-                return _deref(ctx().blocks.ArchetypeLife, self.id() * ArchetypeLife._size_(), ArchetypeLife)
+                return _deref(ctx().blocks.ArchetypeLife, self.id * ArchetypeLife._size_(), ArchetypeLife)
             case _:
                 raise RuntimeError("Life is not available in level data")
 
@@ -826,6 +952,26 @@ class PlayArchetype(_BaseArchetype):
             case _:
                 raise RuntimeError("Result is only accessible from the entity itself")
 
+    @classmethod
+    def update_life(
+        cls,
+        perfect_increment: int | None = None,
+        great_increment: int | None = None,
+        good_increment: int | None = None,
+        miss_increment: int | None = None,
+    ):
+        """Update the life of this archetype.
+
+        Values default to 0.
+
+        Args:
+            perfect_increment: The increment for perfect life.
+            great_increment: The increment for great life.
+            good_increment: The increment for good life.
+            miss_increment: The increment for miss life.
+        """
+        archetype_life_of(cls).update(perfect_increment, great_increment, good_increment, miss_increment)
+
 
 class WatchArchetype(_BaseArchetype):
     """Base class for watch mode archetypes.
@@ -920,7 +1066,7 @@ class WatchArchetype(_BaseArchetype):
             raise RuntimeError("Calling life is only allowed within a callback")
         match self._data_:
             case _ArchetypeSelfData() | _ArchetypeReferenceData():
-                return _deref(ctx().blocks.ArchetypeLife, self.id() * ArchetypeLife._size_(), ArchetypeLife)
+                return _deref(ctx().blocks.ArchetypeLife, self.id * ArchetypeLife._size_(), ArchetypeLife)
             case _:
                 raise RuntimeError("Life is not available in level data")
 
@@ -944,6 +1090,26 @@ class WatchArchetype(_BaseArchetype):
         if cls._exported_fields_:
             raise RuntimeError("Watch archetypes cannot have exported fields")
 
+    @classmethod
+    def update_life(
+        cls,
+        perfect_increment: int | None = None,
+        great_increment: int | None = None,
+        good_increment: int | None = None,
+        miss_increment: int | None = None,
+    ):
+        """Update the life of this archetype.
+
+        Values default to 0.
+
+        Args:
+            perfect_increment: The increment for perfect life.
+            great_increment: The increment for great life.
+            good_increment: The increment for good life.
+            miss_increment: The increment for miss life.
+        """
+        archetype_life_of(cls).update(perfect_increment, great_increment, good_increment, miss_increment)
+
 
 class PreviewArchetype(_BaseArchetype):
     """Base class for preview mode archetypes.
@@ -1032,7 +1198,7 @@ def archetype_life_of(archetype: type[_BaseArchetype] | _BaseArchetype) -> Arche
         raise RuntimeError("Calling archetype_life_of is only allowed within a callback")
     match ctx().global_state.mode:
         case Mode.PLAY | Mode.WATCH:
-            return _deref(ctx().blocks.ArchetypeLife, archetype.id() * ArchetypeLife._size_(), ArchetypeLife)
+            return _deref(ctx().blocks.ArchetypeLife, archetype.id * ArchetypeLife._size_(), ArchetypeLife)
         case _:
             raise RuntimeError(f"Archetype life is not available in mode '{ctx().global_state.mode}'")
 
@@ -1184,3 +1350,7 @@ class StandardArchetypeName(StrEnum):
 
     TIMESCALE_CHANGE = "#TIMESCALE_CHANGE"
     """Timescale change marker"""
+
+
+type AnyArchetype = PlayArchetype | WatchArchetype | PreviewArchetype
+"""Union of all archetype types."""

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/sonolus/script/internal/context.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
 from threading import Lock
-from typing import Any, Self
+from typing import Any, Literal, Self
 
 from sonolus.backend.blocks import BlockData, PlayBlock
 from sonolus.backend.ir import IRConst, IRExpr, IRStmt
@@ -41,6 +41,7 @@ debug_var = ContextVar("debug_var", default=_disabled_debug_config)
 
 class GlobalContextState:
     archetypes: dict[type, int]
+    keys: Sequence[int] | None
     rom: ReadOnlyMemory
     const_mappings: dict[Any, int]
     environment_mappings: dict[_GlobalInfo, int]
@@ -49,7 +50,14 @@ class GlobalContextState:
     lock: Lock
 
     def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None, rom: ReadOnlyMemory | None = None):
+        from sonolus.script.array import Array
+
         self.archetypes = archetypes or {}
+        self.keys = (
+            Array(*((getattr(a, "_key_", -1)) for a in sorted(self.archetypes, key=lambda a: archetypes[a])))
+            if archetypes
+            else Array[int, Literal[0]]()
+        )
         self.rom = ReadOnlyMemory() if rom is None else rom
         self.const_mappings = {}
         self.environment_mappings = {}

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/sonolus/script/internal/introspection.py

@@ -28,4 +28,7 @@ def get_field_specifiers(
             and not isinstance(value, property)
         ):
             raise ValueError(f"Missing annotation for {cls.__name__}.{key}")
+    for skipped_key in skip:
+        if skipped_key in results:
+            del results[skipped_key]
     return results

{sonolus_py-0.5.0 → sonolus_py-0.5.2}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "sonolus-py"
-version = "0.5.0"
+version = "0.5.2"
 source = { editable = "." }
 
 [package.dev-dependencies]