Skip to content

Open-source Revit MCP server: let Claude and other AI assistants read and edit BIM models, with human approval on every change.

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.py
new file mode 100644
index 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.py
new file mode 100644
index 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