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

pyglove/core/symbolic/base_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.symbolic.base."""
-
 import copy
 import inspect
 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 import views
 from pyglove.core.symbolic import base
 from pyglove.core.symbolic.dict import Dict
@@ -33,7 +31,7 @@ class FieldUpdateTest(unittest.TestCase):
   def test_basics(self):
     x = Dict(x=1)
     f = pg_typing.Field('x', pg_typing.Int())
-    update = base.FieldUpdate(object_utils.KeyPath('x'), x, f, 1, 2)
+    update = base.FieldUpdate(utils.KeyPath('x'), x, f, 1, 2)
     self.assertEqual(update.path, 'x')
     self.assertIs(update.target, x)
     self.assertIs(update.field, f)
@@ -42,15 +40,15 @@ class FieldUpdateTest(unittest.TestCase):
 
   def test_format(self):
     self.assertEqual(
-        base.FieldUpdate(
-            object_utils.KeyPath('x'), Dict(x=1), None, 1, 2
-        ).format(compact=True),
+        base.FieldUpdate(utils.KeyPath('x'), Dict(x=1), None, 1, 2).format(
+            compact=True
+        ),
         'FieldUpdate(parent_path=, path=x, old_value=1, new_value=2)',
     )
 
     self.assertEqual(
         base.FieldUpdate(
-            object_utils.KeyPath('a'), Dict(x=Dict(a=1)).x, None, 1, 2
+            utils.KeyPath('a'), Dict(x=Dict(a=1)).x, None, 1, 2
         ).format(compact=True),
         'FieldUpdate(parent_path=x, path=a, old_value=1, new_value=2)',
     )
@@ -59,34 +57,34 @@ class FieldUpdateTest(unittest.TestCase):
     x = Dict()
     f = pg_typing.Field('x', pg_typing.Int())
     self.assertEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
     )
 
     # Targets are not the same instance.
     self.assertNotEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
-        base.FieldUpdate(object_utils.KeyPath('a'), Dict(), f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), Dict(), f, 1, 2),
     )
 
     # Fields are not the same instance.
     self.assertNotEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
-        base.FieldUpdate(object_utils.KeyPath('b'), x, copy.copy(f), 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('b'), x, copy.copy(f), 1, 2),
     )
 
     self.assertNotEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 0, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 0, 2),
     )
 
     self.assertNotEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2),
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 1),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2),
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 1),
     )
 
     self.assertNotEqual(
-        base.FieldUpdate(object_utils.KeyPath('a'), x, f, 1, 2), Dict()
+        base.FieldUpdate(utils.KeyPath('a'), x, f, 1, 2), Dict()
     )
 
 

pyglove/core/symbolic/boilerplate.py

@@ -15,11 +15,10 @@
 
 import copy
 import inspect
-
 from typing import Any, List, Optional, 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 flags
 from pyglove.core.symbolic import object as pg_object
 
@@ -129,9 +128,9 @@ def boilerplate_class(
   cls.auto_register = True
 
   allow_partial = value.allow_partial
-  def _freeze_field(path: object_utils.KeyPath,
-                    field: pg_typing.Field,
-                    value: Any) -> Any:
+  def _freeze_field(
+      path: utils.KeyPath, field: pg_typing.Field, value: Any
+  ) -> Any:
     # We do not do validation since Object is already in valid form.
     del path
     if not isinstance(field.key, pg_typing.ListKey):

pyglove/core/symbolic/class_wrapper.py

@@ -26,8 +26,8 @@ import types
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Type, Union
 
 from pyglove.core import detouring
-from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils
 
 from pyglove.core.symbolic import dict as pg_dict  # pylint: disable=unused-import
 from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
@@ -71,7 +71,7 @@ class _SubclassedWrapperBase(ClassWrapper):
   # the `__init__` method.
   auto_typing = False
 
-  @object_utils.explicit_method_override
+  @utils.explicit_method_override
   def __init__(self, *args, **kwargs):
     """Overridden __init__ to construct symbolic wrapper only."""
     # NOTE(daiyip): We avoid `__init__` to be called multiple times.
@@ -100,7 +100,7 @@ class _SubclassedWrapperBase(ClassWrapper):
   def __init_subclass__(cls):
     # Class wrappers inherit `__init__` from the user class. Therefore, we mark
     # all of them as explicitly overridden.
-    object_utils.explicit_method_override(cls.__init__)
+    utils.explicit_method_override(cls.__init__)
 
     super().__init_subclass__()
     if cls.__init__ is _SubclassedWrapperBase.__init__:
@@ -129,7 +129,7 @@ class _SubclassedWrapperBase(ClassWrapper):
       init_arg_list, arg_fields = _extract_init_signature(
           cls, auto_doc=cls.auto_doc, auto_typing=cls.auto_typing)
 
-      @object_utils.explicit_method_override
+      @utils.explicit_method_override
       @functools.wraps(cls.__init__)
       def _sym_init(self, *args, **kwargs):
         _SubclassedWrapperBase.__init__(self, *args, **kwargs)
@@ -522,7 +522,7 @@ def apply_wrappers(
   """
   if not wrapper_classes:
     wrapper_classes = []
-    for _, c in object_utils.JSONConvertible.registered_types():
+    for _, c in utils.JSONConvertible.registered_types():
       if (issubclass(c, ClassWrapper)
           and c not in (ClassWrapper, _SubclassedWrapperBase)
           and (not where or where(c))
@@ -544,13 +544,13 @@ def _extract_init_signature(
     # Read args docstr from both class doc string and __init__ doc string.
     args_docstr = dict()
     if cls.__doc__:
-      cls_docstr = object_utils.DocStr.parse(cls.__doc__)
+      cls_docstr = utils.DocStr.parse(cls.__doc__)
       args_docstr = cls_docstr.args
     if init_method.__doc__:
-      init_docstr = object_utils.DocStr.parse(init_method.__doc__)
+      init_docstr = utils.DocStr.parse(init_method.__doc__)
       args_docstr.update(init_docstr.args)
-    docstr = object_utils.DocStr(
-        object_utils.DocStrStyle.GOOGLE,
+    docstr = utils.DocStr(
+        utils.DocStrStyle.GOOGLE,
         short_description=None,
         long_description=None,
         examples=[],

pyglove/core/symbolic/compounding.py

@@ -19,7 +19,7 @@ import sys
 import types
 from typing import Any, Dict, List, Optional, Tuple, Type, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.symbolic.base import Symbolic
 from pyglove.core.symbolic.object import Object
 import pyglove.core.typing as pg_typing
@@ -39,7 +39,7 @@ class Compound(Object):
     # from the user class to compound with.
     Object.__init_subclass__(cls)
 
-  @object_utils.explicit_method_override
+  @utils.explicit_method_override
   def __init__(self, *args, **kwargs):
     # `explicit_init` allows the `__init__` of the other classes that sit after
     # `Compound` to be bypassed.

pyglove/core/symbolic/compounding_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.compounding."""
-
 import abc
 import dataclasses
 import sys
 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.compounding import compound as pg_compound
 from pyglove.core.symbolic.compounding import compound_class as pg_compound_class
 from pyglove.core.symbolic.dict import Dict
@@ -145,7 +143,7 @@ class UserClassTest(unittest.TestCase):
     class A(Object):
       x: int
 
-      @object_utils.explicit_method_override
+      @utils.explicit_method_override
       def __init__(self, x):
         super().__init__(x=x)
         assert type(self) is A  # pylint: disable=unidiomatic-typecheck

pyglove/core/symbolic/dict.py

@@ -16,8 +16,8 @@
 import typing
 from typing import Any, Callable, Iterable, Iterator, List, Optional, Sequence, Set, Tuple, Union
 
-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
 
@@ -96,14 +96,16 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
   """
 
   @classmethod
-  def partial(cls,
-              dict_obj: Optional[typing.Dict[Union[str, int], Any]] = None,
-              value_spec: Optional[pg_typing.Dict] = None,
-              *,
-              onchange_callback: Optional[Callable[
-                  [typing.Dict[object_utils.KeyPath, base.FieldUpdate]], None]
-              ] = None,  # pylint: disable=bad-continuation
-              **kwargs) -> 'Dict':
+  def partial(
+      cls,
+      dict_obj: Optional[typing.Dict[Union[str, int], Any]] = None,
+      value_spec: Optional[pg_typing.Dict] = None,
+      *,
+      onchange_callback: Optional[
+          Callable[[typing.Dict[utils.KeyPath, base.FieldUpdate]], None]
+      ] = None,  # pylint: disable=bad-continuation
+      **kwargs,
+  ) -> 'Dict':
     """Class method that creates a partial Dict object."""
     return cls(dict_obj,
                value_spec=value_spec,
@@ -112,13 +114,15 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
                **kwargs)
 
   @classmethod
-  def from_json(cls,
-                json_value: Any,
-                *,
-                value_spec: Optional[pg_typing.Dict] = None,
-                allow_partial: bool = False,
-                root_path: Optional[object_utils.KeyPath] = None,
-                **kwargs) -> 'Dict':
+  def from_json(
+      cls,
+      json_value: Any,
+      *,
+      value_spec: Optional[pg_typing.Dict] = None,
+      allow_partial: bool = False,
+      root_path: Optional[utils.KeyPath] = None,
+      **kwargs,
+  ) -> 'Dict':
     """Class method that load an symbolic Dict from a JSON value.
 
     Args:
@@ -156,27 +160,31 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         {
             k: base.from_json(
                 v,
-                root_path=object_utils.KeyPath(k, root_path),
+                root_path=utils.KeyPath(k, root_path),
                 allow_partial=allow_partial,
-                **kwargs
-            ) for k, v in json_value.items()
+                **kwargs,
+            )
+            for k, v in json_value.items()
         },
         value_spec=value_spec,
         root_path=root_path,
         allow_partial=allow_partial,
     )
 
-  def __init__(self,
-               dict_obj: Union[
-                   None,
-                   Iterable[Tuple[Union[str, int], Any]],
-                   typing.Dict[Union[str, int], Any]] = None,
-               *,
-               value_spec: Optional[pg_typing.Dict] = None,
-               onchange_callback: Optional[Callable[
-                   [typing.Dict[object_utils.KeyPath, base.FieldUpdate]], None]
-               ] = None,  # pylint: disable=bad-continuation
-               **kwargs):
+  def __init__(
+      self,
+      dict_obj: Union[
+          None,
+          Iterable[Tuple[Union[str, int], Any]],
+          typing.Dict[Union[str, int], Any],
+      ] = None,
+      *,
+      value_spec: Optional[pg_typing.Dict] = None,
+      onchange_callback: Optional[
+          Callable[[typing.Dict[utils.KeyPath, base.FieldUpdate]], None]
+      ] = None,  # pylint: disable=bad-continuation
+      **kwargs,
+  ):
     """Constructor.
 
     Args:
@@ -335,8 +343,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     return self
 
   def _sym_rebind(
-      self, path_value_pairs: typing.Dict[object_utils.KeyPath, Any]
-      ) -> List[base.FieldUpdate]:
+      self, path_value_pairs: typing.Dict[utils.KeyPath, Any]
+  ) -> List[base.FieldUpdate]:
     """Subclass specific rebind implementation."""
     updates = []
     for k, v in path_value_pairs.items():
@@ -360,7 +368,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         if keys:
           for key in keys:
             v = self.sym_getattr(key)
-            if object_utils.MISSING_VALUE == v:
+            if utils.MISSING_VALUE == v:
               missing[key] = field.value.default
             else:
               if isinstance(v, base.Symbolic):
@@ -514,14 +522,13 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         pass_through=True)
 
   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."""
     del old_path
     for k, v in self.sym_items():
       if isinstance(v, base.TopologyAware):
-        v.sym_setpath(object_utils.KeyPath(k, new_path))
+        v.sym_setpath(utils.KeyPath(k, new_path))
 
   def _set_item_without_permission_check(  # pytype: disable=signature-mismatch  # overriding-parameter-type-checks
       self, key: Union[str, int], value: Any) -> Optional[base.FieldUpdate]:
@@ -550,7 +557,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     # Detach old value from object tree.
     if isinstance(old_value, base.TopologyAware):
       old_value.sym_setparent(None)
-      old_value.sym_setpath(object_utils.KeyPath())
+      old_value.sym_setpath(utils.KeyPath())
 
     if (pg_typing.MISSING_VALUE == value and
         (not field or isinstance(field.key, pg_typing.NonConstKey))):
@@ -589,13 +596,15 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       value = base.from_json(
           value,
           allow_partial=allow_partial,
-          root_path=object_utils.KeyPath(name, self.sym_path))
+          root_path=utils.KeyPath(name, self.sym_path),
+      )
     if field and flags.is_type_check_enabled():
       value = field.apply(
           value,
           allow_partial=allow_partial,
           transform_fn=base.symbolic_transform_fn(self._allow_partial),
-          root_path=object_utils.KeyPath(name, self.sym_path))
+          root_path=utils.KeyPath(name, self.sym_path),
+      )
     return self._relocate_if_symbolic(name, value)
 
   @property
@@ -603,8 +612,9 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     """Returns True if current dict subscribes field updates."""
     return self._onchange_callback is not None
 
-  def _on_change(self, field_updates: typing.Dict[object_utils.KeyPath,
-                                                  base.FieldUpdate]):
+  def _on_change(
+      self, field_updates: typing.Dict[utils.KeyPath, base.FieldUpdate]
+  ):
     """On change event of Dict."""
     if self._onchange_callback:
       self._onchange_callback(field_updates)
@@ -814,8 +824,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       hide_default_values: bool = False,
       exclude_keys: Optional[Sequence[Union[str, int]]] = None,
       use_inferred: bool = False,
-      **kwargs
-  ) -> object_utils.JSONValueType:
+      **kwargs,
+  ) -> utils.JSONValueType:
     """Converts current object to a dict with plain Python objects."""
     exclude_keys = set(exclude_keys or [])
     if self._value_spec and self._value_spec.schema:
@@ -858,11 +868,12 @@ class Dict(dict, base.Symbolic, 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, 'Dict']:
     """Implement pg.typing.CustomTyping interface.
 
@@ -881,9 +892,12 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     if self._value_spec:
       if value_spec and not value_spec.is_compatible(self._value_spec):
         raise ValueError(
-            object_utils.message_on_path(
+            utils.message_on_path(
                 f'Dict (spec={self._value_spec!r}) cannot be assigned to an '
-                f'incompatible field (spec={value_spec!r}).', path))
+                f'incompatible field (spec={value_spec!r}).',
+                path,
+            )
+        )
       if self._allow_partial == allow_partial:
         proceed_with_standard_apply = False
       else:
@@ -906,7 +920,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       exclude_keys: Optional[Set[Union[str, int]]] = None,
       use_inferred: bool = False,
       cls_name: Optional[str] = None,
-      bracket_type: object_utils.BracketType = object_utils.BracketType.CURLY,
+      bracket_type: utils.BracketType = utils.BracketType.CURLY,
       key_as_attribute: bool = False,
       extra_blankline_for_field_docstr: bool = False,
       **kwargs,
@@ -948,7 +962,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             v = self.sym_inferred(k, default=v)
           field_list.append((None, k, v))
 
-    open_bracket, close_bracket = object_utils.bracket_chars(bracket_type)
+    open_bracket, close_bracket = utils.bracket_chars(bracket_type)
     if not field_list:
       return f'{cls_name}{open_bracket}{close_bracket}'
 
@@ -956,7 +970,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       s = [f'{cls_name}{open_bracket}']
       kv_strs = []
       for _, k, v in field_list:
-        v_str = object_utils.format(
+        v_str = utils.format(
             v,
             compact,
             verbose,
@@ -967,7 +981,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             python_format=python_format,
             use_inferred=use_inferred,
             extra_blankline_for_field_docstr=extra_blankline_for_field_docstr,
-            **kwargs)
+            **kwargs,
+        )
         if not python_format or key_as_attribute:
           if isinstance(k, int):
             k = f'[{k}]'
@@ -989,7 +1004,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
           description = typing.cast(pg_typing.Field, f).description
           for line in description.split('\n'):
             s.append(_indent(f'# {line}\n', root_indent + 1))
-        v_str = object_utils.format(
+        v_str = utils.format(
             v,
             compact,
             verbose,
@@ -1000,7 +1015,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             python_format=python_format,
             use_inferred=use_inferred,
             extra_blankline_for_field_docstr=extra_blankline_for_field_docstr,
-            **kwargs)
+            **kwargs,
+        )
 
         if not python_format:
           # Format in PyGlove's format (default).