Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.
Python aecai-agentsautodeskautomationbimclaudeifcmcpmcp-servermodel-context-protocolnavisworksrevitrevit-addinrevit-apirhino
Scaffold 3, Tasks 3.1 & 3.2: Naming conventions and parameter validation
sammohammad578e6168fea6441
diff --git a/packages/model-checker/src/model_checker/standards.py b/packages/model-checker/src/model_checker/standards.pynew file mode 100644index 0000000..9df265d--- /dev/null+++ b/packages/model-checker/src/model_checker/standards.py@@ -0,0 +1,330 @@+"""Standards compliance checking for BIM models."""++from __future__ import annotations++import re+from dataclasses import dataclass+from typing import Any, Callable+++@dataclass+class NamingRule:+ """A naming convention rule."""++ id: str+ name: str+ category: str+ pattern: str+ description: str+ compiled_pattern: re.Pattern | None = None++ def __post_init__(self) -> None:+ """Compile the regex pattern after initialization."""+ if self.compiled_pattern is None:+ self.compiled_pattern = re.compile(self.pattern)++ def matches(self, name: str) -> bool:+ """Check if a name matches this naming rule.++ Args:+ name: The name to check++ Returns:+ True if name matches the pattern, False otherwise+ """+ if self.compiled_pattern is None:+ return False+ return bool(self.compiled_pattern.match(name))+++class NamingConventionValidator:+ """Validator for checking naming conventions."""++ def __init__(self) -> None:+ """Initialize the naming convention validator."""+ self.rules: dict[str, NamingRule] = {}+ self.violations: list[dict[str, Any]] = []++ def add_rule(self, rule: NamingRule) -> None:+ """Add a naming rule.++ Args:+ rule: The naming rule to add+ """+ self.rules[rule.id] = rule++ def add_view_naming_rules(self) -> None:+ """Add standard view naming rules."""+ # Floor plans: FP-L01, FP-L02, FP-ROOF+ self.add_rule(+ NamingRule(+ id="view_floor_plan",+ name="Floor Plan Naming",+ category="views",+ pattern=r"^FP-[A-Z0-9]+$",+ description="Floor plans must be named FP-XXXX",+ )+ )++ # Sections: SEC-A, SEC-B, SEC-1+ self.add_rule(+ NamingRule(+ id="view_section",+ name="Section Naming",+ category="views",+ pattern=r"^SEC-[A-Z0-9]+$",+ description="Sections must be named SEC-X",+ )+ )++ # 3D Views: 3D-ARCH, 3D-STRUCT, 3D-MEP+ self.add_rule(+ NamingRule(+ id="view_3d",+ name="3D View Naming",+ category="views",+ pattern=r"^3D-[A-Z]+$",+ description="3D views must be named 3D-XXXX",+ )+ )++ def add_sheet_naming_rules(self) -> None:+ """Add standard sheet naming rules."""+ # Sheets: A-101, M-201, E-301+ self.add_rule(+ NamingRule(+ id="sheet_number",+ name="Sheet Number Format",+ category="sheets",+ pattern=r"^[A-Z]-\d{3}$",+ description="Sheet numbers must be X-NNN format",+ )+ )++ def add_family_naming_rules(self) -> None:+ """Add standard family naming rules."""+ # Walls: W-EXT-200, W-INT-100+ self.add_rule(+ NamingRule(+ id="family_wall",+ name="Wall Family Naming",+ category="families",+ pattern=r"^W-[A-Z]+-\d+$",+ description="Wall families must be named W-TYPE-WIDTH",+ )+ )++ # Doors: D-SINGLE-900, D-DOUBLE-1800+ self.add_rule(+ NamingRule(+ id="family_door",+ name="Door Family Naming",+ category="families",+ pattern=r"^D-[A-Z]+-\d+$",+ description="Door families must be named D-TYPE-WIDTH",+ )+ )++ # Windows: W-FIXED-1200, W-CASEMENT-900+ self.add_rule(+ NamingRule(+ id="family_window",+ name="Window Family Naming",+ category="families",+ pattern=r"^WN-[A-Z]+-\d+$",+ description="Window families must be named WN-TYPE-WIDTH",+ )+ )++ def validate_name(+ self, name: str, element_type: str, rule_id: str | None = None+ ) -> tuple[bool, str | None]:+ """Validate a name against rules.++ Args:+ name: The name to validate+ element_type: Type of element (e.g., 'view', 'sheet', 'family')+ rule_id: Specific rule ID to check (optional)++ Returns:+ Tuple of (is_valid, error_message)+ """+ if rule_id:+ rule = self.rules.get(rule_id)+ if rule and rule.matches(name):+ return True, None+ if rule:+ return False, rule.description+ return False, f"Rule {rule_id} not found"++ # Check all rules for this element type+ for rule in self.rules.values():+ if element_type in rule.id and rule.matches(name):+ return True, None++ # No matching rule found+ return False, f"No naming rule matched for {element_type}"++ def validate_element(+ self,+ element_id: str | int,+ element_name: str,+ element_type: str,+ rule_id: str | None = None,+ ) -> bool:+ """Validate an element's name and record violations.++ Args:+ element_id: ID of the element+ element_name: Name of the element+ element_type: Type of element+ rule_id: Specific rule to check (optional)++ Returns:+ True if valid, False if violation found+ """+ is_valid, error_message = self.validate_name(element_name, element_type, rule_id)++ if not is_valid:+ self.violations.append(+ {+ "element_id": element_id,+ "element_name": element_name,+ "element_type": element_type,+ "rule_id": rule_id,+ "error": error_message,+ }+ )++ return is_valid++ def get_violations(self) -> list[dict[str, Any]]:+ """Get all naming convention violations.++ Returns:+ List of violation dictionaries+ """+ return self.violations++ def get_violations_by_type(self, element_type: str) -> list[dict[str, Any]]:+ """Get violations for a specific element type.++ Args:+ element_type: Type of element to filter by++ Returns:+ List of violations for that type+ """+ return [v for v in self.violations if v["element_type"] == element_type]++ def clear_violations(self) -> None:+ """Clear all recorded violations."""+ self.violations = []++ def get_violation_count(self) -> int:+ """Get total number of violations.++ Returns:+ Count of violations+ """+ return len(self.violations)+++@dataclass+class ParameterRule:+ """Rule for parameter validation."""++ id: str+ name: str+ parameter_name: str+ required: bool = True+ value_type: str | None = None+ allowed_values: list[Any] | None = None+ min_value: float | None = None+ max_value: float | None = None+ pattern: str | None = None+ validator_function: Callable[[Any], bool] | None = None++ def validate_value(self, value: Any) -> tuple[bool, str | None]:+ """Validate a parameter value.++ Args:+ value: The value to validate++ Returns:+ Tuple of (is_valid, error_message)+ """+ # Check if required and missing+ if self.required and (value is None or value == ""):+ return False, f"Required parameter '{self.parameter_name}' is missing"++ # If not required and missing, that's okay+ if value is None or value == "":+ return True, None++ # Type validation+ if self.value_type:+ expected_type = self._get_python_type(self.value_type)+ if expected_type and not isinstance(value, expected_type):+ return (+ False,+ f"Parameter '{self.parameter_name}' must be {self.value_type}",+ )++ # Allowed values validation+ if self.allowed_values and value not in self.allowed_values:+ return (+ False,+ f"Parameter '{self.parameter_name}' must be one of {self.allowed_values}",+ )++ # Numeric range validation+ if self.min_value is not None and isinstance(value, (int, float)):+ if value < self.min_value:+ return (+ False,+ f"Parameter '{self.parameter_name}' must be >= {self.min_value}",+ )++ if self.max_value is not None and isinstance(value, (int, float)):+ if value > self.max_value:+ return (+ False,+ f"Parameter '{self.parameter_name}' must be <= {self.max_value}",+ )++ # Pattern validation for strings+ if self.pattern and isinstance(value, str):+ if not re.match(self.pattern, value):+ return (+ False,+ f"Parameter '{self.parameter_name}' does not match pattern {self.pattern}",+ )++ # Custom validator function+ if self.validator_function:+ if not self.validator_function(value):+ return (+ False,+ f"Parameter '{self.parameter_name}' failed custom validation",+ )++ return True, None++ def _get_python_type(self, type_name: str) -> type | None:+ """Convert type name string to Python type.++ Args:+ type_name: String name of type++ Returns:+ Python type object or None+ """+ type_map = {+ "string": str,+ "int": int,+ "float": float,+ "bool": bool,+ "number": (int, float),+ }+ return type_map.get(type_name.lower())diff --git a/packages/model-checker/tests/test_standards.py b/packages/model-checker/tests/test_standards.pynew file mode 100644index 0000000..7bd2493--- /dev/null+++ b/packages/model-checker/tests/test_standards.py@@ -0,0 +1,402 @@+"""Test standards compliance checking."""++import pytest++from model_checker.standards import (+ NamingConventionValidator,+ NamingRule,+ ParameterRule,+)+++def test_create_naming_rule():+ """Test creating a naming rule."""+ rule = NamingRule(+ id="test_rule",+ name="Test Rule",+ category="views",+ pattern=r"^FP-\d+$",+ description="Floor plans must be FP-NNN",+ )++ assert rule.id == "test_rule"+ assert rule.name == "Test Rule"+ assert rule.pattern == r"^FP-\d+$"+ assert rule.compiled_pattern is not None+++def test_naming_rule_matches():+ """Test naming rule pattern matching."""+ rule = NamingRule(+ id="floor_plan",+ name="Floor Plan",+ category="views",+ pattern=r"^FP-L\d{2}$",+ description="Floor plan naming",+ )++ assert rule.matches("FP-L01") is True+ assert rule.matches("FP-L10") is True+ assert rule.matches("FP-ROOF") is False+ assert rule.matches("SEC-A") is False+++def test_create_naming_validator():+ """Test creating naming convention validator."""+ validator = NamingConventionValidator()++ assert len(validator.rules) == 0+ assert len(validator.violations) == 0+++def test_add_naming_rule():+ """Test adding a naming rule."""+ validator = NamingConventionValidator()++ rule = NamingRule(+ id="sheet_rule",+ name="Sheet Naming",+ category="sheets",+ pattern=r"^A-\d{3}$",+ description="Architectural sheets",+ )++ validator.add_rule(rule)++ assert len(validator.rules) == 1+ assert "sheet_rule" in validator.rules+++def test_add_view_naming_rules():+ """Test adding standard view naming rules."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ assert len(validator.rules) > 0+ assert "view_floor_plan" in validator.rules+ assert "view_section" in validator.rules+ assert "view_3d" in validator.rules+++def test_add_sheet_naming_rules():+ """Test adding standard sheet naming rules."""+ validator = NamingConventionValidator()+ validator.add_sheet_naming_rules()++ assert "sheet_number" in validator.rules+++def test_add_family_naming_rules():+ """Test adding standard family naming rules."""+ validator = NamingConventionValidator()+ validator.add_family_naming_rules()++ assert "family_wall" in validator.rules+ assert "family_door" in validator.rules+ assert "family_window" in validator.rules+++def test_validate_name_with_specific_rule():+ """Test validating a name with a specific rule."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ # Valid floor plan name+ is_valid, error = validator.validate_name("FP-L01", "view", "view_floor_plan")+ assert is_valid is True+ assert error is None++ # Invalid floor plan name+ is_valid, error = validator.validate_name("FloorPlan-01", "view", "view_floor_plan")+ assert is_valid is False+ assert error is not None+++def test_validate_name_any_rule():+ """Test validating a name against any matching rule."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ # Valid section name+ is_valid, error = validator.validate_name("SEC-A", "view")+ assert is_valid is True++ # Invalid name+ is_valid, error = validator.validate_name("RandomName", "view")+ assert is_valid is False+++def test_validate_element():+ """Test validating an element and recording violations."""+ validator = NamingConventionValidator()+ validator.add_sheet_naming_rules()++ # Valid sheet+ is_valid = validator.validate_element(+ element_id="sheet_1", element_name="A-101", element_type="sheet", rule_id="sheet_number"+ )+ assert is_valid is True+ assert len(validator.violations) == 0++ # Invalid sheet+ is_valid = validator.validate_element(+ element_id="sheet_2",+ element_name="Arch-Sheet-1",+ element_type="sheet",+ rule_id="sheet_number",+ )+ assert is_valid is False+ assert len(validator.violations) == 1+++def test_get_violations():+ """Test getting all violations."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ validator.validate_element("view_1", "BadName1", "view")+ validator.validate_element("view_2", "BadName2", "view")++ violations = validator.get_violations()+ assert len(violations) == 2+++def test_get_violations_by_type():+ """Test getting violations by element type."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()+ validator.add_sheet_naming_rules()++ validator.validate_element("view_1", "BadView", "view")+ validator.validate_element("sheet_1", "BadSheet", "sheet")++ view_violations = validator.get_violations_by_type("view")+ sheet_violations = validator.get_violations_by_type("sheet")++ assert len(view_violations) == 1+ assert len(sheet_violations) == 1+++def test_clear_violations():+ """Test clearing violations."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ validator.validate_element("view_1", "BadName", "view")+ assert len(validator.violations) > 0++ validator.clear_violations()+ assert len(validator.violations) == 0+++def test_get_violation_count():+ """Test getting violation count."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ for i in range(5):+ validator.validate_element(f"view_{i}", f"BadName{i}", "view")++ assert validator.get_violation_count() == 5+++def test_view_naming_patterns():+ """Test various view naming patterns."""+ validator = NamingConventionValidator()+ validator.add_view_naming_rules()++ # Floor plans+ assert validator.validate_name("FP-L01", "view", "view_floor_plan")[0] is True+ assert validator.validate_name("FP-ROOF", "view", "view_floor_plan")[0] is True+ assert validator.validate_name("FP-B1", "view", "view_floor_plan")[0] is True++ # Sections+ assert validator.validate_name("SEC-A", "view", "view_section")[0] is True+ assert validator.validate_name("SEC-1", "view", "view_section")[0] is True++ # 3D Views+ assert validator.validate_name("3D-ARCH", "view", "view_3d")[0] is True+ assert validator.validate_name("3D-STRUCT", "view", "view_3d")[0] is True+++def test_sheet_naming_patterns():+ """Test sheet naming patterns."""+ validator = NamingConventionValidator()+ validator.add_sheet_naming_rules()++ # Valid sheets+ assert validator.validate_name("A-101", "sheet", "sheet_number")[0] is True+ assert validator.validate_name("M-201", "sheet", "sheet_number")[0] is True+ assert validator.validate_name("E-301", "sheet", "sheet_number")[0] is True++ # Invalid sheets+ assert validator.validate_name("A101", "sheet", "sheet_number")[0] is False+ assert validator.validate_name("Arch-101", "sheet", "sheet_number")[0] is False+++def test_family_naming_patterns():+ """Test family naming patterns."""+ validator = NamingConventionValidator()+ validator.add_family_naming_rules()++ # Walls+ assert validator.validate_name("W-EXT-200", "family", "family_wall")[0] is True+ assert validator.validate_name("W-INT-100", "family", "family_wall")[0] is True++ # Doors+ assert validator.validate_name("D-SINGLE-900", "family", "family_door")[0] is True+ assert validator.validate_name("D-DOUBLE-1800", "family", "family_door")[0] is True++ # Windows+ assert validator.validate_name("WN-FIXED-1200", "family", "family_window")[0] is True+ assert validator.validate_name("WN-CASEMENT-900", "family", "family_window")[0] is True+++def test_create_parameter_rule():+ """Test creating a parameter rule."""+ rule = ParameterRule(+ id="mark_required",+ name="Mark Parameter",+ parameter_name="Mark",+ required=True,+ )++ assert rule.id == "mark_required"+ assert rule.parameter_name == "Mark"+ assert rule.required is True+++def test_parameter_required_validation():+ """Test required parameter validation."""+ rule = ParameterRule(+ id="mark_required",+ name="Mark Required",+ parameter_name="Mark",+ required=True,+ )++ # Missing value+ is_valid, error = rule.validate_value(None)+ assert is_valid is False+ assert "missing" in error.lower()++ # Empty string+ is_valid, error = rule.validate_value("")+ assert is_valid is False++ # Valid value+ is_valid, error = rule.validate_value("W-101")+ assert is_valid is True+++def test_parameter_optional_validation():+ """Test optional parameter validation."""+ rule = ParameterRule(+ id="comment_optional",+ name="Comment Optional",+ parameter_name="Comments",+ required=False,+ )++ # Missing value is okay+ is_valid, error = rule.validate_value(None)+ assert is_valid is True+++def test_parameter_type_validation():+ """Test parameter type validation."""+ rule = ParameterRule(+ id="height_number",+ name="Height Number",+ parameter_name="Height",+ value_type="float",+ )++ # Valid float+ is_valid, error = rule.validate_value(3000.0)+ assert is_valid is True++ # Invalid type (string)+ is_valid, error = rule.validate_value("3000")+ assert is_valid is False+++def test_parameter_allowed_values():+ """Test parameter allowed values validation."""+ rule = ParameterRule(+ id="fire_rating",+ name="Fire Rating",+ parameter_name="Fire Rating",+ allowed_values=["1HR", "2HR", "3HR", "None"],+ )++ # Valid value+ is_valid, error = rule.validate_value("2HR")+ assert is_valid is True++ # Invalid value+ is_valid, error = rule.validate_value("4HR")+ assert is_valid is False+++def test_parameter_numeric_range():+ """Test parameter numeric range validation."""+ rule = ParameterRule(+ id="wall_height",+ name="Wall Height Range",+ parameter_name="Height",+ min_value=2400.0,+ max_value=6000.0,+ )++ # Valid value+ is_valid, error = rule.validate_value(3000.0)+ assert is_valid is True++ # Too low+ is_valid, error = rule.validate_value(2000.0)+ assert is_valid is False++ # Too high+ is_valid, error = rule.validate_value(7000.0)+ assert is_valid is False+++def test_parameter_pattern_validation():+ """Test parameter pattern validation."""+ rule = ParameterRule(+ id="mark_pattern",+ name="Mark Pattern",+ parameter_name="Mark",+ pattern=r"^[A-Z]-\d{3}$",+ )++ # Valid pattern+ is_valid, error = rule.validate_value("A-101")+ assert is_valid is True++ # Invalid pattern+ is_valid, error = rule.validate_value("Wall-1")+ assert is_valid is False+++def test_parameter_custom_validator():+ """Test parameter custom validator function."""++ def is_even(value):+ return isinstance(value, int) and value % 2 == 0++ rule = ParameterRule(+ id="even_number",+ name="Even Number",+ parameter_name="Count",+ validator_function=is_even,+ )++ # Valid (even)+ is_valid, error = rule.validate_value(4)+ assert is_valid is True++ # Invalid (odd)+ is_valid, error = rule.validate_value(3)+ assert is_valid is False