feat: add click callback to parse sequence of regexes

Author: candleindark

dandi/cli/base.py

@@ -1,5 +1,7 @@
 from functools import wraps
 import os
+import re
+from typing import Optional
 
 import click
 
@@ -147,3 +149,61 @@ def wrapper(obj, *args, **kwargs):
 map_to_click_exceptions._do_map = not bool(  # type: ignore[attr-defined]
     os.environ.get("DANDI_DEVEL", None)
 )
+
+
+def _compile_regex(regex: str) -> re.Pattern:
+    """
+    Helper to compile a regex pattern expressed as an `str` into a `re.Pattern`
+
+    Parameters
+    ----------
+    regex : str
+        The regex pattern expressed as a string.
+
+    Returns
+    -------
+    re.Pattern
+        The compiled regex pattern.
+    """
+    try:
+        compiled_regex = re.compile(regex)
+    except re.error as e:
+        raise click.BadParameter(f"Invalid regex pattern {regex!r}: {e}") from e
+
+    return compiled_regex
+
+
+def parse_regexes(
+    _ctx: click.Context, _param: click.Parameter, value: Optional[str]
+) -> Optional[list[re.Pattern]]:
+    """
+    Callback to parse a string of comma-separated regex patterns
+
+    Parameters
+    ----------
+    _ctx : click.Context
+        The Click context (not used).
+
+    _param : click.Parameter
+        The Click parameter (not used).
+
+    value : str | None
+        The input string containing comma-separated regex patterns. It is assumed
+        that none of the patterns contain commas themselves.
+
+    Returns
+    -------
+    list[re.Pattern]
+        A list of compiled regex patterns.
+
+    Notes
+    -----
+        This callback is only suitable to parse patterns that do not contain commas.
+    """
+    if value is None:
+        # Handle the case where no value is provided
+        return None
+
+    regexes = set(value.split(","))
+
+    return [_compile_regex(regex) for regex in regexes]

dandi/cli/tests/test_base.py

@@ -0,0 +1,81 @@
+import re
+
+import click
+import pytest
+
+from dandi.cli.base import _compile_regex, parse_regexes
+
+DUMMY_CTX = click.Context(click.Command("dummy"))
+DUMMY_PARAM = click.Option(["--dummy"])
+
+
+class TestCompileRegex:
+    @pytest.mark.parametrize(
+        "pattern",
+        [
+            "abc",
+            "[a-z]+",
+            "^start$",
+            r"a\.b",
+        ],
+    )
+    def test_valid_patterns_return_pattern(self, pattern):
+        compiled = _compile_regex(pattern)
+        assert isinstance(compiled, re.Pattern)
+
+    @pytest.mark.parametrize("pattern", ["(", "[a-z", "\\"])
+    def test_invalid_patterns_raise_bad_parameter(self, pattern):
+        with pytest.raises(click.BadParameter) as exc_info:
+            _compile_regex(pattern)
+        msg = str(exc_info.value)
+        assert "Invalid regex pattern" in msg
+        assert repr(pattern) in msg
+
+
+class TestParseRegexes:
+    def test_none_returns_none(self):
+        assert parse_regexes(DUMMY_CTX, DUMMY_PARAM, None) is None
+
+    @pytest.mark.parametrize(
+        "value",
+        [
+            "abc",
+            "[a-z]+",
+            r"a\.b",
+            r"",
+        ],
+    )
+    def test_single_pattern(self, value):
+        expected_pattern = re.compile(value)
+
+        result = parse_regexes(DUMMY_CTX, DUMMY_PARAM, value)
+        assert isinstance(result, list)
+        assert len(result) == 1
+
+        (compiled,) = result
+        assert isinstance(compiled, re.Pattern)
+        assert compiled == expected_pattern
+
+    @pytest.mark.parametrize(
+        "value, expected_patterns_in_strs",
+        [
+            ("foo,,bar", ["foo", "", "bar"]),
+            ("^start$,end$", ["^start$", "end$"]),
+            (r"a\.b,c+d", [r"a\.b", r"c+d"]),
+            # duplicates should be collapsed by the internal set()
+            ("foo,foo,bar", ["foo", "bar"]),
+        ],
+    )
+    def test_multiple_patterns(self, value, expected_patterns_in_strs):
+        result = parse_regexes(DUMMY_CTX, DUMMY_PARAM, value)
+        assert isinstance(result, list)
+
+        expected_result_as_set = set(re.compile(p) for p in expected_patterns_in_strs)
+        assert set(result) == expected_result_as_set
+
+    @pytest.mark.parametrize(
+        "value, bad_pattern", [("(", "("), ("foo,(", "("), ("good,[a-z", "[a-z")]
+    )
+    def test_invalid_pattern_raises_bad_parameter(self, value, bad_pattern):
+        with pytest.raises(click.BadParameter, match=re.escape(bad_pattern)):
+            parse_regexes(DUMMY_CTX, DUMMY_PARAM, value)