labull-framework 0.1.30__tar.gz → 0.1.32__tar.gz

{labull_framework-0.1.30/labull_framework.egg-info → labull_framework-0.1.32}/PKG-INFO

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

{labull_framework-0.1.30 → labull_framework-0.1.32}/labull_framework/magic_block/deepcheck.py

@@ -36,6 +36,13 @@
    app registry 是迁移与请求**正在用**的那一份 —— 在进程内试跑块代码等于拿生产赌。
    ⚠️ 子进程里一律用**只读 / 内存**的那条数据库连接（别名 `probe`），真库一根头发都不动。
 
+🔴 **整包与判据正文一律走 stdin**（`subproc.run_child()` 的 `payload`），**不走环境变量**：
+   这一包有多大是作者说了算的（实测有两个块 349 KB / 336 KB），而 Linux 对**单个**环境字符串
+   有硬上限 `MAX_ARG_STRLEN = 128 KiB` —— 超了 `execve` 直接回 E2BIG，而那从前被说成
+   "找不到可用的 Python 解释器"，后果是**整个块存不回去**（保存与体检都走这一份判据）。
+   环境里因此只剩 `PYTHONPATH` / `PYTHONIOENCODING` 那几个小变量，`_GIVEN` 就是 stdin 那一份。
+   细节（为什么两件都要做、errno 怎么分）见 `subproc.py` 的文件头 —— 那一层只有一份实现。
+
 🔴 **软失败**：环境交不出来（没有 settings / 没有 Django / 建表不让）时**不报错、也不停用**，
    只回一句"没验"进日志。这不是宽容，是**判据的方向**：一句假错会让本来能跑的块被停用
    （前端红框 + 路由 403），比"少验一次"严重得多。所以只有拿得准的错才说。
@@ -45,7 +52,6 @@ from __future__ import annotations
 
 import json
 import os
-import subprocess
 import sys
 from typing import Any
 
@@ -53,17 +59,28 @@ from .sdk import (
     BLOCK_BACKEND_FILE,
     BLOCK_DEEPCHECK,
     BLOCK_PROBE,
-    BLOCK_PROBE_LIMIT,
     BLOCK_PROBE_PARAMS,
     is_excluded,
 )
+from .subproc import run_child
 
 #: 框架自己那个 app 的 label：探针**不撒种、也不建表**（块代码本来就不该碰它的表）。
 _OWN_APP = 'labull_framework'
 
 #: 深检那一次的子进程超时（秒）。
 #: 🔴 超时**不算通过**（"不知道"不等于"没问题"），与 `validate.TRIAL_LOAD_TIMEOUT` 同一个口径。
-DEEP_TIMEOUT = 10
+#:
+#: 🔴 10 → 30（2026-10，用户要求）。原来那 10 秒是照"一个典型的块应该秒回"定的，
+#:    但现场它**误报**了：`buy` 项目 14 个块里有 4 个（出入库流水 / 用户与权限 / 申请 /
+#:    退货单）被判成「引用深检超过 10 秒没有结束，已中止」，而它们的 `backend_open.py`
+#:    本身没有任何死循环 —— 慢的是**每个子进程都要跑一遍 `django.setup()`**：
+#:    项目一大（几十个模型 + 几十个块 + 深检自己还要建内存表），冷启动那一下就要好几秒，
+#:    再叠加 `LABULL_BLOCK_WORKERS` 那 4 个口子一起抢 CPU，10 秒根本不够。
+#:    ⇒ 后果不是"少查一点"，而是**好块被停用**（体检不通过 ⇒ `enabled=False`），
+#:      而报文说的是"可能有死循环"，把人往完全错的方向指。
+#: ⚠️ 30 秒是**上限而不是等待**：正常块仍然在一秒内出结果，这个数只在"真的很慢"时才起作用。
+#: ⚠️ 别再往上调：一个块真跑 30 秒还没完，那就该去看它的 `backend_open.py` 了。
+DEEP_TIMEOUT = 30
 
 #: 探针里最多跑几条 handler（一个手滑不该变成"体检跑十分钟"）。
 PROBE_LIMIT = 6
@@ -253,7 +270,9 @@ def _seed_rows(apps: Any) -> list[str]:
 
 #: 子进程里那份深检器。
 #:
-#: 🔴 正文走**环境变量里的 JSON**，不往脚本里拼字符串（块正文里一个引号就能把脚本本身改坏）。
+#: 🔴 正文与整包走 **stdin 里的 JSON**（`deep_check()` 那边 `json.dumps` 的那一份），
+#:    **既不往脚本里拼字符串**（块正文里一个引号就能把脚本本身改坏），**也不走环境变量**
+#:    （Linux 对单个环境字符串有 128 KiB 硬上限 ⇒ 包一大就 E2BIG，见 `subproc.py` 的文件头）。
 #: ⚠️ 这一段里**不许出现反引号**：它整段嵌在本文件的字符串里（模板正文里的反引号会把模板截断，
 #:    `tools/find-stray-backticks.py` 就是拿 `node --check` 兜这一类事故的）。
 _CHECK = r'''
@@ -270,6 +289,15 @@ except Exception:
 #       不停用、也不报错）⇒ 症状是"保存一个引用了不存在模块的块居然 200"（真踩过）。
 from labull_framework.magic_block.sdk import is_excluded
 
+# 🔴 父进程从 **stdin** 递进来的那一份（`deep_check()` 组、`_BOOTSTRAP` 收）：正文 / 整包 /
+#    基线 / 主文件名 / 开关全在里面。**这就是这一层唯一的数据来源**（环境变量里只有
+#    `PYTHONPATH` / `PYTHONIOENCODING` 那几个小变量，所以不会撞内核那条 128 KiB 的单串上限）。
+# ⚠️ `globals().get(...)` 而不是直接写 `_GIVEN`：这一段可能被单独 exec（手工调试）——
+#    那种时候它得是个空字典**而不是 NameError**（NameError 会让整层静默失效，见文件头）。
+#    取不到的那几项后面会以 KeyError / 一句明确的 RuntimeError 收场 ⇒ 父进程报"自己没跑起来，
+#    这一次没验"（软失败），**不会**变成"什么都没报 = 全绿"。
+_GIVEN = globals().get('_GIVEN') or {}
+
 # 🔴 基线里那几条**已经没了的字段名**（父进程从 git 那份契约算出来，见 `canvas.data.deleted_field_names()`）：
 #    `_DEAD` 是全集（字段名 → 它在哪几个模型上被删了），
 #    `_DEAD_BY` 是按模型分开的那一份（知道 `row` 是哪个模型时用，报文能点名"就是这张表"）。
@@ -302,15 +330,20 @@ def _read_dead(raw):
 
 
 try:
-    _read_dead(json.loads(os.environ.get('LABULL_DEEP_DELETED') or '{}'))
+    _read_dead(_GIVEN.get('deleted'))
 except Exception:
     pass
 
-# 🔴 主文件名**在这里从环境变量取**（不靠 `main()` 里的局部量）：下面那几个"点某一处引用"的
+# 🔴 主文件名**在这里取**（不靠 `main()` 里的局部量）：下面那几个"点某一处引用"的
 #    判据是**模块级函数**，它们看不见 `main()` 的局部变量 —— 引用一个不存在的名字会让
 #    整个 `_static_check` 以 `NameError` 收场，而那一层是**软失败**（只记一句"深检自己失败了"、
 #    不停用、也不报错）⇒ 症状是"新判据一条都不报、旧判据照旧"。这里真踩过一次。
-_MAIN_FILE = os.environ.get('LABULL_DEEP_MAIN_FILE') or 'backend_open.py'
+_MAIN_FILE = str(_GIVEN.get('main_file') or 'backend_open.py')
+
+#: 同上的小写那一份（`probe()` / `_handlers()` 用的是它）。
+#: ⚠️ 它从前是**引导脚本注入**进命名空间的（`space["_main_file"] = …`），现在是这里的一行 ——
+#:    两边都行，但**必须有一边**：少了它就是 `NameError`，而"试跑那一层静默不跑"正是它的症状。
+_main_file = _MAIN_FILE
 
 #: 现在静态过的是**哪一份文件**（`main()` 每份 .py 前落一次，见 `_static_check()`）。
 #: 🔴 报文从前写死主文件名：多入口块里 `material_master.py` 的条目也报成
@@ -365,18 +398,19 @@ def main():
     if not settings.configured:
         return _unavailable('Django 设置没配好，这一块这一次没验')
 
-    source = json.loads(os.environ['LABULL_DEEP_SOURCE'])
-    # 🔴 整包一起验（块包可以拆文件）：`LABULL_DEEP_FILES` 是 `{包内相对路径: 正文}`。
+    # 🔴 正文与整包是父进程从 **stdin** 递进来的（见 `_GIVEN` 那一段与 `subproc.py`）。
+    #    递不进来时**要说出来**：这里一声不响地退回空正文，症状就是"判据一条都不报、保存全放行"
+    #    —— 那正是这一层最怕的那种静默失效（`main()` 抛出去反而安全：父进程会记一句"自己没跑起来"）。
+    if 'source' not in _GIVEN and 'files' not in _GIVEN:
+        raise RuntimeError('父进程没把正文递进来（深检的数据走 stdin，见 deepcheck.deep_check()）')
+    source = str(_GIVEN.get('source') or '')
+    # 🔴 整包一起验（块包可以拆文件）：`files` 是 `{包内相对路径: 正文}`。
     # ⚠️ **子进程里没有父进程模块级的那些名字、也没有 wrapper 里的 `_parent`**：
     #    要什么就自己 import（这一段顶上只 import 了 `...sdk` 那几个）。
     #    写一个不存在的名字会让整层深检**静默失效**（`NameError` 被 `_unavailable` 吞成一句说明，
     #    保存于是全放行）—— 这里真踩过，而且是"改动前能报的错、改动后不报了"这种最难发现的形态。
     from labull_framework.magic_block import blockpackage as _blockpackage
-    _main_file = os.environ.get('LABULL_DEEP_MAIN_FILE') or 'backend_open.py'
-    try:
-        raw_package = json.loads(os.environ.get('LABULL_DEEP_FILES') or '{}')
-    except ValueError:
-        raw_package = {}
+    raw_package = _GIVEN.get('files') or {}
     package: dict[str, str] = (
         {str(name): str(body) for name, body in raw_package.items()} if isinstance(raw_package, dict) else {}
     )
@@ -392,7 +426,7 @@ def main():
             f'要么放进**项目**里的公共模块再 import（那是普通 Python，随便用）。',
         ))
 
-    module_name = str(os.environ.get('LABULL_DEEP_MODULE') or 'backend_open')
+    module_name = str(_GIVEN.get('module') or 'backend_open')
 
     # 🔴 **每一份 `.py` 都静态过一遍**（不只主文件）：拆出去的文件里 `Order.no` 这种写法
     #    同样要在保存时现形。`_imported_models` 只对"导入了模型"的文件起作用，
@@ -417,13 +451,14 @@ def main():
     # 🔴 试跑那一层会用到的几个函数（撒样例行 / 取主键 / 错该算谁头上）是**从外面注入**的
     #    （见 `deep_check()` 里那个 wrapper）：它们只有一份实现（模块级那几个），
     #    这里**不许再抄一份** —— 抄一份的下场是"保存时说合法、体检时说非法"。
-    if str(os.environ.get('LABULL_DEEP_PROBE') or '') == '1':
+    probing = bool(_GIVEN.get('probe'))
+    if probing:
         probe(source, module_name, apps, package)
     # 🔴 **"这一次没验运行期"必须说出来**（用户 0.1.19 报的第三条）：探针没跑时，
     #    `probe()` 那几条说明是**不会出现**的（它压根没进去），于是"说明"是空的、
     #    结论那一栏看起来就是"全绿" —— 而"全绿"会被读成"运行期也验过了"。
     #    这一句只在"探针没跑"时补，判据与 `deepcheck.probe_enabled()` **同一份**（见它）。
-    if str(os.environ.get('LABULL_DEEP_PROBE') or '') != '1' and not _any_probe_note():
+    if not probing and not _any_probe_note():
         _NOTES.append('这一次只做了**静态判据**（引用 / 字段 / 枚举在不在），'
                       '运行期错误**没验**（探针没跑）—— 全绿不等于"跑得起来"')
     return _result()
@@ -1062,8 +1097,8 @@ def _run(handlers):
         block={'id': '', 'module': '', 'name': '体检', 'brief': ''},
     )
     params = _params()
-    source = os.environ.get('LABULL_DEEP_SOURCE') or ''
-    limit = int(os.environ.get('LABULL_DEEP_PROBE_LIMIT') or 6)
+    source = str(_GIVEN.get('source') or '')
+    limit = int(_GIVEN.get('limit') or 6)
     ran = 0
     for route, handler, broke in handlers:
         if broke is not None:
@@ -1112,7 +1147,7 @@ def _report(route, exc):
 
 
 def _params():
-    raw = os.environ.get('LABULL_DEEP_PROBE_PARAMS') or '{}'
+    raw = _GIVEN.get('params') or '{}'
     try:
         value = json.loads(raw)
     except Exception:
@@ -1154,14 +1189,22 @@ def deep_check(
            而体检是对每个块各问一次的（见 `canvas.data` 里那段缓存的说明）。
 
     🔴 只回**拿得准的问题**：环境交不出来时回 `([], ['没验…'])` —— 说明进日志，不落库、不停用。
+    🔴 **正文与整包走 stdin**（不是环境变量、也不是 argv）：这一包有多大是作者说了算的，
+       而内核给单个参数 / 环境字符串的额度只有 128 KiB（见 `subproc.py` 的文件头）——
+       从前它一走环境变量，两个大块就必然 E2BIG，且**改完存不回去**。
     """
     if not str(src or '').strip():
         return [], []
+    #: 子进程的引导脚本（`-c` 那一小段进 argv ⇒ 它**只许是常量**，一个字节的数据都不许带）。
     child = (
         'import json, os, sys\n'
         'sys.path[:0] = [item for item in (os.environ.get("LABULL_DEEP_PATH") or "").split(os.pathsep) if item]\n'
+        # 🔴 数据从 **stdin** 进来，且**显式按 UTF-8 解**（`sys.stdin.buffer`）：子进程的
+        #    `sys.stdin.encoding` 是 locale 那一套（中文 Windows = cp936），而父进程递的是 UTF-8。
+        '_raw = sys.stdin.buffer.read() if hasattr(sys.stdin, "buffer") else sys.stdin.read().encode("utf-8")\n'
+        '_given = json.loads(_raw.decode("utf-8", "replace") or "{}")\n'
         'from labull_framework.magic_block import deepcheck as _parent\n'
-        'space = {"__name__": "__deepcheck__"}\n'
+        'space = {"__name__": "__deepcheck__", "_GIVEN": _given}\n'
         # 🔴 这几个函数**只有一份实现**（本模块模块级那几个），编译进来那份正文从命名空间里取用。
         #    在子进程里抄一份的下场是"保存时说合法、体检时说非法"。
         #    ⚠️ `_where` **不在**这个名单里：子进程自己那份认得 `backend_open.py` 这个文件名，
@@ -1169,41 +1212,54 @@ def deep_check(
         'for _name in ("_seed_rows", "_filled", "_blamable", "_needs_params", "_failure_message",\n'
         '              "_route_models"):\n'
         '    space[_name] = getattr(_parent, _name)\n'
-        # ⚠️ `_main_file` 也要注入：`probe()` 是**父进程的函数**、在子进程的命名空间里执行，
-        #    所以它只能读子进程的全局（先前漏了这一条 ⇒ `NameError` ⇒ 试跑那一层静默不跑）。
-        'space["_main_file"] = os.environ.get("LABULL_DEEP_MAIN_FILE") or "backend_open.py"\n'
-        'exec(compile(os.environ["LABULL_DEEP_CHECK"], "labull_deepcheck.py", "exec"), space)\n'
+        'exec(compile(str(_given["check"]), "labull_deepcheck.py", "exec"), space)\n'
         'print("LABULL_DEEP_RESULT" + json.dumps(space["_RESULT_"], ensure_ascii=False))\n'
     )
-    env = dict(os.environ)
-    # 🔴 把父进程的 `sys.path` 交过去：子进程默认的 path 里没有项目根，
-    #    不交的话每个块都会报"找不到 orders / modules"——那是假错。
-    env['PYTHONPATH'] = os.pathsep.join(item for item in sys.path if item)
-    env['LABULL_DEEP_PATH'] = env['PYTHONPATH']
-    env['LABULL_DEEP_CHECK'] = _CHECK
-    env['LABULL_DEEP_SOURCE'] = json.dumps(src, ensure_ascii=False)
-    # 🔴 主文件名由父进程告诉子进程（子进程里**没有**父进程模块级的 `BLOCK_BACKEND_FILE`）。
-    env['LABULL_DEEP_MAIN_FILE'] = BLOCK_BACKEND_FILE
-    # 🔴 **整包**一起递（不只主文件）：拆过文件的块要靠兄弟文件才加载得起来，
-    #    否则保存时说"加载不起来"，而它明明在包里。
-    env['LABULL_DEEP_FILES'] = json.dumps(
-        {name: body for name, body in (files or {}).items()
-         if isinstance(body, str) and name.endswith('.py') and not is_excluded(name)},
-        ensure_ascii=False,
-    )
-    env['LABULL_DEEP_PROBE'] = '1' if probe else '0'
-    env['LABULL_DEEP_PROBE_LIMIT'] = str(PROBE_LIMIT)
     # 🔴 基线里那些"已经没了的字段名"交给子进程（它是**数据**、不是代码：子进程没有父进程的
     #    app registry，自己去比一遍契约是不可能的）。序列化失败就当没有 —— 少一条判据，
     #    绝不让整个深检炸掉（这一层的软失败口径见文件头）。
     try:
-        env['LABULL_DEEP_DELETED'] = json.dumps(deleted or {}, ensure_ascii=False)
+        dead = deleted or {}
+        json.dumps(dead, ensure_ascii=False)
     except (TypeError, ValueError):
-        env['LABULL_DEEP_DELETED'] = '{}'
+        dead = {}
+    # 🔴 探针那一次用的参数：**作者给的 `probe.open.json` 优先**，宿主环境里那个
+    #    `LABULL_DEEP_PROBE_PARAMS` 兜底（与"数据走文件"之前的行为逐字一致 —— 那时子进程读的
+    #    就是父进程环境里这一项，而父进程只在作者给了文件时才把它盖掉）。
     params = (files or {}).get(PROBE_PARAMS_FILE)
-    if isinstance(params, str) and params.strip():
-        env[BLOCK_PROBE_PARAMS] = params
-    # 🔴 这一段子进程的编码要**两头都钉死**（子进程按 UTF-8 写、父进程按 UTF-8 读）：
+    if not (isinstance(params, str) and params.strip()):
+        params = os.environ.get(BLOCK_PROBE_PARAMS) or ''
+    payload_json = json.dumps(
+        {
+            # 🔴 判据正文（那一段 `_CHECK`）也走这里：它本身就有几十 KB，塞环境变量是同一个坑。
+            'check': _CHECK,
+            'source': src,
+            # 🔴 **整包**一起递（不只主文件）：拆过文件的块要靠兄弟文件才加载得起来，
+            #    否则保存时说"加载不起来"，而它明明在包里。
+            'files': {
+                name: body for name, body in (files or {}).items()
+                if isinstance(body, str) and name.endswith('.py') and not is_excluded(name)
+            },
+            # 🔴 主文件名由父进程告诉子进程（子进程里**没有**父进程模块级的 `BLOCK_BACKEND_FILE`）。
+            'main_file': BLOCK_BACKEND_FILE,
+            # ⚠️ 这一个是从**宿主环境**读的（框架自己不设它）：与从前逐字一致，
+            #    它只影响"块模块被塞进 `sys.modules` 时叫什么名字"。
+            'module': os.environ.get('LABULL_DEEP_MODULE') or 'backend_open',
+            'deleted': dead,
+            'probe': bool(probe),
+            'limit': PROBE_LIMIT,
+            # ⚠️ 参数是**小数据**（作者写的一段 JSON），但仍走同一个通道：这一层"数据只有一条路"
+            #    （少一条通道就少一处"某个调用点还塞环境变量"的复发空间）。
+            'params': params if params.strip() else '',
+        },
+        ensure_ascii=False,
+    )
+    env = dict(os.environ)
+    # 🔴 把父进程的 `sys.path` 交过去：子进程默认的 path 里没有项目根，
+    #    不交的话每个块都会报"找不到 orders / modules"——那是假错。
+    env['PYTHONPATH'] = os.pathsep.join(item for item in sys.path if item)
+    env['LABULL_DEEP_PATH'] = env['PYTHONPATH']
+    # 🔴 这一段子进程的编码要**两头都钉死**（子进程按 UTF-8 读 stdin / 写 stdout，父进程按 UTF-8 解码）：
     #    只写 `text=True` 的话，父进程用 `locale.getpreferredencoding(False)` 解码
     #    （中文 Windows = cp936），而子进程一旦吐 UTF-8 —— 服务进程环境里有
     #    `PYTHONIOENCODING=utf-8` / `PYTHONUTF8=1` 这类东西时就是这样 —— `subprocess` 的
@@ -1214,18 +1270,8 @@ def deep_check(
     env['PYTHONIOENCODING'] = 'utf-8'
     # Windows 商店版 Python 的 `sys.executable` 可能是 None，拿不到就没有解释器可用。
     interpreter = sys.executable or 'python'
-    try:
-        done = subprocess.run(
-            [interpreter, '-c', child],
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding='utf-8',
-            # 第二道保险：真碰上编码诡异的输出，也宁可显示成问号，不要让解码线程死掉。
-            errors='replace',
-            timeout=DEEP_TIMEOUT,
-        )
-    except subprocess.TimeoutExpired:
+    child_done = run_child([interpreter, '-c', child], env, payload_json, DEEP_TIMEOUT, '引用深检')
+    if child_done.timed_out:
         return (
             [
                 (
@@ -1236,25 +1282,38 @@ def deep_check(
             ],
             [],
         )
-    except OSError as exc:
+    if not child_done.started:
+        if child_done.arg_limit:
+            # 🔴 **判据自己起不来不算这个块的错**（软失败口径见文件头）：回 `([], [说明])` ——
+            #    不落库、不停用，**更不拦保存**。⚠️ 这一条从前是一句 issue（"找不到可用的 Python
+            #    解释器"），而同一个判据也在保存那条路上（`service._vet` 的 `if issues: raise
+            #    SaveRejected`）⇒ 后果是**整个块存不回去**，而块自己一点毛病都没有（用户报的那条）。
+            #    ⚠️ 数据现在走 stdin，所以走到这里只可能是**宿主进程自己的环境块**撑爆了内核那条线。
+            return [], [
+                f'{BLOCK_BACKEND_FILE} 的引用深检这一次没跑：{child_done.why}。'
+                f'这一层的数据本来走 stdin（环境变量与 argv 里只放小变量），所以这是宿主环境的额度不够，'
+                f'**不是这个块的问题** —— 没验这一块不等于它有问题（不落库、不停用，也不拦保存）。'
+            ]
         return (
-            [('backend', f'{BLOCK_BACKEND_FILE} 引用深检跑不起来（{exc}）：找不到可用的 Python 解释器')],
+            [('backend', f'{BLOCK_BACKEND_FILE} 引用深检跑不起来：{child_done.why}')],
             [],
         )
 
-    if done.stdout is None:
+    if child_done.stdout is None:
         # 正常走不到这里（上面 `encoding` / `errors` 已经给全）；真走到了也**不许静默**：
         # 至少把 stderr 的最后一行说出来，否则"编码不对 ⇒ 什么都没验"会一直隐形。
-        tail = (done.stderr or '').strip().splitlines()
+        tail = (child_done.stderr or '').strip().splitlines()
         return [], [
-            f'引用深检的输出没能解码（returncode={done.returncode}）：'
+            f'引用深检的输出没能解码（returncode={child_done.returncode}）：'
             f'{tail[-1] if tail else "没有 stderr"}'
         ]
-    payload = _payload_of(done.stdout or '')
+    payload = _payload_of(child_done.stdout or '')
     if payload is None:
-        detail = (done.stderr or done.stdout or '').strip().splitlines()
+        detail = (child_done.stderr or child_done.stdout or '').strip().splitlines()
         # 🔴 判据自己崩了**不算这个块的错**：那不是"作者写坏了"，是环境交不出来。
-        return [], [f'引用深检自己没跑起来（{detail[-1] if detail else done.returncode}），这一次没验']
+        return [], [
+            f'引用深检自己没跑起来（{detail[-1] if detail else child_done.returncode}），这一次没验'
+        ]
     issues = [
         (str(item.get('stage') or 'backend'), str(item.get('message') or ''))
         for item in payload.get('issues') or []

{labull_framework-0.1.30 → labull_framework-0.1.32}/labull_framework/magic_block/parallel.py

@@ -16,10 +16,15 @@
 
 🔴 **为什么要有上限**：一次全量体检 = N 个块 × 2 个子进程，每个子进程都要跑一遍 `django.setup()`。
    不限并发的话，20 个块就能同时拉起几十个 Python 进程：内存与 CPU 一起打满，
-   而子进程一慢就会撞上 `validate.TRIAL_LOAD_TIMEOUT` / `deepcheck.DEEP_TIMEOUT`（10 秒）——
+   而子进程一慢就会撞上 `validate.TRIAL_LOAD_TIMEOUT` / `deepcheck.DEEP_TIMEOUT`（30 秒）——
    **超时不算通过**（那是"不知道"，不是"没问题"），于是本来好好的块会被判成不通过。
    所以并发度是**够用就好**，不是越大越好：下面的默认值与上限就是照上面那组实测定的。
 
+   ⚠️ 那两个超时原先是 10 秒，正因为**在这个并发下被撞穿**才调到 30（现场 4 个好块被误判
+      成"疑似死循环"并被停用）。所以下面这个默认值 `4` 与那 30 秒是**一起定的一对数**：
+      调大并发度就等于给每个子进程少留 CPU，超时那个判据会先撑不住。
+      机器小就往下调（`LABULL_BLOCK_WORKERS=2`），别往上调着玩。
+
 🔴 并发度可配：`settings.LABULL_BLOCK_WORKERS = 4`（或环境变量 `LABULL_BLOCK_WORKERS`）。
    配 `1` 就是退回串行 —— 排查"并发引入的怪事"时先试它。
    ⚠️ 启动体检（`health.startup_once()`）走的是同一个口子：多进程部署（gunicorn 起 N 个 worker）时
@@ -43,7 +48,7 @@ ENV_WORKERS = 'LABULL_BLOCK_WORKERS'
 #: 4 与 8 差不多，而 4 同时只拉起 4 个 `django.setup()` 子进程（内存与 CPU 都更稳）。
 DEFAULT_WORKERS = 4
 
-#: 上限：再多也不会更快（瓶颈是"起子进程"），只会把机器压垮 —— 而子进程一慢就撞 10 秒超时，
+#: 上限：再多也不会更快（瓶颈是"起子进程"），只会把机器压垮 —— 而子进程一慢就撞那两个超时，
 #: 超时不算通过 ⇒ 本来好好的块会被判成不通过（见本文件头部第三段）。
 MAX_WORKERS = 8
 

labull_framework-0.1.32/labull_framework/magic_block/subproc.py

@@ -0,0 +1,175 @@
+"""
+子进程那一层的**唯一一份**规矩：数据走 stdin、环境里只放小东西、起不来时分得清是哪一种起不来。
+
+🔴 **这个文件存在的理由**（用户报的那个缺陷，两个大块必然红字、而且改完存不回去）：
+   从前"整包正文"是塞进**环境变量**递给子进程的（`LABULL_DEEP_FILES` / `LABULL_DEEP_SOURCE` /
+   `LABULL_TRIAL_FILES`）。而 Linux 对**单个** argv / 环境字符串有一条硬上限
+   `MAX_ARG_STRLEN = 32 * PAGE_SIZE = 128 KiB`：包一大，`execve` 直接回 `E2BIG`
+   （CPython 把它映射成 errno 7，`OSError` 的文案固定是 `Argument list too long`）。
+   而框架从前把**所有** `OSError` 都说成"找不到可用的 Python 解释器" ——
+   于是现场看到的是一句查不出来的话（解释器明明在、镜像没问题），真因是"递过去的东西太大"。
+   更糟的是同一个判据也在**保存**那条路上（`service._vet`）：后果不是"少验一次"，
+   而是**整个块存不回去**（实测：14 个块里那两个大块 —— `LABULL_DEEP_FILES` 349,052 /
+   336,688 字节 —— 必然红字，其余 12 个 20~126 KB 全正常，与"单串超没超 128 KiB"逐块对得上）。
+
+🔴 所以修法是**两件**事，缺一件都不算修好：
+   ① **数据一律走 stdin**（`run_child(payload=…)` ⇒ `subprocess.run(input=…)`）：
+      环境块与 argv 里只剩 `PYTHONPATH` / `PYTHONIOENCODING` 那几个小变量，于是
+      单串上限（128 KiB）与总量上限（`SC_ARG_MAX`，默认 ≈ 2 MB）**一起**摆脱；
+   ② 递之前按**字节数**量一遍（`oversize()`），真超线就回一句能照着改的人话，
+      **不要盲目 execve** 再拿 errno 7 去猜（那条线是内核的，不是解释器的）；
+      而起不来时按 `errno` **分开报**：`E2BIG` = 内核的参数 / 环境上限，`ENOENT` = 真的没有解释器。
+
+⚠️ 这两件事的分工：`oversize()` 是**前置**判据（只报"确定超线"的，宁可漏报 —— 误报一句
+   就等于白白少验一次，而它要拦的那种场景本来也会以 E2BIG 收场）；`run_child()` 是**兜底**
+   （真撞上了也要说清楚是哪一种）。两处都只**描述**事实，"这一次还要不要算通过"由调用方定：
+   深检那一侧的口径是**软失败**（回 `([], ['没验…'])`：不落库、不停用、也不拦保存）。
+"""
+
+from __future__ import annotations
+
+import errno
+import os
+import subprocess
+from dataclasses import dataclass
+from typing import Any, Mapping, Sequence
+
+#: 内核上限：**单个** argv / 环境字符串最多这么长（Linux 的 `MAX_ARG_STRLEN = 32 * PAGE_SIZE`）。
+#:
+#: 🔴 它量的是**字节**，不是字符数：中文正文按 3 字节一个字算（所以 128 KiB ≈ 4.3 万个汉字）。
+#: 🔴 它是**硬**上限（超了必 E2BIG），而且与"解释器在不在"毫无关系 —— 这两件事从前被合成了一句
+#:    "找不到可用的 Python 解释器"，是那个缺陷最难查的地方。
+#: ⚠️ 这是 Linux 的数（生产部署在那儿）；别的平台没有同一条规矩，这里**照它保守估**。
+#:    代价只是"早报一句、少验一次"，而盲目 execve 的代价是一句查不出来的 errno 7 —— 两边一比就清楚。
+MAX_ARG_STRLEN = 32 * 4096  # 131072 = 128 KiB
+
+#: 拿不到 `SC_ARG_MAX`（Windows / 平台不给）时按这个经验值当"argv + 环境块总量"那条线。
+FALLBACK_ARG_MAX = 2 * 1024 * 1024
+
+
+def arg_max() -> int:
+    """`argv` + 环境块**加起来**那条线（能问内核就问，问不到退回经验值）。
+
+    🔴 Linux 上它是 `SC_ARG_MAX`（默认 ≈ stack/4 ≈ 2 MB），而且 `execve` 先扣掉环境块本身
+       ⇒ 真实可用的比这个数还小。这里只拿它当"必然失败"的闸门，不做任何折扣：
+       折扣估出来的是"可能会失败"，而"可能"不该让判据少验一次（见文件头那条）。
+    """
+    try:
+        value = int(os.sysconf('SC_ARG_MAX'))
+    except (AttributeError, ValueError, OSError):  # Windows 没有 os.sysconf
+        return FALLBACK_ARG_MAX
+    return value if value > 0 else FALLBACK_ARG_MAX
+
+
+def _size(text: Any) -> int:
+    """一个字符串进内核时占多少字节（UTF-8；`surrogatepass` 兜住落单的代理字符）。"""
+    return len(str(text).encode('utf-8', 'surrogatepass'))
+
+
+def oversize(argv: Sequence[str], env: Mapping[str, str] | None) -> str:
+    """`(argv, env)` 里有没有**必然**让 `execve` 失败的那一条：回一句人话，`''` 表示没有。
+
+    🔴 只报"确定超线"的两种：单个字符串 > `MAX_ARG_STRLEN`、或总量 > `SC_ARG_MAX`
+       （见文件头那条：这一层误报一句 = 白白少验一次，而它拦的场景本来也会以 E2BIG 收场）。
+    🔴 报文里必须有**三项**：是哪一个（变量名 / argv 第几项）、它多大、上限多大 ——
+       少了任一项，看的人就只能去猜（"把整包塞环境变量"那个根因正是这么藏起来的）。
+    """
+    biggest, where = 0, ''
+    for name, value in (env or {}).items():
+        size = _size(value)
+        if size > biggest:
+            biggest, where = size, f'环境变量 {name}'
+    for index, item in enumerate(argv or ()):
+        size = _size(item)
+        if size > biggest:
+            biggest, where = size, f'argv 第 {index} 项'
+    if biggest > MAX_ARG_STRLEN:
+        return (f'{where} 是 {biggest:,} 字节，超过内核**单个**参数 / 环境字符串的上限 '
+                f'{MAX_ARG_STRLEN:,} 字节（MAX_ARG_STRLEN = 32 × 页面大小 = 128 KiB）')
+    total = sum(_size(f'{name}={value}') for name, value in (env or {}).items())
+    total += sum(_size(item) for item in (argv or ()))
+    limit = arg_max()
+    if total > limit:
+        return (f'argv 与环境变量加起来 {total:,} 字节，超过内核上限 {limit:,} 字节'
+                f'（SC_ARG_MAX；execve 还要先扣掉环境块本身）')
+    return ''
+
+
+@dataclass(frozen=True)
+class Child:
+    """一次子进程的结果：**永不抛** —— 起不来、超时都收在这个对象里（报文由调用方组）。"""
+
+    #: 进程真的起来了（`False` ⇒ 看 `why`，别去读 `returncode`）。
+    started: bool = True
+    #: 起来了但超时被杀（那两处报文不一样：深检说"中止"、试加载说"加载超时"）。
+    timed_out: bool = False
+    returncode: int = 0
+    #: ⚠️ `None` 是"解码线程死了"那种情况（`errors='replace'` 之后基本见不到，但**不许静默**）。
+    stdout: str | None = None
+    stderr: str = ''
+    #: `started is False` 时的那一句人话。
+    why: str = ''
+    #: 这条失败是"内核的参数 / 环境上限"（E2BIG）—— **不是**这个块的错，调用方该按软失败处理。
+    arg_limit: bool = False
+    #: 这条失败是"真的没有解释器"（ENOENT）—— 环境坏了，什么都验不了。
+    missing: bool = False
+
+
+def _oserror_why(exc: OSError) -> str:
+    """起不来时的一句人话：**按 errno 分开说**（E2BIG 与 ENOENT 从前被合成了一句，见文件头）。"""
+    number = getattr(exc, 'errno', None)
+    if number == errno.E2BIG:
+        return (f'内核拒绝了这一次 execve（{exc}；errno 7 = E2BIG）。'
+                f'⚠️ 这**不是**"找不到 Python 解释器"—— 解释器在，是递给内核的参数 / 环境太大'
+                f'（单个字符串上限 {MAX_ARG_STRLEN:,} 字节，总量上限 {arg_max():,} 字节）')
+    if number == errno.ENOENT:
+        return f'找不到可用的 Python 解释器（{exc}）'
+    return f'子进程起不来（{type(exc).__name__}: {exc}；errno={number}）'
+
+
+def run_child(
+    argv: Sequence[str],
+    env: Mapping[str, str] | None,
+    payload: str,
+    timeout: int | float,
+    what: str,
+) -> Child:
+    """把 `payload` 从 **stdin** 递进去跑一次子进程（数据**不走** argv / 环境变量）。
+
+    :param what: 报文里怎么称呼这一次（`引用深检` / `试加载`）。
+
+    🔴 编码两头钉死：子进程按 UTF-8 读 stdin / 写 stdout，父进程按 UTF-8 解码。
+       只写 `text=True` 的话父进程用 `locale.getpreferredencoding(False)` 解码
+       （中文 Windows = cp936），而子进程一旦吐 UTF-8，`subprocess` 的**解码线程**就会抛
+       `UnicodeDecodeError` 死掉 —— 那个异常在**线程**里：主线程看不见、`returncode` 仍是 0，
+       症状是"这一层只是没跑起来"（真踩过；同一个坑见 `canvas/gitinfo.py` 的 `_run()`）。
+       ⚠️ `errors='replace'` 同时管两头：stdout 那边防解码线程死掉，stdin 这边让正文里
+       落单的代理字符变成 `?` 而不是抛 `UnicodeEncodeError`（那种正文来自库 / JSON，
+       `validate._content_key()` 专门为它写了 `surrogatepass`）。
+    """
+    reason = oversize(argv, env)
+    if reason:
+        # 🔴 前置判据拦住的那一种：**不要**再去 execve 一趟（那只会拿回一句 errno 7）。
+        return Child(started=False, why=f'{what}没法把这一包递出去：{reason}', arg_limit=True)
+    try:
+        done = subprocess.run(
+            list(argv),
+            env=dict(env or {}),
+            input=payload,
+            capture_output=True,
+            text=True,
+            encoding='utf-8',
+            errors='replace',
+            timeout=timeout,
+        )
+    except subprocess.TimeoutExpired:
+        return Child(timed_out=True, returncode=-1)
+    except OSError as exc:
+        number = getattr(exc, 'errno', None)
+        return Child(
+            started=False,
+            why=_oserror_why(exc),
+            arg_limit=(number == errno.E2BIG),
+            missing=(number == errno.ENOENT),
+        )
+    return Child(returncode=done.returncode, stdout=done.stdout, stderr=done.stderr or '')

{labull_framework-0.1.30 → labull_framework-0.1.32}/labull_framework/magic_block/validate.py

@@ -5,7 +5,9 @@
 而"保存说合法、体检说非法"是最难查的一类事故。
 
 🔴 试加载与引用深检都在**子进程**里：那份代码是使用者写的，顶层死循环 / 主动 `os._exit`
-   会带走整个服务进程。超时（10 秒）**不算通过** —— "不知道"不等于"没问题"。
+   会带走整个服务进程。超时（`TRIAL_LOAD_TIMEOUT` = 30 秒）**不算通过** —— "不知道"不等于"没问题"。
+🔴 递给那两个子进程的**整包正文一律走 stdin**（`subproc.run_child()`）：环境变量只有内核给的
+   128 KiB 单串额度，包一大就 E2BIG（详见 `subproc.py` 的文件头，那一层只有一份实现）。
 🔴 引用深检那一层还要一份**基线**：`canvas.data.deleted_field_names()`（"git 那版契约里有、
    现在没了"的字段名）。它由 `baseline_fields()` 取、逐块递进子进程 —— 判据与画布上那份
    字段差异**同源**（画布说"删了 N 个字段"、深检说"块里点的那几个还在不在"，两处不许漂）。
@@ -21,7 +23,6 @@ import json
 import logging
 import os
 import re
-import subprocess
 import sys
 import threading
 from pathlib import Path
@@ -39,6 +40,7 @@ from .sdk import (
     is_excluded,
 )
 from . import blockpackage
+from .subproc import run_child
 
 logger = logging.getLogger('labull_framework.magic_block')
 
@@ -102,19 +104,29 @@ SDK_NAMES: tuple[str, ...] = ('MagicBackendAPI', 'errors')
 _NO_DYNAMIC_CODE: frozenset[str] = frozenset({'eval', 'exec'})
 
 #: 试加载的子进程超时（秒）。判据就是这个数。
-TRIAL_LOAD_TIMEOUT = 10
+#:
+#: 🔴 10 → 30（2026-10，用户要求）：与 `deepcheck.DEEP_TIMEOUT` **必须同一个数**。
+#:    两者都是"起一个 `django.setup()` 子进程"，慢的原因一模一样（项目大 ⇒ 冷启动就要几秒，
+#:    再叠加并发那 4 个口子）；只调其中一个，另一个仍会在 10 秒把好块判成不通过，
+#:    只是换了一句报文（"试加载超过 10 秒"）。理由详见 `deepcheck.DEEP_TIMEOUT` 那一段。
+TRIAL_LOAD_TIMEOUT = 30
 
 #: 试加载脚本：真的 import 那份 SDK 模块、把块后端加载一次。
-#: 🔴 块正文走**环境变量里的 JSON**，不往脚本里拼字符串（正文里一个引号就能把脚本本身改坏）。
-#: 🔴 **整包**一起递进去（`LABULL_TRIAL_FILES`）：块包可以拆文件（`from helper import x`），
+#: 🔴 块正文走 **stdin 里的 JSON**，不往脚本里拼字符串（正文里一个引号就能把脚本本身改坏），
+#:    也**不走环境变量**（Linux 对单个环境字符串有 128 KiB 硬上限 ⇒ 包一大就 E2BIG，
+#:    见 `subproc.py` 的文件头；那一层只有一份实现，两个子进程共用）。
+#: 🔴 **整包**一起递进去（`files`）：块包可以拆文件（`from helper import x`），
 #:    只递主文件的话，拆过文件的块会在保存时报"找不到 helper"——而它明明在包里。
 #: ⚠️ 这里**不做任何替身**：块 import 什么就真的 import 什么 —— 块能用的东西与项目里别的代码一模一样。
 _TRIAL_SCRIPT = (
     'import json, os, sys\n'
-    'FILES = json.loads(os.environ["LABULL_TRIAL_FILES"])\n'
-    'sys.path[:0] = [item for item in (os.environ.get("LABULL_TRIAL_PATH") or "").split(os.pathsep) if item]\n'
+    # 🔴 显式按 UTF-8 读 stdin（`sys.stdin.buffer`）：子进程的 `sys.stdin.encoding` 是 locale
+    #    那一套（中文 Windows = cp936），而父进程递进来的是 UTF-8。
+    'raw = sys.stdin.buffer.read() if hasattr(sys.stdin, "buffer") else sys.stdin.read().encode("utf-8")\n'
+    'DATA = json.loads(raw.decode("utf-8", "replace") or "{}")\n'
+    'sys.path[:0] = [item for item in (DATA.get("path") or "").split(os.pathsep) if item]\n'
     'from labull_framework.magic_block import blockpackage\n'
-    'loaded = blockpackage.load_block(FILES, tag=os.environ.get("LABULL_TRIAL_TAG") or "trial")\n'
+    'loaded = blockpackage.load_block(DATA.get("files") or {}, tag=DATA.get("tag") or "trial")\n'
     'if loaded.errors:\n'
     '    sys.stderr.write("；".join(loaded.errors))\n'
     '    sys.exit(1)\n'
@@ -747,43 +759,49 @@ def trial_load(src: str, files: dict[str, str] | None = None, tag: str = '') ->
     :param files: 那一整包（拆过文件的块要靠它 —— 兄弟文件也要一起递进去）。
     :param tag: 给包内模块起前缀用的（传块 uuid；不给就用固定串）。
 
-    🔴 超时（10 秒）**不算通过**：那是"不知道"，不是"没问题"。
+    🔴 超时（`TRIAL_LOAD_TIMEOUT` = 30 秒）**不算通过**：那是"不知道"，不是"没问题"。
     🔴 这条判据的价值在**及时报错**：块里 `import` 了一个项目里没装的包、拼错了模块名、
        装饰器参数写错 —— 都在保存那一刻报出来，而不是等到某次请求炸。
+    🔴 **整包走 stdin**（不是环境变量）：这一包有多大是作者说了算的，而内核给单个环境字符串的
+       额度只有 128 KiB（见 `subproc.py` 的文件头）—— 从前它一走环境变量，大块就必然 E2BIG，
+       报出来还是一句"找不到可用的 Python 解释器"（真因完全看不出来）。
     """
     env = dict(os.environ)
     # 🔴 把父进程的 sys.path 交过去：子进程默认的 path 里没有项目根，
     #    不交的话每个块都会报"找不到 labull_framework / modules"——那是假错。
     env['PYTHONPATH'] = os.pathsep.join(item for item in sys.path if item)
-    # 🔴 **整包**递进去（不只主文件）：拆过文件的块要靠它才能 import 到兄弟文件。
-    env['LABULL_TRIAL_FILES'] = json.dumps(files_of(src), ensure_ascii=False)
-    env['LABULL_TRIAL_TAG'] = tag or 'trial'
-    env['LABULL_TRIAL_PATH'] = os.pathsep.join(item for item in sys.path if item)
-    # 🔴 同 `deepcheck.deep_check()`：子进程按 UTF-8 写、父进程按 UTF-8 读，两头都得钉死。
-    #    只写 `text=True` 时父进程按 `locale.getpreferredencoding(False)`（中文 Windows = cp936）
-    #    解码，子进程吐 UTF-8 时解码线程会抛 `UnicodeDecodeError` 死掉 ⇒ `stderr` 变成 None，
-    #    这一层就只剩一句"加载失败（……）：1"（真因被吞了）。
+    # 🔴 同 `deepcheck.deep_check()`：子进程按 UTF-8 读 stdin / 写 stdout，父进程按 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(
-            [interpreter, '-c', _TRIAL_SCRIPT],
-            env=env,
-            capture_output=True,
-            text=True,
-            encoding='utf-8',
-            errors='replace',
-            timeout=TRIAL_LOAD_TIMEOUT,
-        )
-    except subprocess.TimeoutExpired:
+    payload = json.dumps(
+        {
+            # 🔴 **整包**递进去（不只主文件）：拆过文件的块要靠它才能 import 到兄弟文件。
+            'files': files_of(src),
+            'tag': tag or 'trial',
+            'path': os.pathsep.join(item for item in sys.path if item),
+        },
+        ensure_ascii=False,
+    )
+    child = run_child([interpreter, '-c', _TRIAL_SCRIPT], env, payload, TRIAL_LOAD_TIMEOUT, '试加载')
+    if child.timed_out:
         return [f'{BLOCK_BACKEND_FILE} 试加载超过 {TRIAL_LOAD_TIMEOUT} 秒没有结束，已中止（顶层不许做耗时的事）']
-    except OSError as exc:
-        return [f'{BLOCK_BACKEND_FILE} 试加载跑不起来（{exc}）：找不到可用的 Python 解释器']
-
-    if done.returncode == 0:
+    if not child.started:
+        if child.arg_limit:
+            # 🔴 内核的参数 / 环境额度不够 ⇒ **软失败**（口径与 `deepcheck` 那一侧逐字一致）：
+            #    回空 = "没验"，而不是"这个块有问题"。⚠️ 这一条从前是一句 issue，而它在保存那条路上
+            #    （`service._vet` 的 `if issues: raise SaveRejected`）⇒ 后果是**整个块存不回去**。
+            #    ⚠️ 能看见的那一句"没验"由引用深检那一侧出（同一个原因它也一样起不来），
+            #    所以这里不重复报一遍（它就是"环境不够"这一件事的第二个受害者）。
+            return []
+        return [f'{BLOCK_BACKEND_FILE} 试加载跑不起来：{child.why}']
+
+    if child.returncode == 0:
         return []
-    lines = (done.stderr or '').strip().splitlines()
-    return [f'{BLOCK_BACKEND_FILE} 加载失败（顶层与装饰器不许出错）：{lines[-1] if lines else done.returncode}']
+    lines = (child.stderr or '').strip().splitlines()
+    return [f'{BLOCK_BACKEND_FILE} 加载失败（顶层与装饰器不许出错）：{lines[-1] if lines else child.returncode}']
 
 
 # ──────────────────────────── 路由名（唯一一处扫它） ────────────────────────────

{labull_framework-0.1.30 → labull_framework-0.1.32}/labull_framework/settings.py

@@ -217,7 +217,8 @@ def apply_platform_settings(ns: dict) -> None:
     # 🔴 逐块校验（读回改动 / 保存 / 体检）同时开几个口子：一个块的结论要起两个子进程
     #    （试加载 + 引用深检），串行时 20 个块要 17 秒 —— 实测 4 个口子 5.5 秒。
     #    ⚠️ 不是越大越好：每个口子都会拉起一个 `django.setup()` 子进程，而子进程一慢就会撞上
-    #    10 秒超时（超时**不算通过** ⇒ 本来好好的块会被判成不通过）。理由与实测见 `magic_block/parallel.py`。
+    #    那两个子进程超时（`validate.TRIAL_LOAD_TIMEOUT` / `deepcheck.DEEP_TIMEOUT`，现在都是 30 秒；
+    #    超时**不算通过** ⇒ 本来好好的块会被判成不通过）。理由与实测见 `magic_block/parallel.py`。
     ns.setdefault('LABULL_BLOCK_WORKERS', BLOCK_WORKERS)
 
     database_url = env.read_env('DATABASE_URL')

{labull_framework-0.1.30 → labull_framework-0.1.32/labull_framework.egg-info}/PKG-INFO

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

{labull_framework-0.1.30 → labull_framework-0.1.32}/labull_framework.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ labull_framework/magic_block/parallel.py
 labull_framework/magic_block/registry.py
 labull_framework/magic_block/sdk.py
 labull_framework/magic_block/service.py
+labull_framework/magic_block/subproc.py
 labull_framework/magic_block/validate.py
 labull_framework/magic_block/views.py
 labull_framework/management/__init__.py

{labull_framework-0.1.30 → labull_framework-0.1.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "labull-framework"
-version = "0.1.30"
+version = "0.1.32"
 description = "Labull Framework: a pluggable Django app with Authing OIDC login and magic blocks"
 readme = "README-pypi.md"
 requires-python = ">=3.10"
@@ -41,7 +41,7 @@ classifiers = [
 #                     与 `apps.py` 拉起 ⇒ 属于**运行时必需**，不是可选项。
 #     `[crypto]`：OIDC 的 RS/PS/ES/EdDSA 走 JWKS 验签，需要 `cryptography` 后端；
 #                 Authing 那支 HS256 也走同一个后端 ⇒ 一起钉上。
-# 其余顶层名字全是标准库：ast collections dataclasses datetime decimal functools inspect
+# 其余顶层名字全是标准库：ast collections dataclasses datetime decimal errno functools inspect
 # json logging os pathlib re subprocess sys threading time typing urllib uuid。
 dependencies = [
     "Django>=4.2",