Update app.py

app.py

@@ -1171,7 +1171,8 @@ def create_histogram(file_path: str, dataset_path: str, slice_str: str = "",
 
 def create_line_plot(file_path: str, dataset_path: str, slice_str: str = "",
                      title_override: str = "", xlabel_override: str = "", ylabel_override: str = "",
-                     x_dataset_path: str = "", memory_limit_mb: float = None) -> Tuple[Dict[str, Any], Optional[str]]:
+                     x_dataset_path: str = "", moving_avg_window: int = 0,
+                     memory_limit_mb: float = None) -> Tuple[Dict[str, Any], Optional[str]]:
     """
     Create line plot for 1D data or time series.
     
@@ -1183,6 +1184,7 @@ def create_line_plot(file_path: str, dataset_path: str, slice_str: str = "",
         xlabel_override: Optional custom x-axis label
         ylabel_override: Optional custom y-axis label
         x_dataset_path: Optional path to X-axis data (if empty, uses indices)
+        moving_avg_window: Window size for moving average (0 or 1 = no smoothing, 2-1000 = apply smoothing)
         memory_limit_mb: Memory limit in MB (default: tiered 100/500/2000)
         
     Returns:
@@ -1284,16 +1286,45 @@ def create_line_plot(file_path: str, dataset_path: str, slice_str: str = "",
         # Create figure
         fig = go.Figure()
         
-        # Add line trace
+        # Add raw data trace
         fig.add_trace(go.Scatter(
             x=x_data,
             y=y_data,
             mode='lines+markers',
-            name=dataset_path,
-            line=dict(color='steelblue', width=2),
-            marker=dict(size=4)
+            name='Raw Data',
+            line=dict(color='steelblue', width=1),
+            marker=dict(size=3),
+            opacity=0.7
         ))
         
+        # Add moving average if requested
+        smoothed_info = None
+        if moving_avg_window and moving_avg_window > 1:
+            # Validate window size
+            if moving_avg_window > len(y_data):
+                smoothed_info = f"Moving average window ({moving_avg_window}) larger than data length ({len(y_data)}), skipping smoothing"
+            else:
+                # Calculate moving average using convolution
+                window = np.ones(moving_avg_window) / moving_avg_window
+                y_smooth = np.convolve(y_data, window, mode='valid')
+                
+                # Adjust X data to match smoothed Y length
+                # 'valid' mode reduces length by (window_size - 1)
+                offset = (moving_avg_window - 1) // 2
+                x_smooth = x_data[offset:offset + len(y_smooth)]
+                
+                # Add smoothed trace
+                fig.add_trace(go.Scatter(
+                    x=x_smooth,
+                    y=y_smooth,
+                    mode='lines',
+                    name=f'Moving Avg (n={moving_avg_window})',
+                    line=dict(color='red', width=2),
+                    opacity=0.9
+                ))
+                
+                smoothed_info = f"Applied moving average with window size {moving_avg_window}"
+        
         # Set title and labels
         title = title_override if title_override else f"Line Plot: {dataset_path}"
         xlabel = xlabel_override if xlabel_override else (x_dataset_path if x_dataset_path else "Index")
@@ -1327,6 +1358,9 @@ def create_line_plot(file_path: str, dataset_path: str, slice_str: str = "",
             "download_info": "Download the HTML file to view the interactive line plot in your browser"
         }
         
+        if smoothed_info:
+            result["smoothing"] = smoothed_info
+        
         return result, html_path
         
     except Exception as e:
@@ -1483,8 +1517,8 @@ def create_heatmap(file_path: str, dataset_path: str, slice_str: str = "",
 
 
 def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str,
-                        slice_str: str = "", title_override: str = "",
-                        xlabel_override: str = "", ylabel_override: str = "",
+                        x_slice_str: str = "", y_slice_str: str = "",
+                        title_override: str = "", xlabel_override: str = "", ylabel_override: str = "",
                         memory_limit_mb: float = None) -> Tuple[Dict[str, Any], Optional[str]]:
     """
     Create scatter plot comparing two variables.
@@ -1493,7 +1527,8 @@ def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str
         file_path: Path to the HDF5/NetCDF file
         x_dataset_path: Path to X-axis dataset/variable
         y_dataset_path: Path to Y-axis dataset/variable
-        slice_str: Optional numpy-style slice notation
+        x_slice_str: Optional numpy-style slice for X data
+        y_slice_str: Optional numpy-style slice for Y data
         title_override: Optional custom title
         xlabel_override: Optional custom x-axis label
         ylabel_override: Optional custom y-axis label
@@ -1528,8 +1563,8 @@ def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str
                 x_var = f.variables[x_dataset_path]
                 y_var = f.variables[y_dataset_path]
             
-            # Check memory safety for both
-            x_safety = check_memory_safety(x_var.shape, x_var.dtype, slice_str, memory_limit_mb)
+            # Check memory safety for X
+            x_safety = check_memory_safety(x_var.shape, x_var.dtype, x_slice_str, memory_limit_mb)
             if not x_safety["safe"]:
                 error_result = {
                     "error": f"X data: {x_safety['error']}",
@@ -1537,10 +1572,11 @@ def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str
                     "status": "failed"
                 }
                 if "suggested_slice" in x_safety:
-                    error_result["suggested_slice"] = x_safety["suggested_slice"]
+                    error_result["suggested_slice_x"] = x_safety["suggested_slice"]
                 return error_result, None
             
-            y_safety = check_memory_safety(y_var.shape, y_var.dtype, slice_str, memory_limit_mb)
+            # Check memory safety for Y
+            y_safety = check_memory_safety(y_var.shape, y_var.dtype, y_slice_str, memory_limit_mb)
             if not y_safety["safe"]:
                 error_result = {
                     "error": f"Y data: {y_safety['error']}",
@@ -1548,16 +1584,21 @@ def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str
                     "status": "failed"
                 }
                 if "suggested_slice" in y_safety:
-                    error_result["suggested_slice"] = y_safety["suggested_slice"]
+                    error_result["suggested_slice_y"] = y_safety["suggested_slice"]
                 return error_result, None
             
-            # Read data
-            if slice_str and slice_str.strip():
-                idx = parse_slice(slice_str)
-                x_data = x_var[idx]
-                y_data = y_var[idx]
+            # Read X data
+            if x_slice_str and x_slice_str.strip():
+                x_idx = parse_slice(x_slice_str)
+                x_data = x_var[x_idx]
             else:
                 x_data = x_var[:]
+            
+            # Read Y data
+            if y_slice_str and y_slice_str.strip():
+                y_idx = parse_slice(y_slice_str)
+                y_data = y_var[y_idx]
+            else:
                 y_data = y_var[:]
             
             # Convert to numpy and flatten
@@ -1572,7 +1613,10 @@ def create_scatter_plot(file_path: str, x_dataset_path: str, y_dataset_path: str
             # Check lengths match
             if len(x_data) != len(y_data):
                 return {
-                    "error": f"X and Y data length mismatch: {len(x_data)} vs {len(y_data)}",
+                    "error": f"X and Y data length mismatch after slicing: {len(x_data)} vs {len(y_data)}",
+                    "x_slice": x_slice_str if x_slice_str else "no slice",
+                    "y_slice": y_slice_str if y_slice_str else "no slice",
+                    "suggestion": "Adjust slices to produce equal-length arrays",
                     "status": "failed"
                 }, None
             
@@ -2137,6 +2181,13 @@ def build_mcp_tools():
                 value="",
                 info="Path to X-axis data (if empty, uses indices)"
             ),
+            gr.Number(
+                label="Moving Average Window (optional)",
+                value=0,
+                minimum=0,
+                maximum=1000,
+                info="Window size for smoothing (0 or 1 = no smoothing, 2-1000 = apply moving average)"
+            ),
             gr.Number(
                 label="Memory Limit (MB) - optional",
                 value=None,
@@ -2235,10 +2286,16 @@ def build_mcp_tools():
                 info="Path to Y-axis dataset/variable"
             ),
             gr.Textbox(
-                label="Slice (optional)",
-                placeholder="0:100, :, 5",
+                label="X Slice (optional)",
+                placeholder="0, :, :",
                 value="",
-                info="Numpy-style slice notation"
+                info="Numpy-style slice for X data (can differ from Y slice)"
+            ),
+            gr.Textbox(
+                label="Y Slice (optional)",
+                placeholder="1, :, :",
+                value="",
+                info="Numpy-style slice for Y data (can differ from X slice)"
             ),
             gr.Textbox(
                 label="Title (optional)",