pyglove 0.5.0.dev202510200810__py3-none-any.whl → 0.5.0.dev202511240812__py3-none-any.whl

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,

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)
@@ -923,6 +946,14 @@ class DictTest(unittest.TestCase):
         sd.sym_jsonify(),
         {'x': 1, 'y': inferred.ValueFromParentChain().to_json()},
     )
+    self.assertEqual(
+        sd.sym_jsonify(omit_symbolic_marker=False),
+        {
+            '__symbolic__': True,
+            'x': 1,
+            'y': inferred.ValueFromParentChain().to_json()
+        },
+    )
 
   def test_sym_rebind(self):
     # Refer to RebindTest for more detailed tests.
@@ -1941,6 +1972,24 @@ class SerializationTest(unittest.TestCase):
     self.assertEqual(sd.to_json_str(), '{"x": 1, "y": 2.0}')
     self.assertEqual(base.from_json_str(sd.to_json_str(), value_spec=spec), sd)
 
+  def test_auto_symbolic(self):
+    value = base.from_json({'x': 1}, auto_symbolic=True)
+    self.assertIsInstance(value, Dict)
+
+    value = base.from_json({'x': 1}, auto_symbolic=False)
+    self.assertNotIsInstance(value, Dict)
+
+  def test_omit_symbolic_marker(self):
+    sd = Dict(x=1)
+    self.assertEqual(sd.to_json(omit_symbolic_marker=True), {'x': 1})
+    self.assertEqual(
+        sd.to_json(omit_symbolic_marker=False),
+        {'__symbolic__': True, 'x': 1}
+    )
+    sd = base.from_json({'__symbolic__': True, 'x': 1}, auto_symbolic=False)
+    self.assertIsInstance(sd, Dict)
+    self.assertEqual(sd, {'x': 1})
+
   def test_hide_frozen(self):
 
     class A(pg_object.Object):

pyglove/core/symbolic/list.py

@@ -137,6 +137,9 @@ class List(list, base.Symbolic, pg_typing.CustomTyping):
     Returns:
       A schema-less symbolic list, but its items maybe symbolic.
     """
+    # Remove symbolic marker if present.
+    if json_value and json_value[0] == utils.JSONConvertible.SYMBOLIC_MARKER:
+      json_value.pop(0)
     return cls(
         [
             base.from_json(
@@ -770,15 +773,26 @@ class List(list, base.Symbolic, pg_typing.CustomTyping):
     return (proceed_with_standard_apply, self)
 
   def sym_jsonify(
-      self, use_inferred: bool = False, **kwargs
+      self,
+      use_inferred: bool = False,
+      omit_symbolic_marker: bool = True,
+      **kwargs
   ) -> utils.JSONValueType:
     """Converts current list to a list of plain Python objects."""
     def json_item(idx):
       v = self.sym_getattr(idx)
       if use_inferred and isinstance(v, base.Inferential):
         v = self.sym_inferred(idx, default=v)
-      return base.to_json(v, use_inferred=use_inferred, **kwargs)
-    return [json_item(i) for i in range(len(self))]
+      return base.to_json(
+          v,
+          use_inferred=use_inferred,
+          omit_symbolic_marker=omit_symbolic_marker,
+          **kwargs
+      )
+    json_value = [json_item(i) for i in range(len(self))]
+    if not omit_symbolic_marker:
+      json_value.insert(0, utils.JSONConvertible.SYMBOLIC_MARKER)
+    return json_value
 
   def format(
       self,

pyglove/core/symbolic/list_test.py

@@ -506,8 +506,7 @@ class ListTest(unittest.TestCase):
   def test_index(self):
     sl = List([0, 1, 2, 1])
     self.assertEqual(sl.index(1), 1)
-    with self.assertRaisesRegex(
-        ValueError, '3 is not in list'):
+    with self.assertRaisesRegex(ValueError, '.* not in list'):
       _ = sl.index(3)
 
     # Index of inferred value is based on its symbolic form.
@@ -799,6 +798,10 @@ class ListTest(unittest.TestCase):
     self.assertEqual(
         sl.sym_jsonify(), [0, inferred.ValueFromParentChain().to_json()]
     )
+    self.assertEqual(
+        sl.sym_jsonify(omit_symbolic_marker=False),
+        ['__symbolic__', 0, inferred.ValueFromParentChain().to_json()]
+    )
 
   def test_sym_rebind(self):
     # Refer to RebindTest for more detailed tests.
@@ -1633,6 +1636,25 @@ class SerializationTest(unittest.TestCase):
         'Tuple should have at least one element besides \'__tuple__\'.'):
       base.from_json_str('["__tuple__"]')
 
+  def test_auto_symbolic(self):
+    value = base.from_json([1, 2, 3], auto_symbolic=True)
+    self.assertIsInstance(value, List)
+
+    value = base.from_json([1, 2, 3], auto_symbolic=False)
+    self.assertNotIsInstance(value, List)
+
+  def test_omit_symbolic_marker(self):
+    sl = List([0])
+    self.assertEqual(sl.to_json(omit_symbolic_marker=True), [0])
+    self.assertEqual(
+        sl.to_json(omit_symbolic_marker=False),
+        ['__symbolic__', 0]
+    )
+    sl = base.from_json(['__symbolic__', 0], auto_symbolic=False)
+    self.assertEqual(sl.to_json(omit_symbolic_marker=True), [0])
+    self.assertIsInstance(sl, List)
+    self.assertEqual(sl, [0])
+
   def test_hide_default_values(self):
     sl = List.partial(
         [dict(x=1)],

pyglove/core/symbolic/object.py

@@ -339,7 +339,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
 
     # Set `__serialization_key__` before JSONConvertible.__init_subclass__
     # is called.
-    setattr(cls, '__serialization_key__', cls.__type_name__)
+    if '__serialization_key__' not in cls.__dict__:
+      setattr(cls, '__serialization_key__', cls.__type_name__)
 
     super().__init_subclass__()
 
@@ -994,6 +995,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
             self.__class__.__serialization_key__
         )
     }
+    kwargs['omit_symbolic_marker'] = True
     json_dict.update(self._sym_attributes.to_json(**kwargs))
     return json_dict
 

pyglove/core/symbolic/object_test.py

@@ -38,6 +38,7 @@ from pyglove.core.symbolic.object import use_init_args as pg_use_init_args
 from pyglove.core.symbolic.origin import Origin
 from pyglove.core.symbolic.pure_symbolic import NonDeterministic
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic
+from pyglove.core.symbolic.unknown_symbols import UnknownTypedObject
 from pyglove.core.views.html import tree_view  # pylint: disable=unused-import
 
 
@@ -3158,7 +3159,7 @@ class SerializationTest(unittest.TestCase):
             Q.partial(P.partial()).to_json_str(), allow_partial=True),
         Q.partial(P.partial()))
 
-  def test_serialization_with_auto_dict(self):
+  def test_serialization_with_convert_unknown(self):
 
     class P(Object):
       auto_register = False
@@ -3181,15 +3182,17 @@ class SerializationTest(unittest.TestCase):
         }
     )
     self.assertEqual(
-        base.from_json_str(Q(P(1), y='foo').to_json_str(), auto_dict=True),
-        {
-            'p': {
-                'type_name': P.__type_name__,
-                'x': 1
-            },
-            'y': 'foo',
-            'type_name': Q.__type_name__,
-        }
+        base.from_json_str(
+            Q(P(1), y='foo').to_json_str(), convert_unknown=True
+        ),
+        UnknownTypedObject(
+            type_name=Q.__type_name__,
+            p=UnknownTypedObject(
+                type_name=P.__type_name__,
+                x=1
+            ),
+            y='foo'
+        )
     )
 
   def test_serialization_with_converter(self):

pyglove/core/symbolic/ref.py

@@ -138,9 +138,7 @@ class Ref(
     del child_transform
     # Check if the field being assigned could accept the referenced value.
     # We do not do any transformation, thus not passing the child transform.
-    value_spec.apply(
-        self._value,
-        allow_partial=allow_partial)
+    value_spec.apply(self._value, allow_partial=allow_partial)
     return (False, self)
 
   def _sym_clone(self, deep: bool, memo: Any = None) -> 'Ref':
@@ -152,10 +150,24 @@ class Ref(
   def sym_eq(self, other: Any) -> bool:
     return isinstance(other, Ref) and self.value is other.value
 
-  def sym_jsonify(self, *, save_ref_value: bool = False, **kwargs: Any) -> Any:
-    if save_ref_value:
-      return base.to_json(self._value, save_ref_value=save_ref_value, **kwargs)
-    raise TypeError(f'{self!r} cannot be serialized at the moment.')
+  def sym_jsonify(
+      self,
+      *,
+      context: utils.JSONConversionContext,
+      **kwargs: Any
+  ) -> Any:
+    # Disable auto_symbolic for Ref value. This allows Ref to create a sub-tree
+    # for reference sharing.
+    kwargs['omit_symbolic_marker'] = False
+    return {
+        utils.JSONConvertible.TYPE_NAME_KEY: self.__class__.__type_name__,
+        'value': context.serialize_maybe_shared(self._value, **kwargs)
+    }
+
+  @classmethod
+  def from_json(cls, json: Any, **kwargs):
+    kwargs['auto_symbolic'] = False
+    return super().from_json(json, **kwargs)
 
   def __getstate__(self):
     raise TypeError(f'{self!r} cannot be pickled at the moment.')

pyglove/core/symbolic/ref_test.py

@@ -21,8 +21,11 @@ from typing import Any
 import unittest
 
 from pyglove.core import typing as pg_typing
+from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
 from pyglove.core.symbolic import ref
 from pyglove.core.symbolic.base import contains
+from pyglove.core.symbolic.base import from_json
+from pyglove.core.symbolic.base import to_json
 from pyglove.core.symbolic.dict import Dict
 from pyglove.core.symbolic.object import Object
 
@@ -33,6 +36,10 @@ class A(Object):
 
 class RefTest(unittest.TestCase):
 
+  def setUp(self):
+    super().setUp()
+    self.maxDiff = None
+
   def test_basics(self):
 
     a = A(1)
@@ -109,14 +116,94 @@ class RefTest(unittest.TestCase):
         """))
 
   def test_to_json(self):
-    with self.assertRaisesRegex(
-        TypeError, '.* cannot be serialized at the moment'):
-      ref.Ref(A(1)).to_json()
+    class B(Object):
+      y: Any
 
-    self.assertEqual(
-        ref.Ref(A(1)).to_json(save_ref_value=True),
-        A(1).to_json()
-    )
+    a = A(1)
+    r1 = ref.Ref(a)
+    r2 = ref.Ref({'z': a})
+    r3 = ref.Ref(Dict(t=r1, p=r2))
+    v = Dict(a=r1, b=[B(r2), [r3], r1])
+    self.assertIs(v.a, v.b[0].y['z'])
+    self.assertIs(v.a, v.b[1][0].t)
+    self.assertIs(v.b[0].y, v.b[1][0].p)
+    self.assertIs(v.a, v.b[2])
+    self.assertIsInstance(v, dict)
+    self.assertIsInstance(v.b[0].y, dict)
+    self.assertNotIsInstance(v.b[0].y, Dict)
+    self.assertIsInstance(v.b[1][0], Dict)
+
+    json = to_json(v)
+    expected = {
+        '__context__': {
+            'shared_objects': [
+                {
+                    '_type': A.__type_name__,
+                    'x': 1
+                },
+                {
+                    'z': {
+                        '__ref__': 0
+                    }
+                }
+            ]
+        },
+        '__root__': {
+            'a': {
+                '_type': ref.Ref.__type_name__,
+                'value': {
+                    '__ref__': 0
+                }
+            },
+            'b': [
+                {
+                    '_type': B.__type_name__,
+                    'y': {
+                        '_type': ref.Ref.__type_name__,
+                        'value': {
+                            '__ref__': 1
+                        }
+                    }
+                },
+                [
+                    {
+                        '_type': ref.Ref.__type_name__,
+                        'value': {
+                            '__symbolic__': True,
+                            't': {
+                                '_type': ref.Ref.__type_name__,
+                                'value': {
+                                    '__ref__': 0
+                                }
+                            },
+                            'p': {
+                                '_type': ref.Ref.__type_name__,
+                                'value': {
+                                    '__ref__': 1
+                                }
+                            }
+                        }
+                    }
+                ],
+                {
+                    '_type': ref.Ref.__type_name__,
+                    'value': {
+                        '__ref__': 0
+                    }
+                }
+            ]
+        }
+    }
+    self.assertEqual(json, expected)
+    v = from_json(json)
+    self.assertIs(v.a, v.b[0].y['z'])
+    self.assertIs(v.a, v.b[1][0].t)
+    self.assertIs(v.b[0].y, v.b[1][0].p)
+    self.assertIs(v.a, v.b[2])
+    self.assertIsInstance(v, dict)
+    self.assertIsInstance(v.b[0].y, dict)
+    self.assertNotIsInstance(v.b[0].y, Dict)
+    self.assertIsInstance(v.b[1][0], Dict)
 
   def test_pickle(self):
     with self.assertRaisesRegex(

pyglove/core/symbolic/unknown_symbols.py

@@ -0,0 +1,147 @@
+# Copyright 2021 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.
+"""Symbolic types for reprenting unknown types and objects."""
+
+from typing import Annotated, Any, ClassVar, Literal
+from pyglove.core import typing as pg_typing
+from pyglove.core import utils
+from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
+from pyglove.core.symbolic import object as pg_object
+
+
+class UnknownSymbol(pg_object.Object, pg_typing.CustomTyping):
+  """Interface for symbolic representation of unknown symbols."""
+  auto_register = False
+
+  def custom_apply(self, *args, **kwargs) -> tuple[bool, Any]:
+    """Bypass PyGlove type check."""
+    return (False, self)
+
+
+class UnknownType(UnknownSymbol):
+  """Symbolic object for representing unknown types."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_type'
+
+  # TODO(daiyip): Revisit the design on how `pg.typing.Object()` handles
+  # UnknownType. This hacky solution should be removed in the future.
+  __no_type_check__ = True
+
+  name: str
+  args: list[Any] = []
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    json_dict = {'_type': 'type', 'name': self.name}
+    if self.args:
+      json_dict['args'] = utils.to_json(self.args, **kwargs)
+    return json_dict
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    s = f'<unknown-type {self.name}>'
+    if self.args:
+      s += f'[{", ".join(repr(x) for x in self.args)}]'
+    return s
+
+  def __call__(self, **kwargs):
+    return UnknownTypedObject(
+        type_name=self.name, **kwargs
+    )
+
+
+class UnknownCallable(UnknownSymbol):
+  """Symbolic object for representing unknown callables."""
+
+  auto_register = False
+  name: str
+  CALLABLE_TYPE: ClassVar[Literal['function', 'method']]
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    return {'_type': self.CALLABLE_TYPE, 'name': self.name}
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    return f'<unknown-{self.CALLABLE_TYPE} {self.name}>'
+
+
+class UnknownFunction(UnknownCallable):
+  """Symbolic objject for representing unknown functions."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_function'
+  CALLABLE_TYPE = 'function'
+
+
+class UnknownMethod(UnknownCallable):
+  """Symbolic object for representing unknown methods."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_method'
+  CALLABLE_TYPE = 'method'
+
+
+class UnknownTypedObject(UnknownSymbol):
+  """Symbolic object for representing objects of unknown-type."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_object'
+
+  type_name: str
+  __kwargs__: Annotated[
+      Any,
+      (
+          'Fields of the original object will be kept as symbolic attributes '
+          'of this object so they can be accessed through `__getattr__`.'
+      )
+  ]
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    """Converts current object to a dict of plain Python objects."""
+    json_dict = self._sym_attributes.to_json(
+        exclude_keys=set(['type_name']), **kwargs
+    )
+    assert isinstance(json_dict, dict)
+    json_dict[utils.JSONConvertible.TYPE_NAME_KEY] = self.type_name
+    return json_dict
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    exclude_keys = kwargs.pop('exclude_keys', set())
+    exclude_keys.add('type_name')
+    kwargs['exclude_keys'] = exclude_keys
+    return self._sym_attributes.format(
+        compact,
+        verbose,
+        root_indent,
+        cls_name=f'<unknown-type {self.type_name}>',
+        key_as_attribute=True,
+        bracket_type=utils.BracketType.ROUND,
+        **kwargs,
+    )