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

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
@@ -109,6 +107,7 @@ class FieldTest(unittest.TestCase):
     self.assertEqual(f.description, 'a field')
     self.assertIsInstance(f.metadata, dict)
     self.assertEqual(len(f.metadata), 0)
+    self.assertIsNone(f.origin)
 
     # Cover the self comparison in __eq__.
     self.assertEqual(f, f)
@@ -204,7 +203,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 +821,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.
 

pyglove/core/typing/key_specs.py

@@ -16,7 +16,7 @@
 import re
 from typing import Any, Dict, Optional
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing.class_schema import KeySpec
 
 
@@ -38,7 +38,7 @@ class KeySpecBase(KeySpec):
     return {}
 
 
-class ConstStrKey(KeySpecBase, object_utils.StrKey):
+class ConstStrKey(KeySpecBase, utils.StrKey):
   """Class that represents a constant string key.
 
   Example::
@@ -159,11 +159,9 @@ class StrKey(NonConstKey):
 
   def format(self, **kwargs):
     """Format this object."""
-    return object_utils.kvlist_str(
-        [
-            ('regex', getattr(self._regex, 'pattern', None), None)
-        ],
-        label=self.__class__.__name__
+    return utils.kvlist_str(
+        [('regex', getattr(self._regex, 'pattern', None), None)],
+        label=self.__class__.__name__,
     )
 
   def to_json(self, **kwargs: Any) -> Dict[str, Any]:

pyglove/core/typing/key_specs_test.py

@@ -14,7 +14,7 @@
 """Tests for pyglove.core.typing.key_specs."""
 
 import unittest
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import key_specs as ks
 
 
@@ -22,7 +22,7 @@ class KeySpecTest(unittest.TestCase):
   """Base class for KeySpec tests."""
 
   def assert_json_conversion(self, spec: ks.KeySpec):
-    self.assertEqual(object_utils.from_json(object_utils.to_json(spec)), spec)
+    self.assertEqual(utils.from_json(utils.to_json(spec)), spec)
 
 
 class ConstStrKeyTest(KeySpecTest):
@@ -35,9 +35,9 @@ class ConstStrKeyTest(KeySpecTest):
     self.assertEqual(key.text, 'a')
     self.assertNotEqual(key, 'b')
     self.assertIn(key, {'a': 1})
-    with object_utils.str_format(markdown=True):
+    with utils.str_format(markdown=True):
       self.assertEqual(str(key), 'a')
-    with object_utils.str_format(markdown=True):
+    with utils.str_format(markdown=True):
       self.assertEqual(repr(key), 'a')
     self.assertTrue(key.match('a'))
     self.assertFalse(key.match('b'))

pyglove/core/typing/type_conversion.py

@@ -17,7 +17,7 @@ import calendar
 import datetime
 from typing import Any, Callable, Optional, Tuple, Type, Union
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import inspect as pg_inspect
 
 
@@ -135,10 +135,9 @@ def _register_builtin_converters():
                      lambda x: calendar.timegm(x.timetuple()))
 
   # string <=> KeyPath.
-  register_converter(str, object_utils.KeyPath,
-                     object_utils.KeyPath.parse)
-  register_converter(object_utils.KeyPath, str, lambda x: x.path)
+  register_converter(str, utils.KeyPath, utils.KeyPath.parse)
+  register_converter(utils.KeyPath, str, lambda x: x.path)
 
 
 _register_builtin_converters()
-object_utils.JSONConvertible.TYPE_CONVERTER = get_json_value_converter
+utils.JSONConvertible.TYPE_CONVERTER = get_json_value_converter

pyglove/core/typing/type_conversion_test.py

@@ -11,14 +11,12 @@
 # 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.type_conversion."""
-
 import calendar
 import datetime
 import typing
 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 type_conversion
 from pyglove.core.typing import value_specs as vs
@@ -137,17 +135,19 @@ class BuiltInConversionsTest(unittest.TestCase):
   def test_keypath_to_str(self):
     """Test built-in converter between string and KeyPath."""
     self.assertEqual(
-        vs.Object(object_utils.KeyPath).apply('a.b.c').keys,
-        ['a', 'b', 'c'])
-    self.assertEqual(
-        vs.Union([vs.Object(object_utils.KeyPath), vs.Int()]).apply(
-            'a.b.c').keys,
-        ['a', 'b', 'c'])
+        vs.Object(utils.KeyPath).apply('a.b.c').keys, ['a', 'b', 'c']
+    )
     self.assertEqual(
-        vs.Str().apply(object_utils.KeyPath.parse('a.b.c')), 'a.b.c')
+        vs.Union([vs.Object(utils.KeyPath), vs.Int()]).apply('a.b.c').keys,
+        ['a', 'b', 'c'],
+    )
+    self.assertEqual(vs.Str().apply(utils.KeyPath.parse('a.b.c')), 'a.b.c')
     self.assertEqual(
-        type_conversion.get_json_value_converter(object_utils.KeyPath)(
-            object_utils.KeyPath.parse('a.b.c')), 'a.b.c')
+        type_conversion.get_json_value_converter(utils.KeyPath)(
+            utils.KeyPath.parse('a.b.c')
+        ),
+        'a.b.c',
+    )
 
 
 if __name__ == '__main__':

pyglove/core/typing/typed_missing.py

@@ -14,15 +14,15 @@
 """Typed value placeholders."""
 
 from typing import Any
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import class_schema
 
 
 # Non-typed missing value.
-MISSING_VALUE = object_utils.MISSING_VALUE
+MISSING_VALUE = utils.MISSING_VALUE
 
 
-class MissingValue(object_utils.MissingValue, object_utils.Formattable):
+class MissingValue(utils.MissingValue, utils.Formattable):
   """Class represents missing value **for a specific value spec**."""
 
   def __init__(self, value_spec: class_schema.ValueSpec):
@@ -37,15 +37,15 @@ class MissingValue(object_utils.MissingValue, object_utils.Formattable):
   def __eq__(self, other: Any) -> bool:
     """Operator ==.
 
-    NOTE: `MissingValue(value_spec) and `object_utils.MissingValue` are
+    NOTE: `MissingValue(value_spec) and `utils.MissingValue` are
     considered equal, but `MissingValue(value_spec1)` and
     `MissingValue(value_spec2)` are considered different. That being said,
     the 'eq' operation is not transitive.
 
     However in practice this is not a problem, since user always compare
-    against `schema.MISSING_VALUE` which is `object_utils.MissingValue`.
+    against `schema.MISSING_VALUE` which is `utils.MissingValue`.
     Therefore the `__hash__` function returns the same value with
-    `object_utils.MissingValue`.
+    `utils.MissingValue`.
 
     Args:
       other: the value to compare against.
@@ -80,4 +80,3 @@ class MissingValue(object_utils.MissingValue, object_utils.Formattable):
   def __deepcopy__(self, memo):
     """Avoid deep copy by copying value_spec by reference."""
     return MissingValue(self.value_spec)
-

pyglove/core/typing/typed_missing_test.py

@@ -11,11 +11,9 @@
 # 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.typed_missing."""
-
 import unittest
 
-from pyglove.core import object_utils
+from pyglove.core import utils
 from pyglove.core.typing import typed_missing
 from pyglove.core.typing import value_specs
 
@@ -25,12 +23,12 @@ class MissingValueTest(unittest.TestCase):
 
   def test_eq(self):
     self.assertEqual(
-        typed_missing.MissingValue(value_specs.Int()),
-        object_utils.MISSING_VALUE)
+        typed_missing.MissingValue(value_specs.Int()), utils.MISSING_VALUE
+    )
 
     self.assertEqual(
-        object_utils.MISSING_VALUE,
-        typed_missing.MissingValue(value_specs.Int()))
+        utils.MISSING_VALUE, typed_missing.MissingValue(value_specs.Int())
+    )
 
     self.assertEqual(
         typed_missing.MissingValue(value_specs.Int()),
@@ -54,7 +52,8 @@ class MissingValueTest(unittest.TestCase):
 
     self.assertEqual(
         hash(typed_missing.MissingValue(value_specs.Int())),
-        hash(object_utils.MISSING_VALUE))
+        hash(utils.MISSING_VALUE),
+    )
 
     self.assertNotEqual(
         hash(typed_missing.MissingValue(value_specs.Int())),