Spaces:
Sleeping
Sleeping
| from flask import Flask, render_template, request, send_file, redirect, url_for | |
| import pandas as pd | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| import io | |
| import os | |
| app = Flask(__name__) | |
| # Cache | |
| data_cache = { | |
| "df1": None, | |
| "limits": {}, | |
| "cols": [], | |
| "golden_loaded": False, | |
| "comparison_file": None | |
| } | |
| def process_golden_file(golden_file): | |
| """Load Golden data and extract limits.""" | |
| limits_df1 = pd.read_excel(golden_file, nrows=4) | |
| df1 = pd.read_excel(golden_file) | |
| df1 = df1.drop([0, 1, 2, 3]) | |
| df1 = df1.apply(pd.to_numeric, errors="coerce") | |
| limits_df1 = limits_df1.drop([0]) | |
| ignore_cols = ["SITE_NUM", "PART_ID", "PASSFG", "SOFT_BIN", "T_TIME", "TEST_NUM"] | |
| cols_to_plot = [col for col in limits_df1.columns if "_" in col and col not in ignore_cols] | |
| limits_df1 = limits_df1.drop(columns=ignore_cols) | |
| limits = { | |
| col: {"LL": limits_df1.iloc[0][col], "UL": limits_df1.iloc[1][col]} | |
| for col in limits_df1.columns | |
| } | |
| data_cache.update({ | |
| "df1": df1, | |
| "limits": limits, | |
| "cols": cols_to_plot, | |
| "golden_loaded": True | |
| }) | |
| def process_test_file(test_file): | |
| """Load Test data.""" | |
| df2 = pd.read_excel(test_file) | |
| df2 = df2.drop([0, 1, 2, 3]) | |
| df2 = df2.apply(pd.to_numeric, errors="coerce") | |
| return df2 | |
| def generate_comparison_excel(df2): | |
| """Generate comparison Excel (mean, std, min, max for both).""" | |
| df1 = data_cache["df1"] | |
| ignore_cols = ["SITE_NUM", "PART_ID", "PASSFG", "SOFT_BIN", "T_TIME", "TEST_NUM"] | |
| # cols_to_plot = [col for col in limits_df1.columns if "_" in col and col not in ignore_cols] | |
| # common_cols = [ignore_cols = ["SITE_NUM", "PART_ID", "PASSFG", "SOFT_BIN", "T_TIME", "TEST_NUM"] | |
| common_cols = [col for col in df1.columns if "_" in col and col not in ignore_cols] | |
| # common_cols = [c for c in df1.columns if c in df2.columns] | |
| summary = [] | |
| for col in common_cols: | |
| g_mean, t_mean = df1[col].mean(), df2[col].mean() | |
| g_std, t_std = df1[col].std(), df2[col].std() | |
| g_min, t_min = df1[col].min(), df2[col].min() | |
| g_max, t_max = df1[col].max(), df2[col].max() | |
| diff = t_mean - g_mean if pd.notna(t_mean) and pd.notna(g_mean) else np.nan | |
| summary.append([col, g_mean, t_mean, diff, g_std, t_std, g_min, t_min, g_max, t_max]) | |
| comp_df = pd.DataFrame(summary, columns=[ | |
| "Parameter", "Golden_Mean", "Test_Mean", "Mean_Diff", | |
| "Golden_Std", "Test_Std", "Golden_Min", "Test_Min", "Golden_Max", "Test_Max" | |
| ]) | |
| path = "comparison_result.xlsx" | |
| comp_df.to_excel(path, index=False) | |
| data_cache["comparison_file"] = path | |
| def generate_plot(df2, col): | |
| """Generate and return a plot comparing Golden vs Test.""" | |
| df1, limits = data_cache["df1"], data_cache["limits"] | |
| plt.figure(figsize=(6, 4)) | |
| x1 = np.arange(1, len(df1[col]) + 1) | |
| plt.plot(x1, df1[col], 'o-', label="Golden", color='blue') | |
| if col in df2.columns: | |
| x2 = np.arange(1, len(df2[col]) + 1) | |
| plt.plot(x2, df2[col], 's--', label="Test", color='red') | |
| if col in limits: | |
| ll, ul = limits[col]["LL"], limits[col]["UL"] | |
| plt.axhline(ll, color='green', linestyle='--', label='LL') | |
| plt.axhline(ul, color='orange', linestyle='--', label='UL') | |
| plt.title(f"{col}") | |
| plt.xlabel("Part # (sequence)") | |
| plt.ylabel("Value") | |
| plt.legend(fontsize='small') | |
| plt.grid(True, linestyle='--', alpha=0.7) | |
| plt.xticks(np.arange(1, len(df1[col]) + 1)) | |
| plt.tight_layout() | |
| buf = io.BytesIO() | |
| plt.savefig(buf, format='png', bbox_inches='tight') | |
| buf.seek(0) | |
| plt.close() | |
| return buf | |
| def index(): | |
| if request.method == "POST": | |
| # Upload Golden first | |
| if not data_cache["golden_loaded"]: | |
| golden_file = request.files.get("golden_file") | |
| if not golden_file: | |
| return render_template("index.html", error="Please upload Golden file.") | |
| try: | |
| process_golden_file(golden_file) | |
| return redirect(url_for("index")) | |
| # return render_template("index.html", message="Golden data loaded successfully!") | |
| except Exception as e: | |
| return render_template("index.html", error=f"Error loading Golden file: {e}") | |
| # Upload Test data next | |
| else: | |
| test_file = request.files.get("test_file") | |
| if not test_file: | |
| return render_template("index.html", error="Please upload Test data.") | |
| try: | |
| df2 = process_test_file(test_file) | |
| data_cache["df2_temp"] = df2 | |
| generate_comparison_excel(df2) | |
| return render_template( | |
| "plot.html", | |
| cols=data_cache["cols"], | |
| file_ready=True | |
| ) | |
| except Exception as e: | |
| return render_template("index.html", error=f"Error processing Test file: {e}") | |
| return render_template("index.html", golden_loaded=data_cache["golden_loaded"]) | |
| def plot_image(col): | |
| df2 = data_cache.get("df2_temp") | |
| if df2 is None: | |
| return "No Test data loaded." | |
| buf = generate_plot(df2, col) | |
| return send_file(buf, mimetype="image/png") | |
| def download_comparison(): | |
| """Download comparison Excel file.""" | |
| path = data_cache.get("comparison_file") | |
| if path and os.path.exists(path): | |
| return send_file(path, as_attachment=True) | |
| return "No comparison file available." | |
| def reset_golden(): | |
| """Reset golden data.""" | |
| data_cache.update({"df1": None, "limits": {}, "cols": [], "golden_loaded": False}) | |
| return redirect(url_for("index")) | |
| if __name__ == "__main__": | |
| app.run(host="0.0.0.0", port=7860, debug=True) | |