pyglove 0.4.5.dev202502020807__py3-none-any.whl → 0.4.5.dev202502040809__py3-none-any.whl

pyglove/core/typing/inspect.py

@@ -30,6 +30,11 @@ def is_subclass(
   """An issubclass extension that supports Any and generic types."""
 
   def _is_subclass(src: Type[Any], target: Type[Any]) -> bool:
+    if is_protocol(target):
+      # NOTE(daiyip): loose runtime check for Protocol.
+      # As runtime protocol check (through decorating the protocol class with
+      # @typing.runtime_checkable) might be unreliable and very slow.
+      return inspect.isclass(src) and src.__module__ != 'builtins'
     if target is Any:
       return True
     elif src is Any:
@@ -78,6 +83,17 @@ def is_subclass(
   return _is_subclass(src, target)
 
 
+def is_protocol(maybe_protocol: Type[Any]) -> bool:
+  """Returns True if a type is a protocol."""
+  if not inspect.isclass(maybe_protocol):
+    return False
+  maybe_protocol = typing.get_origin(maybe_protocol) or maybe_protocol
+  for base in maybe_protocol.__bases__:
+    if base is typing.Protocol or typing.get_origin(base) is typing.Protocol:
+      return True
+  return False
+
+
 def is_generic(maybe_generic: Type[Any]) -> bool:
   """Returns True if a type is a generic class."""
   return typing.get_origin(maybe_generic) is not None

pyglove/core/typing/inspect_test.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Tests for generic type utility."""
 
-from typing import Any, Generic, TypeVar
+from typing import Any, Generic, Protocol, TypeVar
 import unittest
 
 from pyglove.core.typing import callable_signature
@@ -62,6 +62,26 @@ class AA1(AA):
       pass
 
 
+class E(Protocol):
+
+  def __call__(self, x: int) -> int:
+    pass
+
+
+class E1(E):
+  pass
+
+
+class E2(E, Protocol):
+
+  def bar(self, x: int) -> int:
+    pass
+
+
+class F(Protocol[XType]):
+  x: XType
+
+
 class InspectTest(unittest.TestCase):
 
   def test_issubclass(self):
@@ -111,6 +131,16 @@ class InspectTest(unittest.TestCase):
     self.assertFalse(inspect.is_subclass(B1[Str], B[str]))
     self.assertFalse(inspect.is_subclass(B1[Str], A[str, int]))
 
+    # Protocol check.
+    self.assertTrue(inspect.is_subclass(E, E))
+    self.assertTrue(inspect.is_subclass(E, Protocol))
+    # We do not really check protocol comformance at runtime for performance
+    # reasons. So all user classes are considered as subclasses of a Protocol
+    # class.
+    self.assertTrue(inspect.is_subclass(A, E))
+    self.assertFalse(inspect.is_subclass(str, E))
+    self.assertFalse(inspect.is_subclass(1, E))
+
     # Test tuple cases.
     self.assertTrue(inspect.is_subclass(int, (str, int)))
     self.assertTrue(inspect.is_subclass(C, (int, A[str, int])))
@@ -124,7 +154,24 @@ class InspectTest(unittest.TestCase):
     self.assertTrue(inspect.is_instance(D(), A[str, int]))
     self.assertTrue(inspect.is_instance(D(), B[str]))
 
+  def test_is_protocol(self):
+    self.assertFalse(inspect.is_protocol(1))
+    self.assertFalse(inspect.is_protocol(str))
+    self.assertFalse(inspect.is_protocol(Any))
+    self.assertFalse(inspect.is_protocol(A))
+    self.assertFalse(inspect.is_protocol(A[str, int]))
+    self.assertFalse(inspect.is_protocol(Protocol))
+    self.assertFalse(inspect.is_protocol(Protocol[XType]))
+    self.assertTrue(inspect.is_protocol(E))
+    # subclasses of a Protocol class will downgrade if it's not explicitly
+    # inherited from Protocol.
+    # See https://typing.readthedocs.io/en/latest/spec/protocol.html
+    self.assertFalse(inspect.is_protocol(E1))
+    self.assertTrue(inspect.is_protocol(E2))
+    self.assertTrue(inspect.is_protocol(F))
+
   def test_is_generic(self):
+    self.assertFalse(inspect.is_generic(1))
     self.assertFalse(inspect.is_generic(str))
     self.assertFalse(inspect.is_generic(Any))
     self.assertFalse(inspect.is_generic(A))

pyglove/core/typing/type_conversion.py

@@ -24,11 +24,13 @@ from pyglove.core.typing import inspect as pg_inspect
 class _TypeConverterRegistry:
   """Type converter registry."""
 
+  _JSON_VALUE_TYPES = frozenset(
+      [int, float, bool, type(None), list, tuple, dict, str]
+  )
+
   def __init__(self):
     """Constructor."""
     self._converter_list = []
-    self._json_value_types = set(
-        [int, float, bool, type(None), list, tuple, dict, str])
 
   def register(
       self,
@@ -45,14 +47,17 @@ class _TypeConverterRegistry:
       raise TypeError('Argument \'src\' and \'dest\' must be a type or '
                       'tuple of types.')
     if isinstance(dest, tuple):
-      json_value_convertible = any(d in self._json_value_types for d in dest)
+      json_value_convertible = any(d in self._JSON_VALUE_TYPES for d in dest)
     else:
-      json_value_convertible = dest in self._json_value_types
+      json_value_convertible = dest in self._JSON_VALUE_TYPES
     self._converter_list.append((src, dest, convert_fn, json_value_convertible))
 
   def get_converter(
       self, src: Type[Any], dest: Type[Any]) -> Optional[Callable[[Any], Any]]:
     """Get converter from source type to destination type."""
+    if pg_inspect.is_protocol(dest):
+      return None
+
     # TODO(daiyip): Right now we don't see the need of a large number of
     # converters, thus its affordable to iterate the list.
     # We may consider more efficient way to do lookup in future.

pyglove/core/typing/type_conversion_test.py

@@ -38,6 +38,10 @@ class TypeConversionTest(unittest.TestCase):
         super().__init__(x)
         self.y = y
 
+    class C(typing.Protocol):
+      def foo(self, x: int) -> int:
+        pass
+
     a_converter = lambda a: a.x
     type_conversion.register_converter(A, (str, int), a_converter)
 
@@ -46,6 +50,7 @@ class TypeConversionTest(unittest.TestCase):
     self.assertIs(type_conversion.get_json_value_converter(A), a_converter)
 
     self.assertIsNone(type_conversion.get_converter(A, (float, bool)))
+    self.assertIsNone(type_conversion.get_converter(A, C))
     self.assertIs(type_conversion.get_converter(A, (float, int)), a_converter)
 
     # B is a subclass of A, so A's converter applies.

{pyglove-0.4.5.dev202502020807.dist-info → pyglove-0.4.5.dev202502040809.dist-info}/METADATA

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

{pyglove-0.4.5.dev202502020807.dist-info → pyglove-0.4.5.dev202502040809.dist-info}/RECORD

@@ -118,13 +118,13 @@ pyglove/core/typing/callable_signature_test.py,sha256=iQmHsKPhJPQlMikDhEyxKyq7yW
 pyglove/core/typing/class_schema.py,sha256=xfPrLYpqntejMLvSL-7rNiXHTQOgAr2kmxWeR890qLs,53940
 pyglove/core/typing/class_schema_test.py,sha256=UWANPqhu9v_FHNo3cVe05P-bO-HliBmrSBywKrlWep0,29204
 pyglove/core/typing/custom_typing.py,sha256=qdnIKHWNt5kZAAFdpQXra8bBu6RljMbbJ_YDG2mhAUA,2205
-pyglove/core/typing/inspect.py,sha256=Tp2rYqRvMFvL0NzkJo4p04_hQSF__Eip8RduhEaSFfE,7046
-pyglove/core/typing/inspect_test.py,sha256=vJ-MZvSPjzzA7sDY6XIeMeX_aob_6VjGQcIIn_MJl64,8826
+pyglove/core/typing/inspect.py,sha256=VLSz1KAunNm2hx0eEMjiwxKLl9FHlKr9nHelLT25iEA,7726
+pyglove/core/typing/inspect_test.py,sha256=xclevobF0X8c_B5b1q1dkBJZN1TsVA1RUhk5l25DUCM,10248
 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
-pyglove/core/typing/type_conversion.py,sha256=6diZrxNsvSyTLLNdoCqcWatWmhh7kZOiKCesyg-nEYQ,5167
-pyglove/core/typing/type_conversion_test.py,sha256=qwNeotCb96vdUELVtA-0Ee19Jm4yOnPZuSIz5nyEbGo,5203
+pyglove/core/typing/type_conversion.py,sha256=0L4Cbsw_QiM-gpsn-4y-XLEIvwiUB16Clj9gCtoC_Xc,5224
+pyglove/core/typing/type_conversion_test.py,sha256=BhASOGvtKXmYLWKCELU1RVB_Nmt1V-saSkGogvsNL7E,5342
 pyglove/core/typing/typed_missing.py,sha256=-l1omAu0jBZv5BnsFYXBqfvQwVBnmPh_X1wcIKD9bOk,2734
 pyglove/core/typing/typed_missing_test.py,sha256=TCNsb1SRpFaVdxYn2mB_yaLuja8w5Qn5NP7uGiZVBWs,2301
 pyglove/core/typing/value_specs.py,sha256=Yxdrz4aURMBrtqUW4to-2Vptc6Z6oqQrLyMBiAZt2bc,102302
@@ -211,8 +211,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.dev202502020807.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-pyglove-0.4.5.dev202502020807.dist-info/METADATA,sha256=GrPVTap7aw6_4KTpGyqoYfIm6bsCSdrlYm4-ODrgUxs,7067
-pyglove-0.4.5.dev202502020807.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-pyglove-0.4.5.dev202502020807.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
-pyglove-0.4.5.dev202502020807.dist-info/RECORD,,
+pyglove-0.4.5.dev202502040809.dist-info/LICENSE,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+pyglove-0.4.5.dev202502040809.dist-info/METADATA,sha256=g47xUh8StCt5ojg7Arw96L0nds0Kl8hrGazZx7IsU10,7067
+pyglove-0.4.5.dev202502040809.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+pyglove-0.4.5.dev202502040809.dist-info/top_level.txt,sha256=wITzJSKcj8GZUkbq-MvUQnFadkiuAv_qv5qQMw0fIow,8
+pyglove-0.4.5.dev202502040809.dist-info/RECORD,,