labull-framework 0.1.3__tar.gz → 0.1.4__tar.gz

{labull_framework-0.1.3/labull_framework.egg-info → labull_framework-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labull-framework
-Version: 0.1.3
+Version: 0.1.4
 Summary: Labull Framework: a pluggable Django app with Authing OIDC login and magic blocks
 Author: Labull Framework
 License-Expression: MIT

{labull_framework-0.1.3 → labull_framework-0.1.4}/labull_framework/canvas/static/canvas.js

@@ -50,6 +50,11 @@ const GAP = 24;
  *    （`customer_id` 这种 11 字的只占 82px，宽裕；更长的名字仍会压到卡片，那没办法）。
  *  ⚠️ 代价：横向铺得更开 ⇒ 整图更宽 ⇒ "适应视图"的缩放比更小。所以这不是免费的。 */
 const COL_GAP = 140;
+/** 自动排版里"长宽比护栏"的上下限：只最小化总线长会退化成"所有表排成一行"，
+ *  所以形状偏得太厉害的候选**直接淘汰**，只在"还能看"的那些里比线长。
+ *  ⚠️ 取 0.45~2.2 是照着一块屏幕的形状（16:9 的宽屏、竖屏手机、以及中间的平板）留的余量。 */
+const ASPECT_MIN = 0.45;
+const ASPECT_MAX = 2.2;
 /** 基数那个圆圈的半径（与 canvas.css 里 `.cardinality circle` 的 `r` 必须一致）。 */
 const MARKER_R = 12;
 /** 两端那支开口箭头（`edgeDefs` 的 marker）在**用户坐标**里有多长：`markerWidth` × `strokeWidth`。
@@ -167,7 +172,7 @@ async function load() {
     notify(`取数失败：${err.message}`, true);
     return;
   }
-  layout = { ...(state.layout || {}) };
+  layout = { ...(readLocalLayout() || state.layout || {}) };
   notify('');
 
   const git = state.git;
@@ -289,24 +294,13 @@ function render() {
     return;
   }
   place(cards, layer);
-  /* 🔴 **自动保存**：把排完的结果写回盘上 —— 但**只在 `?pins=1` 时**存。
-   *
-   *    用户后来的决定把这件事的定位改了：默认每次都是自动排版、**不依赖存下来的位置**
-   *    （原话：「因为页面排版的数据可能没地方保存，不保存也没关系，只要页面缓存当时有就行」）。
-   *    所以这个 POST 不再是"排版的前提"，而只是"当前这一屏的快照"：
-   *      · 默认（自动排版）时**不写盘** —— 写了也没人读，而且会把 `?pins=1` 用的那份钉子
-   *        覆盖成自动排版的结果（那样钉子就不是钉子了）；
-   *      · `?pins=1` 时（拖动 / 钉住用例）才写 —— 那份是"有人选定过的布局"，值得留。
-   *    ⚠️ 只在**真的变了**的时候发：`layoutAtLoad` 是进页面时那份快照，
-   *       一样就一个字节都不写 —— 否则每次刷新都往盘上写一次，纯属折腾磁盘。
-   *    ⚠️ "自动排列"按钮是**故意清空**的（它 POST 一个空对象，见下面那个按钮的处理器）。
+  /* 🔴 **自动排版排完不再自动写盘了** —— 现在存不存由用户说了算（右上角「保存排版」按钮，
+   *    见 `saveCanvasLayout`），默认每次打开都是自动排版。
+   *    上面那段历史的结论就一句：**"存"和"用"都要有明确的开关**，不能靠"排完顺手存一下"
+   *    把两边搅在一起（那样用户永远说不清"我这次看到的是排的还是我存的"）。
+   *    ⚠️ 拖动**仍然**每次都存（那是"我正在摆"的直接意图），但**要不要用它**由本地存档决定：
+   *       本地存过 ⇒ 用它（见 `LOCAL_KEY`）；没存过 ⇒ 每次自动排版。
    */
-  const layoutAtLoad = JSON.stringify(layout);
-  for (const el of layer.querySelectorAll('.table')) {
-    layout[el.dataset.name] = { x: parseFloat(el.style.left) || 0, y: parseFloat(el.style.top) || 0 };
-  }
-  const wantPins = new URLSearchParams(location.search).get('pins') === '1';
-  if (wantPins && JSON.stringify(layout) !== layoutAtLoad) saveLayout();
   edges(cards, paths, labels);
   // 🔴 把"重画一次"暴露给拖拽：**拖动期间每一帧都要重画**（见 `dragify`）。
   //    原来唯一的重画入口是这一层上的 `click`（下面那一行），而拖动是"按住 + 移动"：
@@ -1242,12 +1236,14 @@ function place(cards, layer) {
   //    存的坐标是**图层坐标**、以 (0,0) 为原点，所以这个常量偏移对每次渲染都成立。
   const top = GAP + loopClearance();
 
-  // ⚠️ 只有 `?pins=1` 才把存下来的位置当回事（见函数头）。默认整份 `layout` 都不参与排版。
-  const usePins = new URLSearchParams(location.search).get('pins') === '1';
+  // ⚠️ 用存下来的位置的两种情形（见 `LOCAL_KEY` 的说明）：地址栏显式 `?pins=1`，
+  //    或者**用户在本地存过一份**（点过「保存排版」）—— 存过就说明他要的是那个布局。
+  //    两者都没有 ⇒ 整份 `layout` 都不参与排版，走自动排版（用户要的默认行为）。
+  const wantPins = new URLSearchParams(location.search).get('pins') === '1' || Boolean(readLocalLayout());
   const loose = [];
   const saved = [];
   for (const item of cards) {
-    const spot = usePins ? layout[item.el.dataset.name] : null;
+    const spot = wantPins ? layout[item.el.dataset.name] : null;
     if (spot && typeof spot.x === 'number' && typeof spot.y === 'number') {
       item.el.style.left = `${spot.x}px`;
       item.el.style.top = `${spot.y}px`;
@@ -1357,21 +1353,201 @@ function placeAuto(items, columns, top, pitch) {
   // 大的分量先摆：货架排出来更整齐（小分量去补最后那点缝）。
   comps.sort((one, two) => two.length - one.length);
 
-  const box = new Map();
-  let cursor = 0;      // 当前货架已经占了几列
-  let shelfTop = top;
-  let shelfTall = 0;
-  for (const members of comps) {
-    const cols = layeringColumns(members, adj, span);
-    if (cursor + cols.length > span) {
-      shelfTop += shelfTall + GAP * 2;
-      cursor = 0;
-      shelfTall = 0;
+  /* 🔴 目标里加一条**总线长**（用户要的：「加一个指标确保关联线总的长度尽可能短」）——
+   *    原来只优化"线×线交错"，排出来会一路往下堆、线拉得很长，正是用户看到的那个毛病。
+   *
+   *    做法：拿几个候选"列数上限"各排一遍，量**所有关联两端卡片中心的曼哈顿距离之和**，
+   *    取最短的那版写回 DOM。
+   *    ⚠️ **必须配长宽比护栏**：只最小化线长会退化成"27 张表排成一行"——线是短了，
+   *       但图变成又扁又宽的一条，`fitView` 缩到看不清，得不偿失。所以长宽比超出
+   *       [`ASPECT_MIN`, `ASPECT_MAX`] 的候选**直接淘汰**，只在"形状还能看"的那些里比线长。
+   *    ⚠️ 距离用**曼哈顿**（横 + 纵）：这一页的走法以横平竖直为主，欧氏距离会把斜线算便宜。
+   *    ⚠️ 每排一版都要**真的写进 DOM**：卡片高度是 `offsetHeight` 量出来的（备注能折好几行，
+   *       估不准），所以最后一版会多写一次 DOM 把赢的那版盖回去。
+   *    ⚠️ 只在"线长"里比，**不掺交错数**：交错交给上面那步重心排序单独负责，
+   *       两个目标混进一个数里会互相拉扯，反而两个都做不好。
+   */
+  const run = (limit) => {
+    const box = new Map();
+    let cursor = 0;      // 当前货架已经占了几列
+    let shelfTop = top;
+    let shelfTall = 0;
+    for (const members of comps) {
+      const cols = layeringColumns(members, adj, limit);
+      if (cursor + cols.length > limit) {
+        shelfTop += shelfTall + GAP * 2;
+        cursor = 0;
+        shelfTall = 0;
+      }
+      shelfTall = Math.max(shelfTall,
+        placeComponent(cols, adj, byName, box, GAP + cursor * pitch, shelfTop, pitch));
+      cursor += cols.length;
+    }
+  };
+  const measure = () => {
+    const at = new Map();
+    let right = 0;
+    let bottom = 0;
+    for (const item of items) {
+      const el = item.el;
+      const x = parseFloat(el.style.left) || 0;
+      const y = parseFloat(el.style.top) || 0;
+      at.set(el.dataset.name, { x, y, w: el.offsetWidth, h: el.offsetHeight });
+      right = Math.max(right, x + el.offsetWidth);
+      bottom = Math.max(bottom, y + el.offsetHeight);
+    }
+    let wire = 0;
+    for (const item of items) {
+      const a = at.get(item.el.dataset.name);
+      for (const link of item.table.relations || []) {
+        const b = at.get(link.targetTable);
+        if (!b || b === a) continue;
+        wire += Math.abs((a.x + a.w / 2) - (b.x + b.w / 2)) + Math.abs((a.y + a.h / 2) - (b.y + b.h / 2));
+      }
+    }
+    return { wire: Math.round(wire), w: right, h: bottom, ratio: right / Math.max(1, bottom) };
+  };
+  // 候选：1 列到"视口塞得下的列数"，再往上探到"表数一半"（更宽往往更短，但形状会变扁）。
+  const cap = Math.max(2, Math.min(items.length, Math.max(columns, 2) * 3));
+  const tries = [...new Set([columns, Math.max(1, columns - 1), columns + 2, columns * 2, cap])]
+    .filter((k) => k >= 1 && k <= items.length)
+    .sort((one, two) => one - two);
+  const tried = [];
+  let best = null;
+  for (const limit of tries) {
+    run(limit);
+    const m = measure();
+    const ok = m.ratio >= ASPECT_MIN && m.ratio <= ASPECT_MAX;
+    tried.push(`${limit}列:线长${m.wire}${ok ? '' : '(形状淘汰)'}`);
+    if (ok && (!best || m.wire < best.wire)) best = { limit, ...m };
+  }
+  // 一个都不合格（极端形状）时退回原来的列数，绝不把图排成一条线。
+  if (!best) best = { limit: span, ...(run(span), measure()) };
+  if (best.limit !== tries[tries.length - 1]) run(best.limit);
+
+  /* ⑥ 🔴 **线×卡片消解**（用户要的：「完全可以让表疏散开，从而确保线和表不重叠，
+   *    同时还不需要增加线的长度，你为什么没这么做」——他说得对，而且这一步在几何上近乎免费）：
+   *
+   *    关键点：**挪一张"中转表"（只是被线穿过、并不是线的两端）完全不改变那条线自己的长度**，
+   *    只可能影响**连在它身上**的其他线。所以判据是"消掉多少穿卡 vs 总线长涨多少"。
+   *
+   *    做法是**贪心 + 有界**，不是全局最优：
+   *      · 先算出哪些表被线穿过（只动这些，别的表一律不碰）；
+   *      · 每张依次试几档纵向平移（上/下 各 40/80/140），
+   *        只接受"**穿卡数下降**、且总线长涨幅 ≤ `MOVE_BUDGET`、且不撞别的卡片"的档；
+   *      · 最多 3 轮，没有可接受的挪法就停。
+   *    ⚠️ 全程在**内存里算**（`at` 这张表），只有最后赢的位置才写回 DOM —— 不然每一档都要重排 DOM，
+   *       代价是几十倍。
+   *    ⚠️ 判据里的"穿过"用**取样**（20 个点）：和走线那边用的是同一套朴素判据，
+   *       换来的是"量到的和画出来的一致"。
+   */
+  const at = new Map();
+  for (const item of items) {
+    const el = item.el;
+    at.set(el.dataset.name, {
+      x: parseFloat(el.style.left) || 0,
+      y: parseFloat(el.style.top) || 0,
+      w: el.offsetWidth,
+      h: el.offsetHeight,
+    });
+  }
+  const pairs = [];
+  for (const item of items) {
+    const a = item.el.dataset.name;
+    for (const link of item.table.relations || []) {
+      const b = link.targetTable;
+      if (a !== b && at.has(b)) pairs.push([a, b]);
+    }
+  }
+  const mid = (spot) => ({ x: spot.x + spot.w / 2, y: spot.y + spot.h / 2 });
+  const hitsRect = (p, q, r) => {
+    for (let i = 1; i < 20; i += 1) {
+      const t = i / 20;
+      const x = p.x + (q.x - p.x) * t;
+      const y = p.y + (q.y - p.y) * t;
+      if (x > r.x && x < r.x + r.w && y > r.y && y < r.y + r.h) return true;
+    }
+    return false;
+  };
+  // 被线穿过的表（返回 名字 → 穿它的线有几条）——只动这些。
+  const scanHits = () => {
+    const bad = new Map();
+    for (const [a, b] of pairs) {
+      const pa = mid(at.get(a));
+      const pb = mid(at.get(b));
+      for (const [name, spot] of at) {
+        if (name === a || name === b) continue;
+        if (hitsRect(pa, pb, spot)) bad.set(name, (bad.get(name) || 0) + 1);
+      }
+    }
+    return bad;
+  };
+  const wireOf = () => {
+    let total = 0;
+    for (const [a, b] of pairs) {
+      const pa = mid(at.get(a));
+      const pb = mid(at.get(b));
+      total += Math.abs(pa.x - pb.x) + Math.abs(pa.y - pb.y);
     }
-    shelfTall = Math.max(shelfTall,
-      placeComponent(cols, adj, byName, box, GAP + cursor * pitch, shelfTop, pitch));
-    cursor += cols.length;
+    return total;
+  };
+  /* 🔴 判据必须是"**线×卡片的总处数**"，不是"被穿过的表有几张"：
+   *    一开始用的是 `bad.size`（后者）—— 实测页面上一眼看过去十几处覆盖，它只报 3；
+   *    更糟的是"挪走 A 又压到 B"这种**等价交换**会被判成没进步而拒绝 ⇒ 消解几乎不动
+   *    （用户的原话：「还是这么多的覆盖，为什么不舒展开」）。所以改成把每张表被穿几次**加起来**。
+   * ⚠️ 预算与幅度同样放宽（用户授权："宁可让图更疏散也要消掉"）：
+   *    线长涨幅到 35%、纵向挪到 ±400、并允许**横向侧移**（斜线只靠上下躲不开）。 */
+  const totalHits = (m) => [...m.values()].reduce((sum, v) => sum + v, 0);
+  const MOVE_BUDGET = 0.35;
+  const OFFSETS = [
+    [0, -40], [0, 40], [0, -80], [0, 80], [0, -140], [0, 140],
+    [-60, 0], [60, 0], [-120, 0], [120, 0],
+    [0, -220], [0, 220], [0, -320], [0, 320], [0, -400], [0, 400],
+  ];
+  let bad = scanHits();
+  const blockHitsBefore = totalHits(bad);
+  let wire0 = wireOf();
+  for (let pass = 0; pass < 6 && totalHits(bad); pass += 1) {
+    let moved = false;
+    for (const name of [...bad.keys()]) {
+      const home = at.get(name);
+      for (const [dx, dy] of OFFSETS) {
+        const trial = { ...home, x: home.x + dx, y: home.y + dy };
+        // 不许撞别的卡片（撞上了就不是"疏散"，是"叠在一起"）
+        let clash = false;
+        for (const [other, spot] of at) {
+          if (other === name) continue;
+          if (trial.x < spot.x + spot.w && spot.x < trial.x + trial.w
+            && trial.y < spot.y + spot.h && spot.y < trial.y + trial.h) { clash = true; break; }
+        }
+        if (clash) continue;
+        at.set(name, trial);
+        const next = scanHits();
+        const wire = wireOf();
+        if (totalHits(next) < totalHits(bad) && wire <= wire0 * (1 + MOVE_BUDGET)) {
+          bad = next;
+          moved = true;
+          break;
+        }
+        at.set(name, home);
+      }
+    }
+    if (!moved) break;
+  }
+  // 只把最终位置写回 DOM（上面全在内存里算）。
+  for (const [name, spot] of at) {
+    const item = byName.get(name);
+    if (!item) continue;
+    item.el.style.left = `${spot.x}px`;
+    item.el.style.top = `${spot.y}px`;
   }
+
+  // 给验收 / 排查看：这一版按哪个列数上限排的、总线长多少、试过哪些（含被形状淘汰的）、
+  // 以及"线×卡片消解"最后还剩几处穿卡。
+  window.__labullLayout = {
+    span: best.limit, wire: best.wire, w: best.w, h: best.h, tried,
+    blockHitsBefore, blockHits: totalHits(bad),
+  };
 }
 
 /** 分量内部分层：返回"第几列 → 该列的表名（已按重心排好序）"。 */
@@ -1401,9 +1577,15 @@ function layeringColumns(members, adj, columns) {  // 根取**度数最大**的
   //    视口塞不下、`fitView` 直接顶到最小档 25%，字全糊了（实测：36 张表排出来 4 列、
   //    高得离谱，缩放被夹在下限）。这里给每列定个上限，把**超出**的往后挪；
   //    挪的是每列**末尾**（重心序里最靠后的），对"关系就近"的破坏最小，挪完再排一遍序。
-  const target = Math.ceil(members.length / count);
-  for (let c = 0; c < count - 1; c += 1) {
-    while (cols[c].length > target) cols[c + 1].push(cols[c].pop());
+  // 🔴 横向预算：**每列最多放 `target` 张**，而 `target` 由**横向预算 `columns`** 算出来。
+  //    ⚠️ 原来这里用的是**层数**（`members.length / count`）—— 那等于"横向预算这个参数根本不起作用"：
+  //       实测改列数上限（2/3/5/6/9）线长**一模一样**（全是 22824），图始终 2184×3167 又高又窄。
+  //       用户报的「一直往下排版、线拉得很长」就是这个。
+  //    ⚠️ 溢出的部分**新增一列**（`splice` 插进去），而不是往后挤：往后挤的话最后一列永远没人接，
+  //       它就会一直堆到天上去。新增列会让后面的列整体右移 —— 那正是"横向发展"。
+  const target = Math.max(1, Math.ceil(members.length / Math.max(1, columns)));
+  for (let c = 0; c < cols.length; c += 1) {
+    while (cols[c].length > target) cols.splice(c + 1, 0, cols[c].splice(target));
   }
   crossingReduction(cols, adj);
   return cols;
@@ -1804,10 +1986,10 @@ moduleSelect.addEventListener('change', () => {
 
 /** 把当前 `layout` 写到服务端。
  *
- *  🔴 两个调用点、一个出口：**拖完一次**要存（原来就存），**自动布局排完**也要存
- *     （用户要的「布局每次能被自动保存」「新加的表按自动布局加上去」——
- *     排完不落盘的话，下次打开又重排一遍，每次刷新都换一个样子）。
- *  ⚠️ 存不上只是提示，不当成错误：这一页**公开、只读也能看**，位置存不上不该让画布变成空白。
+ *  🔴 两个调用点、一个出口：**拖完一次**要存（原来就存），**点「保存排版」**也要存。
+ *  ⚠️ 存不上只是提示，不当成错误：这一页**公开、只读也能看**，位置存不上不该让画布变成空白；
+ *     而且"存到哪"这件事**本地那份（localStorage）才是主力**（见 `LOCAL_KEY`），
+ *     这个 POST 只是"顺便让服务端也留一份"（同一个项目的其他人能看到）。
  */
 function saveLayout() {
   return fetch('canvas/layout', {
@@ -1816,16 +1998,61 @@ function saveLayout() {
     headers: { 'Content-Type': 'application/json', [csrfInfo.header || 'X-CSRFToken']: csrfInfo.token || csrf() },
     body: JSON.stringify(layout),
   }).then((res) => {
-    if (!res.ok) notify(`布局没存上（${res.status}）—— 这一页还是能看，只是下次打开会重新自动排列。`, true);
+    if (!res.ok) notify(`布局没存到服务端（${res.status}）—— 不过本地那份已经存好了，刷新还是这个样子。`, true);
   }).catch(() => {});
 }
 
+/** 本地那份排版的键（存在浏览器里）。
+ *
+ *  🔴 用户要的「点一下就保存当前画布」**主要靠它**：不需要后端能写文件、不需要登录、
+ *     也不需要哪个接口存在 —— 刷新、关掉再开都还在。
+ *  🔴 它同时是"要不要用存下来的位置"的开关：**本地有存档 ⇒ 就不再自动排版**（用户存过就说明
+ *     他要的是这个布局）；点「自动排列」会把它删掉，于是回到"每次打开自动排版"。
+ *  ⚠️ 用 `try` 包住：隐私模式 / 存储被禁用时 `localStorage` 会直接抛异常，
+ *     那一页还得能看（退回自动排版），不能让画布整个白掉。
+ */
+const LOCAL_KEY = 'labull-canvas-layout';
+
+function readLocalLayout() {
+  try {
+    const parsed = JSON.parse(localStorage.getItem(LOCAL_KEY) || 'null');
+    return parsed && typeof parsed === 'object' && Object.keys(parsed).length ? parsed : null;
+  } catch { return null; }
+}
+
+/** 把卡片在 DOM 上的当前位置读回 `layout`（拖动时也是这么更新的）。 */
+function syncLayoutFromDom() {
+  for (const el of canvas.querySelectorAll('.table')) {
+    layout[el.dataset.name] = { x: parseFloat(el.style.left) || 0, y: parseFloat(el.style.top) || 0 };
+  }
+  return layout;
+}
+
+/** 「保存排版」：存本地（主力）+ 服务端（尽力而为）。 */
+function saveCanvasLayout() {
+  syncLayoutFromDom();
+  let localOk = false;
+  try {
+    localStorage.setItem(LOCAL_KEY, JSON.stringify(layout));
+    localOk = true;
+  } catch { /* 隐私模式 / 存储被禁用 */ }
+  const count = Object.keys(layout).length;
+  if (localOk) notify(`排版已保存（${count} 张表）—— 之后每次打开都按这个位置显示；要回自动排列点左边的「自动排列」。`);
+  else notify('这个浏览器不让写本地存储，正在试着存到服务端……', true);
+  void saveLayout();
+}
+
+$('save-layout').addEventListener('click', saveCanvasLayout);
+
 $('reload').addEventListener('click', load);
 
 /** 「自动排列」：清掉手工拖的位置，回到按列自动排。⚠️ 它**不动缩放**（那是「适应视图」的事）——
- *  两个后果混在一个按钮上时，用户想整理布局却被顺带缩了一下，说不清是谁干的。 */
+ *  两个后果混在一个按钮上时，用户想整理布局却被顺带缩了一下，说不清是谁干的。
+ *  🔴 它同时要**清掉本地存档**（`LOCAL_KEY`）：本地存过一份就"不再自动排版"，
+ *     不清的话用户点了「自动排列」、下次打开却又变回他存的那份 —— 按钮就不算数了。 */
 $('fit').addEventListener('click', () => {
   layout = {};
+  try { localStorage.removeItem(LOCAL_KEY); } catch { /* 隐私模式 */ }
   for (const box of canvas.querySelectorAll('.table')) {
     box.style.left = '';
     box.style.top = '';

{labull_framework-0.1.3 → labull_framework-0.1.4}/labull_framework/canvas/static/page.html

@@ -7,7 +7,7 @@
   <!-- ⚠️ `?v=` 是**给浏览器的缓存换钥匙**：这两个静态件在"这一页是公开的"之后尤其容易被缓存住，
        改了正文而人不刷新（或刷新了也还是旧的），症状是"代码明明改了、页面却没变"（真踩过）。
        改这两个文件时把版本号往上加一位。 -->
-  <link rel="stylesheet" href="canvas/asset/canvas.css?v=31">
+  <link rel="stylesheet" href="canvas/asset/canvas.css?v=36">
 </head>
 <body>
   <header class="bar">
@@ -35,6 +35,10 @@
       <button id="zoom-fit" type="button" title="把图缩放到视野内">适应视图</button>
     </span>
     <button id="fit" type="button" title="清掉手工拖的位置，回到自动排列">自动排列</button>
+    <!-- 🔴 「保存排版」：把当前（拖过的）位置存下来，之后每次打开都用它。
+         ⚠️ 存两处：**浏览器本地**（一定成功，不要求后端能写文件）+ 后端的 layout 接口
+         （尽力而为：这一页是公开的，别的项目里那个 POST 可能压根没人接）。 -->
+    <button id="save-layout" type="button" title="保存当前排版：之后每次打开都按这个位置显示（而不是自动排列）">保存排版</button>
     <button id="reload" type="button" title="重新取一次数据">刷新</button>
   </div>
 
@@ -48,6 +52,6 @@
     拖动表可排版（拖完自动存）；空白处按住拖 = 平移，Ctrl + 滚轮 = 缩放；
     点表标题展开备注与关联，点字段行展开枚举取值 / 文件去向 / 关联目标，点线上的关联键名看它的备注。
   </p>
-  <script src="canvas/asset/canvas.js?v=31"></script>
+  <script src="canvas/asset/canvas.js?v=36"></script>
 </body>
 </html>

{labull_framework-0.1.3 → labull_framework-0.1.4}/labull_framework/magic_block/deepcheck.py

@@ -695,12 +695,26 @@ def deep_check(
     params = (files or {}).get(PROBE_PARAMS_FILE)
     if isinstance(params, str) and params.strip():
         env[BLOCK_PROBE_PARAMS] = params
+    # 🔴 这一段子进程的编码要**两头都钉死**（子进程按 UTF-8 写、父进程按 UTF-8 读）：
+    #    只写 `text=True` 的话，父进程用 `locale.getpreferredencoding(False)` 解码
+    #    （中文 Windows = cp936），而子进程一旦吐 UTF-8 —— 服务进程环境里有
+    #    `PYTHONIOENCODING=utf-8` / `PYTHONUTF8=1` 这类东西时就是这样 —— `subprocess` 的
+    #    解码线程会抛 `UnicodeDecodeError` 直接死掉。那个异常在**线程**里，主线程看不见，
+    #    `stdout`/`stderr` 双双变成 `None` 而 `returncode` 仍是 0 ⇒ 这一层看起来只是
+    #    "深检自己没跑起来"，实则**每一次都没验**（0.1.2 ~ 0.1.3.1 就是这个状态）。
+    #    同一个坑的另一处见 `canvas/gitinfo.py` 的 `_run()`。
+    env['PYTHONIOENCODING'] = 'utf-8'
+    # Windows 商店版 Python 的 `sys.executable` 可能是 None，拿不到就没有解释器可用。
+    interpreter = sys.executable or 'python'
     try:
         done = subprocess.run(
-            [sys.executable, '-c', child],
+            [interpreter, '-c', child],
             env=env,
             capture_output=True,
             text=True,
+            encoding='utf-8',
+            # 第二道保险：真碰上编码诡异的输出，也宁可显示成问号，不要让解码线程死掉。
+            errors='replace',
             timeout=DEEP_TIMEOUT,
         )
     except subprocess.TimeoutExpired:
@@ -720,6 +734,14 @@ def deep_check(
             [],
         )
 
+    if done.stdout is None:
+        # 正常走不到这里（上面 `encoding` / `errors` 已经给全）；真走到了也**不许静默**：
+        # 至少把 stderr 的最后一行说出来，否则"编码不对 ⇒ 什么都没验"会一直隐形。
+        tail = (done.stderr or '').strip().splitlines()
+        return [], [
+            f'引用深检的输出没能解码（returncode={done.returncode}）：'
+            f'{tail[-1] if tail else "没有 stderr"}'
+        ]
     payload = _payload_of(done.stdout or '')
     if payload is None:
         detail = (done.stderr or done.stdout or '').strip().splitlines()

{labull_framework-0.1.3 → labull_framework-0.1.4}/labull_framework/magic_block/validate.py

@@ -488,12 +488,20 @@ def trial_load(src: str) -> list[str]:
     #    不交的话每个块都会报"找不到 labull_framework / modules"——那是假错。
     env['PYTHONPATH'] = os.pathsep.join(item for item in sys.path if item)
     env['LABULL_TRIAL_SOURCE'] = json.dumps(src, ensure_ascii=False)
+    # 🔴 同 `deepcheck.deep_check()`：子进程按 UTF-8 写、父进程按 UTF-8 读，两头都得钉死。
+    #    只写 `text=True` 时父进程按 `locale.getpreferredencoding(False)`（中文 Windows = cp936）
+    #    解码，子进程吐 UTF-8 时解码线程会抛 `UnicodeDecodeError` 死掉 ⇒ `stderr` 变成 None，
+    #    这一层就只剩一句"加载失败（……）：1"（真因被吞了）。
+    env['PYTHONIOENCODING'] = 'utf-8'
+    interpreter = sys.executable or 'python'
     try:
         done = subprocess.run(
-            [sys.executable, '-c', _TRIAL_SCRIPT],
+            [interpreter, '-c', _TRIAL_SCRIPT],
             env=env,
             capture_output=True,
             text=True,
+            encoding='utf-8',
+            errors='replace',
             timeout=TRIAL_LOAD_TIMEOUT,
         )
     except subprocess.TimeoutExpired:

{labull_framework-0.1.3 → labull_framework-0.1.4/labull_framework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: labull-framework
-Version: 0.1.3
+Version: 0.1.4
 Summary: Labull Framework: a pluggable Django app with Authing OIDC login and magic blocks
 Author: Labull Framework
 License-Expression: MIT

{labull_framework-0.1.3 → labull_framework-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "labull-framework"
-version = "0.1.3"
+version = "0.1.4"
 description = "Labull Framework: a pluggable Django app with Authing OIDC login and magic blocks"
 readme = "README-pypi.md"
 requires-python = ">=3.10"