데이터 신탁

# 데이터 신탁 서비스 개념 구현 예제
from dataclasses import dataclass, field
from datetime import datetime
from typing import List, Dict, Optional
from enum import Enum
import uuid

class DataUsePurpose(Enum):
    RESEARCH = "research"           # 학술 연구
    AI_TRAINING = "ai_training"     # AI 모델 학습
    MARKETING = "marketing"         # 마케팅
    PERSONALIZATION = "personalization"  # 개인화 서비스
    PUBLIC_INTEREST = "public_interest"  # 공익 목적

class ConsentDecision(Enum):
    ALLOW = "allow"
    DENY = "deny"
    CONDITIONAL = "conditional"  # 조건부 허용

@dataclass
class DataSubject:
    """데이터 주체 (개인)"""
    subject_id: str
    name: str
    trust_preferences: Dict[DataUsePurpose, ConsentDecision]
    data_assets: List[str]  # 신탁에 맡긴 데이터 유형

@dataclass
class DataUseRequest:
    """데이터 활용 요청"""
    request_id: str
    requester: str           # 요청 기업/기관
    purpose: DataUsePurpose
    data_types: List[str]    # 요청 데이터 유형
    duration_days: int       # 활용 기간
    compensation: float      # 제안 보상금 (원)
    ethical_review: bool     # 윤리 심사 통과 여부
    created_at: datetime = field(default_factory=datetime.now)

class DataTrust:
    """데이터 신탁 기관"""

    def __init__(self, trust_name: str):
        self.trust_name = trust_name
        self.subjects: Dict[str, DataSubject] = {}
        self.requests: List[DataUseRequest] = []
        self.decisions: Dict[str, Dict] = {}  # request_id -> 결정 내역

    def register_subject(self, name: str,
                         preferences: Dict[DataUsePurpose, ConsentDecision],
                         data_assets: List[str]) -> str:
        """개인 등록 및 신탁 위임"""
        subject_id = str(uuid.uuid4())[:8]
        self.subjects[subject_id] = DataSubject(
            subject_id=subject_id,
            name=name,
            trust_preferences=preferences,
            data_assets=data_assets
        )
        print(f"[신탁 등록] {name}님의 데이터가 신탁되었습니다.")
        return subject_id

    def submit_data_use_request(self, request: DataUseRequest) -> str:
        """데이터 활용 요청 접수"""
        self.requests.append(request)
        print(f"[요청 접수] {request.requester}의 {request.purpose.value} 목적 요청")
        return request.request_id

    def evaluate_request(self, request_id: str) -> Dict:
        """신탁 기관이 개인들을 대신해 요청 평가"""
        request = next((r for r in self.requests if r.request_id == request_id), None)
        if not request:
            return {"error": "요청을 찾을 수 없습니다"}

        # 각 개인의 선호도에 따라 집합적 결정
        allow_count = 0
        deny_count = 0
        affected_subjects = []

        for subject_id, subject in self.subjects.items():
            # 요청 데이터 유형이 신탁된 데이터와 겹치는지 확인
            if any(asset in request.data_types for asset in subject.data_assets):
                affected_subjects.append(subject_id)
                pref = subject.trust_preferences.get(request.purpose, ConsentDecision.DENY)

                if pref == ConsentDecision.ALLOW:
                    allow_count += 1
                elif pref == ConsentDecision.DENY:
                    deny_count += 1
                else:  # CONDITIONAL
                    # 조건 검증 (예: AI 학습은 윤리 심사 통과 필수)
                    if request.purpose == DataUsePurpose.AI_TRAINING:
                        if request.ethical_review:
                            allow_count += 1
                        else:
                            deny_count += 1

        # 집합적 결정 (과반수 기준)
        total = allow_count + deny_count
        decision = "approved" if allow_count > deny_count else "denied"

        # 보상 분배 계산
        compensation_per_person = request.compensation / len(affected_subjects) if affected_subjects else 0

        result = {
            "request_id": request_id,
            "decision": decision,
            "affected_subjects": len(affected_subjects),
            "allow_votes": allow_count,
            "deny_votes": deny_count,
            "compensation_per_person": compensation_per_person,
            "conditions": self._generate_conditions(request) if decision == "approved" else []
        }

        self.decisions[request_id] = result
        return result

    def _generate_conditions(self, request: DataUseRequest) -> List[str]:
        """승인 시 부가 조건 생성"""
        conditions = []
        if request.purpose == DataUsePurpose.AI_TRAINING:
            conditions.append("학습된 모델에 대한 편향 감사 보고서 제출 의무")
            conditions.append("모델 카드에 데이터 출처로 신탁 기관 명시")
            conditions.append("상업적 이용 시 추가 로열티 협의")
        return conditions

# 사용 예시
trust = DataTrust("한국AI데이터신탁")

# 개인들이 신탁에 데이터 위임
trust.register_subject(
    name="홍길동",
    preferences={
        DataUsePurpose.RESEARCH: ConsentDecision.ALLOW,
        DataUsePurpose.AI_TRAINING: ConsentDecision.CONDITIONAL,
        DataUsePurpose.MARKETING: ConsentDecision.DENY
    },
    data_assets=["건강데이터", "금융데이터"]
)

# AI 기업이 학습 데이터 요청
request = DataUseRequest(
    request_id="REQ-2024-001",
    requester="AI헬스케어(주)",
    purpose=DataUsePurpose.AI_TRAINING,
    data_types=["건강데이터"],
    duration_days=365,
    compensation=1000000,
    ethical_review=True
)
trust.submit_data_use_request(request)

# 신탁 기관이 집합적 결정
result = trust.evaluate_request("REQ-2024-001")
print(f"결정: {result['decision']}, 부가조건: {result['conditions']}")