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.

Author: ssam18

test_callable_fix.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Test script to verify the fix for issue #2008"""
+from functools import partial
+
+def test_function(x, y):
+    """Simple test function"""
+    return -(x**2 + y**2)
+
+def test_single_arg(x):
+    """Single argument function"""
+    return -(x**2)
+
+# Test with functools.partial
+partial_func = partial(test_function, 2)
+
+print("Testing functools.partial with dlib.find_max_global...")
+print(f"partial_func type: {type(partial_func)}")
+print(f"partial_func callable: {callable(partial_func)}")
+
+# This should work after the fix
+try:
+    import dlib
+    result = dlib.find_max_global(partial_func, [0.], [10.], 100)
+    print(f"✓ Success! Result: {result}")
+except AttributeError as e:
+    print(f"✗ Failed with AttributeError: {e}")
+except Exception as e:
+    print(f"✗ Failed with error: {e}")
+
+# Test with regular function (should still work)
+print("\nTesting regular function with dlib.find_max_global...")
+try:
+    import dlib
+    result = dlib.find_max_global(test_single_arg, [0.], [10.], 100)
+    print(f"✓ Success! Result: {result}")
+except Exception as e:
+    print(f"✗ Failed with error: {e}")
+
+# Test with lambda (should still work)
+print("\nTesting lambda with dlib.find_max_global...")
+try:
+    import dlib
+    result = dlib.find_max_global(lambda x: -(x**2), [0.], [10.], 100)
+    print(f"✓ Success! Result: {result}")
+except Exception as e:
+    print(f"✗ Failed with error: {e}")

tools/python/src/global_optimization.cpp

@@ -48,11 +48,42 @@ 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");
+        auto num = py::len(params);
+        
+        // Check if function accepts *args (VAR_POSITIONAL)
+        bool has_var_args = false;
+        for (auto item : params) {
+            auto param = item.second.cast<py::object>();
+            auto kind = param.attr("kind");
+            // inspect.Parameter.VAR_POSITIONAL == 2
+            if (kind.cast<int>() == 2) {
+                has_var_args = true;
+                break;
+            }
+        }
+        
+        if (num < expected_num && has_var_args)
+            return expected_num;
+        return num;
+    } 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)