低代码平台选型：四问决策树

"""路线判定器：把选型问题压成一棵可执行的决策树。

顺序是刻意设计的 —— 先问数据边界，再问团队能力，最后才问成本。
把成本放最后，是因为成本能谈，合规不能谈。

纯标准库，直接 python3 route_decide.py 就能跑。
"""

SAAS = "订阅在线平台"
SELF_HOST = "开源自部署"
SELF_BUILT = "全自研框架"


def decide(case):
    """按固定顺序问四个问题，返回 (推荐路线, 决定性理由)。

    case 是一个字典，字段含义见下方 CASES。
    """
    # 第一问：数据能不能离开自己的网络边界
    # 这是唯一一个「否」就直接砍掉整条分支的问题
    if not case["data_may_leave_network"]:
        if case["needs_deep_customization"]:
            return SELF_BUILT, "数据不许出网 + 需要深度定制，只剩自己搭这一条路"
        return SELF_HOST, "数据不许出网，排除一切托管平台；编排能力够用则自部署"

    # 第二问：有没有人能接住运维
    # 没人运维的自部署，半年后一定变成没人敢升级的黑盒
    if not case["has_ops_capacity"]:
        return SAAS, "数据可出网且无人承接运维，自部署会在升级时失控"

    # 第三问：现有平台的编排能力够不够
    if case["needs_deep_customization"]:
        return SELF_BUILT, "需求超出拖拽编排的表达能力，平台会变成负担"

    # 第四问：这才轮到成本与速度
    if case["monthly_calls"] < 100_000 and case["time_to_market_weeks"] <= 4:
        return SAAS, "量不大且要得急，订阅平台的起步速度不可替代"

    return SELF_HOST, "量已上来且有运维能力，自部署在可控性上更划算"


CASES = {
    "电商批量生成营销文案": {
        "data_may_leave_network": True,      # 商品文案本就是要公开的
        "has_ops_capacity": False,
        "needs_deep_customization": False,
        "monthly_calls": 30_000,
        "time_to_market_weeks": 2,
    },
    "律所法律问答（连业务库）": {
        "data_may_leave_network": False,     # 案卷与客户资料
        "has_ops_capacity": True,
        "needs_deep_customization": False,
        "monthly_calls": 20_000,
        "time_to_market_weeks": 8,
    },
    "医院内部病历问答": {
        "data_may_leave_network": False,
        "has_ops_capacity": True,
        "needs_deep_customization": True,    # 要接院内 HIS，权限模型复杂
        "monthly_calls": 50_000,
        "time_to_market_weeks": 16,
    },
    "运营部门内部提效小工具": {
        "data_may_leave_network": True,
        "has_ops_capacity": False,
        "needs_deep_customization": False,
        "monthly_calls": 5_000,
        "time_to_market_weeks": 1,
    },
    "面向公众的核心对话产品": {
        "data_may_leave_network": True,
        "has_ops_capacity": True,
        "needs_deep_customization": True,
        "monthly_calls": 3_000_000,
        "time_to_market_weeks": 24,
    },
}


def main():
    for name, case in CASES.items():
        route, why = decide(case)
        print("%-22s -> %-8s  %s" % (name, route, why))

    # 把「数据不出网」这条规则钉死：无论其他条件怎么变，结论都不会是订阅平台
    for name, case in CASES.items():
        if not case["data_may_leave_network"]:
            route, _ = decide(case)
            assert route != SAAS, "%s 的数据不许出网，不该推荐订阅平台" % name
    print("\n校验通过：数据不出网的场景，没有一个被推荐到订阅平台。")


if __name__ == "__main__":
    main()

电商批量生成营销文案             -> 订阅在线平台    数据可出网且无人承接运维，自部署会在升级时失控
律所法律问答（连业务库）           -> 开源自部署     数据不许出网，排除一切托管平台；编排能力够用则自部署
医院内部病历问答               -> 全自研框架     数据不许出网 + 需要深度定制，只剩自己搭这一条路
运营部门内部提效小工具            -> 订阅在线平台    数据可出网且无人承接运维，自部署会在升级时失控
面向公众的核心对话产品            -> 全自研框架     需求超出拖拽编排的表达能力，平台会变成负担

校验通过：数据不出网的场景，没有一个被推荐到订阅平台。

"""加权打分：把「感觉哪个好」变成一个可复算的数字。

四个维度不是并列的，权重由业务场景决定 —— 这正是同一道题不同公司
给出不同答案的原因。改权重比改分数更能反映真实立场。

纯标准库，直接 python3 score_matrix.py 就能跑。
"""

# 三条路线在四个维度上的表现分（0-10，越高越好）
# 打分依据写在注释里，换了场景要自己重打，不要照抄
ROUTES = {
    "订阅在线平台": {
        "data_compliance": 3,   # 数据要过平台，跨境/行业监管场景直接出局
        "cost_at_start": 9,     # 起步几乎零成本，不用买机器也不用招运维
        "iteration_speed": 9,   # 拖拽即改，改完立刻能试
        "controllability": 3,   # 模型、插件、配额都由平台定，说停就停
    },
    "开源自部署": {
        "data_compliance": 9,   # 数据落在自己机房，边界清晰
        "cost_at_start": 4,     # 机器 + 运维 + 排障时间都是真金白银
        "iteration_speed": 7,   # 仍是拖拽编排，但升级、修复要自己扛
        "controllability": 8,   # 能改源码、能换模型，受许可证附加条款约束
    },
    "全自研框架": {
        "data_compliance": 9,   # 想怎么隔离就怎么隔离
        "cost_at_start": 2,     # 每个轮子都要自己造，人力成本最高
        "iteration_speed": 3,   # 改一个流程要走完整的开发测试上线
        "controllability": 10,  # 没有任何外部约束
    },
}

# 四类典型业务场景的权重（四项之和固定为 1.0）
SCENARIOS = {
    "个人/小团队快速验证": {
        "data_compliance": 0.10,
        "cost_at_start": 0.40,
        "iteration_speed": 0.40,
        "controllability": 0.10,
    },
    "金融医疗等强监管业务": {
        "data_compliance": 0.55,
        "cost_at_start": 0.10,
        "iteration_speed": 0.10,
        "controllability": 0.25,
    },
    "企业内部提效工具": {
        "data_compliance": 0.30,
        "cost_at_start": 0.25,
        "iteration_speed": 0.30,
        "controllability": 0.15,
    },
    "对外核心产品": {
        "data_compliance": 0.25,
        "cost_at_start": 0.10,
        "iteration_speed": 0.20,
        "controllability": 0.45,
    },
}


def score(route_name, weights):
    """一条路线在给定权重下的加权总分。"""
    dims = ROUTES[route_name]
    return sum(dims[k] * weights[k] for k in weights)


def rank(weights):
    """按加权总分从高到低排序，返回 [(路线, 分数), ...]。"""
    pairs = [(name, score(name, weights)) for name in ROUTES]
    return sorted(pairs, key=lambda x: x[1], reverse=True)


def main():
    for scenario, weights in SCENARIOS.items():
        # 权重必须归一，否则不同场景的分数没法横向比
        total_w = sum(weights.values())
        assert abs(total_w - 1.0) < 1e-9, "%s 权重之和为 %s，应为 1.0" % (scenario, total_w)

        board = rank(weights)
        print("\n【%s】" % scenario)
        for i, (name, sc) in enumerate(board, 1):
            mark = "  <== 推荐" if i == 1 else ""
            print("  %d. %-12s %.2f%s" % (i, name, sc, mark))

        # 第一名和第二名差距太小，说明这道题本身没有明显答案，
        # 该去补业务信息而不是硬选
        gap = board[0][1] - board[1][1]
        if gap < 0.5:
            print("  ⚠ 前两名仅差 %.2f，属于「怎么选都行」，别在这里纠结" % gap)


if __name__ == "__main__":
    main()

【个人/小团队快速验证】
  1. 订阅在线平台       7.80  <== 推荐
  2. 开源自部署        6.10
  3. 全自研框架        3.90

【金融医疗等强监管业务】
  1. 开源自部署        8.05  <== 推荐
  2. 全自研框架        7.95
  3. 订阅在线平台       4.20
  ⚠ 前两名仅差 0.10，属于「怎么选都行」，别在这里纠结

【企业内部提效工具】
  1. 开源自部署        7.00  <== 推荐
  2. 订阅在线平台       6.30
  3. 全自研框架        5.60

【对外核心产品】
  1. 开源自部署        7.65  <== 推荐
  2. 全自研框架        7.55
  3. 订阅在线平台       4.80
  ⚠ 前两名仅差 0.10，属于「怎么选都行」，别在这里纠结

"""数据边界审计：一条请求到底把什么送出了公司网络。

选型讨论里最常见的错觉是「我们只发了一个问题过去」。
实际上一次平台调用会携带：用户原话、命中的知识库分片、
数据库查询结果、历史会话、文件原文 —— 任何一项越界都算越界。

纯标准库，直接 python3 data_boundary_audit.py 就能跑。
"""

# 敏感级别：越高越不能离开自有网络
LEVEL = {
    "public": 0,        # 本来就对外公开
    "internal": 1,      # 公司内部可见
    "confidential": 2,  # 限定人员可见
    "regulated": 3,     # 受行业或法律强监管
}

# 一次平台调用实际会携带的载荷清单
PAYLOAD = [
    # (载荷项, 敏感级别, 是否真的必须送出去)
    ("用户输入的原始问题", "internal", True),
    ("知识库命中的文档分片", "confidential", True),
    ("业务数据库查询结果", "regulated", True),
    ("历史多轮会话", "confidential", True),
    ("用户上传的原始文件", "confidential", True),
    ("内部系统的接口地址与字段名", "internal", False),
    ("调试用的完整堆栈", "internal", False),
]

# 这套系统允许离开网络的最高级别
ALLOWED_MAX = LEVEL["internal"]


def audit(payload, allowed_max):
    """返回 (越界项, 可裁掉的项)。"""
    violations, trimmable = [], []
    for name, lv, required in payload:
        if LEVEL[lv] > allowed_max:
            violations.append((name, lv, required))
        if not required:
            trimmable.append(name)
    return violations, trimmable


def main():
    violations, trimmable = audit(PAYLOAD, ALLOWED_MAX)

    print("允许出网的最高敏感级别：internal\n")
    print("越界载荷：")
    for name, lv, required in violations:
        tag = "业务必需" if required else "可直接删掉"
        print("  ❌ %-22s %-13s %s" % (name, lv, tag))

    print("\n无论如何都该裁掉的：")
    for name in trimmable:
        print("  ✂ %s" % name)

    must_stay = [v for v in violations if v[2]]
    print()
    if must_stay:
        print("结论：有 %d 项越界载荷是业务必需的，删不掉。" % len(must_stay))
        print("这意味着「换个提示词就合规了」是幻想 —— 要么把这些数据")
        print("留在自己网络里（自部署），要么先做脱敏再出网，二选一。")
    else:
        print("结论：越界项都可裁剪，裁完即可使用托管平台。")

    # 只要还有业务必需的越界项，就不允许得出「可以用托管平台」的结论
    assert must_stay, "示例数据本就包含 regulated 级别的必需载荷"


if __name__ == "__main__":
    main()

允许出网的最高敏感级别：internal

越界载荷：
  ❌ 知识库命中的文档分片             confidential  业务必需
  ❌ 业务数据库查询结果              regulated     业务必需
  ❌ 历史多轮会话                 confidential  业务必需
  ❌ 用户上传的原始文件              confidential  业务必需

无论如何都该裁掉的：
  ✂ 内部系统的接口地址与字段名
  ✂ 调试用的完整堆栈

结论：有 4 项越界载荷是业务必需的，删不掉。
这意味着「换个提示词就合规了」是幻想 —— 要么把这些数据
留在自己网络里（自部署），要么先做脱敏再出网，二选一。

"""三条路线的三年总持有成本（TCO）对比模型。

结论不是「哪条便宜」，而是「在多长的时间尺度上哪条便宜」——
订阅制起步便宜但按量线性增长，自部署有一笔固定门槛但边际成本低。
两条曲线一定有交点，找到那个交点，选型就有了量化依据。

所有单价都是占位参数，必须换成自己实际询价得到的数字再算。
纯标准库，直接 python3 tco_model.py 就能跑。
"""

MONTHS = 36

# —— 占位参数：用你自己的真实报价替换 ——
CALLS_PER_MONTH_START = 20_000      # 首月调用量
MONTHLY_GROWTH = 0.08               # 调用量月增长率

PRICE_PER_CALL_SAAS = 0.02          # 订阅平台每次调用的综合单价（元）
PLATFORM_BASE_FEE = 0              # 订阅平台固定月费（元）

SERVER_MONTHLY = 3_000              # 自部署：一台够用的机器月租（元）
OPS_MONTHLY = 6_000                 # 自部署：分摊到这套系统的运维人力（元）
SETUP_ONCE = 40_000                 # 自部署：一次性搭建与调优投入（元）
PRICE_PER_CALL_SELF = 0.006         # 自部署：仍要付给模型厂商的推理单价（元）

DEV_MONTHLY_SELFBUILT = 25_000      # 全自研：持续投入的研发人力（元）
SETUP_ONCE_SELFBUILT = 150_000      # 全自研：从零到可用的一次性投入（元）


def calls_in_month(m):
    """第 m 个月（从 0 开始）的调用量。"""
    return CALLS_PER_MONTH_START * ((1 + MONTHLY_GROWTH) ** m)


def cumulative():
    """逐月累计三条路线的总成本，返回 {路线: [每月累计, ...]}。"""
    saas, self_host, self_built = [], [], []
    a = b = c = 0.0
    b += SETUP_ONCE
    c += SETUP_ONCE_SELFBUILT

    for m in range(MONTHS):
        n = calls_in_month(m)
        a += PLATFORM_BASE_FEE + n * PRICE_PER_CALL_SAAS
        b += SERVER_MONTHLY + OPS_MONTHLY + n * PRICE_PER_CALL_SELF
        c += DEV_MONTHLY_SELFBUILT + n * PRICE_PER_CALL_SELF
        saas.append(a)
        self_host.append(b)
        self_built.append(c)

    return {"订阅在线平台": saas, "开源自部署": self_host, "全自研框架": self_built}


def crossover(series_a, series_b):
    """找 a 由便宜变贵的那个月（1-based）；始终不反超返回 None。"""
    for m in range(len(series_a)):
        if series_a[m] > series_b[m]:
            return m + 1
    return None


def main():
    data = cumulative()

    print("调用量：首月 %s 次，月增 %.0f%%，第 %d 月约 %s 次" % (
        format(CALLS_PER_MONTH_START, ","), MONTHLY_GROWTH * 100,
        MONTHS, format(int(calls_in_month(MONTHS - 1)), ",")))
    print()
    print("%-6s %14s %14s %14s" % ("月份", "订阅在线平台", "开源自部署", "全自研框架"))
    for m in (0, 5, 11, 17, 23, 35):
        print("%-6s %14s %14s %14s" % (
            "第%d月" % (m + 1),
            format(int(data["订阅在线平台"][m]), ","),
            format(int(data["开源自部署"][m]), ","),
            format(int(data["全自研框架"][m]), ",")))

    print()
    cp = crossover(data["订阅在线平台"], data["开源自部署"])
    if cp:
        print("订阅 vs 自部署：第 %d 个月起，自部署开始更划算" % cp)
    else:
        print("订阅 vs 自部署：三年内订阅始终更便宜，别为了省钱去自部署")

    cp2 = crossover(data["订阅在线平台"], data["全自研框架"])
    if cp2:
        print("订阅 vs 全自研：第 %d 个月起，全自研开始更划算" % cp2)
    else:
        print("订阅 vs 全自研：三年内全自研都收不回成本，"
              "选它的理由只能是可控性而不是省钱")


if __name__ == "__main__":
    main()

调用量：首月 20,000 次，月增 8%，第 36 月约 295,706 次

月份             订阅在线平台          开源自部署          全自研框架
第1月               400         49,120        175,120
第6月             2,934         94,880        300,880
第12月            7,590        150,277        452,277
第18月           14,980        206,494        604,494
第24月           26,705        264,011        758,011
第36月           74,840        386,452      1,072,452

订阅 vs 自部署：三年内订阅始终更便宜，别为了省钱去自部署
订阅 vs 全自研：三年内全自研都收不回成本，选它的理由只能是可控性而不是省钱

"""锁定度体检：算一算「换掉这个平台」要付多少钱。

选型时人人都说「大不了以后换」，但真到要换的时候才发现：
提示词能带走，工作流的编排结构带不走；知识库的原始文档能带走，
切好的分片和向量带不走。锁定成本必须在进场之前就估出来。

纯标准库，直接 python3 lockin_score.py 就能跑。
"""

# 每一类资产：迁移难度权重（0-1，越高越难搬）
ASSET_WEIGHT = {
    "提示词文本": 0.1,          # 纯文本，复制即可
    "原始文档": 0.1,            # 自己本来就有备份
    "工作流编排结构": 0.7,      # 节点与连线是平台私有格式
    "插件/工具调用配置": 0.6,   # 每个平台的工具协议都不一样
    "知识库分片与向量": 0.5,    # 要重新灌一遍并重新调参
    "会话历史": 0.8,           # 托管在平台侧，导出接口往往不完整
    "已发布的分发渠道": 0.9,    # 绑定在平台账号上，等于重新上线
}


def lockin(assets):
    """assets: {资产类别: 规模系数}，返回 (总分, 明细)。

    规模系数用「相对工作量」表达即可，比如 10 条工作流就填 10。
    """
    detail = []
    total = 0.0
    for name, size in assets.items():
        w = ASSET_WEIGHT[name]
        cost = w * size
        total += cost
        detail.append((name, size, w, cost))
    detail.sort(key=lambda x: x[3], reverse=True)
    return total, detail


def level(total):
    if total < 10:
        return "低 —— 随时可换，不必为锁定问题让步"
    if total < 30:
        return "中 —— 可换，但要预留一个迭代周期"
    return "高 —— 事实上换不动了，进场前就得接受长期绑定"


def main():
    # 一个跑了一年的中等规模项目的典型资产盘点
    project = {
        "提示词文本": 40,
        "原始文档": 500,
        "工作流编排结构": 18,
        "插件/工具调用配置": 12,
        "知识库分片与向量": 6,
        "会话历史": 4,
        "已发布的分发渠道": 3,
    }

    total, detail = lockin(project)

    print("%-20s %8s %8s %10s" % ("资产类别", "规模", "难度", "迁移成本"))
    print("-" * 50)
    for name, size, w, cost in detail:
        print("%-20s %8s %8.1f %10.1f" % (name, size, w, cost))
    print("-" * 50)
    print("锁定总分 %.1f —— %s" % (total, level(total)))

    print("\n成本最高的三项：")
    for name, _s, _w, cost in detail[:3]:
        print("  • %s（%.1f）" % (name, cost))
    print("降低锁定的办法不是不用平台，而是把这三项尽量留在自己手里：")
    print("  提示词与文档进自己的 git；会话历史落自己的库；")
    print("  分发渠道尽量走自己的域名而不是平台商店。")


if __name__ == "__main__":
    main()

资产类别                       规模       难度       迁移成本
--------------------------------------------------
原始文档                      500      0.1       50.0
工作流编排结构                    18      0.7       12.6
插件/工具调用配置                  12      0.6        7.2
提示词文本                      40      0.1        4.0
会话历史                        4      0.8        3.2
知识库分片与向量                    6      0.5        3.0
已发布的分发渠道                    3      0.9        2.7
--------------------------------------------------
锁定总分 82.7 —— 高 —— 事实上换不动了，进场前就得接受长期绑定

成本最高的三项：
  • 原始文档（50.0）
  • 工作流编排结构（12.6）
  • 插件/工具调用配置（7.2）
降低锁定的办法不是不用平台，而是把这三项尽量留在自己手里：
  提示词与文档进自己的 git；会话历史落自己的库；
  分发渠道尽量走自己的域名而不是平台商店。

"""许可证闸门：判断一份开源协议能不能支撑你打算做的生意。

「它是开源的」这句话不能直接推出「我可以拿它对外卖服务」。
很多平台用的是「标准协议 + 附加条款」，附加条款恰恰卡住的就是
最赚钱的那几种用法：多租户运营、去掉品牌标识、二次分发。

纯标准库，直接 python3 license_guard.py 就能跑。
"""

# 触发商业限制的典型措辞。命中不等于禁止，等于「必须人工读原文」
RISK_PATTERNS = {
    "multi_tenant": [
        "multi-tenant", "multi tenant", "multitenant", "多租户",
    ],
    "branding": [
        "logo", "copyright information", "版权信息", "品牌标识",
    ],
    "commercial_license_required": [
        "commercial license must be obtained",
        "must obtain a commercial license",
        "需要获得商业授权",
    ],
    "network_copyleft": [
        "affero", "agpl", "network use is distribution",
    ],
}

# 你打算怎么用它 —— 按实际业务改
INTENDED_USE = {
    "对外提供多租户 SaaS": "multi_tenant",
    "移除或替换前端品牌标识": "branding",
    "作为闭源产品的一部分分发": "network_copyleft",
}


def scan(license_text):
    """返回 {风险类别: 命中的关键词列表}。"""
    low = license_text.lower()
    hits = {}
    for kind, words in RISK_PATTERNS.items():
        found = [w for w in words if w.lower() in low]
        if found:
            hits[kind] = found
    return hits


def judge(license_text, intended_use=None):
    """把扫描结果对上你的使用意图，给出放行 / 复核清单。"""
    intended_use = intended_use or INTENDED_USE
    hits = scan(license_text)

    print("命中的风险条款类别：")
    if not hits:
        print("  （无）—— 仍建议人工通读一遍，关键词法只能兜底不能定案")
    for kind, words in hits.items():
        print("  • %-28s 关键词 %s" % (kind, "/".join(words)))

    print("\n对照你的使用意图：")
    blocked = []
    for use, kind in intended_use.items():
        if kind in hits:
            blocked.append(use)
            print("  ❌ %-24s 受限 —— 必须走商业授权或放弃这种用法" % use)
        else:
            print("  ✅ %-24s 未命中限制条款" % use)

    return blocked


# 一份「标准协议 + 附加条款」的典型样本，用于离线演示扫描逻辑
SAMPLE = """
Open Source License

This software is licensed under a modified version of the Apache License 2.0,
with the following additional conditions:

1. It may be utilized commercially, including as a backend service for other
   applications. Should the conditions below be met, a commercial license must
   be obtained from the producer:

   a. Multi-tenant service: unless explicitly authorized in writing, you may not
      use the source code to operate a multi-tenant environment.
   b. LOGO and copyright information: you may not remove or modify the LOGO or
      copyright information in the console or applications.

Apart from the specific conditions mentioned above, all other rights and
restrictions follow the Apache License 2.0.
"""


def main():
    print("=== 扫描一份「标准协议 + 附加条款」的许可证 ===\n")
    blocked = judge(SAMPLE)

    print()
    if blocked:
        print("结论：有 %d 种打算好的用法被卡住 —— %s" % (len(blocked), "、".join(blocked)))
        print("这类限制通常不影响企业自用，但会直接否掉「拿它改个皮对外卖」的方案。")
    else:
        print("结论：这份协议不阻碍当前列出的使用意图。")


if __name__ == "__main__":
    main()

=== 扫描一份「标准协议 + 附加条款」的许可证 ===

命中的风险条款类别：
  • multi_tenant                 关键词 multi-tenant
  • branding                     关键词 logo/copyright information

对照你的使用意图：
  ❌ 对外提供多租户 SaaS             受限 —— 必须走商业授权或放弃这种用法
  ❌ 移除或替换前端品牌标识              受限 —— 必须走商业授权或放弃这种用法
  ✅ 作为闭源产品的一部分分发             未命中限制条款

结论：有 2 种打算好的用法被卡住 —— 对外提供多租户 SaaS、移除或替换前端品牌标识
这类限制通常不影响企业自用，但会直接否掉「拿它改个皮对外卖」的方案。

"""平台还活着吗：用 GitHub 公开接口给开源平台做一次体检。

选型时最怕的不是「功能少」，而是「半年后没人维护了」。
star 数只说明曾经火过，真正有信息量的是最后一次提交距今多久、
以及许可证到底是不是你以为的那个。

纯标准库（urllib），联网即可跑：
    python3 platform_liveness.py
离线环境会打印网络错误并跳过，不会崩。
"""

import json
import urllib.request
import urllib.error
from datetime import datetime, timezone

# 想体检哪些平台就往这里加，格式是 GitHub 的 owner/repo
REPOS = [
    "langgenius/dify",
    "coze-dev/coze-studio",
    "infiniflow/ragflow",
]

API = "https://api.github.com/repos/%s"
TIMEOUT = 15


def fetch(repo):
    """拉取仓库元信息；失败返回 None 而不是抛出，便于批量体检。"""
    req = urllib.request.Request(
        API % repo,
        headers={
            "Accept": "application/vnd.github+json",
            # GitHub 对无 UA 的请求直接 403
            "User-Agent": "platform-liveness-check",
        },
    )
    try:
        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        # 403 绝大多数是匿名调用超了频率限制，不是仓库不存在
        print("  [%s] HTTP %s %s" % (repo, e.code, e.reason))
    except Exception as e:
        print("  [%s] 请求失败: %s" % (repo, e))
    return None


def days_since(iso_ts):
    """距今天数。iso_ts 形如 2026-09-18T10:50:01Z。"""
    ts = datetime.strptime(iso_ts, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
    return (datetime.now(timezone.utc) - ts).days


def verdict(idle_days):
    """把「多久没提交」翻译成一句能拿去汇报的判断。"""
    if idle_days <= 30:
        return "活跃，放心用"
    if idle_days <= 90:
        return "正常，观察即可"
    if idle_days <= 365:
        return "放缓，选型要问清楚路线图"
    return "疑似停更，自建前先想好接盘成本"


def main():
    print("%-26s %9s %12s %-26s %s" % (
        "仓库", "star", "闲置天数", "许可证", "判断"))
    print("-" * 96)

    for repo in REPOS:
        info = fetch(repo)
        if not info:
            continue

        lic = info.get("license") or {}
        spdx = lic.get("spdx_id") or "未标注"
        idle = days_since(info["pushed_at"])

        print("%-26s %9s %12d %-26s %s" % (
            info["full_name"],
            format(info["stargazers_count"], ","),
            idle,
            spdx,
            verdict(idle),
        ))

        # spdx_id 为 NOASSERTION 说明 GitHub 没能识别出标准许可证，
        # 几乎都意味着作者在标准协议上加了附加条款 —— 必须翻原文
        if spdx == "NOASSERTION":
            print("    ⚠ 非标准许可证，务必读 LICENSE 原文，"
                  "附加条款常见于商用与多租户限制")


if __name__ == "__main__":
    main()

"""选型报告生成器（骨架模板）。

把前面几个脚本的结论汇总成一份能直接发给决策者的报告。
带 TODO 的地方是必须换成自己业务真实信息的，别拿示例值去汇报。

用法：
    python3 selection_report.py > 选型结论.md
"""

from datetime import date

# ============ TODO: 以下全部替换为你自己的项目信息 ============
PROJECT = "TODO: 项目名称"
OWNER = "TODO: 决策负责人"
DEADLINE = "TODO: 期望上线时间"

# TODO: 按 data_boundary_audit.py 的审计结果填写
DATA_MAY_LEAVE_NETWORK = False
REGULATED_PAYLOAD = ["TODO: 列出受监管的必需载荷"]

# TODO: 按 route_decide.py 的判定结果填写
RECOMMENDED_ROUTE = "TODO: 订阅在线平台 / 开源自部署 / 全自研框架"
DECISIVE_REASON = "TODO: 一句话写清是哪个条件决定的"

# TODO: 按 tco_model.py 的测算填写
CROSSOVER_MONTH = None      # 自部署反超订阅的月份；None 表示三年内不反超
THREE_YEAR_COST = "TODO: 三年总成本区间"

# TODO: 按 lockin_score.py 的测算填写
LOCKIN_SCORE = 0.0
LOCKIN_LEVEL = "TODO: 低 / 中 / 高"

# TODO: 按 platform_liveness.py + license_guard.py 的体检结果填写
CANDIDATES = [
    # (平台, 许可证, 闲置天数, 是否命中商业限制)
    ("TODO: 平台A", "TODO: 许可证", 0, False),
]
# ============================================================


def section(title):
    return "\n## %s\n" % title


def build():
    out = []
    out.append("# %s 低代码平台选型结论\n" % PROJECT)
    out.append("负责人：%s ｜ 期望上线：%s ｜ 成文日期：%s\n"
               % (OWNER, DEADLINE, date.today().isoformat()))

    out.append(section("一、结论"))
    out.append("推荐路线：**%s**\n" % RECOMMENDED_ROUTE)
    out.append("决定性理由：%s\n" % DECISIVE_REASON)

    out.append(section("二、数据边界（第一否决项）"))
    out.append("数据是否允许离开自有网络：**%s**\n"
               % ("是" if DATA_MAY_LEAVE_NETWORK else "否"))
    if not DATA_MAY_LEAVE_NETWORK:
        out.append("以下载荷为业务必需且受监管，无法通过改提示词规避：\n")
        for item in REGULATED_PAYLOAD:
            out.append("- %s\n" % item)

    out.append(section("三、成本测算"))
    if CROSSOVER_MONTH:
        out.append("自部署在第 %d 个月起总成本低于订阅方案。\n" % CROSSOVER_MONTH)
    else:
        out.append("测算区间内订阅方案始终更便宜，"
                   "**选择自部署的理由必须是合规或可控性，不能是省钱**。\n")
    out.append("三年总成本：%s\n" % THREE_YEAR_COST)

    out.append(section("四、锁定风险"))
    out.append("锁定总分 %.1f（%s）。\n" % (LOCKIN_SCORE, LOCKIN_LEVEL))

    out.append(section("五、候选平台体检"))
    out.append("| 平台 | 许可证 | 闲置天数 | 商业限制 |\n")
    out.append("|---|---|---|---|\n")
    for name, lic, idle, blocked in CANDIDATES:
        out.append("| %s | %s | %d | %s |\n"
                   % (name, lic, idle, "命中" if blocked else "无"))

    out.append(section("六、复核约定"))
    out.append("平台能力与条款会变。约定每季度用同一套脚本重跑一次体检，\n")
    out.append("任一候选平台出现「闲置超 365 天」或「许可证变更」时重新评审。\n")

    return "".join(out)


if __name__ == "__main__":
    print(build())