sonolus.py 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

sonolus/script/internal/builtin_impls.py

@@ -1,144 +1,144 @@
-from collections.abc import Iterable
-from typing import overload
-
-from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn, validate_value
-from sonolus.script.iterator import ArrayLike, Enumerator, SonolusIterator
-from sonolus.script.math import MATH_BUILTIN_IMPLS
-from sonolus.script.num import is_num
-from sonolus.script.range import Range
-
-
-@meta_fn
-def _isinstance(value, type_):
-    value = validate_value(value)
-    type_ = validate_value(type_)._as_py_()
-    return validate_value(isinstance(value, type_))
-
-
-@meta_fn
-def _len(value):
-    from sonolus.backend.visitor import compile_and_call
-
-    value = validate_value(value)
-    if not hasattr(value, "__len__"):
-        raise TypeError(f"object of type '{type(value).__name__}' has no len()")
-    return compile_and_call(value.__len__)
-
-
-@meta_fn
-def _enumerate(iterable, start=0):
-    from sonolus.backend.visitor import compile_and_call
-
-    iterable = validate_value(iterable)
-    if not hasattr(iterable, "__iter__"):
-        raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
-    if isinstance(iterable, ArrayLike):
-        return compile_and_call(iterable.enumerate, start)
-    else:
-        iterator = compile_and_call(iterable.__iter__)
-        if not isinstance(iterator, SonolusIterator):
-            raise TypeError("Only subclasses of SonolusIterator are supported as iterators")
-        return Enumerator(0, start, iterator)
-
-
-@meta_fn
-def _abs(value):
-    from sonolus.backend.visitor import compile_and_call
-
-    value = validate_value(value)
-    if not hasattr(value, "__abs__"):
-        raise TypeError(f"bad operand type for abs(): '{type(value).__name__}'")
-    return compile_and_call(value.__abs__)
-
-
-@overload
-def _max[T](iterable: Iterable[T]) -> T: ...
-
-
-@overload
-def _max[T](a: T, b: T, *args: T) -> T: ...
-
-
-@meta_fn
-def _max(*args):
-    from sonolus.backend.visitor import compile_and_call
-
-    args = tuple(validate_value(arg) for arg in args)
-    if len(args) == 0:
-        raise ValueError("Expected at least one argument to max")
-    elif len(args) == 1:
-        (iterable,) = args
-        if isinstance(iterable, ArrayLike):
-            return iterable.max()
-        else:
-            raise TypeError(f"Unsupported type: {type(iterable)} for max")
-    else:
-        if not all(is_num(arg) for arg in args):
-            raise TypeError("Arguments to max must be numbers")
-        if ctx():
-            result = compile_and_call(_max2, args[0], args[1])
-            for arg in args[2:]:
-                result = compile_and_call(_max2, result, arg)
-            return result
-        else:
-            return max(arg._as_py_() for arg in args)
-
-
-def _max2(a, b):
-    if a > b:
-        return a
-    else:
-        return b
-
-
-@overload
-def _min[T](iterable: Iterable[T]) -> T: ...
-
-
-@overload
-def _min[T](a: T, b: T, *args: T) -> T: ...
-
-
-@meta_fn
-def _min(*args):
-    from sonolus.backend.visitor import compile_and_call
-
-    args = tuple(validate_value(arg) for arg in args)
-    if len(args) == 0:
-        raise ValueError("Expected at least one argument to min")
-    elif len(args) == 1:
-        (iterable,) = args
-        if isinstance(iterable, ArrayLike):
-            return iterable.min()
-        else:
-            raise TypeError(f"Unsupported type: {type(iterable)} for min")
-    else:
-        if not all(is_num(arg) for arg in args):
-            raise TypeError("Arguments to min must be numbers")
-        if ctx():
-            result = compile_and_call(_min2, args[0], args[1])
-            for arg in args[2:]:
-                result = compile_and_call(_min2, result, arg)
-            return result
-        else:
-            return min(arg._as_py_() for arg in args)
-
-
-def _min2(a, b):
-    if a < b:
-        return a
-    else:
-        return b
-
-
-BUILTIN_IMPLS = {
-    id(isinstance): _isinstance,
-    id(len): _len,
-    id(enumerate): _enumerate,
-    id(abs): _abs,
-    id(max): _max,
-    id(min): _min,
-    id(range): Range,
-    **MATH_BUILTIN_IMPLS,
-}
+from collections.abc import Iterable
+from typing import overload
+
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.iterator import ArrayLike, Enumerator, SonolusIterator
+from sonolus.script.math import MATH_BUILTIN_IMPLS
+from sonolus.script.num import is_num
+from sonolus.script.range import Range
+
+
+@meta_fn
+def _isinstance(value, type_):
+    value = validate_value(value)
+    type_ = validate_value(type_)._as_py_()
+    return validate_value(isinstance(value, type_))
+
+
+@meta_fn
+def _len(value):
+    from sonolus.backend.visitor import compile_and_call
+
+    value = validate_value(value)
+    if not hasattr(value, "__len__"):
+        raise TypeError(f"object of type '{type(value).__name__}' has no len()")
+    return compile_and_call(value.__len__)
+
+
+@meta_fn
+def _enumerate(iterable, start=0):
+    from sonolus.backend.visitor import compile_and_call
+
+    iterable = validate_value(iterable)
+    if not hasattr(iterable, "__iter__"):
+        raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
+    if isinstance(iterable, ArrayLike):
+        return compile_and_call(iterable.enumerate, start)
+    else:
+        iterator = compile_and_call(iterable.__iter__)
+        if not isinstance(iterator, SonolusIterator):
+            raise TypeError("Only subclasses of SonolusIterator are supported as iterators")
+        return Enumerator(0, start, iterator)
+
+
+@meta_fn
+def _abs(value):
+    from sonolus.backend.visitor import compile_and_call
+
+    value = validate_value(value)
+    if not hasattr(value, "__abs__"):
+        raise TypeError(f"bad operand type for abs(): '{type(value).__name__}'")
+    return compile_and_call(value.__abs__)
+
+
+@overload
+def _max[T](iterable: Iterable[T]) -> T: ...
+
+
+@overload
+def _max[T](a: T, b: T, *args: T) -> T: ...
+
+
+@meta_fn
+def _max(*args):
+    from sonolus.backend.visitor import compile_and_call
+
+    args = tuple(validate_value(arg) for arg in args)
+    if len(args) == 0:
+        raise ValueError("Expected at least one argument to max")
+    elif len(args) == 1:
+        (iterable,) = args
+        if isinstance(iterable, ArrayLike):
+            return iterable.max()
+        else:
+            raise TypeError(f"Unsupported type: {type(iterable)} for max")
+    else:
+        if not all(is_num(arg) for arg in args):
+            raise TypeError("Arguments to max must be numbers")
+        if ctx():
+            result = compile_and_call(_max2, args[0], args[1])
+            for arg in args[2:]:
+                result = compile_and_call(_max2, result, arg)
+            return result
+        else:
+            return max(arg._as_py_() for arg in args)
+
+
+def _max2(a, b):
+    if a > b:
+        return a
+    else:
+        return b
+
+
+@overload
+def _min[T](iterable: Iterable[T]) -> T: ...
+
+
+@overload
+def _min[T](a: T, b: T, *args: T) -> T: ...
+
+
+@meta_fn
+def _min(*args):
+    from sonolus.backend.visitor import compile_and_call
+
+    args = tuple(validate_value(arg) for arg in args)
+    if len(args) == 0:
+        raise ValueError("Expected at least one argument to min")
+    elif len(args) == 1:
+        (iterable,) = args
+        if isinstance(iterable, ArrayLike):
+            return iterable.min()
+        else:
+            raise TypeError(f"Unsupported type: {type(iterable)} for min")
+    else:
+        if not all(is_num(arg) for arg in args):
+            raise TypeError("Arguments to min must be numbers")
+        if ctx():
+            result = compile_and_call(_min2, args[0], args[1])
+            for arg in args[2:]:
+                result = compile_and_call(_min2, result, arg)
+            return result
+        else:
+            return min(arg._as_py_() for arg in args)
+
+
+def _min2(a, b):
+    if a < b:
+        return a
+    else:
+        return b
+
+
+BUILTIN_IMPLS = {
+    id(isinstance): _isinstance,
+    id(len): _len,
+    id(enumerate): _enumerate,
+    id(abs): _abs,
+    id(max): _max,
+    id(min): _min,
+    id(range): Range,
+    **MATH_BUILTIN_IMPLS,
+}

sonolus/script/internal/context.py

@@ -164,7 +164,8 @@ class Context:
                 header.scope.set_value(name, target_value)
                 header.loop_variables[name] = target_value
             else:
-                header.scope.set_binding(name, ConflictBinding())
+                header.scope.set_value(name, value)
+                header.loop_variables[name] = value
         return header
 
     def branch_to_loop_header(self, header: Self):
@@ -174,9 +175,16 @@ class Context:
         self.outgoing[None] = header
         for name, target_value in header.loop_variables.items():
             with using_ctx(self):
-                value = self.scope.get_value(name)
-                value = type(target_value)._accept_(value)
-                target_value._set_(value)
+                if type(target_value)._is_value_type_():
+                    value = self.scope.get_value(name)
+                    value = type(target_value)._accept_(value)
+                    target_value._set_(value)
+                else:
+                    value = self.scope.get_value(name)
+                    if target_value is not value:
+                        raise RuntimeError(
+                            f"Variable '{name}' may have conflicting definitions between loop iterations"
+                        )
 
     def map_constant(self, value: Any) -> int:
         if value not in self.const_mappings:

sonolus/script/internal/descriptor.py

@@ -1,17 +1,17 @@
-from abc import abstractmethod
-
-
-class SonolusDescriptor:
-    """Base class for Sonolus descriptors.
-
-    The compiler checks if a descriptor is an instance of a subclass of this class,
-    so it knows that it's a supported descriptor.
-    """
-
-    @abstractmethod
-    def __get__(self, instance, owner):
-        pass
-
-    @abstractmethod
-    def __set__(self, instance, value):
-        pass
+from abc import abstractmethod
+
+
+class SonolusDescriptor:
+    """Base class for Sonolus descriptors.
+
+    The compiler checks if a descriptor is an instance of a subclass of this class,
+    so it knows that it's a supported descriptor.
+    """
+
+    @abstractmethod
+    def __get__(self, instance, owner):
+        pass
+
+    @abstractmethod
+    def __set__(self, instance, value):
+        pass

sonolus/script/internal/introspection.py

@@ -1,14 +1,14 @@
-import inspect
-from typing import Annotated
-
-_missing = object()
-
-
-def get_field_specifiers(cls, *, globals=None, locals=None, eval_str=True):  # noqa: A002
-    """Like inspect.get_annotations, but also turns class attributes into Annotated."""
-    results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
-    for key, value in results.items():
-        class_value = getattr(cls, key, _missing)
-        if class_value is not _missing:
-            results[key] = Annotated[value, class_value]
-    return results
+import inspect
+from typing import Annotated
+
+_missing = object()
+
+
+def get_field_specifiers(cls, *, globals=None, locals=None, eval_str=True):  # noqa: A002
+    """Like inspect.get_annotations, but also turns class attributes into Annotated."""
+    results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
+    for key, value in results.items():
+        class_value = getattr(cls, key, _missing)
+        if class_value is not _missing:
+            results[key] = Annotated[value, class_value]
+    return results

sonolus/script/internal/native.py

@@ -1,38 +1,40 @@
-import functools
-import inspect
-from collections.abc import Callable
-
-from sonolus.backend.ir import IRInstr, IRPureInstr, IRSet
-from sonolus.backend.ops import Op
-from sonolus.script.internal.context import ctx
-from sonolus.script.internal.impl import meta_fn, validate_value
-from sonolus.script.num import Num, is_num
-
-
-def native_call(op: Op, *args: Num) -> Num:
-    if not ctx():
-        raise RuntimeError("Unexpected native call")
-    args = tuple(validate_value(arg) for arg in args)
-    if not all(is_num(arg) for arg in args):
-        raise RuntimeError("All arguments must be of type Num")
-    result = ctx().alloc(size=1)
-    ctx().add_statements(IRSet(result, (IRPureInstr if op.pure else IRInstr)(op, [arg.ir() for arg in args])))
-    return Num._from_place_(result)
-
-
-def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    def decorator(fn: Callable[P, Num]) -> Callable[P, Num]:
-        signature = inspect.signature(fn)
-
-        @functools.wraps(fn)
-        @meta_fn
-        def wrapper(*args: Num) -> Num:
-            if len(args) != len(signature.parameters):
-                raise TypeError(f"Expected {len(signature.parameters)} arguments, got {len(args)}")
-            if ctx():
-                return native_call(op, *args)
-            return fn(*args)
-
-        return wrapper
-
-    return decorator
+import functools
+import inspect
+from collections.abc import Callable
+
+from sonolus.backend.ir import IRInstr, IRPureInstr, IRSet
+from sonolus.backend.ops import Op
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.num import Num, is_num
+
+
+def native_call(op: Op, *args: Num) -> Num:
+    if not ctx():
+        raise RuntimeError("Unexpected native call")
+    args = tuple(validate_value(arg) for arg in args)
+    if not all(is_num(arg) for arg in args):
+        raise RuntimeError("All arguments must be of type Num")
+    result = ctx().alloc(size=1)
+    ctx().add_statements(IRSet(result, (IRPureInstr if op.pure else IRInstr)(op, [arg.ir() for arg in args])))
+    return Num._from_place_(result)
+
+
+def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def decorator(fn: Callable[P, Num]) -> Callable[P, Num]:
+        signature = inspect.signature(fn)
+
+        @functools.wraps(fn)
+        @meta_fn
+        def wrapper(*args: Num) -> Num:
+            if len(args) < sum(1 for p in signature.parameters.values() if p.default == inspect.Parameter.empty):
+                raise TypeError(f"Expected {len(signature.parameters)} arguments, got {len(args)}")
+            if ctx():
+                bound_args = signature.bind(*args)
+                bound_args.apply_defaults()
+                return native_call(op, *bound_args.args)
+            return fn(*args)
+
+        return wrapper
+
+    return decorator

sonolus/script/internal/value.py

@@ -66,7 +66,7 @@ class Value:
         raise NotImplementedError
 
     @abstractmethod
-    def _to_list_(self) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
         """Converts this value to a list of floats."""
         raise NotImplementedError
 
@@ -76,9 +76,9 @@ class Value:
         """Returns the keys to a flat representation of this value."""
         raise NotImplementedError
 
-    def _to_flat_dict_(self, prefix: str) -> dict[str, float | BlockPlace]:
+    def _to_flat_dict_(self, prefix: str, level_refs: dict[Any, int] | None = None) -> dict[str, float | BlockPlace]:
         """Converts this value to a flat dictionary."""
-        return dict(zip(self._flat_keys_(prefix), self._to_list_(), strict=False))
+        return dict(zip(self._flat_keys_(prefix), self._to_list_(level_refs), strict=False))
 
     @abstractmethod
     def _get_(self) -> Self: