elspais 0.11.0__py3-none-any.whl → 0.11.2__py3-none-any.whl

elspais/core/parser.py

@@ -20,46 +20,39 @@ class RequirementParser:
     # Regex patterns for parsing
     # Generic pattern to find potential requirement headers
     # Actual ID validation is done by PatternValidator
-    HEADER_PATTERN = re.compile(
-        r"^#*\s*(?P<id>[A-Z]+-[A-Za-z0-9-]+):\s*(?P<title>.+)$"
-    )
+    HEADER_PATTERN = re.compile(r"^#*\s*(?P<id>[A-Z]+-[A-Za-z0-9-]+):\s*(?P<title>.+)$")
     LEVEL_STATUS_PATTERN = re.compile(
         r"\*\*Level\*\*:\s*(?P<level>\w+)"
         r"(?:\s*\|\s*\*\*Implements\*\*:\s*(?P<implements>[^|\n]+))?"
         r"(?:\s*\|\s*\*\*Status\*\*:\s*(?P<status>\w+))?"
     )
-    ALT_STATUS_PATTERN = re.compile(
-        r"\*\*Status\*\*:\s*(?P<status>\w+)"
-    )
-    IMPLEMENTS_PATTERN = re.compile(
-        r"\*\*Implements\*\*:\s*(?P<implements>[^|\n]+)"
-    )
+    ALT_STATUS_PATTERN = re.compile(r"\*\*Status\*\*:\s*(?P<status>\w+)")
+    IMPLEMENTS_PATTERN = re.compile(r"\*\*Implements\*\*:\s*(?P<implements>[^|\n]+)")
     END_MARKER_PATTERN = re.compile(
-        r"^\*End\*\s+\*[^*]+\*\s*(?:\|\s*\*\*Hash\*\*:\s*(?P<hash>[a-zA-Z0-9]+))?",
-        re.MULTILINE
-    )
-    RATIONALE_PATTERN = re.compile(
-        r"\*\*Rationale\*\*:\s*(.+?)(?=\n\n|\n\*\*|\Z)", re.DOTALL
+        r"^\*End\*\s+\*[^*]+\*\s*(?:\|\s*\*\*Hash\*\*:\s*(?P<hash>[a-zA-Z0-9]+))?", re.MULTILINE
     )
+    RATIONALE_PATTERN = re.compile(r"\*\*Rationale\*\*:\s*(.+?)(?=\n\n|\n\*\*|\Z)", re.DOTALL)
     ACCEPTANCE_PATTERN = re.compile(
         r"\*\*Acceptance Criteria\*\*:\s*\n((?:\s*-\s*.+\n?)+)", re.MULTILINE
     )
     # Assertions section header (## Assertions or **Assertions**)
-    ASSERTIONS_HEADER_PATTERN = re.compile(
-        r"^##\s+Assertions\s*$", re.MULTILINE
-    )
+    ASSERTIONS_HEADER_PATTERN = re.compile(r"^##\s+Assertions\s*$", re.MULTILINE)
     # Individual assertion line: "A. The system SHALL..." or "01. ..." etc.
     # Captures: label (any alphanumeric), text (rest of line, may continue)
-    ASSERTION_LINE_PATTERN = re.compile(
-        r"^\s*([A-Z0-9]+)\.\s+(.+)$", re.MULTILINE
-    )
+    ASSERTION_LINE_PATTERN = re.compile(r"^\s*([A-Z0-9]+)\.\s+(.+)$", re.MULTILINE)
 
     # Default values that mean "no references" in Implements field
     DEFAULT_NO_REFERENCE_VALUES = ["-", "null", "none", "x", "X", "N/A", "n/a"]
 
     # Default placeholder values that indicate a removed/deprecated assertion
     DEFAULT_PLACEHOLDER_VALUES = [
-        "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
+        "obsolete",
+        "removed",
+        "deprecated",
+        "N/A",
+        "n/a",
+        "-",
+        "reserved",
     ]
 
     def __init__(
@@ -272,9 +265,7 @@ class RequirementParser:
             else:
                 dir_path = base_path / dir_entry
             if dir_path.exists() and dir_path.is_dir():
-                result = self.parse_directory(
-                    dir_path, patterns=patterns, skip_files=skip_files
-                )
+                result = self.parse_directory(dir_path, patterns=patterns, skip_files=skip_files)
                 # Merge requirements, checking for cross-directory duplicates
                 for req_id, req in result.requirements.items():
                     if req_id in requirements:
@@ -385,7 +376,10 @@ class RequirementParser:
 
         warning = ParseWarning(
             requirement_id=original_id,
-            message=f"Duplicate ID found (first occurrence in {original_req.file_path}:{original_req.line_number})",
+            message=(
+                f"Duplicate ID found "
+                f"(first occurrence in {original_req.file_path}:{original_req.line_number})"
+            ),
             file_path=file_path,
             line_number=line_number,
         )
@@ -444,12 +438,14 @@ class RequirementParser:
         implements = self._parse_implements(implements_str)
         for ref in implements:
             if not self.validator.is_valid(ref):
-                block_warnings.append(ParseWarning(
-                    requirement_id=req_id,
-                    message=f"Invalid implements reference: {ref}",
-                    file_path=file_path,
-                    line_number=line_number,
-                ))
+                block_warnings.append(
+                    ParseWarning(
+                        requirement_id=req_id,
+                        message=f"Invalid implements reference: {ref}",
+                        file_path=file_path,
+                        line_number=line_number,
+                    )
+                )
 
         # Extract body (text between header and acceptance/end)
         body = self._extract_body(text)
@@ -475,12 +471,14 @@ class RequirementParser:
         assertions = self._extract_assertions(text)
         for assertion in assertions:
             if not self._is_valid_assertion_label(assertion.label):
-                block_warnings.append(ParseWarning(
-                    requirement_id=req_id,
-                    message=f"Invalid assertion label format: {assertion.label}",
-                    file_path=file_path,
-                    line_number=line_number,
-                ))
+                block_warnings.append(
+                    ParseWarning(
+                        requirement_id=req_id,
+                        message=f"Invalid assertion label format: {assertion.label}",
+                        file_path=file_path,
+                        line_number=line_number,
+                    )
+                )
 
         # Extract hash from end marker
         hash_value = None
@@ -511,17 +509,17 @@ class RequirementParser:
         Default expectation is uppercase letters A-Z.
         """
         # Check against configured assertion label pattern if available
-        assertion_config = getattr(self.pattern_config, 'assertions', None)
+        assertion_config = getattr(self.pattern_config, "assertions", None)
         if assertion_config:
-            label_style = assertion_config.get('label_style', 'uppercase')
-            if label_style == 'uppercase':
-                return bool(re.match(r'^[A-Z]$', label))
-            elif label_style == 'numeric':
-                return bool(re.match(r'^\d+$', label))
-            elif label_style == 'alphanumeric':
-                return bool(re.match(r'^[A-Z0-9]+$', label))
+            label_style = assertion_config.get("label_style", "uppercase")
+            if label_style == "uppercase":
+                return bool(re.match(r"^[A-Z]$", label))
+            elif label_style == "numeric":
+                return bool(re.match(r"^\d+$", label))
+            elif label_style == "alphanumeric":
+                return bool(re.match(r"^[A-Z0-9]+$", label))
         # Default: uppercase single letter
-        return bool(re.match(r'^[A-Z]$', label))
+        return bool(re.match(r"^[A-Z]$", label))
 
     def _parse_implements(self, implements_str: str) -> List[str]:
         """Parse comma-separated implements list.
@@ -608,9 +606,9 @@ class RequirementParser:
 
         # Find the end of the assertions section (next ## header, Rationale, or End marker)
         end_patterns = [
-            r"^##\s+",           # Next section header
-            r"^\*End\*",         # End marker
-            r"^---\s*$",         # Separator line
+            r"^##\s+",  # Next section header
+            r"^\*End\*",  # End marker
+            r"^---\s*$",  # Separator line
         ]
         end_pos = len(section_text)
         for pattern in end_patterns:
@@ -627,14 +625,15 @@ class RequirementParser:
 
             # Check if this is a placeholder
             is_placeholder = any(
-                assertion_text.lower().startswith(pv.lower())
-                for pv in self.placeholder_values
+                assertion_text.lower().startswith(pv.lower()) for pv in self.placeholder_values
             )
 
-            assertions.append(Assertion(
-                label=label,
-                text=assertion_text,
-                is_placeholder=is_placeholder,
-            ))
+            assertions.append(
+                Assertion(
+                    label=label,
+                    text=assertion_text,
+                    is_placeholder=is_placeholder,
+                )
+            )
 
         return assertions

elspais/core/patterns.py

@@ -116,9 +116,7 @@ class PatternValidator:
         self.config = config
         self._regex = self._build_regex()
         self._regex_with_assertion = self._build_regex(include_assertion=True)
-        self._assertion_label_regex = re.compile(
-            f"^{self.config.get_assertion_label_pattern()}$"
-        )
+        self._assertion_label_regex = re.compile(f"^{self.config.get_assertion_label_pattern()}$")
 
     def _build_regex(self, include_assertion: bool = False) -> re.Pattern:
         """Build regex pattern from configuration.
@@ -306,9 +304,7 @@ class PatternValidator:
 
         raise ValueError(f"Cannot parse assertion label: {label}")
 
-    def format(
-        self, type_code: str, number: int, associated: Optional[str] = None
-    ) -> str:
+    def format(self, type_code: str, number: int, associated: Optional[str] = None) -> str:
         """
         Format a requirement ID from components.
 

elspais/core/rules.py

@@ -101,9 +101,9 @@ class FormatConfig:
     require_shall: bool = True
     labels_sequential: bool = True
     labels_unique: bool = True
-    placeholder_values: List[str] = field(default_factory=lambda: [
-        "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
-    ])
+    placeholder_values: List[str] = field(
+        default_factory=lambda: ["obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"]
+    )
 
 
 @dataclass
@@ -142,9 +142,10 @@ class RulesConfig:
             require_shall=format_data.get("require_shall", True),
             labels_sequential=format_data.get("labels_sequential", True),
             labels_unique=format_data.get("labels_unique", True),
-            placeholder_values=format_data.get("placeholder_values", [
-                "obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"
-            ]),
+            placeholder_values=format_data.get(
+                "placeholder_values",
+                ["obsolete", "removed", "deprecated", "N/A", "n/a", "-", "reserved"],
+            ),
         )
 
         return cls(hierarchy=hierarchy, format=format_config)
@@ -169,9 +170,7 @@ class RuleEngine:
         """
         self.config = config
         self.pattern_config = pattern_config
-        self.pattern_validator = (
-            PatternValidator(pattern_config) if pattern_config else None
-        )
+        self.pattern_validator = PatternValidator(pattern_config) if pattern_config else None
 
     def validate(self, requirements: Dict[str, Requirement]) -> List[RuleViolation]:
         """
@@ -381,9 +380,7 @@ class RuleEngine:
 
         return violations
 
-    def _check_assertions(
-        self, req_id: str, req: Requirement
-    ) -> List[RuleViolation]:
+    def _check_assertions(self, req_id: str, req: Requirement) -> List[RuleViolation]:
         """Check assertion-specific validation rules."""
         violations = []
 
@@ -426,9 +423,7 @@ class RuleEngine:
         if self.config.format.labels_sequential and self.pattern_validator:
             expected_labels = []
             for i in range(len(labels)):
-                expected_labels.append(
-                    self.pattern_validator.format_assertion_label(i)
-                )
+                expected_labels.append(self.pattern_validator.format_assertion_label(i))
             if labels != expected_labels:
                 msg = f"Labels not sequential: {labels} (expected {expected_labels})"
                 violations.append(

elspais/mcp/__init__.py

@@ -33,10 +33,12 @@ __all__ = [
 def create_server(working_dir=None):
     """Create MCP server instance."""
     from elspais.mcp.server import create_server as _create
+
     return _create(working_dir)
 
 
 def run_server(working_dir=None, transport="stdio"):
     """Run MCP server."""
     from elspais.mcp.server import run_server as _run
+
     return _run(working_dir, transport)

elspais/mcp/context.py

@@ -52,6 +52,7 @@ class WorkspaceContext:
         else:
             # Use defaults
             from elspais.config.defaults import DEFAULT_CONFIG
+
             config = DEFAULT_CONFIG.copy()
 
         return cls(working_dir=directory, config=config)

elspais/mcp/serializers.py

@@ -4,7 +4,7 @@ elspais.mcp.serializers - JSON serialization for MCP responses.
 Provides functions to serialize elspais data models to JSON-compatible dicts.
 """
 
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from elspais.core.models import Assertion, ContentRule, Requirement
 from elspais.core.rules import RuleViolation

elspais/mcp/server.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional
 
 try:
     from mcp.server.fastmcp import FastMCP
+
     MCP_AVAILABLE = True
 except ImportError:
     MCP_AVAILABLE = False
@@ -39,8 +40,7 @@ def create_server(working_dir: Optional[Path] = None) -> "FastMCP":
     """
     if not MCP_AVAILABLE:
         raise ImportError(
-            "MCP dependencies not installed. "
-            "Install with: pip install elspais[mcp]"
+            "MCP dependencies not installed. " "Install with: pip install elspais[mcp]"
         )
 
     if working_dir is None:
@@ -75,14 +75,17 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         ID, title, level, status, and assertion count.
         """
         import json
+
         requirements = ctx.get_requirements()
-        return json.dumps({
-            "count": len(requirements),
-            "requirements": [
-                serialize_requirement_summary(req)
-                for req in requirements.values()
-            ]
-        }, indent=2)
+        return json.dumps(
+            {
+                "count": len(requirements),
+                "requirements": [
+                    serialize_requirement_summary(req) for req in requirements.values()
+                ],
+            },
+            indent=2,
+        )
 
     @mcp.resource("requirements://{req_id}")
     def get_requirement_resource(req_id: str) -> str:
@@ -93,6 +96,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         implements references, and location.
         """
         import json
+
         req = ctx.get_requirement(req_id)
         if req is None:
             return json.dumps({"error": f"Requirement {req_id} not found"})
@@ -102,34 +106,39 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
     def get_requirements_by_level(level: str) -> str:
         """Get all requirements of a specific level (PRD, OPS, DEV)."""
         import json
+
         requirements = ctx.get_requirements()
-        filtered = [
-            r for r in requirements.values()
-            if r.level.upper() == level.upper()
-        ]
-        return json.dumps({
-            "level": level,
-            "count": len(filtered),
-            "requirements": [serialize_requirement_summary(r) for r in filtered]
-        }, indent=2)
+        filtered = [r for r in requirements.values() if r.level.upper() == level.upper()]
+        return json.dumps(
+            {
+                "level": level,
+                "count": len(filtered),
+                "requirements": [serialize_requirement_summary(r) for r in filtered],
+            },
+            indent=2,
+        )
 
     @mcp.resource("content-rules://list")
     def list_content_rules() -> str:
         """List all configured content rule files."""
         import json
+
         rules = ctx.get_content_rules()
-        return json.dumps({
-            "count": len(rules),
-            "rules": [
-                {
-                    "file": str(r.file_path),
-                    "title": r.title,
-                    "type": r.type,
-                    "applies_to": r.applies_to,
-                }
-                for r in rules
-            ]
-        }, indent=2)
+        return json.dumps(
+            {
+                "count": len(rules),
+                "rules": [
+                    {
+                        "file": str(r.file_path),
+                        "title": r.title,
+                        "type": r.type,
+                        "applies_to": r.applies_to,
+                    }
+                    for r in rules
+                ],
+            },
+            indent=2,
+        )
 
     @mcp.resource("content-rules://{filename}")
     def get_content_rule(filename: str) -> str:
@@ -140,6 +149,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         requirement formats and authoring guidelines.
         """
         import json
+
         rules = ctx.get_content_rules()
         for rule in rules:
             if rule.file_path.name == filename or str(rule.file_path).endswith(filename):
@@ -150,6 +160,7 @@ def _register_resources(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
     def get_current_config() -> str:
         """Get the current elspais configuration."""
         import json
+
         return json.dumps(ctx.config, indent=2, default=str)
 
 
@@ -186,7 +197,10 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
             "valid": len(errors) == 0,
             "errors": [serialize_violation(v) for v in errors],
             "warnings": [serialize_violation(v) for v in warnings],
-            "summary": f"{len(errors)} errors, {len(warnings)} warnings in {len(requirements)} requirements"
+            "summary": (
+                f"{len(errors)} errors, {len(warnings)} warnings "
+                f"in {len(requirements)} requirements"
+            ),
         }
 
     @mcp.tool()
@@ -209,9 +223,8 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
         return {
             "count": len(requirements),
             "requirements": {
-                req_id: serialize_requirement(req)
-                for req_id, req in requirements.items()
-            }
+                req_id: serialize_requirement(req) for req_id, req in requirements.items()
+            },
         }
 
     @mcp.tool()
@@ -233,7 +246,7 @@ def _register_tools(mcp: "FastMCP", ctx: WorkspaceContext) -> None:
             "count": len(results),
             "query": query,
             "field": field,
-            "requirements": [serialize_requirement_summary(r) for r in results]
+            "requirements": [serialize_requirement_summary(r) for r in results],
         }
 
     @mcp.tool()
@@ -299,10 +312,12 @@ def _analyze_orphans(requirements: Dict[str, Any]) -> Dict[str, Any]:
     for req in requirements.values():
         for parent_id in req.implements:
             if parent_id not in all_ids:
-                orphans.append({
-                    "id": req.id,
-                    "missing_parent": parent_id,
-                })
+                orphans.append(
+                    {
+                        "id": req.id,
+                        "missing_parent": parent_id,
+                    }
+                )
 
     return {
         "count": len(orphans),

elspais/reformat/__init__.py

@@ -9,23 +9,23 @@ IMPLEMENTS REQUIREMENTS:
     REQ-int-d00008: Reformat Command
 """
 
-from elspais.reformat.detector import detect_format, needs_reformatting, FormatAnalysis
-from elspais.reformat.transformer import (
-    reformat_requirement,
-    assemble_new_format,
-    validate_reformatted_content,
-)
-from elspais.reformat.line_breaks import (
-    normalize_line_breaks,
-    fix_requirement_line_breaks,
-    detect_line_break_issues,
-)
+from elspais.reformat.detector import FormatAnalysis, detect_format, needs_reformatting
 from elspais.reformat.hierarchy import (
     RequirementNode,
-    get_all_requirements,
     build_hierarchy,
-    traverse_top_down,
+    get_all_requirements,
     normalize_req_id,
+    traverse_top_down,
+)
+from elspais.reformat.line_breaks import (
+    detect_line_break_issues,
+    fix_requirement_line_breaks,
+    normalize_line_breaks,
+)
+from elspais.reformat.transformer import (
+    assemble_new_format,
+    reformat_requirement,
+    validate_reformatted_content,
 )
 
 __all__ = [

elspais/reformat/detector.py

@@ -13,6 +13,7 @@ from dataclasses import dataclass
 @dataclass
 class FormatAnalysis:
     """Result of format detection analysis."""
+
     is_new_format: bool
     has_assertions_section: bool
     has_labeled_assertions: bool
@@ -46,36 +47,28 @@ def detect_format(body: str, rationale: str = "") -> FormatAnalysis:
     full_text = f"{body}\n{rationale}".strip()
 
     # Check for ## Assertions section
-    has_assertions_section = bool(
-        re.search(r'^##\s+Assertions\s*$', full_text, re.MULTILINE)
-    )
+    has_assertions_section = bool(re.search(r"^##\s+Assertions\s*$", full_text, re.MULTILINE))
 
     # Check for labeled assertions (A., B., C., etc. followed by SHALL somewhere in the line)
     labeled_assertions = re.findall(
-        r'^[A-Z]\.\s+.*\bSHALL\b',
-        full_text,
-        re.MULTILINE | re.IGNORECASE
+        r"^[A-Z]\.\s+.*\bSHALL\b", full_text, re.MULTILINE | re.IGNORECASE
     )
     has_labeled_assertions = len(labeled_assertions) >= 1
     assertion_count = len(labeled_assertions)
 
     # Check for Acceptance Criteria section
-    has_acceptance_criteria = bool(re.search(
-        r'\*?\*?Acceptance\s+Criteria\*?\*?\s*:',
-        full_text,
-        re.IGNORECASE
-    ))
+    has_acceptance_criteria = bool(
+        re.search(r"\*?\*?Acceptance\s+Criteria\*?\*?\s*:", full_text, re.IGNORECASE)
+    )
 
     # Check for SHALL language usage anywhere
-    shall_count = len(re.findall(r'\bSHALL\b', full_text, re.IGNORECASE))
+    shall_count = len(re.findall(r"\bSHALL\b", full_text, re.IGNORECASE))
     uses_shall_language = shall_count >= 1
 
     # Determine if new format
     # New format: has Assertions section with labeled assertions, no Acceptance Criteria
     is_new_format = (
-        has_assertions_section and
-        has_labeled_assertions and
-        not has_acceptance_criteria
+        has_assertions_section and has_labeled_assertions and not has_acceptance_criteria
     )
 
     # Calculate confidence score
@@ -100,7 +93,7 @@ def detect_format(body: str, rationale: str = "") -> FormatAnalysis:
         has_acceptance_criteria=has_acceptance_criteria,
         uses_shall_language=uses_shall_language,
         assertion_count=assertion_count,
-        confidence=confidence
+        confidence=confidence,
     )
 
 

elspais/reformat/hierarchy.py

@@ -9,7 +9,7 @@ a traversable hierarchy based on implements relationships.
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Callable, Dict, List, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable, Dict, List, Optional
 
 if TYPE_CHECKING:
     from elspais.core.models import Requirement
@@ -19,6 +19,7 @@ if TYPE_CHECKING:
 @dataclass
 class RequirementNode:
     """Represents a requirement with its metadata and hierarchy info."""
+
     req_id: str
     title: str
     body: str
@@ -76,10 +77,10 @@ def get_all_requirements(
     Returns:
         Dict mapping requirement ID (e.g., 'REQ-d00027') to RequirementNode
     """
-    from elspais.config.loader import load_config, find_config_file, get_spec_directories
+    from elspais.commands.validate import load_requirements_from_repo
+    from elspais.config.loader import find_config_file, get_spec_directories, load_config
     from elspais.core.parser import RequirementParser
     from elspais.core.patterns import PatternConfig
-    from elspais.commands.validate import load_requirements_from_repo
 
     # Find and load config
     if config_path is None:
@@ -140,7 +141,7 @@ def build_hierarchy(requirements: Dict[str, RequirementNode]) -> Dict[str, Requi
     for req_id, node in requirements.items():
         for parent_id in node.implements:
             # Normalize parent ID format
-            parent_key = parent_id if parent_id.startswith('REQ-') else f"REQ-{parent_id}"
+            parent_key = parent_id if parent_id.startswith("REQ-") else f"REQ-{parent_id}"
             if parent_key in requirements:
                 requirements[parent_key].children.append(req_id)
 
@@ -155,7 +156,7 @@ def traverse_top_down(
     requirements: Dict[str, RequirementNode],
     start_req: str,
     max_depth: Optional[int] = None,
-    callback: Optional[Callable[[RequirementNode, int], None]] = None
+    callback: Optional[Callable[[RequirementNode, int], None]] = None,
 ) -> List[str]:
     """
     Traverse hierarchy from start_req downward using BFS.
@@ -214,8 +215,8 @@ def normalize_req_id(req_id: str, validator: Optional["PatternValidator"] = None
     Returns:
         Normalized ID in canonical format from config
     """
-    from elspais.config.loader import load_config, find_config_file
-    from elspais.core.patterns import PatternValidator, PatternConfig
+    from elspais.config.loader import find_config_file, load_config
+    from elspais.core.patterns import PatternConfig, PatternValidator
 
     # Create validator if not provided
     if validator is None: