pyglove 0.4.5.dev202504280824__py3-none-any.whl → 0.4.5.dev202504300810__py3-none-any.whl

pyglove/core/symbolic/base.py

@@ -2458,7 +2458,8 @@ def symbolic_transform_fn(allow_partial: bool):
       return value
     if isinstance(value, dict):
       value_spec = pg_typing.ensure_value_spec(
-          field.value, pg_typing.Dict(), path)
+          field.value, pg_typing.Dict().noneable(), path
+      )
       value = Symbolic.DictType(   # pytype: disable=not-callable  # pylint: disable=not-callable
           value,
           value_spec=value_spec,
@@ -2471,7 +2472,10 @@ def symbolic_transform_fn(allow_partial: bool):
           pass_through=True)
     elif isinstance(value, list):
       value_spec = pg_typing.ensure_value_spec(
-          field.value, pg_typing.List(pg_typing.Any()), path)
+          field.value,
+          pg_typing.List(pg_typing.Any()).noneable(),
+          path
+      )
       value = Symbolic.ListType(   # pytype: disable=not-callable  # pylint: disable=not-callable
           value,
           value_spec=value_spec,

pyglove/core/typing/annotation_conversion.py

@@ -407,7 +407,7 @@ def _value_spec_from_type_annotation(
     else:
       spec = vs.Union([_sub_value_spec_from_annotation(x) for x in args])
     if optional:
-      spec = spec.noneable()
+      spec = spec.noneable(use_none_as_default=False)
     return spec
   elif origin is typing.Final:
     return _value_spec_from_type_annotation(

pyglove/core/typing/annotation_conversion_test.py

@@ -459,11 +459,11 @@ class ValueSpecFromAnnotationTest(unittest.TestCase):
   def test_optional(self):
     self.assertEqual(
         ValueSpec.from_annotation(typing.Optional[int], True),
-        vs.Int().noneable())
+        vs.Int().noneable(use_none_as_default=False))
     if annotation_conversion._UnionType:
       self.assertEqual(
           ValueSpec.from_annotation(int | None, True),
-          vs.Int().noneable())
+          vs.Int().noneable(use_none_as_default=False))
 
   def test_union(self):
     self.assertEqual(
@@ -471,11 +471,11 @@ class ValueSpecFromAnnotationTest(unittest.TestCase):
         vs.Union([vs.Int(), vs.Str()]))
     self.assertEqual(
         ValueSpec.from_annotation(typing.Union[int, str, None], True),
-        vs.Union([vs.Int(), vs.Str()]).noneable())
+        vs.Union([vs.Int(), vs.Str()]).noneable(use_none_as_default=False))
     if annotation_conversion._UnionType:
       self.assertEqual(
-          ValueSpec.from_annotation(int | str, True),
-          vs.Union([vs.Int(), vs.Str()]))
+          ValueSpec.from_annotation(int | str | None, True),
+          vs.Union([vs.Int(), vs.Str()]).noneable(use_none_as_default=False))
 
   def test_final(self):
     self.assertEqual(

pyglove/core/typing/annotation_future_test.py

@@ -67,7 +67,9 @@ class AnnotationFutureConversionTest(unittest.TestCase):
       class Bar(pg.Object):
         x: list[int | None]
 
-      self.assert_value_spec(Bar, 'x', vs.List(vs.Int().noneable()))
+      self.assert_value_spec(
+          Bar, 'x', vs.List(vs.Int().noneable(use_none_as_default=False))
+      )
 
   def test_var_length_tuple(self):
 
@@ -88,13 +90,17 @@ class AnnotationFutureConversionTest(unittest.TestCase):
     class Foo(pg.Object):
       x: typing.Optional[int]
 
-    self.assert_value_spec(Foo, 'x', vs.Int().noneable())
+    self.assert_value_spec(
+        Foo, 'x', vs.Int().noneable(use_none_as_default=False)
+    )
 
     if sys.version_info >= (3, 10):
       class Bar(pg.Object):
         x: int | None
 
-      self.assert_value_spec(Bar, 'x', vs.Int().noneable())
+      self.assert_value_spec(
+          Bar, 'x', vs.Int().noneable(use_none_as_default=False)
+      )
 
   def test_union(self):
 
@@ -102,7 +108,11 @@ class AnnotationFutureConversionTest(unittest.TestCase):
       x: Union[int, typing.Union[str, bool], None]
 
     self.assert_value_spec(
-        Foo, 'x', vs.Union([vs.Int(), vs.Str(), vs.Bool()]).noneable()
+        Foo,
+        'x',
+        vs.Union(
+            [vs.Int(), vs.Str(), vs.Bool()]
+        ).noneable(use_none_as_default=False)
     )
 
     if sys.version_info >= (3, 10):
@@ -125,7 +135,7 @@ class AnnotationFutureConversionTest(unittest.TestCase):
 
   def test_self_referencial(self):
     self.assert_value_spec(
-        self.A, 'a', vs.Object(self.A).noneable()
+        self.A, 'a', vs.Object(self.A).noneable(use_none_as_default=False)
     )
     self.assert_value_spec(
         self.A, 'b', vs.List(vs.Object(self.A))

pyglove/core/typing/class_schema.py

@@ -370,7 +370,10 @@ class ValueSpec(utils.Formattable, utils.JSONConvertible):
     """Returns forward referenes used by the value spec."""
 
   @abc.abstractmethod
-  def noneable(self) -> 'ValueSpec':
+  def noneable(
+      self,
+      is_noneable=True,
+      use_none_as_default: bool = True) -> 'ValueSpec':
     """Marks none-able and returns `self`."""
 
   @property

pyglove/core/typing/class_schema_test.py

@@ -885,20 +885,31 @@ class CreateSchemaTest(unittest.TestCase):
     self.assertEqual(s['e'], Field('e', vs.Enum(0, [0, 1])))
     self.assertEqual(s.metadata, {'user_data': 2})
     self.assertEqual(s['f'], Field('f', vs.Int()))
-    self.assertEqual(s['f1'], Field('f1', vs.Int().noneable()))
+    self.assertEqual(
+        s['f1'], Field('f1', vs.Int().noneable(use_none_as_default=False))
+    )
     self.assertEqual(s['g'], Field('g', vs.Float()))
-    self.assertEqual(s['g1'], Field('g1', vs.Float().noneable()))
+    self.assertEqual(
+        s['g1'], Field('g1', vs.Float().noneable(use_none_as_default=False))
+    )
     self.assertEqual(s['h'], Field('h', vs.Bool()))
-    self.assertEqual(s['h1'], Field('h1', vs.Bool().noneable()))
+    self.assertEqual(
+        s['h1'], Field('h1', vs.Bool().noneable(use_none_as_default=False))
+    )
     self.assertEqual(s['i'], Field('i', vs.Str()))
-    self.assertEqual(s['i1'], Field('i1', vs.Str().noneable()))
+    self.assertEqual(
+        s['i1'], Field('i1', vs.Str().noneable(use_none_as_default=False))
+    )
     self.assertEqual(
         s['j'], Field('j', vs.Union([vs.Int(), vs.Float(), vs.Bool()]))
     )
     self.assertEqual(s['k'], Field('k', vs.List(vs.Any())))
     self.assertEqual(s['l'], Field('l', vs.List(vs.Int())))
     self.assertEqual(s['L'], Field('L', vs.List(vs.Int())))
-    self.assertEqual(s['l1'], Field('l1', vs.List(vs.Int()).noneable()))
+    self.assertEqual(
+        s['l1'],
+        Field('l1', vs.List(vs.Int()).noneable(use_none_as_default=False))
+    )
     self.assertEqual(
         s['l2'],
         Field('l2', vs.List(vs.Str()).set_default(['black', 'white'])),

pyglove/core/typing/value_specs.py

@@ -140,11 +140,18 @@ class ValueSpecBase(ValueSpec):
     """Returns True if current value spec accepts None."""
     return self._is_noneable
 
-  def noneable(self) -> 'ValueSpecBase':
+  def noneable(
+      self,
+      is_noneable: bool = True,
+      use_none_as_default: bool = True
+  ) -> 'ValueSpecBase':
     """Marks None is acceptable and returns `self`."""
-    self._is_noneable = True
-    if MISSING_VALUE == self._default:  # pytype: disable=attribute-error
-      self._default = None
+    self._is_noneable = is_noneable
+    if is_noneable:
+      if use_none_as_default and not self.has_default:  # pytype: disable=attribute-error
+        self.set_default(None, False)
+    elif self.default is None:
+      self.set_default(MISSING_VALUE, False)
     return self
 
   @property
@@ -942,11 +949,21 @@ class Enum(Generic, PrimitiveType):
       return self.default
     return self.apply(*args)
 
-  def noneable(self) -> 'Enum':
+  def noneable(
+      self,
+      is_noneable: bool = True,
+      use_none_as_default: bool = True
+  ) -> 'Enum':
     """Noneable is specially treated for Enum."""
-    if None not in self._values:
-      self._values.append(None)
-    self._is_noneable = True
+    if is_noneable:
+      if None not in self._values:
+        self._values.append(None)
+    else:
+      if None in self._values:
+        self._values.remove(None)
+        if self._default is None:
+          self._default = MISSING_VALUE
+    self._is_noneable = is_noneable
     return self
 
   @property
@@ -1714,10 +1731,19 @@ class Dict(Generic, ValueSpecBase):
     """Returns the schema of this dict spec."""
     return self._schema
 
-  def noneable(self) -> 'Dict':
+  def noneable(
+      self,
+      is_noneable: bool = True,
+      use_none_as_default: bool = True
+  ) -> 'Dict':
     """Override noneable in Dict to always set default value None."""
-    self._is_noneable = True
-    self.set_default(None, False)
+    self._is_noneable = is_noneable
+    if is_noneable:
+      if use_none_as_default:
+        self.set_default(None, False)
+    elif self._default is None:
+      # Automatically generate default based on schema.
+      self.set_default(MISSING_VALUE)
     return self
 
   def set_default(
@@ -2698,11 +2724,18 @@ class Union(Generic, ValueSpecBase):
       value_types.update(child_value_type)
     return tuple(value_types)
 
-  def noneable(self) -> 'Union':
+  def noneable(
+      self,
+      is_noneable: bool = True,
+      use_none_as_default: bool = True
+  ) -> 'Union':
     """Customized noneable for Union."""
-    super().noneable()
+    super().noneable(
+        is_noneable=is_noneable,
+        use_none_as_default=use_none_as_default
+    )
     for c in self._candidates:
-      c.noneable()
+      c.noneable(is_noneable=is_noneable, use_none_as_default=False)
     return self
 
   @property

pyglove/core/typing/value_specs_test.py

@@ -61,6 +61,10 @@ class BoolTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Bool().is_noneable)
     self.assertTrue(vs.Bool().noneable().is_noneable)
+    self.assertIsNone(vs.Bool().noneable().default)
+    self.assertFalse(vs.Bool().noneable(use_none_as_default=False).has_default)
+    self.assertFalse(vs.Bool().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Bool().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Bool()), 'Bool()')
@@ -212,6 +216,10 @@ class StrTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Str().is_noneable)
     self.assertTrue(vs.Str().noneable().is_noneable)
+    self.assertIsNone(vs.Str().noneable().default)
+    self.assertFalse(vs.Str().noneable(use_none_as_default=False).has_default)
+    self.assertFalse(vs.Str().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Str().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Str()), 'Str()')
@@ -371,6 +379,10 @@ class IntTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Int().is_noneable)
     self.assertTrue(vs.Int().noneable().is_noneable)
+    self.assertIsNone(vs.Int().noneable().default)
+    self.assertFalse(vs.Int().noneable(use_none_as_default=False).has_default)
+    self.assertFalse(vs.Int().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Int().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Int()), 'Int()')
@@ -584,6 +596,10 @@ class FloatTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Float().is_noneable)
     self.assertTrue(vs.Float().noneable().is_noneable)
+    self.assertIsNone(vs.Float().noneable().default)
+    self.assertFalse(vs.Float().noneable(use_none_as_default=False).has_default)
+    self.assertFalse(vs.Float().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Float().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(str(vs.Float()), 'Float()')
@@ -809,6 +825,18 @@ class EnumTest(ValueSpecTest):
     self.assertEqual(
         vs.Enum('a', ['a', 'b']).noneable(),
         vs.Enum('a', ['a', 'b', None]))
+    self.assertEqual(
+        vs.Enum('a', ['a', 'b']).noneable().default,
+        'a'
+    )
+    self.assertEqual(
+        vs.Enum('a', ['a', None]).noneable(False),
+        vs.Enum('a', ['a'])
+    )
+    self.assertEqual(
+        vs.Enum(None, [None, 'a']).noneable(False),
+        vs.Enum(typed_missing.MISSING_VALUE, ['a'])
+    )
 
   def test_repr(self):
     self.assertEqual(
@@ -960,6 +988,12 @@ class ListTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.List(vs.Int()).is_noneable)
     self.assertTrue(vs.List(vs.Int()).noneable().is_noneable)
+    self.assertIsNone(vs.List(vs.Int()).noneable().default)
+    self.assertFalse(
+        vs.List(vs.Int()).noneable(use_none_as_default=False).has_default
+    )
+    self.assertFalse(vs.List(vs.Int()).noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.List(vs.Int()).noneable().noneable(False).has_default)
 
   def test_str(self):
     self.assertEqual(
@@ -1268,6 +1302,12 @@ class TupleTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Tuple([vs.Int()]).is_noneable)
     self.assertTrue(vs.Tuple([vs.Int()]).noneable().is_noneable)
+    self.assertFalse(
+        vs.Tuple([vs.Int()]).noneable().noneable(False).is_noneable
+    )
+    self.assertFalse(
+        vs.Tuple([vs.Int()]).noneable().noneable(False).has_default
+    )
 
   def test_fixed_length(self):
     self.assertFalse(vs.Tuple(vs.Int()).fixed_length)
@@ -1750,6 +1790,12 @@ class DictTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Dict().is_noneable)
     self.assertTrue(vs.Dict().noneable().is_noneable)
+    self.assertFalse(vs.Dict().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Dict().noneable().noneable(False).has_default)
+    self.assertEqual(
+        vs.Dict({'x': vs.Int(default=1)}).noneable().noneable(False).default,
+        {'x': 1}
+    )
 
   def test_repr(self):
     self.assertEqual(repr(vs.Dict()), 'Dict()')
@@ -2156,6 +2202,8 @@ class ObjectTest(ValueSpecTest):
     self.assertFalse(vs.Object(self.A).is_noneable)
     self.assertTrue(vs.Object(self.A).noneable().is_noneable)
     self.assertTrue(vs.Object('Foo').noneable().is_noneable)
+    self.assertFalse(vs.Object(self.A).noneable(False).is_noneable)
+    self.assertFalse(vs.Object(self.A).noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Object(self.A)), 'Object(A)')
@@ -2416,6 +2464,8 @@ class CallableTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Callable().is_noneable)
     self.assertTrue(vs.Callable().noneable().is_noneable)
+    self.assertFalse(vs.Callable().noneable().noneable(False).is_noneable)
+    self.assertFalse(vs.Callable().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Callable()), 'Callable()')
@@ -2861,6 +2911,8 @@ class TypeTest(ValueSpecTest):
   def test_noneable(self):
     self.assertFalse(vs.Type(Exception).is_noneable)
     self.assertTrue(vs.Type(Exception).noneable().is_noneable)
+    self.assertFalse(vs.Type(Exception).noneable(False).is_noneable)
+    self.assertFalse(vs.Type(Exception).noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Type(Exception)), 'Type(<class \'Exception\'>)')
@@ -3123,6 +3175,41 @@ class UnionTest(ValueSpecTest):
     )
     self.assertTrue(
         vs.Union([vs.Int().noneable(), vs.Bool()]).is_noneable)
+    self.assertFalse(
+        vs.Union([vs.Int().noneable(), vs.Bool()]).has_default)
+    self.assertTrue(
+        vs.Union([vs.Int().noneable(), vs.Bool()]).candidates[0].has_default
+    )
+    self.assertIsNone(
+        vs.Union(
+            [vs.Int(), vs.Bool()]
+        ).noneable().default
+    )
+    self.assertFalse(
+        vs.Union(
+            [vs.Int(), vs.Bool()]
+        ).noneable(use_none_as_default=False).has_default
+    )
+    self.assertTrue(
+        vs.Union(
+            [vs.Int(), vs.Bool()]
+        ).noneable().candidates[0].is_noneable
+    )
+    self.assertFalse(
+        vs.Union(
+            [vs.Int(), vs.Bool()]
+        ).noneable().candidates[0].has_default
+    )
+    self.assertFalse(
+        vs.Union(
+            [vs.Int().noneable(), vs.Bool()]
+        ).noneable(False).candidates[0].is_noneable
+    )
+    self.assertFalse(
+        vs.Union(
+            [vs.Int().noneable(), vs.Bool()]
+        ).noneable(False).candidates[0].has_default
+    )
 
   def test_str(self):
     self.assertEqual(
@@ -3132,8 +3219,8 @@ class UnionTest(ValueSpecTest):
         'Union([Int(), Bool()], default=1, frozen=True)')
     self.assertEqual(
         repr(vs.Union([vs.Int(), vs.Bool()], default=1).noneable()),
-        'Union([Int(default=None, noneable=True), '
-        'Bool(default=None, noneable=True)], default=1, noneable=True)')
+        'Union([Int(noneable=True), '
+        'Bool(noneable=True)], default=1, noneable=True)')
 
   def test_annotation(self):
     self.assertEqual(
@@ -3436,6 +3523,11 @@ class AnyTest(ValueSpecTest):
 
   def test_noneable(self):
     self.assertTrue(vs.Any().is_noneable)
+    self.assertFalse(vs.Any().has_default)
+    self.assertTrue(vs.Any().noneable().is_noneable)
+    self.assertTrue(vs.Any().noneable().has_default)
+    self.assertFalse(vs.Any().noneable(False).is_noneable)
+    self.assertFalse(vs.Any().noneable().noneable(False).has_default)
 
   def test_repr(self):
     self.assertEqual(repr(vs.Any()), 'Any()')

pyglove/core/views/html/base.py

@@ -18,7 +18,7 @@ import functools
 import html as html_lib
 import inspect
 import typing
-from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Union
+from typing import Any, Callable, Dict, Iterable, Optional, Sequence, Union
 
 from pyglove.core import typing as pg_typing
 from pyglove.core import utils
@@ -297,7 +297,7 @@ class Html(base.Content):
   def element(
       cls,
       tag: str,
-      inner_html: Optional[List[WritableTypes]] = None,
+      inner_html: Optional[utils.Nestable[WritableTypes]] = None,
       *,
       options: Union[str, Iterable[str], None] = None,
       css_classes: NestableStr = None,
@@ -340,8 +340,11 @@ class Html(base.Content):
 
     # Write the inner HTML.
     if inner_html:
-      for child in inner_html:
-        s.write(child)
+      if isinstance(inner_html, list):
+        for child in utils.flatten(inner_html).values():
+          s.write(child)
+      else:
+        s.write(inner_html)
 
     # Write the closing tag.
     s.write(f'</{tag}>')

pyglove/core/views/html/base_test.py

@@ -800,12 +800,14 @@ class HtmlTest(TestCase):
             'div',
             [
                 '<hr>',
-                lambda: '<div>bar</div>',
+                [[lambda: '<div>bar</div>']],
                 None,
-                Html.element(
-                    'div',
-                    css_classes='my_class',
-                ).add_style('div.my_class { color: red; }')
+                [
+                    Html.element(
+                        'div',
+                        css_classes='my_class',
+                    ).add_style('div.my_class { color: red; }')
+                ]
             ]
         )),
         """

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

@@ -16,6 +16,7 @@
 from typing import Annotated, Any, Dict, List, Optional, Union
 
 from pyglove.core import typing as pg_typing
+from pyglove.core import utils as pg_utils
 from pyglove.core.symbolic import flags as pg_flags
 from pyglove.core.symbolic import object as pg_object
 # pylint: disable=g-importing-member
@@ -157,6 +158,23 @@ class LabelGroup(HtmlControl):
       'The label for the name of the group.'
   ] = None
 
+  @pg_utils.explicit_method_override
+  def __init__(
+      self,
+      labels: List[Union[Label, str, Html, None, List[Any]]],
+      name: Optional[Label] = None,
+      id: Optional[str] = None,  # pylint: disable=redefined-builtin
+      css_classes: Optional[List[str]] = None,
+      styles: Optional[Dict[str, str]] = None,
+      **kwargs,
+  ) -> None:
+    if labels:
+      labels = [l for l in pg_utils.flatten(labels).values() if l is not None]
+    super().__init__(
+        labels=labels, name=name, id=id, css_classes=css_classes or [],
+        styles=styles or {}, **kwargs
+    )
+
   def _on_bound(self):
     super()._on_bound()
     with pg_flags.notify_on_change(False):

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

@@ -136,7 +136,7 @@ class LabelTest(TestCase):
 class LabelGroupTest(TestCase):
 
   def test_basic(self):
-    group = label_lib.LabelGroup(['foo', 'bar'], name='baz')
+    group = label_lib.LabelGroup(['foo', None, ['bar']], name='baz')
     self.assert_html_content(
         group,
         (

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

@@ -13,8 +13,9 @@
 # limitations under the License.
 """Tab control."""
 
-from typing import Annotated, List, Literal, Optional, Union
+from typing import Annotated, Any, Dict, List, Literal, Optional, Union
 
+from pyglove.core import utils as pg_utils
 from pyglove.core.symbolic import flags as pg_flags
 from pyglove.core.symbolic import object as pg_object
 
@@ -73,6 +74,48 @@ class TabControl(HtmlControl):
 
   interactive = True
 
+  @pg_utils.explicit_method_override
+  def __init__(
+      self,
+      tabs: List[Union[Tab, None, List[Any]]],
+      selected: Union[int, str, List[str]] = 0,
+      tab_position: Literal['top', 'left'] = 'top',
+      id: Optional[str] = None,   # pylint: disable=redefined-builtin
+      css_classes: Optional[List[str]] = None,
+      styles: Optional[Dict[str, str]] = None,
+      **kwargs,
+  ):
+    if tabs:
+      tabs = [t for t in pg_utils.flatten(tabs).values() if t is not None]
+    selected = self._find_tab_index(tabs, selected)
+    if selected == -1:
+      selected = 0
+    super().__init__(
+        tabs, selected=selected, tab_position=tab_position, id=id,
+        css_classes=css_classes or [], styles=styles or {},
+        **kwargs
+    )
+
+  @classmethod
+  def _find_tab_index(
+      cls,
+      tabs: List[Tab],
+      index_or_name: Union[int, str, List[str]]) -> int:
+    """Finds the index of a tab identified by an index or name."""
+    if isinstance(index_or_name, int):
+      return index_or_name
+    if isinstance(index_or_name, str):
+      priority_choices = [index_or_name]
+    else:
+      priority_choices = index_or_name
+
+    name_index = {t.name: i for i, t in enumerate(tabs)}
+    for name in priority_choices:
+      index = name_index.get(name)
+      if index is not None:
+        return index
+    return -1
+
   def append(self, tab: Tab) -> None:
     with pg_flags.notify_on_change(False):
       self.tabs.append(tab)

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

@@ -28,15 +28,87 @@ class TabControlTest(unittest.TestCase):
       print(actual)
     self.assertEqual(actual, expected)
 
+  def test_find_tab_index(self):
+    self.assertEqual(
+        tab_lib.TabControl._find_tab_index(
+            [
+                tab_lib.Tab('foo', base.Html('<h1>foo</h1>')),
+                tab_lib.Tab('bar', base.Html('<h1>bar</h1>')),
+            ],
+            1
+        ),
+        1
+    )
+    self.assertEqual(
+        tab_lib.TabControl._find_tab_index(
+            [
+                tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), name='foo'),
+                tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar'),
+            ],
+            'bar'
+        ),
+        1
+    )
+    self.assertEqual(
+        tab_lib.TabControl._find_tab_index(
+            [
+                tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), name='foo'),
+                tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar'),
+            ],
+            'baz'
+        ),
+        -1
+    )
+    self.assertEqual(
+        tab_lib.TabControl._find_tab_index(
+            [
+                tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), name='foo'),
+                tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar'),
+                tab_lib.Tab('baz', base.Html('<h1>baz</h1>'), name='baz'),
+            ],
+            ['baz', 'bar']
+        ),
+        2
+    )
+
+  def test_init(self):
+    tab = tab_lib.TabControl(
+        [
+            [tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), name='foo')],
+            None,
+            tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar'),
+        ],
+        1
+    )
+    self.assertEqual(tab.selected, 1)
+    self.assertEqual(tab.tabs[0].name, 'foo')
+    self.assertEqual(tab.tabs[1].name, 'bar')
+
+    # Cannot find tab by name.
+    tab = tab_lib.TabControl(
+        [
+            tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), name='foo'),
+            tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar'),
+        ],
+        'baz'
+    )
+    self.assertEqual(tab.selected, 0)
+    self.assertEqual(tab.tabs[0].name, 'foo')
+    self.assertEqual(tab.tabs[1].name, 'bar')
+
   def test_basic(self):
     tab = tab_lib.TabControl([
-        tab_lib.Tab('foo', base.Html('<h1>foo</h1>'), css_classes=['foo']),
-        tab_lib.Tab('bar', base.Html('<h1>bar</h1>')),
-    ])
+        tab_lib.Tab(
+            'foo', base.Html('<h1>foo</h1>'), css_classes=['foo'], name='foo'
+        ),
+        None,
+        [tab_lib.Tab('bar', base.Html('<h1>bar</h1>'), name='bar')],
+    ], selected='bar')
+    self.assertEqual(tab.selected, 1)
     elem_id = tab.element_id()
     self.assert_html_content(
         tab,
-        f"""<table class="tab-control"><tr><td><div class="tab-button-group top" id="{elem_id}-button-group"><button class="tab-button selected foo" onclick="openTab(event, '{elem_id}', '{elem_id}-0')"><span class="label">foo</span></button><button class="tab-button" onclick="openTab(event, '{elem_id}', '{elem_id}-1')"><span class="label">bar</span></button></div></td></tr><tr><td><div class="tab-content-group top" id="{elem_id}-content-group"><div class="tab-content selected foo" id="{elem_id}-0"><h1>foo</h1></div><div class="tab-content" id="{elem_id}-1"><h1>bar</h1></div></div></td></tr></table>"""
+        f"""<table class="tab-control"><tr><td><div class="tab-button-group top" id="{elem_id}-button-group"><button class="tab-button foo" onclick="openTab(event, '{elem_id}', '{elem_id}-0')"><span class="label">foo</span></button><button class="tab-button selected" onclick="openTab(event, '{elem_id}', '{elem_id}-1')"><span class="label">bar</span></button></div></td></tr><tr><td><div class="tab-content-group top" id="{elem_id}-content-group"><div class="tab-content foo" id="{elem_id}-0"><h1>foo</h1></div><div class="tab-content selected" id="{elem_id}-1"><h1>bar</h1></div></div></td></tr></table>"""
     )
     with tab.track_scripts() as scripts:
       tab.extend([

pyglove/core/views/html/tree_view.py

@@ -1409,7 +1409,7 @@ class HtmlTreeView(HtmlView):
     if remove:
       return {
           k: v for k, v in passthrough_kwargs.items()
-          if k not in remove
+          if k not in remove  # pytype: disable=unsupported-operands
       }
     return passthrough_kwargs
 

{pyglove-0.4.5.dev202504280824.dist-info → pyglove-0.4.5.dev202504300810.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyglove
-Version: 0.4.5.dev202504280824
+Version: 0.4.5.dev202504300810
 Summary: PyGlove: A library for manipulating Python objects.
 Home-page: https://github.com/google/pyglove
 Author: PyGlove Authors

{pyglove-0.4.5.dev202504280824.dist-info → pyglove-0.4.5.dev202504300810.dist-info}/RECORD

@@ -66,7 +66,7 @@ pyglove/core/patching/pattern_based_test.py,sha256=PW1EcVfsFPB6wtgwg3s4dzvigWn3b
 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=JZvyaEcS1QxA8MaAGANBWMmRTQcGk_6F0kjFxjokJqg,6002
-pyglove/core/symbolic/base.py,sha256=aSZPSk7v3Niv6D1HfL_JEEXfI-U1cQnTxJxY9wXem54,77627
+pyglove/core/symbolic/base.py,sha256=3vOHKtanrksBv5B_0HAq2R_CnE355aPx1B9lyJNb5us,77683
 pyglove/core/symbolic/base_test.py,sha256=yASIHIuWiUB1jf4nN-Y4XOjyvr8eQfRpr7s_1LZsu78,7188
 pyglove/core/symbolic/boilerplate.py,sha256=sQ3G25r5bo_UmIdjreL4jkAuQCXIHVlvUfGjjkNod6Y,5955
 pyglove/core/symbolic/boilerplate_test.py,sha256=1CZ1W6kq3l-3tpaknhGFa04V18bO7vPzis5qzWnxHEs,5252
@@ -109,15 +109,15 @@ pyglove/core/tuning/sample_test.py,sha256=JqwDPy3EPC_VjU9dipk90jj1kovZB3Zb9hAjAl
 pyglove/core/typing/__init__.py,sha256=MwraQ-6K8NYI_xk4V3oaVSkrPqiU9InDtAgXPSRBvik,14494
 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=7aMxv5AhC5oYteBtVTRp1no16dFgfGFCLbmxVasrdzQ,15557
-pyglove/core/typing/annotation_conversion_test.py,sha256=tOUM7k_VNiGfBlSy_r6vMKk0lD8gRNT6dqnzBzvhul4,17422
-pyglove/core/typing/annotation_future_test.py,sha256=ZVLU3kheO2V-nrp-m5jrGMLgGMs4S6RWnJbyD9KbHl4,3746
+pyglove/core/typing/annotation_conversion.py,sha256=txUrChAhMNeaukV-PSQEA9BCjtonUQDWFHxnpTE0_K8,15582
+pyglove/core/typing/annotation_conversion_test.py,sha256=GW7e3e00jcYJjJGRvCvMtW4QBHyVwFtZVcETdh1yBS8,17540
+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
 pyglove/core/typing/callable_signature.py,sha256=DRpt7aShfkn8pb3SCiZzS_27eHbkQ_d2UB8BUhJjs0Q,27176
 pyglove/core/typing/callable_signature_test.py,sha256=iQmHsKPhJPQlMikDhEyxKyq7yWyXI9juKCLYgKhrH3U,25145
-pyglove/core/typing/class_schema.py,sha256=dKmF1dwv-7RmCjnAb412AciYZL3LJCToU5WTJWYLj3Y,54482
-pyglove/core/typing/class_schema_test.py,sha256=RurRdCyPuypKJ7izgcq9zW3JNHgODiJdQvDn0BDZDjU,29353
+pyglove/core/typing/class_schema.py,sha256=u_pxvykZlwyd5ycdfHpWYI8ccttmBbzexrajNVbEVG4,54553
+pyglove/core/typing/class_schema_test.py,sha256=sJkE7ndDSIKb0EUcjZiVFOeJYDI7Hdu2GdPJCMgZxrI,29556
 pyglove/core/typing/custom_typing.py,sha256=qdnIKHWNt5kZAAFdpQXra8bBu6RljMbbJ_YDG2mhAUA,2205
 pyglove/core/typing/inspect.py,sha256=VLSz1KAunNm2hx0eEMjiwxKLl9FHlKr9nHelLT25iEA,7726
 pyglove/core/typing/inspect_test.py,sha256=xclevobF0X8c_B5b1q1dkBJZN1TsVA1RUhk5l25DUCM,10248
@@ -128,8 +128,8 @@ pyglove/core/typing/type_conversion.py,sha256=0L4Cbsw_QiM-gpsn-4y-XLEIvwiUB16Clj
 pyglove/core/typing/type_conversion_test.py,sha256=BhASOGvtKXmYLWKCELU1RVB_Nmt1V-saSkGogvsNL7E,5342
 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=Yxdrz4aURMBrtqUW4to-2Vptc6Z6oqQrLyMBiAZt2bc,102302
-pyglove/core/typing/value_specs_test.py,sha256=MsScWDRaN_8pfRDO9MCp9HdUHVm_8wHWyKorWVSnhE4,127165
+pyglove/core/typing/value_specs.py,sha256=8E83QDZMb3lMXhgzfVNt9u6Bg3NPkvpjLXetjkps8UU,103263
+pyglove/core/typing/value_specs_test.py,sha256=eGXVxdduIM-oEaapJS9Kh7WSQHRUFegLIJ1GEzQkKHA,131017
 pyglove/core/utils/__init__.py,sha256=I2bRTzigU7qJVEATGlLUFkYzkiCBBCCEwrQyhsrRNmI,8602
 pyglove/core/utils/common_traits.py,sha256=PWxOgPhG5H60ZwfO8xNAEGRjFUqqDZQBWQYomOfvdy8,3640
 pyglove/core/utils/common_traits_test.py,sha256=DIuZB_1xfmeTVfWnGOguDQcDAM_iGgBOe8C-5CsIqBc,1122
@@ -159,18 +159,18 @@ pyglove/core/views/__init__.py,sha256=gll9ZBRYz4p_-LWOdzSR2a6UTWcJ8nR430trrP0yLC
 pyglove/core/views/base.py,sha256=VVWlkyUPvZoNlcwMpuxt-AujGnuIJPS4Ym-jGBX0g9I,26262
 pyglove/core/views/base_test.py,sha256=UKbr_1TANOAnP7V5ICGF0UEkunfSaHiJ4nXZXhA0SaU,16642
 pyglove/core/views/html/__init__.py,sha256=Ff51MK1AKdzLM0kczTqLR3fRlJSJLDaFUdVyCu_7-eY,1085
-pyglove/core/views/html/base.py,sha256=LcRU8Lot_y1RW6fziaCQVVE0gWP0aVzIcO8v71JaX0E,15002
-pyglove/core/views/html/base_test.py,sha256=5RVPNm4YTamTFu6yXA1p2lJg3JHQBKNNBoL977qBZvE,22782
-pyglove/core/views/html/tree_view.py,sha256=MkQXtNKn88j9NXdhluKbIaHswjh1QtQoPv-CUwUfCNk,52062
+pyglove/core/views/html/base.py,sha256=jwckE6qyKOcbpgkDDYlB5lUKY6iaynENp6sV3kjl5Dc,15113
+pyglove/core/views/html/base_test.py,sha256=vPBP8nX5rodjs2llKznQNMJ8ct6nBmwp3Y1eam7T4VQ,22838
+pyglove/core/views/html/tree_view.py,sha256=TKDPSO0iruasAw68uhTw6aMTjtHAQxIGjhkvNhB4rXE,52102
 pyglove/core/views/html/tree_view_test.py,sha256=whUorrw0eiDaZsEzGB2B3EN3wx0vLFuNEe2RBU03GeU,74707
 pyglove/core/views/html/controls/__init__.py,sha256=61qs5pnJPCTECCGBtkbNfIV3KcCu7cxfVNBEtIg1lMo,1318
 pyglove/core/views/html/controls/base.py,sha256=aSYFEo-I6Yc28TMk1ZFw_Za85xMo8EvgfQLKISsLSe8,7675
-pyglove/core/views/html/controls/label.py,sha256=dXcYId7ASuNqkzKsWMjJ0iQtecoSsUlUgynNNQZOFAM,5681
-pyglove/core/views/html/controls/label_test.py,sha256=uUYqBSZ0XLOuv4qG20gmoZzA3RxYxpfqT63K0azHEfU,5162
+pyglove/core/views/html/controls/label.py,sha256=2u7z_6o-ANf6EbxufFl_fZ1VFSUrjNwDnrM784FFdNs,6312
+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=ELyroRb3qKQ8ULM_BMq2j-tqV_mnHOvrYv2kbuIe65o,9430
-pyglove/core/views/html/controls/tab_test.py,sha256=wr1msQjZHxp1TFKQ5LxtppY2Dys736JCmmEJ8WBC3Fo,3531
+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/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
@@ -212,8 +212,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.4.5.dev202504280824.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.4.5.dev202504280824.dist-info/METADATA,sha256=amyqZ0_zjYZSu1RxugmrxvX5jRDz7DZ77jpdMK-3iDs,7089
-pyglove-0.4.5.dev202504280824.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-pyglove-0.4.5.dev202504280824.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.4.5.dev202504280824.dist-info/RECORD,,
+pyglove-0.4.5.dev202504300810.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.4.5.dev202504300810.dist-info/METADATA,sha256=vipGZt0dKLshbJ9kyOhGBG0ven_rk7lFpUe-X7seIL0,7089
+pyglove-0.4.5.dev202504300810.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
+pyglove-0.4.5.dev202504300810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.4.5.dev202504300810.dist-info/RECORD,,

{pyglove-0.4.5.dev202504280824.dist-info → pyglove-0.4.5.dev202504300810.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any