# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/how-must-an-instance-handle-partial-contract-fulfillment-from-a-peer.md
# Remnant Warrant:    https://corpusfetch.com/c/how-must-an-instance-handle-partial-contract-fulfillment-from-a-peer.warrant.json
# Markdown SHA-256:   d7c733c8b760350cff211277d4c2a1f151203e637ec47ff13f350c3319814b66
# Code AST SHA-256:   7427e32ea433858eac7e1245b4412328fb228fc2c760c8f096e1b0920f668e0f
# Verified Classes:   PartialFulfillmentVerdict, PartialDelivery, PartialPolicy, PartialManifest, PartialFulfillmentGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class PartialFulfillmentVerdict(Enum):
    FULL_FULFILLMENT = auto()
    PARTIAL_ACCEPTED_DECLARED = auto()
    PARTIAL_REJECTED = auto()
    IMPLICIT_WAIVER_RISK = auto()

@dataclass(frozen=True)
class PartialDelivery:
    delivery_id: str
    full_delivery: bool
    contract_permits_partial: bool
    shortfall_value: float
    de_minimis_threshold: float
    declaration_made: bool

@dataclass(frozen=True)
class PartialPolicy:
    require_declaration: bool

@dataclass(frozen=True)
class PartialManifest:
    verdict: PartialFulfillmentVerdict
    directive: str
    manifest_digest: str

class PartialFulfillmentGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_delivery(
        cls, delivery: PartialDelivery, policy: PartialPolicy
    ) -> PartialManifest:
        
        # Gate 1: Full delivery
        if delivery.full_delivery:
            digest = cls._hash(json.dumps({
                "delivery": delivery.delivery_id,
                "full": True
            }, sort_keys=True))
            return PartialManifest(
                verdict=PartialFulfillmentVerdict.FULL_FULFILLMENT,
                directive=f"PROCEED: Delivery {delivery.delivery_id} full.",
                manifest_digest=digest
            )

        # Gate 2: Contract prohibits partial
        if not delivery.contract_permits_partial:
            return PartialManifest(
                verdict=PartialFulfillmentVerdict.PARTIAL_REJECTED,
                directive=f"REJECT: Delivery {delivery.delivery_id} partial, contract prohibits.",
                manifest_digest=cls._hash(f"PROHIBITED:{delivery.delivery_id}")
            )

        # Gate 3: De minimis
        if delivery.shortfall_value <= delivery.de_minimis_threshold:
            digest = cls._hash(json.dumps({
                "delivery": delivery.delivery_id,
                "shortfall": f"{delivery.shortfall_value:.3f}",
                "de_minimis": True
            }, sort_keys=True))
            return PartialManifest(
                verdict=PartialFulfillmentVerdict.PARTIAL_ACCEPTED_DECLARED,
                directive=f"PROCEED: Delivery {delivery.delivery_id} within de minimis.",
                manifest_digest=digest
            )

        # Gate 4: Declaration requirement
        if policy.require_declaration and not delivery.declaration_made:
            return PartialManifest(
                verdict=PartialFulfillmentVerdict.IMPLICIT_WAIVER_RISK,
                directive=f"HALT: Delivery {delivery.delivery_id} partial without declaration.",
                manifest_digest=cls._hash(f"NO_DECLARATION:{delivery.delivery_id}")
            )

        # Gate 5: Declared acceptance
        digest = cls._hash(json.dumps({
            "delivery": delivery.delivery_id,
            "shortfall": f"{delivery.shortfall_value:.3f}",
            "declared": True
        }, sort_keys=True))
        
        return PartialManifest(
            verdict=PartialFulfillmentVerdict.PARTIAL_ACCEPTED_DECLARED,
            directive=f"PROCEED: Delivery {delivery.delivery_id} partial accepted with declaration.",
            manifest_digest=digest
        )