Refactored to meet Sonarcloud cognitive complexity

Author: fjwillemsen

kernel_tuner/util.py

@@ -248,9 +248,37 @@ def check_block_size_params_names_list(block_size_names, tune_params):
                 UserWarning,
             )
 
+def check_restriction(restrict, params: dict) -> bool:
+    """Check whether a configuration meets a search space restriction."""
+    # if it's a python-constraint, convert to function and execute
+    if isinstance(restrict, Constraint):
+        restrict = convert_constraint_restriction(restrict)
+        return restrict(list(params.values()))
+    # if it's a string, fill in the parameters and evaluate
+    elif isinstance(restrict, str):
+        return eval(replace_param_occurrences(restrict, params))
+    # if it's a function, call it
+    elif callable(restrict):
+        return restrict(**params)
+    # if it's a tuple, use only the parameters in the second argument to call the restriction
+    elif (isinstance(restrict, tuple) and len(restrict) == 2
+        and callable(restrict[0]) and isinstance(restrict[1], (list, tuple))):
+        # unpack the tuple
+        restrict, selected_params = restrict
+        # look up the selected parameters and their value
+        selected_params = dict((key, params[key]) for key in selected_params)
+        # call the restriction
+        if isinstance(restrict, Constraint):
+            restrict = convert_constraint_restriction(restrict)
+            return restrict(list(selected_params.values()))
+        else:
+            return restrict(**selected_params)
+    # otherwise, raise an error
+    else:
+        raise ValueError(f"Unkown restriction type {type(restrict)} ({restrict})")
 
 def check_restrictions(restrictions, params: dict, verbose: bool) -> bool:
-    """Check whether a specific configuration meets the search space restrictions."""
+    """Check whether a configuration meets the search space restrictions."""
     if callable(restrictions):
         valid = restrictions(params)
         if not valid and verbose is True:
@@ -260,46 +288,13 @@ def check_restrictions(restrictions, params: dict, verbose: bool) -> bool:
     for restrict in restrictions:
         # Check the type of each restriction and validate accordingly. Re-implement as a switch when Python >= 3.10.
         try:
-            # if it's a python-constraint, convert to function and execute
-            if isinstance(restrict, Constraint):
-                restrict = convert_constraint_restriction(restrict)
-                if not restrict(list(params.values())):
-                    valid = False
-                    break
-            # if it's a string, fill in the parameters and evaluate
-            elif isinstance(restrict, str):
-                if not eval(replace_param_occurrences(restrict, params)):
-                    valid = False
-                    break
-            # if it's a function, call it
-            elif callable(restrict):
-                if not restrict(**params):
-                    valid = False
-                    break
-            # if it's a tuple, use only the parameters in the second argument to call the restriction
-            elif (isinstance(restrict, tuple) and len(restrict) == 2
-                and callable(restrict[0]) and isinstance(restrict[1], (list, tuple))):
-                # unpack the tuple
-                restrict, selected_params = restrict
-                # look up the selected parameters and their value
-                selected_params = dict((key, params[key]) for key in selected_params)
-                # call the restriction
-                if isinstance(restrict, Constraint):
-                    restrict = convert_constraint_restriction(restrict)
-                    if not restrict(list(selected_params.values())):
-                        valid = False
-                        break
-                else:
-                    if not restrict(**selected_params):
-                        valid = False
-                        break
-            # otherwise, raise an error
-            else:
-                raise ValueError(f"Unkown restriction type {type(restrict)} ({restrict})")
+            valid = check_restriction(restrict, params)
+            if not valid:
+                break
         except ZeroDivisionError:
             logging.debug(f"Restriction {restrict} with configuration {get_instance_string(params)} divides by zero.")
     if not valid and verbose is True:
-        print(f"skipping config {get_instance_string(params)}, reason: config fails restriction")
+        print(f"skipping config {get_instance_string(params)}, reason: config fails restriction {restrict}")
     return valid