added auto loader that doesnt work

app.py

@@ -4,9 +4,12 @@ import matplotlib.pyplot as plt
 import numpy as np
 from second import double_main
 from multiple import multiple_main
+from multiple import display_story_points_stats
+from jira_integration import render_jira_login, JIRA_SERVER
 from weekly import generate_weekly_report
 from pre import preprocess_uploaded_file, add_app_description
-from multi_env_compare import multi_env_compare_main 
+from multi_env_compare import multi_env_compare_main
+import multiple_env_loader
 
 
 
@@ -143,33 +146,73 @@ def single_main(uploaded_file):
 def main():
     add_app_description()
 
+    # --- Centralized Sidebar Initialization ---
+    # Initialize session state for Jira and sprint data if they don't exist
+    if 'jira_server' not in st.session_state:
+        st.session_state.jira_server = JIRA_SERVER
+    if 'is_authenticated' not in st.session_state:
+        st.session_state.is_authenticated = False # Start as not authenticated
+    if 'jira_client' not in st.session_state:
+        st.session_state.jira_client = None
+    if 'sprint_data_initialized' not in st.session_state:
+        st.session_state.sprint_data_initialized = False
+    if 'force_sprint_refresh' not in st.session_state:
+        st.session_state.force_sprint_refresh = False
+    if 'sprint_data_cache' not in st.session_state:
+        st.session_state.sprint_data_cache = None
+    if 'last_sprint_fetch' not in st.session_state:
+        st.session_state.last_sprint_fetch = None
+
     # Initialize session state for mode if it doesn't exist
     if "mode" not in st.session_state:
         st.session_state["mode"] = "multi"
     
+    # --- Sidebar Rendering --- 
+    with st.sidebar:
+        # Mode Selection (kept in sidebar)
+        selected_mode = st.selectbox(
+            "Select Mode", 
+            ["Multi", "Compare", "Weekly", "Multi-Env Compare", "Auto Environment Loader"],
+            index=["Multi", "Compare", "Weekly", "Multi-Env Compare", "Auto Environment Loader"].index(st.session_state.get("selected_mode", "Multi"))
+        )
+        # Update the session state with the new selection
+        st.session_state["selected_mode"] = selected_mode
+        st.session_state["mode"] = selected_mode.lower()
+        mode_display = f'## Current mode: {st.session_state["mode"].title()} mode'
+        st.markdown(mode_display)
+
+        st.markdown("---") # Separator
+
+        # Jira Login Expander (always shown)
+        with st.expander("Jira Integration (Optional)", expanded=True):
+            # Render login - function handles checking if already authenticated
+            # It updates st.session_state.is_authenticated and st.session_state.jira_client
+            st.session_state.is_authenticated = render_jira_login()
+            
+            # Sprint Progress Expander (shown only if authenticated)
+            if st.session_state.is_authenticated and st.session_state.jira_client:
+                st.markdown("---") # Separator inside the main expander
+                with st.expander("Sprint Progress", expanded=True):
+                    # Refresh button
+                    if st.button("🔄 Refresh Sprint Data", key="refresh_sprint_sidebar_app"):
+                        st.session_state.force_sprint_refresh = True
+                    # Always call display (it handles caching), passing manual refresh flag
+                    display_story_points_stats(force_refresh=st.session_state.force_sprint_refresh)
+                    # Reset manual refresh flag after use
+                    st.session_state.force_sprint_refresh = False
+
     # Initialize session state for the selectbox widget
     if "selected_mode" not in st.session_state:
         st.session_state["selected_mode"] = "Multi"
-   
-    # Use the session state for the default value of the selectbox
-    selected_mode = st.sidebar.selectbox(
-        "Select Mode", 
-        ["Multi", "Compare", "Weekly", "Multi-Env Compare"],
-        index=["Multi", "Compare", "Weekly", "Multi-Env Compare"].index(st.session_state["selected_mode"])
-    )
     
-    # Update the session state with the new selection
-    st.session_state["selected_mode"] = selected_mode
-    st.session_state["mode"] = selected_mode.lower()
-
-    mode_display = f'## Current mode: {st.session_state["mode"].title()} mode'
-    st.sidebar.markdown(mode_display)
-
+    # --- Main Page Content based on Mode --- 
     if st.session_state["mode"] == "multi":
         multiple_main()
     elif st.session_state["mode"] == "compare":
         st.sidebar.markdown("### Upload Files for Comparison")
-        upload_option = st.sidebar.radio("Upload method", ["Single uploader", "Two separate uploaders"])
+        # Move file uploaders to main page area if needed, or keep in sidebar below Jira?
+        # For now, keeping in sidebar as it was.
+        upload_option = st.sidebar.radio("Upload method", ["Single uploader", "Two separate uploaders"], key="compare_upload_method")
         
         if upload_option == "Single uploader":
             uploaded_files = st.sidebar.file_uploader("Upload CSV or XLSX files for comparison", type=["csv", "xlsx"], accept_multiple_files=True)
@@ -201,6 +244,9 @@ def main():
             generate_weekly_report(uploaded_files)
     elif st.session_state["mode"] == "multi-env compare":
         multi_env_compare_main()
+    elif st.session_state["mode"] == "auto environment loader":
+        # Launch the auto environment loader workflow
+        multiple_env_loader.main()
 
 if __name__ == "__main__":
     main()

environment_loader.py

@@ -0,0 +1,137 @@
+# environment_loader.py
+'''Utility module to load .xlsx files from environment-specific folders and optional Huggingface repositories.'''
+
+import os
+from pathlib import Path
+import pandas as pd
+from datetime import datetime, timedelta
+
+# Optional Huggingface support
+try:
+    from huggingface_hub import hf_hub_download
+except ImportError:
+    hf_hub_download = None
+
+
+def get_latest_file_in_directory(directory_path: str, pattern: str = '*.xlsx') -> Path:
+    '''Return the Path to the latest modified file matching pattern in directory_path.'''
+    dir_path = Path(directory_path)
+    files = list(dir_path.glob(pattern))
+    if not files:
+        return None
+    return max(files, key=lambda f: f.stat().st_mtime)
+
+
+def get_file_by_date(directory_path: str, target_date: datetime.date, pattern: str = '*.xlsx') -> Path:
+    '''Return Path to the file whose name contains target_date or whose modification date matches target_date.'''
+    date_str = target_date.strftime('%Y-%m-%d')
+    dir_path = Path(directory_path)
+    # First try matching date string in filename
+    candidates = [f for f in dir_path.glob(pattern) if date_str in f.name]
+    if candidates:
+        return max(candidates, key=lambda f: f.stat().st_mtime)
+    # Fallback to checking file modification date
+    files = [f for f in dir_path.glob(pattern) if datetime.fromtimestamp(f.stat().st_mtime).date() == target_date]
+    if files:
+        return max(files, key=lambda f: f.stat().st_mtime)
+    return None
+
+
+def load_latest_xlsx_for_env(env_code: str,
+                             base_path: str = 'Q:/Selenium_Reports',
+                             use_date: bool = False,
+                             target_date: datetime.date = None) -> pd.DataFrame:
+    '''Load the latest or date-specific .xlsx file for the given environment code.'''
+    folder = Path(base_path) / env_code / 'XLSX'
+    if not folder.exists():
+        raise FileNotFoundError(f"Environment folder not found: {folder}")
+    if use_date:
+        if target_date is None:
+            raise ValueError('target_date must be provided when use_date is True')
+        file_path = get_file_by_date(folder, target_date)
+    else:
+        file_path = get_latest_file_in_directory(folder)
+    if file_path is None:
+        raise FileNotFoundError(f'No .xlsx files found for environment {env_code} in {folder}')
+    return pd.read_excel(file_path)
+
+
+def load_environments(env_codes: list,
+                      base_path: str = 'Q:/Selenium_Reports',
+                      by_date: bool = False,
+                      days_ago: int = 1) -> dict:
+    '''Load DataFrame for each environment code; by_date chooses file from days_ago days before.'''
+    data = {}
+    target_date = datetime.now().date() - timedelta(days=days_ago)
+    for env in env_codes:
+        df = load_latest_xlsx_for_env(
+            env_code=env,
+            base_path=base_path,
+            use_date=by_date,
+            target_date=target_date
+        )
+        data[env] = df
+    return data
+
+
+def load_from_huggingface(repo_id: str,
+                          filenames: list,
+                          revision: str = 'main') -> dict:
+    '''Download files from a Huggingface repo and load as DataFrames.'''
+    if hf_hub_download is None:
+        raise ImportError('huggingface_hub is not installed. Please pip install huggingface_hub')
+    data = {}
+    for fname in filenames:
+        local_path = hf_hub_download(repo_id=repo_id, filename=fname, revision=revision)
+        data[fname] = pd.read_excel(local_path)
+    return data
+
+
+def get_latest_xlsx_path_for_env(env_code: str,
+                                 base_path: str = 'Q:/Selenium_Reports',
+                                 use_date: bool = False,
+                                 target_date: datetime.date = None) -> Path:
+    '''Return the Path to the desired .xlsx file for the given environment code without loading.'''
+    folder = Path(base_path) / env_code / 'XLSX'
+    if not folder.exists():
+        raise FileNotFoundError(f"Environment folder not found: {folder}")
+    if use_date:
+        if target_date is None:
+            raise ValueError('target_date must be provided when use_date is True')
+        file_path = get_file_by_date(folder, target_date)
+    else:
+        file_path = get_latest_file_in_directory(folder)
+    if file_path is None:
+        raise FileNotFoundError(f'No .xlsx files found for environment {env_code} in {folder}')
+    return file_path
+
+
+def get_environments_paths(env_codes: list,
+                           base_path: str = 'Q:/Selenium_Reports',
+                           by_date: bool = False,
+                           days_ago: int = 1) -> dict:
+    '''Return file Paths for each environment code; by_date chooses file from days_ago days before.'''
+    data = {}
+    target_date = datetime.now().date() - timedelta(days=days_ago)
+    for env in env_codes:
+        path = get_latest_xlsx_path_for_env(
+            env_code=env,
+            base_path=base_path,
+            use_date=by_date,
+            target_date=target_date
+        )
+        data[env] = path
+    return data
+
+
+def get_huggingface_paths(repo_id: str,
+                          filenames: list,
+                          revision: str = 'main') -> dict:
+    '''Download files from a Huggingface repo and return local Paths without loading.'''
+    if hf_hub_download is None:
+        raise ImportError('huggingface_hub is not installed. Please pip install huggingface_hub')
+    data = {}
+    for fname in filenames:
+        local_path = hf_hub_download(repo_id=repo_id, filename=fname, revision=revision)
+        data[fname] = Path(local_path)
+    return data 

jira_integration.py

@@ -10,7 +10,6 @@ from datetime import datetime, timedelta
 import pandas as pd
 import requests
 import json
-from groq import Groq
 from difflib import SequenceMatcher
 import time
 
@@ -48,13 +47,10 @@ load_dotenv()
 
 # Get API keys and configuration with default values for development
 JIRA_SERVER = os.getenv("JIRA_SERVER")
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 
 # Validate required environment variables
 if not JIRA_SERVER:
     st.error("JIRA_SERVER not found in environment variables. Please check your .env file.")
-if not GROQ_API_KEY:
-    st.error("GROQ_API_KEY not found in environment variables. Please check your .env file.")
 
 def init_jira_session():
     """Initialize Jira session state variables"""
@@ -1484,102 +1480,70 @@ def display_story_points_stats(force_refresh=False):
     """Display story points statistics from current sprint"""
     if not st.session_state.jira_client:
         return
-        
-    # Initialize session state for sprint data if not exists
+
+    # Initialize sprint data cache
     if 'sprint_data' not in st.session_state:
         st.session_state.sprint_data = None
-    
-    # Initialize refresh timestamp if not exists
     if 'last_sprint_refresh' not in st.session_state:
         st.session_state.last_sprint_refresh = None
-        
-    try:
-        # Only fetch data if forced refresh, no data exists, or refresh timestamp is old
-        current_time = datetime.now()
-        refresh_needed = (
-            force_refresh or 
-            st.session_state.sprint_data is None or 
-            (st.session_state.last_sprint_refresh and 
-             (current_time - st.session_state.last_sprint_refresh).total_seconds() > 300)  # 5 minutes cache
+
+    current_time = datetime.now()
+    cache_expiry = 300  # 5 minutes
+    # Determine if a data refresh is needed
+    refresh_needed = (
+        force_refresh
+        or st.session_state.sprint_data is None
+        or (st.session_state.last_sprint_refresh
+            and (current_time - st.session_state.last_sprint_refresh).total_seconds() > cache_expiry)
+    )
+
+    if refresh_needed:
+        # Only show spinner when fetching new data
+        with st.spinner("Fetching sprint data..."):
+            board = get_regression_board("RS")
+            if not board:
+                return
+            sprint = get_current_sprint(board['id'])
+            if not sprint:
+                return
+            issues = get_sprint_issues(board['id'], sprint.id, board['estimation_field'])
+            if not issues:
+                return
+            # Calculate story points
+            _, total_points, completed_points, in_progress_points = calculate_points(
+                issues, board['estimation_field']
+            )
+            # Cache results
+            st.session_state.sprint_data = {
+                'sprint_name': sprint.name,
+                'total_points': total_points,
+                'completed_points': completed_points,
+                'in_progress_points': in_progress_points
+            }
+            st.session_state.last_sprint_refresh = current_time
+
+    # Display cached sprint data
+    if st.session_state.sprint_data:
+        sprint_data = st.session_state.sprint_data
+        cols = st.columns(4)
+        with cols[0]:
+            st.metric("Total", f"{sprint_data['total_points']:.1f}")
+        with cols[1]:
+            st.metric("Done", f"{sprint_data['completed_points']:.1f}")
+        with cols[2]:
+            st.metric("In Progress", f"{sprint_data['in_progress_points']:.1f}")
+        with cols[3]:
+            completion_rate = (
+                sprint_data['completed_points'] / sprint_data['total_points'] * 100
+                if sprint_data['total_points'] > 0 else 0
+            )
+            st.metric("Complete", f"{completion_rate:.1f}%")
+        # Show progress bar
+        progress = (
+            sprint_data['completed_points'] / sprint_data['total_points']
+            if sprint_data['total_points'] > 0 else 0
         )
-        
-        if refresh_needed:
-            with st.spinner("Fetching sprint data..."):
-                # Get regression board
-                board = get_regression_board("RS")
-                if not board:
-                    return
-                
-                # Get current sprint
-                sprint = get_current_sprint(board['id'])
-                if not sprint:
-                    return
-                
-                # Get sprint issues
-                issues = get_sprint_issues(board['id'], sprint.id, board['estimation_field'])
-                if not issues:
-                    return
-                
-                # Calculate points
-                issues_data, total_points, completed_points, in_progress_points = calculate_points(issues, board['estimation_field'])
-                
-                # Store in session state
-                st.session_state.sprint_data = {
-                    'sprint_name': sprint.name,
-                    'total_points': total_points,
-                    'completed_points': completed_points,
-                    'in_progress_points': in_progress_points,
-                    'timestamp': current_time
-                }
-                st.session_state.last_sprint_refresh = current_time
-        
-        # Display data from session state
-        if st.session_state.sprint_data:
-            sprint_data = st.session_state.sprint_data
-            
-            # Create compact metrics display using custom HTML/CSS
-            st.markdown(f"""
-                <div style='background-color: #1E1E1E; padding: 10px; border-radius: 5px; margin-bottom: 10px;'>
-                    <div style='font-size: 0.8em; color: #E0E0E0; margin-bottom: 8px;'>Current Sprint: {sprint_data['sprint_name']}</div>
-                    <div style='display: grid; grid-template-columns: repeat(4, 1fr); gap: 5px; font-size: 0.9em;'>
-                        <div style='text-align: center;'>
-                            <div style='color: #E0E0E0;'>Total</div>
-                            <div style='font-size: 1.2em; font-weight: bold;'>{sprint_data['total_points']:.1f}</div>
-                        </div>
-                        <div style='text-align: center;'>
-                            <div style='color: #E0E0E0;'>Done</div>
-                            <div style='font-size: 1.2em; font-weight: bold;'>{sprint_data['completed_points']:.1f}</div>
-                        </div>
-                        <div style='text-align: center;'>
-                            <div style='color: #E0E0E0;'>In Progress</div>
-                            <div style='font-size: 1.2em; font-weight: bold;'>{sprint_data['in_progress_points']:.1f}</div>
-                        </div>
-                        <div style='text-align: center;'>
-                            <div style='color: #E0E0E0;'>Complete</div>
-                            <div style='font-size: 1.2em; font-weight: bold;'>{(sprint_data['completed_points'] / sprint_data['total_points'] * 100) if sprint_data['total_points'] > 0 else 0:.1f}%</div>
-                        </div>
-                    </div>
-                </div>
-            """, unsafe_allow_html=True)
-            
-            # Show progress bar
-            progress = sprint_data['completed_points'] / sprint_data['total_points'] if sprint_data['total_points'] > 0 else 0
-            st.progress(progress)
-            
-            # Add refresh button with key based on timestamp to prevent rerendering
-            refresh_key = f"refresh_stats_{datetime.now().strftime('%Y%m%d%H%M%S')}"
-            if st.button("🔄 Refresh", key=refresh_key, use_container_width=True):
-                # Use a session state flag to trigger refresh on next rerun
-                st.session_state.force_sprint_refresh = True
-                st.rerun()
-                
-    except Exception as e:
-        st.error(f"Error updating story points: {str(e)}")
-        
-    # Check if we need to force refresh (from button click)
-    if 'force_sprint_refresh' in st.session_state and st.session_state.force_sprint_refresh:
-        st.session_state.force_sprint_refresh = False
-        return display_story_points_stats(force_refresh=True)
+        st.progress(progress)
 
 def main():
     st.title("Jira Integration Test")
@@ -1588,10 +1552,20 @@ def main():
     if st.button("Load Test Data"):
         st.session_state.filtered_scenarios_df = create_test_data()
         st.success("Test data loaded!")
-    
-    is_authenticated = render_jira_login()
-    
-    if is_authenticated and st.session_state.projects:
+
+    # Sidebar: Jira login control
+    with st.sidebar:
+        if 'is_authenticated' not in st.session_state:
+            st.session_state.is_authenticated = False
+        if st.session_state.is_authenticated and 'jira_client' in st.session_state and st.session_state.jira_client:
+            st.success("Connected to Jira")
+        else:
+            if st.button("Connect to Jira"):
+                is_authenticated = render_jira_login()
+                st.session_state.is_authenticated = is_authenticated
+                st.experimental_rerun()
+
+    if st.session_state.get('is_authenticated', False) and st.session_state.get('projects'):
         # Fixed project and board selection
         project_key = "RS"
         board_type = "scrum"

multiple.py

@@ -25,6 +25,29 @@ import os
 from dotenv import load_dotenv
 import json
 import logging
+
+# Inject CSS to shrink metric font sizes and padding to prevent ellipsis overflow
+if __name__ == "__main__":
+    st.markdown("""
+<style>
+  [data-testid="metric-container"] {
+    padding: 0.25rem 0.5rem !important;
+    min-width: 80px !important;
+    overflow: visible !important;
+  }
+  [data-testid="metric-container"] div {
+    white-space: nowrap !important;
+    text-overflow: clip !important;
+  }
+  [data-testid="metric-value"] {
+    font-size: 0.8rem !important;
+  }
+  [data-testid="metric-label"] {
+    font-size: 0.6rem !important;
+  }
+</style>
+""", unsafe_allow_html=True)
+
 load_dotenv()
 JIRA_SERVER = os.getenv("JIRA_SERVER")
 # Initialize session state variables
@@ -237,21 +260,18 @@ def perform_analysis(uploaded_dataframes):
                 grouped_filtered_scenarios.index = range(1, len(grouped_filtered_scenarios) + 1)
                 st.dataframe(grouped_filtered_scenarios)
 
-            # Show task creation button if:
-            # 1. User is authenticated
-            # 2. Status is Failed
-            # 3. Exactly one functional area is selected (not "All")
-            if ('jira_client' in st.session_state and 
+            # Task creation section: always show button placeholder with tooltip, enabling only when conditions are met
+            can_create_task = (
+                'jira_client' in st.session_state and 
                 st.session_state.jira_client and 
                 selected_status == 'Failed' and 
                 len(selected_functional_areas) == 1 and 
-                "All" not in selected_functional_areas):
-                
-                # If we have a recently created task, show the success message first
+                "All" not in selected_functional_areas
+            )
+            col1, col2, col3 = st.columns([1, 2, 1])
+            with col2:
                 if st.session_state.show_success and st.session_state.last_task_key:
                     st.success("✅ Task created successfully!")
-                    
-                    # Display task link in a more prominent way
                     st.markdown(
                         f"""
                         <div style='padding: 10px; border-radius: 5px; border: 1px solid #90EE90; margin: 10px 0;'>
@@ -266,46 +286,42 @@ def perform_analysis(uploaded_dataframes):
                         """,
                         unsafe_allow_html=True
                     )
-                    
-                    # Add a button to create another task
-                    col1, col2, col3 = st.columns([1, 2, 1])
-                    with col2:
-                        if st.button("Create Another Task", key="create_another", use_container_width=True):
-                            # Clear all task-related state
-                            st.session_state.task_content = None
-                            st.session_state.last_task_key = None
-                            st.session_state.last_task_url = None
-                            st.session_state.show_success = False
-                            st.rerun()
+                    if st.button("Create Another Task", key="create_another", use_container_width=True):
+                        st.session_state.task_content = None
+                        st.session_state.last_task_key = None
+                        st.session_state.last_task_url = None
+                        st.session_state.show_success = False
+                        st.rerun()
                 else:
-                    environment = filtered_scenarios['Environment'].iloc[0]
-                    # Create columns for compact layout
-                    col1, col2, col3 = st.columns([1, 2, 1])
-                    with col2:
-                        if st.button("📝 Log Jira Task", use_container_width=True):
-                            st.write("Debug: Button clicked")  # Debug line
-                            # Use the properly structured DataFrame for task creation
-                            task_df = grouped_filtered_scenarios.copy()
-                            expected_columns = [
-                                'Environment',
-                                'Functional area',
-                                'Scenario Name',
-                                'Error Message',
-                                'Failed Step',
-                                'Time spent(m:s)',
-                                'Start datetime'
-                            ]
-                            missing_columns = [col for col in expected_columns if col not in task_df.columns]
-                            if missing_columns:
-                                st.error(f"Missing required columns: {', '.join(missing_columns)}")
-                                st.error("Please ensure your data includes all required columns")
-                                return
-                            
-                            # Generate task content
-                            summary, description = generate_task_content(task_df)
-                            if summary and description:
-                                # Call the task creation function
-                                handle_task_button_click(summary, description, environment, task_df)
+                    help_text = (
+                        "Requires: Jira login, 'Failed' status selected, "
+                        "and exactly one functional area (not 'All')."
+                    )
+                    if st.button(
+                        "📝 Log Jira Task",
+                        disabled=not can_create_task,
+                        use_container_width=True,
+                        help=help_text
+                    ) and can_create_task:
+                        environment = filtered_scenarios['Environment'].iloc[0]
+                        task_df = grouped_filtered_scenarios.copy()
+                        expected_columns = [
+                            'Environment',
+                            'Functional area',
+                            'Scenario Name',
+                            'Error Message',
+                            'Failed Step',
+                            'Time spent(m:s)',
+                            'Start datetime'
+                        ]
+                        missing_columns = [col for col in expected_columns if col not in task_df.columns]
+                        if missing_columns:
+                            st.error(f"Missing required columns: {', '.join(missing_columns)}")
+                            st.error("Please ensure your data includes all required columns")
+                            return
+                        summary, description = generate_task_content(task_df)
+                        if summary and description:
+                            handle_task_button_click(summary, description, environment, task_df)
 
             # Check if selected_status is 'Failed' and show bar graph
             if selected_status != 'Passed':
@@ -329,8 +345,19 @@ def perform_analysis(uploaded_dataframes):
                     # Display individual numbers on y-axis
                     for bar in bars:
                         height = bar.get_height()
-                        plt.text(bar.get_x() + bar.get_width() / 2, height, str(int(height)),
-                                ha='center', va='bottom')  # Reduce font size of individual numbers
+                        # Annotate bar height, defaulting to 0 if conversion fails
+                        try:
+                            # Ensure numeric conversion in case of string 'NaN'
+                            h_int = int(float(height))
+                        except Exception:
+                            h_int = 0
+                        plt.text(
+                            bar.get_x() + bar.get_width() / 2,
+                            height,
+                            str(h_int),
+                            ha='center',
+                            va='bottom'
+                        )  # Reduce font size of individual numbers
 
                     plt.tight_layout()  # Add this line to adjust layout
                     st.pyplot(plt)
@@ -339,62 +366,103 @@ def perform_analysis(uploaded_dataframes):
     pass
 
 def display_story_points_stats(force_refresh=False):
-    """Display story points statistics from current sprint"""
+    """Display story points statistics from current sprint with caching"""
     if not st.session_state.jira_client:
         return
-        
-    try:
-        with st.spinner("Fetching sprint data..."):
-            # Get regression board
+
+    # Initialize cache
+    if 'sprint_data_cache' not in st.session_state:
+        st.session_state.sprint_data_cache = None
+    if 'last_sprint_fetch' not in st.session_state:
+        st.session_state.last_sprint_fetch = None
+
+    now = datetime.now()
+    cache_expiry = 300  # 5 minutes
+    refresh_needed = (
+        force_refresh
+        or st.session_state.sprint_data_cache is None
+        or (st.session_state.last_sprint_fetch
+            and (now - st.session_state.last_sprint_fetch).total_seconds() > cache_expiry)
+    )
+
+    if refresh_needed:
+        if force_refresh:
+            with st.spinner("Fetching sprint data..."):
+                board = get_regression_board("RS")
+                if not board:
+                    return
+                sprint = get_current_sprint(board['id'])
+                if not sprint:
+                    return
+                issues = get_sprint_issues(board['id'], sprint.id, board['estimation_field'])
+                if not issues:
+                    return
+                _, total_points, completed_points, in_progress_points = calculate_points(
+                    issues, board['estimation_field']
+                )
+                st.session_state.sprint_data_cache = {
+                    'sprint_name': sprint.name,
+                    'total_points': total_points,
+                    'completed_points': completed_points,
+                    'in_progress_points': in_progress_points
+                }
+                st.session_state.last_sprint_fetch = now
+        else:
+            # Fetch data silently without spinner
             board = get_regression_board("RS")
             if not board:
                 return
-            
-            # Get current sprint
             sprint = get_current_sprint(board['id'])
             if not sprint:
                 return
-            
-            # Get sprint issues
             issues = get_sprint_issues(board['id'], sprint.id, board['estimation_field'])
             if not issues:
                 return
-            
-            # Calculate points
-            issues_data, total_points, completed_points, in_progress_points = calculate_points(issues, board['estimation_field'])
-            
-            # Update session state
-            st.session_state.total_story_points = total_points
-            st.session_state.completed_points = completed_points
-            
-            # Create compact metrics display
-            metrics_container = st.container()
-            with metrics_container:
-                # Show sprint info
-                st.info(f"Current Sprint: {sprint.name}")
-                
-                # Show metrics in a compact format
-                cols = st.columns(4)
-                with cols[0]:
-                    st.metric("Total", f"{total_points:.1f}")
-                with cols[1]:
-                    st.metric("Done", f"{completed_points:.1f}")
-                with cols[2]:
-                    st.metric("In Progress", f"{in_progress_points:.1f}")
-                with cols[3]:
-                    completion_rate = (completed_points / total_points * 100) if total_points > 0 else 0
-                    st.metric("Complete", f"{completion_rate:.1f}%")
-                
-                # Show progress bar
-                progress = completed_points / total_points if total_points > 0 else 0
-                st.progress(progress)
-                
-                # Add refresh button
-                if st.button("🔄 Refresh", key="refresh_stats", use_container_width=True):
-                    st.session_state.last_refresh = datetime.now()
-                    return
-    except Exception as e:
-        st.error(f"Error updating story points: {str(e)}")
+            _, total_points, completed_points, in_progress_points = calculate_points(
+                issues, board['estimation_field']
+            )
+            st.session_state.sprint_data_cache = {
+                'sprint_name': sprint.name,
+                'total_points': total_points,
+                'completed_points': completed_points,
+                'in_progress_points': in_progress_points
+            }
+            st.session_state.last_sprint_fetch = now
+
+    # Display cached sprint data
+    if st.session_state.sprint_data_cache:
+        sprint_data = st.session_state.sprint_data_cache
+
+        # Use markdown with custom HTML for a compact, non-truncating display
+        metrics_html = f"""
+        <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; text-align: center; font-size: 0.8rem;">
+            <div>
+                <div style="color: #888;">Total</div>
+                <div style="font-size: 1rem; font-weight: bold;">{sprint_data['total_points']:.1f}</div>
+            </div>
+            <div>
+                <div style="color: #888;">Done</div>
+                <div style="font-size: 1rem; font-weight: bold;">{sprint_data['completed_points']:.1f}</div>
+            </div>
+            <div>
+                <div style="color: #888;">In Progress</div>
+                <div style="font-size: 1rem; font-weight: bold;">{sprint_data['in_progress_points']:.1f}</div>
+            </div>
+            <div>
+                <div style="color: #888;">Complete</div>
+                <div style="font-size: 1rem; font-weight: bold;">{(
+                    sprint_data['completed_points'] / sprint_data['total_points'] * 100
+                    if sprint_data['total_points'] > 0 else 0
+                ):.1f}%</div>
+            </div>
+        </div>
+        """
+        st.markdown(metrics_html, unsafe_allow_html=True)
+
+        st.progress(
+            sprint_data['completed_points'] / sprint_data['total_points']
+            if sprint_data['total_points'] > 0 else 0
+        )
 
 def show_task_creation_section(filtered_df, environment):
     """Display the task creation section with detailed functional area mapping information."""
@@ -475,39 +543,9 @@ def multiple_main():
     if 'filtered_scenarios_df' not in st.session_state:
         st.session_state.filtered_scenarios_df = None
 
-    if 'jira_server' not in st.session_state:
-        st.session_state.jira_server = JIRA_SERVER
-    # Initialize session state for sprint data if not exists
     if 'sprint_data_initialized' not in st.session_state:
         st.session_state.sprint_data_initialized = False
     
-    # Add Jira login to sidebar (only once)
-    with st.sidebar:
-        st.subheader("Jira Integration (Optional)")
-        
-        # Only render login if not already authenticated
-        if 'is_authenticated' not in st.session_state:
-            st.session_state.is_authenticated = render_jira_login()
-        else:
-            # Just display the status without re-rendering the login
-            if st.session_state.is_authenticated:
-                st.success("Connected to Jira")
-            else:
-                # Allow re-login if not authenticated
-                st.session_state.is_authenticated = render_jira_login()
-        
-        # Only show story points in sidebar if authenticated
-        if st.session_state.is_authenticated and st.session_state.jira_client:
-            st.markdown("---")
-            st.subheader("Sprint Progress")
-            
-            # Only fetch sprint data once or when refresh is clicked
-            if not st.session_state.sprint_data_initialized:
-                display_story_points_stats(force_refresh=True)
-                st.session_state.sprint_data_initialized = True
-            else:
-                display_story_points_stats(force_refresh=False)
-    
     st.title("Multiple File Analysis")
     
     # Initialize session state for uploaded data

multiple_env_loader.py

@@ -0,0 +1,120 @@
+# Use default Streamlit page configuration
+import streamlit as st
+
+# Configure the Streamlit app to use a wide layout for maximum content width
+st.set_page_config(layout="wide")
+
+def main():
+    from pathlib import Path
+    from datetime import datetime, timedelta
+    from pre import preprocess_uploaded_file
+    from environment_loader import get_environments_paths
+    from multiple import perform_analysis
+
+    # Sidebar: Environment selection and loading options
+    st.sidebar.header("Auto Environment Loader")
+    base_path = st.sidebar.text_input("Base folder path", "Q:/Selenium_Reports")
+
+    # Dynamically discover available environment folders
+    env_root = Path(base_path)
+    try:
+        env_codes = [p.name for p in env_root.iterdir() if p.is_dir()]
+    except Exception:
+        env_codes = []
+        st.sidebar.error(f"Could not list environments under {base_path}")
+
+    selected_envs = st.sidebar.multiselect("Select environments to load", env_codes)
+    # For envs ending with 'FIN', let user pick one of the 3 most recent files
+    version_selection = {}
+    for env in selected_envs:
+        # Only FIN environments get manual version selection
+        if env.upper().endswith('FIN'):
+            folder = Path(base_path) / env / 'XLSX'
+            if not folder.exists():
+                st.sidebar.warning(f"No folder found for environment {env}: {folder}")
+                continue
+            # List the 3 most recent files
+            recent_files = sorted(folder.glob('*.xlsx'), key=lambda f: f.stat().st_mtime, reverse=True)[:3]
+            if not recent_files:
+                st.sidebar.warning(f"No .xlsx files found for environment {env}")
+                continue
+            labels = [f.name for f in recent_files]
+            choice = st.sidebar.selectbox(f"Select version for {env}", labels, index=0, key=f"select_{env}")
+            version_selection[env] = folder / choice
+
+    # Initialize session state for incremental loading
+    if 'loaded_envs' not in st.session_state:
+        st.session_state.loaded_envs = []
+    if 'uploaded_env_data' not in st.session_state:
+        st.session_state.uploaded_env_data = {}
+
+    if st.sidebar.button("Load Latest Files", use_container_width=True):
+        if not selected_envs:
+            st.sidebar.warning("Please select at least one environment to load.")
+        else:
+            # Determine which environments are new
+            new_envs = [env for env in selected_envs if env not in st.session_state.loaded_envs]
+            if not new_envs:
+                st.sidebar.info("✅ All selected environments are already loaded.")
+                return
+            # Build paths: manual picks for FIN envs, auto for others
+            paths = {}
+            missing = []
+            fin_envs = [env for env in new_envs if env.upper().endswith('FIN')]
+            non_fin = [env for env in new_envs if not env.upper().endswith('FIN')]
+            # FIN envs must have manual selection
+            for env in fin_envs:
+                path = version_selection.get(env)
+                if not path:
+                    missing.append(env)
+                else:
+                    paths[env] = path
+            if missing:
+                st.sidebar.error(f"Please select a file version for: {', '.join(missing)}")
+                return
+            # Auto-load latest for non-FIN envs
+            if non_fin:
+                auto_paths = get_environments_paths(non_fin, base_path=base_path)
+                paths.update(auto_paths)
+            try:
+                dfs = []
+                loaded = []
+                failed = []
+                # Preprocess each new file, tracking success/failure
+                for env, path in paths.items():
+                    try:
+                        df = preprocess_uploaded_file(path)
+                        dfs.append(df)
+                        loaded.append((env, path))
+                    except Exception as e:
+                        failed.append((env, path, e))
+
+                # Show ticks for successful and failed loads
+                if loaded:
+                    st.sidebar.markdown("**✅ Successfully loaded:**")
+                    for env, path in loaded:
+                        st.sidebar.markdown(f"- ✅ {env}: `{path}`")
+                if failed:
+                    st.sidebar.markdown("**❌ Failed to load:**")
+                    for env, path, e in failed:
+                        st.sidebar.markdown(f"- ❌ {env}: `{path}` ({e})")
+
+                # Update session state with new loaded data
+                for (env, _), df in zip(loaded, dfs):
+                    st.session_state.uploaded_env_data[env] = df
+                    st.session_state.loaded_envs.append(env)
+                # Build combined list of DataFrames for analysis
+                st.session_state.uploaded_data = list(st.session_state.uploaded_env_data.values())
+            except Exception as e:
+                st.sidebar.error(str(e))
+
+    # Main: run analysis if data is loaded
+    st.title("Multiple File Analysis (Auto Env Loader)")
+    if 'uploaded_data' in st.session_state and st.session_state.uploaded_data:
+        perform_analysis(st.session_state.uploaded_data)
+    else:
+        st.info("Use the sidebar to select environments and load their latest files for analysis.")
+
+
+if __name__ == "__main__":
+    main() 

pre.py

@@ -43,18 +43,28 @@ def preprocess_xlsx(uploaded_file):
         'Failed Scenario': 'string'
     }
     
-    # Read both the first sheet for error messages and "Time Taken" sheet
-    excel_file = pd.ExcelFile(uploaded_file, engine='openpyxl')
-    
-    # Read detailed step data from first sheet (contains error messages)
-    error_df = pd.read_excel(excel_file, sheet_name=0)
-    
-    # Read time taken data from the "Time Taken" sheet
-    df = pd.read_excel(
-        excel_file,
-        sheet_name='Time Taken',
-        dtype=dtype_dict
-    )
+    # Attempt fast streaming read (read_only) for performance
+    fast_excel = pd.ExcelFile(uploaded_file, engine='openpyxl')
+    # Read first sheet (error messages)
+    error_df = pd.read_excel(fast_excel, sheet_name=0)
+    # Read 'Time Taken' sheet in fast mode
+    df = pd.read_excel(fast_excel, sheet_name='Time Taken', dtype=object)
+
+    # If the sheet appears truncated (e.g., only header row) or missing expected columns, retry in full mode
+    if df.shape[0] <= 1 or 'Total Time Taken (ms)' not in df.columns:
+        st.warning("Fast Excel read produced incomplete data; retrying in full mode.")
+        slow_excel = pd.ExcelFile(
+            uploaded_file,
+            engine='openpyxl',
+            engine_kwargs={
+                'read_only': False,
+                'data_only': True,
+                'keep_links': False
+            }
+        )
+        # Reload both sheets in full mode
+        error_df = pd.read_excel(slow_excel, sheet_name=0)
+        df = pd.read_excel(slow_excel, sheet_name='Time Taken', dtype=object)
     
     # Print column names and sample values for debugging
     # st.write("Excel columns:", df.columns.tolist())
@@ -66,9 +76,13 @@ def preprocess_xlsx(uploaded_file):
     # empty_features = df['Feature Name'].isna().sum()
     # st.write(f"Empty Feature Names: {empty_features}")
     
-    # Convert Failed Scenario column to boolean after reading
-    # Handle different possible values (TRUE/FALSE, True/False, etc.)
+    # Convert specific columns after reading as object
+    df['Total Time Taken (ms)'] = pd.to_numeric(df['Total Time Taken (ms)'], errors='coerce').fillna(0).astype('float64')
     df['Failed Scenario'] = df['Failed Scenario'].astype(str).str.upper()
+    # Ensure Feature Name and Scenario Name are strings, handling potential NaNs read as objects
+    df['Feature Name'] = df['Feature Name'].astype(str).fillna('Unknown') 
+    df['Scenario Name'] = df['Scenario Name'].astype(str)
+
     df['Status'] = df['Failed Scenario'].map(
         lambda x: 'FAILED' if x in ['TRUE', 'YES', 'Y', '1'] else 'PASSED'
     )
@@ -132,8 +146,9 @@ def preprocess_xlsx(uploaded_file):
     # Add environment column
     result_df['Environment'] = environment
     
-    # Calculate formatted time spent
-    result_df['Time spent(m:s)'] = pd.to_datetime(result_df['Time spent'], unit='s').dt.strftime('%M:%S')
+    # Calculate formatted time spent (coerce non-numeric values)
+    _secs = pd.to_numeric(result_df['Time spent'], errors='coerce')
+    result_df['Time spent(m:s)'] = pd.to_datetime(_secs, unit='s', errors='coerce').dt.strftime('%M:%S')
     
     
     result_df['Start datetime'] = pd.to_datetime(file_date)
@@ -154,8 +169,14 @@ def preprocess_xlsx(uploaded_file):
         result_df = result_df.merge(start_times, on='Scenario Name', how='left')
         result_df.rename(columns={'Time Stamp': 'Scenario Start Time'}, inplace=True)
         scenario_start_times = result_df['Scenario Start Time']
-        # Combine the date from the filename with the time stamp
-        result_df['Start datetime'] = pd.to_datetime(scenario_start_times.dt.strftime('%H:%M:%S') + ' ' + file_date.strftime('%Y-%m-%d'))
+        # Combine time and date strings, then parse with explicit format to prevent mismatches
+        combined = scenario_start_times.dt.strftime('%H:%M:%S') + ' ' + file_date.strftime('%Y-%m-%d')
+        # Let pandas infer the datetime format and coerce invalid parses
+        result_df['Start datetime'] = pd.to_datetime(
+            combined,
+            infer_datetime_format=True,
+            errors='coerce'
+        )
     
     # Print counts for debugging
     # st.write(f"Processed data - Failed: {len(result_df[result_df['Status'] == 'FAILED'])}, Passed: {len(result_df[result_df['Status'] == 'PASSED'])}")
@@ -194,7 +215,9 @@ def preprocess_uploaded_file(uploaded_file):
         data['Start datetime'] = pd.to_datetime(data['Start datetime'], dayfirst=True, errors='coerce')
         data['End datetime'] = pd.to_datetime(data['End datetime'], dayfirst=True, errors='coerce')
         data['Time spent'] = (data['End datetime'] - data['Start datetime']).dt.total_seconds()
-        data['Time spent(m:s)'] = pd.to_datetime(data['Time spent'], unit='s').dt.strftime('%M:%S')
+        ## Format time spent for CSV branch (coerce non-numeric values)
+        _secs = pd.to_numeric(data['Time spent'], errors='coerce')
+        data['Time spent(m:s)'] = pd.to_datetime(_secs, unit='s', errors='coerce').dt.strftime('%M:%S')
         
         # Extract environment name from filename
         filename = uploaded_file.name