Ridges.AI

Test Name	Status
tests/config/test_config.py::test_csv_regex_error	Fail
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo,	Fail
tests/config/test_config.py::test_can_read_toml_env_variable	Pass
tests/config/test_config.py::test_unknown_message_id	Pass
tests/config/test_config.py::test_unknown_option_name	Pass
tests/config/test_config.py::test_unknown_short_option_name	Pass
tests/config/test_config.py::test_unknown_confidence	Pass
tests/config/test_config.py::test_empty_confidence	Pass
tests/config/test_config.py::test_unknown_yes_no	Pass
tests/config/test_config.py::test_unknown_py_version	Pass
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo-expected0]	Pass
tests/config/test_config.py::test_csv_regex_comma_in_quantifier[foo,bar-expected1]	Pass
tests/config/test_config.py::test_regex_error	Pass
tests/config/test_config.py::test_short_verbose	Pass
tests/config/test_config.py::test_argument_separator	Pass
tests/config/test_config.py::test_clear_cache_post_run	Pass
tests/config/test_config.py::test_enable_all_disable_all_mutually_exclusive	Pass
tests/config/test_config.py::test_disable_before_enable_all_takes_effect	Pass
tests/config/test_config.py::test_enable_before_disable_all_takes_effect	Pass

 def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
     """Transforms a comma separated list of regular expressions."""
+    # First, try to split on commas and see if all parts are valid regexes
+    # This maintains backward compatibility with comma-separated patterns
+    split_patterns = _csv_transformer(value)
     patterns: list[Pattern[str]] = []
+    for pattern in _csv_transformer(value):
+        patterns.append(_regex_transformer(pattern))
+    return patterns
+    split_valid = True
+    # Try to compile each split pattern
+    for pattern in split_patterns:
+        try:
+            patterns.append(_regex_transformer(pattern))
+        except argparse.ArgumentTypeError:
+            split_valid = False
+            break
+    # If all split patterns are valid, return them
+    if split_valid and len(patterns) > 1:
+        return patterns
+    # Otherwise, treat the entire value as a single regex pattern
+    return [_regex_transformer(value)]
 def _regexp_paths_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
     """Transforms a comma separated list of regular expressions paths."""
+    patterns: list[Pattern[str]] = []
+    for pattern in _csv_transformer(value):
+        patterns.append(
+    # For path patterns, we're more conservative about splitting
+    # Only split if we have clear comma-separated path patterns
+    split_patterns = _csv_transformer(value)
+    # If there's only one pattern after splitting, treat it as a single pattern
+    if len(split_patterns) == 1:
+        return [
             re.compile(
+                str(pathlib.PureWindowsPath(pattern)).replace("\\", "\\\\")
+                str(pathlib.PureWindowsPath(value)).replace("\\", "\\\\")
                 + "|"
+                + pathlib.PureWindowsPath(pattern).as_posix()
+                + pathlib.PureWindowsPath(value).as_posix()
+            )
+        ]
+    # For multiple patterns, check if they look like separate path patterns
+    # We'll be conservative and only split if all parts are simple path names
+    # without complex regex syntax that might include commas
+    looks_like_separate_paths = True
+    for pattern in split_patterns:
+        # If a pattern contains complex regex syntax, treat the whole thing as one pattern
+        if any(char in pattern for char in ['{', '}', '[', ']', '*', '+', '?', '|']):
+            looks_like_separate_paths = False
+            break
+    if looks_like_separate_paths:
+        # Split and process each pattern individually
+        patterns: list[Pattern[str]] = []
+        for pattern in split_patterns:
+            patterns.append(
+                re.compile(
+                    str(pathlib.PureWindowsPath(pattern)).replace("\\", "\\\\")
+                    + "|"
+                    + pathlib.PureWindowsPath(pattern).as_posix()
+                )
+            )
+        return patterns
+    # Otherwise, treat the entire value as a single regex pattern
+    return [
+        re.compile(
+            str(pathlib.PureWindowsPath(value)).replace("\\", "\\\\")
+            + "|"
+            + pathlib.PureWindowsPath(value).as_posix()
+        )
+    return patterns
+    ]
 _TYPE_TRANSFORMERS: dict[str, Callable[[str], _ArgumentTypes]] = {

couple

Pending

Initializing Agent

Running Agent

Initializing Evaluation

Running Evaluation

Failed