This commit is contained in:
gr
2026-10-23 09:27:45 +08:00
34 changed files with 2866 additions and 225 deletions
+1
View File
@@ -1,4 +1,5 @@
.env
.local-workstation/
.venv/
.venv-build/
.venv-win7-check/
+6
View File
@@ -35,6 +35,12 @@ Windows 打包机需预先安装 `uv` 与 Node.js 20+;脚本会自动处理项
- 腾讯视频:沿用现有项目的 `@trtc/calls-uikit-vue` 主链;UserSig 只从后端短时获取,客户端不包含 SDKSecretKey。当前仅支持隔离的 QtWebEngine 内嵌模式。
- PyInstaller Windows/macOS 构建脚本、macOS 摄像头/麦克风权限配置与自动化测试。
## 本地后端联调
本机 phpStudy 站点准备好后,双击 `Run_DoctorWorkstation_Local.bat`,使用当前源码连接 `https://css.zhenyangtang.com.cn`。此入口要求域名解析到本机,启用 TLS 校验,复用本机站点的公开证书;偏好、日志和登录凭据使用独立目录及凭据命名空间。正式启动入口及正式服务器配置保持原样。本地入口首次启动需要重新登录,不会借用正式环境的会话。
仅检查配置可执行 `Run_DoctorWorkstation_Local.bat --check`。其他本机 HTTPS 站点可通过 `DOCTOR_LOCAL_API_URL` 和 `DOCTOR_LOCAL_CA_FILE` 指定域名与公开证书路径,禁止传入私钥。配置保存在已忽略的 `.local-workstation/` 中;本地后端仍使用 `server/.env` 的现有配置。
## 手动运行
先安装 [uv](https://docs.astral.sh/uv/),然后在项目根目录执行:
+10
View File
@@ -0,0 +1,10 @@
@echo off
setlocal EnableExtensions DisableDelayedExpansion
set "LOCAL_APP_ROOT=%~dp0"
if not exist "%LOCAL_APP_ROOT%.venv\Scripts\python.exe" (
echo Local Python environment is missing. Prepare the source environment first.
exit /b 1
)
"%LOCAL_APP_ROOT%.venv\Scripts\python.exe" "%LOCAL_APP_ROOT%scripts\run_local_workstation.py" %*
set "LOCAL_RESULT=%ERRORLEVEL%"
endlocal & exit /b %LOCAL_RESULT%
+70
View File
@@ -0,0 +1,70 @@
"""Start the source workstation against a loopback backend with isolated login state."""
from __future__ import annotations
import functools
import os
import socket
import sys
from pathlib import Path
from urllib.parse import urlsplit
import certifi
def validate_local_url(api: str) -> None:
parsed = urlsplit(api)
if (parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password
or parsed.query or parsed.fragment):
raise ValueError("本地入口需要不带凭据的 HTTPS 地址")
addresses = {row[4][0] for row in socket.getaddrinfo(parsed.hostname, parsed.port or 443)}
if not addresses or not addresses <= {"127.0.0.1", "::1"}:
raise ValueError("本地入口仅连接解析到本机的后端")
def validate_effective_config(config, requested_api: str) -> None:
from doctor_workstation.config import normalize_api_base_url
validate_local_url(config.api_base_url)
if config.api_base_url != normalize_api_base_url(requested_api) or not config.verify_ssl:
raise ValueError("本地独立配置已改动,请在 .local-workstation/config 中核对本地服务器设置")
def main() -> int:
root = Path(__file__).resolve().parents[1]
api = os.environ.get("DOCTOR_LOCAL_API_URL", "https://css.zhenyangtang.com.cn")
validate_local_url(api)
certificate = Path(os.environ.get(
"DOCTOR_LOCAL_CA_FILE",
"D:/phpstudy_pro/Extensions/Nginx1.15.11/conf/ssl/css.zhenyangtang.com.cn.pem",
))
private_root = root / ".local-workstation"
private_root.mkdir(parents=True, exist_ok=True)
ca_bundle = private_root / "trusted-ca.pem"
ca_bundle.write_bytes(Path(certifi.where()).read_bytes() + b"\n" + certificate.read_bytes())
os.environ.update({
"DOCTOR_CONFIG_DIR": str(private_root / "config"),
"DOCTOR_LOG_DIR": str(private_root / "logs"),
"DOCTOR_API_BASE_URL": api,
"DOCTOR_DEMO_MODE": "false",
"DOCTOR_VERIFY_SSL": "true",
"SSL_CERT_FILE": str(ca_bundle),
})
sys.path.insert(0, str(root / "src"))
import doctor_workstation
# This explicit source-only entry does not edit the formal build configuration.
doctor_workstation.DEBUG_MODE = True
from doctor_workstation.config import AppConfig
config = AppConfig.load()
validate_effective_config(config, api)
if "--check" in sys.argv:
print("Local backend: loopback HTTPS; TLS verification enabled; isolated configuration and credential namespace")
return 0
from doctor_workstation import app as workstation_app
# The normal credential service remains untouched even after a local login.
workstation_app.TokenStore = functools.partial(
workstation_app.TokenStore, service_name="zyt-doctor-workstation-local-source"
)
return workstation_app.main()
if __name__ == "__main__":
raise SystemExit(main())
@@ -2,10 +2,12 @@
from __future__ import annotations
import asyncio
import json
import time
from collections import deque
from collections.abc import Callable, Iterator, Mapping
from contextlib import contextmanager
from contextlib import contextmanager, suppress
from threading import Condition, RLock
from typing import Any
from urllib.parse import urljoin, urlsplit, urlunsplit
@@ -229,6 +231,29 @@ class ApiClient:
headers=headers,
)
def post_independent(
self,
endpoint: str,
payload: Mapping[str, Any],
*,
timeout: float = 10.0,
) -> Any:
"""Send a short control request without waiting for the ordinary pool."""
try:
with httpx.Client(transport=self._stream_transport, verify=self._verify) as client:
response = client.post(
self._endpoint_url(endpoint),
json=dict(payload),
headers=self._headers(None),
timeout=timeout,
)
return self._unwrap(response)
except httpx.TimeoutException as exc:
raise ApiTimeoutError(f"POST {endpoint} timed out") from exc
except httpx.RequestError as exc:
raise ApiTransportError(f"POST {endpoint} failed") from exc
def post_event_stream(
self,
endpoint: str,
@@ -248,6 +273,14 @@ class ApiClient:
headers = self._headers({"Accept": "text/event-stream"})
request_timeout = self.timeout if timeout is None else timeout
try:
if cancelled is not None and (
self._stream_transport is None
or isinstance(self._stream_transport, httpx.AsyncBaseTransport)
):
yield from self._cancellable_event_stream(
url, payload, headers, request_timeout, cancelled
)
return
with httpx.Client(
transport=self._stream_transport,
verify=self._verify,
@@ -287,6 +320,109 @@ class ApiClient:
data={"method": "POST", "endpoint": endpoint},
) from exc
def _cancellable_event_stream(
self,
url: str,
payload: Mapping[str, Any],
headers: Mapping[str, str],
timeout: float | httpx.Timeout,
cancelled: Callable[[], bool],
) -> Iterator[dict[str, Any]]:
"""Own network reads and cancellation on the same worker-local event loop.
Closing a synchronous httpx response from another thread can wait on its
active read lock. Cancelling an async read interrupts idle headers/body
reads and closes their sockets on their owning loop instead.
"""
async def events():
async with httpx.AsyncClient(
transport=self._stream_transport, verify=self._verify
) as client, client.stream(
"POST", url, json=dict(payload), headers=headers, timeout=timeout
) as response:
if not 200 <= response.status_code < 300:
raise ApiHttpError(
f"API returned HTTP {response.status_code}",
status_code=response.status_code,
request_id=self._request_id(response),
)
content_type = response.headers.get("content-type", "").lower()
if "text/event-stream" not in content_type:
await response.aread()
if "json" in content_type:
self._unwrap(response)
raise ApiProtocolError("API response is not an event stream")
frame: list[str] = []
async for line in response.aiter_lines():
frame.append(line)
if not line:
for event in _iter_event_stream(frame):
yield event
frame.clear()
for event in _iter_event_stream(frame):
yield event
if cancelled():
return
loop = asyncio.new_event_loop()
iterator = events()
pending: deque[dict[str, Any]] = deque()
polling = False
wake_handle: asyncio.Handle | None = None
def wake_consumer() -> None:
nonlocal wake_handle
if polling and wake_handle is None:
wake_handle = loop.call_soon(loop.stop)
async def pump() -> None:
try:
async for event in iterator:
if cancelled():
return
pending.append(event)
wake_consumer()
# Bound buffered work and let the scheduled batch wake run,
# even when one HTTP chunk contains thousands of SSE frames.
if len(pending) >= 256:
await asyncio.sleep(0)
finally:
wake_consumer()
producer = loop.create_task(pump())
async def close_producer() -> None:
producer.cancel()
with suppress(asyncio.CancelledError, Exception):
await producer
await iterator.aclose()
try:
while not cancelled():
# Read buffered frames directly. There is one persistent async
# producer, not a new task/event-loop crossing for every delta.
if pending:
yield pending.popleft()
continue
if producer.done():
producer.result() # Propagate EOF errors after queued tails.
return
polling = True
wake_handle = None
timer = loop.call_later(0.03, loop.stop)
try:
loop.run_forever()
finally:
polling = False
timer.cancel()
if wake_handle is not None:
wake_handle.cancel()
finally:
loop.run_until_complete(close_producer())
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
def get_bytes(self, url: str, *, max_bytes: int = 5 * 1024 * 1024) -> bytes:
"""Download a public binary asset without applying the JSON envelope contract."""
@@ -206,9 +206,13 @@ class DoctorRepository(Protocol):
prompt: str,
*,
task: str = "custom",
request_id: str | None = None,
cancelled: Callable[[], bool] | None = None,
) -> Iterator[dict[str, Any]]:
"""Yield normalized ``start``/``delta``/``done`` assistant events."""
"""Yield normalized assistant content and preparation progress events."""
def cancel_diagnosis_ai(self, diagnosis_id: int, request_id: str) -> dict[str, Any]:
"""Request server/upstream cancellation of one correlated stream."""
def generate_ai_prescription(self, diagnosis_id: int) -> dict[str, Any]:
"""Generate a server-validated prescription draft for doctor review."""
@@ -1413,12 +1417,16 @@ class RemoteDoctorRepository:
prompt: str,
*,
task: str = "custom",
request_id: str | None = None,
cancelled: Callable[[], bool] | None = None,
) -> Iterator[dict[str, Any]]:
"""Stream a diagnosis answer; use the legacy route only when streaming is absent."""
clean_prompt, clean_task = _diagnosis_ai_request(diagnosis_id, prompt, task)
body = {"id": diagnosis_id, "prompt": clean_prompt, "task": clean_task}
body = {
"id": diagnosis_id, "prompt": clean_prompt, "task": clean_task,
"request_id": request_id or str(uuid4()),
}
received_event = False
received_done = False
try:
@@ -1467,6 +1475,18 @@ class RemoteDoctorRepository:
yield {"event": "delta", "text": answer, "fallback": True}
yield {**result, "event": "done", "fallback": True}
def cancel_diagnosis_ai(self, diagnosis_id: int, request_id: str) -> dict[str, Any]:
"""Use an independent short request, even while the stream is idle."""
if diagnosis_id <= 0 or not request_id.strip():
raise ValueError("diagnosis_id and request_id are required")
method = "post_independent" if callable(getattr(self.client, "post_independent", None)) else "post"
payload = _client_request(
self.client, method, "tcm.diagnosis/cancelAiAssistant",
{"id": diagnosis_id, "request_id": request_id}, timeout=10.0,
)
return dict(_require_mapping(payload, "tcm.diagnosis/cancelAiAssistant"))
def generate_ai_prescription(self, diagnosis_id: int) -> dict[str, Any]:
"""Generate a structured draft using the server's full patient context."""
@@ -2990,10 +3010,10 @@ def _normalise_diagnosis_ai_event(raw: Mapping[str, Any]) -> dict[str, Any] | No
payload = dict(data) if isinstance(data, Mapping) else {}
if kind == "message":
kind = str(payload.get("event") or payload.get("type") or "message").lower()
if kind == "start":
if kind in {"start", "progress"}:
payload.pop("event", None)
payload.pop("type", None)
return {**payload, "event": "start"}
return {**payload, "event": kind}
if kind == "delta":
text = (
data
@@ -9,9 +9,11 @@ from collections.abc import Callable, Container, Mapping, Sequence
from contextlib import suppress
from copy import deepcopy
from datetime import datetime
from threading import Event, Lock
from time import monotonic
from inspect import Parameter, signature
from threading import Event, Lock, Thread
from time import monotonic, perf_counter
from typing import Any
from uuid import uuid4
from PySide6.QtCore import (
QCoreApplication,
@@ -3051,6 +3053,28 @@ class _ChatBubble(QWidget):
def set_provenance(self, value: Any) -> None:
self._provenance = dict(value) if isinstance(value, Mapping) else {}
def set_transfer_status(self, text: str) -> None:
"""Keep actual input/submission status visible while answer text streams."""
label = getattr(self, "transfer_status", None)
if label is None:
label = QLabel(self._bubble_frame)
label.setObjectName("AiConsultTransferStatus")
label.setTextFormat(Qt.TextFormat.PlainText)
label.setWordWrap(True)
label.setStyleSheet("color:#65718A;font-size:12px;")
self._inner.insertWidget(1, label)
self.transfer_status = label
label.setText(text)
label.setVisible(bool(text))
def set_cancel_status(self, text: str, *, has_text: bool) -> None:
"""Update cancellation without reparsing the received clinical text."""
self.set_transfer_status(text)
if self.body is not None and not has_text:
self.body.hide()
def set_time_text(self, text: str) -> None:
if not text:
return
@@ -3209,6 +3233,7 @@ class _AiStreamSignals(QObject):
ready = Signal()
error = Signal(object)
finished = Signal()
cancel_result = Signal(object)
class _AiStreamWorker(QRunnable):
@@ -3227,18 +3252,54 @@ class _AiStreamWorker(QRunnable):
self.diagnosis_id = diagnosis_id
self.prompt = prompt
self.task = task
self.request_id = str(uuid4())
self.signals = _AiStreamSignals()
self._cancelled = Event()
self._pending_lock = Lock()
self._events: list[Any] = []
self._chunks: list[str] = []
self._first_text_queued = False
self._completed = Event()
self.cancel_text = ""
self.cancel_meta: dict[str, Any] = {}
self.cancel_reason = ""
# High-resolution monotonic diagnostics; GetTickCount64 used by
# monotonic() on Windows/Python 3.12 can hide sub-16ms queue latency.
# No patient/content logging or cross-thread widget access.
self.queued_at: float | None = None
self.run_started_at: float | None = None
self.first_delta_received_at: float | None = None
self.first_delta_processed_at: float | None = None
def cancel(self) -> list[Any]:
"""Signal cancellation before GUI work, preserving the received tail."""
def cancel(self) -> None:
self._cancelled.set()
with self._pending_lock:
self._events.clear()
self._chunks.clear()
request_cancel = not self.is_cancelled() and not self._completed.is_set()
if request_cancel:
self._cancelled.set()
if self._chunks:
self._events.append({"event": "delta", "text": "".join(self._chunks)})
self._chunks.clear()
events, self._events = self._events, []
if request_cancel:
# Never submit control HTTP on the GUI or the occupied stream worker.
Thread(target=self._request_cancel, name="ai-cancel", daemon=True).start()
return events
def mark_completed(self) -> None:
self._completed.set()
def _request_cancel(self) -> None:
try:
cancel = getattr(self.repository, "cancel_diagnosis_ai", None)
result = cancel(self.diagnosis_id, self.request_id) if callable(cancel) else {}
result = dict(result) if isinstance(result, Mapping) else {}
except Exception:
# Do not expose exception text, request bodies or patient metadata.
result = {"cancel_request_failed": True}
with suppress(RuntimeError):
self.signals.cancel_result.emit(result)
def is_cancelled(self) -> bool:
return self._cancelled.is_set()
@@ -3248,18 +3309,22 @@ class _AiStreamWorker(QRunnable):
delta = payload.get("event") == "delta" and isinstance(payload.get("text"), str)
wake = not delta
with self._pending_lock:
if self.is_cancelled():
if self.is_cancelled() or self._completed.is_set():
return
if delta:
self._chunks.append(payload["text"])
if payload["text"] and not self._first_text_queued:
self._first_text_queued = True
self.first_delta_received_at = perf_counter()
wake = True
else:
if self._chunks:
self._events.append({"event": "delta", "text": "".join(self._chunks)})
self._chunks.clear()
self._events.append(event)
if payload.get("event") == "done":
# Completion and its mailbox event are atomic with cancel.
self._completed.set()
# Only control events and the first text wake the GUI. A GUI timer drains
# all later text even if the upstream pauses after its last chunk.
if wake:
@@ -3275,17 +3340,17 @@ class _AiStreamWorker(QRunnable):
@Slot()
def run(self) -> None:
self.run_started_at = perf_counter()
try:
if self.is_cancelled():
return
stream = getattr(self.repository, "stream_diagnosis_ai", None)
if callable(stream):
events = stream(
self.diagnosis_id,
self.prompt,
task=self.task,
cancelled=self.is_cancelled,
)
options = {"task": self.task, "cancelled": self.is_cancelled}
parameters = signature(stream).parameters.values()
if any(p.name == "request_id" or p.kind is Parameter.VAR_KEYWORD for p in parameters):
options["request_id"] = self.request_id
events = stream(self.diagnosis_id, self.prompt, **options)
else:
result = invoke(
self.repository,
@@ -3306,9 +3371,10 @@ class _AiStreamWorker(QRunnable):
for event in events:
if self.is_cancelled():
return
self._queue_event(event)
if isinstance(event, Mapping) and event.get("event") == "done":
self._queue_event(event)
return
self._queue_event(event)
except Exception as error: # UI boundary: render transport/domain errors in place.
if not self.is_cancelled():
self.signals.error.emit(error)
@@ -3346,8 +3412,8 @@ AI_PROMPT_LIMIT = 500
#: 等待服务端整理诊单资料时显示的占位文案。
AI_STREAM_PENDING_TEXT = "正在整理诊单资料…"
#: 服务端确认资料已准备好、尚未收到回答时显示的占位文案。
AI_STREAM_WAITING_TEXT = "资料已整理,正在等待 AI 回复…"
#: 旧版服务只有 start;连接建立不代表资料已经整理或发送完成。
AI_STREAM_WAITING_TEXT = "已连接 AI 服务,正在等待资料处理或回复…"
#: 连接结束但一个字都没收到时的兜底文案。
AI_STREAM_SILENT_TEXT = (
@@ -3357,6 +3423,75 @@ AI_STREAM_TOTAL_TIMEOUT_MS = 180_000
AI_STREAM_TIMEOUT_TEXT = "等待 AI 回复超时,已停止本次等待,请稍后重试。"
AI_CONTEXT_SEPARATOR = "\n\n— 医生提问 —\n"
_TRANSFER_SOURCE_LABELS = (
("diagnosis_count", "诊单"), ("doctor_note_count", "医生备注"),
("tracking_note_count", "随访记录"), ("blood_record_count", "血糖血压记录"),
("diet_record_count", "饮食记录"), ("exercise_record_count", "运动记录"),
("prescription_count", "历史处方"), ("im_message_count", "IM 消息"),
("wechat_message_count", "企微消息"), ("call_record_count", "视频问诊"),
("transcript_segment_count", "转写片段"),
)
def _transfer_description(meta: Mapping[str, Any], state: str) -> str:
lines = [state]
summary = meta.get("source_summary")
if isinstance(summary, Mapping):
counts = [f"{label} {summary[key]} 条" for key, label in _TRANSFER_SOURCE_LABELS
if type(summary.get(key)) is int and summary[key] > 0]
if counts:
lines.append("本请求资料范围:" + "、".join(counts))
if summary.get("may_be_truncated") is True:
lines.append("资料可能按模型限制裁剪;以上为来源范围。")
if meta.get("source_form") == "evidence_summary":
lines.append("本次正文:来源归并证据摘要。")
if meta.get("evidence_cache_hit") is True:
lines.append("复用已整理的证据摘要。")
elif meta.get("source_form") == "full_context":
lines.append("本次正文:来源上下文。")
items = meta.get("items")
if isinstance(items, list):
kinds = {"image": "图片", "document": "文档", "audio": "音频", "video": "视频", "custom": "附件"}
statuses = {"submitting": "提交中", "submitted": "引用已提交", "omitted": "未提交", "failed": "提交失败"}
for index, item in enumerate(items, 1):
if not isinstance(item, Mapping):
continue
kind = kinds.get(str(item.get("kind")), "附件")
# Never display a legacy filename, URL or patient-identifying label.
label = str(item.get("label") or "")
if not re.fullmatch(r"(?:图片附件|文档附件|文件附件|音频附件|视频附件|自定义附件|附件|检查报告|舌象)\s*\d+", label):
label = f"{kind}附件{index}"
lines.append(f"{label}({kind}):{statuses.get(str(item.get('status')), '等待提交')}")
count = meta.get("attachment_count")
if type(count) is int and count >= 0:
lines.append(f"本请求附件通道:{count} 项;模型实际读取进度不可获取。")
return "\n".join(lines)
def _cancel_description(meta: Mapping[str, Any]) -> str:
terminal = meta.get("upstream_terminal_status")
if (
meta.get("upstream_terminal_confirmed") is True
and isinstance(terminal, str)
and terminal in {"stopped", "succeeded", "failed"}
):
notice = {
"stopped": "上游工作流已停止。",
"succeeded": "上游工作流已结束(已完成)。",
"failed": "上游工作流已结束(失败)。",
}[terminal]
elif meta.get("upstream_stop_confirmed") is True:
notice = "上游已接受停止请求;工作流是否结束尚未确认。"
elif meta.get("cancel_request_failed"):
notice = "已停止本次等待,取消请求未确认;上游是否停止尚未确认。"
elif meta.get("cancel_requested") is True:
notice = "已发送取消请求;上游是否停止尚未确认。"
else:
notice = "本次请求已取消;上游是否停止尚未确认。"
if meta.get("transport_closed") is True:
notice = f"本次传输已结束。{notice}"
return notice
def _truncate_for_context(text: str, *, max_chars: int) -> str:
"""Trim a long textual field while preserving a trailing ellipsis."""
@@ -6268,8 +6403,15 @@ class AiConsultDialog(QDialog):
worker.signals.finished.connect(
lambda: self._stream_finished(generation, stream_generation, worker)
)
cancel_signal = getattr(worker.signals, "cancel_result", None)
if cancel_signal is not None:
bubble = self._stream_bubble
cancel_signal.connect(
lambda result: self._stream_cancel_result(generation, diagnosis_id, bubble, worker, result)
)
self._stream_timeout_timer.start(AI_STREAM_TOTAL_TIMEOUT_MS)
self._delivery_timer.start()
worker.queued_at = perf_counter()
QThreadPool.globalInstance().start(worker)
self._request_chat_scroll()
@@ -6337,15 +6479,45 @@ class AiConsultDialog(QDialog):
if kind == "start":
self._stream_meta.update(payload)
self._update_stream_elapsed()
self._update_transfer_status(AI_STREAM_PENDING_TEXT)
if self._stream_bubble is not None and not self._stream_text and not self._pending_chunks:
self._stream_bubble.set_payload(AI_STREAM_WAITING_TEXT)
return
if kind == "progress":
self._stream_meta.update(payload)
phase = str(payload.get("phase") or "")
state = {
"preparing": AI_STREAM_PENDING_TEXT,
"attachments": "正在提交资料与附件到模型…",
"upstream": "资料已提交,正在等待 AI 正文…",
"cancelled": "本次请求已取消;上游是否停止尚未确认。",
}.get(phase, "正在处理本请求资料…")
if phase == "attachments" and payload.get("status") == "submitted":
state = "附件引用已提交,等待模型处理…"
if phase == "preparing" and payload.get("status") == "ready":
state = "资料正文已整理,正在准备提交…"
if payload.get("status") == "failed":
state = "资料提交失败。"
if phase == "cancelled":
state = _cancel_description(self._stream_meta)
self._update_transfer_status(state)
if phase == "cancelled" and self._stream_bubble is not None:
self._stream_bubble.set_cancel_status(
_transfer_description(self._stream_meta, state),
has_text=bool(self._stream_text or self._pending_chunks),
)
elif self._stream_bubble is not None and not self._stream_text and not self._pending_chunks:
self._stream_bubble.set_payload(state)
return
if kind == "delta":
chunk = payload.get("text")
if isinstance(chunk, str) and chunk:
if self._stream_first_delta_at is None:
self._stream_first_delta_at = monotonic()
if self._stream_worker is not None:
self._stream_worker.first_delta_processed_at = perf_counter()
self._update_stream_elapsed()
self._update_transfer_status("已收到 AI 正文,正在生成…")
self._pending_chunks.append(chunk)
if not self._stream_text:
# The first received text replaces the waiting state now.
@@ -6357,6 +6529,11 @@ class AiConsultDialog(QDialog):
return
self._stream_meta.update(payload)
self._stream_completed = True
if self._stream_worker is not None:
mark_completed = getattr(self._stream_worker, "mark_completed", None)
if callable(mark_completed):
mark_completed()
self._update_transfer_status("本次回复已完成。")
self._delivery_timer.stop()
self._stream_timeout_timer.stop()
self._stop_stream_clock()
@@ -6377,6 +6554,23 @@ class AiConsultDialog(QDialog):
self._asking = False
self.send_button.setEnabled(True)
def _update_transfer_status(self, state: str) -> None:
if self._stream_bubble is not None:
self._stream_bubble.set_transfer_status(_transfer_description(self._stream_meta, state))
def _stream_cancel_result(self, generation: int, diagnosis_id: int, bubble: Any, worker: _AiStreamWorker, result: Any) -> None:
if self._session_closed or generation != self._generation or diagnosis_id != self.diagnosis_id:
return
if bubble is None or not isValid(bubble):
return
payload = result if isinstance(result, Mapping) else {}
notice = _cancel_description(payload)
if worker.cancel_reason:
notice = f"{worker.cancel_reason}\n{notice}"
bubble.set_cancel_status(
_transfer_description(worker.cancel_meta, notice), has_text=bool(worker.cancel_text),
)
def _flush_stream_chunks(self) -> None:
self._flush_timer.stop()
if not self._pending_chunks or self._stream_bubble is None:
@@ -6401,11 +6595,28 @@ class AiConsultDialog(QDialog):
self._stop_stream_clock()
self._flush_stream_chunks()
message = friendly_error(error)
if self._stream_text:
error_data = getattr(error, "data", None)
cancelled = self._stream_meta.get("phase") == "cancelled" or (
isinstance(error_data, Mapping) and error_data.get("code") == "AI_ASSISTANT_CANCELLED"
)
if cancelled:
if isinstance(error_data, Mapping):
self._stream_meta.update(error_data)
self._stream_meta["phase"] = "cancelled"
message = _cancel_description(self._stream_meta)
if self._stream_worker is not None:
self._stream_worker.mark_completed()
self._update_transfer_status(message if cancelled else "本次请求失败,资料或回复未完成。")
if cancelled:
if self._stream_bubble is not None:
self._stream_bubble.set_cancel_status(
_transfer_description(self._stream_meta, message), has_text=bool(self._stream_text),
)
elif self._stream_text:
self._stream_text = f"{self._stream_text}\n\n> 生成中断:{message}"
else:
self._stream_text = message
if self._stream_bubble is not None:
if not cancelled and self._stream_bubble is not None:
self._stream_bubble.set_payload(self._stream_text)
self._asking = False
self.send_button.setEnabled(True)
@@ -6422,7 +6633,8 @@ class AiConsultDialog(QDialog):
self._delivery_timer.stop()
self._stream_timeout_timer.stop()
self._flush_stream_chunks()
if self._stream_bubble is not None:
cancelled = self._stream_meta.get("phase") == "cancelled"
if self._stream_bubble is not None and not cancelled:
self._stream_bubble.finish_stream_text()
self._stop_stream_clock()
if self._stream_worker is worker:
@@ -6431,6 +6643,7 @@ class AiConsultDialog(QDialog):
# 将阶段占位文案替换成明确说明。
if (
not self._stream_completed
and not cancelled
and not self._stream_text
and self._stream_bubble is not None
):
@@ -6442,37 +6655,42 @@ class AiConsultDialog(QDialog):
def _stream_timed_out(self) -> None:
if not self._asking or self._stream_completed:
return
self._poll_stream_events()
if not self._asking or self._stream_completed:
return
self._flush_stream_chunks()
bubble = self._stream_bubble
text = self._stream_text
self._stop_stream_clock()
self._cancel_stream()
if bubble is not None:
bubble.set_payload(
f"{text}\n\n> {AI_STREAM_TIMEOUT_TEXT}" if text else AI_STREAM_TIMEOUT_TEXT
)
self._cancel_stream(reason=AI_STREAM_TIMEOUT_TEXT)
def _cancel_stream(self, *, replaced: bool = False) -> None:
if replaced and self._asking:
self._poll_stream_events()
if replaced and self._asking:
def _cancel_stream(self, *, replaced: bool = False, reason: str = "") -> None:
worker = self._stream_worker
if worker is not None:
worker.cancel_reason = reason
# Atomically preserve queued tails/done and signal cancellation before
# any GUI formatting. Already completed workers never send control HTTP.
events = worker.cancel() or []
if (replaced or reason) and self._asking:
for event in events:
self._stream_event(self._generation, self._stream_generation, event)
if reason and self._stream_completed:
# A queued done wins a simultaneous timeout; retain normal completion.
return
if (replaced or reason) and self._asking:
self._flush_stream_chunks()
self._stop_stream_clock()
if self._stream_bubble is not None:
notice = "已停止本次生成,已切换到新的请求。"
self._stream_bubble.set_payload(
f"{self._stream_text}\n\n> {notice}" if self._stream_text else notice
notice = (
"已停止本次等待,已切换到新的请求;正在请求取消,上游是否停止尚未确认。"
if replaced else "已停止本次等待;正在请求取消,上游是否停止尚未确认。"
)
if reason:
notice = f"{reason}\n{notice}"
self._stream_bubble.set_cancel_status(
_transfer_description(self._stream_meta, notice), has_text=bool(self._stream_text),
)
self._stream_generation += 1
self._flush_timer.stop()
self._stream_timeout_timer.stop()
self._stream_elapsed_timer.stop()
self._delivery_timer.stop()
if self._stream_worker is not None:
self._stream_worker.cancel()
if worker is not None:
worker.cancel_text = self._stream_text
worker.cancel_meta = dict(self._stream_meta)
self._stream_worker = None
self._stream_bubble = None
self._pending_chunks.clear()
+322
View File
@@ -0,0 +1,322 @@
"""Only observed input states and confirmed upstream cancellation are claimed."""
from __future__ import annotations
import os
from threading import Event
from time import monotonic
from types import SimpleNamespace
from uuid import UUID
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
import pytest
from PySide6.QtTest import QTest
from PySide6.QtWidgets import QApplication
from doctor_workstation.core.errors import ApiBusinessError
from doctor_workstation.ui.dialogs import ai_consult as module
@pytest.fixture(scope="module")
def application():
return QApplication.instance() or QApplication([])
def dialog_for(monkeypatch, repository):
monkeypatch.setattr(module, "QThreadPool", SimpleNamespace(globalInstance=lambda: SimpleNamespace(start=lambda worker: None)))
dialog = module.AiConsultDialog(repository)
monkeypatch.setattr(dialog, "_load_workspace", lambda _: None)
dialog.open_for(diagnosis_id=501, patient_id=1501)
return dialog
def test_progress_lists_actual_materials_without_claiming_model_reading(application, monkeypatch):
dialog = dialog_for(monkeypatch, object())
dialog._ask("合成问题")
generation, stream_generation = dialog._generation, dialog._stream_generation
bubble = dialog._stream_bubble
dialog._stream_event(generation, stream_generation, {"event": "start"})
assert "资料已整理" not in bubble._raw_payload
assert "整理" in bubble.transfer_status.text()
dialog._stream_event(generation, stream_generation, {
"event": "progress", "phase": "preparing",
"source_summary": {"diagnosis_count": 2, "doctor_note_count": 3, "patient_name": "敏感姓名"},
})
assert "诊单 2 条" in bubble.transfer_status.text() and "医生备注 3 条" in bubble.transfer_status.text()
dialog._stream_event(generation, stream_generation, {
"event": "progress", "phase": "attachments", "status": "submitting", "attachment_count": 2,
"source_form": "evidence_summary", "evidence_cache_hit": True,
"items": [{"label": "图片附件1", "kind": "image", "status": "submitting"},
{"label": "敏感姓名的检查报告.pdf", "kind": "document", "status": "failed"}],
})
text = bubble.transfer_status.text()
assert "图片附件1(图片):提交中" in text and "文档附件2(文档):提交失败" in text
assert "来源归并证据摘要" in text and "复用已整理" in text
assert "敏感姓名" not in text and "pdf" not in text and "%" not in text
dialog._stream_event(generation, stream_generation, {
"event": "progress", "phase": "attachments", "status": "submitted",
"items": [{"label": "图片附件1", "kind": "image", "status": "submitted"}],
})
assert "引用已提交" in bubble.transfer_status.text() and "模型实际读取进度不可获取" in bubble.transfer_status.text()
dialog._stream_event(generation, stream_generation, {"event": "progress", "phase": "upstream"})
assert "等待 AI 正文" in bubble._raw_payload
dialog._stream_event(generation, stream_generation, {"event": "delta", "text": "合成正文"})
assert bubble._raw_payload == "合成正文" and "图片附件1" in bubble.transfer_status.text()
dialog._stream_event(generation, stream_generation, {"event": "done"})
assert "本次回复已完成" in bubble.transfer_status.text()
dialog.close()
@pytest.mark.parametrize("confirmed", [False, True])
def test_replacement_cancel_is_background_correlated_and_requires_upstream_confirmation(application, monkeypatch, confirmed):
entered, release, returned = Event(), Event(), Event()
calls = []
class Repository:
def cancel_diagnosis_ai(self, diagnosis_id, request_id):
calls.append((diagnosis_id, request_id))
entered.set()
assert release.wait(2)
returned.set()
return {"cancel_requested": True, "transport_closed": True, "upstream_stop_confirmed": confirmed}
dialog = dialog_for(monkeypatch, Repository())
try:
dialog._ask("旧问题")
old_worker, old_bubble = dialog._stream_worker, dialog._stream_bubble
request_id = old_worker.request_id
assert str(UUID(request_id)) == request_id
dialog._ask("新问题", replace_active=True)
new_bubble = dialog._stream_bubble
assert entered.wait(1)
assert "上游是否停止尚未确认" in old_bubble.transfer_status.text()
assert old_bubble.body.isHidden()
assert calls == [(501, request_id)]
assert dialog._stream_worker.request_id != request_id
release.set()
assert returned.wait(1)
deadline = monotonic() + 1
while "正在请求取消" in old_bubble.transfer_status.text() and monotonic() < deadline:
QTest.qWait(10)
assert ("上游已接受停止" in old_bubble.transfer_status.text()) is confirmed
assert "尚未确认" in old_bubble.transfer_status.text()
assert "上游工作流已停止" not in old_bubble.transfer_status.text()
assert new_bubble._raw_payload == module.AI_STREAM_PENDING_TEXT
finally:
release.set()
dialog.close()
@pytest.mark.parametrize("exit_path", ["timeout", "patient", "close"])
def test_abort_paths_send_cancel_once_and_done_never_sends_cancel(application, monkeypatch, exit_path):
called = Event()
calls = []
class Repository:
def cancel_diagnosis_ai(self, diagnosis_id, request_id):
calls.append((diagnosis_id, request_id))
called.set()
return {"cancel_requested": True, "upstream_stop_confirmed": False}
dialog = dialog_for(monkeypatch, Repository())
dialog._ask("已完成问题")
dialog._stream_event(dialog._generation, dialog._stream_generation, {"event": "done", "answer": "合成结果"})
dialog._ask("需要取消的问题")
assert calls == []
worker = dialog._stream_worker
if exit_path == "timeout":
dialog._stream_timed_out()
elif exit_path == "patient":
dialog.open_for(diagnosis_id=502, patient_id=1502)
else:
dialog.close()
assert called.wait(1)
worker.cancel()
assert calls == [(501, worker.request_id)]
dialog.close()
def test_cancel_confirmation_cannot_change_reused_patient_session(application, monkeypatch):
dialog = dialog_for(monkeypatch, object())
dialog._ask("旧问题")
old_worker, old_bubble, generation = dialog._stream_worker, dialog._stream_bubble, dialog._generation
dialog.open_for(diagnosis_id=502, patient_id=1502)
dialog._ask("新患者问题")
before = dialog._stream_bubble._raw_payload
dialog._stream_cancel_result(generation, 501, old_bubble, old_worker, {"upstream_stop_confirmed": True})
assert dialog._stream_bubble._raw_payload == before
dialog.close()
def test_server_cancel_terminal_preserves_confirmed_state_without_retry(application, monkeypatch):
dialog = dialog_for(monkeypatch, object())
dialog._ask("服务端取消测试")
generation, stream_generation = dialog._generation, dialog._stream_generation
worker, bubble = dialog._stream_worker, dialog._stream_bubble
dialog._stream_event(generation, stream_generation, {
"event": "progress", "phase": "cancelled", "status": "cancelled",
"upstream_stop_confirmed": True, "transport_closed": True,
})
dialog._stream_failed(generation, stream_generation, ApiBusinessError(
"本次请求已取消", data={"code": "AI_ASSISTANT_CANCELLED"},
))
assert "上游已接受停止" in bubble.transfer_status.text() and "本次传输已结束" in bubble.transfer_status.text()
assert not dialog._asking and worker._completed.is_set()
assert "尚未确认" in bubble.transfer_status.text()
assert bubble.body.isHidden()
dialog.close()
@pytest.mark.parametrize("ack", [
{"upstream_stop_confirmed": True},
{"upstream_terminal_confirmed": True, "upstream_terminal_status": "stopped"},
])
def test_long_replacement_preserves_tail_and_cancels_before_gui_work(application, monkeypatch, ack):
dialog = dialog_for(monkeypatch, object())
dialog._ask("旧长报告")
worker, bubble = dialog._stream_worker, dialog._stream_bubble
worker.signals.blockSignals(True)
body = "## 合成长报告\n\n" + "逐项核对原始记录。\n\n" * 250
dialog._stream_event(dialog._generation, dialog._stream_generation, {"event": "delta", "text": body})
dialog._stream_event(dialog._generation, dialog._stream_generation, {"event": "delta", "text": "GUI未刷尾段"})
worker._queue_event({"event": "delta", "text": "mailbox未刷尾段"})
original_append, original_status = bubble.append_stream_text, bubble.set_cancel_status
observed = []
def append(*args):
assert worker.is_cancelled(), "cancel flag must precede pending GUI rendering"
observed.append("append")
original_append(*args)
def status(*args, **kwargs):
assert worker.is_cancelled(), "cancel flag must precede status updates"
observed.append("status")
original_status(*args, **kwargs)
monkeypatch.setattr(bubble, "append_stream_text", append)
monkeypatch.setattr(bubble, "set_cancel_status", status)
monkeypatch.setattr(bubble, "set_payload", lambda *_: pytest.fail("cancel reparsed complete bubble"))
monkeypatch.setattr(bubble.body, "set_payload", lambda *_: pytest.fail("cancel reparsed clinical text"))
dialog._ask("新问题", replace_active=True)
expected = body + "GUI未刷尾段mailbox未刷尾段"
assert bubble._raw_payload == expected and worker.cancel_text == expected
assert "GUI未刷尾段mailbox未刷尾段" in bubble.body.toPlainText()
assert observed and "status" in observed
before_stamp = bubble.stamp.text()
dialog._stream_cancel_result(dialog._generation, 501, bubble, worker, ack)
assert bubble._raw_payload == expected and bubble.stamp.text() == before_stamp
assert not bubble.body.isHidden()
assert dialog._stream_bubble._raw_payload == module.AI_STREAM_PENDING_TEXT
dialog.close()
@pytest.mark.parametrize("exit_path", ["replacement", "timeout"])
def test_queued_done_is_drained_without_cancel_and_preserves_all_tail(application, monkeypatch, exit_path):
dialog = dialog_for(monkeypatch, object())
dialog._ask("已到达完成事件的旧问题")
worker, bubble = dialog._stream_worker, dialog._stream_bubble
worker.signals.blockSignals(True)
worker._queue_event({"event": "delta", "text": "完整前段"})
worker._queue_event({"event": "delta", "text": "与完整尾段"})
worker._queue_event({"event": "done"})
monkeypatch.setattr(worker, "_request_cancel", lambda: pytest.fail("normal done sent cancel"))
if exit_path == "replacement":
dialog._ask("新问题", replace_active=True)
else:
dialog._stream_timed_out()
assert dialog._stream_completed and dialog._stream_bubble is bubble
assert dialog._stream_text == "完整前段与完整尾段"
assert not worker.is_cancelled()
assert bubble._raw_payload == "完整前段与完整尾段"
assert "本次回复已完成" in bubble.transfer_status.text()
assert "正在请求取消" not in bubble.transfer_status.text()
dialog.close()
def test_server_cancel_preserves_long_body_through_finished_without_reparse(application, monkeypatch):
dialog = dialog_for(monkeypatch, object())
dialog._ask("服务端取消长报告")
generation, stream_generation = dialog._generation, dialog._stream_generation
worker, bubble = dialog._stream_worker, dialog._stream_bubble
body = "## 合成长报告\n\n" + "保留既有临床正文。\n\n" * 250
dialog._stream_event(generation, stream_generation, {"event": "delta", "text": body})
dialog._stream_event(generation, stream_generation, {"event": "delta", "text": "未刷尾段"})
monkeypatch.setattr(bubble, "set_payload", lambda *_: pytest.fail("server cancel reparsed complete bubble"))
monkeypatch.setattr(bubble.body, "set_payload", lambda *_: pytest.fail("server cancel reparsed clinical text"))
dialog._stream_event(generation, stream_generation, {
"event": "progress", "phase": "cancelled", "upstream_terminal_confirmed": True,
"upstream_terminal_status": "stopped",
})
dialog._stream_failed(generation, stream_generation, ApiBusinessError(
"本次请求已取消", data={"code": "AI_ASSISTANT_CANCELLED"},
))
dialog._stream_finished(generation, stream_generation, worker)
assert bubble._raw_payload == body + "未刷尾段"
assert "未刷尾段" in bubble.body.toPlainText()
assert "上游工作流已停止" in bubble.transfer_status.text()
assert not bubble.body.isHidden() and not dialog._asking
dialog.close()
@pytest.mark.parametrize("confirmed,status,expected", [
(True, "stopped", "上游工作流已停止"),
(True, "succeeded", "上游工作流已结束(已完成)"),
(True, "failed", "上游工作流已结束(失败)"),
(False, "stopped", "尚未确认"),
(True, "", "尚未确认"),
(True, "unrecognized", "尚未确认"),
])
@pytest.mark.parametrize("path", ["ack", "server_terminal"])
def test_only_confirmed_workflow_terminal_claims_ended(application, monkeypatch, confirmed, status, expected, path):
dialog = dialog_for(monkeypatch, object())
dialog._ask("终态校验")
generation, stream_generation = dialog._generation, dialog._stream_generation
worker, bubble = dialog._stream_worker, dialog._stream_bubble
state = {"upstream_stop_confirmed": True, "upstream_terminal_confirmed": confirmed,
"upstream_terminal_status": status, "transport_closed": True}
if path == "ack":
dialog._ask("新问题", replace_active=True)
dialog._stream_cancel_result(generation, 501, bubble, worker, state)
else:
dialog._stream_event(generation, stream_generation, {"event": "progress", "phase": "cancelled", **state})
dialog._stream_failed(generation, stream_generation, ApiBusinessError(
"本次请求已取消", data={"code": "AI_ASSISTANT_CANCELLED"},
))
dialog._stream_finished(generation, stream_generation, worker)
assert expected in bubble.transfer_status.text()
if not confirmed or status not in {"stopped", "succeeded", "failed"}:
assert "上游工作流已停止" not in bubble.transfer_status.text()
assert "上游工作流已结束" not in bubble.transfer_status.text()
assert bubble.body.isHidden()
dialog.close()
def test_worker_monotonic_timings_separate_queue_and_gui_delivery(application, monkeypatch):
now = [100.0]
monkeypatch.setattr(module, "monotonic", lambda: now[0])
monkeypatch.setattr(module, "perf_counter", lambda: now[0])
class Repository:
def stream_diagnosis_ai(self, *args, **kwargs):
now[0] = 103.0
yield {"event": "delta", "text": "合成正文"}
yield {"event": "delta", "text": "尾段"}
yield {"event": "done"}
dialog = dialog_for(monkeypatch, Repository())
dialog._ask("时间戳校验")
worker = dialog._stream_worker
assert worker.queued_at == 100.0 and worker.run_started_at is None
worker.signals.blockSignals(True)
now[0] = 102.0
worker.run()
assert worker.run_started_at == 102.0 and worker.first_delta_received_at == 103.0
assert worker.first_delta_processed_at is None
now[0] = 105.0
dialog._poll_stream_events()
assert worker.first_delta_processed_at == 105.0
assert worker.run_started_at - worker.queued_at == 2.0
assert worker.first_delta_processed_at - worker.first_delta_received_at == 2.0
assert dialog._stream_bubble._raw_payload == "合成正文尾段"
dialog.close()
+221
View File
@@ -0,0 +1,221 @@
"""Cancellation interrupts idle I/O and uses an independent control request."""
from __future__ import annotations
import asyncio
import json
import socket
from concurrent.futures import ThreadPoolExecutor
from threading import Event, Thread, get_ident
from uuid import uuid4
import httpx
import pytest
from doctor_workstation.services.api_client import ApiClient
from doctor_workstation.services.repository import RemoteDoctorRepository
@pytest.mark.parametrize("stage", ["headers", "body"])
def test_cancel_interrupts_idle_read_and_cleans_up_on_owning_loop(stage):
entered, cancelled = Event(), Event()
body_threads, closed_threads = [], []
class IdleStream(httpx.AsyncByteStream):
async def __aiter__(self):
body_threads.append(get_ident())
entered.set()
await asyncio.sleep(30)
yield b"event: done\ndata: {}\n\n"
async def aclose(self):
closed_threads.append(get_ident())
async def handler(request):
if stage == "headers":
entered.set()
await asyncio.sleep(30)
return httpx.Response(200, headers={"content-type": "text/event-stream"}, stream=IdleStream())
client = ApiClient("https://example.test", transport=httpx.MockTransport(handler))
with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(lambda: list(client.post_event_stream(
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
)))
assert entered.wait(2)
cancelled.set()
assert future.result(timeout=0.8) == []
if stage == "body":
assert body_threads == closed_threads
client.close()
@pytest.mark.parametrize("headers_sent", [False, True])
def test_default_transport_closes_idle_local_socket_without_another_line(headers_sent):
entered, disconnected, cancelled = Event(), Event(), Event()
listener = socket.socket()
listener.bind(("127.0.0.1", 0))
listener.listen(1)
listener.settimeout(3)
def serve():
try:
connection, _ = listener.accept()
with connection:
connection.settimeout(3)
request = b""
while b"\r\n\r\n" not in request:
request += connection.recv(4096)
header, body = request.split(b"\r\n\r\n", 1)
length = next(int(line.split(b":", 1)[1]) for line in header.split(b"\r\n") if line.lower().startswith(b"content-length:"))
while len(body) < length:
body += connection.recv(4096)
if headers_sent:
connection.sendall(b"HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\n\r\n")
entered.set()
if connection.recv(1) == b"":
disconnected.set()
finally:
listener.close()
thread = Thread(target=serve, daemon=True)
thread.start()
with ApiClient(f"http://127.0.0.1:{listener.getsockname()[1]}") as client, ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(lambda: list(client.post_event_stream(
"tcm.diagnosis/aiAssistantStream", {"id": 501}, cancelled=cancelled.is_set,
)))
try:
assert entered.wait(2)
cancelled.set()
assert future.result(timeout=0.8) == []
assert disconnected.wait(0.8)
finally:
cancelled.set()
thread.join(timeout=1)
assert not thread.is_alive()
def test_cancel_control_post_bypasses_busy_short_request_pool(monkeypatch):
from doctor_workstation.services import api_client as module
entered, release = Event(), Event()
created = []
class Client:
def __init__(self, **options):
created.append(self)
def request(self, *args, **kwargs):
entered.set()
assert release.wait(2)
return httpx.Response(200, json={"code": 1, "data": {}})
def post(self, url, **kwargs):
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True}})
def close(self):
pass
def __enter__(self):
return self
def __exit__(self, *args):
self.close()
monkeypatch.setattr(module.httpx, "Client", Client)
client = ApiClient("https://example.test", max_parallel_requests=1)
with ThreadPoolExecutor(max_workers=1) as executor:
future = executor.submit(client.get, "synthetic/busy")
try:
assert entered.wait(1)
assert client.post_independent("tcm.diagnosis/cancelAiAssistant", {"id": 501}) == {"cancel_requested": True}
assert len(created) == 2
finally:
release.set()
future.result(timeout=1)
client.close()
def test_stream_progress_and_cancel_preserve_same_request_identity():
requests = []
request_id = str(uuid4())
def handler(request):
requests.append(request)
if request.url.path.endswith("cancelAiAssistant"):
return httpx.Response(200, json={"code": 1, "data": {"cancel_requested": True, "upstream_stop_confirmed": False}})
return httpx.Response(200, headers={"content-type": "text/event-stream"}, text=(
'event: progress\ndata: {"phase":"attachments","items":[{"kind":"image","label":"图片附件1","status":"submitted"}],"attachment_count":1}\n\n'
'event: done\ndata: {}\n\n'
))
with ApiClient("https://example.test", transport=httpx.MockTransport(handler)) as client:
repository = RemoteDoctorRepository(client)
events = list(repository.stream_diagnosis_ai(501, "合成问题", request_id=request_id))
result = repository.cancel_diagnosis_ai(501, request_id)
assert events[0]["event"] == "progress" and events[0]["items"][0]["status"] == "submitted"
assert json.loads(requests[0].content)["request_id"] == request_id
assert json.loads(requests[1].content) == {"id": 501, "request_id": request_id}
assert result["cancel_requested"] and not result["upstream_stop_confirmed"]
def test_async_bridge_batches_thousands_of_frames_without_per_delta_tasks(monkeypatch):
from doctor_workstation.services import api_client as module
calls = {"tasks": 0, "loop_runs": 0}
new_event_loop = asyncio.new_event_loop
def counted_loop():
loop = new_event_loop()
create_task, run_forever = loop.create_task, loop.run_forever
def task(*args, **kwargs):
calls["tasks"] += 1
return create_task(*args, **kwargs)
def run():
calls["loop_runs"] += 1
return run_forever()
loop.create_task, loop.run_forever = task, run
return loop
monkeypatch.setattr(module.asyncio, "new_event_loop", counted_loop)
chunks = [f"片段{index}🩺" for index in range(6000)]
content = "".join("event: delta\ndata: " + json.dumps({"text": text}) + "\n\n" for text in chunks)
content += 'event: done\ndata: {}\n\n'
transport = httpx.MockTransport(lambda request: httpx.Response(
200, headers={"content-type": "text/event-stream"}, text=content,
))
with ApiClient("https://example.test", transport=transport) as client:
events = list(client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False))
assert [event["data"]["text"] for event in events[:-1]] == chunks
assert events[-1]["event"] == "done"
assert calls["tasks"] <= 8
assert calls["loop_runs"] <= 40
@pytest.mark.parametrize("ending", ["eof", "error"])
def test_async_batch_drains_queued_tail_before_eof_or_error(ending):
class TailStream(httpx.AsyncByteStream):
async def __aiter__(self):
yield b'event: delta\ndata: {"text":"first"}\n\nevent: delta\ndata: {"text":"tail"}\n\n'
if ending == "error":
raise httpx.ReadError("synthetic read failure")
# A valid final SSE frame need not end with a blank line.
yield b'event: delta\ndata: {"text":"last"}'
transport = httpx.MockTransport(lambda request: httpx.Response(
200, headers={"content-type": "text/event-stream"}, stream=TailStream(),
))
with ApiClient("https://example.test", transport=transport) as client:
stream = client.post_event_stream("synthetic/stream", {}, cancelled=lambda: False)
assert next(stream)["data"]["text"] == "first"
assert next(stream)["data"]["text"] == "tail"
if ending == "error":
from doctor_workstation.core.errors import ApiTransportError
with pytest.raises(ApiTransportError, match="stream failed"):
next(stream)
else:
assert next(stream)["data"]["text"] == "last"
assert list(stream) == []
+15 -9
View File
@@ -1,5 +1,6 @@
from __future__ import annotations
import asyncio
import json
import os
from threading import Event
@@ -1517,7 +1518,8 @@ def test_stalled_stream_exits_pending_state_and_ignores_late_events(
assert not dialog._stream_timeout_timer.isActive()
assert not dialog._asking
assert dialog.send_button.isEnabled()
assert bubble._raw_payload == ai_consult_module.AI_STREAM_TIMEOUT_TEXT
assert ai_consult_module.AI_STREAM_TIMEOUT_TEXT in bubble.transfer_status.text()
assert bubble.body.isHidden()
calls: list[int] = []
monkeypatch.setattr(
@@ -1530,7 +1532,8 @@ def test_stalled_stream_exits_pending_state_and_ignores_late_events(
assert calls == []
dialog._stream_event(generation, stream_generation, {"event": "delta", "text": "迟到回复"})
dialog._stream_finished(generation, stream_generation, worker)
assert bubble._raw_payload == ai_consult_module.AI_STREAM_TIMEOUT_TEXT
assert ai_consult_module.AI_STREAM_TIMEOUT_TEXT in bubble.transfer_status.text()
assert bubble.body.isHidden()
dialog._ask("请补充说明")
second_bubble = dialog._stream_bubble
@@ -1541,8 +1544,8 @@ def test_stalled_stream_exits_pending_state_and_ignores_late_events(
{"event": "delta", "text": "已收到部分分析"},
)
dialog._stream_timed_out()
assert second_bubble._raw_payload.startswith("已收到部分分析\n\n>")
assert ai_consult_module.AI_STREAM_TIMEOUT_TEXT in second_bubble._raw_payload
assert second_bubble._raw_payload == "已收到部分分析"
assert ai_consult_module.AI_STREAM_TIMEOUT_TEXT in second_bubble.transfer_status.text()
dialog.close()
@@ -1685,8 +1688,8 @@ def test_http_stream_paints_before_upstream_finishes_on_the_ui_thread(
release = Event()
waiting_for_end = Event()
class DelayedStream(httpx.SyncByteStream):
def __iter__(self):
class DelayedStream(httpx.AsyncByteStream):
async def __aiter__(self):
first = (
'event: start\r\ndata: {"model_label":"千问"}\r\n\r\n'
'event: delta\r\ndata: {"text":"先收到的内容"}\r\n\r\n'
@@ -1696,8 +1699,11 @@ def test_http_stream_paints_before_upstream_finishes_on_the_ui_thread(
yield first[:split]
yield first[split:]
waiting_for_end.set()
if not release.wait(5):
raise AssertionError("UI did not receive the first streamed text")
deadline = monotonic() + 5
while not release.is_set():
if monotonic() > deadline:
raise AssertionError("UI did not receive the first streamed text")
await asyncio.sleep(0.01)
yield (
'event: delta\r\ndata: {"text":",然后完成。"}\r\n\r\n'
'event: done\r\ndata: {"model_label":"千问"}\r\n\r\n'
@@ -1806,7 +1812,7 @@ def test_clicking_another_quick_tool_switches_the_active_request(
assert worker.prompt == ai_consult_module.TOOL_ITEMS[1][2]
assert old_worker.is_cancelled()
assert "已收到的分析" in old_bubble._raw_payload
assert "已停止" in old_bubble._raw_payload
assert "已停止" in old_bubble.transfer_status.text()
assert bubble is not None and bubble is not old_bubble
assert bubble._raw_payload == ai_consult_module.AI_STREAM_PENDING_TEXT
assert "已等待 0 秒" in bubble.stamp.text()
+48
View File
@@ -0,0 +1,48 @@
"""The explicit local launcher must validate the effective endpoint after preferences."""
from __future__ import annotations
import importlib.util
from pathlib import Path
from types import SimpleNamespace
import pytest
spec = importlib.util.spec_from_file_location(
"local_launcher", Path(__file__).parents[1] / "scripts/run_local_workstation.py"
)
launcher = importlib.util.module_from_spec(spec)
spec.loader.exec_module(launcher)
@pytest.fixture(autouse=True)
def loopback_dns(monkeypatch):
monkeypatch.setattr(launcher.socket, "getaddrinfo", lambda *_: [(None, None, None, None, ("127.0.0.1", 443))])
@pytest.mark.parametrize("url", [
"http://local.test", "https://user:password@local.test", "https://local.test?token=private",
"https://local.test#fragment", "https://local.test:invalid", "https://local.test:70000",
])
def test_local_url_rejects_unsecured_or_credential_url(url):
with pytest.raises(ValueError):
launcher.validate_local_url(url)
def test_local_url_rejects_external_dns(monkeypatch):
monkeypatch.setattr(launcher.socket, "getaddrinfo", lambda *_: [(None, None, None, None, ("192.0.2.1", 443))])
with pytest.raises(ValueError):
launcher.validate_local_url("https://local.test")
@pytest.mark.parametrize("effective", [
"http://local.test/adminapi", "https://local.test:8443/adminapi", "https://local.test/other/adminapi",
])
def test_preferences_cannot_change_validated_scheme_port_or_path(effective):
with pytest.raises(ValueError):
launcher.validate_effective_config(SimpleNamespace(api_base_url=effective, verify_ssl=True), "https://local.test")
def test_local_config_keeps_certificate_verification():
launcher.validate_effective_config(SimpleNamespace(api_base_url="https://local.test/adminapi", verify_ssl=True), "https://local.test")
with pytest.raises(ValueError):
launcher.validate_effective_config(SimpleNamespace(api_base_url="https://local.test/adminapi", verify_ssl=False), "https://local.test")
+3 -1
View File
@@ -5,6 +5,7 @@ from __future__ import annotations
from datetime import date
from pathlib import Path
from typing import Any
from uuid import UUID
import pytest
@@ -759,7 +760,8 @@ def test_remote_diagnosis_ai_stream_normalises_chunks_in_order() -> None:
class StreamingClient(RecordingClient):
def post_event_stream(self, endpoint: str, payload: dict[str, Any], **kwargs: Any):
assert endpoint == "tcm.diagnosis/aiAssistantStream"
assert payload == {"id": 501, "prompt": "请辨证", "task": "tcm_pattern"}
assert {key: value for key, value in payload.items() if key != "request_id"} == {"id": 501, "prompt": "请辨证", "task": "tcm_pattern"}
assert str(UUID(payload["request_id"])) == payload["request_id"]
assert kwargs["timeout"] == 105.0
yield {"event": "start", "data": {"model_key": "qwen"}}
yield {"event": "delta", "data": {"content": "肝郁"}}