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

sonolus/script/ui.py

@@ -1,81 +1,102 @@
 from dataclasses import dataclass, field
-from typing import Literal
-
-UiMetric = Literal[
-    "arcade",
-    "arcadePercentage",
-    "accuracy",
-    "accuracyPercentage",
-    "life",
-    "perfect",
-    "perfectPercentage",
-    "greatGoodMiss",
-    "greatGoodMissPercentage",
-    "miss",
-    "missPercentage",
-    "errorHeatmap",
-]
-
-UiJudgmentErrorStyle = Literal[
-    "none",
-    "plus",
-    "minus",
-    "arrowUp",
-    "arrowDown",
-    "arrowLeft",
-    "arrowRight",
-    "triangleUp",
-    "triangleDown",
-    "triangleLeft",
-    "triangleRight",
-]
-
-UiJudgmentErrorPlacement = Literal["both", "left", "right"]
-
-EaseType = Literal[
-    "linear",
-    "none",
-    "inSine",
-    "inQuad",
-    "inCubic",
-    "inQuart",
-    "inQuint",
-    "inExpo",
-    "inCirc",
-    "inBack",
-    "inElastic",
-    "outSine",
-    "outQuad",
-    "outCubic",
-    "outQuart",
-    "outQuint",
-    "outExpo",
-    "outCirc",
-    "outBack",
-    "outElastic",
-    "inOutSine",
-    "inOutQuad",
-    "inOutCubic",
-    "inOutQuart",
-    "inOutQuint",
-    "inOutExpo",
-    "inOutCirc",
-    "inOutBack",
-    "inOutElastic",
-    "outInSine",
-    "outInQuad",
-    "outInCubic",
-    "outInQuart",
-    "outInQuint",
-    "outInExpo",
-    "outInCirc",
-    "outInBack",
-    "outInElastic",
-]
+from enum import StrEnum
+
+
+class UiMetric(StrEnum):
+    """A metric to display on the UI."""
+
+    ARCADE = "arcade"
+    ARCADE_PERCENTAGE = "arcadePercentage"
+    ACCURACY = "accuracy"
+    ACCURACY_PERCENTAGE = "accuracyPercentage"
+    LIFE = "life"
+    PERFECT = "perfect"
+    PERFECT_PERCENTAGE = "perfectPercentage"
+    GREAT_GOOD_MISS = "greatGoodMiss"
+    GREAT_GOOD_MISS_PERCENTAGE = "greatGoodMissPercentage"
+    MISS = "miss"
+    MISS_PERCENTAGE = "missPercentage"
+    ERROR_HEATMAP = "errorHeatmap"
+
+
+class UiJudgmentErrorStyle(StrEnum):
+    """The style of the judgment error."""
+
+    NONE = "none"
+    PLUS = "plus"
+    MINUS = "minus"
+    ARROW_UP = "arrowUp"
+    ARROW_DOWN = "arrowDown"
+    ARROW_LEFT = "arrowLeft"
+    ARROW_RIGHT = "arrowRight"
+    TRIANGLE_UP = "triangleUp"
+    TRIANGLE_DOWN = "triangleDown"
+    TRIANGLE_LEFT = "triangleLeft"
+    TRIANGLE_RIGHT = "triangleRight"
+
+
+class UiJudgmentErrorPlacement(StrEnum):
+    """The placement of the judgment error."""
+
+    BOTH = "both"
+    LEFT = "left"
+    RIGHT = "right"
+
+
+class EaseType(StrEnum):
+    """The easing function to use."""
+
+    LINEAR = "linear"
+    NONE = "none"
+    IN_SINE = "inSine"
+    IN_QUAD = "inQuad"
+    IN_CUBIC = "inCubic"
+    IN_QUART = "inQuart"
+    IN_QUINT = "inQuint"
+    IN_EXPO = "inExpo"
+    IN_CIRC = "inCirc"
+    IN_BACK = "inBack"
+    IN_ELASTIC = "inElastic"
+    OUT_SINE = "outSine"
+    OUT_QUAD = "outQuad"
+    OUT_CUBIC = "outCubic"
+    OUT_QUART = "outQuart"
+    OUT_QUINT = "outQuint"
+    OUT_EXPO = "outExpo"
+    OUT_CIRC = "outCirc"
+    OUT_BACK = "outBack"
+    OUT_ELASTIC = "outElastic"
+    IN_OUT_SINE = "inOutSine"
+    IN_OUT_QUAD = "inOutQuad"
+    IN_OUT_CUBIC = "inOutCubic"
+    IN_OUT_QUART = "inOutQuart"
+    IN_OUT_QUINT = "inOutQuint"
+    IN_OUT_EXPO = "inOutExpo"
+    IN_OUT_CIRC = "inOutCirc"
+    IN_OUT_BACK = "inOutBack"
+    IN_OUT_ELASTIC = "inOutElastic"
+    OUT_IN_SINE = "outInSine"
+    OUT_IN_QUAD = "outInQuad"
+    OUT_IN_CUBIC = "outInCubic"
+    OUT_IN_QUART = "outInQuart"
+    OUT_IN_QUINT = "outInQuint"
+    OUT_IN_EXPO = "outInExpo"
+    OUT_IN_CIRC = "outInCirc"
+    OUT_IN_BACK = "outInBack"
+    OUT_IN_ELASTIC = "outInElastic"
 
 
 @dataclass
 class UiAnimationTween:
+    """Tween animation configuration for UI elements.
+
+    Args:
+        start: The initial value.
+        end: The final value.
+        duration: The duration of the animation.
+        ease: The easing function to use.
+    """
+
     start: float
     end: float
     duration: float
@@ -92,6 +113,13 @@ class UiAnimationTween:
 
 @dataclass
 class UiAnimation:
+    """Animation configuration for UI elements.
+
+    Args:
+        scale: The animation applied to scale.
+        alpha: The animation applied to alpha.
+    """
+
     scale: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 1, 0, "none"))
     alpha: UiAnimationTween = field(default_factory=lambda: UiAnimationTween(1, 0, 0.2, "outCubic"))
 
@@ -104,6 +132,13 @@ class UiAnimation:
 
 @dataclass
 class UiVisibility:
+    """Visibility configuration for UI elements.
+
+    Args:
+        scale: The scale of the element.
+        alpha: The alpha of the element.
+    """
+
     scale: float = 1.0
     alpha: float = 1.0
 
@@ -116,9 +151,30 @@ class UiVisibility:
 
 @dataclass
 class UiConfig:
+    """Configuration for UI elements.
+
+    Args:
+        scope: The scope of the configuration.
+        primary_metric: The primary metric to display.
+        secondary_metric: The secondary metric to display.
+        menu_visibility: The visibility configuration for the menu.
+        judgment_visibility: The visibility configuration for judgments.
+        combo_visibility: The visibility configuration for the combo.
+        primary_metric_visibility: The visibility configuration for the primary metric.
+        secondary_metric_visibility: The visibility configuration for the secondary metric.
+        progress_visibility: The visibility configuration for progress.
+        tutorial_navigation_visibility: The visibility configuration for tutorial navigation.
+        tutorial_instruction_visibility: The visibility configuration for tutorial instructions.
+        judgment_animation: The animation configuration for judgments.
+        combo_animation: The animation configuration for the combo.
+        judgment_error_style: The style of the judgment error.
+        judgment_error_placement: The placement of the judgment error.
+        judgment_error_min: The minimum judgment error.
+    """
+
     scope: str | None = None
-    primary_metric: UiMetric = "arcade"
-    secondary_metric: UiMetric = "life"
+    primary_metric: UiMetric = UiMetric.ARCADE
+    secondary_metric: UiMetric = UiMetric.LIFE
     menu_visibility: UiVisibility = field(default_factory=UiVisibility)
     judgment_visibility: UiVisibility = field(default_factory=UiVisibility)
     combo_visibility: UiVisibility = field(default_factory=UiVisibility)
@@ -130,11 +186,11 @@ class UiConfig:
     judgment_animation: UiAnimation = field(default_factory=UiAnimation)
     combo_animation: UiAnimation = field(
         default_factory=lambda: UiAnimation(
-            scale=UiAnimationTween(1.2, 1, 0.2, "inCubic"), alpha=UiAnimationTween(1, 1, 0, "none")
+            scale=UiAnimationTween(1.2, 1, 0.2, EaseType.IN_CUBIC), alpha=UiAnimationTween(1, 1, 0, EaseType.NONE)
         )
     )
-    judgment_error_style: UiJudgmentErrorStyle = "none"
-    judgment_error_placement: UiJudgmentErrorPlacement = "both"
+    judgment_error_style: UiJudgmentErrorStyle = UiJudgmentErrorStyle.NONE
+    judgment_error_placement: UiJudgmentErrorPlacement = UiJudgmentErrorPlacement.BOTH
     judgment_error_min: float = 0.0
 
     def to_dict(self):

sonolus/script/values.py

@@ -5,7 +5,10 @@ from sonolus.script.internal.impl import meta_fn, validate_value
 
 @meta_fn
 def alloc[T](type_: type[T]) -> T:
-    """Returns an uninitialized instance of the given type."""
+    """Return an uninitialized instance of the given type.
+
+    Use this carefully as reading from uninitialized memory can lead to unexpected behavior.
+    """
     type_ = validate_concrete_type(type_)
     if ctx():
         return type_._alloc_()
@@ -15,7 +18,7 @@ def alloc[T](type_: type[T]) -> T:
 
 @meta_fn
 def zeros[T](type_: type[T]) -> T:
-    """Returns a new instance of the given type initialized with zeros."""
+    """Make a new instance of the given type initialized with zeros."""
     type_ = validate_concrete_type(type_)
     if ctx():
         return copy(type_._from_list_([0] * type_._size_()))
@@ -25,19 +28,9 @@ def zeros[T](type_: type[T]) -> T:
 
 @meta_fn
 def copy[T](value: T) -> T:
-    """Returns a deep copy of the given value."""
+    """Make a deep copy of the given value."""
     value = validate_value(value)
     if ctx():
         return value._copy_()
     else:
         return value._copy_()._as_py_()
-
-
-@meta_fn
-def with_default[T](value: T, default: T) -> T:
-    """Returns the given value if it's not None, otherwise the default value."""
-    value = validate_value(value)
-    default = validate_value(default)
-    if value._is_py_() and value._as_py_() is None:
-        return default
-    return value

sonolus/script/vec.py

@@ -1,81 +1,196 @@
+from math import atan2, cos, sin
 from typing import Self
 
-from sonolus.script.math import atan2, cos, sin
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 
 
 class Vec2(Record):
+    """A 2D vector.
+
+    Usage:
+        ```python
+        Vec2(x: float, y: float)
+        ```
+    """
+
     x: float
     y: float
 
     @classmethod
     def zero(cls) -> Self:
+        """Return a vector with x and y set to 0.
+
+        Returns:
+            A new vector with x=0 and y=0.
+        """
         return cls(x=0, y=0)
 
     @classmethod
     def one(cls) -> Self:
+        """Return a vector with x and y set to 1.
+
+        Returns:
+            A new vector with x=1 and y=1.
+        """
         return cls(x=1, y=1)
 
     @classmethod
     def up(cls) -> Self:
+        """Return a vector pointing upwards (x=0, y=1).
+
+        Returns:
+            A new vector pointing upwards.
+        """
         return cls(x=0, y=1)
 
     @classmethod
     def down(cls) -> Self:
+        """Return a vector pointing downwards (x=0, y=-1).
+
+        Returns:
+            A new vector pointing downwards.
+        """
         return cls(x=0, y=-1)
 
     @classmethod
     def left(cls) -> Self:
+        """Return a vector pointing to the left (x=-1, y=0).
+
+        Returns:
+            A new vector pointing to the left.
+        """
         return cls(x=-1, y=0)
 
     @classmethod
     def right(cls) -> Self:
+        """Return a vector pointing to the right (x=1, y=0).
+
+        Returns:
+            A new vector pointing to the right.
+        """
         return cls(x=1, y=0)
 
     @property
     def magnitude(self) -> Num:
+        """Calculate the magnitude (length) of the vector.
+
+        Returns:
+            The magnitude of the vector.
+        """
         return (self.x**2 + self.y**2) ** 0.5
 
     @property
     def angle(self) -> Num:
+        """Calculate the angle of the vector in radians from the positive x-axis.
+
+        Returns:
+            The angle of the vector in radians.
+        """
         return atan2(self.y, self.x)
 
     def dot(self, other: Self) -> Num:
+        """Calculate the dot product of this vector with another vector.
+
+        Args:
+            other: The other vector to calculate the dot product with.
+
+        Returns:
+            The dot product of the two vectors.
+        """
         return self.x * other.x + self.y * other.y
 
     def rotate(self, angle: Num) -> Self:
+        """Rotate the vector by a given angle in radians and return a new vector.
+
+        Args:
+            angle: The angle to rotate the vector by, in radians.
+
+        Returns:
+            A new vector rotated by the given angle.
+        """
         return Vec2(
             x=self.x * cos(angle) - self.y * sin(angle),
             y=self.x * sin(angle) + self.y * cos(angle),
         )
 
     def rotate_about(self, angle: Num, pivot: Self) -> Self:
+        """Rotate the vector about a pivot by a given angle in radians and return a new vector.
+
+        Args:
+            angle: The angle to rotate the vector by, in radians.
+            pivot: The pivot point to rotate about.
+
+        Returns:
+            A new vector rotated about the pivot by the given angle.
+        """
         return (self - pivot).rotate(angle) + pivot
 
     @property
     def tuple(self) -> tuple[float, float]:
+        """Return the vector as a tuple (x, y).
+
+        Returns:
+            A tuple representation of the vector.
+        """
         return self.x, self.y
 
     def __add__(self, other: Self) -> Self:
+        """Add this vector to another vector and return a new vector.
+
+        Args:
+            other: The vector to add.
+
+        Returns:
+            A new vector resulting from the addition.
+        """
         return Vec2(x=self.x + other.x, y=self.y + other.y)
 
     def __sub__(self, other: Self) -> Self:
+        """Subtract another vector from this vector and return a new vector.
+
+        Args:
+            other: The vector to subtract.
+
+        Returns:
+            A new vector resulting from the subtraction.
+        """
         return Vec2(x=self.x - other.x, y=self.y - other.y)
 
     def __mul__(self, other: Self | float) -> Self:
+        """Multiply this vector by another vector or a scalar and return a new vector.
+
+        Args:
+            other: The vector or scalar to multiply by.
+
+        Returns:
+            A new vector resulting from the multiplication.
+        """
         match other:
             case Vec2(x, y):
                 return Vec2(x=self.x * x, y=self.y * y)
-            case float() | int() as factor:
+            case Num(factor):
                 return Vec2(x=self.x * factor, y=self.y * factor)
 
     def __truediv__(self, other: Self | float) -> Self:
+        """Divide this vector by another vector or a scalar and return a new vector.
+
+        Args:
+            other: The vector or scalar to divide by.
+
+        Returns:
+            A new vector resulting from the division.
+        """
         match other:
             case Vec2(x, y):
                 return Vec2(x=self.x / x, y=self.y / y)
-            case float() | int() as factor:
+            case Num(factor):
                 return Vec2(x=self.x / factor, y=self.y / factor)
 
     def __neg__(self) -> Self:
+        """Negate the vector (invert the direction) and return a new vector.
+
+        Returns:
+            A new vector with inverted direction.
+        """
         return Vec2(x=-self.x, y=-self.y)

{sonolus_py-0.1.4.dist-info → sonolus_py-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.4
+Version: 0.1.5
 Summary: Sonolus engine development in Python
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

sonolus_py-0.1.5.dist-info/RECORD

@@ -0,0 +1,89 @@
+sonolus/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/backend/blocks.py,sha256=3peyb9eYBy0s53xNVJ1KmK4IgoyVkkwG-lqDQ_VZTHc,18531
+sonolus/backend/excepthook.py,sha256=pqI9gtPBh0mlTgMNqul8bEVO1ARzKb8pNE9EN_CyDpk,994
+sonolus/backend/finalize.py,sha256=XjFeJgpKLI5_vU-okhSXRVTv31BZrUGbnBG_ITr3wrU,3963
+sonolus/backend/interpret.py,sha256=B0jqlLmEGoyO2mxpcvwRwV17Tq_gOE9wLNt26Q5QOfs,14306
+sonolus/backend/ir.py,sha256=TCDLMvlX2S8emFDQwFVeD2OUC4fnhbrMObgYtoa_7PQ,2845
+sonolus/backend/mode.py,sha256=NkcPZJm8dn83LX35uP24MtQOCnfRDFZ280dHeEEfauE,613
+sonolus/backend/node.py,sha256=H8qgnNyIseR-DhfgtcbDX03SUmhAJSSrYAlUEJTkkUo,999
+sonolus/backend/ops.py,sha256=ekkHSdgRubIYLSYFk0wTUuBvyf3TKdApM4AyR_koTQ8,10122
+sonolus/backend/place.py,sha256=Z3yFx-Ki2z32MXsVb6TkZ_D95RyZCu8iJPQRXNiyiNg,2364
+sonolus/backend/utils.py,sha256=9-mmCUwGlNdjp51jKrNBN2dGxCAXVV2PdJn031kaXHM,1717
+sonolus/backend/visitor.py,sha256=a7cRdiM9g1fLuR8_BxOwRTDvtq3JNfE4k1JqZioiQyU,45756
+sonolus/backend/optimize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/backend/optimize/allocate.py,sha256=LCqxvT8YsVGTaVAu58fb6lrrytVLWx1LNbcOfx8CqL8,5671
+sonolus/backend/optimize/constant_evaluation.py,sha256=ty3vNey7I44GK17lQA-3whkioFQGleYKD3P5a22foj0,15997
+sonolus/backend/optimize/copy_coalesce.py,sha256=vKeq1UYxA7cJq5HgP8HdsIACFPjNyK4m_asakm1SOZ4,3966
+sonolus/backend/optimize/dead_code.py,sha256=qYmUqBmAp-O5mUpNusOoMEJVkbc9YIHx6Ynrg6dyNGY,8077
+sonolus/backend/optimize/dominance.py,sha256=oTFUqN8twrw6lTzqr1nlYs-Gk1NzIa-4qGdEQvDGzlM,3217
+sonolus/backend/optimize/flow.py,sha256=mMf5Um2uxwF65nw13UiIv7dFMHZZHnyWv2WaOVnGw2c,4266
+sonolus/backend/optimize/inlining.py,sha256=jwTiuHivSq9bB7FfVbD9Wd_Ztaz8ml_5CRnikr2d6yU,5719
+sonolus/backend/optimize/liveness.py,sha256=c0ejVf1LNcYBlByf3rxkNs18IoXmiOdCFwEk3Afv8DE,7121
+sonolus/backend/optimize/optimize.py,sha256=oGPmsDD0FFNihhrpV9uSybkGHP3C_EU0Rpw6x7kvf8c,1329
+sonolus/backend/optimize/passes.py,sha256=OPzcpFUU7qbQFSrgr84UuzDg_vB1GYkZj2K2aqGkkag,1643
+sonolus/backend/optimize/simplify.py,sha256=Tz4RftjH5TpIxoIOwiZuLchsrwzI9GaS_exdjAW6HKk,7927
+sonolus/backend/optimize/ssa.py,sha256=D3CQm3s3gcuU0_k_0pXVrwirm4xjAZsX6corrTDS1Co,9013
+sonolus/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/build/cli.py,sha256=YlWg3Jfe1gi2wnlIJDh8LCMLSPV3l9AiuDWk2Bbphmg,5812
+sonolus/build/collection.py,sha256=IsDgedsAJ-foHzQ4LnQ9zSVXSz5wVVt4sgqiUICBvCU,10573
+sonolus/build/compile.py,sha256=wBiRX6rnq8Op4_vVXJ-bPLtffgV4ppNBa9M9hIe9twI,3579
+sonolus/build/engine.py,sha256=TAJCdSWOsEcTq9o6jfR3A2JZ8gOoc9YQx6FC_qW-dFw,6766
+sonolus/build/level.py,sha256=3sdGPvIZ4a15u3-JdITnB6rznp6a2E3k6A0gB8A15JA,610
+sonolus/build/node.py,sha256=jwsVWt6Brh4M9MypUt3Nqnxfm7fXrCMRWYQGwBTAszI,1162
+sonolus/build/project.py,sha256=x350tPcwKCYakdbrP796b545hVUaBwrzY0yEcQR7ut4,4023
+sonolus/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sonolus/script/archetype.py,sha256=gYRkUD_hI_MhXA-diIObIp0xqpX6aNiPqWLhiw-t094,33887
+sonolus/script/array.py,sha256=KJxyL4I7A-CNFQW1RbZYQGVI527XZmoesDR-q6BurB8,9339
+sonolus/script/array_like.py,sha256=OVOLMadS-Jj941S-EgoxlFPdaQLT6ZrHzaMnKtB6PfU,8346
+sonolus/script/bucket.py,sha256=ZNlNeBZ1FzRLQ49bTuuJDmnYZ-_sjQEvosySx3ESxQc,6944
+sonolus/script/containers.py,sha256=tf0-UUSq8NH6k9jIKq6qgXRxanFQ0f5olH6uHghTynk,13171
+sonolus/script/debug.py,sha256=ua8FM7h563ZMQp7oyjJRGzjjF0zi4xcnFhI3RgIdOSw,2443
+sonolus/script/easing.py,sha256=7zaDKIfM_whUpb4FBz1DAF4NNG2vk_nDjl8kL2Y90aU,11396
+sonolus/script/effect.py,sha256=kFshJhpVh5XiRPYms30vhry7_P6bQMVEkZ1K90jprgk,5830
+sonolus/script/engine.py,sha256=WUCENp-G_12jN_QW-w1RJCJQrkyRbsVtB1z7OeNV2mQ,6975
+sonolus/script/globals.py,sha256=Z8RfLkgDuXPIKiq-aOqblP0s__ALGmvcKdlyWZH21EM,9166
+sonolus/script/instruction.py,sha256=PNfxC1dhT_hB0BxhDV3KXMn_kKxfI0t1iZmg8m6ddMU,6725
+sonolus/script/interval.py,sha256=3wMy7YlL6XV0g7w3eIDQDXl1WfTjW4NunKtwRxRMnDQ,9004
+sonolus/script/iterator.py,sha256=ZErUmpRrXISe1xiT3VOjHzcqqLhpfT9FI7Kz2s2vUpk,4163
+sonolus/script/level.py,sha256=NuXr8SalXn4eMm00OOYfWPQ-EXhJIKVCtbiIKX2SGag,1872
+sonolus/script/num.py,sha256=-u1wwFkPJYrJCjD8yE2DArrH3SMVKqQaHQhgVpd8EeA,13911
+sonolus/script/options.py,sha256=nTOuoRC2p_qoMx4ngOVDY2WZDooTxwwGTGKyb994v2A,7516
+sonolus/script/particle.py,sha256=K06ArT9tstRNdbuGIviDmDDWcK3-ieA53LHg0Xvizow,8304
+sonolus/script/pointer.py,sha256=pOh5vCSl6xR7mDm5PMOhBc_wf4O-b938DE0LtZWBmPc,1119
+sonolus/script/print.py,sha256=mNYu9QWiacBBGZrnePZQMVwbbguoelUps9GiOK_aVRU,2096
+sonolus/script/project.py,sha256=iGdMEpT6mUcyTmfGwmIW25ucHB51ETd1_SyQ6UC7AYg,612
+sonolus/script/quad.py,sha256=SVMcfRYx8Bv5t7A2vhus9QUiw-1V-qtRhldr3DnnNWw,7693
+sonolus/script/record.py,sha256=rOVlo-eUUvFG_Ee-wKrgX_ZwOqWKWtS7s8m-juM70yE,11216
+sonolus/script/runtime.py,sha256=xeiLJFeqkCev1x6pBiM5afyvi3GWdpLJ5OYRg9M9nwo,18562
+sonolus/script/sprite.py,sha256=-hURLrLrxtu73qSQ4x4_gJqnJ3XiORUmNojh5fdm2E8,15732
+sonolus/script/text.py,sha256=IsoINZJXefjReYDjJFwVaFsUCdgeQvPBDeywljM2dWo,13025
+sonolus/script/timing.py,sha256=ZR0ypV2PIoDCMHHGOMfCeezStCsBQdzomdqaz5VKex0,2981
+sonolus/script/transform.py,sha256=hH6KSRQC8vV-Z10CRCrGewMYqQwUMH3mQIEmniuC2Zw,10760
+sonolus/script/ui.py,sha256=kyuP88sLRJPT-Yx-7fx8Xu9Wdegyw_CJNslcP4WnDUs,7268
+sonolus/script/values.py,sha256=JuvJknskuY6FPprUp9R-6Gj2TDJLu4ppbVcYedG5dG0,1049
+sonolus/script/vec.py,sha256=Uph6Z9xofwbKGZu0H7rl6fzlO4bj5i0cnWu4LQeIL4I,5270
+sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtUwu-Ms8,136
+sonolus/script/internal/builtin_impls.py,sha256=w27aKMhLX4Ivd7uKz1ZgVy1lC5scSSJ23-VfsbCfIb0,7731
+sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
+sonolus/script/internal/constant.py,sha256=lIBBR84Rfw0rBSZU2reCrUnB3yEMEdOX6A7_LgptYz8,3776
+sonolus/script/internal/context.py,sha256=evLOXcOqskK5Gh5Je86ghKlMaon-Opi7dDoMtkCjEh8,13533
+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=YU1hUJoBcGc0OSrFStK5JI6CikOwSmd_IR20pCuT82k,7310
+sonolus/script/internal/impl.py,sha256=HKQVoHknw5t43Wmj_G1vFjGSmnFpOj1FUYnhbUM3rHc,2969
+sonolus/script/internal/introspection.py,sha256=A0P2R2pNQTyj4N6-v-bCzuyIi7F-ST3qzQ3AM5l9P58,819
+sonolus/script/internal/math_impls.py,sha256=7L450U7gW-jUkTWcQ1AMg9IX0yhu4G2WUsJ5xMZ8r3o,2306
+sonolus/script/internal/native.py,sha256=XKlNnWSJ-lxbwVGWhGj_CSSoWsVN18imqT5sAsDJT1w,1551
+sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z50pI,1695
+sonolus/script/internal/range.py,sha256=lrTanQFHU7RuQxSSPwDdoC30Y8FnHGxcP1Ahditu3zU,2297
+sonolus/script/internal/transient.py,sha256=pSDFGu0m26zVsp6owmNTeSPue-osDd1JahjJSijW8t0,1520
+sonolus/script/internal/tuple_impl.py,sha256=vjXmScLVdeTkDn3t9fgIRqtW31iwngnaP2rmA6nlsLw,3431
+sonolus/script/internal/value.py,sha256=ik9sMKl0TbsH_C6QNxD4WfpAnmBFISgmmlazWwh3kY0,4308
+sonolus_py-0.1.5.dist-info/METADATA,sha256=HHVoPymf7iwqOCBJqIEMETzGgzgPIwEA3Owrjudj_a4,216
+sonolus_py-0.1.5.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sonolus_py-0.1.5.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.1.5.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.1.5.dist-info/RECORD,,

sonolus/backend/dead_code.py

@@ -1,80 +0,0 @@
-from sonolus.backend.flow import BasicBlock, traverse_cfg_preorder
-from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRSet
-from sonolus.backend.liveness import LivenessAnalysis, get_live, get_live_phi_targets
-from sonolus.backend.passes import CompilerPass
-from sonolus.backend.place import BlockPlace, SSAPlace, TempBlock
-
-
-class UnreachableCodeElimination(CompilerPass):
-    def run(self, entry: BasicBlock) -> BasicBlock:
-        original_blocks = [*traverse_cfg_preorder(entry)]
-        worklist = {entry}
-        visited = set()
-        while worklist:
-            block = worklist.pop()
-            if block in visited:
-                continue
-            visited.add(block)
-            match block.test:
-                case IRConst(value=value):
-                    block.test = IRConst(0)
-                    taken_edge = next(
-                        (edge for edge in block.outgoing if edge.cond == value),
-                        None,
-                    ) or next((edge for edge in block.outgoing if edge.cond is None), None)
-                    assert not block.outgoing or taken_edge
-                    for edge in [*block.outgoing]:
-                        if edge is not taken_edge:
-                            edge.dst.incoming.remove(edge)
-                            block.outgoing.remove(edge)
-                    if taken_edge:
-                        taken_edge.cond = None
-                        block.outgoing.add(taken_edge)
-                        worklist.add(taken_edge.dst)
-                case _:
-                    worklist.update(edge.dst for edge in block.outgoing)
-        for block in original_blocks:
-            if block not in visited:
-                for edge in block.outgoing:
-                    edge.dst.incoming.remove(edge)
-            else:
-                for args in block.phis.values():
-                    for src_block in [*args]:
-                        if src_block not in visited:
-                            args.pop(src_block)
-        return entry
-
-
-class DeadCodeElimination(CompilerPass):
-    def requires(self) -> set[CompilerPass]:
-        return {LivenessAnalysis()}
-
-    def preserves(self) -> set[CompilerPass] | None:
-        return {LivenessAnalysis()}
-
-    def run(self, entry: BasicBlock) -> BasicBlock:
-        for block in traverse_cfg_preorder(entry):
-            live_stmts = []
-            for statement in block.statements:
-                live = get_live(statement)
-                match statement:
-                    case IRSet(place=place, value=value):
-                        is_live = not (
-                            (isinstance(place, SSAPlace) and place not in live)
-                            or (
-                                isinstance(place, BlockPlace)
-                                and isinstance(place.block, TempBlock)
-                                and place.block not in live
-                            )
-                            or (isinstance(value, IRGet) and place == value.place)
-                        )
-                        if is_live:
-                            live_stmts.append(statement)
-                        elif isinstance(value, IRInstr) and value.op.side_effects:
-                            live_stmts.append(value)
-                            value.live = live
-                    case other:
-                        live_stmts.append(other)
-            block.statements = live_stmts
-            block.phis = {place: phi for place, phi in block.phis.items() if place in get_live_phi_targets(block)}
-        return entry