Upload folder using huggingface_hub

Dockerfile

@@ -11,10 +11,10 @@ RUN pip install --no-cache-dir --upgrade pip setuptools wheel \
     && pip install --no-cache-dir -r requirements.txt
 
 # ========= 拷贝项目文件 =========
-COPY tmp/ ./tmp/
+# COPY tmp/ ./tmp/
 
 # ========= 暴露 Streamlit 端口 =========
 EXPOSE 8501
 
 # ========= 启动命令 =========
-CMD ["streamlit", "run", "tmp/app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

app.py

@@ -0,0 +1,215 @@
+import sys, os
+import tempfile
+import streamlit as st
+
+from config import MODEL_CONFIGS
+from utils.save_secrets import *
+from prompt_engineer.sec1_call_llm import DataLoadingAgent
+from prompt_engineer.sec2_call_llm import DataPreprocessAgent
+from prompt_engineer.sec3_call_llm import VisualizationAgent
+from prompt_engineer.sec4_call_llm import ModelingCodingAgent
+from prompt_engineer.sec5_call_llm import ReportAgent
+from prompt_engineer.planner import PlannerAgent
+
+import warnings
+warnings.filterwarnings("ignore")
+warnings.filterwarnings("ignore", message="missing ScriptRunContext")
+
+import numpy as np
+np.set_printoptions(edgeitems=250, threshold=501)
+
+sys.path.append(os.path.dirname(__file__))
+
+CACHE_FILE = os.path.join(tempfile.gettempdir(), "anystat_cache.pkl")
+CACHE_DIR = './cache'
+SECRETS_PATH = Path(".streamlit") / "secrets.toml"
+
+
+# 设置页面配置
+st.set_page_config(
+    page_title="AnyStat",
+    page_icon="🤖",
+    layout="wide"
+)
+
+
+def init_session_state():
+
+    if 'selected_model' not in st.session_state:
+        st.session_state.selected_model = "DeepSeek"
+    if "api_keys" not in st.session_state:
+        st.session_state.api_keys = load_local_api_keys()
+    if 'auto_mode' not in st.session_state:
+        st.session_state.auto_mode = False
+
+    if 'loading_start_time' not in st.session_state:
+        st.session_state.loading_start_time = None
+    if 'prep_start_time' not in st.session_state:
+        st.session_state.prep_start_time = None
+    if 'vis_start_time' not in st.session_state:
+        st.session_state.vis_start_time = None
+    if 'modeling_start_time' not in st.session_state:
+        st.session_state.modeling_start_time = None
+    if 'report_start_time' not in st.session_state:
+        st.session_state.report_start_time = None
+
+    if 'data_loading_agent' not in st.session_state:
+        st.session_state.data_loading_agent = DataLoadingAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+    if 'data_preprocess_agent' not in st.session_state:
+        st.session_state.data_preprocess_agent = DataPreprocessAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+    if 'visualization_agent' not in st.session_state:
+        st.session_state.visualization_agent = VisualizationAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+    if 'modeling_coding_agent' not in st.session_state:
+        st.session_state.modeling_coding_agent = ModelingCodingAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+    if 'report_agent' not in st.session_state:
+        st.session_state.report_agent = ReportAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+    if 'planner_agent' not in st.session_state:
+        st.session_state.planner_agent = PlannerAgent(
+            api_keys=st.session_state.api_keys,
+            model_configs=MODEL_CONFIGS,
+            model=st.session_state.selected_model
+        )
+
+
+def on_model_selector_change():
+    """
+    Callback when the model selector in the sidebar changes.
+    """
+    st.session_state.selected_model = st.session_state.model_selector
+    
+
+def run_app():
+    """
+    Main entry point to render the Streamlit app.
+    """
+    init_session_state()
+    with st.sidebar:
+        st.subheader("选择大模型")
+        models = list(MODEL_CONFIGS.keys())
+        st.selectbox(
+            "选择要使用的大模型",
+            models,
+            index=models.index(st.session_state.selected_model),
+            key="model_selector",
+            on_change=on_model_selector_change,
+        )
+
+        st.subheader("API 密钥设置")
+        selected = st.session_state.selected_model
+
+        api_key_input = st.text_input(
+            f"{selected} API 密钥",
+            value=st.session_state.api_keys.get(selected, ""),
+            type="password",
+            key="api_key_input",
+        )
+
+
+        if st.button("💾 保存密钥", use_container_width=True, key="save_key"):
+            # 保存在 utils/.streamlit/secrets.toml
+            update_local_api_key(selected, api_key_input)
+
+            st.session_state.api_keys[selected] = api_key_input
+            st.success("已保存")
+            st.rerun()
+
+        if st.button("🧹 清空数据", use_container_width=True, key="clear_data"):
+
+            st.session_state.data_loading_agent = DataLoadingAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.data_preprocess_agent = DataPreprocessAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.visualization_agent = VisualizationAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.modeling_coding_agent = ModelingCodingAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.report_agent = ReportAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.planner_agent = PlannerAgent(
+                api_keys=st.session_state.api_keys,
+                model_configs=MODEL_CONFIGS,
+                model=st.session_state.selected_model
+            )
+            st.session_state.auto_mode = False
+            st.rerun()
+
+        if st.session_state.data_loading_agent.load_df() is not None:
+            planner = st.session_state.planner_agent
+            if st.button("🚗 自动模式", use_container_width=True, key="self_driving"):
+                planner.self_driving(st.session_state.data_loading_agent.load_df())
+                st.session_state.auto_mode = True
+                st.rerun()
+
+        st.image(
+            "logo/logo_big.png",
+            use_container_width=True
+        )
+
+    # Define pages
+    data_loading = st.Page(
+        "workflow/dataloading/dataloading_render.py",
+        title="📥 数据导入",
+    )
+    preprocessing = st.Page(
+        "workflow/preprocessing/preprocessing_render.py",
+        title="⚙️ 数据预处理",
+    )
+    visualization = st.Page(
+        "workflow/visualization/viz_render.py",
+        title="📊 数据可视化",
+    )
+    report = st.Page(
+        "workflow/report/report_render.py",
+        title="📝 报告生成",
+    )
+    coding_modeling = st.Page(
+        "workflow/modeling/modeling_render.py",
+        title="🧠 建模分析",
+    )
+    # Navigation
+    pg = st.navigation(
+        {
+            "设置": [data_loading, preprocessing],
+            "功能": [visualization, coding_modeling, report],
+        }
+    )
+    pg.run()
+    
+if __name__ == "__main__":
+    run_app()
+

prompt_engineer/call_llm.py

@@ -0,0 +1,144 @@
+import re
+from openai import OpenAI, OpenAIError
+from anthropic import Anthropic, AnthropicError
+import requests
+import json
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from config import MODEL_CONFIGS
+from typing import IO, List, Dict
+from zai import ZhipuAiClient
+
+class LLMClient:
+    def __init__(self, model_configs: dict, api_keys: dict, model: str):
+
+        self.model = model
+        self.model_configs = model_configs
+        self.api_keys = api_keys
+        self.memory = []
+        self.df = None
+
+    def call(self, prompt) -> str:
+
+        model_name = st.session_state.selected_model
+        config = self.model_configs.get(model_name, {})
+        api_key = self.api_keys.get(model_name)
+
+        if not api_key:
+            return "请先在设置中配置 API 密钥"
+        
+        system_msg = (
+            "你是一个专业的数据分析助手。"
+        )
+
+        try:
+            if model_name == "GPT-4o" or model_name == "GPT-5" or model_name == "DeepSeek" or model_name == "通义千问" or model_name == "Claude" or model_name == "豆包":
+                try:
+                    client = OpenAI(
+                        api_key=api_key,
+                        base_url=config["api_base"]
+                    )
+                    
+                    # 使用新的 API 调用方式
+                    resp = client.chat.completions.create(
+                        model=config["model_name"],
+                        messages=[
+                            {"role": "system", "content": system_msg},
+                            {"role": "user", "content": prompt},
+                        ],
+                        stream = False
+                    )
+                    return resp.choices[0].message.content
+                
+                except OpenAIError as e:
+                    # 这里可以捕获所有OpenAI SDK定义的错误
+                    st.error(f"API调用失败: {str(e)}")
+                    # 记录日志或提示用户
+                    return "调用失败，请检查密钥或网络"
+                except Exception as e:
+                    # 捕获其他非预期的异常，如网络问题
+                    st.error(f"发生未知错误: {str(e)}")
+                    return "发生未知错误"
+
+            elif model_name == "智谱AI":
+                client = ZhipuAiClient(api_key=api_key)
+                response = client.chat.completions.create(
+                    model=config["model_name"],
+                    messages=[{"role": "system", "content": "你是一个专业的数据分析助手。"},
+                        {"role": "user", "content": prompt}],
+                    thinking={
+                        "type":"enabled"
+                    }
+                )
+                if response:
+                    print(response.choices[0].message)
+                    desc = response.choices[0].message.content if hasattr(response.choices[0].message, "content") else str(response.choices[0].message)
+                    return desc.replace("<|begin_of_box|>", "").replace("<|end_of_box|>", "").strip()
+
+                st.error(f"智谱调用失败：{response.text}")
+                return "调用失败，请检查密钥或网络"
+
+                
+            # elif model_name == "DeepSeek":
+            #     client = OpenAI(
+            #         api_key=api_key,
+            #         base_url=config["api_base"])
+
+            #     resp = client.chat.completions.create(
+            #         model=config["model_name"],
+            #         messages=[
+            #             {"role": "system", "content": system_msg},
+            #             {"role": "user", "content": prompt},
+            #         ],
+            #         stream=False
+            #     )
+            #     if resp:
+            #         return resp.choices[0].message.content
+            #     st.error(f"DeepSeek调用失败：{resp.text}")
+            #     return "调用失败，请检查密钥或网络"
+
+            else:
+                return f"暂不支持模型：{model_name}"
+
+        except Exception as e:
+            st.error(f"{model_name} 调用异常：{e}")
+            return "大模型调用失败，请检查 API 密钥或网络连接"
+
+    
+    def add_memory(self, entry: Dict[str, str]) -> None:
+
+        self.memory.append(entry)
+
+
+    def load_memory(self) -> List[Dict[str, str]]:
+
+        return self.memory
+
+
+    def clear_memory(self) -> None:
+
+        self.memory.clear()
+
+
+    def add_df(self, input_df) -> None:
+
+ 
+        
+        self.df = input_df
+        
+
+    def load_df(self) -> pd.DataFrame:
+        
+        return self.df
+    
+
+    def clear_df(self) -> None:
+
+        self.df = None
+
+
+    def has_df(self) -> bool:
+
+        return self.df == None

prompt_engineer/planner.py

@@ -0,0 +1,177 @@
+import re
+import json
+
+import streamlit as st
+from typing import IO, List
+
+from prompt_engineer.call_llm import LLMClient
+
+
+class PlannerAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.loading_auto = False
+        self.prep_auto = False
+        self.vis_auto = False
+        self.modeling_auto = False
+        self.report_auto = False
+
+        self.switched_loading = False
+        self.switched_prep = False
+        self.switched_vis = False
+        self.switched_modeling = False
+        self.switched_report = False
+
+    def self_driving(self, df, user_input=None) -> str:
+
+        prompt = (
+            f"下面是一个数据集的基本信息，请你根据它和用户的需求，判断需要开启哪些分析步骤：\n\n"
+            f"- 数据维度：{df.shape[0]} 行 × {df.shape[1]} 列\n"
+            f"- 列名和数据类型：{dict(zip(df.columns.tolist(), df.dtypes.astype(str).tolist()))}\n"
+            f"- 前 5 行样本：\n{df.head().to_dict(orient='list')}\n\n"
+        )
+
+        if user_input:
+            prompt += f"用户的具体需求是：“{user_input}”。\n\n"
+
+        prompt += """
+        你需要在以下 5 个步骤中，对每个步骤分别判断是否应该开启（True / False）：
+        1. loading_auto —— 是否需要对数据列名进行初步分析？
+        2. prep_auto —— 是否需要做数据预处理或清洗？
+        3. vis_auto —— 是否需要做数据可视化？
+        4. modeling_auto —— 是否需要建模或统计分析？
+        5. report_auto —— 是否需要生成分析报告？
+
+        必须以 **JSON 格式** 输出你的判断结果，如：
+        {
+            "loading_auto": true,
+            "prep_auto": false,
+            "vis_auto": true,
+            "modeling_auto": true,
+            "report_auto": true
+        }
+
+        不要输出其他内容。
+        """
+
+        plan_text = self.call(prompt)
+        print(plan_text)
+        try:
+            plan_dict = json.loads(plan_text)
+        except json.JSONDecodeError:
+            plan_text_fixed = plan_text.strip().strip('```json').strip('```')
+            plan_dict = json.loads(plan_text_fixed)
+
+        print(plan_dict)
+        self.loading_auto = bool(plan_dict.get("loading_auto", False))
+        self.prep_auto = bool(plan_dict.get("prep_auto", False))
+        self.vis_auto = bool(plan_dict.get("vis_auto", False))
+        self.modeling_auto = bool(plan_dict.get("modeling_auto", False))
+        # self.modeling_auto = False
+        self.report_auto = bool(plan_dict.get("report_auto", False))
+
+
+    def finish_loading_auto(self) -> str:
+
+        self.switched_loading = True
+
+
+    def finish_prep_auto(self) -> str:
+
+        self.switched_prep = True
+
+
+    def finish_vis_auto(self) -> str:
+
+        self.switched_vis = True
+
+
+    def finish_modeling_auto(self) -> str:
+
+        self.switched_modeling = True
+
+
+    def finish_report_auto(self) -> str:
+
+        self.switched_report = True
+
+
+import json
+import ast
+import re
+import traceback
+
+def _extract_first_json(text: str):
+    """从 text 中提取第一个顶层花括号 JSON 子串（用配对计数法），找不到则返回 None。"""
+    if not text:
+        return None
+    start = text.find('{')
+    if start == -1:
+        return None
+    depth = 0
+    for i in range(start, len(text)):
+        ch = text[i]
+        if ch == '{':
+            depth += 1
+        elif ch == '}':
+            depth -= 1
+            if depth == 0:
+                return text[start:i+1]
+    return None
+
+def _safe_parse_json(text: str):
+    """
+    尝试多种策略解析 LLM 输出为 dict：
+    1) 直接 json.loads
+    2) 去除 Markdown code fence 后再 loads
+    3) 提取第一个完整花括号块后 loads
+    4) ast.literal_eval 作为最后手段（接受 Python dict 风格）
+    返回 (dict_or_None, used_text, error_message_or_None)
+    """
+    if not text or not text.strip():
+        return None, text, "empty"
+    # 1) 直接尝试
+    try:
+        return json.loads(text), text, None
+    except Exception as e1:
+        pass
+
+    # 2) 去掉 ```json / ``` fence
+    try:
+        cleaned = re.sub(r'```json\s*', '', text, flags=re.IGNORECASE)
+        cleaned = re.sub(r'```', '', cleaned)
+        cleaned = cleaned.strip()
+        return json.loads(cleaned), cleaned, None
+    except Exception:
+        pass
+
+    # 3) 提取首个匹配的 { ... } 顶层块
+    try:
+        sub = _extract_first_json(text)
+        if sub:
+            return json.loads(sub), sub, None
+    except Exception:
+        pass
+
+    # 4) ast.literal_eval 兼容 Python 字典格式（单引号等）
+    try:
+        literal = ast.literal_eval(text)
+        if isinstance(literal, dict):
+            return literal, text, None
+    except Exception:
+        pass
+
+    # 5) 再次尝试在提取的子串上用 literal_eval（防止单引号）
+    try:
+        sub = _extract_first_json(text)
+        if sub:
+            literal = ast.literal_eval(sub)
+            if isinstance(literal, dict):
+                return literal, sub, None
+    except Exception:
+        pass
+
+    # 最后，返回 None 并带上错误信息
+    return None, text, "unable_to_parse"

prompt_engineer/sec1_call_llm.py

@@ -0,0 +1,248 @@
+import re
+
+import streamlit as st
+from typing import IO, List
+
+from prompt_engineer.call_llm import LLMClient
+
+
+class DataLoadingAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.file_name = []
+        self.user_input = None
+        self.par_content = ""
+        self.dfs = None
+        self.abstract=None
+        self.full = None
+        self.finish_auto_task = False
+
+
+    def finish_auto(self):
+
+        self.finish_auto_task = True
+
+
+    def save_file_name(self, file_name):
+
+        self.file_name.append(file_name)
+
+
+    def load_file_name(self):
+
+        return self.file_name
+
+
+    def save_dfs(self, dfs):
+
+        self.dfs = (dfs)
+
+
+    def load_dfs(self):
+
+        return self.dfs
+
+
+    def clear_file_name(self):
+        
+        self.file_name = []
+
+
+    def read_names_from_file(self, uploaded_names_file, df_head):
+        """
+        从上传的 .names/.arff 文件中提取属性名。
+        优先使用 LLM 识别 @attribute 行中的属性名；如果 LLM 调用失败，退回到正则解析。
+        """
+        
+        raw = uploaded_names_file.read().decode('utf-8', errors='ignore')
+        try:
+            uploaded_names_file.seek(0)
+        except Exception:
+            pass
+
+        prompt = (
+            "下面是上传的 names 和 df_head 文件内容，请仅以 Python 列表格式返回与df_head一一对应的所有属性(attribute)名称，"
+            "并保持顺序，不要添加多余文字，请注意，你只需要返回一个列表，不要出现任何markdown语法：\n```\n"
+            f"name文件：{raw}\n```"
+            f"df_head：{df_head}\n```"
+        )
+        try:
+            response = self.call(prompt)
+            names_list = eval(response.strip())
+            if isinstance(names_list, list) and all(isinstance(n, str) for n in names_list):
+                col_names = names_list
+            else:
+                raise ValueError("LLM 输出格式不正确")
+        except Exception:
+
+            col_names = []
+            attr_re = re.compile(
+                r"""^@attribute\s+ 
+                    ['"]?([^'"\s]+)['"]?
+                    \s+.+
+                """,
+                re.IGNORECASE | re.VERBOSE
+            )
+            for line in raw.splitlines():
+                line = line.strip()
+                if not line:
+                    continue
+                if line.lower().startswith('@data'):
+                    break
+                m = attr_re.match(line)
+                if m:
+                    col_names.append(m.group(1))
+
+        counts: dict[str, int] = {}
+        unique_names: List[str] = []
+        for name in col_names:
+            if name in counts:
+                counts[name] += 1
+                unique_names.append(f"{name}_{counts[name]}")
+            else:
+                counts[name] = 0
+                unique_names.append(name)
+
+        return unique_names
+
+
+    def do_data_description(self, df, user_input=None, memory_limit=6):
+
+        recent_memory = self.memory[-memory_limit:] if self.memory else []
+        if recent_memory:
+            formatted_memory = "\n".join(
+                f"{m['role']}: {m['content']}" for m in recent_memory
+            )
+            memory_block = f"{formatted_memory}"
+        else:
+            memory_block = ""
+
+        prompt = (
+            "你是一名专业的数据分析助手，负责解释数据结构与业务含义。\n"
+            f"- 数据维度：{df.shape[0]} 行 × {df.shape[1]} 列\n"
+            f"- 列名和数据类型：{dict(zip(df.columns.tolist(), df.dtypes.astype(str).tolist()))}\n"
+            f"- 前 5 行样本：\n{df.head().to_dict(orient='list')}\n\n"
+            f"""- 数据解释聊天对话：
+            --- 开始聊天记录 ---
+            {memory_block}
+            --- 结束聊天记录 ---"""
+        )
+
+        if user_input is not None:
+            prompt += f"""
+            请严格依据用户需求“{user_input}”，对当前数据进行深入、系统的分析。
+            要求：
+            1. 分析内容必须与该需求完全对应，不能添加无关推断。
+            2. 结论要具体、清晰，可直接支持后续报告撰写或建模步骤。
+            3. 分析语言应专业、简洁，不使用模糊或情绪化表述。
+            """
+        else:
+            prompt += """
+            以下是一个数据集的基本概览。请帮助我分析它的性质和结构，并回答以下问题：
+
+            1. 该数据集可能来源于什么业务或研究场景？
+            2. 各主要字段分别代表什么含义？若能判断，请说明其单位或数值含义。
+            3. 数据中是否存在明显异常、异常分布或需要注意的特征？
+
+            输出要求：
+            - 使用自然、流畅的中文描述；
+            - 采用清晰的分条结构（1、2、3）；
+            - 语言客观简洁，不使用“可能”“也许”“似乎”等模糊词；
+            - 重点突出数据结构、含义与潜在问题。
+            """
+
+        desc = self.call(prompt)
+
+        return desc
+    
+    
+    def summary_html(self):
+
+        df = self.load_df()
+        df_head = df.head()
+        dtype_info = df.dtypes.astype(str)
+
+        prompt = f"""
+        你正在撰写一份数据分析报告的第一章——《数据概览与数据含义分析》。
+        请根据以下输入内容，整理关键信息并进行分析说明：
+        数据格式：
+        {dtype_info}
+
+        前五行数据：
+        {df_head}
+        
+        数据解释聊天对话：
+        --- 开始聊天记录 ---
+        {self.memory}
+        --- 结束聊天记录 ---
+
+        额外要求：
+        1. 要用流畅的自然语言
+        2. 不要滥用形容词和副词，尽量用简单的动词和名词表达意思
+        3. 不用"可能""也许""似乎""微妙"等模糊表述
+        """.strip()
+
+        desc = self.call(prompt)
+
+        summary = {
+                    "title": "数据导入",
+                    "df": df_head,
+                   "desc": desc,
+                }
+
+        return summary
+
+
+    def summary_word(self):
+
+        return self.summary_html()
+
+
+    def check_abstract(self):
+
+        if self.abstract is None:
+            df = self.load_df()
+            df_head = df.head()
+            dtype_info = df.dtypes.astype(str)
+
+            prompt = f"""
+            这是数据分析的数据导入阶段
+            数据格式：
+            {dtype_info}
+
+            前五行数据：
+            {df_head}
+
+            数据解释聊天对话：
+            --- 开始聊天记录 ---
+            {self.memory}
+            --- 结束聊天记录 ---
+
+            要求：
+            请基于上述数据与对话内容，生成一段简洁、准确的综合摘要。
+            摘要需完整呈现核心信息，便于后续自动判断该内容在报告撰写中是否需要被引用。
+            """.strip()
+
+            desc = self.call(prompt)
+            self.abstract = desc
+
+        return self.abstract
+
+
+    def check_full(self):
+
+        if self.full is None:
+            df = self.load_df()
+            df_head = df.head()
+            dtype_info = df.dtypes.astype(str)
+
+            self.full = (
+                f"【阶段说明】这是数据分析流程中的数据导入阶段。\n"
+                f"【数据格式】{dtype_info}\n"
+                f"【样本预览】\n{df_head}\n"
+                f"【分析对话记录】\n{self.memory}"
+            )
+
+        return self.full

prompt_engineer/sec2_call_llm.py

@@ -0,0 +1,374 @@
+import numpy as np
+import pandas as pd
+
+from prompt_engineer.call_llm import LLMClient
+
+class DataPreprocessAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.processed_df = None
+        self.code = None
+        self.preprocessing_suggestions = None
+        self.allowed_libs = [
+            "numpy",
+            "pandas",
+            "sklearn.impute",
+            "sklearn.preprocessing",
+            "sklearn.compose",
+            "sklearn.pipeline"
+        ]
+        self.par_content = ""
+        self.error = None
+        self.user_input = None
+        self.refined_suggestions = ""
+        self.abstract=None
+        self.full = None
+        self.finish_auto_task = False
+        self.debug_num = 0
+
+
+    def finish_auto(self):
+
+        self.finish_auto_task = True
+
+
+    def save_code(self, code):
+
+        self.code = code
+
+
+    def load_code(self):
+
+        return self.code
+
+
+    def save_user_input(self, user_input):
+
+        self.user_input = user_input
+
+
+    def load_user_input(self):
+
+        return self.user_input
+
+
+    def save_error(self, error):
+
+        self.error = error
+
+
+    def load_error(self):
+
+        return self.error
+    
+
+    def save_preprocessing_suggestions(self, suggestions):
+        
+        self.preprocessing_suggestions = suggestions
+
+
+    def load_preprocessing_suggestions(self):
+        
+        return self.preprocessing_suggestions
+        
+
+    def save_processed_df(self, processed_df):
+
+        if not isinstance(processed_df, pd.DataFrame):
+            if isinstance(processed_df, np.ndarray):
+                processed_df = pd.DataFrame(processed_df)
+            else:
+                raise TypeError(f"期望 pandas.DataFrame 或 numpy.ndarray，收到 {type(processed_df)}")
+
+        self.processed_df = processed_df
+
+
+    def load_processed_df(self):
+
+        return self.processed_df
+    
+
+    def load_refined_suggestions(self):
+        return self.refined_suggestions
+    
+
+    def save_refined_suggestions(self, refined_suggestions):
+        self.refined_suggestions = refined_suggestions
+
+
+    def refine_suggestions(self, df_head):
+        """将 LLM 返回的预处理推荐进行信息提取"""
+
+        suggestion = self.load_preprocessing_suggestions()
+
+        prompt = f"""
+        请根据以下预处理建议，概括数据集中每一列的推荐预处理方法。
+
+        数据示例:
+        {df_head}
+
+        详细预处理建议:
+        {suggestion}
+
+        输出要求（必须严格遵守）：
+        1. 输出格式：列名：推荐预处理方法；每条独立换行。
+        2. 每列最多给出三个推荐方法，多个方法用逗号分隔。
+        3. 输出必须为纯文本，不使用任何 Markdown 标记。
+        4. 每个方法的长度不得超过20个汉字，若包含英文则不超过10个单词。"""
+
+        refined_suggestions = self.call(prompt)
+        self.refined_suggestions = refined_suggestions
+
+        return refined_suggestions
+        
+
+    def get_preprocessing_suggestions(
+        self, 
+        user_input=None,
+        memory_limit=6,
+    ):
+
+        df = self.load_df()
+
+        # 基本统计
+        n_rows, n_cols = df.shape
+        dtype_counts = df.dtypes.value_counts().to_dict()
+        missing_total = int(df.isnull().sum().sum())
+        missing_by_col = df.isnull().mean().mul(100).round(2).to_dict()
+        num_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+        # 整理 memory 片段
+        recent_memory = self.memory[-memory_limit:] if self.memory else []
+        if recent_memory:
+            formatted_memory = "\n".join(
+                f"{m['role']}: {m['content']}" for m in recent_memory
+            )
+            memory_block = f"{formatted_memory}"
+        else:
+            memory_block = ""
+
+        prompt = f"""
+        你是一名资深的数据预处理专家，负责为数据分析报告提供高质量的预处理建议。
+
+        === 数据概览 ===
+        - 数据规模：{n_rows} 行 × {n_cols} 列
+        - 数据类型分布：{dtype_counts}
+        - 缺失值总数：{missing_total}
+        - 各列缺失率：{missing_by_col}
+        - 数值型列：{num_cols}
+        - 历史上下文（仅供参考）：{memory_block}
+        """
+
+        if user_input is None:
+            prompt += """
+            === 请对每一列进行逐项分析（注意，是逐列分析） ===
+            请针对每一列依次说明以下四个方面：
+
+            1. **数据类型**：明确该列的数据类型，若存在混合类型或异常值类型，请指出。
+            2. **缺失值处理建议**：说明该列的缺失值处理策略；若建议调整，请指明具体“缺失值处理 策略”操作。
+            3. **异常值处理建议**：说明该列的异常检测与处理方案；若需调整，请说明“异常值处理 策略或阈��”操作。
+            4. **标准化建议**：说明是否建议标准化或缩放，并在需要时指出“标准化处理 策略”操作。
+
+            输出格式要求：
+            - 按“列名 + 分点说明（1–4）”的形式分段输出；
+            - 每一列独立成段，并以换行分隔；
+            - 使用清晰、简洁的专业语言。
+            """
+        else:
+            prompt += f"""
+            === 用户新需求 ===
+            {user_input}
+
+            请结合以上数据概览与历史上下文，针对该需求，给出下一步操作。
+            可考虑的操作包括：缺失值处理、异常值检测与修正、标准化或归一化、特征类型调整等。
+            输出应保持结构化与连贯性，避免重复说明。
+            """
+
+        suggestions = self.call(prompt)
+
+        return suggestions
+    
+
+    def code_generation(self, df_head, user_prompt):
+        """生成 LLM prompt：要求 LLM 输出 process_df（pandas DataFrame）。"""
+        allowed = ", ".join(self.allowed_libs)
+
+        prompt = f"""
+        请**严格只输出纯 Python 代码**，不得包含以下内容：
+        - 解释性文字、注释、示例；
+        - Markdown 代码块标记（禁止出现 ``` 或 ```python 等）；
+        - 任何多余输出（如 print、全局变量赋值等）。
+
+        === 运行环境说明 ===
+        运行环境中已提供以下对象与库：
+        - pandas DataFrame 变量：`df`
+        - 库：numpy (np)、SimpleImputer、StandardScaler、MinMaxScaler、RobustScaler、
+        OneHotEncoder、OrdinalEncoder、LabelEncoder、FunctionTransformer、
+        ColumnTransformer、Pipeline。
+        若所需功能在这些库中不存在，请自行写 Python code 实现。
+
+        === 生成要求 ===
+        1. 若有用户需求，请优先满足用户需求（优先级高于 LLM 返回的通用建议）。
+        2. 若建议指出某列“无需处理”，则对该列不进行任何操作。
+        3. 禁止导入其他库、禁止文件读写。
+        4. 所有括号（圆括号、方括号、大括号）必须成对闭合，不得错位或遗漏。
+        5. 对类别特征，可使用 OneHotEncoder 或 OrdinalEncoder；
+        若为单列字符串／类别列，请使用 LabelEncoder 或 OrdinalEncoder，不得 passthrough。
+        6. 在构建 ColumnTransformer 前，需检测并处理“混合型列”
+        —— 即同时包含数值和字符串的列，
+        使用 `FunctionTransformer(lambda x: x.astype(str))` 将其统一为字符串类型。
+        7. ColumnTransformer 的 transformers 中仅包含经过上述处理的列。
+        8. 使用 OneHotEncoder 时，若输出稀疏矩阵，请确保所有输入特征均为数值类型。
+        9. 若 df 中存在重复表头（如第 0 行与 header 相同），需自动检测并删除重复表头行。
+        10. 确保预处理后的 DataFrame 中每一列均有明确列名。
+        11. 脚本最后仅保留一行结果：
+            `process_df = ...`  
+            不允许出现 print、显示语句或其他多余输出。
+
+        === 输入数据示例 ===
+        {df_head}
+
+        === 用户指定需求 ===
+        {user_prompt}
+
+        请严格依据以上要求，输出完整且可直接执行的 Python 代码（纯代码块，无额外说明）。
+        """.strip()
+
+        if self.error is not None:
+            if self.debug_num < 5 :
+                self.debug_num += 1
+
+                prompt += f"""
+                上次生成的代码运行失败。
+                【错误信息】：
+                {self.error}
+
+                【原始代码】：
+                {self.code}
+
+                请在不输出任何解释性文字的情况下，推理并理解导致错误的根本原因，
+
+                要求：
+                1. 不输出任何分析、解释或说明（包括文字、列表或注释段落）；
+                2. 可在代码内部使用简短注释说明关键修改；
+                3. 若错误源于逻辑、数据结构或函数使用不当，请自行调整；
+                4. 若依赖库方法不适用，可自行实现替代函数；
+                5. 生成的代码必须可独立运行，无语法错误；
+                6. 保持整体逻辑与原代码意图一致，仅做必要修正。
+                """
+
+            else:
+                self.debug_num = 0
+
+        if self.user_input is not None:
+            prompt += f"用户需求：{self.user_input}。\n请严格遵循并优先执行该需求，其优先级高于所有其他建议或规则。\n"
+
+        if self.refined_suggestions is not None:
+            prompt += f"LLM返回的预处理建议：{self.refined_suggestions}"
+
+        raw = self.call(prompt)
+        return raw
+
+
+    def summary_html(self):
+
+        if self.code is None:
+            summary = None
+            return summary
+
+        else:
+            processed_df = self.load_processed_df()
+            prompt = f"""
+            你正在撰写数据分析报告的第二章——《数据预处理与标准化》。
+            请根据以下输入内容，提炼关键信息并撰写相应分析段落。
+
+            - 预处理代码：
+            {self.code}
+
+            - 预处理结果（数据示例）：
+            {processed_df.head()}
+
+            {f"- 预处理建议对话记录：{self.load_memory}" if self.load_memory else ""}
+
+            撰写要求：
+            1. 使用流畅、自然的中文表达；
+            2. 语言应简洁、准确，避免过多形容词或副词；
+            3. 不使用“可能”“也许”“似乎”“微妙”等模糊表述；
+            4. 不添加大标题，可使用自然段进行叙述；
+            5. 内容需逻辑清晰，体现代码与结果之间的分析关联。
+
+            """.strip()
+
+            desc = self.call(prompt)
+
+            summary = {
+                        "title": "数据预处理",
+                        "desc": desc,
+                        "processed_df": self.processed_df.head(),
+                        "code": self.code,
+                    }
+
+        return summary
+
+
+    def summary_word(self):
+
+        return self.summary_html()
+
+
+    def check_abstract(self):
+
+        if self.abstract is None:
+
+            processed_df = self.load_processed_df()
+
+            if self.code is None:
+                self.abstract = None
+
+            else:
+
+                memory = f"【预处理建议对话记录】\n{self.load_memory}\n" if self.load_memory else ""
+
+                prompt = f"""
+                这是数据分析流程中的“数据预处理与标准化”阶段。
+
+                【预处理代码】
+                {self.code}
+
+                【预处理结果（前五行）】
+                {processed_df.head()}
+
+                {memory}
+                请在确保信息准确完整的前提下，将上述内容概括为一段简洁的文字摘要。
+                要求：
+                1. 语言自然流畅，保持客观和专业；
+                2. 内容应涵盖关键点（包括主要预处理步骤与结果特征）；
+                3. 重点在于“说明核心信息”，而非逐行描述；
+                4. 生成的摘要应可用于报告编写时判断该部分是否需要引用。
+                """.strip()
+
+                desc = self.call(prompt)
+                self.abstract = desc
+
+        return self.abstract
+
+
+    def check_full(self):
+        if self.full is None:
+            processed_df = self.load_processed_df()
+            if self.code is None:
+                self.full = None
+            else:
+                content = f"""
+                【阶段说明】这是数据分析流程中的数据预处理阶段。
+                【预处理代码】{self.code}
+                【预处理结果前五行】{processed_df.head()}
+                """.strip()
+                if self.load_memory is not None:
+                    content += f"\n【预处理建议聊天对话】{self.load_memory}"
+
+                self.full = content
+
+        return self.full

prompt_engineer/sec3_call_llm.py

@@ -0,0 +1,691 @@
+import streamlit as st
+import base64
+import plotly.graph_objs as go
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from prompt_engineer.call_llm import LLMClient
+
+import numpy as np
+np.set_printoptions(edgeitems=250, threshold=501)
+
+class VisualizationAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.cols_wo_id = None
+        self.recommendations = None
+        self.analysis = []
+        self.quick_action = None
+        self.data_meaning = ""
+        self.allowed_libs = [
+            "numpy", "plotly", "plotly.express", "plotly.graph_objects"
+        ]
+        self.code = None
+        self.result = None
+        self.suggestion = None
+        self.user_input = None
+        self.fig = []
+        self.par_content = ""
+        self.error = None
+        self.abstract=None
+        self.full = None
+        self.color = None
+        self.finish_auto_task = False
+        self.debug_num = 0
+        self.refined_suggestions = None
+
+
+    def finish_auto(self):
+
+        self.finish_auto_task = True
+
+
+    def save_user_input(self, user_input):
+
+        self.user_input = user_input
+
+
+    def load_user_input(self):
+
+        return self.user_input
+    
+
+    def save_color(self, color):
+
+        self.color = color
+
+
+    def load_color(self):
+
+        return self.color
+    
+    
+    def add_fig(self, fig, desc):
+
+        entry = {"fig": fig, "desc": desc}
+        self.fig.append(entry)
+
+
+    def load_fig(self):
+
+        return self.fig
+    
+    
+    def save_cols_wo_id(self, col):
+
+        self.cols_wo_id = col
+
+
+    def load_cols_wo_id(self):
+
+        return self.cols_wo_id
+
+
+    def save_code(self, code):
+
+        self.code = code
+
+
+    def load_code(self):
+
+        return self.code
+
+
+    def save_recommendations(self, recommendations):
+
+        self.recommendations = recommendations
+
+
+    def load_recommendations(self):
+
+        return self.recommendations
+
+
+    def save_suggestion(self, suggestion):
+
+        self.suggestion = suggestion
+
+
+    def load_suggestion(self):
+
+        return self.suggestion
+
+
+    def load_data_meaning(self):
+
+        return self.data_meaning
+
+
+    def save_error(self, error):
+
+        self.error = error
+
+
+    def load_error(self):
+
+        return self.error
+
+
+    def refine_suggestions(self, rec):
+
+        prompt = f"""
+        请根据以下详细的可视化建议，提取每一列与每个变量组的推荐可视化方法。
+
+        详细可视化建议:
+        {rec}
+
+        输出要求（必须严格遵守）：
+        1. 输出为纯文本，每条独立换行，且不得有多余说明。
+        2. 单变量格式：列名：图表1, 图表2。
+        3. 多变量格式：关系组：列A,列B：图表1, 图表2。
+        4. 总体变量格式：总体：图表1, 图表2。
+        5. 严格不要添加标题、编号、示例或额外解释。
+        6. 提取可视化方法精准。
+        """
+
+        refined_suggestions = self.call(prompt)
+        self.refined_suggestions = refined_suggestions
+
+        return refined_suggestions
+
+
+    def get_visualization_recommendations(
+        self,
+        cols,
+        user_input=None,
+        memory_limit: int = 6,
+    ) -> str:
+
+        dim_info = f"{self.df.shape[0]} 行 x {self.df.shape[1]} 列"
+
+        recent_memory = self.memory[-memory_limit:] if getattr(self, "memory", None) else []
+        if recent_memory:
+            formatted_memory = "\n".join(
+                f"{m['role']}: {m['content']}" for m in recent_memory
+            )
+            memory_block = f"{formatted_memory}"
+        else:
+            memory_block = ""
+
+        if user_input is None:
+            prompt = f"""
+            你是一位资深数据可视化专家，请根据以下信息，为数据分析报告的“可视化设计”章节提供系统、专业的建议。
+
+            【数据集信息】
+            - 数值型变量：{cols}
+            - 数据维度：{dim_info}
+            - 历史上下文（仅供参考）：{memory_block}
+
+            【输出格式】
+            请严格按照以下结构输出（保持标题和层级一致，不得增减）：
+
+            一、单变量可视化（Univariate）
+            1. 针对每个数值型变量，推荐 1–2 种最合适的可视化方法，并简要说明理由。
+            例如：
+            - `列1`：推荐“直方图（Histogram）”和“盒须图（Box Plot）”，理由：……
+
+            二、多变量关系可视化（Multivariate）
+            1. 从上述变量中选择 1–3 组值得重点分析的变量组合（每组包含 2–3 个变量），并说明选择理由。
+            例如：
+            - 关系组 1：`[列1, 列2]`，理由：……
+            2. 对每一组变量，推荐最合适的可视化方法，并简要说明。
+            例如：
+            - 关系��� 1：散点图（Scatter Plot）+ 回归线（Regression Line），理由：……
+
+            三、整体分布可视化（Distribution Overview）
+            1. 针对全数据的总体分布特征，推荐 1–2 种全局可视化方法，并说明用途。
+            例如：
+            - 推荐“小提琴图矩阵（Violin Plot Matrix）”，用途：……
+            - 推荐“热力图（Heatmap）”，用途：……
+
+            【执行要求】
+            1. 若列名无实际意义（如索引、冗余 ID），应自动过滤；
+            2. 输出内容需保持条理清晰、语言简洁、专业。
+            """.strip()
+
+        else:
+            prompt = f"""
+            你是一位资深数据可视化专家，请根据以下信息，请回应用户需求，实现用户需求：
+
+            【用户需求】
+            {user_input}
+
+            【数据集信息】
+            - 数值型变量：{cols}
+            - 数据维度：{dim_info}
+            - 数据概览（前几行）：
+            {self.df.head().to_string(index=False)}
+            - 历史上下文（仅供参考）：{memory_block}
+
+            【执行要求】
+            1. 若用户明确指定可视化列，仅针对这些列给出建议；
+            2. 若用户提出特定要求（如图形大小、坐标轴 log 缩放等），必须在输出中体现；
+            3. 仅响应用户需求，不输出无关内容；
+            4. 若用户要求对先前内容进行局部修改，应保留未更动部分，仅更新相关建议；
+            5. 输出内容应结构清晰、逻辑连贯、语言简洁。
+            6. 禁止输出代码。
+            """.strip()
+
+        recommendations = self.call(prompt)
+        return recommendations
+
+
+    def desc_fig(self, fig, dtype_info):
+
+        selected = st.session_state.selected_model
+
+        if selected == "智谱AI" or selected == "通义千问" or selected == "GPT-4o" or selected == "GPT-5" or selected == "豆包" or selected == "Claude":
+            img_bytes = fig.to_image(format="jpg")
+            fig_info = extract_plotly_info(fig)
+            base64_bytes = base64.b64encode(img_bytes)
+            base64_string = base64_bytes.decode('utf-8')
+
+            prompt_payload = [
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/jpg;base64,{base64_string}"}
+                },
+                {
+                    "type": "text",
+                    "text": f"""
+                    请综合下方可视化图与变量信息，进行**简洁但深入的分析**。
+                    从分布形态、趋势特征、变量间关系、潜在异常现象、现实含义五个角度，提炼关键洞察。
+                    输出一段不超过 120 字的自然语言分析结论（非摘要）。
+
+                    【变量信息】
+                    {dtype_info}
+
+                    【图表结构信息】
+                    {fig_info}
+
+                    写作要求：
+                    1. 分析需包含对数据异常的识别与说明：
+                    - 若存在明显异常点、异常段或突变趋势，请指出其特征与潜在影响；
+                    - 若未发现异常，也需明确说明整体分布稳定或无显著异常；
+                    2. 内容需体现推理与解释性思考，而非表面描述；
+                    3. 使用逻辑清晰、客观专业的语言；
+                    4. 使用动词驱动句式（如“呈现出”“反映出”“揭示出”“说明了”等）；
+                    5. 不使用模糊词（如“可能”“似乎”“微妙”等）；
+                    6. 不使用标题、列表或格式符号；
+                    7. 若变量含义中存在噪声或重复信息，请自动忽略；
+                    8. 保持语气简洁有力，强调数据特征与分析结论。
+                    """.strip()
+                }
+            ]
+
+            desc_fig = self.call(prompt_payload)
+
+        else:
+            prompt = f"""  
+            请综合下方可视化图与变量信息，从数据分布、趋势特征及潜在关系等角度进行分析。
+            以不超过 100 字的自然语言总结关键发现，突出该变量在整体数据结构中的意义或异常现象。
+            
+            【变量信息】
+            {dtype_info}
+
+            【图表信息】
+            {fig.to_dict()}
+
+            写作要求：
+            1. 语言应流畅自然，保持客观、专业；
+            2. 使用简洁的动词和名词，不滥用形容词或副词；
+            3. 避免“可能”“也许”“似乎”“微妙”等模糊词；
+            4. 不添加标题或列表结构；
+            5. 结合数据含义和图表特征，给出具有洞察力的简要结论；
+            6. 若变量含义中存在杂乱或重复信息，请自动忽略。
+            """.strip()
+
+            desc_fig = self.call(prompt)
+            
+        return desc_fig
+
+
+    def summary_html(self) -> str:
+        
+        analysis = self.summary_fig_analysis_list()
+
+        if analysis is None:
+            
+            return None
+
+        else:
+            analysis = {i: item for i, item in enumerate(analysis)}
+
+            summary = {
+                        "title": "数据可视化",
+                        "fig_analysis": analysis,
+                    }
+
+            return summary
+
+
+    def summary_word(self) -> str:
+        
+        analysis = self.summary_fig_analysis_list()
+
+        if analysis is None:
+            
+            return None
+
+        else:
+
+            summary = {
+                        "title": "数据可视化",
+                        "fig_analysis": analysis,
+                    }
+
+            return summary
+
+
+    def summary_fig_analysis_list(self) -> str:
+
+        if not self.code:
+            return self.analysis
+        
+        if self.analysis:
+            return self.analysis
+
+        # state_copy = dict(st.session_state)
+        selected = st.session_state.get("selected_model", "default")
+        # selected = state_copy.get("selected_model", "default")
+
+        # --- 定义单个任务 ---
+        def analyze_one(item, offset):
+            fig = item["fig"]
+            desc = item["desc"]
+
+            # 恢复状态（如果需要访问 st.session_state）
+            # st.session_state.update(state_copy)
+            selected = st.session_state.get("selected_model", "default")
+            if isinstance(fig, go.Figure):
+                if selected == "智谱AI" or selected == "通义千问" or selected == "GPT-4o" or selected == "GPT-5" or selected == "豆包" or selected == "Claude":
+                    img_bytes = fig.to_image(format="jpg")
+                    base64_string = base64.b64encode(img_bytes).decode("utf-8")
+                
+                    fig_info = extract_plotly_info(fig)
+
+                    prompt_payload = [
+                        {
+                            "type": "image_url",
+                            "image_url": {"url": f"data:image/jpg;base64,{base64_string}"}
+                        },
+                        {
+                            "type": "text",
+                            "text": f"""
+                            你正在撰写数据分析报告的第三章——《数据可视化》。  
+                            请针对下方变量，结合其**业务含义、统计特征**与**可视化图表现**，撰写一段专业、逻辑严谨、可直接用于报告正文的分析内容。
+
+                            【变量信息】
+                            {self.cols_wo_id}
+
+                            【Plotly 图表结构】
+                            {fig_info}
+
+                            【基础统计概览】
+                            {desc}
+
+                            【分析任务】
+                            请在脑中先完成以下推理步骤，然后输出结构化正文：
+                            1. 从图表识别核心模式：整体趋势、峰值、分布形态、异常点或聚集区；
+                            2. 思考该模式与变量业务含义的关系；
+                            3. 判断是否存在异常现象（单点异常、阶段性异常或结构性突变），并说明其潜在影响；
+                            4. 若图中包含其他变量，请分析它们之间的统计或逻辑关联；
+                            5. 将上述洞察整合成逻辑完整、语言自然的段落。
+
+                            【输出格式（严格遵守）】
+                            输出为纯文本，依次包含以下三部分（不使用 Markdown 或符号）：
+
+                            1. 概述  
+                            - 简述变量的定义、业务角色及数据表现的总体趋势；  
+                            - 提出该变量在整体数据结构中可能的重要性。
+
+                            2. 分布与特征分析  
+                            - 从统计与图形角度分析其分布特征（集中趋势、离散程度、偏态、峰度、周期性等）；  
+                            - 若发现异常或突变，请具体说明其表现形式与潜在机制；  
+                            - 若与其他变量有关联趋势，指出方向与强度。
+
+                            3. 实际含义与推论  
+                            - 结合业务或研究背景，解释观察到的现象；  
+                            - 分析其可能揭示的现实规律、风险或优化方向；  
+                            - 若合适，可提出合理推测或后续分析建议（保持客观与逻辑自洽）。
+
+                            【写作要求】  
+                            1. 保持语言正式、专业、逻辑紧密；  
+                            2. 句式多样、表达自然，避免模板化表述���  
+                            3. 禁用模糊词汇（如“可能”“似乎”“大概”等）；  
+                            4. 不使用任何标题符号（如 #、** 等）；  
+                            5. 不输出“AI”“模型”“助手”等字样；  
+                            6. 输出为连续正文，不包含解释性语句或附加说明。  
+                            """.strip()
+                                }
+                            ]
+
+                    analysis_text = self.call(prompt_payload)
+
+                else:
+
+                    prompt = f"""
+                            你正在撰写数据分析报告的第三章——《数据可视化》。
+                            请针对下方变量，结合其业务含义与对应的可视化图，撰写一段结构化、专业的分析文字。
+
+                            【变量信息】
+                            {self.cols_wo_id}
+
+                            【Plotly 图表信息】
+                            {fig.to_dict()}
+
+                            【基础统计概览】
+                            {desc}
+
+                            请严格按照以下格式撰写内容（使用纯文本，不使用 Markdown 语法或符号）：
+
+                            1. 概述
+                            - 说明该变量的含义及其在数据或业务中的作用；  
+                            - 简要描述整体分布特征或变量间的主要关联趋势。
+
+                            2. 分布 / 关联特征
+                            - 从统计角度说明变量的分布特征或相关关系；  
+                            - 可引用关键统计量（均值、中位数、四分位数、相关系数等）支持分析。
+
+                            3. 现实含义
+                            - 结合变量在实际情境中的意义，解释所观察到的分布或关系；  
+                            - 指出这些模式可能反映的现实现象或潜在影响（例如：某变量偏高代表风险上升或群体特征差异）。
+
+                            【写作要求】  
+                            1. 使用流畅、自然且正式的中文表达；  
+                            2. 语言应客观、简洁，避免冗余修辞；  
+                            3. 禁止使用“可能”“也许”“似乎”“微妙”等模糊词；  
+                            4. 不使用标题符号（#、** 等）；  
+                            5. 保持逻辑连贯，分析层次清晰。
+                            """.strip()
+
+                    analysis_text = self.call(prompt)
+                    print(prompt)
+                return offset, {"figure": fig, "analysis": analysis_text}
+
+        # --- 并行执行 ---
+        results = []
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [executor.submit(analyze_one, item, i) for i, item in enumerate(self.fig)]
+            for f in as_completed(futures):
+                result = f.result()
+                if result:
+                    results.append(result)
+
+        # --- 按原顺序排序 ---
+        results.sort(key=lambda x: x[0])
+        self.analysis = [r[1] for r in results]
+
+        return self.analysis
+
+
+    def code_generation(self, df_head: str, user_prompt: str) -> str:
+        """生成 LLM prompt：要求 LLM 输出 result_dict（可 JSON 序列化）。"""
+        allowed = ", ".join(self.allowed_libs)
+
+        prompt = (
+            "请**严格只输出纯 Python 代码**，**不要**输出任何解释性文字、注释、示例、markdown code fence（禁止出现 ``` 或 ```python 等）"
+            "运行环境已提供 pandas DataFrame 变量 `df`、numpy（np）、"
+            "plotly.express（px）、plotly.graph_objects（go）。\n\n"
+            "##严格要求##：\n"
+            "1) **严格执行用户需求**：若用户指定了要可视化的列，可能是精确列名，也可能是模糊输入"
+            "（如输入 “ordera” 但实际列名为 “ordertypea”），不要凭空产生虚假列名！！！"
+            f"请在脚本开头使用 LLM 理解将用户输入映射到 {df_head} 中最合适的真正列名，或采用更保守的索引（如第0列，第1列 推荐！），再仅对这些列绘制图表；\n"
+            """2) **统计并重命名**：所有类别分布图请按下面模板写，**绝不直接用** `index` 作为列名——
+            # === 模板：统计并绘制 Bar Chart ===
+            for col in categorical_cols:
+                df_counts = df[col] \\
+                    .value_counts() \\
+                    .rename_axis(col) \\
+                    .reset_index(name='count')
+                fig = px.bar(
+                    df_counts,
+                    x=col,
+                    y='count',
+                    title=f'Bar Chart of {col}',
+                    labels={col: col, 'count': 'Count'}
+                )
+                fig_dict[f'{col}_bar'] = fig
+
+            3) 智能选图：根据数据类型（数值/类别）自动选择合适的图表。
+            4) 自动检测是否需要按分类列着色，并做两种处理：若存在指定的分类列且想连续映射，先编码为数值 codes;如要离散映射，使用 parallel_categories
+            5) 如 Plotly Express 中无合适图表，使用 `go.Figure` 自定义。
+            6) 脚本末尾仅包含 `fig_dict = {...}`，不要 `print`、不要额外全局变量。
+            7) 任何情况下不得“造”列名或直接写 `'index'`；若要使用索引，必须显式使用 `df.index`。
+            8) 不要使用文件读写或其他外部 IO。
+            9) 请只给我python代码，不要给我任何'''python等非代码内容的标识符。"""
+            f"示例数据头部：\n{df_head}\n\n"
+            f"每一张图的颜色必须从{self.color}中，选择\n\n"
+            f"画图建议: {self.refined_suggestions}\n\n"
+            "返回：完整 Python 代码（纯代码块）。"
+        )
+
+        if self.error is not None:
+            if self.debug_num < 5 :
+                self.debug_num += 1
+                prompt += f"""
+                上次生成的代码运行失败。
+                【错误信息】：
+                {self.error}
+
+                【原始代码】：
+                {self.code}
+
+                请在不输出任何解释性文字的情况下，推理并理解导致错误的根本原因，
+
+                要求：
+                1. 不输出任何分析、解释或说明（包括文字、列表或注释段落）；
+                2. 可在代码内部使用简短注释说明关键修改；
+                3. 若错误源于逻辑、数据结构或函数使用不当，请自行调整；
+                4. 若依赖库方法不适用，可自行实现替代函数；
+                5. 生成的代码必须可独立运行，无语法错误；
+                6. 保持整体逻辑与原代码意图一致，仅做必要修正。
+                """
+            else:
+                self.debug_num = 0
+
+        raw = self.call(prompt)
+
+        return raw
+
+
+    def check_abstract(self):
+        if self.abstract is None:
+            # 获取所有分析内容
+            analysis_list = self.summary_fig_analysis_list()
+
+            if not analysis_list :
+                self.abstract = "暂无可视化分析内容。"
+                return self.abstract
+
+            # 合并所有分析内容为一个整体文本
+            all_analyses = "\n\n".join([
+                f"【变量分析 {i+1}】\n{item['analysis']}"
+                for i, item in enumerate(analysis_list)
+            ])
+
+            prompt = f"""
+            请阅读并综合以下多个变量的分析内容：
+            {all_analyses}
+
+            任务：
+            将这些分析整合为一段结构化、信息充分的**综合语义总结**，供后续大模型自动生成报告目录使用。
+
+            目标：
+            - 输出内容应帮助后续模型理解分析中包含的主题、变量、维度、关系与逻辑顺序；
+            - 它将作为“目录生成模型”的输入，因此必须让模型能看出报告中应有哪些章节与子章节。
+
+            写作要求：
+            1. **信息保留**：
+            - 保留每个变量的关键结论、趋势、特征、显著差异；
+            - 明确变量间的联系、对比或影响；
+            - 不得省略任何对分析主题有价值的事实。
+
+            2. **结构导向**：
+            - 按逻辑顺序组织：总体特征 → 各变量分析 → 变量间关系 → 潜在规律；
+            - 若存在不同主题（如气象因素、污染物指标、模型结果），应自然体现层次；
+            - 语义中隐含章节边界信号（如“首先…其次…最后…”、“在气象变量方面…”、“在建模部分…”等）。
+
+            3. **语言风格**：
+            - 专业、清晰、客观；
+            - 使用完整句表达，不使用列表或编号；
+            - 可以稍微详细，不追求简短。
+
+            4. **输出格式**：
+            - 输出仅为一段完整文字；
+            - 不得加入标题、注释、JSON、代码块；
+            - 该文字将被直接送入目录生成模型，不对人类展示。
+
+            请生成符合上述要求的综合语义总结。
+            """.strip()
+
+            self.abstract = self.call(prompt)
+
+        return self.abstract
+
+
+    def check_full(self):
+        """
+        返回结构化的内容，遵守图片插入协议：
+        - 每个分析内容前标注索引
+        - 图片插入位置用 [FIG:index] 表示
+        - 后续处理时可根据此协议替换为实际图像
+        """
+        if self.full is None:
+            analysis_list = self.summary_fig_analysis_list()
+
+            if not analysis_list :
+                self.full = "暂无可视化分析内容。"
+                return self.full
+
+            # 构造结构化文本：带图片插入标记
+            full_parts = ["""【阶段说明】这是数据分析流程中的数据可视化阶段。"""]
+            for i, item in enumerate(analysis_list):
+                desc = item["analysis"]
+                part = f"""
+                【对图 {i}的分析】
+                {desc}
+                [FIG:{i}]  # 图片插入位置标记
+                """.strip()
+                full_parts.append(part)
+
+            self.full = "\n\n".join(full_parts)
+
+            # 添加协议说明
+            protocol_note = """
+            ---
+            # 图片插入处理协议说明：
+            #  [FIG:index] 表示图片插入位置
+            #  index 对应分析内容中的索引
+            #  你在需要放图的地方用 [FIG:index] 代替即可
+            """.strip()
+
+            self.full = f"{self.full}\n\n{protocol_note}"
+
+        return self.full
+
+
+def extract_plotly_info(fig):
+    """
+    从 Plotly Figure（对象 / dict / 字符串）中提取关键信息：
+    - 图标题
+    - X/Y 轴标题
+    - 图类型
+    - 颜色信息
+    - trace 数量
+    """
+    import ast
+    import plotly.graph_objects as go
+
+    if isinstance(fig, go.Figure):
+        fig = fig.to_dict()
+    elif isinstance(fig, dict):
+        pass
+    elif isinstance(fig, str):
+        clean_str = fig.strip()
+        if clean_str.startswith("Figure("):
+            clean_str = clean_str[len("Figure("):-1]
+        try:
+            fig = ast.literal_eval(clean_str)
+        except Exception as e:
+            raise ValueError(f"无法解析字符串形式的 Figure: {e}")
+    else:
+        raise TypeError(f"不支持的 fig 类型: {type(fig)}")
+
+    layout = fig.get("layout", {})
+    title = layout.get("title", {}).get("text", "")
+    xaxis_title = layout.get("xaxis", {}).get("title", {}).get("text", "")
+    yaxis_title = layout.get("yaxis", {}).get("title", {}).get("text", "")
+
+    data_list = fig.get("data", [])
+    types = list({d.get("type", "") for d in data_list})
+
+
+    return {
+        "title": title or "(无标题)",
+        "xaxis": xaxis_title or "(无X轴标题)",
+        "yaxis": yaxis_title or "(无Y轴标题)",
+        "types": types,
+
+    }

prompt_engineer/sec4_call_llm.py

@@ -0,0 +1,606 @@
+import streamlit as st
+
+from prompt_engineer.call_llm import LLMClient
+
+
+class ModelingCodingAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.allowed_libs = [
+            "numpy", "sklearn.model_selection", "sklearn.preprocessing", "sklearn.ensemble", 'torch', 'torchvision', 'torchaudio', 'xgboost', 'lightgbm'
+        ]
+        self.code = None
+        self.result = None
+        self.suggestion = None
+        self.user_selection = None
+        self.par_content = ""
+        self.inference_code = None
+        self.best_model = None
+        self.inference_data = None
+        self.inference_processed_df = None
+        self.abstract=None
+        self.full = None
+        self.error = None
+        self.inference_error = None
+        self.target = None
+        self.finish_auto_task = False
+        self.best_model_gz_bytes = None
+        self.debug_num = 0
+        self.refined_suggestions = None
+
+    def finish_auto(self):
+
+        self.finish_auto_task = True
+
+
+    def save_best_model_gz_bytes(self, best_model_gz_bytes):
+
+        self.best_model_gz_bytes = best_model_gz_bytes
+
+
+    def load_best_model_gz_bytes(self):
+
+        return self.best_model_gz_bytes
+
+
+    def save_target(self, target):
+
+        self.target = target
+
+
+    def load_target(self):
+
+        return self.target
+
+
+    def save_error(self, error):
+
+        self.error = error
+
+
+    def load_error(self):
+
+        return self.error
+
+    
+    def save_inference_error(self, inference_error):
+
+        self.inference_error = inference_error
+
+
+    def load_inference_error(self):
+
+        return self.inference_error
+
+
+    def save_inference_data(self, inference_data):
+        
+        self.inference_data = inference_data
+        
+        
+    def load_inference_data(self):
+        
+        return self.inference_data
+
+
+    def save_inference_processed_df(self, inference_processed_df):
+        
+        self.inference_processed_df = inference_processed_df
+        
+        
+    def load_inference_processed_df(self):
+        
+        return self.inference_processed_df
+
+
+    def save_inference_code(self, code):
+        
+        self.inference_code = code
+        
+        
+    def load_inference_code(self):
+        
+        return self.inference_code
+
+
+    def save_best_model(self, best_model):
+        
+        self.best_model = best_model
+        
+        
+    def load_best_model(self):
+        
+        return self.best_model
+
+
+    def save_code(self, code):
+
+        self.code = code
+
+
+    def load_code(self):
+
+        return self.code
+
+
+    def save_suggestion(self, suggestion):
+
+        self.suggestion = suggestion
+
+
+    def load_suggestion(self):
+
+        return self.suggestion
+
+
+    def save_modeling_result(self, result):
+
+        self.result = result
+
+
+    def load_modeling_result(self):
+
+        return self.result
+    
+    
+    def save_user_selection(self, user_selection):
+
+        self.user_selection = user_selection
+
+
+    def load_user_selection(self):
+
+        return self.user_selection
+
+
+    def refine_suggestions(self):
+        """将 LLM 返回的预处理推荐进行信息提取"""
+
+        prompt = f"""
+        请阅读以下建模建议，并将其转化为对下一个 coding agent 的清晰建模任务指令。
+
+        === 建模建议 ===
+        {self.suggestion}
+
+        === 输出要求（必须严格遵守） ===
+        1. 输出为纯文本，不使用任何 Markdown、编号或符号；
+        2. 指令应简洁明确，便于 coding agent 直接理解并执行；
+        3. 内容应聚焦于模型构建、训练或评估的具体任务；
+        4. 避免解释性或分析性语言，仅描述“需要执行的操作”；
+        5. 输出应覆盖所有关键步骤，使 coding agent 能独立完成建模流程。
+        """.strip()
+
+        refined_suggestions = self.call(prompt)
+        self.refined_suggestions = refined_suggestions
+
+        print(refined_suggestions)
+
+        return refined_suggestions
+
+
+    def code_generation(self, df_head: str, user_prompt: str) -> str:
+        """生成 LLM prompt：要求 LLM 输出 result_dict（可 JSON 序列化）。"""
+        allowed = ", ".join(self.allowed_libs)
+
+        if self.refined_suggestions is None:
+            suggestion = user_prompt
+        else:
+            suggestion = self.refined_suggestions
+
+        prompt = (
+        f"""请**严格只输出纯 Python 代码**，**不要**输出任何解释性文字、注释、示例、markdown code fence（禁止出现 ``` 或 ```python 等）。运行环境已提供 pandas DataFrame 变量 `df`、numpy（np）、train_test_split、StandardScaler、以及用户在 Requirement 中可能提到的任意模型类（例如 RandomForestRegressor、GradientBoostingRegressor、LinearRegression、XGBRegressor、LogisticRegression、SVC 等）。
+
+        要求：
+
+        1) 使��� 80/20 切分（random_state=42），根据用户需求决定是否对数值特征标准化（StandardScaler），如果标准化，务必只应用于数值列并在训练/测试集上分别执行 fit_transform/transform。
+        2) **对 Requirement 中列出的所有模型都依次训练和评估**，不得只选随机森林；如果用户在 Requirement 中指定了多个模型名称，脚本必须循环遍历这些模型并分别训练、预测、计算指标。
+        3) 不要导入任何评价库（如 sklearn.metrics），如需评价请用 numpy 手写实现常见指标（回归：MAE、MSE、R2；分类：accuracy、precision、recall、f1）。
+        4) **脚本最后必须只输出并赋值一个变量 `result_dict`，且它是一个可以 JSON 序列化的 Python dict。**
+        推荐 schema（必须包含以下键）：
+        {{
+            "dataset": "<可选描述字符串>",
+            "models": [
+            {{
+                "name": "<模型类名>",
+                "type": "<regression 或 classification>",
+                "metrics": {{ "<指标名>": <float>, ... }}
+            }},
+            ...
+            ],
+            "best_model": {{
+            "name": "<得分最优的模型类名>",
+            "score": <float>
+            }},
+            "artifacts": {{
+            "best_model_b64": "<base64 字符串>",
+            "best_model_format": "pickle+gzip"
+            }},
+            // 如模型过大，可选 "artifact_warning": <int 字节大小>
+            // 以及用户在 Requirement 中提出的其他字段
+        }}
+        5) 确保所有数值均为 Python 原生类型（float、int），字段名严格为 models、best_model、artifacts；如果用户有额外需求，如记录训练时间、特征重要性等，也请加入 result_dict。
+        6) 模型导出：训练完毕后，将选定的 best_model 用 pickle 序列化并 gzip 压缩，再 base64 编码；把编码字符串和格式信息填入 result_dict["artifacts"]，并确保最终 result_dict 可 JSON 序列化。
+        7) 脚本末尾仅包含一行 `result_dict = {{...}}`，不要 print、不创建其他全局变量、不读写文件。
+        8) 如果模型序列化后的字节数超过合理大小，请在 result_dict 中添加 `"artifact_warning": <字节数>`。
+        9) 不要使用任何外部 IO 或文件操作。
+        10) 请准确实现Requirement中要求的模型，不许添加Requirement之外的模型，若先提供的库中无法直接调用对应模型，请手动实现！
+
+        示例数据头部：
+        {df_head}
+
+        Requirement（请根据以下建模任务指令，对所有列出的模型依次执行训练与评估。若某模型在当前环境不可用，请手动实现对应算法或类，使结果完整可复现）：
+        {suggestion}
+
+        Allowed libraries: {allowed}。
+
+        返回：完整 Python 代码（纯代码块）。"""
+        )
+
+        if self.error is not None:
+            if self.debug_num < 5 :
+                self.debug_num += 1
+                prompt += f"""
+                上次生成的代码运行失败。
+                【错误信息】：
+                {self.error}
+
+                【原始代码】：
+                {self.code}
+
+                请在不输出任何解释性文字的情况下，推理并理解导致错误的根本原因，
+
+                要求：
+                1. 不输出任何分析、解释或说明（包括文字、列表或注释段落）；
+                2. 可在代码内部使用简短注释说明关键修改；
+                3. 若错误源于逻辑、数据结构或函数使用不当，请自行调整；
+                4. 若依赖库方法不适用，可自行实现替代函数；
+                5. 生成的代码必须可独立运行，无语法错误；
+                6. 保持整体逻辑与原代码意图一致，仅做必要修正。
+                """
+            else:
+                self.debug_num = 0
+
+        raw = self.call(prompt)
+
+        return raw
+
+
+    def result_format_prompt(self, result_json: str) -> str:
+        """生成 LLM prompt：要求 LLM 输出 result_dict（可 JSON 序列化）。"""
+
+        prompt = f"""
+                下面给出一个 JSON 对象（包含模型评估结果结构）。请将其转换为一份对人类友好的 Markdown 报告，输出要求如下：
+
+                === 输出要求 ===
+                1. 报告开头需有一行简短的“数据集说明”。
+                2. 对每个模型，展示以下内容：
+                - 模型名称；
+                - 模型类型（分类 / 回归）；
+                - 主要性能指标（如准确率、R²、MAE、MSE 等），每个指标保留 4 位小数；
+                - 建议使用表格或分点列表清晰呈现。
+                3. 明确标出 **best_model**（以粗体高亮显示其名称和最优指标）。
+                4. 若 JSON 中包含特征工程相关信息，���在“特征工程说明”部分详细描述其具体方法与作用。
+                5. 输出格式：
+                - 只返回 Markdown 文本；
+                - 不得使用任何代码块标记（如 ```、```markdown 等）；
+                - 不输出解释性文字，仅输出最终报告内容（便于直接渲染于 Streamlit）。
+
+                === 输入 JSON ===
+                {result_json}
+                """.strip()
+
+        raw = self.call(prompt)
+
+        return raw
+
+
+    def get_model_suggestion(
+        self,
+        user_input=None,
+        memory_limit: int = 6,  # 控制引入的 memory 轮数
+    ) -> str:
+        """
+        根据数据集与历史上下文，生成建模阶段的智能建议。
+        自动整合 memory（最近几轮对话）作为辅助上下文。
+        """
+
+        # === 加载基础数据 ===
+        df = self.load_df()
+        df_head = df.head().to_string(index=False)
+        columns = df.columns.tolist()
+        data_info = f"数据列名: {columns}\n\n数据前5行:\n{df_head}"
+
+        # === 整理 memory 片段 ===
+        recent_memory = self.memory[-memory_limit:] if getattr(self, "memory", None) else []
+        if recent_memory:
+            formatted_memory = "\n".join(
+                f"{m['role']}: {m['content']}" for m in recent_memory
+            )
+            memory_block = f"\n=== 历史上下文（仅供参考） ===\n{formatted_memory}\n"
+        else:
+            memory_block = ""
+
+        # === 主 prompt 组装 ===
+        prompt = f"""
+        你是一位资深的机器学习建模专家，请基于以下信息进行分析与推理，输出针对性建模建议或改进方案。
+
+        === 数据信息 ===
+        {data_info}
+
+        === 历史上下文（仅供参考） ===
+        {memory_block}
+        """.strip()
+
+        # 若用户有明确建模目标
+        if getattr(self, "target", None):
+            prompt += f"""
+            
+            === 建模目标 ===
+            {self.target}
+            （请务必满足该目标，并在回答中明确复述建模意图。）
+            """
+
+        # 若用户额外输入了需求
+        if user_input:
+            prompt += f"""
+            
+            === 用户当前需求 ===
+            {user_input}
+            （请严格满足该需求。若为局部修改，请保留原逻辑，仅更新指定部分。）
+            """
+
+        # 若有之前生成的训练代码
+        train_code = self.load_code()
+        if train_code:
+            prompt += f"""
+
+            === 历史训练代码 ===
+            {train_code}
+
+            请在充分理解上述代码的基础上，提出 **1–2 条高质量的模型改进建议**。
+            可从以下角度思考，但不限于此：
+            - 模型结构优化（如增加层数、调整激活函数、替换模型类型等）；
+            - 特征工程改进（如变量选择、特征交互、归一化策略等）；
+            - 训练流程优化（如正则化、学习率调度、损失函数调整等）；
+            - 超参数调整（如树深度、学习率、batch size 等）。
+            在给出建议时，请简要说明“为什么”与“预期改进效果”。
+            """
+        else:
+            prompt += """
+            
+            === 建模建议任务 ===
+            请根据数据特征和上下文，推荐 2–3 个适合的模型方案。
+            要求：
+            1. 每个模型需包含模型名称、主要原理、适用场景；
+            2. 指出其在当前任务中的优势与潜在局限；
+            3. 保持语言专业、简洁，不输出代码。
+            """
+
+
+        # # === 主 prompt 组装 ===
+        # prompt = f"""
+        # 你是一位资深的机器学习建模专家。
+
+        # 以下是用户的数据信息：
+        # {data_info}
+
+        # {memory_block}
+        # """.strip()
+
+        # # 若用户有明确建模目标
+        # if getattr(self, "target", None):
+        #     prompt += f"\n\n建模目标：{self.target}（务必满足，并请在回答中复述）"
+
+        # # 若用户额外输入了需求
+        # if user_input:
+        #     prompt += f"""\n\n用户的当前需求：{user_input}（务必满足！）
+        #     若用户的要求是局部更新，则保留先前内容，仅修改特定部分。"""
+
+        # # 若有之前生成的训练代码
+        # train_code = self.load_code()
+        # if train_code:
+        #     prompt += f"""
+            
+        #     用户之前生成的训练代码：
+        #     {train_code}
+
+        #     请在理解该代码的基础上，提供 **1–2 条模型改进建议**，
+        #     可涉及但不限于：
+        #     - 模型结构调整
+        #     - 特征工程优化
+        #     - 模型替换（例如从树模型切换为深度学习模型）
+        #     - 超参数调整或正则化策略优化
+        #     """
+        # else:
+        #     prompt += """
+            
+        #     请基于数据特征，推荐 2–3 个合适的模型，
+        #     并说明每个模型的适用场景和优劣分析。
+        #     """
+
+        # # 若存在以往建模结果
+        # modeling_result = self.load_modeling_result()
+        # if modeling_result:
+        #     prompt += f"\n\n用户之前的模型运行结果：\n{modeling_result}"
+
+        # === 调用 LLM ===
+        raw = self.call(prompt)
+        return raw
+
+    
+    
+    def summary_html(self) -> str:
+
+        if self.code is None:
+            
+            summary = None
+
+            return summary
+
+        else:
+
+            prompt = f"""
+            你正在撰写数据分析报告的**第四章：数据建模**。
+            请根据以下输入内容，综合分析并生成完整的章节正文。
+            内容需逻辑严谨、表达自然，体现专业的分析与总结能力。
+
+            === 输出结构 ===
+            请严格按照以下五个小节组织内容：
+
+            1. 概述
+            - 说明本次建模的目标、研究背景及数据来源的上下文。
+
+            2. 方法说明
+            - 介绍所采用的模型或算法的核心思想与实现流程；
+            - 若涉及特征工程、超参数选择或数据预处理，请一并说明；
+            - 可适当涉及模型的数学原理或优化机制，以体现技术深度。
+
+            3. 关键代码解读
+            - 聚焦核心函数与模块，说明其在建模流程中的作用；
+            - 可提及模型结构定义、训练循环、损失函数与评估逻辑；
+            - 语言应清晰简练，避免逐行解释。
+
+            4. 结果与评估
+            - 概述主要性能指标（如 Accuracy、AUC、MSE 等）及结果表现；
+            - 分析模型效果是否符合预期，并指出主要优劣与瓶颈。
+
+            5. 改进建议
+            - 针对模型性能与实验发现，提出具体可行的优化方向；
+            - 可从模型结构、特征选择、训练策略或正则化等角度给出建议。
+
+            === 写作要求 ===
+            1. 使用自然流畅、正式的书面表达；
+            2. 避免使用模糊或主观词汇（如“可能”“似乎”“微妙”等）；
+            3. 注重逻辑连贯与专业性；
+            4. 不输出标题、列表标记或额外说明，只生成正文内容。
+            """.strip()
+
+            if self.code is not None:
+                prompt += f"=== 数据建模代码 ===\n\n{self.code}"
+            if self.target is not None:
+                prompt += f"=== 用户建模目标 ===\n\n{self.target}"
+            if self.load_memory is not None:
+                prompt += f"=== 数据建模聊天对话 ===\n\n{self.load_memory}"
+            if self.result is not None:
+                prompt += f"=== 建模运行结果 ===\n\n{self.result}"
+            
+            desc = self.call(prompt)
+
+            summary = {
+                        "title": "建模分析",
+                        "code": self.code,
+                        "desc": desc,
+                        "result": self.result,
+                    }
+
+            return summary
+
+
+    def summary_word(self) -> str:
+
+        return self.summary_html()
+
+
+    def code_generation_for_inference(self, code, inference_df_head) -> str:
+        """生成 LLM prompt：要求 LLM 输出推断分析代码。"""
+        
+        prompt = (
+        f"""请生成完整的 Python 推断分析脚本（仅返回代码，不要任何解释文字）。运行环境已提供 pandas DataFrame 变量 `inference_df`、已经 train 好的模型 `model_obj`、numpy（np）、StandardScaler 库、align_features 辅助函数，其余未提及的库请手写实现。要求：
+
+        示例数据信息：
+        {code}, inference_df 前五行: {inference_df_head}（请勿引入不存在 inference_df 中的变量）
+
+        1) **可用变量说明：**
+        - `inference_df`：推断数据集（Pandas DataFrame）
+        - `model_obj`：已训练好的模型对象（从best_model.joblib加载）
+        - `np`：NumPy库
+        - `pd`：Pandas库
+        - `StandardScaler`：用于数据标准化的sklearn工具
+
+        2) **脚本必须实现的功能：**
+        a) 对推断数据进行与训练时完全一致的预处理（例如，缺失值处理、编码转换、标准化等）
+        b) **关键步骤：在预测前，必须使用align_features函数处理特征数据，确保特征数量和顺序与训练时一致**
+        c) 使用model_obj对预处理并对齐后的特征数据进行预测
+        d) 生成详细的推断报告，包含预处理步骤、预测结果分析等
+
+        3) **预测结果处理要求：**
+        - 将模型输出转换为人类可理解的形式（如概率值、类别标签、数值结果等）
+        - **必须生成带预测结果的DataFrame**：将��始或处理后的`inference_df`与预测结果合并，命名为`inference_df_with_predictions`
+        - 合并后的DataFrame必须包含原始特征列和一列名为`'prediction'`的预测结果列（模型输出多维时扩展为`prediction_0`, `prediction_1`, ...）
+
+        4) **序列化要求（用于前端下载）：**
+        - 将`inference_df_with_predictions`转换为无索引的CSV格式
+        - 对CSV数据进行gzip压缩，然后编码为base64字符串
+        - 创建包含以下键的`result_dict['artifacts']`字典：
+          * `'predictions_df_b64'`：base64编码的压缩数据
+          * `'predictions_df_format'`：固定值'csv+gzip'
+          * `'predictions_df_size_bytes'`：压缩后的字节大小（整数）
+        - 在`result_dict`中添加`'predictions_df_records'`键，值为`inference_df_with_predictions.to_dict(orient='records')`
+        - 确保所有numpy/pandas类型转换为原生Python类型（int/float/str）以保证JSON可序列化
+
+        5) **代码结构与输出约束：**
+        - 脚本最后**仅**包含一行`result_dict = {...}`语句
+        - `result_dict`必须是完全JSON可序列化的Python字典
+        - 禁止任何外部IO操作（不读写文件）
+        - 禁止使用print语句或创建额外的全局变量
+
+        8) **生成代码质量要求：**
+        - 确保所有变量名称与上述规范严格一致
+        - 逻辑清晰，步骤完整，严格按照用户提供的数据和最佳模型文件生成代码
+        - 处理可能出现的各种异常情况，提高代码的稳定性和可靠性
+
+        返回：完整的Python代码（仅包含代码本身，不要任何解释性文字）。"""
+        )
+        
+        raw = self.call(prompt)
+        
+        return raw
+
+
+    def check_abstract(self):
+        if self.abstract is None:
+            if self.code is None:
+                self.abstract = None
+            else:
+                prompt = f"""
+                这是数据分析流程中的“建模阶段”。
+
+                请基于以下信息，在保留所有关键信息的前提下，将内容整理成一段简洁、连贯的文字摘要，用于报告撰写中的建模小节预览。
+
+                === 输入信息 ===
+                - 用户初始需求：{self.target}
+                - 建模代码：{self.code}
+                - 建模阶段的交互记录：{self.load_memory}
+                - 建模运行结果：{self.result}
+
+                === 输出要求 ===
+                1. 以自然流畅的语言撰写一段总结，全面涵盖上述内容中的核心信息；
+                2. 重点说明建模目标、所用方法、主要实现逻辑与结果特征；
+                3. 避免逐行描述代码，仅提炼核心思路；
+                4. 语言应专业、客观，不使用“可能”“似乎”“也许”等模糊表达；
+                5. 输出仅为一段完整文字（不要标题、编号或列表）；
+                6. 摘要应能让人据此判断该部分是否需要纳入最终报告。
+                """.strip()
+
+                desc = self.call(prompt)
+                self.abstract = desc
+
+        return self.abstract
+
+
+    def check_full(self):
+        if self.full is None:
+            if self.code is None:
+                self.full = None
+            else:
+                self.full = f"""
+                【阶段说明】这是数据分析流程中的数据建模阶段。
+                【用户初始需求】{self.target}
+                【数据建模代码】{self.code}
+                【建模聊天对话】{self.load_memory}
+                【建模运行结果】{self.result}
+                """.strip()
+
+        return self.full

prompt_engineer/sec5_call_llm.py

@@ -0,0 +1,617 @@
+import streamlit as st
+import openai
+import requests
+import json
+import re
+import pandas as pd
+import numpy as np
+
+from config import MODEL_CONFIGS
+from prompt_engineer.call_llm import LLMClient
+
+
+class ReportAgent(LLMClient):
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.template = None
+        self.name = None
+        self.date = None
+        self.report_format = None
+        self.html = None
+        self.word = None
+        self.markdown = None
+        self.user_input = None
+        self.outline = None
+        self.outline_length = None
+        self.report= None
+        self.finish_auto_task = False
+        self.gen_mode = None
+
+
+    def save_gen_mode(self, gen_mode):
+
+        self.gen_mode = gen_mode
+
+
+    def load_gen_mode(self):
+
+        return self.gen_mode 
+
+
+    def finish_auto(self):
+
+        self.finish_auto_task = True
+
+
+    def save_user_input(self, user_input):
+
+        self.user_input = user_input
+
+
+    def load_user_input(self):
+
+        return self.user_input
+    
+    
+    def save_outline_length(self, outline_length):
+
+        self.outline_length = outline_length
+
+
+    def load_outline_length(self):
+
+        return self.outline_length
+
+
+    def save_outline(self, outline):
+
+        self.outline = outline
+
+
+    def load_outline(self):
+
+        return self.outline
+
+
+    def save_template(self, template):
+
+        self.template = template
+
+
+    def load_template(self):
+
+        return self.template
+
+
+    def save_word(self, word):
+
+        self.word = word
+
+
+    def load_word(self):
+
+        return self.word
+
+
+    def save_html(self, html):
+
+        self.html = html
+
+
+    def load_html(self):
+
+        return self.html
+
+
+    def save_markdown(self, markdown):
+
+        self.markdown = markdown
+
+
+    def load_markdown(self):
+
+        return self.markdown
+    
+
+    def save_report(self, report):
+
+        self.report = report
+
+
+    def load_report(self):
+
+        return self.report
+
+
+    def save_report_format(self, report_format):
+
+        self.report_format = report_format
+
+
+    def load_report_format(self):
+
+        return self.report_format
+
+
+    def save_date(self, date):
+
+        self.date = date
+
+
+    def load_date(self):
+
+        return self.date
+    
+    
+    def save_name(self, name):
+
+        self.name = name
+
+
+    def load_name(self):
+
+        return self.name
+    
+
+    def generate_template(self, user_input = None) -> str:
+        """
+        调用 LLM 生成一个带有占位符的 HTML 报告模板，
+        包含标题、摘要、表格和图表区域等。
+        """
+        prompt = (
+        """
+        我希望你输出一个现代、简洁且美观的 HTML 章节模板，请满足以下要求：
+
+        1. 整体配色采用“蓝 – 白”主题：
+        - 背景为白色，标题与边框使用深蓝（#1E3A8A）和浅蓝（#3B82F6）；
+        2. 最外层用 `<section class="chapter" id="chapter-{{ num }}">` 包裹；
+        3. 标题使用 `<h2>{{ title }}</h2>`：
+        - 文字颜色：#1E3A8A；
+        - 下方装饰性下划线：高度 3px，颜色 #3B82F6，宽度 30%；
+        4. 正文内容区 `<div class="content">{{ body }}</div>`，支持任意 HTML；
+        - **仅对“重点摘录”或“引用”段落加用圆角矩形**，其余普通段落保持标准 `<p>` 样式；
+        - 圆角矩形样式：背景 #EFF6FF，padding 12px，border-radius 8px，margin-bottom 16px；
+        5. 如果有图片列表 `images`：
+        - ≤3 张时水平并排；>3 张时自动换行，每行最多 3 张；
+        - `<img>` 带 6px 圆角、轻微阴影 `box-shadow:0 2px 6px rgba(0,0,0,0.1)`；
+        6. 在 `<style>` 中内联基础样式：
+        - `.chapter` 外层间距、内边距、最大宽度、白底阴影；
+        - `.chapter h2` 字体、颜色、下划线；
+        - `.content p` 和 `.content .highlight`（重点段落）样式区分；
+        - `.images` 的 flex 布局与 gap；  
+        7. 使用 Jinja2 占位符：
+        - 普通段落：`{% for p in paragraphs %}<p>{{ p }}</p>{% endfor %}`；
+        - 重点段落数组 `highlights`：`{% for h in highlights %}<div class="highlight">{{ h }}</div>{% endfor %}`；
+        8. **只输出完整的 `<section>…</section>` 片段**，不要任何解释文字或其他标签。
+        9. 在模板的 .content 区域加入一个 DataFrame 占位并用 Jinja2 渲染变量 df_html（{{ df_html | safe }}），要求输出为响应式 HTML 表格（显示表头、支持横向滚动并在窄屏下自动换行），以便在导出为 PDF 时正确排版。
+
+        请直接给出最终的 HTML 模板代码。
+        """
+        )
+
+        if user_input is not None:
+            prompt += f"请根据用户需求进行调整{user_input}"
+
+        return self.call(prompt)
+
+
+    def fill_report(self, template: str, content: str) -> str:
+        """
+        将 DataFrame 转为 HTML 表格，拼接进模板，
+        并让 LLM 对报告进行润色、补充解释文字。
+        """
+
+        prompt = (f"""  
+            下面是章节结构模板：
+            {template}
+            请仅输出 `<section>` 里完整的 HTML（包括标题、正文、图片区块），请将重点内容用highlight凸显，
+            对于内容的分析具有一下要求：
+            1. 要用流畅的自然语言
+            2. 不要滥用形容词和副词，尽量用简单的动词和名词表达意思
+            3. 不用"可能""也许""似乎""微妙"等模糊表述
+            请根据一下提供的信息对文章进行深入分析：
+            """)
+
+        if content.get("title") is not None:
+            prompt += f"- title={content['title']}\n"
+        if content.get("fig_analysis") is not None:
+            prompt += f"- images及其分析（请将image也放入报告中）：{content['fig_analysis']}\n"
+        if content.get("df") is not None:
+            prompt += f"- 表格预览（请将表格也放入报告中，输出美观完整）：{content['df']}\n"  
+        if content.get("code") is not None:
+            prompt += f"- 对应部分代码（请将代码中的重点公式与内容进行讲解与分析）：{content['code']}\n"  
+        if content.get("processed_df") is not None:
+            prompt += f"- 预处理后的数据预览：{content['processed_df']}\n"  
+        if content.get("desc") is not None:
+            prompt += f"- 具体内容分析：{content['desc']}\n"  
+        if content.get("header") is not None:
+            prompt = f"""
+            下面是章节结构模板：
+            {template}
+            要求：header单独占一页
+            - 请为我生成封面header：{content['header']}
+            """
+        if content.get("footer") is not None:
+            prompt = f"""
+            下面是章节结构模板：
+            {template}
+            要求：footer单独占一页
+            - 请为我生成最后一页footer：{content['footer']}
+            """
+
+        prompt += "请仅返回提供html"
+
+        return self.call(prompt)
+
+
+    def fill_report_word(self, content: str) -> str:
+
+
+        prompt = (f"""  
+            你是一个资深的数据分析专家，
+            请仅输出每一章节的完整的word内容（包括标题、正文、图片区块），
+            对于内容的分析具有一下要求：
+            1. 要用流畅的自然语言
+            2. 不要滥用形容词和副词，尽量用简单的动词和名词表达意思
+            3. 不用"可能""也许""似乎""微妙"等模糊表述
+            请根据一下提供的信息对文章进行深入分析：
+            """)
+
+        if content.get("title") is not None:
+            prompt += f"- title={content['title']}\n"
+        if content.get("fig_analysis") is not None:
+            prompt += f"- images及其分析（请将image也放入报告中）：{content['fig_analysis']}\n"
+        if content.get("df") is not None:
+            prompt += f"- 表格预览（请将表格也放入报告中，输出美观完整）：{content['df']}\n"  
+        if content.get("code") is not None:
+            prompt += f"- 对应部分代码（请将代码中的重点公式与内容进行讲解与分析）：{content['code']}\n"  
+        if content.get("processed_df") is not None:
+            prompt += f"- 预处理后的数据预览：{content['processed_df']}\n"  
+        if content.get("desc") is not None:
+            prompt += f"- 具体内容分析：{content['desc']}\n"  
+        if content.get("header") is not None:
+            prompt = f"""
+            下面是章节结构模板：
+            {template}
+            要求：header单独占一页
+            - 请为我生成封面header：{content['header']}
+            """
+        if content.get("footer") is not None:
+            prompt = f"""
+            下面是章节结构模板：
+            {template}
+            要求：footer单独占一页
+            - 请为我生成最后一页footer：{content['footer']}
+            """
+
+        prompt += "请仅返回提供html"
+
+        return self.call(prompt)
+
+
+    def get_content(self, agent):
+
+        content = agent.summary()
+
+        return content
+
+    def generate_toc_from_summary(self, full_summary) -> str:
+        """
+        调用大模型，根据已有 summary 内容自动生成带有分级结构与内容大纲的目录（最多 2 级标题）
+        """
+
+        prompt = f"""
+        你是一位资深数据分析报告结构设计专家。
+
+        请你根据以下报告摘要内容，为该数据分析报告生成**层次清晰、内容具体、贴合数据本身**的目录结构。
+
+        【输出要求】
+        1. 格式：
+        - 纯文本输出（不得使用 Markdown、代码块、Python 列表或符号标记）
+        - 每行一个目录项，无缩进或前缀符号
+        - 示例格式：
+            1.概述（说明报告背景与目标）
+            2.数据导入（说明数据来源与结构）
+            2.1 数据概览（展示核心字段与样本规模）
+            2.1.1 租赁数量趋势（分析租赁随时间的变化）
+        2. 编号规则：
+        - 一级标题：1, 2, 3...
+        - 二级标题：2.1, 2.2...
+        - 三级标题：2.1.1, 2.1.2...
+        3. 内容说明：
+        - 所有标题与说明应以摘要为基础，可在保持主题一致的前提下，适度补充逻辑性或结构性内容。
+        - 每个标题后附一句说明，用于指导后续大模型撰写章节内容；
+        - 说明须以中文括号“（ ）”包裹；
+        - 每条说明需精准、具体，**明确指示该部分的写作任务、分析角度、数据焦点或方法方向**；
+        - 字数不超过 50 字；
+        - 上下级说明应保持语义连贯，避免重复；
+        - 说明可涉及：
+            - 要分析的变量或主题（如“气温”“租赁数量”“污染物浓度”）；
+            - 要执行的任务（如“展示分布”“分析趋势”“比较模型性能”）；
+        4. 禁止输出任何解释、前言、说明、提示、或多余空行，仅输出目录正文。
+
+        【生成逻辑】
+        1. 依据摘要内容中出现的主题（如数据特征、指标、变量名、任务目标）生成章节标题。
+        - 若摘要中提及 “租赁数量”“气温”“湿度”“时间”等，请将其体现在相关标题中。
+        - 避免使用模糊标题（如“数据分析”“关系探索”“模型评估”等）。
+        2. 报告可能包含模块：
+        “数据导入”、“数据预处理”、“数据可视化”、“建模分析”。
+        - 仅生成摘要中实际涉及的模块。
+        3. 确保章节间语义互斥（正交），避免内容重叠。
+        4. 根据详细程度动态调整层级：
+        - 简要：生成两级标题；
+        - 标准：生成三级标题；
+        - 详细：生成四级标题。
+        5. 若摘要涉及具体变量（如“Temperature”、“Rented Bike Count”），
+        请在目录中直接引用中文变量名（如“气温”、“租赁数量”），
+        以体现报告的“数据感知性”。
+
+        用户选择的目录详细程度为：{self.outline_length}
+
+        报告摘要如下：
+        {full_summary}
+        """
+
+
+        toc_response = self.call(prompt)
+        return toc_response.strip()
+
+
+    def selected_photo_update_toc(self, toc, selected_full_contents_vis: str) -> list:
+        """
+        根据完整报告内容 selected_full_contents_vis，更新 toc，在每个小节增加第四项：对应的图像编号列表。
+        """
+        print(selected_full_contents_vis)
+
+        prompt = f"""
+        你是一位专业的数据分析报告结构与图文匹配专家。
+
+        任务：请你根据报告的目录结构和，正文内容和阶段说明，判断每个 [FIG:x] 图像最合适归属的章节。
+
+        【输入内容】
+        1. 目录结构（含标题、层级、内容大纲）：
+        {toc}
+
+        2. 报告完整正文（带有 [FIG:x] 图片标记）：
+        {selected_full_contents_vis}
+
+        【任务说明】
+        请你逐一分析每个 [FIG:x] 图像的出现上下文，并结合目录内容，判断该图应归属于哪个章节。  
+        要求同时考虑：
+        - **语义匹配**：图像内容的主题（如污染物趋势、气象变化、时间分布、模型结果）与章节描述的一致性；
+        - **上下文位置**：图像在正文中出现时，其前后段落通常属于哪个章节；
+        - **粒度优先**：若图像语义符合多个章节（如“气象参数”与“气象参数图形分析”），优先归入更具体的章节（层级数字更大）；
+        - **禁止误归**：禁止将图像分配到“概述”“结论”“摘要”等非分析或与图像不相关的章节！
+        - **全部使用**：所有 [FIG:x] 必须被使用一次，不得遗漏或重复。
+
+        【输出格式】
+        请以 Python 列表形式输出，每项为：
+        (标题, 层级, 内容大纲, 图编号列表)
+        要求：
+        - 图编号按出现顺序排列；
+        - 若无图片则为空列表 [];
+        - 层级仅用整数表示（1, 2, 3...）；
+        - 不输出任何解释、注释、Markdown标记。
+
+        【示例格式】
+        [
+        ('概述',1,'说明报告背景与目标',[]),
+        ('数据导入',1,'说明数据来源与结构',[]),
+        ('数据可视化',1,'展示变量特征与关系',[4,5]),
+        ('气象参数分析',2,'研究温度与湿度对污染的影响',[2,3]),
+        ('模型评估',2,'展示预测结果与误差',[6,7])
+        ]
+
+        【提示与约束】
+        1. 若章节间存在嵌套关系，优先分配���最具体的子章节（如 3.1.2 比 3.1 更优）。
+        """
+
+        toc_with_figs = self.call(prompt)
+        return toc_with_figs.strip()
+
+
+    def summarize_all_sections(
+        self,
+        toc_md: str,
+        load_summary: str,
+        preproc_summary: str,
+        visual_summary: str,
+        coding_summary: str
+    ) -> str:
+        """
+        汇总所有 agent 的 summary，并根据 toc_md 结构进行文字性总结
+        """
+
+        # Step 1：拼接所有 agent 的摘要
+        section_summaries = {
+            "加载阶段": load_summary,
+            "预处理阶段": preproc_summary,
+            "可视化分析": visual_summary,
+            "模型建构": coding_summary,
+        }
+
+        # Step 2：构建大模型 prompt
+        prompt = f"""你现在是一个经验丰富的数据分析报告撰写助手。
+
+        我已经完成了一个数据分析项目的初稿，结构目录如下：
+        {toc_md}
+
+        现在我将为你提供各个章节的内容摘要，请你根据这些内容，用流畅的中文撰写一段总结性描述（可用于报告的导语或结语），要求包括但不限于：
+
+        1. 报告分析的主题方向  
+        2. 各章节的核心处理逻辑和大致作用  
+        3. 报告内容的整体风格与结构特性（例如是否包含图表、是否强调建模等）  
+        4. 使用自然语言、风格正式，避免主观判断词汇（如“也许”、“不错”、“感觉”）  
+        5. 最终输出 150~300 字中文总结段落，不需要标题  
+
+        每个阶段摘要如下：\n\n"""
+
+        for title, content in section_summaries.items():
+            if content:
+                prompt += f"\n【{title}】\n{content}\n"
+
+        # 调用大模型总结
+        overall_summary = self.call(prompt)
+
+        return overall_summary
+
+
+    def update_toc_with_relevant_sections(self, toc, agent_abstracts):
+        """
+        根据 toc 和各模块摘要，为每个章节生成应参考的模块编号列表，
+        并将结果添加为第五项。
+        """
+        prompt = f"""
+        你是一个专业的数据分析报告规划助手。
+        我将提供报告目录和各分析模块的摘要，请为每个章节确定应参考的模块编号列表。
+        
+        报告目录（每个元素为四元组：标题、层级、内容大纲、图编号列表）：
+        {toc}
+
+        各数据分析模块摘要如下：
+        {agent_abstracts}
+        请根据：
+        1. 各章节的标题、层级与内容大纲；
+        2. 各数据处理板块摘要；
+        3. 各章节的图编号分配情况（报告目录第四项）；
+
+        合理判断各章节在生成报告时应参考哪些数据处理板块的信息。
+        输出要求：
+
+        - 对每个章节生成一个五元组 (标题, 层级, 内容大纲, 图编号列表, 模块编号列表)
+            - 标题, 层级, 内容大纲, 图编号列表一定不能改变，只在原有基础上添加第五项
+        - 模块编号列表为 Python list，例如 [0, 2]
+        - 若无需参考任何模块，返回 []
+        - 输出为 Python 列表，不含任何额外说明
+        示例：
+        输入：
+        [
+          ('概述',1,'介绍报告背景与目标',[1]),
+          ('数据可视化',1,'分析空气质量和相关环境变量的可视化图表',[2,3]),
+          ('xxxx关联性分析',2,'分析相对湿度与其他污染物关系',[4,5])
+        ]
+        输出：
+        [
+          ('概述',1,'介绍报告背景与目标',[1],[1,2]),
+          ('数据可视化',1,'分析空气质量和相关环境变量的可视化图表',[2,3],[0,1]),
+          ('xxxx关联性分析',2,'分析相对湿度与其他污染物关系',[4,5],[2,3])
+        ]
+        """
+        toc_with_sections = self.call(prompt)
+        print(toc_with_sections)
+        return toc_with_sections.strip()
+
+
+    def write_section_body(self, toc, t, selected_full_contents, history_content):
+
+        prompt = f"""
+        你是一个专业的数据分析报告撰写助手。你的任务是基于我提供的参考信息，生成逻辑清晰、结构严谨、内容专业的报告章节。
+
+        当前章节信息（四元组：标题、层级、内容大纲、图编号列表）：
+        {t}
+
+        报告目录结构（包含所有章节的四元组信息）：
+        {toc}
+
+        可参考的分析内容如下：
+        {selected_full_contents}
+
+        此前已生成的章节内容如下（用于保持整体风格一致、避免重复）：
+        {history_content}
+
+        写作要求：
+
+        一、写作目标
+        1. 仅撰写当前章节“{t[0]}”的正文内容；
+        2. 内容必须以“参考信息”为核心依据，可在其逻辑框架内**进行适度拓展与归纳总结**；
+        3. 允许进行合理的专业性补充（如统计学解释、方法原理、结果含义），但**禁止编造具体数据、图表结果、实验场景或样本特征**；
+        4. 若参考信息不足，可补充一般性分析思路，但需保持内容通用、客观、抽象，不得具体化为假想数据。
+
+        二、语言与结构
+        1. 文风应正式、专业、学术化；
+        2. 论述应符合数据分析逻辑：先描述、后解释、再总结；
+        3. 每一自然段应围绕一个逻辑核心展开（如趋势、对比、相关性、分布特征等）。
+
+        三、图表使用规范
+        1. 正文中仅可使用本章节的图编号 {t[3]}；
+        2. 使用占位符 [FIG:index] 标注图表位置；
+        3. 在每个占位符下方添加图片标题：
+            图：图片标题（简要说明图片内容及分析要点）
+        4. 图片位置与语义保持自然衔接：
+        - 若图片引出分析 → 放在段落开头；
+        - 若图片支撑论点 → 放在相关描述句之后；
+        - 若图片总结结果 → 放在段落结尾；
+        5. 不得增删或重排图片编号。
+
+        四、输出要求
+        - 仅输出正文内容；
+        - 不得输出标题、编号、解释文字、Markdown；
+        - 不使用加粗、斜体、符号修饰或非正文语句；
+        - 不得出现“我认为”、“请继续”、“综上可见”等主观表达。
+
+        五、写作模式
+        当前模式：{self.outline_length}
+        - 简要：仅写结论；
+        - 标准：含逻辑与结论；
+        - 详细：包含推理与方法，但仍应基于参考信息，不得自由创作。
+
+        请严格在以上范围内撰写本章节正文。
+        """
+
+
+        # prompt = f"""
+        # 你是一个专业的数据分析报告撰写助手。你需要基于我提供的参考信息进行深入分析，生成结构严谨、逻辑清晰的专业报告章节。
+
+        # 当前需要撰写的章节信息（完整四元组，依次为标题、层级、内容大纲、图编号列表）：
+        # {t}
+
+        # 报告目录结构（包含所有章节的四元组信息）：
+        # {toc}
+
+        # 可参考的分析内容如下：
+        # {selected_full_contents}
+
+        # 此前已生成的章节内容如下（用于保持整体风格一致，并避免内容重复）：
+        # {history_content}
+
+        # 请根据章节标题、层级、内容大纲、参考信息和图编号列表，生成该章节的完整正文。
+
+        # 正文详细程度有三种模式：
+        # - 简要：只包含核心结论与关键点，语言精炼；
+        # - 标准：包含主要分析逻辑、步骤与结果；
+        # - 详细：展开完整分析、方法论、推理过程与补充说明。
+        # 用户当前选择的模式是：{self.outline_length}
+
+        # 写作要求：
+        # 1. **核心任务**：仅撰写当前章节 **“{t[0]}”** 的正文内容，不得涉及其他章节。
+        # 2. **图表引用**：正文中引用的图表必须严格对应本章节的图编号（即 {t[3]}），**不得使用或编造其他编号**。
+        # 3. **语言规范**：
+        # - 语言应专业、准确、逻辑严谨；
+        # - 叙述风格应正式、学术化；
+        # - 禁止使用口语化或主观色彩表达。
+        # 4. **输出要求**：
+        # - 仅输出章节正文内容，不得输出 Markdown；
+        # - 不得输出任何标题，如：1，一，（1）等；
+        # - 禁止加粗、斜体、表情符号或其他符号修饰；
+        # - 不得出现非正文短语，如 “我认为”、“请继续”、“感谢阅读”、“---” 等；
+        # 5. **图片规范**：
+        # - 图片应独立成行，不得嵌入句子内部；
+        # - 图片可放置在段落的开头、结尾，或自然停顿处（如句号、分号后），以保持语义连贯；
+        # - 使用占位符格式 [FIG:index] 标记图片位置，其中 index 为对应图片的编号；
+        # - 在每个 [FIG:index] 占位符后，需紧跟一行图片标题，格式如下：
+        #       图：图片标题（简要说明图片内容及分析要点）
+        # - 图片插入位置应依据其语义和上下文逻辑确定：
+        #       · 若图片用于引出分析，应放在段落开头；
+        #       · 若用于支撑论述，应放在对应描述句之后；
+        #       · 若总结结果或展示对比，应放在段落结尾；
+        # - 请务必确保图片位置与文字逻辑匹配，使图片与正文形成自然的论证衔接；
+        # - 请不要删除、合并或重排序图片编号，系统将在后续自动替换为真实图像。
+
+        # 请直接输出该章节的正文内容，不要有任何其他文字。
+        # """
+
+        content = self.call(prompt)
+
+        return content

utils/content.py

@@ -0,0 +1,13 @@
+import streamlit as st
+from dataclasses import dataclass
+
+@dataclass
+class Content:
+    def __init__(self, text: str = None, fig = None):
+        self.text = text
+        self.fig = fig
+
+    def display(self):
+        pass
+
+

utils/sanitize_code.py

@@ -0,0 +1,47 @@
+import re
+from typing import Any
+import numpy as np
+
+
+def sanitize_code(code: str) -> str:
+    """清理可能包含的 Markdown 代码块标记。"""
+    if not isinstance(code, str):
+        return ""
+    code = code.strip()
+    if code.startswith("```") and code.endswith("```"):
+        lines = code.splitlines()
+        # 去掉首尾 ``` 或 ```python
+        if re.match(r"^```(?:python)?", lines[0].strip()):
+            lines = lines[1:]
+        if lines and lines[-1].strip() == "```":
+            lines = lines[:-1]
+        code = "\n".join(lines)
+    return code
+
+
+def to_json_serializable(obj: Any) -> Any:
+    """将可能含 numpy 类型的对象转换为可 JSON 序列化类型（递归）。"""
+    if obj is None:
+        return None
+    if isinstance(obj, (str, bool, int)):
+        return obj
+    if isinstance(obj, float):
+        # 确保是内置 float（JSON 支持）
+        return float(obj)
+    if isinstance(obj, np.generic):
+        return obj.item()
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    if isinstance(obj, dict):
+        return {str(k): to_json_serializable(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [to_json_serializable(v) for v in obj]
+    # fallback: try to cast to float / str
+    try:
+        return float(obj)
+    except Exception:
+        try:
+            return str(obj)
+        except Exception:
+            return None
+

utils/save_secrets.py

@@ -0,0 +1,33 @@
+import toml
+from pathlib import Path
+
+# 我们把 secrets 放在项目根目录下的 .streamlit 文件夹
+BASE = Path(__file__).parent
+SECRETS_DIR  = BASE / ".streamlit"
+SECRETS_FILE = SECRETS_DIR / "secrets.toml"
+
+
+def load_local_api_keys() -> dict[str, str]:
+    """
+    从项目目录的 .streamlit/secrets.toml 中读取 [api_keys] 部分。
+    如果文件或该节不存在，返回空字典。
+    """
+    if not SECRETS_FILE.exists():
+        return {}
+    data = toml.load(SECRETS_FILE)
+    return data.get("api_keys", {})
+
+
+def update_local_api_key(model_name: str, api_key: str) -> None:
+    """
+    将一对 model_name: api_key 写入 .streamlit/secrets.toml 的 [api_keys]。
+    如果文件或该节不存在，会自动创建；保留其它已有设置。
+    """
+    SECRETS_DIR.mkdir(exist_ok=True)
+    if SECRETS_FILE.exists():
+        data = toml.load(SECRETS_FILE)
+    else:
+        data = {}
+    data.setdefault("api_keys", {})[model_name] = api_key
+    with SECRETS_FILE.open("w", encoding="utf-8") as f:
+        toml.dump(data, f)

utils/spinner_pool.py

@@ -0,0 +1,25 @@
+import random
+
+def get_spinner_msg(stage="writing"):
+    msg_pool = {
+        "summarizing": [
+            "正在汇总各模块的分析结果...",
+            "稍等一下，正在总结前面几个 Agent 的内容...",
+            "AI 正在整理前面的分析，请稍候...",
+            "正在综合各分析步骤的结论..."
+        ],
+        "writing": [
+            "正在生成各章节内容...",
+            "请稍候，系统正在详细撰写报告...",
+            "AI 正在逐步生成报告章节...",
+            "正在整理并撰写每一章节..."
+        ],
+        "default": [
+            "正在处理数据，请稍候...",
+            "AI 正在努力生成结果...",
+            "请耐心等待，正在计算中..."
+        ]
+    }
+
+    pool = msg_pool.get(stage, msg_pool["default"])
+    return random.choice(pool)

workflow/dataloading/dataloading_core.py

@@ -0,0 +1,287 @@
+import csv
+import io
+import os
+from typing import List, Optional
+
+import chardet
+import numpy as np
+import pandas as pd
+from scipy import sparse
+from scipy.io import loadmat, arff
+import streamlit as st
+import streamlit_antd_components as sac
+
+
+def read_data_from_file(
+    uploaded_data_file,
+    col_names: Optional[List[str]] = None,
+    sep: Optional[str] = None,
+    na_values: List[str] = ['?'],
+    encoding: Optional[str] = None
+) -> pd.DataFrame:
+    """
+    从上传的数据文件读取 DataFrame。
+    - 支持 .csv/.data/.txt/.xlsx/.xls/.mat
+    - col_names=None 时使用 header=0（文件首行做列名）
+    - col_names 不为 None 时使用 header=None 并指定 names=col_names
+    - 文本文件：自动探测编码、嗅探分隔符，跳过坏行
+    - Excel 文件：直接使用 pandas.read_excel
+    - MAT 文件：使用 scipy.loadmat，提取第一个主要变量，转为 DataFrame，并保证一维列
+    """
+    # 读取所有字节
+    data_bytes = uploaded_data_file.read()
+    # 重置流位置
+    try:
+        uploaded_data_file.seek(0)
+    except Exception:
+        pass
+
+    name = uploaded_data_file.name
+    ext = os.path.splitext(name)[1].lower()
+
+    # Excel 文件处理
+    if ext in ('.xlsx', '.xls'):
+        excel_kwargs = {}
+        if col_names is None:
+            excel_kwargs['header'] = 0
+        else:
+            excel_kwargs['header'] = None
+            excel_kwargs['names'] = col_names
+        return pd.read_excel(io.BytesIO(data_bytes), **excel_kwargs)
+
+    # ARFF 文件特殊处理
+    if ext == '.arff':
+        text = data_bytes.decode(encoding or 'utf-8', errors='ignore')
+        raw_data, meta = arff.loadarff(io.StringIO(text))
+        df = pd.DataFrame(raw_data)
+        for col in df.select_dtypes([object]).columns:
+            if isinstance(df[col].iloc[0], bytes):
+                df[col] = df[col].str.decode('utf-8', errors='ignore')
+        if col_names is not None and df.shape[1] == len(col_names):
+            df.columns = col_names
+        return df
+        
+    # —— MAT 文件特殊处理 —— #
+    if ext == '.mat':
+        mat = loadmat(io.BytesIO(data_bytes))
+        data_keys = [k for k in mat.keys() if not k.startswith('__')]
+        if not data_keys:
+            raise ValueError('MAT 文件中未发现有效数据变量')
+        arr = mat[data_keys[0]]
+
+        # —— 先处理稀疏矩阵 —— #
+        if sparse.issparse(arr):
+            arr = arr.toarray()
+
+        arr = np.array(arr)
+        if arr.ndim > 2:
+            arr = arr.reshape(arr.shape[0], -1)
+
+        df = pd.DataFrame(arr)
+
+        if col_names is not None and df.shape[1] == len(col_names):
+            df.columns = col_names
+
+        return df
+
+    if encoding is None:
+        detected = chardet.detect(data_bytes)
+        encoding = detected.get('encoding', 'utf-8')
+    sample = data_bytes[:10_000].decode(encoding, errors='ignore')
+
+    try:
+        dialect = csv.Sniffer().sniff(sample, delimiters=[',',';','\t','|'])
+        detected_sep = dialect.delimiter
+        use_whitespace = False
+    except csv.Error:
+        detected_sep = None
+        use_whitespace = True
+
+    read_kwargs = {
+        'engine': 'python',
+        'encoding': encoding,
+        'na_values': na_values,
+        'comment': '|',
+        'skipinitialspace': True,
+        'on_bad_lines': 'skip',
+    }
+    if use_whitespace:
+        read_kwargs['delim_whitespace'] = True
+    else:
+        read_kwargs['sep'] = detected_sep
+
+    if col_names is None:
+        read_kwargs['header'] = 0
+    else:
+        read_kwargs['header'] = None
+        read_kwargs['names'] = col_names
+
+    return pd.read_csv(io.BytesIO(data_bytes), **read_kwargs)
+
+
+def process_complex_data(uploaded_files, dataloadingagent):
+    """
+    上传处理逻辑：
+    - 单文件：当作普通表格或 MAT 文件读（第一行当表头）
+    - 多文件：若有 .names/.arff 表头文件，则用其列名；否则推断列名
+      并在存在多个数据文件时，通过用户选择进行横向或纵向拼接
+    """
+    if not uploaded_files:
+        st.error("请先上传文件")
+        return None, None
+
+    names_exts = ('.names', '.arff', '.doc')
+    data_exts = ('.data', '.csv', '.txt', '.xlsx', '.xls', '.mat', '.arff', '.tsv', '.dat', '.tst')
+
+    names_files = [f for f in uploaded_files
+                   if os.path.splitext(f.name)[1].lower() in names_exts]
+    data_files = [f for f in uploaded_files
+                  if os.path.splitext(f.name)[1].lower() in data_exts]
+
+    # 单文件直接读取
+    if len(uploaded_files) == 1 and uploaded_files[0] in data_files:
+        return read_data_from_file(uploaded_files[0], col_names=None), None
+
+    if not data_files:
+        raise ValueError(
+            "未检测到任何数据文件，请上传支持的格式：.csv/.data/.txt/.xlsx/.xls/.mat/.arff/.tsv/.dat/.tst"
+        )
+
+    # 1) 如果存在表头文件 (.names/.arff)，读取���名
+    if names_files:
+        header_file = names_files[0]
+        # 使用 read_data_from_file 读取 sample，以确保正确处理编码
+        sample_df = read_data_from_file(data_files[0], col_names=None)
+        col_names = dataloadingagent.read_names_from_file(header_file, sample_df.head())
+    else:
+        # 2) 否则从第一个数据文件推断列名，加入编码容错
+        sample = data_files[0]
+        ext0 = os.path.splitext(sample.name)[1].lower()
+        try:
+            if ext0 in ('.xlsx', '.xls'):
+                col_names = list(pd.read_excel(sample, nrows=0))
+            elif ext0 == '.mat':
+                df_sample = read_data_from_file(sample, col_names=None)
+                col_names = list(df_sample.columns)
+            else:
+                # 文本文件推断列名，带上 encoding 参数
+                # 先通过 chardet 检测，再尝试 utf-8,失败则 latin1
+                raw_bytes = sample.read()
+                detected = chardet.detect(raw_bytes)
+                enc = detected.get('encoding', 'utf-8')
+                try:
+                    col_names = list(pd.read_csv(
+                        io.BytesIO(raw_bytes),
+                        nrows=0,
+                        encoding=enc,
+                        engine='python'
+                    ).columns)
+                except UnicodeDecodeError:
+                    col_names = list(pd.read_csv(
+                        io.BytesIO(raw_bytes),
+                        nrows=0,
+                        encoding='latin1',
+                        engine='python'
+                    ).columns)
+        finally:
+            try: sample.seek(0)
+            except: pass
+
+    # 读取所有数据文件并统一列名
+    dfs = [read_data_from_file(f, col_names=col_names) for f in data_files]
+
+    # 若多个数据文件，弹出拼接模式选择
+    if len(data_files) >= 2:
+
+        big_df = pd.concat(dfs, axis=0, ignore_index=True)
+
+    else:
+        big_df = dfs[0]
+
+    return big_df, dfs
+
+
+def load_from_path(local_path):
+
+    ext = os.path.splitext(local_path)[1].lower()
+    if ext in (".csv", ".txt", ".data"):
+        df_local = pd.read_csv(local_path)
+    elif ext in (".xls", ".xlsx"):
+        df_local = pd.read_excel(local_path)
+    elif ext == ".json":
+        df_local = pd.read_json(local_path)
+    elif ext == ".jsonl":
+        df_local = pd.read_json(local_path, lines=True)
+    elif ext == ".parquet":
+        df_local = pd.read_parquet(local_path)
+    elif ext in (".pkl", ".pickle"):
+        df_local = pd.read_pickle(local_path)
+    elif ext == ".feather":
+        df_local = pd.read_feather(local_path)
+    elif ext == ".arff":
+        data, meta = arff.loadarff(local_path)
+        df_local = pd.DataFrame(data)
+        for col in df_local.select_dtypes([object]).columns:
+            if isinstance(df_local[col].iloc[0], bytes):
+                df_local[col] = df_local[col].str.decode('utf-8')
+    else:
+        st.error(f"不支持的文件类型：{ext}")
+        df_local = None
+
+    return df_local
+
+
+def load_concat_file(dfs, agent):
+
+    mode = sac.segmented(
+        items=[
+            sac.SegmentedItem(label='纵向拼接'),
+            sac.SegmentedItem(label='横向拼接'),
+        ], label='检测到多个数据文件，请选择拼接方式', size='sm', radius='sm'
+    )
+
+    if mode.startswith("横向拼接"):
+        dfs_pos = [df.reset_index(drop=True) for df in dfs]
+        big_df = pd.concat(dfs_pos, axis=1)
+
+        cols = []
+        seen = {}
+        for c in big_df.columns:
+            if c in seen:
+                seen[c] += 1
+                cols.append(f"{c}_{seen[c]}")
+            else:
+                seen[c] = 0
+                cols.append(c)
+        big_df.columns = cols
+        agent.add_df(big_df)
+    else:
+        big_df = pd.concat(dfs, axis=0, ignore_index=True)
+        agent.add_df(big_df)
+
+    csv_bytes = big_df.to_csv(index=False).encode('utf-8')
+    st.download_button(
+    label="下载文件",
+    data=csv_bytes,
+    file_name="processed_data.csv",
+    mime="text/csv"
+    )
+
+
+class PathFileWrapper:
+    """A wrapper to treat a local file path as a Streamlit UploadedFile."""
+    def __init__(self, path):
+        self.path = path
+        self.name = os.path.basename(path)
+        self._file = None
+
+    def read(self, *args, **kwargs):
+        with open(self.path, 'rb') as f:
+            return f.read()
+
+    def seek(self, offset, whence=0):
+
+        pass
+
+    def __repr__(self):
+        return f"PathFileWrapper(path='{self.path}')"

workflow/dataloading/dataloading_render.py

@@ -0,0 +1,210 @@
+import os
+from typing import List, Optional
+
+import pandas as pd
+import streamlit as st
+import streamlit_antd_components as sac
+
+from workflow.dataloading.dataloading_core import process_complex_data, load_from_path, load_concat_file, PathFileWrapper
+
+
+def loading_data_file(agent):
+
+    st.info(
+        "💡 提示：\n"
+        "1. 支持一次上传多个数据文件\n"
+        "2. 自动使用大模型分析并处理数据\n"
+        "3. 支持多种格式的文件类型上传\n"
+    )
+
+    selected_index = sac.tabs([
+        sac.TabsItem(label='本地上传'),
+        sac.TabsItem(label='路径导入'),
+    ], color='#5980AE',)
+
+    if selected_index == "本地上传":
+        # 点击上传文件
+        uploaded_files = st.file_uploader(
+            "选择新文件",
+            accept_multiple_files=True,
+            help="拖拽或点击上传多个文件",
+        )
+
+        if uploaded_files:
+            current_memory_file_name = agent.load_file_name()
+            new_files = [f for f in uploaded_files if f.name not in current_memory_file_name]
+            if new_files:
+                try:
+                    with st.spinner("正在处理数据..."):
+                        df, dfs = process_complex_data(new_files, agent)
+                    if df is not None:
+                        agent.add_df(df)
+                        agent.save_dfs(dfs)
+                        for f in new_files:
+                            agent.save_file_name(f.name)
+                        st.rerun()
+                except Exception as err:
+                    st.error(f"导入失败：{err}")
+
+    elif selected_index == "路径导入":
+        # 路径上传文件
+        raw_paths = st.text_area(
+            "从路径导入数据 (每行一个文件路径)",
+            placeholder=    "C:\\data\\iris.names\nC:\\data\\iris.data",
+            height=100
+        )
+
+        if st.button("从路径加载文件", use_container_width=True):
+            if raw_paths:
+
+                path_list = [p.strip().strip("'\"") for p in raw_paths.strip().split('\n') if p.strip()]
+                
+                valid_paths = [p for p in path_list if os.path.exists(p)]
+                invalid_paths = [p for p in path_list if not os.path.exists(p)]
+
+                if invalid_paths:
+                    st.warning(f"路径不存在，已跳过：\n- " + "\n- ".join(invalid_paths))
+
+                if not valid_paths:
+                    st.error("未找到任何有效的本地文件路径。")
+                else:
+                    current_memory_file_name = agent.load_file_name()
+                    new_paths = [p for p in valid_paths if p not in current_memory_file_name]
+
+                    if not new_paths:
+                        st.info("所有指定的路径文件均已加载。")
+                    else:
+                        files_to_process = [PathFileWrapper(p) for p in new_paths]
+                        try:
+                            with st.spinner("正在处理数据..."):
+                                df, dfs = process_complex_data(files_to_process, agent)
+                            if df is not None:
+                                agent.add_df(df)
+                                agent.save_dfs(dfs)
+                                for p in new_paths:
+                                    agent.save_file_name(p)
+                                st.rerun()
+                        except Exception as err:
+                            st.error(f"本地文件读取失败：{err}")
+    
+    dfs = agent.load_dfs()
+    if dfs is not None and len(dfs) >= 2:
+        load_concat_file(dfs, agent)
+
+
+def loading_basic_info(agent):
+    
+    df = agent.load_df()
+    if df is not None:
+        r, c = df.shape
+        missing = int(df.isnull().sum().sum())
+        col1, col2, col3 = st.columns(3)
+        col1.metric("行数", r)
+        col2.metric("列数", c)
+        col3.metric("缺失值总数", missing)
+
+        dtype_info = pd.DataFrame({
+            "列名": df.columns,
+            "类型": df.dtypes.astype(str),
+            "非空": df.count().values,
+            "缺失%": (df.isnull().mean() * 100).round(2).values,
+        }).reset_index(drop=True)
+
+        selected_index = sac.tabs([
+            sac.TabsItem(label='数据类型概览'),
+            sac.TabsItem(label='数据预览'),
+        ],color='#5980AE',)
+
+        if selected_index == "数据类型概览":
+            st.dataframe(dtype_info, use_container_width=True)
+        elif selected_index == "数据预览":
+            if st.button("🎲 随机抽样"):
+                display_df = df.sample(10)
+                st.dataframe(display_df, use_container_width=True)
+            else:
+                st.dataframe(df.head(10), use_container_width=True)
+
+
+def loading_chat(agent, auto=False) -> None:
+
+    df = agent.load_df()
+    if df is None:
+        return
+
+    with st.chat_message("assistant"):
+        st.write(
+            "我是 Anystat 数据分析助手，很高兴为您服务！\n\n"
+            "请先上传您的数据文件，上传完成后，您可以在下方和我对话，也可以直接点击按钮解析数据含义。"
+        )
+        analyze_btn = st.button("🔍 解析含义")
+        result_placeholder = st.empty()
+        
+    # 渲染历史对话
+    chat_history = agent.load_memory()
+
+    for idx, entry in enumerate(chat_history):
+        bubble = st.chat_message(entry["role"])
+        content = entry["content"]
+        if isinstance(content, str):
+            bubble.write(content)
+
+    already_generated = any(
+        entry["role"] == "assistant" and "含义" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    if analyze_btn or (auto and not already_generated):
+        st.chat_message("user").write("请帮我解析数据含义")
+        agent.add_memory({"role": "user", "content": "请帮我解析数据含义"})
+        with st.spinner("分析中..."):
+            desc = agent.do_data_description(df)
+
+        agent.finish_auto()
+        st.chat_message("assistant").write(desc)
+        agent.add_memory({"role": "assistant", "content": desc})
+        st.rerun()
+
+    # 用户自定义输入
+    user_input = st.chat_input("请输入需求，例如“帮我分析xx列”")
+    if user_input:
+        st.chat_message("user").write(user_input)
+        agent.add_memory({"role": "user", "content": user_input})
+        with st.spinner("处理中…"):
+            reply = agent.do_data_description(df, user_input)
+
+        st.chat_message("assistant").write(reply)
+        agent.add_memory({"role": "assistant", "content": reply})
+        st.rerun()
+
+
+if __name__ == "__main__":
+
+    agent = st.session_state.data_loading_agent
+    planner = st.session_state.planner_agent
+    auto = planner.loading_auto
+
+    if st.session_state.auto_mode == True:
+        if (agent.finish_auto_task == True and planner.switched_prep == False) or planner.prep_auto == False:
+            planner.finish_loading_auto()
+            st.switch_page("workflow/preprocessing/preprocessing_render.py")
+
+    c1,c2 = st.columns(2)
+    with c1:
+        st.title("数据导入")
+    with c2:
+        st.write("")  
+        st.write("")  
+        sac.buttons([
+            sac.ButtonsItem(label='Github', icon='github', href='https://github.com/ElvisWang1111/AAAAAnystat'),
+            sac.ButtonsItem(label='Doc', icon=sac.BsIcon(name='bi bi-file-earmark-post-fill', size=16), href='https://elviswang1111.github.io/anystatweb.github.io/index.html'),
+        ], align='end', color='dark', variant='filled', index=None)
+    st.markdown("---")
+
+    c = st.columns(2)
+    with c[0].expander('数据上传', True):
+        loading_data_file(agent)
+    with c[1].expander('数据建议', True):
+        loading_chat(agent, auto)
+    with c[0].expander('数据展示', True):
+        loading_basic_info(agent)
+

workflow/modeling/model_inference.py

@@ -0,0 +1,102 @@
+import base64
+import gzip
+import io
+import json
+import traceback
+
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+import streamlit as st
+
+from workflow.dataloading.dataloading_core import process_complex_data
+from utils.sanitize_code import sanitize_code, to_json_serializable
+
+
+def infer_load_data(agent) -> None:
+
+    uploaded_files = st.file_uploader(
+        "选择推理数据集",
+        accept_multiple_files=True,
+        help="拖拽或点击上传多个文件",
+    )
+
+    if uploaded_files:
+        try:
+            with st.spinner("正在处理数据..."):
+                big_df, dfs = process_complex_data(uploaded_files, agent)
+            if big_df is not None:
+                agent.save_inference_data(big_df)
+                st.success("导入并处理完成！")
+        except Exception as err:
+            st.error(f"导入失败：{err}")
+
+
+def infer_execution(agent):
+
+    inference_df = agent.load_inference_processed_df()
+    edited_code = agent.load_inference_code()
+
+    try:
+        model_obj = agent.load_best_model()
+        
+        exec_ns = {
+            "inference_df": inference_df,
+            'model_obj': model_obj,
+            "np": np,
+            "pd": pd,
+            "StandardScaler": StandardScaler
+        }
+        
+        with st.spinner("正在进行推断分析..."):
+            exec(edited_code, exec_ns)
+            
+            result_dict = exec_ns.get("result_dict")
+            if result_dict is None:
+                st.error("脚本未写入 `result_dict`。请确保编辑后的脚本在末尾赋值 result_dict。")
+            else:
+                art = result_dict.get('artifacts', {})
+                b64 = art.pop('predictions_df_b64', None)
+                if not art:
+                    result_dict.pop('artifacts', None)
+
+                serializable = to_json_serializable(result_dict)
+                try:
+                    result_json = json.dumps(serializable, ensure_ascii=False)
+                except Exception:
+                    result_json = json.dumps(serializable, default=str, ensure_ascii=False)
+
+                with st.expander("推理结果", True):
+                    if b64:
+                        try:
+                            gz_bytes = base64.b64decode(b64)
+                            csv_bytes = gzip.decompress(gz_bytes)
+
+                            df_pred = pd.read_csv(io.BytesIO(csv_bytes))
+                            st.success("已加载带预测结果的 DataFrame")
+                            st.dataframe(df_pred)
+
+                            st.download_button(
+                                label="下载带预测结果（predictions.csv）",
+                                data=csv_bytes,
+                                file_name="predictions.csv",
+                                mime="text/csv"
+                            )
+                        except Exception as e:
+                            st.error(f"解码 predictions_df 失败: {e}")
+                            # 兜底：尝试从 records 字段恢复
+                            records = result_dict.get('predictions_df_records')
+                            if records:
+                                try:
+                                    df_pred = pd.DataFrame(records)
+                                    st.dataframe(df_pred)
+                                except Exception as e2:
+                                    st.error(f"从 records 恢复表格失败: {e2}")
+
+    except Exception as e:
+        st.error(f"推断失败：{e}")
+        st.text(traceback.format_exc())
+        agent.save_inference_error(traceback.format_exc())
+        raw = agent.code_generation_for_inference(agent.load_code(), inference_data.head(), auto=True)
+        code = sanitize_code(raw)
+        agent.save_inference_code(code)

workflow/modeling/model_training.py

@@ -0,0 +1,143 @@
+import importlib
+import json
+import traceback
+import base64
+import gzip
+import pickle
+import time
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+import streamlit_antd_components as sac
+from streamlit_ace import st_ace
+import torch
+import torchvision
+import xgboost
+import lightgbm
+from sklearn.ensemble import GradientBoostingRegressor, RandomForestClassifier, RandomForestRegressor
+from sklearn.linear_model import LinearRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+from utils.sanitize_code import sanitize_code, to_json_serializable
+
+
+def train_execution(agent):
+
+    code = agent.load_code()
+    df = agent.load_df()
+
+    torch = importlib.import_module("torch")
+    torchvision = importlib.import_module("torchvision")
+
+    exec_ns = {
+        "df": df,
+        "np": np,
+        "pd": pd,
+        "torch": torch,
+        "torchvision": torchvision,
+        "train_test_split": train_test_split,
+        "StandardScaler": StandardScaler,
+        "LinearRegression": LinearRegression,
+        "RandomForestRegressor": RandomForestRegressor,
+        "GradientBoostingRegressor": GradientBoostingRegressor,
+        "RandomForestClassifier": RandomForestClassifier,
+        "xgboost": xgboost,
+        "lightgbm": lightgbm,
+    }
+
+    try:
+        with st.spinner("正在运行程序..."):
+            exec(code, exec_ns)
+    except Exception as exc:
+        st.error(f"已保存报错，请重新调用llm生成代码debug")
+        # st.error(f"脚本执行失败：{exc}")
+        st.text(traceback.format_exc())
+        agent.save_error(traceback.format_exc())
+        modeling_code_gen(agent, debug=True)
+    else:
+        result_dict = exec_ns.get("result_dict")
+        if result_dict is None:
+            st.error(
+                "脚本未写入 `result_dict`。请确保编辑后的脚本在末尾赋值 result_dict。"
+            )
+        else:
+            art = result_dict.get('artifacts', {})
+            b64 = art.pop('best_model_b64', None)
+            artifact_warning = result_dict.pop('artifact_warning', None)
+
+            if not art:
+                result_dict.pop('artifacts', None)
+
+            serializable = to_json_serializable(result_dict)
+            try:
+                result_json = json.dumps(serializable, ensure_ascii=False)
+            except Exception:
+                result_json = json.dumps(serializable, default=str, ensure_ascii=False)
+
+            with st.spinner("请求 LLM 格式化结果为 Markdown..."):
+                formatted = agent.result_format_prompt(result_json)
+                agent.save_modeling_result(formatted)
+
+            if b64:
+
+                gz_bytes = base64.b64decode(b64)
+
+                try:
+                    agent.save_best_model_gz_bytes(gz_bytes)
+                    model_obj = pickle.loads(gzip.decompress(gz_bytes))
+                    st.success("最佳模型已加载到内存，可用于即时推理（示例）。")
+                    agent.save_best_model(model_obj)
+                except Exception as e:
+                    st.error(f"加载模型失败：{e}")
+                    
+        
+def modeling_code_gen(agent, debug = False, auto = False, ) -> None:
+
+    df = agent.load_df()
+    suggest = agent.load_suggestion()
+    print(suggest)
+    chat_history = agent.load_memory()
+    already_generated = any(
+        entry["role"] == "assistant" and "训练脚本已更新！请重新运行代码！" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    if suggest is not None:
+        if debug == True or (auto and not already_generated):
+            with st.spinner("建模 Agent 正在生成训练脚本..."):
+                raw = agent.code_generation(
+                    df.head().to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+            st.chat_message("assistant").write("训练脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "训练脚本已更新！请重新运行代码！"})
+            st.rerun()        
+
+        analyze_btn = st.button("🔧 生成建模代码", key='modeling_code')
+        if analyze_btn:
+            with st.spinner("建模 Agent 正在生成训练脚本..."):
+                raw = agent.code_generation(
+                    df.head().to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+            st.chat_message("assistant").write("训练脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "训练脚本已更新！请重新运行代码！"})
+            st.rerun()
+
+    
+def train_download_model(agent):
+
+    model = agent.load_best_model_gz_bytes()
+    if model is not None:
+        st.download_button(
+        label="⬇�� 下载最佳模型",
+        data=model,
+        file_name="best_model.pkl.gz",
+        mime="application/gzip"
+        )

workflow/modeling/modeling_render.py

@@ -0,0 +1,218 @@
+import streamlit as st
+import streamlit_antd_components as sac
+from streamlit_ace import st_ace
+
+from utils.sanitize_code import sanitize_code
+from workflow.modeling.model_training import train_execution, modeling_code_gen, train_download_model
+from workflow.modeling.model_inference import infer_load_data, infer_execution
+from workflow.preprocessing.preprocessing_core import prep_meta_execution
+
+
+def modeling_quick_actions(agent):
+
+    st.write("选择一个或多个model：")
+    selected_models = sac.chip(
+        items=[
+            sac.ChipItem(label='线性回归'),
+            sac.ChipItem(label='XGBoost'),
+            sac.ChipItem(label='随机森林'),
+            sac.ChipItem(label='神经网络'),
+        ], index=[0, 2], align='center', radius='md', color='#44658C', multiple=True
+    )
+    
+    df = agent.load_df()
+
+    if st.button("🖋️ 快速建模"):
+        if not selected_models:
+            st.error("请先选择训练model。")
+        else:
+            with st.spinner("建模 Agent 正在生成训练脚本..."):
+                raw = agent.code_generation(df.head().to_string(), selected_models)
+                code = sanitize_code(raw)
+                agent.save_code(code)
+                agent.save_suggestion(selected_models)
+                agent.save_user_selection(selected_models)
+                st.success("训练脚本已生成并保存。")
+                st.rerun()
+                    
+    return selected_models
+
+
+def modeling_execution(agent, auto = False) -> None:
+
+    code = agent.load_code()
+
+    edited = st_ace(
+        value=code,
+        height=450,
+        theme="tomorrow_night",
+        language="python",
+        auto_update=True
+    )
+
+    not_executed = agent.load_modeling_result() == None
+
+    if edited is not None:
+        if st.button("▶️ 执行建模", key="modeling_run_code") or (auto and not_executed):
+            code = sanitize_code(edited)
+            agent.save_code(code)
+            train_execution(agent)
+            agent.finish_auto()
+            st.rerun()
+
+        modeling_result = agent.load_modeling_result()
+        if modeling_result is None:
+            result_expand = False
+        else:
+            result_expand = True
+            train_download_model(agent)
+            with st.expander("训练结果", result_expand):
+                if modeling_result:
+                    st.subheader("训练结果")
+                    try:
+                        st.markdown(modeling_result)
+                    except Exception:
+                        st.write(modeling_result)
+
+
+def modeling_inference(agent, preproc_agent):
+
+    infer_load_data(agent)
+    inference_processed_data = agent.load_inference_processed_df()
+    inference_data = agent.load_inference_data()
+
+    code = agent.load_inference_code()
+
+    if st.button("▶️ 执行推断"):
+
+        with st.spinner("正在对推理数据进行预处理..."):
+ 
+            inference_data = agent.load_inference_data()
+            if preproc_agent.code is not None:
+                inference_processed_df = prep_meta_execution(preproc_agent, preproc_agent.code, inference_data)
+                inference_data = inference_processed_df
+            agent.save_inference_processed_df(inference_data)
+            st.write("推断数据预览：")
+            st.dataframe(inference_data.head())
+
+        with st.spinner("建模 Agent 正在生成推理脚本..."):
+            
+            raw = agent.code_generation_for_inference(agent.load_code(), inference_data.head())
+            code = sanitize_code(raw)
+            agent.save_inference_code(code)
+
+    if code is not None:
+        edited_code = st_ace(
+            value=code,
+            height=450,
+            theme="tomorrow_night",
+            language="python",
+            auto_update=True
+        )
+        agent.save_inference_code(code)
+        if st.button("▶️ 执行建模"):
+            infer_execution(agent)
+
+
+def modeling_chat(agent, auto) -> None:
+
+    user_input = st.text_input("建模目标", "默认")
+    agent.save_target(user_input)
+
+    with st.chat_message("assistant"):
+        st.write(
+            "我是 Anystat 数据分析助手，很高兴为您服务！\n\n"
+            "您可以在下方输入建模相关问题，或直接点击按钮获取建模建议。"
+        )
+        analyze_btn = st.button("🔍 建模推荐", key='modeling_suggest')
+        result_placeholder = st.empty()
+        
+    chat_history = agent.load_memory()
+
+    for idx, entry in enumerate(chat_history):
+        bubble = st.chat_message(entry["role"])
+        content = entry["content"]
+        if isinstance(content, str):
+            bubble.write(content)
+        
+    already_generated = any(
+        entry["role"] == "assistant" and "模" in str(entry["content"])
+        for entry in chat_history
+    )
+    
+    if analyze_btn or (auto and not already_generated):
+        st.chat_message("user").write("请帮我获取��模建议")
+        agent.add_memory({"role": "user", "content": "请帮我获取建模建议"})
+        with st.spinner("分析中..."):
+            suggestion = agent.get_model_suggestion()
+            agent.save_suggestion(suggestion)
+            agent.refine_suggestions()
+        st.chat_message("assistant").write(suggestion)
+        agent.add_memory({"role": "assistant", "content": suggestion})
+        st.chat_message("assistant").write("需要进一步优化？再次点击按钮获取下一条建议")
+        agent.add_memory({"role": "assistant", "content": "需要进一步优化？再次点击按钮获取下一条建议"})
+
+    user_input = st.chat_input("请输入您的问题，例如“如何优化这个模型”")
+    if user_input:
+        st.chat_message("user").write(user_input)
+        agent.add_memory({"role": "user", "content": user_input})
+        with st.spinner("处理中…"):
+            reply = agent.get_model_suggestion(user_input)
+            agent.save_suggestion(reply)
+            agent.refine_suggestions()
+        st.chat_message("assistant").write(reply)
+        agent.add_memory({"role": "assistant", "content": reply})
+        st.chat_message("assistant").write("需要进一步优化？再次点击按钮获取下一条建议")
+        agent.add_memory({"role": "assistant", "content": "需要进一步优化？再次点击按钮获取下一条建议"})
+
+
+if __name__ == "__main__":
+
+    st.title("数据建模")
+    st.markdown("---")
+
+    preproc_agent = st.session_state.data_preprocess_agent
+    load_agent   = st.session_state.data_loading_agent
+
+    processed_df = preproc_agent.load_processed_df()
+    if processed_df is None:
+        df = load_agent.load_df()
+    else:
+        df = processed_df
+
+    if df is None:
+        st.warning("⚠️ 请先在数据导入页面加载数据")
+        st.stop()
+
+    agent = st.session_state.modeling_coding_agent
+    agent.add_df(df)
+    planner = st.session_state.planner_agent
+    auto = planner.modeling_auto
+
+    if st.session_state.auto_mode == True:
+        if (agent.finish_auto_task == True and planner.switched_modeling == False) or planner.modeling_auto == False:
+            planner.finish_modeling_auto()
+            st.switch_page("workflow/report/report_render.py")
+
+    code = agent.load_code()
+    if code is None:
+        expand = False
+    else:
+        expand = True
+
+    inference_model = agent.load_best_model()
+    if inference_model is None:
+        inference_expand = False
+    else:
+        inference_expand = True
+
+    c = st.columns(2)
+    with c[0].expander('快速建模', True):
+        modeling_quick_actions(agent)
+    with c[1].expander('建模建议', True):
+        modeling_chat(agent, auto)
+        modeling_code_gen(agent, auto=auto)
+    with c[0].expander('建模执行', expand):
+        modeling_execution(agent, auto)
+    # with c[0].expander('推断分析', inference_expand):
+    #     modeling_inference(agent, preproc_agent)

workflow/preprocessing/preprocessing_core.py

@@ -0,0 +1,112 @@
+import time
+import traceback
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+from streamlit_ace import st_ace
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import FunctionTransformer
+from sklearn.preprocessing import LabelEncoder, MinMaxScaler, OneHotEncoder, OrdinalEncoder, RobustScaler, StandardScaler
+
+from utils.sanitize_code import sanitize_code
+
+
+def prep_meta_execution(agent, code, df, auto=False):
+
+    edited = st_ace(
+        value=code,
+        height=400,
+        theme="tomorrow_night",
+        language="python",
+        auto_update=True
+    )
+
+    not_generated = agent.load_processed_df() is None
+    
+    if code is not None:
+        if st.button("▶️ 执行预处理") or (auto and not_generated):
+            code = sanitize_code(edited)
+            agent.save_code(code)
+
+            exec_ns = {
+                "df": df,
+                "np": np,
+                "pd": pd,
+                "st": st,
+                "SimpleImputer": SimpleImputer,
+                "FunctionTransformer": FunctionTransformer,
+                "StandardScaler": StandardScaler,
+                "MinMaxScaler": MinMaxScaler,
+                "RobustScaler": RobustScaler,
+                "OneHotEncoder": OneHotEncoder,
+                "OrdinalEncoder": OrdinalEncoder,
+                "LabelEncoder": LabelEncoder,
+                "ColumnTransformer": ColumnTransformer,
+                "Pipeline": Pipeline,
+            }
+
+            try:
+                with st.spinner("正在运行程序..."):
+                    exec(code, exec_ns)
+            except Exception as exc:
+                st.error(f"已保存报错，请重新调用llm生成代码debug")
+                st.text(traceback.format_exc())
+                agent.save_error(traceback.format_exc())
+                prep_code_gen(agent, debug=True)
+            else:
+                process_df = exec_ns.get("process_df")
+                if process_df is None:
+                    st.error(
+                        "脚本未写入 `process_df`。请确保编辑后的脚本在末尾赋值 process_df"
+                    )
+                else:
+                    agent.save_processed_df(process_df)
+                    agent.finish_auto()
+                    st.rerun()
+                    return process_df
+                    
+
+def prep_code_gen(agent, auto = False, debug = False):
+
+    suggest = agent.load_preprocessing_suggestions()
+    df = agent.load_df()
+
+    chat_history = agent.load_memory()
+    already_generated = any(
+        entry["role"] == "assistant" and "预处理脚本已更新！请重新运行代码！" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    if suggest is not None:
+
+        if debug == True or (auto and not already_generated):
+            with st.spinner("预处理 Agent 正在编写脚本..."):
+                raw = agent.code_generation(
+                    df.head(10).to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+
+            st.chat_message("assistant").write("预处理脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "预处理脚本已更新！请重新运行代码！"})
+
+            st.rerun()
+
+        analyze_btn = st.button("🔧 生成预处理代码", key='prep_code')
+        if analyze_btn:
+            with st.spinner("向 LLM 请求生成预处理脚本..."):
+                raw = agent.code_generation(
+                    df.head(10).to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+
+            st.chat_message("assistant").write("预处理脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "预处理脚本已更新！请重新运行代码！"})
+
+            st.rerun()

workflow/preprocessing/preprocessing_render.py

@@ -0,0 +1,159 @@
+import io
+import traceback
+
+import numpy as np
+import pandas as pd
+import streamlit as st
+from streamlit_ace import st_ace
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import FunctionTransformer
+from sklearn.preprocessing import LabelEncoder, MinMaxScaler, OneHotEncoder, OrdinalEncoder, RobustScaler, StandardScaler
+
+from utils.sanitize_code import sanitize_code
+from workflow.preprocessing.preprocessing_core import prep_meta_execution, prep_code_gen
+
+
+def prep_basic_info(agent):
+
+    df = agent.load_df()
+
+    # 展示基本统计
+    r, c = df.shape
+    missing = int(df.isnull().sum().sum())
+    col1, col2, col3 = st.columns(3)
+    col1.metric("行数", r)
+    col2.metric("列数", c)
+    col3.metric("缺失值总数", missing)
+
+    dtype_info = pd.DataFrame({
+        '列名': df.columns,
+        '类型': df.dtypes.astype(str),
+        '非空值数量': df.count().values,
+        '缺失值比例(%)': (df.isnull().mean() * 100).round(2).values,
+    })
+    dtype_info = dtype_info.reset_index(drop=True)
+    st.dataframe(dtype_info, use_container_width=True)
+
+
+def prep_execution(agent, auto=False):
+    ''' 
+    training data进行预处理
+    '''
+
+    code = agent.load_code()
+    df = agent.load_df()
+
+    process_df = prep_meta_execution(agent, code, df, auto=auto)
+
+
+def prep_result(agent):
+    
+    process_df = agent.load_processed_df()
+    df = agent.load_df()
+    
+    if process_df is not None:
+        st.write("处理前数据预览：", df.head(10))
+        st.write("处理后数据预览：", process_df.head(10))
+            
+        csv_buffer = io.StringIO()
+        process_df.to_csv(csv_buffer, index=False)
+        csv_bytes = csv_buffer.getvalue().encode('utf-8')
+        
+        st.download_button(
+            label="⬇️ 下载处理后数据",
+            data=csv_bytes,
+            file_name="processed_data.csv",
+            mime="text/csv",
+        )
+
+
+def prep_chat(agent, auto=False):
+    """渲染对话式建议区"""
+
+    with st.chat_message("assistant"):
+        st.write("我是 Anystat 数据分析助手，很高兴为您服务！\n\n"
+            "您可以在下方输入预处理需求，或直接点击按钮获取预处理建议。")
+        analyze_btn = st.button("🔍 预处理推荐", key='prep_suggest')
+
+    # 对话历史渲染
+    chat_history = agent.load_memory()
+
+    for idx, entry in enumerate(chat_history):
+        bubble = st.chat_message(entry["role"])
+        content = entry["content"]
+        if isinstance(content, str):
+            bubble.write(content)
+
+    already_generated = any(
+        entry["role"] == "assistant" and "预处理" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    # 自动/手动触发
+    if analyze_btn or (auto and not already_generated):
+
+        st.chat_message("user").write("请给我预处理建议")
+        agent.add_memory({'role': 'user', 'content': "请给我预处理建议"})
+
+        with st.spinner("生成建议中…"):
+            text = agent.get_preprocessing_suggestions()
+            agent.save_preprocessing_suggestions(text)
+            agent.refine_suggestions(df.head(10).to_string())
+        st.chat_message("assistant").write(text)
+        agent.add_memory({'role': 'assistant', 'content': text})
+
+    # 用户自然语言交互
+    user_input = st.chat_input("请输入您的问题")
+    if user_input:
+        st.chat_message("user").write(user_input)
+        agent.add_memory({'role': 'user', 'content': user_input})
+        agent.save_user_input(user_input)
+        with st.spinner("处理中…"):
+            reply = agent.get_preprocessing_suggestions(user_input)
+            agent.save_preprocessing_suggestions(reply)
+            agent.refine_suggestions(df.head(10).to_string())
+        st.chat_message('assistant').write(reply)
+        agent.add_memory({'role': 'assistant', 'content': reply})          
+
+
+if __name__ == '__main__':
+
+    st.title("数据预处理与标准化")
+
+    st.markdown("---")
+
+    data_loading_agent = st.session_state.data_loading_agent
+    df = data_loading_agent.load_df()
+    planner = st.session_state.planner_agent
+    auto = planner.prep_auto
+
+    if df is None:
+        st.warning("⚠️ 请先在数据导入页面加载数据")
+        st.stop()
+
+    agent = st.session_state.data_preprocess_agent
+    agent.add_df(df)
+
+    if st.session_state.auto_mode == True:
+        if (agent.finish_auto_task == True and planner.switched_prep == False) or planner.prep_auto == False:
+            planner.finish_prep_auto()
+            st.switch_page("workflow/visualization/viz_render.py")
+
+    code = agent.load_code()
+    if code is None:
+        code_expand = False
+    else:
+        code_expand = True
+
+    c = st.columns(2)
+    with c[0].expander('预处理展示', True):
+        prep_basic_info(agent)
+    with c[1].expander('预处理建议', True):
+        prep_chat(agent, auto)
+        prep_code_gen(agent, auto=auto)
+    with c[0].expander('预处理执行', code_expand):
+        prep_execution(agent, auto)
+    with c[0].expander('预处理结果', code_expand):
+        prep_result(agent)

workflow/report/report_core.py

@@ -0,0 +1,46 @@
+class ReportNode:
+    """文档节点：可以是 heading 或 paragraph"""
+    def __init__(self, node_type, text, level=0):
+        self.type = node_type   # "heading" 或 "paragraph"
+        self.text = text
+        self.level = level
+        self.children = []  # 子节点（用于分层）
+
+    def to_dict(self):
+        return {
+            "type": self.type,
+            "text": self.text,
+            "level": self.level,
+            "children": [c.to_dict() for c in self.children]
+        }
+
+# 现在只适合于顺序添加
+class Reportcore:
+    def __init__(self):
+        self.root = ReportNode("root", "", level=-1)  # 虚拟根节点
+        self.current_stack = [self.root]  # 用栈管理当前层级
+
+    def add_heading(self, text, level=0):# 从0开始
+        """
+        添加标题，根据 level 自动挂载到合适的父节点
+        """
+        new_node = ReportNode("heading", text, level)
+
+        # 回溯到合适的父节点
+        while self.current_stack and self.current_stack[-1].level >= level:
+            self.current_stack.pop()
+
+        parent = self.current_stack[-1]
+        parent.children.append(new_node)
+        self.current_stack.append(new_node)
+
+    def add_paragraph(self, text):
+        """
+        添加段落，挂在当前最后一个 heading 下
+        """
+        parent = self.current_stack[-1]
+
+        parent.children.append(ReportNode("paragraph", text, level=parent.level + 1))
+
+    def to_dict(self):
+        return self.root.to_dict()

workflow/report/report_html.py

@@ -0,0 +1,117 @@
+import io
+import re
+import streamlit as st
+import plotly.io as pio
+from utils.sanitize_code import sanitize_code
+import base64
+
+def write_html(agents):
+    report_agent = agents[-1]
+    report_obj = report_agent.load_report()  # Reportcore
+
+    # 图像分析列表
+    analysis_list = agents[2].summary_fig_analysis_list()
+
+    # 给 heading 加唯一 id
+    heading_counter = {"count": 0}
+    def _gen_id(text):
+        heading_counter["count"] += 1
+        return f"sec-{heading_counter['count']}"
+
+    # 遍历树 → 正文 & TOC
+    toc_items, content_items = [], []
+
+    def _process_node(node):
+        if node.type == "heading":
+            sec_id = _gen_id(node.text)
+            toc_items.append((sec_id, node.text, node.level))
+            content_items.append(
+                f"<h{node.level} id='{sec_id}' class='font-bold text-gray-800 mt-8 mb-4 text-{max(6-node.level,1)}xl'>{node.text}</h{node.level}>"
+            )
+            for ch in node.children:
+                _process_node(ch)
+
+        elif node.type == "paragraph":
+            parts = re.split(r'(\[FIG:\d+\])', node.text)
+            html_parts = []
+            for part in parts:
+                part = part.strip()
+                if not part:
+                    continue
+                if part.startswith("[FIG:") and part.endswith("]"):
+                    idx = int(part[5:-1])
+                    fig_html = ""
+                    if 0 <= idx < len(analysis_list):
+                        fig_obj = analysis_list[idx].get("figure")
+                        try:
+                            buf = io.BytesIO()
+                            pio.write_image(fig_obj, buf, format="png")
+                            data = buf.getvalue()
+                            b64 = base64.b64encode(data).decode("utf-8")
+                            fig_html = f"<div class='flex justify-center my-6'><img src='data:image/png;base64,{b64}' class='rounded-xl shadow-md max-w-3xl w-full'/></div>"
+                        except Exception as e:
+                            fig_html = f"<p class='text-red-500'>[图像插入失败: {e}]</p>"
+                    html_parts.append(fig_html)
+                else:
+                    html_parts.append(f"<p class='text-gray-700 leading-relaxed mb-4'>{part}</p>")
+            content_items.append("".join(html_parts))
+
+        else:  # root
+            for ch in node.children:
+                _process_node(ch)
+
+    _process_node(report_obj.root)
+
+    # TOC HTML
+    toc_html = ["<nav class='space-y-2'>"]
+    prev_level = -1
+    for sec_id, text, level in toc_items:
+        indent = "ml-" + str(level * 4)
+        toc_html.append(f"<a href='#{sec_id}' class='block {indent} text-gray-600 hover:text-blue-600 transition-colors'>{text}</a>")
+    toc_html.append("</nav>")
+
+    # 拼接完整 HTML
+    html_content = f"""
+    <html>
+    <head>
+        <meta charset="utf-8">
+        <script src="https://cdn.tailwindcss.com"></script>
+        <script>
+        document.addEventListener("DOMContentLoaded", function() {{
+            const sections = document.querySelectorAll("h1, h2, h3, h4, h5, h6");
+            const navLinks = document.querySelectorAll("nav a");
+
+            function onScroll() {{
+                let scrollPos = document.documentElement.scrollTop || document.body.scrollTop;
+                let currentId = "";
+                sections.forEach(sec => {{
+                    if (sec.offsetTop - 80 <= scrollPos) {{
+                        currentId = sec.id;
+                    }}
+                }});
+                navLinks.forEach(link => {{
+                    link.classList.remove("font-bold", "text-blue-600");
+                    if (link.getAttribute("href") === "#" + currentId) {{
+                        link.classList.add("font-bold", "text-blue-600");
+                    }}
+                }});
+            }}
+            window.addEventListener("scroll", onScroll);
+            onScroll();
+        }});
+        </script>
+    </head>
+    <body class="flex font-sans">
+        <aside class="fixed top-0 left-0 h-screen w-64 bg-gray-100 border-r border-gray-300 p-6 overflow-y-auto">
+            <h2 class="text-xl font-bold mb-4">目录</h2>
+            {''.join(toc_html)}
+        </aside>
+        <main class="ml-64 p-10 w-full max-w-5xl">
+            {''.join(content_items)}
+        </main>
+    </body>
+    </html>
+    """
+
+    report_agent.save_html(html_content)
+    st.success("HTML 报告 (Tailwind 风格) 生成成功 ✅")

workflow/report/report_markdown.py

@@ -0,0 +1,55 @@
+import io
+import re
+import base64
+import plotly.io as pio
+import streamlit as st
+def write_markdown(agents):
+    report_agent = agents[-1]
+    report_obj = report_agent.load_report()  # Reportcore
+
+    # 图像分析列表
+    analysis_list = agents[2].summary_fig_analysis_list()
+
+    md_parts = []
+
+    def _process_node(node):
+        if node.type == "heading":
+            prefix = "#" * (node.level if node.level > 0 else 1)
+            md_parts.append(f"{prefix} {node.text}\n")
+            for ch in node.children:
+                _process_node(ch)
+
+        elif node.type == "paragraph":
+            parts = re.split(r'(\[FIG:\d+\])', node.text)
+            for part in parts:
+                part = part.strip()
+                if not part:
+                    continue
+
+                if part.startswith("[FIG:") and part.endswith("]"):
+                    idx = int(part[5:-1])
+                    if 0 <= idx < len(analysis_list):
+                        fig_obj = analysis_list[idx].get("figure")
+                        try:
+                            buf = io.BytesIO()
+                            pio.write_image(fig_obj, buf, format="png")
+                            data = buf.getvalue()
+                            b64 = base64.b64encode(data).decode("utf-8")
+                            # 🔹 直接内嵌 base64
+                            md_parts.append(
+                                f"![Figure {idx}](data:image/png;base64,{b64})\n"
+                            )
+                        except Exception as e:
+                            md_parts.append(f"> **图像插入失败**: {e}\n")
+                else:
+                    md_parts.append(f"{part}\n\n")
+
+        else:  # root
+            for ch in node.children:
+                _process_node(ch)
+
+    _process_node(report_obj.root)
+
+    md_content = "\n".join(md_parts)
+    report_agent.save_markdown(md_content)
+    st.success("Markdown 报告生成成功 ✅")

workflow/report/report_prepare_er.py

@@ -0,0 +1,102 @@
+import ast
+import io
+import re
+from io import BytesIO
+
+import streamlit as st
+from tqdm import tqdm
+from stqdm import stqdm
+from docx import Document
+from docx.oxml.ns import qn
+from docx.shared import Inches
+from docx.enum.table import WD_TABLE_ALIGNMENT
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+import plotly.express as px
+import plotly.io as pio
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from utils.sanitize_code import sanitize_code
+from workflow.report.report_core import *
+
+
+def report_prepare(agents, parallel=True, max_workers=4):
+    report_agent = agents[-1]
+    toc = report_agent.load_outline()
+    if toc is None:
+        st.error("请先生成目录")
+        return
+
+    toc = sanitize_code(toc)
+
+    # === 汇总各分析模块的摘要 ===
+    agent_abstracts = {}
+    with st.spinner("正在汇总各分析模块的结果..."):
+        for i in stqdm(range(len(agents) - 1)):
+            agent_abstracts[i] = agents[i].check_abstract()
+
+    # === 更新 toc 的 FIG 列表 ===
+    selected_full_contents_vis = agents[2].check_full()
+    toc = report_agent.selected_photo_update_toc(toc, selected_full_contents_vis)
+    toc = sanitize_code(toc)
+    print(toc)
+    try:
+        toc = ast.literal_eval(toc)
+    except Exception:
+        pass
+
+    # === 更新 toc 的 模块选择 列表 ===
+    with st.spinner("正在匹配各章节所需的分析模块..."):
+        toc_with_choice = report_agent.update_toc_with_relevant_sections(toc, agent_abstracts)
+        toc_with_choice = sanitize_code(toc_with_choice)
+        try:
+            toc_with_choice = ast.literal_eval(toc_with_choice)
+        except Exception:
+            pass
+
+    # === 初始化报告结构 ===
+    doc = Reportcore()
+    doc.add_heading('数据分析报告', 0)
+    selected_model = st.session_state.selected_model
+
+    def process_section(idx, t,t_w_c, history_content=""):
+        st.session_state.selected_model = selected_model
+        # t: ('标题', 层级, 内容大纲, [figs], [modules])
+        _, _, _, _, choice_list = t_w_c
+        selected_full_contents = {i: agents[i].check_full() for i in choice_list if i < len(agents) - 1}
+        content = report_agent.write_section_body(toc, t, selected_full_contents, history_content)
+        print(idx)
+        return (idx, t, content)
+
+    results = []
+
+    # 串行或并行
+    if not parallel:
+        with st.spinner("正在串行生成各章节内容（带上下文）..."):
+            history_content = ""
+            for idx, t in stqdm(enumerate(toc)):
+                t_w_c= toc_with_choice[idx]
+                _, _, content = process_section(idx, t,t_w_c, history_content)
+                results.append((idx, t, content))
+                history_content += f"\n\n{t[0]}\n{content}"
+    else:
+        with st.spinner(f"正在并行生成各章节内容（{max_workers}线程）..."):
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                print(toc_with_choice)
+                # print(f"idx={idx}, len={len(toc_with_choice)}")
+                futures = {
+                    executor.submit(process_section, idx, t, toc_with_choice[idx], ""): idx
+                    for idx, t in enumerate(toc)
+                }
+                for future in stqdm(as_completed(futures), total=len(futures)):
+                    try:
+                        results.append(future.result())
+                    except Exception as e:
+                        print(f"章节生成失败: {e}")
+
+    # 排序 & 写入报告
+    results.sort(key=lambda x: x[0])
+    for _, t, content in results:
+        doc.add_heading(t[0], level=t[1])
+        doc.add_paragraph(content)
+
+    report_agent.save_report(doc)

workflow/report/report_render.py

@@ -0,0 +1,243 @@
+import datetime
+import io
+from io import BytesIO
+
+from stqdm import stqdm
+import mammoth
+import numpy as np
+import pandas as pd
+import streamlit as st
+import streamlit_antd_components as sac
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from prompt_engineer.sec5_call_llm import *
+from workflow.report.report_utils import html_dowmload
+from workflow.report.report_html import write_html
+from workflow.report.report_word import write_word
+from workflow.report.report_markdown import write_markdown
+from workflow.report.report_prepare_er import report_prepare
+
+
+def report_save(agents, auto): 
+
+    report_agent = agents[-1]
+    action = report_agent.load_report_format()
+    
+    if report_agent.load_report_format() == 'HTML':
+        not_generate = report_agent.html == None
+    if report_agent.load_report_format() == 'Word':
+        not_generate = report_agent.word == None
+    if report_agent.load_report_format() == 'Markdown':
+        not_generate = report_agent.markdown == None
+
+    mode = report_agent.load_gen_mode()
+    parallel = (mode == "并行")
+    
+    if st.button(f"📝 生成 {action} 报告") or (auto and not_generate):
+        with st.spinner(f"正在生成 {action} 报告..."):
+
+            report_prepare(agents, parallel=parallel)
+
+            if report_agent.load_report_format() == 'Word':
+                write_word(agents)
+            elif report_agent.load_report_format() == 'HTML':
+                write_html(agents)
+            elif report_agent.load_report_format() == 'Markdown':
+                write_markdown(agents)
+
+
+def report_basic_info(agent, auto) -> None:
+    outline_length = sac.segmented(
+        items=[
+            sac.SegmentedItem(label='简要'),
+            sac.SegmentedItem(label='标准'),
+            sac.SegmentedItem(label='详细'),
+        ],
+        label='详细程度', index=1, align='center',
+        size='sm', radius='sm', use_container_width=True
+    )
+    agent.save_outline_length(outline_length)
+
+    c1, c2 = st.columns(2)
+    with c1:
+        date = st.date_input("报告日期", datetime.date(2025, 10, 1))
+        agent.save_date(date)
+    with c2:
+        name = st.text_input("报告作者", "Anystat")
+        agent.save_name(name)
+
+    c1, c2 = st.columns([3, 1])
+    with c1:
+        report_format = sac.chip(
+            items=[
+                sac.ChipItem(label='Word', icon=sac.BsIcon(name='file-earmark-word', size=16)),
+                sac.ChipItem(label='HTML', icon=sac.BsIcon(name='filetype-html', size=16)),
+                sac.ChipItem(label='Markdown', icon=sac.BsIcon(name='file-earmark-code', size=16)),
+            ],
+            label='选择报告生成格式', index=[0, 2],
+            align='start', radius='md', multiple=False,
+        )
+        agent.save_report_format(report_format)
+
+    with c2:
+        mode = sac.segmented(
+            items=[
+                sac.SegmentedItem(label='并行'),
+                sac.SegmentedItem(label='串行'),
+            ],
+            label='生成模式', align='end', size='sm',
+            use_container_width=True, radius='md'
+        )
+        agent.save_gen_mode(mode)
+
+    user_input = st.text_input("报告生成要求", "默认")
+    agent.save_user_input(user_input)
+
+    not_generated = report_agent.load_outline() is None
+
+    # === 并行生成目录 ===
+    if st.button("🗒️ 生成目录") or (auto and not_generated):
+        with st.spinner("⏳ 正在自动生成目录结构..."):
+            summaries = []
+
+            # === 保存当前 Streamlit 状态副本 ===
+            session_snapshot = dict(st.session_state)
+
+            def process_summary(idx, sub_agent, session_snapshot):
+                """并行执行 summary_html/summary_word（带状态复制）"""
+                # 恢复 session_state
+                for k, v in session_snapshot.items():
+                    st.session_state[k] = v
+
+                # 实际生成逻辑
+                if hasattr(sub_agent, "summary_html"):
+                    summary = sub_agent.summary_html()
+                else:
+                    summary = sub_agent.summary_word()
+
+                return idx, summary
+
+            max_workers = min(6, len(agents) - 1)
+            results = []
+
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                futures = {
+                    executor.submit(process_summary, i, sub_agent, session_snapshot): i
+                    for i, sub_agent in enumerate(agents[:-1])
+                }
+
+                for future in stqdm(as_completed(futures), total=len(futures)):
+                    try:
+                        idx, summary = future.result()
+                        if summary:
+                            results.append((idx, summary))
+                    except Exception as e:
+                        print(f"子模块摘要生成失败: {e}")
+
+            # === 恢复章节原顺序 ===
+            results.sort(key=lambda x: x[0])
+            summaries = [summary for _, summary in results if summary]
+
+            # === 生成目录 ===
+            default_toc = report_agent.generate_toc_from_summary(summaries)
+            report_agent.save_outline(default_toc)
+
+
+def report_outline(agents):
+
+    st.subheader("目录结构预览与编辑")
+    load_agent, preproc_agent, visual_agent, coding_agent, report_agent = agents[0], agents[1], agents[2], agents[3], agents[4]
+
+    default_toc = report_agent.load_outline()
+
+    toc_md = st.text_area(
+        "您可以在此处编辑目录结构", 
+        value=default_toc, 
+        height=260
+    )
+
+    report_agent.save_outline(toc_md)
+
+
+def report_execution(report_agent):
+
+    if report_agent.load_report_format() == 'Word':
+
+        full_report = report_agent.load_word()
+        if full_report is not None:
+            st.download_button(
+                label="⬇️ 下载 Word 报告",
+                data=full_report,
+                file_name="report.docx",
+                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+            )
+
+    elif report_agent.load_report_format() == 'HTML':
+
+        full_report = report_agent.load_html()
+
+        if full_report is not None:
+            st.download_button(
+                label="⬇️ 下载 HTML 报告",
+                data=full_report.encode("utf-8"),
+                file_name="report.html",
+                mime="text/html",
+            )
+
+            if st.button("⬇️ 下载 PDF 报告"):
+                html_dowmload(full_report)
+    elif report_agent.load_report_format() == 'Markdown':
+
+        full_report = report_agent.load_markdown()
+        if full_report is not None:
+
+            # 提供下载按钮
+            st.download_button(
+                label="⬇️ 下载 Markdown 报告",
+                data=full_report,
+                file_name="report.md",
+                mime="text/markdown"
+            )
+
+
+if __name__ == "__main__":
+
+    st.title("报告生成")
+
+    st.markdown("---")
+
+    load_agent   = st.session_state.data_loading_agent
+    preproc_agent = st.session_state.data_preprocess_agent
+    visual_agent = st.session_state.visualization_agent
+    coding_agent = st.session_state.modeling_coding_agent
+    planner = st.session_state.planner_agent
+    auto = planner.report_auto
+
+    processed_df = preproc_agent.load_processed_df()
+    if processed_df is None:
+        df = load_agent.load_df()
+    else:
+        df = processed_df
+
+    if df is None:
+        st.warning("⚠️ 请先在数据导入页面加载数据")
+        st.stop()
+
+    if isinstance(df, np.ndarray):
+        df = pd.DataFrame(df)
+
+    df_shuffled = df.sample(frac=1, random_state=42).reset_index(drop=True)
+
+    report_agent = st.session_state.report_agent
+    report_agent.add_df(df_shuffled)
+
+    agents = [load_agent, preproc_agent, visual_agent, coding_agent, report_agent]
+
+    c = st.columns(2)
+    with c[0].expander('报告设置', True):
+        report_basic_info(report_agent, auto)
+
+    with c[1].expander('报告大纲', True):
+        report_outline(agents)
+        report_save(agents, auto)
+        report_execution(report_agent)

workflow/report/report_utils.py

@@ -0,0 +1,59 @@
+import re
+import base64
+
+import streamlit as st
+from playwright.sync_api import sync_playwright
+
+
+def html_to_pdf_bytes_playwright(html: str) -> bytes:
+    with sync_playwright() as p:
+        browser = p.chromium.launch()
+        page = browser.new_page()
+        page.set_content(html, wait_until="load")
+        pdf_bytes = page.pdf(format="A4", print_background=True)
+        browser.close()
+        return pdf_bytes
+
+
+def html_dowmload(full_report):
+
+    try:
+        pdf_bytes = html_to_pdf_bytes_playwright(full_report)
+    except Exception as e:
+        st.error(f"生成 PDF 出错：{e}")
+    else:
+        b64 = base64.b64encode(pdf_bytes).decode("utf-8")
+
+        auto_download_html = f"""
+        <html>
+        <body>
+            <a id="dl_link"
+            href="data:application/pdf;base64,{b64}"
+            download="report.pdf"
+            style="display:none">download</a>
+            <script>
+            (function() {{
+                const a = document.getElementById('dl_link');
+                try {{
+                a.click();
+                }} catch (err) {{
+                // 如果自动点击被阻止，替换页面内容并露出手动链接
+                document.body.innerHTML =
+                    '<p>自动下载被浏览器阻止，请点击下面链接手动下载：</p>' + a.outerHTML;
+                }}
+            }})();
+            </script>
+        </body>
+        </html>
+        """
+
+        st.components.v1.html(auto_download_html, height=120)
+
+        st.download_button(
+            label="⬇️ 手动下载 PDF（回退）",
+            data=pdf_bytes,
+            file_name="report.pdf",
+            mime="application/pdf",
+        )
+
+        st.success("PDF 已生成（如未自动下载，请使用上方手动下载按钮）。")

workflow/report/report_word.py

@@ -0,0 +1,89 @@
+import ast
+import io
+import re
+from io import BytesIO
+
+import streamlit as st
+from stqdm import stqdm
+from docx import Document
+from docx.oxml.ns import qn
+from docx.shared import Inches
+from docx.enum.table import WD_TABLE_ALIGNMENT
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+import plotly.express as px
+import plotly.io as pio
+
+from utils.sanitize_code import sanitize_code
+
+
+
+def write_word(agents):
+    '''
+    choice：是否要搜索
+        True：根据目录搜索相关章节
+        False：全部章节
+    '''
+    # 拿图
+    analysis_list = agents[2].summary_fig_analysis_list()
+
+    report_agent = agents[-1]
+    report_obj = report_agent.load_report()  # Reportcore
+
+    doc = Document()
+
+    style = doc.styles['Normal']
+
+    style.font.name = 'Times New Roman'
+    style._element.rPr.rFonts.set(qn('w:eastAsia'), '微软雅黑')
+
+    def _insert_figure(fig_obj):
+        if fig_obj is None:
+            return
+        try:
+            img_bytes = io.BytesIO()
+            img_bytes = io.BytesIO(fig_obj.to_image(format="png"))
+            # pio.write_image(fig_obj, img_bytes, format='png')
+            img_bytes.seek(0)
+
+            paragraph = doc.add_paragraph()
+            run = paragraph.add_run()
+            run.add_picture(img_bytes, width=Inches(4))
+            paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+        except Exception as e:
+            doc.add_paragraph(f"[图像插入失败: {e}]")
+
+    def _process_node(node):
+        if node.type == "heading":
+            doc.add_heading(node.text, level=node.level)
+            for ch in node.children:
+                _process_node(ch)
+
+        elif node.type == "paragraph":
+            parts = re.split(r'(\[FIG:\d+\])', node.text)
+
+            for part in parts:
+                part = part.strip()
+                if not part:
+                    continue
+                if part.startswith("[FIG:") and part.endswith("]"):
+                    idx = int(part[5:-1])
+                    fig_obj = None
+                    if 0 <= idx < len(analysis_list):
+                        entry = analysis_list[idx]
+                        fig_obj = entry.get("figure")
+                    _insert_figure(fig_obj)
+                else:
+                    doc.add_paragraph(part)
+
+        else:  # root
+            for ch in node.children:
+                _process_node(ch)
+
+    # 从 root.children 开始写
+    _process_node(report_obj.root)
+
+    buf = io.BytesIO()
+    doc.save(buf)
+    buf.seek(0)
+    report_agent.save_word(buf.getvalue())
+    st.success("Word 报告生成成功")

workflow/visualization/viz_coding.py

@@ -0,0 +1,110 @@
+import time
+import traceback
+
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objs as go
+import streamlit as st
+from stqdm import stqdm
+from streamlit_ace import st_ace
+import streamlit_antd_components as sac
+
+from utils.sanitize_code import sanitize_code
+
+
+def vis_code_gen(agent, debug = False, auto = False) -> None:
+
+    df = agent.load_df()
+    suggest = agent.load_suggestion()
+    user_input = agent.load_user_input()
+
+    chat_history = agent.load_memory()
+    already_generated = any(
+        entry["role"] == "assistant" and "训练脚本已更新！请重新运行代码！" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    if suggest is not None:
+        if debug == True or (auto and not already_generated):
+            with st.spinner("可视化 Agent 正在编写脚本..."):
+                raw = agent.code_generation(
+                    df.head().to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+            st.chat_message("assistant").write("训练脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "训练脚本已更新！请重新运行代码！"})
+            st.rerun()
+        
+        analyze_btn = st.button("🔧 生成可视化代码", key="viz_code")
+        if analyze_btn:
+            with st.spinner("可视化 Agent 正在编写脚本..."):
+                raw = agent.code_generation(
+                    df.head().to_string(),
+                    suggest,
+                )
+                code = sanitize_code(raw)
+                agent.save_code(code)
+            st.chat_message("assistant").write("训练脚本已更新！请重新运行代码！")
+            agent.add_memory({"role": "assistant", "content": "训练脚本已更新！请重新运行代码！"})
+            st.rerun()
+            
+
+def vis_execution(agent, auto = False):
+
+    df = agent.load_df()
+
+    exec_ns = {
+        "df": df,
+        "np": np,
+        "pd": pd,
+        "px": px,
+        "go": go,
+    }
+
+    code = agent.load_code()
+    edited = st_ace(
+            value=code,
+            height=450,
+            theme="tomorrow_night",
+            language="python",
+            auto_update=True
+        )
+    desc_switch = sac.switch(label='附加分析', value=False, off_label='Off')
+    if code is not None:
+        not_executed = agent.load_fig() == []
+        # 当点击按钮，或者 auto=True 且尚未执行过时才执行
+        if st.button("▶️ 执行可视化") or (auto and not_executed):
+            code = sanitize_code(edited)
+            agent.save_code(code)
+            try:
+                with st.spinner("正在运行可视化脚本..."):
+                    exec(code, exec_ns)
+            except Exception as exc:
+                st.error(f"已记录报错内容，正在为您debug...")
+                st.text(traceback.format_exc())
+                agent.save_error(traceback.format_exc())
+                vis_code_gen(agent, debug=True)
+            else:
+                fig_dict = exec_ns.get("fig_dict")
+                if not fig_dict or not isinstance(fig_dict, dict):
+                    st.error(
+                        "脚本未写入 `fig_dict` 或格式不正确。请确保末尾赋值 `fig_dict`，且它是一个 {列名: 图表} 的 dict。"
+                    )
+                    agent.save_error(traceback.format_exc())
+                    vis_code_gen(agent, debug=True)
+                else:
+                    with st.spinner("正在处理可视化结果..."):
+                        for col_name, fig in stqdm(fig_dict.items()):
+                            dtype_info = ", ".join(
+                                f"{c}: {df[c].dtype}" for c in df.columns
+                            )
+                            if desc_switch == True:
+                                desc = agent.desc_fig(fig, dtype_info)
+                            else:
+                                desc = None
+                            agent.add_fig(fig, desc)
+                        agent.finish_auto()
+                        st.rerun()

workflow/visualization/viz_color.py

@@ -0,0 +1,58 @@
+import streamlit as st
+
+PALETTES = {
+    "Classic": [
+        "#2B5C8A", "#4F81AF", "#77ACD3", "#D9D5C9", "#F69035"
+    ],
+    "Ocean Breeze": [
+        "#03045E", "#0077B6", "#00B4D8", "#90E0EF", "#CAF0F8"
+    ],
+    "Olive Garden Feast": [
+        "#606C38", "#283618", "#FEFAE0", "#DDA15E", "#BC6C25"
+    ],
+    "Fiery Ocean": [
+        "#780000", "#C1121F", "#FDF0D5", "#003049", "#669BBC"
+    ],
+    "Refreshing Summer Fun": [
+        "#8ECAE6", "#219EBC", "#023047", "#FFB703", "#FB8500"
+    ],
+    "Golden Summer Fields": [
+        "#CCD5AE", "#E9EDC9", "#FEFAE0", "#FAEDCD", "#D4A373"
+    ],
+    "Deep Sea": [
+        "#0D1B2A", "#1B263B", "#415A77", "#778DA9", "#E0E1DD"
+    ],
+    "Bold Berry": [
+        "#F9DBBD", "#FFA5AB", "#DA627D", "#A53860", "#450920"
+    ],
+    "Fresh Greens": [
+        "#D8F3DC", "#95D5B2", "#52B788", "#2D6A4F", "#1B4332"
+    ],
+    "Deep Sea": [
+        "#EDEDE9", "#D6CCC2", "#F5EBE0", "#E3D5CA", "#D5BDAF"
+    ],
+}
+
+def vis_palette(agent):
+
+    choice = st.selectbox("请选择配色方案", list(PALETTES.keys()))
+    colors = PALETTES[choice]
+    
+    cols = st.columns(len(colors))
+    for col, code in zip(cols, colors):
+        col.markdown(
+            f"""
+            <div style="
+                background-color: {code};
+                height: 30px;
+                border-radius: 4px;
+                margin-bottom: 2px;
+            "></div>
+            <div style="text-align: center; font-size: 10px;">{code}</div>
+            """,
+            unsafe_allow_html=True
+        )
+        
+    agent.save_color(colors)
+        
+    return colors

workflow/visualization/viz_quick_action.py

@@ -0,0 +1,23 @@
+import streamlit as st
+import plotly.express as px
+
+
+def plot_for_option(df, option: str, column: str):
+    
+    series = df[column]
+    
+    if option == "直方图":
+        fig = px.histogram(df, x=column, title=f"{column} 的直方图")
+    elif option == "饼图":
+        counts = series.value_counts().reset_index()
+        counts.columns = [column, 'count']
+        fig = px.pie(counts, names=column, values='count', title=f"{column} 的饼图")
+    elif option == "折线图":
+        fig = px.line(df, y=column, title=f"{column} 的折线图")
+    elif option == "箱线图":
+        fig = px.box(df, y=column, title=f"{column} 的箱线图")
+    else:
+        st.error("未知的图表类型")
+        return
+    
+    return fig

workflow/visualization/viz_render.py

@@ -0,0 +1,192 @@
+import os
+
+import numpy as np
+import pandas as pd
+from PIL import Image
+import plotly.graph_objs as go
+import streamlit as st
+import streamlit_antd_components as sac
+
+from utils.sanitize_code import sanitize_code
+from workflow.visualization.viz_suggestion import vis_button_suggest, vis_talk_suggest
+from workflow.visualization.viz_coding import vis_execution, vis_code_gen
+from workflow.visualization.viz_quick_action import plot_for_option
+from workflow.visualization.viz_color import vis_palette
+
+def vis_quick_actions(agent):
+
+    cols_list = agent.load_df().columns.tolist()
+    options = ["直方图", "饼图", "箱线图", "折线图"]
+
+    selected_col = st.selectbox("选择一个列:", cols_list)
+
+    logo_dir = r"logo\sec3"
+    logo_paths = {opt: os.path.join(logo_dir, f"{opt}.png") for opt in options}
+
+    cols = st.columns(len(options))
+
+    fig_placeholder = st.empty()
+
+    for idx, opt in enumerate(options):
+        with cols[idx]:
+            left, center, right = st.columns([1, 8, 1]) 
+            with center:
+                st.write(opt)
+                path = logo_paths.get(opt)
+                if path and os.path.exists(path):
+                    st.image(Image.open(path), width=80)
+                else:
+                    st.text("Logo 文件未找到")
+
+                if st.button("Try me", key=f"try_{idx}"):
+                    fig = plot_for_option(agent.load_df(), opt, selected_col)
+                    fig_placeholder.plotly_chart(fig, use_container_width=True)
+
+
+def vis_result(agent) -> None:
+    
+    fig_desc_list = agent.load_fig() 
+    total = len(fig_desc_list)
+    PAGE_SIZE = 5
+
+    current_page = sac.pagination(
+        total=total,
+        page_size=PAGE_SIZE,
+        align='center',
+        jump=False,
+        show_total=True,
+        variant='filled',
+        color='#44658C'
+    )
+
+    start_idx = (current_page - 1) * PAGE_SIZE
+    end_idx = min(start_idx + PAGE_SIZE, total)
+    page_items = fig_desc_list[start_idx:end_idx]
+
+    for offset, item in enumerate(page_items):
+        
+        idx = start_idx + offset
+        fig = item["fig"]
+        desc = item["desc"]
+
+        st.plotly_chart(
+            fig,
+            use_container_width=True,
+            key=f"fig_{idx}"
+        )
+        if desc is not None:
+            st.write(desc)
+
+
+def vis_chat(agent, auto = False):
+    
+    msg = st.chat_message("assistant")
+    msg.write(
+        "我是 Anystat 数据分析助手，很高兴为您服务！\n\n"
+        "您可以在下方对话框输入具体可视化需求，"
+        "也可以点击下面的按钮，一键获取可视化建议并绘图。"
+    )
+    analyze_clicked = msg.button("🔍 可视化推荐", key="viz_suggest")
+    reply_placeholder = msg.empty()
+
+    chat_history = agent.load_memory()
+
+    for idx, entry in enumerate(chat_history):
+        bubble = st.chat_message(entry["role"])
+        content = entry["content"]
+        if isinstance(content, str):
+            bubble.write(content)
+        elif isinstance(content, go.Figure):
+            bubble.plotly_chart(
+                content,
+                use_container_width=True,
+                key=f"chart-{idx}"
+            )
+
+    already_generated = any(
+        entry["role"] == "assistant" and "图" in str(entry["content"])
+        for entry in chat_history
+    )
+
+    # 按钮路径
+    if analyze_clicked or (auto and not already_generated):
+        st.chat_message("user").write("请帮我做可视化分析")
+        agent.add_memory({'role': 'user', 'content': "请帮我做可视化分析"})
+        with st.spinner("正在处理您的请求..."):
+            rec = vis_button_suggest(agent)
+            agent.save_suggestion(rec)
+            st.chat_message("assistant").write(rec)
+            agent.add_memory({"role": "assistant", "content": str(rec)})
+
+    # 对话路径
+    reply = None
+    user_input = None
+    user_input = st.chat_input("请输入需求，例如'请给我一些可视化建议'")
+    if user_input is not None:
+        st.chat_message("user").write(user_input)
+        with st.spinner("正在处理您的请求..."):
+            agent.save_user_input(user_input)
+            agent.add_memory({"role": "user", "content": user_input})
+            rec = vis_talk_suggest(agent, user_input)
+            agent.save_suggestion(rec)
+            st.chat_message("assistant").write(rec)
+            agent.add_memory({"role": "assistant", "content": str(rec)})
+            st.rerun()
+
+
+if __name__ == "__main__":
+
+    st.title("统计可视化分析")
+    st.markdown("---")
+
+    preproc_agent = st.session_state.data_preprocess_agent
+    load_agent   = st.session_state.data_loading_agent
+    planner = st.session_state.planner_agent
+    auto = planner.vis_auto
+
+    processed_df = preproc_agent.load_processed_df()
+    if processed_df is None:
+        df = load_agent.load_df()
+    else:
+        df = processed_df
+
+    if df is None:
+        st.warning("⚠️ ���先在数据导入页面加载数据")
+        st.stop()
+
+    if isinstance(df, np.ndarray):
+        df = pd.DataFrame(df)
+
+    df_shuffled = df.sample(frac=1, random_state=42).reset_index(drop=True)
+    agent = st.session_state.visualization_agent
+    agent.add_df(df_shuffled)
+
+    if st.session_state.auto_mode == True:
+        if (agent.finish_auto_task == True and planner.switched_vis == False) or planner.vis_auto == False:
+            planner.finish_vis_auto()
+            st.switch_page("workflow/modeling/modeling_render.py")
+
+    code = agent.load_code()
+    if code is None:
+        code_expand = False
+    else:
+        code_expand = True
+        
+    fig = agent.load_fig()
+    if fig is None:
+        fig_expand = False
+    else:
+        fig_expand = True
+
+    c = st.columns(2)
+    # with c[1].expander('快速可视化', False):
+    #     vis_quick_actions(agent)
+    with c[0].expander('配色选择', True):
+        vis_palette(agent)
+    with c[1].expander('可视化建议', True):
+        vis_chat(agent, auto)
+        vis_code_gen(agent, auto = auto)
+    with c[0].expander('可视化执行', code_expand):
+        vis_execution(agent, auto = auto)
+    with c[0].expander('可视化结果', fig_expand):
+        vis_result(agent)

workflow/visualization/viz_suggestion.py

@@ -0,0 +1,38 @@
+import streamlit as st
+
+
+def vis_button_suggest(agent):
+    """
+    按钮路径：调用 LLM 获取结构化的可视化推荐（JSON）。
+    """
+    df = agent.load_df()
+    cols_wo_id = agent.load_cols_wo_id()
+
+    if cols_wo_id is None:
+        cols_wo_id = [str(c) for c in df.columns if not str(c).lower().startswith(('id', 'idx', 'index'))]
+        agent.save_cols_wo_id(cols_wo_id)
+
+    rec = agent.get_visualization_recommendations(cols_wo_id)
+
+    agent.save_recommendations(rec)
+    agent.refine_suggestions(rec)
+
+    return rec
+
+    
+def vis_talk_suggest(agent, user_input):
+    """
+    对话路径：根据对话获取建议
+    """
+    df = agent.load_df()
+    cols_wo_id = agent.load_cols_wo_id()
+
+    if cols_wo_id is None:
+        cols_wo_id = [c for c in df.columns if not c.lower().startswith(('id', '编号', '序号', 'index'))]
+        agent.save_cols_wo_id(cols_wo_id)
+
+    rec = agent.get_visualization_recommendations(cols_wo_id, user_input)
+    agent.save_recommendations(rec)
+    agent.refine_suggestions(rec)
+
+    return rec