pyglove 0.5.0.dev202510200810__tar.gz → 0.5.0.dev202510210811__tar.gz

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202510200810
+Version: 0.5.0.dev202510210811
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove/core/symbolic/base.py

@@ -503,10 +503,12 @@ class Symbolic(
         return default
 
   def _sym_inferred(self, key: Union[str, int], **kwargs) -> Any:
-    v = self.sym_getattr(key)
-    if isinstance(v, Inferential):
-      v = v.infer(**kwargs)
-    return v
+    return self._infer_if_applicable(self.sym_getattr(key), **kwargs)
+
+  def _infer_if_applicable(self, value: Any, **kwargs) -> Any:
+    if isinstance(value, Inferential):
+      return value.infer(**kwargs)
+    return value
 
   @abc.abstractmethod
   def sym_keys(self) -> Iterator[Union[str, int]]:

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove/core/symbolic/dict.py

@@ -236,7 +236,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         accessor_writable=True,
         # We delay seal operation until members are filled.
         sealed=False,
-        root_path=root_path)
+        root_path=root_path
+    )
 
     dict.__init__(self)
     self._value_spec = None
@@ -247,9 +248,10 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     for k, v in kwargs.items():
       dict_obj[k] = v
 
+    iter_items = getattr(dict_obj, 'sym_items', dict_obj.items)
     if value_spec:
       if pass_through:
-        for k, v in dict_obj.items():
+        for k, v in iter_items():
           super().__setitem__(k, self._relocate_if_symbolic(k, v))
 
         # NOTE(daiyip): when pass_through is on, we simply trust input
@@ -258,11 +260,11 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         # repeated validation and transformation.
         self._value_spec = value_spec
       else:
-        for k, v in dict_obj.items():
+        for k, v in iter_items():
           super().__setitem__(k, self._formalized_value(k, None, v))
         self.use_value_spec(value_spec, allow_partial)
     else:
-      for k, v in dict_obj.items():
+      for k, v in iter_items():
         self._set_item_without_permission_check(k, v)
 
     # NOTE(daiyip): We set onchange callback at the end of init to avoid
@@ -537,7 +539,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       raise KeyError(self._error_message(
           f'Key must be string or int type. Encountered {key!r}.'))
 
-    old_value = self.get(key, pg_typing.MISSING_VALUE)
+    old_value = self.sym_getattr(key, pg_typing.MISSING_VALUE)
     if old_value is value:
       return None
 
@@ -644,6 +646,13 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     except AttributeError as e:
       raise KeyError(key) from e
 
+  def get(self, key: Union[str, int], default: Any = None) -> Any:
+    """Get item in this Dict."""
+    try:
+      return self.sym_inferred(key)
+    except AttributeError:
+      return default
+
   def __setitem__(self, key: Union[str, int], value: Any) -> None:
     """Set item in this Dict.
 
@@ -751,11 +760,13 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
 
   def items(self) -> Iterator[Tuple[Union[str, int], Any]]:  # pytype: disable=signature-mismatch
     """Returns an iterator of (key, value) items in current dict."""
-    return self.sym_items()
+    for k, v in self.sym_items():
+      yield k, self._infer_if_applicable(v)
 
   def values(self) -> Iterator[Any]:  # pytype: disable=signature-mismatch
     """Returns an iterator of values in current dict.."""
-    return self.sym_values()
+    for v in self.sym_values():
+      yield self._infer_if_applicable(v)
 
   def copy(self) -> 'Dict':
     """Overridden copy using symbolic copy."""

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove/core/symbolic/dict_test.py

@@ -415,6 +415,19 @@ class DictTest(unittest.TestCase):
     with self.assertRaisesRegex(KeyError, 'Key \'y1\' is not allowed'):
       sd.y1 = 4
 
+  def test_get(self):
+    sd = Dict(a=1)
+    self.assertEqual(sd.get('a'), 1)
+    self.assertIsNone(sd.get('x'))
+    self.assertEqual(sd.get('x', 2), 2)
+
+    # Test inferred values.
+    sd = Dict(x=inferred.ValueFromParentChain())
+    self.assertIsNone(sd.get('x'))
+
+    _ = Dict(sd=sd, x=1)
+    self.assertEqual(sd.get('x'), 1)
+
   def test_getattr(self):
     sd = Dict(a=1)
     self.assertEqual(sd.a, 1)
@@ -713,6 +726,11 @@ class DictTest(unittest.TestCase):
     ]))
     self.assertEqual(list(sd.values()), [2, 1, 3])
 
+    # Test values with inferred values.
+    sd = Dict(x=1, y=inferred.ValueFromParentChain())
+    _ = Dict(sd=sd, y=2)
+    self.assertEqual(list(sd.values()), [1, 2])
+
   def test_items(self):
     sd = Dict(b={'c': True, 'd': []}, a=0)
     self.assertEqual(list(sd.items()), [('b', {'c': True, 'd': []}), ('a', 0)])
@@ -725,6 +743,11 @@ class DictTest(unittest.TestCase):
     ]))
     self.assertEqual(list(sd.items()), [('b', 2), ('a', 1), ('c', 3)])
 
+    # Test items with inferred values.
+    sd = Dict(x=1, y=inferred.ValueFromParentChain())
+    _ = Dict(sd=sd, y=2)
+    self.assertEqual(list(sd.items()), [('x', 1), ('y', 2)])
+
   def test_non_default(self):
     sd = Dict(a=1)
     self.assertEqual(len(sd.non_default_values()), 1)

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove/core/typing/class_schema.py

@@ -1229,6 +1229,9 @@ class Schema(utils.Formattable, utils.JSONConvertible):
           f'(parent=\'{root_path}\')'
       )
 
+    # Symbolic.Dict uses `sym_getattr` to support getting symbolic attributes.
+    get_value = getattr(dict_obj, 'sym_getattr', dict_obj.get)
+
     for key_spec, keys in matched_keys.items():
       field = self._fields[key_spec]
       # For missing const keys, we add to keys collection to add missing value.
@@ -1236,7 +1239,7 @@ class Schema(utils.Formattable, utils.JSONConvertible):
         keys.append(str(key_spec))
       for key in keys:
         if dict_obj:
-          value = dict_obj.get(key, utils.MISSING_VALUE)
+          value = get_value(key, utils.MISSING_VALUE)
         else:
           value = utils.MISSING_VALUE
         # NOTE(daiyip): field.default_value may be MISSING_VALUE too

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove/core/utils/json_conversion.py

@@ -569,7 +569,7 @@ def resolve_typenames(
       if _resolve_typename(v):
         # Only resolve children when _types in this tree is not resolved
         # previously
-        for x in v.values():
+        for x in getattr(v, 'sym_values', v.values)():
           _visit(x)
 
   _visit(json_value)

{pyglove-0.5.0.dev202510200810 → pyglove-0.5.0.dev202510210811}/pyglove.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202510200810
+Version: 0.5.0.dev202510210811
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors