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

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
@@ -324,6 +322,26 @@ class ObjectTest(unittest.TestCase):
     self.assertEqual(e.x, 1)
     self.assertEqual(e.y, 3)
 
+    class F(Object):
+      x: typing.Literal[1, 'a']
+
+    class G(F):
+      x: typing.Final[int] = 1
+      y: typing.ClassVar[int] = 2
+
+    self.assertEqual(G().x, 1)
+    self.assertEqual(G.y, 2)
+
+    with self.assertRaisesRegex(
+        ValueError, 'Frozen field is not assignable'):
+      G(x=2)
+
+    with self.assertRaisesRegex(
+        TypeError, 'Field x is marked as final but has no default value'):
+
+      class H(Object):  # pylint: disable=unused-variable
+        x: typing.Final[int]  # pylint: disable=invalid-name
+
   def test_init_arg_list(self):
 
     def _update_init_arg_list(cls, init_arg_list):
@@ -392,7 +410,7 @@ class ObjectTest(unittest.TestCase):
     _assert_init_arg_list(F, ['x', '*y'], ['x'], [], 'y')
 
   def test_forward_reference(self):
-    self.assertIs(Foo.schema.get_field('p').value.cls, Foo)
+    self.assertIs(Foo.__schema__.get_field('p').value.cls, Foo)
 
   def test_update_of_default_values(self):
 
@@ -782,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):
@@ -808,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))
@@ -1575,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')
@@ -1896,6 +1914,32 @@ class InheritanceTest(unittest.TestCase):
     self.assertEqual(d.x, 'foo')
     self.assertEqual(d.foo(), 'B')
 
+  def test_multi_inheritance2(self):
+
+    class A(Object):
+      x: typing.Callable[[], Any]
+
+    class B(A):
+      def x(self):
+        return 1
+
+    class C(A):
+      pass
+
+    class D(C, B):
+      pass
+
+    self.assertIs(D.__schema__['x'].default_value, B.x)
+
+    class E(A):
+      def x(self):
+        return 2
+
+    class F(E, B):
+      pass
+
+    self.assertIs(F.__schema__['x'].default_value, E.x)
+
 
 class InitSignatureTest(unittest.TestCase):
   """Tests for `pg.Object.__init__` signature."""
@@ -2055,7 +2099,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)
 
@@ -2349,7 +2393,7 @@ class RebindTest(unittest.TestCase):
       A(1).rebind({})
 
     with self.assertRaisesRegex(
-        KeyError, 'Key must be string type. Encountered 1'):
+        KeyError, 'Key 1 is not allowed for .*'):
       A(1).rebind({1: 1})
 
     with self.assertRaisesRegex(
@@ -2430,44 +2474,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, [])
@@ -2490,28 +2541,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,
@@ -2527,21 +2578,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,
@@ -2557,29 +2608,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 = []
@@ -2625,7 +2677,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):
 
@@ -2636,8 +2688,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)
@@ -3039,7 +3091,7 @@ class SerializationTest(unittest.TestCase):
 
   def test_serialization_with_json_convertible(self):
 
-    class Y(object_utils.JSONConvertible):
+    class Y(utils.JSONConvertible):
 
       TYPE_NAME = 'Y'
 
@@ -3059,7 +3111,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)
@@ -3266,9 +3318,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)`',
     )
@@ -3313,9 +3363,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("""
             ```
@@ -3482,10 +3535,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.
 

pyglove/core/symbolic/ref.py

@@ -14,16 +14,30 @@
 """Symbolic reference."""
 
 import functools
-import numbers
-from typing import Any, Callable, List, Optional, Tuple
-from pyglove.core import object_utils
+import typing
+from typing import Any, Callable, List, Optional, Tuple, Type
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 from pyglove.core.symbolic import base
-from pyglove.core.symbolic.object import Object
+from pyglove.core.symbolic import object as pg_object
 from pyglove.core.views.html import tree_view
 
 
-class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
+class RefMeta(pg_object.ObjectMeta):
+  """Metaclass for Ref."""
+
+  def __getitem__(cls, type_arg: Type[Any]) -> Any:    # pylint: disable=no-self-argument
+    if typing.TYPE_CHECKING:
+      return type_arg
+    return pg_typing.Object(type_arg, transform=Ref)
+
+
+class Ref(
+    pg_object.Object,
+    base.Inferential,
+    tree_view.HtmlTreeView.Extension,
+    metaclass=RefMeta
+):
   """Symbolic reference.
 
   When adding a symbolic node to a symbolic tree, it undergoes a copy operation
@@ -82,11 +96,11 @@ class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
 
   def __new__(cls, value: Any, **kwargs):
     del kwargs
-    if isinstance(value, (bool, numbers.Number, str)):
-      return value
-    return object.__new__(cls)
+    if isinstance(value, (base.Symbolic, list, dict)):
+      return object.__new__(cls)
+    return value
 
-  @object_utils.explicit_method_override
+  @utils.explicit_method_override
   def __init__(self, value: Any, **kwargs) -> None:
     super().__init__(**kwargs)
     if isinstance(value, Ref):
@@ -113,12 +127,13 @@ class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
 
   def custom_apply(
       self,
-      path: object_utils.KeyPath,
+      path: utils.KeyPath,
       value_spec: pg_typing.ValueSpec,
       allow_partial: bool = False,
-      child_transform: Optional[Callable[
-          [object_utils.KeyPath, pg_typing.Field, Any], Any]] = None
-      ) -> Tuple[bool, Any]:
+      child_transform: Optional[
+          Callable[[utils.KeyPath, pg_typing.Field, Any], Any]
+      ] = None,
+  ) -> Tuple[bool, Any]:
     """Validate candidates during value_spec binding time."""
     del child_transform
     # Check if the field being assigned could accept the referenced value.
@@ -152,9 +167,12 @@ class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
       root_indent: int = 0,
       **kwargs: Any,
   ) -> str:
-    value_str = object_utils.format(
+    value_str = utils.format(
         self._value,
-        compact=compact, verbose=verbose, root_indent=root_indent + 1)
+        compact=compact,
+        verbose=verbose,
+        root_indent=root_indent + 1,
+    )
     if compact:
       return f'{self.__class__.__name__}({value_str})'
     else:
@@ -241,4 +259,3 @@ def deref(value: base.Symbolic, recursive: bool = False) -> Any:
       return v
     return value.rebind(_deref, raise_on_no_change=False)
   return value
-

pyglove/core/symbolic/ref_test.py

@@ -16,6 +16,7 @@
 import copy
 import inspect
 import pickle
+import typing
 from typing import Any
 import unittest
 
@@ -202,6 +203,22 @@ class RefTest(unittest.TestCase):
         """
     )
 
+  def test_annotation(self):
+    typing.TYPE_CHECKING = True
+    assert ref.Ref[ValueError] is ValueError
+    typing.TYPE_CHECKING = False
+
+    class Bar(Object):
+      x: int
+
+    class Foo(Object):
+      y: ref.Ref[Bar]
+
+    f = Foo(Bar(1))
+    self.assertIsInstance(f.sym_getattr('y'), ref.Ref)
+    self.assertEqual(f.y.sym_path, '')
+    self.assertIsInstance(ref.Ref[Bar](1), ref.Ref)
+
 
 if __name__ == '__main__':
   unittest.main()

pyglove/core/tuning/local_backend.py

@@ -21,8 +21,8 @@ from typing import Any, Callable, Dict, List, Optional, Sequence
 
 from pyglove.core import geno
 from pyglove.core import logging
-from pyglove.core import object_utils
 from pyglove.core import symbolic
+from pyglove.core import utils
 from pyglove.core.tuning import backend
 from pyglove.core.tuning.early_stopping import EarlyStoppingPolicy
 from pyglove.core.tuning.protocols import Feedback
@@ -278,7 +278,7 @@ class _InMemoryResult(Result):
           ('step', self._best_trial.final_measurement.step),
           ('dna', self._best_trial.dna.format(compact=True))
       ])
-    return object_utils.format(json_repr, compact, False, root_indent, **kwargs)
+    return utils.format(json_repr, compact, False, root_indent, **kwargs)
 
 
 @backend.add_backend('in-memory')

pyglove/core/tuning/protocols.py

@@ -22,9 +22,9 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, Union
 
 from pyglove.core import geno
 from pyglove.core import logging
-from pyglove.core import object_utils
 from pyglove.core import symbolic
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 
 
 class _DataEntity(symbolic.Object):
@@ -116,7 +116,7 @@ class Trial(_DataEntity):
     return tuple(metric_values) if len(metric_values) > 1 else metric_values[0]
 
 
-class Result(object_utils.Formattable):
+class Result(utils.Formattable):
   """Interface for tuning result."""
 
   @property
@@ -416,7 +416,7 @@ class Feedback(metaclass=abc.ABCMeta):
       error_stack = traceback.format_exc()
       logging.warning('Skipping trial on unhandled exception: %s', error_stack)
       self.skip(error_stack)
-    return object_utils.catch_errors(exceptions, skip_on_exception)
+    return utils.catch_errors(exceptions, skip_on_exception)
 
   @contextlib.contextmanager
   def ignore_race_condition(self):