pyglove 0.4.5.dev202410170809__py3-none-any.whl → 0.4.5.dev202410180346__py3-none-any.whl

pyglove/core/__init__.py

@@ -302,6 +302,7 @@ timeit = object_utils.timeit
 
 from pyglove.core import views
 view = views.view
+view_options = views.view_options
 View = views.View
 Html = views.Html
 to_html = views.to_html

pyglove/core/symbolic/base.py

@@ -949,21 +949,22 @@ 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),
+      name: Optional[str] = None,
+      parent: Any = None,
+      root_path: Optional[object_utils.KeyPath] = None,
+      extra_flags: Optional[Dict[str, Any]],
       **kwargs,
   ) -> html.Html:
-  # pytype: enable=annotation-type-mismatch
     """Returns the content HTML for a symbolic object.."""
+    extra_flags = extra_flags or {}
+    hide_frozen = extra_flags.get('hide_frozen', True)
+    hide_default_values = extra_flags.get('hide_default_values', False)
+    use_inferred = extra_flags.get('use_inferred', False)
+
     kv = {}
     for k, v in self.sym_items():
       # Apply frozen filter.
@@ -981,8 +982,7 @@ class Symbolic(
       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
+        extra_flags=extra_flags, **kwargs
     )
 
   @classmethod

pyglove/core/symbolic/base_test.py

@@ -20,6 +20,7 @@ import unittest
 
 from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import views
 from pyglove.core.symbolic import base
 from pyglove.core.symbolic.dict import Dict
 from pyglove.core.symbolic.inferred import ValueFromParentChain
@@ -112,7 +113,7 @@ class HtmlTreeViewExtensionTest(unittest.TestCase):
             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 str">x</span></td><td><div><span class="simple_value int">1</span></div></td></tr><tr><td><span class="object_key str">y</span></td><td><div><span class="simple_value str">&#x27;foo&#x27;</span></div></td></tr></table></div></details>
+        <details open class="pyglove foo"><summary><div class="summary-title">Foo(...)</div></summary><div class="complex-value foo"><details open class="pyglove int"><summary><div class="summary-name">x</div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details><details open class="pyglove str"><summary><div class="summary-name">y</div><div class="summary-title">str</div></summary><span class="simple-value str">&#x27;foo&#x27;</span></details></div></details>
         """
     )
     # Hide frozen and default values.
@@ -121,11 +122,28 @@ class HtmlTreeViewExtensionTest(unittest.TestCase):
             enable_summary_tooltip=False,
             enable_key_tooltip=False,
             collapse_level=0,
-            hide_frozen=True,
-            hide_default_values=True
+            key_style='label',
+            extra_flags=dict(
+                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 str">x</span></td><td><div><span class="simple_value int">1</span></div></td></tr></table></div></details>
+        <details class="pyglove foo"><summary><div class="summary-title">Foo(...)</div></summary><div class="complex-value foo"><table><tr><td><span class="object-key str">x</span></td><td><span class="simple-value int">1</span></td></tr></table></div></details>
+        """
+    )
+    self.assert_content(
+        Foo(x=1, y='foo').to_html(
+            enable_summary_tooltip=False,
+            enable_key_tooltip=False,
+            collapse_level=0,
+            extra_flags=dict(
+                hide_frozen=True,
+                hide_default_values=True
+            )
+        ),
+        """
+        <details class="pyglove foo"><summary><div class="summary-title">Foo(...)</div></summary><div class="complex-value foo"><details open class="pyglove int"><summary><div class="summary-name">x</div><div class="summary-title">int</div></summary><span class="simple-value int">1</span></details></div></details>
         """
     )
     # Use inferred values.
@@ -134,22 +152,43 @@ class HtmlTreeViewExtensionTest(unittest.TestCase):
         x.x.to_html(
             enable_summary_tooltip=False,
             enable_key_tooltip=False,
-            use_inferred=False
+            key_style='label',
+            extra_flags=dict(
+                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 str">y</span></td><td><div><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></div></td></tr></table></div></details>
+        <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 str">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
+            key_style='label',
+            extra_flags=dict(
+                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 str">y</span></td><td><div><span class="simple_value int">2</span></div></td></tr></table></div></details>
+        <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 str">y</span></td><td><span class="simple-value int">2</span></td></tr></table></div></details>
         """
     )
+    # Test collapse level.
+    v = Foo(1, Foo(2, Foo(3, Foo(4))))
+    with views.view_options(key_style='label'):
+      self.assertEqual(
+          v.to_html(collapse_level=0).content.count('open'), 0
+      )
+      self.assertEqual(
+          v.to_html(collapse_level=1).content.count('open'), 1
+      )
+      self.assertEqual(
+          v.to_html(collapse_level=2).content.count('open'), 2
+      )
+      self.assertEqual(
+          v.to_html(collapse_level=None).content.count('open'), 4
+      )
 
 
 if __name__ == '__main__':

pyglove/core/symbolic/diff.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Symbolic differences."""
 
-from typing import Any, Callable, List, Optional, 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
@@ -150,8 +150,9 @@ class Diff(PureSymbolic, pg_object.Object):
       self,
       *,
       view: html.HtmlTreeView,
+      css_classes: Optional[Sequence[str]] = None,
       title: Optional[str] = None,
-      max_summary_len_for_str: int = html.HtmlView.PresetArgValue(40),
+      max_summary_len_for_str: int = 80,
       **kwargs,
     ) -> Optional[html.Html]:
   # pytype: enable=annotation-type-mismatch
@@ -165,12 +166,14 @@ class Diff(PureSymbolic, pg_object.Object):
         return view.summary(
             self,
             title=title or 'Diff',
+            css_classes=css_classes,
             max_summary_len_for_str=max_summary_len_for_str,
             **kwargs
         )
       return view.summary(
           self.value,
           title=title,
+          css_classes=css_classes,
           max_summary_len_for_str=max_summary_len_for_str,
           **kwargs
       )
@@ -186,6 +189,7 @@ class Diff(PureSymbolic, pg_object.Object):
       return view.summary(
           self,
           title=title or diff_title,
+          css_classes=css_classes,
           max_summary_len_for_str=max_summary_len_for_str,
           **kwargs
       )
@@ -196,6 +200,7 @@ class Diff(PureSymbolic, pg_object.Object):
       view: html.HtmlTreeView,
       parent: Any,
       root_path: object_utils.KeyPath,
+      css_classes: Optional[Sequence[str]] = None,
       **kwargs
   ) -> html.Html:
     if not bool(self):
@@ -203,46 +208,30 @@ class Diff(PureSymbolic, pg_object.Object):
         root = html.Html.element(
             'span',
             # CSS class already defined in HtmlTreeView.
-            css_class=['diff_empty']
+            css_classes=['diff-empty']
         )
       else:
         # When there is no diff, but the same value needs to be displayed
         # we simply return the value.
-        root = html.Html.element(
-            'div',
-            [
-                view.content(
-                    self.value, parent=parent, root_path=root_path, **kwargs,
-                )
-            ],
-            css_class=['diff_left', 'diff_right']
+        root = view.content(
+            self.value, parent=parent, root_path=root_path,
+            css_classes=['no-diff', view.css_class_name(self.value)],
+            **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'],
+              view.render(   # pylint: disable=g-long-ternary
+                  self.left, root_path=root_path + 'left',
+                  css_classes=['diff-left'], **kwargs
               ) 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,
+              view.render(   # pylint: disable=g-long-ternary
+                  self.right, root_path=root_path + 'right',
+                  css_classes=['diff-right'], **kwargs
+              ) if self.right != Diff.MISSING else None,
           ],
-          css_class=['diff_value']
+          css_classes=['diff-value']
       )
     else:
       assert isinstance(self.left, type)
@@ -257,20 +246,21 @@ class Diff(PureSymbolic, pg_object.Object):
       for k, v in self.children.items():
         k = key_fn(k)
         child_path = root_path + k
-
+        has_diff = bool(v)
         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
+                child_path, value=v, parent=self,
+                css_classes=None if has_diff else ['no-diff'],
             ),
         )
         # Print Value.
         s.write(
             '</td><td>',
-            view.render(v, root_path=child_path, **kwargs),
+            view.render(
+                v, root_path=child_path, **kwargs
+            ),
             '</td></tr>'
         )
       root = html.Html.element(
@@ -278,61 +268,65 @@ class Diff(PureSymbolic, pg_object.Object):
           [
               '<table>', s, '</table>'
           ],
-          css_class=[
-              'complex_value', view.css_class_name(self.left)
+          css_classes=[
+              'complex-value', view.css_class_name(self.left), css_classes,
           ]
       )
     return root
 
-  def _html_style(self) -> List[str]:
-    return [
+  def _html_tree_view_config(self) -> dict[str, Any]:
+    return html.HtmlTreeView.get_kwargs(
+        super()._html_tree_view_config(),
+        dict(
+            css_classes=[
+                'has-diff' if bool(self) else 'no-diff'
+            ]
+        )
+    )
+
+  @classmethod
+  def _html_tree_view_css_styles(cls) -> list[str]:
+    return super()._html_tree_view_css_styles() + [
         """
         /* Diff styles. */
-        .diff .summary_title::after {
+        .has-diff.summary-title::after {
           content: ' (diff)';
           color: #aaa;
         }
-        .diff .summary_title {
+        .has-diff.summary-title {
           background-color: yellow;
         }
-        .diff table td {
-          padding: 4px;
-        }
-        .diff_value {
-          display: inline-block;
-          align-items: center;
+        .no-diff.summary-title::after {
+          content: ' (no diff)';
+          font-style: italic;
+          font-weight: normal;
+          color: #aaa;
         }
-        .no_diff_key {
-          opacity: 0.4;
+        .no-diff {
+          opacity: 0.6;
         }
-        .diff_left.diff_right::after {
+        .no-diff.simple_value::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-empty::before {
+          content: '(empty)';
+          font-style: italic;
+          margin-left: 0.5em;
+          color: #aaa;
         }
-        .diff_value .diff_left::before {
+        .diff-left.summary-title::before, .diff-left.simple-value::before{
           content: '🇱';
         }
-        .diff_value .diff_left > .simple_value {
+        .diff-left {
           background-color: #ffcccc;
         }
-        .diff_value .diff_left > details {
-          background-color: #ffcccc;
-        }
-        .diff_value .diff_right::before {
+        .diff-right.summary-title::before, .diff-right.simple-value::before{
           content: '🇷';
         }
-        .diff_value .diff_right > .simple_value {
-          background-color: #ccffcc;
-        }
-        .diff_value .diff_right > details {
+        .diff-right {
           background-color: #ccffcc;
         }
         """