pyglove 0.4.5.dev202411132359__py3-none-any.whl → 0.4.5.dev202501250807__py3-none-any.whl

pyglove/core/utils/text_color_test.py

@@ -0,0 +1,94 @@
+# 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 os
+import unittest
+from pyglove.core.utils import text_color
+
+
+class TextColorTest(unittest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    os.environ.pop('ANSI_COLORS_DISABLED', None)
+    os.environ.pop('NO_COLOR', None)
+    os.environ['FORCE_COLOR'] = '1'
+
+  def test_colored_block_without_colors_and_styles(self):
+    self.assertEqual(text_color.colored_block('foo', '{{', '}}'), 'foo')
+
+  def test_colored_block(self):
+    original_text = inspect.cleandoc("""
+        Hi << foo >>
+        <# print x if x is present #>
+        <% if x %>
+        << x >>
+        <% endif %>
+        """)
+
+    colored_text = text_color.colored_block(
+        text_color.colored(original_text, color='blue'),
+        '<<', '>>',
+        color='white',
+        background='blue',
+    )
+    origin_color = '\x1b[34m'
+    reset = '\x1b[0m'
+    block_color = text_color.colored(
+        'TEXT', color='white', background='blue'
+    ).split('TEXT')[0]
+    self.assertEqual(
+        colored_text,
+        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.assertEqual(text_color.decolor(colored_text), original_text)
+
+  def test_colored_block_without_full_match(self):
+    self.assertEqual(
+        text_color.colored_block(
+            'Hi {{ foo',
+            '{{', '}}',
+            color='white',
+            background='blue',
+        ),
+        'Hi {{ foo'
+    )
+
+  def test_colored_block_without_termcolor(self):
+    termcolor = text_color.termcolor
+    text_color.termcolor = None
+    original_text = inspect.cleandoc("""
+        Hi {{ foo }}
+        {# print x if x is present #}
+        {% if x %}
+        {{ x }}
+        {% endif %}
+        """)
+
+    colored_text = text_color.colored_block(
+        text_color.colored(original_text, color='blue'),
+        '{{', '}}',
+        color='white',
+        background='blue',
+    )
+    self.assertEqual(colored_text, original_text)
+    self.assertEqual(text_color.decolor(colored_text), original_text)
+    text_color.termcolor = termcolor
+
+
+if __name__ == '__main__':
+  unittest.main()

pyglove/core/{object_utils → utils}/thread_local_test.py

@@ -11,13 +11,11 @@
 # 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.object_utils.thread_local."""
-
 import threading
 import time
 import unittest
 
-from pyglove.core.object_utils import thread_local
+from pyglove.core.utils import thread_local
 
 
 class ThreadLocalTest(unittest.TestCase):

pyglove/core/{object_utils → utils}/timing.py

@@ -18,9 +18,9 @@ import dataclasses
 import time
 from typing import Any, Dict, List, Optional
 
-from pyglove.core.object_utils import error_utils
-from pyglove.core.object_utils import json_conversion
-from pyglove.core.object_utils import thread_local
+from pyglove.core.utils import error_utils
+from pyglove.core.utils import json_conversion
+from pyglove.core.utils import thread_local
 
 
 class TimeIt:
@@ -56,6 +56,16 @@ class TimeIt:
           **kwargs,
       )
 
+    def merge(self, other: 'TimeIt.Status') -> 'TimeIt.Status':
+      """Merges the status of two `pg.timeit`."""
+      assert other.name == self.name, (self.name, other.name)
+      return TimeIt.Status(
+          name=self.name,
+          elapse=self.elapse + other.elapse,
+          has_ended=self.has_ended and other.has_ended,
+          error=self.error or other.error,
+      )
+
   @dataclasses.dataclass
   class StatusSummary(json_conversion.JSONConvertible):
     """Aggregated summary for repeated calls for `pg.timeit`."""
@@ -125,7 +135,7 @@ class TimeIt:
     self._name: str = name
     self._start_time: Optional[float] = None
     self._end_time: Optional[float] = None
-    self._child_contexts: Dict[str, TimeIt] = {}
+    self._child_contexts: List[TimeIt] = []
     self._error: Optional[error_utils.ErrorInfo] = None
     self._parent: Optional[TimeIt] = None
 
@@ -137,13 +147,11 @@ class TimeIt:
   @property
   def children(self) -> List['TimeIt']:
     """Returns child contexts."""
-    return list(self._child_contexts.values())
+    return self._child_contexts
 
   def add(self, context: 'TimeIt'):
     """Adds a child context."""
-    if context.name in self._child_contexts:
-      raise ValueError(f'`timeit` with name {context.name!r} already exists.')
-    self._child_contexts[context.name] = context
+    self._child_contexts.append(context)
 
   def start(self):
     """Starts timing."""
@@ -206,11 +214,14 @@ class TimeIt:
             has_ended=self.has_ended, error=self._error,
         )
     }
-    for child in self._child_contexts.values():
+    for child in self._child_contexts:
       child_result = child.status()
       for k, v in child_result.items():
         key = f'{self.name}.{k}' if self.name else k
-        result[key] = v
+        if key in result:
+          result[key] = result[key].merge(v)
+        else:
+          result[key] = v
     return result
 
   def __enter__(self):

pyglove/core/{object_utils → utils}/timing_test.py

@@ -11,12 +11,11 @@
 # 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 time
 import unittest
 
-from pyglove.core.object_utils import json_conversion
-from pyglove.core.object_utils import timing
+from pyglove.core.utils import json_conversion
+from pyglove.core.utils import timing
 
 
 class TimeItTest(unittest.TestCase):
@@ -63,9 +62,9 @@ class TimeItTest(unittest.TestCase):
         self.assertFalse(r['node.child'].has_ended)
         self.assertTrue(r['node.child.grandchild'].has_ended)
 
-        with self.assertRaisesRegex(ValueError, '.* already exists'):
-          with timing.timeit('grandchild'):
-            pass
+        with timing.timeit('grandchild') as t3:
+          time.sleep(0.5)
+        self.assertEqual(t1.children, [t2, t3])
 
     elapse2 = t.elapse
     self.assertTrue(t.has_ended)
@@ -73,17 +72,20 @@ class TimeItTest(unittest.TestCase):
     time.sleep(0.5)
     self.assertEqual(elapse2, t.elapse)
 
-    statuss = t.status()
+    status = t.status()
     self.assertEqual(
-        list(statuss.keys()),
+        list(status.keys()),
         ['node', 'node.child', 'node.child.grandchild']
     )
     self.assertEqual(
-        sorted([v.elapse for v in statuss.values()], reverse=True),
-        [v.elapse for v in statuss.values()],
+        status['node.child.grandchild'].elapse, t2.elapse + t3.elapse
+    )
+    self.assertEqual(
+        sorted([v.elapse for v in status.values()], reverse=True),
+        [v.elapse for v in status.values()],
     )
-    self.assertTrue(all(v.has_ended for v in statuss.values()))
-    self.assertFalse(any(v.has_error for v in statuss.values()))
+    self.assertTrue(all(v.has_ended for v in status.values()))
+    self.assertFalse(any(v.has_error for v in status.values()))
     status = t.status()
     json_dict = json_conversion.to_json(status)
     status2 = json_conversion.from_json(json_dict)

pyglove/core/{object_utils → utils}/value_location.py

@@ -17,7 +17,7 @@ import abc
 import copy as copy_lib
 import operator
 from typing import Any, Callable, Iterable, Iterator, List, Optional, Union
-from pyglove.core.object_utils import formatting
+from pyglove.core.utils import formatting
 
 
 class KeyPath(formatting.Formattable):
@@ -822,7 +822,7 @@ class StrKey(metaclass=abc.ABCMeta):
 
   Example::
 
-    class MyKey(pg.object_utils.StrKey):
+    class MyKey(pg.utils.StrKey):
 
       def __init__(self, name):
         self.name = name

pyglove/core/{object_utils → utils}/value_location_test.py

@@ -11,11 +11,9 @@
 # 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.object_utils.value_location."""
-
 import unittest
-from pyglove.core.object_utils import formatting
-from pyglove.core.object_utils import value_location
+from pyglove.core.utils import formatting
+from pyglove.core.utils import value_location
 
 
 KeyPath = value_location.KeyPath

pyglove/core/views/base.py

@@ -136,18 +136,18 @@ import types
 from typing import Any, Callable, Dict, Iterator, Optional, Sequence, Set, Type, Union
 
 from pyglove.core import io as pg_io
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 
 
 # Type definition for the value filter function.
 NodeFilter = Callable[
     [
-        object_utils.KeyPath,    # The path to the value.
-        Any,        # Current value.
-        Any,        # Parent value
+        utils.KeyPath,  # The path to the value.
+        Any,  # Current value.
+        Any,  # Parent value
     ],
-    bool            # Whether to include the value.
+    bool,  # Whether to include the value.
 ]
 
 
@@ -157,7 +157,7 @@ _TLS_KEY_OPERAND_STACK_BY_METHOD = '__view_operand_stack__'
 _TLS_KEY_VIEW_OPTIONS = '__view_options__'
 
 
-class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
+class Content(utils.Formattable, metaclass=abc.ABCMeta):
   """Content: A type of media to be displayed in a view.
 
   For example, `pg.Html` is a `Content` type that represents HTML to be
@@ -171,7 +171,7 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
       None
   ]
 
-  class SharedParts(object_utils.Formattable):
+  class SharedParts(utils.Formattable):
     """A part of the content that should appear just once.
 
     For example, `pg.Html.Styles` is a `SharedParts` type that represents
@@ -244,7 +244,7 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
         **kwargs
     ) -> str:
       if compact:
-        return object_utils.kvlist_str(
+        return utils.kvlist_str(
             [
                 ('parts', self._parts, {}),
             ],
@@ -252,7 +252,7 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
             compact=compact,
             verbose=verbose,
             root_indent=root_indent,
-            bracket_type=object_utils.BracketType.ROUND,
+            bracket_type=utils.BracketType.ROUND,
         )
       return self.content
 
@@ -363,17 +363,16 @@ class Content(object_utils.Formattable, metaclass=abc.ABCMeta):
     """Formats the Content object."""
     del kwargs
     if compact:
-      return object_utils.kvlist_str(
+      return utils.kvlist_str(
           [
               ('content', self.content, ''),
-          ] + [
-              (k, v, None) for k, v in self._shared_parts.items()
-          ],
+          ]
+          + [(k, v, None) for k, v in self._shared_parts.items()],
           label=self.__class__.__name__,
           compact=compact,
           verbose=verbose,
           root_indent=root_indent,
-          bracket_type=object_utils.BracketType.ROUND,
+          bracket_type=utils.BracketType.ROUND,
       )
     return self.to_str(content_only=content_only)
 
@@ -427,9 +426,9 @@ def view(
     value: Any,
     *,
     name: Optional[str] = None,
-    root_path: Optional[object_utils.KeyPath] = None,
+    root_path: Optional[utils.KeyPath] = None,
     view_id: str = 'html-tree-view',
-    **kwargs
+    **kwargs,
 ) -> Content:
   """Views an object through generating content based on a specific view.
 
@@ -451,8 +450,7 @@ def view(
   with view_options(**kwargs) as options:
     view_object = View.create(view_id)
     return view_object.render(
-        value, name=name, root_path=root_path or object_utils.KeyPath(),
-        **options
+        value, name=name, root_path=root_path or utils.KeyPath(), **options
     )
 
 
@@ -471,14 +469,14 @@ def view_options(**kwargs) -> Iterator[Dict[str, Any]]:
   Yields:
     The merged keyword arguments.
   """
-  parent_options = object_utils.thread_local_peek(_TLS_KEY_VIEW_OPTIONS, {})
+  parent_options = utils.thread_local_peek(_TLS_KEY_VIEW_OPTIONS, {})
   # Deep merge the two dict.
-  options = object_utils.merge([parent_options, kwargs])
-  object_utils.thread_local_push(_TLS_KEY_VIEW_OPTIONS, options)
+  options = utils.merge([parent_options, kwargs])
+  utils.thread_local_push(_TLS_KEY_VIEW_OPTIONS, options)
   try:
     yield options
   finally:
-    object_utils.thread_local_pop(_TLS_KEY_VIEW_OPTIONS)
+    utils.thread_local_pop(_TLS_KEY_VIEW_OPTIONS)
 
 
 class View(metaclass=abc.ABCMeta):
@@ -697,8 +695,8 @@ class View(metaclass=abc.ABCMeta):
       value: Any,
       *,
       name: Optional[str] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
-      **kwargs
+      root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
   ) -> Content:
     """Renders the input value.
 
@@ -789,20 +787,18 @@ class View(metaclass=abc.ABCMeta):
   ) -> Iterator[Any]:
     """Context manager for tracking the value being rendered."""
     del self
-    rendering_stack = object_utils.thread_local_get(
+    rendering_stack = utils.thread_local_get(
         _TLS_KEY_OPERAND_STACK_BY_METHOD, {}
     )
     callsite_value = rendering_stack.get(view_method, None)
     rendering_stack[view_method] = value
-    object_utils.thread_local_set(
-        _TLS_KEY_OPERAND_STACK_BY_METHOD, rendering_stack
-    )
+    utils.thread_local_set(_TLS_KEY_OPERAND_STACK_BY_METHOD, rendering_stack)
     try:
       yield callsite_value
     finally:
       if callsite_value is None:
         rendering_stack.pop(view_method)
         if not rendering_stack:
-          object_utils.thread_local_del(_TLS_KEY_OPERAND_STACK_BY_METHOD)
+          utils.thread_local_del(_TLS_KEY_OPERAND_STACK_BY_METHOD)
       else:
         rendering_stack[view_method] = callsite_value

pyglove/core/views/html/base.py

@@ -20,8 +20,8 @@ import inspect
 import typing
 from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union
 
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 from pyglove.core.views import base
 
 NestableStr = Union[
@@ -33,11 +33,11 @@ NestableStr = Union[
 NodeFilter = base.NodeFilter
 NodeColor = Callable[
     [
-        object_utils.KeyPath,    # The path to the value.
-        Any,        # Current value.
-        Any,        # Parent value
+        utils.KeyPath,  # The path to the value.
+        Any,  # Current value.
+        Any,  # Parent value
     ],
-    Optional[str]   # The color of the node.
+    Optional[str],  # The color of the node.
 ]
 
 
@@ -352,7 +352,7 @@ class Html(base.Content):
       cls,
       s: WritableTypes,
       javascript_str: bool = False
-  ) -> Union[str, 'Html', None]:
+  ) -> Any:
     """Escapes an HTML writable object."""
     if s is None:
       return None
@@ -386,7 +386,7 @@ class Html(base.Content):
       cls, nestable_str: NestableStr, separator: str = ' ', dedup: bool = True
   ) -> Optional[str]:
     """Concates the string nodes in a nestable object."""
-    flattened = object_utils.flatten(nestable_str)
+    flattened = utils.flatten(nestable_str)
     if isinstance(flattened, str):
       return flattened
     elif isinstance(flattened, dict):
@@ -456,8 +456,8 @@ class HtmlView(base.View):
       value: Any,
       *,
       name: Optional[str] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
-      **kwargs
+      root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
   ) -> Html:
     """Renders the input value into an HTML object."""
     # For customized HtmlConvertible objects, call their `to_html()` method.
@@ -473,8 +473,8 @@ class HtmlView(base.View):
       value: Any,
       *,
       name: Optional[str] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
-      **kwargs
+      root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
   ) -> Html:
     """View's implementation of HTML rendering."""
 
@@ -483,9 +483,9 @@ def to_html(
     value: Any,
     *,
     name: Optional[str] = None,
-    root_path: Optional[object_utils.KeyPath] = None,
+    root_path: Optional[utils.KeyPath] = None,
     view_id: str = 'html-tree-view',
-    **kwargs
+    **kwargs,
 ) -> Html:
   """Returns the HTML representation of a value.
 
@@ -517,10 +517,10 @@ def to_html_str(
     value: Any,
     *,
     name: Optional[str] = None,
-    root_path: Optional[object_utils.KeyPath] = None,
+    root_path: Optional[utils.KeyPath] = None,
     view_id: str = 'html-tree-view',
     content_only: bool = False,
-    **kwargs
+    **kwargs,
 ) -> str:
   """Returns a HTML str for a value.
 
@@ -545,4 +545,3 @@ def to_html_str(
       view_id=view_id,
       **kwargs
   ).to_str(content_only=content_only)
-

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

@@ -19,7 +19,7 @@ import inspect
 import sys
 from typing import Annotated, Any, Dict, Iterator, List, Optional, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.symbolic import object as pg_object
 from pyglove.core.views.html import base
 
@@ -62,6 +62,7 @@ class HtmlControl(pg_object.Object):
     super()._on_bound()
     self._rendered = False
     self._css_styles = []
+    self._dynamic_injected_css = set()
     self._scripts = []
 
   def add_style(self, *css: str) -> 'HtmlControl':
@@ -76,6 +77,7 @@ class HtmlControl(pg_object.Object):
   def to_html(self, **kwargs) -> Html:
     """Returns the HTML representation of the control."""
     self._rendered = True
+    self._dynamic_injected_css = set()
     html = self._to_html(**kwargs)
     return html.add_style(*self._css_styles).add_script(*self._scripts)
 
@@ -87,22 +89,22 @@ class HtmlControl(pg_object.Object):
   @contextlib.contextmanager
   def track_scripts(cls) -> Iterator[List[str]]:
     del cls
-    all_tracked = object_utils.thread_local_get(_TLS_TRACKED_SCRIPTS, [])
+    all_tracked = utils.thread_local_get(_TLS_TRACKED_SCRIPTS, [])
     current = []
     all_tracked.append(current)
-    object_utils.thread_local_set(_TLS_TRACKED_SCRIPTS, all_tracked)
+    utils.thread_local_set(_TLS_TRACKED_SCRIPTS, all_tracked)
     try:
       yield current
     finally:
       all_tracked.pop(-1)
       if not all_tracked:
-        object_utils.thread_local_del(_TLS_TRACKED_SCRIPTS)
+        utils.thread_local_del(_TLS_TRACKED_SCRIPTS)
 
   def _sync_members(self, **fields) -> None:
     """Synchronizes displayed values to members."""
     self.rebind(fields, skip_notification=True, raise_on_no_change=False)
 
-  def _run_javascript(self, code: str) -> None:
+  def _run_javascript(self, code: str, debug: bool = False) -> None:
     """Runs the given JavaScript code."""
     if not self.interactive:
       raise ValueError(
@@ -113,14 +115,50 @@ class HtmlControl(pg_object.Object):
       return
 
     code = inspect.cleandoc(code)
+    if debug:
+      print('RUN JAVSCRIPT:\n', code)
     if _notebook is not None:
       _notebook.display(_notebook.Javascript(code))
 
     # Track script execution.
-    all_tracked = object_utils.thread_local_get(_TLS_TRACKED_SCRIPTS, [])
+    all_tracked = utils.thread_local_get(_TLS_TRACKED_SCRIPTS, [])
     for tracked in all_tracked:
       tracked.append(code)
 
+  def _add_css_rules(self, css: str) -> None:
+    if not self._rendered or not css or css in self._dynamic_injected_css:
+      return
+    self._run_javascript(
+        f"""
+        const style = document.createElement('style');
+        style.type = 'text/css';
+        style.textContent = "{Html.escape(css, javascript_str=True)}";
+        document.head.appendChild(style);
+        """
+    )
+    self._dynamic_injected_css.add(css)
+
+  def _apply_css_rules(self, html: Html) -> None:
+    self._add_css_rules(html.styles.content)
+
+  def _insert_adjacent_html(
+      self,
+      element_selector_js: str,
+      html: Html,
+      var_name: str = 'elem',
+      position: str = 'beforeend'
+  ):
+    self._run_javascript(
+        f"""
+        {element_selector_js}
+        {var_name}.insertAdjacentHTML(
+            "{position}",
+            "{Html.escape(html, javascript_str=True).to_str(content_only=True)}"
+        );
+        """,
+    )
+    self._apply_css_rules(html)
+
   def element_id(self, child: Optional[str] = None) -> Optional[str]:
     """Returns the element id of this control or a child."""
     if self.id is not None:
@@ -163,14 +201,13 @@ class HtmlControl(pg_object.Object):
       child: Optional[str] = None,
   ) -> base.Html:
     """Updates the inner HTML of the control."""
-    js_html = Html.escape(html, javascript_str=True)
-    assert isinstance(js_html, Html), js_html
     self._run_javascript(
         f"""
         elem = document.getElementById("{self.element_id(child)}");
-        elem.innerHTML = "{js_html.to_str(content_only=True)}";
+        elem.innerHTML = "{Html.escape(html, javascript_str=True).to_str(content_only=True)}";
         """
     )
+    self._add_css_rules(html.styles.content)
     return html
 
   def _update_style(

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

@@ -74,7 +74,7 @@ class Label(HtmlControl):
 
   def _to_html(self, **kwargs) -> Html:
     text_elem = Html.element(
-        'a',
+        'a' if self.link is not None else 'span',
         [self.text],
         id=self.element_id(),
         href=self.link,
@@ -96,6 +96,8 @@ class Label(HtmlControl):
       tooltip: Union[str, Html, None] = None,
       link: Optional[str] = None,
       styles: Optional[Dict[str, Any]] = None,
+      add_class: Optional[List[str]] = None,
+      remove_class: Optional[List[str]] = None,
   ) -> None:
     if text is not None:
       self._sync_members(text=self._update_content(text))
@@ -105,7 +107,16 @@ class Label(HtmlControl):
       self._sync_members(link=self._update_property('href', link))
     if tooltip is not None:
       self.tooltip.update(content=tooltip)
-
+    if add_class or remove_class:
+      css_classes = list(self.css_classes)
+      for x in add_class or []:
+        self._add_css_class(x)
+        css_classes.append(x)
+      for x in remove_class or []:
+        self._remove_css_class(x)
+        if x in css_classes:
+          css_classes.remove(x)
+      self._sync_members(css_classes=css_classes)
 
 # Register converter for automatic conversion.
 pg_typing.register_converter(str, Label, Label)