pyglove 0.4.5.dev202411030808__py3-none-any.whl → 0.4.5.dev202411060809__py3-none-any.whl

pyglove/core/__init__.py

@@ -309,6 +309,14 @@ Html = views.Html
 to_html = views.to_html
 to_html_str = views.to_html_str
 
+# NOTE(daiyip): Hack to add `controls` to `pg.views.html`.
+# We exclude `html.controls` from `pyglove.core.views.html` package to avoid
+# circular dependency between `pyglove.core.views.html` and
+# `pyglove.core.symbolic`.
+from pyglove.core.views.html import controls
+views.html.controls = controls
+
+
 #
 # Symbols from `io` sub-module.
 #

pyglove/core/symbolic/base.py

@@ -31,7 +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
+from pyglove.core.views.html.base import HtmlConvertible
 
 
 class WritePermissionError(Exception):
@@ -175,7 +175,7 @@ class Symbolic(
     object_utils.Formattable,
     object_utils.JSONConvertible,
     object_utils.MaybePartial,
-    html.HtmlTreeView.Extension
+    HtmlConvertible,
 ):
   """Base for all symbolic types.
 
@@ -949,42 +949,6 @@ class Symbolic(
     """Serializes current object into a JSON string."""
     return to_json_str(self, json_indent=json_indent, **kwargs)
 
-  def _html_tree_view_content(
-      self,
-      *,
-      view: html.HtmlTreeView,
-      name: Optional[str] = None,
-      parent: Any = None,
-      root_path: Optional[object_utils.KeyPath] = None,
-      extra_flags: Optional[Dict[str, Any]],
-      **kwargs,
-  ) -> html.Html:
-    """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.
-      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,
-        extra_flags=extra_flags, **kwargs
-    )
-
   @classmethod
   def load(cls, *args, **kwargs) -> Any:
     """Loads an instance of this type using the global load handler."""

pyglove/core/symbolic/diff.py

@@ -21,10 +21,10 @@ 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
+from pyglove.core.views.html import tree_view
 
 
-class Diff(PureSymbolic, pg_object.Object):
+class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
   """A value diff between two objects: a 'left' object and a 'right' object.
 
   If one of them is missing, it may be represented by pg.Diff.MISSING
@@ -149,12 +149,12 @@ class Diff(PureSymbolic, pg_object.Object):
   def _html_tree_view_summary(
       self,
       *,
-      view: html.HtmlTreeView,
+      view: tree_view.HtmlTreeView,
       css_classes: Optional[Sequence[str]] = None,
       title: Optional[str] = None,
       max_summary_len_for_str: int = 80,
       **kwargs,
-    ) -> Optional[html.Html]:
+    ) -> Optional[tree_view.Html]:
   # pytype: enable=annotation-type-mismatch
     if not bool(self):
       v = self.value
@@ -197,15 +197,16 @@ class Diff(PureSymbolic, pg_object.Object):
   def _html_tree_view_content(
       self,
       *,
-      view: html.HtmlTreeView,
-      parent: Any,
-      root_path: object_utils.KeyPath,
+      view: tree_view.HtmlTreeView,
+      parent: Any = None,
+      root_path: Optional[object_utils.KeyPath] = None,
       css_classes: Optional[Sequence[str]] = None,
       **kwargs
-  ) -> html.Html:
+  ) -> tree_view.Html:
+    root_path = root_path or object_utils.KeyPath()
     if not bool(self):
       if self.value == Diff.MISSING:
-        root = html.Html.element(
+        root = tree_view.Html.element(
             'span',
             # CSS class already defined in HtmlTreeView.
             css_classes=['diff-empty']
@@ -219,7 +220,7 @@ class Diff(PureSymbolic, pg_object.Object):
             **kwargs,
         )
     elif self.is_leaf:
-      root = html.Html.element(
+      root = tree_view.Html.element(
           'div',
           [
               view.render(   # pylint: disable=g-long-ternary
@@ -242,7 +243,7 @@ class Diff(PureSymbolic, pg_object.Object):
       else:
         key_fn = lambda k: k
 
-      s = html.Html()
+      s = tree_view.Html()
       for k, v in self.children.items():
         k = key_fn(k)
         child_path = root_path + k
@@ -263,7 +264,7 @@ class Diff(PureSymbolic, pg_object.Object):
             ),
             '</td></tr>'
         )
-      root = html.Html.element(
+      root = tree_view.Html.element(
           'div',
           [
               '<table>', s, '</table>'
@@ -275,7 +276,7 @@ class Diff(PureSymbolic, pg_object.Object):
     return root
 
   def _html_tree_view_config(self) -> dict[str, Any]:
-    return html.HtmlTreeView.get_kwargs(
+    return tree_view.HtmlTreeView.get_kwargs(
         super()._html_tree_view_config(),
         dict(
             css_classes=[

pyglove/core/symbolic/object_test.py

@@ -39,6 +39,7 @@ from pyglove.core.symbolic.object import use_init_args as pg_use_init_args
 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.html import tree_view  # pylint: disable=unused-import
 
 
 MISSING_VALUE = object_utils.MISSING_VALUE

pyglove/core/symbolic/ref.py

@@ -20,10 +20,10 @@ from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
 from pyglove.core.symbolic import base
 from pyglove.core.symbolic.object import Object
-from pyglove.core.views import html
+from pyglove.core.views.html import tree_view
 
 
-class Ref(Object, base.Inferential):
+class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
   """Symbolic reference.
 
   When adding a symbolic node to a symbolic tree, it undergoes a copy operation
@@ -167,17 +167,17 @@ class Ref(Object, base.Inferential):
   def _html_tree_view_content(
       self,
       *,
-      view: html.HtmlTreeView,
-      **kwargs: Any) -> html.Html:
+      view: tree_view.HtmlTreeView,
+      **kwargs: Any) -> tree_view.Html:
     """Overrides `_html_content` to render the referenced value."""
     return view.content(self._value, **kwargs)
 
   def _html_tree_view_summary(
       self,
       *,
-      view: html.HtmlTreeView,
+      view: tree_view.HtmlTreeView,
       title: Optional[str] = None,
-      **kwargs: Any) -> Optional[html.Html]:
+      **kwargs: Any) -> Optional[tree_view.Html]:
     """Overrides `_html_content` to render the referenced value."""
     return view.summary(
         self,
@@ -188,7 +188,7 @@ class Ref(Object, base.Inferential):
   @classmethod
   @functools.cache
   def _html_tree_view_config(cls) -> dict[str, Any]:
-    return html.HtmlTreeView.get_kwargs(
+    return tree_view.HtmlTreeView.get_kwargs(
         super()._html_tree_view_config(),
         dict(
             css_classes=['ref'],

pyglove/core/views/__init__.py

@@ -24,6 +24,7 @@ view_options = base.view_options
 NodeFilter = base.NodeFilter
 
 Html = html.Html
+HtmlConvertible = html.HtmlConvertible
 HtmlView = html.HtmlView
 HtmlTreeView = html.HtmlTreeView
 

pyglove/core/views/base.py

@@ -272,11 +272,10 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
     self._shared_parts = shared_parts
 
     for c in content:
+      c = self._to_content(c)
       if c is None:
         continue
-      if callable(c):
-        c = c()
-      if isinstance(c, str):
+      elif isinstance(c, str):
         self._content_stream.write(c)
       else:
         self.write(c)
@@ -306,9 +305,7 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
     """
     content_updated = False
     for p in parts:
-      if callable(p):
-        p = p()
-
+      p = self._to_content(p)
       if p is None:
         continue
 
@@ -342,8 +339,7 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
 
   def __add__(self, other: WritableTypes) -> 'Content':
     """Operator +: Concatenates two Content objects."""
-    if callable(other):
-      other = other()
+    other = self._to_content(other)
     if not other:
       return self
     s = copy_lib.deepcopy(self)
@@ -416,6 +412,16 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
       return value
     return cls(value)   # pytype: disable=not-instantiable
 
+  @classmethod
+  def _to_content(cls, value: WritableTypes) -> Union['Content', str, None]:
+    """Returns a Content object or None from a writable type."""
+    if callable(value):
+      value = value()
+    if value is None:
+      return None
+    assert isinstance(value, (str, cls)), value
+    return value
+
 
 def view(
     value: Any,

pyglove/core/views/base_test.py

@@ -1,4 +1,4 @@
-# Copyright 2024 The Langfun Authors
+# Copyright 2024 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.

pyglove/core/views/html/__init__.py

@@ -17,10 +17,10 @@
 # pylint: disable=g-bad-import-order
 
 from pyglove.core.views.html.base import Html
+from pyglove.core.views.html.base import HtmlConvertible
 from pyglove.core.views.html.base import HtmlView
 from pyglove.core.views.html.base import to_html
 from pyglove.core.views.html.base import to_html_str
-
 from pyglove.core.views.html.tree_view import HtmlTreeView
 
 # pylint: enable=g-bad-import-order

pyglove/core/views/html/base.py

@@ -1,4 +1,4 @@
-# Copyright 2024 The Langfun Authors
+# Copyright 2024 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.
@@ -86,7 +86,8 @@ class Html(base.Content):
   WritableTypes = Union[    # pylint: disable=invalid-name
       str,
       'Html',
-      Callable[[], Union[str, 'Html', None]],
+      'HtmlConvertible',
+      Callable[[], Union[str, 'Html', 'HtmlConvertible', None]],
       None
   ]
 
@@ -274,6 +275,20 @@ class Html(base.Content):
         Html, super().from_value(value, copy=copy)
     )
 
+  @classmethod
+  def _to_content(
+      cls, value: WritableTypes
+  ) -> Union['Html', str, None]:
+    if callable(value):
+      value = value()
+    if value is None:
+      return None
+    elif isinstance(value, HtmlConvertible):
+      value = value.to_html()
+    elif not isinstance(value, (str, cls)):
+      raise TypeError(f'Not a writable value for `{cls.__name__}`: {value!r}')
+    return value
+
   #
   # Helper methods for creating templated Html objects.
   #
@@ -337,13 +352,15 @@ class Html(base.Content):
       cls,
       s: WritableTypes,
       javascript_str: bool = False
-  ) -> WritableTypes:
+  ) -> Union[str, 'Html', None]:
     """Escapes an HTML writable object."""
     if s is None:
       return None
 
     if callable(s):
       s = s()
+    if isinstance(s, HtmlConvertible):
+      s = s.to_html()
 
     def _escape(s: str) -> str:
       if javascript_str:
@@ -413,87 +430,27 @@ class Html(base.Content):
 pg_typing.register_converter(str, Html, convert_fn=Html.from_value)
 
 
-class HtmlView(base.View):
-  """Base class for HTML views."""
+class HtmlConvertible:
+  """Base class for HTML convertible objects."""
 
-  class Extension(base.View.Extension):
-    """Base class for HtmlView extensions."""
+  def to_html(self, **kwargs) -> Html:
+    """Returns the HTML representation of the object."""
+    return to_html(self, **kwargs)
 
-    def _html_style(self) -> List[str]:
-      """Returns additional CSS style to add for this extension.
-
-      Subclasses can override this method to add additional CSS style to the
-      rendered HTML.
-      """
-      return []
-
-    def _html_element_class(self) -> List[str]:
-      """Returns the CSS classes for the rendered element for this node.
-
-      Subclasses can override this method to add CSS classes to the
-      rendered element of this object.
-      """
-      return [
-          object_utils.camel_to_snake(self.__class__.__name__, '-')
-      ]
-
-    def to_html(
-        self,
-        *,
-        name: Optional[str] = None,
-        root_path: Optional[object_utils.KeyPath] = None,
-        view_id: str = 'html-tree-view',
-        **kwargs
-    ) -> Html:
-      """Returns the HTML representation of the object.
-
-      Args:
-        name: The name of the object.
-        root_path: The root path of the object.
-        view_id: The ID of the view to render the value.
-          See `pg.views.HtmlView.dir()` for all available HTML view IDs.
-        **kwargs: View-specific keyword arguments passed to `pg.to_html`, wich
-          will be used to construct/override `HtmlView` settings.
-
-      Returns:
-        An rendered HTML.
-      """
-      return to_html(
-          self, name=name, root_path=root_path, view_id=view_id, **kwargs
-      )
+  def to_html_str(self, *, content_only: bool = False, **kwargs) -> str:
+    """Returns the HTML str of the object."""
+    return self.to_html(**kwargs).to_str(content_only=content_only)
 
-    def to_html_str(
-        self,
-        *,
-        name: Optional[str] = None,
-        root_path: Optional[object_utils.KeyPath] = None,
-        view_id: str = 'html-tree-view',
-        content_only: bool = False,
-        **kwargs
-    ) -> str:
-      """Returns the HTML str of the object.
-
-      Args:
-        name: The name of the object.
-        root_path: The root path of the object.
-        view_id: The ID of the view to render the value.
-          See `pg.views.HtmlView.dir()` for all available HTML view IDs.
-        content_only: If True, only the content will be returned.
-        **kwargs: View-specific keyword arguments passed to `pg.to_html`, wich
-          will be used to construct/override `HtmlView` settings.
-
-      Returns:
-        An rendered HTML str.
-      """
-      return to_html_str(
-          self, name=name, root_path=root_path,
-          view_id=view_id, content_only=content_only, **kwargs
-      )
+  def _repr_html_(self) -> str:
+    return self.to_html_str()
 
-    def _repr_html_(self) -> str:
-      return self.to_html_str()
 
-  @abc.abstractmethod
+class HtmlView(base.View):
+  """Base class for HTML views."""
+
+  class Extension(base.View.Extension, HtmlConvertible):
+    """Base class for HtmlView extensions."""
+
   def render(
       self,
       value: Any,
@@ -503,6 +460,23 @@ class HtmlView(base.View):
       **kwargs
   ) -> Html:
     """Renders the input value into an HTML object."""
+    # For customized HtmlConvertible objects, call their `to_html()` method.
+    if (isinstance(value, HtmlConvertible)
+        and not isinstance(value, self.__class__.Extension)
+        and value.__class__.to_html is not HtmlConvertible.to_html):
+      return value.to_html(name=name, root_path=root_path, **kwargs)
+    return self._render(value, name=name, root_path=root_path, **kwargs)
+
+  @abc.abstractmethod
+  def _render(
+      self,
+      value: Any,
+      *,
+      name: Optional[str] = None,
+      root_path: Optional[object_utils.KeyPath] = None,
+      **kwargs
+  ) -> Html:
+    """View's implementation of HTML rendering."""
 
 
 def to_html(

pyglove/core/views/html/base_test.py

@@ -1,4 +1,4 @@
-# Copyright 2024 The Langfun Authors
+# Copyright 2024 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.
@@ -422,6 +422,10 @@ class SharedPartTest(TestCase):
 
 class HtmlTest(TestCase):
 
+  class Foo(base.HtmlConvertible):
+    def to_html(self, **kwargs):
+      return base.Html('<h1>foo</h1>')
+
   def test_content_init(self):
     html = Html()
     self.assertEqual(html, Html())
@@ -446,6 +450,9 @@ class HtmlTest(TestCase):
     )
     self.assertEqual(html, Html('abcdefghi'))
 
+    html = Html(HtmlTest.Foo())
+    self.assertEqual(html, Html('<h1>foo</h1>'))
+
   def test_basics(self):
     html = Html(
         '<h1>foo</h1>',
@@ -583,7 +590,7 @@ class HtmlTest(TestCase):
     html2.write('<div class="c">bar</div>')
     html2.write('\n<script>\nconsole.log("bar");\n</script>')
 
-    html1.write('<div class="a">foo</div>')
+    html1.write(HtmlTest.Foo())
     html1.write('\n<script>\nconsole.log("foo");\n</script>\n')
     html1.write(html2)
 
@@ -603,7 +610,7 @@ class HtmlTest(TestCase):
         </script>
         </head>
         <body>
-        <div class="a">foo</div>
+        <h1>foo</h1>
         <script>
         console.log("foo");
         </script>
@@ -618,7 +625,7 @@ class HtmlTest(TestCase):
     self.assert_html(
         html1.to_str(content_only=True),
         """
-        <div class="a">foo</div>
+        <h1>foo</h1>
         <script>
         console.log("foo");
         </script>
@@ -641,6 +648,8 @@ class HtmlTest(TestCase):
     html2 = Html.from_value(html, copy=True)
     self.assertIsNot(html2, html)
     self.assertEqual(html2, html)
+    html3 = Html.from_value(HtmlTest.Foo())
+    self.assertEqual(html3, Html('<h1>foo</h1>'))
 
     with self.assertRaises(TypeError):
       Html.from_value(1)
@@ -694,9 +703,13 @@ class HtmlTest(TestCase):
     self.assertEqual(Html.escape('foo'), 'foo')
     self.assertEqual(Html.escape('foo"bar'), 'foo&quot;bar')
     self.assertEqual(Html.escape(Html('foo"bar')), Html('foo&quot;bar'))
+    self.assertEqual(Html.escape(HtmlTest.Foo()), Html('&lt;h1&gt;foo&lt;/h1&gt;'))
     self.assertEqual(Html.escape(lambda: 'foo"bar'), 'foo&quot;bar')
     self.assertEqual(Html.escape('"x=y"', javascript_str=True), '\\"x=y\\"')
     self.assertEqual(Html.escape('x\n"', javascript_str=True), 'x\\n\\"')
+    self.assertEqual(
+        Html.escape(HtmlTest.Foo(), javascript_str=True), Html('<h1>foo</h1>')
+    )
 
   def test_concate(self):
     self.assertIsNone(Html.concate(None))

pyglove/core/views/html/controls/__init__.py

@@ -0,0 +1,35 @@
+# Copyright 2024 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.
+"""Common HTML controls."""
+
+# pylint: disable=g-importing-member
+# pylint: disable=g-bad-import-order
+
+from pyglove.core.views.html.controls.base import HtmlControl
+
+
+from pyglove.core.views.html.controls.label import Label
+from pyglove.core.views.html.controls.label import LabelGroup
+from pyglove.core.views.html.controls.label import Badge
+
+from pyglove.core.views.html.controls.tooltip import Tooltip
+
+from pyglove.core.views.html.controls.tab import Tab
+from pyglove.core.views.html.controls.tab import TabControl
+
+from pyglove.core.views.html.controls.progress_bar import ProgressBar
+from pyglove.core.views.html.controls.progress_bar import SubProgress
+
+# pylint: enable=g-bad-import-order
+# pylint: enable=g-importing-member