pyglove 0.4.5.dev202412100720__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.
 ]
 
 
@@ -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
 
@@ -89,16 +89,16 @@ 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."""
@@ -121,7 +121,7 @@ class HtmlControl(pg_object.Object):
       _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)
 

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,

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

@@ -34,7 +34,7 @@ class LabelTest(TestCase):
     label = label_lib.Label('foo')
     self.assertIsNone(label.tooltip)
     self.assertIsNone(label.link)
-    self.assert_html_content(label, '<a class="label">foo</a>')
+    self.assert_html_content(label, '<span class="label">foo</span>')
     with self.assertRaisesRegex(ValueError, 'Non-interactive .*'):
       label.update('bar')
 
@@ -54,7 +54,7 @@ class LabelTest(TestCase):
     self.assert_html_content(
         label,
         (
-            '<div class="label-container"><a class="label">foo</a>'
+            '<div class="label-container"><span class="label">foo</span>'
             '<span class="tooltip">bar</span></div>'
         )
     )
@@ -130,7 +130,7 @@ class LabelTest(TestCase):
 
   def test_badge(self):
     badge = label_lib.Badge('foo')
-    self.assert_html_content(badge, '<a class="label badge">foo</a>')
+    self.assert_html_content(badge, '<span class="label badge">foo</span>')
 
 
 class LabelGroupTest(TestCase):
@@ -140,9 +140,9 @@ class LabelGroupTest(TestCase):
     self.assert_html_content(
         group,
         (
-            '<div class="label-group"><a class="label group-name">baz</a>'
-            '<a class="label group-value">foo</a>'
-            '<a class="label group-value">bar</a></div>'
+            '<div class="label-group"><span class="label group-name">baz</span>'
+            '<span class="label group-value">foo</span>'
+            '<span class="label group-value">bar</span></div>'
         )
     )
 

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

@@ -16,7 +16,7 @@
 import functools
 from typing import Annotated, List, Optional, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.symbolic import object as pg_object
 # pylint: disable=g-importing-member
 from pyglove.core.views.html.base import Html
@@ -73,10 +73,8 @@ class SubProgress(HtmlControl):
         [],
         id=self.element_id(),
         styles=styles,
-        css_classes=[
-            'sub-progress',
-            object_utils.camel_to_snake(self.name, '-')
-        ] + self.css_classes,
+        css_classes=['sub-progress', utils.camel_to_snake(self.name, '-')]
+        + self.css_classes,
     )
 
   def increment(self, delta: int = 1):

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

@@ -42,8 +42,8 @@ class ProgressBarTest(unittest.TestCase):
             f'<div class="sub-progress foo" id="{bar["foo"].element_id()}">'
             '</div><div class="sub-progress bar" '
             f'id="{bar["bar"].element_id()}"></div></div>'
-            '<div class="label-container"><a class="label progress-label"'
-            f' id="{bar._progress_label.element_id()}">n/a</a><span class='
+            '<div class="label-container"><span class="label progress-label"'
+            f' id="{bar._progress_label.element_id()}">n/a</span><span class='
             f'"tooltip" id="{bar._progress_label.tooltip.element_id()}">'
             'Not started</span></div></div>'
         )