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

pyglove/core/symbolic/ref.py

@@ -16,8 +16,8 @@
 import functools
 import typing
 from typing import Any, Callable, List, Optional, Tuple, Type
-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 object as pg_object
 from pyglove.core.views.html import tree_view
@@ -100,7 +100,7 @@ class Ref(
       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):
@@ -127,12 +127,13 @@ class Ref(
 
   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.
@@ -166,9 +167,12 @@ class Ref(
       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:

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):

pyglove/core/typing/annotation_conversion.py

@@ -18,7 +18,7 @@ import inspect
 import types
 import typing
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import annotated
 from pyglove.core.typing import class_schema
 from pyglove.core.typing import inspect as pg_inspect
@@ -73,7 +73,7 @@ def _value_spec_from_default_value(
   elif isinstance(value, tuple):
     value_spec = vs.Tuple(
         [_value_spec_from_default_value(elem, False) for elem in value])
-  elif inspect.isfunction(value) or isinstance(value, object_utils.Functor):
+  elif inspect.isfunction(value) or isinstance(value, utils.Functor):
     value_spec = vs.Callable()
   elif not isinstance(value, type):
     value_spec = vs.Object(type(value))
@@ -132,7 +132,7 @@ def _value_spec_from_type_annotation(
     return vs.Union([vs.List(elem), vs.Tuple(elem)])
   # Handling literals.
   elif origin is typing.Literal:
-    return vs.Enum(object_utils.MISSING_VALUE, args)
+    return vs.Enum(utils.MISSING_VALUE, args)
   # Handling dict.
   elif origin in (dict, typing.Dict, collections.abc.Mapping):
     if not args:

pyglove/core/typing/callable_ext.py

@@ -19,14 +19,14 @@ import inspect
 import types
 from typing import Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import callable_signature
 
 
 _TLS_KEY_PRESET_KWARGS = '__preset_kwargs__'
 
 
-class PresetArgValue(object_utils.Formattable):
+class PresetArgValue(utils.Formattable):
   """Value placeholder for arguments whose value will be provided by presets.
 
   Example:
@@ -39,12 +39,12 @@ class PresetArgValue(object_utils.Formattable):
     print(foo(x=1))  # 2: y=1
   """
 
-  def __init__(self, default: Any = object_utils.MISSING_VALUE):
+  def __init__(self, default: Any = utils.MISSING_VALUE):
     self.default = default
 
   @property
   def has_default(self) -> bool:
-    return self.default != object_utils.MISSING_VALUE
+    return self.default != utils.MISSING_VALUE
 
   def __eq__(self, other: Any) -> bool:
     return isinstance(other, PresetArgValue) and (
@@ -55,13 +55,13 @@ class PresetArgValue(object_utils.Formattable):
     return not self.__eq__(other)
 
   def format(self, *args, **kwargs):
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
-            ('default', self.default, object_utils.MISSING_VALUE),
+            ('default', self.default, utils.MISSING_VALUE),
         ],
         label='PresetArgValue',
         *args,
-        **kwargs
+        **kwargs,
     )
 
   @classmethod
@@ -182,15 +182,15 @@ def preset_args(
     Current preset kwargs.
   """
 
-  parent_presets = object_utils.thread_local_peek(
+  parent_presets = utils.thread_local_peek(
       _TLS_KEY_PRESET_KWARGS, _ArgPresets()
   )
   current_preset = parent_presets.derive(kwargs, preset_name, inherit_preset)
-  object_utils.thread_local_push(_TLS_KEY_PRESET_KWARGS, current_preset)
+  utils.thread_local_push(_TLS_KEY_PRESET_KWARGS, current_preset)
   try:
     yield current_preset
   finally:
-    object_utils.thread_local_pop(_TLS_KEY_PRESET_KWARGS, None)
+    utils.thread_local_pop(_TLS_KEY_PRESET_KWARGS, None)
 
 
 def enable_preset_args(
@@ -243,9 +243,7 @@ def enable_preset_args(
       @functools.wraps(func)
       def _func(*args, **kwargs):
         # Map positional arguments to keyword arguments.
-        presets = object_utils.thread_local_peek(
-            _TLS_KEY_PRESET_KWARGS, None
-        )
+        presets = utils.thread_local_peek(_TLS_KEY_PRESET_KWARGS, None)
         preset_kwargs = presets.get_preset(preset_name) if presets else {}
         args, kwargs = PresetArgValue.resolve_args(
             args, kwargs, positional_arg_names, arg_defaults, preset_kwargs,

pyglove/core/typing/callable_signature.py

@@ -22,7 +22,7 @@ import typing
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from pyglove.core import coding
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import class_schema
 from pyglove.core.typing import key_specs as ks
 
@@ -141,7 +141,7 @@ class CallableType(enum.Enum):
   METHOD = 2
 
 
-class Signature(object_utils.Formattable):
+class Signature(utils.Formattable):
   """PY3 function signature."""
 
   def __init__(self,
@@ -257,7 +257,7 @@ class Signature(object_utils.Formattable):
       **kwargs,
   ) -> str:
     """Format current object."""
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
             ('', self.id, ''),
             ('args', self.args, []),
@@ -271,7 +271,7 @@ class Signature(object_utils.Formattable):
         compact=compact,
         verbose=verbose,
         root_indent=root_indent,
-        **kwargs
+        **kwargs,
     )
 
   def annotate(
@@ -288,7 +288,7 @@ class Signature(object_utils.Formattable):
       return_value = class_schema.ValueSpec.from_annotation(
           return_value, auto_typing=True
       )
-      if object_utils.MISSING_VALUE != return_value.default:
+      if utils.MISSING_VALUE != return_value.default:
         raise ValueError('return value spec should not have default value.')
       self.return_value = return_value
 
@@ -337,12 +337,12 @@ class Signature(object_utils.Formattable):
           or field.value.default is None
       ):
         field.value.set_default(
-            arg.value_spec.default, root_path=object_utils.KeyPath(arg.name)
+            arg.value_spec.default, root_path=utils.KeyPath(arg.name)
         )
       if arg.value_spec.default != field.value.default:
         if field.value.is_noneable and not arg.value_spec.has_default:
-            # Special handling noneable which always comes with a default.
-          field.value.set_default(object_utils.MISSING_VALUE)
+          # Special handling noneable which always comes with a default.
+          field.value.set_default(utils.MISSING_VALUE)
         elif not (
             # Special handling Dict type which always has default.
             isinstance(field.value, class_schema.ValueSpec.DictType)
@@ -549,7 +549,7 @@ class Signature(object_utils.Formattable):
     if not callable(callable_object):
       raise TypeError(f'{callable_object!r} is not callable.')
 
-    if isinstance(callable_object, object_utils.Functor):
+    if isinstance(callable_object, utils.Functor):
       assert callable_object.__signature__ is not None
       return callable_object.__signature__
 
@@ -566,15 +566,15 @@ class Signature(object_utils.Formattable):
         description = None
         args_doc = {}
         if func.__doc__:
-          cls_doc = object_utils.DocStr.parse(func.__doc__)
+          cls_doc = utils.DocStr.parse(func.__doc__)
           description = cls_doc.short_description
           args_doc.update(cls_doc.args)
 
         if func.__init__.__doc__:
-          init_doc = object_utils.DocStr.parse(func.__init__.__doc__)
+          init_doc = utils.DocStr.parse(func.__init__.__doc__)
           args_doc.update(init_doc.args)
-        docstr = object_utils.DocStr(
-            object_utils.DocStrStyle.GOOGLE,
+        docstr = utils.DocStr(
+            utils.DocStrStyle.GOOGLE,
             short_description=description,
             long_description=None,
             examples=[],
@@ -593,7 +593,7 @@ class Signature(object_utils.Formattable):
           else CallableType.FUNCTION
       )
       if auto_doc:
-        docstr = object_utils.docstr(func)
+        docstr = utils.docstr(func)
       sig = inspect.signature(func)
 
     module_name = getattr(func, '__module__', None)
@@ -617,7 +617,7 @@ class Signature(object_utils.Formattable):
       module_name: Optional[str] = None,
       qualname: Optional[str] = None,
       auto_typing: bool = False,
-      docstr: Union[str, object_utils.DocStr, None] = None,
+      docstr: Union[str, utils.DocStr, None] = None,
       parent_module: Optional[types.ModuleType] = None,
   ) -> 'Signature':
     """Returns PyGlove signature from Python signature.
@@ -644,7 +644,7 @@ class Signature(object_utils.Formattable):
     varkw = None
 
     if isinstance(docstr, str):
-      docstr = object_utils.DocStr.parse(docstr)
+      docstr = utils.DocStr.parse(docstr)
 
     def make_arg_spec(param: inspect.Parameter) -> Argument:
       """Makes argument spec from inspect.Parameter."""
@@ -708,7 +708,7 @@ class Signature(object_utils.Formattable):
         force_missing_as_default: bool = False,
         arg_prefix: str = ''):
       s = [f'{arg_prefix}{arg_name}']
-      if arg_spec.annotation != object_utils.MISSING_VALUE:
+      if arg_spec.annotation != utils.MISSING_VALUE:
         s.append(f': _annotation_{arg_name}')
         exec_locals[f'_annotation_{arg_name}'] = arg_spec.annotation
       if not arg_prefix and (force_missing_as_default or arg_spec.has_default):
@@ -761,7 +761,8 @@ class Signature(object_utils.Formattable):
         exec_globals=exec_globals,
         exec_locals=exec_locals,
         return_type=getattr(
-            self.return_value, 'annotation', coding.NO_TYPE_ANNOTATION)
+            self.return_value, 'annotation', coding.NO_TYPE_ANNOTATION
+        ),
     )
     fn.__module__ = self.module_name
     fn.__name__ = self.name

pyglove/core/typing/callable_signature_test.py

@@ -11,15 +11,13 @@
 # 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.core.typing.callable_signature."""
-
 import copy
 import dataclasses
 import inspect
 from typing import List
 import unittest
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import annotation_conversion   # pylint: disable=unused-import
 from pyglove.core.typing import callable_signature
 from pyglove.core.typing import class_schema
@@ -628,8 +626,8 @@ class FromCallableTest(unittest.TestCase):
     self.assertIsNotNone(signature.varkw)
 
   def test_signature_with_forward_declarations(self):
-    signature = callable_signature.signature(object_utils.KeyPath)
-    self.assertIs(signature.get_value_spec('parent').cls, object_utils.KeyPath)
+    signature = callable_signature.signature(utils.KeyPath)
+    self.assertIs(signature.get_value_spec('parent').cls, utils.KeyPath)
 
 
 class FromSchemaTest(unittest.TestCase):

pyglove/core/typing/class_schema.py

@@ -20,10 +20,10 @@ import sys
 import types
 from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Set, Tuple, Type, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 
 
-class KeySpec(object_utils.Formattable, object_utils.JSONConvertible):
+class KeySpec(utils.Formattable, utils.JSONConvertible):
   """Interface for key specifications.
 
   A key specification determines what keys are acceptable for a symbolic
@@ -94,7 +94,7 @@ class KeySpec(object_utils.Formattable, object_utils.JSONConvertible):
     assert False, 'Overridden in `key_specs.py`.'
 
 
-class ForwardRef(object_utils.Formattable):
+class ForwardRef(utils.Formattable):
   """Forward type reference."""
 
   def __init__(self, module: types.ModuleType, name: str):
@@ -147,7 +147,7 @@ class ForwardRef(object_utils.Formattable):
       **kwargs
   ) -> str:
     """Format this object."""
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
             ('module', self.module.__name__, None),
             ('name', self.name, None),
@@ -180,7 +180,7 @@ class ForwardRef(object_utils.Formattable):
     return ForwardRef(self.module, self.name)
 
 
-class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
+class ValueSpec(utils.Formattable, utils.JSONConvertible):
   """Interface for value specifications.
 
   A value specification defines what values are acceptable for a symbolic
@@ -367,7 +367,7 @@ class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
       self,
       default: Any,
       use_default_apply: bool = True,
-      root_path: Optional[object_utils.KeyPath] = None
+      root_path: Optional[utils.KeyPath] = None,
   ) -> 'ValueSpec':
     """Sets the default value and returns `self`.
 
@@ -398,13 +398,14 @@ class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
   @property
   def has_default(self) -> bool:
     """Returns True if the default value is provided."""
-    return self.default != object_utils.MISSING_VALUE
+    return self.default != utils.MISSING_VALUE
 
   @abc.abstractmethod
   def freeze(
       self,
-      permanent_value: Any = object_utils.MISSING_VALUE,
-      apply_before_use: bool = True) -> 'ValueSpec':
+      permanent_value: Any = utils.MISSING_VALUE,
+      apply_before_use: bool = True,
+  ) -> 'ValueSpec':
     """Sets the default value using a permanent value and freezes current spec.
 
     A frozen value spec will not accept any value that is not the default
@@ -471,10 +472,11 @@ class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
       self,
       value: Any,
       allow_partial: bool = False,
-      child_transform: Optional[Callable[
-          [object_utils.KeyPath, 'Field', Any], Any]] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
-      ) -> Any:
+      child_transform: Optional[
+          Callable[[utils.KeyPath, 'Field', Any], Any]
+      ] = None,
+      root_path: Optional[utils.KeyPath] = None,
+  ) -> Any:
     """Validates, completes and transforms the input value.
 
     Here is the procedure of ``apply``::
@@ -551,7 +553,7 @@ class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
     assert False, 'Overridden in `annotation_conversion.py`.'
 
 
-class Field(object_utils.Formattable, object_utils.JSONConvertible):
+class Field(utils.Formattable, utils.JSONConvertible):
   """Class that represents the definition of one or a group of attributes.
 
   ``Field`` is held by a :class:`pyglove.Schema` object for defining the
@@ -681,9 +683,11 @@ class Field(object_utils.Formattable, object_utils.JSONConvertible):
       self,
       value: Any,
       allow_partial: bool = False,
-      transform_fn: Optional[Callable[
-          [object_utils.KeyPath, 'Field', Any], Any]] = None,
-      root_path: Optional[object_utils.KeyPath] = None) -> Any:
+      transform_fn: Optional[
+          Callable[[utils.KeyPath, 'Field', Any], Any]
+      ] = None,
+      root_path: Optional[utils.KeyPath] = None,
+  ) -> Any:
     """Apply current field to a value, which validate and complete the value.
 
     Args:
@@ -735,7 +739,7 @@ class Field(object_utils.Formattable, object_utils.JSONConvertible):
       **kwargs,
   ) -> str:
     """Format this field into a string."""
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
             ('key', self._key, None),
             ('value', self._value, None),
@@ -746,7 +750,7 @@ class Field(object_utils.Formattable, object_utils.JSONConvertible):
         compact=compact,
         verbose=verbose,
         root_indent=root_indent,
-        **kwargs
+        **kwargs,
     )
 
   def to_json(self, **kwargs: Any) -> Dict[str, Any]:
@@ -775,7 +779,7 @@ class Field(object_utils.Formattable, object_utils.JSONConvertible):
     return not self.__eq__(other)
 
 
-class Schema(object_utils.Formattable, object_utils.JSONConvertible):
+class Schema(utils.Formattable, utils.JSONConvertible):
   """Class that represents a schema.
 
   PyGlove's runtime type system is based on the concept of ``Schema`` (
@@ -959,13 +963,12 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
         parent_field: Field,
         child_field: Field) -> Field:
       """Merge function on field with the same key."""
-      if parent_field != object_utils.MISSING_VALUE:
-        if object_utils.MISSING_VALUE == child_field:
+      if parent_field != utils.MISSING_VALUE:
+        if utils.MISSING_VALUE == child_field:
           if (not self._allow_nonconst_keys and not parent_field.key.is_const):
-            hints = object_utils.kvlist_str([
-                ('base', base.name, None),
-                ('path', path, None)
-            ])
+            hints = utils.kvlist_str(
+                [('base', base.name, None), ('path', path, None)]
+            )
             raise ValueError(
                 f'Non-const key {parent_field.key} is not allowed to be '
                 f'added to the schema. ({hints})')
@@ -974,16 +977,15 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
           try:
             child_field.extend(parent_field)
           except Exception as e:  # pylint: disable=broad-except
-            hints = object_utils.kvlist_str([
-                ('base', base.name, None),
-                ('path', path, None)
-            ])
+            hints = utils.kvlist_str(
+                [('base', base.name, None), ('path', path, None)]
+            )
             raise e.__class__(f'{e} ({hints})').with_traceback(
                 sys.exc_info()[2])
       return child_field
 
-    self._fields = object_utils.merge([base.fields, self.fields], _merge_field)
-    self._metadata = object_utils.merge([base.metadata, self.metadata])
+    self._fields = utils.merge([base.fields, self.fields], _merge_field)
+    self._metadata = utils.merge([base.metadata, self.metadata])
 
     # Inherit dynamic field from base if it's not present in the child.
     if self._dynamic_field is None:
@@ -1106,8 +1108,8 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
       dict_obj: Dict[str, Any],
       allow_partial: bool = False,
       child_transform: Optional[Callable[
-          [object_utils.KeyPath, Field, Any], Any]] = None,
-      root_path: Optional[object_utils.KeyPath] = None,
+          [utils.KeyPath, Field, Any], Any]] = None,
+      root_path: Optional[utils.KeyPath] = None,
   ) -> Dict[str, Any]:  # pyformat: disable
     # pyformat: disable
     """Apply this schema to a dict object, validate and transform it.
@@ -1164,18 +1166,18 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
         keys.append(str(key_spec))
       for key in keys:
         if dict_obj:
-          value = dict_obj.get(key, object_utils.MISSING_VALUE)
+          value = dict_obj.get(key, utils.MISSING_VALUE)
         else:
-          value = object_utils.MISSING_VALUE
+          value = utils.MISSING_VALUE
         # NOTE(daiyip): field.default_value may be MISSING_VALUE too
         # or partial.
-        if object_utils.MISSING_VALUE == value:
+        if utils.MISSING_VALUE == value:
           value = copy.deepcopy(field.default_value)
         new_value = field.apply(
             value,
             allow_partial=allow_partial,
             transform_fn=child_transform,
-            root_path=object_utils.KeyPath(key, root_path)
+            root_path=utils.KeyPath(key, root_path),
         )
 
         # NOTE(daiyip): `pg.Dict.__getitem__`` has special logics in handling
@@ -1189,10 +1191,12 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
           dict_obj[key] = new_value
     return dict_obj
 
-  def validate(self,
-               dict_obj: Dict[str, Any],
-               allow_partial: bool = False,
-               root_path: Optional[object_utils.KeyPath] = None) -> None:
+  def validate(
+      self,
+      dict_obj: Dict[str, Any],
+      allow_partial: bool = False,
+      root_path: Optional[utils.KeyPath] = None,
+  ) -> None:
     """Validates whether dict object is conformed with the schema."""
     self.apply(
         copy.deepcopy(dict_obj),
@@ -1257,12 +1261,12 @@ class Schema(object_utils.Formattable, object_utils.JSONConvertible):
       root_indent: int = 0,
       *,
       cls_name: Optional[str] = None,
-      bracket_type: object_utils.BracketType = object_utils.BracketType.ROUND,
+      bracket_type: utils.BracketType = utils.BracketType.ROUND,
       fields_only: bool = False,
       **kwargs,
   ) -> str:
     """Format current Schema into nicely printed string."""
-    return object_utils.kvlist_str(
+    return utils.kvlist_str(
         [
             ('name', self.name, None),
             ('description', self.description, None),

pyglove/core/typing/class_schema_test.py

@@ -11,15 +11,13 @@
 # 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.core.typing.class_schema."""
-
 import copy
 import inspect
 import sys
 from typing import Optional, Union, List
 import unittest
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import annotation_conversion  # pylint: disable=unused-import
 from pyglove.core.typing import class_schema
 from pyglove.core.typing import custom_typing
@@ -204,7 +202,7 @@ class FieldTest(unittest.TestCase):
 
   def test_json_conversion(self):
     def assert_json_conversion(f):
-      self.assertEqual(object_utils.from_json(f.to_json()), f)
+      self.assertEqual(utils.from_json(f.to_json()), f)
 
     assert_json_conversion(Field('a', vs.Int()))
     assert_json_conversion(Field('a', vs.Int(), 'description'))
@@ -822,7 +820,7 @@ class SchemaTest(unittest.TestCase):
     schema = self._create_test_schema()
     schema.set_description('Foo')
     schema.set_name('Bar')
-    schema_copy = object_utils.from_json(schema.to_json())
+    schema_copy = utils.from_json(schema.to_json())
 
     # This compares fields only
     self.assertEqual(schema_copy, schema)

pyglove/core/typing/custom_typing.py

@@ -16,7 +16,7 @@
 import abc
 from typing import Any, Callable, Optional, Tuple
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import class_schema
 
 
@@ -34,11 +34,12 @@ class CustomTyping(metaclass=abc.ABCMeta):
   @abc.abstractmethod
   def custom_apply(
       self,
-      path: object_utils.KeyPath,
+      path: utils.KeyPath,
       value_spec: class_schema.ValueSpec,
       allow_partial: bool,
-      child_transform: Optional[Callable[
-          [object_utils.KeyPath, class_schema.Field, Any], Any]] = None
+      child_transform: Optional[
+          Callable[[utils.KeyPath, class_schema.Field, Any], Any]
+      ] = None,
   ) -> Tuple[bool, Any]:
     """Custom apply on a value based on its original value spec.