Bug fixes on default value inspection.

- `pg.Symbolic.sym_nondefault` to honor object-level default value vs. schema-level default value, and could work well with symbolic objects which do not use symbolic comparison.
- `pg.format(hide_default_values=True)` to work with symbolic objects which do not use symbolic comparison.

PiperOrigin-RevId: 584506769

Author: daiyip

pyglove/core/symbolic/dict.py

@@ -369,32 +369,50 @@ def _sym_missing(self) -> typing.Dict[str, Any]:
   def _sym_nondefault(self) -> typing.Dict[str, Any]:
     """Returns non-default values as key/value pairs in a dict."""
     non_defaults = dict()
-    if self._value_spec and self._value_spec.schema:
+    if self._value_spec is not None and self._value_spec.schema:
       dict_schema = self._value_spec.schema
-      matched_keys, unmatched_keys = dict_schema.resolve(self.keys())
-      assert not unmatched_keys
+      matched_keys, _ = dict_schema.resolve(self.keys())
       for key_spec, keys in matched_keys.items():
         value_spec = dict_schema[key_spec].value
         for key in keys:
-          v = self.sym_getattr(key)
-          child_has_non_defaults = False
-          if isinstance(v, base.Symbolic):
-            non_defaults_child = v.non_default_values(flatten=False)
-            if non_defaults_child:
-              non_defaults[key] = non_defaults_child
-              child_has_non_defaults = True
-          if not child_has_non_defaults and value_spec.default != v:
-            non_defaults[key] = v
+          diff = self._diff_base(self.sym_getattr(key), value_spec.default)
+          if pg_typing.MISSING_VALUE != diff:
+            non_defaults[key] = diff
     else:
       for k, v in self.sym_items():
         if isinstance(v, base.Symbolic):
-          non_defaults_child = v.non_default_values(flatten=False)
+          non_defaults_child = v.sym_nondefault(flatten=False)
           if non_defaults_child:
             non_defaults[k] = non_defaults_child
         else:
           non_defaults[k] = v
     return non_defaults
 
+  def _diff_base(self, value: Any, base_value: Any) -> Any:
+    """Computes the diff between a value and a base value."""
+    if base.eq(value, base_value):
+      return pg_typing.MISSING_VALUE
+
+    if (isinstance(value, list)
+        or not isinstance(value, base.Symbolic)
+        or pg_typing.MISSING_VALUE == base_value):
+      return value
+
+    if value.__class__ is base_value.__class__:
+      getter = lambda x, k: x.sym_getattr(k)
+    elif isinstance(value, dict) and isinstance(base_value, dict):
+      getter = lambda x, k: x[k]
+    else:
+      return value
+
+    diff = {}
+    for k, v in value.sym_items():
+      base_v = getter(base_value, k)
+      child_diff = self._diff_base(v, base_v)
+      if pg_typing.MISSING_VALUE != child_diff:
+        diff[k] = child_diff
+    return diff
+
   def seal(self, sealed: bool = True) -> 'Dict':
     """Seals or unseals current object from further modification."""
     if self.is_sealed == sealed:
@@ -796,7 +814,7 @@ def sym_jsonify(
               value = self.sym_getattr(key)
               if pg_typing.MISSING_VALUE == value:
                 continue
-              if hide_default_values and value == field.default_value:
+              if hide_default_values and base.eq(value, field.default_value):
                 continue
               json_repr[key] = base.to_json(
                   value, hide_default_values=hide_default_values, **kwargs)
@@ -886,7 +904,7 @@ def _should_include_key(key):
             if pg_typing.MISSING_VALUE == v:
               if hide_missing_values:
                 continue
-            elif hide_default_values and v == field.default_value:
+            elif hide_default_values and base.eq(v, field.default_value):
               continue
             field_list.append((field, key, v))
     else:

pyglove/core/symbolic/dict_test.py

@@ -988,16 +988,32 @@ def test_sym_missing(self):
     self.assertEqual(sd.sym_missing(), {})
 
   def test_sym_nondefault(self):
-    # Refer to `test_non_default_values` for more details.
-    sd = Dict(x=1, value_spec=pg_typing.Dict([
+
+    class A(pg_object.Object):
+      x: int
+      use_symbolic_comparison = False
+
+    class B(pg_object.Object):
+      y: int = 1
+      use_symbolic_comparison = True
+
+    sd = Dict(x=1, y=dict(a1=A(1)), value_spec=pg_typing.Dict([
         ('x', pg_typing.Int(default=0)),
         ('y', pg_typing.Dict([
-            ('z', pg_typing.Int(default=1))
+            ('z', pg_typing.Int(default=1)),
+            ('a1', pg_typing.Object(A)),
+            ('a2', pg_typing.Object(A, default=A(1))),
+            ('b', pg_typing.Object(B, default=B(2))),
         ])),
     ]))
-    self.assertEqual(sd.sym_nondefault(), {'x': 1})
-    sd.rebind({'y.z': 2}, x=0)
-    self.assertEqual(sd.sym_nondefault(), {'y.z': 2})
+    self.assertTrue(base.eq(sd.sym_nondefault(), {'x': 1, 'y.a1': A(1)}))
+    sd.rebind({'y.z': 2, 'y.a2': A(2), 'y.b': B(1)}, x=0)
+    self.assertTrue(
+        base.eq(
+            sd.sym_nondefault(),
+            {'y.z': 2, 'y.a1': A(1), 'y.a2.x': 2, 'y.b.y': 1}
+        )
+    )
 
     # Test inferred value as the default value.
     sd = Dict(
@@ -1892,9 +1908,15 @@ def __eq__(self, other):
     self.assertEqual(base.from_json_str(sd.to_json_str(), value_spec=spec), sd)
 
   def test_hide_default_values(self):
+
+    class A(pg_object.Object):
+      x: int = 1
+      use_symbolic_comparison = False
+
     sd = Dict.partial(
         x=1,
         value_spec=pg_typing.Dict([
+            ('v', pg_typing.Object(A, default=A(1))),
             ('w', pg_typing.Str()),
             ('x', pg_typing.Int()),
             ('y', pg_typing.Str().noneable()),