pyglove 0.4.5.dev202412140808__py3-none-any.whl → 0.4.5.dev202412160810__py3-none-any.whl

pyglove/core/symbolic/object.py

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

pyglove/core/symbolic/object_test.py

@@ -324,6 +324,26 @@ class ObjectTest(unittest.TestCase):
     self.assertEqual(e.x, 1)
     self.assertEqual(e.y, 3)
 
+    class F(Object):
+      x: typing.Literal[1, 'a']
+
+    class G(F):
+      x: typing.Final[int] = 1
+      y: typing.ClassVar[int] = 2
+
+    self.assertEqual(G().x, 1)
+    self.assertEqual(G.y, 2)
+
+    with self.assertRaisesRegex(
+        ValueError, 'Frozen field is not assignable'):
+      G(x=2)
+
+    with self.assertRaisesRegex(
+        TypeError, 'Field x is marked as final but has no default value'):
+
+      class H(Object):  # pylint: disable=unused-variable
+        x: typing.Final[int]  # pylint: disable=invalid-name
+
   def test_init_arg_list(self):
 
     def _update_init_arg_list(cls, init_arg_list):

pyglove/core/symbolic/ref.py

@@ -14,16 +14,30 @@
 """Symbolic reference."""
 
 import functools
-import numbers
-from typing import Any, Callable, List, Optional, Tuple
+import typing
+from typing import Any, Callable, List, Optional, Tuple, Type
 from pyglove.core import object_utils
 from pyglove.core import typing as pg_typing
 from pyglove.core.symbolic import base
-from pyglove.core.symbolic.object import Object
+from pyglove.core.symbolic import object as pg_object
 from pyglove.core.views.html import tree_view
 
 
-class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
+class RefMeta(pg_object.ObjectMeta):
+  """Metaclass for Ref."""
+
+  def __getitem__(cls, type_arg: Type[Any]) -> Any:    # pylint: disable=no-self-argument
+    if typing.TYPE_CHECKING:
+      return type_arg
+    return pg_typing.Object(type_arg, transform=Ref)
+
+
+class Ref(
+    pg_object.Object,
+    base.Inferential,
+    tree_view.HtmlTreeView.Extension,
+    metaclass=RefMeta
+):
   """Symbolic reference.
 
   When adding a symbolic node to a symbolic tree, it undergoes a copy operation
@@ -82,9 +96,9 @@ class Ref(Object, base.Inferential, tree_view.HtmlTreeView.Extension):
 
   def __new__(cls, value: Any, **kwargs):
     del kwargs
-    if isinstance(value, (bool, numbers.Number, str)):
-      return value
-    return object.__new__(cls)
+    if isinstance(value, (base.Symbolic, list, dict)):
+      return object.__new__(cls)
+    return value
 
   @object_utils.explicit_method_override
   def __init__(self, value: Any, **kwargs) -> None:
@@ -241,4 +255,3 @@ def deref(value: base.Symbolic, recursive: bool = False) -> Any:
       return v
     return value.rebind(_deref, raise_on_no_change=False)
   return value
-

pyglove/core/symbolic/ref_test.py

@@ -16,6 +16,7 @@
 import copy
 import inspect
 import pickle
+import typing
 from typing import Any
 import unittest
 
@@ -202,6 +203,22 @@ class RefTest(unittest.TestCase):
         """
     )
 
+  def test_annotation(self):
+    typing.TYPE_CHECKING = True
+    assert ref.Ref[ValueError] is ValueError
+    typing.TYPE_CHECKING = False
+
+    class Bar(Object):
+      x: int
+
+    class Foo(Object):
+      y: ref.Ref[Bar]
+
+    f = Foo(Bar(1))
+    self.assertIsInstance(f.sym_getattr('y'), ref.Ref)
+    self.assertEqual(f.y.sym_path, '')
+    self.assertIsInstance(ref.Ref[Bar](1), ref.Ref)
+
 
 if __name__ == '__main__':
   unittest.main()

pyglove/core/typing/annotation_conversion.py

@@ -177,6 +177,11 @@ def _value_spec_from_type_annotation(
     if optional:
       spec = spec.noneable()
     return spec
+  elif origin is typing.Final:
+    return _value_spec_from_type_annotation(
+        args[0],
+        accept_value_as_annotation=False
+    ).freeze(vs._FROZEN_VALUE_PLACEHOLDER)  # pylint: disable=protected-access
   elif isinstance(annotation, typing.ForwardRef):
     annotation = annotation.__forward_arg__
     if parent_module is not None:

pyglove/core/typing/annotation_conversion_test.py

@@ -306,6 +306,14 @@ class ValueSpecFromAnnotationTest(unittest.TestCase):
           ValueSpec.from_annotation(int | str, True),
           vs.Union([vs.Int(), vs.Str()]))
 
+  def test_final(self):
+    self.assertEqual(
+        ValueSpec.from_annotation(
+            typing.Final[int], True
+        ).set_default(1),
+        vs.Int().freeze(1)
+    )
+
 
 if __name__ == '__main__':
   unittest.main()

pyglove/core/typing/class_schema.py

@@ -344,6 +344,10 @@ class ValueSpec(object_utils.Formattable, object_utils.JSONConvertible):
       Tuple[Type[Any], ...]]:  # pyformat: disable
     """Returns acceptable (resolved) value type(s)."""
 
+  @abc.abstractmethod
+  def __call__(self, *args, **kwargs) -> Any:
+    """Instantiates a value based on the spec.."""
+
   @property
   @abc.abstractmethod
   def forward_refs(self) -> Set[ForwardRef]:

pyglove/core/typing/value_specs.py

@@ -37,6 +37,17 @@ from pyglove.core.typing.custom_typing import CustomTyping
 
 MISSING_VALUE = object_utils.MISSING_VALUE
 
+
+class _FrozenValuePlaceholder(CustomTyping):
+  """Placeholder for to-be-assigned frozen value."""
+
+  def custom_apply(self, *args, **kwargs) -> typing.Tuple[bool, typing.Any]:
+    return (False, self)
+
+
+_FROZEN_VALUE_PLACEHOLDER = _FrozenValuePlaceholder()
+
+
 # Type alias for ValueSpec object or Python annotation that could be converted
 # to ValueSpec via `pg.typing.ValueSpec.from_annotation()`. This type alias is
 # just for better readability.
@@ -194,8 +205,18 @@ class ValueSpecBase(ValueSpec):
 
   def extend(self, base: ValueSpec) -> ValueSpec:
     """Extend current value spec on top of a base spec."""
-    if base.frozen:
-      raise TypeError(f'Cannot extend a frozen value spec: {base!r}')
+    if base.frozen and (not self.frozen or self.default != base.default):
+      raise TypeError(f'{self!r} cannot extend a frozen value spec: {base!r}')
+
+    # Special handling for extending enum.
+    if self.frozen and isinstance(base, Enum):
+      if self.default in base.values:
+        return Enum(MISSING_VALUE, base.values).freeze(self.default)
+      else:
+        raise TypeError(
+            f'{self!r} cannot extend {base!r} with incompatible '
+            f'frozen value: {self.default!r} '
+        )
 
     if self._transform is None:
       self._transform = base.transform
@@ -232,7 +253,7 @@ class ValueSpecBase(ValueSpec):
       root_path: typing.Optional[object_utils.KeyPath] = None) -> typing.Any:  # pyformat: disable pylint: disable=line-too-long
     """Apply spec to validate and complete value."""
     root_path = root_path or object_utils.KeyPath()
-    if self.frozen:
+    if self.frozen and self.default is not _FROZEN_VALUE_PLACEHOLDER:
       # Always return the default value if a field is frozen.
       if MISSING_VALUE != value and self.default != value:
         raise ValueError(
@@ -270,7 +291,8 @@ class ValueSpecBase(ValueSpec):
         value = self._transform(value)
       except Exception as e:  # pylint: disable=broad-except
         raise e.__class__(
-            object_utils.message_on_path(str(e), root_path)
+            object_utils.message_on_path(
+                str(e), root_path)
             ).with_traceback(sys.exc_info()[2])
 
       return self.skip_user_transform.apply(
@@ -319,7 +341,7 @@ class ValueSpecBase(ValueSpec):
     return value
 
   def is_compatible(self, other: ValueSpec) -> bool:
-    """Returns if current spec is compatible with the other value spec."""
+    """Returns if current spec can receive all values from the other spec."""
     if self is other:
       return True
     if not isinstance(other, self.__class__):
@@ -417,6 +439,12 @@ class PrimitiveType(ValueSpecBase):
         value_type, default, is_noneable=is_noneable, frozen=frozen
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del kwargs
+    if (not args and self.has_default) or self.frozen:
+      return self.default
+    return self.apply(self.value_type(*args))
+
 
 class Bool(PrimitiveType):
   """Value spec for boolean type.
@@ -898,6 +926,12 @@ class Enum(Generic, PrimitiveType):
         value_type, default, is_noneable=is_noneable, frozen=frozen
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del kwargs
+    if (not args and self.has_default) or self.frozen:
+      return self.default
+    return self.apply(*args)
+
   def noneable(self) -> 'Enum':
     """Noneable is specially treated for Enum."""
     if None not in self._values:
@@ -929,6 +963,12 @@ class Enum(Generic, PrimitiveType):
             f'{repr(v)} is not an acceptable value.'
         ) from e
 
+  def is_compatible(self, other: ValueSpec) -> bool:
+    """Enum specific compatibility check."""
+    if other.frozen and other.default in self.values:
+      return True
+    return super().is_compatible(other)
+
   def _is_compatible(self, other: 'Enum') -> bool:
     """Enum specific compatibility check."""
     for v in other.values:
@@ -1067,6 +1107,12 @@ class List(Generic, ValueSpecBase):
         list, default, transform, is_noneable=is_noneable, frozen=frozen
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del kwargs
+    if (not args and self.has_default) or self.frozen:
+      return self.default
+    return self.apply(list(*args))
+
   @property
   def element(self) -> Field:
     """Returns Field specification of list element."""
@@ -1316,6 +1362,12 @@ class Tuple(Generic, ValueSpecBase):
         tuple, default, transform, is_noneable=is_noneable, frozen=frozen
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del kwargs
+    if (not args and self.has_default) or self.frozen:
+      return self.default
+    return self.apply(tuple(*args))
+
   @property
   def fixed_length(self) -> bool:
     """Returns True if current Tuple spec is fixed length."""
@@ -1617,6 +1669,9 @@ class Dict(Generic, ValueSpecBase):
     if MISSING_VALUE == default:
       self.set_default(default)
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    return self.apply(dict(*args, **kwargs))
+
   @property
   def schema(self) -> typing.Optional[Schema]:
     """Returns the schema of this dict spec."""
@@ -1816,6 +1871,9 @@ class Object(Generic, ValueSpecBase):
         t, default, transform, is_noneable=is_noneable, frozen=frozen
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    return self.apply(self.cls(*args, **kwargs))
+
   @property
   def forward_refs(self) -> typing.Set[class_schema.ForwardRef]:
     """Returns forward references used in this spec."""
@@ -2014,6 +2072,10 @@ class Callable(Generic, ValueSpecBase):
         frozen=frozen,
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del args, kwargs
+    raise TypeError(f'{self!r} cannot be instantiated.')
+
   @functools.cached_property
   def forward_refs(self) -> typing.Set[class_schema.ForwardRef]:
     """Returns forward references used in this spec."""
@@ -2351,6 +2413,10 @@ class Type(Generic, ValueSpecBase):
     self._forward_ref = forward_ref
     super().__init__(type, default, is_noneable=is_noneable, frozen=frozen)
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del args, kwargs
+    return self.type
+
   @property
   def type(self) -> typing.Type[typing.Any]:
     """Returns desired type."""
@@ -2539,6 +2605,10 @@ class Union(Generic, ValueSpecBase):
         frozen=frozen,
     )
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del args, kwargs
+    raise TypeError(f'{self!r} cannot be instantiated.')
+
   @functools.cached_property
   def forward_refs(self) -> typing.Set[class_schema.ForwardRef]:
     """Returns forward references used in this spec."""
@@ -2856,6 +2926,10 @@ class Any(ValueSpecBase):
     )
     self._annotation = annotation
 
+  def __call__(self, *args, **kwargs) -> typing.Any:
+    del args, kwargs
+    raise TypeError(f'{self!r} cannot be instantiated.')
+
   def is_compatible(self, other: ValueSpec) -> bool:
     """Any is compatible with any ValueSpec."""
     return True

pyglove/core/typing/value_specs_test.py

@@ -99,6 +99,13 @@ class BoolTest(ValueSpecTest):
     with self.assertRaisesRegex(ValueError, 'Value cannot be None'):
       vs.Bool().apply(None)
 
+  def test_instantiation(self):
+    self.assertTrue(vs.Bool()(True))
+    self.assertFalse(vs.Bool()(False))
+    self.assertIsNone(vs.Bool().noneable()())
+    self.assertFalse(vs.Bool()())
+    self.assertTrue(vs.Bool().freeze(True)(False))
+
   def test_is_compatible(self):
     v = vs.Bool()
     self.assertTrue(v.is_compatible(v))
@@ -117,6 +124,12 @@ class BoolTest(ValueSpecTest):
     # Child may extend a noneable base into non-noneable.
     self.assertFalse(vs.Bool().extend(vs.Bool().noneable()).is_noneable)
 
+    # A frozen child may extend a enum with its value as candidate.
+    self.assertEqual(
+        vs.Bool().freeze(True).extend(vs.Enum(2, [2, True])),
+        vs.Enum(True, [2, True]).freeze(),
+    )
+
     # Child cannot extend a base with different type.
     with self.assertRaisesRegex(
         TypeError, '.* cannot extend .*: incompatible type.'):
@@ -127,6 +140,11 @@ class BoolTest(ValueSpecTest):
         TypeError, '.* cannot extend .*: None is not allowed in base spec.'):
       vs.Bool().noneable().extend(vs.Bool())
 
+    # Child cannot extend a non-noneable base to noneable.
+    with self.assertRaisesRegex(
+        TypeError, '.* cannot extend .* with incompatible frozen value'):
+      vs.Bool().freeze(True).extend(vs.Enum(False, [2, False]))
+
   def test_freeze(self):
     self.assertFalse(vs.Bool().frozen)
 
@@ -144,7 +162,7 @@ class BoolTest(ValueSpecTest):
     self.assertTrue(v.default)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Bool().extend(v)
 
     with self.assertRaisesRegex(
@@ -224,6 +242,12 @@ class StrTest(ValueSpecTest):
     self.assertNotEqual(vs.Str(), vs.Str(regex='.*'))
     self.assertNotEqual(vs.Str(regex='a'), vs.Str(regex='.*'))
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Str()('abc'), 'abc')
+    self.assertIsNone(vs.Str().noneable()())
+    self.assertEqual(vs.Str()(), '')
+    self.assertEqual(vs.Str().freeze('abc')('def'), 'abc')
+
   def test_apply(self):
     self.assertEqual(vs.Str().apply('a'), 'a')
     self.assertEqual(vs.Str(regex='a.*').apply('a1'), 'a1')
@@ -266,6 +290,12 @@ class StrTest(ValueSpecTest):
     # Child may extend a noneable base into non-noneable.
     self.assertFalse(vs.Str().extend(vs.Str().noneable()).is_noneable)
 
+    # A frozen child may extend a enum with its value as candidate.
+    self.assertEqual(
+        vs.Str().freeze('a').extend(vs.Enum(2, [2, 'a'])),
+        vs.Enum('a', [2, 'a']).freeze(),
+    )
+
     # Child cannot extend a base of different type.
     with self.assertRaisesRegex(
         TypeError, '.* cannot extend .*: incompatible type.'):
@@ -276,6 +306,11 @@ class StrTest(ValueSpecTest):
         TypeError, '.* cannot extend .*: None is not allowed in base spec.'):
       vs.Str().noneable().extend(vs.Str())
 
+    # Child cannot extend a non-noneable base to noneable.
+    with self.assertRaisesRegex(
+        TypeError, '.* cannot extend .* with incompatible frozen value'):
+      vs.Str().freeze('b').extend(vs.Enum('a', ['a', False]))
+
   def test_freeze(self):
     self.assertFalse(vs.Str().frozen)
 
@@ -293,7 +328,7 @@ class StrTest(ValueSpecTest):
     self.assertEqual(v.default, 'foo')
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Str().extend(v)
 
     with self.assertRaisesRegex(
@@ -307,6 +342,7 @@ class StrTest(ValueSpecTest):
     self.assert_json_conversion(vs.Str().noneable().freeze('abc'))
     self.assert_json_conversion_key(vs.Str(), 'pyglove.typing.Str')
 
+
 class IntTest(ValueSpecTest):
   """Tests for `Int`."""
 
@@ -377,6 +413,16 @@ class IntTest(ValueSpecTest):
         ValueError, '"max_value" must be equal or greater than "min_value".'):
       vs.Int(min_value=1, max_value=0)
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Int()(1), 1)
+    self.assertEqual(vs.Int()(), 0)
+    self.assertIsNone(vs.Int().noneable()())
+    self.assertEqual(vs.Int().freeze(1)(0), 1)
+    with self.assertRaisesRegex(
+        ValueError, 'Value .* is out of range'
+    ):
+      vs.Int(min_value=1)()
+
   def test_apply(self):
     self.assertEqual(vs.Int().apply(1), 1)
     self.assertEqual(vs.Int(min_value=1, max_value=1).apply(1), 1)
@@ -434,6 +480,12 @@ class IntTest(ValueSpecTest):
         vs.Int(min_value=1),
     )
 
+    # A frozen child may extend a enum with its value as candidate.
+    self.assertEqual(
+        vs.Int().freeze(2).extend(vs.Enum(2, [2, 'a'])),
+        vs.Enum(2, [2, 'a']).freeze(),
+    )
+
     with self.assertRaisesRegex(TypeError,
                                 '.* cannot extend .*: incompatible type.'):
       vs.Int().extend(vs.Bool())
@@ -466,6 +518,11 @@ class IntTest(ValueSpecTest):
         TypeError, '.* cannot extend .*: no compatible type found in Union.'):
       vs.Int().extend(vs.Union([vs.Bool(), vs.Str()]))
 
+    # Child cannot extend a non-noneable base to noneable.
+    with self.assertRaisesRegex(
+        TypeError, '.* cannot extend .* with incompatible frozen value'):
+      vs.Int().freeze(1).extend(vs.Enum('a', ['a', False]))
+
   def test_freeze(self):
     self.assertFalse(vs.Int().frozen)
 
@@ -483,7 +540,7 @@ class IntTest(ValueSpecTest):
     self.assertEqual(v.default, 1)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Int().extend(v)
 
     with self.assertRaisesRegex(
@@ -571,6 +628,16 @@ class FloatTest(ValueSpecTest):
         ValueError, '"max_value" must be equal or greater than "min_value".'):
       vs.Float(min_value=1., max_value=0.)
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Float()(1), 1.0)
+    self.assertEqual(vs.Float()(), 0.0)
+    self.assertIsNone(vs.Float().noneable()())
+    self.assertEqual(vs.Float().freeze(1.0)(0), 1.0)
+    with self.assertRaisesRegex(
+        ValueError, 'Value .* is out of range'
+    ):
+      vs.Float(min_value=1)()
+
   def test_apply(self):
     self.assertEqual(vs.Float().apply(1.), 1.)
     self.assertEqual(vs.Float().apply(1), 1.)
@@ -617,6 +684,12 @@ class FloatTest(ValueSpecTest):
     # Child may extend a noneable base into non-noneable.
     self.assertFalse(vs.Float().extend(vs.Float().noneable()).is_noneable)
 
+    # A frozen child may extend a enum with its value as candidate.
+    self.assertEqual(
+        vs.Float().freeze(2.5).extend(vs.Enum(2.5, [2.5, 'a'])),
+        vs.Enum(2.5, [2.5, 'a']).freeze(),
+    )
+
     with self.assertRaisesRegex(
         TypeError, '.* cannot extend .*: incompatible type.'):
       vs.Float().extend(vs.Int())
@@ -645,6 +718,11 @@ class FloatTest(ValueSpecTest):
         'min_value .* is greater than max_value .* after extension'):
       vs.Float(min_value=1.).extend(vs.Float(max_value=0.))
 
+    # Child cannot extend a non-noneable base to noneable.
+    with self.assertRaisesRegex(
+        TypeError, '.* cannot extend .* with incompatible frozen value'):
+      vs.Float().freeze(1.0).extend(vs.Enum('a', ['a', False]))
+
   def test_freeze(self):
     self.assertFalse(vs.Float().frozen)
 
@@ -662,7 +740,7 @@ class FloatTest(ValueSpecTest):
     self.assertEqual(v.default, 1.0)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Float().extend(v)
 
     with self.assertRaisesRegex(
@@ -768,6 +846,11 @@ class EnumTest(ValueSpecTest):
         ValueError, 'Enum default value \'a\' is not in candidate list.'):
       vs.Enum('a', ['b'])
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Enum(1, [1, 2, 3])(), 1)
+    self.assertEqual(vs.Enum(1, [1, 2, 3])(2), 2)
+    self.assertEqual(vs.Enum(1, [1, 2, 3]).freeze(2)(3), 2)
+
   def test_apply(self):
     self.assertEqual(vs.Enum('a', ['a']).apply('a'), 'a')
     self.assertIsNone(vs.Enum('a', ['a', None]).apply(None))
@@ -784,6 +867,8 @@ class EnumTest(ValueSpecTest):
     self.assertTrue(
         vs.Enum(0, [0, 1]).is_compatible(vs.Enum(0, [0, 1])))
     self.assertTrue(vs.Enum(0, [0, 1]).is_compatible(vs.Enum(0, [0])))
+    self.assertTrue(vs.Enum(0, [0, 'a']).is_compatible(vs.Int().freeze(0)))
+    self.assertTrue(vs.Enum(0, [0, 'a']).is_compatible(vs.Str().freeze('a')))
     self.assertFalse(vs.Enum(0, [0]).is_compatible(vs.Enum(0, [0, 1])))
     self.assertFalse(vs.Enum(0, [0]).is_compatible(vs.Int()))
 
@@ -814,7 +899,7 @@ class EnumTest(ValueSpecTest):
     self.assertEqual(v.default, 'a')
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Enum('c', ['a', 'b', 'c']).extend(v)
 
   def test_json_conversion(self):
@@ -942,6 +1027,12 @@ class ListTest(ValueSpecTest):
         'Either "size" or "min_size"/"max_size" pair can be specified.'):
       vs.List(vs.Int(), size=5, min_size=1)
 
+  def test_instantiation(self):
+    self.assertEqual(vs.List(vs.Int())([1]), [1])
+    self.assertEqual(vs.List(vs.Int())(), [])
+    self.assertIsNone(vs.List(vs.Int()).noneable()())
+    self.assertEqual(vs.List(vs.Int()).freeze([0])([]), [0])
+
   def test_apply(self):
     self.assertEqual(vs.List(vs.Int()).apply([]), [])
     self.assertEqual(vs.List(vs.Int()).apply([1]), [1])
@@ -1107,7 +1198,7 @@ class ListTest(ValueSpecTest):
     self.assertEqual(v.default, [1])
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.List(vs.Int()).extend(v)
 
     with self.assertRaisesRegex(
@@ -1301,6 +1392,12 @@ class TupleTest(ValueSpecTest):
         '<(type|class) \'int\'>.'):
       vs.Tuple([vs.Int()], default=1)
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Tuple(vs.Int())([1]), (1,))
+    self.assertEqual(vs.Tuple(vs.Int())(), ())
+    self.assertIsNone(vs.Tuple(vs.Int()).noneable()())
+    self.assertEqual(vs.Tuple(vs.Int()).freeze((0,))((1, 2)), (0,))
+
   def test_apply(self):
     self.assertEqual(vs.Tuple(vs.Int()).apply(tuple()), tuple())
     self.assertEqual(vs.Tuple(vs.Int()).apply((1, 1, 1)), (1, 1, 1))
@@ -1533,7 +1630,7 @@ class TupleTest(ValueSpecTest):
     self.assertEqual(v.default, (1,))
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Tuple(vs.Int()).extend(v)
 
     with self.assertRaisesRegex(
@@ -1756,6 +1853,12 @@ class DictTest(ValueSpecTest):
         'should be a dict of objects.'):
       vs.Dict([('key', 1, 'field 1', 123)])
 
+  def test_instantiation(self):
+    self.assertEqual(vs.Dict()(), {})
+    self.assertEqual(vs.Dict()({'x': 1, 2: 2}), {'x': 1, 2: 2})
+    self.assertEqual(vs.Dict()(x=1), dict(x=1))
+    self.assertEqual(vs.Dict({'a': int, 'b': 1})(a=1), dict(a=1, b=1))
+
   def test_apply(self):
     self.assertEqual(vs.Dict().apply({'a': 1}), {'a': 1})
     self.assertEqual(
@@ -2108,6 +2211,10 @@ class ObjectTest(ValueSpecTest):
         TypeError, '<(type|class) \'object\'> is too general for Object spec.'):
       vs.Object(object)
 
+  def test_instantiation(self):
+    self.assertIsInstance(vs.Object(self.A)(), self.A)
+    self.assertIsInstance(vs.Object(self.B)(1), self.B)
+
   def test_apply(self):
     a = self.A()
     self.assertEqual(vs.Object(self.A).apply(a), a)
@@ -2230,7 +2337,7 @@ class ObjectTest(ValueSpecTest):
     self.assertIs(v.default, b)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Object(self.A).extend(v)
 
     with self.assertRaisesRegex(
@@ -2427,6 +2534,10 @@ class CallableTest(ValueSpecTest):
         TypeError, '.* only take 0 positional arguments, while 1 is required'):
       vs.Callable([vs.Int()]).apply(f)
 
+  def test_instantiation(self):
+    with self.assertRaisesRegex(TypeError, '.* cannot be instantiated'):
+      vs.Callable()()
+
   def test_apply_on_callable_object(self):
 
     class CallableObject:
@@ -2652,7 +2763,7 @@ class CallableTest(ValueSpecTest):
     self.assertIs(v.default, f)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Callable().extend(v)
 
     with self.assertRaisesRegex(
@@ -2797,6 +2908,9 @@ class TypeTest(ValueSpecTest):
     self.assertNotEqual(
         vs.Type(Exception), vs.Type(Exception, default=ValueError))
 
+  def test_instantiate(self):
+    self.assertIs(vs.Type[str](), str)
+
   def test_apply(self):
     self.assertEqual(vs.Type(Exception).apply(Exception), Exception)
     self.assertEqual(vs.Type(Exception).apply(ValueError), ValueError)
@@ -2904,7 +3018,7 @@ class TypeTest(ValueSpecTest):
     self.assertIs(v.default, e)
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Type(Exception).extend(v)
 
     with self.assertRaisesRegex(
@@ -3111,6 +3225,12 @@ class UnionTest(ValueSpecTest):
         vs.Union([vs.Callable(), vs.Int()]).get_candidate(vs.Any()),
         vs.Callable())
 
+  def test_instantiate(self):
+    with self.assertRaisesRegex(
+        TypeError, '.* cannot be instantiated'
+    ):
+      vs.Union[int, str]()
+
   def test_apply(self):
     self.assertEqual(vs.Union([vs.Int(), vs.Str()]).apply(1), 1)
     self.assertEqual(
@@ -3261,7 +3381,7 @@ class UnionTest(ValueSpecTest):
     self.assertEqual(v.default, 'foo')
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec.'):
       vs.Str().extend(v)
 
     with self.assertRaisesRegex(
@@ -3343,6 +3463,10 @@ class AnyTest(ValueSpecTest):
     self.assertNotEqual(vs.Any(), vs.Int())
     self.assertNotEqual(vs.Any(True), vs.Any())
 
+  def test_instantiate(self):
+    with self.assertRaisesRegex(TypeError, '.* cannot be instantiated'):
+      vs.Any()()
+
   def test_apply(self):
     self.assertEqual(vs.Any().apply(True), True)
     self.assertEqual(vs.Any().apply(1), 1)
@@ -3392,7 +3516,7 @@ class AnyTest(ValueSpecTest):
     self.assertEqual(v.default, 'foo')
 
     with self.assertRaisesRegex(
-        TypeError, 'Cannot extend a frozen value spec.'):
+        TypeError, '.* cannot extend a frozen value spec'):
       vs.Any().extend(v)
 
     with self.assertRaisesRegex(

{pyglove-0.4.5.dev202412140808.dist-info → pyglove-0.4.5.dev202412160810.dist-info}/METADATA

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

{pyglove-0.4.5.dev202412140808.dist-info → pyglove-0.4.5.dev202412160810.dist-info}/RECORD

@@ -98,13 +98,13 @@ pyglove/core/symbolic/inferred.py,sha256=jGCKXLkYGDs-iUflR57UWrCrOQIpkpv5kHVyj-J
 pyglove/core/symbolic/inferred_test.py,sha256=G6uPykONcChvs6vZujXHSWaYfjewLTVBscMqzzKNty0,1270
 pyglove/core/symbolic/list.py,sha256=63v4Ph0FdkoCDj1FjwcmjUHGZSJLBLxaTKcGg7PdghE,30345
 pyglove/core/symbolic/list_test.py,sha256=yHYAJhe_EYwtU9p8eDztSXNBjnAGKe0UDN5U6S-xDr8,60627
-pyglove/core/symbolic/object.py,sha256=oSb5pNxQDdvrjCFYsWARa8NkQxWIjdCo9lTbETiVQ38,42335
-pyglove/core/symbolic/object_test.py,sha256=hM4XD4vCyVL8rcvf0XcpYT1ROq_fLJuPOX49FbwLPOI,93081
+pyglove/core/symbolic/object.py,sha256=VL_Q8KpuwmLEgjagwTBBzBin9gLxQGkM8L48-WW2NIg,42761
+pyglove/core/symbolic/object_test.py,sha256=qiVtQchArGwGt4D0GsL8xVVHA7GQlf-7NplNBLRMBzA,93609
 pyglove/core/symbolic/origin.py,sha256=5bH1jZvFHY5jwku32vDm8Bj2i-buv-YNuzOOsA5GlSA,6177
 pyglove/core/symbolic/origin_test.py,sha256=dU_ZGrGDetM_lYVMn3wQO0d367_t_t8eESe3NrKPBNE,3159
 pyglove/core/symbolic/pure_symbolic.py,sha256=FVq-5Cg5uZe3ybTIrTqTHIEJIpje0oxzV2kKL6UKlsU,3244
-pyglove/core/symbolic/ref.py,sha256=Kf2QKRBi4uP7Ql4zL8hh6Le1fUWTo5c0kiGzg06ZpAQ,8204
-pyglove/core/symbolic/ref_test.py,sha256=ZQV7qb6LGnLyyYgY1fL86rfMZ6T3uy_leQDAd2Bd5Tc,5890
+pyglove/core/symbolic/ref.py,sha256=4RQcdgP4WBW1HnHeeOriZHL37PCArjUrx6o48Ve-Ilc,8522
+pyglove/core/symbolic/ref_test.py,sha256=0687hClfR5G5_VKuRlwjJGVQ2MC74ADFWklDaZ3aEVI,6294
 pyglove/core/symbolic/symbolize.py,sha256=ohID9-V8QiFe7OMpPlRomiqUnKBVMpypd8ZuMuHaa4s,6582
 pyglove/core/symbolic/symbolize_test.py,sha256=o7bRfMhGc6uw2FIH8arE99-bPb3i0YixcHYyiP-QqeQ,6487
 pyglove/core/tuning/__init__.py,sha256=JtXpjsBto01fLf55hZ1dSx-CEZUyVQeyRP9AMH_hw8c,2229
@@ -119,13 +119,13 @@ pyglove/core/tuning/sample_test.py,sha256=JqwDPy3EPC_VjU9dipk90jj1kovZB3Zb9hAjAl
 pyglove/core/typing/__init__.py,sha256=Z_jnwUvDQ3wA16a5TiuWbuof9hW0Xm6YoTNwgG4QGqI,14395
 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=lNqyccuQaGhcxxFm4DkYPcUol2VURWZpgQGQhHfx4nw,8815
-pyglove/core/typing/annotation_conversion_test.py,sha256=xbpmpA9sjvDEV2n8TXTJiTQ2V9M-XOmxXzba_Rg_MZU,11483
+pyglove/core/typing/annotation_conversion.py,sha256=rNYOyC0ury-kiDpxRqABz-E3ll7ryq9MwLBE0vzDxyw,9028
+pyglove/core/typing/annotation_conversion_test.py,sha256=tZheqbLWbr76WBIDOplLtY3yznMc4m9u7KCznWEJdEs,11660
 pyglove/core/typing/callable_ext.py,sha256=1OM770LhT46qjhriKEgyDHp6whAGG0inobPbFUM2J8k,9218
 pyglove/core/typing/callable_ext_test.py,sha256=TnWKU4_ZjvpbHZFtFHgFvCMDiCos8VmLlODcM_7Xg8M,10156
 pyglove/core/typing/callable_signature.py,sha256=MAH7isqhxXp8QdMw8jqxqWbsKs2jMh7uJlFIBL0tTQk,27242
 pyglove/core/typing/callable_signature_test.py,sha256=BYdn0i7nd0ITkACnR1RNtnmpXiE0MfpBrlQ7-yWSxYE,25223
-pyglove/core/typing/class_schema.py,sha256=XFGLidRQ_B_x6Va57ml89_zgkEj-4a4bHXSpHPMgZKE,53153
+pyglove/core/typing/class_schema.py,sha256=ls_pg4MgwvV4s5gLnsjqDkiP3O2Fg0sWdjL1NVD-iyE,53273
 pyglove/core/typing/class_schema_test.py,sha256=1DvJTss20jzjruTnB4CuW6ozO6Hcs6TIN-xsJzEQkCM,29244
 pyglove/core/typing/custom_typing.py,sha256=w5gdx7JbHmAJfrUKLvonW9rI2gpCwMJo2wdF4yqarLI,2218
 pyglove/core/typing/inspect.py,sha256=Tp2rYqRvMFvL0NzkJo4p04_hQSF__Eip8RduhEaSFfE,7046
@@ -137,8 +137,8 @@ pyglove/core/typing/type_conversion.py,sha256=mOkp2LP2O9C5k8Q6r-CFwk9P_-oy4u26DI
 pyglove/core/typing/type_conversion_test.py,sha256=AH7HTOfWcF7cpWi49EG6UmB_xfCsdz7HS1U0Bg8o-PI,5295
 pyglove/core/typing/typed_missing.py,sha256=5lzkrd-DqJDT8eoW1d8p6mxV3mvy5X78zFon7qEqPIA,2784
 pyglove/core/typing/typed_missing_test.py,sha256=3k_s0JBYBJ_6xoOuPSMrQzqas6QHD0PHux0T9NlTBZc,2381
-pyglove/core/typing/value_specs.py,sha256=V6m4RhCc4yi6H8X1LoptSk5gsa7ko8HgLYDSfVsMBtQ,99874
-pyglove/core/typing/value_specs_test.py,sha256=kKwoEmGIXtM5JikhtbhcE4Ds-wSyYAsMTozHVa2Lpbc,122707
+pyglove/core/typing/value_specs.py,sha256=D59ZB8L4HALtljzVkiLG9R2Uxg3bViDyc9Ebsr1fBH8,102276
+pyglove/core/typing/value_specs_test.py,sha256=XY_txldanc5lycz0WgDhtn2XcO3nFo_ymlKLjgN18Mg,127258
 pyglove/core/views/__init__.py,sha256=gll9ZBRYz4p_-LWOdzSR2a6UTWcJ8nR430trrP0yLCU,967
 pyglove/core/views/base.py,sha256=Eq94AM5lryQ1IKuQsTSb7ZzX-lp2nhuOnS4ztMnCPIM,26447
 pyglove/core/views/base_test.py,sha256=UKbr_1TANOAnP7V5ICGF0UEkunfSaHiJ4nXZXhA0SaU,16642
@@ -196,8 +196,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.dev202412140808.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.4.5.dev202412140808.dist-info/METADATA,sha256=R1KlgVeQR7K4-f-7x29aAwp9fQmUdlmR7Z1P1HIPMxY,6828
-pyglove-0.4.5.dev202412140808.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-pyglove-0.4.5.dev202412140808.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.4.5.dev202412140808.dist-info/RECORD,,
+pyglove-0.4.5.dev202412160810.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.4.5.dev202412160810.dist-info/METADATA,sha256=PkzGA4zFYMds7iJaQIs0dgq7A3yte__HQHsdnWQAEKA,6828
+pyglove-0.4.5.dev202412160810.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+pyglove-0.4.5.dev202412160810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.4.5.dev202412160810.dist-info/RECORD,,