sonolus.py 0.12.0__tar.gz → 0.12.1__tar.gz

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.12.0
+Version: 0.12.1
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/doc_stubs/builtins.pyi

@@ -113,6 +113,38 @@ def float(x: builtins.int | builtins.float) -> builtins.float:
     """
     ...
 
+@overload
+def getattr(obj: object, name: builtins.str) -> Any: ...
+@overload
+def getattr[T](obj: object, name: builtins.str, default: T) -> Any | T: ...
+def getattr(obj: object, name: builtins.str, default: Any = ...) -> Any:
+    """Get a named attribute from an object.
+
+    Args:
+        obj: The object to get the attribute from.
+        name: The name of the attribute.
+        default: The value to return if the attribute does not exist.
+
+    Returns:
+        The value of the attribute, or default if it does not exist.
+    """
+    ...
+
+def hasattr(obj: object, name: builtins.str) -> builtins.bool:
+    """Check if an object has a named attribute.
+
+    Can result in a compile-time error if an unsupported property is checked,
+    since later trying to access it would also fail.
+
+    Args:
+        obj: The object to check.
+        name: The name of the attribute.
+
+    Returns:
+        True if the object has the attribute, False otherwise.
+    """
+    ...
+
 def int(x: builtins.int | builtins.float) -> builtins.int:
     """Convert a number to an integer.
 
@@ -277,6 +309,30 @@ def round(number: builtins.int | builtins.float, ndigits: builtins.int = ...) ->
     """
     ...
 
+def setattr(obj: object, name: builtins.str, value: Any) -> None:
+    """Set a named attribute on an object.
+
+    Args:
+        obj: The object to set the attribute on.
+        name: The name of the attribute.
+        value: The value to set.
+
+    Returns:
+        None.
+    """
+    ...
+
+def super(cls: type = ..., instance: Any = ...) -> Any:
+    """Return a proxy object that delegates method calls to a parent or sibling class.
+
+    Args:
+        cls: The class to delegate.
+        instance: The instance to delegate to.
+    Returns:
+        A proxy object that can be used to call methods from the parent or sibling class.
+    """
+    ...
+
 def type(obj: object) -> builtins.type:
     """Return the type of an object.
 
@@ -298,13 +354,3 @@ def zip[T](*iterables: Iterable[T]) -> Iterator[tuple[T, ...]]:
         An iterator of aggregated tuples.
     """
     ...
-
-def super(cls: type = ..., instance: Any = ...) -> Any:
-    """Return a proxy object that delegates method calls to a parent or sibling class.
-
-    Args:
-        cls: The class to delegate
-        instance: The instance to delegate to.
-    Returns:
-        A proxy object that can be used to call methods from the parent or sibling class.
-    """

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/docs/changelog/index.md

@@ -1,3 +1,7 @@
+### 0.12.1
+
+- Added support for the `getattr()`, `setattr()`, `hasattr()`, and `sum()` built-in functions
+
 ### 0.12.0
 
 - Improved support for mixin classes in archetypes, including support for callbacks and memory fields within mixins

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/docs/concepts/builtins.md

@@ -8,6 +8,8 @@ The supported functions and parameters are listed below.
 - `enumerate(iterable, start=0)`
 - `filter(function, iterable)`
 - `float(x)` (for a num argument)
+- `getattr(object, name[, default])`
+- `hasattr(object, name)`
 - `int(x)` (for a num argument)
 - `isinstance(object, classinfo)`
 - `issubclass(class, classinfo)`
@@ -17,10 +19,11 @@ The supported functions and parameters are listed below.
 - `max(iterable, *, default=..., key=None)`, `max(arg1, arg2, *args, key=None)`
 - `min(iterable, *, default=..., key=None)`, `min(arg1, arg2, *args, key=None)`
 - `next(iterator)`
-- `sum(iterable, start=0)`
 - `range(stop)`, `range(start, stop[, step])`
 - `reversed(seq)`
 - `round(number[, ndigits])`
+- `setattr(object, name, value)`
+- `sum(iterable, start=0)`
 - `super(type[, object-or-type])`
 - `zip(*iterables)`
 

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/pyproject.toml

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

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/sonolus/backend/visitor.py

@@ -1308,6 +1308,7 @@ class Visitor(ast.NodeVisitor):
         raise NotImplementedError(f"Unsupported syntax: {type(node).__name__}")
 
     def handle_getattr(self, node: ast.stmt | ast.expr, target: Value, key: str) -> Value:
+        # If this is changed, remember to update the getattr impl too
         with self.reporting_errors_at_node(node):
             if isinstance(target, ConstantValue):
                 # Unwrap so we can access fields
@@ -1328,6 +1329,7 @@ class Visitor(ast.NodeVisitor):
                     raise TypeError(f"Unsupported field or descriptor {key}")
 
     def handle_setattr(self, node: ast.stmt | ast.expr, target: Value, key: str, value: Value):
+        # If this is changed, remember to update the setattr impl too
         with self.reporting_errors_at_node(node):
             if target._is_py_():
                 target = target._as_py_()

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/sonolus/script/archetype.py

@@ -509,7 +509,7 @@ class _BaseArchetype:
         Args:
             index: The index of the entity to reference.
             check: If true, raises an error if the entity at the index is not of this archetype or of a subclass of
-            this archetype. If false, no validation is performed.
+                   this archetype. If false, no validation is performed.
 
         Returns:
             The entity at the given index.
@@ -528,7 +528,7 @@ class _BaseArchetype:
         Args:
             index: The index of the entity to check.
             strict: If true, only returns true if the entity is exactly of this archetype. If false, also returns true
-            if the entity is of a subclass of this archetype.
+                    if the entity is of a subclass of this archetype.
 
         Returns:
             Whether the entity at the given index is of this archetype.
@@ -1349,7 +1349,7 @@ class EntityRef[A: _BaseArchetype](Record):
 
         Args:
             check: If true, raises an error if the referenced entity is not of this archetype or of a subclass of
-            this archetype. If false, no validation is performed.
+                   this archetype. If false, no validation is performed.
 
         Returns:
             The entity this reference points to.
@@ -1370,7 +1370,7 @@ class EntityRef[A: _BaseArchetype](Record):
 
         Args:
             strict: If true, only returns true if the entity is exactly of this archetype. If false, also returns true
-            if the entity is of a subclass of this archetype.
+                    if the entity is of a subclass of this archetype.
 
         Returns:
             Whether the entity at the given index is of this archetype.

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/sonolus/script/internal/builtin_impls.py

@@ -1,4 +1,5 @@
-from typing import Never, assert_never
+from types import FunctionType
+from typing import Any, Never, assert_never
 
 from sonolus.backend.ops import Op
 from sonolus.script.array import Array
@@ -389,6 +390,78 @@ def _super(*args):
     return super(*(arg._as_py_() if arg._is_py_() else arg for arg in args))
 
 
+@meta_fn
+def _hasattr(obj: Any, name: str) -> bool:
+    from sonolus.script.internal.constant import ConstantValue
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if isinstance(obj, ConstantValue):
+        # Unwrap so we can access fields
+        obj = obj._as_py_()
+    descriptor = None
+    for cls in type.mro(type(obj)):
+        descriptor = cls.__dict__.get(name, None)
+        if descriptor is not None:
+            break
+    # We want to mirror what getattr supports and fail fast if a future getattr would fail.
+    match descriptor:
+        case None:
+            return hasattr(obj, name)
+        case property() | SonolusDescriptor() | FunctionType() | classmethod() | staticmethod():
+            return True
+        case non_descriptor if not hasattr(non_descriptor, "__get__"):
+            return True
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
+@meta_fn
+def _getattr(obj: Any, name: str, default=_empty) -> Any:
+    from sonolus.backend.visitor import compile_and_call
+    from sonolus.script.internal.constant import ConstantValue
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if isinstance(obj, ConstantValue):
+        # Unwrap so we can access fields
+        obj = obj._as_py_()
+    descriptor = None
+    for cls in type.mro(type(obj)):
+        descriptor = cls.__dict__.get(name, None)
+        if descriptor is not None:
+            break
+    match descriptor:
+        case property(fget=getter):
+            return compile_and_call(getter, obj)
+        case SonolusDescriptor() | FunctionType() | classmethod() | staticmethod() | None:
+            return validate_value(getattr(obj, name) if default is _empty else getattr(obj, name, default))
+        case non_descriptor if not hasattr(non_descriptor, "__get__"):
+            return validate_value(getattr(obj, name) if default is _empty else getattr(obj, name, default))
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
+@meta_fn
+def _setattr(obj: Any, name: str, value: Any):
+    from sonolus.backend.visitor import compile_and_call
+    from sonolus.script.internal.descriptor import SonolusDescriptor
+
+    name = validate_value(name)._as_py_()
+    if obj._is_py_():
+        obj = obj._as_py_()
+    descriptor = getattr(type(obj), name, None)
+    match descriptor:
+        case property(fset=setter):
+            if setter is None:
+                raise AttributeError(f"Cannot set attribute {name} because property has no setter")
+            compile_and_call(setter, obj, value)
+        case SonolusDescriptor():
+            setattr(obj, name, value)
+        case _:
+            raise TypeError(f"Unsupported field or descriptor {name}")
+
+
 class _Type(Record):
     @meta_fn
     def __call__(self, value, /):
@@ -412,12 +485,13 @@ BUILTIN_IMPLS = {
     id(abs): _abs,
     id(all): _all,
     id(any): _any,
-    id(sum): _sum,
     id(bool): _bool,
     id(callable): _callable,
     id(enumerate): _enumerate,
     id(filter): _filter,
     id(float): _float,
+    id(getattr): _getattr,
+    id(hasattr): _hasattr,
     id(int): _int,
     id(isinstance): _isinstance,
     id(iter): _iter,
@@ -428,6 +502,8 @@ BUILTIN_IMPLS = {
     id(next): _next,
     id(range): Range,
     id(reversed): _reversed,
+    id(setattr): _setattr,
+    id(sum): _sum,
     id(super): _super,
     id(type): _type,
     id(zip): _zip,

sonolus_py-0.12.1/tests/script/test_reflection.py

@@ -0,0 +1,227 @@
+import pytest
+
+from sonolus.script.array import Array
+from sonolus.script.debug import debug_log
+from sonolus.script.internal.error import CompilationError
+from sonolus.script.record import Record
+from tests.script.conftest import run_and_validate, run_compiled
+
+
+class UnsupportedDescriptor:
+    def __get__(self, instance, owner):
+        return -1
+
+    def __set__(self, instance, value):
+        pass
+
+
+class MyBox[T](Record):
+    value: T
+
+    @classmethod
+    def my_classmethod(cls):
+        return 123
+
+    def my_method(self):
+        return 456
+
+    @property
+    def my_property(self):
+        return 789
+
+    @my_property.setter
+    def my_property(self, value):
+        debug_log(value)
+
+
+MyBox.unsupported_descriptor = UnsupportedDescriptor()
+
+
+def test_hasattr_record_field():
+    def fn():
+        return hasattr(MyBox(1), "value")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_record_method():
+    def fn():
+        return hasattr(MyBox(1), "my_method")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_record_classmethod():
+    def fn():
+        return hasattr(MyBox(1), "my_classmethod")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_record_property():
+    def fn():
+        return hasattr(MyBox(1), "my_property")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_record_not_present():
+    def fn():
+        return hasattr(MyBox(1), "does_not_exist")
+
+    assert run_and_validate(fn) == 0
+
+
+def test_hasattr_record_unsupported():
+    def fn():
+        return hasattr(MyBox(1), "unsupported_descriptor")
+
+    with pytest.raises(CompilationError, match="Unsupported field"):
+        run_compiled(fn)
+
+
+def test_hasattr_array_method():
+    def fn():
+        return hasattr(Array(1), "__getitem__")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_array_not_present():
+    def fn():
+        return hasattr(Array(1), "does_not_exist")
+
+    assert run_and_validate(fn) == 0
+
+
+def test_hasattr_type_classmethod():
+    def fn():
+        return hasattr(MyBox, "my_classmethod")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_type_method():
+    def fn():
+        return hasattr(MyBox, "my_method")
+
+    assert run_and_validate(fn) == 1
+
+
+def test_hasattr_type_not_present():
+    def fn():
+        return hasattr(MyBox, "does_not_exist")
+
+    assert run_and_validate(fn) == 0
+
+
+def test_getattr_record_field():
+    def fn():
+        box = MyBox(100)
+        return box.value
+
+    assert run_and_validate(fn) == 100
+
+
+def test_getattr_record_method():
+    def fn():
+        box = MyBox(100)
+        method = box.my_method
+        return method()
+
+    assert run_and_validate(fn) == 456
+
+
+def test_getattr_record_classmethod():
+    def fn():
+        method = MyBox.my_classmethod
+        return method()
+
+    assert run_and_validate(fn) == 123
+
+
+def test_getattr_record_property():
+    def fn():
+        box = MyBox(100)
+        return box.my_property
+
+    assert run_and_validate(fn) == 789
+
+
+def test_getattr_record_unsupported():
+    def fn():
+        box = MyBox(100)
+        return box.unsupported_descriptor
+
+    with pytest.raises(CompilationError, match="Unsupported field"):
+        run_compiled(fn)
+
+
+def test_getattr_array_method():
+    def fn():
+        arr = Array(10, 20, 30)
+        method = arr.__getitem__
+        return method(1)
+
+    assert run_and_validate(fn) == 20
+
+
+def test_getattr_type_classmethod():
+    def fn():
+        method = MyBox.my_classmethod
+        return method()
+
+    assert run_and_validate(fn) == 123
+
+
+def test_getattr_type_method():
+    def fn():
+        method = MyBox.my_method
+        return method(MyBox(0))
+
+    assert run_and_validate(fn) == 456
+
+
+def test_getattr_type_not_present():
+    def fn():
+        return MyBox.does_not_exist
+
+    with pytest.raises(CompilationError, match="has no attribute 'does_not_exist'"):
+        run_compiled(fn)
+
+
+def test_setattr_record_field():
+    def fn():
+        box = MyBox(0)
+        box.value = 100
+        return box.value
+
+    assert run_and_validate(fn) == 100
+
+
+def test_setattr_record_property():
+    def fn():
+        box = MyBox(0)
+        box.my_property = 100
+        return 1
+
+    assert run_and_validate(fn) == 1
+
+
+def test_setattr_record_unsupported():
+    def fn():
+        box = MyBox(0)
+        box.unsupported_descriptor = 100
+        return 1
+
+    with pytest.raises(CompilationError, match="Unsupported field"):
+        run_compiled(fn)
+
+
+def test_setattr_type_not_supported():
+    def fn():
+        MyBox.my_classmethod = 100
+        return 1
+
+    with pytest.raises(CompilationError, match="Unsupported field"):
+        run_compiled(fn)

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/tests/script/test_var_array.py

@@ -734,6 +734,20 @@ def test_all_empty():
     assert run_and_validate(fn)
 
 
+@given(lists)
+def test_sum(values_list):
+    values = Array(*values_list)
+    value_count = len(values_list)
+    expected_sum = sum(values_list)
+
+    def fn():
+        va = VarArray[int, value_count].new()
+        va.extend(values)
+        return sum(va)
+
+    assert run_and_validate(fn) == expected_sum
+
+
 def test_var_array_truthiness_empty():
     def fn():
         x = VarArray[int, 1].new()

{sonolus_py-0.12.0 → sonolus_py-0.12.1}/uv.lock

@@ -727,7 +727,7 @@ wheels = [
 
 [[package]]
 name = "sonolus-py"
-version = "0.12.0"
+version = "0.12.1"
 source = { editable = "." }
 
 [package.dev-dependencies]