sonolus.py 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

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/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/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/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/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.dist-info → sonolus_py-0.5.2.dist-info}/METADATA

@@ -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.dist-info → sonolus_py-0.5.2.dist-info}/RECORD

@@ -11,7 +11,7 @@ sonolus/backend/node.py,sha256=eEzPP14jzWJp2xrZCAaPlNtokxdoqg0bSM7xQiwx1j8,1254
 sonolus/backend/ops.py,sha256=5weB_vIxbkwCSJuzYZyKUk7vVXsSIEDJYRlvE-2ke8A,10572
 sonolus/backend/place.py,sha256=7qwV732hZ4WP-9GNN8FQSEKssPJZELip1wLXTWfop7Y,4717
 sonolus/backend/utils.py,sha256=DDgYUVHh4h_eSY65v2KcxUaLSBYGYS6oHar5gTdV7QU,2356
-sonolus/backend/visitor.py,sha256=UAdp3Lg9kFVcFmBfn6rqpE9xM_CWBWlsB2o6OJiFqxQ,63193
+sonolus/backend/visitor.py,sha256=Dz_3w3gvmJraNC2fMMlkYthEmT0AkZfHGFsrracELuo,63121
 sonolus/backend/optimize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/backend/optimize/allocate.py,sha256=CuumoMphkpQlGRNeKLHT4FBGE0XVj5pwhfNdrqiLFSs,7535
 sonolus/backend/optimize/constant_evaluation.py,sha256=U--9moGsXFzrgweWWwHIiEuuMzwetd1IOjjtrCscoNM,21450
@@ -28,13 +28,13 @@ sonolus/backend/optimize/ssa.py,sha256=raQO0furQQRPYb8iIBKfNrJlj-_5wqtI4EWNfLZ8Q
 sonolus/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/build/cli.py,sha256=-_lTN8zT7nQB2lySM8itAEPVutcEQI-TJ13BcPIfGb4,10113
 sonolus/build/collection.py,sha256=kOVnpQC_KHAsyTM4nAplSh6QE16CgO-H6PP1GItWm78,12187
-sonolus/build/compile.py,sha256=B7w6Uqa4HlZPNklNhhjJoq9ncXMVXLCYabGLxtxWGV4,6521
+sonolus/build/compile.py,sha256=Yex-ZbSZmv9ujyAOVaMcfq-0NnZzFIqtmNYYaplF4Uc,6761
 sonolus/build/engine.py,sha256=zUl0KfRygqNhIM8BABNJkKG-0zXFwcYwck-5hJy59yk,13338
 sonolus/build/level.py,sha256=yXsQtnabkJK0vuVmZ_Wr1jx37jFLgInCS7lTlXjkv9Q,706
 sonolus/build/node.py,sha256=gnX71RYDUOK_gYMpinQi-bLWO4csqcfiG5gFmhxzSec,1330
 sonolus/build/project.py,sha256=mv2OuzgIDG-E9G4SIRiUDL5XiPCd1i81wVl1p7itFHA,6329
 sonolus/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonolus/script/archetype.py,sha256=HJeKJ_vj7xUYaCAmNdGYO45rhFMSLMwOLyvpKjulfVY,42418
+sonolus/script/archetype.py,sha256=-i7TQMI0_ztNTwd1bXu39q3wSaa70kRlPoNZFUHNbHY,48534
 sonolus/script/array.py,sha256=9uOUHZIDMyMT9q3APcXJWXWt97yG-AZoRlxwrvSY6SU,12367
 sonolus/script/array_like.py,sha256=jFOfXkniTLrIK4ER6HO_tUyKn_TvwjyM4B3SDd9cUS8,9678
 sonolus/script/bucket.py,sha256=VxsSgHidYhY_Y5UXpBZY_tzjQff0TRgNJVj4Al8LVec,7654
@@ -71,13 +71,13 @@ sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtU
 sonolus/script/internal/builtin_impls.py,sha256=POmWRyTQa-9mpQ_jATDYlFWo_n0a65vXAgqitkKYzGY,12870
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
 sonolus/script/internal/constant.py,sha256=3ycbGkDJVUwcrCZ96vLjAoAARgsvaqDM8rJ_YCrLrvo,4289
-sonolus/script/internal/context.py,sha256=qn8xp5BB1C3IaUS8jsSUfkMUJgPzeaIV7K4FY9mHHQo,16903
+sonolus/script/internal/context.py,sha256=JtKyjFlt7t2YwR1qFUGGjzYrE8v0yfsP-7XA196gtaQ,17211
 sonolus/script/internal/descriptor.py,sha256=XRFey-EjiAm_--KsNl-8N0Mi_iyQwlPh68gDp0pKf3E,392
 sonolus/script/internal/dict_impl.py,sha256=alu_wKGSk1kZajNf64qbe7t71shEzD4N5xNIATH8Swo,1885
 sonolus/script/internal/error.py,sha256=ZNnsvQVQAnFKzcvsm6-sste2lo-tP5pPI8sD7XlAZWc,490
 sonolus/script/internal/generic.py,sha256=F0-cCiRNGTaUJvYlpmkiOsU3Xge_XjoBpBwBhH_qS_s,7577
 sonolus/script/internal/impl.py,sha256=alcFJs1yDx9ixEOxg-r_1IvWG2arMSUKSc-Eg9nAHOw,3255
-sonolus/script/internal/introspection.py,sha256=MfdXo3GFHNZT2-vAKuvsE54V-5TOfbg4vU9dBI6sLqo,1032
+sonolus/script/internal/introspection.py,sha256=guL9_NR2D3OJAnNpeFdyYkO_vVXk-3KQr2-y4YielM0,1133
 sonolus/script/internal/math_impls.py,sha256=nHSLgA7Tcx7jY1p07mYBCeSRmVx713bwdNayCIcaXSE,2652
 sonolus/script/internal/native.py,sha256=DQxmzxgLG_UsLpXhIEtBdO7eIeDFprU78UBDC4OZzw0,1597
 sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z50pI,1695
@@ -86,8 +86,8 @@ sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDw
 sonolus/script/internal/transient.py,sha256=y2AWABqF1aoaP6H4_2u4MMpNioC4OsZQCtPyNI0txqo,1634
 sonolus/script/internal/tuple_impl.py,sha256=DPNdmmRmupU8Ah4_XKq6-PdT336l4nt15_uCJKQGkkk,3587
 sonolus/script/internal/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.5.0.dist-info/METADATA,sha256=UCeZWEVfiGWGob4XES8cE9MgkmE44kD_6PJ-dVEQypI,302
-sonolus_py-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.5.0.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.5.0.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.5.0.dist-info/RECORD,,
+sonolus_py-0.5.2.dist-info/METADATA,sha256=95TnAW9JgpYR6UNXhEm3rZbHCqKWkUY6cGr93eYo4Wo,302
+sonolus_py-0.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.5.2.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.5.2.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.5.2.dist-info/RECORD,,