Merge branch 'master' of http://git.zhenyangtang.com.cn/ZYT/zyt
This commit is contained in:
@@ -1,4 +1,5 @@
|
||||
.env
|
||||
.local-workstation/
|
||||
.venv/
|
||||
.venv-build/
|
||||
.venv-win7-check/
|
||||
|
||||
@@ -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/),然后在项目根目录执行:
|
||||
|
||||
@@ -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%
|
||||
@@ -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()
|
||||
|
||||
@@ -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()
|
||||
@@ -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) == []
|
||||
@@ -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()
|
||||
|
||||
@@ -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")
|
||||
@@ -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": "肝郁"}}
|
||||
|
||||
Reference in New Issue
Block a user