pyglove 0.4.5.dev202501160330__tar.gz → 0.4.5.dev202501170808__tar.gz

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/PKG-INFO

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

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove/core/hyper/derived_test.py

@@ -120,7 +120,7 @@ class ValueReferenceTest(unittest.TestCase):
     sd.y = ValueReference(['x'])
     # TODO(daiyip): Enable this test once static analysis is done
     # on derived values.
-    # with self.assertRaisesRegexp(
+    # with self.assertRaisesRegex(
     #     TypeError, ''):
     #   sd.z = ValueReference(['x'])
 

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove/core/symbolic/object.py

@@ -96,6 +96,7 @@ class ObjectMeta(abc.ABCMeta):
         base_schema_list=[cls.__schema__] if extend else [],
         allow_nonconst_keys=True,
         metadata=metadata,
+        for_cls=cls,
     )
     cls.apply_schema(schema)
 
@@ -193,6 +194,7 @@ class ObjectMeta(abc.ABCMeta):
             field.value.freeze(attr_value, apply_before_use=False)
         else:
           field.value.set_default(attr_value)
+        field.set_origin(cls)
 
 
 # Use ObjectMeta as meta class to inherit schema and type_name property.
@@ -344,6 +346,7 @@ class Object(base.Symbolic, metaclass=ObjectMeta):
           base_schema_list=base_schema_list,
           allow_nonconst_keys=True,
           metadata={},
+          for_cls=user_cls,
       )
 
       # Freeze callable symbolic attributes if they are provided as methods.

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove/core/symbolic/object_test.py

@@ -1914,6 +1914,32 @@ class InheritanceTest(unittest.TestCase):
     self.assertEqual(d.x, 'foo')
     self.assertEqual(d.foo(), 'B')
 
+  def test_multi_inheritance2(self):
+
+    class A(Object):
+      x: typing.Callable[[], Any]
+
+    class B(A):
+      def x(self):
+        return 1
+
+    class C(A):
+      pass
+
+    class D(C, B):
+      pass
+
+    self.assertIs(D.__schema__['x'].default_value, B.x)
+
+    class E(A):
+      def x(self):
+        return 2
+
+    class F(E, B):
+      pass
+
+    self.assertIs(F.__schema__['x'].default_value, E.x)
+
 
 class InitSignatureTest(unittest.TestCase):
   """Tests for `pg.Object.__init__` signature."""

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove/core/typing/class_schema.py

@@ -593,7 +593,9 @@ class Field(utils.Formattable, utils.JSONConvertible):
       key_spec: Union[KeySpec, str],
       value_spec: ValueSpec,
       description: Optional[str] = None,
-      metadata: Optional[Dict[str, Any]] = None):
+      metadata: Optional[Dict[str, Any]] = None,
+      origin: Optional[Type[Any]] = None,
+  ) -> None:
     """Constructor.
 
     Args:
@@ -602,6 +604,7 @@ class Field(utils.Formattable, utils.JSONConvertible):
       value_spec: Value specification of the field.
       description: Description of the field.
       metadata: A dict of objects as metadata for the field.
+      origin: The class that this field originates from.
 
     Raises:
       ValueError: metadata is not a dict.
@@ -612,6 +615,7 @@ class Field(utils.Formattable, utils.JSONConvertible):
     self._key = key_spec
     self._value = value_spec
     self._description = description
+    self._origin = origin
 
     if metadata and not isinstance(metadata, dict):
       raise ValueError('metadata must be a dict.')
@@ -667,6 +671,15 @@ class Field(utils.Formattable, utils.JSONConvertible):
     """
     return self._metadata
 
+  @property
+  def origin(self) -> Optional[Type[Any]]:
+    """The class that this field originates from."""
+    return self._origin
+
+  def set_origin(self, origin: Type[Any]) -> None:
+    """Sets the origin (source class) of this field."""
+    self._origin = origin
+
   def extend(self, base_field: 'Field') -> 'Field':
     """Extend current field based on a base field."""
     self.key.extend(base_field.key)
@@ -745,6 +758,7 @@ class Field(utils.Formattable, utils.JSONConvertible):
             ('value', self._value, None),
             ('description', self._description, None),
             ('metadata', self._metadata, {}),
+            ('origin', self._origin, None),
         ],
         label=self.__class__.__name__,
         compact=compact,
@@ -869,7 +883,9 @@ class Schema(utils.Formattable, utils.JSONConvertible):
       description: Optional[str] = None,
       *,
       allow_nonconst_keys: bool = False,
-      metadata: Optional[Dict[str, Any]] = None):
+      metadata: Optional[Dict[str, Any]] = None,
+      for_cls: Optional[Type[Any]] = None,
+  ):
     """Constructor.
 
     Args:
@@ -882,6 +898,7 @@ class Schema(utils.Formattable, utils.JSONConvertible):
       description: Optional str as the description for the schema.
       allow_nonconst_keys: Whether immediate fields can use non-const keys.
       metadata: Optional dict of user objects as schema-level metadata.
+      for_cls: Optional class that this schema applies to.
 
     Raises:
       TypeError: Argument `fields` is not a list.
@@ -903,6 +920,11 @@ class Schema(utils.Formattable, utils.JSONConvertible):
     self._description = description
     self._metadata = metadata or {}
 
+    if for_cls is not None:
+      for f in fields:
+        if f.origin is None:
+          f.set_origin(for_cls)
+
     self._dynamic_field = None
     for f in fields:
       if not f.key.is_const:
@@ -938,21 +960,27 @@ class Schema(utils.Formattable, utils.JSONConvertible):
     Returns:
       The merged schema.
     """
-    field_names = set()
-    fields = []
+    fields = {}
     kw_field = None
     for schema in schema_list:
       for key, field in schema.fields.items():
-        if key.is_const and key not in field_names:
-          fields.append(field)
-          field_names.add(key)
-        elif not key.is_const and kw_field is None:
+        if key.is_const:
+          if key not in fields or (
+              field.origin is not None
+              and fields[key].origin is not None
+              and issubclass(field.origin, fields[key].origin)
+          ):
+            fields[key] = field
+        elif kw_field is None:
           kw_field = field
 
     if kw_field is not None:
-      fields.append(kw_field)
+      fields[kw_field.key] = kw_field
     return Schema(
-        fields, name=name, description=description, allow_nonconst_keys=True
+        list(fields.values()),
+        name=name,
+        description=description,
+        allow_nonconst_keys=True
     )
 
   def extend(self, base: 'Schema') -> 'Schema':
@@ -1415,6 +1443,7 @@ def create_schema(
     allow_nonconst_keys: bool = False,
     metadata: Optional[Dict[str, Any]] = None,
     description: Optional[str] = None,
+    for_cls: Optional[Type[Any]] = None,
     parent_module: Optional[types.ModuleType] = None
 ) -> Schema:
   """Creates ``Schema`` from a list of ``Field``s or equivalences.
@@ -1456,6 +1485,7 @@ def create_schema(
     allow_nonconst_keys: Whether to allow non const keys in schema.
     metadata: Optional dict of user objects as schema-level metadata.
     description: Optional description of the schema.
+    for_cls: (Optional) the class that this schema applies to.
     parent_module: (Optional) parent module for defining this schema, which will
       be used for forward reference lookup.
 
@@ -1479,6 +1509,7 @@ def create_schema(
       allow_nonconst_keys=allow_nonconst_keys,
       metadata=metadata,
       description=description,
+      for_cls=for_cls,
   )
 
 

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove/core/typing/class_schema_test.py

@@ -107,6 +107,7 @@ class FieldTest(unittest.TestCase):
     self.assertEqual(f.description, 'a field')
     self.assertIsInstance(f.metadata, dict)
     self.assertEqual(len(f.metadata), 0)
+    self.assertIsNone(f.origin)
 
     # Cover the self comparison in __eq__.
     self.assertEqual(f, f)

{pyglove-0.4.5.dev202501160330 → pyglove-0.4.5.dev202501170808}/pyglove.egg-info/PKG-INFO

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