pyglove 0.4.5.dev202410020809__tar.gz → 0.4.5.dev202410090808__tar.gz

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/PKG-INFO

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

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/__init__.py

@@ -297,6 +297,15 @@ docstr = object_utils.docstr
 catch_errors = object_utils.catch_errors
 timeit = object_utils.timeit
 
+# Symbols from 'views' sub-module.
+
+from pyglove.core import views
+view = views.view
+View = views.View
+Html = views.Html
+to_html = views.to_html
+to_html_str = views.to_html_str
+
 #
 # Symbols from `io` sub-module.
 #

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/object_utils/__init__.py

@@ -137,6 +137,7 @@ from pyglove.core.object_utils.thread_local import thread_local_increment
 from pyglove.core.object_utils.thread_local import thread_local_decrement
 from pyglove.core.object_utils.thread_local import thread_local_push
 from pyglove.core.object_utils.thread_local import thread_local_pop
+from pyglove.core.object_utils.thread_local import thread_local_peek
 
 # Handling docstrings.
 from pyglove.core.object_utils.docstr_utils import DocStr

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/object_utils/value_location.py

@@ -400,6 +400,16 @@ class KeyPath(formatting.Formattable):
     except KeyError:
       return False
 
+  def is_relative_to(self, other: Union[int, str, 'KeyPath']) -> bool:
+    """Returns whether current path is relative to another path."""
+    other = KeyPath.from_value(other)
+    if len(self) < len(other):
+      return False
+    for i in range(len(other)):
+      if self.keys[i] != other.keys[i]:
+        return False
+    return True
+
   @property
   def path(self) -> str:
     """JSONPath representation of current path."""

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/object_utils/value_location_test.py

@@ -226,6 +226,28 @@ class KeyPathTest(unittest.TestCase):
     with self.assertRaisesRegex(TypeError, 'Cannot subtract KeyPath'):
       _ = value_location.KeyPath.parse('a.b') - 1.0
 
+  def test_is_relative_to(self):
+    self.assertTrue(
+        value_location.KeyPath.parse('a.b.c').is_relative_to(
+            value_location.KeyPath())
+    )
+    self.assertTrue(
+        value_location.KeyPath.parse('a.b.c').is_relative_to(
+            value_location.KeyPath.parse('a.b'))
+    )
+    self.assertTrue(
+        value_location.KeyPath.parse('a.b.c').is_relative_to(
+            value_location.KeyPath.parse('a.b.c'))
+    )
+    self.assertFalse(
+        value_location.KeyPath.parse('a.b').is_relative_to(
+            value_location.KeyPath.parse('a.b.c'))
+    )
+    self.assertFalse(
+        value_location.KeyPath.parse('a.b.d').is_relative_to(
+            value_location.KeyPath.parse('a.b.c'))
+    )
+
   def test_hash(self):
     self.assertIn(value_location.KeyPath.parse('a.b.c'), {'a.b.c': 1})
     self.assertNotIn(value_location.KeyPath.parse('a.b.c'), {'a.b': 1})

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/symbolic/base.py

@@ -31,6 +31,7 @@ from pyglove.core.symbolic import flags
 from pyglove.core.symbolic.origin import Origin
 from pyglove.core.symbolic.pure_symbolic import NonDeterministic
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic
+from pyglove.core.views import html
 
 
 class WritePermissionError(Exception):
@@ -171,9 +172,10 @@ RAISE_IF_NOT_FOUND = (pg_typing.MISSING_VALUE,)
 
 class Symbolic(
     TopologyAware,
+    object_utils.Formattable,
     object_utils.JSONConvertible,
     object_utils.MaybePartial,
-    object_utils.Formattable,
+    html.HtmlTreeView.Extension
 ):
   """Base for all symbolic types.
 
@@ -525,7 +527,7 @@ class Symbolic(
   def sym_contains(
       self,
       value: Any = None,
-      type: Union[None, Type[Any], Tuple[Type[Any]]] = None   # pylint: disable=redefined-builtin
+      type: Union[None, Type[Any], Tuple[Type[Any], ...]] = None   # pylint: disable=redefined-builtin
       ) -> bool:
     """Returns True if the object contains sub-nodes of given value or type."""
     return contains(self, value, type)
@@ -947,6 +949,42 @@ class Symbolic(
     """Serializes current object into a JSON string."""
     return to_json_str(self, json_indent=json_indent, **kwargs)
 
+  # pytype: disable=annotation-type-mismatch
+  def _html_tree_view_content(
+      self,
+      *,
+      view: html.HtmlTreeView,
+      name: Optional[str],
+      parent: Any,
+      root_path: object_utils.KeyPath,
+      hide_frozen: bool = html.HtmlView.PresetArgValue(True),
+      hide_default_values: bool = html.HtmlView.PresetArgValue(False),
+      use_inferred: bool = html.HtmlView.PresetArgValue(True),
+      **kwargs,
+  ) -> html.Html:
+  # pytype: enable=annotation-type-mismatch
+    """Returns the content HTML for a symbolic object.."""
+    kv = {}
+    for k, v in self.sym_items():
+      # Apply frozen filter.
+      field = self.sym_attr_field(k)
+      if hide_frozen and field and field.frozen:
+        continue
+
+      # Apply inferred value.
+      if use_inferred and isinstance(v, Inferential):
+        v = self.sym_inferred(k, default=v)
+
+      # Apply default value filter.
+      if field and hide_default_values and eq(v, field.default_value):
+        continue
+      kv[k] = v
+    return view.complex_value(
+        kv, name=name, parent=self, root_path=root_path,
+        hide_frozen=hide_frozen, hide_default_values=hide_default_values,
+        use_inferred=use_inferred, **kwargs
+    )
+
   @classmethod
   def load(cls, *args, **kwargs) -> Any:
     """Loads an instance of this type using the global load handler."""

pyglove-0.4.5.dev202410090808/pyglove/core/symbolic/base_test.py

@@ -0,0 +1,156 @@
+# Copyright 2022 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.
+"""Tests for pyglove.symbolic.base."""
+
+import copy
+import inspect
+from typing import Any
+import unittest
+
+from pyglove.core import object_utils
+from pyglove.core import typing as pg_typing
+from pyglove.core.symbolic import base
+from pyglove.core.symbolic.dict import Dict
+from pyglove.core.symbolic.inferred import ValueFromParentChain
+from pyglove.core.symbolic.object import Object
+
+
+class FieldUpdateTest(unittest.TestCase):
+  """Tests for `pg.symbolic.FieldUpdate`."""
+
+  def test_basics(self):
+    x = Dict(x=1)
+    f = pg_typing.Field('x', pg_typing.Int())
+    update = base.FieldUpdate(object_utils.KeyPath('x'), x, f, 1, 2)
+    self.assertEqual(update.path, 'x')
+    self.assertIs(update.target, x)
+    self.assertIs(update.field, f)
+    self.assertEqual(update.old_value, 1)
+    self.assertEqual(update.new_value, 2)
+
+  def test_format(self):
+    self.assertEqual(
+        base.FieldUpdate(
+            object_utils.KeyPath('x'), Dict(x=1), None, 1, 2
+        ).format(compact=True),
+        'FieldUpdate(parent_path=, path=x, old_value=1, new_value=2)',
+    )
+
+    self.assertEqual(
+        base.FieldUpdate(
+            object_utils.KeyPath('a'), Dict(x=Dict(a=1)).x, None, 1, 2
+        ).format(compact=True),
+        'FieldUpdate(parent_path=x, path=a, old_value=1, new_value=2)',
+    )
+
+  def test_eq_ne(self):
+    x = Dict()
+    f = pg_typing.Field('x', pg_typing.Int())
+    self.assertEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+    )
+
+    # Targets are not the same instance.
+    self.assertNotEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(object_utils.KeyPath('a'), Dict(), f, 1, 2),
+    )
+
+    # Fields are not the same instance.
+    self.assertNotEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(object_utils.KeyPath('b'), x, copy.copy(f), 1, 2),
+    )
+
+    self.assertNotEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 0, 2),
+    )
+
+    self.assertNotEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 1),
+    )
+
+    self.assertNotEqual(
+        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2), Dict()
+    )
+
+
+class HtmlFormattableTest(unittest.TestCase):
+
+  def assert_content(self, html, expected):
+    expected = inspect.cleandoc(expected).strip()
+    actual = html.content.strip()
+    if actual != expected:
+      print(actual)
+    self.assertEqual(actual.strip(), expected)
+
+  def test_to_html(self):
+
+    class Foo(Object):
+      x: int
+      y: Any = 'foo'
+      z: pg_typing.Int().freeze(1)
+
+    # Disable tooltip.
+    self.assert_content(
+        Foo(x=1, y='foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False
+        ),
+        """
+        <details open class="pyglove foo"><summary><div class="summary_title">Foo(...)</div></summary><div class="complex_value foo"><table><tr><td><span class="object_key">x</span></td><td><span class="simple_value int">1</span></td></tr><tr><td><span class="object_key">y</span></td><td><span class="simple_value str">&#x27;foo&#x27;</span></td></tr></table></div></details>
+        """
+    )
+    # Hide frozen and default values.
+    self.assert_content(
+        Foo(x=1, y='foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            collapse_level=0,
+            hide_frozen=True,
+            hide_default_values=True
+        ),
+        """
+        <details class="pyglove foo"><summary><div class="summary_title">Foo(...)</div></summary><div class="complex_value foo"><table><tr><td><span class="object_key">x</span></td><td><span class="simple_value int">1</span></td></tr></table></div></details>
+        """
+    )
+    # Use inferred values.
+    x = Dict(x=Dict(y=ValueFromParentChain()), y=2)
+    self.assert_content(
+        x.x.to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            use_inferred=False
+        ),
+        """
+        <details open class="pyglove dict"><summary><div class="summary_title">Dict(...)</div></summary><div class="complex_value dict"><table><tr><td><span class="object_key">y</span></td><td><details class="pyglove value-from-parent-chain"><summary><div class="summary_title">ValueFromParentChain(...)</div></summary><div class="complex_value value-from-parent-chain"><span class="empty_container"></span></div></details></td></tr></table></div></details>
+        """
+    )
+    self.assert_content(
+        x.x.to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            use_inferred=True
+        ),
+        """
+        <details open class="pyglove dict"><summary><div class="summary_title">Dict(...)</div></summary><div class="complex_value dict"><table><tr><td><span class="object_key">y</span></td><td><span class="simple_value int">2</span></td></tr></table></div></details>
+        """
+    )
+
+
+if __name__ == '__main__':
+  unittest.main()

{pyglove-0.4.5.dev202410020809 → pyglove-0.4.5.dev202410090808}/pyglove/core/symbolic/diff.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Symbolic differences."""
 
-from typing import Any, Callable, Tuple, Union
+from typing import Any, Callable, Optional, Sequence, Tuple, Union
 
 from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
@@ -21,6 +21,7 @@ from pyglove.core.symbolic import base
 from pyglove.core.symbolic import list as pg_list
 from pyglove.core.symbolic import object as pg_object
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic
+from pyglove.core.views import html
 
 
 class Diff(PureSymbolic, pg_object.Object):
@@ -144,6 +145,194 @@ class Diff(PureSymbolic, pg_object.Object):
           **kwargs,
       )
 
+  # pytype: disable=annotation-type-mismatch
+  def _html_tree_view_summary(
+      self,
+      *,
+      view: html.HtmlTreeView,
+      title: Optional[str] = None,
+      max_summary_len_for_str: int = html.HtmlView.PresetArgValue(40),
+      **kwargs,
+    ) -> Optional[html.Html]:
+  # pytype: enable=annotation-type-mismatch
+    if not bool(self):
+      v = self.value
+      if (isinstance(v, (int, float, bool, type(None)))
+          or (isinstance(v, str) and len(v) <= max_summary_len_for_str)):
+        return None
+
+      if v == Diff.MISSING:
+        return view.summary(
+            self,
+            title=title or 'Diff',
+            max_summary_len_for_str=max_summary_len_for_str,
+            **kwargs
+        )
+      return view.summary(
+          self.value,
+          title=title,
+          max_summary_len_for_str=max_summary_len_for_str,
+          **kwargs
+      )
+    elif self.is_leaf:
+      return None
+    else:
+      assert isinstance(self.left, type), self.left
+      assert isinstance(self.right, type), self.right
+      if self.left is self.right:
+        diff_title = self.left.__name__
+      else:
+        diff_title = f'{self.left.__name__} | {self.right.__name__}'
+      return view.summary(
+          self,
+          title=title or diff_title,
+          max_summary_len_for_str=max_summary_len_for_str,
+          **kwargs
+      )
+
+  def _html_tree_view_content(
+      self,
+      *,
+      view: html.HtmlTreeView,
+      parent: Any,
+      root_path: object_utils.KeyPath,
+      css_class: Optional[Sequence[str]] = None,
+      **kwargs
+  ) -> html.Html:
+    del parent
+    user_specified_css_class = css_class or []
+    if not bool(self):
+      if self.value == Diff.MISSING:
+        root = html.Html.element(
+            'span',
+            # CSS class already defined in HtmlTreeView.
+            css_class=['diff_empty'] + user_specified_css_class,
+        )
+      else:
+        # When there is no diff, but the same value needs to be displayed
+        # we simply return the value.
+        root = view.content(
+            self.value,
+            css_class=['diff_left', 'diff_right'] + user_specified_css_class,
+            root_path=root_path, **kwargs
+        )
+    elif self.is_leaf:
+      root = html.Html.element(
+          'div',
+          [
+              # Render left value.
+              lambda: html.Html.element(  # pylint: disable=g-long-ternary
+                  'div',
+                  [
+                      view.render(
+                          self.left, root_path=root_path + 'left', **kwargs
+                      )
+                  ],
+                  css_class=['diff_left'],
+              ) if self.left != Diff.MISSING else None,
+              # Render right value.
+              lambda: html.Html.element(  # pylint: disable=g-long-ternary
+                  'div',
+                  [
+                      view.render(
+                          self.right, root_path=root_path + 'right', **kwargs
+                      )
+                  ],
+                  css_class=['diff_right'],
+              )  if self.right != Diff.MISSING else None,
+          ],
+          css_class=['diff_value'] + user_specified_css_class,
+      )
+    else:
+      assert isinstance(self.left, type)
+      assert isinstance(self.right, type)
+
+      if issubclass(self.left, list):
+        key_fn = int
+      else:
+        key_fn = lambda k: k
+
+      s = html.Html()
+      for k, v in self.children.items():
+        k = key_fn(k)
+        child_path = root_path + k
+
+        s.write('<tr><td>')
+        # Print Key.
+        s.write(
+            view.object_key(
+                k, parent=v, root_path=child_path,
+                css_class=None if bool(v) else ['no_diff_key'],
+                **kwargs
+            ),
+        )
+        # Print Value.
+        s.write(
+            '</td><td>',
+            view.render(v, root_path=child_path, **kwargs),
+            '</td></tr>'
+        )
+      root = html.Html.element(
+          'div',
+          [
+              '<table>', s, '</table>'
+          ],
+          css_class=[
+              'complex_value', view.css_class_name(self.left)
+          ] + user_specified_css_class,
+      )
+    return root.add_style(
+        """
+        .diff .summary_title::after {
+          content: ' (diff)';
+          color: #aaa;
+        }
+        .diff .summary_title {
+          background-color: yellow;
+        }
+        .diff table td {
+          padding: 4px;
+        }
+        .diff_value {
+          display: inline-block;
+          align-items: center;
+        }
+        .no_diff_key {
+          opacity: 0.4;
+        }
+        .diff_left.diff_right::after {
+          content: '(no diff)';
+          margin-left: 0.5em;
+          color: #aaa;
+          font-style: italic;
+        }
+        .diff_empty::before {
+            content: '(empty)';
+            font-style: italic;
+            margin-left: 0.5em;
+            color: #aaa;
+        }
+        .diff_value .diff_left::before {
+          content: '🇱';
+        }
+        .diff_value .diff_left > .simple_value {
+          background-color: #ffcccc;
+        }
+        .diff_value .diff_left > details {
+          background-color: #ffcccc;
+        }
+        .diff_value .diff_right::before {
+          content: '🇷';
+        }
+        .diff_value .diff_right > .simple_value {
+          background-color: #ccffcc;
+        }
+        .diff_value .diff_right > details {
+          background-color: #ccffcc;
+        }
+        """
+    )
+
 
 # NOTE(daiyip): we add the symbolic attribute to Diff after its declaration
 # since we need to access Diff.MISSING as the default value for `left` and