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

pyglove/core/io/file_system_test.py

@@ -16,6 +16,8 @@ import os
 import pathlib
 import tempfile
 import unittest
+from unittest import mock
+import fsspec
 from pyglove.core.io import file_system
 
 
@@ -82,6 +84,75 @@ class StdFileSystemTest(unittest.TestCase):
     fs.rmdirs(os.path.join(dir_a, 'b/c'))
     self.assertEqual(sorted(fs.listdir(dir_a)), ['file1'])   # pylint: disable=g-generic-assert
 
+  def test_rename(self):
+    tmp_dir = tempfile.mkdtemp()
+    fs = file_system.StdFileSystem()
+
+    _ = fs.mkdirs(os.path.join(tmp_dir, 'a/b'))
+    file_foo = os.path.join(tmp_dir, 'a/foo.txt')
+    file_bar = os.path.join(tmp_dir, 'a/bar.txt')
+
+    with fs.open(file_foo, 'w') as f:
+      f.write('foo')
+    with fs.open(file_bar, 'w') as f:
+      f.write('bar')
+
+    # Rename file to a new name.
+    file_foo_new = os.path.join(tmp_dir, 'a/foo-new.txt')
+    fs.rename(file_foo, file_foo_new)
+    self.assertFalse(fs.exists(file_foo))
+    self.assertTrue(fs.exists(file_foo_new))
+
+    # Rename file to an existing file name.
+    fs.rename(file_foo_new, file_bar)
+    self.assertFalse(fs.exists(file_foo_new))
+    with fs.open(file_bar, 'r') as f:
+      self.assertEqual(f.read(), 'foo')
+
+    # Rename directory to a new name.
+    dir_b = os.path.join(tmp_dir, 'a/b')
+    dir_c = os.path.join(tmp_dir, 'a/c')
+    fs.rename(dir_b, dir_c)
+    self.assertFalse(fs.exists(dir_b))
+    self.assertTrue(fs.exists(dir_c))
+    self.assertTrue(fs.isdir(dir_c))
+
+    # Rename directory to an existing empty directory.
+    dir_d = os.path.join(tmp_dir, 'a/d')
+    fs.mkdirs(dir_d)
+    fs.rename(dir_c, dir_d)
+    self.assertFalse(fs.exists(dir_c))
+    self.assertTrue(fs.exists(dir_d))
+
+    # Rename directory to a non-empty directory.
+    dir_x = os.path.join(tmp_dir, 'x')
+    dir_a = os.path.join(tmp_dir, 'a')
+    fs.mkdirs(os.path.join(dir_x, 'y'))
+    with self.assertRaises(OSError):
+      fs.rename(dir_a, dir_x)
+    self.assertTrue(fs.exists(dir_a))
+    self.assertTrue(fs.exists(os.path.join(dir_x, 'y')))
+
+    # Errors
+    dir_u = os.path.join(tmp_dir, 'u')
+    dir_u_v = os.path.join(dir_u, 'v')
+    file_u_a = os.path.join(dir_u, 'a.txt')
+    fs.mkdirs(dir_u_v)
+    with fs.open(file_u_a, 'w') as f:
+      f.write('a')
+
+    with self.assertRaises((OSError, NotADirectoryError)):
+      fs.rename(dir_u, file_u_a)
+
+    with self.assertRaises(IsADirectoryError):
+      fs.rename(file_u_a, dir_u_v)
+
+    with self.assertRaises(FileNotFoundError):
+      fs.rename(
+          os.path.join(tmp_dir, 'non-existent'),
+          os.path.join(tmp_dir, 'y')
+      )
+
 
 class MemoryFileSystemTest(unittest.TestCase):
 
@@ -180,6 +251,94 @@ class MemoryFileSystemTest(unittest.TestCase):
     fs.rmdirs(os.path.join(dir_a, 'b/c'))
     self.assertEqual(fs.listdir(dir_a), ['file1'])   # pylint: disable=g-generic-assert
 
+  def test_glob(self):
+    fs = file_system.MemoryFileSystem()
+    fs.mkdirs('/mem/a/b/c')
+    with fs.open('/mem/a/foo.txt', 'w') as f:
+      f.write('foo')
+    with fs.open('/mem/a/bar.json', 'w') as f:
+      f.write('bar')
+    with fs.open('/mem/a/b/baz.txt', 'w') as f:
+      f.write('baz')
+
+    self.assertEqual(
+        sorted(fs.glob('/mem/a/*')),
+        ['/mem/a/b', '/mem/a/b/baz.txt', '/mem/a/b/c',
+         '/mem/a/bar.json', '/mem/a/foo.txt'])
+    self.assertEqual(
+        sorted(fs.glob('/mem/a/*.txt')),
+        ['/mem/a/b/baz.txt', '/mem/a/foo.txt'])
+    self.assertEqual(
+        sorted(fs.glob('/mem/a/b/*')),
+        ['/mem/a/b/baz.txt', '/mem/a/b/c'])
+    self.assertEqual(fs.glob('/mem/a/b/*.txt'), ['/mem/a/b/baz.txt'])
+    self.assertEqual(fs.glob('/mem/a/b/c/*'), [])
+    self.assertEqual(fs.glob('/mem/a/???.txt'), ['/mem/a/foo.txt'])
+    self.assertEqual(fs.glob('/mem/a/bar.*'), ['/mem/a/bar.json'])
+    self.assertEqual(
+        sorted(fs.glob('/mem/a/*.*')),
+        ['/mem/a/b/baz.txt', '/mem/a/bar.json', '/mem/a/foo.txt'])
+
+  def test_rename(self):
+    fs = file_system.MemoryFileSystem()
+    fs.mkdirs('/mem/a/b')
+    with fs.open('/mem/a/foo.txt', 'w') as f:
+      f.write('foo')
+    with fs.open('/mem/a/bar.txt', 'w') as f:
+      f.write('bar')
+
+    # Rename file to a new name.
+    fs.rename('/mem/a/foo.txt', '/mem/a/foo-new.txt')
+    self.assertFalse(fs.exists('/mem/a/foo.txt'))
+    self.assertTrue(fs.exists('/mem/a/foo-new.txt'))
+
+    # Rename file to an existing file name.
+    fs.rename('/mem/a/foo-new.txt', '/mem/a/bar.txt')
+    self.assertFalse(fs.exists('/mem/a/foo-new.txt'))
+    with fs.open('/mem/a/bar.txt', 'r') as f:
+      self.assertEqual(f.read(), 'foo')
+
+    # Rename directory to a new name.
+    fs.rename('/mem/a/b', '/mem/a/c')
+    self.assertFalse(fs.exists('/mem/a/b'))
+    self.assertTrue(fs.exists('/mem/a/c'))
+    self.assertTrue(fs.isdir('/mem/a/c'))
+
+    # Rename directory to an existing empty directory.
+    fs.mkdirs('/mem/a/d')
+    fs.rename('/mem/a/c', '/mem/a/d')
+    self.assertFalse(fs.exists('/mem/a/c'))
+    self.assertTrue(fs.exists('/mem/a/d'))
+
+    # Rename directory to a non-empty directory.
+    fs.mkdirs('/mem/x/y')
+    with self.assertRaisesRegex(OSError, "Directory not empty: '/mem/x'"):
+      fs.rename('/mem/a', '/mem/x')
+    self.assertTrue(fs.exists('/mem/a'))
+    self.assertTrue(fs.exists('/mem/x/y'))
+
+    # Errors
+    fs.mkdirs('/mem/u/v')
+    with fs.open('/mem/u/a.txt', 'w') as f:
+      f.write('a')
+
+    with self.assertRaisesRegex(
+        OSError, "Cannot move directory '/mem/u' to a subdirectory of itself"):
+      fs.rename('/mem/u', '/mem/u/v/w')
+
+    with self.assertRaisesRegex(
+        NotADirectoryError,
+        "Cannot rename directory '/mem/u' to non-directory '/mem/u/a.txt'"):
+      fs.rename('/mem/u', '/mem/u/a.txt')
+
+    with self.assertRaisesRegex(
+        IsADirectoryError,
+        "Cannot rename non-directory '/mem/u/a.txt' to directory '/mem/u/v'"):
+      fs.rename('/mem/u/a.txt', '/mem/u/v')
+
+    with self.assertRaises(FileNotFoundError):
+      fs.rename('/mem/non-existent', '/mem/y')
+
 
 class FileIoApiTest(unittest.TestCase):
 
@@ -217,6 +376,14 @@ class FileIoApiTest(unittest.TestCase):
     file_system.rm(file2)
     self.assertFalse(file_system.path_exists(file2))
 
+    # Test glob with standard file system.
+    glob_dir = os.path.join(tempfile.mkdtemp(), 'glob')
+    file_system.mkdirs(os.path.join(glob_dir, 'a/b'))
+    file_system.writefile(os.path.join(glob_dir, 'a/foo.txt'), 'foo')
+    self.assertEqual(
+        sorted(file_system.glob(os.path.join(glob_dir, 'a/*'))),
+        [os.path.join(glob_dir, 'a/b'), os.path.join(glob_dir, 'a/foo.txt')])
+
   def test_memory_filesystem(self):
     file1 = pathlib.Path('/mem/file1')
     with self.assertRaises(FileNotFoundError):
@@ -248,6 +415,130 @@ class FileIoApiTest(unittest.TestCase):
     file_system.rm(file2)
     self.assertFalse(file_system.path_exists(file2))
 
+    # Test glob with memory file system.
+    file_system.mkdirs('/mem/g/a/b')
+    file_system.writefile('/mem/g/a/foo.txt', 'foo')
+    file_system.rename('/mem/g/a/foo.txt', '/mem/g/a/foo2.txt')
+    file_system.writefile('/mem/g/a/b/bar.txt', 'bar')
+    self.assertEqual(
+        sorted(file_system.glob('/mem/g/a/*')),
+        ['/mem/g/a/b', '/mem/g/a/b/bar.txt', '/mem/g/a/foo2.txt'])
+
+
+class FsspecFileSystemTest(unittest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.fs = fsspec.filesystem('memory')
+    self.fs.pipe('memory:///a/b/c', b'abc')
+    self.fs.pipe('memory:///a/b/d', b'abd')
+    self.fs.mkdir('memory:///a/e')
+
+  def tearDown(self):
+    super().tearDown()
+    fsspec.filesystem('memory').rm('/', recursive=True)
+
+  def test_read_file(self):
+    self.assertEqual(file_system.readfile('memory:///a/b/c', mode='rb'), b'abc')
+    with file_system.open('memory:///a/b/d', 'rb') as f:
+      self.assertEqual(f.read(), b'abd')
+
+  def test_fsspec_file_ops(self):
+    file_system.writefile('memory:///f', b'hello\nworld\n', mode='wb')
+    with file_system.open('memory:///f', 'rb') as f:
+      self.assertIsInstance(f, file_system.FsspecFile)
+      self.assertEqual(f.readline(), b'hello\n')
+      self.assertEqual(f.tell(), 6)
+      self.assertEqual(f.seek(8), 8)
+      self.assertEqual(f.read(), b'rld\n')
+      f.flush()
+
+  def test_write_file(self):
+    file_system.writefile('memory:///a/b/e', b'abe', mode='wb')
+    self.assertTrue(self.fs.exists('memory:///a/b/e'))
+    self.assertEqual(self.fs.cat('memory:///a/b/e'), b'abe')
+
+  def test_exists(self):
+    self.assertTrue(file_system.path_exists('memory:///a/b/c'))
+    self.assertFalse(file_system.path_exists('memory:///a/b/nonexist'))
+
+  def test_isdir(self):
+    self.assertTrue(file_system.isdir('memory:///a/b'))
+    self.assertTrue(file_system.isdir('memory:///a/e'))
+    self.assertFalse(file_system.isdir('memory:///a/b/c'))
+
+  def test_listdir(self):
+    self.assertCountEqual(file_system.listdir('memory:///a'), ['b', 'e'])
+    self.assertCountEqual(file_system.listdir('memory:///a/b'), ['c', 'd'])
+
+  def test_glob(self):
+    self.assertCountEqual(
+        file_system.glob('memory:///a/b/*'),
+        ['memory:///a/b/c', 'memory:///a/b/d']
+    )
+
+  def test_mkdir(self):
+    file_system.mkdir('memory:///a/f')
+    self.assertTrue(self.fs.isdir('memory:///a/f'))
+
+  def test_mkdirs(self):
+    file_system.mkdirs('memory:///g/h/i')
+    self.assertTrue(self.fs.isdir('memory:///g/h/i'))
+
+  def test_rm(self):
+    file_system.rm('memory:///a/b/c')
+    self.assertFalse(self.fs.exists('memory:///a/b/c'))
+
+  def test_rename(self):
+    file_system.rename('memory:///a/b/c', 'memory:///a/b/c_new')
+    self.assertFalse(self.fs.exists('memory:///a/b/c'))
+    self.assertTrue(self.fs.exists('memory:///a/b/c_new'))
+    with self.assertRaisesRegex(ValueError, 'Rename across different'):
+      file_system.rename('memory:///a/b/c_new', 'file:///a/b/c_d')
+
+  def test_chmod(self):
+    mock_fs = mock.Mock()
+    mock_fs.chmod = mock.Mock()
+    with mock.patch('fsspec.core.url_to_fs', return_value=(mock_fs, 'path')):
+      file_system.chmod('protocol:///path', 0o777)
+      mock_fs.chmod.assert_called_once_with('path', 0o777)
+
+  def test_rmdir(self):
+    file_system.rmdir('memory:///a/e')
+    self.assertFalse(self.fs.exists('memory:///a/e'))
+
+  def test_rmdirs(self):
+    file_system.mkdirs('memory:///x/y/z')
+    self.assertTrue(file_system.isdir('memory:///x/y/z'))
+    file_system.rmdirs('memory:///x')
+    self.assertFalse(file_system.path_exists('memory:///x'))
+
+  def test_fsspec_uri_catcher(self):
+    with mock.patch.object(
+        file_system.FsspecFileSystem, 'exists', return_value=True
+    ) as mock_fsspec_exists:
+      # We use a protocol that is not registered in
+      # fsspec.available_protocols() to make sure _FsspecUriCatcher is used.
+      self.assertTrue(file_system.path_exists('some-proto://foo'))
+      mock_fsspec_exists.assert_called_once_with('some-proto://foo')
+
+    # For full coverage of _FsspecUriCatcher.get_fs returning StdFileSystem,
+    # we need to test a non-URI path that doesn't match other prefixes.
+    # We mock StdFileSystem.exists to check if it's called.
+    with mock.patch.object(
+        file_system.StdFileSystem, 'exists', return_value=True
+    ) as mock_std_exists:
+      self.assertTrue(file_system.path_exists('/foo/bar/baz'))
+      mock_std_exists.assert_called_once_with('/foo/bar/baz')
+
+    with mock.patch.object(
+        file_system.FsspecFileSystem, 'rename', return_value=None
+    ) as mock_fsspec_rename:
+      file_system.rename('some-proto://foo', 'some-proto://bar')
+      mock_fsspec_rename.assert_called_once_with(
+          'some-proto://foo', 'some-proto://bar'
+      )
+
 
 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):