contracts.py

• Pfad: /var/www/mcp-servers/mcp-contracts/domain/contracts.py
• Namespace: -
• Zeilen: 131 | Größe: 4,303 Bytes
• Geändert: 2025-12-28 12:51:16 | Gescannt: 2025-12-31 10:22:15

Code Hygiene Score: 93

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

Keine Issues gefunden.

Dependencies 10

• extends str
• trait Enum
• use dataclasses.dataclass
• use dataclasses.field
• use datetime.datetime
• use enum.Enum
• use typing.Optional
• use typing.Dict
• use typing.Any
• use typing.List

Klassen 5

• ContractStatus class Zeile 8
• Contract class Zeile 16
• ContractHistory class Zeile 56
• ContractValidation class Zeile 78
• ContractValidationResult class Zeile 109

Code

"""Domain Entities für MCP-Contracts Server"""
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from typing import Optional, Dict, Any, List


class ContractStatus(str, Enum):
    """Contract-Status-Werte"""
    DRAFT = "draft"
    ACTIVE = "active"
    DEPRECATED = "deprecated"


@dataclass
class Contract:
    """Contract-Entity für Datenbank"""
    id: Optional[int] = None
    uuid: str = ""
    name: str = ""
    version: str = "1.0"
    status: ContractStatus = ContractStatus.ACTIVE
    yaml_content: str = ""
    scope_description: Optional[str] = None
    created_at: datetime = field(default_factory=datetime.now)
    created_by: str = "system"
    updated_at: datetime = field(default_factory=datetime.now)

    def to_dict(self) -> Dict[str, Any]:
        """Vollständige Darstellung"""
        return {
            "id": self.id,
            "uuid": self.uuid,
            "name": self.name,
            "version": self.version,
            "status": self.status.value if isinstance(self.status, ContractStatus) else self.status,
            "yaml_content": self.yaml_content,
            "scope_description": self.scope_description,
            "created_at": self.created_at.isoformat() if self.created_at else None,
            "created_by": self.created_by,
            "updated_at": self.updated_at.isoformat() if self.updated_at else None,
        }

    def to_dict_compact(self) -> Dict[str, Any]:
        """Kompakte Darstellung für Listen (Token-sparend)"""
        return {
            "id": self.id,
            "name": self.name,
            "version": self.version,
            "status": self.status.value if isinstance(self.status, ContractStatus) else self.status,
            "scope_description": self.scope_description,
        }


@dataclass
class ContractHistory:
    """Contract-Änderungshistorie"""
    id: Optional[int] = None
    contract_id: int = 0
    previous_yaml: Optional[str] = None
    previous_version: Optional[str] = None
    change_description: Optional[str] = None
    changed_at: datetime = field(default_factory=datetime.now)
    changed_by: str = "system"

    def to_dict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "contract_id": self.contract_id,
            "previous_version": self.previous_version,
            "change_description": self.change_description,
            "changed_at": self.changed_at.isoformat() if self.changed_at else None,
            "changed_by": self.changed_by,
        }


@dataclass
class ContractValidation:
    """Contract-Validierungslauf"""
    id: Optional[int] = None
    contract_id: int = 0
    validated_at: datetime = field(default_factory=datetime.now)
    result: str = "passed"  # passed | failed
    critical_count: int = 0
    major_count: int = 0
    minor_count: int = 0
    violations: List[Dict[str, Any]] = field(default_factory=list)
    triggered_by: str = "mcp"  # sync | manual | hook | mcp
    target_path: Optional[str] = None
    duration_ms: int = 0

    def to_dict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "contract_id": self.contract_id,
            "validated_at": self.validated_at.isoformat() if self.validated_at else None,
            "result": self.result,
            "critical_count": self.critical_count,
            "major_count": self.major_count,
            "minor_count": self.minor_count,
            "violations": self.violations,
            "triggered_by": self.triggered_by,
            "target_path": self.target_path,
            "duration_ms": self.duration_ms,
        }


@dataclass
class ContractValidationResult:
    """Ergebnis einer Contract-Validierung (in-memory)"""
    contract: str = ""
    outcome: str = "passed"  # passed | revision_required | rejected
    critical: int = 0
    major: int = 0
    minor: int = 0
    findings: List[Dict[str, Any]] = field(default_factory=list)

    def to_dict(self) -> Dict[str, Any]:
        return {
            "contract": self.contract,
            "outcome": self.outcome,
            "violations": {
                "critical": self.critical,
                "major": self.major,
                "minor": self.minor,
            },
            "findings": self.findings,
        }