Validation against certain rules including strict checking of casing as an option (#51)

* Validate against certain rules. Validation now returns a list of valid rules or an empty list if none found

Author: xiancg

docs/source/changelog.rst

@@ -1,6 +1,13 @@
 Changelog
 ================================
 
+1.5.1-beta
+---------------------------------------
+
+**Improvements:**
+    - Adds strict validation option. If strict is True, the name must match exactly the casing the rule.
+    - If no rule names are passed to with_rules, only the active rule is validated.
+
 1.4.5-beta
 ---------------------------------------
 

docs/source/usage/validating.rst

@@ -14,6 +14,8 @@ Many times the only thing we need is to know if a name is valid or not for a giv
 - The number of expected separators must match with the rule.
 - If tokens have options, the given name must use one of those options.
 - If token is a number, validates suffix, prefix and padding.
+- If strict is passed as True to the validate function, the name must match exactly the casing the rule.
+- If no rule names are passed to with_rules, only the active rule is validated.
 
 Let's set these Tokens and Rule.
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vfxnaming"
-version = "1.5.0-beta"
+version = "1.5.1-beta"
 authors = [
   { name="Chris Granados", email="info@chrisgranados.com" },
 ]

src/vfxnaming/naming.py

@@ -24,7 +24,7 @@
 import vfxnaming.rules as rules
 import vfxnaming.tokens as tokens
 from pathlib import Path
-from typing import AnyStr, Dict, Union
+from typing import AnyStr, Dict, Union, Iterable
 
 from vfxnaming.logger import logger
 from vfxnaming.error import SolvingError, RepoError
@@ -138,9 +138,12 @@ def solve(*args, **kwargs) -> AnyStr:
     return rule.solve(**values)
 
 
-def validate(name: AnyStr, **kwargs) -> bool:
-    """Validates a name string against the currently active rule and its
-    tokens if passed as keyword arguments.
+def validate(  # noqa: C901
+    name: AnyStr, with_rules: Iterable[str] = [], strict: bool = False, **kwargs
+) -> Iterable[rules.Rule]:
+    """Validates a name string against the currently active rule if no rules are passed or
+    against the list of specific rules passed in with_rules.
+    It also validates its tokens if passed as keyword arguments.
 
     -For rules with repeated tokens:
 
@@ -162,50 +165,77 @@ def validate(name: AnyStr, **kwargs) -> bool:
     Args:
         name (str): Name string e.g.: C_helmet_001_MSH
 
+        with_rules (list, optional): List of rule names to validate against. Defaults to [].
+
+        strict (bool, optional): If False, it'll try to accept casing mismatches.
+
         kwargs (dict): Keyword arguments with token names and values.
 
     Returns:
-        bool: True if the name is valid, False otherwise.
+        list: List of validated rules. Empty list if no rule could be validated.
     """
-    rule = rules.get_active_rule()
-    # * This accounts for those cases where a token is used more than once in a rule
-    repeated_fields = dict()
-    for each in rule.fields:
-        if each not in repeated_fields.keys():
-            if rule.fields.count(each) > 1:
-                repeated_fields[each] = 1
-    fields_with_digits = list()
-    for each in rule.fields:
-        if each in repeated_fields.keys():
-            counter = repeated_fields.get(each)
-            repeated_fields[each] = counter + 1
-            fields_with_digits.append(f"{each}{counter}")
-        else:
-            fields_with_digits.append(each)
-    values = {}
-    fields_inc = 0
-    for f in fields_with_digits:
-        token = tokens.get_token(rule.fields[fields_inc])
-        if token:
-            # Explicitly passed as keyword argument
-            if kwargs.get(f) is not None:
-                values[f] = token.solve(kwargs.get(f))
-                fields_inc += 1
-                continue
-            # Explicitly passed as keyword argument without repetitive digits
-            # Use passed argument for all field repetitions
-            elif kwargs.get(rule.fields[fields_inc]) is not None:
-                values[f] = token.solve(kwargs.get(rule.fields[fields_inc]))
-                fields_inc += 1
-                continue
-            elif token.required and isinstance(token, tokens.Token):
-                if len(token.fallback):
-                    values[f] = token.fallback
+    previously_active_rule = rules.get_active_rule()
+    if not len(with_rules):
+        with_rules = [previously_active_rule.name]
+    validated: Iterable[rules.Rule] = []
+    for with_rule in with_rules:
+        rule = rules.get_rule(with_rule)
+        if not rule:
+            logger.warning(f"Rule {with_rule} not found.")
+
+        rules.set_active_rule(rule)
+        # * This accounts for those cases where a token is used more than once in a rule
+        repeated_fields = dict()
+        for each in rule.fields:
+            if each not in repeated_fields.keys():
+                if rule.fields.count(each) > 1:
+                    repeated_fields[each] = 1
+        fields_with_digits = list()
+        for each in rule.fields:
+            if each in repeated_fields.keys():
+                counter = repeated_fields.get(each)
+                repeated_fields[each] = counter + 1
+                fields_with_digits.append(f"{each}{counter}")
+            else:
+                fields_with_digits.append(each)
+        values = {}
+        fields_inc = 0
+        for f in fields_with_digits:
+            token = tokens.get_token(rule.fields[fields_inc])
+            if token:
+                # Explicitly passed as keyword argument
+                if kwargs.get(f) is not None:
+                    values[f] = token.solve(kwargs.get(f))
                     fields_inc += 1
                     continue
-            fields_inc += 1
-    logger.debug(f"Validating rule '{rule.name}' with values {values}")
-    return rule.validate(name, **values)
+                # Explicitly passed as keyword argument without repetitive digits
+                # Use passed argument for all field repetitions
+                elif kwargs.get(rule.fields[fields_inc]) is not None:
+                    values[f] = token.solve(kwargs.get(rule.fields[fields_inc]))
+                    fields_inc += 1
+                    continue
+                elif token.required and isinstance(token, tokens.Token):
+                    if len(token.fallback):
+                        values[f] = token.fallback
+                        fields_inc += 1
+                        continue
+                fields_inc += 1
+        logger.debug(f"Validating rule '{rule.name}' with values {values}")
+        validation = rule.validate(name, strict, **values)
+        if validation:
+            rules.set_active_rule(previously_active_rule)
+            validated.append(rule)
+    rules.set_active_rule(previously_active_rule)
+    if not len(validated):
+        logger.warning(
+            f"Could not validate {name} with any of the given "
+            f"rules {', '.join([rule for rule in with_rules])}."
+        )
+    else:
+        logger.info(
+            f"Name {name} validated with rules: {', '.join([rule.name for rule in validated])}."
+        )
+    return validated
 
 
 def validate_repo(repo: Path) -> bool:

src/vfxnaming/rules.py

@@ -160,7 +160,7 @@ def parse(self, name: AnyStr) -> Union[Dict, None]:
                 f"and rule's pattern '{self._pattern}':'{len(expected_separators)}'."
             )
 
-    def validate(self, name: AnyStr, **validate_values) -> bool:  # noqa: C901
+    def validate(self, name: AnyStr, strict: bool = False, **validate_values) -> bool:  # noqa: C901
         """Validate if given name matches the rule pattern.
 
         Args:
@@ -184,14 +184,10 @@ def validate(self, name: AnyStr, **validate_values) -> bool:  # noqa: C901
             )
             return False
 
-        regex = self.__build_regex()
+        regex = self.__build_regex(strict)
         match = regex.search(name)
         if not match:
             logger.warning(f"Name {name} does not match rule pattern '{self._pattern}'")
-            if regex.search(name.lower()):
-                logger.warning(
-                    f"Name {name} has casing mismatches with '{self._pattern}'"
-                )
             return False
 
         match_dict = match.groupdict()
@@ -297,7 +293,7 @@ def validate(self, name: AnyStr, **validate_values) -> bool:  # noqa: C901
 
         return matching_options
 
-    def __build_regex(self) -> re.Pattern:
+    def __build_regex(self, strict: bool = False) -> re.Pattern:
         # ? Taken from Lucidity by Martin Pengelly-Phillips
         # Escape non-placeholder components
         expression = re.sub(
@@ -320,7 +316,10 @@ def __build_regex(self) -> re.Pattern:
                 expression = f"{expression}$"
         # Compile expression
         try:
-            compiled = re.compile(expression)
+            if strict:
+                compiled = re.compile(expression)
+            else:
+                compiled = re.compile(expression, re.IGNORECASE)
         except re.error as error:
             if any(
                 [

tests/naming_test.py

@@ -1,7 +1,8 @@
 from pathlib import Path
 import pytest
 import tempfile
-from typing import Dict, List
+import types
+from typing import Dict, List, Union
 
 from vfxnaming import naming as n
 import vfxnaming.rules as rules
@@ -236,60 +237,92 @@ def setup(self):
         [
             (
                 "dramatic_bounce_chars_001_LGT",
-                True,
+                1,
             ),
             (
                 "dramatic_bounce_chars_001",
-                False,
+                0,
             ),
             (
                 "whatEver_bounce_chars_001_LGT",
-                False,
+                0,
             ),
             (
                 "dramatic_bounce_chars_01_LGT",
-                False,
+                0,
             ),
             (
                 "dramatic_bounce_chars_v001_LGT",
-                False,
+                0,
             ),
             (
                 "dramatic_bounce_chars_1000_LGT",
-                True,
+                1,
             ),
         ],
     )
-    def test_valid(self, name: str, expected: bool):
-        assert n.validate(name) is expected
+    def test_valid(self, name: str, expected: int):
+        validated = n.validate(name)
+        assert len(validated) == expected
 
     @pytest.mark.parametrize(
         "name,validate_values,expected",
         [
             (
                 "dramatic_bounce_chars_001_LGT",
                 {"category": "dramatic"},
-                True,
+                1,
             ),
             (
                 "dramatic_bounce_chars_001_LGT",
                 {"whatAffects": "chars"},
-                True,
+                1,
             ),
             (
                 "dramatic_bounce_chars_001_LGT",
                 {"category": "practical"},
-                False,
+                0,
             ),
             (
                 "dramatic_bounce_chars_001_LGT",
                 {"whatAffects": "anything"},
-                False,
+                0,
             ),
         ],
     )
-    def test_valid_with_tokens(self, name: str, validate_values: dict, expected: bool):
-        assert n.validate(name, **validate_values) is expected
+    def test_valid_with_tokens(self, name: str, validate_values: dict, expected: int):
+        validated = n.validate(name, **validate_values)
+        assert len(validated) == expected
+
+
+class Test_ValidateHarcodedValues:
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        tokens.reset_tokens()
+        rules.reset_rules()
+        tokens.add_token("side", center="C", left="L", right="R", default="center")
+        tokens.add_token(
+            "region",
+            orbital="ORBI",
+            parotidmasseter="PAROT",
+            mental="MENT",
+            frontal="FRONT",
+            zygomatic="ZYGO",
+            retromandibularfossa="RETMAND",
+        )
+        rules.add_rule("filename", "{side}-ALWAYS_{side}-This_{side}-{region}")
+
+    @pytest.mark.parametrize(
+        "name,strict,expected",
+        [
+            ("C-ALWAYS_C-This_C-ORBI", False, 1),
+            ("C-always_C-This_C-ORBI", False, 1),
+            ("C-always_C-this_C-ORBI", True, 0),
+        ],
+    )
+    def test_valid_harcoded(self, name: str, strict: bool, expected: int):
+        validated = n.validate(name, strict=strict)
+        assert len(validated) == expected
 
 
 class Test_ValidateWithRepetitions:
@@ -322,28 +355,29 @@ def setup(self):
                     "side3": "right",
                     "region3": "zygomatic",
                 },
-                True,
+                1,
             ),
             (
                 "R-MENT_C-PAROT_L-RETMAND",
                 {
                     "side2": "center",
                 },
-                True,
+                1,
             ),
             (
                 "R-MENT_C-PAROT_L-RETMAND",
                 {
                     "side": "center",
                 },
-                False,
+                0,
             ),
         ],
     )
     def test_valid_with_repetitions(
-        self, name: str, validate_values: dict, expected: bool
+        self, name: str, validate_values: dict, expected: int
     ):
-        assert n.validate(name, **validate_values) is expected
+        validated = n.validate(name, **validate_values)
+        assert len(validated) == expected
 
 
 class Test_RuleWithRepetitions: