pyglove 0.4.5.dev202505150810__tar.gz → 0.4.5.dev202505160313__tar.gz

{pyglove-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/PKG-INFO

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

{pyglove-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505160313/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-0.4.5.dev202505160313/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/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 → pyglove-0.4.5.dev202505160313}/pyglove.egg-info/PKG-INFO

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

{pyglove-0.4.5.dev202505150810 → pyglove-0.4.5.dev202505160313}/pyglove.egg-info/SOURCES.txt

@@ -88,6 +88,8 @@ pyglove/core/symbolic/dict.py
 pyglove/core/symbolic/dict_test.py
 pyglove/core/symbolic/diff.py
 pyglove/core/symbolic/diff_test.py
+pyglove/core/symbolic/error_info.py
+pyglove/core/symbolic/error_info_test.py
 pyglove/core/symbolic/flags.py
 pyglove/core/symbolic/flags_test.py
 pyglove/core/symbolic/functor.py