# -*- coding: utf-8 -*- """ 同业业务管理驾驶舱 —— ETL / 标准化层 / 指标层 / 校验层输入 <工作区>/2026xxxx-同业业务交易台账.xlsm 输出 etl/data.json 驾驶舱数据 etl/snapshot/<台账日期>.json 每日快照（§33 历史数据设计）实测表结构： A. 资金业务 8 张 Sheet（金额单位=元）回购交易日 + 到期结算日 + 占款天数 + 利息 + 到期结算金额拆借/借款/存款/存放同业起息日 + 到期日 + 期限 + 利息 + 本息合计（无交易日）同业存单发行发行日 + 起息日 + 到期日 + 兑付日 + 参考收益率 + 券面总额同业存款另有投资方 / 是否质押（对应 §7.2 信用类·质押类） B. 债券交易 8 张 Sheet（面额单位=万元，结算金额单位=元）国债/政金债/地方债/同业存单/信用债/ABS → AC；OCI账户交易明细 → OCI；TPL账户交易明细 → TPL 每个 Sheet 底部藏一个「持仓汇总块」：债券名称|债券代码|债券性质|债券到期日|剩余期限(年)|剩余量(万) 以「合计」行收口 —— 台账维护者认可的持仓口径，优先于"买入-卖出"推算 C. 现券库存：账户|债券类型|债券名称|债券代码|券面总额(万)|到期日|质押|可用余额 → 实际库存快照，末行为「合计」行（须剔除，仅用于勾稽） D. 货币基金：按「赎回日为空」判定持有中 E. 台账日期：单 Sheet，T 日唯一来源（§11 禁止使用系统日期） """ import zipfile, re, os, sys, json, datetime, math from collections import defaultdict, Counter, OrderedDict ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) OUT_DIR = os.path.join(ROOT, "etl") SNAP_DIR = os.path.join(OUT_DIR, "snapshot") # ── 输入目录（目录整理第二轮，2026-10-15）────────────────────────────────── # 引入「输入数据/」集中存放主台账、核算余额、年度目标等原始输入；同时保留 # 根目录旧位置向后兼容 —— 扫描时按「新目录优先、旧位置兜底」逐个文件判断， # 避免迁移期间两处同时存在导致歧义。同一类输入只取一处（先到先得）， # 不把两处同名文件叠加。 IN_DIR = os.path.join(ROOT, "输入数据") IN_LEDGER_DIR = os.path.join(IN_DIR, "当前台账") IN_HB_DIR = os.path.join(IN_DIR, "核算余额") IN_TARGET_DIR = os.path.join(IN_DIR, "年度目标") IN_AUX_DIR = os.path.join(IN_DIR, "辅助录入") def has_composite_income(ptype): """信用债、ABS 不适用综合收益；仅排除该指标，不影响持仓及普通收益率。""" name = str(ptype or "").upper() return not any(term in name for term in ("信用债", "ABS", "资产证券化")) def _scan_ledger_fns(base): """在给定目录扫描「含『台账』字样的 xlsm/xlsx」，排除锁文件与隐藏文件，按文件名排序（保持既有语义：取排序最后一个，不按修改时间）。""" if not os.path.isdir(base): return [] out = [] for fn in sorted(os.listdir(base)): if fn.startswith("~$") or fn.startswith("."): continue if fn.endswith((".xlsm", ".xlsx")) and "台账" in fn: out.append(os.path.join(base, fn)) return out def _scan_hb_fns(base): """扫描「核算余额*.xls」（老式 .xls，OLE 二进制）。""" if not os.path.isdir(base): return [] out = [] for fn in sorted(os.listdir(base)): if fn.startswith("~$") or fn.startswith("."): continue if fn.lower().endswith(".xls") and "核算余额" in fn: out.append(os.path.join(base, fn)) return out # 主台账：输入数据/当前台账/ 优先，根目录兜底。取排序最后一个（既有语义不变）。 LEDGER_FILE = None _ledger_cands = _scan_ledger_fns(IN_LEDGER_DIR) + _scan_ledger_fns(ROOT) if _ledger_cands: LEDGER_FILE = _ledger_cands[-1] # 核算余额：输入数据/核算余额/ 优先，根目录兜底（取排序最后一个）。 HB_FILE = None _hb_cands = _scan_hb_fns(IN_HB_DIR) + _scan_hb_fns(ROOT) if _hb_cands: HB_FILE = _hb_cands[-1] # 年度目标：输入数据/年度目标/ 优先，根目录「年度目标页面构建/」兜底。 TG_DIR = IN_TARGET_DIR if os.path.isdir(IN_TARGET_DIR) else os.path.join(ROOT, "年度目标页面构建") DATE_BUILTIN = {14, 15, 16, 17, 18, 19, 20, 21, 22, 27, 30, 36, 45, 46, 47, 50, 51, 52, 53, 54, 55, 56, 57, 58} EPOCH = datetime.date(1899, 12, 30) D = datetime.date YI, WAN = 1e8, 1e4 TOTAL_WORDS = ("合计", "小计", "总计", "合计") # 历史存量序列的固定起点：自 2026-01-01 起统计，**不随台账日 T 滚动**（窗口随时间自然变长）。 # 首点 = 该日真实存量（2026 年前起息、当时仍存续的业务照常计入）—— _hseries 会把起点之前的 # 增量在首日一次性结算，故首点天然正确、不是 0。改口径只改这一个常量＋下方窗口段。 HIST_START_FIXED = D(2026, 1, 1) # ── 数据能力版本（审查报告 N12 / F13）────────────────────────────────────────── # 🔴 本项目有**三个互不相干**的「版本」，绝不可混用： # ① WBC_BUILD —— 产物 html 内容的 sha1 前 12 位。**仅**用于前端自检「页面与 wbc-build.txt # 是否为同一次构建」，由 build.py 计算、与数据无关。 # ② WBC_DOC_VER —— 展示版本号（V2.xx），由 build.py 从技术文档首行解析注入，纯展示。 # ③ SCHEMA（下面这个）—— **数据能力版本**：描述产出的 data.json 里「有哪些字段可用」。 # 与①②正交 —— 换一份台账不会改它，新增一种数据能力才会 +1。 # 🔴 为什么需要它（N12 的根因）：`renderFundRange()` 的取值器 `at(path,i)` 对「路径不存在」 # 一律 `return 0` —— 于是用**旧版数据**（V2.23 的 slice 里没有累积量 ci/cm）配**新前端** # 时，区间表会把「缺失」渲染成「0.00 亿元」这个**看似正常的正式结论**（起息 0 / 到期 0 / # 净变动 0）。数据缺失被静默降级成了业务结论，这是最难被发现的一类错误。 # ⇒ 前端先验能力、不达标就显式降级（宁可不显示，也不显示 0）。 # ⚠ 契约是**单向**的：新前端 + 旧数据 ⇒ 显式降级并提示；旧前端 + 新数据 ⇒ 多余字段被忽略、无感。 SCHEMA = 3 CAPS_PRODUCED = {"fund_range_ci_cm", # 「业务区间变动情况」所需的累积起息/到期量 ci/cm "ledger_row", # 逐笔明细携带**台账物理行号**（xl_row / xl_n） "fund_cls", # 资金业务逐笔携带**质押/信用分类**（cls）—— V2.36 "profit_accrual", # 盈利预测按**核算口径**（全价×持仓−面额−应计−调整）—— V2.38 "inv_range_buy_sell_mat"} # 投资业务「业务区间变动情况」所需的买入/卖出/到期券面·笔数—— V2.67 # ⚠ ledger_row 是「在台账中定位」类功能的前置：没有它，前端只能拿 ETL 自造的 id # （F1389 / M0165 —— 那是按输出行序生成的，台账里根本不存在）去 Excel 里搜，必然搜不到。 # 没有这个能力时前端**显式说不支持**，绝不猜行号（猜错比不猜更糟：会把用户带到别的业务上）。 # ⚠ V2.32 起覆盖范围扩到 bonds：逐笔浮层的「行内展开」把「某券持仓 N 亿」拆成 N 笔买卖， # 每笔要能对回台账行（bonds.xl_row）。所以证据侧必须**同时**查 bonds —— # 否则一份「positions/bond_master 有行号、bonds 没有」的旧快照仍会被判为能力齐备， # 展开出来的每一行都写着「台账行 —」（静默降级，正是这道闸门要拦的东西）。 # ⚠ fund_cls 是资金页「业务 × 质押/信用矩阵」单元格/列合计下钻与「同业存款信用/质押」 # 环图扇区下钻的前置：没有它，前端分不出哪笔是质押类 —— 缺能力时**不打点** # （宁可点不动，也不能点开一张按错误口径筛出来的表）。 def produced_caps(sl, rows=None, profit_lots=None): """从**实际产出**反推能力集合（证据侧）。与 `CAPS_PRODUCED`（声明侧）互为独立两方。 ⚠ 两侧必须一致：`CAPS_PRODUCED` 是人工维护的**声明**，本函数是客观**证据**。分叉的两个方向都危险 —— 声明了却没产出 ⇒ 前端认为能力齐备、放行渲染，于是把缺失渲染成 0.00（N12 的原病）；产出了却没声明 ⇒ 前端误判为旧数据、无谓降级（白丢功能）。故 main() 里有一道硬自检：声明 ⊄ 证据就中止（这是**开发期错误**，不是数据问题）。 """ caps = set() # fund_range_ci_cm 证据侧（N12）：不是「任一路径带 .ci/.cm 后缀就算」，而是**完整覆盖** # 「8 业务（branches_all 下标）× 2 分类（FUND_CLS）× 3 序列（p/ci/cm）」—— 缺任意一格， # 前端区间表的差分就会把缺失当 0、静默产出错误结论。 # N12 第二轮：keys 齐全还不够，**vals 必须真有值**（keys 保留但值被删同样不能声称能力）。 # ⚠ sl 可能是 dict（keys/vals）或 None；测试桩里也可能只传 keys 列表，这里兼容两种。 _sl_keys = sl.get("keys", []) if isinstance(sl, dict) else (sl or []) _sl_vals = sl.get("vals", {}) if isinstance(sl, dict) else None _sl_n = sl.get("n") if isinstance(sl, dict) else None # N53：_seq_ok 提升到函数公共作用域（原来定义在 fund_range_ci_cm 的 if 块内， # inv_range_buy_sell_mat 分支在「资金 48 路径不齐」时引用会抛 NameError # —— 各能力必须独立判断，不能依赖另一能力的判断分支先执行才定义本函数）。 def _seq_ok(v): if v is None: return False if isinstance(v, list): if _sl_n is not None and len(v) != _sl_n: return False return len(v) > 0 and all( (isinstance(x, (int, float)) and math.isfinite(x)) for x in v) return isinstance(v, (int, float)) and math.isfinite(v) _exp_ci_cm = { "branches_all[%d].cls.%s.%s" % (k, cl, fld) for k in range(len(FUND_SHEETS)) for cl in FUND_CLS for fld in ("p", "ci", "cm") } if _exp_ci_cm and _exp_ci_cm <= set(_sl_keys): # N12 第三轮：值不仅要「存在」，还要「有限且非空」。vals[p] 可能是标量（全等折叠） # 或 n 长数组（非常量序列）；只要有一个元素是 None / 非有限数，就说明序列有空洞， # 前端差分会把空洞当 0、静默产出错误结论 ⇒ 不能声称能力。 # N12 第四轮：数组不仅要有值，**长度还必须 == 日序列 n**（否则短数组 [0] 在 n=273 下 # 索引后续日期会空值回退、静默当 0，区间金额照样错）。标量（全等折叠）是合法压缩， # 不校验长度；只对数组校验。sl 可能是 dict 或 list，只有 dict 才带 n。 if _sl_vals is None or all(_seq_ok(_sl_vals.get(p)) for p in _exp_ci_cm): caps.add("fund_range_ci_cm") # 证据侧：不是「声明了就算」，而是**逐行查**每笔明细都真的带了正的台账行号。 # ⚠ 必须区分「没给证据」与「没有反例」这两件事，否则会把退化台账误判成开发期错误： # rows is None ⇒ 调用方没交证据 ⇒ **不声称**（漏传一次参数就能白拿走能力，这最危险）； # rows == [] ⇒ 台账里确实一笔明细都没有 ⇒ 没有反例，能力成立（真空为真）。 # 这是**数据退化**而不是声明/实现分叉：不该触发 exit(3) 的硬阻断 # （M 组那些合成台账就是这种 —— 阻断力只留给「严重」一级，别把它用光）。 if rows is not None and all((r.get("xl_row") or 0) > 0 for r in rows): caps.add("ledger_row") # fund_cls 证据侧：每一笔资金业务行都真的带上了合法的质押/信用分类。 # ⚠ rows 是 fund + mf + bond_master + bonds 的拼接 —— 只有 fund 行有 lv1="资金业务"， # 其余三类不查（mf/债券没有担保方式分类，属正常形态，不是缺证据）。 # rows == []（真空为真）的语义与 ledger_row 相同：数据退化 ≠ 声明/实现分叉。 if rows is not None and all( r.get("cls") in FUND_CLS for r in rows if r.get("lv1") == "资金业务"): caps.add("fund_cls") # profit_accrual 证据侧（N27）：盈利预测按核算口径 = 每一笔 lot 都带核算字段 # （full_px / accrued_int / amort_adj）。旧净价口径的 profit_lots 没有这些字段 # ⇒ 缺能力时前端显式降级「旧口径数据」，绝不拿净价字段套核算标签。 # ⚠ 缺核算文件时 accrued_int/amort_adj 会是 None（N23），字段仍存在 ⇒ 能力仍成立 # （是「数据缺失」不是「口径缺失」）；用「字段名是否在键里」判，不看值。 # ⚠ 真空为真：profit_lots 为空（本期无债券持仓）也判能力成立 —— 与 ledger_row 的 # rows==[] 同理，是「数据退化」不是「声明/实现分叉」（M 组合成台账就是这种）。 if profit_lots is not None and all( all(f in r for f in ("full_px", "accrued_int", "amort_adj")) for r in profit_lots): caps.add("profit_accrual") # inv_range_buy_sell_mat 证据侧：投资业务「业务区间变动情况」所需的 6 个量（买入/卖出/到期 × 券面/笔数）， # 按「账户(AC/OCI/TPL) × 品种(PTYPE_ORDER 7 类)」二维各一份累积序列。缺任意一格， # 前端差分会把缺失当 0、静默产出错误结论 —— 与 fund_range_ci_cm 的 N12 同一套判据。 # 必须「键齐全 + 值有限且长度 == n」才算能力齐备（复用上面的 _seq_ok 与 _sl_n）。 _exp_inv = { "inv_acc.%s.%s.%s" % (a, pt, fld) for a in ("AC", "OCI", "TPL") for pt in PTYPE_ORDER for fld in ("buy_face", "buy_n", "sell_face", "sell_n", "mat_face", "mat_n") } if _exp_inv and _exp_inv <= set(_sl_keys): if _sl_vals is None or all(_seq_ok(_sl_vals.get(p)) for p in _exp_inv): caps.add("inv_range_buy_sell_mat") return caps # ── 发布前质量门槛（审查报告 F08）───────────────────────────────────────────── # 🔴 原状况：`q()` 只**登记**质量条目，全程没有一处按质量级别拦过 —— 台账缺 Sheet 时 # 数据照样写出、产物照样生成、cloud_sync 照样推上云，页面上只是「多了一条提示」。 # 制单人若没看那一页，错数据就已经在用了。 # ✅ 判据刻意只取「严重」一级：见 `severe_items()` 的注释（避免过度阻断 ⇒ 闸门被习惯性绕过）。 SEVERE_LEVELS = ("严重",) ALLOW_SEVERE = "--allow-severe" in sys.argv[1:] # 显式放行开关（默认**不带** ⇒ 默认阻断） def severe_items(quality): """产出「必须人工确认才能放行」的严重质量项（纯函数 ⇒ 可单测）。 ⚠ 为什么**不**把「高」也纳入阻断：高 / 中 / 低三级都已经在页面上有显式清单与修复指引，且它们**不改变口径的正确性** （库存差异是待业务确认的口径问题；收益率格式异常已自动归一）。若把「高」也做成阻断，就会撞上本项目的「告警零噪音」原则 —— 阻断一旦频繁触发，操作员就会习惯性地加 `--allow-severe`，闸门等于不存在。「严重」的判据是**结构性缺失**（缺必需 Sheet）—— 此时任何汇总数字都是错的，必须停。 """ return [x for x in quality if x.get("level") in SEVERE_LEVELS] # ══════════════════════════════════════════════════════════ 读取层 def unescape(s): s = str(s) s = re.sub(r"&#x([0-9A-Fa-f]+);", lambda m: chr(int(m.group(1), 16)), s) s = re.sub(r"&#(\d+);", lambda m: chr(int(m.group(1))), s) for a, b in (("<", "<"), (">", ">"), (""", '"'), ("'", "'"), ("&", "&")): s = s.replace(a, b) return s def _fmt_table(styles_xml): custom = dict(re.findall(r']*>(.*?)", styles_xml, re.S) ids = [int(x) for x in re.findall(r'numFmtId="(\d+)"', xfs.group(1))] if xfs else [] def is_date(nf): if nf in DATE_BUILTIN: return True c = re.sub(r'\[[^\]]*\]', "", custom.get(str(nf), "")) return bool(re.search(r"(yyyy|yy|dd|mm)", c)) and not re.search(r"^[#0.,%]+$", c) return ids, is_date def load_workbook(path, diag=None): """读取 .xlsx/.xlsm（OOXML ZIP）→ OrderedDict{sheet名: grid[row][col]}。只用标准库 zipfile + 正则（零第三方依赖，保持 Pyodide 可内联）。边界处理（F11）： ① 1904 日期系统：workbook.xml 的决定序列号纪元（默认 1900 系统 0 = 1899-12-30；1904 系统 0 = 1904-01-01，Mac Excel 默认）； ② 无 sharedStrings.xml 的合法文件（全部 inlineStr）：降级为空表，tt=s 单元格按原索引告警； ③ 公式单元格无缓存（有无）：值取空并记告警 —— 绝不把「未计算」当 0； ④ workbook.xml.rels 的关系解析不依赖 Id/Target 属性书写顺序。 diag: 可选 list，传入则把上述边界告警逐条 append（调用点决定进质量清单还是打印）。 """ z = zipfile.ZipFile(path) _warn = (diag.append if diag is not None else (lambda _m: None)) _names = set(z.namelist()) # ② 共享字符串：合法 OOXML 可能没有 sharedStrings.xml（全部 inlineStr），不能 KeyError。 strs = [] if "xl/sharedStrings.xml" in _names: ss_xml = z.read("xl/sharedStrings.xml").decode("utf-8", "ignore") strs = [unescape("".join(re.findall(r"]*>(.*?)", si, re.S))) for si in re.findall(r"(.*?)", ss_xml, re.S)] xf_ids, is_date = _fmt_table(z.read("xl/styles.xml").decode("utf-8", "ignore")) wb = z.read("xl/workbook.xml").decode("utf-8", "ignore") # ① 1904 日期系统纪元（Mac Excel 默认；序列号 0 = 1904-01-01，且无 1900 假闰日）。 _epoch = (datetime.date(1904, 1, 1) if re.search(r']*?date1904="(?:1|true)"', wb) else EPOCH) # ④ 关系解析：Id / Target 各自独立提取、按 Id 配对，不依赖属性书写顺序。 rels = {} _rels_xml = z.read("xl/_rels/workbook.xml.rels").decode("utf-8", "ignore") for _rm in re.finditer(r"]*?>", _rels_xml): _id = re.search(r'Id="([^"]+)"', _rm.group(0)) _tg = re.search(r'Target="([^"]+)"', _rm.group(0)) if _id and _tg: rels[_id.group(1)] = _tg.group(1) out = OrderedDict() for nm, rid in re.findall(r']*r:id="(rId\d+)"', wb): sh = z.read("xl/" + rels[rid]).decode("utf-8", "ignore") grid = defaultdict(dict) for m in re.finditer(r']*?)(?:/>|>(.*?))', sh, re.S): col, row, attrs, inner = m.group(1), int(m.group(2)), m.group(3), m.group(4) or "" t = re.search(r't="([^"]+)"', attrs) tt = t.group(1) if t else "n" s = re.search(r's="(\d+)"', attrs) si = int(s.group(1)) if s else 0 nf = xf_ids[si] if si < len(xf_ids) else 0 v = re.search(r"(.*?)", inner, re.S) # ③ 公式单元格：有无 = 缓存陈旧/未计算，值缺失 ≠ 数值 0。 if re.search(r"]", inner) and not v: _warn("Sheet「%s」%s%d：公式无缓存结果（单元格按空处理，不作 0）" % (nm, col, row)) val = v.group(1) if v else "" inline = re.findall(r"]*>(.*?)", inner, re.S) if tt == "s" and val != "": try: _idx = int(val) except (ValueError, TypeError): _warn("Sheet「%s」%s%d：共享字符串索引非法（%s）" % (nm, col, row, val)) else: if _idx < len(strs): val = strs[_idx] else: _warn("Sheet「%s」%s%d：共享字符串索引 %d 越界（文件可能缺 sharedStrings.xml）" % (nm, col, row, _idx)) elif tt in ("inlineStr", "str"): val = unescape("".join(inline)) or val elif tt == "n" and val != "" and is_date(nf): try: val = (_epoch + datetime.timedelta(days=int(float(val)))).isoformat() except Exception: pass grid[row][col] = str(val).strip() if isinstance(val, str) else val out[nm] = grid return out def _read_xml_spreadsheet(path): """读取 XML Spreadsheet 2003（伪 .xls，实为 UTF-8 XML 文本），返回 OrderedDict{sheet名: grid[row][col]}。与 load_workbook 同一网格结构（row 用 Excel 行号 1-based，col 用 A/B/C 字母），供年度目标页取「区间投资收益（税前）」「区间投资收益折算后（税前）」两列。只用标准库 ElementTree —— 保持 ETL 零第三方依赖（xlrd/openpyxl 均不装，而 .xls 伪装的 XML 用 zipfile 也读不了，必须走 XML 解析）。""" import xml.etree.ElementTree as ET _NS = "{urn:schemas-microsoft-com:office:spreadsheet}" tree = ET.parse(path) root = tree.getroot() out = OrderedDict() for ws in root.iter(_NS + "Worksheet"): name = ws.get(_NS + "Name") or "Sheet1" grid = defaultdict(dict) for r, row in enumerate(ws.findall(_NS + "Table/" + _NS + "Row"), start=1): ci = 0 # 列指针（0-based）：Cell 带 Index 时按它定位，否则顺延 for cell in row.findall(_NS + "Cell"): idx = cell.get(_NS + "Index") if idx is not None: ci = int(idx) - 1 col = chr(ord("A") + ci) data = cell.find(_NS + "Data") val = data.text if data is not None else "" if val is not None: grid[r][col] = val.strip() ci += 1 out[name] = grid return out def _nxc_snapshot(path, var2dg, diag=None): """解析一份「年初至月底」累计净息差报表 → {底稿项目名: [区间投资收益H(元), 折算后J(元), 券面余额D(万元), 账面日均F(万元)]}。 🔴 行结构三坑（2026-10-10 实测锁定，改动前先跑 9 月重建核对）： ① 部分「品种」是连续重复行（分组行+叶子行同值，如货币基金/ABS/存单发行/央行支小再贷款） —— 直接求和会翻倍，同键同值必须去重； ② 「B=合计」的小计行会把账簿状态污染成 '合计' ⇒ 负债端品种（B 为空）全部丢失 —— B='合计' 不得更新账簿状态，且进入负债端（A='负债端'）时账簿状态复位为 ''； ③ 同业存单/地方政府债在交易账簿与银行账簿各有一行 —— 口径 = **两账簿合并求和** （施主 2026-10-10 验算确认：区间投资收益 + 折算后/4 两账簿相加，1-7月零误差；交易账簿地方债 H/J 在 6-9月全程恒定 ⇒ 默认 9 月增量=0，合并=银行账簿、不影响 9 月）。只取叶子行（A 列为空）；分组词（债券/同业存款/买入返售/卖出回购/同业拆借/合计）不算品种。 diag: 可选 list —— 传入则把「收益有值但规模/日均缺列」等缺项告警追加进去（N40）。""" import xml.etree.ElementTree as ET _warn = (diag.append if diag is not None else (lambda _m: None)) _NS = "{urn:schemas-microsoft-com:office:spreadsheet}" tree = ET.parse(path) root = tree.getroot() ws = root.find(_NS + "Worksheet") table = ws.find(_NS + "Table") _SKIP_C = {"", "合计", "净息差", "资产端", "负债端", "业务品种", "债券", "同业存款", "买入返售", "卖出回购", "同业拆借"} entries = {} # (账簿, 品种) -> [H,J,D,F] cur_book = "" for row in table.findall(_NS + "Row"): cells = {} _ci = 0 # N40：XML Spreadsheet 的 Cell 若省略 ss:Index，列号 = 上一列 + 1 for cell in row.findall(_NS + "Cell"): idx = cell.get(_NS + "Index") data = cell.find(_NS + "Data") if idx is not None: _ci = int(idx) else: _ci += 1 if data is not None: cells[_ci] = (data.text or "").strip() a, b, c = cells.get(1, ""), cells.get(2, ""), cells.get(3, "") if a == "负债端": cur_book = "" # ③ 账簿状态复位 elif b and b not in ("合计", "账簿类型"): cur_book = b if a: # 只取叶子行 continue if c in _SKIP_C: continue def _f(i): try: return float(cells[i]) except (KeyError, TypeError, ValueError): return None vals = [_f(8), _f(10), _f(4), _f(6)] # H, J, D, F if vals[0] is None and vals[1] is None: continue # N40：H/J（收益）有值但 D/F（规模/日均）缺列 —— 缺项会被当 0 计入，低估日均规模/券面余额。 # 这里显式告警，不静默（审查报告点名的「H/J/D/F 缺项可默认」风险）。 if (vals[0] is not None or vals[1] is not None) and (vals[2] is None or vals[3] is None): _warn("净息差品种「%s」收益有值但规模/日均缺列（券面余额或账面日均缺 → 按 0 计入）" % c) key = (cur_book, c) if key in entries: p = entries[key] if p == vals: # ① 同键同值重复行 → 去重 continue entries[key] = [(p[i] or 0) + (v or 0) for i, v in enumerate(vals)] else: entries[key] = vals # 品种 → 底稿项目名：**两账簿合并求和**（施主 2026-10-10 验算确认零误差）， # 且**同底稿名的多个净息差品种累加**（如「存放同业」= 存放同业活期 + 存放同业定期）。 by_dg = {} for (bk, v), vals in entries.items(): dg = var2dg.get(v) if not dg: continue merged = by_dg.setdefault(dg, [0.0, 0.0, 0.0, 0.0]) for i in range(4): merged[i] += (vals[i] or 0.0) return by_dg # ══════════════════════════════════════════════════════════ 工具 def num(x): if x is None: return None s = str(x).replace(",", "").replace(" ", "").strip() if s in ("", "-", "/", "—", "－", "无", "#REF!", "#VALUE!", "#DIV/0!", "N/A", "∞"): return None s = s.rstrip("%") try: return float(s) except Exception: return None def isodate(x): s = str(x or "").strip() if not s or s in ("-", "—", "/"): return None for pat in (r"^(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})$", r"^(\d{4})(\d{2})(\d{2})$"): m = re.match(pat, s) if m: try: return D(int(m.group(1)), int(m.group(2)), int(m.group(3))).isoformat() except Exception: return None return None def dnum(s): return D(*map(int, s.split("-"))).toordinal() def days_between(a, b): return dnum(b) - dnum(a) # ── 2026 年法定节假日与调休（国办发明电〔2025〕7 号）──────────────────────────── # 用于「到期日向后顺延至工作日」勾选框：到期日若落在节假日/休息日，顺延到下一工作日。 # HOLIDAYS = 放假调休日（不营业）｜WORKDAYS = 调休补班日（周六/周日上班）。 # next_workday(d)：d 是工作日则原样返回；否则顺延到最近的下一个工作日。 # ⚠ 这是**数据口径**（影响计息天数/现金流），不是展示偏好 —— 改节假日表必须重跑 ETL + 重灌云库。 HOLIDAYS_2026 = { # 元旦 1/1~1/3 "2026-01-01", "2026-01-02", "2026-01-03", # 春节 2/15~2/23 "2026-02-15", "2026-02-16", "2026-02-17", "2026-02-18", "2026-02-19", "2026-02-20", "2026-02-21", "2026-02-22", "2026-02-23", # 清明 4/4~4/6 "2026-04-04", "2026-04-05", "2026-04-06", # 劳动节 5/1~5/5 "2026-05-01", "2026-05-02", "2026-05-03", "2026-05-04", "2026-05-05", # 端午 6/19~6/21 "2026-06-19", "2026-06-20", "2026-06-21", # 中秋 9/25~9/27 "2026-09-25", "2026-09-26", "2026-09-27", # 国庆 10/1~10/7 "2026-10-01", "2026-10-02", "2026-10-03", "2026-10-04", "2026-10-05", "2026-10-06", "2026-10-07", } # 调休补班日（周六/周日上班，按工作日对待） WORKDAYS_2026 = { "2026-01-04", # 元旦调休 "2026-02-14", "2026-02-28", # 春节调休 "2026-05-09", # 劳动节调休 "2026-09-20", "2026-10-10", # 国庆调休 } def _is_holiday(ds): return ds in HOLIDAYS_2026 def _is_workday(ds): """工作日 = 非节假日且（周六/周日但被列为补班日，或周一~周五）。""" if ds in HOLIDAYS_2026: return False if ds in WORKDAYS_2026: return True return D(*map(int, ds.split("-"))).weekday() < 5 def next_workday(ds): """到期日向后顺延至下一个工作日（含当日判断）。顺延天数 = 返回值 − ds。""" d = D(*map(int, ds.split("-"))) while not _is_workday(d.isoformat()): d += datetime.timedelta(days=1) return d.isoformat() def nh(s): s = str(s or "").replace("\n", "").replace("\r", "").replace("　", "") s = s.replace("（", "(").replace("）", ")").replace("：", ":") return re.sub(r"\s+", "", s).strip() def hdr_map(grid, row): h = {} for c, v in grid.get(row, {}).items(): k = nh(v) if k and k not in h: h[k] = c return h def pick(h, aliases): for a in aliases: k = nh(a) if k in h: return h[k] return None def find_header(grid, min_cells=3, limit=20): best, best_n = None, 0 for r in sorted(grid)[:limit]: n = sum(1 for v in grid[r].values() if str(v).strip()) if n > best_n: best, best_n = r, n if n >= min_cells and best == r: break return best def cell(grid, r, c): return grid.get(r, {}).get(c, "") if c else "" def to_wan(x): """汇总块金额单位自适应：|x| >= 1e7（1000 万元）视为「元」，折万。 ⚠ 只用于「单位不明确、靠大小猜」的汇总块；字段单位已明确的（如 settle_amt 以元记）必须用固定换算（÷WAN），不得走这里的阈值猜测，否则小额会被漏转、放大万倍（审查报告 F07）。""" if x is None: return None return x / WAN if abs(x) >= 1e7 else x def med(v): """中位数（stdlib-only，避免为一处用途引入 statistics）。用途见 audit_scale：人工台账的「录入习惯」常整列不一致（有人写 1.41、有人写 0.0141），因此不能拿某个"标准值"当参照，只能拿同一 Sheet 同一字段的**中位数**当参照。""" s = sorted(x for x in v if x is not None) if not s: return None n = len(s) return s[n // 2] if n % 2 else (s[n // 2 - 1] + s[n // 2]) / 2.0 def mag(r): """把比值折成「相差几倍」（恒 ≥1），用于提示文案。""" if not r or r <= 0: return 0.0 return r if r >= 1 else 1.0 / r def is_total(s): return nh(s) in [nh(x) for x in TOTAL_WORDS] def bucket(remaining): """到期区间分档。「存量」口径 = 生效日 ≤ T < 到期日（F05），故 T 当日到期（remaining == 0）单列「T日到期」，不进存量分档（BUCKETS_R 里没有它），只在逐笔明细里可筛。""" if remaining is None: return "无固定期限" if remaining < 0: return "逾期" if remaining == 0: return "T日到期" if remaining == 1: return "明日" if remaining <= 7: return "2-7日" if remaining <= 30: return "8-30日" if remaining <= 90: return "31-90日" return "90日以上" # 存量到期区间分档（不含「今日」：T 日到期业务不算存量；也不含「逾期」：已被 stock 过滤掉） BUCKETS_R = ("明日", "2-7日", "8-30日", "31-90日", "90日以上") TYPE_RULES = [("记账式国债", "国债"), ("国债", "国债"), ("地方", "地方债"), ("专项债", "地方债"), ("一般债", "地方债"), ("政金", "政金债"), ("国开", "政金债"), ("农发", "政金债"), ("进出", "政金债"), ("存单", "同业存单"), ("CD", "同业存单"), ("ABS", "ABS"), ("资产支持", "ABS"), ("金融债", "政金债")] STDDIR = {"一级买入": 1, "二级买入": 1, "债券买入": 1, "一级卖出": -1, "二级卖出": -1, "债券卖出": -1} def infer_type(*parts): t = " ".join(str(p or "") for p in parts) for k, v in TYPE_RULES: if k in t: return v return "信用债" def acc_of(raw): u = str(raw or "").upper() if not u.strip(): return "" if "OCI" in u or "FVOCI" in u or "其他" in u: return "OCI" if "TPL" in u or "交易性" in u or "损益" in u: return "TPL" return "AC" def strip_code(c): c = str(c or "").strip().upper() c = re.sub(r"^(AC|OCI|TPL|FVOCI)", "", c) return re.sub(r"\.(IB|SH|SZ|N)$", "", c).strip() # ══════════════════════════════════════════════════════════ 配置 FUND_SHEETS = [ dict(sheet="正回购", side="负债", lv2="回购", label="正回购", disp="正回购", collateral=True, a=dict(对手=["交易对手"], 本金=["金额(元)"], 交易日=["交易日"], 到期日=["到期结算日"], 期限=["占款天数"], 利率=["利率"], 利息=["利息"], 现金流=["到期结算金额"], 交易员=["交易员"], 备注=["备注"], 质押=["质押债券"], 经纪=["货币经纪"])), dict(sheet="逆回购", side="资产", lv2="回购", label="逆回购", disp="逆回购", collateral=True, a=dict(对手=["交易对手"], 本金=["金额(元)"], 交易日=["交易日"], 到期日=["到期结算日"], 期限=["占款天数"], 利率=["利率"], 利息=["利息"], 现金流=["到期结算金额"], 交易员=["交易员"], 备注=["备注"], 质押=["质押债券"])), dict(sheet="线上拆入", side="负债", lv2="拆借", label="拆入", disp="同业拆入", a=dict(对手=["交易对手"], 本金=["金额(元)"], 起息日=["起息日"], 到期日=["到期日"], 期限=["期限(天)"], 利率=["利率"], 利息=["应付利息(元)"], 现金流=["本息合计(元)"], 备注=["备注"])), dict(sheet="线上拆出", side="资产", lv2="拆借", label="拆出", disp="同业拆出", a=dict(对手=["交易对手"], 本金=["金额(元)"], 起息日=["起息日"], 到期日=["到期日"], 期限=["期限(天)"], 利率=["利率"], 利息=["应收利息(元)"], 现金流=["本息合计(元)"], 备注=["备注"])), dict(sheet="同业借款", side="资产", lv2="借款", label="同业借款", disp="同业借款", a=dict(对手=["交易对手"], 本金=["金额(元)"], 起息日=["起息日"], 到期日=["到期日"], 期限=["期限(天)"], 利率=["利率"], 利息=["应收利息(元)"], 备注=["备注"], 付息频率=["付息频率"], 下一付息日=["下一付息日"])), dict(sheet="同业存款", side="负债", lv2="存款", label="同业存款", disp="同业存款", deposit=True, a=dict(对手=["交易对手"], 本金=["金额(元)"], 起息日=["起息日"], 到期日=["到期日"], 期限=["期限(天)"], 利率=["利率"], 利息=["应付利息(元)"], 现金流=["本息合计(元)"], 备注=["备注"], 投资方=["投资方"], 质押=["是否质押"])), dict(sheet="存放同业FTU", side="资产", lv2="存放同业", label="存放同业", disp="存放同业", a=dict(对手=["交易对手"], 本金=["金额(元)"], 起息日=["起息日"], 到期日=["到期日"], 期限=["期限(天)"], 利率=["利率"], 现金流=["到期结算金额(元)"], 备注=["备注"])), dict(sheet="同业存单发行", side="负债", lv2="存单发行", label="存单发行", disp="存单发行", cd=True, a=dict(对手=["投资人全称"], 本金=["券面总额"], 起息日=["起息日"], 到期日=["到期日"], 利率=["参考收益率"], 现金流=["券面总额"], 备注=["备注"], 代码=["存单代码"], 名称=["存单简称"], 发行日=["发行日"], 兑付日=["兑付日"], 期限文本=["期限"], 缴款=["缴款金额"], 投资方=["投资方"])), ] BOND_TRADE = [ dict(sheet="国债", account="AC", ptype="国债"), dict(sheet="政金债", account="AC", ptype="政金债"), dict(sheet="地方债", account="AC", ptype="地方债"), dict(sheet="同业存单", account="AC", ptype="同业存单"), dict(sheet="信用债", account="AC", ptype="信用债"), dict(sheet="资产支持债券（ABS）", account="AC", ptype="ABS"), dict(sheet="OCI账户交易明细", account="OCI", ptype=None), dict(sheet="TPL账户交易明细", account="TPL", ptype=None), ] BOND_A = dict(交易日=["交易日"], 对手=["交易对手"], 名称=["债券名称", "存单名称"], 代码=["债券代码", "存单代码"], 性质=["债券性质"], 方向=["交易方向"], 面额=["券面总额(万)"], 剩余=["剩余金额(万)", "剩余量(万)", "剩余金额", "剩余量"], 净价=["净价"], 全价=["全价"], 结算日=["结算日"], 结算金额=["结算金额(元)"], 收益率=["到期收益率"], 票面利率=["票面利率", "票面利率/发行利率(贴现国债)", "票面利率/发行利率", "发行利率"], 债券起息=["债券起息日", "存单起息日"], 债券到期=["债券到期日", "存单到期日"], 交易员=["交易员"], 备注=["备注"], 委托=["委托信息"], 评级=["评级"], 原始权益人=["原始权益人"], 担保人=["担保人"], 计划管理人=["计划管理人"], 是否短债=["是否短债"], 是否超长债=["是否超长债"]) BLOCK_AMT = ["剩余量(万)", "剩余金额(万)", "券面总额", "剩余金额", "剩余量", "券面总额(万)"] # 中债估值列（两种录入方式任选其一或并存，ETL 都认） # ① 持仓汇总块右侧新增列（估值日期 / 中债估值净价 / 中债估值全价）—— 逐行贴着手持券 # ② 独立 Sheet（推荐命名「中债估值」，中债登估值文件或自建表）—— 逐券，代码为主键 # 过渡期可只填净价，此时全价口径自动降级为「不可用」，绝不按 0 或推算值静默填充。 VAL_A = dict(code=["债券代码", "存单代码", "证券代码", "代码"], name=["债券名称", "存单名称", "证券名称", "名称"], account=["账户", "会计账户", "账户类型", "投资账户"], date=["估值日期", "中债估值日", "估值基准日", "估值日", "日期"], net=["中债估值（反算净价）T日", "中债估值净价", "估值净价", "中债净价", "中债估值(昨日净值)", "估值(昨日净值)", "中债估值(昨日净价)", "昨日净值", "昨日净价", "净价"], gross=["中债估值（反算全价）T日", "中债估值全价", "估值全价", "中债全价", "中债估值(昨日全价)", "估值(昨日全价)", "昨日全价", "中债估值(反算全价)T-1日", "反算全价", "全价"]) # 独立估值 Sheet 的识别关键字（Sheet 名包含其一即视为估值表） VAL_SHEET_HINT = ["中债估值", "中债登估值", "估值表", "估值"] # 逐笔持仓（lot）是否纳入预测盈利：由「Σ逐笔剩余量 == 持仓汇总块合计」自动判定。 # 实测国债 797000=797000 / 地方债 397500=397500 / OCI 142000=142000 逐位相等 → 纳入； # ABS 为摊还型（买卖行都带 running balance，且有「偿还本金」行）→ 勾稽必然不过 → 自动排除， # 避免把余额当逐笔持仓重复计数。信用债走「剩余金额」列，与汇总块不完全一致 → 同样自动排除。 LOT_TOL = 0.5 # 勾稽容差（万元） # ── 提前兑付 / 已结清的备注识别 ──────────────────────────────────────────────── # 台账「债券到期日」列填的是**法定到期日**，而券可能已提前兑付/被清偿 —— 制表人的登记方式 # 是在「备注」列手写一句「2026/8/14已结清」（本项目实测唯一一只：`266099.SH`/AC，法定到期 # 2027-07-15、实际 2026-08-14 结清）。若只按法定到期日算，历史存量序列会一直把它留到 2027 年 # （实测多算 2000 万 ⇒ 历史序列对账差 0.20 亿，且只报总差额、查不出是哪只券）。 # ⚠ 只认「日期紧跟结清类关键词」这一种明确句式：认不出就报质量条目让人补，**绝不猜**一个日期 # 出来 —— 备注是自由文本，凭语义猜日期就是编造，比留个差额更危险。 PAYOFF_KW = ("已结清", "结清", "提前兑付", "提前偿还", "提前清偿", "已兑付", "全额偿还", "已清偿") _PAYOFF_DATE = re.compile(r"(\d{4})\s*[/\-.年]\s*(\d{1,2})\s*[/\-.月]\s*(\d{1,2})\s*日?") # N11：否定/计划句式不能当成「已结清」。 # · 否定词（未/尚未/不/没/未能/未在）——「未结清」「尚未结清」「未能结清」「不结清」； # · 计划词（计划/拟/将/待/预计/计划于/拟于/预计于）——「计划2026-09-10结清」「计划于…结清」。 # 判断：取关键词前的一段文本（含紧邻前缀），若**含**任一否定/计划词，一律判「非结清」， # 认不出就返回 None 让人补（绝不猜日期）。 # ⚠ 报告 N11 明示：不能无限堆黑名单就宣称语义可靠，这里只挡**常见**否定/计划句式， # 其余自由文本仍走「认不出 → 报质量条目人工补」的兜底，不猜测。 _PAYOFF_NEG = ("尚未", "未", "未能", "没", "不", "计划", "拟", "将", "待", "预计") def early_payoff(text): """备注文本 → 提前兑付日（ISO 字符串 `YYYY-MM-DD`）；识别不出返回 None。纯函数，可单测。返回值与 `isodate()` 同形（都是 ISO 字符串），这样可以直接和 `bond_maturity` 比大小 —— 本项目所有日期一律走 ISO 字符串，**不要混入 `date` 对象**（曾因此炸 `TypeError: '<' not supported between 'datetime.date' and 'str'`）。识别的句式：`<日期>已结清` / `已于<日期>结清` —— 即**关键词之前最近的那个日期**，且日期与关键词之间只允许隔 3 个字符（`已` / `于` 之类），避免把备注里另一段无关的日期（如「展期至2027/1/28」）错认成结清日。 N11：关键词前若含否定/计划语义词（未/尚未/不/没/未能/计划/拟/将/待/预计…）一律不认，避免把「2026-09-10未结清」「计划2026-09-10结清」「计划于…结清」「未能结清」误判成已结清。""" if not text: return None s = str(text) pos = -1 for k in PAYOFF_KW: i = s.find(k) if i >= 0 and (pos < 0 or i < pos): pos = i if pos < 0: return None # N11：关键词前段（含紧邻前缀 + 抠掉日期后的剩余文本）若**含**否定/计划词，一律判非结清。 # 用「包含」而非「endswith」—— 覆盖「计划于…结清」（计划于中间有「于」）、 # 「未能结清」（未能后有「能」）这类词尾带字的情况。 _head = _PAYOFF_DATE.sub("", s[:pos]) if any(_n in _head for _n in _PAYOFF_NEG): return None last = None for m in _PAYOFF_DATE.finditer(s[:pos]): last = m if last is None or pos - last.end() > 3: return None try: return D(int(last.group(1)), int(last.group(2)), int(last.group(3))).isoformat() except ValueError: return None # 投资品种展示顺序（矩阵列序 / 期限结构 / 账户 breakdown / 预测盈利，全项目唯一一处） PTYPE_ORDER = ["国债", "政金债", "地方债", "同业存单", "信用债", "ABS", "货币基金"] # ══════════════════════════════════════════════ 质量条目归因（§给台账制表人的话） # 台账是**人工填写**的，最贵的一类错误不是「业务判断分歧」，而是**量级笔误**： # 忘输 % → 利率直接放大 100 倍；元/万元混用 → 金额放大 10000 倍；漏填一格 → 整笔被排除。 # 这类问题光在驾驶舱里"算对"没用 —— 台账没改，下期照错。所以每条质量条目都要能回答三件事： # 出在哪一格（at）、该归谁改（kind）、具体怎么改（fix）。 # Q_META：cat → (kind, fix, auto) # kind 录入笔误 / 录入遗漏 / 口径待确认 / 结构缺失 / 系统已跳过 # fix 建议动作 —— 必须写成「怎么改这一格」的可执行动作，页面原样展示 # auto 系统是否已自动修正（已修正的仍要告知，但语气是「知会」而不是「请你改」） # ⚠ 新加质量条目时**必须在此登记**，否则归因栏为空、页面只能归到「其它」组。 Q_META = { "缺失Sheet": ("结构缺失", "确认台账是否改名/删除过该 Sheet —— 缺 Sheet 会让整块业务不参与统计。", False), "本金异常": ("录入笔误", "把「本金 / 券面总额」改成纯数值（>0）；带逗号或单位的文本会被判为无法识别。", False), "到期日缺失": ("录入遗漏", "补填到期日 —— 缺它就无法进入到期日历与现金流分析。", False), "日期倒挂": ("录入笔误", "检查到期日与起息日是否填反（到期日应晚于起息日）。", False), "利率格式异常": ("录入笔误", "改成数值小数（如 0.0139），或直接输入「1.39%」让 Excel 自己存成 0.0139。", True), "利率异常": ("录入笔误", "复核利率列：应为 0~20% 的小数（0.0139 = 1.39%）。", False), "利率量级存疑": ("录入笔误", "对照同 Sheet 其他行的利率量级重填 —— 典型是忘输/多输「%」。", False), "收益率格式异常": ("录入笔误", "改成数值小数（如 0.0192），或直接输入「1.92%」。", True), "收益率异常": ("录入笔误", "复核到期收益率列：应为 0~20% 的小数，该值已按无效处理、未纳入加权。", False), "利息勾稽不符": ("录入笔误", "本金×利率×期限÷365 应与「利息」列一致 —— 请核对利率与利息两列哪一列写错。", False), "交易日缺失": ("录入遗漏", "补填交易日。", False), "结算日缺失": ("录入遗漏", "补填「结算日」—— 它是债券的入库生效日（T+1/T+2 交收，交易日≠入库日）；" "缺它系统只能按交易日回退估算，可能把尚未入库的券算进持仓。", False), "未入库交易": ("系统已跳过", "结算日晚于台账日的成交按「入库生效日≤台账日」口径未计入存量（银行间 T+1/T+2 交收属正常，" "无需修改）；若该笔实际已在台账日入库，请核对「结算日」列是否填错。", True), "备注标注已结清": ("系统已跳过", "系统已按备注里的结清日把该券提前归零（不按法定到期日算）—— " "建议顺手把「债券到期日」列也改成结清日，以后就不再依赖这句备注文本了。", True), "申购日缺失": ("录入遗漏", "补填申购日 —— 缺它无法判断持有天数。", False), "账户缺失": ("录入遗漏", "补填会计账户（AC / OCI / TPL）。", False), "估值净价异常": ("录入笔误", "复核中债估值净价 —— 该值超出合理区间，已按无效处理。", False), "估值未填全": ("录入遗漏", "持仓汇总块的「估值日期 / 中债估值净价」有几行没填，补齐后预测盈利才能覆盖。", False), "持仓汇总缺金额": ("录入遗漏", "汇总块该行缺「剩余量(万)」—— 补上，否则持仓口径会偏小。", False), "预测盈利覆盖范围": ("录入遗漏", "补齐各 Sheet 的估值列，未覆盖部分不计入预测盈利。", False), "汇总勾稽不符": ("口径待确认", "汇总块「合计」与明细求和不一致 —— 先确认哪个是准的，再统一。", False), "库存不一致": ("口径待确认", "理论持仓与现券库存不符 —— 属业务性问题，需业务确认后修台账。", False), "台账有·库存无": ("口径待确认", "台账显示持有但现券库存没有 —— 确认该笔是否已到期/已处置。", False), "库存有·台账无": ("口径待确认", "现券库存有但台账查不到 —— 确认是否漏登了买/卖行。", False), "库存重复行": ("系统已跳过", "同一债券代码出现多行，系统已按累计合并；若为重复粘贴请删掉多余行。", True), "疑似重复": ("口径待确认", "同对手/同本金/同起止日的多笔，确认是拆单还是误录。", False), "逐笔持仓口径待确认": ("口径待确认", "逐笔「剩余量」与汇总块不一致，系统已按汇总块口径取值。", False), "非交易行": ("系统已跳过", "该行无法识别为交易，系统已跳过；若确实要统计请补全关键列。", True), "无持仓汇总块": ("结构缺失", "该 Sheet 底部缺「持仓汇总块」，持仓由交易流水推算（按结算日入库、扣除已到期部分）" "**并计入投资规模与核对项** —— 数值不会漏，但比汇总块多一层推算，建议补块。", False), "推算持仓为净空头": ("口径待确认", "该券按流水推算为负持仓（卖出多于买入）—— 已按负值并入投资规模。" "通常意味着交易区漏记买入，请核对；若确为卖出开仓则属正常。", False), "估值列多余行": ("结构缺失", "估值列下方有多余内容，请清理，避免误读。", False), "估值表列名未识别": ("结构缺失", "估值表列名与预期不符，请对照《功能与技术说明文档》的列名约定调整。", False), "估值表为空": ("结构缺失", "估值 Sheet 是空的 —— 未接入估值则预测盈利无法计算。", True), "估值未接入": ("结构缺失", "台账内无可用中债估值（汇总块无估值列或估值 Sheet 为空）。", False), "历史窗口起点晚于台账日": ("口径待确认", "台账日早于历史序列固定起点，已自动回退为「近 12 个月」窗口。", True), "历史序列对账不符": ("口径待确认", "历史末点与当期 KPI 未对上 —— 属系统内部问题，请联系维护人；" "差异明细见「详情」列（逐券点名的，多为台账该券的到期日/结算日未更新）。", False), "债券到期日异常": ("录入笔误", "复核债券到期日是否填错（早于台账日过多/年份异常）。", False), "年度目标核对不符": ("口径待确认", "年度目标页重算的实际值与底稿不一致 —— 核对净息差报表与卖出明细口径。", False), "年度目标未读取": ("数据源", "年度目标数据文件存在但解析失败 —— 核对文件格式（净息差报表应为 XML 格式 .xls）。", False), "年度目标未接入": ("数据源", "「输入数据/年度目标/」目录缺少数据文件（净息差报表/卖出成交明细）。", False), # ── F11 Excel 解析边界（防御性）── "Excel解析边界": ("结构缺失", "Excel 文件使用了非标准边界（公式无缓存 / 1904 日期系统 / 缺共享字符串），系统已按边界规则处理 —— 请确认该文件由常规 Excel 另存为标准格式后重传。", False), # ── 第三方库存（同业系统）核对 ── # 同业系统快照是三个来源里可靠性最高的（现券库存靠手工维护、持仓块由交易流水推算）， # 所以「不符」时的动作是**照同业系统改台账**，而不是反过来。 "核对源时点不符": ("数据源", "同业系统库存是「某一天拉下来的快照」：拉取时间必须等于台账日期才能与台账、" "现券库存同日比对。把该快照重新拉到 T 日后再更新数据，即自动启用三方核对。", False), "核对源表头异常": ("结构缺失", "「债券库存核对」Sheet 里找不到「查询日期」表头行，请确认该 Sheet 结构未被改动。", False), "核对源缺日期行": ("数据源", "同业系统快照里有些行的「查询日期」是空的 —— 这些行数不清来源时点，却会被算进" "三方核对的分母，所以本次直接停用三方核对。请把该列补齐后重新拉取快照。", False), "核对源勾稽不符": ("数据源", "同业系统明细求和与它自带的汇总块不一致 —— 请确认该快照是否拉取中断/漏行，" "修正后再更新数据（三方核对以它为基准，基准不完整结论就不可信）。", False), "第三方缺金额": ("录入遗漏", "同业系统明细缺「券面总额(万元)」，请把该列重新导出。", False), "现券库存不符": ("录入笔误", "现券库存与同业系统不符（台账持仓是对上的）⇒ 照同业系统改「现券库存」Sheet 该行的券面总额。", False), "台账持仓不符": ("录入笔误", "台账持仓与同业系统不符（现券库存是对上的）⇒ 照同业系统改对应 Sheet 持仓汇总块该行的「剩余量(万)」。", False), "两方均不符": ("录入笔误", "台账持仓与现券库存都与同业系统不符 ⇒ 以同业系统为准，这两处都要逐项核对。", False), "同业系统缺该券": ("数据源", "同业系统快照里没有这只券 —— 多为 T 日新买入尚未进同业系统，T+1 再拉一次即可见。", False), # ── 风险测算（页 8）── "久期凸性缺失": ("录入遗漏", "现券库存该券缺中债估值久期套件（全价 / 修正久期 / 基点价值 / 凸性有空值）⇒ " "风险测算里它的市值、DV01 与损益按「—」处理（不估算）。核对中债估值是否整行没贴全。", False), "DV01勾稽不符": ("录入笔误", "「基点价值」应等于「中债估值全价 × 修正久期 × 1bp ÷ 100」—— " "两者对不上说明这两列至少一列取错券/取错行，请核对后重填。", False), # ── 盈利预测核算口径（V2.37 起）── "应计利息按面额分摊": ("数据源", "该笔债券在「核算余额查询」里未精确匹配到「结算日＋券面总额」，应计利息/利息调整" "已按该券剩余面额占比分摊（通常因 OCI 账户在核算系统里合并了批次）—— 属合理近似，" "若需精确归属请在核算系统补录批次明细。", False), "核算余额未接入": ("数据源", "未读到「核算余额查询*.xls」⇒ 应计利息/利息调整缺失，预测盈余无法按核算口径计算" "（相关逐笔盈余留空显示「—」，不按 0 编造）。请把核算余额文件放到台账同目录后重算。", False), # N29：读取异常路径（缺 xlrd / 表头缺列 / 读取中途失败）与「整份未接入」分开登记， # 否则 test_audit 的「类别必须有 kind/fix」会漏检这些异常分支（正常样本测不到）。 "核算余额未读取": ("数据源", "核算余额文件存在但**未能成功读取**（缺 xlrd 依赖 / 表头缺列 / 解析中途失败），" "应计利息/利息调整缺失 ⇒ 相关逐笔盈余留空显示「—」，不按 0 编造。" "请确认环境装了 xlrd、表头列名与别名匹配后重算。", False), # N24：有核算来源但没有在持买入批次认领（可能含已售部分），差额未计入盈余。 "核算余额未分配": ("数据源", "有「券＋账户」的核算余额未被任何在持买入批次认领（多出的来源 / 已售部分 / 批次合并），" "该差额未计入预测盈余。请核对核算表的归属与在持范围。", False), } # 利率类字段的「量级离群」阈值（见 audit_scale）： # 比值 ≥ RATE_SCALE_HI ⇒ 高（必然是笔误）；≥ RATE_SCALE_LO ⇒ 中（请复核） # 同一 Sheet 同一字段内出现 10 倍以上的价差，已不可能是真实行情，故取 10 作下限。 RATE_SCALE_LO, RATE_SCALE_HI = 10.0, 20.0 RATE_GROUP_MIN = 5 # 参照中位数要求的最少样本数（样本太少则中位数不可信，不报） def scale_outliers(obs, group_min=None, lo=None, hi=None): """给一批「利率类「观测」算出量级离群判定（纯函数，不碰工作簿 ⇒ 可直接单测）。 obs: [dict(sheet, field, at, raw, norm, flagged)] raw/norm 分别是原始值与归一后值；flagged=True 表示已被既有检查点名（不要再报一次）。返回: [(o, 参照中位数, 相差倍数)]，按倍数降序；倍数恒 ≥1。参照系取「同一 Sheet 同一字段的归一后值中位数」：归一后即真实利率，因此不受「有人写 1.41、有人写 0.0141」这种整列混用习惯干扰。样本数 < group_min 的组不判定 —— 中位数在 2~3 个样本上没有意义，宁可漏报不可误报。""" g_min = RATE_GROUP_MIN if group_min is None else group_min g_lo = RATE_SCALE_LO if lo is None else lo g_hi = RATE_SCALE_HI if hi is None else hi grp = defaultdict(list) for o in obs: if o.get("norm") and o["norm"] > 0: grp[(o["sheet"], o["field"])].append(o["norm"]) ref = {k: med(v) for k, v in grp.items() if len(v) >= g_min} out = [] for o in obs: if o.get("flagged") or not o.get("raw") or o["raw"] <= 0: continue m = ref.get((o["sheet"], o["field"])) if not m: continue k = mag(o["raw"] / m) if k < g_lo: continue out.append((o, m, k, len(grp[(o["sheet"], o["field"])]) - 1)) out.sort(key=lambda t: -t[2]) return out def interest_ratio(item, divider=365.0): """资金业务「利息」勾稽比值 = 利息 ÷ (本金 × 利率 × 期限 ÷ 天数基数)。台账实测算式即此式（实测 43 笔全部落在 1.0000 或 365/360 = 1.0139）。无法计算（缺列 / 非正）时返回 None。""" if not (item.get("rate") and item.get("interest") and item.get("principal") and item.get("term")): return None calc = item["principal"] * item["rate"] * item["term"] / divider return (item["interest"] / calc) if calc > 0 else None # ══════════════════════════════════════════════════════════ 三方库存核对 # 来源与可靠性（高 → 低）： # ① 同业系统债券库存（台账「债券库存核对」Sheet 的 F:L 块，G 列 = 拉取时间）—— 系统直出，最可靠； # ② 现券库存 Sheet —— 人工维护的快照； # ③ 各债券 Sheet 底部「持仓汇总块」—— 由交易流水推算。 # 三方都在 ≠ 三方都能比：① 带**拉取时间**，与台账日期不一致时它本身就带时点偏差， # 此时把它拉进来会把「时点差」误报成「账实不符」，反而淹掉真问题 ⇒ **不满足就退回两方**。 RECON_EPS = 0.5 # 差异容差（万元）：与既有两方核对的判「不一致」阈值保持一致 THIRD_SHEET_HINTS = ["债券库存核对", "库存核对", "债券核对"] # Sheet 名形如「债券库存核对0902」，按前缀认 def three_way(book_wan, inv_wan, third_wan, eps=RECON_EPS): """三方归因判定（纯函数 ⇒ 可单测）。以**同业系统**（可靠性最高）为基准，回答「错在哪一方」而不是只报「不一致」：三方一致 / 现券库存不符 / 台账持仓不符 / 两方均不符 / 同业系统缺该券返回 (判定, 台账持仓−同业系统, 现券库存−同业系统)。third_wan 为 None ⇒ 同业系统无该券。""" if third_wan is None: return "同业系统缺该券", None, None db = round((book_wan or 0.0) - third_wan, 4) di = round((inv_wan or 0.0) - third_wan, 4) ok_b, ok_i = abs(db) < eps, abs(di) < eps if ok_b and ok_i: return "三方一致", db, di if ok_b: return "现券库存不符", db, di if ok_i: return "台账持仓不符", db, di return "两方均不符", db, di def third_enabled(third, third_meta, T, bad3): """三方核对「是否启用」的判定（纯函数 ⇒ 可单测；审查报告 N05）。 ⚠ 原判定只写了 `bool(third) and pull == T`，有两个漏洞： ① **缺日期的行照样被累加进 `third`** —— `pulls` 只收「日期解析成功」的行，所以只要快照里混有**一行**日期 == T，整块就被判为「时点统一」，而那些缺日期的行已经在分母里了； ② **自勾稽失败（`bad3` 非空）对启用毫无影响** —— 基准本身不平，结论全错，却仍然给出「三方一致 / 台账持仓不符」这类**归因**结论。三项全过才启用：有数据 + 时点唯一且 == T + 无缺日期行 + 自勾稽通过。 """ return (bool(third) and third_meta.get("pull") == T and third_meta.get("n_nodate", 0) == 0 and not bad3) def third_reason(third, third_meta, T, bad3): """未启用的原因（面板要显示「为什么没启用」，不能只给一个 False）。""" if not third: return "无快照" if third_meta.get("n_nodate", 0) > 0: return "缺日期行" if third_meta.get("pull") != T: return "时点不符" if bad3: return "自勾稽不符" return "" # ══════════════════════════════════════════════ 持仓回退（无汇总块的 Sheet） # 🔴 F06：台账某个债券 Sheet 底部**没有**「持仓汇总块」时，理论持仓原先只被算进辅助键 # `flow_wan`（账户三分对照用），**从未回写 `book_pos`** —— 而 `book_pos` 是全项目 # 「投资规模 / 债券主数据 / 期限结构 / 库存核对」的唯一来源 ⇒ 该 Sheet 的持仓 # **静默漏计**（台账少一个汇总块，总量就少一块，且没有任何页面能看出来）。 # ⇒ 抽成纯函数（可单测），推算结果原样并入 `book_pos`。 # ⚠ 口径必须与下面三处**逐字一致**：`flow_wan`（账户三分对照）、`bond_settle_ledger()`、 # `iter_bond_daily()`（历史序列）。任何一处单改，都会让「投资规模」与「历史曲线」分叉。 def derive_book_pos(bonds, sheets, T): """无持仓汇总块的 Sheet：按交易流水推算理论持仓（F06）。口径 = 已入库（`settled`：结算日 ≤ T）且未到期（`mat_eff or bond_maturity` > T），按 (债券代码, 投资账户) 聚合，面额（万元）× STDDIR（买入 +1 / 卖出 −1）。 ⚠ 两条**刻意**的取舍： ① 余额为 0 或为负的键**一律保留**（不静默丢弃）——「当日平仓」「净空头」都是真实状态，丢掉会让投资规模与核对项同时少算； ② `avg_remaining_years` 由「法定到期日 − T」推出（汇总块里有「剩余期限(年)」列，流水区没有）。推出值只用于久期分桶；缺到期日时为 None（落「未知」档）。 """ out = {} for b in bonds: if b["sheet"] not in sheets: continue if not b["settled"]: continue # 未入库（结算日 > T 或日期缺失） _me = b.get("mat_eff") or b.get("bond_maturity") if _me and _me <= T: continue # 已到期 / 已提前结清（含 T 日到期） k = (strip_code(b["code"]), b["account"]) x = out.get(k) if x is None: out[k] = x = dict(sheet=b["sheet"], account=b["account"], code=b["code"], name=b["name"], nature=b["nature"], ptype=b["ptype"], wan=0.0, bond_maturity=b["bond_maturity"], avg_remaining_years=None, src="flow") x["wan"] += b["face_wan"] * STDDIR[b["direction"]] if (b["bond_maturity"] or "") > (x["bond_maturity"] or ""): x["bond_maturity"] = b["bond_maturity"] # 同键多笔理论上同一到期日，取较晚者兜底 for x in out.values(): m = x["bond_maturity"] if m: x["avg_remaining_years"] = round( (datetime.date.fromisoformat(m) - datetime.date.fromisoformat(T)).days / 365.0, 4) return [out[k] for k in sorted(out, key=lambda t: (t[1] or "", t[0] or ""))] INV_A = dict(账户=["账户"], 类型=["债券类型"], 名称=["债券名称"], 代码=["债券代码"], 性质=["债券性质"], 面额=["券面总额"], 到期日=["到期日"], 质押=["质押"], 可用=["可用余额"], 质押到期=["质押到期日"], 短债=["是否短债"], 超长=["是否超长债"], 备注=["备注"], 净价=["中债估值（反算净价）T日", "中债估值（净值）T日", "中债估值（净值）T-1日", "当日净价", "中债估值净价", "估值净价", "中债净价", "当日估值净价", "昨日净值"], # ── 风险测算（页 8）用的中债估值衍生列 ── # 现券库存尾部这几列是中债每日配套下发的估值套件：净价 / 全价 / 收益率 / # 票面 / 剩余久期 / 修正久期 / 基点价值 / 凸性。缺列的券其风险字段一律 None # （页面显示「—」），**不按替代口径估算**。 # ⚠ V2.68：估值口径统一为 **T 日**（表头「…T日」，全价=「反算全价」、净价= # 「反算净价」），旧的「T-1日 / 日间全价 / 净值」候选保留仅作向后兼容。全价=["中债估值（反算全价）T日", "中债估值（日间全价）T日", "中债估值（反算全价）T-1日", "中债估值（日间全价）T-1日", "中债估值全价", "反算全价", "日间全价", "中债全价"], 收益率=["中债估值（收益率）T日", "中债估值（收益率）T-1日", "中债估值收益率", "中债收益率"], 票面=["票面利率", "票面利率/发行利率", "发行利率"], 久期剩余=["剩余久期"], 久期修正=["修正久期T日", "修正久期T-1日", "修正久期"], 基点价值=["基点价值T日", "基点价值T-1日", "基点价值"], 凸性=["凸性T日", "凸性T-1日", "凸性"]) # ══════════════════════════════════════════════════════ 债券余额引擎（唯一真相） # 🔴 N08：历史曲线（main() 的 ev_bt/hist_bond）与展示日切片（slice_days）曾经**各写一遍** # 债券存量 —— history 逐笔按各自日期登记增量、券到期整笔归零；slice 却把**全期最终净额** # 套用到「首笔入库日 ~ 有效到期日」的每一天，并把最终已清仓的券整只剔除。 # 后果：273 天里 271 天的切片债券规模与历史曲线不符（最大差 29.5 亿元），且已清仓的 # 历史头寸整段消失 —— 而末点守卫只看最后一天 ⇒ 全绿、**完全静默**。 # ⇒ 自本节起，债券余额只有**一份**实现：下面的账本 + 逐日迭代器。 # history 消费账本的 events（一次聚合，_hseries 不动）；slice 消费逐日持仓明细。 BOOK_EPS = 1e-6 # 元：低于此视为零持仓（与旧 slice 的 abs(_cum0) < 1e-6 同口径） def bond_settle_ledger(bonds, book_pos, T_iso): """按 (代码, 账户) 建「逐笔结算事件账本」—— 债券余额的唯一真相。 ⚠ 金额一律**元**：面额列是万元，乘 WAN 折元后再累加，与 main() 的 ev_bt 逐字同款。少一个 ×WAN 会让全库镜像小 1 万倍，而存量合计看着仍「像个正经数字」，只有矩阵 / 期限结构会露馅。 ⚠ 事件日期取「入库生效日 start（= 结算日，缺则交易日）」，不是交易日：T+1 成交在交易日尚未入库，按交易日入账会让历史曲线提前一天把未入库的券算进存量。 ⚠ 归零日取「有效到期日 mat = 各笔 (mat_eff or bond_maturity) 的最大值」；到期日当天已结清 ⇒ 当日即出表。mat 不晚于末笔结算日时**不归零**并置 anomaly（由调用方报质量）。返回 {(strip_code(code), account): dict( ptype 品种 —— **按流水笔数取多数**（与 main() 的历史分品种序列同款） ptype_ref 持仓汇总块的品种（切片侧优先用它，取不到为 None）；两者分开存是因为「谁优先」在两侧本来就不一样，合成一个字段必有一侧改数 events [(日期 ISO, 增量元)] 升序，**已含到期归零事件** mat 有效到期上限；bmat 法定到期上限；last 末笔结算日；anomaly 见上 rem0 台账日剩余期限基准（book_pos 的列；不在 book_pos 里的清仓券用法定到期日兜底） latest 整份台账 trade_date 最大的那笔（与 bond_master 同取出法，自证 D=T 一致） meta [(trade_date, coupon, ytm)] 升序 —— 供 bond_meta_asof() 逐日取用)}""" _all, _valid = defaultdict(list), defaultdict(list) for b in bonds: k = (strip_code(b["code"]), b["account"]) _all[k].append(b) if STDDIR.get(b["direction"]) is None or not b.get("start"): continue # 与 main() 的 _bt / 旧 slice 的 _bk 同一道过滤 _valid[k].append(b) _ref = {} for p in book_pos: _ref[(strip_code(p["code"]), p["account"])] = p out = {} for key in sorted(_valid, key=lambda k: (k[0] or "", k[1] or "")): _ts = _valid[key] # ⚠「最新一笔」按台账行序取「首个最大 trade_date」（严格大于才替换）—— 与 # bond_master 的 latest 逐字同款。候选集是**该键的全部流水**（含未生效/方向异常的 # 笔），这样 D = T 时 as-of 结果才与 bond_master 完全相同。 latest = None for x in _all[key]: if latest is None or (x.get("trade_date") or "") > (latest.get("trade_date") or ""): latest = x _ts = sorted(_ts, key=lambda x: (x["start"], x["code"] or "", x["account"] or "")) _p = _ref.get(key) ptype = Counter(x["ptype"] for x in _ts).most_common(1)[0][0] ptype_ref = _p["ptype"] if _p else None ev, cum, mat, bmat = defaultdict(float), 0.0, None, None for x in _ts: delta = STDDIR[x["direction"]] * x["face_wan"] * WAN cum += delta ev[x["start"]] += delta _m = x.get("mat_eff") or x.get("bond_maturity") if _m and (mat is None or _m > mat): mat = _m _m2 = x.get("bond_maturity") if _m2 and (bmat is None or _m2 > bmat): bmat = _m2 last = _ts[-1]["start"] anomaly = bool(mat and mat <= last) if mat and not anomaly: ev[mat] -= cum # 到期日整笔归零（当日即出表，边界 ≤） rem0 = _p.get("avg_remaining_years") if _p is not None else ( (days_between(T_iso, bmat) / 365.0) if bmat else None) # ⚠ 只按 trade_date 排序（**稳定排序**，不可用整元组排序）—— 否则同日多笔会按 # 票面/收益率重排，as-of 取到的「首笔」与 bond_master 的 latest 分叉（实测差 2e-5）。 meta = [(x.get("trade_date") or "", x.get("coupon"), x.get("ytm")) for x in _all[key]] meta.sort(key=lambda t: t[0]) out[key] = dict(ptype=ptype, ptype_ref=ptype_ref, events=sorted(ev.items()), mat=mat, bmat=bmat, last=last, anomaly=anomaly, rem0=rem0, latest=latest, meta=meta) return out def bond_meta_asof(led, key, day_iso): """某券「截至展示日 D」的原始票面 / 收益率 = trade_date ≤ D 的最后一笔。 D = T 时等于账本 latest ⇒ 与 bond_master 逐字一致（消除「用后发生的交易参数去算更早展示日」的时间穿越）。取不到返回 (None, None)，由调用方归一并决定是否落空。 ⚠ 并列交易日必须取**第一笔**（严格大于才替换）—— 与 bond_master 的 latest 同款；取最后一笔会在同一天有多笔交易且票面不同时与当期口径分叉（本轮实测差 2e-5）。""" cur, cur_td = None, None for td, cp, yt in led[key]["meta"]: if td > day_iso: break if cur_td is None or td > cur_td: cur, cur_td = (cp, yt), td return cur if cur else (None, None) def iter_bond_daily(led, hdays): """事件扫描线 → 逐日产出在持仓券明细：(i, day, [(key, 余额元, ptype, rem0, coupon, ytm)]) ⚠ 券数语义 = **当日余额非零**，不是「全期从未有余额」：清仓日之后自然不在 open 集里，持有期间如实计入。旧 slice 的「整键剔除」把「最终净额为零」误当「从未持有」，既丢了清仓前的历史持仓，又让券数 / 加权重虚增（实测 AC 虚增 6 只 / OCI 虚增 25 只）。 ⚠ 复杂度 O(E log E) + O(天数 × 当日持仓券数) —— 与旧实现同量级， **不是**「每天重扫全表流水」（那会退化成 O(天数 × 券数 × 笔数)）。""" # 事件全部摊平后按 (日期, 键) 排序 —— 显式二级键，不依赖 dict 顺序（F17 可复现） seq = sorted(((d, k, a) for k, v in led.items() for d, a in v["events"]), key=lambda t: (t[0], t[1][0] or "", t[1][1] or "")) openbal, p, m = {}, 0, len(seq) for i, day in enumerate(hdays): while p < m and seq[p][0] <= day: _, k, a = seq[p] p += 1 nb = openbal.get(k, 0.0) + a if abs(nb) < BOOK_EPS: openbal.pop(k, None) # 归零 ⇒ 当日即出 open 集 else: openbal[k] = nb rows = [] for k in sorted(openbal, key=lambda k: (k[0] or "", k[1] or "")): v = led[k] cp, yt = bond_meta_asof(led, k, day) # 行元组顺序：键 / 余额元 / 账户 / 品种 / rem0 / bmat / 票面 / 收益率 rows.append((k, openbal[k], k[1], v["ptype_ref"] or v["ptype"], v["rem0"], v["bmat"], cp, yt)) yield i, day, rows # ─────────────────────────────────────── 资金业务「质押类 / 信用类」二分 # 「业务 × 质押/信用矩阵」（页 2）用。归类规则（业务口径，已与业务方确认）： # 回购（逆回购 / 正回购）**整体**质押类（回购天然是质押式，不逐笔看质押券是否为空）； # 同业存款按台账「是否质押」列**逐笔**归类（谓词与 main() 的 dep_split 逐字相同）； # 其余（同业拆出 / 同业借款 / 存放同业 / 同业拆入 / 存单发行）信用类。 # ⚠ 结果**嵌进已有的 branches_all[k] 的 cls 子块**，不新建顶层键 —— 新建顶层键会连锁 # 触发「键表(cloud_sync.BASIC_KEYS) → 云库键数 → test_tdz_guard 的 N_KEYS → tier/RLS」 # 四处改动；而 branches_all 已在 BASIC_KEYS、切片白名单又是前缀匹配，嵌入是零连锁。 FUND_CLS = ("质押类", "信用类") # 单元格字段（**存原始加权和、不存成品比率**）：多选剔除业务、以及合计行/列要跨业务求和， # 存已平均的利率再求平均会对不齐分母（agg() 里 rate 的分母是「rate 非空行的本金和」）。 # ⚠ 字段名**不能**叫 rate / wam —— 守卫的 _tol() 给 rate 的容差是 2e-6，金额和大必然假红。 FM_F = ("p", "n", "rW", "rN", "tW", "tN", "mW") def fund_class_of(lv2, collateral): """→ '质押类' / '信用类'。见上注：回购整体质押类，同业存款逐笔看「是否质押」。""" if lv2 == "回购": return "质押类" if lv2 == "存款": return "信用类" if ((not collateral) or collateral in ("否", "N", "n", "无", "信用")) else "质押类" return "信用类" def cls_raw(rows): """rows: 可迭代 (principal, rate, term, remaining_days) → {p,n,rW,rN,tW,tN,mW}。 p = Σprincipal 存元；存量规模；也是 WAM 的分母 n = 笔数 rW = Σ(rate×principal) rN = Σ(principal | rate≠None) 加权利率 = rW/rN tW = Σ(rate×principal×term) tN = Σ(principal×term | rate≠None) 金额期限加权利率 = tW/tN mW = Σ(principal×max(remaining,0)) WAM（天） = mW/p ⚠ 与 main().agg() 的分母口径**必须逐字一致**（F10：分子分母同源，缺利率的行不得被隐式当 0% 稀释），否则切片日与台账日会给出两个利率。 """ p = n = 0 rW = tW = 0.0 rN = tN = mW = 0 for pr, rt, tm, rem in rows: p += pr n += 1 mW += pr * max(rem, 0) if rt is not None: _t = (tm or 0) rW += rt * pr rN += pr tW += rt * pr * _t tN += pr * _t out = dict(p=p, n=n, rW=rW, rN=rN, tW=tW, tN=tN, mW=mW) return {k: (v if k == "n" else int(round(v))) for k, v in out.items()} # ────────────────────────────────────────────────────── 展示日切片 def slice_days(hdays, fund, mf, bonds, book_pos, lv2_order, dur_order): """按日预计算「展示日切片」：页「总览驾驶舱 / 资金业务 / 投资业务」底部时间轴拖动时取用。产出一张「路径 → 273 天序列」的稀疏表（``keys`` / ``vals``）：前端按路径把值贴回 ``DATA`` 的浅副本，就得到该展示日的页面数据视图 —— 前端只搬运、不计算，口径仍只在这里算一次（项目铁律：绝不允许第二份真相）。为什么用「路径」而不是「逐日整对象」：**键名只存一份**。500 余条序列若逐日各带一遍键名，data.json 会从 ~1 MB 涨到 ~3.5 MB；另外全零 / 全等序列在 ``out()`` 里折叠成标量，实测再省约一半（历史日的资产端、多数久期区间、多数矩阵格子整段为 0）。 ⚠ 口径与 main() 的历史存量序列同源：同一套「生效日 ≤ D < 到期日」、同一个 bucket()、同一套 agg() 派生量。存量集只取 ``fund`` 流水，**不用**台账日的任何快照。 🔴 债券余额（N08）：不再在本函数里另写一遍，改用模块级 **bond_settle_ledger() + iter_bond_daily()** —— 与 main() 的历史曲线共用同一份逐笔结算账本。三条由此确立的语义，改动前必须想清楚： ① 每日取**当日余额**（逐笔累加），不是「全期最终净额」； ② **券数 / 加权重计数 = 当日余额非零的券**，清仓日之后自然出集（旧实现的「整键剔除」把最终清仓误当「从未持有」，既丢历史持仓又虚增计数）； ③ 票面 / 收益率按**展示日之前可用来源**取（trade_date ≤ D 的最后一笔），不是整份台账的最新一笔 —— 消除「用后发生的交易参数去算更早展示日」的时间穿越。 ⚠ 久期类字段（期限结构 / 账户加权久期 / 矩阵久期视图）以台账「剩余期限(年)」为基准、按展示日回推：剩余(D) = 剩余(T) + (T − D) / 365。D = T 时与台账原值逐字相同（前端在 D = T 直接返回原始 DATA，一条值都不贴）；历史日即「到期日 − 展示日」近似，与历史折线图同一条已知近似（页面已注明）。台账「剩余期限」缺失的券一律落「未知」档， **不按到期日替它估算** —— 否则会和台账日两个口径。 ⚠ 逐日**不存**到期日历的逐笔 items 与现金流日历：变长结构单日 12~20 KB，273 天会把 data.json 撑到 8 MB 以上。日历类模块按设计归「仅台账日」，前端灰显。 ⚠ 本函数**只算、不报质量**：台账日的质量清单已完整覆盖过一遍，历史日再报一次只会把「零噪音」告警淹掉（用户铁律）。故 _nrate() 不登记 AUDIT。 """ W = WAN n = len(hdays) T = hdays[-1] Td = datetime.date.fromisoformat(T) def _cum(ev, div=W, nd=2): """{日期: 增量} → 与 hdays 逐日对齐的累计序列。与 main()._hseries 同款累加。""" keys, out, cur, i, m = sorted(ev), [], 0.0, 0, len(ev) for day in hdays: while i < m and keys[i] <= day: cur += ev[keys[i]] i += 1 out.append(int(round(cur)) if div == 1 else round(cur / div, nd)) return out def _dbk(y): """与 main() 的 dur_bucket 逐字一致 —— 边界不同会让期限结构两处悄悄分叉。""" if y is None: return "未知" if y <= 1: return "≤1年" if y <= 3: return "1-3年" if y <= 5: return "3-5年" if y <= 10: return "5-10年" return ">10年" def _wends(day): """D 所在自然周的周日 / 自然月最后一日 —— 与 main() 的 undue 同款。""" d = datetime.date.fromisoformat(day) w = (d + datetime.timedelta(days=6 - d.weekday())).isoformat() nx = datetime.date(d.year + (1 if d.month == 12 else 0), (1 if d.month == 12 else d.month + 1), 1) return w, (nx - datetime.timedelta(days=1)).isoformat() def _nrate(x): """利率归一，与 main()._norm_rate 同规则：≤0.2 视为小数；0.2~20 视为百分数 ÷100；其余视为异常返 None（那一笔在台账日已单独报过质量条目）。""" if x is None: return None if x <= 0.2: return x if 0 < x / 100 <= 0.2: return x / 100 return None def _ri(v): return None if v is None else int(round(v)) def _r(v, nd=2): return None if v is None else round(v, nd) def _ag(g, day): """复刻 main().agg() 的全部派生量（逐日版）。字段名与现码逐字一致，这样前端把切片值贴回 DATA 后，cash() 的表格一行都不用改。 ⚠ wam 用「到期日 − D」当剩余天数；rate_amt_term 只对 rate 非空行求和（F10：分子分母同源，缺利率的行不得被隐式当 0% 稀释）。""" if not g: return None pr = sum(t[5] for t in g) at = sum(t[5] * (t[7] or 0) for t in g) _rw = sum(t[5] for t in g if t[8] is not None) _aw = sum(t[5] * t[8] for t in g if t[8] is not None) _rat = [(t[5] * (t[7] or 0), t[8]) for t in g if t[8] is not None] _rat_at = sum(a for a, _ in _rat) d = dict(n=len(g), principal=pr, cashflow=sum(t[9] for t in g), interest=sum(t[10] for t in g), rate=(_aw / _rw) if _rw else None, rate_amt_term=(sum(a * r for a, r in _rat) / _rat_at) if _rat_at else None, rate_cov=(_rw / pr) if pr else None, wam=(sum(t[5] * max(days_between(day, t[1]), 0) for t in g) / pr) if pr else None, avg_term=(at / pr) if pr else None) for b in BUCKETS_R: xs = [t[5] for t in g if bucket(days_between(day, t[1])) == b] d["b_" + b] = sum(xs) d["n_" + b] = len(xs) return d # ══════════════════════════════════════════════════════ 一次性预备 # ── 资金业务元组化（273 天反复遍历，先取出字段，避免重复取字典键） # 下标：0 start / 1 maturity / 2 side / 3 lv2 / 4 sheet / 5 principal # 6 collateral / 7 term / 8 rate / 9 cashflow / 10 interest ft = [(f["start_date"], f["maturity"], f["side"], f["lv2"], f["sheet"], f["principal"], f["collateral"], f["term"], f["rate"], f["cashflow"], f["interest"] or 0) for f in fund if f["start_date"] and f["maturity"] and f["maturity"] > f["start_date"]] _disp = {cfg["sheet"]: cfg["disp"] for cfg in FUND_SHEETS} _ord = {} for cfg in FUND_SHEETS: _ord.setdefault(cfg["side"], []).append(cfg["sheet"]) # branches_all 的行序 = 资产 4 类 + 负债 4 类，严格照 FUND_SHEETS 顺序（与 main() 同） _BA = [cfg for sd in ("资产", "负债") for cfg in FUND_SHEETS if cfg["side"] == sd] assert len(_BA) == len(FUND_SHEETS), "FUND_SHEETS 的 side 只能是资产/负债" # ── 债券：改用**唯一余额引擎**（N08）─────────────────────────────────────────── # 旧实现把「全期最终净额」套用到「首笔入库日 ~ 有效到期日」的每一天，并把最终已清仓 # 的券整只剔除 ⇒ 273 天里 271 天的债券规模与历史曲线不符（最大差 29.5 亿元）， # 已清仓的历史头寸整段消失。现在逐日取**当日余额**，与 main() 的历史曲线共用同一账本。 # ⚠ 久期基准仍只认台账日的「剩余期限(年)」列（台账没有历史列），按展示日回推近似 # —— 见 docstring；不在 book_pos 里的清仓券用「法定到期日 − T」兜底。 _led = bond_settle_ledger(bonds, book_pos, T) bond_holds = [h for _i, _d, h in iter_bond_daily(_led, hdays)] # ── 投资业务「业务区间变动情况」：买入/卖出/到期券面·笔数（V2.67）──────────── # 与「业务区间变动情况」的 ci/cm 同构 —— 前端只做差分（seq[hi] − seq[lo]），口径 # 仍只在**这里**算一次（项目铁律：绝不允许第二份真相）。 # 三条事件流（逐日累积成序列）： # 买入 direction>0（一级/二级买入），按**交易日 trade_date** 落账（非结算日） # 卖出 direction<0（一级/二级卖出），按**交易日 trade_date** 落账 # 到期该券净持仓 > 0 时，按有效到期日 mat_eff 整券归零（= 持有至到期兑付；无交易日） # 货基：申购 = 买入（buy/start 日）、赎回 = 卖出（redeem 日），**无到期**，归 # TPL 账户 / 货币基金品种。 # 🔴 恒等式（逐日，债券）：Δ存量 ≡ 买入 − 卖出 − 到期（货基无到期项，同样成立）。 # 到期量复用 bond_settle_ledger 的账本（mat 归零的 cum = 净持仓），绝不另算第二份。 # ⚠ 维度：**账户 × 品种二维**（inv_acc...）—— 前端按 # 「按账户-业务品种 / 按业务品种-账户」两级嵌套分组，两种视图都从这份二维聚合 # （账户小计 = Σ品种、品种小计 = Σ账户），不另产第二份。券面存**元**、笔数存**整数**。 # ⚠ 口径 = **含起始日 ~ 含结束日、均为交易日**（前端差分用 at(hi) − at(lo−1)）。 # ⚠ 事件**只保留 slice 起点（hdays[0]）之后**的：起点前的成交（如 2016 年起的历史买入） # 若也落账，_cum 会把它们吸收进 at(0)，导致「含起始日」差分（at(hi)−at(−1)）把 # 起点前历史一并算进区间 —— 起点前的那批券要么早已到期、要么已体现在起点存量里， # 不该重复计入「区间买入」。故 `date < hdays[0]` 的事件一律丢弃。 _hd0 = hdays[0] def _inv_path(acc, pt, fld): return "inv_acc.%s.%s.%s" % (acc, pt, fld) _inv_ev = defaultdict(lambda: defaultdict(float)) # path -> {日期: 增量} # 债券：买入/卖出按**交易日 trade_date** 落账（账户 × 品种；只留起点后） for b in bonds: if STDDIR.get(b["direction"]) is None or not b.get("trade_date"): continue if b["trade_date"] < _hd0: continue face = b["face_wan"] * WAN fld = "buy" if STDDIR[b["direction"]] > 0 else "sell" _inv_ev[_inv_path(b["account"], b["ptype"], fld + "_face")][b["trade_date"]] += face _inv_ev[_inv_path(b["account"], b["ptype"], fld + "_n")][b["trade_date"]] += 1 # 债券：到期按 mat_eff 归零（净持仓 = 到期日前所有买入/卖出增量之和，> 0 才算兑付） for key, v in _led.items(): mat = v.get("mat") if not mat or v.get("anomaly") or mat < _hd0: continue cum = sum(a for d, a in v["events"] if d < mat) if cum <= 0: continue # 已清仓 / 卖空的券没有「持有至到期兑付」 pt = v["ptype_ref"] or v["ptype"] _inv_ev[_inv_path(key[1], pt, "mat_face")][mat] += cum _inv_ev[_inv_path(key[1], pt, "mat_n")][mat] += 1 # 货基：申购 = 买入、赎回 = 卖出，无到期；amount 单位**元**（与 slice_days 里 ev_mf 同款） for m in mf: s0 = m["buy"] or m["start"] if not s0: continue amt = m["amount"] if s0 >= _hd0: _inv_ev[_inv_path("TPL", "货币基金", "buy_face")][s0] += amt _inv_ev[_inv_path("TPL", "货币基金", "buy_n")][s0] += 1 if m["redeem"] and m["redeem"] >= _hd0: _inv_ev[_inv_path("TPL", "货币基金", "sell_face")][m["redeem"]] += amt _inv_ev[_inv_path("TPL", "货币基金", "sell_n")][m["redeem"]] += 1 # 预计算「与 hdays 逐日对齐」的累积序列（账户 × 品种 × 字段都产，缺组合的全 0 折叠成标量） _inv_fields = ("buy_face", "buy_n", "sell_face", "sell_n", "mat_face", "mat_n") _inv_cum = {} for _a in ("AC", "OCI", "TPL"): for _pt in PTYPE_ORDER: for _f in _inv_fields: _p = _inv_path(_a, _pt, _f) _inv_cum[_p] = _cum(_inv_ev.get(_p, {}), div=1) # ── 货基（与 main() 的 ev_mf 同款：申购日入库、赎回日出库） _ms = [(m, (m["buy"] or m["start"])) for m in mf] _ev = defaultdict(float) _evn = defaultdict(float) for m, s0 in _ms: if not s0: continue _ev[s0] += m["amount"] _evn[s0] += 1 if m["redeem"]: _ev[m["redeem"]] -= m["amount"] _evn[m["redeem"]] -= 1 mf_wan_s = _cum(_ev) mf_n_s = _cum(_evn, 1) # ══════════════════════════════════════════════════════ 收集器 class _C(object): """路径 → 273 天序列。写入时按路径建数组；导出时把「全等序列」折叠成标量。""" def __init__(self, n): self.n = n self.buf = {} def put(self, path, i, val): a = self.buf.get(path) if a is None: a = self.buf[path] = [None] * self.n a[i] = val def out(self): keys, vals = [], {} for p in sorted(self.buf): a = self.buf[p] f = a[0] flat = True for v in a: if v != f: flat = False break # ⚠ 只折叠**非列表**值：branches / dep_split 的「一天的值」本身就是列表， # 折叠后与「n 长序列」形状撞车，前端 Array.isArray() 分不清两者。 vals[p] = f if (flat and not isinstance(f, list)) else a keys.append(p) return keys, vals C = _C(n) ACCS = ("AC", "OCI", "TPL") BK_ALL = list(BUCKETS_R) + ["逾期"] # bucket_table 的分档（与 main() 的 bnames 同） BA_F = ["n", "principal", "cashflow", "interest", "rate", "rate_amt_term", "rate_cov", "wam", "avg_term"] + ["b_" + b for b in BUCKETS_R] + \ ["n_" + b for b in BUCKETS_R] # ── 「业务区间变动情况」的两股事件流（按业务 sheet × 质押/信用拆）────────────── # 为什么必须**另建**两条序列：存量 p 只是净值。对任意起止日做差分 p[d1] − p[d0] # 得到的是「起息 − 到期」的**净**结果，拆不出「区间起息量 / 区间到期量」两列—— # 而这两列正是本模块要给的。故把同一批流水按「生效日」和「到期日」各累一条序列， # 前端只做减法（ci[d1] − ci[d0]），口径仍然只在这里算一次。 # 🔴 恒等式（逐日精确，两种口径共用同一份 ft 是它成立的唯一前提）： # 当日存量 p[i] ≡ ci[i] − cm[i] # 证明：Δci 只在 t[0] == day 时计入该笔本金（+1），Δcm 只在 t[1] == day 时计入 # 该笔本金（−1）；而存量集取 t[0] ≤ day < t[1]。两条序列相减后，某笔要么两边都 # 计过（t[1] ≤ day，+1−1 抵消），要么只在 ci 侧（t[0] ≤ day < t[1]，净 +1）， # 要么两边都没到（t[0] > day，净 0）—— 逐笔等于「在存量中」，求和即 p[i]。∎ # ⚠ 初值必须**吸收区间起点之前**的事件：起点前就起息、至今仍在存的业务若不计入 # ci，它却会在到期日被 cm 减掉 ⇒ 恒等式从第一天起就错。故 t[0] < hdays[0] 的 # 本金计入 ci 初值、t[1] < hdays[0] 的计入 cm 初值（同一笔两边都进则自动抵消）。 # 前端只用**差值**，初值在减法里天然消掉，所以它取多少不影响「区间起息量」； # 之所以仍按上述方式计入，是为了让恒等式**逐日**可断言（就地 + 独立复核两道锁）。 # ⚠ 与 p 同款：这两条也**每天都写**，绝不断点 —— _C.out() 的初值是 None， # 漏写某天会留 None ⇒ _slPack 覆盖不全 ⇒ 历史日残留台账日数字（静默串数）。 _ids = set(hdays) _hd0 = hdays[0] _iss, _mat, _ci0, _cm0 = {}, {}, {}, {} for t in ft: _key = (t[4], fund_class_of(t[3], t[6])) if t[0] < _hd0: _ci0[_key] = _ci0.get(_key, 0.0) + t[5] elif t[0] in _ids: _e = _iss.setdefault(_key, {}) _e[t[0]] = _e.get(t[0], 0.0) + t[5] if t[1] < _hd0: _cm0[_key] = _cm0.get(_key, 0.0) + t[5] elif t[1] in _ids: _e = _mat.setdefault(_key, {}) _e[t[1]] = _e.get(t[1], 0.0) + t[5] _run, _wedge = {}, [] # ══════════════════════════════════════════════════════ 逐日 for i, day in enumerate(hdays): # ───────────── 资金业务：存量集（F05：生效日 ≤ D < 到期日） st = [t for t in ft if t[0] <= day < t[1]] sia = [t for t in st if t[2] == "资产"] sil = [t for t in st if t[2] == "负债"] C.put("overview.asset_stock", i, _ri(sum(t[5] for t in sia))) C.put("overview.liab_stock", i, _ri(sum(t[5] for t in sil))) C.put("overview.net_stock", i, _ri(sum(t[5] for t in sia) - sum(t[5] for t in sil))) # ── 资金业务存量汇总（branches）：整段替换 ⇒ 只留页面真正读的字段 br = [] for sd, pool in (("资产", sia), ("负债", sil)): for l2 in lv2_order: g = [t for t in pool if t[3] == l2] a = _ag(g, day) if not a: continue br.append(dict(side=sd, lv2=l2, n=a["n"], principal=_ri(a["principal"]), cashflow=_ri(a["cashflow"]), rate=_r(a["rate"], 6), rate_amt_term=_r(a["rate_amt_term"], 6), wam=_r(a["wam"]))) C.put("branches", i, br) # ── 资金业务信息一览表 / 资产负债业务结构 / 总览四行明细（branches_all，恒 8 行含 0 值） pool_by_sheet = {} for cfg in _BA: pool_by_sheet[cfg["sheet"]] = [t for t in st if t[4] == cfg["sheet"]] for k, cfg in enumerate(_BA): a = _ag(pool_by_sheet[cfg["sheet"]], day) if not a: a = dict(n=0, principal=0.0, cashflow=0.0, interest=0.0, rate=None, rate_amt_term=None, rate_cov=None, wam=None, avg_term=None) for b in BUCKETS_R: a["b_" + b] = 0.0 a["n_" + b] = 0 base = "branches_all[%d]." % k for f in BA_F: v = a[f] if f == "n" or f.startswith("n_"): C.put(base + f, i, int(v)) elif f in ("rate", "rate_amt_term", "rate_cov"): C.put(base + f, i, _r(v, 6)) elif f == "wam" or f == "avg_term": C.put(base + f, i, _r(v)) else: C.put(base + f, i, _ri(v)) # 质押类 / 信用类二分（「业务 × 质押/信用矩阵」）。与 main() 的 row["cls"] 同源： # 同一个 fund_class_of()、同一套分母口径（_ag 与 agg 已逐字对齐；cls_raw 与 agg 的 # rate / rate_amt_term / wam 三处分母也逐字一致）。 # ⚠ 8×2×7 **每天都全写**，绝不「有数才写」：_C.out() 的初值是 None，漏写某天会让 # 该天留 None ⇒ _slPack 覆盖不全 ⇒ 历史日残留台账日数字（静默串数）。 # test_audit [I] I5 与 test_slice S3 是这两道锁。 for _cl in FUND_CLS: _raw = cls_raw([(t[5], t[8], t[7], days_between(day, t[1])) for t in pool_by_sheet[cfg["sheet"]] if fund_class_of(t[3], t[6]) == _cl]) _cb = base + "cls." + _cl + "." for f in FM_F: C.put(_cb + f, i, _raw[f]) # 累积起息量 ci / 累积到期量 cm（「业务区间变动情况」）。见循环前的长注： # 逐日写、不断点；恒等式 p ≡ ci − cm 在这里**就地**逐日断言（第二道锁在 main()）。 _rk = (cfg["sheet"], _cl) _c = _run.get(_rk) if _c is None: _c = _run[_rk] = [_ci0.get(_rk, 0.0), _cm0.get(_rk, 0.0)] _e = _iss.get(_rk) if _e is not None: _c[0] += _e.get(day, 0.0) _e = _mat.get(_rk) if _e is not None: _c[1] += _e.get(day, 0.0) C.put(_cb + "ci", i, int(round(_c[0]))) C.put(_cb + "cm", i, int(round(_c[1]))) if len(_wedge) < 5 and abs(_raw["p"] - (_c[0] - _c[1])) > 2: _wedge.append((_rk[0], _cl, day, _raw["p"], _c[0] - _c[1])) # 总览「资产类 / 负债类业务存量」卡内的四行明细（名称 + 存量 + WAM） for _side, _key in (("资产", "asset"), ("负债", "liab")): for k, cfg in enumerate([c for c in _BA if c["side"] == _side]): a = _ag(pool_by_sheet[cfg["sheet"]], day) or dict(n=0, principal=0.0, wam=None) b = "stock_break.%s[%d]." % (_key, k) C.put(b + "n", i, int(a["n"])) C.put(b + "principal", i, _ri(a["principal"])) C.put(b + "wam", i, _r(a.get("wam"))) # ── 到期区间分布（bucket_table，恒 2 行）：与 main() 同一组分档 for side, pool in (("资产", sia), ("负债", sil)): row = {} for bn in BK_ALL: xs = [t[5] for t in pool if bucket(days_between(day, t[1])) == bn] row[bn] = sum(xs) row[bn + "_n"] = len(xs) base = "bucket_table[%d]." % (0 if side == "资产" else 1) for bn in BK_ALL: C.put(base + bn, i, _ri(row[bn])) C.put(base + bn + "_n", i, row[bn + "_n"]) C.put(base + "total", i, _ri(sum(t[5] for t in pool))) C.put(base + "total_n", i, len(pool)) # ── 同业存款信用类 / 质押类（担保方式口径，与 main() 的 dep_split 同款） dep = [t for t in st if t[3] == "存款"] dp = [] for label, pred in ( ("信用类", lambda t: (not t[6]) or t[6] in ("否", "N", "n", "无", "信用")), ("质押类", lambda t: t[6] and t[6] not in ("否", "N", "n", "无", "信用"))): a = _ag([t for t in dep if pred(t)], day) if a: dp.append(dict(label=label, n=a["n"], principal=_ri(a["principal"]), rate=_r(a["rate"], 6), wam=_r(a["wam"]))) C.put("dep_split", i, dp) # ── 未到期窗口（自然周 / 自然月）：到期日严格晚于 D 且落在窗口内 wend, mend = _wends(day) lo = (datetime.date.fromisoformat(day) + datetime.timedelta(days=1)).isoformat() C.put("overview.undue.win_start", i, lo) C.put("overview.undue.week_end", i, wend) C.put("overview.undue.month_end", i, mend) for tag, end in (("week", wend), ("month", mend)): sp = days_between(day, end) for sd, kk, pool in (("资产", "asset", sia), ("负债", "liab", sil)): xs = [t for t in pool if 1 <= days_between(day, t[1]) <= sp] C.put("overview.undue.%s_%s" % (tag, kk), i, _ri(sum(t[5] for t in xs))) C.put("overview.undue.%s_%s_n" % (tag, kk), i, len(xs)) # 卡右侧「到期日 / 业务 / 到期量」明细：与 dueRows() 同一条聚合（到期日 × 业务）。 # 金额存**元**（整数），前端直接 yi() —— 若先折算成亿元再回乘会丢精度。 # ⚠ 键名按**窗口**分开（rows_week_* / rows_month_*）：V2.21 起「本周」与「本月」 # 两张卡都要能在切片日显示各自的明细。原实现不分窗口（month 覆盖 week）， # 历史日会让「本周未到期」卡错拿月度明细 —— 表头写"本周"、金额是本月， # 比不显示更糟（看起来有数其实是错的）。 for sd, kk in (("资产", "asset"), ("负债", "liab")): by = {} for t in st: if t[2] != sd or t[1] < lo or t[1] > end: continue by.setdefault(t[1], {}) by[t[1]][t[4]] = by[t[1]].get(t[4], 0.0) + t[5] rows = [] for m in sorted(by): # ⚠ F17：排序键必须**完全确定**。只按「业务固定顺序」排会有并列（都不在 # _ord 里时全为 99），并列时结果取决于 dict 插入顺序 —— 那是隐式依赖。 # 补一个 sheet 名做二级键，输出才在任意 PYTHONHASHSEED 下一致。 for sh in sorted(by[m], key=lambda s: ( _ord[sd].index(s) if s in _ord.get(sd, []) else 99, s)): rows.append("%s|%s|%d" % (m[5:], _disp.get(sh, sh), int(round(by[m][sh])))) C.put("overview.undue.rows_%s_%s" % (tag, kk), i, ";".join(rows)) # ── 债券：逐券在持仓（生效日 ≤ D < 有效到期日） mf_wan_i = mf_wan_s[i] mf_n_i = mf_n_s[i] mx = defaultdict(float) # (账户, 品种) → 持仓（万元） cell = {} # (账户, 品种) → 7 项加权和 dty = defaultdict(lambda: defaultdict(lambda: defaultdict(float))) accb = defaultdict(lambda: [0.0, 0.0]) # 账户 → [久期加权和, 权重和] accn = defaultdict(int) btot = 0.0 for _bk_key, _bal, acc, pt, rem0, _bmat, _cp_raw, _ytm_raw in bond_holds[i]: # wan = 当日余额（元 → 万元）。余额非零是 iter_bond_daily 的入集判据， # ⇒ 清仓后的日子自动不入集、券数不再虚增（N08）。 wan = _bal / W cp = _nrate(_cp_raw) ytm = _nrate(_ytm_raw) btot += wan mx[(acc, pt)] += wan accn[acc] += 1 c = cell.get((acc, pt)) if c is None: c = cell[(acc, pt)] = dict(wan=0.0, ytmW=0.0, ytmN=0.0, cpW=0.0, cpN=0.0, durW=0.0, durN=0.0, comboW=0.0, comboN=0.0) c["wan"] += wan y = None if rem0 is not None: # 剩余期限(D)：以台账日基准回推（见 docstring）。缺基准的券落「未知」档， # 不按到期日替它估 —— 台账日那侧同样是「未知」，两边必须一个口径。 y = rem0 + (Td - datetime.date.fromisoformat(day)).days / 365.0 accb[acc][0] += wan * y accb[acc][1] += wan c["durW"] += wan * y c["durN"] += wan # ⚠ 期限结构必须**无条件**入桶（y = None 时落「未知」）—— main() 是 # `dur_bucket(p.get("avg_remaining_years"))`，None 也照样计 30000 万。 # 只在 rem0 非空时才入桶，会让 ABS / 信用债从「未知」档整段消失。 dty[pt][acc][_dbk(y)] += wan if ytm is not None: c["ytmW"] += wan * ytm c["ytmN"] += wan if cp is not None: c["cpW"] += wan * cp c["cpN"] += wan if has_composite_income(pt) and ytm is not None and cp is not None: c["comboW"] += wan * (ytm + cp / 3.0) c["comboN"] += wan C.put("overview.book_total", i, _ri(btot * W)) C.put("overview.mf_total", i, _ri(mf_wan_i * W)) C.put("overview.invest_total", i, _ri(btot * W + mf_wan_i * W)) # ── 投资账户结构 / 账户持仓（accounts）：breakdown 逐日整段替换（变长键） for a in ACCS: bw = 0.0 for pt in PTYPE_ORDER: if pt != "货币基金": bw += mx.get((a, pt), 0.0) mfw = mf_wan_i if a == "TPL" else 0.0 d = accb[a] yw = yn = cw = cn = 0.0 for pt in PTYPE_ORDER: c = cell.get((a, pt)) if not c: continue yw += c["ytmW"] yn += c["ytmN"] cw += c["cpW"] cn += c["cpN"] base = "accounts.%s." % a C.put(base + "total_wan", i, _r(bw + mfw)) C.put(base + "bond_wan", i, _r(bw)) C.put(base + "mf_wan", i, _r(mfw)) C.put(base + "n_bond", i, accn.get(a, 0)) C.put(base + "n_mf", i, mf_n_i if a == "TPL" else 0) C.put(base + "bond_duration", i, _r(d[0] / d[1], 4) if d[1] else None) C.put(base + "bond_coupon", i, _r(cw / cn, 6) if cn else None) C.put(base + "bond_ytm", i, _r(yw / yn, 6) if yn else None) brk = {} for pt in PTYPE_ORDER: v = mfw if pt == "货币基金" else mx.get((a, pt), 0.0) if v > 0: brk[pt] = _r(v) C.put(base + "breakdown", i, brk) # ── 账户 × 品种矩阵：matrix（账户分项图用）+ matrix_cells（四视图矩阵用） mxd = {} for (a, pt), v in mx.items(): if v > 0: mxd.setdefault(a, {})[pt] = _r(v) C.put("matrix", i, mxd) C.put("matrix_mf.货币基金", i, _r(mf_wan_i)) for a in ACCS: for pt in PTYPE_ORDER: if pt == "货币基金": continue c = cell.get((a, pt)) base = "matrix_cells.%s|%s." % (a, pt) # ⚠ 字段顺序 = renderMatrix 的 _mxEmpty()：wan / ytmW / ytmN / comboW / # comboN / durW / durN。前端 renderMatrix 直接吃这七个数，不再自己聚合 # bond_master（那样在历史日会用台账日的持仓权重，是错的）。 C.put(base + "wan", i, _r(c["wan"]) if c else 0) C.put(base + "ytmW", i, _r(c["ytmW"], 6) if c else 0) C.put(base + "ytmN", i, _r(c["ytmN"]) if c else 0) C.put(base + "comboW", i, _r(c["comboW"], 6) if c else 0) C.put(base + "comboN", i, _r(c["comboN"]) if c else 0) C.put(base + "durW", i, _r(c["durW"], 4) if c else 0) C.put(base + "durN", i, _r(c["durN"]) if c else 0) # ── 债券期限结构（品种 × 账户 × 剩余期限区间） for pt in PTYPE_ORDER: if pt == "货币基金": continue for a in ACCS: for db in dur_order: C.put("dur_by_type.%s.%s.%s" % (pt, a, db), i, _r(dty[pt][a].get(db, 0.0))) # ── ⚠ 这里**刻意不产出 due_win**（到期窗口 4 档）────────────────────── # due_win 只被「到期日历」页读到（cal()），而那不是三个切片页之一 —— # 一旦切片也产出它，用户把时间轴拖到历史日再切到「到期日历」，就会看到 # 「四张 KPI 卡是历史日的、下面的日历明细是台账日的」这种半新半旧的页面。 # 宁可让该页整体保持台账日（它没有时间轴，语义上也确实不是切片页）。 # ⇒ 判据：切片只允许产出「三个切片页自己读」的键；发现跨页共用的键就把它摘出去。 # ── 基金存量表（行 = 基金管理人 × 列 = 购买渠道）：变长，整段替换 _ch_wan, _ch_set, _mg_wan, _mg_set, _cell = (defaultdict(float), defaultdict(set), defaultdict(float), defaultdict(set), defaultdict(float)) _held = 0 _held_keys = set() for m, s0 in _ms: if not s0 or s0 > day: continue if m["redeem"] and m["redeem"] <= day: continue _held += 1 ch = (m["note"] or "").strip() or "未标注" mg = (m["manager"] or "").strip() or "未标注" _k = (m["code"] or m["name"] or "").strip() or m["id"] _ch_wan[ch] += m["amount"] _ch_set[ch].add(_k) _mg_wan[mg] += m["amount"] _mg_set[mg].add(_k) _cell[(mg, ch)] += m["amount"] _held_keys.add(_k) _cho = sorted(_ch_wan, key=lambda x: (-_ch_wan[x], x)) _cho = [c for c in _cho if c != "直销"] + (["直销"] if "直销" in _ch_wan else []) _mgo = sorted(_mg_wan, key=lambda x: (-_mg_wan[x], x)) C.put("mf_matrix", i, dict( unit="万元", channel_label="购买渠道", row_label="基金管理人", channels=[dict(name=c, wan=_r(_ch_wan[c] / W), n=len(_ch_set[c])) for c in _cho], rows=[dict(manager=g, n=len(_mg_set[g]), wan=_r(_mg_wan[g] / W), cells=[_r(_cell[(g, c)] / W) for c in _cho]) for g in _mgo], total=dict(n=len(_held_keys), wan=_r(sum(_mg_wan.values()) / W)))) # ── 投资业务「业务区间变动情况」：买入/卖出/到期券面·笔数（累积序列，逐日写） # ⚠ 每天都全写（哪怕全 0）—— _C.out() 初值是 None，漏写某天会让该天留 None ⇒ # _slPack 覆盖不全 ⇒ 历史日残留台账日数字（静默串数）。与 ci/cm 同一道铁律。 for _p, _seq in _inv_cum.items(): C.put(_p, i, _seq[i]) # ── 区间口径的**就地**守卫（逐日）───────────────────────────────────────── # 为什么必须逐日：N08 的教训 —— 只比末点会「271/273 天错而全绿」。恒等式 # p ≡ ci − cm 是一条**逐日**成立的等式，任一天错都说明两条事件流与票池三者的 # 口径分了叉（现实里最容易发生在「初值少吸收了起点前的事件」）。 # 容差 2 元：p 经 cls_raw 取整到元、ci/cm 经 int(round) 取整到元，两端各 ±0.5 元， # 再留 1 元给浮点累加。相对量级（几百亿元）而言 2 元是零。 # 第二道锁是 main() 的「独立复核」——它从**已折叠的切片值**重新取一遍， # 覆盖本函数看不见的折叠/写出环节。 if _wedge: print("[区间口径对账] ✗ %d 处「存量 ≠ 累积起息 − 累积到期」（容差 2 元）：%s" % (len(_wedge), _wedge[0])) for _w in _wedge: print(" · %s/%s %s：存量 %.0f，ci−cm %.0f" % _w) else: print("[区间口径对账] ✓ %d 个「业务 × 质押/信用」逐日恒等 p ≡ ci − cm（%d 天）" % (len(_run), n)) keys, vals = C.out() return dict(start=hdays[0], end=T, n=n, unit="万元", keys=keys, vals=vals) # ══════════════════════════════════════════════════════════ 主流程 def main(): if not LEDGER_FILE: sys.exit("未找到台账 xlsm/xlsx") # F11：读台账时的 Excel 解析边界告警（公式无缓存 / 1904 日期系统 / 共享字符串缺失等）。 # 单独收集，q() 定义后再逐条进质量清单 —— 正常台账（1900 系统、公式全缓存）不触发。 _load_diag = [] wb = load_workbook(LEDGER_FILE, _load_diag) quality = [] # 录入量级审计观测：各读取点把「原始值 / 归一后值 / 是否已被既有检查点名」记进来， # 读完所有 Sheet 后由 audit_scale() 统一比中位数 —— 单点读不到「同 Sheet 其他行」， # 必须两遍走：先收集，再判定。 AUDIT = [] def q(level, cat, sheet, desc, detail="", at="", kind=None, fix=None, auto=None): """登记一条质量条目。kind/fix/auto 默认由 Q_META 按 cat 兜底 ⇒ 既有调用点一字不用改； at 是「出在哪一格」（行号 / 债券代码 / 明细 ID），页面据此把问题指名到行回给制表人。""" _k, _f, _a = Q_META.get(cat, ("", "", False)) quality.append(dict(level=level, cat=cat, sheet=sheet, desc=desc, detail=str(detail), # at 缺省「整表」：整 Sheet 级的问题（如缺汇总块）也要有个明确的 # 定位徽标，不能留空 —— 页面上空徽标看起来像渲染出错。 at=(str(at) if at else "整表"), kind=(_k if kind is None else kind), fix=(_f if fix is None else fix), auto=(_a if auto is None else auto))) # F11：Excel 解析边界告警进质量清单（公式无缓存 / 1904 日期系统 / 共享字符串缺失等）。 # 纯防御性 —— 正常台账（1900 系统、公式全缓存、有 sharedStrings）一条都不会触发。 for _dm in _load_diag: q("高", "Excel解析边界", "台账", _dm, at="整表") def _norm_rate(x, code, name, sheet, field="到期收益率"): """利率类字段统一归一到小数（0.0192 = 1.92%），并留痕、记观测。 ⚠ 债券的「票面利率 / 到期收益率」与资金业务的「利率」是同一类人工录入字段，必须走同一套归一与守卫 —— 曾只给 ytm 归一、coupon 裸读，于是「票面利率」列忘输 % 会直接污染加权票面利率且**悄无声息**（无任何质量条目）。 ⚠ 提前到 main() 开头定义（原在 bond_master 循环内）：bonds 交易明细的 ytm/coupon 也要走同一套归一（N21 —— 交易展开里 1.92 曾显示成 192%、17550 显示成 17550%）。""" at = "%s %s" % (code, name) if x is None: return None if x <= 0.2: AUDIT.append(dict(sheet=sheet, field=field, at=at, who=name, raw=x, norm=x, flagged=False)) return x if 0 < x / 100 <= 0.2: q("中", "收益率格式异常", sheet, "%s以百分数录入（如 %.2f 实为 %.2f%%），已按 ÷100 归一化" % (field, x, x), "", at=at) AUDIT.append(dict(sheet=sheet, field=field, at=at, who=name, raw=x, norm=x / 100, flagged=True)) return x / 100 q("高", "收益率异常", sheet, "%s超出合理区间，未纳入加权" % field, "值=%s" % x, at=at) AUDIT.append(dict(sheet=sheet, field=field, at=at, who=name, raw=x, norm=None, flagged=True)) return None T = None for r in sorted(wb.get("台账日期", {})): for c in sorted(wb["台账日期"][r]): d = isodate(wb["台账日期"][r][c]) if d: T = d if not T: sys.exit("无法从「台账日期」Sheet 读取 T 日") Td = D(*map(int, T.split("-"))) # ────────────────────────────────── 资金业务 fund = [] for cfg in FUND_SHEETS: grid = wb.get(cfg["sheet"]) if not grid: q("严重", "缺失Sheet", cfg["sheet"], "台账中不存在该 Sheet") continue hr = find_header(grid) h = hdr_map(grid, hr) for r in sorted(grid): if r <= hr or not any(str(v).strip() for v in grid[r].values()): continue g = lambda k: cell(grid, r, pick(h, cfg["a"].get(k, []))) principal = num(g("本金")) mat = isodate(g("到期日")) if principal is None and not mat: continue counterparty = str(g("对手") or "").strip() if principal is None or principal <= 0: q("高", "本金异常", cfg["sheet"], "本金无法识别或非正数，已排除", "对手=%s 本金=%r" % (counterparty, g("本金")), at="第%d行" % r) continue if not mat: q("高", "到期日缺失", cfg["sheet"], "缺到期日，无法纳入到期与现金流分析", "对手=%s 本金=%s" % (counterparty, principal), at="第%d行" % r) continue start = isodate(g("起息日")) or isodate(g("交易日")) trade = isodate(g("交易日")) or start start_assumed = not isodate(g("起息日")) if start and mat < start: q("高", "日期倒挂", cfg["sheet"], "到期日早于起息日", "%s < %s" % (mat, start), at="第%d行" % r) continue rate = num(g("利率")) if rate is not None and rate > 0.2 and 0 < rate / 100 <= 0.2: # 台账同列混用小数(0.016)与百分数(1.41)两种录入习惯 → 统一归一到小数 q("中", "利率格式异常", cfg["sheet"], "利率以百分数录入（如 1.41 实为 1.41%），已按 ÷100 归一化", "原始=%s → %.4f 对手=%s" % (g("利率"), rate / 100, counterparty), at="第%d行" % r) AUDIT.append(dict(sheet=cfg["sheet"], field="利率", at="第%d行" % r, who=counterparty, raw=rate, norm=rate / 100, flagged=True)) rate = rate / 100 elif rate is not None and (rate <= 0 or rate > 0.2): q("中", "利率异常", cfg["sheet"], "利率超出 0~20% 合理区间，未纳入加权利率", "利率=%s 对手=%s" % (g("利率"), counterparty), at="第%d行" % r) AUDIT.append(dict(sheet=cfg["sheet"], field="利率", at="第%d行" % r, who=counterparty, raw=rate, norm=None, flagged=True)) rate = None elif rate is not None: # 值落在合法区间 ⇒ 既有检查不会碰它。但"看着合法"不等于"没写错"： # 忘输 % 时若基数小（如 1.3‰ 写成 0.13），值仍是 0.13 < 0.2 而蒙混过关。 # 记录观测交给 audit_scale 用中位数比出量级离群。 AUDIT.append(dict(sheet=cfg["sheet"], field="利率", at="第%d行" % r, who=counterparty, raw=rate, norm=rate, flagged=False)) term = num(g("期限")) if term is None and start: term = days_between(start, mat) remaining = days_between(T, mat) interest = num(g("利息")) cashflow = num(g("现金流")) or (principal + (interest or 0)) # ── 到期日顺延至工作日（勾选框「向后顺沿至工作日」的数据口径，V2.50）── # 到期日落在法定节假日/休息日 ⇒ 顺延到下一工作日，计息天数相应增多、利息重算。 # ⚠ 重算用**比例法**而非本金×利率×天数：不同业务计息基数不同（拆借/存款 act/360、 # 回购 act/365 …），台账「利息」列是权威值。比例法 = 原始利息 × (原始天数+顺延天数)/原始天数， # 既尊重台账利息、又无需臆断计息基数。原始天数 = term（期限列）或 start→mat。 mat_shift = next_workday(mat) shift_days = days_between(mat, mat_shift) interest_shift = interest if shift_days > 0 and interest is not None: base_days = term if term else (days_between(start, mat) if start else None) if base_days and base_days > 0: interest_shift = round(interest * (base_days + shift_days) / base_days, 2) cashflow_shift = (principal + interest_shift) if interest_shift is not None else cashflow collateral = str(g("质押") or "").strip() # 质押/信用分类的输入（下方 dict 与 cls 共用同一次取值） fund.append(dict( # 🔴 xl_row = 该笔在**台账 Sheet 里的物理行号**（Excel 行号，不是 ETL 的序号）。 # id=F1389 这类是 ETL 按输出行序自造的，台账里搜不到；只有 xl_row 能定位。 xl_row=r, id="F%04d" % (len(fund) + 1), sheet=cfg["sheet"], side=cfg["side"], lv1="资金业务", lv2=cfg["lv2"], account="不适用", counterparty=counterparty, code=str(g("代码") or "").strip(), name=str(g("名称") or "").strip(), trade_date=trade, start_date=start, maturity=mat, principal=principal, rate=rate, term=term, remaining=remaining, interest=interest, cashflow=cashflow, # 顺延口径（V2.50）：勾选「向后顺沿至工作日」时前端改用这两列 mat_shift=mat_shift, interest_shift=interest_shift, cashflow_shift=cashflow_shift, # 存量口径：生效日 ≤ T < 到期日才算存量（F05）。起息日缺失时已按交易日回退 # （见上方 start 赋值）；缺生效日则 start=None ⇒ 不入存量。T 当日到期的业务于当日 # 结清、不再计入存量（仍保留在到期日历 / 现金流 / 逐笔明细中，见 live 集合）。 stock=(start is not None and start <= T) and remaining > 0, bucket=bucket(remaining), trader=str(g("交易员") or "").strip(), note=str(g("备注") or "").strip(), collateral=collateral, broker=str(g("经纪") or "").strip(), pay_freq=str(g("付息频率") or "").strip(), investor=str(g("投资方") or "").strip(), start_assumed=start_assumed, # 质押类 / 信用类随行下发（fund_class_of 是这条规则的**唯一实现点**，前端零口径）： # 「业务 × 质押/信用矩阵」的单元格/列合计下钻、「同业存款信用/质押」环图扇区下钻 # 都拿它筛逐笔 —— 面板合计必须与被点的那个数字同源（capabilities: fund_cls）。 cls=fund_class_of(cfg["lv2"], collateral))) # ────────────────────────────────── 货币基金 mf = [] grid = wb.get("货币基金") if grid: hr = find_header(grid) h = hdr_map(grid, hr) a = dict(名称=["基金简称"], 代码=["基金代码"], 管理人=["基金管理人"], 本金=["交易金额(元)"], 申购日=["申购日期"], 起息日=["起息日"], 赎回日=["赎回日"], 到账日=["到账日"], 备注=["备注"], 资金来源=["资金来源"]) for r in sorted(grid): if r <= hr: continue g = lambda k: cell(grid, r, pick(h, a.get(k, []))) amt = num(g("本金")) if amt is None or amt <= 0: if any(str(v).strip() for v in grid[r].values()): q("中", "非交易行", "货币基金", "无法识别的行，已跳过", at="第%d行" % r) continue redeem, arrive = isodate(g("赎回日")), isodate(g("到账日")) mat = arrive or redeem # N19：当前持有状态必须与历史/切片同一套 as-of 规则 —— 入库日（申购日，缺则起息日） # 已到账（≤ T）且尚未赎回（无赎回日，或赎回日在 T 之后）。旧写法 `redeem is None` # 把「未来申购/未来起息」错算为已持有、把「T 之后才赎回」的提前踢出，两套规则分叉。 _in = (isodate(g("申购日")) or isodate(g("起息日"))) held = (_in is not None and _in <= T) and (redeem is None or redeem > T) remaining = days_between(T, mat) if mat else None mf.append(dict(id="M%04d" % (len(mf) + 1), xl_row=r, name=str(g("名称") or "").strip(), code=str(g("代码") or "").strip(), manager=str(g("管理人") or "").strip(), amount=amt, buy=isodate(g("申购日")), start=isodate(g("起息日")), redeem=redeem, arrive=arrive, maturity=mat, remaining=remaining, held=held, bucket="随时可赎" if held else bucket(remaining), source=str(g("资金来源") or "").strip(), note=str(g("备注") or "").strip())) if held and not isodate(g("申购日")): q("中", "申购日缺失", "货币基金", "持有中但缺申购日", at="%s %s" % (g("基金代码"), g("基金简称"))) # ────────────────────────────────── 债券交易 + 底部持仓汇总块 bonds, book_pos, no_block = [], [], [] # 债券行号侧表：(净代码, 账户) → 该券在台账交易区出现过的**物理行号**列表。 # 为什么用侧表而不是往 bonds 每条里加字段：bonds 有 575 条、且整份要进云库载荷， # 而定位只需要「每只券一行」。侧表只在构建 bond_master 时被读一次。 BROW = defaultdict(list) block_sum = {} # Sheet → 持仓汇总块「合计」（万元），供逐笔持仓勾稽（预测盈利） block_total = {} # Sheet → 汇总块「合计」行金额（万元）；为 None 表示该块无合计行 block_hdr = {} # Sheet → 汇总块表头所在行，供读取新增的估值列 for cfg in BOND_TRADE: sheet = cfg["sheet"] grid = wb.get(sheet) if not grid: q("严重", "缺失Sheet", sheet, "台账中不存在该 Sheet") continue hr = find_header(grid) h = hdr_map(grid, hr) block_row = None for r in sorted(grid): if r <= hr: continue vals = {nh(v) for v in grid[r].values()} if "债券名称" in vals and "债券代码" in vals: block_row = r break # ---- 交易区 for r in sorted(grid): if r <= hr or (block_row and r >= block_row): continue if not any(str(v).strip() for v in grid[r].values()): continue g = lambda k: cell(grid, r, pick(h, BOND_A.get(k, []))) face, code = num(g("面额")), str(g("代码") or "").strip() direction = str(g("方向") or "").strip() if face is None or not code or direction not in STDDIR: vals = {str(v).strip() for v in grid[r].values()} note = " | ".join(sorted(v for v in vals if v))[:160] q("低", "非交易行", sheet, "交易区中无法识别为交易的行，已跳过", note, at="第%d行" % r) continue ptype_raw = str(g("性质") or "").strip() ptype = cfg["ptype"] or infer_type(ptype_raw, g("名称"), code) trade = isodate(g("交易日")) if not trade: q("中", "交易日缺失", sheet, "有面额但缺交易日", "代码=%s" % code, at="第%d行" % r) # 债券「入库生效日」= 台账「结算日」列（K 列），**不是交易日**： # 银行间债券 T+1/T+2 交收，交易日只是成交，券要到结算日才真正入库。 # 存量口径与资金业务完全一致（F05：生效日 ≤ T < 到期日）—— # 结算日 > T 的成交按「未入库」处理，不计入持仓 / 历史存量 / 理论持仓。 # 缺结算日则回退交易日（并报质量条目，让制单人补 K 列）。 settle = isodate(g("结算日")) if not settle: q("中", "结算日缺失", sheet, "缺「结算日」—— 债券入库生效日缺失，已按交易日回退", "代码=%s 交易日=%s" % (code, trade), at="第%d行" % r) start = settle or trade # 提前兑付：备注标注了结清日 ⇒ 该券的实际退出日比「债券到期日」列早。 # `mat_eff`（有效到期日）= 结清日与法定到期日取早；只用于**持仓/历史序列的存续区间**， # `bond_maturity` 仍原样保留台账填的法定到期日（期限结构、到期日历等不受影响）。 _pay = early_payoff(g("备注")) _mat = isodate(g("债券到期")) mat_eff = _pay if (_pay and (not _mat or _pay < _mat)) else _mat BROW[(strip_code(code), cfg["account"])].append(r) bonds.append(dict( # 🔴 xl_row = 该笔成交在**台账交易区里的物理行号**（Excel 行号）。 # 「逐笔明细」浮层靠它把「某券持仓 N 亿」拆成「这 N 笔买入/卖出」后逐笔对回台账； # 没有它，用户只能拿日期 + 金额去台账里猜行。注意与 id（B0001，ETL 自造）无关。 xl_row=r, id="B%04d" % (len(bonds) + 1), sheet=sheet, account=cfg["account"], ptype=ptype, nature=ptype_raw, code=code, name=str(g("名称") or "").strip(), direction=direction, side="买入" if STDDIR[direction] > 0 else "卖出", face_wan=face, face=face * WAN, remain_wan=num(g("剩余")), net=num(g("净价")), gross=num(g("全价")), trade_date=trade, settle=settle, settle_amt=num(g("结算金额")), start=start, settled=(start is not None and start <= T), payoff=_pay, mat_eff=mat_eff, # N21：bonds 的收益率/票面利率也走 _norm_rate 归一 + 异常拒用（原裸读 num()， # 交易展开里 1.92 曾显示 192%、17550 显示 17550%）。 ytm=_norm_rate(num(g("收益率")), code, str(g("名称") or "").strip(), sheet, "到期收益率"), coupon=_norm_rate(num(g("票面利率")), code, str(g("名称") or "").strip(), sheet, "票面利率"), bond_start=isodate(g("债券起息")), bond_maturity=isodate(g("债券到期")), trader=str(g("交易员") or "").strip(), note=str(g("备注") or "").strip(), trustee=str(g("委托") or "").strip(), rating=str(g("评级") or "").strip(), originator=str(g("原始权益人") or "").strip(), guarantor=str(g("担保人") or "").strip(), isShort=str(g("是否短债") or "").strip(), isLong=str(g("是否超长债") or "").strip())) # ---- 持仓汇总块（用块自己的表头） if block_row: bh = hdr_map(grid, block_row) block_hdr[sheet] = block_row c_name, c_code = pick(bh, ["债券名称"]), pick(bh, ["债券代码"]) c_amt, c_mat = pick(bh, BLOCK_AMT), pick(bh, ["债券到期日", "存单到期日"]) c_rem, c_nat = pick(bh, ["剩余期限(年)"]), pick(bh, ["债券性质"]) blk_total, blk_sum, blk_n = None, 0.0, 0 for r in sorted(grid): if r <= block_row: continue nm2 = str(cell(grid, r, c_name) or "").strip() cd2 = str(cell(grid, r, c_code) or "").strip() if is_total(nm2): blk_total = to_wan(num(cell(grid, r, c_amt))) break if not cd2 or cd2 in ("-", "—", "/"): continue raw = num(cell(grid, r, c_amt)) if raw is None: q("中", "持仓汇总缺金额", sheet, "汇总块明细缺剩余量", at="%s %s" % (cd2, nm2)) continue amt = to_wan(raw) book_pos.append(dict(sheet=sheet, account=cfg["account"], code=cd2, name=nm2, nature=str(cell(grid, r, c_nat) or "").strip(), ptype=cfg["ptype"] or infer_type(cell(grid, r, c_nat), nm2, cd2), wan=amt, bond_maturity=isodate(cell(grid, r, c_mat)), avg_remaining_years=num(cell(grid, r, c_rem)))) blk_sum += amt blk_n += 1 if blk_total is not None and abs(blk_total - blk_sum) > 0.5: q("中", "汇总勾稽不符", sheet, "汇总块「合计」行与明细求和不一致", "合计 %.2f 万 / 明细求和 %.2f 万" % (blk_total, blk_sum), at="汇总块「合计」行") block_sum[sheet] = blk_sum block_total[sheet] = blk_total print(" ≥ %-18s 持仓块 %3d 只 %12.2f 万" % (sheet, blk_n, blk_sum)) else: no_block.append(sheet) # ⚠ 质量条目**不在这里发** —— 要等 loop 结束后把流水的推算结果并进 book_pos # 再报（F06）：它现在**会改变投资规模与核对项**，级别与文案都要跟着变。 # ── F06：无持仓汇总块 ⇒ 按交易流水推算持仓**并回写主链** ──────────────── # 原实现只把推算结果落进辅助键 `flow_wan`，从未回写 `book_pos` ⇒ 该 Sheet 的持仓 # 在「投资规模 / 债券主数据 / 期限结构 / 库存核对」里全部漏掉。现改为并入。 if no_block: _derived = derive_book_pos(bonds, set(no_block), T) if _derived: book_pos.extend(_derived) for _sh in no_block: _rows = [x for x in _derived if x["sheet"] == _sh] q("中", "无持仓汇总块", _sh, "Sheet 底部无「持仓汇总块」，持仓已按交易流水推算（按结算日入库、扣除已到期部分）" "并**计入投资规模**", "%d 只 / 合计 %.2f 万" % (len(_rows), sum(x["wan"] for x in _rows)), at="Sheet「%s」底部" % _sh) # 净空头 / 当日平仓是真实状态（不静默丢弃），但必须逐券知会 —— 它多半意味着 # 交易区漏记了一笔买入，而负持仓会让「投资规模」偏小。 for _x in _derived: if _x["wan"] < 0: q("中", "推算持仓为净空头", _x["sheet"], "该券按流水推算为**负**持仓（卖出多于买入），已按负值并入投资规模；" "请核对交易区是否漏记买入", "代码=%s（%s）%.2f 万" % (_x["code"], _x["account"], _x["wan"]), at="%s %s" % (_x["code"], _x["name"])) # ── 未入库交易（结算日 > 台账日）────────────────────────────────────── # T+1/T+2 交收下的当日成交，券要到结算日才真正入库 ⇒ 按 F05 口径不入存量。 # 这类行在交易区「看得见」、在持仓/历史存量里「看不见」，是使用者第一个会问的问题， # 所以必须显式知会；但它是正常交收行为、不是错误，故**聚合成 1 条「低」级**（逐笔报＝噪音）。 _unsettled = [b for b in bonds if b.get("start") and b["start"] > T] if _unsettled: q("低", "未入库交易", "债券交易", "本期 %d 笔成交的结算日晚于台账日，按「入库生效日 ≤ 台账日」口径未计入存量与历史序列" % len(_unsettled), "；".join("%s（%s）%s %.2f 万，交易日 %s → 结算日 %s" % (b["code"], b["account"], b["side"], b["face_wan"], b.get("trade_date"), b["start"]) for b in sorted(_unsettled, key=lambda x: -x["face_wan"])[:10]), at="交易区「结算日」列") # ── 备注标注「已结清」的券 ──────────────────────────────────────────── # 制表人用备注登记提前兑付 —— 系统认了并已提前归零，但**这份信息不该只活在自由文本里**： # 逐券知会一次，并建议把「债券到期日」列一并改掉（否则下次改台账的人还是会看错）。 for _b in [x for x in bonds if x.get("payoff")]: _gap = ("；「债券到期日」列仍为 %s，与该结清日不一致，建议一并改为结清日" % _b["bond_maturity"]) if (_b.get("bond_maturity") and _b["bond_maturity"] > _b["payoff"]) else "" q("低", "备注标注已结清", _b["sheet"], "该券备注标注提前结清，已按结清日 %s 提前归零（不按法定到期日计算）%s" % (_b["payoff"], _gap), "代码=%s（%s）%s" % (_b["code"], _b["account"], _b["note"]), at="交易区「备注」列") # ────────────────────────────────── 实际库存（现券库存） # 该 Sheet 右侧常被维护者加一列「当日净价」= 中债估值净价（逐券 × 账户）—— # 本项目把它当作预测盈利的估值来源 ③（与汇总块新增列 / 独立估值 Sheet 并列）。 inv, inv_declared_total = [], None inv_val, inv_val_orphan = {}, [] # 风险测算（页 8）：逐券敏感度字段（现券库存尾部的中债估值套件），与 inv 同一个解析循环 risk_lots, risk_missing = [], [] grid = wb.get("现券库存") if grid: hr = find_header(grid) h = hdr_map(grid, hr) c_vn = pick(h, INV_A["净价"]) seen_inv = Counter() for r in sorted(grid): if r <= hr: continue g = lambda k: cell(grid, r, pick(h, INV_A.get(k, []))) face, code = num(g("面额")), str(g("代码") or "").strip() acc_raw, nm_raw = str(g("账户") or "").strip(), str(g("名称") or "").strip() if is_total(nm_raw) or (not acc_raw and face is not None): inv_declared_total = face continue if face is None or not code: if any(str(v).strip() for v in grid[r].values()): # 「净价列比债券清单长」是多填/拖拽的常见结果（无代码的裸数值行）： # 这些行对计算无用，聚合成 1 条提示，避免淹没有效的质量告警。 if not code and num(cell(grid, r, c_vn)) is not None: inv_val_orphan.append(r) else: q("中", "非交易行", "现券库存", "无法识别的行，已跳过", at="第%d行" % r) continue if not str(g("到期日") or "").strip(): q("中", "到期日缺失", "现券库存", "库存记录缺到期日", at="%s %s" % (code, nm_raw)) if not acc_raw: q("中", "账户缺失", "现券库存", "库存记录缺账户", at="%s %s" % (code, nm_raw)) vn = num(cell(grid, r, c_vn)) if vn is not None: if vn > 0: inv_val[(strip_code(code), acc_of(acc_raw))] = vn else: q("中", "估值净价异常", "现券库存", "「当日净价」<= 0，按估值缺失处理（不按 0 计入）", "值=%s" % vn, at="%s（%s）" % (code, acc_raw)) inv.append(dict(account=acc_raw, acc=acc_of(acc_raw), btype=str(g("类型") or "").strip(), name=nm_raw, code=code, nature=str(g("性质") or "").strip(), face_wan=face, face=face * WAN, maturity=isodate(g("到期日")), pledge=str(g("质押") or "").strip(), avail=num(g("可用")), short=str(g("短债") or "").strip(), long=str(g("超长") or "").strip(), note=str(g("备注") or "").strip())) # ── 风险测算（页 8）：逐券敏感度字段 ──────────────────────────────── # 市值(万) = 中债估值（日间全价）÷100 × 券面总额(万) # DV01(万/bp) = 基点价值 ÷100 × 券面总额(万) ← 与台账该列逐位可对照； # 缺基点价值时回退市值 × 修正久期 × 1e-4（两者实测严格等价） # 自勾稽恒等式 = 基点价值 ≟ 全价 × 修正久期 × 1e-4 # ⚠ 容差必须按「每 100 元面值」比：台账基点价值列只留 4 位小数，极短久期券 # （如 190016.IB=0.0019）相对误差可达 2.3%，按总额比会给正常券发假警。 _full, _mod = num(g("全价")), num(g("久期修正")) _bpv, _cvx = num(g("基点价值")), num(g("凸性")) # N56：全价必须「有限且 > 0」才算有效估值。0 / 负数 / inf / nan 一律按「估值缺失」 # 处理（_full 置 None），不让它们进入市值与盈余集合——否则会把「数据没到/录错」 # 算成一个确定的巨亏。与「当日净价」入口（上面 vn<=0 按缺失）保持同一约束。 if _full is not None and (not math.isfinite(_full) or _full <= 0): q("中", "估值全价异常", "现券库存", "「当日全价」<= 0 或非有限值，按估值缺失处理（不按 0/负价计入市值与盈余）", "值=%s" % _full, at="%s（%s）" % (code, acc_raw)) _full = None _mv = (_full / 100.0 * face) if (_full is not None and face is not None) else None if _bpv is not None and face is not None: _dv01, _src = _bpv / 100.0 * face, "bpv" elif _mv is not None and _mod is not None: _dv01, _src = _mv * _mod * 1e-4, "derived" else: _dv01, _src = None, "" rk = dict(sheet="现券库存", code=code, name=nm_raw, account=acc_raw, acc=acc_of(acc_raw), btype=str(g("类型") or "").strip(), face_wan=face, net_px=num(g("净价")), full_px=_full, ytm_pct=num(g("收益率")), coupon_pct=num(g("票面")), dur_rem=num(g("久期剩余")), dur_mod=_mod, bpv=_bpv, cvx=_cvx, mv_wan=_mv, dv01_wan=_dv01, dv01_src=_src) _lack = [n for n, v in (("全价", _full), ("修正久期", _mod), ("基点价值", _bpv), ("凸性", _cvx)) if v is None] if _lack: risk_missing.append(rk) q("中", "久期凸性缺失", "现券库存", "该券缺中债估值久期套件 —— 风险测算里它的市值/DV01/损益按「—」处理，不估算", "缺：%s" % "、".join(_lack), at="%s（%s）" % (code, acc_raw or "账户缺失")) elif _bpv: _calc = _full * _mod * 1e-4 if abs(_bpv - _calc) > max(5e-5, abs(_bpv) * 0.02): q("中", "DV01勾稽不符", "现券库存", "「基点价值」与「全价×修正久期×1bp」对不上 —— 请复核这两列哪一列取错", "基点价值=%.6f / 由久期算得=%.6f（差 %.1f%%）" % (_bpv, _calc, (_calc - _bpv) / _bpv * 100), at="%s（%s）" % (code, acc_raw or "账户缺失")) risk_lots.append(rk) seen_inv[(strip_code(code), acc_of(acc_raw))] += 1 if inv_val_orphan: q("低", "估值列多余行", "现券库存", "「当日净价」列存在无对应债券代码的数值行（多填/拖拽所致），已忽略，不影响估值计算", "共 %d 行" % len(inv_val_orphan), at="第 %d ~ %d 行" % (min(inv_val_orphan), max(inv_val_orphan))) for k, v in seen_inv.items(): if v > 1: q("中", "库存重复行", "现券库存", "%s（%s）出现 %d 行，已合并累计" % (k[0], k[1], v), at="%s（%s）" % (k[0], k[1])) # ────────────────────────────────── 风险测算汇总（页 8） # 逐券在上面已抽好，这里只做**账户级聚合**：久期 / 凸性 / 剩余久期一律按「全价市值」加权。 # 等权会把 9.4 亿的券和 1 千万的券看得一样重，账户久期会严重失真。 # 覆盖口径：现券库存只登记「国债 / 地方债」；台账里归 AC 的信用债 / ABS 不在这张表里 # （那两张 Sheet 只有「剩余金额」，没有中债估值久期套件）⇒ 必须披露覆盖率，不假装全覆盖。 risk_by, _rank = {}, [] def _rb(a): if a not in risk_by: risk_by[a] = dict(acc=a, n=0, n_risk=0, face_wan=0.0, mv_wan=0.0, dv01_wan=0.0, dur_rem_w=None, dur_mod_w=None, cvx_w=None, _mr=0.0, _mc=0.0, _cv=0.0, _w=0.0, _w_cv=0.0) _rank.append(a) return risk_by[a] for rk in sorted(risk_lots, key=lambda x: (x["acc"] or "", x["code"] or "", x["name"] or "")): b = _rb(rk["acc"] or "未标注") b["n"] += 1 b["face_wan"] += rk["face_wan"] or 0.0 if rk["mv_wan"] is None: continue b["mv_wan"] += rk["mv_wan"] if rk["dv01_wan"] is not None: b["dv01_wan"] += rk["dv01_wan"] b["n_risk"] += 1 if rk["dur_mod"] is not None: b["_w"] += rk["mv_wan"] b["_mc"] += rk["mv_wan"] * rk["dur_mod"] if rk["dur_rem"] is not None: b["_mr"] += rk["mv_wan"] * rk["dur_rem"] # N10：凸性累计**独立于** dur_mod —— 有凸性就计入凸性集合，不能因「缺修正久期」而 # 把凸性也丢掉（报告：清空修正久期时，披露 137 只、实际加权 136 只的分叉就源于此）。 if rk["cvx"] is not None: b["_cv"] += rk["mv_wan"] * rk["cvx"] b["_w_cv"] += rk["mv_wan"] for _a in _rank: _b = risk_by[_a] # N10：cvx_w 赋值**独立于** dur_mod 集合 —— 只要「有凸性券市值」非零就算， # 不能因「全部缺修正久期」而把已知凸性也一并丢弃（_w_cv 与 _w 是两个独立集合）。 if _b["_w"]: _b["dur_mod_w"] = _b["_mc"] / _b["_w"] if _b["_mr"]: _b["dur_rem_w"] = _b["_mr"] / _b["_w"] _b["cvx_w"] = (_b["_cv"] / _b["_w_cv"]) if _b["_w_cv"] else None _tot = {k: 0.0 for k in ("n", "n_risk", "face_wan", "mv_wan", "dv01_wan", "_mr", "_mc", "_cv", "_w", "_w_cv")} for _a in _rank: for _k in _tot: _tot[_k] += risk_by[_a][_k] _tot["acc"] = "合计" _tot["dur_rem_w"] = _tot["dur_mod_w"] = _tot["cvx_w"] = None if _tot["_w"]: _tot["dur_mod_w"] = _tot["_mc"] / _tot["_w"] if _tot["_mr"]: _tot["dur_rem_w"] = _tot["_mr"] / _tot["_w"] _tot["cvx_w"] = (_tot["_cv"] / _tot["_w_cv"]) if _tot["_w_cv"] else None # 未纳入现券库存的债券（台账有持仓、但没有中债久期套件）→ 逐品种披露，是覆盖率的分母 _INV_PT, un = ("国债", "地方债"), {} for _bp in book_pos: if (_bp.get("ptype") or "") in _INV_PT: continue # 国债/地方债由现券库存覆盖；逐券差异属库存核对页的职责 _pk = _bp.get("ptype") or _bp.get("sheet") or "其它" _u = un.setdefault(_pk, dict(ptype=_pk, sheet=_bp.get("sheet") or "", account=_bp.get("account") or "", n=0, wan=0.0)) _u["n"] += 1 _u["wan"] += _bp.get("wan") or 0.0 un = [un[_k] for _k in sorted(un)] _cover = sum(x["face_wan"] or 0.0 for x in risk_lots) _un = sum(x["wan"] for x in un) # N51：估值套件「待补」判断 —— 反算全价/净价已有值（T 日反算已到），但收益率/修正久期/ # 基点价值/凸性这组 Wind 中债估值套件全为 0 时，判为「套件待补」（业务方确认 Wind 需 # 次日补齐）。绝不能把所有 0 一律当缺失（真实零要保留），故判据收窄为「反算价有值 + # 套件四项全 0」——137 只券久期/凸性/收益率不可能同时都是真实零。 def _suite_pending(x): # N56/N51：价格必须「有限且 > 0」才算就绪；负价/0 价/非有限都视为未就绪。 px_ok = ((x.get("full_px") is not None and math.isfinite(x.get("full_px")) and x.get("full_px") > 0) or (x.get("net_px") is not None and math.isfinite(x.get("net_px")) and x.get("net_px") > 0)) suite_zero = (x.get("ytm_pct") == 0 and x.get("dur_mod") == 0 and x.get("bpv") == 0 and x.get("cvx") == 0) return bool(px_ok and suite_zero) _pending_n = sum(1 for x in risk_lots if _suite_pending(x)) # N51 残留收口：把「待补券」与「有效参数券」分开计数，给出「就绪覆盖金额」。 # 待补券的 DV01/久期/凸性是 0 占位，不得混进「有效覆盖」（n_risk），否则会误读成 # 「137 只全覆盖、零风险」。有效集合 = 非待补、且 DV01 真实可算的券。 _ready = [x for x in risk_lots if not _suite_pending(x)] _ready_dv01 = [x for x in _ready if x["dv01_wan"] is not None] risk = dict( lots=risk_lots, by_acc=[dict((k, v) for k, v in risk_by[_a].items() if not k.startswith("_")) for _a in _rank] + [dict((k, v) for k, v in _tot.items() if not k.startswith("_"))], meta=dict(t_date=T, n_lots=len(risk_lots), # n_risk = 有效 DV01 覆盖的券数（排除待补占位 0），不再把「待补」当「有效」。 n_risk=len(_ready_dv01), n_missing=len(risk_missing), # N51：估值套件待补标记（供前端禁用压力测试/黄点并标「待补」，而非误读零风险）。 pending=_pending_n > 0, pending_n=_pending_n, # N51 残留收口：就绪覆盖金额 —— 待补券面值/市值单独披露，与有效集合分开。 # 前端据此区分「有效参数覆盖」与「待补占位」，而非只看 n_risk 一个数。 ready_n=len(_ready), ready_dv01_n=len(_ready_dv01), ready_face_wan=sum(x["face_wan"] or 0.0 for x in _ready), ready_mv_wan=sum(x["mv_wan"] or 0.0 for x in _ready), pending_face_wan=sum(x["face_wan"] or 0.0 for x in risk_lots if _suite_pending(x)), pending_mv_wan=sum(x["mv_wan"] or 0.0 for x in risk_lots if _suite_pending(x)), # N10：凸性有效集合独立披露 —— 凸性缺失的券不计入凸性加权，但仍是 DV01/久期的一部分。 # cvx_n 与 _w_cv 同口径（有凸性且市值非空），避免「披露 137 / 加权 136」的分叉。 cvx_n=sum(1 for x in risk_lots if x["cvx"] is not None and x["mv_wan"] is not None), cvx_mv_wan=sum(x["mv_wan"] or 0.0 for x in risk_lots if x["cvx"] is not None), cover_face_wan=_cover, cover_mv_wan=sum(x["mv_wan"] or 0.0 for x in risk_lots), uncovered_face_wan=_un, uncovered=un, cover_pct=(_cover / (_cover + _un)) if (_cover + _un) else None, inv_declared_wan=inv_declared_total, missing=[dict(code=x["code"], name=x["name"], account=x["account"], face_wan=x["face_wan"]) for x in risk_missing]), ) # ────────────────────────────────── 第三方库存（同业系统） # 台账里的人工核对 Sheet（名如「债券库存核对0902」）**F:L 块**是从同业系统拉下来的债券库存快照： # F=同业系统(分组表头) G=查询日期(拉取时间) H=债券代码 I=债券名称 J=券面总额(万元) K=债券类型 L=账户 # 它只在**拉取时间 == 台账日期**时才认（见 three_way 上方注释）： # 满足 ⇒ 纳入核对、成为「最可靠来源」，并借它把「不一致」归因到具体哪一方； # 不满足 ⇒ 退回两方核对 + 一条「时点不符」提示（差几天、重拉即启用）， # 绝不硬比 —— 差一天的快照同样会「全军覆没」，那是噪声不是问题。 # ⚠ 该 Sheet 名带日期后缀（0902），所以按「名称包含关键词」认，不能写死 Sheet 名。 third, third_meta = {}, dict(sheet=None, pull=None, pulls=[], n=0, rows=0, n_nodate=0) # ⚠ `bad3`（自勾稽不符明细）必须在**最外层**就初始化、不能只在下面 `if blk_lbl:` 里建 —— # 启用判定 third_enabled() 要在块外读它。放在块内会让「台账里没有该 Sheet」 # 「有 Sheet 但没有汇总块」这两条路径直接 UnboundLocalError（合成样本已复现）。 bad3 = [] for nm in sorted(wb): if any(k in nm for k in THIRD_SHEET_HINTS): third_meta["sheet"] = nm break if third_meta["sheet"]: tname = third_meta["sheet"] grid = wb[tname] hr = None for r in sorted(grid): if any(nh(v) == "查询日期" for v in grid[r].values()): hr = r break if hr is None: q("中", "核对源表头异常", tname, "「债券库存核对」Sheet 中找不到「查询日期」表头行，同业系统快照未纳入核对", at="整表") else: h = hdr_map(grid, hr) c_code, c_name = pick(h, ["债券代码"]), pick(h, ["债券名称"]) # ⚠ 金额列必须带单位别名：J 列表头是「券面总额(万元)」而不是「券面总额」， # 只认短名会命中右侧现券库存块的 Y 列（那两列里正好有 #REF!），静默取到错列。 c_amt = pick(h, ["券面总额(万元)", "券面总额(万)", "券面总额(万人民币)", "券面总额"]) c_type = pick(h, ["债券类型", "类型"]) c_acc, c_pull = pick(h, ["账户"]), pick(h, ["查询日期"]) for r in sorted(grid): if r <= hr: continue cd = str(cell(grid, r, c_code) or "").strip() if not cd or cd in ("-", "—", "/"): continue amt = num(cell(grid, r, c_amt)) if amt is None: q("中", "第三方缺金额", tname, "同业系统明细缺「券面总额(万元)」，该行未纳入核对", at="第%d行" % r) continue pull = isodate(cell(grid, r, c_pull)) if pull: third_meta["pulls"].append(pull) else: # ⚠ 缺「查询日期」的行**不会被 pulls 收录**，但它**仍然累加进 third 分母**。 # 原实现因此会把「混了一行正常日期的残缺快照」判成时点统一（N05）⇒ 单独计数。 third_meta["n_nodate"] += 1 nm3 = str(cell(grid, r, c_name) or "").strip() t3 = str(cell(grid, r, c_type) or "").strip() x = third.setdefault((strip_code(cd), acc_of(cell(grid, r, c_acc))), dict(code=cd, name=nm3, account=acc_of(cell(grid, r, c_acc)), ptype=infer_type(t3, nm3, cd), wan=0.0, n=0)) # J 列表头已标「(万元)」；to_wan 对万元级数值是恒等映射， # 只在有人误按「元」录入时才兜住（与持仓汇总块同一处手法）。 x["wan"] += to_wan(amt) x["n"] += 1 third_meta["n"], third_meta["rows"] = len(third), sum(x["n"] for x in third.values()) pulls = sorted(set(third_meta["pulls"])) third_meta["pull"] = pulls[0] if len(pulls) == 1 else None third_meta["pulls"] = pulls # ⚠ 必须在这里初始化为空列表、而不是在下面的 `if blk_lbl:` 内部 —— # 启用判定要在块外读它（N05）。放在块内会让「无汇总块」时 NameError， # 或让「有汇总块但全平」时的空列表被误当成「没检查过」。 bad3 = [] # 自勾稽：Sheet 自带「同业系统债券汇总」矩阵块（B 列标签 / C=国债 / D=地方债 / E=合计）。 # 明细求和必须与它逐格相等 —— 不等说明认错了列或快照被截断。三方核对**以它为基准**， # 基准错了结论全错，所以这道理必须显式报出来，不能默默往下算。 blk_lbl = None for r in sorted(grid): b = nh(cell(grid, r, "B")) if "同业系统" in b and "汇总" in b: blk_lbl = r break if blk_lbl: th = hdr_map(grid, blk_lbl + 1) agg3 = defaultdict(float) for x in third.values(): agg3[(x["account"], x["ptype"])] += x["wan"] cols3 = [(t, pick(th, [t])) for t in ("国债", "地方债")] for r in range(blk_lbl + 2, blk_lbl + 12): lbl = nh(cell(grid, r, "B")) if not lbl or lbl == "类型": continue if lbl in ("AC", "OCI", "TPL", "FVOCI"): acc = lbl elif lbl.startswith("合计"): acc = None else: break # B 列出现无法识别的标签 ⇒ 已到下一个汇总块，本块结束 for t, c in cols3: if not c: continue want = num(cell(grid, r, c)) got = (sum(v for (a, tt), v in agg3.items() if tt == t) if acc is None else agg3.get((acc, t), 0.0)) if want is not None and abs(want - got) > 0.5: bad3.append("%s/%s 块 %.0f ≠ 明细 %.0f" % (acc or "合计", t, want, got)) if bad3: # ⚠ 级别「中 → 高」并显式写出后果（N05）：基准自己不平 ⇒ 归因结论全错， # 所以这次**不启用**三方核对、退回两方，而不是照旧给出「哪一方不符」。 q("高", "核对源勾稽不符", tname, "同业系统明细求和与该 Sheet 自带「同业系统债券汇总」块不一致 ⇒ " "三方核对**已停用**（基准不平，归因结论不可信），本期退回两方核对", "；".join(bad3[:6]), at="B:E「同业系统债券汇总」块") third_on = third_enabled(third, third_meta, T, bad3) third_why = third_reason(third, third_meta, T, bad3) if third and not third_on: ps, _nd = third_meta["pulls"], third_meta["n_nodate"] # ⚠ 「勾稽不符」的条目已在上面写过 ⇒ 这里只报**日期/时点类**失效原因，避免同一件事报两遍。 if _nd: q("中", "核对源缺日期行", third_meta["sheet"], "同业系统快照混有 %d 行缺「查询日期」⇒ 三方核对**已停用**（分母不干净；" "「时点统一」不能只看有没有一行正常）" % _nd, "缺日期 %d 行；已解析日期 %s" % (_nd, "、".join(ps) or "无"), at="F:L 块「查询日期」列") elif third_meta["pull"] != T and not bad3: if len(ps) == 1: gap = (Td - D(*map(int, ps[0].split("-")))).days detail = ("同业系统快照拉取时间 %s / 台账日期 %s（相差 %d 天，%s）" % (ps[0], T, abs(gap), "快照早于台账日" if gap > 0 else "快照晚于台账日")) else: detail = "同业系统快照内「查询日期」不统一：%s" % "、".join(ps) q("中", "核对源时点不符", third_meta["sheet"], "同业系统债券库存快照未纳入三方核对（拉取时间 ≠ 台账日期，直接比对会把「时点差」误报成「账实不符」）", detail, at="F:L 块「查询日期」列") if third_on: print(" ≥ 三方核对已启用：同业系统快照 %s，%d 个代码 / %d 行" % (third_meta["pull"], third_meta["n"], third_meta["rows"])) elif third: print(" ≥ 三方核对未启用（原因：%s）" % (third_why or "?")) # ────────────────────────────────── 库存核对 bk = {} for p in book_pos: x = bk.setdefault((strip_code(p["code"]), p["account"]), dict(code=p["code"], name=p["name"], account=p["account"], ptype=p["ptype"], book=0.0, inv=0.0, bond_maturity=p["bond_maturity"])) x["book"] += p["wan"] iv = {} for i in inv: x = iv.setdefault((strip_code(i["code"]), i["acc"] or "未标注"), dict(code=i["code"], name=i["name"], account=i["acc"] or "未标注", ptype=i["btype"], book=0.0, inv=0.0, bond_maturity=i["maturity"])) x["inv"] += i["face_wan"] # 三方只比「同业系统覆盖到的品种」：它的快照本来就只含国债/地方债（政金债/信用债/ABS 不在其中）。 # 若把范围外的逐条标成「同业系统缺该券」，几十条噪声会把真差异淹掉 ⇒ 范围外只聚合计数、页面上说明。 third_types = sorted({v["ptype"] for v in third.values()}) t3 = {k: v["wan"] for k, v in third.items()} if third_on else {} recon, third_out_n, third_miss_n = [], 0, 0 for k in sorted(set(bk) | set(iv) | set(t3), key=lambda t: (str(t[1]), str(t[0]))): b, v = bk.get(k), iv.get(k) base = b or v or third.get(k) d = round((b["book"] if b else 0.0) - (v["inv"] if v else 0.0), 4) bw, iw = (b["book"] if b else 0.0), (v["inv"] if v else 0.0) row = dict(code=base["code"], name=base["name"], account=k[1], ptype=base.get("ptype") or "", book_wan=bw, inv_wan=iw, diff_wan=d, bond_maturity=base.get("bond_maturity"), status="一致" if abs(d) < 0.5 else ("台账多" if d > 0 else "库存多"), nway=bool(third_on), third_wan=None, third_at=None, verdict="", d_book3=None, d_inv3=None, err3=0.0) if third_on: in_scope = (k in t3) or (row["ptype"] in third_types) if not in_scope: third_out_n += 1 # 同业系统本来就覆盖不到，不算问题 else: tw = t3.get(k) vd, db, di = three_way(bw, iw, tw) row.update(third_wan=tw, third_at=third_meta["pull"], verdict=vd, d_book3=db, d_inv3=di) if vd == "同业系统缺该券": third_miss_n += 1 elif vd != "三方一致": row["err3"] = max(abs(db or 0.0), abs(di or 0.0)) recon.append(row) if not third_on or not row["verdict"]: # 两方口径（未启用三方，或该券不在同业系统覆盖范围内）：保持既有判定与提示 if abs(d) >= 0.5: lvl = "高" if (b is None or v is None or abs(d) > 10000) else "中" q(lvl, "库存不一致", "理论持仓 vs 现券库存", "%s（%s）差额 %.2f 万元" % (base["code"], k[1], d), "台账持仓 %.2f / 现券库存 %.2f" % (bw, iw), at="%s（%s）" % (base["code"], k[1])) else: # 三方口径：以同业系统为基准归因到具体哪一方，提示里直接写「照它改成多少」 vd = row["verdict"] if vd == "同业系统缺该券": # 同业系统没有这只券 ⇒ 无法借它归因；但**两方自己**还打架时不能只报「低」， # 那仍是实实在在的账实不符，只是缺了裁判而已。 if abs(d) < 0.5: q("低", vd, "同业系统快照", "%s（%s）同业系统快照无记录，台账持仓与现券库存一致（均 %.2f 万）" % (base["code"], k[1], bw), at="%s（%s）" % (base["code"], k[1])) else: lvl = "高" if (b is None or v is None) else "中" q(lvl, "库存不一致", "理论持仓 vs 现券库存", "%s（%s）差额 %.2f 万元（同业系统快照亦无该券，无法进一步归因）" % (base["code"], k[1], d), "台账持仓 %.2f / 现券库存 %.2f" % (bw, iw), at="%s（%s）" % (base["code"], k[1])) elif vd != "三方一致": lvl = "高" if (b is None or v is None or abs(row["d_book3"] or 0) > 10000 or abs(row["d_inv3"] or 0) > 10000) else "中" q(lvl, vd, third_meta["sheet"], "%s（%s）与同业系统不符：台账持仓 %+.2f / 现券库存 %+.2f 万元（同业系统 %.2f）" % (base["code"], k[1], row["d_book3"] or 0.0, row["d_inv3"] or 0.0, row["third_wan"]), "同业系统快照 %s / 台账持仓 %.2f / 现券库存 %.2f" % (row["third_at"], bw, iw), at="%s（%s）" % (base["code"], k[1])) if not third_on: for k in sorted(set(bk) - set(iv)): q("高", "台账有·库存无", "现券库存", "%s（%s）台账持仓 %.2f 万元，但现券库存无记录" % (k[0], k[1], bk[k]["book"]), at="%s（%s）" % (k[0], k[1])) for k in sorted(set(iv) - set(bk)): q("高", "库存有·台账无", "现券库存", "%s（%s）现券库存 %.2f 万元，但台账持仓汇总块无记录" % (k[0], k[1], iv[k]["inv"]), at="%s（%s）" % (k[0], k[1])) # ────────────────────────────────── 重复交易 seen = defaultdict(list) for f in fund: seen[(f["sheet"], f["counterparty"], f["principal"], f["start_date"], f["maturity"], f["collateral"])].append(f["id"]) for k, ids in seen.items(): if len(ids) > 1: q("低", "疑似重复", k[0], "同对手/同本金/同起止日/同质押共 %d 笔，建议人工复核" % len(ids), "对手 " + k[1], at=",".join(ids)) # ══════════════════════════════════ 指标层 # 「未结清」= 到期日 ≥ T（含 T 当日）；「存量」= 生效日 ≤ T < 到期日（F05：已生效且未到期， # 未来起息业务不算存量、T 当日已结清也不计存量）。 # 到期日历 / 现金流 / 未来 N 日累计到期用 live（T 当日仍有真实收付）；存量类指标一律用 stock。 live = [f for f in fund if f["remaining"] is not None and f["remaining"] >= 0] stock = [f for f in fund if f["stock"]] matured = [f for f in fund if not f["stock"]] mf_held = [m for m in mf if m["held"]] def wavg(xs, key, w="principal"): pairs = [(x[w], x[key]) for x in xs if x.get(w) and x.get(key) is not None] if not pairs: return None tw = sum(a for a, _ in pairs) return sum(a * b for a, b in pairs) / tw if tw else None def agg(xs): if not xs: return None pr = sum(x["principal"] for x in xs) at = sum(x["principal"] * (x["term"] or 0) for x in xs) # F10：金额期限加权利率「分子」「分母」必须同源 —— 只对 rate 非空的行求和， # 否则利率缺失行会「本金×期限进了分母、没进分子」被隐式当 0% 稀释。 # rate_cov = 有效利率覆盖的本金占比（0~1），全部缺失时 rate_amt_term 返 None。 _rat = [(x["principal"] * (x["term"] or 0), x["rate"]) for x in xs if x["rate"] is not None] _rat_at = sum(a for a, _ in _rat) _rat_cov = (sum(x["principal"] for x in xs if x["rate"] is not None) / pr) if pr else None return dict(n=len(xs), principal=pr, cashflow=sum(x["cashflow"] for x in xs), interest=sum((x["interest"] or 0) for x in xs), rate=wavg(xs, "rate"), rate_amt_term=(sum(a * r for a, r in _rat) / _rat_at) if _rat_at else None, rate_cov=_rat_cov, wam=(sum(x["principal"] * max(x["remaining"], 0) for x in xs) / pr) if pr else None, avg_term=(at / pr) if pr else None, **{("b_" + b): sum(x["principal"] for x in xs if x["bucket"] == b) for b in BUCKETS_R}, **{("n_" + b): sum(1 for x in xs if x["bucket"] == b) for b in BUCKETS_R}) lv2_order = ["回购", "拆借", "借款", "存款", "存放同业", "存单发行"] branches = [] for side in ("资产", "负债"): for l in lv2_order: a = agg([x for x in stock if x["side"] == side and x["lv2"] == l]) if a: branches.append(dict(side=side, lv2=l, **a)) # 全量分支（§现券/资金业务结构图）：即使当期无存量也输出 0 值，保证「没有规模的业务也显示」 _BB = BUCKETS_R empty_agg = dict(n=0, principal=0.0, cashflow=0.0, interest=0.0, rate=None, rate_amt_term=None, rate_cov=None, wam=None, avg_term=None, **{("b_" + b): 0.0 for b in _BB}, **{("n_" + b): 0 for b in _BB}) branches_all = [] for side in ("资产", "负债"): for cfg in FUND_SHEETS: if cfg["side"] != side: continue # 同一份 rows 既喂 agg() 也喂 cls_raw() —— 「行合计 ≡ 两个类之和」这条恒等式 # （test_audit [I] I2/I2b）就靠这一处同源；另建一份列表会悄悄分叉。 rows = [x for x in stock if x["sheet"] == cfg["sheet"]] a = agg(rows) row = dict(side=side, lv2=cfg["lv2"], sheet=cfg["sheet"], label=cfg["label"], disp=cfg["disp"], **(a if a else dict(empty_agg))) # 质押类 / 信用类二分（「业务 × 质押/信用矩阵」的数据源；嵌进本行，不建新顶层键） row["cls"] = {cl: cls_raw([(x["principal"], x["rate"], x["term"], x["remaining"]) for x in rows if fund_class_of(x["lv2"], x["collateral"]) == cl]) for cl in FUND_CLS} branches_all.append(row) # 总览「资产类业务存量 / 负债类业务存量」四行明细（名称 + 存量 + WAM），无存量的业务同样列出（0 值） _disp = {cfg["sheet"]: cfg["disp"] for cfg in FUND_SHEETS} # 业务固定顺序（资产 4 类 → 负债 4 类，严格照 FUND_SHEETS）。供「未到期明细」排序用， # 与 slice_days() 里同名变量同源；**不要**改成按 sheet 名字典序 —— 那是另一套业务顺序。 _ord = {} for cfg in FUND_SHEETS: _ord.setdefault(cfg["side"], []).append(cfg["sheet"]) stock_break = {} for _side, _key in (("资产", "asset"), ("负债", "liab")): stock_break[_key] = [dict(name=_disp[b["sheet"]], sheet=b["sheet"], lv2=b["lv2"], principal=b["principal"], wam=b["wam"], n=b["n"]) for b in branches_all if b["side"] == _side] by_sheet = [] for cfg in FUND_SHEETS: a = agg([x for x in stock if x["sheet"] == cfg["sheet"]]) if a: by_sheet.append(dict(sheet=cfg["sheet"], side=cfg["side"], lv2=cfg["lv2"], **a)) dep_split = [] for label, pred in (("信用类", lambda x: (not x["collateral"]) or x["collateral"] in ("否", "N", "n", "无", "信用")), ("质押类", lambda x: x["collateral"] and x["collateral"] not in ("否", "N", "n", "无", "信用"))): a = agg([x for x in stock if x["lv2"] == "存款" and pred(x)]) if a: dep_split.append(dict(label=label, **a)) # ── 基金存量表：行 = 基金管理人 × 列 = 购买渠道 # 购买渠道取自「货币基金」Sheet 的「备注」列（台账里该列记的是代销行 / 直销渠道）。 # 0 值单元格前端留白（不留痕地说"没有"），空渠道统一归入「未标注」并计入合计。 _mf_none = "未标注" _ch_wan, _ch_set = defaultdict(float), defaultdict(set) _mg_wan, _mg_set = defaultdict(float), defaultdict(set) _cell = defaultdict(float) # V2.68：只数按**基金代码去重**（同一只基金多笔申购只算 1 只），不再按笔数定只数。 # 代码缺省时退用简称，再退用流水 id（保证不同标的不会因「无代码」被错误并成 1 只）。 _mfkey = lambda m: (m["code"] or m["name"] or "").strip() or m["id"] for m in mf_held: ch = (m["note"] or "").strip() or _mf_none mg = (m["manager"] or "").strip() or _mf_none _k = _mfkey(m) _ch_wan[ch] += m["amount"] _ch_set[ch].add(_k) _mg_wan[mg] += m["amount"] _mg_set[mg].add(_k) _cell[(mg, ch)] += m["amount"] _ch_order = sorted(_ch_wan, key=lambda k: (-_ch_wan[k], k)) # 「直销」不属于任何代销行，语义上与「合计」同列并列 —— 固定挪到最后一列（紧邻合计之前） _ch_order = [c for c in _ch_order if c != "直销"] + (["直销"] if "直销" in _ch_wan else []) _mg_order = sorted(_mg_wan, key=lambda k: (-_mg_wan[k], k)) mf_matrix = dict( unit="万元", channel_label="购买渠道", row_label="基金管理人", channels=[dict(name=c, wan=round(_ch_wan[c] / WAN, 2), n=len(_ch_set[c])) for c in _ch_order], rows=[dict(manager=g, n=len(_mg_set[g]), wan=round(_mg_wan[g] / WAN, 2), cells=[round(_cell[(g, c)] / WAN, 2) for c in _ch_order]) for g in _mg_order], total=dict(n=len({_mfkey(m) for m in mf_held}), wan=round(sum(m["amount"] for m in mf_held) / WAN, 2)), ) cal = defaultdict(lambda: dict(inflow=0.0, outflow=0.0, inflow_n=0, outflow_n=0, items=[])) for f in live: # 含 T 当日：当日到期同样产生收付，日历口径不剔除 e = cal[f["maturity"]] if f["side"] == "资产": e["inflow"] += f["cashflow"] e["inflow_n"] += 1 else: e["outflow"] += f["cashflow"] e["outflow_n"] += 1 e["items"].append(dict(id=f["id"], sheet=f["sheet"], side=f["side"], lv2=f["lv2"], counterparty=f["counterparty"], principal=f["principal"], cashflow=f["cashflow"], rate=f["rate"], start=f["start_date"], mat=f["maturity"], mat_shift=f.get("mat_shift"), cashflow_shift=f.get("cashflow_shift"))) calendar, cum = [], 0.0 for d in sorted(cal): e = cal[d] net = e["inflow"] - e["outflow"] cum += net calendar.append(dict(date=d, days=days_between(T, d), inflow=e["inflow"], outflow=e["outflow"], net=net, cum=cum, inflow_n=e["inflow_n"], outflow_n=e["outflow_n"], items=e["items"])) # 投资业务到期现金流（总览「未来 90 日现金流」按业务类型切换用） # 债券按「持仓剩余量（面值）」计到期兑付本金；货币基金按持有金额计到期赎回。 # 口径：债券不含应计利息（台账无逐券利息明细）；货基基本为「随时可赎」，无固定到期日故通常不计入。 cal_inv = defaultdict(lambda: dict(inflow=0.0, n=0)) for p in book_pos: m = p["bond_maturity"] if not m: continue e = cal_inv[m] e["inflow"] += p["wan"] * WAN e["n"] += 1 for m0 in mf_held: m = m0.get("maturity") if not m: continue e = cal_inv[m] e["inflow"] += m0["amount"] e["n"] += 1 calendar_inv = [dict(date=d, days=days_between(T, d), inflow=cal_inv[d]["inflow"], n=cal_inv[d]["n"]) for d in sorted(cal_inv)] def cum_due(n): # 「未来 N 日累计到期」= 含 T 当日（T 日仍有实际收付），故基于 live 而非 stock return sum(f["principal"] for f in live if 0 <= f["remaining"] <= n) # 账户口径三分对照：台账汇总块 / 现券库存 / 交易流水推算（限定债券未到期） # 流水推算必须与存量统计同口径：已入库（结算日 ≤ T）且未到期（到期日 > T）。 # ⚠ 到期边界用「≤ T 即剔除」而非「< T」：到期日为 T 的券当日结清，与资金业务 # 的 F05 口径一致（曾因写 `< T` 把 T 日到期的券留在理论持仓里）。 flow_wan = defaultdict(float) for b in bonds: if not b["settled"]: continue # 未入库（结算日 > T 或日期缺失） _me = b.get("mat_eff") or b.get("bond_maturity") if _me and _me <= T: continue # 已到期/已提前结清（含 T 日到期当日结清） flow_wan[(strip_code(b["code"]), b["account"])] += b["face_wan"] * STDDIR[b["direction"]] acc_sum = defaultdict(lambda: dict(book=0.0, inv=0.0, flow=0.0, n=0)) for p in book_pos: acc_sum[p["account"]]["book"] += p["wan"] acc_sum[p["account"]]["n"] += 1 for i in inv: acc_sum[i["acc"] or "未标注"]["inv"] += i["face_wan"] for k, v in flow_wan.items(): acc_sum[k[1]]["flow"] += v matrix = defaultdict(lambda: defaultdict(float)) for p in book_pos: matrix[p["account"]][p["ptype"]] += p["wan"] matrix_mf = defaultdict(float) for m in mf_held: matrix_mf["货币基金"] += m["amount"] / WAN # ── 债券主数据 + 期限结构（第二阶段：投资组合管理） _trades = defaultdict(list) for b in bonds: _trades[(strip_code(b["code"]), b["account"])].append(b) inv_map = defaultdict(float) for i in inv: inv_map[(strip_code(i["code"]), i["acc"] or "未标注")] += i["face_wan"] bond_master = [] for p in book_pos: key = (strip_code(p["code"]), p["account"]) trades = _trades.get(key, []) latest = None for t in trades: if latest is None or (t.get("trade_date") or "") > (latest.get("trade_date") or ""): latest = t _k = strip_code(p["code"]) coupon = _norm_rate(latest.get("coupon"), _k, p["name"], p["sheet"], "票面利率") if latest else None ytm = _norm_rate(latest.get("ytm"), _k, p["name"], p["sheet"], "到期收益率") if latest else None # 该券（代码 × 账户）在台账交易区占用的物理行号：xl_row = 最近一笔所在行（定位跳它）， # xl_n = 成交笔数。⚠ 键必须带账户 —— 同一代码会同时躺在「国债」与「OCI账户交易明细」 # 两个 Sheet 里，只用代码做键会被后者覆盖、静默漏掉一批。 _brows = BROW.get(key) or [] bond_master.append(dict( xl_row=(max(_brows) if _brows else None), xl_n=len(_brows), code=p["code"], key=strip_code(p["code"]), name=p["name"], account=p["account"], ptype=p["ptype"], nature=p["nature"], sheet=p["sheet"], book_wan=p["wan"], flow_wan=flow_wan.get(key, 0.0), inv_wan=inv_map.get(key, 0.0), bond_maturity=p["bond_maturity"], avg_remaining_years=p["avg_remaining_years"], coupon=coupon, ytm=ytm, rating=(latest.get("rating") if latest else None) or None, originator=(latest.get("originator") if latest else None) or None, guarantor=(latest.get("guarantor") if latest else None) or None, trade_n=len(trades), buy_n=sum(1 for t in trades if t["side"] == "买入"), sell_n=sum(1 for t in trades if t["side"] == "卖出"))) # ══════════════════════════════════ 录入量级审计（§给台账制表人的话） def audit_scale(): """利率类字段的「量级离群」审计 —— 专抓忘输 / 多输「%」这类 100 倍笔误。为什么不能只判「值是否落在 0.2~20」这个绝对窗口：它漏掉两种真实错误 —— ① 基数小的时候值仍落在窗口内（0.13 被当成 1.3‰ 用），既有检查完全看不见； ② 整列都忘输 % 时全体一起放大 100 倍，每题的值都"看着离谱"，反而挑不出错行。判定逻辑见模块级 scale_outliers()（纯函数，可单测）；本处只负责产出文案。""" for o, m, k, n_other in scale_outliers(AUDIT): q("高" if k >= RATE_SCALE_HI else "中", "利率量级存疑", o["sheet"], "与同 Sheet 其他 %d 笔的中位数 %.4f%% 相差约 %d 倍，疑似量级笔误（多为忘输/多输「%%」）" % (n_other, m * 100, round(k)), "%s %s 原始=%s" % (o["field"], o["at"], o["raw"]), at=o["at"]) def audit_interest(): """利息勾稽 —— 唯一能抓出「利率与利息被同时放大/缩小」的检查。台账里利息 = 本金 × 利率 × 期限 ÷ 365（实测 43 笔全部落在 1.0000 或 365/360 的 1.0139，可见这个等式就是台账维护者自己在用的口径 ⇒ 可直接当勾稽基准）。若整列忘输 % 且利息是照着错利率算出来的，利率自身的"量级离群"就消失了（全体一起错 ⇒ 中位数也一起错），唯有这条交叉校验还站着。实测还额外抓到 3 笔柜台债回购：占款天数写 3 天、利息却只算了 1 天（比值恰好 1/3）。""" for p in fund: x = interest_ratio(p) if x is None: continue k = mag(x) if k <= 1.15: # 1.0139（365/360）与四舍五入都在容差内 continue q("高" if k >= RATE_SCALE_LO else "中", "利息勾稽不符", p["sheet"], "「利息」与「本金×利率×期限÷365」相差约 %d 倍，请复核利率 / 期限 / 利息三列" % round(k), "本金=%.2f 利率=%s 期限=%s 利息=%.2f 应≈%.2f" % (p["principal"], p["rate"], p["term"], p["interest"], p["principal"] * p["rate"] * p["term"] / 365.0), at=p["id"]) audit_scale() audit_interest() # ══════════════════════════════════ 预测盈利（逐笔 lot × 中债估值） # 概念：假设按「当日中债估值净价」卖出手持债券所能获得的盈余，逐笔（lot）口径，便于挑券。 # 成本侧：买入行「结算金额（元）」= 购入成本（全价口径，含应计利息）；「净价」= 成本净价； # 「剩余量（万）」= 当前仍持有面额（逐笔维护，实测与持仓汇总块逐位勾稽）。 # 估值侧：持仓汇总块右侧新增列（估值日期 / 中债估值净价 / 中债估值全价），人工录入。 # 口径：净价对净价 = 资本利得（不受应计利息干扰，主口径）； # 全价对全价 = 含持有期利息的总额（需全价列，缺失则该项为 null，不推算）。 # 账户差异（页面呈现口径，此处不编造）：AC = 估值净价 − 摊余成本； # OCI = 处置价差（≈0）+ OCI 累计结转；TPL = ≈0（浮盈已入当期损益）另给「累计浮盈」管理口径。 # 纳入条件：Σ逐笔剩余量 == 该 Sheet 持仓汇总块合计（且汇总块须有「合计」行）。 # ABS 为摊还型（买卖行都带 running balance，另有「偿还本金」行）→ 必然不过 → 自动排除， # 避免把「余额」当逐笔持仓重复计数。信用债「剩余金额」列与汇总块不一致 → 同样自动排除。 valuations, val_sheets, val_by_code = {}, [], {} for cfg in BOND_TRADE: sheet = cfg["sheet"] grid = wb.get(sheet) brow = block_hdr.get(sheet) if not grid or not brow: continue bh = hdr_map(grid, brow) c_d, c_n, c_g = pick(bh, VAL_A["date"]), pick(bh, VAL_A["net"]), pick(bh, VAL_A["gross"]) if c_n is None and c_g is None: continue # 该 Sheet 未新增估值列 val_sheets.append(sheet) c_code, c_name = pick(bh, ["债券代码", "存单代码"]), pick(bh, ["债券名称", "存单名称"]) n_present = 0 for r in sorted(grid): if r <= brow: continue cd = str(cell(grid, r, c_code) or "").strip() nm = str(cell(grid, r, c_name) or "").strip() if not cd or is_total(nm): continue vn, vg = num(cell(grid, r, c_n)), num(cell(grid, r, c_g)) if vn is None and vg is None: continue n_present += 1 item = dict(date=isodate(cell(grid, r, c_d)), net=vn, gross=vg, name=nm) valuations[(strip_code(cd), cfg["account"])] = item val_by_code.setdefault(strip_code(cd), item) print(" ¥ %-18s 估值 %3d 只" % (sheet, n_present)) # ---- 估值来源 ②：独立 Sheet（如「中债估值」） # 中债估值本质是「逐券」的（同一只券在不同账户估值价相同），故主键 = 债券代码； # 若表内另带「账户」列，则同时写一份 (代码,账户) 主键以精确覆盖来源 ①。 val_src_sheets, val_src_empty, val_src_bad = [], [], [] for nm in list(wb.keys()): nk = nh(nm) if not any(h in nk for h in VAL_SHEET_HINT): continue g2 = wb.get(nm) or {} if not any(g2): val_src_empty.append(nm) continue hr = find_header(g2, min_cells=2) bh2 = hdr_map(g2, hr) if hr else {} cols_seen = sorted(bh2.keys()) c_code = pick(bh2, VAL_A["code"]) c_n, c_g2 = pick(bh2, VAL_A["net"]), pick(bh2, VAL_A["gross"]) c_d, c_ac = pick(bh2, VAL_A["date"]), pick(bh2, VAL_A["account"]) c_nm2 = pick(bh2, VAL_A["name"]) if c_code is None or (c_n is None and c_g2 is None): val_src_bad.append((nm, cols_seen)) q("高", "估值表列名未识别", nm, "「%s」Sheet 里没认出「债券代码 + 估值净价/全价」，该表估值未被采用" % nm, "识别到的表头：%s" % "、".join(cols_seen[:30]), at="表头行") continue n2 = 0 for r in sorted(g2): if r <= hr: continue cd = str(cell(g2, r, c_code) or "").strip() if not cd or is_total(cd): continue vn, vg = num(cell(g2, r, c_n)), num(cell(g2, r, c_g2)) if vn is None and vg is None: continue n2 += 1 item = dict(date=isodate(cell(g2, r, c_d)), net=vn, gross=vg, name=str(cell(g2, r, c_nm2) or "").strip()) cd0 = strip_code(cd) val_by_code[cd0] = item if c_ac: a2 = acc_of(cell(g2, r, c_ac)) if a2: valuations[(cd0, a2)] = item if n2: val_src_sheets.append(nm) if nm not in val_sheets: val_sheets.append(nm) print(" ¥ %-18s 估值 %3d 只（%s）" % (nm, n2, "逐券+账户" if c_ac else "逐券")) # ---- 估值来源 ③：现券库存「当日净价」列（逐券 × 账户，最适合本项目：库存表本身就有代码+账户） # 优先级最低（setdefault），已由 ①/② 填过的键不覆盖。 if inv_val: for (cdk, ak), vn3 in inv_val.items(): item3 = dict(date=None, net=vn3, gross=None, name="") val_by_code.setdefault(cdk, item3) valuations.setdefault((cdk, ak), item3) if "现券库存" not in val_sheets: val_sheets.append("现券库存") print(" ¥ %-18s 估值 %3d 只（逐券×账户 · 列「当日净价」）" % ("现券库存", len(inv_val))) # ══════════════════════════════════ 核算余额（应计利息 / 利息调整）—— V2.37 # 数据源：根目录「核算余额查询*.xls」（老式 .xls，OLE 二进制，zipfile 读不了，需 xlrd）。 # 用途：AC / OCI 债券预测盈余的新口径 —— 预测盈余 = 全价×持仓数量 − 券面金额 − 应计利息 − 利息调整。 # 应计利息 / 利息调整是**逐笔（按买入批次）**的，主键 = (债券代码, 账户, 交易日期=台账结算日, 券面总额)。 # ⚠ 核算余额是「可选输入」：文件不存在 / 缺 xlrd / 解析失败 ⇒ 只降级（新口径缺这两项按 0 计， # 并在质量清单点名），**绝不阻断**台账 ETL（台账仍是主数据源）。 hb_rows, hb_note = [], "" if HB_FILE: # N23：**提交式读取** —— 先完整解析到临时集合 `_hb_tmp`，全部成功后才提交给 `hb_rows`； # 中途任何异常都不提交（丢弃半读结果），避免「读到 60 行就停了却仍按 245 笔算」。 # 逐字段区分「有值 / 缺值（None）/ 真零」：应计利息/利息调整读不到时保留 None（未知）， # **绝不转 0**（旧代码 `if _accr is not None else 0.0` 把「缺」当成了「零」）。 _hb_tmp = [] try: import xlrd as _xlrd _xw = _xlrd.open_workbook(HB_FILE) _xs = _xw.sheet_by_index(0) # 表头在第 0 行：列名 → 列号（按别名匹配，不硬编码列序） _hdr = {} for _c in range(_xs.ncols): _k = nh(_xs.cell_value(0, _c)) if _k and _k not in _hdr: _hdr[_k] = _c _hb_a = dict(code=["金融工具代码", "债券代码", "代码"], date=["交易日期"], acct=["会计分类"], ptype=["产品类型", "产品分类"], face_wan=["券面总额（万元）", "券面总额(万元)", "券面总额"], accrued=["应计利息(元)", "应计利息（元）", "应计利息"], amort=["利息调整(元)", "利息调整（元）", "利息调整"]) _cm = {k: next((_hdr[a] for a in aliases if a in _hdr), None) for k, aliases in _hb_a.items()} _need = ["code", "acct", "ptype", "face_wan", "accrued", "amort"] if any(_cm[k] is None for k in _need): _miss = "、".join(k for k in _need if _cm[k] is None) hb_note = "核算余额表头缺列（%s），未读取" % _miss q("中", "核算余额未读取", "盈利预测", hb_note, at=HB_FILE.split(os.sep)[-1]) else: _gv = lambda r, c: _xs.cell_value(r, c) for _r in range(1, _xs.nrows): _pt = str(_gv(_r, _cm["ptype"]) or "").strip() _ac = str(_gv(_r, _cm["acct"]) or "").strip() if _pt not in ("债券", "资产证券化债券"): continue if _ac not in ("AC类", "FVOCI类"): continue _cd = strip_code(_gv(_r, _cm["code"])) _acc = "AC" if _ac == "AC类" else "OCI" _dt = str(_gv(_r, _cm["date"]) or "").strip()[:10] _fw = num(_gv(_r, _cm["face_wan"])) _accr = num(_gv(_r, _cm["accrued"])) _am = num(_gv(_r, _cm["amort"])) if not _cd: continue # 统一转万元；None 保留 None（N23：缺 ≠ 0），只有真数值才 ÷WAN。 _hb_tmp.append(dict(code=_cd, account=_acc, date=_dt, face_wan=_fw, accrued=(_accr / WAN if _accr is not None else None), amort=(_am / WAN if _am is not None else None))) # 全部行解析成功 ⇒ 提交 hb_rows = _hb_tmp hb_note = "已读取核算余额 %d 行（AC/OCI 债券）" % len(hb_rows) print(" ¥ 核算余额查询 %-18s %d 行（应计利息/利息调整）" % (HB_FILE.split(os.sep)[-1], len(hb_rows))) except ImportError: hb_note = "缺 xlrd 依赖，未读取核算余额（应计利息/利息调整缺失）" q("中", "核算余额未读取", "盈利预测", "读取「核算余额查询*.xls」需要 xlrd 库，当前环境未安装 ⇒ 应计利息/利息调整缺失，" "相关盈余留空显示「—」（不按 0 计）", at="pip install xlrd") except Exception as _e: # N23：读取中途失败 ⇒ 不提交半读结果（hb_rows 保持空），逐笔盈余按「核算未知」留空。 hb_note = "核算余额读取失败：%s" % _e q("中", "核算余额未读取", "盈利预测", hb_note, at=HB_FILE.split(os.sep)[-1]) else: hb_note = "未找到「核算余额查询*.xls」（请放到「输入数据/核算余额/」或根目录）" # 核算余额逐笔索引：(code, account) -> [(date, face_wan, accrued, amort), ...] hb_by = defaultdict(list) for _h in hb_rows: hb_by[(_h["code"], _h["account"])].append(_h) # 现券库存「日间全价」逐券索引：(code, account) -> full_px（同一券多笔共用同一全价） full_px_by = {} for _rk in risk_lots: _k = (strip_code(_rk.get("code")), _rk.get("acc") or "") if _rk.get("full_px") is not None: full_px_by.setdefault(_k, _rk["full_px"]) TORD = dnum(T) lots, lot_sheets, lot_excluded = [], [], [] for cfg in BOND_TRADE: sheet, acc = cfg["sheet"], cfg["account"] buys = [b for b in bonds if b["sheet"] == sheet and b["side"] == "买入" and (to_wan(b.get("remain_wan")) or 0) > 0] if not buys: continue # 本 Sheet 本期无在手持仓 rem = sum(to_wan(b["remain_wan"]) or 0 for b in buys) blk, btot = block_sum.get(sheet), block_total.get(sheet) if blk is None or btot is None or abs(rem - blk) > LOT_TOL: lot_excluded.append(dict(sheet=sheet, account=acc, lots=len(buys), lot_wan=rem, block_wan=blk, block_total=btot)) q("中", "逐笔持仓口径待确认", sheet, "交易区「剩余量」逐笔求和与持仓汇总块合计不一致，该 Sheet 未纳入预测盈利", "逐笔 %d 笔合计 %.2f 万 / 汇总块 %s / 合计行 %s" % (len(buys), rem, ("%.2f 万" % blk) if blk is not None else "无", ("%.2f 万" % btot) if btot is not None else "无"), at="交易区「剩余量」列") continue lot_sheets.append(sheet) lots.extend(buys) # N23/N24：核算余额「是否可用」＝文件读到且解析成功且非空。缺核算输入时，盈利不能按 # 「应计利息/利息调整 = 0」冒充完整口径 —— 应计/调整置 None、盈余置 None（见下方）。 hb_ok = bool(hb_rows) hb_fallback_n = 0 # 应计利息/利息调整未精确匹配、走「按券剩余面额分摊」的笔数 profit_lots = [] # ── N24（两阶段守恒）：先把所有能精确匹配的 lot 与核算来源行**一对一消费**； # 再把「未被精确消费掉的余额」按「未匹配 lot 的剩余面额占比」分摊给未匹配 lot。 # 从源头保证组内守恒：精确领走 + 兜底分摊 ≡ 该券核算来源合计，不重不漏。── _hb_used = set() # 已被精确匹配消费的核算行（(code,account) 键 + 行内下标） # 阶段1：精确匹配（(code,account) 内，settle 日 + 面额相等，首条未消费即领走） _exact = {} # lot 在 lots 中的下标 -> (accrued, amort) _rowlist_of = {k: hb_by.get(k, []) for k in {(strip_code(b["code"]), b["account"]) for b in lots}} for _bi, b in enumerate(lots): k = (strip_code(b["code"]), b["account"]) _rowlist = _rowlist_of.get(k, []) for _hi, _h in enumerate(_rowlist): if (k, _hi) in _hb_used: continue if _h["date"] == b.get("settle") and (_h["face_wan"] is None or _h["face_wan"] == (b.get("face_wan") or 0.0)): _exact[_bi] = (_h["accrued"], _h["amort"]) _hb_used.add((k, _hi)) break # 阶段2：兜底分摊 —— 按券聚合「未消费余额」与「未匹配 lot 面额」。 # N23/N24：来源行的 accrued/amort 可能是 None（缺值）。原来「部分缺」只汇已知部分、 # 把 None 当 0 参与，等于用「已知金额 + None」冒充完整口径去算盈余。修复：只要该组 # 未消费余额里出现任一 None（空洞），整组就判「来源不完整」、accrued/amort 置 None， # 盈余留空 —— 只有「全部行都有值（含真实零）」才允许求和。这样才符合 # 「来源 = 已分配 + 明确排除 + 未分配」的守恒验证，不完整组停止确定盈余。 _rest = {} # (code,account) -> (accrued_rest, amort_rest)，None 表示「来源不完整」 for k, _rowlist in _rowlist_of.items(): _ra = _rm = 0.0 _ra_gap = _rm_gap = False for _hi, _h in enumerate(_rowlist): if (k, _hi) in _hb_used: continue _a = _h["accrued"] _m = _h["amort"] if _a is not None: _ra += _a else: _ra_gap = True if _m is not None: _rm += _m else: _rm_gap = True _rest[k] = ((None if _ra_gap else _ra), (None if _rm_gap else _rm)) _unmatched_rem = {} # (code,account) -> 未精确匹配 lot 的剩余面额合计（分摊分母） for _bi, b in enumerate(lots): if _bi in _exact: continue k = (strip_code(b["code"]), b["account"]) _unmatched_rem[k] = _unmatched_rem.get(k, 0.0) + (to_wan(b["remain_wan"]) or 0.0) for _bi, b in enumerate(lots): rem_wan = to_wan(b["remain_wan"]) or 0.0 face_wan = b.get("face_wan") or 0.0 buy_net, buy_gross = b.get("net"), b.get("gross") # settle_amt 来自台账「结算金额」列，明确以「元」记（对照 face=face*WAN）， # 固定 ÷10000 转万元；不走 to_wan() 的大小猜测，否则小额结算漏转会放大万倍（F07）。 _sa = b.get("settle_amt") settle_wan = (_sa / WAN) if _sa is not None else None k = (strip_code(b["code"]), b["account"]) # ── V2.37 新口径：全价（现券库存日间全价）＋应计利息/利息调整（核算余额） full_px = full_px_by.get(k) accrued = amort = None if _bi in _exact: accrued, amort = _exact[_bi] else: # 兜底：该券「未被精确消费掉的余额」按「未匹配 lot 剩余面额占比」分摊。 # ⚠ 临时变量带 `_hb` 前缀：main() 是巨型函数，裸名 `_tot` 会覆盖下面 # 风险测算的 `_tot` dict（历史事故，L3138 有注释）。绝不用 `_tot`。 # N23：该券**根本没有来源**（k 不在 hb_by）⇒ 不给零元组，应计/调整保持 None。 if hb_ok and k in _rowlist_of: _hb_rest = _rest.get(k, (0.0, 0.0)) _denom = _unmatched_rem.get(k, 0.0) _ratio = (rem_wan / _denom) if _denom else 0.0 if _ratio > 0: _a = _hb_rest[0] _m = _hb_rest[1] accrued = (_a * _ratio) if _a is not None else None amort = (_m * _ratio) if _m is not None else None hb_fallback_n += 1 vstat = "已匹配" if full_px is not None else "估值缺失" # 新口径预测盈余（万元）：全价×持仓数量 − 券面金额 − 应计利息 − 利息调整 # N33：全价市值 val_full **只要有全价就能算**，与核算完整性无关（有价格+数量即可）。 # N23：盈余 s_net 才要求「应计/调整都已知（非 None）」；缺任一 ⇒ 盈余留空不按 0。 val_full = (full_px / 100.0 * rem_wan) if full_px is not None else None if full_px is not None and accrued is not None and amort is not None: face_amt = rem_wan s_net = val_full - face_amt - accrued - amort # 盈余率分母 = 摊余成本 = 剩余面额 + 利息调整（AC 类债券核算口径） _amort_cost = face_amt + amort s_rate = (s_net / _amort_cost) if _amort_cost else None else: s_net = s_rate = None profit_lots.append(dict( lot_id="L%04d" % (len(profit_lots) + 1), sheet=b["sheet"], account=b["account"], ptype=b["ptype"], code=b["code"], key=k[0], name=b["name"], buy_date=b.get("trade_date"), buy_net=buy_net, buy_gross=buy_gross, settle_wan=settle_wan, face_wan=face_wan, rem_wan=rem_wan, coupon=b.get("coupon"), bond_maturity=b.get("bond_maturity"), hold_days=(TORD - dnum(b["trade_date"])) if b.get("trade_date") else None, rem_years=(round(days_between(T, b["bond_maturity"]) / 365.25, 4) if b.get("bond_maturity") else None), val_date=None, val_net=None, val_gross=None, val_status=vstat, # 新口径核心字段 full_px=full_px, accrued_int=accrued, amort_adj=amort, # N22：本金统一 = 剩余面额（rem_wan）；原买入面额由 face_wan 单独保留。 cost_net=rem_wan, # 持仓本金（万元）＝剩余面额 val_amt_net=val_full, # 全价市值（万元） surplus_net=s_net, # 预测盈余（万元，新口径；缺核算为 None） # V2.68：单位券面盈余 = 预测盈余 ÷ 剩余面额 × 100（每百元面值的盈余，元）。 # 与「盈余率」（÷摊余成本）区分：这里分母是**券面**，便于跨券比「每张赚多少」。 surplus_per_face=((s_net / rem_wan * 100.0) if (s_net is not None and rem_wan > 0) else None), cost_gross=None, val_amt_gross=None, surplus_gross=None, surplus_rate=s_rate)) # N24：未分配余额守卫 —— 分摊后，某券的核算来源「未被任何 lot 认领」的余额若不为 0， # 说明来源/lot 关系对不上（多出的来源、已售部分、或批次合并），不能静默丢弃，必须点名。 # 只对「有来源但完全没被消费、也没有未匹配 lot 领走」的券报警（该券无在持 lot 或全精确匹配后多出来源）。 # ⚠ N24 第三轮：遍历 hb_by **全集**而非 _rowlist_of —— _rowlist_of 只含 lots 里出现过的券， # 「台账里已无在持 lot（已全部卖出）」的券，其核算来源若不为 0，同样要报警（否则守卫看不到它们）。 _hb_orphan = [] _lot_keys = {(strip_code(b["code"]), b["account"]) for b in lots} for _k, _rowlist in hb_by.items(): if _k not in _lot_keys: # 该券在台账里已无在持 lot ⇒ 其核算来源「整体无人认领」，只要余额不为 0 就报警 _ra = _rm = 0.0 for _h in _rowlist: if _h["accrued"] is not None: _ra += _h["accrued"] if _h["amort"] is not None: _rm += _h["amort"] if abs(_ra) > 0.005 or abs(_rm) > 0.005: _hb_orphan.append((_k, round(_ra, 4), round(_rm, 4))) continue # 该券未消费余额 _ra = _rm = 0.0 for _hi, _h in enumerate(_rowlist): if (_k, _hi) in _hb_used: continue if _h["accrued"] is not None: _ra += _h["accrued"] if _h["amort"] is not None: _rm += _h["amort"] # 该券是否有未匹配 lot（会去分摊这些余额） _has_unmatched = _k in _unmatched_rem and _unmatched_rem[_k] > 0 if not _has_unmatched and (abs(_ra) > 0.005 or abs(_rm) > 0.005): _hb_orphan.append((_k, round(_ra, 4), round(_rm, 4))) def _pagg(rows): """逐笔聚合。成本/面额覆盖全部逐笔（成本与估值无关）；市值与盈余**分开统计**（N33）：市值覆盖「有全价」的逐笔（有价格+数量即可算，与核算无关）；盈余只覆盖「核算完整（surplus_net 非 None）」的逐笔。并同时给出各自基数，避免「拿部分盈余除以全部成本」的错配。 N25：盈余率分母 = Σ剩余面额 + Σ利息调整（= 摊余成本，与前端 plAgg 同口径）。""" mt = [x for x in rows if x["surplus_net"] is not None] # 核算完整、盈余可算 mv = [x for x in rows if x["val_amt_net"] is not None] # 有全价、市值可算（N33） c_all = sum(x["cost_net"] or 0.0 for x in rows) # 剩余面额合计（万元） c_mt = sum(x["cost_net"] or 0.0 for x in mt) val = sum(x["val_amt_net"] or 0.0 for x in mv) # 全价市值合计（万元，独立集合） sur = sum(x["surplus_net"] or 0.0 for x in mt) # 盈余率分母 = 摊余成本 = 剩余面额 + 利息调整（AC/OCI 债券核算口径） _amort = sum((x["amort_adj"] or 0.0) for x in mt) _denom = c_mt + _amort return dict(n_lot=len(rows), n_matched=len(mt), n_valued=len(mv), rem_wan=sum(x["rem_wan"] for x in rows), cost_wan=c_all, cost_matched_wan=c_mt, val_wan=val, surplus_wan=sur, surplus_rate=(sur / _denom if _denom else None), surplus_gross_wan=None, n_gross=0) profit_summary = OrderedDict() for acc_name in ("AC", "OCI", "TPL"): profit_summary[acc_name] = _pagg([x for x in profit_lots if x["account"] == acc_name]) profit_summary["合计"] = _pagg(profit_lots) profit_by_type = OrderedDict() for acc_name in ("AC", "OCI", "TPL"): d = OrderedDict() for t in PTYPE_ORDER: rows = [x for x in profit_lots if x["account"] == acc_name and x["ptype"] == t] if rows: d[t] = _pagg(rows) if d: profit_by_type[acc_name] = d # TPL 双口径：① 会计新增损益（需「上日估值」，本期无数据 → null，绝不推算） # ② 累计浮盈（= 估值净价 − 买入净价，管理口径，非当期会计损益） _tpl = [x for x in profit_lots if x["account"] == "TPL"] tpl_dual = dict(cum_fv_wan=(sum(x["surplus_net"] for x in _tpl if x["surplus_net"] is not None) if _tpl else None), cum_fv_n=len(_tpl), accrual_new_wan=None, note="会计新增损益需「上日/上期估值净价」，台账未提供该列，故不推算；" "累计浮盈为管理口径，不得与当期会计损益混计。") matched_keys = {(x["key"], x["account"]) for x in profit_lots if x["val_status"] == "已匹配"} n_matched_lot = sum(1 for x in profit_lots if x["val_status"] == "已匹配") # ⚠ 排序键必须覆盖**全部判别字段**（F17）。原来写 key=lambda z: z[0]（只按 code）， # 同一只券同时在 AC / OCI 持有时两个三元组并列，先后就取决于**集合迭代顺序**—— # 而它依赖进程随机的 PYTHONHASHSEED：同一份台账重跑会得到**不同字节**的 data.json， # 构建戳（= 产物 sha1 前 12 位）随之漂移、cloud_sync --verify 报「内容不一致」的假警报。 # 实测 4 个种子跑出 2 种结果；键属 P7_KEYS（要灌库），故必须钉死。 # 加 account 作次序键即可：value 全序 ⇒ 输出与进程无关。 val_missing = sorted({(x["code"], x["name"], x["account"]) for x in profit_lots if x["val_status"] == "估值缺失"}, key=lambda z: (z[0], z[2], z[1])) valuation_quality = dict( val_sheets=val_sheets, lot_sheets=lot_sheets, val_src_sheets=val_src_sheets, val_src_empty=val_src_empty, n_lot=len(profit_lots), n_matched=n_matched_lot, n_matched_key=len(matched_keys), coverage=(round(n_matched_lot / len(profit_lots), 4) if profit_lots else None), missing=[dict(code=c, name=n, account=a) for c, n, a in val_missing], excluded=lot_excluded, val_dates=sorted({v["date"] for v in list(valuations.values()) + list(val_by_code.values()) if v.get("date")}), # ── V2.37 新口径：全价（现券库存日间全价）+ 应计利息/利息调整（核算余额查询） hb_note=hb_note, hb_n=len(hb_rows), hb_fallback_n=hb_fallback_n, degraded=([] if val_sheets else ["台账内未找到可用的中债估值（汇总块新增列或独立估值 Sheet）"])) if val_src_empty: q("高", "估值表为空", "预测盈利", "台账里已建估值 Sheet 但没有数据，估值未被采用", "空表：%s" % "、".join(val_src_empty), at="、".join(val_src_empty)) if val_src_bad: q("高", "估值表列名未识别", "预测盈利", "估值 Sheet 里有数据但列名对不上，估值未被采用", "；".join("%s → 表头[%s]" % (s, "、".join(h[:12])) for s, h in val_src_bad), at="、".join(s for s, _ in val_src_bad)) if profit_lots and not val_sheets: q("高", "估值未接入", "预测盈利", "台账内无可用中债估值（汇总块无估值列、估值 Sheet 为空或列名未识别），预测盈利无法计算（未编造数据）", "在手持仓 %d 笔 / %.2f 亿" % (len(profit_lots), sum(x["rem_wan"] for x in profit_lots) / WAN), at="在手持仓 %d 笔" % len(profit_lots)) elif val_sheets and val_missing: q("中", "估值未填全", "预测盈利", "部分持仓未填中债估值净价，其盈余按「未匹配」留空（不按 0 处理）", "已匹配 %d / %d 笔，缺 %d 只" % (len(matched_keys), len(profit_lots), len(val_missing)), at="缺 %d 只" % len(val_missing)) if lot_excluded: q("中", "预测盈利覆盖范围", "预测盈利", "有 Sheet 因逐笔剩余量口径不一致未纳入预测盈利", "；".join("%s(%d笔)" % (x["sheet"], x["lots"]) for x in lot_excluded), at="；".join(x["sheet"] for x in lot_excluded)) if hb_fallback_n: q("中", "应计利息按面额分摊", "盈利预测", "有 %d 笔债券在核算余额查询里未精确匹配到「结算日+券面总额」对应的应计利息/利息调整，" "已按「该券剩余面额占比」分摊（通常因 OCI 账户在核算系统里合并了批次）" % hb_fallback_n, at="%d 笔" % hb_fallback_n) # N24：未分配余额守卫 —— 有核算来源但没有任何 lot 认领（无在持 lot 或全精确匹配后多出来源）， # 不能静默丢弃，报「高」级点名让人核对（可能含已售部分，需业务确认归属）。 if _hb_orphan: q("高", "核算余额未分配", "盈利预测", "有 %d 组「券+账户」的核算余额（应计利息/利息调整）未被任何在持买入批次认领，" "可能含已售部分或来源批次合并，差额未计入预测盈余，请核对归属" % len(_hb_orphan), "；".join("%s 应计%s/调整%s" % (_k[0] + "/" + _k[1], _ra, _rm) for _k, _ra, _rm in _hb_orphan[:10]), at="%d 组" % len(_hb_orphan)) # N23：缺核算输入 ⇒ 盈利完整口径不可得，必须生成**高级别**质量项点名，绝不静默按 0 冒充。 if not hb_ok: q("高", "核算余额未接入", "盈利预测", "未读到「核算余额查询*.xls」（应计利息/利息调整）⇒ 预测盈余无法按核算口径计算，" "相关逐笔盈余一律留空显示「—」，绝不按 0 编造（%s）" % hb_note, at="缺核算输入") # ── 期限结构：债券剩余期限区间（年）分布 def dur_bucket(y): if y is None: return "未知" if y <= 1: return "≤1年" if y <= 3: return "1-3年" if y <= 5: return "3-5年" if y <= 10: return "5-10年" return ">10年" DUR_ORDER = ["≤1年", "1-3年", "3-5年", "5-10年", ">10年", "未知"] duration_structure = defaultdict(lambda: defaultdict(float)) for p in book_pos: duration_structure[p["account"]][dur_bucket(p.get("avg_remaining_years"))] += p["wan"] # 期限结构再按【投资品种】切一层：{品种: {账户: {区间: 万元}}}。 # 供「债券期限结构」图的「剔除品种」下拉在前端按品种过滤后重算 —— 与 duration_structure # 同源同循环（全品种求和恒等于 duration_structure），前端只做线性求和，不产生第二份口径。 dur_by_type = defaultdict(lambda: defaultdict(lambda: defaultdict(float))) for p in book_pos: dur_by_type[p["ptype"]][p["account"]][dur_bucket(p.get("avg_remaining_years"))] += p["wan"] # ── 账户完整视图：全部业务余额（债券 + 货币基金，货基归 TPL）+ 分项 + 债券加权剩余期限（久期近似，排除基金）+ 加权票面/收益率 mf_wan_total = sum(m["amount"] for m in mf_held) / WAN accounts = OrderedDict() for acc_name in ("AC", "OCI", "TPL"): bd = defaultdict(float) for p in book_pos: if p["account"] == acc_name: bd[p["ptype"]] += p["wan"] if acc_name == "TPL" and mf_wan_total: bd["货币基金"] += mf_wan_total bond_ps = [p for p in book_pos if p["account"] == acc_name] pairs = [(p["wan"], p["avg_remaining_years"]) for p in bond_ps if p.get("avg_remaining_years") is not None] tw = sum(a for a, _ in pairs) dur = (sum(a * b for a, b in pairs) / tw) if tw else None _bm = [x for x in bond_master if x["account"] == acc_name] _cps = [(x["book_wan"], x["coupon"]) for x in _bm if x.get("coupon") is not None] _twc = sum(a for a, _ in _cps) _ytms = [(x["book_wan"], x["ytm"]) for x in _bm if x.get("ytm") is not None] _twy = sum(a for a, _ in _ytms) accounts[acc_name] = dict( total_wan=sum(bd.values()), bond_wan=sum(v for k, v in bd.items() if k != "货币基金"), mf_wan=bd.get("货币基金", 0.0), n_bond=len(bond_ps), n_mf=len(mf_held) if acc_name == "TPL" else 0, breakdown=OrderedDict((k, bd[k]) for k in PTYPE_ORDER if bd[k] > 0), bond_duration=dur, bond_coupon=(sum(a * b for a, b in _cps) / _twc) if _twc else None, bond_ytm=(sum(a * b for a, b in _ytms) / _twy) if _twy else None) mf_total = sum(m["amount"] for m in mf_held) book_total_wan = sum(p["wan"] for p in book_pos) inv_total_wan = sum(i["face_wan"] for i in inv) asset_stock = sum(x["principal"] for x in stock if x["side"] == "资产") liab_stock = sum(x["principal"] for x in stock if x["side"] == "负债") if inv_declared_total is not None: s = round(inv_total_wan, 2) if abs(inv_declared_total - s) > 0.5: q("中", "库存勾稽不符", "现券库存", "现券库存「合计」行与明细求和不一致", "合计 %.2f 万 / 明细求和 %.2f 万" % (inv_declared_total, s), at="「合计」行") # ── 本周 / 本月「未到期」窗口（§总览 KPI）────────────────────────── # 定义：到期日「严格晚于台账日 T」、且落在本周（周一起算的自然周）/ 本月（自然月）内的存量， # 即「目前尚未到期、但将在本窗口内到期」的资产 / 负债规模。T 当日到期的部分不计入。 _T = datetime.date.fromisoformat(T) _start = (_T + datetime.timedelta(days=1)).isoformat() week_end = (_T + datetime.timedelta(days=6 - _T.weekday())).isoformat() _me = datetime.date(_T.year + (1 if _T.month == 12 else 0), (1 if _T.month == 12 else _T.month + 1), 1) month_end = (_me - datetime.timedelta(days=1)).isoformat() def undue_win(end): span = days_between(T, end) # T 之后到窗口末的天数 r = {} for side, k in (("资产", "asset"), ("负债", "liab")): xs = [x for x in stock if x["side"] == side and 1 <= x["remaining"] <= span] r[k] = sum(x["principal"] for x in xs) r[k + "_n"] = len(xs) # 卡右侧「到期日 / 业务 / 到期量」明细：行 =「到期日 × 业务」，金额存**元**（整数）。 # ⚠ V2.21：这里同时成为**切片日**那一侧的数据来源（slice_days 逐日预计算同名键）， # 前端 dueRows() 一律直读，于是「当期」与「切片」共用一个出处。 # 前端仍保留 positions 现算的兜底分支（老快照里没有这些键时用）， # 并由 test_slice.js 断言「两份实现在 T 日逐行相同」——口径说明必须配断言。 by = {} for x in xs: by.setdefault(x["maturity"], {}) by[x["maturity"]][x["sheet"]] = by[x["maturity"]].get(x["sheet"], 0.0) + x["principal"] rows = [] for m in sorted(by): # ⚠ F17：排序键必须**完全确定**（原因见 slice_days 同处的长注释） for sh in sorted(by[m], key=lambda s: ( _ord[side].index(s) if s in _ord.get(side, []) else 99, s)): rows.append("%s|%s|%d" % (m[5:], _disp.get(sh, sh), int(round(by[m][sh])))) r["rows_" + k] = ";".join(rows) return r _uw, _um = undue_win(week_end), undue_win(month_end) undue = dict(win_start=_start, week_end=week_end, month_end=month_end, week_asset=_uw["asset"], week_asset_n=_uw["asset_n"], week_liab=_uw["liab"], week_liab_n=_uw["liab_n"], month_asset=_um["asset"], month_asset_n=_um["asset_n"], month_liab=_um["liab"], month_liab_n=_um["liab_n"], # 两个窗口**各存一份**明细：只存一份（原先 month 覆盖 week 的写法） # 会让「本周未到期」卡在切片日拿月度明细顶包 —— 表头写本周、金额是本月。 rows_week_asset=_uw["rows_asset"], rows_week_liab=_uw["rows_liab"], rows_month_asset=_um["rows_asset"], rows_month_liab=_um["rows_liab"]) # ── 到期窗口分类别口径（§到期日历 KPI）───────────────────────────── # 窗口 = T 起未来 N 个自然日（含 T 当日，与「今日到期 / 未来 N 日」标签一致）。 # 资产到期 = 资金业务资产端本金（存量区，含 T 日到期）+ 债券业务到期面值（持仓汇总块剩余量）； # 负债到期 = 资金业务负债端本金。货币基金「随时可赎」无固定到期日，不计入。 # 口径统一为【本金 / 面值】，不含应计利息 —— 与旧卡片 due_today / due_7 等的口径保持连续。 due_win = [] for _lbl, _n in (("今日到期", 0), ("未来 7 日", 7), ("未来 30 日", 30), ("未来 90 日", 90)): _fa = [x for x in live if x["side"] == "资产" and 0 <= x["remaining"] <= _n] _fl = [x for x in live if x["side"] == "负债" and 0 <= x["remaining"] <= _n] _bd = [p for p in book_pos if p["bond_maturity"] and 0 <= days_between(T, p["bond_maturity"]) <= _n] _a = sum(x["principal"] for x in _fa) _b = sum(p["wan"] for p in _bd) * WAN _l = sum(x["principal"] for x in _fl) due_win.append(dict(label=_lbl, days=_n, asset=_a, asset_n=len(_fa), bond=_b, bond_n=len(_bd), asset_all=_a + _b, liab=_l, liab_n=len(_fl))) # ── 历史存量序列（§历史趋势）────────────────────────────────────── # 台账是「交易流水累积」，没有历史持仓快照（snapshot 只记当日汇总），但任一时点的存量 # 可以由流水精确重建：一笔业务在其 [起息日/交易日, 到期日) 区间内计入存量 —— 与 # 「存量 = 到期日严格晚于当日」同一条规则，因此序列末点（T 日）必然等于当期存量 KPI。 # 下方做对账断言并写入数据质量清单，偏差不许静默（§32）。 # 窗口：固定起点 HIST_START_FIXED（2026-01-01）逐日至台账日 T，**不滚动**；窗口之前的 # 增量在首日一次性结算 ⇒ 首点 = 该日真实存量。口径见技术文档「历史存量」与 MEMORY 铁律。 # 边界守卫：若台账日早于固定起点（误用旧台账），range(...)+1 ≤ 0 ⇒ hdays 为空， # 1421 行 hist_fa[-1]（打印）与 1288 行 _hi（对账）都会 IndexError。此时回退到旧的 # 「近 12 个月滚动」口径并写数据质量清单 —— 既不崩、也不静默（§32）。 HIST_START = HIST_START_FIXED if Td < HIST_START: HIST_START = D(Td.year - 1, Td.month, 1) q("高", "历史窗口起点晚于台账日", "历史存量序列", "台账日 %s 早于固定起点 %s，已回退为近 12 个月滚动口径" % (T, HIST_START_FIXED.isoformat()), "请核对「台账日期」Sheet 的台账日，或确认是否误用了旧台账", at="台账日期") hdays = [(HIST_START + datetime.timedelta(days=k)).isoformat() for k in range((Td - HIST_START).days + 1)] def _hseries(ev): """{日期: 增量} → 与 hdays 逐日对齐的累计值列表（亿元，保留 4 位小数）""" keys, out, cur, i, n = sorted(ev), [], 0.0, 0, len(ev) for day in hdays: while i < n and keys[i] <= day: cur += ev[keys[i]] i += 1 out.append(round(cur / YI, 4)) return out ev_fa, ev_fl = defaultdict(float), defaultdict(float) # V2.29：另起一份**按业务（台账 Sheet）拆分**的增量表，供总览页两张历史图 # （同业资产 / 同业负债历史存量）的级联多选（二级 = 具体业务）使用。 # 与原汇总走**同一次循环、同一个 f、同一对起息/到期日、同一个 principal** —— # 两条路径只在「分不分桶」上不同，故必然逐位一致（下方 _by_biz 守卫会当场验）。 # 原汇总路径一个字都没动 ⇒ 已发布数值零变化。 ev_fa_b = defaultdict(lambda: defaultdict(float)) ev_fl_b = defaultdict(lambda: defaultdict(float)) for f in fund: if not f["start_date"] or not f["maturity"] or f["maturity"] <= f["start_date"]: continue tgt = ev_fa if f["side"] == "资产" else ev_fl tgt[f["start_date"]] += f["principal"] tgt[f["maturity"]] -= f["principal"] # 到期日当天已结清 → 当日即出表 bgt = ev_fa_b if f["side"] == "资产" else ev_fl_b bgt[f["sheet"]][f["start_date"]] += f["principal"] bgt[f["sheet"]][f["maturity"]] -= f["principal"] ev_mf = defaultdict(float) for m in mf: s0 = m["buy"] or m["start"] if not s0: continue ev_mf[s0] += m["amount"] if m["redeem"]: ev_mf[m["redeem"]] -= m["amount"] # 债券：改用**唯一余额引擎**（N08）—— 与展示日切片共用同一份逐笔结算账本。 # ⚠ 增量日期取「入库生效日 start（= 结算日，缺则交易日）」而非交易日：T+1 成交在交易日 # 尚未入库，若按交易日入账，历史曲线会提前一天把未入库的券算进存量，末点因此高于 # 持仓汇总块 / 当期 KPI（曾表现为「历史序列对账不符」）。 # ⚠ 归零日取「有效到期日 mat_eff」= 题注结清日与法定到期日取早，理由见 early_payoff()。 # 这两条口径连同「逐笔事件」现在都只写在 bond_settle_ledger() 里 —— 事件集合与旧实现 # 等价 ⇒ history 序列逐字不变（只有质量条目按键名排序，顺序可能变化）。 _led = bond_settle_ledger(bonds, book_pos, T) ev_bt = defaultdict(lambda: defaultdict(float)) for _key in sorted(_led, key=lambda k: (k[0] or "", k[1] or "")): _v = _led[_key] for _d0, _amt in _v["events"]: ev_bt[_v["ptype"]][_d0] += _amt if _v["anomaly"]: q("中", "债券到期日异常", "债券流水", "%s（%s）到期日 %s 不晚于最后一笔交易日 %s，未做到期归零（历史序列偏高）" % (_key[0], _key[1], _v["mat"], _v["last"]), at="%s（%s）" % (_key[0], _key[1])) hist_fa, hist_fl = _hseries(ev_fa), _hseries(ev_fl) hist_by_type = {t: _hseries(ev_bt[t]) for t in PTYPE_ORDER if t != "货币基金"} hist_by_type["货币基金"] = _hseries(ev_mf) ev_bond = defaultdict(float) for _p, _ev in ev_bt.items(): for _d0, _v in _ev.items(): ev_bond[_d0] += _v hist_bond = _hseries(ev_bond) ev_inv = defaultdict(float) for _d0, _v in ev_bond.items(): ev_inv[_d0] += _v for _d0, _v in ev_mf.items(): ev_inv[_d0] += _v hist_inv = _hseries(ev_inv) # 序列末点 vs 当期 KPI 对账（口径同源，不一致即为实现缺陷，必须显式报出） # ⚠ 报「总差额」等于没说 —— 没人能从 0.20 亿反推是哪只券。既然债券序列是逐券重建的， # 就顺手逐券比对「流水推算 vs 持仓汇总块」，把差异券点名写进 detail（制单人改一格即可）。 _bk, _fk = defaultdict(float), defaultdict(float) for p in book_pos: _bk[(strip_code(p["code"]), p["account"])] += p["wan"] for b in bonds: if not b["settled"]: continue _me = b.get("mat_eff") or b.get("bond_maturity") if _me and _me <= T: continue _fk[(strip_code(b["code"]), b["account"])] += b["face_wan"] * STDDIR[b["direction"]] _rec = sorted((((_fk[k] - _bk.get(k, 0.0)), k) for k in set(_fk) | set(_bk)), key=lambda x: -abs(x[0])) _rec_hint = "；".join("%s（%s）流水推算 %.2f 万 / 汇总块 %.2f 万" % (k[0], k[1], _fk.get(k, 0.0), _bk.get(k, 0.0)) for _d, k in _rec if abs(_d) >= 0.5) _hi = len(hdays) - 1 for _nm, _got, _want in (("资金资产存量", hist_fa[_hi], asset_stock / YI), ("资金负债存量", hist_fl[_hi], liab_stock / YI), ("债券持仓", hist_bond[_hi], book_total_wan / WAN), ("货币基金", hist_by_type["货币基金"][_hi], mf_total / YI), ("投资业务存量", hist_inv[_hi], (book_total_wan * WAN + mf_total) / YI)): if abs(_got - _want) > 0.01: _dt = "窗口 %s ~ %s" % (HIST_START.isoformat(), T) if _nm == "债券持仓" and _rec_hint: _dt += "；逐券归因：" + _rec_hint q("高", "历史序列对账不符", "历史存量序列", "%s 序列末点 %.4f 亿 ≠ 当期 KPI %.4f 亿" % (_nm, _got, _want), _dt, at="%s 序列" % _nm) # ── V2.29 按业务（台账 Sheet）拆分的两条序列：供总览页两张历史图的级联多选二级叶子 # 行序严格照 FUND_SHEETS（_ord 已在上面按 side 分好）⇒ 与前端叶子顺序天然一致。 hist_fa_b = {s: _hseries(ev_fa_b[s]) for s in _ord["资产"]} hist_fl_b = {s: _hseries(ev_fl_b[s]) for s in _ord["负债"]} # 🔴 守卫（两条独立实现互证）：按业务拆分后线性加回去，必须等于上面那条汇总序列。 # 容差 1e-3（亿元）而非严格相等 —— 两条路径各自先 round 到 4 位再累加，浮点加法不 # 可结合，最大累积误差 = 分桶数 × 0.5e-4（8 桶 ⇒ 4e-4）< 1e-3。 # 不相等 = 拆分漏了 / 多了业务 ⇒ 拒绝出产物（与「CAPS 不符即 exit(3)」同一纪律： # 宁可不出，不可出错）。 # ⚠⚠ 临时变量一律带 `_bz_` 前缀：main() 是个 3400 行的巨型函数，`_tot` / `_bad` / # `_acc` / `_side` / `_s` / `_i` / `_v` 这些短名**全都已被别处占用**——第一次写成本轮 # 这样的裸名，`_tot` 当场覆盖了下面风险测算的 `_tot` dict，直接 TypeError 崩在 3422 行。 # 往这个函数里加局部变量之前，先 grep 一遍同名。 for _bz_side, _bz_bk, _bz_tot in (("资产", hist_fa_b, hist_fa), ("负债", hist_fl_b, hist_fl)): _bz_acc = [0.0] * len(hdays) for _bz_k in _bz_bk.values(): for _bz_i, _bz_v in enumerate(_bz_k): _bz_acc[_bz_i] += _bz_v _bz_bad = [(hdays[_bz_i], _bz_acc[_bz_i], _bz_tot[_bz_i]) for _bz_i in range(len(_bz_tot)) if abs(_bz_acc[_bz_i] - _bz_tot[_bz_i]) > 1e-3] if _bz_bad: sys.stderr.write("[FATAL] 资金业务%s端「按业务拆分」序列求和 ≠ 汇总序列，" "%d 处不符，首处 %s：拆分 %.4f ≠ 汇总 %.4f\n" % (_bz_side, len(_bz_bad), _bz_bad[0][0], _bz_bad[0][1], _bz_bad[0][2])) sys.exit(3) history = dict(start=HIST_START.isoformat(), end=T, n=len(hdays), unit="亿元", types=list(PTYPE_ORDER), fund_asset=hist_fa, fund_liab=hist_fl, fund_asset_by_biz=hist_fa_b, fund_liab_by_biz=hist_fl_b, inv=hist_inv, bond=hist_bond, mf=hist_by_type["货币基金"], inv_by_type=hist_by_type) # ── 展示日切片（页 0「总览驾驶舱」/ 页 1「资金业务」/ 页 3「投资业务」底部时间轴） # 逐日预计算页面级汇总聚合，前端拖动时间轴时只「取第 i 天」并把值贴回 DATA 的副本， # 不重算任何口径。末点（D = 台账日）与当期对象逐字段对账（见下方「切片对账守卫」）。 _sl = slice_days(hdays, fund, mf, bonds, book_pos, lv2_order, DUR_ORDER) overview = dict( asset_stock=asset_stock, liab_stock=liab_stock, net_stock=asset_stock - liab_stock, book_total=book_total_wan * WAN, inv_total=inv_total_wan * WAN, mf_total=mf_total, invest_total=book_total_wan * WAN + mf_total, flow_n=len(fund), stock_n=len(stock), matured_n=len(matured), # T 当日到期（已结清，不计存量，但计入现金流与到期日历） # N06：T 日到期严格按 remaining==0 计，与下面 tday_asset/liab 同源。旧 `len(live)-len(stock)` # 会把「缺生效日 / 未来生效」这类 remaining>0 但不在 stock 的记录错算成 T 日到期。 live_n=len(live), tday_n=len([f for f in live if f["remaining"] == 0]), tday_asset=sum(f["principal"] for f in live if f["remaining"] == 0 and f["side"] == "资产"), tday_liab=sum(f["principal"] for f in live if f["remaining"] == 0 and f["side"] == "负债"), due_today=cum_due(0), due_7=cum_due(7), due_30=cum_due(30), due_90=cum_due(90), book_n=len(book_pos), inv_n=len(inv), bond_pos_n=len(book_pos), mf_n=len(mf_held), recon_n=len(recon), recon_diff_n=sum(1 for r in recon if abs(r["diff_wan"]) >= 0.5), recon_diff_amt=sum(abs(r["diff_wan"]) for r in recon if abs(r["diff_wan"]) >= 0.5) * WAN, # 三方核对（同业系统快照）：拉取时间 == 台账日期才启用；否则退回两方核对 recon3_on=bool(third_on), recon3_at=third_meta["pull"] or "", recon3_sheet=third_meta["sheet"] or "", recon3_n=len(third), recon3_rows=third_meta["rows"], recon3_scope=third_types, recon3_out_n=third_out_n, recon3_miss_n=third_miss_n, # 「不符项」= 能归因到具体一方的 + 同业系统缺券但两方自己还打架的（后者仍是真的账实不符）。 # ⚠ 必须与前端「差异清单」逐项一致，否则卡片数 ≠ 表体行数，用户第一个就会问这个。 recon3_diff_n=sum(1 for r in recon if r["verdict"] and r["verdict"] != "三方一致" and not (r["verdict"] == "同业系统缺该券" and abs(r["diff_wan"]) < 0.5)), recon3_diff_amt=sum((r["err3"] or abs(r["diff_wan"])) for r in recon if r["verdict"] and r["verdict"] != "三方一致" and not (r["verdict"] == "同业系统缺该券" and abs(r["diff_wan"]) < 0.5)) * WAN, recon3_ok_n=sum(1 for r in recon if r["verdict"] == "三方一致"), recon3_unit_n=sum(1 for r in recon if r["verdict"] == "同业系统缺该券" and abs(r["diff_wan"]) < 0.5), inv_declared_total=inv_declared_total, acc={k: dict(v) for k, v in acc_sum.items()}, no_block_sheets=no_block, undue=undue, # ⚠ F02：quality_n / quality_high / profit_* 这 10 个字段是页 5（数据质量）、页 7（盈利预测）的 # 隐私统计，前端 O.xxx 零消费（各隐私页读自己的 quality / profit_summary 档，不读 overview）。 # 它们的存在只会把隐私页的汇总泄露给「基础 5 页」档用户 ⇒ 已从 overview 摘除。 ) bnames = list(BUCKETS_R) + ["逾期"] bucket_table = [] for side in ("资产", "负债"): row = dict(side=side) for b in bnames: xs = [x for x in stock if x["side"] == side and x["bucket"] == b] row[b] = sum(x["principal"] for x in xs) row[b + "_n"] = len(xs) a = agg([x for x in stock if x["side"] == side]) row["total"] = a["principal"] if a else 0 # total_n = 该方向存量笔数。资金业务页「到期区间分布」的合计行原本自己数 # positions.filter(side).length —— 那是同一事实的第二份来源（前端重算）， # 这里一并给出，前端直接取，杜绝两处口径分叉。 row["total_n"] = a["n"] if a else 0 bucket_table.append(row) detail = [] for f in fund: detail.append(dict(id=f["id"], kind="资金业务", sheet=f["sheet"], side=f["side"], lv2=f["lv2"], account="", code=f["code"], name=f["name"], counterparty=f["counterparty"], principal=f["principal"], rate=f["rate"], start=f["start_date"], maturity=f["maturity"], remaining=f["remaining"], bucket=f["bucket"], stock=("未知" if f["start_date"] is None else ("未生效" if f["start_date"] > T else ("存量" if f["remaining"] > 0 else ("T日到期" if f["remaining"] == 0 else "已到期")))), interest=f["interest"], cashflow=f["cashflow"], trader=f["trader"], note=f["note"], mat_shift=f.get("mat_shift"), interest_shift=f.get("interest_shift"), cashflow_shift=f.get("cashflow_shift"))) for m in mf: detail.append(dict(id=m["id"], kind="货币基金", sheet="货币基金", side="资产", lv2="货币基金", account="TPL", code=m["code"], name=m["name"], counterparty=m["manager"], principal=m["amount"], rate=None, start=m["start"], maturity=m["maturity"], remaining=m["remaining"], bucket=m["bucket"], stock="持有中" if m["held"] else "已赎回", interest=None, cashflow=m["amount"], trader="", note=m["note"])) for p in book_pos: detail.append(dict(id="P" + str(p["code"]), kind="债券持仓", sheet=p["sheet"], side="资产", lv2="债券", account=p["account"], code=p["code"], name=p["name"], counterparty="", principal=p["wan"] * WAN, rate=None, start=None, maturity=p["bond_maturity"], remaining=None, bucket="", stock="持仓", interest=None, cashflow=None, trader="", note=p["ptype"])) # ── F08：发布前质量门槛（默认阻断 + 可强制放行 + 放行留痕）────────────────── # 位置刻意选在**第一次写盘之前**：一旦阻断，磁盘上不留任何半成品 # （data.json 不写、快照不写 ⇒ build.py 也无从生成产物 ⇒ 云库也拿不到新数据）。 # ⚠ 「严重」只来自解析期的「缺失Sheet」（结构性），所以放在这个位置能覆盖全部严重项。 _sev = severe_items(quality) if _sev and not ALLOW_SEVERE: print("✗ 存在 %d 项严重质量问题，已中止（**未写 data.json、未写快照、未生成任何产物**）：" % len(_sev)) for _x in _sev: print(" · [%s] %s / %s：%s" % (_x["sheet"], _x["cat"], _x["at"], _x["desc"])) print(" 缺 Sheet ⇒ 任何汇总都是错的，请先补齐台账。") print(" 如确需放行：python etl/etl.py --allow-severe" "（产物与页面都会带「已放行 N 项严重问题」的橙色横幅）") sys.exit(2) _waived = None if _sev: _waived = dict(n=len(_sev), cats=sorted({_x["cat"] for _x in _sev}), at=sorted({str(_x["at"]) for _x in _sev}), at_date=T) print("⚠ 已**放行** %d 项严重质量问题（%s）—— 产物与页面都会带「已放行」标记，" "请在使用前核实" % (len(_sev), "、".join(_waived["cats"]))) os.makedirs(SNAP_DIR, exist_ok=True) with open(os.path.join(SNAP_DIR, "%s.json" % T), "w", encoding="utf-8") as fo: json.dump(dict(ledger_date=T, asset_stock=asset_stock, liab_stock=liab_stock, invest_total=overview["invest_total"], stock_n=len(stock), tday_n=overview["tday_n"], due_today=overview["due_today"], due_7=overview["due_7"], due_30=overview["due_30"], due_90=overview["due_90"], book_total=overview["book_total"], inv_total=overview["inv_total"], recon_diff_n=overview["recon_diff_n"], week_asset=undue["week_asset"], week_liab=undue["week_liab"], month_asset=undue["month_asset"], month_liab=undue["month_liab"], profit_surplus_wan=profit_summary["合计"]["surplus_wan"], profit_cost_wan=profit_summary["合计"]["cost_wan"], profit_lot_n=profit_summary["合计"]["n_lot"], quality_high=sum(1 for x in quality if x["level"] in ("严重", "高")), ), fo, ensure_ascii=False, indent=1) # ── 数据能力版本的自检（声明 vs 证据）────────────────────────────────── # ⚠ 必须**改声明或改实现**，不许让二者悄悄分叉：声明多了 ⇒ 前端拿旧数据也能出 # 「0.00 亿元」的假结论（N12）；声明少了 ⇒ 前端无谓降级、白丢功能。 _caps_ev = produced_caps(_sl, fund + mf + bond_master + bonds, profit_lots) if not CAPS_PRODUCED <= _caps_ev: print("✗ 数据能力声明与实现分叉：CAPS_PRODUCED 声明了 %s，但实际产出只有 %s" % (sorted(CAPS_PRODUCED), sorted(_caps_ev))) print(" ⇒ 请二选一：补上产出实现，或改 CAPS_PRODUCED / SCHEMA。已中止（未写 data.json）。") sys.exit(3) if _caps_ev - CAPS_PRODUCED: print("⚠ 产出了未声明的能力 %s（前端会误判为旧数据、无谓降级）—— 请补进 CAPS_PRODUCED" % sorted(_caps_ev - CAPS_PRODUCED)) meta = dict(ledger_date=T, file=os.path.basename(LEDGER_FILE), sheets=len(wb), generated=datetime.datetime.now().strftime("%Y-%m-%d %H:%M"), # 数据能力版本（第三个「版本」，与 WBC_BUILD / WBC_DOC_VER 正交，见顶部常量区） schema=SCHEMA, caps=sorted(CAPS_PRODUCED), # V2.50 工作日历（挂 meta ⇒ 零顶层键连锁）：前端「向后顺沿至工作日」勾选框用它判节假日。 holidays=sorted(HOLIDAYS_2026), workdays=sorted(WORKDAYS_2026), # N38：工作日历覆盖年份。HOLIDAYS/WORKDAYS 只精确到 2026；超出该年的顺延 # 按「周一~周五」近似（next_workday 兜底）。前端据此披露「顺延超出覆盖范围」， # 避免把 2027 年的近似结果当成确定的清算营业日。 holiday_years=[2026], # N38：日历**规则版本**（「可查」的那一维）——节假日/调休来自国办发明电〔2025〕7 号 # 的 2026 年安排，统一银行间市场人民币口径。跨年换规则源时必须同步更新本字段与 # HOLIDAYS/WORKDAYS 表，否则前端「覆盖范围」提示会与实际日历脱节。 holiday_rule="国办发明电〔2025〕7号（2026 年）· 银行间市场人民币") if _waived: # F08 放行留痕：**只有真放过行才写这个键**（无放行 ⇒ 键不存在 ⇒ 前端不显示横幅）。 # ⚠ 一定要挂在 meta 里，**绝不新开顶层键** —— 顶层键每多一个都要连锁改 4 处 # （cloud_sync.BASIC_KEYS → 云键数 → test_tdz_guard 的 N_KEYS → test_online_e2e 的 N_BASIC）， # 而 meta 已在 basic 档 ⇒ 挂进去是零连锁。 meta["waived"] = _waived # ══════════════════════════════════════════════════════ 年度目标（V2.56） # 数据源：<工作区>/年度目标页面构建/（含一级子目录，如净息差年初到月底/）： # ① 净息差-*.xls（XML Spreadsheet 2003）「年初至月底」累计快照（0101-MMDD 或 MMDD 命名） # → 任意区间实际值由「累计快照天数加权相减」重建；起始非 0101 的区间文件（当月报表）不入快照 # ② *卖出成交明细.xlsx → 逐笔资本利得（税前，元），前端按选定区间聚合 # ③ *金市考核完成进度.xlsx → 「底稿」sheet（行骨架 + 考核目标 + 无快照行兜底 + 核对基准） # 口径（施主定义）： # · 信用债、ABS 不适用综合收益（composite=None），不参与综合收益加权。 # · 国债/地方债：实际值 = 区间投资收益 + 折算后收益/4 − 税前资本利得。 # · 政金债/ABS：实际值 = 折算后收益 − 税前资本利得；其余品种取折算后收益。 # · 有资本利得时实际税后（含资本利得）= 实际值 + 资本利得税前/1.06；无数据保持空值。 # · 资本利得时间口径 = 页面选定的统计区间（默认 = 年初至今）。 # · 底稿提供「考核目标 / 日均规模 / 利率」与行骨架；「实际值」重算后与「1-N月」sheet 核对（容差 0.02 万元）。 # · 前端区间选择：起始只能选每月一号、截止为各快照月末；目标三列固定不变（施主 2026-10-10 拍板）。 # ── 年度考核目标（V2.67 起金市考核完成进度文件不再上传，此处固化）──────────────────── # 每行 (name, bond, scale_t, rate_t)： # scale_t = 日均规模考核目标（亿元）；rate_t = 利率考核目标（小数）； # 年度总目标（万元）= scale_t × rate_t × 10000（代码派生，前端按「全年天数」比例折算）。 # 数值取自金市考核「底稿」sheet 的 C/F 列基线（2026 年度），实施时已逐行核对。 # 🔴 N40 契约：这批常量是**某个年度的基线**，跨年不得静默沿用（365/366 折算、考核目标都会变）。 # TARGET_YEAR 声明它们对应的年度；台账日年份 ≠ TARGET_YEAR 时显式告警（下方 _year 判定）， # 而不是把 2026 的考核目标悄悄套到 2027。 TARGET_YEAR = 2026 TARGET_RULE = "V2.67 固化（2026 年度金市考核基线）" TARGET_ASSET = [ ("一、同业资产", False, 200.0, 0.0222960959104782), ("1、债券投资", False, 142.2, 0.0248924636948138), ("1.1 国债", True, 85.0, 0.0246738933118453), ("1.2 政金债", False, 1.2, 0.0280485421573245), ("1.3 地方债", True, 50.0, 0.0245), ("1.4 同业存单", False, 2.0, 0.0165), ("1.5 ABS", False, 2.0, 0.03114), ("1.6 交易性", False, 2.0, 0.02), ("2、货币基金", False, 25.0, 0.018), ("3、存放同业", False, 15.0, 0.015), ("4、同业拆出", False, 4.0, 0.016), ("5、同业借款", False, 2.0, 0.026), ("6、逆回购", False, 11.8, 0.015), ("二、存款准备金", False, 37.5, 0.012), ("资产合计", False, 237.5, 0.0206703965561922), ] TARGET_LIAB = [ ("一、同业负债", False, 125.0, 0.017504), ("1、同业存款-定期", False, 30.0, 0.0181), ("2、同业存款-活期", False, 0.0, 0.0075), ("3、正回购", False, 25.0, 0.014), ("4、拆入", False, 35.0, 0.0185), ("5、存单", False, 35.0, 0.0185), ("二、股东权益", False, 46.3, 0.0), ("三、再贷款", False, 5.0, 0.015), ("四、资产负债资金缺口", False, 61.2, 0.017504), ("负债合计", False, 237.5, 0.0140389254736842), ] _target_dir = TG_DIR _nxc_files = [] # 全部「年初至月底」累计净息差快照（含子目录） _sell_file = None if os.path.isdir(_target_dir): _dirs = [_target_dir] + [os.path.join(_target_dir, d) for d in sorted(os.listdir(_target_dir)) if os.path.isdir(os.path.join(_target_dir, d)) and not d.startswith((".", "~$"))] for _dr in _dirs: for _fn in sorted(os.listdir(_dr)): if _fn.startswith("~$") or _fn.startswith("."): continue _lp = _fn.lower() _fp = os.path.join(_dr, _fn) if _lp.startswith("净息差") and _lp.endswith(".xls"): _nxc_files.append(_fp) elif "卖出成交明细" in _fn and _lp.endswith(".xlsx"): _sell_file = _fp # 净息差报表业务品种 → 底稿项目名（叶子行映射；账簿过滤见 _nxc_snapshot）。 # V2.56 起补齐：政金债/同业存单（累计报表里有、当月为 0），同业借款/同业拆出。 _NXC_TO_DG = { "货币基金": "2、货币基金", "国债": "1.1 国债", "政金债": "1.2 政金债", "地方政府债": "1.3 地方债", "同业存单": "1.4 同业存单", "资产证券化债券": "1.5 ABS", "存放同业活期": "3、存放同业", "存放同业定期": "3、存放同业", "同业拆出": "4、同业拆出", "同业借款": "5、同业借款", "质押式逆回购": "6、逆回购", "同业存放定期": "1、同业存款-定期", "质押式正回购": "3、正回购", "同业拆入": "4、拆入", "存单发行": "5、存单", "央行支小再贷款": "三、再贷款", } # 债券类（免税折算：综合收益 = 区间投资收益 + 折算后/4）的底稿项目名。 # ⚠ 2026-10-10 实测修正：政金债 H=J（无免税折算）⇒ 移出债券类、按非债券直接取折算后 J。 _BOND_ITEMS = {"1.1 国债", "1.3 地方债"} # 需「减资本利得」的品种：债券类（国债/地方债）+ ABS + 政金债。 # ⚠ 政金债：H=J（无免税折算、不做 H+J/4），且当前「持有到期」不卖出 ⇒ 资本利得恒 0。 # 但口径上它属于「债券、若卖出就产生资本利得」——纳入 _CAP_ITEMS 后，当前减 0 结果不变， # 将来政金债一旦卖出，公式自动正确（施主 2026-10-10 拍板）。 # ⚠ ABS 是「资产证券化债券」，H=J（不做 H+J/4），但有卖出资本利得 ⇒ 实际值 = 折算后 J − 资本利得。 _CAP_ITEMS = {"1.1 国债", "1.2 政金债", "1.3 地方债", "1.5 ABS"} # 卖出明细「债券属性」→ 底稿项目名（资本利得计国债/地方债/政金债/ABS）。 # N40：补齐「政金债」映射 —— 当前政金债持有到期不卖出（资本利得恒 0），但映射必须齐， # 否则将来一旦卖出，会静默漏减资本利得（单靠 _CAP_ITEMS 并入集合保证不了正确）。 _SELL_ATTR_TO_DG = {"国债": "1.1 国债", "地方政府债": "1.3 地方债", "政金债": "1.2 政金债", "ABS": "1.5 ABS"} target = None # N36：净息差（累计快照）是年度目标的**必要**来源（决定期间基准与 snaps），卖出明细是**可选** # 资本利得修正。原来要求两者同时存在（and）⇒ 只上传净息差也会产出 target=null，导致 # 网页常规更新把云端已发布的年度目标整体覆盖为空。改为「有净息差即可生成 target」， # 卖出明细缺失时 lots 为空、资本利得为 null（前端合并时保留云端旧 lots）。 if _nxc_files: try: _sell_diag = [] _sell_wb = load_workbook(_sell_file, _sell_diag) if _sell_file else {} # F11：卖出明细的 Excel 解析边界告警同进质量清单（sheet 名写「年度目标」）。 for _dm in _sell_diag: q("高", "Excel解析边界", "年度目标", _dm, at="整表") # 年份取台账日（不再依赖金市考核文件名） _year = int(T[:4]) if T else 2026 # N40：目标常量年度契约 —— 台账日跨年时，考核目标/365·366 折算仍是上一年的基线， # 必须显式告警，不得静默沿用（否则 2027 的年度目标会套着 2026 的考核值）。 if _year != TARGET_YEAR: q("中", "年度目标核对不符", "年度目标", "年度考核目标固化于 %d 年度（%s），当前台账日年份为 %d —— 请确认是否需按新年度更新考核目标" % (TARGET_YEAR, TARGET_RULE, _year), at="整表") # ── 累计净息差快照：{截止日ISO: {底稿项目名: [H元, J元, D万, F万]}} ── # 文件名两种形态：`…0101-0831.xls`（区间，起点须 0101）/ `…0831.xls`（纯截止日）。 # 起点非 0101 的区间文件（如 0901-0930 当月报表）不进快照 —— 当月值一律由 # 累计快照「天数加权相减」重建（实测 15/15 品种逐位对上底稿）。 _snaps = {} _snap_src = {} # 截止日 → 源文件名（N40：同截止日多源冲突门） _nxc_diag = [] # N40：净息差报表的缺项告警（H/J 有值但 D/F 缺列） for _fp in sorted(_nxc_files): _base = os.path.basename(_fp) _m = re.search(r"(\d{4})-(\d{4})", _base) _end_md = None if _m: if _m.group(1) == "0101": _end_md = _m.group(2) else: _m2 = re.search(r"(\d{4})\.xls$", _base, re.I) if _m2: _end_md = _m2.group(1) if not _end_md: continue _end_iso = D(_year, int(_end_md[:2]), int(_end_md[2:])).isoformat() _val = _nxc_snapshot(_fp, _NXC_TO_DG, _nxc_diag) # N40：同截止日多源冲突门。`0101-0831.xls` 与 `0831.xls` 会映射到同一截止日—— # 内容一致 = 同一份数据的两种命名（去重，无害）；内容不一致 = 真冲突，必须阻断， # 否则后处理的文件静默覆盖前者、期间口径对不上（正是审查报告点名的覆盖风险）。 if _end_iso in _snaps: if _snaps[_end_iso] != _val: raise ValueError( "同一截止日 %s 有多个净息差快照且内容冲突（%s vs %s）——请只保留一份权威快照" % (_end_iso, _snap_src[_end_iso], _base)) continue _snaps[_end_iso] = _val _snap_src[_end_iso] = _base # N40：净息差报表的缺项告警进质量清单（H/J 有值但 D/F 缺列 → 规模/日均按 0 计入）。 for _dm in _nxc_diag: q("中", "年度目标核对不符", "年度目标", _dm, at="整表") _ends = sorted(_snaps) if not _ends: raise ValueError("无「年初至月底」累计净息差快照（文件名须为 0101-MMDD 或 MMDD）") # 默认统计区间 = 年初至今（施主 2026-10-10 拍板）：起始 = 当年 1 月 1 日， # 截止 = 最新快照月末。此时「一、同业资产」= 年初至今累计日均，与金市考核 # 「1-N月」sheet 对齐（如 1-9月 = 207.20），而非单月值（9月单月 = 206.40）。 _end = _ends[-1] _start = _end[:4] + "-01-01" _prev_end = [x for x in _ends if x < _start] _prev_end = _prev_end[-1] if _prev_end else None def _cumdays(iso): # 年初累计天数（含当日）；任意公共锚点皆可，取同年 1 月 1 日 return (D(int(iso[:4]), int(iso[5:7]), int(iso[8:10])) - D(int(iso[:4]), 1, 1)).days + 1 def _interval(s, e): """[s, e] 区间的累计相减结果。返回 {名称: [H元, J元, D万, F万]}（天数加权）。""" _pe = [x for x in _ends if x < s] _pe = _pe[-1] if _pe else None _ce, _di = _cumdays(e), (D(int(e[:4]), int(e[5:7]), int(e[8:10])) - D(int(s[:4]), int(s[5:7]), int(s[8:10]))).days + 1 _cp = _cumdays(_pe) if _pe else 0 _ce_snap, _pe_snap = _snaps[e], (_snaps[_pe] if _pe else {}) _out = {} for _nm, _c in _ce_snap.items(): _p = _pe_snap.get(_nm) _out[_nm] = [ _c[0] - (_p[0] if _p else 0.0), _c[1] - (_p[1] if _p else 0.0), (_c[2] * _ce - (_p[2] * _cp if _p else 0.0)) / _di, (_c[3] * _ce - (_p[3] * _cp if _p else 0.0)) / _di, ] return _out, _di # ── 卖出明细逐笔（剔汇总行）：[{d,a,g}]，供任意区间前端聚合资本利得 ── _lots = [] for _nm, _grid in _sell_wb.items(): _hdr = {} for _r in sorted(_grid): for _c, _v in _grid[_r].items(): _hdr[str(_v).strip()] = (_r, _c) if "资本利得" in _hdr and "债券属性" in _hdr and "成交日期" in _hdr: break _col_gain = _hdr.get("资本利得", (None, "J"))[1] _col_attr = _hdr.get("债券属性", (None, "K"))[1] _col_date = _hdr.get("成交日期", (None, "B"))[1] _col_book = _hdr.get("账簿", (None, "A"))[1] _hdr_row = _hdr.get("资本利得", (1, "J"))[0] for _r in sorted(_grid): if _r <= _hdr_row: continue _book = str(_grid[_r].get(_col_book, "")).strip() if "合计" in _book: # 剔除汇总行（税前合计/税后合计/…合计） continue _attr = str(_grid[_r].get(_col_attr, "")).strip() # 成交日期：load_workbook 已把日期单元格转成 ISO 字符串（如 '2026-06-15'）， # 直接拿字符串做区间比较（ISO 字符串字典序 == 时间序），别再当序列号 num()。 _dd = str(_grid[_r].get(_col_date, "")).strip() if not _attr or not _dd or dnum(_dd) is None: continue _lots.append(dict(d=_dd, a=_attr, g=num(_grid[_r].get(_col_gain)) or 0.0)) _capgain = defaultdict(float) # 底稿项目名 -> 默认区间资本利得（税前，元） for _lt in _lots: if _lt["d"] < _start or _lt["d"] > _end: continue _dg = _SELL_ATTR_TO_DG.get(_lt["a"]) if _dg: _capgain[_dg] += _lt["g"] # ── 行骨架 + 考核目标：V2.67 起由 TARGET_ASSET/TARGET_LIAB 常量驱动（金市考核文件不再上传）── _asset, _liab = [], [] for _side_label, _defs in (("资产", TARGET_ASSET), ("负债", TARGET_LIAB)): for _name, _is_bond, _scale_t, _rate_t in _defs: _is_cap = _name in _CAP_ITEMS _cost_t = round(_scale_t * _rate_t * 10000.0, 4) # 年度总目标（万元） # 🔴 资本利得一律从卖出明细聚合（元 → 万元） _capgain_wan = _capgain.get(_name) _cap_pre_wan = _capgain_wan / WAN if _capgain_wan is not None else None _iv, _di = _interval(_start, _end) _src = _iv.get(_name) # 🔴 日均规模实际：快照「券面余额(万元)」天数加权差 ÷ 10000 得亿元。 # 无快照行（存款准备金/股东权益/资金缺口/分类行/合计行）沿用常量 scale_t 兜底。 if _src is not None: _scale_a = round(_src[2] / 10000.0, 4) else: _scale_a = _scale_t if _is_bond and has_composite_income(_name): # 国债/地方债：综合收益 = 区间投资收益 + 折算后/4；实际值 = 综合收益 − 资本利得税前 if _src: _h_wan, _j_wan = _src[0] / WAN, _src[1] / WAN _composite = _h_wan + _j_wan / 4.0 _actual = _composite - (_cap_pre_wan or 0.0) else: _composite = _actual = 0.0 elif _src: # 非债券类：实际值 = 折算后（税前）；ABS 等 _CAP_ITEMS 再减资本利得 _actual = _src[1] / WAN if _is_cap: _actual -= (_cap_pre_wan or 0.0) _composite = _actual else: # 无快照的行（存款准备金/股东权益/资金缺口/分类/合计行）：实际值按 0 # （前端 _tgBuild 会对特殊行用固定值/配平重算，分类/合计行按子项重算） _actual = 0.0 _composite = 0.0 # 信用债、ABS 没有综合收益；实际收益及资本利得仍按各自来源计算。 if not has_composite_income(_name): _composite = None # 实际税后（含资本利得，不限债券类）：本期有资本利得就回传实际税后金额 # = 实际值 + 资本利得税后（税前 / 1.06）。与前端 _tgCalc 同规则 —— N44： # ABS 等 _CAP_ITEMS 非债券行在自定义区间能算出 after_tax，默认区间却 null ⇒ 分叉。 _after_tax = None if _actual is not None and _cap_pre_wan is not None: _cap_post_wan = _cap_pre_wan / 1.06 _after_tax = _actual + _cap_post_wan # 实际年化利率（N47）：默认区间叶子也要按「实际 /(规模×10000)×360/区间天数」算， # 与前端 _tgCalc 同规则（不再是恒 None）。仅对「有快照且有效规模 > 0」的叶子计算； # 无快照行（资金缺口/特殊行）保持 None —— 前端自定义区间对这类行同样给 null， # 两边不得分叉。_di 是默认区间天数（_interval 返回），与前端 days 同口径。 _rate_a = None if _src is not None and _scale_a and _scale_a > 0 and _actual is not None: _rate_a = round(_actual / (_scale_a * 10000.0) * (360.0 / _di), 6) _row = dict( name=_name, bond=_is_bond, scale_t=_scale_t, scale_a=_scale_a, rate_t=_rate_t, rate_a=_rate_a, cost_t=_cost_t, cost_a=_actual, # 收益/付息（万元） composite=round(_composite, 4) if _composite is not None else None, actual=round(_actual, 4) if _actual is not None else None, after_tax=round(_after_tax, 4) if _after_tax is not None else None, cap_pre=round(_cap_pre_wan, 4) if _cap_pre_wan is not None else None, cap_post=round(_cap_pre_wan / 1.06, 4) if _cap_pre_wan is not None else None, ) if _side_label == "资产": _asset.append(_row) else: _liab.append(_row) target = dict( period=dict(start=_start, end=_end, src="净息差累计快照相减（" + os.path.basename(_nxc_files[-1]) + "）"), asset=_asset, liab=_liab, totals=dict(spread=None), # V2.56：累计净息差快照 + 卖出明细逐笔 —— 供前端任意区间（起始限每月一号）重算 ends=_ends, snaps=_snaps, lots=_lots, ) print(" ¥ 年度目标 %s~%s：资产 %d 行 / 负债 %d 行" % (_start, _end, len(_asset), len(_liab))) except Exception as _e: target = None q("中", "年度目标未读取", "年度目标", "年度目标页数据读取失败，页面留空", detail=str(_e), at="年度目标") else: if not _nxc_files: _miss = [x for x, f in (("累计净息差报表", _nxc_files and True or None), ("卖出成交明细", _sell_file)) if not f] q("低", "年度目标未接入", "年度目标", "「输入数据/年度目标/」目录缺少数据文件，页面留空", detail="缺：" + "、".join(_miss), at="年度目标") data = dict( meta=meta, overview=overview, branches=branches, branches_all=branches_all, stock_break=stock_break, by_sheet=by_sheet, dep_split=dep_split, mf_matrix=mf_matrix, due_win=due_win, history=history, bucket_table=bucket_table, positions=stock, mf=mf, mf_held=mf_held, calendar=calendar, calendar_inv=calendar_inv, recon=recon, quality=quality, detail=detail, third=dict(sheet=third_meta["sheet"], pull=third_meta["pull"], pulls=third_meta["pulls"], n=len(third), rows=third_meta["rows"], types=third_types, on=bool(third_on), # N05：未启用时页面要能说出**为什么**（原来只有 on=False，用户无从判断该改什么）。 reason=(third_why if not third_on else ""), n_nodate=third_meta["n_nodate"]), matrix={k: dict(v) for k, v in matrix.items()}, matrix_mf=dict(matrix_mf), accounts=accounts, bond_master=bond_master, duration_structure={k: dict(v) for k, v in duration_structure.items()}, dur_by_type={t: {a: dict(v) for a, v in d.items()} for t, d in dur_by_type.items()}, dur_buckets=DUR_ORDER, book_pos=book_pos, inventory=inv, bonds=bonds, risk=risk, profit_lots=profit_lots, profit_summary=profit_summary, profit_by_type=profit_by_type, tpl_dual=tpl_dual, valuation_quality=valuation_quality, buckets=bnames, lv2_order=lv2_order, target=target, # 展示日切片（页 0/1/3 底部时间轴）。逐日页面级汇总聚合，紧凑数值序列式存储： # 每个维度一条 n 长数组、标签只存一份 —— 与 history 同一手法，约 135~300 数/日。 slice=_sl, ) # ══════════════════════════════════════════════ 切片对账守卫（§切片铁律） # slice_days() 是**第二份实现**（main() 那份是本期的权威口径）。两套代码一旦分叉—— # 哪怕只差一个分桶边界、一个排序并列、一次利率归一——页面拖动时间轴到台账日就会与 # 默认视图给出不同的数。这里是唯一防线：把切片末点（D = 台账日）逐路径对回当期对象， # 不一致立刻点名到具体字段并进质量清单（页面可见）。 # ⚠ 不许「只比几个 KPI 就收工」—— V2.18 的教训正是「看起来对」而两列同时落空。 _MISS = object() def _gp(o, p): """按切片路径取值（支持 a.b、a[3].b）。缺键返回 _MISS，不抛错。""" cur = o for seg in p.split("."): m = re.match(r"^([^\[\]]+)(?:\[(\d+)\])?$", seg) if not m or not isinstance(cur, dict): return _MISS k, idx = m.group(1), m.group(2) if k not in cur: return _MISS cur = cur[k] if idx is not None: if not isinstance(cur, list) or int(idx) >= len(cur): return _MISS cur = cur[int(idx)] return cur def _last(p): v = _sl["vals"][p] return v[-1] if isinstance(v, list) else v def _tol(p): """容差按切片侧的**舍入精度**定：金额取整（±0.5 元）、利率 6 位小数、久期 4 位、WAM/期限 2 位、笔数精确。比这更松就等于没守住，更紧则必然假警。""" leaf = p.rsplit(".", 1)[-1].split("|")[-1] if leaf == "n" or leaf.endswith("_n"): return 0.0 if leaf in ("rate", "rate_amt_term", "rate_cov", "bond_coupon", "bond_ytm", "ytmW", "ytmN", "comboW", "comboN", "cpW", "cpN"): return 2e-6 if leaf in ("bond_duration", "durW", "durN"): return 2e-4 if leaf in ("wam", "avg_term"): return 0.02 return 0.6 _bad = [] def _cmp(a, b, tol): """切片值 a 对当期值 b：逐叶比数值（容差 tol）。**只比 a 有的键** —— branches / dep_split / matrix 这几处在切片侧有意只留页面真正读的字段，当期对象多出来的键属"没被切片消费"，不是差异。列表长度必须相同（笔数不能少）。""" if isinstance(a, dict): if not isinstance(b, dict): return False for k in a: if k not in b or not _cmp(a[k], b[k], tol): return False return True if isinstance(a, list): if not isinstance(b, list) or len(a) != len(b): return False for x, y in zip(a, b): if not _cmp(x, y, tol): return False return True if a is None or b is None: return a is None and b is None if isinstance(a, str) or isinstance(b, str): return a == b return abs(a - b) <= max(tol, abs(b) * 1e-9) for _p in _sl["keys"]: if _p.startswith("matrix_cells."): continue # 当期无同名对象，单独用 bond_master 复核（见下） _want = _gp(data, _p) if _want is _MISS: continue # 当期没有这个键 ⇒ 无从对账（属"切片独有"的中间量） _got = _last(_p) if not _cmp(_got, _want, _tol(_p)): _bad.append((_p, _got, _want)) # ── matrix_cells 另有来源：当期是被前端 renderMatrix() 从 bond_master 现算的， # 这里按同一算法复算一遍比对，顺带把「利率归一是否一致」也钉死。 _mc = {} for _b in bond_master: _c = _mc.setdefault((_b["account"], _b["ptype"]), dict(wan=0.0, ytmW=0.0, ytmN=0.0, comboW=0.0, comboN=0.0, durW=0.0, durN=0.0)) _w = _b["book_wan"] _c["wan"] += _w if _b["ytm"] is not None: _c["ytmW"] += _b["ytm"] * _w _c["ytmN"] += _w if _b["avg_remaining_years"] is not None: _c["durW"] += _b["avg_remaining_years"] * _w _c["durN"] += _w if has_composite_income(_b["ptype"]) and _b["ytm"] is not None and _b["coupon"] is not None: _c["comboW"] += (_b["ytm"] + _b["coupon"] / 3.0) * _w _c["comboN"] += _w for _a in ("AC", "OCI", "TPL"): for _pt in PTYPE_ORDER: if _pt == "货币基金": continue _c = _mc.get((_a, _pt)) for _f in ("wan", "ytmW", "ytmN", "comboW", "comboN", "durW", "durN"): _p = "matrix_cells.%s|%s.%s" % (_a, _pt, _f) _want = (_c[_f] if _c else 0.0) if abs(_last(_p) - _want) > max(_tol(_p), abs(_want) * 1e-9): _bad.append((_p, _last(_p), _want)) if _bad: def _fmt(v): if isinstance(v, float): return "%.6g" % v if isinstance(v, int) or isinstance(v, str) or v is None: return repr(v) try: return json.dumps(v, ensure_ascii=False)[:200] except Exception: return repr(v)[:200] for _p, _g, _w in _bad[:5]: q("高", "切片对账不符", "展示日切片", "切片末点与当期口径不一致：%s" % _p, "切片 %s ≠ 当期 %s" % (_fmt(_g), _fmt(_w)), at=_p) if len(_bad) > 5: q("高", "切片对账不符", "展示日切片", "另有 %d 处切片末点与当期口径不一致（已省略明细）" % (len(_bad) - 5), "请核对 slice_days() 的实现；本条目只报首 5 处，避免刷屏", at="展示日切片") print("[切片对账] ✗ %d 处不一致：" % len(_bad)) for _p, _g, _w in _bad[:20]: print(" %-46s 切片 %s ≠ 当期 %s" % (_p, _fmt(_g), _fmt(_w))) else: print("[切片对账] ✓ %d 条路径的末点与当期口径逐字段一致" % len(_sl["keys"])) # ── 逐日对账（N08 的教训）──────────────────────────────────────────────── # 末点守卫只能守最后一天：债券切片曾经把「全期最终净额」套用到每一天， # 273 天里 271 天与历史曲线不符（最大差 29.50 亿元），而**末点完全一致 ⇒ 全绿**。 # 现在逐日把切片对回 history —— 两条路径消费的是**同一份** bond_settle_ledger()， # 本该逐日相等；一旦不等，就说明又有人塞进了第三份实现。 # 判据只用 history（它是被「末点 ≡ 当期 KPI」铁律钉死的权威序列），不另写第三套复算。 def _at(p, i): v = _sl["vals"][p] return v[i] if isinstance(v, list) else v _PD_TOL = 1.5e-4 # 亿元：history 保留 4 位小数(5e-5) + 切片取整到元的舍入裕度 _pd_bad, _n = [], _sl["n"] for _i in range(_n): _d0 = abs(_at("overview.book_total", _i) / YI - hist_bond[_i]) if _d0 > _PD_TOL: _pd_bad.append(("overview.book_total", _i, _d0)) for _pt in PTYPE_ORDER: if _pt == "货币基金": continue _sw = sum(_at("matrix_cells.%s|%s.wan" % (_a, _pt), _i) for _a in ("AC", "OCI", "TPL")) / WAN _d1 = abs(_sw - hist_by_type[_pt][_i]) if _d1 > _PD_TOL: _pd_bad.append(("matrix_cells.*|%s.wan" % _pt, _i, _d1)) if _pd_bad: _worst = max(_pd_bad, key=lambda t: t[2]) q("高", "切片逐日对账不符", "展示日切片", "切片有 %d 个「日 × 路径」与历史曲线不一致（最大差 %.4f 亿元）" % (len(_pd_bad), _worst[2]), "最差 %s 第 %d 日；首例 %s 第 %d 日差 %.4f" % (_worst[0], _worst[1] + 1, _pd_bad[0][0], _pd_bad[0][1] + 1, _pd_bad[0][2]), at="slice_days()") print("[切片逐日对账] ✗ %d 处「日 × 路径」不一致（最大差 %.4f 亿元 @ %s 第 %d 日）" % (len(_pd_bad), _worst[2], _worst[0], _worst[1] + 1)) else: print("[切片逐日对账] ✓ %d/%d 天与历史曲线逐日一致（债券总额 + 分品种）" % (_n, _n)) # ── 区间口径的**独立**复核（从折叠后的切片值重取，不复用 slice_days 的内部状态）── # 就地守卫比的是「当日票池现算的 p」；这一道比的是**切片里真正写出去的那三个数**。 # 两者若不一致，问题一定出在就地守卫看不见的环节：折叠成标量、写出时路径拼错、 # 或某天漏写（_C.out() 初值 None ⇒ 标量/断点）。同容差 2 元、同样**逐日**比。 _NBA = len(FUND_SHEETS) _rng_bad = [] for _k in range(_NBA): for _cl in FUND_CLS: _pre = "branches_all[%d].cls.%s." % (_k, _cl) for _i in range(_sl["n"]): _pv = _at(_pre + "p", _i) _dv = _at(_pre + "ci", _i) - _at(_pre + "cm", _i) if abs(_pv - _dv) > 2: _rng_bad.append((_pre, _i, _pv, _dv)) break if _rng_bad: q("高", "区间口径对账不符", "展示日切片", "有 %d 个「业务 × 质押/信用」的「累积起息 − 累积到期」≠ 当日存量" % len(_rng_bad), "首例 %s 第 %d 日：存量 %.0f，ci−cm %.0f" % (_rng_bad[0][0], _rng_bad[0][1] + 1, _rng_bad[0][2], _rng_bad[0][3]), at="slice_days()") print("[区间口径对账·独立复核] ✗ %d 处不一致，首例 %s 第 %d 日" % (len(_rng_bad), _rng_bad[0][0], _rng_bad[0][1] + 1)) else: print("[区间口径对账·独立复核] ✓ %d 条「业务 × 质押/信用」× %d 天逐日一致" % (_NBA * len(FUND_CLS), _sl["n"])) # ── 切片键的「跨页泄漏」防线 ────────────────────────────────────────── # 切片**只允许**产出「三个切片页自己读」的键。一旦有人往 slice_days() 里加了 # 被其它页共用的键（现实案例：due_win 只被「到期日历」读），用户把时间轴拖到 # 历史日、再切到那一页，就会看到「上半页是历史日、下半页是台账日」的半新半旧页面。 # 这类"混日"页面比整页陈旧危险得多 —— 它读起来像正常数据。 _SLICE_OK = ("overview.", "branches", "branches_all", "stock_break", "bucket_table", "dep_split", "accounts.", "matrix", "matrix_cells.", "matrix_mf.", "dur_by_type.", "mf_matrix", "inv_acc.", "inv_ptype.") _leak = sorted({p for p in _sl["keys"] if not p.startswith(_SLICE_OK)}) if _leak: q("高", "切片键越界", "展示日切片", "slice_days() 产出了非切片页也会读到 %d 个数据键" % len(_leak), "、".join(_leak[:8]) + ("…" if len(_leak) > 8 else ""), at="slice_days()") print("[切片键越界] ✗ %d 个键不在白名单内：%s" % (len(_leak), "、".join(_leak[:8]))) with open(os.path.join(OUT_DIR, "data.json"), "w", encoding="utf-8") as fo: json.dump(data, fo, ensure_ascii=False, separators=(",", ":")) print("═" * 78) print("[台账日期] %s 文件 %s 共 %d 个 Sheet" % (T, os.path.basename(LEDGER_FILE), len(wb))) print("[数据能力] schema=%d caps=%s（前端按其是否达标决定渲染 or 显式降级）" % (SCHEMA, "、".join(sorted(CAPS_PRODUCED)) or "（无）")) print("[资金业务] 流水 %d 笔 → 存量 %d 笔（生效日≤T<到期日） / T 日到期 %d 笔 / 已到期 %d 笔" % (len(fund), len(stock), len(live) - len(stock), len(matured) - (len(live) - len(stock)))) print("[存量金额] 资产 %.2f 亿负债 %.2f 亿净头寸 %.2f 亿" % (asset_stock / YI, liab_stock / YI, (asset_stock - liab_stock) / YI)) print("[未来到期] 今日 %.2f 亿 7日 %.2f 亿 30日 %.2f 亿 90日 %.2f 亿" % (cum_due(0) / YI, cum_due(7) / YI, cum_due(30) / YI, cum_due(90) / YI)) for _w in due_win: print(" %-8s 资产到期 %.2f 亿（资金 %.2f + 债券 %.2f） / 负债到期 %.2f 亿" % (_w["label"], _w["asset_all"] / YI, _w["asset"] / YI, _w["bond"] / YI, _w["liab"] / YI)) print("[历史序列] %s ~ %s 共 %d 日末点资金资产 %.2f / 资金负债 %.2f / 债券 %.2f / 货基 %.2f / 投资合计 %.2f 亿" % (HIST_START.isoformat(), T, len(hdays), hist_fa[-1], hist_fl[-1], hist_bond[-1], hist_by_type["货币基金"][-1], hist_inv[-1])) print("[债券持仓] 台账汇总块 %.2f 亿（%d 只）现券库存 %.2f 亿（%d 条）" % (book_total_wan / WAN, len(book_pos), inv_total_wan / WAN, len(inv))) print("[账户口径] " + " | ".join("%s 台账%.2f亿库存%.2f亿流水%.2f亿 %d只" % (k, v["book"] / WAN, v["inv"] / WAN, v["flow"] / WAN, v["n"]) for k, v in sorted(acc_sum.items()))) print("[货币基金] 持有 %d 只 %.2f 亿" % (len(mf_held), mf_total / YI)) print("[预测盈利] 逐笔 %d 笔（剩余面额 %.2f 亿）成本 %.2f 亿 / 估值 %.2f 亿 / 盈余 %.2f 万 / 收益率 %s" % (profit_summary["合计"]["n_lot"], profit_summary["合计"]["rem_wan"] / WAN, profit_summary["合计"]["cost_wan"] / WAN, profit_summary["合计"]["val_wan"] / WAN, profit_summary["合计"]["surplus_wan"], ("%.4f%%" % (profit_summary["合计"]["surplus_rate"] * 100)) if profit_summary["合计"]["surplus_rate"] is not None else "—")) print(" 纳入 Sheet %s / 估值列 %s / 已匹配 %d 笔" % (lot_sheets or "无", val_sheets or "未接入", profit_summary["合计"]["n_matched"])) print("[库存核对] %d 项，不一致 %d 项（金额 %.2f 亿）" % (len(recon), overview["recon_diff_n"], overview["recon_diff_amt"] / YI)) if third_on: print("[三方核对] 已启用（同业系统 %s，覆盖 %s）；一致 %d / 不符 %d / 缺券 %d / 范围外 %d" % (third_meta["pull"], "、".join(third_types), overview["recon3_ok_n"], overview["recon3_diff_n"], third_miss_n, third_out_n)) else: print("[三方核对] 未启用：同业系统 %s（拉取 %s / 台账日 %s）⇒ 本次按两方核对" % (third_meta["sheet"] or "无", third_meta["pull"] or "/".join(third_meta["pulls"]) or "?", T)) _rm = risk["meta"] print("[风险测算] 逐券 %d 只（其中有久期套件 %d 只 / 缺件 %d 只），市值 %.2f 亿 / DV01 %.2f 万/bp" % (_rm["n_lots"], _rm["n_risk"], _rm["n_missing"], _rm["cover_mv_wan"] / WAN, _tot["dv01_wan"])) for _a in risk["by_acc"]: print(" %-6s %3d 只面值 %8.2f 亿市值 %8.2f 亿修正久期 %s 凸性 %s DV01 %8.2f 万/bp" % (_a["acc"], _a["n"], _a["face_wan"] / WAN, _a["mv_wan"] / WAN, ("%.3f" % _a["dur_mod_w"]) if _a["dur_mod_w"] is not None else "—", ("%.2f" % _a["cvx_w"]) if _a["cvx_w"] is not None else "—", _a["dv01_wan"])) if _rm["uncovered"]: print(" ⚠ 未纳入现券库存（无中债久期）：%s ⇒ 按面值覆盖 %.1f%%" % ("，".join("%s %d 只 %.2f 亿" % (x["ptype"], x["n"], x["wan"] / WAN) for x in _rm["uncovered"]), (_rm["cover_pct"] or 0) * 100)) print("[数据质量] 共 %d 条" % len(quality)) for lv in ("严重", "高", "中", "低"): c = Counter(x["cat"] for x in quality if x["level"] == lv) if c: print(" [%s] %s" % (lv, dict(c.most_common()))) print("═" * 78) if __name__ == "__main__": main()