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

pyglove/core/symbolic/object.py

@@ -20,8 +20,8 @@ import typing
 from typing import Any, Dict, Iterator, List, Optional, Sequence, Union
 
 from pyglove.core import coding
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 from pyglove.core.symbolic import base
 from pyglove.core.symbolic import dict as pg_dict
 from pyglove.core.symbolic import flags
@@ -116,7 +116,7 @@ class ObjectMeta(abc.ABCMeta):
 
     # Register class with 'type' property.
     for key in serialization_keys:
-      object_utils.JSONConvertible.register(
+      utils.JSONConvertible.register(
           key, cls, flags.is_repeated_class_registration_allowed()
       )
 
@@ -309,7 +309,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     Args:
       user_cls: The source class that calls this class method.
     """
-    object_utils.ensure_explicit_method_override(
+    utils.ensure_explicit_method_override(
         cls.__init__,
         (
             '`pg.Object.__init__` is a PyGlove managed method. For setting up '
@@ -317,7 +317,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
             '`_on_init()`. If you do have a need to override `__init__` and '
             'know the implications, please decorate your overridden method '
             'with `@pg.explicit_method_override`.'
-        ))
+        ),
+    )
 
     # Set `__serialization_key__` before JSONConvertible.__init_subclass__
     # is called.
@@ -363,11 +364,11 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     """Normalizes the schema before applying it."""
 
     schema.set_name(cls.__type_name__)
-    docstr = object_utils.docstr(cls)
+    docstr = utils.docstr(cls)
     if docstr:
       schema.set_description(docstr.description)
 
-    def _formalize_field(path: object_utils.KeyPath, node: Any) -> bool:
+    def _formalize_field(path: utils.KeyPath, node: Any) -> bool:
       """Formalize field."""
       if isinstance(node, pg_typing.Field):
         field = node
@@ -385,27 +386,29 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         if isinstance(field.value, pg_typing.Dict):
           if field.value.schema is not None:
             field.value.schema.set_name(f'{schema.name}.{path.path}')
-            object_utils.traverse(field.value.schema.fields, _formalize_field,
-                                  None, path)
+            utils.traverse(
+                field.value.schema.fields, _formalize_field, None, path
+            )
         elif isinstance(field.value, pg_typing.List):
-          _formalize_field(object_utils.KeyPath(0, path), field.value.element)
+          _formalize_field(utils.KeyPath(0, path), field.value.element)
         elif isinstance(field.value, pg_typing.Tuple):
           for i, elem in enumerate(field.value.elements):
-            _formalize_field(object_utils.KeyPath(i, path), elem)
+            _formalize_field(utils.KeyPath(i, path), elem)
         elif isinstance(field.value, pg_typing.Union):
           for i, c in enumerate(field.value.candidates):
             _formalize_field(
-                object_utils.KeyPath(i, path),
-                pg_typing.Field(field.key, c, 'Union sub-type.'))
+                utils.KeyPath(i, path),
+                pg_typing.Field(field.key, c, 'Union sub-type.'),
+            )
       return True
 
-    object_utils.traverse(schema.fields, _formalize_field)
+    utils.traverse(schema.fields, _formalize_field)
     return schema
 
   @classmethod
   def _finalize_init_arg_list(cls) -> List[str]:
     """Finalizes init_arg_list based on schema."""
-     # Update `init_arg_list`` based on the updated schema.
+    # Update `init_arg_list`` based on the updated schema.
     init_arg_list = cls.__schema__.metadata.get('init_arg_list', None)
     if init_arg_list is None:
       # Inherit from the first non-empty base if they have the same signature.
@@ -476,7 +479,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     # Create a new `__init__` that passes through all the arguments to
     # in `pg.Object.__init__`. This is needed for each class to use different
     # signature.
-    @object_utils.explicit_method_override
+    @utils.explicit_method_override
     @functools.wraps(pseudo_init)
     def _init(self, *args, **kwargs):
       # We pass through the arguments to `Object.__init__` instead of
@@ -539,8 +542,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
       json_value: Any,
       *,
       allow_partial: bool = False,
-      root_path: Optional[object_utils.KeyPath] = None,
-      **kwargs
+      root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
   ) -> 'Object':
     """Class method that load an symbolic Object from a JSON value.
 
@@ -588,15 +591,16 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         for k, v in json_value.items()
     })
 
-  @object_utils.explicit_method_override
+  @utils.explicit_method_override
   def __init__(
       self,
       *args,
       allow_partial: bool = False,
       sealed: Optional[bool] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
+      root_path: Optional[utils.KeyPath] = None,
       explicit_init: bool = False,
-      **kwargs):
+      **kwargs,
+  ):
     """Create an Object instance.
 
     Args:
@@ -638,8 +642,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     # Fill field_args and init_args from **kwargs.
     _, unmatched_keys = self.__class__.__schema__.resolve(list(kwargs.keys()))
     if unmatched_keys:
-      arg_phrase = object_utils.auto_plural(len(unmatched_keys), 'argument')
-      keys_str = object_utils.comma_delimited_str(unmatched_keys)
+      arg_phrase = utils.auto_plural(len(unmatched_keys), 'argument')
+      keys_str = utils.comma_delimited_str(unmatched_keys)
       raise TypeError(
           f'{self.__class__.__name__}.__init__() got unexpected '
           f'keyword {arg_phrase}: {keys_str}')
@@ -659,8 +663,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         field_args[vararg_name] = list(args[num_named_args:])
         args = args[:num_named_args]
       elif len(args) > len(init_arg_names):
-        arg_phrase = object_utils.auto_plural(len(init_arg_names), 'argument')
-        was_phrase = object_utils.auto_plural(len(args), 'was', 'were')
+        arg_phrase = utils.auto_plural(len(init_arg_names), 'argument')
+        was_phrase = utils.auto_plural(len(args), 'was', 'were')
         raise TypeError(
             f'{self.__class__.__name__}.__init__() takes '
             f'{len(init_arg_names)} positional {arg_phrase} but {len(args)} '
@@ -672,7 +676,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
 
     for k, v in kwargs.items():
       if k in field_args:
-        values_str = object_utils.comma_delimited_str([field_args[k], v])
+        values_str = utils.comma_delimited_str([field_args[k], v])
         raise TypeError(
             f'{self.__class__.__name__}.__init__() got multiple values for '
             f'argument \'{k}\': {values_str}.')
@@ -687,8 +691,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
             and field.key not in field_args):
           missing_args.append(str(field.key))
       if missing_args:
-        arg_phrase = object_utils.auto_plural(len(missing_args), 'argument')
-        keys_str = object_utils.comma_delimited_str(missing_args)
+        arg_phrase = utils.auto_plural(len(missing_args), 'argument')
+        keys_str = utils.comma_delimited_str(missing_args)
         raise TypeError(
             f'{self.__class__.__name__}.__init__() missing {len(missing_args)} '
             f'required {arg_phrase}: {keys_str}.')
@@ -738,8 +742,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     and during __init__.
     """
 
-  def _on_change(self,
-                 field_updates: Dict[object_utils.KeyPath, base.FieldUpdate]):
+  def _on_change(self, field_updates: Dict[utils.KeyPath, base.FieldUpdate]):
     """Event that is triggered when field values in the subtree are updated.
 
     This event will be called
@@ -759,8 +762,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     del field_updates
     return self._on_bound()
 
-  def _on_path_change(
-      self, old_path: object_utils.KeyPath, new_path: object_utils.KeyPath):
+  def _on_path_change(self, old_path: utils.KeyPath, new_path: utils.KeyPath):
     """Event that is triggered after the symbolic path changes."""
     del old_path, new_path
 
@@ -839,8 +841,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     return self._sym_attributes.sym_getattr(key)
 
   def _sym_rebind(
-      self, path_value_pairs: Dict[object_utils.KeyPath, Any]
-      ) -> List[base.FieldUpdate]:
+      self, path_value_pairs: Dict[utils.KeyPath, Any]
+  ) -> List[base.FieldUpdate]:
     """Rebind current object using object-form members."""
     if base.treats_as_sealed(self):
       raise base.WritePermissionError(
@@ -879,9 +881,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
     return self
 
   def _update_children_paths(
-      self,
-      old_path: object_utils.KeyPath,
-      new_path: object_utils.KeyPath) -> None:
+      self, old_path: utils.KeyPath, new_path: utils.KeyPath
+  ) -> None:
     """Update children paths according to root_path of current node."""
     self._sym_attributes.sym_setpath(new_path)
     self._on_path_change(old_path, new_path)
@@ -965,10 +966,10 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
       return self.sym_hash()
     return super().__hash__()
 
-  def sym_jsonify(self, **kwargs) -> object_utils.JSONValueType:
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
     """Converts current object to a dict of plain Python objects."""
     json_dict = {
-        object_utils.JSONConvertible.TYPE_NAME_KEY: (
+        utils.JSONConvertible.TYPE_NAME_KEY: (
             self.__class__.__serialization_key__
         )
     }
@@ -987,8 +988,9 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
         root_indent,
         cls_name=self.__class__.__name__,
         key_as_attribute=True,
-        bracket_type=object_utils.BracketType.ROUND,
-        **kwargs)
+        bracket_type=utils.BracketType.ROUND,
+        **kwargs,
+    )
 
 
 base.Symbolic.ObjectType = Object

pyglove/core/symbolic/object_test.py

@@ -11,8 +11,6 @@
 # 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."""
-
 import copy
 import inspect
 import io
@@ -23,8 +21,8 @@ import typing
 from typing import Any
 import unittest
 
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 from pyglove.core.symbolic import base
 from pyglove.core.symbolic import flags
 from pyglove.core.symbolic import inferred
@@ -42,7 +40,7 @@ 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
+MISSING_VALUE = utils.MISSING_VALUE
 
 
 class ObjectMetaTest(unittest.TestCase):
@@ -205,7 +203,7 @@ class ObjectTest(unittest.TestCase):
     ])
     class A(Object):
 
-      @object_utils.explicit_method_override
+      @utils.explicit_method_override
       def __init__(self, x):
         super().__init__(int(x))
 
@@ -214,7 +212,7 @@ class ObjectTest(unittest.TestCase):
 
     class B(A):
 
-      @object_utils.explicit_method_override
+      @utils.explicit_method_override
       def __init__(self, x):  # pylint: disable=super-init-not-called
         # Forgot to call super().__init__ will trigger error.
         self.x = x
@@ -802,8 +800,8 @@ class ObjectTest(unittest.TestCase):
     a = A(A(dict(y=A(1))))
     self.assertTrue(a.sym_has('x'))
     self.assertTrue(a.sym_has('x.x'))
-    self.assertTrue(a.sym_has(object_utils.KeyPath.parse('x.x.y')))
-    self.assertTrue(a.sym_has(object_utils.KeyPath.parse('x.x.y.x')))
+    self.assertTrue(a.sym_has(utils.KeyPath.parse('x.x.y')))
+    self.assertTrue(a.sym_has(utils.KeyPath.parse('x.x.y.x')))
     self.assertFalse(a.sym_has('y'))   # `y` is not a symbolic field.
 
   def test_sym_get(self):
@@ -828,10 +826,10 @@ class ObjectTest(unittest.TestCase):
     self.assertIs(a.sym_get('x'), a.x)
     self.assertIs(a.sym_get('p'), a.sym_getattr('p'))
     self.assertIs(a.sym_get('x.x'), a.x.x)
-    self.assertIs(a.sym_get(object_utils.KeyPath.parse('x.x.y')), a.x.x.y)
-    self.assertIs(a.sym_get(object_utils.KeyPath.parse('x.x.y.x')), a.x.x.y.x)
+    self.assertIs(a.sym_get(utils.KeyPath.parse('x.x.y')), a.x.x.y)
+    self.assertIs(a.sym_get(utils.KeyPath.parse('x.x.y.x')), a.x.x.y.x)
     self.assertIs(
-        a.sym_get(object_utils.KeyPath.parse('x.x.y.p')),
+        a.sym_get(utils.KeyPath.parse('x.x.y.p')),
         a.x.x.y.sym_getattr('p'),
     )
     self.assertIsNone(a.sym_get('x.x.y.q', use_inferred=True))
@@ -1595,7 +1593,7 @@ class ObjectTest(unittest.TestCase):
     self.assertEqual(a.x.x.x.sym_path, 'x.x.x')
     self.assertEqual(a.x.x.x[0].sym_path, 'x.x.x[0]')
 
-    a.sym_setpath(object_utils.KeyPath('a'))
+    a.sym_setpath(utils.KeyPath('a'))
     self.assertEqual(a.sym_path, 'a')
     self.assertEqual(a.x.sym_path, 'a.x')
     self.assertEqual(a.x.x.sym_path, 'a.x.x')
@@ -2075,7 +2073,7 @@ class InitSignatureTest(unittest.TestCase):
     class C(B):
       """Custom __init__."""
 
-      @object_utils.explicit_method_override
+      @utils.explicit_method_override
       def __init__(self, a, b):
         super().__init__(b, x=a)
 
@@ -2450,44 +2448,51 @@ class EventsTest(unittest.TestCase):
         [
             # Set default value from outer space (parent List) for field d1.
             {
-                'd1':
-                    base.FieldUpdate(
-                        path=object_utils.KeyPath.parse('a2.b1.c1[0].d1'),
-                        target=sd.a2.b1.c1[0],
-                        field=sd.a2.b1.c1[0].value_spec.schema['d1'],
-                        old_value=MISSING_VALUE,
-                        new_value='foo')
+                'd1': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d1'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d1'],
+                    old_value=MISSING_VALUE,
+                    new_value='foo',
+                )
             },
             # Set default value from outer space (parent List) for field d2.
             {
-                'd2':
-                    base.FieldUpdate(
-                        path=object_utils.KeyPath.parse('a2.b1.c1[0].d2'),
-                        target=sd.a2.b1.c1[0],
-                        field=sd.a2.b1.c1[0].value_spec.schema['d2'],
-                        old_value=MISSING_VALUE,
-                        new_value=True)
-            }
-        ])
+                'd2': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d2'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d2'],
+                    old_value=MISSING_VALUE,
+                    new_value=True,
+                )
+            },
+        ],
+    )
 
     # list get updated after bind with parent structures.
-    self.assertEqual(list_updates, [{
-        '[0].d1':
-            base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a2.b1.c1[0].d1'),
-                target=sd.a2.b1.c1[0],
-                field=sd.a2.b1.c1[0].value_spec.schema['d1'],
-                old_value=MISSING_VALUE,
-                new_value='foo')
-    }, {
-        '[0].d2':
-            base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a2.b1.c1[0].d2'),
-                target=sd.a2.b1.c1[0],
-                field=sd.a2.b1.c1[0].value_spec.schema['d2'],
-                old_value=MISSING_VALUE,
-                new_value=True)
-    }])
+    self.assertEqual(
+        list_updates,
+        [
+            {
+                '[0].d1': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d1'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d1'],
+                    old_value=MISSING_VALUE,
+                    new_value='foo',
+                )
+            },
+            {
+                '[0].d2': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d2'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d2'],
+                    old_value=MISSING_VALUE,
+                    new_value=True,
+                )
+            },
+        ],
+    )
 
     # There are no updates in root.
     self.assertEqual(root_updates, [])
@@ -2510,28 +2515,28 @@ class EventsTest(unittest.TestCase):
         root_updates[0],
         {
             'a1': base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a1'),
+                path=utils.KeyPath.parse('a1'),
                 target=sd,
                 field=sd.value_spec.schema['a1'],
                 old_value=MISSING_VALUE,
                 new_value=1,
             ),
             'a2.b1.c1[0].d1': base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a2.b1.c1[0].d1'),
+                path=utils.KeyPath.parse('a2.b1.c1[0].d1'),
                 target=sd.a2.b1.c1[0],
                 field=sd.a2.b1.c1[0].value_spec.schema['d1'],
                 old_value='foo',
                 new_value='bar',
             ),
             'a2.b1.c1[0].d2': base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a2.b1.c1[0].d2'),
+                path=utils.KeyPath.parse('a2.b1.c1[0].d2'),
                 target=sd.a2.b1.c1[0],
                 field=sd.a2.b1.c1[0].value_spec.schema['d2'],
                 old_value=True,
                 new_value=False,
             ),
             'a2.b1.c1[0].d3.z': base.FieldUpdate(
-                path=object_utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
+                path=utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
                 target=sd.a2.b1.c1[0].d3,
                 field=sd.a2.b1.c1[0].d3.__class__.__schema__['z'],
                 old_value=MISSING_VALUE,
@@ -2547,21 +2552,21 @@ class EventsTest(unittest.TestCase):
             # Root object rebind.
             {
                 '[0].d1': base.FieldUpdate(
-                    path=object_utils.KeyPath.parse('a2.b1.c1[0].d1'),
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d1'),
                     target=sd.a2.b1.c1[0],
                     field=sd.a2.b1.c1[0].value_spec.schema['d1'],
                     old_value='foo',
                     new_value='bar',
                 ),
                 '[0].d2': base.FieldUpdate(
-                    path=object_utils.KeyPath.parse('a2.b1.c1[0].d2'),
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d2'),
                     target=sd.a2.b1.c1[0],
                     field=sd.a2.b1.c1[0].value_spec.schema['d2'],
                     old_value=True,
                     new_value=False,
                 ),
                 '[0].d3.z': base.FieldUpdate(
-                    path=object_utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
                     target=sd.a2.b1.c1[0].d3,
                     field=sd.a2.b1.c1[0].d3.__class__.__schema__['z'],
                     old_value=MISSING_VALUE,
@@ -2577,29 +2582,30 @@ class EventsTest(unittest.TestCase):
         [
             # Root object rebind.
             {
-                'd1':
-                    base.FieldUpdate(
-                        path=object_utils.KeyPath.parse('a2.b1.c1[0].d1'),
-                        target=sd.a2.b1.c1[0],
-                        field=sd.a2.b1.c1[0].value_spec.schema['d1'],
-                        old_value='foo',
-                        new_value='bar'),
-                'd2':
-                    base.FieldUpdate(
-                        path=object_utils.KeyPath.parse('a2.b1.c1[0].d2'),
-                        target=sd.a2.b1.c1[0],
-                        field=sd.a2.b1.c1[0].value_spec.schema['d2'],
-                        old_value=True,
-                        new_value=False),
-                'd3.z':
-                    base.FieldUpdate(
-                        path=object_utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
-                        target=sd.a2.b1.c1[0].d3,
-                        field=sd.a2.b1.c1[0].d3.__class__.__schema__['z'],
-                        old_value=MISSING_VALUE,
-                        new_value='foo')
+                'd1': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d1'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d1'],
+                    old_value='foo',
+                    new_value='bar',
+                ),
+                'd2': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d2'),
+                    target=sd.a2.b1.c1[0],
+                    field=sd.a2.b1.c1[0].value_spec.schema['d2'],
+                    old_value=True,
+                    new_value=False,
+                ),
+                'd3.z': base.FieldUpdate(
+                    path=utils.KeyPath.parse('a2.b1.c1[0].d3.z'),
+                    target=sd.a2.b1.c1[0].d3,
+                    field=sd.a2.b1.c1[0].d3.__class__.__schema__['z'],
+                    old_value=MISSING_VALUE,
+                    new_value='foo',
+                ),
             }
-        ])
+        ],
+    )
 
   def test_on_change_notification_order(self):
     change_order = []
@@ -2645,7 +2651,7 @@ class EventsTest(unittest.TestCase):
     y.x = A()
     self.assertIs(x.old_parent, y)
     self.assertIsNone(x.new_parent)
-    self.assertEqual(x.sym_path, object_utils.KeyPath())
+    self.assertEqual(x.sym_path, utils.KeyPath())
 
   def test_on_path_change(self):
 
@@ -2656,8 +2662,8 @@ class EventsTest(unittest.TestCase):
         self.new_path = new_path
 
     x = A()
-    x.sym_setpath(object_utils.KeyPath('a'))
-    self.assertEqual(x.old_path, object_utils.KeyPath())
+    x.sym_setpath(utils.KeyPath('a'))
+    self.assertEqual(x.old_path, utils.KeyPath())
     self.assertEqual(x.new_path, 'a')
 
     y = Dict(x=x)
@@ -3059,7 +3065,7 @@ class SerializationTest(unittest.TestCase):
 
   def test_serialization_with_json_convertible(self):
 
-    class Y(object_utils.JSONConvertible):
+    class Y(utils.JSONConvertible):
 
       TYPE_NAME = 'Y'
 
@@ -3079,7 +3085,7 @@ class SerializationTest(unittest.TestCase):
       def from_json(cls, json_dict, *args, **kwargs):
         return cls(json_dict.pop('value'))
 
-    object_utils.JSONConvertible.register(Y.TYPE_NAME, Y)
+    utils.JSONConvertible.register(Y.TYPE_NAME, Y)
 
     a = self._A(Y(1), y=True)
     self.assertEqual(base.from_json_str(a.to_json_str()), a)
@@ -3286,9 +3292,7 @@ class FormatTest(unittest.TestCase):
 
   def test_compact_python_format(self):
     self.assertEqual(
-        object_utils.format(
-            self._a, compact=True, python_format=True, markdown=True
-        ),
+        utils.format(self._a, compact=True, python_format=True, markdown=True),
         "`A(x=[A(x=1, y=None), A(x='foo', y={'a': A(x=True, y=1.0)})], "
         'y=MISSING_VALUE)`',
     )
@@ -3333,9 +3337,12 @@ class FormatTest(unittest.TestCase):
 
   def test_noncompact_python_format(self):
     self.assertEqual(
-        object_utils.format(
-            self._a, compact=False, verbose=False, python_format=True,
-            markdown=True
+        utils.format(
+            self._a,
+            compact=False,
+            verbose=False,
+            python_format=True,
+            markdown=True,
         ),
         inspect.cleandoc("""
             ```
@@ -3502,10 +3509,10 @@ class FormatTest(unittest.TestCase):
         return f() if f is not None else None
       return fn
 
-    with object_utils.str_format(custom_format=_method('_repr_xml_')):
+    with utils.str_format(custom_format=_method('_repr_xml_')):
       self.assertEqual(str(Bar(Foo())), 'Bar(\n  foo = Foo()\n)')
 
-    with object_utils.str_format(custom_format=_method('_repr_html_')):
+    with utils.str_format(custom_format=_method('_repr_html_')):
       self.assertIn('<html>', str(Bar(Foo())))
 
 

pyglove/core/symbolic/origin.py

@@ -16,11 +16,11 @@
 import traceback
 from typing import Any, Callable, List, Optional
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.symbolic import flags
 
 
-class Origin(object_utils.Formattable):
+class Origin(utils.Formattable):
   """Class that represents the origin of a symbolic value.
 
   Origin is used for debugging the creation chain of a symbolic value, as
@@ -158,14 +158,12 @@ class Origin(object_utils.Formattable):
     if isinstance(self._source, (str, type(None))):
       source_str = self._source
     else:
-      source_info = object_utils.format(
+      source_info = utils.format(
           self._source, compact, verbose, root_indent + 1, **kwargs
       )
-      source_str = object_utils.RawText(
-          f'{source_info} at 0x{id(self._source):8x}'
-      )
+      source_str = utils.RawText(f'{source_info} at 0x{id(self._source):8x}')
 
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
             ('tag', self._tag, None),
             ('source', source_str, None),

pyglove/core/symbolic/pure_symbolic.py

@@ -14,8 +14,8 @@
 """Interfaces for pure symbolic objects."""
 
 from typing import Any, Callable, Optional, Tuple
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 
 
 class PureSymbolic(pg_typing.CustomTyping):
@@ -37,11 +37,12 @@ class PureSymbolic(pg_typing.CustomTyping):
 
   def custom_apply(
       self,
-      path: object_utils.KeyPath,
+      path: utils.KeyPath,
       value_spec: pg_typing.ValueSpec,
       allow_partial: bool,
       child_transform: Optional[
-          Callable[[object_utils.KeyPath, pg_typing.Field, Any], Any]] = None
+          Callable[[utils.KeyPath, pg_typing.Field, Any], Any]
+      ] = None,
   ) -> Tuple[bool, Any]:
     """Custom apply on a value based on its original value spec.