pyglove 0.4.5.dev202502020807__tar.gz → 0.4.5.dev202502040809__tar.gz

{pyglove-0.4.5.dev202502020807 → pyglove-0.4.5.dev202502040809}/PKG-INFO

@@ -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 → pyglove-0.4.5.dev202502040809}/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-0.4.5.dev202502020807 → pyglove-0.4.5.dev202502040809}/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-0.4.5.dev202502020807 → pyglove-0.4.5.dev202502040809}/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-0.4.5.dev202502020807 → pyglove-0.4.5.dev202502040809}/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 → pyglove-0.4.5.dev202502040809}/pyglove.egg-info/PKG-INFO

@@ -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