Fix callable detection to support functools.partial and all callable objects (#3121)

* Fix callable detection to support all callable objects (functools.partial, etc)

Fixes #2008

The old implementation checked for __code__ attribute directly, which
doesn't exist for callable objects like functools.partial. This caused
an AttributeError when trying to use such objects with find_max_global
and find_min_global functions.

Changed to use Python's inspect.signature() which properly handles all
callable objects including:
- Regular functions
- Lambda functions
- functools.partial objects
- Class methods
- Any object with __call__ method

The fix includes a fallback to the old __code__ method for backward
compatibility in case inspect.signature fails for any reason.

* Update the code to loop through params.values() instead of params itself, since parameters is a dictionary-like object. The earlier code tried to access .second on the iterator, which isn’t valid when working with dict values

Signed-off-by: Samaresh Kumar Singh <[email protected]>

* Fix parameter counting to exclude *args and **kwargs

The previous code was counting VAR_POSITIONAL (*args) and VAR_KEYWORD
(**kwargs) parameters in the total count, which caused functions like
'lambda a, b, c, *args' to be counted as having 4 parameters instead
of 3. Now only regular parameters are counted, while still checking
for the presence of *args to allow variable argument functions.

Also removed test_callable_fix.py as it was causing pytest errors.

Signed-off-by: Samaresh Kumar Singh <[email protected]>

---------

Signed-off-by: Samaresh Kumar Singh <[email protected]>

Author: ssam18

tools/python/src/global_optimization.cpp

@@ -48,11 +48,45 @@ py::list mat_to_list (
 
 size_t num_function_arguments(py::object f, size_t expected_num)
 {
-    const auto code_object = f.attr(hasattr(f,"func_code") ? "func_code" : "__code__");
-    const auto num = code_object.attr("co_argcount").cast<std::size_t>();
-    if (num < expected_num && (code_object.attr("co_flags").cast<int>() & CO_VARARGS))
-        return expected_num;
-    return num;
+    // Use Python's inspect module to get signature, which works with all callable objects
+    // including functools.partial, lambdas, and regular functions
+    auto inspect = py::module_::import("inspect");
+    
+    try {
+        auto sig = inspect.attr("signature")(f);
+        auto params = sig.attr("parameters");
+        
+        // Count only regular parameters, excluding VAR_POSITIONAL (*args) and VAR_KEYWORD (**kwargs)
+        size_t num_regular_params = 0;
+        bool has_var_args = false;
+        
+        for (auto item : params.attr("values")()) {
+            auto param = item.cast<py::object>();
+            auto kind = param.attr("kind").cast<int>();
+            // inspect.Parameter.VAR_POSITIONAL == 2, VAR_KEYWORD == 4
+            if (kind == 2) {
+                has_var_args = true;
+            } else if (kind != 4) {
+                // Count all parameters except VAR_POSITIONAL and VAR_KEYWORD
+                num_regular_params++;
+            }
+        }
+        
+        if (num_regular_params < expected_num && has_var_args)
+            return expected_num;
+        return num_regular_params;
+    } catch (const py::error_already_set&) {
+        // Fallback to old method if inspect.signature fails
+        // This maintains backward compatibility
+        if (!hasattr(f, "__code__") && !hasattr(f, "func_code")) {
+            throw;
+        }
+        const auto code_object = f.attr(hasattr(f,"func_code") ? "func_code" : "__code__");
+        const auto num = code_object.attr("co_argcount").cast<std::size_t>();
+        if (num < expected_num && (code_object.attr("co_flags").cast<int>() & CO_VARARGS))
+            return expected_num;
+        return num;
+    }
 }
 
 double call_func(py::object f, const matrix<double,0,1>& args)