feat: presentation

.streamlit/config.toml

@@ -1,17 +1,17 @@
 [theme]
 base = "dark"
 baseFontSize = 15
-primaryColor = "#6EA8FE"
-backgroundColor = "#0D1117"
-secondaryBackgroundColor = "#1A1F2B"
-textColor = "#D1D5DB"
-linkColor = "#B8C0FF"
-borderColor = "#2E3440"
+primaryColor = "#1ED760"
+backgroundColor = "#121212"
+secondaryBackgroundColor = "#333333"
+textColor = "#FFFFFF"
+linkColor = "#9D9D9D"
+borderColor = "#7F7F7F"
 showWidgetBorder = false
 baseRadius = "0.3rem"
-font = "JetBrains Mono"
+font = "Poppins"
 
 [theme.sidebar]
-backgroundColor = "#0A0A0A"
-secondaryBackgroundColor = "#1A1A1A"
-borderColor = "#2E3440"
+backgroundColor = "#000000"
+secondaryBackgroundColor = "#333333"
+borderColor = "#696969"

.streamlit/theme.toml

@@ -1,2 +1,2 @@
-theme_name = "柳暗 (Willows Dark) 🌒"
-theme_poem = "🌒「深而不死黑，蓝而不夺目，静而不沉闷」柳影婆娑之下，代码悄然生长。"
+theme_name = "Spotify"
+theme_poem = ""

src copy/components/metrics_visualizer.py

@@ -0,0 +1,39 @@
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+import time
+
+
+def render_metrics_charts(current_study, current_trial):
+    """把原来在 tab_charts 里的 DataFrame 可视化代码都搬进来，只依赖 current_trial 和 st.session_state."""
+    if not current_trial.metrics_data:
+        st.info("当前 Trial 没有可显示的指标数据。")
+        return
+
+    # 全局步骤控制、st.session_state.shared_selected_global_step 等逻辑照搬
+    # …（省略，直接粘进去原来 streamlit_app.py 中的控制器和自动播放部分）…
+
+    # 然后就是那段循环绘图和 st.metric + st.plotly_chart + st.dataframe
+    metric_names = sorted(current_trial.metrics_data.keys())
+    cols_per_row = st.slider(
+        "每行图表数量",
+        1,
+        4,
+        2,
+        key=f"cols_slider_{current_study.name}_{current_trial.name}",
+    )
+    for i in range(0, len(metric_names), cols_per_row):
+        chunk = metric_names[i : i + cols_per_row]
+        cols = st.columns(len(chunk))
+        for j, m in enumerate(chunk):
+            with cols[j]:
+                df = current_trial.get_metric_dataframe(m)
+                if df is None or df.empty:
+                    st.warning(f"指标 '{m}' 无数据")
+                    continue
+                st.subheader(m)
+                # …Metric 计算 + Plotly 绘制 + 高亮 + 点击同步…
+                fig = go.Figure()
+                # …省略：完全同原来逻辑…
+                st.plotly_chart(fig, use_container_width=True, key=f"chart_{m}")
+                st.dataframe(df)

src copy/data_loader.py

@@ -0,0 +1,207 @@
+# data_loader.py
+from pathlib import Path
+from typing import Dict, List, Any
+import pandas as pd
+import tomli
+import streamlit as st
+from functools import lru_cache  # For non-Streamlit specific caching if needed
+
+# Assuming utils.py is in the same directory
+from utils import DATA_ROOT_PATH  # Used for ensuring directory exists
+
+# --- Cache Clearing Functions ---
+# These are more specific cache clearing functions that can be called by model methods.
+
+
+def clear_study_cache():
+    """Clears all study discovery cache."""
+    discover_studies_cached.clear()
+    st.toast("所有 Study 发现缓存已清除。")
+
+
+def clear_trial_cache():
+    """Clears all trial-related data loading caches."""
+    # This is a bit broad. Ideally, clear caches for specific trials/studies.
+    load_input_variables_from_path.clear()
+    load_all_metrics_for_trial_path.clear()
+    discover_trials_from_path.clear()
+    st.toast("所有 Trial 数据加载缓存已清除。")
+
+
+def clear_specific_trial_metric_cache(trial_path: Path):
+    load_all_metrics_for_trial_path.clear()  # This clears the whole cache for this func
+    # For more granular control with @st.cache_data, you'd typically rely on Streamlit's
+    # automatic cache invalidation based on input args, or rerun.
+    # If using lru_cache, you could do: load_all_metrics_for_trial_path.cache_clear()
+    # but for st.cache_data, clearing for specific args is not direct.
+    # The common pattern is to clear the entire function's cache.
+    st.toast(f"Trial '{trial_path.name}' 的指标缓存已清除 (函数级别)。")
+
+
+def clear_specific_trial_input_vars_cache(trial_path: Path):
+    load_input_variables_from_path.clear()
+    st.toast(f"Trial '{trial_path.name}' 的参数缓存已清除 (函数级别)。")
+
+
+def clear_specific_study_trial_discovery_cache(study_path: Path):
+    discover_trials_from_path.clear()
+    st.toast(f"Study '{study_path.name}' 的 Trial 发现缓存已清除 (函数级别)。")
+
+
+# --- Data Discovery and Loading Functions (Cached) ---
+
+
+def ensure_data_directory_exists(data_path: Path = DATA_ROOT_PATH):
+    """Ensures the root data directory exists."""
+    if not data_path.exists():
+        try:
+            data_path.mkdir(parents=True, exist_ok=True)
+            st.info(f"数据目录 {data_path} 已创建。")
+        except Exception as e:
+            st.error(f"创建数据目录 {data_path} 失败: {e}")
+            st.stop()
+    elif not data_path.is_dir():
+        st.error(f"路径 {data_path} 已存在但不是一个目录。")
+        st.stop()
+
+
+@st.cache_data(ttl=3600)  # Cache for 1 hour, or adjust as needed
+def discover_studies_cached(
+    _data_root: Path,
+) -> Dict[
+    str, Any
+]:  # Return type hint as Any to avoid circular dep with data_models.Study
+    """
+    Scans the data_root for study directories and returns a dictionary
+    mapping study names to Study objects (or just their paths initially).
+    The actual Study object creation happens in the main app for now.
+    """
+    # To avoid issues with caching complex objects directly, or circular dependencies,
+    # this function can return simpler structures like Dict[str, Path]
+    # and the main app or model can instantiate Study objects.
+    # For this iteration, we'll import Study here for convenience, assuming careful structure.
+    from data_models import (
+        Study,
+    )  # Local import to help with potential circularity if models grow complex
+
+    if not _data_root.is_dir():
+        return {}
+    studies = {}
+    for d in _data_root.iterdir():
+        if d.is_dir():
+            studies[d.name] = Study(name=d.name, path=d)
+    return studies
+
+
+@st.cache_data(ttl=3600)
+def discover_trials_from_path(_study_path: Path) -> Dict[str, Path]:
+    """Scans a study_path for trial directories."""
+    if not _study_path.is_dir():
+        return {}
+    trials = {}
+    for d in _study_path.iterdir():
+        if d.is_dir():
+            trials[d.name] = d
+    return trials
+
+
+@st.cache_data(ttl=3600)
+def load_input_variables_from_path(_trial_path: Path) -> Dict[str, Any]:
+    """Loads input_variables.toml from a trial directory."""
+    input_vars_file = _trial_path / "input_variables.toml"
+    if input_vars_file.exists():
+        try:
+            with open(input_vars_file, "rb") as f:
+                return tomli.load(f)
+        except tomli.TOMLDecodeError:
+            # st.error(f"错误：无法解析 input_variables.toml 文件于 {_trial_path}") # Avoid st.error in cached funcs if possible
+            print(f"Error parsing input_variables.toml at {_trial_path}")
+            return {}
+    return {}
+
+
+def _load_single_metric_toml(_toml_file_path: Path) -> pd.DataFrame:
+    """Loads metrics from a single TOML file into a DataFrame."""
+    if not _toml_file_path.exists():
+        return pd.DataFrame()
+    try:
+        with open(_toml_file_path, "rb") as f:
+            data = tomli.load(f)
+        metrics_list = data.get("metrics", [])
+        if not metrics_list:
+            return pd.DataFrame()
+        return pd.DataFrame(metrics_list)
+    except tomli.TOMLDecodeError:
+        print(f"Error parsing TOML file: {_toml_file_path.name}")
+        return pd.DataFrame()
+    except Exception as e:
+        print(f"Error loading {_toml_file_path.name}: {e}")
+        return pd.DataFrame()
+
+
+@st.cache_data(ttl=300)  # Cache metric data for 5 minutes
+def load_all_metrics_for_trial_path(_trial_path: Path) -> Dict[str, pd.DataFrame]:
+    """
+    Loads all metrics from all tracks in a trial.
+    Returns a dictionary where keys are metric names (e.g., 'loss', 'accuracy')
+    and values are DataFrames containing 'global_step', 'value', and 'track'.
+    """
+    scalar_dir = _trial_path / "logs" / "scalar"
+    if not scalar_dir.is_dir():
+        return {}
+
+    all_metrics_data_combined: Dict[str, pd.DataFrame] = {}
+
+    for toml_file in scalar_dir.glob("metrics_*.toml"):
+        track_name = toml_file.stem.replace("metrics_", "")
+        df_track = _load_single_metric_toml(toml_file)
+
+        if df_track.empty or "global_step" not in df_track.columns:
+            continue
+
+        id_vars = ["global_step"]
+        value_vars = [col for col in df_track.columns if col not in id_vars]
+
+        if not value_vars:
+            continue
+
+        # Process each metric column individually to build up the combined DataFrame
+        for metric_col_name in value_vars:
+            try:
+                # Create a DataFrame for the current metric and track
+                current_metric_df = df_track[["global_step", metric_col_name]].copy()
+                current_metric_df.rename(
+                    columns={metric_col_name: "value"}, inplace=True
+                )
+                current_metric_df["track"] = track_name
+                current_metric_df["value"] = pd.to_numeric(
+                    current_metric_df["value"], errors="coerce"
+                )
+                current_metric_df.dropna(subset=["value"], inplace=True)
+
+                if current_metric_df.empty:
+                    continue
+
+                # Append to the combined DataFrame for this metric_col_name
+                if metric_col_name not in all_metrics_data_combined:
+                    all_metrics_data_combined[metric_col_name] = current_metric_df
+                else:
+                    all_metrics_data_combined[metric_col_name] = pd.concat(
+                        [all_metrics_data_combined[metric_col_name], current_metric_df],
+                        ignore_index=True,
+                    )
+            except Exception as e:
+                print(
+                    f"Error processing metric '{metric_col_name}' from file '{toml_file.name}': {e}"
+                )
+                continue
+
+    # Sort data by global_step for proper line plotting
+    for metric_name in all_metrics_data_combined:
+        all_metrics_data_combined[metric_name] = (
+            all_metrics_data_combined[metric_name]
+            .sort_values(by=["track", "global_step"])
+            .reset_index(drop=True)
+        )
+
+    return all_metrics_data_combined

src copy/data_models.py

@@ -0,0 +1,100 @@
+# data_models.py
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+import pandas as pd
+import streamlit as st  # For caching
+
+# Import from data_loader, assuming it's in the same directory
+# We'll define these functions in data_loader.py
+# To avoid circular imports, data_loader functions won't import data_models directly for type hints if possible,
+# or use string type hints.
+
+# Forward declaration for type hint if data_loader needs Study/Trial
+# class Study: pass
+# class Trial: pass
+
+from data_loader import (
+    load_input_variables_from_path,
+    load_all_metrics_for_trial_path,
+    discover_trials_from_path,
+    clear_trial_cache as clear_trial_loader_cache,
+    clear_study_cache as clear_study_loader_cache,
+    clear_specific_trial_metric_cache,
+    clear_specific_trial_input_vars_cache,
+    clear_specific_study_trial_discovery_cache,
+)
+
+
+@dataclass
+class Trial:
+    name: str
+    path: Path
+    study_name: str  # To know its parent study
+    input_variables: Dict[str, Any] = field(default_factory=dict, repr=False)
+    metrics_data: Dict[str, pd.DataFrame] = field(
+        default_factory=dict, repr=False
+    )  # Key: metric_name, Value: DataFrame with global_step, value, track
+
+    def __post_init__(self):
+        # Automatically load data if needed, but prefer explicit calls from UI for clarity
+        pass
+
+    # Use st.cache_data on the loader functions, not directly here for complex objects.
+    # Instead, methods here will call cached loader functions.
+
+    def load_input_variables_cached(self):
+        """Loads or retrieves cached input variables."""
+        if not self.input_variables:  # Load only if not already populated
+            self.input_variables = load_input_variables_from_path(self.path)
+        return self.input_variables
+
+    def load_metrics_cached(self):
+        """Loads or retrieves cached metrics data."""
+        if not self.metrics_data:  # Load only if not already populated
+            self.metrics_data = load_all_metrics_for_trial_path(self.path)
+        return self.metrics_data
+
+    def get_metric_dataframe(self, metric_name: str) -> Optional[pd.DataFrame]:
+        """Returns the DataFrame for a specific metric, combining all tracks."""
+        return self.metrics_data.get(metric_name)
+
+    def clear_cache(self):
+        """Clears cached data for this specific trial."""
+        # Clear Streamlit's cache for functions related to this trial
+        clear_specific_trial_metric_cache(self.path)
+        clear_specific_trial_input_vars_cache(self.path)
+        # Reset instance variables
+        self.input_variables = {}
+        self.metrics_data = {}
+        st.success(f"Trial '{self.name}' 的缓存已清除。")
+
+
+@dataclass
+class Study:
+    name: str
+    path: Path
+    trials: Dict[str, Trial] = field(default_factory=dict, repr=False)
+
+    def discover_trials_cached(self):
+        """Discovers or retrieves cached trials for this study."""
+        if not self.trials:  # Discover only if not already populated
+            trial_paths = discover_trials_from_path(
+                self.path
+            )  # This loader function should be cached
+            for trial_name, trial_path in trial_paths.items():
+                self.trials[trial_name] = Trial(
+                    name=trial_name, path=trial_path, study_name=self.name
+                )
+        return self.trials
+
+    def get_trial(self, trial_name: str) -> Optional[Trial]:
+        return self.trials.get(trial_name)
+
+    def clear_cache(self):
+        """Clears cached data for this study and its trials."""
+        clear_specific_study_trial_discovery_cache(self.path)
+        for trial in self.trials.values():
+            trial.clear_cache()  # Clear cache for each trial within the study
+        self.trials = {}  # Reset trials dictionary
+        st.success(f"Study '{self.name}' 及其 Trials 的缓存已清除。")

src copy/streamlit_app.py

@@ -0,0 +1,634 @@
+import streamlit as st
+
+# --- Page Configuration ---
+st.set_page_config(
+    layout="wide",
+    page_title="柳暗花明 (flowillower)",
+    page_icon=":sunrise_over_mountains:",
+    initial_sidebar_state="expanded",
+)
+
+from pathlib import Path
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import pandas as pd
+import time
+
+# --- Logo ---
+st.logo("logo.png", icon_image="logo.png")
+
+# 导入重构后的模块
+try:
+    from utils import DATA_ROOT_PATH, AppMode
+    from data_models import Study, Trial  # Study, Trial will be used
+    from data_loader import discover_studies_cached, ensure_data_directory_exists
+    from theme_selector import render_theme_selector  # 新增：导入主题选择器
+except ImportError as e:
+    st.error(
+        f"导入模块失败，请确保 utils.py, data_models.py, data_loader.py, theme_selector.py 文件存在于正确的位置: {e}"
+    )
+    st.stop()
+
+
+# --- 应用状态管理 ---
+if "selected_study_name" not in st.session_state:
+    st.session_state.selected_study_name = None
+if "selected_trial_name" not in st.session_state:
+    st.session_state.selected_trial_name = None
+# if "studies_data" not in st.session_state: # Not directly used, discover_studies_cached returns objects
+#     st.session_state.studies_data = {}
+if "app_mode" not in st.session_state:
+    st.session_state.app_mode = AppMode.VIEWING
+
+# 新增: 用于跨图表共享选中的 global_step
+if "shared_selected_global_step" not in st.session_state:
+    st.session_state.shared_selected_global_step = None
+
+# 新增: 自动播放相关状态
+if "is_auto_playing" not in st.session_state:
+    st.session_state.is_auto_playing = False
+if "auto_play_speed" not in st.session_state:
+    st.session_state.auto_play_speed = 1.0
+if "auto_play_needs_rerun" not in st.session_state:
+    st.session_state.auto_play_needs_rerun = False
+
+
+# --- UI Rendering ---
+
+# --- Header ---
+header_cols = st.columns([2, 3, 1.5, 0.5, 0.5, 0.5, 1])  # 新增一列用于主题选择器
+with header_cols[0]:
+    st.markdown("## 柳暗花明")
+    st.caption("flowillower")
+
+ensure_data_directory_exists(DATA_ROOT_PATH)
+all_study_objects = discover_studies_cached(DATA_ROOT_PATH)
+study_names = list(all_study_objects.keys())
+
+if not study_names:
+    st.warning(
+        f"在 {DATA_ROOT_PATH} 未找到任何 Study。请确保您的数据结构正确或使用 flowillower API 开始记录实验。"
+    )
+
+if study_names:
+    with header_cols[1]:
+        if st.session_state.selected_study_name not in study_names:
+            st.session_state.selected_study_name = (
+                study_names[0] if study_names else None
+            )
+
+        selected_study_name_from_ui = st.selectbox(
+            "选择 Study (Select Study)",
+            study_names,
+            index=study_names.index(st.session_state.selected_study_name)
+            if st.session_state.selected_study_name in study_names
+            else 0,
+            label_visibility="collapsed",
+            key="study_selector_main_ui",
+        )
+        if selected_study_name_from_ui != st.session_state.selected_study_name:
+            st.session_state.selected_study_name = selected_study_name_from_ui
+            st.session_state.selected_trial_name = None
+            st.session_state.shared_selected_global_step = None  # Study 变化时清除高亮
+            st.rerun()
+
+    with header_cols[2]:
+        if st.session_state.selected_study_name:
+            st.write(f"当前 Study: **{st.session_state.selected_study_name}**")
+else:
+    with header_cols[1]:
+        st.info("没有可用的 Study。")
+
+with header_cols[3]:
+    st.button("➕", help="添加 (Add)", disabled=True)
+with header_cols[4]:
+    st.button("⚙️", help="设置 (Settings)", disabled=True)
+with header_cols[5]:
+    st.button("👤", help="用户 (User)", disabled=True)
+with header_cols[6]:  # 新增：主题选择器列
+    with st.container():
+        # st.markdown("**主题**")
+        render_theme_selector()
+st.markdown("---")
+
+# --- Sidebar ---
+current_study: Study | None = None
+if (
+    st.session_state.selected_study_name
+    and st.session_state.selected_study_name in all_study_objects
+):
+    current_study = all_study_objects[st.session_state.selected_study_name]
+    if not current_study.trials:
+        current_study.discover_trials_cached()
+
+trial_names = list(current_study.trials.keys()) if current_study else []
+
+with st.sidebar:
+    st.markdown("### Study")
+    if current_study:
+        st.markdown(f"##### {current_study.name}")
+        if st.button("刷新 Study 数据 (Refresh Study Data)", use_container_width=True):
+            current_study.clear_cache()
+            st.rerun()
+        if st.button("概览 (Overview)", use_container_width=True, disabled=True):
+            st.toast("功能待实现")
+        if st.button(
+            "图表对比视图 (Chart Comparison View)",
+            use_container_width=True,
+            disabled=True,
+        ):
+            st.toast("功能待实现")
+    else:
+        st.markdown("未选择 Study")
+
+    st.markdown("---")
+    st.markdown("### Trial")
+    if current_study and trial_names:
+        if st.session_state.selected_trial_name not in trial_names:
+            st.session_state.selected_trial_name = (
+                trial_names[0] if trial_names else None
+            )
+
+        selected_trial_name_from_ui = st.radio(
+            "选择 Trial (Select Trial)",
+            trial_names,
+            index=trial_names.index(st.session_state.selected_trial_name)
+            if st.session_state.selected_trial_name in trial_names
+            else 0,
+            label_visibility="collapsed",
+            key="trial_selector_sidebar_ui",
+        )
+        if selected_trial_name_from_ui != st.session_state.selected_trial_name:
+            st.session_state.selected_trial_name = selected_trial_name_from_ui
+            st.session_state.shared_selected_global_step = None  # Trial 变化时清除高亮
+            st.rerun()
+        if st.session_state.selected_trial_name:
+            st.markdown(f"当前选择: **{st.session_state.selected_trial_name}**")
+    elif current_study:
+        st.info(f"Study '{current_study.name}' 中没有 Trial。")
+    else:
+        st.info("请先选择一个 Study。")
+    st.markdown("---")
+    if st.button("⚙️ App 设置 (App Settings)", use_container_width=True, disabled=True):
+        st.toast("功能待实现")
+
+# --- Main Content Area ---
+current_trial: Trial | None = None
+if (
+    current_study
+    and st.session_state.selected_trial_name
+    and st.session_state.selected_trial_name in current_study.trials
+):
+    current_trial = current_study.trials[st.session_state.selected_trial_name]
+    current_trial.load_input_variables_cached()
+    current_trial.load_metrics_cached()
+
+if current_study and current_trial:
+    main_title_cols = st.columns([3, 1, 0.5])
+    with main_title_cols[0]:
+        st.markdown(f"## {current_trial.name}")
+        st.caption(f"属于 Study: {current_study.name}")
+    with main_title_cols[1]:
+        if st.button("刷新 Trial 数据 (Refresh Trial Data)", type="secondary"):
+            current_trial.clear_cache()
+            st.rerun()
+    with main_title_cols[2]:
+        st.button("...", help="更多选项 (More Options)", disabled=True)
+
+    # 添加全局步骤控制器
+    if current_trial.metrics_data:
+        st.markdown("### 全局步骤控制 (Global Step Control)")
+
+        # 获取所有指标的全局步骤范围
+        all_global_steps = set()
+        for metric_name in current_trial.metrics_data.keys():
+            df_metric = current_trial.get_metric_dataframe(metric_name)
+            if (
+                df_metric is not None
+                and not df_metric.empty
+                and "global_step" in df_metric.columns
+            ):
+                all_global_steps.update(df_metric["global_step"].tolist())
+
+        if all_global_steps:
+            all_global_steps = sorted(list(all_global_steps))
+            min_step, max_step = min(all_global_steps), max(all_global_steps)
+
+            # 控制器布局
+            control_cols = st.columns([3, 1, 1, 1])
+
+            with control_cols[0]:
+                # 滑动条
+                if st.session_state.shared_selected_global_step is None:
+                    # 默认选择最后一个step
+                    st.session_state.shared_selected_global_step = max_step
+
+                # 确保当前选中的步骤在有效范围内
+                if st.session_state.shared_selected_global_step not in all_global_steps:
+                    # 找到最接近的有效步骤
+                    closest_step = min(
+                        all_global_steps,
+                        key=lambda x: abs(
+                            x - st.session_state.shared_selected_global_step
+                        ),
+                    )
+                    st.session_state.shared_selected_global_step = closest_step
+
+                selected_step = st.select_slider(
+                    "选择全局步骤",
+                    options=all_global_steps,
+                    value=st.session_state.shared_selected_global_step,
+                    format_func=lambda x: f"Step {x}",
+                    key="global_step_slider",
+                )
+
+                if selected_step != st.session_state.shared_selected_global_step:
+                    st.session_state.shared_selected_global_step = selected_step
+                    st.rerun()
+
+            with control_cols[1]:
+                # 播放/暂停按钮
+                if st.session_state.is_auto_playing:
+                    if st.button("⏸️ 暂停", type="primary", use_container_width=True):
+                        st.session_state.is_auto_playing = False
+                        st.rerun()
+                else:
+                    if st.button("▶️ 播放", type="primary", use_container_width=True):
+                        st.session_state.is_auto_playing = True
+                        st.rerun()
+
+            with control_cols[2]:
+                # 速度控制
+                speed = st.selectbox(
+                    "播放速度",
+                    options=[0.5, 1.0, 2.0, 4.0],
+                    index=[0.5, 1.0, 2.0, 4.0].index(st.session_state.auto_play_speed),
+                    format_func=lambda x: f"{x}x",
+                    key="speed_selector",
+                )
+                if speed != st.session_state.auto_play_speed:
+                    st.session_state.auto_play_speed = speed
+
+            with control_cols[3]:
+                # 重置按钮
+                if st.button("🔄 重置", use_container_width=True):
+                    st.session_state.shared_selected_global_step = min_step
+                    st.session_state.is_auto_playing = False
+                    st.rerun()
+
+            # 自动播放逻辑 - 设置标志但不立即rerun
+            if st.session_state.is_auto_playing:
+                current_index = all_global_steps.index(
+                    st.session_state.shared_selected_global_step
+                )
+                if current_index < len(all_global_steps) - 1:
+                    # 等待指定时间后移动到下一步
+                    time.sleep(1.0 / st.session_state.auto_play_speed)
+                    st.session_state.shared_selected_global_step = all_global_steps[
+                        current_index + 1
+                    ]
+                    st.session_state.auto_play_needs_rerun = True
+                else:
+                    # 到达末尾，停止播放
+                    st.session_state.is_auto_playing = False
+                    st.session_state.auto_play_needs_rerun = True
+
+            # 显示当前步骤信息
+            st.info(
+                f"当前选中步骤: **{st.session_state.shared_selected_global_step}** / {max_step}"
+            )
+
+        st.markdown("---")
+
+    tab_titles = [
+        "图表 (Charts)",
+        "参数 (Parameters)",
+        "系统 (System)",
+        "日志 (Logs)",
+        "环境 (Environment)",
+    ]
+    tab_charts, tab_params, tab_system, tab_logs, tab_env = st.tabs(tab_titles)
+
+    with tab_charts:
+        st.header("指标图表 (Metrics Charts)")
+        st.markdown("---")
+
+        if not current_trial.metrics_data:
+            st.info("当前 Trial 没有可显示的指标数据。")
+        else:
+            num_metrics = len(current_trial.metrics_data)
+            cols_per_row = st.slider(
+                "每行图表数量 (Charts per row)",
+                1,
+                4,
+                min(2, num_metrics) if num_metrics > 0 else 1,
+                key=f"cols_slider_{current_study.name}_{current_trial.name}",
+            )
+            metric_names = sorted(list(current_trial.metrics_data.keys()))
+
+            for i in range(0, num_metrics, cols_per_row):
+                metric_chunk = metric_names[i : i + cols_per_row]
+                chart_cols = st.columns(cols_per_row)
+                for j, metric_name in enumerate(metric_chunk):
+                    with chart_cols[j]:
+                        df_metric = current_trial.get_metric_dataframe(metric_name)
+                        if df_metric is None or df_metric.empty:
+                            st.warning(f"指标 '{metric_name}' 数据不完整或缺失。")
+                            continue
+
+                        with st.container(border=True):
+                            st.subheader(metric_name)
+
+                            # 添加metric组件 - 显示当前值和增量
+                            try:
+                                current_step = (
+                                    st.session_state.shared_selected_global_step
+                                )
+
+                                # 获取所有可能的track
+                                all_tracks = (
+                                    df_metric["track"].unique()
+                                    if "track" in df_metric.columns
+                                    else [None]
+                                )
+
+                                # 为每个track创建metric组件
+                                if len(all_tracks) > 1:
+                                    metric_cols = st.columns(len(all_tracks))
+                                else:
+                                    metric_cols = [st]  # 使用整个容器
+
+                                for idx, track in enumerate(all_tracks):
+                                    # 查找当前步骤的数据
+                                    if track is not None:
+                                        current_step_data = df_metric[
+                                            (df_metric["global_step"] == current_step)
+                                            & (df_metric["track"] == track)
+                                        ]
+                                    else:
+                                        current_step_data = df_metric[
+                                            df_metric["global_step"] == current_step
+                                        ]
+
+                                    current_value = None
+                                    delta_value = None
+
+                                    # 如果当前步骤没有该track的数据，向前查找最近的步骤
+                                    if current_step_data.empty:
+                                        # 向前查找最近的有该track数据的步骤
+                                        current_index = all_global_steps.index(
+                                            current_step
+                                        )
+                                        for search_idx in range(
+                                            current_index - 1, -1, -1
+                                        ):
+                                            search_step = all_global_steps[search_idx]
+                                            if track is not None:
+                                                search_data = df_metric[
+                                                    (
+                                                        df_metric["global_step"]
+                                                        == search_step
+                                                    )
+                                                    & (df_metric["track"] == track)
+                                                ]
+                                            else:
+                                                search_data = df_metric[
+                                                    df_metric["global_step"]
+                                                    == search_step
+                                                ]
+
+                                            if not search_data.empty:
+                                                current_value = search_data[
+                                                    "value"
+                                                ].iloc[0]
+                                                current_step_found = search_step
+                                                break
+                                    else:
+                                        current_value = current_step_data["value"].iloc[
+                                            0
+                                        ]
+                                        current_step_found = current_step
+
+                                    # 计算增量：查找比当前找到的步骤更早的数据
+                                    if current_value is not None:
+                                        current_found_index = all_global_steps.index(
+                                            current_step_found
+                                        )
+                                        for prev_idx in range(
+                                            current_found_index - 1, -1, -1
+                                        ):
+                                            prev_step = all_global_steps[prev_idx]
+                                            if track is not None:
+                                                prev_step_data = df_metric[
+                                                    (
+                                                        df_metric["global_step"]
+                                                        == prev_step
+                                                    )
+                                                    & (df_metric["track"] == track)
+                                                ]
+                                            else:
+                                                prev_step_data = df_metric[
+                                                    df_metric["global_step"]
+                                                    == prev_step
+                                                ]
+
+                                            if not prev_step_data.empty:
+                                                prev_value = prev_step_data[
+                                                    "value"
+                                                ].iloc[0]
+                                                delta_value = current_value - prev_value
+                                                break
+
+                                    # 显示metric组件
+                                    with (
+                                        metric_cols[idx]
+                                        if len(all_tracks) > 1
+                                        else metric_cols[0]
+                                    ):
+                                        if current_value is not None:
+                                            # 确定label
+                                            if track is not None:
+                                                if current_step_found != current_step:
+                                                    label = f"{track} (Step {current_step_found})"
+                                                else:
+                                                    label = f"{track}"
+                                            else:
+                                                if current_step_found != current_step:
+                                                    label = f"当前值 (Step {current_step_found})"
+                                                else:
+                                                    label = (
+                                                        f"当前值 (Step {current_step})"
+                                                    )
+
+                                            st.metric(
+                                                label=label,
+                                                value=f"{current_value:.4f}",
+                                                delta=f"{delta_value:.4f}"
+                                                if delta_value is not None
+                                                else None,
+                                            )
+                                        else:
+                                            # 没有找到任何数据
+                                            track_label = (
+                                                track if track is not None else "数据"
+                                            )
+                                            st.metric(
+                                                label=f"{track_label}",
+                                                value="无数据",
+                                                delta=None,
+                                            )
+
+                            except Exception as e:
+                                st.warning(f"计算指标值时出错: {e}")
+
+                            try:
+                                # 创建 Plotly 图表
+                                fig = go.Figure()
+
+                                # 按track分组绘制线条
+                                if "track" in df_metric.columns:
+                                    tracks = df_metric["track"].unique()
+                                    colors = px.colors.qualitative.Set1[: len(tracks)]
+
+                                    for k, track in enumerate(tracks):
+                                        track_data = df_metric[
+                                            df_metric["track"] == track
+                                        ]
+                                        fig.add_trace(
+                                            go.Scatter(
+                                                x=track_data["global_step"],
+                                                y=track_data["value"],
+                                                mode="lines+markers",
+                                                name=track,
+                                                line=dict(
+                                                    color=colors[k % len(colors)]
+                                                ),
+                                                marker=dict(
+                                                    size=6,
+                                                    color=colors[k % len(colors)],
+                                                    line=dict(width=1, color="white"),
+                                                ),
+                                                customdata=track_data[
+                                                    ["global_step", "value", "track"]
+                                                ],
+                                                hovertemplate="<b>%{fullData.name}</b><br>"
+                                                + "Global Step: %{x}<br>"
+                                                + "Value: %{y}<br>"
+                                                + "<extra></extra>",
+                                            )
+                                        )
+                                else:
+                                    # 如果没有track列，绘制单条线
+                                    fig.add_trace(
+                                        go.Scatter(
+                                            x=df_metric["global_step"],
+                                            y=df_metric["value"],
+                                            mode="lines+markers",
+                                            name=metric_name,
+                                            marker=dict(
+                                                size=6,
+                                                line=dict(width=1, color="white"),
+                                            ),
+                                            customdata=df_metric[
+                                                ["global_step", "value"]
+                                            ],
+                                            hovertemplate="Global Step: %{x}<br>"
+                                            + "Value: %{y}<br>"
+                                            + "<extra></extra>",
+                                        )
+                                    )
+
+                                # 如果有共享的选中步骤，添加高亮线
+                                if (
+                                    st.session_state.shared_selected_global_step
+                                    is not None
+                                ):
+                                    fig.add_vline(
+                                        x=st.session_state.shared_selected_global_step,
+                                        line_width=2,
+                                        line_dash="solid",
+                                        line_color="firebrick",
+                                        opacity=0.9,
+                                    )
+
+                                # 设置图表布局
+                                fig.update_layout(
+                                    title=None,
+                                    xaxis_title="全局步骤 (Global Step)",
+                                    yaxis_title=metric_name,
+                                    height=400,
+                                    margin=dict(l=0, r=0, t=0, b=0),
+                                    showlegend=True
+                                    if "track" in df_metric.columns
+                                    and len(df_metric["track"].unique()) > 1
+                                    else False,
+                                    hovermode="closest",
+                                )
+
+                                # 显示图表并处理点击事件
+                                chart_key = f"chart_metric_{current_study.name}_{current_trial.name}_{metric_name}"
+                                clicked_points = st.plotly_chart(
+                                    fig,
+                                    use_container_width=True,
+                                    key=chart_key,
+                                    on_select="rerun",
+                                )
+
+                                # 处理点击事件
+                                if clicked_points and "selection" in clicked_points:
+                                    selection = clicked_points["selection"]
+                                    if (
+                                        "points" in selection
+                                        and len(selection["points"]) > 0
+                                    ):
+                                        # 获取第一个点击点的 x 坐标 (global_step)
+                                        clicked_x = selection["points"][0]["x"]
+                                        if clicked_x is not None:
+                                            new_step = int(clicked_x)
+                                            if (
+                                                st.session_state.get(
+                                                    "shared_selected_global_step"
+                                                )
+                                                != new_step
+                                            ):
+                                                st.session_state.shared_selected_global_step = new_step
+                                                # 点击图表时停止自动播放
+                                                st.session_state.is_auto_playing = False
+                                                st.rerun()
+
+                            except Exception as e:
+                                st.error(f"为指标 '{metric_name}' 生成图表时出错: {e}")
+                            st.dataframe(df_metric)
+                            # raise e
+
+    with tab_params:
+        st.header("输入参数 (Input Parameters)")
+        if current_trial.input_variables:
+            st.json(current_trial.input_variables)
+        else:
+            st.info("未找到 `input_variables.toml` 或文件为空。")
+
+    for tab_content, name in [
+        (tab_system, "系统监控"),
+        (tab_logs, "日志"),
+        (tab_env, "环境"),
+    ]:
+        with tab_content:
+            st.header(name)
+            st.info("此功能待您的 `flowillower` API 提供相关数据后实现。")
+
+elif not st.session_state.selected_study_name:
+    st.info("👈 请从顶部选择一个 Study 开始。")
+elif not st.session_state.selected_trial_name:
+    st.info("👈 请从侧边栏选择一个 Trial。")
+else:
+    st.info("请选择 Study 和 Trial 以查看数据。")
+
+st.markdown("---")
+st.caption("柳暗花明 (flowillower) - 数据可视化App")
+
+# 在页面最后处理自动播放的rerun
+if st.session_state.get("auto_play_needs_rerun", False):
+    st.session_state.auto_play_needs_rerun = False
+    st.rerun()

src copy/theme_selector.py

@@ -0,0 +1,162 @@
+import streamlit as st
+import toml
+from pathlib import Path
+import os
+import time
+
+
+class ThemeSelector:
+    def __init__(
+        self, themes_dir=".streamlit/themes", config_path=".streamlit/config.toml"
+    ):
+        self.themes_dir = Path(themes_dir)
+        self.config_path = Path(config_path)
+        self.themes = {}
+        self.load_themes()
+
+    def load_themes(self):
+        """加载所有主题文件"""
+        self.themes = {}
+        if not self.themes_dir.exists():
+            return
+
+        for theme_file in self.themes_dir.glob("*.toml"):
+            try:
+                theme_data = toml.load(theme_file)
+
+                # 从根级别获取theme_name和theme_poem
+                theme_name = theme_data.get("theme_name", theme_file.stem)
+                theme_poem = theme_data.get("theme_poem", "")
+                theme_config = theme_data.get("theme", {})
+
+                self.themes[theme_name] = {
+                    "file": theme_file,
+                    "name": theme_name,
+                    "poem": theme_poem,
+                    "config": theme_config,
+                }
+            except Exception as e:
+                st.warning(f"读取主题文件 {theme_file} 失败: {e}")
+
+    def get_current_theme(self):
+        """获取当前主题名称"""
+        if not self.config_path.exists():
+            return None
+
+        try:
+            # config = toml.load(self.config_path)
+            # # 从根级别读取theme_name
+            # current_theme_name = config.get("theme") or {}
+            # current_theme_name = current_theme_name.get("theme_name")
+            # return current_theme_name
+            theme_toml = self.config_path.parent / "theme.toml"
+            theme = toml.load(theme_toml)
+            return theme.get("theme_name")
+
+        except Exception:
+            return None
+
+    def apply_theme(self, theme_name):
+        """应用选定的主题"""
+        if theme_name not in self.themes:
+            st.error(f"主题 '{theme_name}' 不存在")
+            return False
+
+        try:
+            # 确保配置目录存在
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # 读取现有配置或创建新配置
+            config = {}
+            if self.config_path.exists():
+                try:
+                    config = toml.load(self.config_path)
+                except Exception:
+                    config = {}
+
+            # 添加根级别的theme_name和theme_poem
+            # config["theme_name"] = self.themes[theme_name]["name"]
+            # config["theme_poem"] = self.themes[theme_name]["poem"]
+
+            # 更新主题配置
+            theme_config = self.themes[theme_name]["config"].copy()
+            # theme_config["theme_name"] = self.themes[theme_name]["name"]
+            # theme_config["theme_poem"] = self.themes[theme_name]["poem"]
+            config["theme"] |= theme_config
+
+            # 写入配置文件
+            with open(self.config_path, "w", encoding="utf-8") as f:
+                toml.dump(config, f)
+
+            theme_toml = self.config_path.parent / "theme.toml"
+            with open(theme_toml, "w", encoding="utf-8") as f:
+                toml.dump(
+                    dict(
+                        theme_name=self.themes[theme_name]["name"],
+                        theme_poem=self.themes[theme_name]["poem"],
+                    ),
+                    f,
+                )
+
+            return True
+
+        except Exception as e:
+            st.error(f"应用主题失败: {e}")
+            return False
+
+    def render_theme_selector(self):
+        """渲染主题选择器UI"""
+        if not self.themes:
+            st.warning("未找到可用主题")
+            return
+
+        theme_names = list(self.themes.keys())
+        current_theme = self.get_current_theme()
+
+        # 确定当前选中的索引
+        current_index = 0
+        if current_theme and current_theme in theme_names:
+            current_index = theme_names.index(current_theme)
+
+        # 主题选择下拉菜单
+        selected_theme = st.selectbox(
+            "选择主题",
+            options=theme_names,
+            index=current_index,
+            format_func=lambda x: self.themes[x]["name"],
+            key="theme_selector_widget",
+            label_visibility="collapsed",
+        )
+
+        # 如果选择了新主题
+        if selected_theme != current_theme:
+            if self.apply_theme(selected_theme):
+                # 显示主题诗句
+                theme_poem = self.themes[selected_theme]["poem"]
+                if theme_poem:
+                    st.toast(f"✨ {theme_poem}", icon="🎨")
+                else:
+                    st.toast(f"已切换到主题: {selected_theme}", icon="🎨")
+
+                time.sleep(3)
+                # 延迟重新运行以应用主题
+                st.rerun()
+
+        return selected_theme
+
+
+# 全局主题选择器实例
+_theme_selector = None
+
+
+def get_theme_selector():
+    """获取全局主题选择器实例"""
+    global _theme_selector
+    if _theme_selector is None:
+        _theme_selector = ThemeSelector()
+    return _theme_selector
+
+
+def render_theme_selector():
+    """便捷函数：渲染主题选择器"""
+    return get_theme_selector().render_theme_selector()

src/.streamlit/config.toml

@@ -0,0 +1,17 @@
+[theme]
+base = "light"
+baseFontSize = 15
+primaryColor = "#FF5F7E"
+backgroundColor = "#F9FAFB"
+secondaryBackgroundColor = "#F0F4F8"
+textColor = "#1F2937"
+linkColor = "#2563EB"
+borderColor = "#D1D5DB"
+showWidgetBorder = false
+baseRadius = "0.3rem"
+font = "Poppins"
+
+[theme.sidebar]
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F3F4F6"
+borderColor = "#D1D5DB"

src/.streamlit/theme.toml

@@ -0,0 +1,2 @@
+theme_name = "花明 (Flowers Bright) 🌸"
+theme_poem = "🌸「浅色但不苍白，明亮而不过曝，柔和中有力量」"

src/.streamlit/themes/antropic.toml

@@ -0,0 +1,20 @@
+theme_name = "Antropic"
+
+[theme]
+primaryColor = "#bb5a38"
+backgroundColor = "#f4f3ed"
+secondaryBackgroundColor = "#ecebe3"
+textColor = "#3d3a2a"
+linkColor = "#3d3a2a"
+borderColor = "#d3d2ca"
+showWidgetBorder = true
+baseRadius = "0.6rem"
+font = "SpaceGrotesk"
+headingFont = "SpaceGroteskHeader"
+codeFont = "SpaceMono"
+codeBackgroundColor = "#ecebe4"
+showSidebarBorder = true
+
+[theme.sidebar]
+backgroundColor = "#e8e7dd"
+secondaryBackgroundColor = "#ecebe3"

src/.streamlit/themes/flowers_bright.toml

@@ -0,0 +1,20 @@
+theme_name = "花明 (Flowers Bright) 🌸"
+theme_poem = "🌸「浅色但不苍白，明亮而不过曝，柔和中有力量」"
+
+[theme]
+base = "light"
+baseFontSize = 15
+primaryColor = "#FF5F7E"                 # 樱花粉
+backgroundColor = "#F9FAFB"              # 轻柔灰白
+secondaryBackgroundColor = "#F0F4F8"     # 卡片淡蓝灰
+textColor = "#1F2937"                    # 蓝黑灰
+linkColor = "#2563EB"                    # 浅蓝色链接
+borderColor = "#D1D5DB"                  # 卡片分界线
+showWidgetBorder = false
+baseRadius = "0.3rem"
+font = "Poppins"                         # 保持现代圆润感
+
+[theme.sidebar]
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F3F4F6"
+borderColor = "#D1D5DB"

src/.streamlit/themes/spotify.toml

@@ -0,0 +1,19 @@
+theme_name = "Spotify"
+
+[theme]
+base = "dark"
+baseFontSize = 15
+primaryColor = "#1ED760"
+backgroundColor = "#121212"
+secondaryBackgroundColor = "#333333"
+textColor = "#FFFFFF"
+linkColor = "#9D9D9D"
+borderColor = "#7F7F7F"
+showWidgetBorder = false
+baseRadius = "0.3rem"
+font = "Poppins"
+
+[theme.sidebar]
+backgroundColor = "#000000"
+secondaryBackgroundColor = "#333333"
+borderColor = "#696969"

src/.streamlit/themes/willows_dark.toml

@@ -0,0 +1,20 @@
+theme_name = "柳暗 (Willows Dark) 🌒"
+theme_poem = "🌒「深而不死黑，蓝而不夺目，静而不沉闷」柳影婆娑之下，代码悄然生长。"
+
+[theme]
+base = "dark"
+baseFontSize = 15
+primaryColor = "#6EA8FE"                # 柔和的蓝色光感
+backgroundColor = "#0D1117"             # 深夜蓝黑
+secondaryBackgroundColor = "#1A1F2B"    # 柔和灰蓝
+textColor = "#D1D5DB"                   # 清晰柔白
+linkColor = "#B8C0FF"                   # 柔紫蓝
+borderColor = "#2E3440"                 # 北极灰边
+showWidgetBorder = false
+baseRadius = "0.3rem"
+font = "JetBrains Mono"                 # 强科技感
+
+[theme.sidebar]
+backgroundColor = "#0A0A0A"
+secondaryBackgroundColor = "#1A1A1A"
+borderColor = "#2E3440"

src/data_loader.py

@@ -7,7 +7,9 @@ import streamlit as st
 from functools import lru_cache  # For non-Streamlit specific caching if needed
 
 # Assuming utils.py is in the same directory
-from utils import DATA_ROOT_PATH  # Used for ensuring directory exists
+from infra import (
+    DATA_ROOT_PATH,
+)  # Used for ensuring directory exists
 
 # --- Cache Clearing Functions ---
 # These are more specific cache clearing functions that can be called by model methods.

src/infra.py

@@ -0,0 +1,16 @@
+# utils.py
+from pathlib import Path
+from enum import Enum, auto
+
+# Base path for studies and trials.
+# Streamlit apps are typically run from their root directory.
+# If your app.py is in 'src/', and 'data/' is at the same level as 'src/',
+# then Path("./data") from app.py's perspective would be Path("../data").
+# For simplicity, assuming data is relative to where streamlit run is executed,
+# or you adjust this path accordingly.
+DATA_ROOT_PATH = Path("./data").resolve()
+
+
+class AppMode(Enum):
+    VIEWING = auto()
+    # Potentially other modes like COMPARISON, EDITING etc.

src/streamlit_app.py

@@ -20,7 +20,7 @@ st.logo("logo.png", icon_image="logo.png")
 
 # 导入重构后的模块
 try:
-    from utils import DATA_ROOT_PATH, AppMode
+    from infra import DATA_ROOT_PATH, AppMode
     from data_models import Study, Trial  # Study, Trial will be used
     from data_loader import discover_studies_cached, ensure_data_directory_exists
     from theme_selector import render_theme_selector  # 新增：导入主题选择器
@@ -441,46 +441,84 @@ if current_study and current_trial:
                                                 break
 
                                     # 显示metric组件
-                                    with (
-                                        metric_cols[idx]
-                                        if len(all_tracks) > 1
-                                        else metric_cols[0]
-                                    ):
-                                        if current_value is not None:
-                                            # 确定label
-                                            if track is not None:
-                                                if current_step_found != current_step:
-                                                    label = f"{track} (Step {current_step_found})"
+                                    # print(metric_cols)
+                                    # print(metric_cols[idx])
+                                    # print(len(metric_cols), len(all_tracks))
+                                    metric_col = metric_cols[0] if len(metric_cols) == 1 else metric_cols[idx]
+                                    
+                                    try:
+                                        with (
+                                            metric_col
+                                        ):
+                                            if current_value is not None:
+                                                # 确定label
+                                                if track is not None:
+                                                    if current_step_found != current_step:
+                                                        label = f"{track} (Step {current_step_found})"
+                                                    else:
+                                                        label = f"{track}"
                                                 else:
-                                                    label = f"{track}"
+                                                    if current_step_found != current_step:
+                                                        label = f"当前值 (Step {current_step_found})"
+                                                    else:
+                                                        label = (
+                                                            f"当前值 (Step {current_step})"
+                                                        )
+
+                                                st.metric(
+                                                    label=label,
+                                                    value=f"{current_value:.4f}",
+                                                    delta=f"{delta_value:.4f}"
+                                                    if delta_value is not None
+                                                    else None,
+                                                )
                                             else:
-                                                if current_step_found != current_step:
-                                                    label = f"当前值 (Step {current_step_found})"
+                                                # 没有找到任何数据
+                                                track_label = (
+                                                    track if track is not None else "数据"
+                                                )
+                                                st.metric(
+                                                    label=f"{track_label}",
+                                                    value="无数据",
+                                                    delta=None,
+                                                )
+                                    except Exception as e:
+                                            if current_value is not None:
+                                                # 确定label
+                                                if track is not None:
+                                                    if current_step_found != current_step:
+                                                        label = f"{track} (Step {current_step_found})"
+                                                    else:
+                                                        label = f"{track}"
                                                 else:
-                                                    label = (
-                                                        f"当前值 (Step {current_step})"
-                                                    )
-
-                                            st.metric(
-                                                label=label,
-                                                value=f"{current_value:.4f}",
-                                                delta=f"{delta_value:.4f}"
-                                                if delta_value is not None
-                                                else None,
-                                            )
-                                        else:
-                                            # 没有找到任何数据
-                                            track_label = (
-                                                track if track is not None else "数据"
-                                            )
-                                            st.metric(
-                                                label=f"{track_label}",
-                                                value="无数据",
-                                                delta=None,
-                                            )
+                                                    if current_step_found != current_step:
+                                                        label = f"当前值 (Step {current_step_found})"
+                                                    else:
+                                                        label = (
+                                                            f"当前值 (Step {current_step})"
+                                                        )
+
+                                                st.metric(
+                                                    label=label,
+                                                    value=f"{current_value:.4f}",
+                                                    delta=f"{delta_value:.4f}"
+                                                    if delta_value is not None
+                                                    else None,
+                                                )
+                                            else:
+                                                # 没有找到任何数据
+                                                track_label = (
+                                                    track if track is not None else "数据"
+                                                )
+                                                st.metric(
+                                                    label=f"{track_label}",
+                                                    value="无数据",
+                                                    delta=None,
+                                                )
 
                             except Exception as e:
                                 st.warning(f"计算指标值时出错: {e}")
+                                raise e
 
                             try:
                                 # 创建 Plotly 图表

src/test.py

@@ -1,42 +0,0 @@
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import numpy as np
-
-# 创建示例数据
-x = np.linspace(0, 10, 100)
-y1 = np.sin(x)
-y2 = np.cos(x)
-
-# 创建两个 FigureWidget 图表
-fig1 = go.FigureWidget(data=[go.Scatter(x=x, y=y1, mode="lines", name="sin(x)")])
-fig2 = go.FigureWidget(data=[go.Scatter(x=x, y=y2, mode="lines", name="cos(x)")])
-
-
-# 定义悬停事件的回调函数
-def hover_fn(trace, points, state):
-    if points.xs:
-        hover_x = points.xs[0]
-        with fig2.batch_update():
-            # 在第二个图表上添加垂直线
-            fig2.layout.shapes = [
-                dict(
-                    type="line",
-                    x0=hover_x,
-                    x1=hover_x,
-                    y0=min(y2),
-                    y1=max(y2),
-                    line=dict(color="red", dash="dot"),
-                )
-            ]
-
-
-# 为第一个图表的第一个 trace 注册悬停事件
-fig1.data[0].on_hover(hover_fn)
-
-# 显示图表
-import streamlit as st
-
-st.plotly_chart(fig1, use_container_width=True)
-st.plotly_chart(fig2, use_container_width=True)
-
-# %%

src/visualizers/base_visualizer.py

@@ -1,254 +0,0 @@
-# src/visualizers/base_visualizer.py
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Dict, Type, Any, Optional, Callable, List
-import streamlit as st
-
-# --- Component Registry ---
-VISUALIZER_REGISTRY: Dict[str, Type["VisualizationComponent"]] = {}
-
-def register_visualizer(name: str):
-    """
-    一个装饰器，用于将可视化组件类注册到全局注册表。
-    A decorator to register a visualization component class to the global registry.
-    """
-    def decorator(cls: Type["VisualizationComponent"]):
-        if name in VISUALIZER_REGISTRY:
-            # 在调试或开发模式下可能是警告，生产模式下可能是错误
-            # In debug/dev mode this might be a warning, in production an error
-            print(f"警告: 可视化组件 '{name}' 已被注册，将被覆盖。Visualizer '{name}' already registered. Will be overridden.")
-        VISUALIZER_REGISTRY[name] = cls
-        return cls
-    return decorator
-
-def get_visualizer_class(type_name: str) -> Optional[Type["VisualizationComponent"]]:
-    """
-    从注册表中获取组件类。
-    Gets a component class from the registry.
-    """
-    return VISUALIZER_REGISTRY.get(type_name)
-
-# --- Abstract Base Class for Visualization Components ---
-class VisualizationComponent(ABC):
-    """
-    可视化组件的抽象基类。
-    Abstract base class for all visualization components.
-    """
-    def __init__(self,
-                 component_instance_id: str,
-                 trial_root_path: Path,
-                 # data_asset_info: Dict[str, Any], # 描述此组件主要关联的数据资产信息 (来自清单)
-                                                  # Describes the data asset this component is primarily associated with (from manifest)
-                 # ^ 将被更通用的 data_sources_map 替代
-                 data_sources_map: Dict[str, Dict[str, Any]], # Key: 逻辑数据源名称, Value: 数据资产信息字典
-                                                              # Key: logical data source name, Value: data asset info dict
-                                                              # e.g., {"main_scalar_data": asset_info_for_loss, "reference_images": asset_info_for_images}
-                 component_specific_config: Dict[str, Any] = None
-                ):
-        """
-        初始化可视化组件。
-        Initializes the visualization component.
-
-        Args:
-            component_instance_id (str): 此组件在仪表盘上的唯一实例ID。
-                                         Unique instance ID for this component on the dashboard.
-            trial_root_path (Path): 此组件所属的Trial的根目录路径。
-                                    Root directory path of the Trial this component belongs to.
-            data_sources_map (Dict[str, Dict[str, Any]]):
-                一个字典，映射逻辑数据源名称到具体的数据资产信息。
-                数据资产信息字典通常包含 'asset_id', 'display_name', 'data_type', 'path', 
-                以及其他从 _trial_manifest.toml 中解析得到的元数据。
-                A dictionary mapping logical data source names to specific data asset information.
-                The data asset info dict typically contains 'asset_id', 'display_name', 'data_type', 'path',
-                and other metadata parsed from _trial_manifest.toml.
-            component_specific_config (Dict[str, Any], optional):
-                特定于此组件实例的配置 (例如，图表标题、颜色等)。
-                Configuration specific to this component instance (e.g., chart title, color, etc.).
-        """
-        self.component_instance_id = component_instance_id
-        self.trial_root_path = trial_root_path
-        self.data_sources_map = data_sources_map
-        self.config = component_specific_config if component_specific_config is not None else {}
-
-        # 组件自身持久化配置或小型数据的路径
-        # Path for the component to persist its own configuration or small data
-        self.component_private_storage_path = self.trial_root_path / "visualizers_data" / self.component_instance_id
-        self.component_private_storage_path.mkdir(parents=True, exist_ok=True)
-
-        self._current_global_step: Optional[int] = None
-        self._on_global_step_change_request: Optional[Callable[[int], None]] = None
-        self._all_available_steps: Optional[List[int]] = None # 由主应用或数据加载器填充
-
-    def _get_data_asset_info(self, logical_name: str = "default") -> Optional[Dict[str, Any]]:
-        """
-        辅助方法，获取指定逻辑名称的数据资产信息。
-        Helper method to get data asset info for a given logical name.
-        如果组件只处理一个主要数据源，可以使用 "default" 或在初始化时指定。
-        If a component handles one primary data source, "default" or a specific name can be used.
-        """
-        return self.data_sources_map.get(logical_name)
-
-    def _get_data_asset_path(self, logical_name: str = "default") -> Optional[Path]:
-        """获取指定逻辑数据源的绝对路径。Gets the absolute path for a given logical data source."""
-        asset_info = self._get_data_asset_info(logical_name)
-        if asset_info and "path" in asset_info:
-            # 路径在清单中是相对于trial_root_path的
-            # Path in manifest is relative to trial_root_path
-            return (self.trial_root_path / asset_info["path"]).resolve()
-        return None
-
-    def configure_global_step_interaction(self,
-                                        current_step: Optional[int],
-                                        all_available_steps: Optional[List[int]],
-                                        on_step_change_request_callback: Optional[Callable[[int], None]]):
-        """
-        由主应用调用，以配置与全局步骤相关的交互。
-        Called by the main application to configure global step related interactions.
-
-        Args:
-            current_step (Optional[int]): 当前选中的全局步骤。
-                                          The currently selected global step.
-            all_available_steps (Optional[List[int]]): 此Trial中所有可用的全局步骤列表 (已排序)。
-                                                       A sorted list of all available global steps in this Trial.
-            on_step_change_request_callback (Optional[Callable[[int], None]]):
-                当组件希望更改全局步骤时调用的回调函数。
-                Callback function to be called when the component wishes to change the global step.
-        """
-        self._current_global_step = current_step
-        self._all_available_steps = sorted(list(set(all_available_steps))) if all_available_steps else []
-        self._on_global_step_change_request = on_step_change_request_callback
-
-    def _request_global_step_change(self, new_step: int) -> None:
-        """
-        组件内部调用此方法来请求更改全局共享的global_step。
-        Component calls this internally to request a change to the shared global_step.
-        """
-        if self._on_global_step_change_request:
-            if self._all_available_steps and new_step not in self._all_available_steps:
-                # 如果请求的步骤无效，可以选择寻找最近的有效步骤或忽略
-                # If requested step is invalid, can choose to find nearest valid step or ignore
-                # For now, let's assume the interaction (e.g., chart click) provides a valid step from its data
-                print(f"警告: 组件 {self.component_instance_id} 请求了一个无效的全局步骤 {new_step}。")
-                # Potentially find closest:
-                # if self._all_available_steps:
-                #     new_step = min(self._all_available_steps, key=lambda x: abs(x - new_step))
-
-            self._on_global_step_change_request(new_step)
-        else:
-            st.warning(f"组件 {self.component_instance_id}: 尝试更改全局步骤，但未设置回调。")
-
-    def _get_closest_available_step(self, target_step: Optional[int]) -> Optional[int]:
-        """
-        如果目标步骤无效或数据在该步骤不可用，则查找最近的可用步骤。
-        Finds the closest available step if the target step is invalid or data isn't available at that step.
-        组件的子类可以覆盖此逻辑以适应其特定的数据可用性。
-        Subclasses can override this logic for their specific data availability.
-        """
-        if target_step is None:
-            return None
-        if not self._all_available_steps:
-            return None
-        if target_step in self._all_available_steps:
-            return target_step
-        
-        # 寻找最接近的步骤 (简单的实现)
-        # Find the closest step (simple implementation)
-        try:
-            closest = min(self._all_available_steps, key=lambda x: abs(x - target_step))
-            return closest
-        except ValueError: # _all_available_steps为空
-            return None
-
-
-    @abstractmethod
-    def load_data(self) -> None:
-        """
-        加载此组件渲染所需的数据。
-        Load data required by this component for rendering.
-        实现者应使用 self._get_data_asset_path() 来获取数据文件路径。
-        Implementers should use self._get_data_asset_path() to get data file paths.
-        数据加载后通常存储在实例变量中。
-        Loaded data is typically stored in instance variables.
-        """
-        pass
-
-    @abstractmethod
-    def render(self) -> None:
-        """
-        将组件渲染为Streamlit UI元素。
-        Renders the component as Streamlit UI elements.
-        应使用 self._current_global_step (可能通过 self._get_closest_available_step 调整) 来显示对应步骤的数据。
-        Should use self._current_global_step (possibly adjusted by self._get_closest_available_step)
-        to display data for the corresponding step.
-        任何可以触发全局步骤更改的交互都应调用 self._request_global_step_change()。
-        Any interaction that can trigger a global step change should call self._request_global_step_change().
-        """
-        pass
-
-    @classmethod
-    @abstractmethod
-    def can_handle_data_types(cls, data_type_names: List[str]) -> bool:
-        """
-        类方法：判断此组件类型是否能处理清单中声明的一个或多个数据类型。
-        Class method: Determines if this component type can handle one or more data types
-        declared in the manifest.
-
-        Args:
-            data_type_names (List[str]): 从数据资产清单中获取的数据类型名称列表。
-                                         A list of data type names from a data asset manifest.
-                                         (通常，主应用会为每个数据资产调用此方法，列表只包含一个元素)
-                                         (Usually, the main app calls this for each data asset, so the list has one element)
-
-        Returns:
-            bool: True 如果此组件可以处理至少一种给定的数据类型。
-                  True if this component can handle at least one of the given data types.
-        """
-        pass
-
-    @classmethod
-    def get_display_name(cls) -> str:
-        """
-        类方法：返回此组件类型的用户友好显示名称。
-        Class method: Returns a user-friendly display name for this component type.
-        """
-        # 简单的实现：将类名从CamelCase转换为带空格的标题
-        # Simple implementation: Convert CamelCase class name to space-separated title
-        name = cls.__name__
-        if name.endswith("Visualizer"):
-            name = name[:-len("Visualizer")]
-        s1 = VISUALIZER_REGISTRY.get(name, name) # Fallback to class name if not in registry (should not happen with decorator)
-        # Add spaces before capital letters (simple version)
-        import re
-        return re.sub(r'(?<!^)(?=[A-Z])', ' ', s1)
-
-
-    def save_component_config(self) -> None:
-        """
-        将当前组件的特定配置 (self.config) 保存到其私有存储路径。
-        Saves the current component-specific configuration (self.config) to its private storage path.
-        """
-        config_file = self.component_private_storage_path / "_component_config.toml"
-        try:
-            import tomli_w # 确保已安装 Ensure tomli_w is installed
-            with open(config_file, "wb") as f:
-                tomli_w.dump(self.config, f)
-            # st.toast(f"组件 '{self.component_instance_id}' 配置已保存。")
-        except Exception as e:
-            st.error(f"保存组件 '{self.component_instance_id}' 配置失败: {e}")
-
-    def load_component_config(self) -> None:
-        """
-        从其私有存储路径加载组件的特定配置，并更新 self.config。
-        Loads the component-specific configuration from its private storage path and updates self.config.
-        """
-        config_file = self.component_private_storage_path / "_component_config.toml"
-        if config_file.exists():
-            try:
-                import tomli # 确保已安装 Ensure tomli is installed
-                with open(config_file, "rb") as f:
-                    loaded_config = tomli.load(f)
-                self.config.update(loaded_config) # 合并加载的配置 Merge loaded config
-                # st.toast(f"组件 '{self.component_instance_id}' 配置已加载。")
-            except Exception as e:
-                st.error(f"加载组件 '{self.component_instance_id}' 配置失败: {e}")
-

src/visualizers/ide_app.py

@@ -1,303 +0,0 @@
-# src/debugger/ide_app.py
-import streamlit as st
-from pathlib import Path
-import tempfile
-import json
-import shutil
-from typing import Dict, Any, Optional, Type, List
-import tomli # 确保导入 tomli Ensure tomli is imported
-
-# 动态确定根目录，以便能够导入src下的模块
-# Dynamically determine root directory to import modules from src
-try:
-    current_file_path = Path(__file__).resolve()
-    # 假设 ide_app.py 在 src/debugger/ 目录下
-    # Assumes ide_app.py is in src/debugger/
-    # src_path = current_file_path.parent.parent 
-    # import sys
-    # if str(src_path) not in sys.path:
-    #    sys.path.insert(0, str(src_path))
-except NameError:
-    # project_root = Path(".") # 默认为当前工作目录
-    pass # 在某些环境中 __file__ 可能未定义 In some environments __file__ might be undefined
-
-try:
-    from visualizers.base_visualizer import (
-        VISUALIZER_REGISTRY,
-        get_visualizer_class,
-        VisualizationComponent
-    )
-    # 确保所有组件都被导入和注册
-    # Ensure all components are imported and registered
-    import visualizers.scalar_dashboard_visualizer 
-
-except ImportError as e:
-    st.error(
-        "错误：无法导入可视化组件模块。请确保此IDE应用位于正确的项目结构中，"
-        f"并且 `visualizers` 目录及其内容可访问。\n详细信息: {e}"
-        "Error: Could not import visualization component modules. Ensure this IDE app is in the correct "
-        f"project structure and the `visualizers` directory and its contents are accessible.\nDetails: {e}"
-    )
-    st.stop()
-
-# --- 应用标题和配置 ---
-st.set_page_config(layout="wide", page_title="Flowillower - 组件IDE (Component IDE)")
-st.title("🔬 Flowillower - 可视化组件IDE (Visualization Component IDE)")
-st.markdown("在此环境中独立测试、调试和预览您的可视化组件。")
-
-# --- 会话状态初始化 ---
-if "selected_visualizer_type_name" not in st.session_state:
-    st.session_state.selected_visualizer_type_name = None
-if "component_instance_id" not in st.session_state:
-    st.session_state.component_instance_id = "test_instance_001"
-if "trial_root_path_str" not in st.session_state:
-    st.session_state.trial_root_path_str = tempfile.mkdtemp(prefix="flowillower_ide_trial_")
-if "component_specific_config_str" not in st.session_state:
-    st.session_state.component_specific_config_str = "{}" 
-if "active_visualizer_instance" not in st.session_state:
-    st.session_state.active_visualizer_instance = None
-if "generated_data_sources_map" not in st.session_state: 
-    st.session_state.generated_data_sources_map = None
-if "current_simulated_global_step" not in st.session_state:
-    st.session_state.current_simulated_global_step = 0 # 默认值 Default value
-if "all_simulated_steps" not in st.session_state: 
-    st.session_state.all_simulated_steps = []
-
-
-def cleanup_temp_dir(path_str):
-    try:
-        if path_str and Path(path_str).exists() and "flowillower_ide_trial_" in path_str: 
-            shutil.rmtree(path_str)
-            st.toast(f"临时目录已清理: {path_str}")
-    except Exception as e:
-        st.warning(f"清理临时目录失败 {path_str}: {e}")
-
-with st.sidebar:
-    st.header("组件选择与配置")
-
-    registered_type_names = list(VISUALIZER_REGISTRY.keys())
-    if not registered_type_names:
-        st.error("错误：没有已注册的可视化组件类型。")
-        st.stop()
-
-    if st.session_state.selected_visualizer_type_name is None and registered_type_names:
-        st.session_state.selected_visualizer_type_name = registered_type_names[0]
-
-    st.session_state.selected_visualizer_type_name = st.selectbox(
-        "选择可视化组件类型",
-        options=registered_type_names,
-        index=registered_type_names.index(st.session_state.selected_visualizer_type_name)
-              if st.session_state.selected_visualizer_type_name in registered_type_names else 0,
-        help="选择您想要测试的可视化组件。"
-    )
-
-    SelectedVisualizerClass: Optional[Type[VisualizationComponent]] = get_visualizer_class(st.session_state.selected_visualizer_type_name)
-
-    if SelectedVisualizerClass:
-        st.caption(f"显示名称: `{SelectedVisualizerClass.get_display_name()}`")
-    else:
-        st.error(f"无法加载组件类 '{st.session_state.selected_visualizer_type_name}'。")
-        st.stop()
-
-    st.session_state.component_instance_id = st.text_input(
-        "组件实例ID", value=st.session_state.component_instance_id
-    )
-    st.markdown(f"**临时Trial根路径:** `{st.session_state.trial_root_path_str}`")
-    
-    example_data_target_dir = Path(st.session_state.trial_root_path_str) / "example_assets_for_ide"
-    
-    if st.button("生成示例数据"):
-        if SelectedVisualizerClass:
-            try:
-                if example_data_target_dir.exists():
-                    shutil.rmtree(example_data_target_dir)
-                example_data_target_dir.mkdir(parents=True, exist_ok=True)
-
-                st.session_state.generated_data_sources_map = SelectedVisualizerClass.generate_example_data(
-                    example_data_path=example_data_target_dir
-                )
-                st.success(f"'{SelectedVisualizerClass.get_display_name()}' 的示例数据已生成。")
-                
-                temp_all_steps = set()
-                if st.session_state.generated_data_sources_map:
-                    for ds_name, ds_info in st.session_state.generated_data_sources_map.items():
-                        if "path" in ds_info:
-                            try:
-                                # 路径是相对于 trial_root_path 的
-                                # Path is relative to trial_root_path
-                                full_path = Path(st.session_state.trial_root_path_str) / ds_info["path"]
-                                if full_path.exists() and full_path.suffix == ".toml":
-                                    with open(full_path, "rb") as f:
-                                        d = tomli.load(f)
-                                    if "metrics" in d and isinstance(d["metrics"], list):
-                                        for point in d["metrics"]:
-                                            if "global_step" in point:
-                                                temp_all_steps.add(int(point["global_step"]))
-                            except Exception as e_load:
-                                st.warning(f"解析示例数据中的步骤时出错 ({ds_info['path']}): {e_load}")
-                
-                st.session_state.all_simulated_steps = sorted(list(temp_all_steps))
-                if not st.session_state.all_simulated_steps: # 如果没有解析到步骤，至少放一个0
-                     st.session_state.all_simulated_steps = [0]
-                
-                # 更新 current_simulated_global_step 为有效值
-                # Update current_simulated_global_step to a valid value
-                if st.session_state.all_simulated_steps:
-                     st.session_state.current_simulated_global_step = st.session_state.all_simulated_steps[0]
-                else: # 理论上不会到这里，因为上面保证了至少有[0] Theoretically won't reach here as [0] is guaranteed above
-                     st.session_state.current_simulated_global_step = 0
-                st.rerun() # 重新运行以更新UI中的步骤滑块 Rerun to update step slider in UI
-
-            except Exception as e:
-                st.error(f"生成示例数据失败: {e}")
-                st.exception(e)
-                st.session_state.generated_data_sources_map = None
-        else:
-            st.warning("请先选择一个组件类型。")
-
-    st.session_state.component_specific_config_str = st.text_area(
-        "组件特定配置 (JSON)", value=st.session_state.component_specific_config_str, height=100
-    )
-
-    if st.button("🚀 实例化组件", type="primary"):
-        if SelectedVisualizerClass and st.session_state.component_instance_id and st.session_state.generated_data_sources_map:
-            try:
-                specific_config = json.loads(st.session_state.component_specific_config_str)
-                st.session_state.active_visualizer_instance = SelectedVisualizerClass(
-                    component_instance_id=st.session_state.component_instance_id,
-                    trial_root_path=Path(st.session_state.trial_root_path_str),
-                    data_sources_map=st.session_state.generated_data_sources_map,
-                    component_specific_config=specific_config
-                )
-                st.success(f"组件 '{st.session_state.component_instance_id}' 已实例化。")
-                active_viz_instance_for_load = st.session_state.active_visualizer_instance
-                active_viz_instance_for_load.load_data()
-                
-                # 从组件加载数据后获取实际的all_available_steps
-                # Get actual all_available_steps after component loads data
-                if hasattr(active_viz_instance_for_load, '_all_available_steps') and active_viz_instance_for_load._all_available_steps:
-                    st.session_state.all_simulated_steps = active_viz_instance_for_load._all_available_steps
-                    if st.session_state.current_simulated_global_step not in st.session_state.all_simulated_steps:
-                        st.session_state.current_simulated_global_step = st.session_state.all_simulated_steps[0]
-
-                active_viz_instance_for_load.configure_global_step_interaction(
-                    current_step=st.session_state.current_simulated_global_step,
-                    all_available_steps=st.session_state.all_simulated_steps,
-                    on_step_change_request_callback=lambda step: st.session_state.update({"current_simulated_global_step": step})
-                )
-                st.rerun() # 确保UI更新 Ensure UI updates
-
-            except Exception as e:
-                st.error(f"实例化组件失败: {e}")
-                st.exception(e)
-                st.session_state.active_visualizer_instance = None
-        else:
-            st.warning("请先选择组件类型，输入实例ID，并生成示例数据。")
-
-st.header("组件预览与交互")
-active_viz_instance: Optional[VisualizationComponent] = st.session_state.active_visualizer_instance
-
-if active_viz_instance:
-    st.markdown(f"**当前活动组件:** `{active_viz_instance.component_instance_id}` "
-                f"(类型: `{SelectedVisualizerClass.get_display_name() if SelectedVisualizerClass else 'N/A'}`)")
-    st.markdown(f"**Trial根路径:** `{active_viz_instance.trial_root_path}`")
-    
-    st.markdown("---")
-    st.subheader("全局步骤模拟")
-    col_step1, col_step2 = st.columns([3,1])
-    
-    # --- 全局步骤模拟 (FIXED RangeError) ---
-    # --- Global Step Simulation (FIXED RangeError) ---
-    current_step_for_ui = st.session_state.current_simulated_global_step
-    all_steps_for_ui = st.session_state.all_simulated_steps
-
-    # 确保 current_step_for_ui 在 all_steps_for_ui 中 (如果 all_steps_for_ui 非空)
-    # Ensure current_step_for_ui is in all_steps_for_ui (if all_steps_for_ui is not empty)
-    if all_steps_for_ui and current_step_for_ui not in all_steps_for_ui:
-        # 尝试寻找最近的，或者直接用第一个/最后一个
-        # Try to find the closest, or just use the first/last
-        current_step_for_ui = min(all_steps_for_ui, key=lambda x:abs(x-current_step_for_ui)) if all_steps_for_ui else 0
-        # st.session_state.current_simulated_global_step = current_step_for_ui # 避免在渲染中直接修改会话状态 Avoid direct session state modification in render path
-
-    with col_step1:
-        if all_steps_for_ui:
-            if len(all_steps_for_ui) == 1:
-                st.markdown(f"当前模拟全局步骤: **{all_steps_for_ui[0]}** (只有一步可用)")
-                # 如果只有一步，确保会话状态也正确
-                # If only one step, ensure session state is also correct
-                if st.session_state.current_simulated_global_step != all_steps_for_ui[0]:
-                    st.session_state.current_simulated_global_step = all_steps_for_ui[0]
-                    # st.rerun() # 可能会导致循环，让 configure_global_step_interaction 处理 Might cause loop, let configure_global_step_interaction handle
-                new_sim_step = all_steps_for_ui[0] # 保持一致 Keep consistent
-            else: # 多于一个步骤 More than one step
-                new_sim_step = st.select_slider(
-                    "当前模拟全局步骤",
-                    options=all_steps_for_ui,
-                    value=current_step_for_ui, # 使用已验证的值 Use validated value
-                    key="sim_step_slider_corrected"
-                )
-        else: # 没有从数据中解析到步骤 No steps parsed from data
-            new_sim_step = st.number_input(
-                "当前模拟全局步骤 (无可用步骤)",
-                value=current_step_for_ui, 
-                key="sim_step_input_empty_corrected"
-            )
-    
-    # 如果用户通过UI更改了步骤，则更新会话状态
-    # If user changed step via UI, update session state
-    if new_sim_step != st.session_state.current_simulated_global_step:
-        st.session_state.current_simulated_global_step = new_sim_step
-        # st.rerun() # select_slider/number_input 通常会在值变化时自动 rerun
-
-    # 每次渲染都更新组件的步骤信息
-    # Update component's step info on every render
-    active_viz_instance.configure_global_step_interaction(
-        current_step=st.session_state.current_simulated_global_step,
-        all_available_steps=all_steps_for_ui, # 使用从数据加载的步骤 Use steps loaded from data
-        on_step_change_request_callback=lambda step: st.session_state.update({"current_simulated_global_step": step}) # 更新会话状态，Streamlit会自动rerun
-    )
-    
-    with col_step2:
-        if st.button("🔄 重新加载数据"):
-            try:
-                active_viz_instance.load_data()
-                st.toast("组件数据已重新加载。")
-                # 重新加载数据后，可能需要更新 all_simulated_steps
-                # After reloading data, all_simulated_steps might need an update
-                if hasattr(active_viz_instance, '_all_available_steps') and active_viz_instance._all_available_steps:
-                     st.session_state.all_simulated_steps = active_viz_instance._all_available_steps
-                     # 确保当前步骤仍然有效
-                     # Ensure current step is still valid
-                     if st.session_state.current_simulated_global_step not in st.session_state.all_simulated_steps:
-                         st.session_state.current_simulated_global_step = st.session_state.all_simulated_steps[0] if st.session_state.all_simulated_steps else 0
-                
-                active_viz_instance.configure_global_step_interaction( # 再次配置以防步骤列表变化 Reconfigure in case step list changed
-                    current_step=st.session_state.current_simulated_global_step,
-                    all_available_steps=st.session_state.all_simulated_steps,
-                    on_step_change_request_callback=lambda step: st.session_state.update({"current_simulated_global_step": step})
-                )
-                st.rerun() # 强制刷新UI Force UI refresh
-            except Exception as e:
-                st.error(f"重新加载数据失败: {e}")
-
-    st.markdown("---")
-    st.subheader("渲染输出")
-    try:
-        with st.container(border=True):
-            active_viz_instance.render()
-    except Exception as e:
-        st.error(f"渲染组件 '{active_viz_instance.component_instance_id}' 时出错: {e}")
-        st.exception(e)
-else:
-    st.info("请在侧边栏中选择一个组件类型，生成示例数据，然后点击“实例化组件”以开始调试。")
-
-st.sidebar.markdown("---")
-st.sidebar.caption(f"IDE 会话临时路径: {st.session_state.trial_root_path_str}")
-if st.sidebar.button("清理当前会话的临时Trial目录"):
-    cleanup_temp_dir(st.session_state.trial_root_path_str)
-    st.session_state.trial_root_path_str = tempfile.mkdtemp(prefix="flowillower_ide_trial_")
-    st.session_state.active_visualizer_instance = None
-    st.session_state.generated_data_sources_map = None
-    st.session_state.all_simulated_steps = []
-    st.session_state.current_simulated_global_step = 0
-    st.rerun()

src/visualizers/scalar_dashboard_visualizer.py

@@ -1,333 +0,0 @@
-# src/visualizers/scalar_dashboard_visualizer.py
-import streamlit as st
-import pandas as pd
-import plotly.graph_objects as go
-import plotly.express as px
-import tomli
-import tomli_w
-from pathlib import Path
-from typing import Dict, Any, Optional, List, Tuple
-
-from .base_visualizer import VisualizationComponent, register_visualizer
-
-@register_visualizer(name="scalar_metrics_dashboard")
-class ScalarMetricsDashboardVisualizer(VisualizationComponent):
-    """
-    一个用于显示多个标量指标（每个指标可能包含多个track）的仪表盘组件。
-    它会为每个指标在选定的global_step显示st.metric摘要，并绘制一个Plotly折线图。
-    A dashboard component to display multiple scalar metrics, each potentially with multiple tracks.
-    It shows st.metric summaries for the selected global_step and a Plotly line chart for each metric.
-    """
-
-    _raw_data: Optional[pd.DataFrame] = None
-    _processed_metrics_data: Dict[str, pd.DataFrame] = None 
-
-    DEFAULT_CHARTS_PER_ROW = 2
-
-    def __init__(self,
-                 component_instance_id: str,
-                 trial_root_path: Path,
-                 data_sources_map: Dict[str, Dict[str, Any]],
-                 component_specific_config: Dict[str, Any] = None):
-        super().__init__(component_instance_id, trial_root_path, data_sources_map, component_specific_config)
-        self._raw_data = None
-        self._processed_metrics_data = {}
-        self.load_component_config() 
-
-        self.charts_per_row = self.config.get("charts_per_row", self.DEFAULT_CHARTS_PER_ROW)
-        self.chart_height = self.config.get("chart_height", 400)
-
-    @classmethod
-    def can_handle_data_types(cls, data_type_names: List[str]) -> bool:
-        return "multi_metric_multi_track_scalars" in data_type_names
-
-    @classmethod
-    def generate_example_data(cls, example_data_path: Path, # This path is like .../trial_root/example_assets_for_ide
-                              data_sources_config: Optional[Dict[str, Dict[str, Any]]] = None
-                             ) -> Dict[str, Dict[str, Any]]:
-        example_data_path.mkdir(parents=True, exist_ok=True)
-        metrics_file_name = "example_scalar_metrics.toml"
-        # 文件实际写入位置: example_data_path / metrics_file_name
-        # Actual file write location: example_data_path / metrics_file_name
-        metrics_file_full_path = example_data_path / metrics_file_name
-
-        data_points = []
-        for step in range(20):
-            data_points.append({"global_step": step, "track": "train", "loss": 1.0 / (step + 1) + 0.1, "accuracy": 0.6 + step * 0.015})
-            data_points.append({"global_step": step, "track": "validation", "loss": 1.0 / (step + 1) + 0.2, "accuracy": 0.55 + step * 0.01})
-            if step % 5 == 0:
-                 data_points.append({"global_step": step, "track": "system", "learning_rate": 0.001 * (0.9**step)})
-
-        try:
-            with open(metrics_file_full_path, "wb") as f:
-                tomli_w.dump({"metrics": data_points}, f)
-        except Exception as e:
-            st.error(f"生成示例数据失败: {e}")
-            raise
-        
-        # *** 修正点 (FIXED POINT) ***
-        # 返回的路径应该是相对于 trial_root_path 的。
-        # The returned path should be relative to trial_root_path.
-        # example_data_path 的父目录是 trial_root_path。
-        # The parent of example_data_path is trial_root_path in the IDE's context.
-        # 所以，相对路径是 example_data_path 的名称（即 "example_assets_for_ide"）加上文件名。
-        # So, the relative path is the name of example_data_path (i.e., "example_assets_for_ide") plus the filename.
-        # path_relative_to_trial_root = example_data_path.name / metrics_file_name
-        # 更稳健的方式是，如果 example_data_path 是绝对路径，而我们需要相对于 trial_root_path 的路径，
-        # 并且我们知道 trial_root_path 是 example_data_path 的父目录（或更早的祖先）。
-        # A more robust way, if example_data_path is absolute, and we need path relative to trial_root_path,
-        # and we know trial_root_path is a parent (or earlier ancestor) of example_data_path.
-        # 在IDE的上下文中，example_data_path = trial_root_path / "example_assets_for_ide"
-        # In the IDE's context, example_data_path = trial_root_path / "example_assets_for_ide"
-        # 所以，相对于 trial_root_path 的路径就是 "example_assets_for_ide" / metrics_file_name
-        # So, path relative to trial_root_path is "example_assets_for_ide" / metrics_file_name
-        
-        path_for_manifest = Path(example_data_path.name) / metrics_file_name
-
-        return {
-            "main_metrics_source": { 
-                "asset_id": "example_metrics_dashboard_data",
-                "data_type": "multi_metric_multi_track_scalars", 
-                "path": str(path_for_manifest), # 使用修正后的相对路径 Use the corrected relative path
-                "display_name": "示例综合指标数据 (Example Comprehensive Metrics)"
-            }
-        }
-
-    def load_data(self) -> None:
-        data_asset_path = self._get_data_asset_path("main_metrics_source")
-        if data_asset_path is None or not data_asset_path.exists():
-            st.warning(f"组件 {self.component_instance_id}: 未找到数据源 'main_metrics_source' 或路径无效: {data_asset_path}")
-            self._raw_data = pd.DataFrame() 
-            self._processed_metrics_data = {}
-            return
-
-        try:
-            with open(data_asset_path, "rb") as f:
-                data = tomli.load(f)
-            
-            metrics_list = data.get("metrics", [])
-            if not metrics_list:
-                self._raw_data = pd.DataFrame()
-            else:
-                self._raw_data = pd.DataFrame(metrics_list)
-            
-            self._process_raw_data()
-
-        except Exception as e:
-            st.error(f"组件 {self.component_instance_id}: 加载数据 '{data_asset_path}' 失败: {e}")
-            self._raw_data = pd.DataFrame()
-            self._processed_metrics_data = {}
-
-    def _process_raw_data(self) -> None:
-        self._processed_metrics_data = {}
-        if self._raw_data is None or self._raw_data.empty:
-            return
-
-        if "global_step" not in self._raw_data.columns:
-            st.warning(f"组件 {self.component_instance_id}: 数据缺少 'global_step' 列。")
-            return
-
-        potential_metric_cols = [
-            col for col in self._raw_data.columns if col not in ["global_step", "track"]
-        ]
-
-        for metric_col_name in potential_metric_cols:
-            metric_df_cols = ["global_step", metric_col_name]
-            if "track" in self._raw_data.columns:
-                 metric_df_cols.append("track")
-            
-            # 确保所有需要的列都存在于self._raw_data中
-            # Ensure all needed columns exist in self._raw_data
-            if not all(col in self._raw_data.columns for col in metric_df_cols):
-                # st.warning(f"组件 {self.component_instance_id}: 指标 '{metric_col_name}' 的原始数据缺少某些列: {metric_df_cols}")
-                continue
-
-            metric_df = self._raw_data[metric_df_cols].copy()
-            
-            if "track" not in metric_df.columns: # 如果原始数据就没有track列
-                metric_df["track"] = "default" 
-            
-            metric_df.rename(columns={metric_col_name: "value"}, inplace=True)
-            metric_df["value"] = pd.to_numeric(metric_df["value"], errors='coerce')
-            metric_df["global_step"] = pd.to_numeric(metric_df["global_step"], errors='coerce')
-            metric_df.dropna(subset=["value", "global_step"], inplace=True) 
-            
-            if not metric_df.empty:
-                metric_df = metric_df.sort_values(by=["track", "global_step"]).reset_index(drop=True)
-                self._processed_metrics_data[metric_col_name] = metric_df
-        
-        if self._all_available_steps is None and not self._raw_data.empty and "global_step" in self._raw_data.columns:
-            valid_steps = pd.to_numeric(self._raw_data["global_step"], errors='coerce').dropna().astype(int).unique()
-            self._all_available_steps = sorted(list(valid_steps))
-
-
-    def _render_metric_summary(self, metric_name: str, metric_df: pd.DataFrame, target_step: Optional[int]):
-        if target_step is None and self._all_available_steps: # 如果target_step是None，默认用最后一个step
-            target_step = self._all_available_steps[-1]
-        elif target_step is None or not self._all_available_steps:
-            st.metric(label=f"{metric_name}", value="无可用步骤", delta=None)
-            return
-
-        actual_display_step = self._get_closest_available_step(target_step)
-        if actual_display_step is None: 
-             st.metric(label=f"{metric_name}", value="无数据", delta=None)
-             return
-
-        all_tracks = sorted(list(metric_df["track"].unique()))
-        num_tracks = len(all_tracks)
-        if num_tracks == 0: return 
-
-        cols = st.columns(num_tracks) if num_tracks > 1 else [st.container()] 
-
-        for idx, track_name in enumerate(all_tracks):
-            with cols[idx if num_tracks > 1 else 0]:
-                track_data = metric_df[metric_df["track"] == track_name]
-                if track_data.empty:
-                    st.metric(label=f"{metric_name} ({track_name})", value="无数据", delta=None)
-                    continue
-
-                current_value = None
-                delta_value = None
-                step_for_current_value = actual_display_step 
-
-                current_step_data = track_data[track_data["global_step"] == step_for_current_value]
-                if current_step_data.empty:
-                    prev_steps_for_track = track_data[track_data["global_step"] <= step_for_current_value]["global_step"]
-                    if not prev_steps_for_track.empty:
-                        step_for_current_value = prev_steps_for_track.max()
-                        current_step_data = track_data[track_data["global_step"] == step_for_current_value]
-                
-                if not current_step_data.empty:
-                    current_value = current_step_data["value"].iloc[0]
-                    prev_steps_for_delta = track_data[track_data["global_step"] < step_for_current_value]["global_step"]
-                    if not prev_steps_for_delta.empty:
-                        step_for_prev_value = prev_steps_for_delta.max()
-                        prev_value_data = track_data[track_data["global_step"] == step_for_prev_value]
-                        if not prev_value_data.empty:
-                            prev_value = prev_value_data["value"].iloc[0]
-                            delta_value = current_value - prev_value
-                
-                metric_label = f"{metric_name} ({track_name})"
-                if step_for_current_value != target_step and current_value is not None: # 仅当找到的值的步骤与目标步骤不同时才显示
-                    metric_label += f" @S{int(step_for_current_value)}"
-
-                st.metric(
-                    label=metric_label,
-                    value=f"{current_value:.4f}" if current_value is not None else "无数据",
-                    delta=f"{delta_value:.4f}" if delta_value is not None and current_value is not None else None,
-                )
-
-    def _render_plotly_chart(self, metric_name: str, metric_df: pd.DataFrame, chart_key: str):
-        fig = go.Figure()
-        all_tracks = sorted(list(metric_df["track"].unique()))
-        colors = px.colors.qualitative.Plotly 
-
-        for i, track_name in enumerate(all_tracks):
-            track_data = metric_df[metric_df["track"] == track_name]
-            fig.add_trace(go.Scatter(
-                x=track_data["global_step"],
-                y=track_data["value"],
-                mode="lines+markers",
-                name=track_name,
-                line=dict(color=colors[i % len(colors)]),
-                marker=dict(size=6, color=colors[i % len(colors)], line=dict(width=1, color="white")),
-                customdata=track_data[["global_step", "value", "track"]], 
-                hovertemplate="<b>%{customdata[2]}</b><br>Step: %{customdata[0]}<br>Value: %{customdata[1]:.4f}<extra></extra>"
-            ))
-
-        current_step_to_highlight = self._get_closest_available_step(self._current_global_step)
-        if current_step_to_highlight is not None:
-            fig.add_vline(
-                x=current_step_to_highlight,
-                line_width=1.5, line_dash="solid", line_color="firebrick", opacity=0.7
-            )
-
-        fig.update_layout(
-            xaxis_title="Global Step",
-            yaxis_title=metric_name, 
-            height=self.chart_height,
-            margin=dict(l=10, r=10, t=30, b=10), 
-            showlegend=len(all_tracks) > 1,
-            hovermode="closest",
-        )
-        
-        event_data = st.plotly_chart(
-            fig,
-            use_container_width=True,
-            key=chart_key, 
-            on_select="rerun" 
-        )
-        
-        current_selection = st.session_state.get(chart_key, {}).get("selection")
-        if current_selection and current_selection.get("points"):
-            clicked_point = current_selection["points"][0]
-            if "customdata" in clicked_point and isinstance(clicked_point["customdata"], list):
-                clicked_global_step = int(clicked_point["customdata"][0])
-                last_clicked_step_key = f"{chart_key}_last_clicked_step"
-                if st.session_state.get(last_clicked_step_key) != clicked_global_step:
-                    st.session_state[last_clicked_step_key] = clicked_global_step
-                    self._request_global_step_change(clicked_global_step)
-        elif current_selection and not current_selection.get("points"): 
-            st.session_state[f"{chart_key}_last_clicked_step"] = None
-
-
-    def render_settings_ui(self):
-        st.markdown("##### 组件设置 (Component Settings)")
-        new_charts_per_row = st.slider(
-            "每行图表数 (Charts per row)", 1, 4, self.charts_per_row,
-            key=f"{self.component_instance_id}_charts_per_row"
-        )
-        if new_charts_per_row != self.charts_per_row:
-            self.charts_per_row = new_charts_per_row
-            self.config["charts_per_row"] = new_charts_per_row
-            self.save_component_config() 
-            st.rerun() 
-        
-        new_chart_height = st.number_input(
-            "图表高度 (Chart Height)", min_value=200, max_value=1000, step=50,
-            value=self.chart_height,
-            key=f"{self.component_instance_id}_chart_height"
-        )
-        if new_chart_height != self.chart_height:
-            self.chart_height = new_chart_height
-            self.config["chart_height"] = new_chart_height
-            self.save_component_config()
-            st.rerun()
-
-
-    def render(self) -> None:
-        if self._processed_metrics_data is None or not self._processed_metrics_data:
-            if self._raw_data is None: # 尝试加载一次
-                self.load_data()
-            # 再次检查
-            if self._processed_metrics_data is None or not self._processed_metrics_data:
-                st.info(f"组件 {self.component_instance_id}: 没有处理好的指标数据可供显示。请先加载数据或生成示例数据。")
-                st.caption("如果已生成示例数据但仍看到此消息，请检查数据路径和格式是否正确。If example data was generated but you still see this, check data paths and format.")
-                return
-        
-        with st.expander("图表显示设置 (Chart Display Settings)", expanded=False):
-            self.render_settings_ui()
-
-        metric_names_to_display = sorted(list(self._processed_metrics_data.keys()))
-        if not metric_names_to_display:
-            st.caption("没有可显示的指标。No metrics to display.")
-            return
-
-        num_metrics = len(metric_names_to_display)
-        cols_per_row = self.charts_per_row
-
-        for i in range(0, num_metrics, cols_per_row):
-            metric_chunk = metric_names_to_display[i : i + cols_per_row]
-            actual_cols_for_this_row = len(metric_chunk)
-            chart_cols = st.columns(actual_cols_for_this_row)
-            
-            for j, metric_name in enumerate(metric_chunk):
-                with chart_cols[j]:
-                    metric_df = self._processed_metrics_data[metric_name]
-                    
-                    with st.container(border=True, height=self.chart_height + 200): # 增加容器高度以容纳metric和图表
-                        st.subheader(metric_name)
-                        self._render_metric_summary(metric_name, metric_df, self._current_global_step)
-                        st.markdown("---") 
-                        chart_key = f"plotly_{self.component_instance_id}_{metric_name}"
-                        self._render_plotly_chart(metric_name, metric_df, chart_key)