技术为商业变现赋能：从价值假设到 ROI 验证的工程闭环

from dataclasses import dataclass, field

@dataclass
class ValueHypothesis:
    customer: str
    pain_point: str
    current_solution: str
    measurable_metric: str
    assumptions: list[str] = field(default_factory=list)

    def is_testable(self) -> bool:
        """可验证的假设：必须有明确客户、替代方案和量化指标"""
        return bool(self.customer and self.current_solution
                    and self.measurable_metric)

    def risk_level(self) -> str:
        n = len(self.assumptions)
        return "high" if n >= 3 else "medium" if n == 2 else "low"

hypothesis = ValueHypothesis(
    customer="中小跨境电商客服团队",
    pain_point="多语言客服夜间无人值守",
    current_solution="人工客服 + FAQ 模板",
    measurable_metric="自动解决率 ≥ 50%，转人工率 ≤ 40%",
    assumptions=[
        "客户愿意为自动解决率付费",
        "多语言质量满足基本沟通",
        "单次成本低于人工成本",
    ],
)

from dataclasses import dataclass

@dataclass
class CostModel:
    input_price_per_1k: float
    output_price_per_1k: float
    avg_input_tokens: int
    avg_output_tokens: int
    cache_hit_rate: float = 0.0
    retry_rate: float = 0.0

    def per_call_cost(self) -> float:
        raw = (self.avg_input_tokens / 1000 * self.input_price_per_1k
               + self.avg_output_tokens / 1000 * self.output_price_per_1k)
        effective = raw * (1 - self.cache_hit_rate)
        return round(effective * (1 + self.retry_rate), 6)

    def monthly_cost(self, calls_per_day: int) -> float:
        return round(self.per_call_cost() * calls_per_day * 30, 2)

    def margin(self, price_per_call: float) -> float:
        cost = self.per_call_cost()
        if price_per_call <= 0:
            return 0.0
        return round((price_per_call - cost) / price_per_call, 4)

model = CostModel(
    input_price_per_1k=0.001, output_price_per_1k=0.002,
    avg_input_tokens=800, avg_output_tokens=200,
    cache_hit_rate=0.3, retry_rate=0.05,
)

print(f"单次成本：{model.per_call_cost():.6f}")
print(f"月成本（1000 次/天）：{model.monthly_cost(1000)}")
print(f"毛利率（售价 0.01）：{model.margin(0.01):.1%}")

from dataclasses import dataclass, field

@dataclass
class IntegrationChecklist:
    network_ok: bool = False
    data_local_only: bool = False
    needs_masking: bool = False
    deploy_target: str = ""
    monitoring_owner: str = ""
    retention_days: int = 0

    def validate(self) -> list[str]:
        problems = []
        if not self.network_ok and not self.data_local_only:
            problems.append("网络受限且不允许本地部署，方案不可行")
        if self.needs_masking and self.retention_days > 30:
            problems.append("含个人信息但留存超 30 天，需重新评估")
        if not self.monitoring_owner:
            problems.append("未明确监控责任人")
        if not self.deploy_target:
            problems.append("未确认部署目标环境")
        return problems

from dataclasses import dataclass

@dataclass
class BusinessMetrics:
    total_requests: int
    auto_resolved: int
    escalated: int
    total_cost: float
    baseline_cost: float

    @property
    def auto_resolve_rate(self) -> float:
        if self.total_requests == 0:
            return 0.0
        return self.auto_resolved / self.total_requests

    def report(self) -> dict:
        saving = round(self.baseline_cost - self.total_cost, 2)
        return {
            "auto_resolve_rate": round(self.auto_resolve_rate, 3),
            "cost_saving": saving,
            "roi": round(saving / self.total_cost, 2)
                   if self.total_cost else 0,
        }