pyglove 0.4.5.dev202505150810__py3-none-any.whl → 0.4.5.dev202505160810__py3-none-any.whl

pyglove/core/symbolic/__init__.py

@@ -145,5 +145,6 @@ from pyglove.core.symbolic.list import mark_as_insertion
 
 # Error types.
 from pyglove.core.symbolic.base import WritePermissionError
+from pyglove.core.symbolic.error_info import ErrorInfo
 
 # pylint: enable=g-bad-import-order

pyglove/core/symbolic/error_info.py

@@ -0,0 +1,127 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Symbolic class for capture error information."""
+
+from typing import Annotated, List
+from pyglove.core import utils
+from pyglove.core.symbolic import dict as pg_dict  # pylint: disable=unused-import
+from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
+from pyglove.core.symbolic import object as pg_object
+from pyglove.core.views.html import controls
+from pyglove.core.views.html import tree_view
+
+
+@pg_object.members(
+    [],
+    # For backwards compatibility.
+    additional_keys=['pyglove.core.utils.error_utils.ErrorInfo']
+)
+class ErrorInfo(
+    pg_object.Object,
+    utils.ErrorInfo,
+    tree_view.HtmlTreeView.Extension
+):
+  """Symbolic error info."""
+
+  tag: Annotated[
+      str,
+      (
+          'A path of the error types in the exception chain. For example, '
+          '`ValueError.ZeroDivisionError` means the error is a '
+          '`ZeroDivisionError` raised at the first place and then reraised as '
+          'a `ValueError`.'
+      )
+  ]
+
+  description: Annotated[
+      str,
+      'The description of the error.',
+  ]
+
+  stacktrace: Annotated[
+      str,
+      'The stacktrace of the error.',
+  ]
+
+  def _html_tree_view_summary(
+      self,
+      *,
+      view: tree_view.HtmlTreeView,
+      **kwargs
+  ) -> tree_view.Html:
+    kwargs.pop('title', None)
+    kwargs.pop('enable_summary_tooltip', None)
+    return view.summary(
+        self,
+        title=tree_view.Html.element(
+            'div',
+            [
+                'ErrorInfo',
+                controls.Label(self.tag, css_classes=['error_tag']),
+            ],
+            styles=dict(display='inline-block')
+        ),
+        enable_summary_tooltip=False,
+        **kwargs
+    )
+
+  def _html_tree_view_content(self, **kwargs) -> tree_view.Html:
+    del kwargs
+    return controls.TabControl([
+        controls.Tab(
+            'description',
+            tree_view.Html.element(
+                'div',
+                [
+                    tree_view.Html.escape(utils.decolor(self.description))
+                ],
+                css_classes=['error_text']
+            )
+        ),
+        controls.Tab(
+            'stacktrace',
+            tree_view.Html.element(
+                'div',
+                [
+                    tree_view.Html.escape(utils.decolor(self.stacktrace))
+                ],
+                css_classes=['error_text']
+            )
+        )
+    ]).to_html()
+
+  @classmethod
+  def _html_tree_view_css_styles(cls) -> List[str]:
+    return super()._html_tree_view_css_styles() + [
+        '''
+        .error_tag {
+          background-color: red;
+          border-radius: 5px;
+          padding: 5px;
+          margin-left: 5px;
+          color: white;
+          font-size: small;
+        }
+        .error_text {
+          display: block;
+          white-space: pre-wrap;
+          padding: 0.5em;
+          margin-top: 0.15em;
+          background-color: #f2f2f2;
+        }
+        '''
+    ]
+
+# Use the symbolic error info class as the default ErrorInfo implementation.
+utils.ErrorInfo._IMPLEMENTATION = ErrorInfo  # pylint: disable=protected-access

pyglove/core/symbolic/error_info_test.py

@@ -0,0 +1,92 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import unittest
+from pyglove.core.symbolic import base
+from pyglove.core.symbolic import error_info as error_info_lib  # pylint: disable=g-bad-import-order
+
+
+class ErrorInfoTest(unittest.TestCase):
+  """Tests for ErrorInfo."""
+
+  def test_from_exception(self):
+
+    def foo():
+      return 1 / 0
+
+    def bar():
+      try:
+        foo()
+      except ZeroDivisionError as e:
+        raise ValueError('Bad call to `foo`') from e
+
+    error_info = None
+    try:
+      bar()
+    except ValueError as e:
+      error_info = error_info_lib.ErrorInfo.from_exception(e)
+    self.assertIsNotNone(error_info)
+    self.assertEqual(error_info.tag, 'ValueError.ZeroDivisionError')
+    self.assertEqual(error_info.description, 'Bad call to `foo`')
+    self.assertIn('Traceback (most recent call last)', error_info.stacktrace)
+
+  def test_to_json(self):
+    error_info = error_info_lib.ErrorInfo(
+        tag='ValueError.ZeroDivisionError',
+        description='Bad call to `foo`',
+        stacktrace='Traceback (most recent call last)',
+    )
+    json_dict = error_info.to_json()
+    error_info2 = base.from_json(json_dict)
+    self.assertIsNot(error_info2, error_info)
+    self.assertEqual(error_info2, error_info)
+    json_dict['_type'] = 'pyglove.core.utils.error_utils.ErrorInfo'
+    error_info2 = base.from_json(json_dict)
+    self.assertEqual(error_info2, error_info)
+
+  def test_format(self):
+    error_info = error_info_lib.ErrorInfo(
+        tag='ValueError.ZeroDivisionError',
+        description='Bad call to `foo`',
+        stacktrace='Traceback (most recent call last)',
+    )
+    self.assertEqual(
+        error_info.format(compact=False),
+        inspect.cleandoc(
+            """
+            ErrorInfo(
+              tag = 'ValueError.ZeroDivisionError',
+              description = 'Bad call to `foo`',
+              stacktrace = 'Traceback (most recent call last)'
+            )
+            """
+        )
+    )
+
+  def test_to_html(self):
+    error_info = error_info_lib.ErrorInfo(
+        tag='ValueError.ZeroDivisionError',
+        description='Bad call to `foo`',
+        stacktrace='Traceback (most recent call last)',
+    )
+    html = error_info.to_html()
+    self.assertIn('ErrorInfo', html.content)
+    self.assertIn('ValueError.ZeroDivisionError', html.content)
+    self.assertIn('Bad call to `foo`', html.content)
+    self.assertIn('Traceback (most recent call last)', html.content)
+
+
+if __name__ == '__main__':
+  unittest.main()

pyglove/core/symbolic/object.py

@@ -101,6 +101,18 @@ class ObjectMeta(abc.ABCMeta):
     )
     cls.apply_schema(schema)
 
+    # Update abstract methods.
+    # abc.update_abstractmethods is only available in Python 3.10 and above.
+    if sys.version_info >= (3, 10):
+      abc.update_abstractmethods(cls)
+    elif cls.allow_symbolic_attribute:
+      abstract_methods = getattr(cls, '__abstractmethods__', frozenset())
+      new_abstract_methods = []
+      for name in abstract_methods:
+        if name not in cls.__schema__.fields:
+          new_abstract_methods.append(name)
+      setattr(cls, '__abstractmethods__', frozenset(new_abstract_methods))
+
   def register_for_deserialization(
       cls,
       serialization_key: Optional[str] = None,
@@ -506,7 +518,10 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         attr_value = getattr(cls, attr_name, pg_typing.MISSING_VALUE)
         if attr_value == pg_typing.MISSING_VALUE or (
             not inspect.isfunction(attr_value)
-            and not isinstance(attr_value, property)
+            and (
+                not isinstance(attr_value, property)
+                or getattr(attr_value, '__isabstractmethod__', False)
+            )
         ):
           setattr(cls, attr_name, cls._create_sym_attribute(attr_name, field))
 
@@ -517,7 +532,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         coding.make_function(
             attr_name,
             ['self'],
-            [f"return self.sym_inferred('{attr_name}')"],
+            [f'return self.sym_inferred(\'{attr_name}\')'],
             return_type=field.value.annotation,
         )
     )

pyglove/core/symbolic/object_test.py

@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import abc
 import copy
 import inspect
 import io
@@ -493,6 +494,33 @@ class ObjectTest(unittest.TestCase):
     self.assertEqual(b.x, 2)
     self.assertEqual(b.sym_init_args.x, 1)
 
+  def test_override_abstract_property(self):
+    class A(metaclass=abc.ABCMeta):
+
+      @property
+      @abc.abstractmethod
+      def x(self):
+        pass
+
+    class B(Object, A):
+      x: int
+
+    self.assertEqual(B(1).x, 1)
+
+  def test_override_abstract_property_with_members_decorator(self):
+    class A(metaclass=abc.ABCMeta):
+
+      @property
+      @abc.abstractmethod
+      def x(self):
+        pass
+
+    class B(Object, A):
+      pass
+
+    pg_members([('x', pg_typing.Int())])(B)
+    self.assertEqual(B(1).x, 1)   # pylint: disable=abstract-class-instantiated
+
   def test_runtime_type_check(self):
 
     @pg_members([

pyglove/core/utils/error_utils.py

@@ -13,33 +13,37 @@
 # limitations under the License.
 """Utilities for working with errors."""
 
+import abc
 import contextlib
 import dataclasses
 import inspect
 import re
 import sys
 import traceback
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type, Union
+from typing import Callable, Dict, List, Optional, Sequence, Tuple, Type, Union
 
-from pyglove.core.utils import formatting
-from pyglove.core.utils import json_conversion
 
+class ErrorInfo(metaclass=abc.ABCMeta):
+  """Interface for error information."""
 
-@dataclasses.dataclass(frozen=True)
-class ErrorInfo(json_conversion.JSONConvertible, formatting.Formattable):
-  """Serializable error information.
+  # The implementation of ErrorInfo will be a symbolic class, which is
+  # defined in pyglove.core.symbolic.error_info and will be assigned later.
+  _IMPLEMENTATION = None
 
-  Attributes:
-    tag: A path of the error types in the exception chain. For example,
-      `ValueError.ZeroDivisionError` means the error is a `ZeroDivisionError`
-      raised at the first place and then reraised as a `ValueError`.
-    description: The description of the error.
-    stacktrace: The stacktrace of the error.
-  """
+  @property
+  @abc.abstractmethod
+  def tag(self) -> str:
+    """A path of the error types in the exception chain."""
+
+  @property
+  @abc.abstractmethod
+  def description(self) -> str:
+    """The description of the error."""
 
-  tag: str
-  description: str
-  stacktrace: str
+  @property
+  @abc.abstractmethod
+  def stacktrace(self) -> str:
+    """The stacktrace of the error."""
 
   @classmethod
   def _compute_tag(cls, error: BaseException):
@@ -52,7 +56,8 @@ class ErrorInfo(json_conversion.JSONConvertible, formatting.Formattable):
   @classmethod
   def from_exception(cls, error: BaseException) -> 'ErrorInfo':
     """Creates an error info from an exception."""
-    return cls(
+    assert cls._IMPLEMENTATION is not None, 'ErrorInfo is not implemented.'
+    return cls._IMPLEMENTATION(   # pytype: disable=wrong-arg-types
         tag=cls._compute_tag(error),
         description=str(error),
         stacktrace=''.join(
@@ -60,29 +65,6 @@ class ErrorInfo(json_conversion.JSONConvertible, formatting.Formattable):
         )
     )
 
-  def to_json(self, **kwargs) -> Dict[str, Any]:
-    return self.to_json_dict(
-        fields=dict(
-            tag=(self.tag, None),
-            description=(self.description, None),
-            stacktrace=(self.stacktrace, None),
-        ),
-        exclude_default=True,
-        **kwargs,
-    )
-
-  def format(self, *args, **kwargs) -> str:
-    return formatting.kvlist_str(
-        [
-            ('tag', self.tag, None),
-            ('description', self.description, None),
-            ('stacktrace', self.stacktrace, None),
-        ],
-        *args,
-        label=self.__class__.__name__,
-        **kwargs,
-    )
-
 
 @dataclasses.dataclass()
 class CatchErrorsContext:

pyglove/core/utils/error_utils_test.py

@@ -11,66 +11,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import inspect
 import unittest
 from pyglove.core.utils import error_utils
 
 
-class ErrorInfoTest(unittest.TestCase):
-  """Tests for ErrorInfo."""
-
-  def test_from_exception(self):
-
-    def foo():
-      return 1 / 0
-
-    def bar():
-      try:
-        foo()
-      except ZeroDivisionError as e:
-        raise ValueError('Bad call to `foo`') from e
-
-    error_info = None
-    try:
-      bar()
-    except ValueError as e:
-      error_info = error_utils.ErrorInfo.from_exception(e)
-    self.assertIsNotNone(error_info)
-    self.assertEqual(error_info.tag, 'ValueError.ZeroDivisionError')
-    self.assertEqual(error_info.description, 'Bad call to `foo`')
-    self.assertIn('Traceback (most recent call last)', error_info.stacktrace)
-
-  def test_to_json(self):
-    error_info = error_utils.ErrorInfo(
-        tag='ValueError.ZeroDivisionError',
-        description='Bad call to `foo`',
-        stacktrace='Traceback (most recent call last)',
-    )
-    json_dict = error_info.to_json()
-    error_info2 = error_utils.ErrorInfo.from_json(json_dict)
-    self.assertIsNot(error_info2, error_info)
-    self.assertEqual(error_info2, error_info)
-
-  def test_format(self):
-    error_info = error_utils.ErrorInfo(
-        tag='ValueError.ZeroDivisionError',
-        description='Bad call to `foo`',
-        stacktrace='Traceback (most recent call last)',
-    )
-    self.assertEqual(
-        error_info.format(compact=False),
-        inspect.cleandoc(
-            """
-            ErrorInfo(
-              tag='ValueError.ZeroDivisionError',
-              description='Bad call to `foo`',
-              stacktrace='Traceback (most recent call last)'
-            )
-            """
-        )
-    )
-
-
 class CatchErrorsTest(unittest.TestCase):
 
   def assert_caught_error(self, func, errors_to_catch):

pyglove/core/utils/text_color_test.py

@@ -48,13 +48,16 @@ class TextColorTest(unittest.TestCase):
     block_color = text_color.colored(
         'TEXT', color='white', background='blue'
     ).split('TEXT')[0]
-    self.assertEqual(
-        colored_text,
+    expected = (
         f'{origin_color}Hi {block_color}<< foo >>{reset}{origin_color}\n'
         '<# print x if x is present #>\n<% if x %>\n'
         f'{block_color}<< x >>{reset}{origin_color}\n'
         f'<% endif %>{reset}'
     )
+    self.assertTrue(
+        # On some termcolor versions, the color codes are not applied.
+        colored_text == expected or colored_text == original_text
+    )
     self.assertEqual(text_color.decolor(colored_text), original_text)
 
   def test_colored_block_without_full_match(self):

pyglove/core/utils/timing_test.py

@@ -14,6 +14,7 @@
 import time
 import unittest
 
+from pyglove.core.symbolic import error_info  # pylint: disable=unused-import
 from pyglove.core.utils import json_conversion
 from pyglove.core.utils import timing
 

{pyglove-0.4.5.dev202505150810.dist-info → pyglove-0.4.5.dev202505160810.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.4.5.dev202505150810
+Version: 0.4.5.dev202505160810
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors

{pyglove-0.4.5.dev202505150810.dist-info → pyglove-0.4.5.dev202505160810.dist-info}/RECORD

@@ -65,7 +65,7 @@ pyglove/core/patching/pattern_based.py,sha256=UtSNB-ARNqVjXwZovjVi84QEoXUGLLBTgL
 pyglove/core/patching/pattern_based_test.py,sha256=PW1EcVfsFPB6wtgwg3s4dzvigWn3b5S8eMNGo0SJiZ0,2771
 pyglove/core/patching/rule_based.py,sha256=JAQp8mWeIOxwIdqusA3GmXia-fxQhQsxbUTmE329wF8,17038
 pyglove/core/patching/rule_based_test.py,sha256=qfy0ILmczV_LMHWEnwo2y079OrJsGYO0nKxSZdmIUcI,18782
-pyglove/core/symbolic/__init__.py,sha256=JZvyaEcS1QxA8MaAGANBWMmRTQcGk_6F0kjFxjokJqg,6002
+pyglove/core/symbolic/__init__.py,sha256=VMQj8oW2hGaJwqgchBJbu5qXoJKaNizxv__vsYL4b7U,6057
 pyglove/core/symbolic/base.py,sha256=3vOHKtanrksBv5B_0HAq2R_CnE355aPx1B9lyJNb5us,77683
 pyglove/core/symbolic/base_test.py,sha256=yASIHIuWiUB1jf4nN-Y4XOjyvr8eQfRpr7s_1LZsu78,7188
 pyglove/core/symbolic/boilerplate.py,sha256=sQ3G25r5bo_UmIdjreL4jkAuQCXIHVlvUfGjjkNod6Y,5955
@@ -80,6 +80,8 @@ pyglove/core/symbolic/dict.py,sha256=7IxKSjUsGulUcNk3xqQnJ2ubGNUbqcc0ZFe8cKiigKA
 pyglove/core/symbolic/dict_test.py,sha256=3MATsFw9Ci0jVPbAT2ivKVZ3PCnBBBvbkMWKgpgl-Fk,72915
 pyglove/core/symbolic/diff.py,sha256=zHfED0Bbq8G_HWNPj3vrOCWzt_062rFhx3BMlpCb9oo,16282
 pyglove/core/symbolic/diff_test.py,sha256=EDiGHqqKhi-NeMxr-bgjBEqlquee_4l_0IM6hgAb9Mg,29400
+pyglove/core/symbolic/error_info.py,sha256=rqRwfmnEibMixaS2G-P0VhKjkZl79qjO6EUItnATHlQ,3675
+pyglove/core/symbolic/error_info_test.py,sha256=y9HdGbvhQ6O4KB7Yv-N5N18k6v6nhiV_f-r1lTImHMo,3041
 pyglove/core/symbolic/flags.py,sha256=a_8VZEhJjkt-zk1v3jCjlfNe7vEG2FqFfAC4l-gKrzg,12090
 pyglove/core/symbolic/flags_test.py,sha256=JDJcm6dYTlnktFsdNFjQszmHXf9bZnhrXMxi_jUiKUA,5483
 pyglove/core/symbolic/functor.py,sha256=6g1eBZSfSB6lp5NSXtAMw--xRhAfkYipSJh2LCVPNTM,26723
@@ -88,8 +90,8 @@ pyglove/core/symbolic/inferred.py,sha256=E4zgphg6NNZad9Fl3jdHQOMZeqEp9XHq5OUYqXE
 pyglove/core/symbolic/inferred_test.py,sha256=G6uPykONcChvs6vZujXHSWaYfjewLTVBscMqzzKNty0,1270
 pyglove/core/symbolic/list.py,sha256=z8goU0ntd-Q5ADaCGiKsJwPhdRdQb0Kd_p-ZekXaLy4,30303
 pyglove/core/symbolic/list_test.py,sha256=IAyFQ48nyczKUcPNZFKHBkX5oh7Xuxbnv3rRkONhbHw,61146
-pyglove/core/symbolic/object.py,sha256=6bCg20r76sfHfVA-BBQYFxTYBzOM_c8BihHEKMKt3i8,42093
-pyglove/core/symbolic/object_test.py,sha256=vIL_ymGpPPXamIljEBdufpw-p82kTeWNy2IbgzGQjig,93811
+pyglove/core/symbolic/object.py,sha256=OZ6eK8qyaLsUKxFiV2GWL5Ol6FDzMrrkpWSRKRwIKAA,42726
+pyglove/core/symbolic/object_test.py,sha256=rDP7lcQZTFdQCqeaNYs7ZfwvGanzHz7CHM33NCmRIFk,94391
 pyglove/core/symbolic/origin.py,sha256=OSWMKjvPcISOXrzuX3lCQC8m_qaGl-9INsIB81erUnU,6124
 pyglove/core/symbolic/origin_test.py,sha256=dU_ZGrGDetM_lYVMn3wQO0d367_t_t8eESe3NrKPBNE,3159
 pyglove/core/symbolic/pure_symbolic.py,sha256=pvo15gn35_KLiGW_XrTjlx5ddmHbwpLr93VgbQ59uQ8,3231
@@ -139,8 +141,8 @@ pyglove/core/utils/contextual.py,sha256=RxBQkDM2gB6QwZj_2oMels6oh-zQPGJJlinZbbqH
 pyglove/core/utils/contextual_test.py,sha256=OOcthquVyAekTqt1RyYcEMHaockMIokpbv4pSf13Nzs,3252
 pyglove/core/utils/docstr_utils.py,sha256=5BY40kXozPKVGOB0eN8jy1P5_GHIzqFJ9FXAu_kzxaw,5119
 pyglove/core/utils/docstr_utils_test.py,sha256=i33VT6zHXEuIIJ4PPg1bVSfaYSnUsC8yST_NfpT-Uds,4228
-pyglove/core/utils/error_utils.py,sha256=ACIqtq4hsWrV00Gxd1OyeHCI-obGBR6J3H9VI1Y9clM,5780
-pyglove/core/utils/error_utils_test.py,sha256=zwTzmyJupIW8GeF3Z-gnpVNdhdTYwzmO0ClODqbR4bU,4164
+pyglove/core/utils/error_utils.py,sha256=U9Ms3G1a_WUXaFgWccyPL7yOIf4k8Wi0nyXJ3yIaIfY,5264
+pyglove/core/utils/error_utils_test.py,sha256=gnsEwFmgDNNVNvuQyhSWai8GDfLoCuX_DMqYow9Q2l4,2547
 pyglove/core/utils/formatting.py,sha256=Wn4d933LQLhuMIfjdRJgpxOThCxBxQrkRBa6Z1-hL_I,15591
 pyglove/core/utils/formatting_test.py,sha256=hhg-nL6DyE5A2QA92ALHK5QtfAYKfPpTbBARF-IT1j0,14241
 pyglove/core/utils/hierarchical.py,sha256=jwB-0FhqOspAymAkvJphRhPTQEsoShmKupCZpU3Vip4,19690
@@ -150,11 +152,11 @@ pyglove/core/utils/json_conversion_test.py,sha256=zA_cy7ixVL3sTf6i9BCXMlSH56Aa3J
 pyglove/core/utils/missing.py,sha256=9gslt1lXd1qSEIuAFxUWu30oD-YdYcnm13eau1S9uqY,1445
 pyglove/core/utils/missing_test.py,sha256=D6-FuVEwCyJemUiPLcwLmwyptqI5Bx0Pfipc2juhKSE,1335
 pyglove/core/utils/text_color.py,sha256=xcCTCxY2qFNZs_jismMGus8scEXKBpYGAhpAgnz-MHk,4112
-pyglove/core/utils/text_color_test.py,sha256=3HtZpUB5XPr7A_5Fg4ZSMfNWeDRiQgSzmg9b1tctMI4,2801
+pyglove/core/utils/text_color_test.py,sha256=cZ2JQyTFtEhEeSQhuS1_hWHTD4Din2i4ypoDRT1dvIg,2938
 pyglove/core/utils/thread_local.py,sha256=i-CnyY3VREtLfAj4_JndBnsKuQLIgwG29ma8dAyRxbI,4839
 pyglove/core/utils/thread_local_test.py,sha256=AOqsdNsA-cYMvJckqxb25ql3Y5kDW0qLfBW1cl85Bnw,6757
 pyglove/core/utils/timing.py,sha256=gnHCA2IJ9DZ3Y0vb8ItB1Ap8ss8j_zN0OMUAdhoGy2Y,7550
-pyglove/core/utils/timing_test.py,sha256=t_awsYs5SqEO3_2u6HDbVxRcSxSfHsE4zMbFG-1ErZw,5011
+pyglove/core/utils/timing_test.py,sha256=g5r55V938sSUWdmiJbssNbaJzRm_09wyfkKgJJYRwc4,5089
 pyglove/core/utils/value_location.py,sha256=wAryIwQeEfrRddyGRk-KbLA7dnNDLhL-dSyFI9wIG5U,26756
 pyglove/core/utils/value_location_test.py,sha256=X6Gih3IoYugziwXWH8VGz5bPeb3Kq0CfZxwbNVIsZJo,21338
 pyglove/core/views/__init__.py,sha256=gll9ZBRYz4p_-LWOdzSR2a6UTWcJ8nR430trrP0yLCU,967
@@ -214,8 +216,8 @@ pyglove/ext/scalars/randoms.py,sha256=LkMIIx7lOq_lvJvVS3BrgWGuWl7Pi91-lA-O8x_gZs
 pyglove/ext/scalars/randoms_test.py,sha256=nEhiqarg8l_5EOucp59CYrpO2uKxS1pe0hmBdZUzRNM,2000
 pyglove/ext/scalars/step_wise.py,sha256=IDw3tuTpv0KVh7AN44W43zqm1-E0HWPUlytWOQC9w3Y,3789
 pyglove/ext/scalars/step_wise_test.py,sha256=TL1vJ19xVx2t5HKuyIzGoogF7N3Rm8YhLE6JF7i0iy8,2540
-pyglove-0.4.5.dev202505150810.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.4.5.dev202505150810.dist-info/METADATA,sha256=wJaP1Y348ijeXOzVXgAeffwWyDbyDHLjyVhRbnXJyBI,7089
-pyglove-0.4.5.dev202505150810.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-pyglove-0.4.5.dev202505150810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.4.5.dev202505150810.dist-info/RECORD,,
+pyglove-0.4.5.dev202505160810.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.4.5.dev202505160810.dist-info/METADATA,sha256=VWfNPs2xHEwUAa7wIVLCBwCGp7bb7wPV5Sap6ewTZ00,7089
+pyglove-0.4.5.dev202505160810.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pyglove-0.4.5.dev202505160810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.4.5.dev202505160810.dist-info/RECORD,,