pyglove 0.5.0.dev202510230131__py3-none-any.whl → 0.5.0.dev202511300809__py3-none-any.whl

pyglove/core/utils/json_conversion.py

@@ -685,7 +685,7 @@ def from_json(
     *,
     context: Optional[JSONConversionContext] = None,
     auto_import: bool = True,
-    auto_dict: bool = False,
+    convert_unknown: bool = False,
     **kwargs
 ) -> Any:
   """Deserializes a (maybe) JSONConvertible value from JSON value.
@@ -697,8 +697,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.
     **kwargs: Keyword arguments that will be passed to JSONConvertible.__init__.
 
   Returns:
@@ -707,14 +712,21 @@ def from_json(
   if context is None:
     if (isinstance(json_value, dict)
         and (context_node := json_value.get(JSONConvertible.CONTEXT_KEY))):
-      context = JSONConversionContext.from_json(context_node, **kwargs)
+      context = JSONConversionContext.from_json(
+          context_node,
+          auto_import=auto_import,
+          convert_unknown=convert_unknown,
+          **kwargs
+      )
       json_value = json_value[JSONConvertible.ROOT_VALUE_KEY]
     else:
       context = JSONConversionContext()
 
   typename_resolved = kwargs.pop('_typename_resolved', False)
   if not typename_resolved:
-    json_value = resolve_typenames(json_value, auto_import, auto_dict)
+    json_value = resolve_typenames(
+        json_value, auto_import=auto_import, convert_unknown=convert_unknown
+    )
 
   def child_from(v):
     return from_json(v, context=context, _typename_resolved=True, **kwargs)
@@ -743,7 +755,7 @@ def from_json(
 def resolve_typenames(
     json_value: JSONValueType,
     auto_import: bool = True,
-    auto_dict: bool = False,
+    convert_unknown: bool = False,
 ) -> JSONValueType:
   """Inplace resolves the "_type" keys with their factories in a JSON tree."""
 
@@ -755,11 +767,11 @@ def resolve_typenames(
       return False
     type_name = v[JSONConvertible.TYPE_NAME_KEY]
     if type_name == 'type':
-      factory_fn = _type_from_json
+      factory_fn = _type_from_json(convert_unknown)
     elif type_name == 'function':
-      factory_fn = _function_from_json
+      factory_fn = _function_from_json(convert_unknown)
     elif type_name == 'method':
-      factory_fn = _method_from_json
+      factory_fn = _method_from_json(convert_unknown)
     else:
       cls = JSONConvertible.class_from_typename(type_name)
       if cls is None:
@@ -768,32 +780,38 @@ def resolve_typenames(
             cls = _load_symbol(type_name)
             assert inspect.isclass(cls), cls
           except (ModuleNotFoundError, AttributeError) as e:
-            if not auto_dict:
+            if not convert_unknown:
               raise TypeError(
                   f'Cannot load class {type_name!r}.\n'
-                  'Try pass `auto_dict=True` to load the object into a dict '
-                  'without depending on the type.'
+                  'Try pass `convert_unknown=True` to load the object into '
+                  '`pg.symbolic.UnknownObject` without depending on the type.'
               ) from e
-        elif not auto_dict:
+        elif not convert_unknown:
           raise TypeError(
               f'Type name \'{type_name}\' is not registered '
               'with a `pg.JSONConvertible` subclass.\n'
-              'Try pass `auto_import=True` to load the type from its module, '
-              'or pass `auto_dict=True` to load the object into a dict '
-              'without depending on the type.'
+              'Try pass `auto_import=True` to load the type from its module.'
           )
 
       factory_fn = getattr(cls, 'from_json', None)
-      if cls is not None and factory_fn is None and not auto_dict:
+      if cls is not None and factory_fn is None and not convert_unknown:
         raise TypeError(
             f'{cls} is not a `pg.JSONConvertible` subclass.'
-            'Try pass `auto_dict=True` to load the object into a dict '
-            'without depending on the type.'
+            'Try pass `convert_unknown=True` to load the object into a '
+            '`pg.symbolic.UnknownObject` without depending on the type.'
         )
 
-      if factory_fn is None and auto_dict:
-        v['type_name'] = type_name
-        v.pop(JSONConvertible.TYPE_NAME_KEY)
+      if factory_fn is None and convert_unknown:
+        type_name = v[JSONConvertible.TYPE_NAME_KEY]
+        def _factory_fn(json_value: Dict[str, Any], **kwargs):
+          del kwargs
+          # See `pg.symbolic.UnknownObject` for details.
+          unknown_object_cls = JSONConvertible.class_from_typename(
+              'unknown_object'
+          )
+          return unknown_object_cls(type_name=type_name, **json_value)  # pytype: disable=wrong-keyword-args
+
+        v[JSONConvertible.TYPE_NAME_KEY] = _factory_fn
         return True
       assert factory_fn is not None
 
@@ -992,39 +1010,79 @@ def _load_symbol(type_name: str) -> Any:
   return symbol
 
 
-def _type_from_json(json_value: Dict[str, str], **kwargs) -> Type[Any]:
+def _type_from_json(convert_unknown: bool) -> Callable[..., Any]:
   """Loads a type from a JSON dict."""
-  del kwargs
-  t = _load_symbol(json_value['name'])
-  if 'args' in json_value:
-    return _bind_type_args(
-        t, from_json(json_value['args'], _typename_resolved=True)
-    )
-  return t
+  def _fn(json_value: Dict[str, str], **kwargs) -> Type[Any]:
+    del kwargs
+    try:
+      t = _load_symbol(json_value['name'])
+      if 'args' in json_value:
+        return _bind_type_args(
+            t, from_json(json_value['args'], _typename_resolved=True)
+        )
+      return t
+    except (ModuleNotFoundError, AttributeError) as e:
+      if not convert_unknown:
+        raise TypeError(
+            f'Cannot load type {json_value["name"]!r}.\n'
+            'Try pass `convert_unknown=True` to load the object '
+            'into `pg.UnknownType` without depending on the type.'
+        ) from e
+      # See `pg.symbolic.UnknownType` for details.
+      json_value[JSONConvertible.TYPE_NAME_KEY] = 'unknown_type'
+      return from_json(json_value)
+  return _fn
 
 
 def _function_from_json(
-    json_value: Dict[str, str], **kwargs) -> types.FunctionType:
+    convert_unknown: bool
+) -> Callable[..., types.FunctionType]:
   """Loads a function from a JSON dict."""
-  del kwargs
-  function_name = json_value['name']
-  if 'code' in json_value:
-    code = marshal.loads(
-        base64.decodebytes(json_value['code'].encode('utf-8')))
-    defaults = from_json(json_value['defaults'], _typename_resolved=True)
-    return types.FunctionType(
-        code=code,
-        globals=globals(),
-        argdefs=defaults,
-    )
-  else:
-    return _load_symbol(function_name)
-
-
-def _method_from_json(json_value: Dict[str, str], **kwargs) -> types.MethodType:
+  def _fn(json_value: Dict[str, str], **kwargs) -> types.FunctionType:
+    del kwargs
+    function_name = json_value['name']
+    if 'code' in json_value:
+      code = marshal.loads(
+          base64.decodebytes(json_value['code'].encode('utf-8')))
+      defaults = from_json(json_value['defaults'], _typename_resolved=True)
+      return types.FunctionType(
+          code=code,
+          globals=globals(),
+          argdefs=defaults,
+      )
+    else:
+      try:
+        return _load_symbol(function_name)
+      except (ModuleNotFoundError, AttributeError) as e:
+        if not convert_unknown:
+          raise TypeError(
+              f'Cannot load function {function_name!r}.\n'
+              'Try pass `convert_unknown=True` to load the object into '
+              '`pg.UnknownFunction` without depending on the type.'
+          ) from e
+        json_value[JSONConvertible.TYPE_NAME_KEY] = 'unknown_function'
+        return from_json(json_value)
+  return _fn
+
+
+def _method_from_json(
+    convert_unknown: bool
+) -> Callable[..., types.MethodType]:
   """Loads a class method from a JSON dict."""
-  del kwargs
-  return _load_symbol(json_value['name'])
+  def _fn(json_value: Dict[str, str], **kwargs) -> types.MethodType:
+    del kwargs
+    try:
+      return _load_symbol(json_value['name'])
+    except (ModuleNotFoundError, AttributeError) as e:
+      if not convert_unknown:
+        raise TypeError(
+            f'Cannot load method {json_value["name"]!r}.\n'
+            'Try pass `convert_unknown=True` to load the object '
+            'into `pg.UnknownMethod` without depending on the type.'
+        ) from e
+      json_value[JSONConvertible.TYPE_NAME_KEY] = 'unknown_method'
+      return from_json(json_value)
+  return _fn
 
 
 def _bind_type_args(t, args):

pyglove/core/utils/json_conversion_test.py

@@ -14,6 +14,7 @@
 import abc
 import typing
 import unittest
+from pyglove.core.symbolic import unknown_symbols
 from pyglove.core.typing import inspect as pg_inspect
 from pyglove.core.utils import json_conversion
 
@@ -271,7 +272,8 @@ class JSONConvertibleTest(unittest.TestCase):
     self.assert_conversion_is(typing.List[typing.List[int]])
     self.assert_conversion_is(typing.Annotated[int, 'abc'])
     self.assert_conversion_is(typing.Dict[str, typing.Any])
-    self.assert_conversion_is(typing.Union[int, str])
+    # From Python 3.14, union no longer preserves `is` identity.
+    self.assert_conversion_equal(typing.Union[int, str])
     self.assert_conversion_is(typing.Sequence[int])
     self.assert_conversion_is(typing.Set[int])
     self.assert_conversion_is(typing.FrozenSet[int])
@@ -307,6 +309,19 @@ class JSONConvertibleTest(unittest.TestCase):
     self.assertEqual(baz1(1), 2)
     self.assertEqual(baz1(1, 2), 3)
 
+    with self.assertRaisesRegex(
+        TypeError, 'Cannot load function .*'):
+      json_conversion.from_json(
+          {'_type': 'function', 'name': 'non_existent_function'}
+      )
+    self.assertEqual(
+        json_conversion.from_json(
+            {'_type': 'function', 'name': 'non_existent_function'},
+            convert_unknown=True
+        ),
+        unknown_symbols.UnknownFunction('non_existent_function')
+    )
+
   def test_json_conversion_for_methods(self):
     # Test class-level method.
     f = json_conversion.from_json(json_conversion.to_json(X.Y.Z.class_method))
@@ -319,6 +334,19 @@ class JSONConvertibleTest(unittest.TestCase):
         ValueError, 'Cannot convert instance method .* to JSON.'):
       json_conversion.to_json(X.Y.Z().instance_method)
 
+    with self.assertRaisesRegex(
+        TypeError, 'Cannot load method .*'):
+      json_conversion.from_json(
+          {'_type': 'method', 'name': 'non_existent_method'}
+      )
+    self.assertEqual(
+        json_conversion.from_json(
+            {'_type': 'method', 'name': 'non_existent_method'},
+            convert_unknown=True
+        ),
+        unknown_symbols.UnknownMethod('non_existent_method')
+    )
+
   def test_json_conversion_for_opaque_objects(self):
     self.assert_conversion_equal(X(1))
 
@@ -335,12 +363,15 @@ class JSONConvertibleTest(unittest.TestCase):
         ValueError, 'Cannot decode opaque object with pickle.'):
       json_conversion.from_json(json_dict)
 
-  def test_json_conversion_auto_dict(self):
-    # Does not exist.
+  def test_json_conversion_convert_unknown(self):
     self.assertEqual(
         json_conversion.from_json([
             '__tuple__',
             1,
+            {
+                '_type': 'type',
+                'name': 'Unknown type',
+            },
             {
                 '_type': 'Unknown type',
                 'x': [{
@@ -350,13 +381,18 @@ class JSONConvertibleTest(unittest.TestCase):
                     'name': 'builtins.print'
                 }]
             }
-        ], auto_dict=True),
-        (1, {
-            'type_name': 'Unknown type',
-            'x': [{
-                'type_name': 'Unknown type',
-            }, print]
-        })
+        ], convert_unknown=True),
+        (
+            1,
+            unknown_symbols.UnknownType('Unknown type'),
+            unknown_symbols.UnknownTypedObject(
+                type_name='Unknown type',
+                x=[
+                    unknown_symbols.UnknownTypedObject('Unknown type'),
+                    print
+                ]
+            )
+        )
     )
 
   def test_json_conversion_with_bad_types(self):
@@ -383,6 +419,10 @@ class JSONConvertibleTest(unittest.TestCase):
         TypeError, 'Cannot load class .*'):
       json_conversion.from_json({'_type': '__main__.ABC'})
 
+    with self.assertRaisesRegex(
+        TypeError, 'Cannot load type .*'):
+      json_conversion.from_json({'_type': 'type', 'name': '__main__.ABC'})
+
     # Type exist but not a JSONConvertible subclass.
     class A:
       pass
@@ -451,6 +491,41 @@ class JSONConvertibleTest(unittest.TestCase):
     self.assertIs(y_prime['t'], y_prime['v'][1])
     self.assertIs(y_prime['u'], y_prime['v'][0])
 
+  def test_json_conversion_with_sharing_convert_unknown(self):
+    self.assertEqual(
+        json_conversion.from_json(
+            {
+                '__context__': {
+                    'shared_objects': [
+                        {
+                            '_type': 'type',
+                            'name': '__main__.ABC',
+                        },
+                        {
+                            '_type': '__main__.ABC',
+                            'x': 1
+                        }
+                    ]
+                },
+                '__root__': [
+                    {
+                        '__ref__': 0
+                    },
+                    {
+                        '__ref__': 1
+                    },
+                ]
+            },
+            convert_unknown=True
+        ),
+        [
+            unknown_symbols.UnknownType('__main__.ABC'),
+            unknown_symbols.UnknownTypedObject(
+                type_name='__main__.ABC',
+                x=1
+            )
+        ]
+    )
 
 if __name__ == '__main__':
   unittest.main()

pyglove/core/views/html/controls/tab.py

@@ -158,6 +158,39 @@ class TabControl(HtmlControl):
         position='beforebegin',
     )
 
+  def remove(self, index_or_name: Union[int, str]) -> Tab:
+    """Removes a tab identified by index or name."""
+    index = self.indexof(index_or_name)
+    if index == -1:
+      raise ValueError(f'Tab not found: {index_or_name!r}')
+
+    with pg_flags.notify_on_change(False):
+      tab = self.tabs.pop(index)
+
+    self._run_javascript(
+        f"""
+        const button = document.querySelectorAll('#{self.element_id()}-button-group > .tab-button')[{index}];
+        if (button) {{
+          button.remove();
+        }}
+        const content = document.querySelectorAll('#{self.element_id()}-content-group > .tab-content')[{index}];
+        if (content) {{
+          content.remove();
+        }}
+        """
+    )
+
+    if not self.tabs:
+      self._sync_members(selected=0)
+      return tab
+
+    if self.selected == index:
+      new_selected = index - 1 if index == len(self.tabs) else index
+      self.select(max(0, new_selected))
+    elif self.selected > index:
+      self._sync_members(selected=self.selected - 1)
+    return tab
+
   def indexof(self, index_or_name: Union[int, str]) -> int:
     if isinstance(index_or_name, int):
       index = index_or_name

pyglove/core/views/html/controls/tab_test.py

@@ -154,6 +154,43 @@ class TabControlTest(unittest.TestCase):
       self.assertEqual(len(scripts), 1)
       self.assertEqual(tab.selected, 1)
 
+  def test_remove(self):
+    tabs = [tab_lib.Tab(l, l, name=l) for l in ['a', 'b', 'c', 'd']]
+    tc = tab_lib.TabControl(tabs, selected='c')
+    self.assertEqual([t.name for t in tc.tabs], ['a', 'b', 'c', 'd'])
+    self.assertEqual(tc.selected, 2)
+
+    # Trigger rendering so scripts are tracked.
+    _ = tc.to_html()
+    with tc.track_scripts() as scripts:
+      tc.remove('b')
+      self.assertEqual(len(scripts), 1)
+    self.assertEqual([t.name for t in tc.tabs], ['a', 'c', 'd'])
+    self.assertEqual(tc.selected, 1)
+
+    with tc.track_scripts() as scripts:
+      # Remove currently selected tab 'c'
+      tc.remove('c')
+      # 1 script for remove, 1 for select.
+      self.assertEqual(len(scripts), 2)
+    self.assertEqual([t.name for t in tc.tabs], ['a', 'd'])
+    self.assertEqual(tc.selected, 1)
+
+    with tc.track_scripts() as scripts:
+      tc.remove(1)
+      self.assertEqual(len(scripts), 2)
+    self.assertEqual([t.name for t in tc.tabs], ['a'])
+    self.assertEqual(tc.selected, 0)
+
+    with tc.track_scripts() as scripts:
+      tc.remove('a')
+      self.assertEqual(len(scripts), 1)
+    self.assertEqual(tc.tabs, [])
+    self.assertEqual(tc.selected, 0)
+
+    with self.assertRaisesRegex(ValueError, 'Tab not found'):
+      tc.remove('x')
+
 
 if __name__ == '__main__':
   unittest.main()

pyglove/ext/evolution/base_test.py

@@ -57,7 +57,7 @@ class NextValue(base.Mutator):
   """A mutator to increase current DNA by 1."""
 
   def mutate(self, dna, step):
-    return dna.next_dna()
+    return dna.next_dna() or dna
 
 
 def search_space():

{pyglove-0.5.0.dev202510230131.dist-info → pyglove-0.5.0.dev202511300809.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.5.0.dev202510230131
+Version: 0.5.0.dev202511300809
 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.dev202510230131.dist-info → pyglove-0.5.0.dev202511300809.dist-info}/RECORD

@@ -56,8 +56,8 @@ pyglove/core/hyper/numerical_test.py,sha256=UWdH55Bok7bghYDLJOGsgOwV_2LNkhj1AmFw
 pyglove/core/hyper/object_template.py,sha256=YPALTV0mMULa7iuqnryTpA2wMsdyFZ_6g-R525asAr8,22222
 pyglove/core/hyper/object_template_test.py,sha256=TEFX7LIqUvdCdJILnK_gP5xIgNJKzRnioUF0CGVBzcY,9105
 pyglove/core/io/__init__.py,sha256=4ZT1a595DqQuLTNYc2JP_eCp_KesXvHmKRkr777bzpg,785
-pyglove/core/io/file_system.py,sha256=E_kSi1Lqo31al4GJYywCzJT97X3ByW8Te4xVfAM93D4,13990
-pyglove/core/io/file_system_test.py,sha256=mQdg4p8_D66sxRp_Hu2ILPvJa6PcR_y8q3NB0UCYjW8,8719
+pyglove/core/io/file_system.py,sha256=r7x_kDWDynKbAcO8tEkkRHShOPiYXyB9wmCXv2c-Oes,23149
+pyglove/core/io/file_system_test.py,sha256=QvcPEQj3hAk7xc8VkFda1ZzgsV0etBimc1V9CJXr_Rk,19145
 pyglove/core/io/sequence.py,sha256=XdVpPBuvhUnrTIWMUrak_qdcNdUJBpjgH5c1b5I3E2A,8873
 pyglove/core/io/sequence_test.py,sha256=mnONyNG1M1sCae2tyI-tF8qns96htfZPKycthETPthU,4062
 pyglove/core/patching/__init__.py,sha256=C1Q1cWPV74YL3eXbzGvc-8aPw1DR8EK6lRhQYDCwHek,2059
@@ -67,8 +67,8 @@ pyglove/core/patching/pattern_based.py,sha256=UtSNB-ARNqVjXwZovjVi84QEoXUGLLBTgL
 pyglove/core/patching/pattern_based_test.py,sha256=PW1EcVfsFPB6wtgwg3s4dzvigWn3b5S8eMNGo0SJiZ0,2771
 pyglove/core/patching/rule_based.py,sha256=JAQp8mWeIOxwIdqusA3GmXia-fxQhQsxbUTmE329wF8,17038
 pyglove/core/patching/rule_based_test.py,sha256=qfy0ILmczV_LMHWEnwo2y079OrJsGYO0nKxSZdmIUcI,18782
-pyglove/core/symbolic/__init__.py,sha256=VMQj8oW2hGaJwqgchBJbu5qXoJKaNizxv__vsYL4b7U,6057
-pyglove/core/symbolic/base.py,sha256=aRo-v1w1kGHPhJNddaGA-SZMeLSQs4dNyRPEjHH4Phg,79102
+pyglove/core/symbolic/__init__.py,sha256=ifUnJyF_hNFyrNAqlN7ClKWUvZouIA38GrYctnMc-F4,6402
+pyglove/core/symbolic/base.py,sha256=QMAMFuqH_FjwJUSlUZKTBnxDpiVkM9Z8j611u6FWAcg,79816
 pyglove/core/symbolic/base_test.py,sha256=OHEexXI7uE2bixT-trfR3j-dfiAJsbY7pFyAA6XEPqA,7338
 pyglove/core/symbolic/boilerplate.py,sha256=sQ3G25r5bo_UmIdjreL4jkAuQCXIHVlvUfGjjkNod6Y,5955
 pyglove/core/symbolic/boilerplate_test.py,sha256=1CZ1W6kq3l-3tpaknhGFa04V18bO7vPzis5qzWnxHEs,5252
@@ -91,9 +91,9 @@ pyglove/core/symbolic/functor_test.py,sha256=9c5_7OBKNVNbYC7IaVQB6c5ks2v00qQ36oi
 pyglove/core/symbolic/inferred.py,sha256=E4zgphg6NNZad9Fl3jdHQOMZeqEp9XHq5OUYqXEmwZQ,3178
 pyglove/core/symbolic/inferred_test.py,sha256=G6uPykONcChvs6vZujXHSWaYfjewLTVBscMqzzKNty0,1270
 pyglove/core/symbolic/list.py,sha256=CRDoBxYJsmNly1MxhY5vO0wp6EUTnxze6-2O9vXHna4,30717
-pyglove/core/symbolic/list_test.py,sha256=Q3kqQ6aaQ40Nw6osSxrGk4N_E1lGZyvwdvxZgLRwMS0,61954
-pyglove/core/symbolic/object.py,sha256=UgDgKdcYDYX3J51EMQamdwaXHkG4SHPunAGkSuHuTa0,42768
-pyglove/core/symbolic/object_test.py,sha256=rDP7lcQZTFdQCqeaNYs7ZfwvGanzHz7CHM33NCmRIFk,94391
+pyglove/core/symbolic/list_test.py,sha256=sH3wuJB6SqXVefJEPmzGVfoXc-ZiJ1ZTV4-O88LFuaM,61943
+pyglove/core/symbolic/object.py,sha256=g6omG6r6B5TQaHSgoOWCEL_2OY_DcutxOTe1R1M1uFo,42822
+pyglove/core/symbolic/object_test.py,sha256=mB8Aw1foE3XWdRX1LVn9C9U5XJeR7iqZYHrv4y94STE,94514
 pyglove/core/symbolic/origin.py,sha256=OSWMKjvPcISOXrzuX3lCQC8m_qaGl-9INsIB81erUnU,6124
 pyglove/core/symbolic/origin_test.py,sha256=dU_ZGrGDetM_lYVMn3wQO0d367_t_t8eESe3NrKPBNE,3159
 pyglove/core/symbolic/pure_symbolic.py,sha256=pvo15gn35_KLiGW_XrTjlx5ddmHbwpLr93VgbQ59uQ8,3231
@@ -101,6 +101,8 @@ pyglove/core/symbolic/ref.py,sha256=gIu02b8BfKspH1XejXhEFh_Iil3jvfGHdpaCRq6qor0,
 pyglove/core/symbolic/ref_test.py,sha256=-rCA1AaLZnyuKOh0cJzS5UaQ_9Kp4p7xexZ_e3IwpOg,8974
 pyglove/core/symbolic/symbolize.py,sha256=ohID9-V8QiFe7OMpPlRomiqUnKBVMpypd8ZuMuHaa4s,6582
 pyglove/core/symbolic/symbolize_test.py,sha256=o7bRfMhGc6uw2FIH8arE99-bPb3i0YixcHYyiP-QqeQ,6487
+pyglove/core/symbolic/unknown_symbols.py,sha256=-BuT1izzGZDjuz_OSPDz9UAd1ialpxK8ceTZtIdni1Y,4323
+pyglove/core/symbolic/unknown_symbols_test.py,sha256=0bjZ4cYjDdTCHwQ5GHe-D7VVDfJez7iG0v6Z0ksEDTU,3069
 pyglove/core/tuning/__init__.py,sha256=JtXpjsBto01fLf55hZ1dSx-CEZUyVQeyRP9AMH_hw8c,2229
 pyglove/core/tuning/backend.py,sha256=GwbBI9nHYYe5h6iDuhqRtD-Msjmmc7wFtagxW0rTypU,5597
 pyglove/core/tuning/backend_test.py,sha256=vyfUi509-hbF5uYk-I0FsoniPFBXmobQVl-4d0YPIWY,1999
@@ -113,8 +115,8 @@ pyglove/core/tuning/sample_test.py,sha256=JqwDPy3EPC_VjU9dipk90jj1kovZB3Zb9hAjAl
 pyglove/core/typing/__init__.py,sha256=u2YSrSi8diTkQn8_1J2hEpk5o7zDhx2tU_oRuS-k1XU,14580
 pyglove/core/typing/annotated.py,sha256=llaajIDj9GK-4kUGJoO4JsHU6ESPOra2SZ-jG6xmsOQ,3203
 pyglove/core/typing/annotated_test.py,sha256=p1qid3R-jeiOTTxOVq6hXW8XFvn-h1cUzJWISPst2l8,2484
-pyglove/core/typing/annotation_conversion.py,sha256=hi4LcRXwYzspHAKZ0rtXlq2dQyAmo9GXrm_HCJAGl34,15657
-pyglove/core/typing/annotation_conversion_test.py,sha256=g66iyt3ti_pskIXndk4DiKgO8j8aMYOe2nPKXszlXmw,17675
+pyglove/core/typing/annotation_conversion.py,sha256=pnm6dZbn_nsTCreyarspkwpsdteMb8uFT2TLtblq_0M,15780
+pyglove/core/typing/annotation_conversion_test.py,sha256=N49ZuzsmaqVi23wszDpfwcJApr2-Pk2E_ELrjssSQb0,17598
 pyglove/core/typing/annotation_future_test.py,sha256=tAVuzWNfW8R4e4l7fx88Q4nJDM2LPUogNKNAIIPAEWQ,3959
 pyglove/core/typing/callable_ext.py,sha256=PiBQWPeUAH7Lgmf2xKCZqgK7N0OSrTdbnEkV8Ph31OA,9127
 pyglove/core/typing/callable_ext_test.py,sha256=TnWKU4_ZjvpbHZFtFHgFvCMDiCos8VmLlODcM_7Xg8M,10156
@@ -130,12 +132,12 @@ pyglove/core/typing/json_schema_test.py,sha256=ZxMO2xgKiELNDzoQ84cmXsyCtFA0Ltn1I
 pyglove/core/typing/key_specs.py,sha256=-7xjCuUGoQgD0sMafsRFNlw3S4f1r-7t5OO4ev5bbeI,9225
 pyglove/core/typing/key_specs_test.py,sha256=5zornpyHMAYoRaG8KDXHiQ3obu9UfRp3399lBeUNTPk,6499
 pyglove/core/typing/pytype_support.py,sha256=lyX11WVbCwoOi5tTQ90pEOS-yvo_6iEi7Lxbp-nXu2A,2069
-pyglove/core/typing/type_conversion.py,sha256=0L4Cbsw_QiM-gpsn-4y-XLEIvwiUB16Clj9gCtoC_Xc,5224
-pyglove/core/typing/type_conversion_test.py,sha256=BhASOGvtKXmYLWKCELU1RVB_Nmt1V-saSkGogvsNL7E,5342
+pyglove/core/typing/type_conversion.py,sha256=S_57FU-9DOk-MTE-1Mh31FMshaA3IoKiSDsoKxGxGv4,5432
+pyglove/core/typing/type_conversion_test.py,sha256=rK0lAjLi1azKY4ZltquIsCpKh20EtYSIekArnqI6ThQ,5475
 pyglove/core/typing/typed_missing.py,sha256=-l1omAu0jBZv5BnsFYXBqfvQwVBnmPh_X1wcIKD9bOk,2734
 pyglove/core/typing/typed_missing_test.py,sha256=TCNsb1SRpFaVdxYn2mB_yaLuja8w5Qn5NP7uGiZVBWs,2301
-pyglove/core/typing/value_specs.py,sha256=8E83QDZMb3lMXhgzfVNt9u6Bg3NPkvpjLXetjkps8UU,103263
-pyglove/core/typing/value_specs_test.py,sha256=eGXVxdduIM-oEaapJS9Kh7WSQHRUFegLIJ1GEzQkKHA,131017
+pyglove/core/typing/value_specs.py,sha256=oaLjvJ61Gv7myn93krzG3kfdw0n9va3sxmyDjy0xRFY,103368
+pyglove/core/typing/value_specs_test.py,sha256=Mi0Esw-0E_1JSjoEQcjkefkcaS0-omIBzlWVTRYv1F8,131170
 pyglove/core/utils/__init__.py,sha256=6P2VcGkjDsOFG640Jqu-jd1K3pfAK5NkcK3NBPLI6RY,8726
 pyglove/core/utils/common_traits.py,sha256=PWxOgPhG5H60ZwfO8xNAEGRjFUqqDZQBWQYomOfvdy8,3640
 pyglove/core/utils/common_traits_test.py,sha256=DIuZB_1xfmeTVfWnGOguDQcDAM_iGgBOe8C-5CsIqBc,1122
@@ -149,8 +151,8 @@ pyglove/core/utils/formatting.py,sha256=Wn4d933LQLhuMIfjdRJgpxOThCxBxQrkRBa6Z1-h
 pyglove/core/utils/formatting_test.py,sha256=hhg-nL6DyE5A2QA92ALHK5QtfAYKfPpTbBARF-IT1j0,14241
 pyglove/core/utils/hierarchical.py,sha256=jwB-0FhqOspAymAkvJphRhPTQEsoShmKupCZpU3Vip4,19690
 pyglove/core/utils/hierarchical_test.py,sha256=f382DMJPa_bavJGGQDjuw-hWcafUg5bkQCPX-nbzeiI,21077
-pyglove/core/utils/json_conversion.py,sha256=V7wUviGKhEPWi1gtCGSDXXvBzV6cO7CvmEiGDZ2jWFY,34643
-pyglove/core/utils/json_conversion_test.py,sha256=6afuPJxBXIO-OxFzJBkv1MZqNX-44HIBD6YJjwxXSbs,13412
+pyglove/core/utils/json_conversion.py,sha256=PWV51Dm7J-ovakhqXJux_zBAFqvjHKb9RObER8phDvw,37165
+pyglove/core/utils/json_conversion_test.py,sha256=w4k6qgXGEnNXrfryTQppxtF3GJ9rdEHjvjznXSIOMcg,15809
 pyglove/core/utils/missing.py,sha256=9gslt1lXd1qSEIuAFxUWu30oD-YdYcnm13eau1S9uqY,1445
 pyglove/core/utils/missing_test.py,sha256=D6-FuVEwCyJemUiPLcwLmwyptqI5Bx0Pfipc2juhKSE,1335
 pyglove/core/utils/text_color.py,sha256=xcCTCxY2qFNZs_jismMGus8scEXKBpYGAhpAgnz-MHk,4112
@@ -175,8 +177,8 @@ pyglove/core/views/html/controls/label.py,sha256=2u7z_6o-ANf6EbxufFl_fZ1VFSUrjNw
 pyglove/core/views/html/controls/label_test.py,sha256=_Fi6vMITup8iFYTiU_1w7FZCXaYp1eMmVBxub8JMYbs,5170
 pyglove/core/views/html/controls/progress_bar.py,sha256=0an0eCbPCDjwrR58C16NwLZ-cf3Oy0wQerLsiNgGHmk,5235
 pyglove/core/views/html/controls/progress_bar_test.py,sha256=kKOJDZQtBPkmNcgIBrRQkNNzcTm51ojuFBTRUEDSsp0,3506
-pyglove/core/views/html/controls/tab.py,sha256=dn2rs6IBqvjtKvk0BC8ypVYqjjHsqJvP_Bh9y94QjMc,10818
-pyglove/core/views/html/controls/tab_test.py,sha256=deRXg4LM4dzVgods5HVTXznrOWdddF6wrcl1RuhmRCA,5656
+pyglove/core/views/html/controls/tab.py,sha256=f3ZfYyXfMmERGOXY4a4bxmOhomL3MQONMossaxw8hQw,11851
+pyglove/core/views/html/controls/tab_test.py,sha256=V0HrY0YaGyVlOykMCFg85QSxOq8eBPa3Fqcv2q1c12s,6912
 pyglove/core/views/html/controls/tooltip.py,sha256=01BbpuM1twf3FYMUT09_Ck5JSSONe8QE9RmyA9nhCnU,3092
 pyglove/core/views/html/controls/tooltip_test.py,sha256=17BY-WmZKpz9tCbySPcwG6KJyfeE_MeMyKxtfxorBQ0,3194
 pyglove/ext/__init__.py,sha256=3jp8cJvKW6PENOZlmVAbT0w-GBRn_kjhc0wDX3XjpOE,755
@@ -187,7 +189,7 @@ pyglove/ext/early_stopping/step_wise.py,sha256=P99Z2hODmCNBnR3iVOOj2NCCwveSH6h5V
 pyglove/ext/early_stopping/step_wise_test.py,sha256=I9DDMrCpDwIWC6mV9w2pDypnrwYnWjg6QXTFNT13cts,9032
 pyglove/ext/evolution/__init__.py,sha256=lAf4NyxUZRt39kMFFoW_i8-ExigJXakG1-sUREW7jkQ,3214
 pyglove/ext/evolution/base.py,sha256=I27qJja6MErMs3SyrlBYvmDQ4eTq9dY9RVpscKlwReQ,50090
-pyglove/ext/evolution/base_test.py,sha256=yIw4YS60c_MvDj71QkoxX5Y2NLZgGc_KzT_NuHMCXMk,29936
+pyglove/ext/evolution/base_test.py,sha256=HgWSGGHh7nd03IFLln3dKV4TsI1kK4idJd4azAGaxHw,29943
 pyglove/ext/evolution/hill_climb.py,sha256=Bysi2u4KEM7d9CIPcnvKKgEQHttkaKFkI8xlrNOkBB8,1688
 pyglove/ext/evolution/hill_climb_test.py,sha256=7snzopGFRgkryNXiDVcHMhtVz6LXLZCOH_tz_t15b4I,3110
 pyglove/ext/evolution/mutators.py,sha256=ZkNmIf9B2KRP3H7UfML7nkjUYPPgOkm5Fe1kaJQ8W5I,10062
@@ -218,8 +220,8 @@ pyglove/ext/scalars/randoms.py,sha256=LkMIIx7lOq_lvJvVS3BrgWGuWl7Pi91-lA-O8x_gZs
 pyglove/ext/scalars/randoms_test.py,sha256=nEhiqarg8l_5EOucp59CYrpO2uKxS1pe0hmBdZUzRNM,2000
 pyglove/ext/scalars/step_wise.py,sha256=IDw3tuTpv0KVh7AN44W43zqm1-E0HWPUlytWOQC9w3Y,3789
 pyglove/ext/scalars/step_wise_test.py,sha256=TL1vJ19xVx2t5HKuyIzGoogF7N3Rm8YhLE6JF7i0iy8,2540
-pyglove-0.5.0.dev202510230131.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.5.0.dev202510230131.dist-info/METADATA,sha256=ym-feRv6WNcWJcHwyu0hlpledVeQZznTxZpGyI62kog,7089
-pyglove-0.5.0.dev202510230131.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pyglove-0.5.0.dev202510230131.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.5.0.dev202510230131.dist-info/RECORD,,
+pyglove-0.5.0.dev202511300809.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.5.0.dev202511300809.dist-info/METADATA,sha256=UenEruuR6yfx1_hUKjd-L5lbN15GMZnpOhKYeA7hwPc,7349
+pyglove-0.5.0.dev202511300809.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyglove-0.5.0.dev202511300809.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.5.0.dev202511300809.dist-info/RECORD,,