Improvements to code style

Author: fjwillemsen

kernel_tuner/searchspace.py

@@ -496,7 +496,12 @@ def __build_searchspace(self, block_size_names: list, max_threads: int, solver:
     def __add_restrictions(self, parameter_space: Problem) -> Problem:
         """Add the user-specified restrictions as constraints on the parameter space."""
         restrictions = deepcopy(self.restrictions)
-        if len(restrictions) == 1 and not isinstance(restrictions[0], (Constraint, FunctionConstraint, str)) and callable(restrictions[0]) and len(signature(restrictions[0]).parameters) == 1:
+        # differentiate between old style monolithic with single 'p' argument and newer *args style
+        if (len(restrictions) == 1 
+            and not isinstance(restrictions[0], (Constraint, FunctionConstraint, str)) 
+            and callable(restrictions[0]) 
+            and len(signature(restrictions[0]).parameters) == 1 
+            and len(self.param_names) > 1):
             restrictions = restrictions[0]
         if isinstance(restrictions, list):
             for restriction in restrictions:
@@ -507,16 +512,7 @@ def __add_restrictions(self, parameter_space: Problem) -> Problem:
                     required_params = restriction[1]
                     restriction = restriction[0]
                 if callable(restriction) and not isinstance(restriction, Constraint):
-                    # differentiate between old style monolithic with single 'p' argument and newer *args style
-                    if len(signature(restriction).parameters) == 1 and len(self.param_names) != 1:
-                        def restrictions_wrapper(*args):
-                            # raise ValueError(self.param_names, args, restriction, signature(restriction).parameters)
-                            # return restriction(dict(zip(self.param_names, args)))
-                            return check_instance_restrictions(restriction, dict(zip(self.param_names, args)), False)
-
-                        restriction = FunctionConstraint(restrictions_wrapper)
-                    else:
-                        restriction = FunctionConstraint(restriction, required_params)
+                    restriction = FunctionConstraint(restriction, required_params)
 
                 # add as a Constraint
                 all_params_required = all(param_name in required_params for param_name in self.param_names)
@@ -537,6 +533,7 @@ def restrictions_wrapper(*args):
         elif callable(restrictions):
 
             def restrictions_wrapper(*args):
+                """Wrap old-style monolithic restrictions to work with multiple arguments."""
                 return check_instance_restrictions(restrictions, dict(zip(self.param_names, args)), False)
 
             parameter_space.addConstraint(FunctionConstraint(restrictions_wrapper), self.param_names)