481 lines
21 KiB
Python
481 lines
21 KiB
Python
# ============================================================
|
||
# 矩阵 101（方向 Y）：多模态输入与低置信确认框架黄金测试
|
||
# 覆盖：stub 提取候选+置信度、低置信出卡不写世界、高置信直通、
|
||
# 确认后写世界、拒绝不写、未注册提取器显式报错、审计齐全、
|
||
# 阈值可配、扩展提取器注册接口。
|
||
# ============================================================
|
||
from __future__ import annotations
|
||
|
||
import base64
|
||
|
||
import pytest
|
||
from fastapi.testclient import TestClient
|
||
|
||
from server.agent_core import harness
|
||
from server.aps_domain.multimodal import (
|
||
DEFAULT_CONFIDENCE_THRESHOLD,
|
||
ExtractionCandidate,
|
||
ExtractorNotRegisteredError,
|
||
ExtractorRegistry,
|
||
FileImportExtractor,
|
||
TextOrderExtractor,
|
||
apply_multimodal_candidates,
|
||
candidates_to_batches,
|
||
default_registry,
|
||
ingest_candidates,
|
||
)
|
||
from server.aps_domain.workflow import execute_confirmed
|
||
from server.auth.context import IdentityContext, bind_identity, reset_identity
|
||
from server.state.seed import seed_world
|
||
from server.timeutil import today0
|
||
|
||
_PLANNER = IdentityContext(1001, "planner", "计划员", "tenant-multimodal", roles=("planner",))
|
||
_THRESHOLD = DEFAULT_CONFIDENCE_THRESHOLD
|
||
|
||
|
||
def _next_id(world):
|
||
counters: dict[str, int] = {}
|
||
|
||
def next_id(kind: str) -> int:
|
||
table = "auditEvents" if kind == "audit" else kind + "s"
|
||
if kind not in counters:
|
||
rows = world.get(table, [])
|
||
counters[kind] = max((r.get("id", 0) for r in rows if isinstance(r, dict)), default=0)
|
||
counters[kind] += 1
|
||
return counters[kind]
|
||
|
||
return next_id
|
||
|
||
|
||
class _WorldStore:
|
||
def __init__(self, world, next_id_fn, *, tenant_uuid="tenant-multimodal", world_key="personal-1001"):
|
||
self.data = world
|
||
self._next_id_fn = next_id_fn
|
||
self.tenant_uuid = tenant_uuid
|
||
self.world_key = world_key
|
||
|
||
def next_id(self, kind: str) -> int:
|
||
return self._next_id_fn(kind)
|
||
|
||
def save(self) -> None:
|
||
pass
|
||
|
||
|
||
def _demo_product(world) -> dict:
|
||
return next(m for m in world["materials"] if m.get("type") == "FINISHED_PRODUCT")
|
||
|
||
|
||
def _orders_csv(product_code: str, ok: int = 1, bad: int = 0) -> bytes:
|
||
head = "订单号,客户,产品编码,数量,交期,优先级\n"
|
||
rows = [f"SO-OK-{i},导入客户,{product_code},{10 + i},2026-08-01,3" for i in range(1, ok + 1)]
|
||
rows += [f"SO-BAD-{i},客户X,UNKNOWN-{i},5,2026-08-01,3" for i in range(1, bad + 1)]
|
||
return (head + "\n".join(rows) + "\n").encode("utf-8")
|
||
|
||
|
||
# ---------------- stub 提取器：结构化候选 + 置信度 ----------------
|
||
|
||
def test_text_order_stub_sparse_template_is_low_confidence():
|
||
cands = TextOrderExtractor().extract("订单 单号 SO-101 数量 5")
|
||
assert len(cands) == 1
|
||
c = cands[0]
|
||
assert c.kind == "text_order" and c.source == "STUB_TEXT"
|
||
assert c.complete is True # 必填（单号+数量）齐
|
||
assert c.confidence == pytest.approx(0.6) # 缺交期/客户/产品 → 低于默认 0.7
|
||
assert "deliveryDate" in c.fields["missing"]
|
||
assert c.value["orderNo"] == "SO-101"
|
||
assert c.value["quantity"] == 5
|
||
assert c.to_dict()["confidence"] == pytest.approx(0.6)
|
||
|
||
|
||
def test_text_order_stub_full_template_is_high_confidence():
|
||
cands = TextOrderExtractor().extract(
|
||
"订单 单号 SO-102 数量 8 交期 2026-08-20 客户 华东公司 产品编码 CTRL-A")
|
||
c = cands[0]
|
||
assert c.complete is True
|
||
assert c.confidence == pytest.approx(1.0)
|
||
assert c.fields["missing"] == []
|
||
assert c.value["deliveryDate"] == "2026-08-20"
|
||
|
||
|
||
def test_text_order_stub_no_match_and_incomplete():
|
||
extractor = TextOrderExtractor()
|
||
assert extractor.extract("今天天气不错") == [] # 无模板命中：不编造
|
||
partial = extractor.extract("订单 数量 5") # 缺单号 → 不完整
|
||
assert len(partial) == 1
|
||
assert partial[0].complete is False
|
||
assert partial[0].confidence == pytest.approx(0.3)
|
||
|
||
|
||
def test_file_import_stub_reuses_importers_preview():
|
||
world = seed_world()
|
||
product = _demo_product(world)
|
||
cands = FileImportExtractor(world=world).extract(
|
||
{"filename": "orders.csv", "data": _orders_csv(product["code"])})
|
||
c = cands[0]
|
||
assert c.kind == "file_import" and c.source == "STUB_FILE"
|
||
assert c.confidence == pytest.approx(1.0)
|
||
assert c.complete is True
|
||
assert c.value["canCommit"] is True
|
||
assert c.value["batches"][0]["kind"] == "orders"
|
||
assert c.fields["batches"]["orders"]["okCount"] == 1
|
||
|
||
|
||
def test_file_import_stub_low_confidence_on_error_rows():
|
||
world = seed_world()
|
||
product = _demo_product(world)
|
||
cands = FileImportExtractor(world=world).extract(
|
||
{"filename": "orders.csv", "data": _orders_csv(product["code"], ok=2, bad=5)})
|
||
c = cands[0]
|
||
assert c.complete is True # 仍有有效行可入库
|
||
assert 0 < c.confidence < _THRESHOLD # 2/7 ≈ 0.286 → 低置信
|
||
assert c.value["totalOk"] == 2
|
||
assert c.value["totalErrors"] == 5
|
||
|
||
|
||
# ---------------- 注册表：未注册显式报错 + 扩展注册接口 ----------------
|
||
|
||
def test_registry_unregistered_kind_raises_explicit_error():
|
||
registry = default_registry(world=seed_world())
|
||
with pytest.raises(ExtractorNotRegisteredError) as excinfo:
|
||
registry.extract("asr", {"text": "语音识别内容"})
|
||
assert "未注册" in str(excinfo.value) and "asr" in str(excinfo.value)
|
||
assert "file_import" in str(excinfo.value) # 提示已注册 kinds
|
||
with pytest.raises(ExtractorNotRegisteredError):
|
||
registry.get("vlm")
|
||
assert registry.get("file_import").kind == "file_import"
|
||
assert registry.get("text_order").kind == "text_order"
|
||
assert set(registry.list_kinds()) == {"file_import", "image_meta", "text_order", "dxf_drawing"}
|
||
|
||
|
||
def test_registry_accepts_extended_asr_vlm_extractor():
|
||
class FakeAsrExtractor:
|
||
kind = "asr"
|
||
source = "ASR_EXT"
|
||
|
||
def extract(self, raw):
|
||
return [ExtractionCandidate(
|
||
kind="asr", value={"text": str((raw or {}).get("text") or "")},
|
||
confidence=0.9, source="ASR_EXT", fields={"text": {"raw": raw}}, complete=True)]
|
||
|
||
registry = ExtractorRegistry()
|
||
registry.register(FakeAsrExtractor())
|
||
cands = registry.extract("asr", {"text": "语音内容"})
|
||
assert len(cands) == 1 and cands[0].kind == "asr"
|
||
assert cands[0].confidence == pytest.approx(0.9)
|
||
with pytest.raises(ValueError): # 重复注册默认拒绝
|
||
registry.register(FakeAsrExtractor())
|
||
registry.register(FakeAsrExtractor(), replace=True) # 显式覆盖允许（接真实服务入口）
|
||
|
||
|
||
# ---------------- 归一化与 fail-closed 写入 ----------------
|
||
|
||
def test_candidates_to_batches_text_order_normalizes():
|
||
cands = TextOrderExtractor().extract("订单 单号 SO-103 数量 12")
|
||
batches = candidates_to_batches(cands)
|
||
assert batches == [{
|
||
"kind": "orders", "sheet": "multimodal-text",
|
||
"okRows": [{"orderNo": "SO-103", "quantity": 12,
|
||
"deliveryDate": today0().strftime("%Y-%m-%d"),
|
||
"customerName": ""}],
|
||
}]
|
||
|
||
|
||
def test_apply_fail_closed_on_incomplete_and_bad_quantity():
|
||
world = seed_world()
|
||
next_id = _next_id(world)
|
||
incomplete = ExtractionCandidate(
|
||
kind="text_order", value={"orderNo": "SO-X", "quantity": ""},
|
||
confidence=0.3, source="STUB_TEXT", complete=False,
|
||
fields={"missing": ["quantity"]})
|
||
before = len(world["salesOrders"]) + len(world["flexOrders"])
|
||
with pytest.raises(ValueError):
|
||
apply_multimodal_candidates(world, next_id, [incomplete])
|
||
bad_qty = ExtractionCandidate(
|
||
kind="text_order", value={"orderNo": "SO-Y", "quantity": "abc"},
|
||
confidence=0.6, source="STUB_TEXT", complete=True)
|
||
with pytest.raises(ValueError):
|
||
apply_multimodal_candidates(world, next_id, [bad_qty])
|
||
assert len(world["salesOrders"]) + len(world["flexOrders"]) == before # 无部分写入
|
||
assert not world.get("auditEvents")
|
||
|
||
|
||
# ---------------- 门禁：高置信直通 / 低置信出卡不写世界 ----------------
|
||
|
||
def test_ingest_high_confidence_direct_apply_no_card():
|
||
world = seed_world()
|
||
next_id = _next_id(world)
|
||
cands = TextOrderExtractor().extract(
|
||
"订单 单号 SO-DIR-1 数量 5 交期 2026-08-20 客户 华东公司 产品编码 CTRL-A")
|
||
result = ingest_candidates(world, next_id, cands, threshold=_THRESHOLD)
|
||
assert result["status"] == "applied"
|
||
assert any(o["orderNo"] == "SO-DIR-1" for o in world["flexOrders"])
|
||
assert any(e["action"] == "multimodal.apply" for e in world["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.stage" for e in world["auditEvents"])
|
||
|
||
|
||
def test_ingest_low_confidence_stages_card_without_world_write():
|
||
world = seed_world()
|
||
next_id = _next_id(world)
|
||
token = bind_identity(_PLANNER)
|
||
try:
|
||
cands = TextOrderExtractor().extract("订单 单号 SO-LOW-1 数量 5")
|
||
result = ingest_candidates(world, next_id, cands, session_id="mm-session",
|
||
threshold=_THRESHOLD)
|
||
finally:
|
||
reset_identity(token)
|
||
assert result["status"] == "staged"
|
||
confirm_id = result["confirmId"]
|
||
assert result["block"]["type"] == "confirm-card"
|
||
assert "低置信" in result["block"]["props"]["title"]
|
||
assert not any(o["orderNo"] == "SO-LOW-1" for o in world["flexOrders"]) # 确认前绝不写
|
||
assert not any(e["action"] == "multimodal.apply" for e in world["auditEvents"])
|
||
stages = [e for e in world["auditEvents"] if e["action"] == "multimodal.stage"]
|
||
assert len(stages) == 1
|
||
assert stages[0]["rationale"]["confirmId"] == confirm_id
|
||
assert stages[0]["rationale"]["action"] == "import.commit"
|
||
assert stages[0]["result"] == "PENDING"
|
||
token = bind_identity(_PLANNER)
|
||
try:
|
||
assert harness.is_confirmation_pending(confirm_id) is True
|
||
finally:
|
||
reset_identity(token)
|
||
|
||
|
||
def test_module_confirm_writes_world_reject_does_not():
|
||
world = seed_world()
|
||
next_id = _next_id(world)
|
||
token = bind_identity(_PLANNER)
|
||
try:
|
||
cands = TextOrderExtractor().extract("订单 单号 SO-LOW-2 数量 7")
|
||
staged = ingest_candidates(world, next_id, cands, session_id="mm", threshold=_THRESHOLD)
|
||
cid = staged["confirmId"]
|
||
store = _WorldStore(world, next_id)
|
||
message = execute_confirmed(store, cid, True, actor="planner")
|
||
assert "导入完成" in message
|
||
assert any(o["orderNo"] == "SO-LOW-2" for o in world["flexOrders"]) # 确认后写世界
|
||
assert any(e["action"] == "import.commit" for e in world["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.apply" for e in world["auditEvents"]) # 确认通道审计为 import.commit
|
||
|
||
# 第二条卡：驳回 → 不写世界 + 留痕
|
||
cands2 = TextOrderExtractor().extract("订单 单号 SO-LOW-3 数量 3")
|
||
staged2 = ingest_candidates(world, next_id, cands2, session_id="mm", threshold=_THRESHOLD)
|
||
cid2 = staged2["confirmId"]
|
||
before = len(world["flexOrders"])
|
||
message2 = execute_confirmed(store, cid2, False, actor="planner")
|
||
assert "已驳回" in message2
|
||
assert len(world["flexOrders"]) == before
|
||
assert any(e["action"] == "import.commit.reject" for e in world["auditEvents"])
|
||
finally:
|
||
reset_identity(token)
|
||
|
||
|
||
# ---------------- 网关接线：/api/multimodal/* + 确认卡通道 ----------------
|
||
|
||
class _AuditStore:
|
||
def __init__(self, tenant_uuid: str = "tenant-multimodal"):
|
||
self.tenant_uuid = tenant_uuid
|
||
self.world_key = "personal-1001"
|
||
self.data: dict = seed_world()
|
||
self._counter = 0
|
||
|
||
def next_id(self, _kind: str) -> int:
|
||
self._counter += 1
|
||
return self._counter
|
||
|
||
def save(self) -> None:
|
||
pass
|
||
|
||
|
||
class _CheckpointStore:
|
||
def create(self, *_args, **_kwargs) -> dict:
|
||
return {"pairId": "mm-pair"}
|
||
|
||
def get(self, pair_id: str) -> dict | None:
|
||
return {"pairId": pair_id}
|
||
|
||
|
||
class _ProjectStore:
|
||
def active_world_key(self) -> str:
|
||
return "personal-1001"
|
||
|
||
def require_active_write(self) -> None:
|
||
pass
|
||
|
||
|
||
@pytest.fixture
|
||
def client_factory(monkeypatch):
|
||
import server.gateway.app as gateway_module
|
||
import server.state.projects as projects_module
|
||
from tests.auth_provider import install_test_auth
|
||
|
||
provider = install_test_auth(monkeypatch, "tenant-multimodal")
|
||
|
||
def factory():
|
||
store = _AuditStore()
|
||
monkeypatch.setattr(gateway_module, "get_store", lambda: store)
|
||
monkeypatch.setattr(gateway_module, "get_checkpoints", lambda: _CheckpointStore())
|
||
monkeypatch.setattr(projects_module, "get_project_store", lambda: _ProjectStore())
|
||
client = TestClient(gateway_module.create_app())
|
||
login = client.post("/api/auth/login", json={"username": "planner", "password": "test"})
|
||
assert login.status_code == 200, login.text
|
||
return client, store, provider
|
||
|
||
return factory
|
||
|
||
|
||
def test_api_extract_returns_candidates_and_confidence(client_factory):
|
||
client, store, _ = client_factory()
|
||
resp = client.post("/api/multimodal/extract", json={
|
||
"kind": "text_order", "text": "订单 单号 SO-API-1 数量 5"})
|
||
assert resp.status_code == 200, resp.text
|
||
data = resp.json()
|
||
assert data["kind"] == "text_order"
|
||
assert data["registeredKinds"] == ["dxf_drawing", "file_import", "image_meta", "text_order"]
|
||
assert data["defaultThreshold"] == pytest.approx(0.7)
|
||
assert len(data["candidates"]) == 1
|
||
cand = data["candidates"][0]
|
||
assert cand["confidence"] == pytest.approx(0.6)
|
||
assert cand["complete"] is True
|
||
assert cand["source"] == "STUB_TEXT"
|
||
assert any(e["action"] == "multimodal.extract" for e in store.data["auditEvents"])
|
||
|
||
|
||
def test_api_extract_unregistered_kind_errors_explicitly(client_factory):
|
||
client, _, _ = client_factory()
|
||
for kind in ("asr", "vlm"):
|
||
resp = client.post("/api/multimodal/extract", json={"kind": kind, "text": "外部语音/图片"})
|
||
assert resp.status_code == 200, resp.text
|
||
assert "未注册" in resp.json()["error"]
|
||
assert kind in resp.json()["error"]
|
||
|
||
|
||
def test_api_file_extract_low_confidence_stage_confirm_writes(client_factory):
|
||
client, store, _ = client_factory()
|
||
product = _demo_product(store.data)
|
||
payload = base64.b64encode(_orders_csv(product["code"], ok=2, bad=5)).decode("ascii")
|
||
extract = client.post("/api/multimodal/extract", json={
|
||
"kind": "file_import", "filename": "orders.csv", "dataBase64": payload})
|
||
assert extract.status_code == 200, extract.text
|
||
cands = extract.json()["candidates"]
|
||
assert cands[0]["confidence"] < _THRESHOLD
|
||
assert cands[0]["complete"] is True
|
||
|
||
before_so = len(store.data["salesOrders"])
|
||
before_flex = len(store.data["flexOrders"])
|
||
ingest = client.post("/api/multimodal/ingest", json={
|
||
"sessionId": "web", "candidates": cands, "threshold": _THRESHOLD})
|
||
assert ingest.status_code == 200, ingest.text
|
||
body = ingest.json()
|
||
assert body["status"] == "staged"
|
||
cid = body["confirmId"]
|
||
assert len(store.data["salesOrders"]) == before_so # 出卡不写世界
|
||
assert len(store.data["flexOrders"]) == before_flex
|
||
assert any(e["action"] == "multimodal.stage" for e in store.data["auditEvents"])
|
||
|
||
confirm = client.post("/api/actions/confirm", json={
|
||
"confirmId": cid, "approve": True, "note": "确认低置信文件"})
|
||
assert confirm.status_code == 200, confirm.text
|
||
assert len(store.data["salesOrders"]) == before_so
|
||
assert len(store.data["flexOrders"]) == before_flex + 2 # 确认后写世界
|
||
assert any(e["action"] == "import.commit" for e in store.data["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.apply" for e in store.data["auditEvents"])
|
||
|
||
|
||
def test_api_high_confidence_direct_apply(client_factory):
|
||
client, store, _ = client_factory()
|
||
resp = client.post("/api/multimodal/extract", json={
|
||
"kind": "text_order",
|
||
"text": "订单 单号 SO-HI-1 数量 9 交期 2026-08-20 客户 华东公司 产品编码 CTRL-A"})
|
||
cands = resp.json()["candidates"]
|
||
assert cands[0]["confidence"] == pytest.approx(1.0)
|
||
|
||
before = len(store.data["flexOrders"])
|
||
ingest = client.post("/api/multimodal/ingest", json={"candidates": cands})
|
||
assert ingest.status_code == 200, ingest.text
|
||
body = ingest.json()
|
||
assert body["status"] == "applied"
|
||
assert len(store.data["flexOrders"]) == before + 1
|
||
assert any(o["orderNo"] == "SO-HI-1" for o in store.data["flexOrders"])
|
||
assert any(e["action"] == "multimodal.apply" for e in store.data["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.stage" for e in store.data["auditEvents"])
|
||
|
||
|
||
def test_api_reject_does_not_write(client_factory):
|
||
client, store, _ = client_factory()
|
||
product = _demo_product(store.data)
|
||
payload = base64.b64encode(_orders_csv(product["code"], ok=1, bad=4)).decode("ascii")
|
||
extract = client.post("/api/multimodal/extract", json={
|
||
"kind": "file_import", "filename": "orders.csv", "dataBase64": payload})
|
||
cands = extract.json()["candidates"]
|
||
ingest = client.post("/api/multimodal/ingest", json={"candidates": cands})
|
||
assert ingest.json()["status"] == "staged"
|
||
|
||
before_so = len(store.data["salesOrders"])
|
||
reject = client.post("/api/actions/confirm", json={
|
||
"confirmId": ingest.json()["confirmId"], "approve": False, "note": "数据不对"})
|
||
assert reject.status_code == 200, reject.text
|
||
assert "已驳回" in reject.json()["message"]
|
||
assert len(store.data["salesOrders"]) == before_so # 拒绝不写
|
||
assert any(e["action"] == "import.commit.reject" for e in store.data["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.apply" for e in store.data["auditEvents"])
|
||
|
||
|
||
def test_api_incomplete_candidate_rejected_without_card(client_factory):
|
||
client, store, _ = client_factory()
|
||
extract = client.post("/api/multimodal/extract", json={
|
||
"kind": "text_order", "text": "订单 单号 SO-INC-1"}) # 缺数量
|
||
cands = extract.json()["candidates"]
|
||
assert cands[0]["complete"] is False
|
||
before = len(store.data["flexOrders"]) + len(store.data["salesOrders"])
|
||
ingest = client.post("/api/multimodal/ingest", json={"candidates": cands})
|
||
assert ingest.status_code == 200, ingest.text
|
||
assert ingest.json()["status"] == "incomplete"
|
||
assert len(store.data["flexOrders"]) + len(store.data["salesOrders"]) == before
|
||
assert not any(e["action"] == "multimodal.stage" for e in store.data["auditEvents"])
|
||
assert not any(e["action"] == "multimodal.apply" for e in store.data["auditEvents"])
|
||
|
||
|
||
def test_api_threshold_override_changes_decision(client_factory):
|
||
client, store, _ = client_factory()
|
||
resp = client.post("/api/multimodal/extract", json={
|
||
"kind": "text_order", "text": "订单 单号 SO-TH-1 数量 4"}) # 0.6 置信
|
||
cands = resp.json()["candidates"]
|
||
assert cands[0]["confidence"] == pytest.approx(0.6)
|
||
|
||
before = len(store.data["flexOrders"])
|
||
# 默认 0.7 → 低置信出卡
|
||
staged = client.post("/api/multimodal/ingest", json={"candidates": cands})
|
||
assert staged.json()["status"] == "staged"
|
||
assert len(store.data["flexOrders"]) == before
|
||
# 阈值放宽 0.5 → 同一候选直通
|
||
applied = client.post("/api/multimodal/ingest", json={
|
||
"candidates": cands, "threshold": 0.5})
|
||
assert applied.json()["status"] == "applied"
|
||
assert len(store.data["flexOrders"]) == before + 1
|
||
|
||
|
||
def test_api_audit_trail_complete_for_low_confidence_flow(client_factory):
|
||
"""审计齐全：extract → stage → 确认后 apply（import.commit 通道）→ 拒绝留痕。"""
|
||
client, store, _ = client_factory()
|
||
product = _demo_product(store.data)
|
||
payload = base64.b64encode(_orders_csv(product["code"], ok=1, bad=3)).decode("ascii")
|
||
extract = client.post("/api/multimodal/extract", json={
|
||
"kind": "file_import", "filename": "orders.csv", "dataBase64": payload})
|
||
cands = extract.json()["candidates"]
|
||
ingest = client.post("/api/multimodal/ingest", json={"candidates": cands})
|
||
assert ingest.json()["status"] == "staged"
|
||
|
||
confirm = client.post("/api/actions/confirm", json={
|
||
"confirmId": ingest.json()["confirmId"], "approve": True})
|
||
assert confirm.status_code == 200, confirm.text
|
||
|
||
actions = [e["action"] for e in store.data["auditEvents"]]
|
||
assert "multimodal.extract" in actions
|
||
assert "multimodal.stage" in actions
|
||
assert "import.commit" in actions
|
||
stage = next(e for e in store.data["auditEvents"] if e["action"] == "multimodal.stage")
|
||
assert stage["rationale"]["confirmId"] == ingest.json()["confirmId"]
|
||
assert stage["rationale"]["candidates"][0]["confidence"] < _THRESHOLD
|
||
commit = next(e for e in store.data["auditEvents"] if e["action"] == "import.commit")
|
||
assert commit["beforeSnapshot"] is not None
|