Spaces:
Running
Running
| # -*- coding: utf-8 -*- | |
| """SmartPaper R3-Free UI: Streamlit is an observer, never the paper executor.""" | |
| import hashlib | |
| import html | |
| import json | |
| import logging | |
| import os | |
| import re | |
| import secrets | |
| import shutil | |
| import subprocess | |
| import sys | |
| import time | |
| import textwrap | |
| from datetime import datetime, timezone | |
| from pathlib import Path | |
| import streamlit as st | |
| import streamlit.components.v1 as components | |
| from config import APP_CONFIG | |
| from managed_auth import ( | |
| cancel_generation_task, | |
| generation_task_status, | |
| get_product_ui_projection, | |
| recover_generation_task, | |
| require_alipay_login, | |
| render_logged_in_account, | |
| render_payment_purchase, | |
| start_generation_task, | |
| ) | |
| from i18n import ( | |
| LANGUAGE_OPTIONS, get_amj_csv_template, get_asq_txt_template, | |
| get_output_suffix, get_target_flag, get_target_language, tr, | |
| ) | |
| from smartpaper_restore_bridge import edge_bridge | |
| st.set_page_config( | |
| page_title="Article Agent", | |
| page_icon="📊", | |
| layout="wide", | |
| initial_sidebar_state="collapsed", | |
| ) | |
| # A3-R5D: default-off, benchmark-only startup probe; never blocks the UI. | |
| try: | |
| from core.a3_glm_live_probe import run_startup_probe_if_enabled | |
| run_startup_probe_if_enabled() | |
| except Exception as _a3_probe_exc: | |
| logging.error("[A3_R5D_GLM_PROBE] bootstrap_failed error_class=%s", _a3_probe_exc.__class__.__name__) | |
| # A3-R5H: default-off Gemini Free-Tier startup probe; never blocks the UI. | |
| try: | |
| from core.a3_gemini_live_probe import run_startup_probe_if_enabled as run_gemini_startup_probe_if_enabled | |
| run_gemini_startup_probe_if_enabled() | |
| except Exception as _a3_gemini_probe_exc: | |
| logging.error("[A3_R5H_GEMINI_PROBE] bootstrap_failed error_class=%s", _a3_gemini_probe_exc.__class__.__name__) | |
| WORKSPACE_DIR = APP_CONFIG.get("workspace_dir", ".workspace") | |
| os.makedirs(WORKSPACE_DIR, exist_ok=True) | |
| # The display-only preview cache must exist from the first Streamlit script run. | |
| # Runtime preview files remain ephemeral and carry no task/execution authority. | |
| (Path(__file__).resolve().parent / "static" / "previews").mkdir(parents=True, exist_ok=True) | |
| os.environ["STREAMLIT_SERVER_ENABLE_CORS"] = "false" | |
| os.environ["STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION"] = "false" | |
| WECHAT_BLOCKER_JS = """<script>try{var ua=navigator.userAgent.toLowerCase();if(ua.indexOf('micromessenger')!==-1){var parentDoc=window.parent.document;if(!parentDoc.getElementById('wx-blocker')){var overlay=parentDoc.createElement('div');overlay.id='wx-blocker';overlay.style.cssText='position:fixed;top:0;left:0;width:100vw;height:100vh;background:#1a365d;z-index:9999999;color:white;display:flex;flex-direction:column;align-items:center;justify-content:center;text-align:center;font-family:sans-serif;padding:30px;box-sizing:border-box;';overlay.innerHTML='<h2 style="font-size:26px;margin-bottom:15px;font-weight:bold;">环境受限 / Restricted</h2><p style="font-size:18px;line-height:1.6;color:#e2e8f0;max-width:100%;">为了保障最终双语 ZIP 压缩包正常下载，<b>本系统禁止在微信内直接运行</b>。<br><br>👉 <b>请点击右上角 [···] 菜单，选择“在浏览器打开” (Open in Browser)</b></p>';parentDoc.body.appendChild(overlay);}}}catch(e){}</script>""" | |
| components.html(WECHAT_BLOCKER_JS, height=0, width=0) | |
| def inject_file_uploader_i18n(language: str) -> None: | |
| """Localize uploaders by semantic label, never by visual/tab position.""" | |
| payload = { | |
| "browse": tr(language, "browse_files"), | |
| "uploaders": { | |
| tr(language, "upload_reference"): { | |
| "title": tr(language, "drop_docs"), | |
| "limit": tr(language, "limit_docs"), | |
| }, | |
| tr(language, "upload_interviews"): { | |
| "title": tr(language, "drop_interviews"), | |
| "limit": tr(language, "limit_interviews"), | |
| }, | |
| tr(language, "upload_stats"): { | |
| "title": tr(language, "drop_data"), | |
| "limit": tr(language, "limit_data"), | |
| }, | |
| }, | |
| } | |
| script = f""" | |
| <script> | |
| (() => {{ | |
| const payload = {json.dumps(payload, ensure_ascii=False)}; | |
| const parentDocument = window.parent.document; | |
| function leafTextElements(root) {{ | |
| return Array.from( | |
| root.querySelectorAll("p, span, small, div") | |
| ).filter((element) => ( | |
| element.children.length === 0 && | |
| element.textContent.trim().length > 0 | |
| )); | |
| }} | |
| function replaceTextSafely(element, value) {{ | |
| if (element && element.textContent.trim() !== value) {{ | |
| element.textContent = value; | |
| }} | |
| }} | |
| function semanticUploaderConfig(uploader) {{ | |
| const label = uploader.querySelector('label'); | |
| const labelText = (label ? label.textContent : '').trim(); | |
| return payload.uploaders[labelText] || null; | |
| }} | |
| function applyUploaderTranslations() {{ | |
| const uploaders = parentDocument.querySelectorAll( | |
| '[data-testid="stFileUploader"]' | |
| ); | |
| uploaders.forEach((uploader) => {{ | |
| const config = semanticUploaderConfig(uploader); | |
| if (!config) return; | |
| const zone = uploader.querySelector('[data-testid="stFileUploaderDropzone"]'); | |
| if (!zone) return; | |
| const instructions = zone.querySelector( | |
| '[data-testid="stFileUploaderDropzoneInstructions"]' | |
| ); | |
| if (instructions) {{ | |
| const leaves = leafTextElements(instructions); | |
| replaceTextSafely(leaves[0], config.title); | |
| replaceTextSafely(leaves[1], config.limit); | |
| }} | |
| const button = zone.querySelector("button"); | |
| if (button) {{ | |
| const buttonLeaves = leafTextElements(button); | |
| const textTarget = buttonLeaves[buttonLeaves.length - 1]; | |
| replaceTextSafely(textTarget, payload.browse); | |
| button.setAttribute("aria-label", payload.browse); | |
| button.setAttribute("title", payload.browse); | |
| }} | |
| }}); | |
| }} | |
| [0, 100, 300, 700, 1400, 2500].forEach((delay) => {{ | |
| window.setTimeout(applyUploaderTranslations, delay); | |
| }}); | |
| }})(); | |
| </script> | |
| """ | |
| components.html(script, height=0, width=0) | |
| def inject_wechat_browser_notice() -> None: | |
| """Warn immediately when SmartPaper is opened inside WeChat or WeCom.""" | |
| script = """ | |
| <script> | |
| (() => { | |
| const parentWindow = window.parent; | |
| const parentDocument = parentWindow.document; | |
| const userAgent = String( | |
| parentWindow.navigator.userAgent || navigator.userAgent || "" | |
| ); | |
| const isWechat = | |
| /MicroMessenger|WeChat|wxwork/i.test(userAgent); | |
| const noticeId = "smartpaper-wechat-browser-notice"; | |
| const existingNotice = parentDocument.getElementById(noticeId); | |
| if (!isWechat) { | |
| if (existingNotice) existingNotice.remove(); | |
| return; | |
| } | |
| if (existingNotice) return; | |
| const overlay = parentDocument.createElement("div"); | |
| overlay.id = noticeId; | |
| overlay.style.cssText = [ | |
| "position:fixed", | |
| "inset:0", | |
| "z-index:2147483647", | |
| "display:flex", | |
| "align-items:center", | |
| "justify-content:center", | |
| "padding:24px", | |
| "background:rgba(8,12,20,.96)", | |
| "box-sizing:border-box" | |
| ].join(";"); | |
| const card = parentDocument.createElement("div"); | |
| card.style.cssText = [ | |
| "width:min(620px,100%)", | |
| "padding:30px", | |
| "border:1px solid rgba(148,163,184,.35)", | |
| "border-radius:18px", | |
| "background:#111827", | |
| "color:#f8fafc", | |
| "font-family:Arial,'Microsoft YaHei','PingFang SC',sans-serif", | |
| "line-height:1.7", | |
| "box-shadow:0 20px 50px rgba(0,0,0,.38)" | |
| ].join(";"); | |
| const title = parentDocument.createElement("h2"); | |
| title.textContent = "请在浏览器中打开 / Open in Browser"; | |
| title.style.cssText = | |
| "margin:0 0 14px;font-size:24px;color:#ffffff;"; | |
| const chinese = parentDocument.createElement("p"); | |
| chinese.textContent = | |
| "微信内置页面可能无法正常完成登录和文件操作。请点击右上角“…”并选择“在浏览器打开”。"; | |
| chinese.style.cssText = "margin:0 0 12px;font-size:16px;"; | |
| const english = parentDocument.createElement("p"); | |
| english.textContent = | |
| "The WeChat in-app page may not complete sign-in or file operations correctly. Tap “…” in the top-right corner and choose “Open in Browser.”"; | |
| english.style.cssText = | |
| "margin:0 0 20px;font-size:15px;color:#cbd5e1;"; | |
| const copyButton = parentDocument.createElement("button"); | |
| copyButton.type = "button"; | |
| copyButton.textContent = "复制网址 / Copy link"; | |
| copyButton.style.cssText = [ | |
| "width:100%", | |
| "padding:12px 16px", | |
| "border:0", | |
| "border-radius:10px", | |
| "background:#1677ff", | |
| "color:#ffffff", | |
| "font-size:16px", | |
| "font-weight:700", | |
| "cursor:pointer" | |
| ].join(";"); | |
| copyButton.addEventListener("click", async () => { | |
| const url = parentWindow.location.href; | |
| try { | |
| await parentWindow.navigator.clipboard.writeText(url); | |
| copyButton.textContent = "已复制 / Copied"; | |
| } catch (_) { | |
| const textarea = parentDocument.createElement("textarea"); | |
| textarea.value = url; | |
| textarea.style.position = "fixed"; | |
| textarea.style.opacity = "0"; | |
| parentDocument.body.appendChild(textarea); | |
| textarea.focus(); | |
| textarea.select(); | |
| parentDocument.execCommand("copy"); | |
| textarea.remove(); | |
| copyButton.textContent = "已复制 / Copied"; | |
| } | |
| parentWindow.setTimeout(() => { | |
| copyButton.textContent = "复制网址 / Copy link"; | |
| }, 1800); | |
| }); | |
| card.appendChild(title); | |
| card.appendChild(chinese); | |
| card.appendChild(english); | |
| card.appendChild(copyButton); | |
| overlay.appendChild(card); | |
| parentDocument.body.appendChild(overlay); | |
| })(); | |
| </script> | |
| """ | |
| components.html(script, height=0, width=0) | |
| for key, default in { | |
| "is_running": False, | |
| "zip_buffer": None, | |
| "zip_filename": "", | |
| "run_mode": "asq", | |
| "sp_generation_task": None, | |
| "sp_pending_launch": None, | |
| "sp_pending_resume_task_id": "", | |
| "sp_pending_cancel_task_id": "", | |
| "sp_payment_required": False, | |
| "sp_terminal_notice": None, | |
| "sp_task_recovery_initialized": False, | |
| "sp_last_ui_task_status": "", | |
| "sp_scroll_to_generation_action": False, | |
| "sp_completed_download_scroll_task_id": "", | |
| }.items(): | |
| if key not in st.session_state: | |
| st.session_state[key] = default | |
| def _safe_key(value: str) -> str: | |
| cleaned = re.sub(r"[^A-Za-z0-9_.-]", "_", str(value or "").strip()) | |
| return cleaned[:100] or "anonymous" | |
| def _new_generation_idempotency_key() -> str: | |
| return f"gen_{int(time.time() * 1000)}_{secrets.token_urlsafe(18)}" | |
| def _atomic_json(path: Path, value: dict) -> None: | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| temporary = path.with_suffix(path.suffix + ".tmp") | |
| temporary.write_text(json.dumps(value, ensure_ascii=False), encoding="utf-8") | |
| os.replace(temporary, path) | |
| def _canonical_request_hash(value: dict) -> str: | |
| material = dict(value or {}) | |
| material.pop("request_hash", None) | |
| encoded = json.dumps(material, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8") | |
| return hashlib.sha256(encoded).hexdigest() | |
| def _task_dir(task_id: str) -> Path: | |
| return Path(_user_workspace) / "tasks" / _safe_key(task_id) | |
| def _local_resume_capability(task: dict) -> tuple[bool, str]: | |
| """Return whether this HF runtime has the local material required to resume. | |
| Worker/D1 remains authoritative for the remote task state. This function | |
| answers only the local capability question and never changes task/quota | |
| state. | |
| """ | |
| task = dict(task or {}) | |
| task_id = str(task.get("task_id") or "").strip() | |
| if not task_id: | |
| return False, "task_id_missing" | |
| task_dir = _task_dir(task_id) | |
| request_path = task_dir / "request.json" | |
| if not request_path.is_file(): | |
| return False, "request_missing" | |
| try: | |
| request_payload = json.loads(request_path.read_text(encoding="utf-8")) | |
| except Exception: | |
| return False, "request_unreadable" | |
| if not isinstance(request_payload, dict): | |
| return False, "request_invalid" | |
| if str(request_payload.get("task_id") or "").strip() != task_id: | |
| return False, "request_task_mismatch" | |
| request_hash = str(request_payload.get("request_hash") or "").strip().lower() | |
| if not re.fullmatch(r"[a-f0-9]{64}", request_hash): | |
| return False, "request_hash_invalid" | |
| if request_hash != _canonical_request_hash(request_payload): | |
| return False, "request_hash_mismatch" | |
| task_root = task_dir.resolve() | |
| for field in ("reference_files", "data_files", "interview_files"): | |
| items = request_payload.get(field) or [] | |
| if not isinstance(items, list): | |
| return False, f"{field}_invalid" | |
| for item in items: | |
| local_path = (task_dir / str(item)).resolve() | |
| if task_root not in local_path.parents or not local_path.is_file(): | |
| return False, "input_missing" | |
| try: | |
| checkpoint_seq = int(task.get("checkpoint_seq") or 0) | |
| except (TypeError, ValueError): | |
| return False, "checkpoint_seq_invalid" | |
| if checkpoint_seq <= 0: | |
| return True, "ready" | |
| expected_stage = str(task.get("checkpoint_stage") or "").strip() | |
| try: | |
| candidates = sorted((task_dir / "checkpoints").glob(f"checkpoint_{checkpoint_seq:05d}_*.json")) | |
| except Exception: | |
| candidates = [] | |
| for candidate in candidates: | |
| try: | |
| payload = json.loads(candidate.read_text(encoding="utf-8")) | |
| if not isinstance(payload, dict): | |
| continue | |
| if str(payload.get("request_hash") or "").strip().lower() != request_hash: | |
| continue | |
| if int(payload.get("checkpoint_seq") or 0) != checkpoint_seq: | |
| continue | |
| if expected_stage and str(payload.get("checkpoint_stage") or "").strip() != expected_stage: | |
| continue | |
| return True, "ready" | |
| except Exception: | |
| continue | |
| return False, "checkpoint_missing" | |
| def _task_preview_path(task_id: str) -> str: | |
| """Return the unguessable local static preview URL for this task, if any.""" | |
| request_path = _task_dir(task_id) / "request.json" | |
| if not request_path.is_file(): | |
| return "" | |
| try: | |
| payload = json.loads(request_path.read_text(encoding="utf-8")) | |
| token = str(payload.get("preview_token") or "").strip() | |
| if not re.fullmatch(r"[A-Za-z0-9_-]{32,128}", token): | |
| return "" | |
| return f"/app/static/previews/{token}.json" | |
| except Exception: | |
| return "" | |
| def _cleanup_task_artifacts(task_id: str) -> None: | |
| """Delete local stage artifacts only after authoritative cancellation.""" | |
| task_dir = _task_dir(task_id) | |
| token = "" | |
| request_path = task_dir / "request.json" | |
| if request_path.is_file(): | |
| try: | |
| payload = json.loads(request_path.read_text(encoding="utf-8")) | |
| token = str(payload.get("preview_token") or "").strip() | |
| except Exception: | |
| token = "" | |
| if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", token): | |
| try: | |
| (Path(__file__).resolve().parent / "static" / "previews" / f"{token}.json").unlink(missing_ok=True) | |
| except Exception as exc: | |
| logging.warning("[SP_UI] cancel_preview_cleanup_error task_id=%s error=%s", task_id, type(exc).__name__) | |
| shutil.rmtree(task_dir, ignore_errors=True) | |
| def _task_mode(task: dict) -> str: | |
| mode = str((task or {}).get("mode") or st.session_state.get("run_mode") or "asq").strip().lower() | |
| return "amj" if mode == "amj" else "asq" | |
| def _task_output_path(task: dict) -> Path | None: | |
| task_id = str(task.get("task_id") or "").strip() | |
| filename = os.path.basename(str(task.get("output_filename") or "").strip()) | |
| if not task_id or not filename: | |
| return None | |
| return _task_dir(task_id) / "outputs" / filename | |
| def _save_uploaded(items, inputs_dir: Path, prefix: str) -> list[str]: | |
| saved = [] | |
| for index, item in enumerate(items or []): | |
| if item is None: | |
| continue | |
| original = os.path.basename(str(getattr(item, "name", f"input_{index}"))) | |
| safe_name = re.sub(r"[^A-Za-z0-9_.-]", "_", original)[:140] or f"input_{index}" | |
| filename = f"{prefix}_{index:02d}_{safe_name}" | |
| path = inputs_dir / filename | |
| data = item.getvalue() if hasattr(item, "getvalue") else item.read() | |
| path.write_bytes(bytes(data or b"")) | |
| saved.append(str(Path("inputs") / filename)) | |
| try: | |
| item.seek(0) | |
| except Exception: | |
| pass | |
| return saved | |
| def _persist_task_request(task: dict, mode: str, lang_code: str) -> dict: | |
| task_id = str(task.get("task_id") or "").strip() | |
| numeric_id = (st.session_state.get("sp_user") or {}).get("numeric_id") | |
| if not task_id or not isinstance(numeric_id, int) or numeric_id <= 0: | |
| raise RuntimeError("task_identity_missing") | |
| task_dir = _task_dir(task_id) | |
| inputs_dir = task_dir / "inputs" | |
| inputs_dir.mkdir(parents=True, exist_ok=True) | |
| if mode == "amj": | |
| refs = _save_uploaded(st.session_state.get("up_amj_ref") or [], inputs_dir, "ref") | |
| data = _save_uploaded([st.session_state.get("up_amj_data")], inputs_dir, "data") | |
| interviews = [] | |
| else: | |
| refs = _save_uploaded(st.session_state.get("up_asq_ref") or [], inputs_dir, "ref") | |
| data = [] | |
| interviews = _save_uploaded([st.session_state.get("up_asq_data")], inputs_dir, "interview") | |
| request_data = { | |
| "task_id": task_id, | |
| "user_id": numeric_id, | |
| "mode": mode, | |
| "interface_language": lang_code, | |
| "target_lang": get_target_language(lang_code), | |
| "output_suffix": get_output_suffix(lang_code), | |
| "topic": str(st.session_state.get("sp_topic") or DEFAULT_TOPIC), | |
| "keywords": str(st.session_state.get("sp_keywords") or DEFAULT_KEYWORDS), | |
| "target_words": int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]), | |
| # High-entropy, display-only token. It is part of the immutable task | |
| # request/hash, but it grants no Worker/D1 authority. | |
| "preview_token": secrets.token_urlsafe(32), | |
| "reference_files": refs, | |
| "data_files": data, | |
| "interview_files": interviews, | |
| "created_at": datetime.now(timezone.utc).isoformat(), | |
| } | |
| request_data["request_hash"] = _canonical_request_hash(request_data) | |
| _atomic_json(task_dir / "request.json", request_data) | |
| return request_data | |
| def _pid_alive(pid: int) -> bool: | |
| if not isinstance(pid, int) or pid <= 0: | |
| return False | |
| try: | |
| os.kill(pid, 0) | |
| return True | |
| except OSError: | |
| return False | |
| def _pid_is_task_executor(pid: int, task_id: str, task_dir: Path) -> bool: | |
| """Best-effort Linux identity check before trusting/killing a launch PID. | |
| Hugging Face Spaces run on Linux. A stale PID can be reused, so a bare | |
| ``os.kill(pid, 0)`` is never enough to identify our executor. | |
| """ | |
| if not _pid_alive(pid): | |
| return False | |
| try: | |
| raw = (Path("/proc") / str(pid) / "cmdline").read_bytes() | |
| command = raw.replace(b"\x00", b" ").decode("utf-8", errors="ignore") | |
| except Exception: | |
| return False | |
| return ( | |
| "task_executor.py" in command | |
| and f"--task-id {task_id}" in command | |
| and str(task_dir.resolve()) in command | |
| ) | |
| def _launch_executor(task_id: str, *, force: bool = False) -> int: | |
| """Start a detached executor without making Streamlit its lifecycle owner. | |
| ``subprocess.Popen`` only proves that the OS accepted the child process. | |
| R3.2 therefore records the PID and returns immediately. The executor owns | |
| claim/heartbeat/checkpoint/finalization; Worker/D1 owns task authority and | |
| startup-lease expiry. Streamlit never waits for claim and never terminates | |
| an executor because a UI-side timer expired. | |
| """ | |
| task_dir = _task_dir(task_id) | |
| request_path = task_dir / "request.json" | |
| if not request_path.is_file(): | |
| raise RuntimeError("task_request_manifest_missing") | |
| request_data = json.loads(request_path.read_text(encoding="utf-8")) | |
| numeric_id = int(request_data.get("user_id") or 0) | |
| request_hash = str(request_data.get("request_hash") or "").strip() | |
| if numeric_id <= 0 or not request_hash: | |
| raise RuntimeError("task_request_identity_invalid") | |
| launch_marker_path = task_dir / "executor_launch.json" | |
| claim_marker_path = task_dir / "executor_claim.json" | |
| if launch_marker_path.is_file(): | |
| try: | |
| marker = json.loads(launch_marker_path.read_text(encoding="utf-8")) | |
| pid = int(marker.get("pid") or 0) | |
| if _pid_is_task_executor(pid, task_id, task_dir) and not force: | |
| logging.info("[SP_UI] executor_already_spawned task_id=%s pid=%s", task_id, pid) | |
| return pid | |
| except Exception: | |
| pass | |
| # A stale local claim marker can never establish ownership for a new | |
| # launch/resume. Epoch fencing in Worker/D1, not process termination here, | |
| # prevents an older executor from overwriting a newer epoch. | |
| try: | |
| claim_marker_path.unlink(missing_ok=True) | |
| except TypeError: | |
| if claim_marker_path.exists(): | |
| claim_marker_path.unlink() | |
| log_path = task_dir / "executor.log" | |
| task_dir.mkdir(parents=True, exist_ok=True) | |
| command = [ | |
| sys.executable, | |
| str(Path(__file__).resolve().parent / "task_executor.py"), | |
| "--task-dir", str(task_dir.resolve()), | |
| "--task-id", str(task_id), | |
| "--user-id", str(numeric_id), | |
| ] | |
| executor_env = os.environ.copy() | |
| executor_env["SMARTPAPER_EXECUTOR_LOG_PATH"] = str(log_path.resolve()) | |
| process = subprocess.Popen( | |
| command, | |
| cwd=str(Path(__file__).resolve().parent), | |
| stdin=subprocess.DEVNULL, | |
| # Inherit stdout/stderr so executor bootstrap/errors are visible in HF | |
| # Container Logs; task_executor also writes the same log to executor.log. | |
| close_fds=True, | |
| start_new_session=True, | |
| env=executor_env, | |
| ) | |
| _atomic_json( | |
| launch_marker_path, | |
| { | |
| "pid": process.pid, | |
| "task_id": str(task_id), | |
| "request_hash": request_hash, | |
| "launched_at": datetime.now(timezone.utc).isoformat(), | |
| }, | |
| ) | |
| logging.info("[SP_UI] executor_spawned task_id=%s pid=%s", task_id, process.pid) | |
| return int(process.pid) | |
| def _process_pending_cancel() -> None: | |
| task_id = str(st.session_state.get("sp_pending_cancel_task_id") or "").strip() | |
| if not task_id: | |
| return | |
| result = cancel_generation_task(task_id) | |
| if result.get("cancelled"): | |
| _cleanup_task_artifacts(task_id) | |
| st.session_state["sp_pending_cancel_task_id"] = "" | |
| st.session_state["sp_generation_task"] = dict(result.get("task") or {}) or None | |
| st.rerun() | |
| def _process_pending_resume() -> None: | |
| task_id = str(st.session_state.get("sp_pending_resume_task_id") or "").strip() | |
| if not task_id: | |
| return | |
| task = dict(st.session_state.get("sp_generation_task") or {}) | |
| capable, reason = _local_resume_capability(task) | |
| if str(task.get("task_id") or "").strip() != task_id or not capable: | |
| logging.warning("[SP_UI] resume_unavailable task_id=%s reason=%s", task_id, reason) | |
| st.session_state["sp_pending_resume_task_id"] = "" | |
| lang_code = str(st.session_state.get("sp_lang_code") or "zh") | |
| st.session_state["sp_terminal_notice"] = { | |
| "kind": "warning", | |
| "message": tr(lang_code, "resume_unavailable_runtime_replaced"), | |
| } | |
| st.rerun() | |
| _launch_executor(task_id, force=True) | |
| st.session_state["sp_pending_resume_task_id"] = "" | |
| st.session_state["sp_scroll_to_generation_action"] = True | |
| st.rerun() | |
| def _process_pending_launch(lang_code: str) -> None: | |
| pending = st.session_state.get("sp_pending_launch") | |
| if not isinstance(pending, dict): | |
| return | |
| mode = str(pending.get("mode") or "").strip().lower() | |
| idempotency_key = str(pending.get("idempotency_key") or "").strip() | |
| projection = get_product_ui_projection() | |
| selected_product_tier = ( | |
| str(st.session_state.get("sp_product_tier") or "").strip().upper() | |
| if projection.get("mode") == "a5_product" | |
| else None | |
| ) | |
| try: | |
| response = start_generation_task( | |
| idempotency_key=idempotency_key, | |
| mode=mode, | |
| interface_language=lang_code, | |
| target_words=int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]), | |
| product_tier=selected_product_tier, | |
| ) | |
| except Exception as exc: | |
| st.session_state["sp_pending_launch"] = None | |
| raw = str(exc or "") | |
| if "payment_required" in raw: | |
| st.session_state["sp_payment_required"] = True | |
| st.error(tr(lang_code, "quota_exhausted")) | |
| render_payment_purchase(lang_code) | |
| elif "a5_product_task_path_not_authorized" in raw: | |
| st.error(tr(lang_code, "product_generation_not_active")) | |
| else: | |
| st.error(raw) | |
| return | |
| task = dict(response.get("task") or {}) | |
| task_id = str(task.get("task_id") or "").strip() | |
| if not task_id: | |
| st.session_state["sp_pending_launch"] = None | |
| st.error("task_start_missing_task_id") | |
| return | |
| st.session_state["sp_generation_task"] = task | |
| st.session_state["sp_last_ui_task_status"] = str(task.get("status") or "") | |
| try: | |
| request_path = _task_dir(task_id) / "request.json" | |
| if not request_path.is_file(): | |
| _persist_task_request(task, mode, lang_code) | |
| _launch_executor(task_id) | |
| except Exception as exc: | |
| st.session_state["sp_pending_launch"] = None | |
| st.session_state["sp_pending_cancel_task_id"] = task_id | |
| st.session_state["sp_terminal_notice"] = {"kind": "error", "message": str(exc)[:800]} | |
| st.rerun() | |
| st.session_state["sp_pending_launch"] = None | |
| st.session_state["sp_payment_required"] = False | |
| st.session_state["sp_scroll_to_generation_action"] = True | |
| st.rerun() | |
| inject_wechat_browser_notice() | |
| DEFAULT_TOPIC = "Generative Artificial Intelligence in Ubiquitous Learning: Evaluating a Chatbot-based Recommendation Engine for Personalized and Context-aware Education" | |
| DEFAULT_KEYWORDS = "Ubiquitous computing; Context awareness; Deep learning; Personalized educational; Educational technologies; HCI; Recommendation system; LLMs; Generative AI; ChatGPT; Prompting engineering; Few-shot prompting" | |
| def _current_language_code() -> str: | |
| choice = st.session_state.get("interface_language_choice") | |
| return LANGUAGE_OPTIONS.get(choice, "zh") | |
| authenticated_user = require_alipay_login(_current_language_code()) | |
| if not bool(st.session_state.get("sp_task_recovery_initialized")): | |
| recover_generation_task() | |
| st.session_state["sp_task_recovery_initialized"] = True | |
| _recovered_task = st.session_state.get("sp_generation_task") or {} | |
| _recovered_mode = str((_recovered_task or {}).get("mode") or "").strip().lower() | |
| if _recovered_mode in {"amj", "asq"}: | |
| # The task record, not the first visual tab, owns the research mode after refresh. | |
| st.session_state["run_mode"] = _recovered_mode | |
| _user_workspace = os.path.join(WORKSPACE_DIR, "users", _safe_key(authenticated_user.get("id"))) | |
| os.makedirs(_user_workspace, exist_ok=True) | |
| ACTIVE_TASK_STATUSES = {"created", "running", "resumable", "cancelling"} | |
| LIVE_TASK_STATUSES = {"created", "running", "cancelling"} | |
| def _localized_task_status(lang_code: str, status: str) -> str: | |
| key = f"task_status_{str(status or '').strip().lower()}" | |
| value = tr(lang_code, key) | |
| return value if value != key else tr(lang_code, "draft_stage_processing") | |
| def _localized_monitor_node(lang_code: str, node: str) -> str: | |
| """Translate stable executor progress codes without exposing engineering identifiers.""" | |
| value = str(node or "").strip() | |
| exact = { | |
| "inputs_and_evidence": "draft_stage_inputs", | |
| "S2 + OpenAlex": "draft_stage_search", | |
| "literature_synthesis": "draft_stage_synthesis", | |
| "research_logic": "draft_stage_research_logic", | |
| "working_front_matter": "draft_stage_working_front", | |
| "outline_planning": "draft_stage_outline", | |
| "citation_planning": "draft_stage_citation", | |
| "english_validation": "draft_stage_english_validation", | |
| "final_front_matter": "draft_stage_final_front", | |
| "translation": "draft_stage_translation", | |
| "translation_complete": "translation_complete_label", | |
| "packaging": "draft_stage_packaging", | |
| "package_validation": "draft_stage_package_validation", | |
| "package_validated": "draft_stage_package_validated", | |
| } | |
| if value in exact: | |
| return tr(lang_code, exact[value]) | |
| for prefix, key in ( | |
| ("writing:", "draft_stage_writing_unit"), | |
| ("citation_audit:", "draft_stage_citation_audit_unit"), | |
| ("citation_recovery:", "draft_stage_citation_recovery_unit"), | |
| ("writing_complete:", "draft_stage_writing_complete_unit"), | |
| ("translation_final_gate:", "draft_stage_translation"), | |
| ): | |
| if value.startswith(prefix): | |
| parts = value[len(prefix):].split(":") | |
| if key == "draft_stage_translation": | |
| return tr(lang_code, key) | |
| if len(parts) >= 2: | |
| return tr(lang_code, key, current=parts[0], total=parts[1]) | |
| return tr(lang_code, "draft_stage_processing") | |
| if value.startswith("translation_"): | |
| return tr(lang_code, "draft_stage_translation") | |
| if value.startswith("section_"): | |
| return tr(lang_code, "draft_stage_writing") | |
| return tr(lang_code, "draft_stage_processing") | |
| def _markdown_safe_html(markup: str) -> str: | |
| """Prevent Streamlit Markdown from reclassifying indented HTML as code. | |
| Only indentation before actual HTML tags is removed. Text rendered inside | |
| preview containers keeps its own leading whitespace. | |
| """ | |
| lines = [] | |
| for line in textwrap.dedent(str(markup or "")).strip().splitlines(): | |
| stripped = line.lstrip() | |
| lines.append(stripped if stripped.startswith("<") else line) | |
| return "\n".join(lines) | |
| def _render_monitor_box(task: dict, lang_code: str) -> None: | |
| """Render the approved monitor location with DOM targets for live updates.""" | |
| status = str(task.get("status") or "") | |
| node = str(task.get("current_node") or status or "") | |
| status_label = _localized_task_status(lang_code, status) | |
| node_label = _localized_monitor_node(lang_code, node) | |
| progress = max(0, min(100, int(task.get("progress_pct") or 0))) | |
| checkpoint_seq = int(task.get("checkpoint_seq") or 0) | |
| checkpoint_stage = str(task.get("checkpoint_stage") or "") | |
| ds_calls = int(task.get("ds_calls") or 0) | |
| s2_calls = int(task.get("s2_calls") or 0) | |
| oa_calls = int(task.get("oa_calls") or 0) | |
| progress_markup = "" | |
| if status in ACTIVE_TASK_STATUSES: | |
| progress_markup = textwrap.dedent(f""" | |
| <div id='sp-live-progress-wrap' style='margin:0 0 12px 0;'> | |
| <div id='sp-live-progress-text' style='margin-bottom:7px;'>{progress}% — {html.escape(node_label)}</div> | |
| <div style='width:100%;height:10px;background:rgba(128,128,128,.24);border-radius:999px;overflow:hidden;'> | |
| <div id='sp-live-progress-fill' style='width:{progress}%;height:100%;background:currentColor;border-radius:999px;transition:width .35s ease;'></div> | |
| </div> | |
| </div> | |
| """).strip() | |
| st.markdown(_markdown_safe_html(f""" | |
| <div class='log-box' id='sp-live-monitor'> | |
| {progress_markup} | |
| <div><b>{tr(lang_code, 'monitor_pipeline')}:</b> <span id='sp-live-status'>{html.escape(status_label)}</span></div> | |
| <div><b>{tr(lang_code, 'monitor_node')}:</b> <span id='sp-live-node'>{html.escape(node_label)}</span></div> | |
| <div><b>{tr(lang_code, 'monitor_log')}:</b> <span id='sp-live-checkpoint-stage'>{html.escape(tr(lang_code, 'monitor_checkpoint_saved', seq=checkpoint_seq))}</span><span id='sp-live-checkpoint-seq' style='display:none'>{checkpoint_seq}</span></div> | |
| <div id='sp-live-evidence-warning' style='display:none;margin:8px 0;padding:8px 10px;border-radius:6px;background:rgba(245,158,11,.13);'></div> | |
| <div id='sp-live-activity-feed' style='margin:8px 0 10px 0;max-height:150px;overflow:auto;line-height:1.55;'> | |
| <div>• {html.escape(node_label)}</div> | |
| </div><hr> | |
| <div><b>{tr(lang_code, 'monitor_compute')}:</b></div> | |
| <div style='display:flex;gap:8px;'> | |
| <span style='background: #fef3c7;padding:4px 8px;border-radius:4px;color:black;'>🧠 DeepSeek: <b id='sp-live-ds'>{ds_calls}</b></span> | |
| <span style='background: #dbeafe;padding:4px 8px;border-radius:4px;color:black;'>📚 S2: <b id='sp-live-s2'>{s2_calls}</b></span> | |
| <span style='background: #d1fae5;padding:4px 8px;border-radius:4px;color:black;'>🌐 OpenAlex: <b id='sp-live-oa'>{oa_calls}</b></span> | |
| </div> | |
| </div> | |
| """), unsafe_allow_html=True) | |
| def _watch_task_status_live(task: dict) -> dict | None: | |
| """Start browser-only read polling for live UI state. | |
| DOM updates remain read-only and never participate in task liveness. | |
| During execution, progress and manuscript preview updates stay entirely in | |
| the browser; Streamlit is notified only once at terminal/resumable state. | |
| This prevents checkpoint-driven full-page reruns and visible flicker. | |
| """ | |
| task_id = str(task.get("task_id") or "").strip() | |
| status = str(task.get("status") or "") | |
| if not task_id or status not in LIVE_TASK_STATUSES: | |
| return None | |
| api_origin = str(st.session_state.get("sp_auth_api_origin") or "").strip() | |
| if not api_origin: | |
| logging.warning("[SP_UI] live_watch_missing_api_origin task_id=%s", task_id) | |
| return None | |
| expected_request_hash = str(task.get("request_hash") or "").strip().lower() | |
| if not expected_request_hash: | |
| try: | |
| request_path = _task_dir(task_id) / "request.json" | |
| if request_path.is_file(): | |
| expected_request_hash = str(json.loads(request_path.read_text(encoding="utf-8")).get("request_hash") or "").strip().lower() | |
| except Exception: | |
| expected_request_hash = "" | |
| try: | |
| watch_result = edge_bridge( | |
| action="task_watch", | |
| command_id=f"watch:{task_id}", | |
| api_origin=api_origin, | |
| payload={ | |
| "task_id": task_id, | |
| "poll_interval_ms": 2000, | |
| "preview_interval_ms": 700, | |
| "preview_path": _task_preview_path(task_id), | |
| "expected_execution_epoch": int(task.get("execution_epoch") or 0), | |
| "expected_request_hash": expected_request_hash, | |
| "initial_checkpoint_seq": int(task.get("checkpoint_seq") or 0), | |
| "best_effort_page_exit_cancel": False, | |
| "draft_status_labels": { | |
| "default": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_preparing"), | |
| "inputs_and_evidence": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_inputs"), | |
| "S2 + OpenAlex": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_search"), | |
| "literature_synthesis": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_synthesis"), | |
| "research_logic": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_research_logic"), | |
| "outline_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_outline"), | |
| "citation_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation"), | |
| "writing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing"), | |
| "working_front_matter": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_working_front"), | |
| "writing_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing_unit"), | |
| "citation_audit_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation_audit_unit"), | |
| "citation_recovery_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation_recovery_unit"), | |
| "writing_complete_unit": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing_complete_unit"), | |
| "english_validation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_english_validation"), | |
| "final_front_matter": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_final_front"), | |
| "translation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_translation"), | |
| "packaging": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_packaging"), | |
| "package_validation": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_package_validation"), | |
| "package_validated": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_package_validated"), | |
| "processing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_processing"), | |
| "checkpoint_saved": tr(str(st.session_state.get("sp_lang_code") or "zh"), "monitor_checkpoint_saved"), | |
| "status_created": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_created"), | |
| "status_running": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_running"), | |
| "status_resumable": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_resumable"), | |
| "status_cancelling": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_cancelling"), | |
| "status_completed": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_completed"), | |
| "status_failed": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_failed"), | |
| "status_cancelled": tr(str(st.session_state.get("sp_lang_code") or "zh"), "task_status_cancelled"), | |
| "evidence_limited": tr(str(st.session_state.get("sp_lang_code") or "zh"), "evidence_limited_running"), | |
| "progress": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_progress"), | |
| "s2": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_s2"), | |
| "oa": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_oa"), | |
| "current": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_detail_current"), | |
| }, | |
| "target_status_labels": { | |
| "waiting": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_waiting"), | |
| "translating": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_running"), | |
| "qa": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_qa"), | |
| "final_gate": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_final_gate"), | |
| "repairing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_repairing"), | |
| "repair_pending": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_repair_pending"), | |
| "adjudicating": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_adjudicating"), | |
| "counts": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_progress_counts"), | |
| "ready": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_section_ready"), | |
| "complete": tr(str(st.session_state.get("sp_lang_code") or "zh"), "translation_complete_label"), | |
| }, | |
| }, | |
| key=f"sp_task_watch_{_safe_key(task_id)}", | |
| ) | |
| boundary_task = watch_result.get("task") if isinstance(watch_result, dict) and watch_result.get("boundary") else None | |
| if isinstance(watch_result, dict) and watch_result.get("boundary"): | |
| navdiag = watch_result.get("ui_navdiag") | |
| if isinstance(navdiag, dict): | |
| try: | |
| safe_diag = json.dumps(navdiag, ensure_ascii=False, separators=(",", ":"))[:4000] | |
| logging.info("[SP_UI_NAVDIAG] task_id=%s snapshot=%s", task_id, safe_diag) | |
| except Exception: | |
| logging.info("[SP_UI_NAVDIAG] task_id=%s snapshot_unserializable", task_id) | |
| if isinstance(boundary_task, dict) and str(boundary_task.get("task_id") or "") == task_id: | |
| st.session_state["sp_generation_task"] = dict(boundary_task) | |
| st.session_state["sp_last_ui_task_status"] = str(boundary_task.get("status") or "") | |
| return dict(boundary_task) | |
| except Exception as exc: | |
| logging.warning("[SP_UI] live_watch_error task_id=%s error=%s", task_id, type(exc).__name__) | |
| return None | |
| def _load_confirmed_checkpoint(task: dict) -> dict | None: | |
| """Load only the checkpoint sequence already acknowledged by Worker/D1.""" | |
| task_id = str(task.get("task_id") or "").strip() | |
| checkpoint_seq = int(task.get("checkpoint_seq") or 0) | |
| if not task_id or checkpoint_seq <= 0: | |
| return None | |
| task_dir = _task_dir(task_id) | |
| request_path = task_dir / "request.json" | |
| if not request_path.is_file(): | |
| return None | |
| try: | |
| request_payload = json.loads(request_path.read_text(encoding="utf-8")) | |
| expected_hash = str(request_payload.get("request_hash") or "") | |
| candidates = sorted((task_dir / "checkpoints").glob(f"checkpoint_{checkpoint_seq:05d}_*.json")) | |
| if not candidates: | |
| return None | |
| payload = json.loads(candidates[-1].read_text(encoding="utf-8")) | |
| if not isinstance(payload, dict): | |
| return None | |
| if expected_hash and str(payload.get("request_hash") or "") != expected_hash: | |
| return None | |
| if int(payload.get("checkpoint_seq") or 0) != checkpoint_seq: | |
| return None | |
| return payload | |
| except Exception as exc: | |
| logging.warning("[SP_UI] checkpoint_preview_error task_id=%s error=%s", task_id, type(exc).__name__) | |
| return None | |
| _PREVIEW_UNNUMBERED_HEADINGS = { | |
| "abstract", "keyword", "keywords", "references", "reference list", | |
| "摘要", "关键词", "关键字", "参考文献", | |
| "аннотация", "ключевое слово", "ключевые слова", "литература", "список литературы", | |
| "аңдатпа", "түйіндеме", "түйін сөздер", "түйінді сөздер", "кілт сөздер", | |
| "әдебиеттер", "пайдаланылған әдебиеттер", | |
| } | |
| _PREVIEW_UNNUMBERED_PREFIXES = ("appendix", "附录", "приложение", "қосымша") | |
| def _normalize_preview_display_text(value: str) -> str: | |
| """Mirror the browser heading presentation for initial/terminal rerenders. | |
| Live updates are normalized by the browser bridge. A terminal Streamlit | |
| rerender used to fall back to raw Markdown, so completed pages could show | |
| ``#`` markers or lose the Arabic numbering users saw during generation. | |
| Keep one deterministic server-side equivalent for the initial/terminal DOM. | |
| """ | |
| lines = str(value or "").replace("\r", "").split("\n") | |
| heading_rows = [] | |
| for index, line in enumerate(lines): | |
| match = re.match(r"^(#{1,3})\s+(.+?)\s*$", line) | |
| if not match: | |
| continue | |
| title = re.sub(r"^\d+(?:\.\d+){0,2}\s+", "", match.group(2).strip()) | |
| heading_rows.append((index, len(match.group(1)), title)) | |
| if not heading_rows: | |
| return "\n".join(lines) | |
| def unnumbered(title: str) -> bool: | |
| key = str(title or "").strip().casefold() | |
| return key in _PREVIEW_UNNUMBERED_HEADINGS or any(key.startswith(prefix) for prefix in _PREVIEW_UNNUMBERED_PREFIXES) | |
| has_front_matter = any(unnumbered(title) for _index, _level, title in heading_rows) | |
| first_h1 = next((row for row in heading_rows if row[1] == 1), None) | |
| counters = [0, 0, 0] | |
| for index, level, title in heading_rows: | |
| is_known_unnumbered = unnumbered(title) | |
| is_title = bool(has_front_matter and first_h1 and index == first_h1[0] and not is_known_unnumbered) | |
| if is_known_unnumbered or is_title: | |
| lines[index] = title | |
| continue | |
| if level == 1: | |
| counters[0] += 1 | |
| counters[1] = counters[2] = 0 | |
| lines[index] = f"{counters[0]} {title}" | |
| elif level == 2: | |
| if counters[0] == 0: | |
| counters[0] = 1 | |
| counters[1] += 1 | |
| counters[2] = 0 | |
| lines[index] = f"{counters[0]}.{counters[1]} {title}" | |
| else: | |
| if counters[0] == 0: | |
| counters[0] = 1 | |
| if counters[1] == 0: | |
| counters[1] = 1 | |
| counters[2] += 1 | |
| lines[index] = f"{counters[0]}.{counters[1]}.{counters[2]} {title}" | |
| return "\n".join(lines) | |
| def _render_checkpoint_preview(task: dict, lang_code: str) -> None: | |
| """Render stable bilingual DOM targets; browser mutates them in place.""" | |
| checkpoint = _load_confirmed_checkpoint(task) | |
| english = str((checkpoint or {}).get("full_draft_en") or "").strip() | |
| target = str((checkpoint or {}).get("full_draft_translated") or "").strip() | |
| english_initial = _normalize_preview_display_text(english) | |
| english_status_initial = "" if english else tr(lang_code, "draft_preparing") | |
| english_status_display = "none" if english else "block" | |
| target_initial = _normalize_preview_display_text(target) if target else tr(lang_code, "translation_waiting") | |
| english_placeholder = "0" if english else "1" | |
| target_placeholder = "0" if target else "1" | |
| left, right = st.columns([1, 1], gap="medium") | |
| with left: | |
| st.markdown(tr(lang_code, "english_draft")) | |
| st.markdown( | |
| _markdown_safe_html(f""" | |
| <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;color:#111827;'> | |
| <div id='sp-live-manuscript-status' style='white-space:pre-wrap;font-size:0.88em;color:#374151;opacity:1;margin:0 0 8px 0;display:{english_status_display};'>{html.escape(english_status_initial)}</div> | |
| <div id='sp-live-manuscript-preview' data-sp-placeholder='{english_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(english_initial)}</div> | |
| <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span> | |
| </div> | |
| """), | |
| unsafe_allow_html=True, | |
| ) | |
| with right: | |
| st.markdown(tr(lang_code, "target_draft", flag=get_target_flag(lang_code))) | |
| st.markdown( | |
| _markdown_safe_html(f""" | |
| <div id='sp-live-translation-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:220px;max-height:68vh;overflow:auto;background:#ffffff;color:#111827;'> | |
| <div id='sp-live-translation-preview' data-sp-placeholder='{target_placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{html.escape(target_initial)}</div> | |
| <span id='sp-live-translation-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span> | |
| </div> | |
| """), | |
| unsafe_allow_html=True, | |
| ) | |
| st.markdown("<style>@keyframes spBlink { 0%,49% {opacity:1} 50%,100% {opacity:0} }</style>", unsafe_allow_html=True) | |
| def _scroll_to_completed_download_once(task_id: str) -> None: | |
| """Scroll only after the task-scoped download anchor actually exists. | |
| Success identity is browser-session scoped and is written only after | |
| scrollIntoView executes. A missed early attempt therefore remains retryable | |
| on later Streamlit reruns. | |
| """ | |
| task_id = str(task_id or "").strip() | |
| if not task_id: | |
| return | |
| components.html( | |
| f""" | |
| <script> | |
| (() => {{ | |
| const parentWindow = window.parent; | |
| const parentDocument = parentWindow.document; | |
| const expectedTaskId = {json.dumps(task_id)}; | |
| const storageKey = `sp-completed-download-scrolled:${{expectedTaskId}}`; | |
| const root = parentDocument.documentElement; | |
| if (root && root.dataset.spCompletedDownloadScrolled === expectedTaskId) return; | |
| try {{ | |
| if (parentWindow.sessionStorage.getItem(storageKey) === '1') return; | |
| }} catch (_) {{}} | |
| let done = false; | |
| let observer = null; | |
| const locate = () => {{ | |
| if (done) return true; | |
| const target = parentDocument.getElementById('sp-completed-download-anchor'); | |
| if (!target || target.dataset.spTaskId !== expectedTaskId) return false; | |
| done = true; | |
| target.scrollIntoView({{behavior:'smooth', block:'center'}}); | |
| if (root) root.dataset.spCompletedDownloadScrolled = expectedTaskId; | |
| try {{ parentWindow.sessionStorage.setItem(storageKey, '1'); }} catch (_) {{}} | |
| if (observer) observer.disconnect(); | |
| return true; | |
| }}; | |
| if (locate()) return; | |
| if (parentDocument.body && parentWindow.MutationObserver) {{ | |
| observer = new parentWindow.MutationObserver(locate); | |
| observer.observe(parentDocument.body, {{childList:true, subtree:true}}); | |
| }} | |
| [80, 180, 360, 700, 1200, 2000, 3200, 4800].forEach((delay) => | |
| parentWindow.setTimeout(locate, delay) | |
| ); | |
| parentWindow.setTimeout(() => {{ if (observer) observer.disconnect(); }}, 5200); | |
| }})(); | |
| </script> | |
| """, | |
| height=0, | |
| width=0, | |
| ) | |
| def _render_task_status_once(lang_code: str) -> None: | |
| task = st.session_state.get("sp_generation_task") or {} | |
| task_id = str(task.get("task_id") or "").strip() | |
| if not task_id: | |
| return | |
| status = str(task.get("status") or "") | |
| # First-paint invariant: render useful, localized progress and manuscript | |
| # placeholders before any browser bridge call that may yield once via | |
| # st.stop(). The browser watcher mutates these stable DOM targets in place | |
| # after the bridge handshake, so no duplicate monitor/preview is needed. | |
| st.session_state["sp_last_ui_task_status"] = status | |
| _render_monitor_box(task, lang_code) | |
| _render_checkpoint_preview(task, lang_code) | |
| if status in ACTIVE_TASK_STATUSES: | |
| try: | |
| result = generation_task_status(task_id) | |
| task = dict(result.get("task") or task) | |
| st.session_state["sp_generation_task"] = task | |
| status = str(task.get("status") or "") | |
| except Exception as exc: | |
| logging.warning("[SP_UI] status_poll_error task_id=%s error=%s", task_id, type(exc).__name__) | |
| if status in LIVE_TASK_STATUSES: | |
| boundary_task = _watch_task_status_live(task) | |
| if isinstance(boundary_task, dict): | |
| task = boundary_task | |
| status = str(task.get("status") or "") | |
| st.session_state["sp_last_ui_task_status"] = status | |
| if status == "resumable": | |
| resume_capable, _ = _local_resume_capability(task) | |
| st.warning(tr(lang_code, "checkpoint_warning" if resume_capable else "resume_unavailable_runtime_replaced")) | |
| elif status == "completed": | |
| output_path = _task_output_path(task) | |
| if output_path and output_path.is_file(): | |
| st.markdown( | |
| f"<div id='sp-completed-download-anchor' data-sp-task-id='{html.escape(task_id, quote=True)}'></div>", | |
| unsafe_allow_html=True, | |
| ) | |
| if str(task.get("safe_error_code") or "") == "W_EVIDENCE_COVERAGE_LIMITED": | |
| st.warning(tr(lang_code, "evidence_limited_completed")) | |
| st.success(tr(lang_code, "success")) | |
| st.download_button(label=tr(lang_code, "download"), data=output_path.read_bytes(), file_name=output_path.name, mime="application/zip") | |
| _scroll_to_completed_download_once(task_id) | |
| else: | |
| st.warning("The task completed, but the local output file is unavailable after runtime replacement.") | |
| elif status == "failed": | |
| error_message, translation_note = _localized_terminal_task_error(task, lang_code) | |
| st.error(error_message) | |
| if translation_note: | |
| st.warning(translation_note) | |
| elif status == "cancelled": | |
| detail = str(task.get("safe_error_detail") or "") | |
| if detail: | |
| st.warning(detail) | |
| def _localized_terminal_task_error(task: dict, lang_code: str) -> tuple[str, str]: | |
| """Map stable business error codes to UI-language messages. | |
| Engineering details remain in task/log state; the user-facing terminal view | |
| does not expose a long English runtime exception in non-English interfaces. | |
| """ | |
| code = str(task.get("safe_error_code") or "").strip() | |
| detail = str(task.get("safe_error_detail") or "").strip() | |
| raw = f"{code} {detail}" | |
| if "E_LITERATURE_INSUFFICIENT" in raw: | |
| return tr(lang_code, "literature_insufficient"), tr(lang_code, "upstream_translation_stopped") | |
| return detail or code or tr(lang_code, "node_error"), "" | |
| def _inject_generation_action_scroll(mode: str) -> None: | |
| """Scroll immediately to the active generation action without a server wait.""" | |
| target_id = "sp-generation-action-asq" if str(mode or "").lower() == "asq" else "sp-generation-action-amj" | |
| components.html( | |
| f""" | |
| <script> | |
| (() => {{ | |
| const parentDocument = window.parent.document; | |
| const targetId = {json.dumps(target_id)}; | |
| let done = false; | |
| const locate = () => {{ | |
| if (done) return; | |
| const target = parentDocument.getElementById(targetId); | |
| if (!target) return; | |
| done = true; | |
| target.scrollIntoView({{behavior:'auto', block:'center'}}); | |
| }}; | |
| [0, 40, 100, 220, 450, 800].forEach((delay) => window.parent.setTimeout(locate, delay)); | |
| }})(); | |
| </script> | |
| """, | |
| height=0, | |
| width=0, | |
| ) | |
| def _scroll_to_generation_action_once() -> None: | |
| """One-time post-launch/resume scroll to the monitor/live manuscript.""" | |
| if not bool(st.session_state.get("sp_scroll_to_generation_action")): | |
| return | |
| st.session_state["sp_scroll_to_generation_action"] = False | |
| mode = str(st.session_state.get("run_mode") or "asq") | |
| fallback_id = "sp-generation-action-asq" if mode.lower() == "asq" else "sp-generation-action-amj" | |
| components.html( | |
| f""" | |
| <script> | |
| (() => {{ | |
| const parentDocument = window.parent.document; | |
| const fallbackId = {json.dumps(fallback_id)}; | |
| let done = false; | |
| const locate = (allowFallback = false) => {{ | |
| if (done) return; | |
| const target = | |
| parentDocument.getElementById('sp-task-monitor-anchor') || | |
| parentDocument.getElementById('sp-live-manuscript-shell') || | |
| (allowFallback ? parentDocument.getElementById(fallbackId) : null); | |
| if (!target) return; | |
| done = true; | |
| target.scrollIntoView({{behavior:'auto', block:'center'}}); | |
| }}; | |
| [0, 60, 140, 300, 650, 1000, 1600].forEach((delay) => | |
| window.parent.setTimeout(() => locate(false), delay) | |
| ); | |
| window.parent.setTimeout(() => locate(true), 2200); | |
| }})(); | |
| </script> | |
| """, | |
| height=0, | |
| width=0, | |
| ) | |
| def _select_active_task_tab(task: dict, lang_code: str) -> None: | |
| """Keep the existing visual tab aligned with the immutable task mode after rerun/refresh.""" | |
| status = str((task or {}).get("status") or "") | |
| mode = str((task or {}).get("mode") or "").strip().lower() | |
| if mode not in {"amj", "asq"}: | |
| return | |
| if status not in (ACTIVE_TASK_STATUSES | {"resumable", "completed", "failed", "cancelled"}): | |
| return | |
| label = tr(lang_code, "tab_asq" if mode == "asq" else "tab_amj") | |
| components.html( | |
| f""" | |
| <script> | |
| (() => {{ | |
| const parentDocument = window.parent.document; | |
| const expected = {json.dumps(label)}; | |
| const select = () => {{ | |
| const tabs = Array.from(parentDocument.querySelectorAll('[role="tab"]')); | |
| const target = tabs.find((node) => (node.textContent || '').trim() === expected.trim()); | |
| if (target && target.getAttribute('aria-selected') !== 'true') target.click(); | |
| }}; | |
| [0, 80, 220, 500, 900].forEach((delay) => window.parent.setTimeout(select, delay)); | |
| }})(); | |
| </script> | |
| """, | |
| height=0, | |
| width=0, | |
| ) | |
| def render_workspace_controls(user): | |
| top_toolbar = st.container() | |
| with top_toolbar: | |
| language_col, account_col = st.columns([5.4, 4.6]) | |
| with language_col: | |
| lang_choice = st.radio( | |
| "Language", list(LANGUAGE_OPTIONS.keys()), index=0, horizontal=True, | |
| label_visibility="collapsed", key="interface_language_choice", | |
| ) | |
| lang_code = LANGUAGE_OPTIONS[lang_choice] | |
| st.session_state["sp_lang_code"] = lang_code | |
| st.session_state["sp_target_lang"] = get_target_language(lang_code) | |
| st.session_state["sp_output_suffix"] = get_output_suffix(lang_code) | |
| st.session_state["sp_target_flag"] = get_target_flag(lang_code) | |
| with account_col: | |
| render_logged_in_account(lang_code, user) | |
| task = st.session_state.get("sp_generation_task") or {} | |
| task_status = str(task.get("status") or "") | |
| task_mode = str(task.get("mode") or "").strip().lower() | |
| if task_mode in {"amj", "asq"}: | |
| st.session_state["run_mode"] = task_mode | |
| active = task_status in ACTIVE_TASK_STATUSES | |
| st.session_state["is_running"] = active | |
| st.markdown(f"<div class='main-title'><h2>{tr(lang_code, 'title')}</h2></div>", unsafe_allow_html=True) | |
| if task_status == "resumable": | |
| resume_capable, resume_reason = _local_resume_capability(task) | |
| if resume_capable: | |
| st.warning(tr(lang_code, "checkpoint_warning")) | |
| else: | |
| logging.warning( | |
| "[SP_UI] local_resume_capability_missing task_id=%s reason=%s", | |
| str(task.get("task_id") or ""), resume_reason, | |
| ) | |
| st.warning(tr(lang_code, "resume_unavailable_runtime_replaced")) | |
| colA, colB = st.columns([1, 1]) | |
| if colA.button(tr(lang_code, "resume"), key="resume_task", disabled=not resume_capable): | |
| st.session_state["sp_pending_resume_task_id"] = str(task.get("task_id") or "") | |
| st.rerun() | |
| if colB.button(tr(lang_code, "clear"), key="clear_task"): | |
| st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "") | |
| st.rerun() | |
| st.markdown("---") | |
| st.text_input(tr(lang_code, "topic_label"), value=DEFAULT_TOPIC, disabled=active, key="sp_topic") | |
| st.text_input(tr(lang_code, "keywords_label"), value=DEFAULT_KEYWORDS, disabled=active, key="sp_keywords") | |
| product_ui = get_product_ui_projection() | |
| if product_ui.get("mode") == "a5_product": | |
| products = product_ui.get("products") or {} | |
| tier_options = [tier for tier in ("STANDARD", "FLAGSHIP") if tier in products] | |
| if len(tier_options) != 2: | |
| st.error(tr(lang_code, "product_generation_not_active")) | |
| st.stop() | |
| selected_tier = str(st.session_state.get("sp_product_tier") or "STANDARD").strip().upper() | |
| if selected_tier not in tier_options: | |
| selected_tier = "STANDARD" | |
| st.session_state["sp_product_tier"] = selected_tier | |
| selected_tier = st.radio( | |
| tr(lang_code, "product_tier_label"), | |
| tier_options, | |
| index=tier_options.index(selected_tier), | |
| format_func=lambda tier: tr(lang_code, f"product_tier_{tier.lower()}"), | |
| horizontal=True, | |
| disabled=active, | |
| key="sp_product_tier", | |
| ) | |
| selected_product = products[selected_tier] | |
| word_min = int(selected_product["min_body_words"]) | |
| word_max = int(selected_product["max_body_words"]) | |
| word_label = tr( | |
| lang_code, | |
| "words_label_product", | |
| min_words=word_min, | |
| max_words=word_max, | |
| ) | |
| else: | |
| st.session_state.pop("sp_product_tier", None) | |
| word_min = int(APP_CONFIG["target_words_min"]) | |
| word_max = int(APP_CONFIG["target_words_max"]) | |
| word_label = tr( | |
| lang_code, | |
| "words_label", | |
| min_words=word_min, | |
| max_words=word_max, | |
| ) | |
| current_words = int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]) | |
| bounded_words = min(word_max, max(word_min, current_words)) | |
| if st.session_state.get("sp_words") != bounded_words: | |
| st.session_state["sp_words"] = bounded_words | |
| st.number_input( | |
| word_label, | |
| min_value=word_min, | |
| max_value=word_max, | |
| value=bounded_words, | |
| step=1000, | |
| disabled=active, | |
| key="sp_words", | |
| ) | |
| tab_asq, tab_amj = st.tabs([tr(lang_code, "tab_asq"), tr(lang_code, "tab_amj")]) | |
| with tab_asq: | |
| st.markdown(tr(lang_code, "asq_config")) | |
| st.info(tr(lang_code, "asq_info")) | |
| st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_asq_ref", disabled=active) | |
| st.file_uploader(tr(lang_code, "upload_interviews"), type=["txt", "pdf", "doc", "docx"], key="up_asq_data", disabled=active) | |
| with st.expander(tr(lang_code, "asq_expander")): | |
| st.markdown(tr(lang_code, "asq_hint")) | |
| template = get_asq_txt_template(lang_code) | |
| st.code(template, language="text") | |
| st.download_button(label=tr(lang_code, "download_asq_template"), data=template, file_name="ASQ_Interview_Template.txt", mime="text/plain", use_container_width=True) | |
| st.markdown("<div id='sp-generation-action-asq'></div>", unsafe_allow_html=True) | |
| if active and _task_mode(task) == "asq": | |
| if st.button(tr(lang_code, "cancel_generation"), key="cancel_asq"): | |
| st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "") | |
| st.rerun() | |
| elif st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"): | |
| st.session_state["run_mode"] = "asq" | |
| st.session_state["sp_pending_launch"] = {"mode": "asq", "idempotency_key": _new_generation_idempotency_key()} | |
| st.session_state["sp_scroll_to_generation_action"] = True | |
| st.info(tr(lang_code, "pipeline_start")) | |
| _inject_generation_action_scroll("asq") | |
| with tab_amj: | |
| st.markdown(tr(lang_code, "amj_config")) | |
| st.info(tr(lang_code, "amj_info")) | |
| st.file_uploader(tr(lang_code, "upload_reference"), type=["pdf", "doc", "docx"], accept_multiple_files=True, key="up_amj_ref", disabled=active) | |
| st.file_uploader(tr(lang_code, "upload_stats"), type=["csv", "xlsx", "xls"], key="up_amj_data", disabled=active) | |
| with st.expander(tr(lang_code, "amj_expander")): | |
| st.markdown(tr(lang_code, "amj_hint")) | |
| template = get_amj_csv_template(lang_code) | |
| st.code(template, language="csv") | |
| st.download_button(label=tr(lang_code, "download_amj_template"), data=template, file_name="AMJ_Data_Template.csv", mime="text/csv", use_container_width=True) | |
| st.markdown("<div id='sp-generation-action-amj'></div>", unsafe_allow_html=True) | |
| if active and _task_mode(task) == "amj": | |
| if st.button(tr(lang_code, "cancel_generation"), key="cancel_amj"): | |
| st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "") | |
| st.rerun() | |
| elif st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"): | |
| st.session_state["run_mode"] = "amj" | |
| st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()} | |
| st.session_state["sp_scroll_to_generation_action"] = True | |
| st.info(tr(lang_code, "pipeline_start")) | |
| _inject_generation_action_scroll("amj") | |
| _select_active_task_tab(task, lang_code) | |
| inject_file_uploader_i18n(lang_code) | |
| render_workspace_controls(authenticated_user) | |
| lang_code = str(st.session_state.get("sp_lang_code") or _current_language_code()) | |
| _notice = st.session_state.pop("sp_terminal_notice", None) | |
| if isinstance(_notice, dict) and _notice.get("message"): | |
| (st.error if _notice.get("kind") == "error" else st.warning)(str(_notice.get("message"))) | |
| _process_pending_cancel() | |
| _process_pending_resume() | |
| _process_pending_launch(lang_code) | |
| if st.session_state.get("sp_payment_required"): | |
| render_payment_purchase(lang_code) | |
| # R3.2.4 keeps the approved task-monitor location. Active progress is updated | |
| # inside the browser by read-only edge polling; Streamlit reruns only on a | |
| # user action or a terminal/resumable boundary, so there is no periodic flicker. | |
| _task_for_monitor = st.session_state.get("sp_generation_task") or {} | |
| if str(_task_for_monitor.get("task_id") or "").strip(): | |
| st.markdown("<div id='sp-task-monitor-anchor'></div>", unsafe_allow_html=True) | |
| # Install the one-time navigation script before task-status bridge calls. | |
| # If the first bridge handshake yields via st.stop(), the browser still | |
| # receives the anchor and can position the user at visible task progress. | |
| _scroll_to_generation_action_once() | |
| _render_task_status_once(lang_code) | |