add support for method overloads

Author: siliataider

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_rdf_pyz.py

@@ -269,6 +269,31 @@ def get_column_types(rdf, cols):
     types = [rdf.GetColumnType(col) for col in cols]
     return types
 
+def get_overload_based_on_args(signatures, types):
+    """
+    Gets the C++ overloads for a function based on the provided signatures and types.
+    """
+    if not isinstance(signatures, list) or not all(isinstance(sig, str) for sig in signatures):
+        raise TypeError("Function signatures must be a list of strings.")
+
+    if not isinstance(types, list) or not all(isinstance(t, str) for t in types):
+        raise TypeError("Types must be a list of strings.")
+
+    if len(signatures) == 1:
+        # If there is only one signature, return it directly
+        return signatures[0]
+
+    for sig in signatures:
+        args_str = sig[sig.index('(') + 1:sig.rindex(')')]
+
+        if not args_str and not types:
+            return sig
+
+        args = [arg.strip() for arg in args_str.split(',') if arg.strip()]
+
+        if len(args) == len(types):
+            return sig
+
 def _get_cpp_signature(func, rdf, cols):
     """
     Gets the C++ signature of a cppyy callable.
@@ -286,12 +311,7 @@ def _get_cpp_signature(func, rdf, cols):
         raise ValueError(f"Function {func} has no `__overload__` method, cannot deduce signature.")
 
     signatures = [remove_fn_name_from_signature(sig) for sig in get_overloads()]
-    if len(signatures) != 1:
-        raise NotImplementedError(
-            f"Function {func} has multiple overloads :)"
-        )
-
-    return signatures[0]
+    return get_overload_based_on_args(signatures, get_column_types(rdf, cols))
 
 def _to_std_function(func, rdf, cols):
     """
@@ -310,6 +330,7 @@ def _handle_cpp_callables(func, original_template, *args, rdf=None, cols=None):
     Checks whether the callable `func` is a cppyy proxy of one of these:
     1. C++ functor
     2. std::function
+    3. C++ free function
 
     The cases above are supported by cppyy, so we can just invoke the original
     cppyy TemplateProxy (Filter or Define) with the callable as argument.
@@ -332,12 +353,18 @@ def _handle_cpp_callables(func, original_template, *args, rdf=None, cols=None):
 
     is_cpp_functor  = lambda : isinstance(getattr(func, '__call__', None), cppyy._backend.CPPOverload)
 
-    # handle free functions
-    if callable(func) and not is_cpp_functor():
-        func = _to_std_function(func, rdf, cols)
-
     is_std_function = lambda : isinstance(getattr(func, 'target_type', None), cppyy._backend.CPPOverload)
 
+    # handle free functions
+    if callable(func) and not is_cpp_functor() and not is_std_function():
+        try:
+            func = _to_std_function(func, rdf, cols)
+        except TypeError as e:
+            if "Expected a cppyy callable" in str(e):
+                pass # this function is not convertible to std::function, move on to the next check
+            else:
+                raise
+
     if is_cpp_functor() or is_std_function():
         return original_template[type(func)](*args)