先定不变量与契约，再写实现：Evans/Fowler 实战法

class Order:
    def __init__(self, status):
        self.status = status


def cancel(order: Order) -> Order:
    if order.status != "CREATED":
        return order
    order.status = "CANCELLED"
    return order


if __name__ == "__main__":
    order = Order("PAID")
    after = cancel(order)
    print(after.status)

class CannotCancelOrder(Exception):
    pass


class Order:
    def __init__(self, status):
        self.status = status

    def cancel(self):
        if self.status != "CREATED":
            raise CannotCancelOrder(f"invalid status={self.status}")
        self.status = "CANCELLED"
        return self


if __name__ == "__main__":
    order = Order("CREATED")
    order.cancel()
    print(order.status)

from dataclasses import dataclass
from decimal import Decimal


class ContractViolation(Exception):
    def __init__(self, code: str, message: str, retryable: bool = False):
        super().__init__(message)
        self.code = code
        self.retryable = retryable


@dataclass
class CreatePaymentCommand:
    order_id: str
    amount: Decimal
    currency: str
    request_id: str


def create_payment(cmd: CreatePaymentCommand) -> dict:
    # 数据契约
    if not cmd.order_id:
        raise ContractViolation("INVALID_ORDER_ID", "order_id is required")
    if cmd.amount <= Decimal("0"):
        raise ContractViolation("INVALID_AMOUNT", "amount must be > 0")
    if cmd.currency not in {"CNY", "USD"}:
        raise ContractViolation("INVALID_CURRENCY", "unsupported currency")
    if not cmd.request_id:
        raise ContractViolation("INVALID_REQUEST_ID", "request_id is required")

    # 行为契约（示例化返回）
    return {
        "payment_id": "pay_001",
        "order_id": cmd.order_id,
        "status": "PENDING",
    }


if __name__ == "__main__":
    cmd = CreatePaymentCommand("order_1", Decimal("99.90"), "CNY", "req-123")
    print(create_payment(cmd))

class InsufficientStock(Exception):
    pass


class InvalidSkuState(Exception):
    pass


class InventoryItem:
    def __init__(self, sku: str, available: int, status: str = "ACTIVE"):
        self.sku = sku
        self.available = available
        self.reserved = 0
        self.status = status

    def reserve(self, qty: int):
        # 数据契约
        if qty <= 0:
            raise ValueError("qty must be > 0")
        # 状态契约
        if self.status != "ACTIVE":
            raise InvalidSkuState(f"sku {self.sku} is not active")
        # 不变式契约（库存不可负）
        if self.available < qty:
            raise InsufficientStock(f"available={self.available}, qty={qty}")

        self.available -= qty
        self.reserved += qty
        # 后置条件 + 不变式
        assert self.available >= 0
        assert self.reserved >= 0
        return self


if __name__ == "__main__":
    item = InventoryItem("sku-1", 10)
    item.reserve(3)
    print(item.available, item.reserved)  # 7 3

class AuditLogError(Exception):
    pass


class OrderService:
    def __init__(self):
        self.db = {}
        self.audit_logs = []

    def _write_audit(self, message: str):
        # 模拟偶发失败
        raise AuditLogError("audit service unavailable")

    def cancel_order(self, order_id: str) -> dict:
        # 副作用契约（主路径）
        # 1) 订单状态更新必须成功，否则整体失败
        self.db[order_id] = "CANCELLED"

        # 副作用契约（非关键路径）
        # 2) 审计日志失败不回滚主事务，但必须记录告警/重试任务（此处用字段模拟）
        audit_pending = False
        try:
            self._write_audit(f"cancel {order_id}")
        except AuditLogError:
            audit_pending = True

        return {"order_id": order_id, "status": "CANCELLED", "audit_pending": audit_pending}


if __name__ == "__main__":
    svc = OrderService()
    print(svc.cancel_order("o-1"))