pyglove 0.5.0.dev202510020810__py3-none-any.whl → 0.5.0.dev202512280810__py3-none-any.whl

pyglove/core/typing/json_schema_test.py

@@ -31,7 +31,7 @@ class Bar(pg_object.Object):
   z: Optional[Foo]
 
 
-class JsonSchemaTest(unittest.TestCase):
+class ToJsonSchemaTest(unittest.TestCase):
 
   maxDiff = None
 
@@ -53,6 +53,10 @@ class JsonSchemaTest(unittest.TestCase):
     self.assert_json_schema(bool, {
         'type': 'boolean',
     })
+    self.assert_json_schema(vs.Bool(default=True), {
+        'type': 'boolean',
+        'default': True,
+    })
 
   def test_int(self):
     self.assert_json_schema(int, {
@@ -62,9 +66,10 @@ class JsonSchemaTest(unittest.TestCase):
         'type': 'integer',
         'minimum': 0,
     })
-    self.assert_json_schema(vs.Int(max_value=1), {
+    self.assert_json_schema(vs.Int(max_value=1, default=0), {
         'type': 'integer',
         'maximum': 1,
+        'default': 0,
     })
 
   def test_float(self):
@@ -75,30 +80,43 @@ class JsonSchemaTest(unittest.TestCase):
         'type': 'number',
         'minimum': 0.0,
     })
-    self.assert_json_schema(vs.Float(max_value=1.0), {
+    self.assert_json_schema(vs.Float(max_value=1.0, default=0.0), {
         'type': 'number',
         'maximum': 1.0,
+        'default': 0.0,
     })
 
   def test_str(self):
     self.assert_json_schema(str, {
         'type': 'string',
     })
-    self.assert_json_schema(vs.Str(regex='a.*'), {
+    self.assert_json_schema(vs.Str(regex='a.*', default='a1'), {
         'type': 'string',
         'pattern': 'a.*',
+        'default': 'a1',
     })
 
   def test_enum(self):
     self.assert_json_schema(Literal['a', 1], {
         'enum': ['a', 1]
     })
+    self.assert_json_schema(vs.Enum(1, ['a', 1]), {
+        'enum': ['a', 1],
+        'default': 1,
+    })
     self.assert_json_schema(Literal['a', 1, None], {
         'anyOf': [
             {'enum': ['a', 1]},
             {'type': 'null'}
         ]
     })
+    self.assert_json_schema(vs.Enum(None, ['a', 1, None]), {
+        'anyOf': [
+            {'enum': ['a', 1]},
+            {'type': 'null'}
+        ],
+        'default': None
+    })
     with self.assertRaisesRegex(
         ValueError, 'Enum candidate .* is not supported'
     ):
@@ -111,6 +129,13 @@ class JsonSchemaTest(unittest.TestCase):
             'type': 'integer',
         }
     })
+    self.assert_json_schema(vs.List(int, default=[1, 2]), {
+        'type': 'array',
+        'items': {
+            'type': 'integer',
+        },
+        'default': [1, 2],
+    })
 
   def test_dict(self):
     self.assert_json_schema(vs.Dict(), {
@@ -143,6 +168,15 @@ class JsonSchemaTest(unittest.TestCase):
             {'type': 'null'},
         ]
     })
+    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(), {
@@ -155,6 +189,17 @@ class JsonSchemaTest(unittest.TestCase):
             {'type': 'null'},
         ]
     })
+    self.assert_json_schema(vs.Any(default=1), {
+        'anyOf': [
+            {'type': 'boolean'},
+            {'type': 'number'},
+            {'type': 'string'},
+            {'type': 'array'},
+            {'type': 'object', 'additionalProperties': True},
+            {'type': 'null'},
+        ],
+        'default': 1,
+    })
 
   def test_object(self):
     class A:
@@ -176,9 +221,16 @@ class JsonSchemaTest(unittest.TestCase):
         'additionalProperties': False,
     }, include_type_name=False)
 
-    self.assert_json_schema(vs.Object(A), {
+    class B(pg_object.Object):
+      x: int
+      y: str
+
+    self.assert_json_schema(vs.Object(B), {
         'type': 'object',
         'properties': {
+            '_type': {
+                'const': B.__type_name__,
+            },
             'x': {
                 'type': 'integer',
             },
@@ -186,11 +238,30 @@ class JsonSchemaTest(unittest.TestCase):
                 'type': 'string',
             },
         },
-        'required': ['x', 'y'],
-        'title': 'A',
+        'required': ['_type', 'x', 'y'],
+        'title': 'B',
         'additionalProperties': False,
     }, include_type_name=True)
 
+    self.assert_json_schema(vs.Object(B, default=B(x=1, y='a')), {
+        'type': 'object',
+        'properties': {
+            'x': {
+                'type': 'integer',
+            },
+            'y': {
+                'type': 'string',
+            },
+        },
+        'required': ['x', 'y'],
+        'title': 'B',
+        'additionalProperties': False,
+        'default': {
+            'x': 1,
+            'y': 'a',
+        },
+    }, include_type_name=False)
+
   def test_pg_object(self):
 
     class A(pg_object.Object):
@@ -230,14 +301,14 @@ class JsonSchemaTest(unittest.TestCase):
         'additionalProperties': False,
     }, include_type_name=True)
 
-  def test_pg_object_nessted(self):
+  def test_pg_object_nested(self):
 
     class A(pg_object.Object):
       x: Annotated[int, 'field x']
       y: str
 
     class B(pg_object.Object):
-      z: A
+      z: A = A(x=1, y='a')
 
     self.assert_json_schema(vs.Object(B), {
         '$defs': {
@@ -266,10 +337,15 @@ class JsonSchemaTest(unittest.TestCase):
                 'const': B.__type_name__,
             },
             'z': {
-                '$ref': '#/$defs/A'
+                '$ref': '#/$defs/A',
+                'default': {
+                    '_type': A.__type_name__,
+                    'x': 1,
+                    'y': 'a',
+                },
             },
         },
-        'required': ['_type', 'z'],
+        'required': ['_type'],
         'title': 'B',
         'additionalProperties': False,
     }, include_type_name=True)
@@ -299,7 +375,7 @@ class JsonSchemaTest(unittest.TestCase):
                 'additionalProperties': False,
             },
         },
-        'required': ['_type', 'z'],
+        'required': ['_type'],
         'title': 'B',
         'additionalProperties': False,
     }, include_type_name=True, inline_nested_refs=True)
@@ -357,6 +433,7 @@ class JsonSchemaTest(unittest.TestCase):
                     'type': 'null',
                 }
             ],
+            'default': None,
         },
         include_type_name=True,
         include_subclasses=True,
@@ -473,5 +550,424 @@ class JsonSchemaTest(unittest.TestCase):
         }
     )
 
+
+class FromJsonSchemaTest(unittest.TestCase):
+
+  def assert_value_spec(self, input_json_schema, expected_value_spec):
+    value_spec = vs.ValueSpec.from_json_schema(input_json_schema)
+    self.assertEqual(value_spec, expected_value_spec)
+
+  def test_bool(self):
+    self.assert_value_spec(
+        {
+            'type': 'boolean',
+        },
+        vs.Bool(),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'boolean',
+            'default': True
+        },
+        vs.Bool(default=True),
+    )
+
+  def test_int(self):
+    self.assert_value_spec(
+        {
+            'type': 'integer',
+        },
+        vs.Int(),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'integer',
+            'minimum': 0,
+        },
+        vs.Int(min_value=0),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'integer',
+            'maximum': 1,
+            'default': 0,
+        },
+        vs.Int(max_value=1, default=0),
+    )
+
+  def test_number(self):
+    self.assert_value_spec(
+        {
+            'type': 'number',
+        },
+        vs.Float(),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'number',
+            'minimum': 0.0,
+        },
+        vs.Float(min_value=0.0),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'number',
+            'maximum': 1.0,
+            'default': 0.0,
+        },
+        vs.Float(max_value=1.0, default=0.0),
+    )
+
+  def test_str(self):
+    self.assert_value_spec(
+        {
+            'type': 'string',
+        },
+        vs.Str(),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'string',
+            'pattern': 'a.*',
+            'default': 'a1',
+        },
+        vs.Str(regex='a.*', default='a1'),
+    )
+
+  def test_enum(self):
+    self.assert_value_spec(
+        {
+            'enum': ['a', 'b', 'c'],
+            'default': 'b',
+        },
+        vs.Enum('b', ['a', 'b', 'c']),
+    )
+    with self.assertRaisesRegex(
+        ValueError, 'Enum candidate .* is not supported'
+    ):
+      vs.ValueSpec.from_json_schema({'enum': [{'x': 1}, {'y': 'abc'}]})
+
+  def test_null(self):
+    self.assert_value_spec(
+        {
+            'type': 'null',
+        },
+        vs.Any().freeze(None),
+    )
+
+  def test_any_of(self):
+    self.assert_value_spec(
+        {
+            'anyOf': [
+                {'type': 'integer'},
+            ],
+        },
+        vs.Int(),
+    )
+    self.assert_value_spec(
+        {
+            'anyOf': [
+                {'type': 'integer'},
+                {'type': 'string'},
+            ],
+        },
+        vs.Union([vs.Int(), vs.Str()]),
+    )
+    self.assert_value_spec(
+        {
+            'anyOf': [
+                {'type': 'integer'},
+                {'type': 'string'},
+                {'type': 'null'},
+            ],
+        },
+        vs.Union([vs.Int(), vs.Str()]).noneable(),
+    )
+
+  def test_list(self):
+    self.assert_value_spec(
+        {
+            'type': 'array',
+        },
+        vs.List(vs.Any()),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'array',
+            'items': {
+                'type': 'integer',
+            },
+        },
+        vs.List(vs.Int()),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'array',
+            'items': {
+                'type': 'integer',
+            },
+            'default': [1, 2],
+        },
+        vs.List(vs.Int(), default=[1, 2]),
+    )
+
+  def test_dict(self):
+    self.assert_value_spec(
+        {
+            'type': 'object',
+        },
+        vs.Dict(),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'object',
+            'properties': {
+                'a': {
+                    'type': 'integer',
+                },
+            },
+            'required': ['a'],
+            'additionalProperties': False,
+        },
+        vs.Dict({'a': vs.Int()}),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'object',
+            'additionalProperties': {'type': 'integer'},
+        },
+        vs.Dict([(ks.StrKey(), vs.Int())]),
+    )
+    self.assert_value_spec(
+        {
+            'type': 'object',
+            'additionalProperties': True,
+        },
+        vs.Dict([(ks.StrKey(), vs.Any())]),
+    )
+
+  def _cls_value_spec(self, input_json_schema):
+    def schema_to_class(name, schema):
+      class _Class(pg_object.Object):
+        pass
+      cls = _Class
+      cls.__name__ = name
+      cls.__doc__ = schema.description
+      cls.apply_schema(schema)
+      return cls
+    return vs.ValueSpec.from_json_schema(
+        input_json_schema, class_fn=schema_to_class
+    )
+
+  def test_simple_object(self):
+    cls_spec = self._cls_value_spec(
+        {
+            'type': 'object',
+            'title': 'A',
+            'description': 'Class A',
+            'properties': {
+                'x': {
+                    'type': 'integer',
+                    'description': 'field x',
+                },
+                'y': {
+                    'type': 'string',
+                },
+            },
+            'required': ['x'],
+            'additionalProperties': False,
+        },
+    )
+    self.assertIsNone(cls_spec.cls(x=1).y)
+    self.assertEqual(cls_spec.cls.__name__, 'A')
+    self.assertEqual(cls_spec.cls.__doc__, 'Class A')
+    self.assertEqual(
+        cls_spec.cls.__schema__['x'], vs.Field('x', vs.Int(), 'field x')
+    )
+    self.assertEqual(
+        cls_spec.cls.__schema__['y'], vs.Field('y', vs.Str().noneable())
+    )
+
+  def test_nested_object(self):
+    cls_spec = self._cls_value_spec(
+        {
+            'type': 'object',
+            'title': 'A',
+            'description': 'Class A',
+            'properties': {
+                'x': {
+                    'type': 'integer',
+                    'description': 'field x',
+                },
+                'y': {
+                    'type': 'object',
+                    'title': 'B',
+                    'description': 'Class B',
+                    'properties': {
+                        'z': {
+                            'type': 'string',
+                        },
+                    },
+                    'required': ['z'],
+                    'additionalProperties': False,
+                },
+            },
+            'required': ['x'],
+            'additionalProperties': False,
+        },
+    )
+    self.assertIsNone(cls_spec.cls(x=1).y)
+    self.assertEqual(cls_spec.cls.__name__, 'A')
+    self.assertEqual(cls_spec.cls.__doc__, 'Class A')
+    self.assertEqual(
+        cls_spec.cls.__schema__['x'], vs.Field('x', vs.Int(), 'field x')
+    )
+    b_cls = cls_spec.cls.__schema__['y'].value.cls
+    self.assertEqual(b_cls.__schema__['z'], vs.Field('z', vs.Str()))
+
+  def test_simple_object_with_def(self):
+    cls_spec = self._cls_value_spec(
+        {
+            '$defs': {
+                'A': {
+                    'type': 'object',
+                    'title': 'A',
+                    'description': 'Class A',
+                    'properties': {
+                        'x': {
+                            'type': 'integer',
+                            'description': 'field x',
+                            'default': 1,
+                        },
+                        'y': {
+                            'type': 'string',
+                        },
+                    },
+                    'required': ['x'],
+                    'additionalProperties': False,
+                }
+            },
+            '$ref': '#/$defs/A',
+        }
+    )
+    self.assertEqual(cls_spec.cls(y='a').x, 1)
+    self.assertEqual(cls_spec.cls.__name__, 'A')
+    self.assertEqual(cls_spec.cls.__doc__, 'Class A')
+
+  def test_complex_object_with_def(self):
+    cls_spec = self._cls_value_spec(
+        {
+            '$defs': {
+                'B': {
+                    'type': 'object',
+                    'title': 'B',
+                    'description': 'Class B',
+                    'properties': {
+                        'z': {
+                            'type': 'string',
+                        },
+                    },
+                    'required': ['z'],
+                    'additionalProperties': False,
+                },
+                'A': {
+                    'type': 'object',
+                    'title': 'A',
+                    'description': 'Class A',
+                    'properties': {
+                        'x': {
+                            'type': 'integer',
+                            'description': 'field x',
+                            'default': 1,
+                        },
+                        'y': {
+                            '$ref': '#/$defs/B',
+                        }
+                    },
+                    'required': ['x'],
+                    'additionalProperties': False,
+                },
+            },
+            '$ref': '#/$defs/A',
+        }
+    )
+    self.assertIsNone(cls_spec.cls(x=1).y)
+    self.assertEqual(cls_spec.cls.__name__, 'A')
+    self.assertEqual(cls_spec.cls.__doc__, 'Class A')
+    self.assertEqual(
+        cls_spec.cls.__schema__['x'],
+        vs.Field('x', vs.Int(default=1), 'field x')
+    )
+    b_cls = cls_spec.cls.__schema__['y'].value.cls
+    self.assertEqual(b_cls.__name__, 'B')
+    self.assertEqual(b_cls.__doc__, 'Class B')
+    self.assertEqual(b_cls.__schema__['z'], vs.Field('z', vs.Str()))
+
+    with self.assertRaisesRegex(
+        ValueError, 'Reference .* not defined'
+    ):
+      self._cls_value_spec(
+          {
+              '$defs': {
+                  'A': {
+                      'type': 'object',
+                      'title': 'A',
+                      'description': 'Class A',
+                      'properties': {
+                          'x': {
+                              '$ref': '#/$defs/B',
+                          }
+                      },
+                      'required': ['x'],
+                      'additionalProperties': False,
+                  },
+                  # B should go before A.
+                  'B': {
+                      'type': 'object',
+                      'title': 'B',
+                      'description': 'Class B',
+                      'properties': {
+                          'z': {
+                              'type': 'string',
+                          },
+                      },
+                      'required': ['z'],
+                      'additionalProperties': False,
+                  },
+              },
+              '$ref': '#/$defs/A',
+          }
+      )
+
+  def test_unsupported_json_schema(self):
+    with self.assertRaisesRegex(
+        ValueError, 'Unsupported type .* in JSON schema'
+    ):
+      vs.ValueSpec.from_json_schema({'type': 'oneOf'})
+
+  def test_schema_from_json_schema(self):
+    schema = vs.Schema.from_json_schema(
+        {
+            'type': 'object',
+            'title': 'A',
+            'description': 'Class A',
+            'properties': {
+                'x': {
+                    'type': 'integer',
+                },
+            },
+            'required': ['x'],
+            'additionalProperties': False,
+        },
+    )
+    self.assertEqual(schema.description, 'Class A')
+    self.assertEqual(list(schema.fields.keys()), ['x'])
+    self.assertEqual(schema.fields['x'].value, vs.Int())
+
+    with self.assertRaisesRegex(
+        ValueError, 'JSON schema is not an object type'
+    ):
+      vs.Schema.from_json_schema({'type': 'integer'})
+
 if __name__ == '__main__':
   unittest.main()

pyglove/core/typing/type_conversion.py

@@ -15,6 +15,7 @@
 
 import calendar
 import datetime
+import sys
 from typing import Any, Callable, Optional, Tuple, Type, Union
 
 from pyglove.core import utils
@@ -135,9 +136,22 @@ def _register_builtin_converters():
   register_converter(int, float, float)
 
   # int <=> datetime.datetime.
-  register_converter(int, datetime.datetime, datetime.datetime.utcfromtimestamp)
-  register_converter(datetime.datetime, int,
-                     lambda x: calendar.timegm(x.timetuple()))
+  if sys.version_info >= (3, 11):
+    register_converter(
+        int,
+        datetime.datetime,
+        lambda x: datetime.datetime.fromtimestamp(x, datetime.UTC)
+    )
+  else:
+    register_converter(
+        int, datetime.datetime, datetime.datetime.utcfromtimestamp
+    )
+
+  register_converter(
+      datetime.datetime,
+      int,
+      lambda x: calendar.timegm(x.timetuple())
+  )
 
   # string <=> KeyPath.
   register_converter(str, utils.KeyPath, utils.KeyPath.parse)

pyglove/core/typing/type_conversion_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 import calendar
 import datetime
+import sys
 import typing
 import unittest
 
@@ -130,12 +131,16 @@ class BuiltInConversionsTest(unittest.TestCase):
   def test_datetime_to_int(self):
     """Test built-in converter between int and datetime.datetime."""
     timestamp = calendar.timegm(datetime.datetime.now().timetuple())
-    now = datetime.datetime.utcfromtimestamp(timestamp)
+    if sys.version_info >= (3, 11):
+      now = datetime.datetime.fromtimestamp(timestamp, datetime.UTC)
+    else:
+      now = datetime.datetime.utcfromtimestamp(timestamp)
     self.assertEqual(vs.Object(datetime.datetime).apply(timestamp), now)
     self.assertEqual(vs.Int().apply(now), timestamp)
     self.assertEqual(
         type_conversion.get_json_value_converter(datetime.datetime)(now),
-        timestamp)
+        timestamp
+    )
 
   def test_keypath_to_str(self):
     """Test built-in converter between string and KeyPath."""