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

pyglove/core/symbolic/dict_test.py

@@ -11,16 +11,14 @@
 # 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.Dict."""
-
 import copy
 import inspect
 import io
 import pickle
 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
@@ -31,7 +29,7 @@ from pyglove.core.symbolic.pure_symbolic import NonDeterministic
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic
 
 
-MISSING_VALUE = object_utils.MISSING_VALUE
+MISSING_VALUE = utils.MISSING_VALUE
 
 
 class DictTest(unittest.TestCase):
@@ -799,7 +797,7 @@ class DictTest(unittest.TestCase):
     self.assertTrue(sd.sym_has('y.z'))
     self.assertTrue(sd.sym_has('[1].a'))
     self.assertTrue(sd.sym_has('y[2]'))
-    self.assertTrue(sd.sym_has(object_utils.KeyPath.parse('y.z')))
+    self.assertTrue(sd.sym_has(utils.KeyPath.parse('y.z')))
     self.assertFalse(sd.sym_has('x.z'))
 
   def test_sym_get(self):
@@ -1267,7 +1265,7 @@ class DictTest(unittest.TestCase):
     self.assertEqual(sd.x.a.sym_path, 'x.a')
     self.assertEqual(sd.y[0].b.sym_path, 'y[0].b')
 
-    sd.sym_setpath(object_utils.KeyPath('a'))
+    sd.sym_setpath(utils.KeyPath('a'))
     self.assertEqual(sd.sym_path, 'a')
     self.assertEqual(sd.x.sym_path, 'a.x')
     self.assertEqual(sd.x.a.sym_path, 'a.x.a')
@@ -1724,96 +1722,112 @@ class RebindTest(unittest.TestCase):
         'd': 'foo',  # Unchanged.
         'e': 'bar'
     })
-    self.assertEqual(updates, [
-        {  # Notification to `sd.c[0]`.
-            'p': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].p'),
-                target=sd.c[0],
-                field=None,
-                old_value=1,
-                new_value=MISSING_VALUE),
-            'q': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].q'),
-                target=sd.c[0],
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=2),
-        },
-        {  # Notification to `sd.c`.
-            '[0].p': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].p'),
-                target=sd.c[0],
-                field=None,
-                old_value=1,
-                new_value=MISSING_VALUE),
-            '[0].q': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].q'),
-                target=sd.c[0],
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=2),
-        },
-        {  # Notification to `sd.b.y`.
-            'z': base.FieldUpdate(
-                object_utils.KeyPath.parse('b.y.z'),
-                target=sd.b.y,
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=1),
-        },
-        {  # Notification to `sd.b`.
-            'x': base.FieldUpdate(
-                object_utils.KeyPath.parse('b.x'),
-                target=sd.b,
-                field=None,
-                old_value=1,
-                new_value=2),
-            'y.z': base.FieldUpdate(
-                object_utils.KeyPath.parse('b.y.z'),
-                target=sd.b.y,
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=1),
-        },
-        {  # Notification to `sd`.
-            'a': base.FieldUpdate(
-                object_utils.KeyPath.parse('a'),
-                target=sd,
-                field=None,
-                old_value=1,
-                new_value=2),
-            'b.x': base.FieldUpdate(
-                object_utils.KeyPath.parse('b.x'),
-                target=sd.b,
-                field=None,
-                old_value=1,
-                new_value=2),
-            'b.y.z': base.FieldUpdate(
-                object_utils.KeyPath.parse('b.y.z'),
-                target=sd.b.y,
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=1),
-            'c[0].p': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].p'),
-                target=sd.c[0],
-                field=None,
-                old_value=1,
-                new_value=MISSING_VALUE),
-            'c[0].q': base.FieldUpdate(
-                object_utils.KeyPath.parse('c[0].q'),
-                target=sd.c[0],
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value=2),
-            'e': base.FieldUpdate(
-                object_utils.KeyPath.parse('e'),
-                target=sd,
-                field=None,
-                old_value=MISSING_VALUE,
-                new_value='bar')
-        }
-    ])
+    self.assertEqual(
+        updates,
+        [
+            {  # Notification to `sd.c[0]`.
+                'p': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].p'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=1,
+                    new_value=MISSING_VALUE,
+                ),
+                'q': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].q'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=2,
+                ),
+            },
+            {  # Notification to `sd.c`.
+                '[0].p': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].p'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=1,
+                    new_value=MISSING_VALUE,
+                ),
+                '[0].q': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].q'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=2,
+                ),
+            },
+            {  # Notification to `sd.b.y`.
+                'z': base.FieldUpdate(
+                    utils.KeyPath.parse('b.y.z'),
+                    target=sd.b.y,
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=1,
+                ),
+            },
+            {  # Notification to `sd.b`.
+                'x': base.FieldUpdate(
+                    utils.KeyPath.parse('b.x'),
+                    target=sd.b,
+                    field=None,
+                    old_value=1,
+                    new_value=2,
+                ),
+                'y.z': base.FieldUpdate(
+                    utils.KeyPath.parse('b.y.z'),
+                    target=sd.b.y,
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=1,
+                ),
+            },
+            {  # Notification to `sd`.
+                'a': base.FieldUpdate(
+                    utils.KeyPath.parse('a'),
+                    target=sd,
+                    field=None,
+                    old_value=1,
+                    new_value=2,
+                ),
+                'b.x': base.FieldUpdate(
+                    utils.KeyPath.parse('b.x'),
+                    target=sd.b,
+                    field=None,
+                    old_value=1,
+                    new_value=2,
+                ),
+                'b.y.z': base.FieldUpdate(
+                    utils.KeyPath.parse('b.y.z'),
+                    target=sd.b.y,
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=1,
+                ),
+                'c[0].p': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].p'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=1,
+                    new_value=MISSING_VALUE,
+                ),
+                'c[0].q': base.FieldUpdate(
+                    utils.KeyPath.parse('c[0].q'),
+                    target=sd.c[0],
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value=2,
+                ),
+                'e': base.FieldUpdate(
+                    utils.KeyPath.parse('e'),
+                    target=sd,
+                    field=None,
+                    old_value=MISSING_VALUE,
+                    new_value='bar',
+                ),
+            },
+        ],
+    )
 
   def test_rebind_with_fn(self):
     sd = Dict(a=1, b=dict(x=2, y='foo', z=[0, 1, 2]))
@@ -2096,7 +2110,7 @@ class FormatTest(unittest.TestCase):
 
   def test_compact_python_format(self):
     self.assertEqual(
-        object_utils.format(
+        utils.format(
             self._dict, compact=True, python_format=True, markdown=True
         ),
         "`{'a1': 1, 'a2': {'b1': {'c1': [{'d1': MISSING_VALUE, "
@@ -2106,9 +2120,12 @@ class FormatTest(unittest.TestCase):
 
   def test_noncompact_python_format(self):
     self.assertEqual(
-        object_utils.format(
-            self._dict, compact=False, verbose=False,
-            python_format=True, markdown=True
+        utils.format(
+            self._dict,
+            compact=False,
+            verbose=False,
+            python_format=True,
+            markdown=True,
         ),
         inspect.cleandoc("""
             ```

pyglove/core/symbolic/diff.py

@@ -15,8 +15,8 @@
 
 from typing import Any, Callable, Optional, Sequence, 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 list as pg_list
 from pyglove.core.symbolic import object as pg_object
@@ -112,8 +112,7 @@ class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
         return 'No diff'
       # When there is no diff, but the same value needs to be displayed
       # we simply return the value.
-      return object_utils.format(
-          self.value, compact, verbose, root_indent, **kwargs)
+      return utils.format(self.value, compact, verbose, root_indent, **kwargs)
     if self.is_leaf:
       exclude_keys = kwargs.pop('exclude_keys', None)
       exclude_keys = exclude_keys or set()
@@ -129,7 +128,7 @@ class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
             verbose=verbose,
             root_indent=root_indent,
             cls_name='',
-            bracket_type=object_utils.BracketType.SQUARE,
+            bracket_type=utils.BracketType.SQUARE,
             **kwargs,
         )
       if self.left is self.right:
@@ -141,7 +140,7 @@ class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
           verbose=verbose,
           root_indent=root_indent,
           cls_name=cls_name,
-          bracket_type=object_utils.BracketType.ROUND,
+          bracket_type=utils.BracketType.ROUND,
           **kwargs,
       )
 
@@ -155,7 +154,7 @@ class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
       max_summary_len_for_str: int = 80,
       **kwargs,
     ) -> Optional[tree_view.Html]:
-  # pytype: enable=annotation-type-mismatch
+    # pytype: enable=annotation-type-mismatch
     if not bool(self):
       v = self.value
       if (isinstance(v, (int, float, bool, type(None)))
@@ -199,11 +198,11 @@ class Diff(PureSymbolic, pg_object.Object, tree_view.HtmlTreeView.Extension):
       *,
       view: tree_view.HtmlTreeView,
       parent: Any = None,
-      root_path: Optional[object_utils.KeyPath] = None,
+      root_path: Optional[utils.KeyPath] = None,
       css_classes: Optional[Sequence[str]] = None,
-      **kwargs
+      **kwargs,
   ) -> tree_view.Html:
-    root_path = root_path or object_utils.KeyPath()
+    root_path = root_path or utils.KeyPath()
     if not bool(self):
       if self.value == Diff.MISSING:
         root = tree_view.Html.element(
@@ -353,7 +352,8 @@ def diff(
     right: Any,
     flatten: bool = False,
     collapse: Union[bool, str, Callable[[Any, Any], bool]] = 'same_type',
-    mode: str = 'diff') -> object_utils.Nestable[Diff]:
+    mode: str = 'diff',
+) -> utils.Nestable[Diff]:
   """Inspect the symbolic diff between two objects.
 
   For example::
@@ -479,7 +479,7 @@ def diff(
       assert isinstance(container, base.Symbolic)
       return container.sym_hasattr, container.sym_getattr, container.sym_items
 
-  def _diff(x, y) -> Tuple[object_utils.Nestable[Diff], bool]:
+  def _diff(x, y) -> Tuple[utils.Nestable[Diff], bool]:
     if x is y or x == y:
       return (Diff(x, y), False)
     if not _should_collapse(x, y):
@@ -533,5 +533,5 @@ def diff(
   if not has_diff and mode == 'diff':
     diff_value = Diff()
   if flatten:
-    diff_value = object_utils.flatten(diff_value)
+    diff_value = utils.flatten(diff_value)
   return diff_value

pyglove/core/symbolic/flags.py

@@ -14,7 +14,7 @@
 """Global, thread-local and scoped flags for handling symbolic objects."""
 
 from typing import Any, Callable, ContextManager, Optional
-from pyglove.core.object_utils import thread_local
+from pyglove.core.utils import thread_local
 
 
 #

pyglove/core/symbolic/functor.py

@@ -22,14 +22,14 @@ import types
 import typing
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, Type, 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
 from pyglove.core.symbolic import object as pg_object
 
 
-class Functor(pg_object.Object, object_utils.Functor):
+class Functor(pg_object.Object, utils.Functor):
   """Symbolic functions (Functors).
 
   A symbolic function is a symbolic class with a ``__call__`` method, whose
@@ -124,7 +124,7 @@ class Functor(pg_object.Object, object_utils.Functor):
     if not hasattr(cls, '__orig_init__'):
       setattr(cls, '__orig_init__', cls.__init__)
 
-    @object_utils.explicit_method_override
+    @utils.explicit_method_override
     @functools.wraps(pseudo_init)
     def _init(self, *args, **kwargs):
       self.__class__.__orig_init__(self, *args, **kwargs)
@@ -148,14 +148,15 @@ class Functor(pg_object.Object, object_utils.Functor):
       return instance()
     return instance
 
-  @object_utils.explicit_method_override
+  @utils.explicit_method_override
   def __init__(
       self,
       *args,
-      root_path: Optional[object_utils.KeyPath] = None,
+      root_path: Optional[utils.KeyPath] = None,
       override_args: bool = False,
       ignore_extra_args: bool = False,
-      **kwargs):
+      **kwargs,
+  ):
     """Constructor.
 
     Args:
@@ -182,8 +183,8 @@ class Functor(pg_object.Object, object_utils.Functor):
         varargs = list(args[len(signature.args) :])
         args = args[: len(signature.args)]
       else:
-        arg_phrase = object_utils.auto_plural(len(signature.args), 'argument')
-        was_phrase = object_utils.auto_plural(len(args), 'was', 'were')
+        arg_phrase = utils.auto_plural(len(signature.args), 'argument')
+        was_phrase = utils.auto_plural(len(args), 'was', 'were')
         raise TypeError(
             f'{signature.id}() takes {len(signature.args)} '
             f'positional {arg_phrase} but {len(args)} {was_phrase} given.'
@@ -257,8 +258,7 @@ class Functor(pg_object.Object, object_utils.Functor):
     # pylint: enable=protected-access
     return typing.cast(Functor, other)
 
-  def _on_change(
-      self, field_updates: Dict[object_utils.KeyPath, base.FieldUpdate]):
+  def _on_change(self, field_updates: Dict[utils.KeyPath, base.FieldUpdate]):
     """Custom handling field change to update bound args."""
     for relative_path, update in field_updates.items():
       assert relative_path
@@ -406,8 +406,8 @@ class Functor(pg_object.Object, object_utils.Functor):
       if ignore_extra_args:
         args = args[: len(signature.args)]
       else:
-        arg_phrase = object_utils.auto_plural(len(signature.args), 'argument')
-        was_phrase = object_utils.auto_plural(len(args), 'was', 'were')
+        arg_phrase = utils.auto_plural(len(signature.args), 'argument')
+        was_phrase = utils.auto_plural(len(args), 'was', 'were')
         raise TypeError(
             f'{signature.id}() takes {len(signature.args)} '
             f'positional {arg_phrase} but {len(args)} {was_phrase} given.'
@@ -483,9 +483,10 @@ class Functor(pg_object.Object, object_utils.Functor):
         missing_required_arg_names.append(arg.name)
 
     if missing_required_arg_names:
-      arg_phrase = object_utils.auto_plural(
-          len(missing_required_arg_names), 'argument')
-      args_str = object_utils.comma_delimited_str(missing_required_arg_names)
+      arg_phrase = utils.auto_plural(
+          len(missing_required_arg_names), 'argument'
+      )
+      args_str = utils.comma_delimited_str(missing_required_arg_names)
       raise TypeError(
           f'{signature.id}() missing {len(missing_required_arg_names)} '
           f'required positional {arg_phrase}: {args_str}.'

pyglove/core/symbolic/functor_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.Functor."""
-
 import inspect
 import io
 import typing
 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 flags
 from pyglove.core.symbolic.base import from_json_str as pg_from_json_str
 from pyglove.core.symbolic.dict import Dict
@@ -31,7 +29,7 @@ from pyglove.core.symbolic.object import members as pg_members
 from pyglove.core.symbolic.object import Object
 
 
-MISSING_VALUE = object_utils.MISSING_VALUE
+MISSING_VALUE = utils.MISSING_VALUE
 
 
 class FunctorTest(unittest.TestCase):

pyglove/core/symbolic/inferred.py

@@ -14,8 +14,8 @@
 """Common inferential values."""
 
 from typing import Any, Tuple
-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.object import Object
 
@@ -65,7 +65,7 @@ class ValueFromParentChain(InferredValue):
       if v == pg_typing.MISSING_VALUE:
         if parent is None:
           raise AttributeError(
-              object_utils.message_on_path(
+              utils.message_on_path(
                   (
                       f'`{self.inference_key}` is not found under its context '
                       '(along its symbolic parent chain).'