contract_parser.py

• Pfad: /var/www/mcp-servers/mcp-contracts/tools/contract_tools_components/contract_parser.py
• Namespace: -
• Zeilen: 78 | Größe: 2,030 Bytes
• Geändert: 2025-12-28 12:21:49 | Gescannt: 2025-12-31 10:22:15

Code Hygiene Score: 100

• Dependencies: 100 (25%)
• LOC: 100 (20%)
• Methods: 100 (20%)
• Secrets: 100 (15%)
• Classes: 100 (10%)
• Magic Numbers: 100 (10%)

Keine Issues gefunden.

Dependencies 4

• extends Exception
• use typing.Any
• use typing.Optional
• use yaml

Klassen 2

• ContractParseError class Zeile 6
• ContractParser class Zeile 11

Code

"""Contract YAML Parser Module"""
from typing import Any, Optional
import yaml


class ContractParseError(Exception):
    """Raised when contract YAML cannot be parsed"""
    pass


class ContractParser:
    """Handles parsing and validation of contract YAML content"""

    @staticmethod
    def parse_yaml(yaml_content: str) -> dict[str, Any]:
        """
        Parse YAML content into a dictionary.

        Args:
            yaml_content: Raw YAML string

        Returns:
            Parsed YAML as dictionary

        Raises:
            ContractParseError: If YAML is invalid
        """
        try:
            data = yaml.safe_load(yaml_content)
            if data is None:
                raise ContractParseError("Empty YAML content")
            return data
        except yaml.YAMLError as e:
            raise ContractParseError(f"Invalid YAML: {e}") from e

    @staticmethod
    def validate_yaml_syntax(yaml_content: str) -> tuple[bool, Optional[str]]:
        """
        Validate YAML syntax without parsing into domain object.

        Args:
            yaml_content: Raw YAML string

        Returns:
            Tuple of (is_valid, error_message)
        """
        try:
            ContractParser.parse_yaml(yaml_content)
            return True, None
        except ContractParseError as e:
            return False, str(e)

    @staticmethod
    def extract_scope(contract_data: dict[str, Any]) -> Optional[str]:
        """
        Extract scope from parsed contract data.

        Args:
            contract_data: Parsed contract dictionary

        Returns:
            Scope path or None if not found
        """
        return contract_data.get("scope")

    @staticmethod
    def extract_rules(contract_data: dict[str, Any]) -> list[dict[str, Any]]:
        """
        Extract rules from parsed contract data.

        Args:
            contract_data: Parsed contract dictionary

        Returns:
            List of rule dictionaries
        """
        return contract_data.get("rules", [])