Create multi_env_compare.py

multi_env_compare.py

@@ -0,0 +1,162 @@
+import pandas as pd
+import streamlit as st
+import numpy as np
+from pre import preprocess_uploaded_file
+from difflib import SequenceMatcher
+
+def similar(a, b, threshold=0.9):
+    return SequenceMatcher(None, a, b).ratio() > threshold
+
+def perform_multi_env_analysis(uploaded_dataframes):
+    # Concatenate all dataframes into a single dataframe
+    combined_data = pd.concat(uploaded_dataframes, ignore_index=True)
+
+    # Get unique environments and functional areas
+    unique_environments = combined_data['Environment'].unique()
+    unique_areas = np.append(combined_data['Functional area'].unique(), "All")
+
+    # Select environments to display
+    selected_environments = st.multiselect("Select environments to display", unique_environments, default=unique_environments)
+
+    # Initialize session state for selected functional areas if it doesn't exist
+    if 'selected_functional_areas' not in st.session_state:
+        st.session_state.selected_functional_areas = ["All"]
+
+    # Select functional areas to display, using session state
+    selected_functional_areas = st.multiselect(
+        "Select functional areas",
+        unique_areas,
+        default=st.session_state.selected_functional_areas
+    )
+
+    # Update session state with the new selection
+    st.session_state.selected_functional_areas = selected_functional_areas
+
+    if "All" in selected_functional_areas:
+        selected_functional_areas = combined_data['Functional area'].unique()
+
+    # Filter data based on selected environments and functional areas
+    filtered_data = combined_data[
+        (combined_data['Environment'].isin(selected_environments)) &
+        (combined_data['Functional area'].isin(selected_functional_areas))
+    ]
+
+    # Group data by Environment, Functional area, Scenario name, and Status
+    grouped_data = filtered_data.groupby(['Environment', 'Functional area', 'Scenario name', 'Status']).size().unstack(fill_value=0)
+
+    # Ensure 'PASSED' and 'FAILED' columns exist
+    if 'PASSED' not in grouped_data.columns:
+        grouped_data['PASSED'] = 0
+    if 'FAILED' not in grouped_data.columns:
+        grouped_data['FAILED'] = 0
+
+    # Calculate total scenarios
+    grouped_data['Total'] = grouped_data['PASSED'] + grouped_data['FAILED']
+
+    # Reset index to make Environment, Functional area, and Scenario name as columns
+    grouped_data = grouped_data.reset_index()
+
+    # Reorder columns
+    grouped_data = grouped_data[['Environment', 'Functional area', 'Scenario name', 'Total', 'PASSED', 'FAILED']]
+
+    # Display the grouped data
+    st.write("### Scenario Counts by Environment and Functional Area")
+    # st.dataframe(grouped_data.style.highlight_max(axis=0, subset=['Total', 'PASSED', 'FAILED']))
+
+    # Display summary statistics
+    st.write("### Summary Statistics")
+    summary = grouped_data.groupby('Environment').agg({
+        'Total': 'sum',
+        'PASSED': 'sum',
+        'FAILED': 'sum'
+    }).reset_index()
+
+    # Add column names as the first row
+    summary_with_headers = pd.concat([pd.DataFrame([summary.columns], columns=summary.columns), summary], ignore_index=True)
+
+    # Display the DataFrame
+    st.dataframe(summary_with_headers)
+    # Define scenarios_by_env here
+    scenarios_by_env = {env: set(grouped_data[grouped_data['Environment'] == env]['Scenario name']) for env in selected_environments}
+
+    # Debug: Print the number of scenarios in each environment
+    for env, scenarios in scenarios_by_env.items():
+        st.write(f"Number of scenarios in {env}: {len(scenarios)}")
+
+    missing_scenarios = []
+    mismatched_scenarios = []
+    
+    # New section for efficient inconsistency analysis
+    st.write("### Inconsistent Scenario Count Analysis by Functional Area")
+    
+    if len(selected_environments) > 1:
+        # Group data by Environment and Functional area, count scenarios
+        scenario_counts = filtered_data.groupby(['Environment', 'Functional area'])['Scenario name'].nunique().unstack(fill_value=0)
+        
+        # Calculate the difference between max and min counts for each functional area
+        count_diff = scenario_counts.max() - scenario_counts.min()
+        
+        # Sort functional areas by count difference, descending
+        inconsistent_areas = count_diff.sort_values(ascending=False)
+        
+        st.write("Functional areas with inconsistent scenario counts across environments:")
+        for area, diff in inconsistent_areas.items():
+            if diff > 0:
+                st.write(f"- {area}: Difference of {diff} scenarios")
+                st.write(scenario_counts[area])
+                st.write("\n")
+        
+        # Option to show detailed breakdown
+        if st.checkbox("Show detailed scenario count breakdown"):
+            st.write(scenario_counts)
+    
+    else:
+        st.write("Please select at least two environments for comparison.")
+
+    # Debug: Print the number of missing and mismatched scenarios
+    st.write(f"Number of truly missing scenarios: {len(missing_scenarios)}")
+    st.write(f"Number of scenarios with name differences: {len(mismatched_scenarios)}")
+
+    if missing_scenarios:
+        st.write("### Truly Missing Scenarios")
+        missing_df = pd.DataFrame(missing_scenarios)
+        st.dataframe(missing_df)
+    else:
+        st.write("No truly missing scenarios found across environments.")
+
+    if mismatched_scenarios:
+        st.write("### Scenarios with Name Differences")
+        mismatched_df = pd.DataFrame(mismatched_scenarios)
+        st.dataframe(mismatched_df)
+    else:
+        st.write("No scenarios with name differences found across environments.")
+
+def multi_env_compare_main():
+    st.title("Multi-Environment Comparison")
+    
+    # Get the number of environments from the user
+    num_environments = st.number_input("Enter the number of environments", min_value=1, value=1, step=1)
+
+    # Initialize list to store uploaded dataframes
+    uploaded_dataframes = []
+
+    # Loop through the number of environments and create file uploaders
+    for i in range(num_environments):
+        uploaded_files = st.file_uploader(f"Upload CSV files for Environment {i + 1}", type="csv", accept_multiple_files=True)
+        
+        for uploaded_file in uploaded_files:
+            # Preprocess the uploaded CSV file
+            data = preprocess_uploaded_file(uploaded_file)
+            
+            # Append the dataframe to the list
+            uploaded_dataframes.append(data)
+    
+    # Check if any files were uploaded
+    if uploaded_dataframes:
+        # Perform analysis for uploaded data
+        perform_multi_env_analysis(uploaded_dataframes)
+    else:
+        st.write("Please upload at least one CSV file.")
+
+if __name__ == "__main__":
+    multi_env_compare_main()