pyglove 0.4.5.dev202505010810__py3-none-any.whl → 0.4.5.dev202505030808__py3-none-any.whl

pyglove/core/typing/__init__.py

@@ -394,6 +394,9 @@ from pyglove.core.typing.callable_ext import enable_preset_args
 from pyglove.core.typing.callable_ext import preset_args
 from pyglove.core.typing.callable_ext import CallableWithOptionalKeywordArgs
 
+# JSON schema conversion.
+from pyglove.core.typing.json_schema import to_json_schema
+
 # PyType support.
 from pyglove.core.typing.pytype_support import *
 

pyglove/core/typing/class_schema.py

@@ -571,6 +571,17 @@ class ValueSpec(utils.Formattable, utils.JSONConvertible):
     del annotation, auto_typing, accept_value_as_annotation, parent_module
     assert False, 'Overridden in `annotation_conversion.py`.'
 
+  def to_json_schema(
+      self,
+      include_type_name: bool = True,
+      include_subclasses: bool = False,
+      inline_nested_refs: bool = False,
+      **kwargs
+  ) -> Dict[str, Any]:
+    """Converts this field to JSON schema."""
+    del include_type_name, include_subclasses, inline_nested_refs, kwargs
+    assert False, 'Overridden in `json_schema.py`.'
+
 
 class Field(utils.Formattable, utils.JSONConvertible):
   """Class that represents the definition of one or a group of attributes.
@@ -1344,6 +1355,18 @@ class Schema(utils.Formattable, utils.JSONConvertible):
         **kwargs,
     )
 
+  def to_json_schema(
+      self,
+      *,
+      include_type_name: bool = True,
+      include_subclasses: bool = False,
+      inline_nested_refs: bool = False,
+      **kwargs
+  ) -> Dict[str, Any]:
+    """Converts this field to JSON schema."""
+    del include_type_name, include_subclasses, inline_nested_refs, kwargs
+    assert False, 'Overridden in `json_schema.py`.'
+
   def __eq__(self, other: Any) -> bool:
     if self is other:
       return True

pyglove/core/typing/json_schema.py

@@ -0,0 +1,340 @@
+# 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.
+"""PyGlove typing to JSON schema conversion."""
+
+import dataclasses
+import inspect
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from pyglove.core import utils
+from pyglove.core.typing import callable_signature
+from pyglove.core.typing import class_schema
+from pyglove.core.typing import key_specs as ks
+from pyglove.core.typing import value_specs as vs
+
+
+@dataclasses.dataclass
+class _DefEntry:
+  definition: Optional[Dict[str, Any]]
+  num_references: int = 0
+
+
+def _json_schema_from_schema(
+    schema: class_schema.Schema,
+    *,
+    defs: Dict[str, _DefEntry],
+    type_name: Optional[str] = None,
+    include_type_name: bool = True,
+    include_subclasses: bool = False,
+) -> Dict[str, Any]:
+  """Converts a PyGlove schema to JSON schema."""
+  title = schema.name.split('.')[-1] if schema.name else None
+  entry = defs.get(title)
+  if entry is None:
+    # NOTE(daiyip): Add a forward reference to the entry so recursive
+    # references can be resolved.
+    entry = _DefEntry(definition=None, num_references=0)
+    if title:
+      defs[title] = entry
+
+    additional_properties = False
+    properties = {}
+    required = []
+
+    if type_name and include_type_name:
+      properties['_type'] = {'const': type_name}
+      required.append('_type')
+
+    for key, field in schema.items():
+      if isinstance(key, ks.ConstStrKey):
+        prop = _json_schema_from_value_spec(
+            field.value, defs=defs
+        )
+        if field.description:
+          prop['description'] = field.description
+        properties[key.text] = prop
+        if not field.value.has_default:
+          required.append(key.text)
+      else:
+        if isinstance(field.value, vs.Any):
+          additional_properties = True
+        else:
+          additional_properties = _json_schema_from_value_spec(
+              field.value, defs=defs,
+              include_type_name=include_type_name,
+              include_subclasses=include_subclasses,
+          )
+    entry.definition = _dict_with_optional_fields([
+        ('type', 'object', None),
+        ('title', title, None),
+        ('description', schema.description, None),
+        ('properties', properties, {}),
+        ('required', required, []),
+        ('additionalProperties', additional_properties, None),
+    ])
+
+  entry.num_references += 1
+  if title:
+    return {'$ref': f'#/$defs/{title}'}
+  else:
+    assert entry.definition is not None
+    return entry.definition   # pytype: disable=bad-return-type
+
+
+def _json_schema_from_value_spec(
+    value_spec: vs.ValueSpec,
+    *,
+    defs: Dict[str, _DefEntry],
+    include_type_name: bool = True,
+    include_subclasses: bool = False,
+    ignore_nonable: bool = False,
+) -> Dict[str, Any]:
+  """Converts a value spec to JSON schema."""
+  def _child_json_schema(v: vs.ValueSpec, ignore_nonable: bool = False):
+    return _json_schema_from_value_spec(
+        v, defs=defs,
+        include_type_name=include_type_name,
+        include_subclasses=include_subclasses,
+        ignore_nonable=ignore_nonable
+    )
+
+  if isinstance(value_spec, vs.Bool):
+    definition = {
+        'type': 'boolean'
+    }
+  elif isinstance(value_spec, vs.Int):
+    definition = _dict_with_optional_fields([
+        ('type', 'integer', None),
+        ('minimum', value_spec.min_value, None),
+        ('maximum', value_spec.max_value, None),
+    ])
+  elif isinstance(value_spec, vs.Float):
+    definition = _dict_with_optional_fields([
+        ('type', 'number', None),
+        ('minimum', value_spec.min_value, None),
+        ('maximum', value_spec.max_value, None),
+    ])
+  elif isinstance(value_spec, vs.Str):
+    definition = _dict_with_optional_fields([
+        ('type', 'string', None),
+        ('pattern', getattr(value_spec.regex, 'pattern', None), None)
+    ])
+  elif isinstance(value_spec, vs.Enum):
+    for v in value_spec.values:
+      if not isinstance(v, (str, bool, int, float, type(None))):
+        raise ValueError(
+            f'Enum candidate {v!r} is not supported for JSON schema generation.'
+        )
+    definition = {
+        'enum': [v for v in value_spec.values if v is not None],
+    }
+  elif isinstance(value_spec, vs.List):
+    definition = {
+        'type': 'array',
+    }
+    if not isinstance(value_spec.element.value, vs.Any):
+      definition['items'] = _child_json_schema(value_spec.element.value)
+    return definition
+  elif isinstance(value_spec, vs.Dict):
+    if value_spec.schema is None:
+      definition = {
+          'type': 'object',
+          'additionalProperties': True
+      }
+    else:
+      definition = _json_schema_from_schema(
+          value_spec.schema, defs=defs, include_type_name=include_type_name
+      )
+  elif isinstance(value_spec, vs.Object):
+    def _json_schema_from_cls(cls: type[Any]):
+      schema = getattr(cls, '__schema__', None)
+      if schema is None:
+        schema = callable_signature.signature(cls).to_schema()
+      return _json_schema_from_schema(
+          schema,
+          defs=defs,
+          type_name=getattr(cls, '__type_name__', None),
+          include_type_name=include_type_name,
+          include_subclasses=include_subclasses,
+      )
+    definitions = [
+        _json_schema_from_cls(value_spec.cls)
+    ]
+
+    if include_subclasses:
+      for subclass in value_spec.cls.__subclasses__():
+        if not inspect.isabstract(subclass):
+          definitions.append(_json_schema_from_cls(subclass))
+
+    if len(definitions) == 1:
+      definition = definitions[0]
+    else:
+      definition = {'anyOf': _normalize_anyofs(definitions)}
+  elif isinstance(value_spec, vs.Union):
+    definition = {
+        'anyOf': _normalize_anyofs([
+            _child_json_schema(v, ignore_nonable=True)
+            for v in value_spec.candidates
+        ])
+    }
+  elif isinstance(value_spec, vs.Any):
+    # Consider using return {}
+    definition = {
+        'anyOf': [
+            _child_json_schema(v) for v in [
+                vs.Bool(),
+                vs.Float(),
+                vs.Str(),
+                vs.List(vs.Any()),
+                vs.Dict(),
+            ]
+        ]
+    }
+  else:
+    raise TypeError(
+        f'Value spec {value_spec!r} cannot be converted to JSON schema.'
+    )
+
+  if not ignore_nonable and value_spec.is_noneable:
+    nullable = {'type': 'null'}
+    if 'anyOf' in definition:
+      definition['anyOf'].append(nullable)
+    else:
+      definition = {'anyOf': [definition, nullable]}
+  return definition
+
+
+def _normalize_anyofs(candidates: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+  flattened = []
+  for candidate in candidates:
+    if 'anyOf' in candidate:
+      flattened.extend(_normalize_anyofs(candidate['anyOf']))
+    else:
+      flattened.append(candidate)
+  return flattened
+
+
+def _dict_with_optional_fields(
+    pairs: List[Tuple[str, Any, Any]]
+) -> Dict[str, Any]:
+  return {
+      k: v for k, v, default in pairs if v != default
+  }
+
+
+def to_json_schema(
+    value: Union[vs.ValueSpec, class_schema.Schema, Any],
+    *,
+    include_type_name: bool = True,
+    include_subclasses: bool = False,
+    inline_nested_refs: bool = False,
+) -> Dict[str, Any]:
+  """Converts a value spec to JSON schema."""
+  defs = dict()
+  if isinstance(value, class_schema.Schema):
+    root = _json_schema_from_schema(
+        value, defs=defs,
+        type_name=value.name,
+        include_type_name=include_type_name,
+        include_subclasses=include_subclasses,
+    )
+  else:
+    value = vs.ValueSpec.from_annotation(value, auto_typing=True)
+    root = _json_schema_from_value_spec(
+        value,
+        defs=defs,
+        include_type_name=include_type_name,
+        include_subclasses=include_subclasses,
+    )
+  return _canonicalize_schema(root, defs, inline_nested_refs=inline_nested_refs)
+
+
+def _canonicalize_schema(
+    root: Dict[str, Any],
+    defs: Dict[str, _DefEntry],
+    *,
+    inline_nested_refs: bool = True,
+    include_defs: bool = True,
+) -> Dict[str, Any]:
+  """Canonicalizes a JSON schema."""
+  if not defs:
+    return root
+
+  def _maybe_inline_ref(k: utils.KeyPath, v: Any):
+    del k
+    if isinstance(v, dict) and '$ref' in v:
+      ref_key = v['$ref'].split('/')[-1]
+      if defs[ref_key].num_references == 1:
+        defs[ref_key].num_references -= 1
+        if not inline_nested_refs:
+          return defs[ref_key].definition
+        else:
+          return _canonicalize_schema(
+              defs[ref_key].definition, defs=defs, include_defs=False,
+              inline_nested_refs=True
+          )
+    return v
+
+  new_root = utils.transform(root, _maybe_inline_ref)
+  if not include_defs:
+    return new_root
+  referenced_defs = {
+      k: v.definition for k, v in defs.items() if v.num_references > 0
+  }
+  canonical_form = {'$defs': referenced_defs} if referenced_defs else {}
+  canonical_form.update(new_root)
+  return canonical_form
+
+#
+# Override to_json_schema() method for ValueSpec and Schema.
+#
+
+
+def _value_spec_to_json_schema(
+    self: Union[vs.ValueSpec, class_schema.Schema, Any],
+    *,
+    include_type_name: bool = True,
+    include_subclasses: bool = False,
+    inline_nested_refs: bool = False,
+    **kwargs
+) -> Dict[str, Any]:
+  """Converts a value spec to JSON schema."""
+  return to_json_schema(
+      self,
+      include_type_name=include_type_name,
+      include_subclasses=include_subclasses,
+      inline_nested_refs=inline_nested_refs,
+      **kwargs
+  )
+
+
+def _schema_to_json_schema(
+    self: class_schema.Schema,
+    *,
+    include_type_name: bool = True,
+    include_subclasses: bool = False,
+    inline_nested_refs: bool = False,
+    **kwargs
+) -> Dict[str, Any]:
+  """Converts a schema to JSON schema."""
+  return to_json_schema(
+      self,
+      include_type_name=include_type_name,
+      include_subclasses=include_subclasses,
+      inline_nested_refs=inline_nested_refs,
+      **kwargs
+  )
+
+vs.ValueSpec.to_json_schema = _value_spec_to_json_schema
+class_schema.Schema.to_json_schema = _schema_to_json_schema

pyglove/core/typing/json_schema_test.py

@@ -0,0 +1,477 @@
+# 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.
+"""Tests for JSON schema conversion."""
+
+from typing import Annotated, Literal, Optional
+import unittest
+from pyglove.core.symbolic import object as pg_object
+from pyglove.core.typing import annotation_conversion  # pylint: disable=unused-import
+from pyglove.core.typing import json_schema
+from pyglove.core.typing import key_specs as ks
+from pyglove.core.typing import value_specs as vs
+
+
+class Foo(pg_object.Object):
+  x: int
+  y: 'Bar'
+
+
+class Bar(pg_object.Object):
+  z: Optional[Foo]
+
+
+class JsonSchemaTest(unittest.TestCase):
+
+  maxDiff = None
+
+  def assert_json_schema(
+      self, t, expected_json_schema,
+      *,
+      include_type_name: bool = True,
+      include_subclasses: bool = False,
+      inline_nested_refs: bool = False):
+    actual_schema = json_schema.to_json_schema(
+        t,
+        include_type_name=include_type_name,
+        include_subclasses=include_subclasses,
+        inline_nested_refs=inline_nested_refs,
+    )
+    self.assertEqual(actual_schema, expected_json_schema)
+
+  def test_bool(self):
+    self.assert_json_schema(bool, {
+        'type': 'boolean',
+    })
+
+  def test_int(self):
+    self.assert_json_schema(int, {
+        'type': 'integer',
+    })
+    self.assert_json_schema(vs.Int(min_value=0), {
+        'type': 'integer',
+        'minimum': 0,
+    })
+    self.assert_json_schema(vs.Int(max_value=1), {
+        'type': 'integer',
+        'maximum': 1,
+    })
+
+  def test_float(self):
+    self.assert_json_schema(float, {
+        'type': 'number',
+    })
+    self.assert_json_schema(vs.Float(min_value=0.0), {
+        'type': 'number',
+        'minimum': 0.0,
+    })
+    self.assert_json_schema(vs.Float(max_value=1.0), {
+        'type': 'number',
+        'maximum': 1.0,
+    })
+
+  def test_str(self):
+    self.assert_json_schema(str, {
+        'type': 'string',
+    })
+    self.assert_json_schema(vs.Str(regex='a.*'), {
+        'type': 'string',
+        'pattern': 'a.*',
+    })
+
+  def test_enum(self):
+    self.assert_json_schema(Literal['a', 1], {
+        'enum': ['a', 1]
+    })
+    self.assert_json_schema(Literal['a', 1, None], {
+        'anyOf': [
+            {'enum': ['a', 1]},
+            {'type': 'null'}
+        ]
+    })
+    with self.assertRaisesRegex(
+        ValueError, 'Enum candidate .* is not supported'
+    ):
+      json_schema.to_json_schema(Literal['a', 1, None, ValueError()])
+
+  def test_list(self):
+    self.assert_json_schema(vs.List[int], {
+        'type': 'array',
+        'items': {
+            'type': 'integer',
+        }
+    })
+
+  def test_dict(self):
+    self.assert_json_schema(vs.Dict(), {
+        'type': 'object', 'additionalProperties': True
+    })
+    self.assert_json_schema(vs.Dict({'a': int}), {
+        'type': 'object',
+        'properties': {'a': {
+            'type': 'integer',
+        }},
+        'required': ['a'],
+        'additionalProperties': False,
+    })
+    self.assert_json_schema(vs.Dict([(ks.StrKey(), int)]), {
+        'type': 'object',
+        'additionalProperties': {'type': 'integer'},
+    })
+    self.assert_json_schema(vs.Dict([(ks.StrKey(), vs.Any())]), {
+        'type': 'object',
+        'additionalProperties': True,
+    })
+
+  def test_union(self):
+    self.assert_json_schema(vs.Union([int, vs.Union([str, int]).noneable()]), {
+        'anyOf': [
+            {'type': 'integer'},
+            {'type': 'string'},
+            # TODO(daiyip): Remove duplicates for nested Union in future.
+            {'type': 'integer'},
+            {'type': 'null'},
+        ]
+    })
+
+  def test_any(self):
+    self.assert_json_schema(vs.Any(), {
+        'anyOf': [
+            {'type': 'boolean'},
+            {'type': 'number'},
+            {'type': 'string'},
+            {'type': 'array'},
+            {'type': 'object', 'additionalProperties': True},
+            {'type': 'null'},
+        ]
+    })
+
+  def test_object(self):
+    class A:
+      def __init__(self, x: int, y: str):
+        pass
+
+    self.assert_json_schema(vs.Object(A), {
+        'type': 'object',
+        'properties': {
+            'x': {
+                'type': 'integer',
+            },
+            'y': {
+                'type': 'string',
+            },
+        },
+        'required': ['x', 'y'],
+        'title': 'A',
+        'additionalProperties': False,
+    }, include_type_name=False)
+
+    self.assert_json_schema(vs.Object(A), {
+        'type': 'object',
+        'properties': {
+            'x': {
+                'type': 'integer',
+            },
+            'y': {
+                'type': 'string',
+            },
+        },
+        'required': ['x', 'y'],
+        'title': 'A',
+        'additionalProperties': False,
+    }, include_type_name=True)
+
+  def test_pg_object(self):
+
+    class A(pg_object.Object):
+      x: int
+      y: str
+
+    self.assert_json_schema(vs.Object(A), {
+        'type': 'object',
+        'properties': {
+            'x': {
+                'type': 'integer',
+            },
+            'y': {
+                'type': 'string',
+            },
+        },
+        'required': ['x', 'y'],
+        'title': 'A',
+        'additionalProperties': False,
+    }, include_type_name=False)
+
+    self.assert_json_schema(vs.Object(A), {
+        'type': 'object',
+        'properties': {
+            '_type': {
+                'const': A.__type_name__,
+            },
+            'x': {
+                'type': 'integer',
+            },
+            'y': {
+                'type': 'string',
+            },
+        },
+        'required': ['_type', 'x', 'y'],
+        'title': 'A',
+        'additionalProperties': False,
+    }, include_type_name=True)
+
+  def test_pg_object_nessted(self):
+
+    class A(pg_object.Object):
+      x: Annotated[int, 'field x']
+      y: str
+
+    class B(pg_object.Object):
+      z: A
+
+    self.assert_json_schema(vs.Object(B), {
+        '$defs': {
+            'A': {
+                'type': 'object',
+                'properties': {
+                    '_type': {
+                        'const': A.__type_name__,
+                    },
+                    'x': {
+                        'type': 'integer',
+                        'description': 'field x',
+                    },
+                    'y': {
+                        'type': 'string',
+                    },
+                },
+                'required': ['_type', 'x', 'y'],
+                'title': 'A',
+                'additionalProperties': False,
+            }
+        },
+        'type': 'object',
+        'properties': {
+            '_type': {
+                'const': B.__type_name__,
+            },
+            'z': {
+                '$ref': '#/$defs/A'
+            },
+        },
+        'required': ['_type', 'z'],
+        'title': 'B',
+        'additionalProperties': False,
+    }, include_type_name=True)
+
+    self.assert_json_schema(vs.Object(B), {
+        'type': 'object',
+        'properties': {
+            '_type': {
+                'const': B.__type_name__,
+            },
+            'z': {
+                'type': 'object',
+                'properties': {
+                    '_type': {
+                        'const': A.__type_name__,
+                    },
+                    'x': {
+                        'type': 'integer',
+                        'description': 'field x',
+                    },
+                    'y': {
+                        'type': 'string',
+                    },
+                },
+                'required': ['_type', 'x', 'y'],
+                'title': 'A',
+                'additionalProperties': False,
+            },
+        },
+        'required': ['_type', 'z'],
+        'title': 'B',
+        'additionalProperties': False,
+    }, include_type_name=True, inline_nested_refs=True)
+
+  def test_pg_object_with_subclasses(self):
+    class A(pg_object.Object):
+      x: int
+      y: str
+
+    class B(A):
+      z: int
+
+    self.assert_json_schema(
+        vs.Object(A).noneable(),
+        {
+            'anyOf': [
+                {
+                    'additionalProperties': False,
+                    'properties': {
+                        '_type': {
+                            'const': A.__type_name__,
+                        },
+                        'x': {
+                            'type': 'integer',
+                        },
+                        'y': {
+                            'type': 'string',
+                        },
+                    },
+                    'required': ['_type', 'x', 'y'],
+                    'title': 'A',
+                    'type': 'object',
+                },
+                {
+                    'additionalProperties': False,
+                    'properties': {
+                        '_type': {
+                            'const': B.__type_name__,
+                        },
+                        'x': {
+                            'type': 'integer',
+                        },
+                        'y': {
+                            'type': 'string',
+                        },
+                        'z': {
+                            'type': 'integer',
+                        },
+                    },
+                    'required': ['_type', 'x', 'y', 'z'],
+                    'title': 'B',
+                    'type': 'object',
+                },
+                {
+                    'type': 'null',
+                }
+            ],
+        },
+        include_type_name=True,
+        include_subclasses=True,
+    )
+
+  def test_pg_object_with_recursive_refs(self):
+    self.assert_json_schema(
+        vs.Object(Foo),
+        {
+            '$defs': {
+                'Foo': {
+                    'additionalProperties': False,
+                    'properties': {
+                        '_type': {
+                            'const': Foo.__type_name__,
+                        },
+                        'x': {
+                            'type': 'integer',
+                        },
+                        'y': {
+                            '$ref': '#/$defs/Bar',
+                        },
+                    },
+                    'required': ['_type', 'x', 'y'],
+                    'title': 'Foo',
+                    'type': 'object',
+                },
+                'Bar': {
+                    'additionalProperties': False,
+                    'properties': {
+                        '_type': {
+                            'const': Bar.__type_name__,
+                        },
+                        'z': {
+                            'anyOf': [
+                                {'$ref': '#/$defs/Foo'},
+                                {'type': 'null'},
+                            ]
+                        },
+                    },
+                    'required': ['_type', 'z'],
+                    'title': 'Bar',
+                    'type': 'object',
+                }
+            },
+            '$ref': '#/$defs/Foo',
+        }
+    )
+
+  def test_unsupported_value_spec(self):
+    with self.assertRaisesRegex(
+        TypeError, 'Value spec .* cannot be converted to JSON schema'
+    ):
+      json_schema.to_json_schema(vs.Callable())
+
+  def test_schema(self):
+    class A(pg_object.Object):
+      x: int
+      y: str
+
+    self.assert_json_schema(
+        A.__schema__,
+        {
+            'type': 'object',
+            'properties': {
+                '_type': {
+                    'const': A.__type_name__,
+                },
+                'x': {
+                    'type': 'integer',
+                },
+                'y': {
+                    'type': 'string',
+                },
+            },
+            'required': ['_type', 'x', 'y'],
+            'title': 'A',
+            'additionalProperties': False,
+        },
+        include_type_name=True,
+    )
+
+  def test_value_spec_to_json_schema(self):
+    self.assertEqual(
+        vs.Int().to_json_schema(),
+        {
+            'type': 'integer',
+        }
+    )
+
+  def test_schema_to_json_schema(self):
+    class A(pg_object.Object):
+      x: int
+      y: str
+
+    self.assertEqual(
+        A.__schema__.to_json_schema(),
+        {
+            'type': 'object',
+            'properties': {
+                '_type': {
+                    'const': A.__type_name__,
+                },
+                'x': {
+                    'type': 'integer',
+                },
+                'y': {
+                    'type': 'string',
+                },
+            },
+            'required': ['_type', 'x', 'y'],
+            'title': 'A',
+            'additionalProperties': False,
+        }
+    )
+
+if __name__ == '__main__':
+  unittest.main()

{pyglove-0.4.5.dev202505010810.dist-info → pyglove-0.4.5.dev202505030808.dist-info}/METADATA

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

{pyglove-0.4.5.dev202505010810.dist-info → pyglove-0.4.5.dev202505030808.dist-info}/RECORD

@@ -106,7 +106,7 @@ pyglove/core/tuning/protocols.py,sha256=10Iukt1rqh05caURTZffSsb3CcHo7epBQnNtnyMy
 pyglove/core/tuning/protocols_test.py,sha256=Cbzvz3EacaW2sbm1rTSQXEt_VucMoQbeQ6AeN-GV5Vc,1883
 pyglove/core/tuning/sample.py,sha256=UzsCY8kiqnzH_mR94zLXhOloyvvEwfmBWluBjmefUFA,12975
 pyglove/core/tuning/sample_test.py,sha256=JqwDPy3EPC_VjU9dipk90jj1kovZB3Zb9hAjAlZ-U1U,17551
-pyglove/core/typing/__init__.py,sha256=MwraQ-6K8NYI_xk4V3oaVSkrPqiU9InDtAgXPSRBvik,14494
+pyglove/core/typing/__init__.py,sha256=u2YSrSi8diTkQn8_1J2hEpk5o7zDhx2tU_oRuS-k1XU,14580
 pyglove/core/typing/annotated.py,sha256=llaajIDj9GK-4kUGJoO4JsHU6ESPOra2SZ-jG6xmsOQ,3203
 pyglove/core/typing/annotated_test.py,sha256=p1qid3R-jeiOTTxOVq6hXW8XFvn-h1cUzJWISPst2l8,2484
 pyglove/core/typing/annotation_conversion.py,sha256=txUrChAhMNeaukV-PSQEA9BCjtonUQDWFHxnpTE0_K8,15582
@@ -116,11 +116,13 @@ pyglove/core/typing/callable_ext.py,sha256=PiBQWPeUAH7Lgmf2xKCZqgK7N0OSrTdbnEkV8
 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=u_pxvykZlwyd5ycdfHpWYI8ccttmBbzexrajNVbEVG4,54553
+pyglove/core/typing/class_schema.py,sha256=3U92-Suwdxlc8mXjK6Tqa9iiqogtRuv1YZwVYpmkMTc,55288
 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
+pyglove/core/typing/json_schema.py,sha256=shHElSIpw6AZ5L1iKrKzX3yZXgGKYFJOvMC-syEf-i8,10453
+pyglove/core/typing/json_schema_test.py,sha256=DhtyoWLoYzCS-DU67QuwaZKZ-9WgK_ZFVsiFp94Ltx8,13011
 pyglove/core/typing/key_specs.py,sha256=-7xjCuUGoQgD0sMafsRFNlw3S4f1r-7t5OO4ev5bbeI,9225
 pyglove/core/typing/key_specs_test.py,sha256=5zornpyHMAYoRaG8KDXHiQ3obu9UfRp3399lBeUNTPk,6499
 pyglove/core/typing/pytype_support.py,sha256=lyX11WVbCwoOi5tTQ90pEOS-yvo_6iEi7Lxbp-nXu2A,2069
@@ -212,8 +214,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.dev202505010810.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.4.5.dev202505010810.dist-info/METADATA,sha256=x9jX1JAzZ7jsVnFkXSCjct596hP4KJPUd88EPcHwPj0,7089
-pyglove-0.4.5.dev202505010810.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-pyglove-0.4.5.dev202505010810.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.4.5.dev202505010810.dist-info/RECORD,,
+pyglove-0.4.5.dev202505030808.dist-info/licenses/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.4.5.dev202505030808.dist-info/METADATA,sha256=glCGeZAatT2jJo4vHgSm2evKvJxY9jC-K1N82J32JJ4,7089
+pyglove-0.4.5.dev202505030808.dist-info/WHEEL,sha256=7ciDxtlje1X8OhobNuGgi1t-ACdFSelPnSmDPrtlobY,91
+pyglove-0.4.5.dev202505030808.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.4.5.dev202505030808.dist-info/RECORD,,

{pyglove-0.4.5.dev202505010810.dist-info → pyglove-0.4.5.dev202505030808.dist-info}/WHEEL

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