pyglove 0.4.5.dev202412130809__py3-none-any.whl → 0.4.5.dev202412150808__py3-none-any.whl

pyglove/core/object_utils/common_traits.py

@@ -18,7 +18,7 @@ object, for example, partiality (MaybePartial), functor (Functor).
 """
 
 import abc
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 
 
 class MaybePartial(metaclass=abc.ABCMeta):
@@ -47,7 +47,7 @@ class MaybePartial(metaclass=abc.ABCMeta):
     return len(self.missing_values()) > 0  # pylint: disable=g-explicit-length-test
 
   @abc.abstractmethod
-  def missing_values(self, flatten: bool = True) -> Dict[str, Any]:  # pylint: disable=redefined-outer-name
+  def missing_values(self, flatten: bool = True) -> Dict[Union[str, int], Any]:  # pylint: disable=redefined-outer-name
     """Returns missing values from this object.
 
     Args:

pyglove/core/object_utils/json_conversion.py

@@ -37,7 +37,7 @@ JSONPrimitiveType = Union[int, float, bool, str]
 # pytype doesn't support recursion. Use Any instead of 'JSONValueType'
 # in List and Dict.
 JSONListType = List[Any]
-JSONDictType = Dict[str, Any]
+JSONDictType = Dict[Union[str, int], Any]
 JSONValueType = Union[JSONPrimitiveType, JSONListType, JSONDictType]
 
 # pylint: enable=invalid-name

pyglove/core/symbolic/base.py

@@ -310,7 +310,7 @@ class Symbolic(
     """Seals or unseals current object from further modification."""
     return self._set_raw_attr('_sealed', is_seal)
 
-  def sym_missing(self, flatten: bool = True) -> Dict[str, Any]:
+  def sym_missing(self, flatten: bool = True) -> Dict[Union[str, int], Any]:
     """Returns missing values."""
     missing = getattr(self, '_sym_missing_values')
     if missing is None:
@@ -729,7 +729,7 @@ class Symbolic(
     """Returns if current object is deterministic."""
     return is_deterministic(self)
 
-  def missing_values(self, flatten: bool = True) -> Dict[str, Any]:
+  def missing_values(self, flatten: bool = True) -> Dict[Union[str, int], Any]:
     """Alias for `sym_missing`."""
     return self.sym_missing(flatten)
 
@@ -1094,7 +1094,7 @@ class Symbolic(
     """
 
   @abc.abstractmethod
-  def _sym_missing(self) -> Dict[str, Any]:
+  def _sym_missing(self) -> Dict[Union[str, int], Any]:
     """Returns missing values."""
 
   @abc.abstractmethod
@@ -2142,8 +2142,23 @@ def from_json_str(json_str: str,
   Returns:
     A deserialized value.
   """
+  def _get_key(k: str) -> Union[str, int]:
+    if k.startswith('n_:'):
+      return int(k[3:])
+    return k
+
+  def _decode_int_keys(v):
+    if isinstance(v, dict):
+      return {
+          _get_key(k): _decode_int_keys(v)
+          for k, v in v.items()
+      }
+    elif isinstance(v, list):
+      return [_decode_int_keys(v) for v in v]
+    return v
+
   return from_json(
-      json.loads(json_str),
+      _decode_int_keys(json.loads(json_str)),
       allow_partial=allow_partial,
       root_path=root_path,
       auto_import=auto_import,
@@ -2217,7 +2232,20 @@ def to_json_str(value: Any,
   Returns:
     A JSON string.
   """
-  return json.dumps(to_json(value, **kwargs), indent=json_indent)
+  def _encode_int_keys(v):
+    if isinstance(v, dict):
+      return {
+          f'n_:{k}' if isinstance(k, int) else k: _encode_int_keys(v)
+          for k, v in v.items()
+      }
+    elif isinstance(v, list):
+      return [
+          _encode_int_keys(v) for v in v
+      ]
+    return v
+  return json.dumps(
+      _encode_int_keys(to_json(value, **kwargs)), indent=json_indent
+  )
 
 
 def load(path: str, *args, **kwargs) -> Any:

pyglove/core/symbolic/dict.py

@@ -97,7 +97,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
 
   @classmethod
   def partial(cls,
-              dict_obj: Optional[typing.Dict[str, Any]] = None,
+              dict_obj: Optional[typing.Dict[Union[str, int], Any]] = None,
               value_spec: Optional[pg_typing.Dict] = None,
               *,
               onchange_callback: Optional[Callable[
@@ -169,8 +169,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
   def __init__(self,
                dict_obj: Union[
                    None,
-                   Iterable[Tuple[str, Any]],
-                   typing.Dict[str, Any]] = None,
+                   Iterable[Tuple[Union[str, int], Any]],
+                   typing.Dict[Union[str, int], Any]] = None,
                *,
                value_spec: Optional[pg_typing.Dict] = None,
                onchange_callback: Optional[Callable[
@@ -345,7 +345,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         updates.append(update)
     return updates
 
-  def _sym_missing(self) -> typing.Dict[str, Any]:
+  def _sym_missing(self) -> typing.Dict[Union[str, int], Any]:
     """Returns missing values.
 
     Returns:
@@ -375,7 +375,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             missing[k] = missing_child
     return missing
 
-  def _sym_nondefault(self) -> typing.Dict[str, Any]:
+  def _sym_nondefault(self) -> typing.Dict[Union[str, int], Any]:
     """Returns non-default values as key/value pairs in a dict."""
     non_defaults = dict()
     if self._value_spec is not None and self._value_spec.schema:
@@ -444,7 +444,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     """Tests if a symbolic attribute exists."""
     return key in self
 
-  def sym_keys(self) -> Iterator[str]:
+  def sym_keys(self) -> Iterator[Union[str, int]]:
     """Iterates the keys of symbolic attributes."""
     if self._value_spec is None or self._value_spec.schema is None:
       for key in super().__iter__():
@@ -467,7 +467,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       yield self._sym_getattr(k)
 
   def sym_items(self) -> Iterator[
-      Tuple[str, Any]]:
+      Tuple[Union[str, int], Any]]:
     """Iterates the (key, value) pairs of symbolic attributes."""
     for k in self.sym_keys():
       yield k, self._sym_getattr(k)
@@ -490,7 +490,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
                 if v != pg_typing.MISSING_VALUE])))
 
   def _sym_getattr(  # pytype: disable=signature-mismatch  # overriding-parameter-type-checks
-      self, key: str) -> Any:
+      self, key: Union[str, int]) -> Any:
     """Gets symbolic attribute by key."""
     return super().__getitem__(key)
 
@@ -524,11 +524,11 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
         v.sym_setpath(object_utils.KeyPath(k, new_path))
 
   def _set_item_without_permission_check(  # pytype: disable=signature-mismatch  # overriding-parameter-type-checks
-      self, key: str, value: Any) -> Optional[base.FieldUpdate]:
+      self, key: Union[str, int], value: Any) -> Optional[base.FieldUpdate]:
     """Set item without permission check."""
-    if not isinstance(key, str):
+    if not isinstance(key, (str, int)):
       raise KeyError(self._error_message(
-          f'Key must be string type. Encountered {key!r}.'))
+          f'Key must be string or int type. Encountered {key!r}.'))
 
     old_value = self.get(key, pg_typing.MISSING_VALUE)
     if old_value is value:
@@ -545,7 +545,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
           container_cls = self.__class__
         raise KeyError(
             self._error_message(
-                f'Key \'{key}\' is not allowed for {container_cls}.'))
+                f'Key {key!r} is not allowed for {container_cls}.'))
 
     # Detach old value from object tree.
     if isinstance(old_value, base.TopologyAware):
@@ -575,9 +575,11 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     return base.FieldUpdate(
         self.sym_path + key, target, field, old_value, new_value)
 
-  def _formalized_value(self, name: str,
-                        field: Optional[pg_typing.Field],
-                        value: Any) -> Any:
+  def _formalized_value(
+      self, name: Union[str, int],
+      field: Optional[pg_typing.Field],
+      value: Any
+  ) -> Any:
     """Get transformed (formal) value from user input."""
     allow_partial = base.accepts_partial(self)
     if field and pg_typing.MISSING_VALUE == value:
@@ -625,14 +627,14 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     """Customizes pickle.load."""
     self.__init__(state['value'], **state['kwargs'])
 
-  def __getitem__(self, key: str) -> Any:
+  def __getitem__(self, key: Union[str, int]) -> Any:
     """Get item in this Dict."""
     try:
       return self.sym_inferred(key)
     except AttributeError as e:
       raise KeyError(key) from e
 
-  def __setitem__(self, key: str, value: Any) -> None:
+  def __setitem__(self, key: Union[str, int], value: Any) -> None:
     """Set item in this Dict.
 
     Args:
@@ -733,11 +735,11 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     """Iterate keys in field declaration order."""
     return self.sym_keys()
 
-  def keys(self) -> Iterator[str]:  # pytype: disable=signature-mismatch
+  def keys(self) -> Iterator[Union[str, int]]:  # pytype: disable=signature-mismatch
     """Returns an iterator of keys in current dict."""
     return self.sym_keys()
 
-  def items(self) -> Iterator[Tuple[str, Any]]:  # pytype: disable=signature-mismatch
+  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()
 
@@ -750,7 +752,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     return self.sym_clone(deep=False)
 
   def pop(
-      self, key: Any, default: Any = base.RAISE_IF_NOT_FOUND  # pylint: disable=protected-access
+      self, key: Union[str, int], default: Any = base.RAISE_IF_NOT_FOUND  # pylint: disable=protected-access
   ) -> Any:
     """Pops a key from current dict."""
     if key in self:
@@ -762,7 +764,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       raise KeyError(key)
     return default
 
-  def popitem(self) -> Tuple[str, Any]:
+  def popitem(self) -> Tuple[Union[str, int], Any]:
     if self._value_spec is not None:
       raise ValueError(
           '\'popitem\' cannot be performed on a Dict with value spec.')
@@ -781,7 +783,7 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
     if value_spec:
       self.use_value_spec(value_spec, self._allow_partial)
 
-  def setdefault(self, key: str, default: Any = None) -> Any:
+  def setdefault(self, key: Union[str, int], default: Any = None) -> Any:
     """Sets default as the value to key if not present."""
     value = pg_typing.MISSING_VALUE
     if key in self:
@@ -791,12 +793,15 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       value = default
     return value
 
-  def update(self,
-             other: Union[
-                 None,
-                 typing.Dict[str, Any],
-                 Iterable[Tuple[str, Any]]] = None,
-             **kwargs) -> None:  # pytype: disable=signature-mismatch
+  def update(
+      self,
+      other: Union[
+          None,
+          typing.Dict[Union[str, int], Any],
+          Iterable[Tuple[Union[str, int], Any]]
+      ] = None,
+      **kwargs
+  ) -> None:  # pytype: disable=signature-mismatch
     """Update Dict with the same semantic as update on standard dict."""
     updates = dict(other) if other else {}
     updates.update(kwargs)
@@ -807,9 +812,10 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       self,
       hide_frozen: bool = True,
       hide_default_values: bool = False,
-      exclude_keys: Optional[Sequence[str]] = None,
+      exclude_keys: Optional[Sequence[Union[str, int]]] = None,
       use_inferred: bool = False,
-      **kwargs) -> object_utils.JSONValueType:
+      **kwargs
+  ) -> object_utils.JSONValueType:
     """Converts current object to a dict with plain Python objects."""
     exclude_keys = set(exclude_keys or [])
     if self._value_spec and self._value_spec.schema:
@@ -896,8 +902,8 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
       hide_frozen: bool = True,
       hide_default_values: bool = False,
       hide_missing_values: bool = False,
-      include_keys: Optional[Set[str]] = None,
-      exclude_keys: Optional[Set[str]] = None,
+      include_keys: Optional[Set[Union[str, int]]] = None,
+      exclude_keys: Optional[Set[Union[str, int]]] = None,
       use_inferred: bool = False,
       cls_name: Optional[str] = None,
       bracket_type: object_utils.BracketType = object_utils.BracketType.CURLY,
@@ -963,10 +969,12 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             extra_blankline_for_field_docstr=extra_blankline_for_field_docstr,
             **kwargs)
         if not python_format or key_as_attribute:
-          kv_strs.append(f'{k}={v_str}')
+          if isinstance(k, int):
+            k = f'[{k}]'
+          item = f'{k}={v_str}'
         else:
-          kv_strs.append(f'\'{k}\': {v_str}')
-
+          item = f'{k!r}: {v_str}'
+        kv_strs.append(item)
       s.append(', '.join(kv_strs))
       s.append(close_bracket)
     else:
@@ -993,15 +1001,19 @@ class Dict(dict, base.Symbolic, pg_typing.CustomTyping):
             use_inferred=use_inferred,
             extra_blankline_for_field_docstr=extra_blankline_for_field_docstr,
             **kwargs)
+
         if not python_format:
           # Format in PyGlove's format (default).
-          s.append(_indent(f'{k} = {v_str}', root_indent + 1))
+          if isinstance(k, int):
+            k = f'[{k}]'
+          item = f'{k} = {v_str}'
         elif key_as_attribute:
           # Format `pg.Objects` under Python format.
-          s.append(_indent(f'{k}={v_str}', root_indent + 1))
+          item = f'{k}={v_str}'
         else:
           # Format regular `pg.Dict` under Python format.
-          s.append(_indent(f'\'{k}\': {v_str}', root_indent + 1))
+          item = f'{k!r}: {v_str}'
+        s.append(_indent(item, root_indent + 1))
       s.append('\n')
       s.append(_indent(close_bracket, root_indent))
     return ''.join(s)

pyglove/core/symbolic/dict_test.py

@@ -44,14 +44,14 @@ class DictTest(unittest.TestCase):
     self.assertEqual(len(sd), 0)
 
     # Schemaless dict created from a regular dict.
-    sd = Dict({'a': 1})
+    sd = Dict({'a': 1, 1: 1})
     self.assertIsNone(sd.value_spec)
-    self.assertEqual(sd, dict(a=1))
+    self.assertEqual(sd, {'a': 1, 1: 1})
 
     # Schemaless dict created from key value pairs.
-    sd = Dict((('a', 1),))
+    sd = Dict((('a', 1), (1, 1)))
     self.assertIsNone(sd.value_spec)
-    self.assertEqual(sd, dict(a=1))
+    self.assertEqual(sd, {'a': 1, 1: 1})
 
     # Schemaless dict created from keyword args.
     sd = Dict(a=1)
@@ -59,9 +59,9 @@ class DictTest(unittest.TestCase):
     self.assertEqual(sd, dict(a=1))
 
     # Schemaless dict created from both a regular dict and keyword args.
-    sd = Dict({'a': 1}, a=2)
+    sd = Dict({'a': 1, 1: 1}, a=2)
     self.assertIsNone(sd.value_spec)
-    self.assertEqual(sd, dict(a=2))
+    self.assertEqual(sd, {'a': 2, 1: 1})
 
     # Schematized dict.
     vs = pg_typing.Dict([('a', pg_typing.Int())])
@@ -305,8 +305,8 @@ class DictTest(unittest.TestCase):
       with self.assertRaisesRegex(
           base.WritePermissionError, 'Cannot modify field of a sealed Dict.'):
         sd['b'] = 1
-    with self.assertRaisesRegex(KeyError, 'Key must be string type'):
-      sd[0] = 1
+    with self.assertRaisesRegex(KeyError, 'Key must be string or int type'):
+      sd[0.5] = 1
 
     # Set item in a schematized dict.
     sd = Dict(value_spec=pg_typing.Dict([('a', pg_typing.Int(default=0))]))
@@ -786,35 +786,45 @@ class DictTest(unittest.TestCase):
         sd.missing_values(flatten=False), {'a': MISSING_VALUE})
 
     # A non-schematized dict has a schematized child.
-    sd = Dict(x=sd)
+    sd = Dict({'x': sd, 1: sd})
     self.assertIsNone(sd.value_spec)
-    self.assertEqual(sd.missing_values(), {'x.a': MISSING_VALUE})
+    self.assertEqual(
+        sd.missing_values(), {'x.a': MISSING_VALUE, '[1].a': MISSING_VALUE}
+    )
 
   def test_sym_has(self):
-    sd = Dict(x=1, y=Dict(z=2))
+    sd = Dict({'x': 1, 1: dict(a=3), 'y': Dict({'z': 2, 2: 3})})
     self.assertTrue(sd.sym_has('x'))
+    self.assertTrue(sd.sym_has(1))
     self.assertTrue(sd.sym_has('y.z'))
+    self.assertTrue(sd.sym_has('[1].a'))
+    self.assertTrue(sd.sym_has('y[2]'))
     self.assertTrue(sd.sym_has(object_utils.KeyPath.parse('y.z')))
     self.assertFalse(sd.sym_has('x.z'))
 
   def test_sym_get(self):
-    sd = Dict(x=1, y=Dict(z=2))
+    sd = Dict({'x': 1, 1: dict(a=3), 'y': Dict({'z': 2, 2: 3})})
     self.assertEqual(sd.sym_get('x'), 1)
+    self.assertEqual(sd.sym_get(1), dict(a=3))
     self.assertEqual(sd.sym_get('y.z'), 2)
+    self.assertEqual(sd.sym_get('[1].a'), 3)
+    self.assertEqual(sd.sym_get('y[2]'), 3)
     self.assertIsNone(sd.sym_get('x.z', None))
     with self.assertRaisesRegex(
         KeyError, 'Cannot query sub-key \'z\' of object.'):
       sd.sym_get('x.z')
 
   def test_sym_hasattr(self):
-    sd = Dict(x=1, y=Dict(z=2))
+    sd = Dict({'x': 1, 1: dict(a=3), 'y': Dict({'z': 2, 2: 3})})
     self.assertTrue(sd.sym_hasattr('x'))
+    self.assertTrue(sd.sym_hasattr(1))
     self.assertFalse(sd.sym_hasattr('y.z'))
     self.assertFalse(sd.sym_hasattr('a'))
 
   def test_sym_getattr(self):
-    sd = Dict(x=1, y=Dict(z=2))
+    sd = Dict({'x': 1, 1: dict(a=3), 'y': Dict({'z': 2, 2: 3})})
     self.assertEqual(sd.sym_getattr('x'), 1)
+    self.assertEqual(sd.sym_getattr(1), dict(a=3))
     self.assertIsNone(sd.sym_getattr('a', None))
     with self.assertRaisesRegex(
         AttributeError,
@@ -832,8 +842,9 @@ class DictTest(unittest.TestCase):
     with self.assertRaisesRegex(AttributeError, 'z'):
       _ = sd.sym_inferred('z')
 
-    sd = Dict(y=1, x=Dict(x=Dict(y=inferred.ValueFromParentChain())))
+    sd = Dict(y=1, x={'x': Dict(y=inferred.ValueFromParentChain()), 1: 2})
     self.assertEqual(sd.x.x.y, 1)
+    self.assertEqual(sd.x[1], 2)
 
   def test_sym_field(self):
     sd = Dict(x=1, y=Dict(z=2))
@@ -859,9 +870,9 @@ class DictTest(unittest.TestCase):
     self.assertIs(sd.sym_attr_field('x'), spec.schema.get_field('x'))
 
   def test_sym_keys(self):
-    sd = Dict(x=1, y=2)
+    sd = Dict({'x': 1, 'y': 2, 1: 3})
     self.assertEqual(next(sd.sym_keys()), 'x')
-    self.assertEqual(list(sd.sym_keys()), ['x', 'y'])
+    self.assertEqual(list(sd.sym_keys()), ['x', 'y', 1])
 
     sd = Dict(x=1, z=3, y=2, value_spec=pg_typing.Dict([
         (pg_typing.StrKey(), pg_typing.Int())
@@ -874,9 +885,9 @@ class DictTest(unittest.TestCase):
     self.assertEqual(list(sd.sym_keys()), ['x', 'y'])
 
   def test_sym_values(self):
-    sd = Dict(x=1, y=2)
+    sd = Dict({'x': 1, 'y': 2, 1: 3})
     self.assertEqual(next(sd.sym_values()), 1)
-    self.assertEqual(list(sd.sym_values()), [1, 2])
+    self.assertEqual(list(sd.sym_values()), [1, 2, 3])
 
     sd = Dict(x=1, z=3, y=2, value_spec=pg_typing.Dict([
         (pg_typing.StrKey(), pg_typing.Int())
@@ -891,9 +902,9 @@ class DictTest(unittest.TestCase):
     )
 
   def test_sym_items(self):
-    sd = Dict(x=1, y=2)
+    sd = Dict({'x': 1, 'y': 2, 1: 3})
     self.assertEqual(next(sd.sym_items()), ('x', 1))
-    self.assertEqual(list(sd.sym_items()), [('x', 1), ('y', 2)])
+    self.assertEqual(list(sd.sym_items()), [('x', 1), ('y', 2), (1, 3)])
 
     sd = Dict(x=1, z=3, y=2, value_spec=pg_typing.Dict([
         (pg_typing.StrKey(), pg_typing.Int())
@@ -917,9 +928,9 @@ class DictTest(unittest.TestCase):
 
   def test_sym_rebind(self):
     # Refer to RebindTest for more detailed tests.
-    sd = Dict(x=1, y=2)
-    sd.sym_rebind(x=2)
-    self.assertEqual(sd, dict(x=2, y=2))
+    sd = Dict({'x': 1, 'y': 2, 1: 3})
+    sd.sym_rebind({1: 4}, x=2)
+    self.assertEqual(sd, {'x': 2, 'y': 2, 1: 4})
 
   def test_sym_clone(self):
     class A:
@@ -997,6 +1008,12 @@ class DictTest(unittest.TestCase):
       y: int = 1
       use_symbolic_comparison = True
 
+    sd = Dict({'x': A(2), 1: B(2)})
+    self.assertEqual(sd.sym_nondefault(), {'x.x': 2, '[1].y': 2})
+
+    sd = Dict({'x': A(1), 1: B(1)})
+    self.assertEqual(sd.sym_nondefault(), {'x.x': 1})
+
     sd = Dict(x=1, y=dict(a1=A(1)), value_spec=pg_typing.Dict([
         ('x', pg_typing.Int(default=0)),
         ('y', pg_typing.Dict([
@@ -1080,7 +1097,7 @@ class DictTest(unittest.TestCase):
     self.assertTrue(Dict().sym_eq(Dict()))
     self.assertTrue(base.eq(Dict(), Dict()))
 
-    self.assertEqual(Dict(a=1), Dict(a=1))
+    self.assertEqual(Dict({'a': 1, 1: 2}), Dict({'a': 1, 1: 2}))
     self.assertTrue(Dict(a=1).sym_eq(Dict(a=1)))
     self.assertTrue(base.eq(Dict(a=1), Dict(a=1)))
     self.assertTrue(
@@ -1130,6 +1147,8 @@ class DictTest(unittest.TestCase):
     self.assertTrue(base.ne(Dict(), 1))
     self.assertNotEqual(Dict(), Dict(a=1))
     self.assertTrue(base.ne(Dict(), Dict(a=1)))
+    self.assertNotEqual(Dict({1: 1}), Dict({'1': 1}))
+    self.assertTrue(base.ne(Dict({1: 1}), Dict({'1': 1})))
     self.assertNotEqual(Dict(a=0), Dict(a=1))
     self.assertTrue(base.ne(Dict(a=0), Dict(a=1)))
 
@@ -1192,6 +1211,7 @@ class DictTest(unittest.TestCase):
     self.assertEqual(hash(Dict(a=1)), hash(Dict(a=1)))
     self.assertEqual(hash(Dict(a=dict(x=1))), hash(Dict(a=dict(x=1))))
     self.assertNotEqual(hash(Dict()), hash(Dict(a=1)))
+    self.assertNotEqual(hash(Dict({'1': 1})), hash(Dict({1: 1})))
     self.assertNotEqual(hash(Dict(a=1)), hash(Dict(a=2)))
 
     class A:
@@ -1845,10 +1865,6 @@ class RebindTest(unittest.TestCase):
         ValueError, 'There are no values to rebind.'):
       Dict().rebind({})
 
-    with self.assertRaisesRegex(
-        KeyError, 'Key must be string type. Encountered 1'):
-      Dict().rebind({1: 1})
-
     with self.assertRaisesRegex(
         ValueError, 'Required value is not specified.'):
       Dict(a=1, value_spec=pg_typing.Dict([('a', pg_typing.Int())])).rebind({
@@ -1859,13 +1875,17 @@ class SerializationTest(unittest.TestCase):
   """Dedicated tests for `pg.Dict` serialization."""
 
   def test_schemaless(self):
-    sd = Dict()
+    sd = Dict({1: 2})
     sd.b = 0
     sd.c = None
     sd.a = 'foo'
 
     # Key order is preserved.
-    self.assertEqual(sd.to_json_str(), '{"b": 0, "c": null, "a": "foo"}')
+    self.assertEqual(
+        sd.to_json_str(),
+        '{"n_:1": 2, "b": 0, "c": null, "a": "foo"}'
+    )
+    self.assertEqual(base.from_json_str(sd.to_json_str()), sd)
 
   def test_schematized(self):
     sd = Dict.partial(
@@ -2188,6 +2208,7 @@ class FormatTest(unittest.TestCase):
         }"""))
 
   def test_noncompact_verbose_with_extra_blankline_for_field_docstr(self):
+    self.maxDiff = None
     self.assertEqual(
         self._dict.format(
             compact=False, verbose=True, extra_blankline_for_field_docstr=True),
@@ -2306,6 +2327,25 @@ class FormatTest(unittest.TestCase):
         '{\n  x = 1,\n  y = True,\n  z = {\n    v = 1,\n    w = True\n  }\n}'
     )
 
+  def test_compact_int_key(self):
+    d = Dict({1: 1, '1': 2})
+    self.assertEqual(d.format(compact=True), '{[1]=1, 1=2}')
+    self.assertEqual(
+        d.format(compact=True, python_format=True),
+        '{1: 1, \'1\': 2}'
+    )
+
+  def test_non_compact_int_key(self):
+    d = Dict({1: 1, '1': 2})
+    self.assertEqual(
+        d.format(compact=False, verbose=False),
+        '{\n  [1] = 1,\n  1 = 2\n}'
+    )
+    self.assertEqual(
+        d.format(compact=False, python_format=True),
+        '{\n  1: 1,\n  \'1\': 2\n}'
+    )
+
 
 def _on_change_callback(updates):
   del updates

pyglove/core/symbolic/object.py

@@ -164,11 +164,22 @@ class ObjectMeta(abc.ABCMeta):
       if key is None:
         continue
 
+      # Skip class-level attributes that are not symbolic fields.
+      if typing.get_origin(attr_annotation) is typing.ClassVar:
+        continue
+
       field = pg_typing.Field.from_annotation(key, attr_annotation)
       if isinstance(key, pg_typing.ConstStrKey):
         attr_value = cls.__dict__.get(attr_name, pg_typing.MISSING_VALUE)
         if attr_value != pg_typing.MISSING_VALUE:
           field.value.set_default(attr_value)
+
+      if (field.value.frozen and
+          field.value.default is
+          pg_typing.value_specs._FROZEN_VALUE_PLACEHOLDER):  # pylint: disable=protected-access
+        raise TypeError(
+            f'Field {field.key!r} is marked as final but has no default value.'
+        )
       fields.append(field)
 
     # Trigger event so subclass could modify the fields.

pyglove/core/symbolic/object_test.py

@@ -324,6 +324,26 @@ class ObjectTest(unittest.TestCase):
     self.assertEqual(e.x, 1)
     self.assertEqual(e.y, 3)
 
+    class F(Object):
+      x: typing.Literal[1, 'a']
+
+    class G(F):
+      x: typing.Final[int] = 1
+      y: typing.ClassVar[int] = 2
+
+    self.assertEqual(G().x, 1)
+    self.assertEqual(G.y, 2)
+
+    with self.assertRaisesRegex(
+        ValueError, 'Frozen field is not assignable'):
+      G(x=2)
+
+    with self.assertRaisesRegex(
+        TypeError, 'Field x is marked as final but has no default value'):
+
+      class H(Object):  # pylint: disable=unused-variable
+        x: typing.Final[int]  # pylint: disable=invalid-name
+
   def test_init_arg_list(self):
 
     def _update_init_arg_list(cls, init_arg_list):
@@ -2349,7 +2369,7 @@ class RebindTest(unittest.TestCase):
       A(1).rebind({})
 
     with self.assertRaisesRegex(
-        KeyError, 'Key must be string type. Encountered 1'):
+        KeyError, 'Key 1 is not allowed for .*'):
       A(1).rebind({1: 1})
 
     with self.assertRaisesRegex(