Fix/callable protocols 2

CHANGELOG.rst

@@ -11,6 +11,13 @@ The semantic versioning only considers the public API as described in
 :ref:`api-ref`. Components not mentioned in :ref:`api-ref` or different import
 paths are considered internals and can change in minor and patch releases.
 
+v4.34.1 (2024-10-??)
+--------------------
+
+Fixed
+^^^^^
+- Fix callable protocol inheritance.
+
 
 v4.34.0 (2024-10-??)
 --------------------

jsonargparse/_typehints.py

@@ -1101,14 +1101,15 @@ def adapt_typehints(
 
 
 def implements_protocol(value, protocol) -> bool:
+    allowed_dunder_methods = {"__call__"}
     from jsonargparse._parameter_resolvers import get_signature_parameters
     from jsonargparse._postponed_annotations import get_return_type
 
-    if not inspect.isclass(value):
+    if not inspect.isclass(value):  # Should we check if callables implement protocols?
         return False
     members = 0
     for name, _ in inspect.getmembers(protocol, predicate=inspect.isfunction):
-        if name.startswith("_"):
+        if name.startswith("_") and name not in allowed_dunder_methods:
             continue
         if not hasattr(value, name):
             return False

jsonargparse_tests/test_subclasses.py

@@ -1485,6 +1485,61 @@
     ctx.match("Not a valid subclass of Interface")
 
 
+# callable protocol tests
+
+
+class CallableInterface(Protocol):
+    def __call__(self, items: List[float]) -> List[float]: ...
+
+
+class ImplementsCallableInterface1:
+    def __init__(self, batch_size: int):
+        self.batch_size = batch_size
+
+    def __call__(self, items: List[float]) -> List[float]:
+        return items
+
+
+def implements_callable_interface2(items: List[float]) -> List[float]:
+    return items
+
+
+class NotImplementsCallableInterface1:
+    def __call__(self, items: str) -> List[float]:
+        return []
+
+
+class NotImplementsCallableInterface2:
+    def __call__(self, items: List[float], extra: int) -> List[float]:
+        return items
+
+
+class NotImplementsCallableInterface3:
+    def __call__(self, items: List[float]) -> None:
+        return
+
+
+def not_implements_callable_interface4(items: str) -> List[float]:
+    return []
+
+
+@pytest.mark.parametrize(
+    "expected, value",
+    [
+        (True, ImplementsCallableInterface1),
+        (False, ImplementsCallableInterface1(1)),
+        (True, implements_callable_interface2),
+        (False, NotImplementsCallableInterface1),
+        (False, NotImplementsCallableInterface2),
+        (False, NotImplementsCallableInterface3),
+        (False, not_implements_callable_interface4),
+        (False, object),
+    ],
+)
+def test_implements_callable_protocol(expected, value):
+    assert implements_protocol(value, CallableInterface) is expected
+
+
 # parameter skip tests