CREATE TABLE documents (
  id UUID PRIMARY KEY,
  source_path VARCHAR(255),
  document_type ENUM('clinical_policy', 'sop', 'consent_form', 'quality_manual'),
  risk_level ENUM('high', 'medium', 'low'),
  source_language VARCHAR(5),
  created_at TIMESTAMP,
  accreditation_deadline DATE
);

CREATE TABLE translations (
  id UUID PRIMARY KEY,
  document_id UUID REFERENCES documents(id),
  target_language VARCHAR(5),
  translator_id UUID,
  reviewer_id UUID,
  status ENUM('draft', 'translated', 'reviewed', 'approved'),
  translation_memory_matches JSONB,
  created_at TIMESTAMP,
  approved_at TIMESTAMP
);

CREATE TABLE terminology (
  id UUID PRIMARY KEY,
  term_source VARCHAR(255),
  term_target VARCHAR(255),
  language_pair VARCHAR(11), -- e.g., 'en-pt'
  domain ENUM('clinical', 'quality', 'regulatory'),
  approved_by UUID,
  created_at TIMESTAMP
);

import re
from typing import List, Dict, Tuple

class TerminologyValidator:
    def __init__(self, glossary: Dict[str, str]):
        self.glossary = glossary
        # Create regex patterns for each term
        self.patterns = {
            term: re.compile(r'\b' + re.escape(term) + r'\b', re.IGNORECASE)
            for term in glossary.keys()
        }

    def validate_translation(self, source_text: str, target_text: str) -> List[Dict]:
        issues = []

        for source_term, pattern in self.patterns.items():
            if pattern.search(source_text):
                expected_translation = self.glossary[source_term]
                target_pattern = re.compile(r'\b' + re.escape(expected_translation) + r'\b', re.IGNORECASE)

                if not target_pattern.search(target_text):
                    issues.append({
                        'type': 'terminology_mismatch',
                        'source_term': source_term,
                        'expected_translation': expected_translation,
                        'severity': 'high' if self._is_critical_term(source_term) else 'medium'
                    })

        return issues

    def _is_critical_term(self, term: str) -> bool:
        critical_domains = ['adverse event', 'non-conformance', 'clinical risk']
        return any(domain in term.lower() for domain in critical_domains)

from enum import Enum
from dataclasses import dataclass
from typing import Optional

class DocumentRiskLevel(Enum):
    HIGH = "high"  # Clinical policies, consent forms
    MEDIUM = "medium"  # SOPs, training materials
    LOW = "low"  # Internal communications

class TranslationStatus(Enum):
    DRAFT = "draft"
    TRANSLATED = "translated"
    REVIEWED = "reviewed"
    APPROVED = "approved"

@dataclass
class QualityGate:
    risk_level: DocumentRiskLevel
    required_reviewers: int
    terminology_check_required: bool
    iso_17100_compliance: bool

class WorkflowEngine:
    def __init__(self):
        self.quality_gates = {
            DocumentRiskLevel.HIGH: QualityGate(
                risk_level=DocumentRiskLevel.HIGH,
                required_reviewers=2,
                terminology_check_required=True,
                iso_17100_compliance=True
            ),
            DocumentRiskLevel.MEDIUM: QualityGate(
                risk_level=DocumentRiskLevel.MEDIUM,
                required_reviewers=1,
                terminology_check_required=True,
                iso_17100_compliance=False
            ),
            DocumentRiskLevel.LOW: QualityGate(
                risk_level=DocumentRiskLevel.LOW,
                required_reviewers=0,
                terminology_check_required=False,
                iso_17100_compliance=False
            )
        }

    def can_advance_status(self, translation_id: str, target_status: TranslationStatus) -> Tuple[bool, Optional[str]]:
        # Implementation would check database for current reviews, terminology validation, etc.
        pass

import requests
from typing import Dict, Any

class TranslationAPI:
    def __init__(self, api_key: str, base_url: str):
        self.api_key = api_key
        self.base_url = base_url

    def translate_with_memory(self, text: str, source_lang: str, target_lang: str, 
                            translation_memory: Dict[str, str]) -> Dict[str, Any]:

        # Check translation memory first
        memory_matches = self._check_translation_memory(text, translation_memory)

        if memory_matches['match_percentage'] > 95:
            return {
                'translation': memory_matches['target_text'],
                'source': 'translation_memory',
                'confidence': memory_matches['match_percentage'],
                'requires_review': memory_matches['match_percentage'] < 100
            }

        # Fall back to API
        response = requests.post(f"{self.base_url}/translate", {
            'text': text,
            'source': source_lang,
            'target': target_lang,
            'api_key': self.api_key
        })

        if response.status_code == 200:
            result = response.json()
            return {
                'translation': result['translated_text'],
                'source': 'machine_translation',
                'confidence': result.get('confidence', 0.8),
                'requires_review': True  # Always require review for MT
            }

        raise Exception(f"Translation API error: {response.status_code}")

    def _check_translation_memory(self, text: str, memory: Dict[str, str]) -> Dict[str, Any]:
        # Implement fuzzy matching logic here
        pass

import logging
from datetime import datetime
from typing import Dict, Any

class ComplianceLogger:
    def __init__(self, db_connection):
        self.db = db_connection
        self.logger = logging.getLogger('compliance')

    def log_translation_event(self, event_type: str, document_id: str, 
                            user_id: str, metadata: Dict[str, Any]):

        event_record = {
            'timestamp': datetime.utcnow(),
            'event_type': event_type,
            'document_id': document_id,
            'user_id': user_id,
            'metadata': metadata
        }

        # Store in database
        self.db.execute(
            "INSERT INTO audit_trail (timestamp, event_type, document_id, user_id, metadata) "
            "VALUES (%(timestamp)s, %(event_type)s, %(document_id)s, %(user_id)s, %(metadata)s)",
            event_record
        )

        # Also log for real-time monitoring
        self.logger.info(f"Translation event: {event_type}", extra=event_record)

    def generate_compliance_report(self, accreditation_project_id: str) -> Dict[str, Any]:
        # Generate detailed report for auditors
        pass

def test_high_risk_document_workflow():
    # Test that high-risk documents require two reviewers
    document = create_test_document(risk_level=DocumentRiskLevel.HIGH)
    translation = submit_translation(document.id, 'en', 'pt')

    # Should not be approvable with only one review
    assert not workflow.can_advance_status(translation.id, TranslationStatus.APPROVED)[0]

    # Should be approvable after two reviews
    add_review(translation.id, reviewer_1_id)
    add_review(translation.id, reviewer_2_id)
    assert workflow.can_advance_status(translation.id, TranslationStatus.APPROVED)[0]