pyglove 0.5.0.dev202508250811__py3-none-any.whl → 0.5.0.dev202511300809__py3-none-any.whl

pyglove/core/monitoring_test.py

@@ -0,0 +1,289 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+
+import time
+import unittest
+from pyglove.core import monitoring
+from pyglove.core.symbolic import error_info  # pylint: disable=unused-import
+
+
+class MetricCollectionTest(unittest.TestCase):
+  """Tests for metric collection."""
+
+  def test_default_metric_collection_cls(self):
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        monitoring.InMemoryMetricCollection
+    )
+
+    class TestMetricCollection(monitoring.MetricCollection):
+      pass
+
+    monitoring.set_default_metric_collection_cls(TestMetricCollection)
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        TestMetricCollection
+    )
+    monitoring.set_default_metric_collection_cls(
+        monitoring.InMemoryMetricCollection
+    )
+    self.assertIs(
+        monitoring.default_metric_collection_cls(),
+        monitoring.InMemoryMetricCollection
+    )
+
+  def test_metric_collection(self):
+    collection = monitoring.metric_collection('/test')
+    self.assertEqual(collection.namespace, '/test')
+    self.assertIsInstance(collection, monitoring.InMemoryMetricCollection)
+
+  def test_creation_failures(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter('counter', 'counter description')
+    self.assertIsInstance(counter, monitoring.Counter)
+    with self.assertRaisesRegex(
+        ValueError, 'Metric .* already exists with a different type'
+    ):
+      collection.get_distribution('counter', 'counter description')
+
+    with self.assertRaisesRegex(
+        ValueError, 'Metric .* already exists with a different description'
+    ):
+      collection.get_counter('counter', 'different description')
+
+    with self.assertRaisesRegex(
+        ValueError,
+        'Metric .* already exists with different parameter definitions'
+    ):
+      collection.get_counter(
+          'counter', 'counter description', parameters={'field1': str}
+      )
+
+
+class InMemoryDistributionValueTest(unittest.TestCase):
+  """Tests for in memory distribution value."""
+
+  def test_empty_distribution(self):
+    dist = monitoring._InMemoryDistributionValue()
+    self.assertEqual(dist.count, 0)
+    self.assertEqual(dist.sum, 0.0)
+    self.assertEqual(dist.mean, 0.0)
+    self.assertEqual(dist.stddev, 0.0)
+    self.assertEqual(dist.variance, 0.0)
+    self.assertEqual(dist.median, 0.0)
+    self.assertEqual(dist.percentile(50), 0.0)
+    self.assertEqual(dist.fraction_less_than(100), 0.0)
+
+  def test_add_value(self):
+    dist = monitoring._InMemoryDistributionValue()
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 4)
+    self.assertEqual(dist.sum, 16.0)
+    self.assertEqual(dist.mean, 4.0)
+    self.assertEqual(dist.stddev, 3.5355339059327378)
+    self.assertEqual(dist.variance, 12.5)
+    self.assertEqual(dist.median, 2.5)
+    self.assertEqual(dist.percentile(50), 2.5)
+    self.assertEqual(dist.percentile(10), 1.3)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.75)
+
+  def test_add_value_no_numpy(self):
+    numpy = monitoring.numpy
+    monitoring.numpy = None
+    dist = monitoring._InMemoryDistributionValue()
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 4)
+    self.assertEqual(dist.sum, 16.0)
+    self.assertEqual(dist.mean, 4.0)
+    self.assertEqual(dist.stddev, 3.5355339059327378)
+    self.assertEqual(dist.variance, 12.5)
+    self.assertEqual(dist.median, 2.5)
+    self.assertEqual(dist.percentile(50), 2.5)
+    self.assertEqual(dist.percentile(10), 1.3)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.75)
+    monitoring.numpy = numpy
+
+  def test_window_size(self):
+    dist = monitoring._InMemoryDistributionValue(window_size=3)
+    dist.add(1)
+    dist.add(3)
+    dist.add(10)
+    dist.add(2)
+    self.assertEqual(dist.count, 3)
+    self.assertEqual(dist.sum, 15.0)
+    self.assertEqual(dist.mean, 5.0)
+    self.assertEqual(dist.stddev, 3.5590260840104366)
+    self.assertEqual(dist.variance, 12.666666666666664)
+    self.assertEqual(dist.median, 3.0)
+    self.assertEqual(dist.percentile(50), 3.0)
+    self.assertEqual(dist.percentile(10), 2.2)
+    self.assertEqual(dist.fraction_less_than(100), 1.0)
+    self.assertEqual(dist.fraction_less_than(1), 0.0)
+    self.assertEqual(dist.fraction_less_than(10), 0.6666666666666666)
+
+
+class InMemoryCounterTest(unittest.TestCase):
+  """Tests for in memory counter."""
+
+  def test_counter_without_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter('counter', 'counter description')
+    self.assertEqual(counter.namespace, '/test')
+    self.assertEqual(counter.name, 'counter')
+    self.assertEqual(counter.description, 'counter description')
+    self.assertEqual(counter.parameter_definitions, {})
+    self.assertEqual(counter.full_name, '/test/counter')
+    self.assertEqual(counter.value(), 0)
+    self.assertEqual(counter.increment(), 1)
+    self.assertEqual(counter.value(), 1)
+    self.assertEqual(counter.increment(2), 3)
+    self.assertEqual(counter.value(), 3)
+    self.assertIs(collection.metrics()[0], counter)
+
+  def test_counter_with_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    counter = collection.get_counter(
+        'counter', 'counter description', {'field1': str}
+    )
+    self.assertEqual(counter.namespace, '/test')
+    self.assertEqual(counter.name, 'counter')
+    self.assertEqual(counter.description, 'counter description')
+    self.assertEqual(counter.parameter_definitions, {'field1': str})
+    self.assertEqual(counter.full_name, '/test/counter')
+    self.assertEqual(counter.value(field1='foo'), 0)
+    self.assertEqual(counter.increment(field1='foo'), 1)
+    self.assertEqual(counter.value(field1='bar'), 0)
+    self.assertEqual(counter.increment(field1='bar'), 1)
+    self.assertEqual(counter.increment(field1='foo', delta=2), 3)
+    self.assertEqual(counter.value(field1='foo'), 3)
+
+    with self.assertRaisesRegex(TypeError, '.* has type .* but expected type'):
+      counter.increment(field1=1)
+
+    with self.assertRaisesRegex(KeyError, '.* is required but not given'):
+      counter.increment()
+
+    with self.assertRaisesRegex(KeyError, '.* is not defined but provided'):
+      counter.increment(field1='foo', field2='a')
+
+
+class InMemoryScalarTest(unittest.TestCase):
+  """Tests for in memory scalar."""
+
+  def test_scalar_without_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    scalar = collection.get_scalar('scalar', 'scalar description')
+    self.assertEqual(scalar.namespace, '/test')
+    self.assertEqual(scalar.name, 'scalar')
+    self.assertEqual(scalar.description, 'scalar description')
+    self.assertEqual(scalar.parameter_definitions, {})
+    self.assertEqual(scalar.full_name, '/test/scalar')
+    self.assertEqual(scalar.value(), 0)
+    self.assertEqual(scalar.increment(), 1)
+    self.assertEqual(scalar.value(), 1)
+    scalar.set(3)
+    self.assertEqual(scalar.increment(2), 5)
+    self.assertEqual(scalar.value(), 5)
+
+  def test_scalar_with_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    scalar = collection.get_scalar(
+        'scalar', 'scalar description', {'field1': str}, float
+    )
+    self.assertEqual(scalar.namespace, '/test')
+    self.assertEqual(scalar.name, 'scalar')
+    self.assertEqual(scalar.description, 'scalar description')
+    self.assertEqual(scalar.parameter_definitions, {'field1': str})
+    self.assertEqual(scalar.full_name, '/test/scalar')
+    self.assertEqual(scalar.value(field1='foo'), 0.0)
+    scalar.set(2.5, field1='bar')
+    self.assertEqual(scalar.value(field1='bar'), 2.5)
+    self.assertEqual(scalar.increment(1.1, field1='bar'), 3.6)
+    self.assertEqual(scalar.value(field1='bar'), 3.6)
+    self.assertEqual(scalar.value(field1='foo'), 0.0)
+
+
+class InMemoryDistributionTest(unittest.TestCase):
+  """Tests for in memory distribution."""
+
+  def test_distribution_without_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    dist = collection.get_distribution(
+        'distribution', 'distribution description'
+    )
+    self.assertEqual(dist.namespace, '/test')
+    self.assertEqual(dist.name, 'distribution')
+    self.assertEqual(dist.description, 'distribution description')
+    self.assertEqual(dist.parameter_definitions, {})
+    self.assertEqual(dist.full_name, '/test/distribution')
+    v = dist.value()
+    self.assertEqual(v.count, 0)
+    dist.record(1)
+    dist.record(2)
+    dist.record(3)
+    v = dist.value()
+    self.assertEqual(v.count, 3)
+
+    dist = collection.get_distribution(
+        'distribution2', 'distribution description'
+    )
+    with dist.record_duration():
+      time.sleep(0.1)
+    self.assertGreaterEqual(dist.value().mean, 100)
+
+  def test_distribution_with_parameters(self):
+    collection = monitoring.InMemoryMetricCollection('/test')
+    dist = collection.get_distribution(
+        'distribution', 'distribution description', {'field1': str}
+    )
+    self.assertEqual(dist.namespace, '/test')
+    self.assertEqual(dist.name, 'distribution')
+    self.assertEqual(dist.description, 'distribution description')
+    self.assertEqual(dist.parameter_definitions, {'field1': str})
+    self.assertEqual(dist.full_name, '/test/distribution')
+    value = dist.value(field1='foo')
+    self.assertEqual(value.count, 0)
+    dist.record(1, field1='foo')
+    dist.record(2, field1='foo')
+    dist.record(3, field1='bar')
+    value = dist.value(field1='foo')
+    self.assertEqual(value.count, 2)
+    value = dist.value(field1='bar')
+    self.assertEqual(value.count, 1)
+
+    dist = collection.get_distribution(
+        'distribution2', 'distribution description', {'error': str}
+    )
+    with self.assertRaises(ValueError):
+      with dist.record_duration():
+        time.sleep(0.1)
+        raise ValueError()
+    self.assertGreaterEqual(dist.value(error='ValueError').mean, 100)
+    with dist.record_duration():
+      time.sleep(0.1)
+    self.assertGreaterEqual(dist.value(error='').mean, 100)
+
+
+if __name__ == '__main__':
+  unittest.main()

pyglove/core/symbolic/__init__.py

@@ -147,4 +147,11 @@ from pyglove.core.symbolic.list import mark_as_insertion
 from pyglove.core.symbolic.base import WritePermissionError
 from pyglove.core.symbolic.error_info import ErrorInfo
 
+# Unknown symbols.
+from pyglove.core.symbolic.unknown_symbols import UnknownSymbol
+from pyglove.core.symbolic.unknown_symbols import UnknownType
+from pyglove.core.symbolic.unknown_symbols import UnknownFunction
+from pyglove.core.symbolic.unknown_symbols import UnknownMethod
+from pyglove.core.symbolic.unknown_symbols import UnknownTypedObject
+
 # pylint: enable=g-bad-import-order

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]]:
@@ -944,7 +946,7 @@ class Symbolic(
 
   def to_json(self, **kwargs) -> utils.JSONValueType:
     """Alias for `sym_jsonify`."""
-    return to_json(self, **kwargs)
+    return utils.to_json(self, **kwargs)
 
   def to_json_str(self, json_indent: Optional[int] = None, **kwargs) -> str:
     """Serializes current object into a JSON string."""
@@ -1983,10 +1985,12 @@ def is_abstract(x: Any) -> bool:
 def contains(
     x: Any,
     value: Any = None,
-    type: Optional[Union[    # pylint: disable=redefined-builtin
+    type: Union[    # pylint: disable=redefined-builtin
         Type[Any],
-        Tuple[Type[Any]]]]=None
-    ) -> bool:
+        Tuple[Type[Any], ...],
+        None,
+    ]=None,
+) -> bool:
   """Returns if a value contains values of specific type.
 
   Example::
@@ -2035,10 +2039,12 @@ def contains(
 def from_json(
     json_value: Any,
     *,
+    context: Optional[utils.JSONConversionContext] = None,
+    auto_symbolic: bool = True,
+    auto_import: bool = True,
+    convert_unknown: bool = False,
     allow_partial: bool = False,
     root_path: Optional[utils.KeyPath] = None,
-    auto_import: bool = True,
-    auto_dict: bool = False,
     value_spec: Optional[pg_typing.ValueSpec] = None,
     **kwargs,
 ) -> Any:
@@ -2059,14 +2065,23 @@ def from_json(
 
   Args:
     json_value: Input JSON value.
-    allow_partial: Whether to allow elements of the list to be partial.
-    root_path: KeyPath of loaded object in its object tree.
+    context: JSON conversion context.
+    auto_symbolic: If True, list and dict will be automatically converted to
+      `pg.List` and `pg.Dict`. Otherwise, they will be plain lists
+      and dicts.
     auto_import: If True, when a '_type' is not registered, PyGlove will
       identify its parent module and automatically import it. For example,
       if the type is 'foo.bar.A', PyGlove will try to import 'foo.bar' and
       find the class 'A' within the imported module.
-    auto_dict: If True, dict with '_type' that cannot be loaded will remain
-      as dict, with '_type' renamed to 'type_name'.
+    convert_unknown: If True, when a '_type' is not registered and cannot
+      be imported, PyGlove will create objects of:
+        - `pg.symbolic.UnknownType` for unknown types;
+        - `pg.symbolic.UnknownTypedObject` for objects of unknown types;
+        - `pg.symbolic.UnknownFunction` for unknown functions;
+        - `pg.symbolic.UnknownMethod` for unknown methods.
+      If False, TypeError will be raised.
+    allow_partial: Whether to allow elements of the list to be partial.
+    root_path: KeyPath of loaded object in its object tree.
     value_spec: The value spec for the symbolic list or dict.
     **kwargs: Allow passing through keyword arguments to from_json of specific
       types.
@@ -2082,10 +2097,23 @@ def from_json(
   if isinstance(json_value, Symbolic):
     return json_value
 
+  if context is None:
+    if (isinstance(json_value, dict) and (
+        context_node := json_value.get(utils.JSONConvertible.CONTEXT_KEY))):
+      context = utils.JSONConversionContext.from_json(
+          context_node,
+          auto_import=auto_import,
+          convert_unknown=convert_unknown,
+          **kwargs
+      )
+      json_value = json_value[utils.JSONConvertible.ROOT_VALUE_KEY]
+    else:
+      context = utils.JSONConversionContext()
+
   typename_resolved = kwargs.pop('_typename_resolved', False)
   if not typename_resolved:
     json_value = utils.json_conversion.resolve_typenames(
-        json_value, auto_import=auto_import, auto_dict=auto_dict
+        json_value, auto_import, convert_unknown
     )
 
   def _load_child(k, v):
@@ -2094,6 +2122,7 @@ def from_json(
         root_path=utils.KeyPath(k, root_path),
         _typename_resolved=True,
         allow_partial=allow_partial,
+        context=context,
         **kwargs,
     )
 
@@ -2109,24 +2138,42 @@ def from_json(
             )
         )
       return tuple(_load_child(i, v) for i, v in enumerate(json_value[1:]))
-    return Symbolic.ListType.from_json(    # pytype: disable=attribute-error
+    if json_value and json_value[0] == utils.JSONConvertible.SYMBOLIC_MARKER:
+      auto_symbolic = True
+    if auto_symbolic:
+      from_json_fn = Symbolic.ListType.from_json  # pytype: disable=attribute-error
+    else:
+      from_json_fn = utils.from_json
+    return from_json_fn(
         json_value,
+        context=context,
         value_spec=value_spec,
         root_path=root_path,
         allow_partial=allow_partial,
         **kwargs,
     )
   elif isinstance(json_value, dict):
+    if utils.JSONConvertible.REF_KEY in json_value:
+      x = context.get_shared(
+          json_value[utils.JSONConvertible.REF_KEY]
+      ).value
+      return x
     if utils.JSONConvertible.TYPE_NAME_KEY not in json_value:
-      return Symbolic.DictType.from_json(   # pytype: disable=attribute-error
-          json_value,
-          value_spec=value_spec,
-          root_path=root_path,
-          allow_partial=allow_partial,
-          **kwargs,
+      auto_symbolic = json_value.get(
+          utils.JSONConvertible.SYMBOLIC_MARKER, auto_symbolic
       )
+      if auto_symbolic:
+        return Symbolic.DictType.from_json(   # pytype: disable=attribute-error
+            json_value,
+            context=context,
+            value_spec=value_spec,
+            root_path=root_path,
+            allow_partial=allow_partial,
+            **kwargs,
+        )
     return utils.from_json(
         json_value,
+        context=context,
         _typename_resolved=True,
         root_path=root_path,
         allow_partial=allow_partial,
@@ -2138,10 +2185,12 @@ def from_json(
 def from_json_str(
     json_str: str,
     *,
+    context: Optional[utils.JSONConversionContext] = None,
+    auto_import: bool = True,
+    convert_unknown: bool = False,
     allow_partial: bool = False,
     root_path: Optional[utils.KeyPath] = None,
-    auto_import: bool = True,
-    auto_dict: bool = False,
+    value_spec: Optional[pg_typing.ValueSpec] = None,
     **kwargs,
 ) -> Any:
   """Deserialize (maybe) symbolic object from JSON string.
@@ -2161,15 +2210,22 @@ def from_json_str(
 
   Args:
     json_str: JSON string.
-    allow_partial: If True, allow a partial symbolic object to be created.
-      Otherwise error will be raised on partial value.
-    root_path: The symbolic path used for the deserialized root object.
+    context: JSON conversion context.
     auto_import: If True, when a '_type' is not registered, PyGlove will
       identify its parent module and automatically import it. For example,
       if the type is 'foo.bar.A', PyGlove will try to import 'foo.bar' and
       find the class 'A' within the imported module.
-    auto_dict: If True, dict with '_type' that cannot be loaded will remain
-      as dict, with '_type' renamed to 'type_name'.
+    convert_unknown: If True, when a '_type' is not registered and cannot
+      be imported, PyGlove will create objects of:
+        - `pg.symbolic.UnknownType` for unknown types;
+        - `pg.symbolic.UnknownTypedObject` for objects of unknown types;
+        - `pg.symbolic.UnknownFunction` for unknown functions;
+        - `pg.symbolic.UnknownMethod` for unknown methods.
+      If False, TypeError will be raised.
+    allow_partial: If True, allow a partial symbolic object to be created.
+      Otherwise error will be raised on partial value.
+    root_path: The symbolic path used for the deserialized root object.
+    value_spec: The value spec for the symbolic list or dict.
     **kwargs: Additional keyword arguments that will be passed to
       ``pg.from_json``.
 
@@ -2193,10 +2249,12 @@ def from_json_str(
 
   return from_json(
       _decode_int_keys(json.loads(json_str)),
+      context=context,
+      auto_import=auto_import,
+      convert_unknown=convert_unknown,
       allow_partial=allow_partial,
       root_path=root_path,
-      auto_import=auto_import,
-      auto_dict=auto_dict,
+      value_spec=value_spec,
       **kwargs
   )
 
@@ -2232,10 +2290,6 @@ def to_json(value: Any, **kwargs) -> Any:
   Returns:
     JSON value.
   """
-  # NOTE(daiyip): special handling `sym_jsonify` since symbolized
-  # classes may have conflicting `to_json` method in their existing classes.
-  if isinstance(value, Symbolic):
-    return value.sym_jsonify(**kwargs)
   return utils.to_json(value, **kwargs)
 
 

pyglove/core/symbolic/base_test.py

@@ -20,9 +20,9 @@ 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
-from pyglove.core.symbolic.inferred import ValueFromParentChain
-from pyglove.core.symbolic.object import Object
+from pyglove.core.symbolic.dict import Dict                      # pylint: disable=g-importing-member
+from pyglove.core.symbolic.inferred import ValueFromParentChain  # pylint: disable=g-importing-member
+from pyglove.core.symbolic.object import Object                  # pylint: disable=g-importing-member
 
 
 class FieldUpdateTest(unittest.TestCase):

pyglove/core/symbolic/dict.py

@@ -156,6 +156,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         # Not okay:
         d.a.f2.abc = 1
     """
+    # Remove symbolic marker if present.
+    json_value.pop(utils.JSONConvertible.SYMBOLIC_MARKER, None)
     return cls(
         {
             k: base.from_json(
@@ -236,7 +238,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 +250,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 +262,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 +541,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 +648,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 +762,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."""
@@ -824,12 +837,15 @@ 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,
+      omit_symbolic_marker: bool = True,
       **kwargs,
   ) -> utils.JSONValueType:
     """Converts current object to a dict with plain Python objects."""
     exclude_keys = set(exclude_keys or [])
+    json_repr = {}
+    if not omit_symbolic_marker:
+      json_repr[utils.JSONConvertible.SYMBOLIC_MARKER] = True
     if self._value_spec and self._value_spec.schema:
-      json_repr = dict()
       matched_keys, _ = self._value_spec.schema.resolve(self.keys())  # pytype: disable=attribute-error
       for key_spec, keys in matched_keys.items():
         # NOTE(daiyip): The key values of frozen field can safely be excluded
@@ -851,20 +867,23 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
                 hide_frozen=hide_frozen,
                 hide_default_values=hide_default_values,
                 use_inferred=use_inferred,
-                **kwargs)
-      return json_repr
+                omit_symbolic_marker=omit_symbolic_marker,
+                **kwargs
+            )
     else:
-      return {
+      json_repr.update({
           k: base.to_json(
               self.sym_inferred(k, default=v) if (
                   use_inferred and isinstance(v, base.Inferential)) else v,
               hide_frozen=hide_frozen,
               hide_default_values=hide_default_values,
               use_inferred=use_inferred,
+              omit_symbolic_marker=omit_symbolic_marker,
               **kwargs)
           for k, v in self.sym_items()
           if k not in exclude_keys
-      }
+      })
+    return json_repr
 
   def custom_apply(
       self,