feat: format

.streamlit/config.toml

@@ -1,17 +1,17 @@
 [theme]
-base = "light"
+base = "dark"
 baseFontSize = 15
-primaryColor = "#FF5F7E"
-backgroundColor = "#F9FAFB"
-secondaryBackgroundColor = "#F0F4F8"
-textColor = "#1F2937"
-linkColor = "#2563EB"
-borderColor = "#D1D5DB"
+primaryColor = "#6EA8FE"
+backgroundColor = "#0D1117"
+secondaryBackgroundColor = "#1A1F2B"
+textColor = "#D1D5DB"
+linkColor = "#B8C0FF"
+borderColor = "#2E3440"
 showWidgetBorder = false
 baseRadius = "0.3rem"
-font = "Poppins"
+font = "JetBrains Mono"
 
 [theme.sidebar]
-backgroundColor = "#FFFFFF"
-secondaryBackgroundColor = "#F3F4F6"
-borderColor = "#D1D5DB"
+backgroundColor = "#0A0A0A"
+secondaryBackgroundColor = "#1A1A1A"
+borderColor = "#2E3440"

.streamlit/theme.toml

@@ -1,2 +1,2 @@
-theme_name = "花明 (Flowers Bright) 🌸"
-theme_poem = "🌸「浅色但不苍白，明亮而不过曝，柔和中有力量」"
+theme_name = "柳暗 (Willows Dark) 🌒"
+theme_poem = "🌒「深而不死黑，蓝而不夺目，静而不沉闷」柳影婆娑之下，代码悄然生长。"

src/data_loader.py

@@ -4,19 +4,21 @@ 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
+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 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.
@@ -25,8 +27,9 @@ def clear_trial_cache():
     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
+    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()
@@ -39,6 +42,7 @@ 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 发现缓存已清除 (函数级别)。")
@@ -46,6 +50,7 @@ def clear_specific_study_trial_discovery_cache(study_path: Path):
 
 # --- 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():
@@ -60,8 +65,12 @@ def ensure_data_directory_exists(data_path: Path = DATA_ROOT_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
+@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).
@@ -71,7 +80,9 @@ def discover_studies_cached(_data_root: Path) -> Dict[str, Any]: # Return type h
     # 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
+    from data_models import (
+        Study,
+    )  # Local import to help with potential circularity if models grow complex
 
     if not _data_root.is_dir():
         return {}
@@ -128,7 +139,7 @@ def _load_single_metric_toml(_toml_file_path: Path) -> pd.DataFrame:
         return pd.DataFrame()
 
 
-@st.cache_data(ttl=300) # Cache metric data for 5 minutes
+@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.
@@ -150,19 +161,23 @@ def load_all_metrics_for_trial_path(_trial_path: Path) -> Dict[str, pd.DataFrame
 
         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.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)
+                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
@@ -173,16 +188,20 @@ def load_all_metrics_for_trial_path(_trial_path: Path) -> Dict[str, pd.DataFrame
                 else:
                     all_metrics_data_combined[metric_col_name] = pd.concat(
                         [all_metrics_data_combined[metric_col_name], current_metric_df],
-                        ignore_index=True
+                        ignore_index=True,
                     )
             except Exception as e:
-                print(f"Error processing metric '{metric_col_name}' from file '{toml_file.name}': {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)
+        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
+    return all_metrics_data_combined

src/data_models.py

@@ -3,7 +3,7 @@ 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 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
@@ -22,7 +22,7 @@ from data_loader import (
     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
+    clear_specific_study_trial_discovery_cache,
 )
 
 
@@ -30,9 +30,11 @@ from data_loader import (
 class Trial:
     name: str
     path: Path
-    study_name: str # To know its parent study
+    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
+    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
@@ -43,13 +45,13 @@ class Trial:
 
     def load_input_variables_cached(self):
         """Loads or retrieves cached input variables."""
-        if not self.input_variables: # Load only if not already populated
+        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
+        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
 
@@ -76,10 +78,14 @@ class Study:
 
     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
+        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)
+                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]:
@@ -89,6 +95,6 @@ class Study:
         """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 的缓存已清除。")
+            trial.clear_cache()  # Clear cache for each trial within the study
+        self.trials = {}  # Reset trials dictionary
+        st.success(f"Study '{self.name}' 及其 Trials 的缓存已清除。")

src/streamlit_app.py

@@ -1,6 +1,12 @@
 import streamlit as st
+
 # --- Page Configuration ---
-st.set_page_config(layout="wide", page_title="柳暗花明 (flowillower)", page_icon=":sunrise_over_mountains:", initial_sidebar_state="expanded")
+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
@@ -15,7 +21,7 @@ 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_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:
@@ -48,8 +54,6 @@ if "auto_play_needs_rerun" not in st.session_state:
     st.session_state.auto_play_needs_rerun = False
 
 
-
-
 # --- UI Rendering ---
 
 # --- Header ---
@@ -63,24 +67,30 @@ 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 开始记录实验。")
+    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
+            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,
+            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" 
+            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.session_state.selected_trial_name = None
+            st.session_state.shared_selected_global_step = None  # Study 变化时清除高亮
             st.rerun()
 
     with header_cols[2]:
@@ -90,9 +100,12 @@ 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[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("**主题**")
@@ -101,7 +114,10 @@ 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:
+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()
@@ -113,10 +129,16 @@ with st.sidebar:
     if current_study:
         st.markdown(f"##### {current_study.name}")
         if st.button("刷新 Study 数据 (Refresh Study Data)", use_container_width=True):
-            current_study.clear_cache() 
+            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("功能待实现")
+        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")
 
@@ -124,18 +146,22 @@ with st.sidebar:
     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
+            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,
+            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"
+            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.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}**")
@@ -144,17 +170,22 @@ with st.sidebar:
     else:
         st.info("请先选择一个 Study。")
     st.markdown("---")
-    if st.button("⚙️ App 设置 (App Settings)", use_container_width=True, disabled=True): st.toast("功能待实现")
+    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:
+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])
+    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}")
@@ -162,50 +193,60 @@ if current_study and current_trial:
         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)
+    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 (
+                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))
+                    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"
+                    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:
@@ -216,7 +257,7 @@ if current_study and current_trial:
                     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(
@@ -224,37 +265,49 @@ if current_study and current_trial:
                     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"
+                    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)
+                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.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.info(
+                f"当前选中步骤: **{st.session_state.shared_selected_global_step}** / {max_step}"
+            )
+
         st.markdown("---")
 
-    tab_titles = ["图表 (Charts)", "参数 (Parameters)", "系统 (System)", "日志 (Logs)", "环境 (Environment)"]
+    tab_titles = [
+        "图表 (Charts)",
+        "参数 (Parameters)",
+        "系统 (System)",
+        "日志 (Logs)",
+        "环境 (Environment)",
+    ]
     tab_charts, tab_params, tab_system, tab_logs, tab_env = st.tabs(tab_titles)
 
     with tab_charts:
@@ -266,12 +319,14 @@ if current_study and current_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}"
+                "每行图表数量 (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)
@@ -281,78 +336,116 @@ if current_study and current_trial:
                         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
-                                
+                                current_step = (
+                                    st.session_state.shared_selected_global_step
+                                )
+
                                 # 获取所有可能的track
-                                all_tracks = df_metric['track'].unique() if 'track' in df_metric.columns else [None]
-                                
+                                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)
+                                            (df_metric["global_step"] == current_step)
+                                            & (df_metric["track"] == track)
                                         ]
                                     else:
-                                        current_step_data = df_metric[df_metric['global_step'] == current_step]
-                                    
+                                        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):
+                                        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)
+                                                    (
+                                                        df_metric["global_step"]
+                                                        == search_step
+                                                    )
+                                                    & (df_metric["track"] == track)
                                                 ]
                                             else:
-                                                search_data = df_metric[df_metric['global_step'] == search_step]
-                                            
+                                                search_data = df_metric[
+                                                    df_metric["global_step"]
+                                                    == search_step
+                                                ]
+
                                             if not search_data.empty:
-                                                current_value = search_data['value'].iloc[0]
+                                                current_value = search_data[
+                                                    "value"
+                                                ].iloc[0]
                                                 current_step_found = search_step
                                                 break
                                     else:
-                                        current_value = current_step_data['value'].iloc[0]
+                                        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):
+                                        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)
+                                                    (
+                                                        df_metric["global_step"]
+                                                        == prev_step
+                                                    )
+                                                    & (df_metric["track"] == track)
                                                 ]
                                             else:
-                                                prev_step_data = df_metric[df_metric['global_step'] == prev_step]
-                                            
+                                                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]
+                                                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]:
+                                    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:
@@ -364,120 +457,163 @@ if current_study and current_trial:
                                                 if current_step_found != current_step:
                                                     label = f"当前值 (Step {current_step_found})"
                                                 else:
-                                                    label = f"当前值 (Step {current_step})"
-                                            
+                                                    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
+                                                delta=f"{delta_value:.4f}"
+                                                if delta_value is not None
+                                                else None,
                                             )
                                         else:
                                             # 没有找到任何数据
-                                            track_label = track if track is not None else "数据"
+                                            track_label = (
+                                                track if track is not None else "数据"
+                                            )
                                             st.metric(
                                                 label=f"{track_label}",
                                                 value="无数据",
-                                                delta=None
+                                                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)]
-                                    
+                                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>'
-                                        ))
+                                        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>'
-                                    ))
-                                
+                                    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:
+                                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
+                                        opacity=0.9,
                                     )
-                                
+
                                 # 设置图表布局
                                 fig.update_layout(
                                     title=None,
-                                    xaxis_title='全局步骤 (Global Step)',
+                                    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'
+                                    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, 
+                                    fig,
                                     use_container_width=True,
                                     key=chart_key,
-                                    on_select="rerun"
+                                    on_select="rerun",
                                 )
-                                
+
                                 # 处理点击事件
-                                if clicked_points and 'selection' in clicked_points:
-                                    selection = clicked_points['selection']
-                                    if 'points' in selection and len(selection['points']) > 0:
+                                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']
+                                        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:
+                                            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
-
+                            # 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` 或文件为空。")
+        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, "环境")]:
+    for tab_content, name in [
+        (tab_system, "系统监控"),
+        (tab_logs, "日志"),
+        (tab_env, "环境"),
+    ]:
         with tab_content:
             st.header(name)
             st.info("此功能待您的 `flowillower` API 提供相关数据后实现。")

src/test.py

@@ -8,8 +8,9 @@ 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)')])
+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):
@@ -17,20 +18,24 @@ def hover_fn(trace, points, state):
         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')
-            )]
+            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/theme_selector.py

@@ -4,65 +4,68 @@ from pathlib import Path
 import os
 import time
 
+
 class ThemeSelector:
-    def __init__(self, themes_dir=".streamlit/themes", config_path=".streamlit/config.toml"):
+    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
+                    "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 = 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():
@@ -70,48 +73,51 @@ class ThemeSelector:
                     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"
+            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)
-            
+                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(
             "选择主题",
@@ -119,9 +125,9 @@ class ThemeSelector:
             index=current_index,
             format_func=lambda x: self.themes[x]["name"],
             key="theme_selector_widget",
-            label_visibility="collapsed"
+            label_visibility="collapsed",
         )
-        
+
         # 如果选择了新主题
         if selected_theme != current_theme:
             if self.apply_theme(selected_theme):
@@ -131,16 +137,18 @@ class ThemeSelector:
                     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
@@ -148,6 +156,7 @@ def get_theme_selector():
         _theme_selector = ThemeSelector()
     return _theme_selector
 
+
 def render_theme_selector():
     """便捷函数：渲染主题选择器"""
     return get_theme_selector().render_theme_selector()

src/utils.py

@@ -13,4 +13,4 @@ DATA_ROOT_PATH = Path("./data").resolve()
 
 class AppMode(Enum):
     VIEWING = auto()
-    # Potentially other modes like COMPARISON, EDITING etc.
+    # Potentially other modes like COMPARISON, EDITING etc.