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

pyglove/core/symbolic/dict_test.py

@@ -415,6 +415,19 @@ class DictTest(unittest.TestCase):
     with self.assertRaisesRegex(KeyError, 'Key \'y1\' is not allowed'):
       sd.y1 = 4
 
+  def test_get(self):
+    sd = Dict(a=1)
+    self.assertEqual(sd.get('a'), 1)
+    self.assertIsNone(sd.get('x'))
+    self.assertEqual(sd.get('x', 2), 2)
+
+    # Test inferred values.
+    sd = Dict(x=inferred.ValueFromParentChain())
+    self.assertIsNone(sd.get('x'))
+
+    _ = Dict(sd=sd, x=1)
+    self.assertEqual(sd.get('x'), 1)
+
   def test_getattr(self):
     sd = Dict(a=1)
     self.assertEqual(sd.a, 1)
@@ -713,6 +726,11 @@ class DictTest(unittest.TestCase):
     ]))
     self.assertEqual(list(sd.values()), [2, 1, 3])
 
+    # Test values with inferred values.
+    sd = Dict(x=1, y=inferred.ValueFromParentChain())
+    _ = Dict(sd=sd, y=2)
+    self.assertEqual(list(sd.values()), [1, 2])
+
   def test_items(self):
     sd = Dict(b={'c': True, 'd': []}, a=0)
     self.assertEqual(list(sd.items()), [('b', {'c': True, 'd': []}), ('a', 0)])
@@ -725,6 +743,11 @@ class DictTest(unittest.TestCase):
     ]))
     self.assertEqual(list(sd.items()), [('b', 2), ('a', 1), ('c', 3)])
 
+    # Test items with inferred values.
+    sd = Dict(x=1, y=inferred.ValueFromParentChain())
+    _ = Dict(sd=sd, y=2)
+    self.assertEqual(list(sd.items()), [('x', 1), ('y', 2)])
+
   def test_non_default(self):
     sd = Dict(a=1)
     self.assertEqual(len(sd.non_default_values()), 1)
@@ -923,6 +946,14 @@ class DictTest(unittest.TestCase):
         sd.sym_jsonify(),
         {'x': 1, 'y': inferred.ValueFromParentChain().to_json()},
     )
+    self.assertEqual(
+        sd.sym_jsonify(omit_symbolic_marker=False),
+        {
+            '__symbolic__': True,
+            'x': 1,
+            'y': inferred.ValueFromParentChain().to_json()
+        },
+    )
 
   def test_sym_rebind(self):
     # Refer to RebindTest for more detailed tests.
@@ -1941,6 +1972,24 @@ class SerializationTest(unittest.TestCase):
     self.assertEqual(sd.to_json_str(), '{"x": 1, "y": 2.0}')
     self.assertEqual(base.from_json_str(sd.to_json_str(), value_spec=spec), sd)
 
+  def test_auto_symbolic(self):
+    value = base.from_json({'x': 1}, auto_symbolic=True)
+    self.assertIsInstance(value, Dict)
+
+    value = base.from_json({'x': 1}, auto_symbolic=False)
+    self.assertNotIsInstance(value, Dict)
+
+  def test_omit_symbolic_marker(self):
+    sd = Dict(x=1)
+    self.assertEqual(sd.to_json(omit_symbolic_marker=True), {'x': 1})
+    self.assertEqual(
+        sd.to_json(omit_symbolic_marker=False),
+        {'__symbolic__': True, 'x': 1}
+    )
+    sd = base.from_json({'__symbolic__': True, 'x': 1}, auto_symbolic=False)
+    self.assertIsInstance(sd, Dict)
+    self.assertEqual(sd, {'x': 1})
+
   def test_hide_frozen(self):
 
     class A(pg_object.Object):

pyglove/core/symbolic/list.py

@@ -137,6 +137,9 @@ class List(list, base.Symbolic, pg_typing.CustomTyping):
     Returns:
       A schema-less symbolic list, but its items maybe symbolic.
     """
+    # Remove symbolic marker if present.
+    if json_value and json_value[0] == utils.JSONConvertible.SYMBOLIC_MARKER:
+      json_value.pop(0)
     return cls(
         [
             base.from_json(
@@ -770,15 +773,26 @@ class List(list, base.Symbolic, pg_typing.CustomTyping):
     return (proceed_with_standard_apply, self)
 
   def sym_jsonify(
-      self, use_inferred: bool = False, **kwargs
+      self,
+      use_inferred: bool = False,
+      omit_symbolic_marker: bool = True,
+      **kwargs
   ) -> utils.JSONValueType:
     """Converts current list to a list of plain Python objects."""
     def json_item(idx):
       v = self.sym_getattr(idx)
       if use_inferred and isinstance(v, base.Inferential):
         v = self.sym_inferred(idx, default=v)
-      return base.to_json(v, use_inferred=use_inferred, **kwargs)
-    return [json_item(i) for i in range(len(self))]
+      return base.to_json(
+          v,
+          use_inferred=use_inferred,
+          omit_symbolic_marker=omit_symbolic_marker,
+          **kwargs
+      )
+    json_value = [json_item(i) for i in range(len(self))]
+    if not omit_symbolic_marker:
+      json_value.insert(0, utils.JSONConvertible.SYMBOLIC_MARKER)
+    return json_value
 
   def format(
       self,

pyglove/core/symbolic/list_test.py

@@ -506,8 +506,7 @@ class ListTest(unittest.TestCase):
   def test_index(self):
     sl = List([0, 1, 2, 1])
     self.assertEqual(sl.index(1), 1)
-    with self.assertRaisesRegex(
-        ValueError, '3 is not in list'):
+    with self.assertRaisesRegex(ValueError, '.* not in list'):
       _ = sl.index(3)
 
     # Index of inferred value is based on its symbolic form.
@@ -799,6 +798,10 @@ class ListTest(unittest.TestCase):
     self.assertEqual(
         sl.sym_jsonify(), [0, inferred.ValueFromParentChain().to_json()]
     )
+    self.assertEqual(
+        sl.sym_jsonify(omit_symbolic_marker=False),
+        ['__symbolic__', 0, inferred.ValueFromParentChain().to_json()]
+    )
 
   def test_sym_rebind(self):
     # Refer to RebindTest for more detailed tests.
@@ -1633,6 +1636,25 @@ class SerializationTest(unittest.TestCase):
         'Tuple should have at least one element besides \'__tuple__\'.'):
       base.from_json_str('["__tuple__"]')
 
+  def test_auto_symbolic(self):
+    value = base.from_json([1, 2, 3], auto_symbolic=True)
+    self.assertIsInstance(value, List)
+
+    value = base.from_json([1, 2, 3], auto_symbolic=False)
+    self.assertNotIsInstance(value, List)
+
+  def test_omit_symbolic_marker(self):
+    sl = List([0])
+    self.assertEqual(sl.to_json(omit_symbolic_marker=True), [0])
+    self.assertEqual(
+        sl.to_json(omit_symbolic_marker=False),
+        ['__symbolic__', 0]
+    )
+    sl = base.from_json(['__symbolic__', 0], auto_symbolic=False)
+    self.assertEqual(sl.to_json(omit_symbolic_marker=True), [0])
+    self.assertIsInstance(sl, List)
+    self.assertEqual(sl, [0])
+
   def test_hide_default_values(self):
     sl = List.partial(
         [dict(x=1)],

pyglove/core/symbolic/object.py

@@ -339,7 +339,8 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
 
     # Set `__serialization_key__` before JSONConvertible.__init_subclass__
     # is called.
-    setattr(cls, '__serialization_key__', cls.__type_name__)
+    if '__serialization_key__' not in cls.__dict__:
+      setattr(cls, '__serialization_key__', cls.__type_name__)
 
     super().__init_subclass__()
 
@@ -994,6 +995,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
             self.__class__.__serialization_key__
         )
     }
+    kwargs['omit_symbolic_marker'] = True
     json_dict.update(self._sym_attributes.to_json(**kwargs))
     return json_dict
 

pyglove/core/symbolic/object_test.py

@@ -38,6 +38,7 @@ from pyglove.core.symbolic.object import use_init_args as pg_use_init_args
 from pyglove.core.symbolic.origin import Origin
 from pyglove.core.symbolic.pure_symbolic import NonDeterministic
 from pyglove.core.symbolic.pure_symbolic import PureSymbolic
+from pyglove.core.symbolic.unknown_symbols import UnknownTypedObject
 from pyglove.core.views.html import tree_view  # pylint: disable=unused-import
 
 
@@ -3158,7 +3159,7 @@ class SerializationTest(unittest.TestCase):
             Q.partial(P.partial()).to_json_str(), allow_partial=True),
         Q.partial(P.partial()))
 
-  def test_serialization_with_auto_dict(self):
+  def test_serialization_with_convert_unknown(self):
 
     class P(Object):
       auto_register = False
@@ -3181,15 +3182,17 @@ class SerializationTest(unittest.TestCase):
         }
     )
     self.assertEqual(
-        base.from_json_str(Q(P(1), y='foo').to_json_str(), auto_dict=True),
-        {
-            'p': {
-                'type_name': P.__type_name__,
-                'x': 1
-            },
-            'y': 'foo',
-            'type_name': Q.__type_name__,
-        }
+        base.from_json_str(
+            Q(P(1), y='foo').to_json_str(), convert_unknown=True
+        ),
+        UnknownTypedObject(
+            type_name=Q.__type_name__,
+            p=UnknownTypedObject(
+                type_name=P.__type_name__,
+                x=1
+            ),
+            y='foo'
+        )
     )
 
   def test_serialization_with_converter(self):

pyglove/core/symbolic/ref.py

@@ -138,9 +138,7 @@ class Ref(
     del child_transform
     # Check if the field being assigned could accept the referenced value.
     # We do not do any transformation, thus not passing the child transform.
-    value_spec.apply(
-        self._value,
-        allow_partial=allow_partial)
+    value_spec.apply(self._value, allow_partial=allow_partial)
     return (False, self)
 
   def _sym_clone(self, deep: bool, memo: Any = None) -> 'Ref':
@@ -152,10 +150,24 @@ class Ref(
   def sym_eq(self, other: Any) -> bool:
     return isinstance(other, Ref) and self.value is other.value
 
-  def sym_jsonify(self, *, save_ref_value: bool = False, **kwargs: Any) -> Any:
-    if save_ref_value:
-      return base.to_json(self._value, save_ref_value=save_ref_value, **kwargs)
-    raise TypeError(f'{self!r} cannot be serialized at the moment.')
+  def sym_jsonify(
+      self,
+      *,
+      context: utils.JSONConversionContext,
+      **kwargs: Any
+  ) -> Any:
+    # Disable auto_symbolic for Ref value. This allows Ref to create a sub-tree
+    # for reference sharing.
+    kwargs['omit_symbolic_marker'] = False
+    return {
+        utils.JSONConvertible.TYPE_NAME_KEY: self.__class__.__type_name__,
+        'value': context.serialize_maybe_shared(self._value, **kwargs)
+    }
+
+  @classmethod
+  def from_json(cls, json: Any, **kwargs):
+    kwargs['auto_symbolic'] = False
+    return super().from_json(json, **kwargs)
 
   def __getstate__(self):
     raise TypeError(f'{self!r} cannot be pickled at the moment.')

pyglove/core/symbolic/ref_test.py

@@ -21,8 +21,11 @@ from typing import Any
 import unittest
 
 from pyglove.core import typing as pg_typing
+from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
 from pyglove.core.symbolic import ref
 from pyglove.core.symbolic.base import contains
+from pyglove.core.symbolic.base import from_json
+from pyglove.core.symbolic.base import to_json
 from pyglove.core.symbolic.dict import Dict
 from pyglove.core.symbolic.object import Object
 
@@ -33,6 +36,10 @@ class A(Object):
 
 class RefTest(unittest.TestCase):
 
+  def setUp(self):
+    super().setUp()
+    self.maxDiff = None
+
   def test_basics(self):
 
     a = A(1)
@@ -109,14 +116,94 @@ class RefTest(unittest.TestCase):
         """))
 
   def test_to_json(self):
-    with self.assertRaisesRegex(
-        TypeError, '.* cannot be serialized at the moment'):
-      ref.Ref(A(1)).to_json()
+    class B(Object):
+      y: Any
 
-    self.assertEqual(
-        ref.Ref(A(1)).to_json(save_ref_value=True),
-        A(1).to_json()
-    )
+    a = A(1)
+    r1 = ref.Ref(a)
+    r2 = ref.Ref({'z': a})
+    r3 = ref.Ref(Dict(t=r1, p=r2))
+    v = Dict(a=r1, b=[B(r2), [r3], r1])
+    self.assertIs(v.a, v.b[0].y['z'])
+    self.assertIs(v.a, v.b[1][0].t)
+    self.assertIs(v.b[0].y, v.b[1][0].p)
+    self.assertIs(v.a, v.b[2])
+    self.assertIsInstance(v, dict)
+    self.assertIsInstance(v.b[0].y, dict)
+    self.assertNotIsInstance(v.b[0].y, Dict)
+    self.assertIsInstance(v.b[1][0], Dict)
+
+    json = to_json(v)
+    expected = {
+        '__context__': {
+            'shared_objects': [
+                {
+                    '_type': A.__type_name__,
+                    'x': 1
+                },
+                {
+                    'z': {
+                        '__ref__': 0
+                    }
+                }
+            ]
+        },
+        '__root__': {
+            'a': {
+                '_type': ref.Ref.__type_name__,
+                'value': {
+                    '__ref__': 0
+                }
+            },
+            'b': [
+                {
+                    '_type': B.__type_name__,
+                    'y': {
+                        '_type': ref.Ref.__type_name__,
+                        'value': {
+                            '__ref__': 1
+                        }
+                    }
+                },
+                [
+                    {
+                        '_type': ref.Ref.__type_name__,
+                        'value': {
+                            '__symbolic__': True,
+                            't': {
+                                '_type': ref.Ref.__type_name__,
+                                'value': {
+                                    '__ref__': 0
+                                }
+                            },
+                            'p': {
+                                '_type': ref.Ref.__type_name__,
+                                'value': {
+                                    '__ref__': 1
+                                }
+                            }
+                        }
+                    }
+                ],
+                {
+                    '_type': ref.Ref.__type_name__,
+                    'value': {
+                        '__ref__': 0
+                    }
+                }
+            ]
+        }
+    }
+    self.assertEqual(json, expected)
+    v = from_json(json)
+    self.assertIs(v.a, v.b[0].y['z'])
+    self.assertIs(v.a, v.b[1][0].t)
+    self.assertIs(v.b[0].y, v.b[1][0].p)
+    self.assertIs(v.a, v.b[2])
+    self.assertIsInstance(v, dict)
+    self.assertIsInstance(v.b[0].y, dict)
+    self.assertNotIsInstance(v.b[0].y, Dict)
+    self.assertIsInstance(v.b[1][0], Dict)
 
   def test_pickle(self):
     with self.assertRaisesRegex(

pyglove/core/symbolic/unknown_symbols.py

@@ -0,0 +1,147 @@
+# Copyright 2021 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Symbolic types for reprenting unknown types and objects."""
+
+from typing import Annotated, Any, ClassVar, Literal
+from pyglove.core import typing as pg_typing
+from pyglove.core import utils
+from pyglove.core.symbolic import list as pg_list  # pylint: disable=unused-import
+from pyglove.core.symbolic import object as pg_object
+
+
+class UnknownSymbol(pg_object.Object, pg_typing.CustomTyping):
+  """Interface for symbolic representation of unknown symbols."""
+  auto_register = False
+
+  def custom_apply(self, *args, **kwargs) -> tuple[bool, Any]:
+    """Bypass PyGlove type check."""
+    return (False, self)
+
+
+class UnknownType(UnknownSymbol):
+  """Symbolic object for representing unknown types."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_type'
+
+  # TODO(daiyip): Revisit the design on how `pg.typing.Object()` handles
+  # UnknownType. This hacky solution should be removed in the future.
+  __no_type_check__ = True
+
+  name: str
+  args: list[Any] = []
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    json_dict = {'_type': 'type', 'name': self.name}
+    if self.args:
+      json_dict['args'] = utils.to_json(self.args, **kwargs)
+    return json_dict
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    s = f'<unknown-type {self.name}>'
+    if self.args:
+      s += f'[{", ".join(repr(x) for x in self.args)}]'
+    return s
+
+  def __call__(self, **kwargs):
+    return UnknownTypedObject(
+        type_name=self.name, **kwargs
+    )
+
+
+class UnknownCallable(UnknownSymbol):
+  """Symbolic object for representing unknown callables."""
+
+  auto_register = False
+  name: str
+  CALLABLE_TYPE: ClassVar[Literal['function', 'method']]
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    return {'_type': self.CALLABLE_TYPE, 'name': self.name}
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    return f'<unknown-{self.CALLABLE_TYPE} {self.name}>'
+
+
+class UnknownFunction(UnknownCallable):
+  """Symbolic objject for representing unknown functions."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_function'
+  CALLABLE_TYPE = 'function'
+
+
+class UnknownMethod(UnknownCallable):
+  """Symbolic object for representing unknown methods."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_method'
+  CALLABLE_TYPE = 'method'
+
+
+class UnknownTypedObject(UnknownSymbol):
+  """Symbolic object for representing objects of unknown-type."""
+
+  auto_register = True
+  __serialization_key__ = 'unknown_object'
+
+  type_name: str
+  __kwargs__: Annotated[
+      Any,
+      (
+          'Fields of the original object will be kept as symbolic attributes '
+          'of this object so they can be accessed through `__getattr__`.'
+      )
+  ]
+
+  def sym_jsonify(self, **kwargs) -> utils.JSONValueType:
+    """Converts current object to a dict of plain Python objects."""
+    json_dict = self._sym_attributes.to_json(
+        exclude_keys=set(['type_name']), **kwargs
+    )
+    assert isinstance(json_dict, dict)
+    json_dict[utils.JSONConvertible.TYPE_NAME_KEY] = self.type_name
+    return json_dict
+
+  def format(
+      self,
+      compact: bool = False,
+      verbose: bool = True,
+      root_indent: int = 0,
+      **kwargs
+  ) -> str:
+    exclude_keys = kwargs.pop('exclude_keys', set())
+    exclude_keys.add('type_name')
+    kwargs['exclude_keys'] = exclude_keys
+    return self._sym_attributes.format(
+        compact,
+        verbose,
+        root_indent,
+        cls_name=f'<unknown-type {self.type_name}>',
+        key_as_attribute=True,
+        bracket_type=utils.BracketType.ROUND,
+        **kwargs,
+    )

pyglove/core/symbolic/unknown_symbols_test.py

@@ -0,0 +1,100 @@
+# Copyright 2025 The PyGlove Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+from pyglove.core import utils
+from pyglove.core.symbolic import unknown_symbols
+
+
+class UnknownTypeTest(unittest.TestCase):
+
+  def test_basics(self):
+    t = unknown_symbols.UnknownType(name='__main__.ABC', args=[int, str])
+    self.assertEqual(t.name, '__main__.ABC')
+    self.assertEqual(t.args, [int, str])
+    self.assertEqual(
+        repr(t),
+        '<unknown-type __main__.ABC>[<class \'int\'>, <class \'str\'>]'
+    )
+    self.assertEqual(
+        t.to_json(),
+        {
+            '_type': 'type',
+            'name': '__main__.ABC',
+            'args': [
+                {'_type': 'type', 'name': 'builtins.int'},
+                {'_type': 'type', 'name': 'builtins.str'},
+            ]
+        }
+    )
+    self.assertEqual(utils.from_json(t.to_json(), convert_unknown=True), t)
+    self.assertEqual(
+        t(x=1, y=2),
+        unknown_symbols.UnknownTypedObject(type_name='__main__.ABC', x=1, y=2)
+    )
+
+
+class UnknownFunctionTest(unittest.TestCase):
+
+  def test_basics(self):
+    t = unknown_symbols.UnknownFunction(name='__main__.foo')
+    self.assertEqual(t.name, '__main__.foo')
+    self.assertEqual(repr(t), '<unknown-function __main__.foo>')
+    self.assertEqual(
+        t.to_json(),
+        {
+            '_type': 'function',
+            'name': '__main__.foo',
+        }
+    )
+    self.assertEqual(utils.from_json(t.to_json(), convert_unknown=True), t)
+
+
+class UnknownMethodTest(unittest.TestCase):
+
+  def test_basics(self):
+    t = unknown_symbols.UnknownMethod(name='__main__.ABC.bar')
+    self.assertEqual(t.name, '__main__.ABC.bar')
+    self.assertEqual(repr(t), '<unknown-method __main__.ABC.bar>')
+    self.assertEqual(
+        t.to_json(),
+        {
+            '_type': 'method',
+            'name': '__main__.ABC.bar',
+        }
+    )
+    self.assertEqual(utils.from_json(t.to_json(), convert_unknown=True), t)
+
+
+class UnknownObjectTest(unittest.TestCase):
+
+  def test_basics(self):
+    v = unknown_symbols.UnknownTypedObject(type_name='__main__.ABC', x=1)
+    self.assertEqual(v.type_name, '__main__.ABC')
+    self.assertEqual(v.x, 1)
+    self.assertEqual(repr(v), '<unknown-type __main__.ABC>(x=1)')
+    self.assertEqual(
+        str(v), '<unknown-type __main__.ABC>(\n  x = 1\n)')
+    self.assertEqual(
+        v.to_json(),
+        {
+            '_type': '__main__.ABC',
+            'x': 1,
+        }
+    )
+    self.assertEqual(utils.from_json(v.to_json(), convert_unknown=True), v)
+
+
+if __name__ == '__main__':
+  unittest.main()

pyglove/core/typing/annotation_conversion.py

@@ -16,6 +16,7 @@
 import builtins
 import collections
 import inspect
+import sys
 import types
 import typing
 
@@ -197,6 +198,8 @@ def annotation_from_str(
   def _resolve(type_id: str):
 
     def _as_forward_ref() -> typing.ForwardRef:
+      if sys.version_info >= (3, 14):
+        return typing.ForwardRef(type_id)  # pytype: disable=not-callable
       return typing.ForwardRef(type_id, False, parent_module)  # pytype: disable=not-callable
 
     def _resolve_name(name: str, parent_obj: typing.Any):
@@ -318,6 +321,9 @@ def _value_spec_from_type_annotation(
     parent_module: typing.Optional[types.ModuleType] = None
 ) -> class_schema.ValueSpec:
   """Creates a value spec from type annotation."""
+  if isinstance(annotation, class_schema.ValueSpec):
+    return annotation
+
   if isinstance(annotation, str) and not accept_value_as_annotation:
     annotation = annotation_from_str(annotation, parent_module)
 
@@ -454,7 +460,8 @@ def _value_spec_from_annotation(
   """Creates a value spec from annotation."""
   if isinstance(annotation, class_schema.ValueSpec):
     return annotation
-  elif annotation == inspect.Parameter.empty:
+
+  if annotation == inspect.Parameter.empty:
     return vs.Any()
 
   if annotation is None: