pyglove 0.4.5.dev202501030808__py3-none-any.whl → 0.4.5.dev202501060809__py3-none-any.whl

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/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/tree_view.py

@@ -16,13 +16,13 @@
 import inspect
 from typing import Any, Callable, Dict, Iterable, Literal, Optional, Sequence, Tuple, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.symbolic import base as pg_symbolic
 from pyglove.core.views.html import base
 
 
-KeyPath = object_utils.KeyPath
-KeyPathSet = object_utils.KeyPathSet
+KeyPath = utils.KeyPath
+KeyPathSet = utils.KeyPathSet
 Html = base.Html
 HtmlView = base.HtmlView
 
@@ -940,10 +940,13 @@ class HtmlTreeView(HtmlView):
           return repr(value)
         else:
           return value
-      return object_utils.format(
+      return utils.format(
           value,
-          compact=False, verbose=False, hide_default_values=True,
-          python_format=True, use_inferred=True,
+          compact=False,
+          verbose=False,
+          hide_default_values=True,
+          python_format=True,
+          use_inferred=True,
           max_bytes_len=64,
       )
     return Html.element(
@@ -1257,7 +1260,7 @@ class HtmlTreeView(HtmlView):
     del parent, kwargs
     if content is None:
       content = Html.escape(
-          object_utils.format(
+          utils.format(
               value,
               root_path=root_path,
               compact=False,
@@ -1302,7 +1305,7 @@ class HtmlTreeView(HtmlView):
       class_name = f'{value.__name__}-class'
     else:
       class_name = type(value).__name__
-    return object_utils.camel_to_snake(class_name, '-')
+    return utils.camel_to_snake(class_name, '-')
 
   @staticmethod
   def init_uncollapse(
@@ -1341,40 +1344,40 @@ class HtmlTreeView(HtmlView):
   @staticmethod
   def get_passthrough_kwargs(
       *,
-      enable_summary: Optional[bool] = object_utils.MISSING_VALUE,
-      enable_summary_for_str: bool = object_utils.MISSING_VALUE,
-      max_summary_len_for_str: int = object_utils.MISSING_VALUE,
-      enable_summary_tooltip: bool = object_utils.MISSING_VALUE,
+      enable_summary: Optional[bool] = utils.MISSING_VALUE,
+      enable_summary_for_str: bool = utils.MISSING_VALUE,
+      max_summary_len_for_str: int = utils.MISSING_VALUE,
+      enable_summary_tooltip: bool = utils.MISSING_VALUE,
       key_style: Union[
           Literal['label', 'summary'],
-          Callable[[KeyPath, Any, Any], Literal['label', 'summary']]
-      ] = object_utils.MISSING_VALUE,
+          Callable[[KeyPath, Any, Any], Literal['label', 'summary']],
+      ] = utils.MISSING_VALUE,
       key_color: Union[
           Tuple[Optional[str], Optional[str]],
-          Callable[[KeyPath, Any, Any], Tuple[Optional[str], Optional[str]]]
-      ] = object_utils.MISSING_VALUE,
+          Callable[[KeyPath, Any, Any], Tuple[Optional[str], Optional[str]]],
+      ] = utils.MISSING_VALUE,
       include_keys: Union[
           Iterable[Union[int, str]],
           Callable[[KeyPath, Any, Any], Iterable[Union[int, str]]],
-          None
-      ] = object_utils.MISSING_VALUE,
+          None,
+      ] = utils.MISSING_VALUE,
       exclude_keys: Union[
           Iterable[Union[int, str]],
           Callable[[KeyPath, Any, Any], Iterable[Union[int, str]]],
-          None
-      ] = object_utils.MISSING_VALUE,
-      enable_key_tooltip: bool = object_utils.MISSING_VALUE,
+          None,
+      ] = utils.MISSING_VALUE,
+      enable_key_tooltip: bool = utils.MISSING_VALUE,
       uncollapse: Union[
           KeyPathSet, base.NodeFilter, None
-      ] = object_utils.MISSING_VALUE,
-      extra_flags: Optional[Dict[str, Any]] = object_utils.MISSING_VALUE,
-      highlight: Optional[base.NodeFilter] = object_utils.MISSING_VALUE,
-      lowlight: Optional[base.NodeFilter] = object_utils.MISSING_VALUE,
-      debug: bool = object_utils.MISSING_VALUE,
+      ] = utils.MISSING_VALUE,
+      extra_flags: Optional[Dict[str, Any]] = utils.MISSING_VALUE,
+      highlight: Optional[base.NodeFilter] = utils.MISSING_VALUE,
+      lowlight: Optional[base.NodeFilter] = utils.MISSING_VALUE,
+      debug: bool = utils.MISSING_VALUE,
       remove: Optional[Iterable[str]] = None,
       **kwargs,
   ):
-  # pytype: enable=annotation-type-mismatch
+    # pytype: enable=annotation-type-mismatch
     """Gets the rendering arguments to pass through to the child nodes."""
     del kwargs
     passthrough_kwargs = dict(
@@ -1386,23 +1389,22 @@ class HtmlTreeView(HtmlView):
         key_style=key_style,
         key_color=key_color,
         include_keys=(
-            include_keys if callable(include_keys)
-            else object_utils.MISSING_VALUE
+            include_keys if callable(include_keys) else utils.MISSING_VALUE
         ),
         exclude_keys=(
-            exclude_keys if callable(exclude_keys)
-            else object_utils.MISSING_VALUE
+            exclude_keys if callable(exclude_keys) else utils.MISSING_VALUE
         ),
         uncollapse=uncollapse,
         highlight=highlight,
         lowlight=lowlight,
         extra_flags=extra_flags,
-        debug=debug
+        debug=debug,
     )
     # Filter out missing values.
     passthrough_kwargs = {
-        k: v for k, v in passthrough_kwargs.items()
-        if v is not object_utils.MISSING_VALUE
+        k: v
+        for k, v in passthrough_kwargs.items()
+        if v is not utils.MISSING_VALUE
     }
     if remove:
       return {
@@ -1467,7 +1469,7 @@ class HtmlTreeView(HtmlView):
       )
 
     # Deep hierarchy merge.
-    return object_utils.merge_tree(call_kwargs, overriden_kwargs)
+    return utils.merge_tree(call_kwargs, overriden_kwargs)
 
   @staticmethod
   def merge_uncollapse(

{pyglove-0.4.5.dev202501030808.dist-info → pyglove-0.4.5.dev202501060809.dist-info}/METADATA

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