Benjamin Admin
9312ad18ef
The Map Renderer explains the engine's state, it does not extend it. Pure composition of resolve_product_scope (scope verdict) + derive_obligations (registry-linked obligations + overlaps) into one RegulatoryMap. - product_summary, trigger_facts, applicable/uncertain/excluded regulations, unsupported_domains, overlaps (shared_obligations), shared_evidence, and a customer-readable executive_summary. - No own legal decisions: applicable/uncertain mirror the scope verdict exactly. - Obligations shown ONLY when registry-linkable (registry_anchor) — MaschinenVO/ EMV obligations are proposed, so they render empty + a note, never as linked. Overlaps/shared_evidence likewise filtered to registry-linked members. - Uncertain regulations link to the navigator question that would resolve them (RED -> has_radio_module, DataAct -> generates_usage_data). - Environmental appears only as unsupported_domain; executive_summary has NO percentage (counts + "no further regulations identified" instead). - POST /reasoning/regulatory-map (thin handler). Response types are presentation- level, not meta-model classes (freeze v1.0 untouched). - 9 tests; 56 green (existing reasoning MVP stays green), mypy clean, LOC ok. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
87 lines
3.2 KiB
Python
87 lines
3.2 KiB
Python
"""HTTP endpoints for the Regulatory Reasoning Engine (spec §7).
|
|
|
|
Thin handlers — all reasoning lives in `compliance.reasoning.*`. No DB, no RAG;
|
|
pure deterministic rule evaluation.
|
|
|
|
POST /reasoning/scope -> which regulations apply + missing facts
|
|
POST /reasoning/obligations -> obligations, overlaps, multi-evidence
|
|
POST /reasoning/implementation-reasoning -> claim->obligation mapping (Welt 1, no verdict)
|
|
POST /reasoning/interpretation-assessment -> verdict on a customer interpretation
|
|
POST /reasoning/product-scope -> gate on facts, else run discover_scope once
|
|
POST /reasoning/regulatory-map -> customer-readable read-model over the scope
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from fastapi import APIRouter
|
|
|
|
from compliance.product_scope import (
|
|
ProductScopeRequest,
|
|
ProductScopeResponse,
|
|
resolve_product_scope,
|
|
)
|
|
from compliance.regulatory_map import RegulatoryMap, RegulatoryMapRequest, render_regulatory_map
|
|
from compliance.reasoning import (
|
|
assess_interpretation,
|
|
derive_obligations,
|
|
discover_scope,
|
|
reason_implementation_claim,
|
|
)
|
|
from compliance.reasoning.schemas import (
|
|
ImplementationReasoningRequest,
|
|
ImplementationReasoningResponse,
|
|
InterpretationRequest,
|
|
InterpretationResponse,
|
|
ObligationsRequest,
|
|
ObligationsResponse,
|
|
ScopeRequest,
|
|
ScopeResponse,
|
|
)
|
|
|
|
router = APIRouter(prefix="/reasoning", tags=["reasoning"])
|
|
|
|
|
|
@router.post("/scope", response_model=ScopeResponse)
|
|
def scope_discovery(req: ScopeRequest) -> ScopeResponse:
|
|
scope = discover_scope(req.product_profile)
|
|
return ScopeResponse(
|
|
regulatory_scope=scope,
|
|
missing_facts=scope.missing_facts,
|
|
confidence=scope.confidence,
|
|
)
|
|
|
|
|
|
@router.post("/obligations", response_model=ObligationsResponse)
|
|
def applicable_obligations(req: ObligationsRequest) -> ObligationsResponse:
|
|
return derive_obligations(req.product_profile, req.regulatory_scope)
|
|
|
|
|
|
@router.post("/implementation-reasoning", response_model=ImplementationReasoningResponse)
|
|
def implementation_reasoning(req: ImplementationReasoningRequest) -> ImplementationReasoningResponse:
|
|
return reason_implementation_claim(req.product_profile, req.customer_claim)
|
|
|
|
|
|
@router.post("/product-scope", response_model=ProductScopeResponse)
|
|
def product_scope(req: ProductScopeRequest) -> ProductScopeResponse:
|
|
return resolve_product_scope(req.product_profile)
|
|
|
|
|
|
@router.post("/regulatory-map", response_model=RegulatoryMap)
|
|
def regulatory_map(req: RegulatoryMapRequest) -> RegulatoryMap:
|
|
return render_regulatory_map(req.product_profile)
|
|
|
|
|
|
@router.post("/interpretation-assessment", response_model=InterpretationResponse)
|
|
def interpretation_assessment(req: InterpretationRequest) -> InterpretationResponse:
|
|
result = assess_interpretation(req.customer_interpretation, req.product_profile)
|
|
return InterpretationResponse(
|
|
assessment=result.assessment,
|
|
affected_regulations=result.affected_regulations,
|
|
affected_obligations=result.affected_obligations,
|
|
corrected_interpretation=result.corrected_interpretation,
|
|
risks=result.risks,
|
|
legal_basis_refs=result.legal_basis_refs,
|
|
explanation=result.explanation,
|
|
confidence=result.confidence,
|
|
)
|