fix: update FunctionDetector and RegexDetector to handle missing detection functions and patterns, returning None or 0.0 as appropriate

Author: saichandrapandraju

garak/detectors/function.py

@@ -140,19 +140,17 @@ def detect(self, attempt: garak.attempt.Attempt) -> List[float]:
         Returns:
             List of scores (0.0-1.0) for each output, or [None] * len if detector failed to initialize
         """
-        # If detection_function failed to load, return None for all outputs
-        if self.detection_function is None:
-            logging.error(
-                "function.FunctionDetector: Failed to load function %s",
-                self.function_name
-            )
-            return [None] * len(attempt.outputs)
-        
-        results = []
-        for output in attempt.outputs:
+        results = [None] * len(attempt.outputs)
+        for idx, output in enumerate(attempt.outputs):
             output_text = output.text if output else None
+            
             if output_text is None:
-                results.append(None)
+                continue
+
+            if self.detection_function is None:
+                logging.warning(
+                    "function.FunctionDetector: No detection function found (or failed to load), setting None",
+                )
                 continue
 
             try:
@@ -162,7 +160,7 @@ def detect(self, attempt: garak.attempt.Attempt) -> List[float]:
                 # Validate return type
                 if not isinstance(score, (int, float)):
                     logging.error(
-                        "function.FunctionDetector: %s returned non-numeric value: %s (type: %s)",
+                        "function.FunctionDetector: %s returned non-numeric value: %s (type: %s). Setting 0.0",
                         self.function_name, score, type(score)
                     )
                     score = 0.0
@@ -174,13 +172,13 @@ def detect(self, attempt: garak.attempt.Attempt) -> List[float]:
                         "function.FunctionDetector: %s returned score outside 0-1 range: %s (clamped to %s)",
                         self.function_name, score, score_clamped
                     )
-                results.append(score_clamped)
+                results[idx] = score_clamped
 
             except Exception as e:
                 logging.error(
                     "function.FunctionDetector: Error calling %s: %s",
                     self.function_name, e, exc_info=e
                 )
-                results.append(None)  # Default to None on error
+                results[idx] = None  # Default to None on error
 
         return results

garak/detectors/regex.py

@@ -145,17 +145,20 @@ def detect(self, attempt: garak.attempt.Attempt) -> List[float]:
             List of scores (0.0 or 1.0) for each output
         """
         results = [None] * len(attempt.outputs)
-        if not self.compiled_patterns:
-            logging.error(
-                "regex.RegexDetector: No compiled patterns found, returning None for all outputs"
-            )
-            return results
 
         for idx, output in enumerate(attempt.outputs):
             output_text = output.text if output else None
             if output_text is None:
                 continue
 
+            # If no patterns configured, return 0.0 (no match) for valid outputs
+            if not self.compiled_patterns:
+                logging.warning(
+                    "regex.RegexDetector: No compiled patterns found, setting 0.0 (no match or safe)"
+                )
+                results[idx] = 0.0
+                continue
+
             # Check patterns based on match_type
             matched = False
             if self.match_type == "any":

tests/detectors/test_detectors_regex.py

@@ -159,7 +159,7 @@ def test_none_output_handling(self):
         assert results[2] == 0.0
 
     def test_empty_patterns_returns_safe(self):
-        """Test that RegexDetector with no patterns returns None"""
+        """Test that RegexDetector with no patterns returns 0.0 (safe)"""
         config = {
                 'detectors': {
                     'regex': {
@@ -176,7 +176,7 @@ def test_empty_patterns_returns_safe(self):
         attempt.outputs = [garak.attempt.Message("any text here")]
 
         results = detector.detect(attempt)
-        assert results[0] is None  # None with no patterns
+        assert results[0] == 0.0  # Safe with no patterns
 
     def test_multiline_flag(self):
         """Test MULTILINE flag for matching at line boundaries"""
@@ -442,7 +442,7 @@ def test_single_string_re_flags_normalized(self):
         assert 'MULTILINE' in detector.re_flags
 
     def test_all_invalid_patterns_returns_safe(self):
-        """Test that if all patterns are invalid, detector returns None"""
+        """Test that if all patterns are invalid, detector returns 0.0 (safe)"""
         config = {
                 'detectors': {
                     'regex': {
@@ -459,9 +459,9 @@ def test_all_invalid_patterns_returns_safe(self):
         # No valid patterns compiled
         assert len(detector.compiled_patterns) == 0
 
-        # Should return None
+        # Should return safe (0.0)
         attempt = garak.attempt.Attempt(prompt=garak.attempt.Message())
         attempt.outputs = [garak.attempt.Message("any text")]
 
         results = detector.detect(attempt)
-        assert results[0] is None  # None when no valid patterns
+        assert results[0] == 0.0  # Safe when no valid patterns