nex_animation/scripts/ui/projectswitchcheck.py

416 lines
24 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""项目切换的数据生命周期(第 14 道常驻探针 · 2026-11-10 · NEX 阶段 33 · 用户第 2 条)。
为什么要有这一道(真缺陷,不是假想敌):
store 里「路由现在是哪个项目」和「手上这份数据属于哪个项目」以前是**同一个字段**。
同一次会话里从 A 切到 B(点项目列表的链接、点平台动态里的那条、点概况抽屉里的七站跳转,
走的都是 react-router 的 in-app transition,不重载页面):`id` 立刻变成 B,
而 `project` / `workflow` / `stats` 还是 A —— 概览页于是把上一个项目的 12 个节点
顶在 B 的地址下面(改前实测命中 +40 / +80 ms 两次)。
更糟的是 B 已经被别处删掉:详情 404 只写 `error`,`project` 永远停在 A,
「未找到项目」永远出不来。这不是理论——项目列表 20 秒自刷
(`pages/Dashboard.tsx` 的 `useAutoRefresh`),另一个标签页删掉项目之后,
这一行的链接最多 20 秒内还在,点下去就是这一条。
改前读数:`reports/ui_evidence/nex-p33/projspa_before.log`(缺陷 2 条)。
修法:`stores/project.ts` 增加 `loadedId`(只在拉成功时与数据同写、同清),
非 silent 换项目先清(由 `ProjectDetail.tsx` 既有的骨架态接管),
消费方比 `loadedId` 而不是 `project?.id`;再加请求序号,旧响应不许盖新数据。
没有常驻闸,「先清」这一句会在下一次重构里被静默删掉:它不影响任何单页首次载入,
只有**换项目**才看得出来,而换项目恰好没人截图。
三条判据(退出码 = 缺陷条数,0 = 全绿):
① 换项目不残留 路由已经在 B,页面节点表就不许等于 A 的节点指纹。
中途允许的是「这份数据还不可用」的形态(骨架 / 空表),不是 A 的旧数据。
落定必须是 B 的真值(`SETTLE_MS` 内等不到才算缺陷,避免慢机器假红)。
② 404 必须认错 切到一个详情 404 的项目:必须出现「未找到项目」的 Empty,
节点表必须清空,顶栏胶囊必须退成「项目 #<路由号>」而不是上一个项目的名字;
并且**切回真项目要能恢复**(证明 store 没被一次失败永久污染)。
③ 静置不许闪 停在同一个项目上跨过一整轮 6 秒轮询(`IDLE_MS`,默认 8 秒):
节点表必须一直在,不许出现骨架。这条钉的是反向退化——
有人把「清」加到 silent 通道上,就会变成每 6 秒整屏闪一次骨架。
判据用的探测器 `matches()` 是纯函数,夹具与自证在同文件的 `selftest()`,
由 `scripts/ui/gateprobe.py` 判据 ㉘ 反向验证(它退化成长驻 True / 恒 False 时自证必须红)。
环境要求:一台跑着的前端(默认 :5173)+ 库里至少两个「节点指纹不同」的项目。
凑不齐时直接 EXIT=2 并说明原因,不伪装成绿(§15.1「恒 0 也要说出来」的反面:没量到要说没量到)。
切换用 pushState + popstate:react-router 就是靠 popstate 走 in-app transition,
与点内链走的是同一条路径,不新增 Tab 停靠点、不改任何业务操作。
NEX_BASE=http://127.0.0.1:5173 .venv/bin/python scripts/ui/projectswitchcheck.py
NEX_SHOTS=/tmp/p34 NEX_THEME=dark … # 顺手落三张过程截图(切换途中 / 落定 / 404)。
「切换途中」那张是三条判据跑完之后的**证据补拍**:重新走一遍 A→B、在 +80 ms 处读一次并截图,
不参与任何判据(采样窗口只有几十毫秒,截图本身比窗口长,量了就不准)。它的作用是让人眼直接看到
「清空期显示的是骨架 / 空表,不是上一个项目的节点」——把这条突变回改前行为,同一张图就变成残留。
"""
import importlib.util
import json
import os
import pathlib
import sys
HERE = pathlib.Path(__file__).resolve().parent
ROOT = HERE.parents[1]
def _load(name, rel):
spec = importlib.util.spec_from_file_location(name, str(ROOT / rel))
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
return mod
sc = _load("nex_semanticcheck_for_login", "scripts/ui/semanticcheck.py")
BASE = os.environ.get("NEX_BASE", sc.BASE)
WIDTH = int(os.environ.get("NEX_WIDTH", "1440"))
IDLE_MS = int(os.environ.get("NEX_IDLE_MS", "8000"))
SETTLE_MS = int(os.environ.get("NEX_SETTLE_MS", "8000"))
SHOTS = pathlib.Path(os.environ["NEX_SHOTS"]) if os.environ.get("NEX_SHOTS") else None
THEME = os.environ.get("NEX_THEME", "") # light / dark;只影响截图,判据与主题无关
GHOST = os.environ.get("NEX_GHOST_ID", "999999") # 详情必然 404 的项目号
# 概览页节点表每行的「状态 | 名字 key」前缀 = 这个项目的节点指纹。
# 认 key(`import_script` 这类稳定英文标识)而不是认中文状态,是为了让「同一批节点、
# 状态变了」也算换了指纹——那正是「显示的是不是这一份数据」要看的东西。
STATE_CN = {"done": "已完成", "active": "进行中", "failed": "需处理", "pending": "待处理"}
READ = r"""() => {
const tx = (e) => (e && e.innerText || '').replace(/\s+/g, ' ').trim();
const rows = [...document.querySelectorAll('.nex-table tbody tr')]
.map(tr => [...tr.querySelectorAll('td')].map(tx)).filter(r => r.length);
// 概览页的「流程节点明细」表:认「名字 key」那一列,别的表不算
const nodes = rows.map(r => r.join(' | ')).filter(s => /[a-z_]{4,}/.test(s));
return {
url: location.pathname,
rows: rows.length,
nodes: nodes,
firstCells: (rows[0] || []).slice(0, 4),
skeleton: !!document.querySelector('.ant-skeleton'),
notFound: document.body.innerText.includes('未找到项目'),
hdr: tx(document.querySelector('header')).slice(0, 160),
obs: window.__nexObs ? { removedTR: window.__nexObs.removedTR,
batches: window.__nexObs.batches } : null
};
}"""
LIST = r"""async () => {
const j = await (await fetch('/api/projects')).json();
const list = j.projects || (j.result || {}).projects || [];
// 列表接口自带 workflow(与详情接口同源);取 state/label/key 三样拼指纹
return list.map(p => ({ id: String(p.id), name: p.name,
workflow: (p.workflow || []).map(n => ({ state: n.state, label: n.label, key: n.key })) }));
}"""
NAV = r"""(path) => { history.pushState({}, '', path); dispatchEvent(new PopStateEvent('popstate')); }"""
# 为什么要有观察器:本地接口一次往返只有几毫秒,「清 → 立刻填回来」的窗口比任何
# 轮询采样都短——实测把「清」错加到 silent 通道上(每 6 秒清一次),400 ms 采一次
# 采 20 次一次都没抓到(`/tmp/p34/mutB.log` 缺陷 0),③ 于是成了一条看不见的闸。
# MutationObserver 不吃采样运气:行被摘掉一次就记一次。
# 只数「被摘掉的 <tr>」,不数文字变化——轮询把相对时间从「4 分钟前」刷成「5 分钟前」
# 是 characterData,不是重挂载,那是正常行为,不能算闪。
ARM = r"""() => {
// 只数「和节点表那一族有关的移除」:被摘掉的整行 <tr>,或装着它的更大块
// (ProjectDetail 换骨架时会把整个内容子树一起摘走——那是一次 childList
// 变化,发生在被观察节点的**祖先**上;MutationObserver 不看祖先,
// 所以观察面必须直接铺在 body 上,否则「清空」这件事恰好看不见)。
const isNodeRow = (tr) => /[a-z_]{4,}/.test(tr.textContent || '');
const rowish = (n) => {
if (!n || n.nodeType !== 1) return false;
if (n.tagName === 'TR') return isNodeRow(n);
if (!n.querySelector) return false;
return [...n.querySelectorAll('tr')].some(isNodeRow);
};
const bodies = [...document.querySelectorAll('.nex-table tbody')]
.filter(tb => [...tb.querySelectorAll('tr')].some(isNodeRow));
if (!bodies.length) return { armed: false, why: '页面上找不到节点表 tbody' };
window.__nexObs = { removedTR: 0, batches: 0, bodies: bodies.length };
window.__nexConn && window.__nexConn.disconnect();
window.__nexConn = new MutationObserver((list) => {
for (const m of list) {
let hit = 0;
for (const n of m.removedNodes) if (rowish(n)) hit++;
if (hit) { window.__nexObs.batches++; window.__nexObs.removedTR += hit; }
}
});
window.__nexConn.observe(document.body, { childList: true, subtree: true });
return { armed: true, bodies: bodies.length };
}"""
SET_THEME = r"""(mode) => {
if (!mode) return document.documentElement.getAttribute('data-theme');
localStorage.setItem('nex-the', mode);
document.documentElement.setAttribute('data-theme', mode);
return mode;
}"""
def fingerprint(workflow):
"""节点指纹:逐项「<中文状态> | <label> <key>」,只取前两列能拼出来的部分。"""
return [f"{STATE_CN.get(n['state'], n['state'])} | {n['label']} {n['key']}" for n in workflow]
def matches(read, fp):
"""页面读数是否就是这份节点指纹(按「状态 | 名字 key」前缀逐行比)。
口径两条,都是被假阳性教出来的:
· `len(nodes) < len(fp)` 直接 False —— 骨架 / 半挂载时 nodes 是空的,
它「不等于 A」也「不等于 B」,是「数据还不可用」的第三种形态,不许算命中任何一方;
· 只比**前缀**不比整行 —— 行里第三列往后是产出物计数、时间戳(相对时间会自己走字),
拿整行比会把自己走的时间读成「换了一个项目」。
"""
if not fp or len(read.get("nodes") or []) < len(fp):
return False
for got, want in zip(read["nodes"], fp):
if not got.startswith(want):
return False
return True
def selftest():
"""探测器两头都要灵:恒 True(把残留当正常)与恒 False(三条判据全空转)都必须被抓到。"""
a = ["已完成 | 导入脚本 import_script", "进行中 | 分镜生成 storyboard"]
b = ["待处理 | 导入脚本 import_script"]
rd = lambda rows: {"nodes": rows}
cases = [
("A面相等→命中", matches(rd(a), a) is True),
("B面相等→命中", matches(rd(b), b) is True),
("显示A时不算B→不命中", matches(rd(a), b) is False),
("显示B时不算A→不命中", matches(rd(b), a) is False),
("骨架(空表)→谁都不命中", matches(rd([]), a) is False and matches(rd([]), b) is False),
("半挂载(行数不够)→不命中", matches(rd([a[0]]), a) is False),
("整行多出来的列不影响→命中", matches(rd([x + " | 3 个 | 4 分钟前" for x in a]), a) is True),
("空指纹不许命中任何东西→不命中", matches(rd(a), []) is False),
("某一行状态变了→不命中", matches(rd([b[0], a[1]]), a) is False),
]
bad = [n for n, ok in cases if not ok]
line = (f"SELFTEST OK {len(cases)}/{len(cases)}" if not bad
else f"SELFTEST FAIL {len(bad)}/{len(cases)} " + ",".join(bad))
return (not bad), line
def pick(truth):
"""挑两个节点指纹真的不同的项目——指纹相同就等于页面分不出显示的是谁的数。"""
ids = [i for i, t in truth.items() if t["fp"]]
for i in ids:
for j in ids:
if i != j and truth[i]["fp"] != truth[j]["fp"]:
return i, j
return None, None
def shot(page, name):
if not SHOTS:
return
SHOTS.mkdir(parents=True, exist_ok=True)
p = SHOTS / f"{name}-{WIDTH}{('-' + THEME) if THEME else ''}.png"
page.screenshot(path=str(p))
print(f" 截图 {p}")
def main():
defects, ev = [], {"base": BASE, "width": WIDTH, "idle_ms": IDLE_MS, "settle_ms": SETTLE_MS}
from playwright.sync_api import sync_playwright
with sync_playwright() as pw:
b = pw.chromium.launch()
ctx = b.new_context(viewport={"width": WIDTH, "height": 1000})
page = ctx.new_page()
sc.login(page)
if THEME:
page.goto(BASE + "/", wait_until="domcontentloaded")
page.evaluate(SET_THEME, THEME)
page.goto(BASE + "/", wait_until="networkidle")
page.wait_for_timeout(1500)
raw = page.evaluate(LIST)
truth = {t["id"]: {**t, "fp": fingerprint(t["workflow"])} for t in raw}
A, B = pick(truth)
if not A:
print(f"没有两个节点指纹不同的项目(共 {len(raw)} 个项目)⇒ 页面分不出显示的是谁的数,无法判定")
print("SUMMARY 项目数=%d 缺陷=? 判定=无法判定" % len(raw))
return 2
na, nb = truth[A]["name"], truth[B]["name"]
print(f"项目切换的数据生命周期 | A=#{A}「{na}」节点 {len(truth[A]['fp'])} 个"
f" | B=#{B}「{nb}」节点 {len(truth[B]['fp'])} 个 | base {BASE} · {WIDTH}px"
f"{' · ' + THEME if THEME else ''}")
# ── ③ 静置不许闪:停在 A 上跨过一整轮轮询 ─────────────────────────────
page.goto(f"{BASE}/projects/{A}/overview", wait_until="networkidle")
page.wait_for_timeout(1500)
armed3 = page.evaluate(ARM)
if not armed3.get("armed"):
defects.append(f"③ 观察器布不下去({armed3.get('why')})⇒ 静置判据是空转")
print(f"③ 观察器:{armed3}")
stable = page.evaluate(READ)
ok_stable = matches(stable, truth[A]["fp"])
flick = []
n_idle = max(int(IDLE_MS / 400), 4)
for _ in range(n_idle):
page.wait_for_timeout(400)
r = page.evaluate(READ)
if r["skeleton"] or not matches(r, truth[A]["fp"]):
flick.append((r["skeleton"], len(r["nodes"])))
after3 = page.evaluate(READ)
dropped = (after3["obs"] or {}).get("removedTR", 0) if armed3.get("armed") else None
ok_final3 = matches(after3, truth[A]["fp"])
print(f"\n③ 停在 A 不动 {IDLE_MS} ms(覆盖一轮 6 s 轮询,采样 {n_idle} 次):"
f"起始节点表 {len(stable['nodes'])} 行 | 与 A 真值一致={ok_stable}"
f" | 采样抓到骨架/换数据={len(flick)} 次"
f" | 观察器数到「节点行被摘掉」={dropped} 次(批 {after3['obs']['batches'] if after3['obs'] else '-'})")
if dropped and ok_final3:
defects.append(f"③ 静置期间节点表被重挂载 {dropped} 次(轮询把数据清了又填回来,"
f"采样窗口太短看不见,只有观察器抓得到)")
elif dropped:
print(f" 观察器数到 {dropped} 次摘行,但结束时数据已不等于 A ⇒ 期间项目本身变了,不立案")
if not ok_stable:
print(f" 页面首行:{stable['firstCells']}\n 真值首行:{truth[A]['fp'][:1]}")
defects.append("③ 停在项目概览时节点表与该项目真值不符(基线就不对,后面无法判)")
if flick:
defects.append(f"③ 静置期间节点表被轮询打断(骨架/换数据){len(flick)} 次:{flick[:3]}")
ev["idle"] = {"stable_rows": len(stable["nodes"]), "samples": n_idle, "flicker": flick,
"armed": armed3, "removedTR": dropped, "batches": (after3["obs"] or {}).get("batches")}
# ── ① SPA 内 A→B:细粒度采样找残留 ──────────────────────────────────
page.goto(f"{BASE}/projects/{A}/overview", wait_until="networkidle")
page.wait_for_timeout(1500)
armed1 = page.evaluate(ARM)
page.evaluate(NAV, f"/projects/{B}/overview")
seen = []
tms = [40, 80, 120, 180, 260, 360, 500, 700, 1000, 1500]
prev = 0
for ms in tms:
page.wait_for_timeout(max(ms - prev, 10))
prev = ms
r = page.evaluate(READ)
seen.append((ms, r))
print(f"\n① +{ms:>4}ms url={r['url']:<26} 行{len(r['nodes']):>3} 骨架={str(r['skeleton']):<5}"
f" A的数据={str(matches(r, truth[A]['fp'])):<5} B的数据={matches(r, truth[B]['fp'])}")
settled_at = None
if not matches(seen[-1][1], truth[B]["fp"]):
extra = 250
waited = prev
while waited < SETTLE_MS:
page.wait_for_timeout(extra)
waited += extra
r = page.evaluate(READ)
if matches(r, truth[B]["fp"]):
settled_at = waited
seen.append((waited, r))
print(f"① 追加等待 +{waited} ms 后落定是 B(慢机器兜底,上限 {SETTLE_MS} ms)")
break
stale = [ms for ms, r in seen if r["url"] == f"/projects/{B}/overview" and matches(r, truth[A]["fp"])]
final = seen[-1][1]
saw_clear = [ms for ms, r in seen if r["url"] == f"/projects/{B}/overview" and r["skeleton"]]
print(f"\n① 路由已在 B 却显示 A 的节点:{len(stale)} 次 {stale}"
f" | 落定是 B={matches(final, truth[B]['fp'])}"
f" | 中途看到「数据不可用」形态(骨架):{len(saw_clear)} 次 {saw_clear[:4]}"
+ ("" if saw_clear else "(一次都没采到 ⇒ 清空窗口短于采样粒度,不作为缺陷)"))
if stale:
print(f" 首个残留样本首行:{seen[tms.index(stale[0])][1]['firstCells']}")
defects.append(f"① SPA 内已切到 B 但概览仍显示 A 的节点,命中 {len(stale)} 次:+{stale}ms")
if not matches(final, truth[B]["fp"]):
print(f" 落定首行:{final['firstCells']}\n B 真值首行:{truth[B]['fp'][:1]}")
defects.append(f"① SPA 切换落定后概览不是 B 的节点(等满 {SETTLE_MS} ms 仍不是)")
obs1 = final.get("obs") or {}
print(f"① 观察器正对照:切换途中数到「节点行被摘掉」{obs1.get('removedTR')} 次"
f" | 采样看到骨架 {len(saw_clear)} 次 | 观察器布上={armed1.get('armed')}")
if armed1.get("armed") and not obs1.get("removedTR") and not saw_clear:
defects.append("① 切换途中既没采到骨架、观察器也没数到摘行 ⇒ 观察器是瞎的,"
"③ 那条「静置不许闪」从此不可信(先修取证,别信绿灯)")
shot(page, "switch-settled")
# 顶栏胶囊:换项目途中不许还写着上一个项目的名字
# (阶段 33 把总控台 / 概况抽屉两处 `project?.id === id` 收敛成 `loadedId === id`,这条钉住它)
comparable = bool(na) and na not in nb and nb not in na
pill_bad = ([ms for ms, r in seen if comparable and r["url"] == f"/projects/{B}/overview"
and na in r["hdr"]] if comparable else [])
if not comparable:
print(f"① 顶栏胶囊检查跳过:A「{na}」与 B「{nb}」互为子串,分不出写的是谁的名字")
else:
print(f"① 顶栏胶囊仍写着 A 的项目名:{len(pill_bad)} 次 {pill_bad[:4]}"
f" | 落定顶栏「{final['hdr'][:60]}」")
if pill_bad:
defects.append(f"① 路由已在 B,顶栏胶囊仍显示 A「{na}」,命中 {len(pill_bad)} 次:+{pill_bad[:4]}ms")
ev["switch"] = {
"samples": [{"ms": ms, "url": r["url"], "rows": len(r["nodes"]), "skeleton": r["skeleton"],
"isA": matches(r, truth[A]["fp"]), "isB": matches(r, truth[B]["fp"]),
"hdr": r["hdr"]} for ms, r in seen],
"settled_at_ms": settled_at if settled_at else prev,
"clear_window_samples": saw_clear,
"comparable_names": comparable,
"pill_stale_samples": pill_bad,
"observer_control": {"armed": armed1, **obs1}}
# ── ② 切到详情 404 的项目,再切回真项目 ─────────────────────────────
page.goto(f"{BASE}/projects/{B}/overview", wait_until="networkidle")
page.wait_for_timeout(1500)
before = page.evaluate(READ)
page.evaluate(NAV, f"/projects/{GHOST}/overview")
page.wait_for_timeout(2500)
r404 = page.evaluate(READ)
stale404 = matches(r404, truth[B]["fp"])
print(f"\n② SPA 内切到详情 404 的 #{GHOST}:报「未找到项目」={r404['notFound']}"
f" | 骨架={r404['skeleton']} | 节点表 {len(r404['nodes'])} 行"
f" | 仍是 B 的节点={stale404}")
print(f" 该页顶栏:{r404['hdr']}")
print(f" 节点表首行:{r404['firstCells']}")
if stale404 and not r404["notFound"]:
defects.append("② SPA 内切到不存在的项目后,概览永久停留在上一个项目(B)的节点,且不报「未找到项目」")
if not r404["notFound"]:
defects.append(f"② 切到详情 404 的 #{GHOST} 没有落到「未找到项目」的 Empty")
shot(page, "404-ghost")
page.evaluate(NAV, f"/projects/{B}/overview")
page.wait_for_timeout(2500)
back = page.evaluate(READ)
ok_back = matches(back, truth[B]["fp"])
print(f"② 从 404 页切回 #{B}:节点表恢复={ok_back}({len(back['nodes'])} 行)")
if not ok_back:
print(f" 恢复后首行:{back['firstCells']}")
defects.append("② 从 404 的项目切回真项目后,概览没有恢复成该项目的节点(一次失败污染了 store)")
ev["notfound"] = {"ghost": GHOST, "before_rows": len(before["nodes"]),
"read": r404, "recovered": ok_back, "back_rows": len(back["nodes"])}
# ── 证据补拍(只在 NEX_SHOTS 下跑,不参与判据):切换途中的可见形态 ──
if SHOTS:
page.goto(f"{BASE}/projects/{A}/overview", wait_until="networkidle")
page.wait_for_timeout(1500)
page.evaluate(NAV, f"/projects/{B}/overview")
page.wait_for_timeout(80)
mid = page.evaluate(READ)
isA, isB = matches(mid, truth[A]["fp"]), matches(mid, truth[B]["fp"])
shot(page, "switch-clear")
print(f"\n证据补拍 +80ms(不参与判据)url={mid['url']} 行{len(mid['nodes']):>3}"
f" 骨架={mid['skeleton']} A的数据={isA} B的数据={isB}")
ev["evidence_clear"] = {"url": mid["url"], "rows": len(mid["nodes"]),
"skeleton": mid["skeleton"], "isA": isA, "isB": isB}
b.close()
print(f"\n=== 缺陷 {len(defects)} 条 ===")
for d in defects:
print(" ✗", d)
stale_hits = sum(1 for s in ev["switch"]["samples"] if s["isA"])
print(f"SUMMARY 项目数={len(raw)} A=#{A} B=#{B} 采样={len(ev['switch']['samples'])} 残留命中={stale_hits} "
f"落定是B={matches(final, truth[B]['fp'])} 404未找到={r404['notFound']} "
f"404恢复={ok_back} 静置闪={len(flick)} 缺陷={len(defects)}")
# 读数落盘(阶段 36 收口):默认 /tmp/nex_ui_projectswitch,与其余常驻探针的
# NEX_SHOTS 口径一致。阶段 33 落地时默认写 HERE —— 跑一次就在 scripts/ui/ 里
# 留一个未跟踪的 JSON,白污染一次工作树(阶段 36 实测多出的那一条 ??)。
# 优先级:NEX_JSON(整条路径)> NEX_OUT(文件名,可绝对)> 默认目录 + 默认文件名。
art = pathlib.Path(os.environ.get("NEX_OUT", f"projectswitchcheck-{WIDTH}.json"))
if os.environ.get("NEX_JSON"):
out = pathlib.Path(os.environ["NEX_JSON"])
elif art.is_absolute():
out = art
else:
out = pathlib.Path(os.environ.get("NEX_SHOTS", "/tmp/nex_ui_projectswitch")) / art
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(ev, ensure_ascii=False, indent=1))
print(f"读数落盘 {out}")
return len(defects)
if __name__ == "__main__":
sys.exit(main())