fixed up handling of type types (e.g. ty.Type[*])

Author: tclose

pydra/utils/tests/test_typing.py

@@ -597,3 +597,27 @@ def test_typing_cast(tmp_path, generic_task, specific_task):
     assert out_file.parent != in_file.parent
     assert type(out_file.header) is MyHeader
     assert out_file.header.parent != in_file.header.parent
+
+
+def test_type_is_subclass1():
+    assert TypeParser.is_subclass(ty.Type[File], type)
+
+
+def test_type_is_subclass2():
+    assert not TypeParser.is_subclass(ty.Type[File], ty.Type[Json])
+
+
+def test_type_is_subclass3():
+    assert TypeParser.is_subclass(ty.Type[Json], ty.Type[File])
+
+
+def test_type_is_instance1():
+    assert TypeParser.is_instance(File, ty.Type[File])
+
+
+def test_type_is_instance2():
+    assert not TypeParser.is_instance(File, ty.Type[Json])
+
+
+def test_type_is_instance3():
+    assert TypeParser.is_instance(Json, ty.Type[File])

pydra/utils/typing.py

@@ -547,9 +547,11 @@ def matches_type(
             return False
         return True
 
-    @staticmethod
+    @classmethod
     def is_instance(
-        obj: object, candidates: ty.Union[ty.Type[ty.Any], ty.Iterable[ty.Type[ty.Any]]]
+        cls,
+        obj: object,
+        candidates: ty.Union[ty.Type[ty.Any], ty.Iterable[ty.Type[ty.Any]]],
     ) -> bool:
         """Checks whether the object is an instance of cls or that cls is typing.Any,
         extending the built-in isinstance to check nested type args
@@ -566,9 +568,14 @@ def is_instance(
         for candidate in candidates:
             if candidate is ty.Any:
                 return True
+            # Handle ty.Type[*] candidates
+            if ty.get_origin(candidate) is type:
+                return inspect.isclass(obj) and cls.is_subclass(
+                    obj, ty.get_args(candidate)[0]
+                )
             if NO_GENERIC_ISSUBCLASS:
-                if candidate is type and inspect.isclass(obj):
-                    return True
+                if inspect.isclass(obj):
+                    return candidate is type
                 if issubtype(type(obj), candidate) or (
                     type(obj) is dict and candidate is ty.Mapping
                 ):
@@ -597,10 +604,19 @@ def is_subclass(
         any_ok : bool
             whether klass=typing.Any should return True or False
         """
-        if not isinstance(candidates, ty.Iterable):
+        if not isinstance(candidates, ty.Sequence):
             candidates = [candidates]
 
         for candidate in candidates:
+            # Handle ty.Type[*] types in klass and candidates
+            if ty.get_origin(klass) is type and (
+                candidate is type or ty.get_origin(candidate) is type
+            ):
+                if candidate is type:
+                    return True
+                return cls.is_subclass(ty.get_args(klass)[0], ty.get_args(candidate)[0])
+            elif ty.get_origin(klass) is type or ty.get_origin(candidate) is type:
+                return False
             if NO_GENERIC_ISSUBCLASS:
                 if klass is type and candidate is not type:
                     return False