pyglove 0.5.0.dev202511161718__tar.gz → 0.5.0.dev202511250811__tar.gz

{pyglove-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202511161718
+Version: 0.5.0.dev202511250811
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors
@@ -23,6 +23,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: docstring-parser>=0.12
 Requires-Dist: termcolor>=1.1.0
+Provides-Extra: all
+Requires-Dist: docstring-parser>=0.12; extra == "all"
+Requires-Dist: termcolor>=1.1.0; extra == "all"
+Requires-Dist: fsspec>=2023.3.0; extra == "all"
+Provides-Extra: io
+Requires-Dist: fsspec>=2023.3.0; extra == "io"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -32,6 +38,7 @@ Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
 Dynamic: license-file
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: summary
 

{pyglove-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/pyglove/core/io/file_system.py

@@ -19,7 +19,6 @@ import glob as std_glob
 import io
 import os
 import re
-import time
 from typing import Any, Literal, Optional, Union
 
 
@@ -179,14 +178,6 @@ class StdFile(File):
   def close(self) -> None:
     self._file_object.close()
 
-    # For some file systems, the file might not be immediately available
-    # after writing. We retry for a few times to ensure the file is
-    # world-readable.
-    while True:
-      if os.path.exists(self._path):
-        break
-      time.sleep(0.1)
-
 
 class StdFileSystem(FileSystem):
   """The standard file system."""
@@ -502,6 +493,205 @@ def add_file_system(prefix: str, fs: FileSystem) -> None:
 add_file_system('/mem/', MemoryFileSystem('/mem/'))
 
 
+try:
+  # pylint: disable=g-import-not-at-top
+  # pytype: disable=import-error
+  import fsspec
+  # pytype: enable=import-error
+  # pylint: enable=g-import-not-at-top
+except ImportError:
+  fsspec = None
+
+
+class FsspecFile(File):
+  """File object based on fsspec."""
+
+  def __init__(self, f):
+    self._f = f
+
+  def read(self, size: Optional[int] = None) -> Union[str, bytes]:
+    return self._f.read(size)
+
+  def readline(self) -> Union[str, bytes]:
+    return self._f.readline()
+
+  def write(self, content: Union[str, bytes]) -> None:
+    self._f.write(content)
+
+  def seek(self, offset: int, whence: Literal[0, 1, 2] = 0) -> int:
+    return self._f.seek(offset, whence)
+
+  def tell(self) -> int:
+    return self._f.tell()
+
+  def flush(self) -> None:
+    self._f.flush()
+
+  def close(self) -> None:
+    self._f.close()
+
+
+class FsspecFileSystem(FileSystem):
+  """File system based on fsspec."""
+
+  def open(
+      self, path: Union[str, os.PathLike[str]], mode: str = 'r', **kwargs
+  ) -> File:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    return FsspecFile(fsspec.open(path, mode, **kwargs).open())
+
+  def chmod(self, path: Union[str, os.PathLike[str]], mode: int) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    if hasattr(fs, 'chmod'):
+      fs.chmod(path, mode)
+
+  def exists(self, path: Union[str, os.PathLike[str]]) -> bool:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    return fs.exists(path)
+
+  def glob(self, pattern: Union[str, os.PathLike[str]]) -> list[str]:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(pattern)
+    protocol = fsspec.utils.get_protocol(pattern)
+    return [f'{protocol}:///{r.lstrip("/")}' for r in fs.glob(path)]
+
+  def listdir(self, path: Union[str, os.PathLike[str]]) -> list[str]:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    return [os.path.basename(f) for f in fs.ls(path, detail=False)]
+
+  def isdir(self, path: Union[str, os.PathLike[str]]) -> bool:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    return fs.isdir(path)
+
+  def mkdir(
+      self,
+      path: Union[str, os.PathLike[str]], mode: int = 0o777
+  ) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    fs.mkdir(path)
+
+  def mkdirs(
+      self,
+      path: Union[str, os.PathLike[str]],
+      mode: int = 0o777,
+      exist_ok: bool = True,
+  ) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    fs.makedirs(path, exist_ok=exist_ok)
+
+  def rm(self, path: Union[str, os.PathLike[str]]) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    fs.rm(path)
+
+  def rename(
+      self,
+      oldpath: Union[str, os.PathLike[str]],
+      newpath: Union[str, os.PathLike[str]],
+  ) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, old_path = fsspec.core.url_to_fs(oldpath)
+    fs2, new_path = fsspec.core.url_to_fs(newpath)
+    if fs.__class__ != fs2.__class__:
+      raise ValueError(
+          f'Rename across different filesystems is not supported: '
+          f'{type(fs)} vs {type(fs2)}'
+      )
+    fs.rename(old_path, new_path)
+
+  def rmdir(self, path: Union[str, os.PathLike[str]]) -> None:   # pytype: disable=signature-mismatch
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    fs.rmdir(path)
+
+  def rmdirs(self, path: Union[str, os.PathLike[str]]) -> None:
+    assert fsspec is not None, '`fsspec` is not installed.'
+    fs, path = fsspec.core.url_to_fs(path)
+    fs.rm(path, recursive=True)
+
+
+class _FsspecUriCatcher(FileSystem):
+  """File system to catch URI paths and redirect to FsspecFileSystem."""
+
+  # Catch all paths that contains '://' but not registered by
+  # available_protocols.
+  _URI_PATTERN = re.compile(r'^[a-zA-Z][a-zA-Z0-9+-.]*://.*')
+
+  def __init__(self):
+    super().__init__()
+    self._std_fs = StdFileSystem()
+    self._fsspec_fs = FsspecFileSystem()
+
+  def get_fs(self, path: Union[str, os.PathLike[str]]) -> FileSystem:
+    if self._URI_PATTERN.match(resolve_path(path)):
+      return self._fsspec_fs
+    return self._std_fs
+
+  def open(
+      self, path: Union[str, os.PathLike[str]], mode: str = 'r', **kwargs
+  ) -> File:
+    return self.get_fs(path).open(path, mode, **kwargs)
+
+  def chmod(self, path: Union[str, os.PathLike[str]], mode: int) -> None:
+    self.get_fs(path).chmod(path, mode)
+
+  def exists(self, path: Union[str, os.PathLike[str]]) -> bool:
+    return self.get_fs(path).exists(path)
+
+  def glob(self, pattern: Union[str, os.PathLike[str]]) -> list[str]:
+    return self.get_fs(pattern).glob(pattern)
+
+  def listdir(self, path: Union[str, os.PathLike[str]]) -> list[str]:
+    return self.get_fs(path).listdir(path)
+
+  def isdir(self, path: Union[str, os.PathLike[str]]) -> bool:
+    return self.get_fs(path).isdir(path)
+
+  def mkdir(
+      self,
+      path: Union[str, os.PathLike[str]],
+      mode: int = 0o777
+  ) -> None:
+    self.get_fs(path).mkdir(path, mode)
+
+  def mkdirs(
+      self,
+      path: Union[str, os.PathLike[str]],
+      mode: int = 0o777,
+      exist_ok: bool = True,
+  ) -> None:
+    self.get_fs(path).mkdirs(path, mode, exist_ok)
+
+  def rm(self, path: Union[str, os.PathLike[str]]) -> None:
+    self.get_fs(path).rm(path)
+
+  def rename(
+      self,
+      oldpath: Union[str, os.PathLike[str]],
+      newpath: Union[str, os.PathLike[str]],
+  ) -> None:
+    self.get_fs(oldpath).rename(oldpath, newpath)
+
+  def rmdir(self, path: Union[str, os.PathLike[str]]) -> None:   # pytype: disable=signature-mismatch
+    self.get_fs(path).rmdir(path)
+
+  def rmdirs(self, path: Union[str, os.PathLike[str]]) -> None:
+    self.get_fs(path).rmdirs(path)
+
+
+if fsspec is not None:
+  fsspec_fs = FsspecFileSystem()
+  for p in fsspec.available_protocols():
+    add_file_system(p + '://', fsspec_fs)
+  add_file_system('', _FsspecUriCatcher())
+
+
 #
 # APIs for file IO.
 #

{pyglove-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/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
 
 
@@ -423,5 +425,120 @@ class FileIoApiTest(unittest.TestCase):
         ['/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-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/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-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/pyglove/core/symbolic/base.py

@@ -2042,7 +2042,7 @@ def from_json(
     context: Optional[utils.JSONConversionContext] = None,
     auto_symbolic: bool = True,
     auto_import: bool = True,
-    auto_dict: bool = False,
+    convert_unknown: bool = False,
     allow_partial: bool = False,
     root_path: Optional[utils.KeyPath] = None,
     value_spec: Optional[pg_typing.ValueSpec] = None,
@@ -2073,8 +2073,13 @@ def from_json(
       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.
@@ -2095,7 +2100,12 @@ def from_json(
   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, **kwargs)
+      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()
@@ -2103,7 +2113,7 @@ def from_json(
   typename_resolved = kwargs.pop('_typename_resolved', False)
   if not typename_resolved:
     json_value = utils.json_conversion.resolve_typenames(
-        json_value, auto_import, auto_dict
+        json_value, auto_import, convert_unknown
     )
 
   def _load_child(k, v):
@@ -2177,7 +2187,7 @@ def from_json_str(
     *,
     context: Optional[utils.JSONConversionContext] = None,
     auto_import: bool = True,
-    auto_dict: bool = False,
+    convert_unknown: bool = False,
     allow_partial: bool = False,
     root_path: Optional[utils.KeyPath] = None,
     value_spec: Optional[pg_typing.ValueSpec] = None,
@@ -2205,8 +2215,13 @@ def from_json_str(
       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.
@@ -2236,7 +2251,7 @@ def from_json_str(
       _decode_int_keys(json.loads(json_str)),
       context=context,
       auto_import=auto_import,
-      auto_dict=auto_dict,
+      convert_unknown=convert_unknown,
       allow_partial=allow_partial,
       root_path=root_path,
       value_spec=value_spec,

{pyglove-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/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__()
 

{pyglove-0.5.0.dev202511161718 → pyglove-0.5.0.dev202511250811}/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-0.5.0.dev202511250811/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,
+    )