Create app.py

app.py

@@ -0,0 +1,802 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import io, base64, datetime, re
+from collections import Counter
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
+def get_first_row_totals(df, group_column):
+    """Get the GenAI efficiency hours from the first row of each group"""
+    first_row_totals = {}
+    for group_value in df[group_column].unique():
+        group_rows = df[df[group_column] == group_value]
+        if not group_rows.empty:
+            first_row_totals[group_value] = group_rows.iloc[0]['GenAI Efficiency (Log time in hours)']
+    return first_row_totals
+
+def create_unique_work_items(df):
+    """Create unique work identifiers to avoid double counting"""
+    analysis_df = df.copy()
+    if 'Key' in analysis_df.columns and 'Project' in analysis_df.columns:
+        analysis_df['UniqueWorkID'] = analysis_df.apply(lambda row: f"{row['Project']}_{row['Key']}", axis=1)
+    elif all(col in analysis_df.columns for col in ['Date', 'Worklog', 'User']):
+        analysis_df['UniqueWorkID'] = analysis_df.apply(lambda row: f"{row['Project']}_{row['Date']}_{row['Worklog']}_{row['User']}", axis=1)
+    return analysis_df
+
+def calculate_champion_score(descriptions, project_data=None):
+    """Calculate champion score based on Tools (20%), Use-case (30%), Prompt (30%), Outcome (20%)"""
+    if not descriptions or not any(pd.notnull(desc) for desc in descriptions):
+        return 0
+    
+    # Filter and join descriptions
+    valid_descriptions = [desc for desc in descriptions if pd.notnull(desc) and str(desc).strip()]
+    if not valid_descriptions:
+        return 0
+    
+    combined_desc = "\n".join(str(desc) for desc in valid_descriptions)
+    combined_desc_lower = combined_desc.lower()
+    
+    # Tools score (20%)
+    tools_score = 0
+    ai_tools = ['gpt', 'chatgpt', 'claude', 'gemini', 'copilot', 'dall-e', 'midjourney', 'stable diffusion', 
+                'hugging face', 'llama', 'mistral', 'bard', 'anthropic']
+    tools_mentioned = sum(1 for tool in ai_tools if re.search(r'\b' + re.escape(tool) + r'\b', combined_desc_lower))
+    
+    if tools_mentioned == 1:
+        tools_score = 10
+    elif tools_mentioned >= 2:
+        tools_score = 15
+    if re.search(r'\b(gpt-4|gpt-3.5|claude-2|claude-instant|gemini pro)\b', combined_desc_lower):
+        tools_score += 5
+    tools_score = min(tools_score, 20)
+    
+    # Use-case score (30%)
+    use_case_score = 0
+    use_case_keywords = {
+        'code generation': ['code', 'coding', 'script', 'programming', 'develop'],
+        'content creation': ['content', 'write', 'writing', 'draft', 'article'],
+        'data analysis': ['data', 'analysis', 'analyze', 'metrics', 'statistics'],
+        'problem solving': ['problem', 'solution', 'solve', 'issue', 'challenge'],
+        'summarization': ['summary', 'summarize', 'summarization', 'extract'],
+        'research': ['research', 'study', 'investigate', 'literature', 'information'],
+        'automation': ['automate', 'automation', 'workflow', 'process']
+    }
+    
+    use_cases_found = sum(1 for _, keywords in use_case_keywords.items() 
+                         if any(re.search(r'\b' + re.escape(keyword) + r'\b', combined_desc_lower) for keyword in keywords))
+    use_case_score += min(use_cases_found * 5, 15)
+    
+    if re.search(r'\bfor\s+(a|an|the)\s+\w+', combined_desc_lower) or re.search(r'\bto\s+\w+\s+the\s+\w+', combined_desc_lower):
+        use_case_score += 5
+    
+    domain_terms = ['frontend', 'backend', 'api', 'database', 'ui', 'ux', 'algorithm', 'component', 'feature']
+    if any(re.search(r'\b' + re.escape(term) + r'\b', combined_desc_lower) for term in domain_terms):
+        use_case_score += 5
+    
+    if re.search(r'\bproject\b|\btask\b|\bticket\b|\bissue\b|\bstory\b', combined_desc_lower):
+        use_case_score += 5
+    
+    use_case_score = min(use_case_score, 30)
+    
+    # Prompt quality score (30%)
+    prompt_score = 0
+    if len(combined_desc) > 500:
+        prompt_score += 10
+    elif len(combined_desc) > 200:
+        prompt_score += 5
+    
+    if re.search(r'".*?"|\bprompt\b|\'.*?\'|\bassist\b|\bcreate\b|\bgenerate\b', combined_desc_lower):
+        prompt_score += 10
+    
+    prompt_techniques = ['step by step', 'chain of thought', 'few-shot', 'zero-shot', 'example']
+    techniques_found = sum(1 for technique in prompt_techniques 
+                          if re.search(r'\b' + re.escape(technique) + r'\b', combined_desc_lower))
+    prompt_score += min(techniques_found * 2, 10)
+    prompt_score = min(prompt_score, 30)
+    
+    # Outcome/iteration score (20%)
+    outcome_score = 0
+    outcome_keywords = ['result', 'output', 'generated', 'created', 'produced', 'improved']
+    outcomes_found = sum(1 for keyword in outcome_keywords 
+                        if re.search(r'\b' + re.escape(keyword) + r'\b', combined_desc_lower))
+    outcome_score += min(outcomes_found * 2, 10)
+    
+    iteration_keywords = ['iteration', 'refine', 'revise', 'update', 'modify', 'enhance', 'feedback']
+    iterations_found = sum(1 for keyword in iteration_keywords 
+                          if re.search(r'\b' + re.escape(keyword) + r'\b', combined_desc_lower))
+    outcome_score += min(iterations_found * 2, 5)
+    
+    if re.search(r'\d+%|\d+\s*hours|\d+\s*minutes|reduced by|increased by', combined_desc_lower):
+        outcome_score += 5
+    
+    outcome_score = min(outcome_score, 20)
+    
+    return tools_score + use_case_score + prompt_score + outcome_score
+
+def process_genai_data(df):
+    """Process GenAI data at the user level, ensuring no duplication of hours"""
+    # Create unique users DataFrame
+    unique_users = df['User'].drop_duplicates().reset_index(drop=True)
+    result_df = pd.DataFrame(unique_users, columns=['User'])
+    
+    # Get descriptions for each user
+    result_df['GenAI_Descriptions'] = result_df['User'].apply(
+        lambda user: "\n".join(["- " + str(desc) for desc in df[df['User'] == user]['GenAI use case description'].dropna().unique()]) 
+        if len(df[df['User'] == user]['GenAI use case description'].dropna().unique()) > 0 else ""
+    )
+    
+    # Calculate metrics using unique combinations
+    def get_unique_metric_sum(user, metric_col):
+        user_data = df[df['User'] == user].copy()
+        
+        if all(col in user_data.columns for col in ['Project', 'Key']):
+            user_data['UniqueID'] = user_data.apply(lambda row: f"{row['Project']}_{row['Key']}", axis=1)
+            return user_data.drop_duplicates('UniqueID')[metric_col].sum()
+        elif all(col in user_data.columns for col in ['Date', 'Project', 'Worklog']):
+            user_data['UniqueID'] = user_data.apply(lambda row: f"{row['Project']}_{row['Date']}_{row['Worklog']}", axis=1)
+            return user_data.drop_duplicates('UniqueID')[metric_col].sum()
+        return user_data[metric_col].sum()
+    
+    result_df['GenAI_Efficiency'] = result_df['User'].apply(lambda user: get_unique_metric_sum(user, 'GenAI Efficiency (Log time in hours)'))
+    
+    if 'Logged' in df.columns:
+        result_df['Total_Logged_Hours'] = result_df['User'].apply(lambda user: get_unique_metric_sum(user, 'Logged'))
+    if 'Required' in df.columns:
+        result_df['Total_Required_Hours'] = result_df['User'].apply(lambda user: get_unique_metric_sum(user, 'Required'))
+    
+    # Calculate utilization percentage
+    if 'Total_Logged_Hours' in result_df.columns and 'Total_Required_Hours' in result_df.columns:
+        result_df['Utilization_Percentage'] = (result_df['Total_Logged_Hours'] / result_df['Total_Required_Hours'] * 100).round(2)
+    
+    # Get date range for each user
+    if 'Date' in df.columns:
+        result_df['Date_Range'] = result_df['User'].apply(
+            lambda user: f"{min(dates)} to {max(dates)}" if 
+            len(dates := df[df['User'] == user]['Date'].dropna()) > 0 else "N/A"
+        )
+    
+    # Add champion score for each user
+    result_df['Description_Quality_Score'] = result_df['GenAI_Descriptions'].apply(
+        lambda desc: calculate_champion_score([desc]) if isinstance(desc, str) and desc.strip() else 0
+    )
+    
+    # Get project and category data if available
+    if 'Project' in df.columns:
+        result_df['Projects'] = result_df['User'].apply(
+            lambda user: list(df[df['User'] == user]['Project'].dropna().unique())
+        )
+    
+    if 'Project Category' in df.columns:
+        result_df['Project_Categories'] = result_df['User'].apply(
+            lambda user: list(df[df['User'] == user]['Project Category'].dropna().unique())
+        )
+    
+    return result_df
+
+def analyze_projects_by_genai_hours(df, exclude_qed42_global=False):
+    """Analyzes projects by GenAI hours with quality metrics"""
+    if 'Project' not in df.columns:
+        return None
+    
+    # Get first row totals for each project
+    project_totals = get_first_row_totals(df, 'Project')
+    
+    # Calculate project data using unique work items
+    analysis_df = create_unique_work_items(df)
+    
+    # Filter out QED42 Global projects if requested
+    if exclude_qed42_global:
+        analysis_df = analysis_df[~analysis_df['Project'].str.contains('QED42 Global', case=False, na=False)]
+        project_totals = {k: v for k, v in project_totals.items() if 'qed42 global' not in k.lower()}
+    
+    projects_data = []
+    for project in analysis_df['Project'].unique():
+        if project in project_totals:
+            total_hours = project_totals[project]
+            user_count = len(analysis_df[analysis_df['Project'] == project]['User'].unique())
+            
+            # Get project category if available
+            project_category = 'Unknown'
+            if 'Project Category' in analysis_df.columns:
+                project_category_series = analysis_df[analysis_df['Project'] == project]['Project Category'].dropna()
+                if not project_category_series.empty:
+                    project_category = project_category_series.iloc[0]
+            
+            # Get best description for this project
+            project_descriptions = analysis_df[analysis_df['Project'] == project]['GenAI use case description'].dropna().tolist()
+            best_description = max(project_descriptions, key=lambda x: len(str(x))) if project_descriptions else ""
+            champion_score = calculate_champion_score(project_descriptions)
+            
+            projects_data.append({
+                'Project': project,
+                'Total_GenAI_Hours': total_hours,
+                'User_Count': user_count,
+                'Project Category': project_category,
+                'Best_Description': best_description,
+                'Champion_Score': champion_score
+            })
+    
+    # Create DataFrame from projects data
+    project_hours = pd.DataFrame(projects_data) if projects_data else pd.DataFrame()
+    
+    # Add combined scores
+    if not project_hours.empty:
+        max_hours = project_hours['Total_GenAI_Hours'].max() or 1
+        max_quality = project_hours['Champion_Score'].max() or 1
+        
+        project_hours['Hours_Score'] = (project_hours['Total_GenAI_Hours'] / max_hours) * 100
+        project_hours['Quality_Score_Normalized'] = (project_hours['Champion_Score'] / max_quality) * 100
+        project_hours['Combined_Score'] = (project_hours['Hours_Score'] * 0.6) + (project_hours['Quality_Score_Normalized'] * 0.4)
+        
+        project_hours = project_hours.sort_values('Combined_Score', ascending=False)
+    
+    return project_hours
+
+def extract_ai_tools_from_descriptions(df):
+    """Extracts AI tools mentioned in descriptions"""
+    ai_tools = [
+        'chatgpt', 'gpt-4', 'gpt-3', 'gpt', 'openai', 'claude', 'anthropic', 
+        'gemini', 'bard', 'google ai', 'copilot', 'github copilot', 'microsoft copilot',
+        'dall-e', 'midjourney', 'stable diffusion', 'hugging face', 'transformers',
+        'bert', 'llama', 'mistral', 'tensorflow', 'pytorch', 'ml',
+        'jupyter', 'colab', 'langchain', 'llm', 'rag'
+    ]
+    
+    tool_mapping = {
+        'gpt': 'ChatGPT/GPT', 'gpt-3': 'ChatGPT/GPT', 'gpt-4': 'ChatGPT/GPT', 'chatgpt': 'ChatGPT/GPT',
+        'openai': 'OpenAI', 'claude': 'Claude', 'anthropic': 'Claude',
+        'gemini': 'Google AI', 'bard': 'Google AI', 'google ai': 'Google AI',
+        'copilot': 'GitHub Copilot', 'github copilot': 'GitHub Copilot'
+    }
+    
+    all_descriptions = df['GenAI use case description'].dropna()
+    if all_descriptions.empty:
+        return Counter()
+        
+    all_descriptions_text = " ".join(all_descriptions.astype(str)).lower()
+    
+    tool_counts = Counter()
+    for tool in ai_tools:
+        count = len(re.findall(r'\b' + re.escape(tool) + r'\b', all_descriptions_text))
+        if count > 0:
+            normalized_tool = tool_mapping.get(tool, tool)
+            tool_counts[normalized_tool] += count
+    
+    return tool_counts
+
+def extract_use_cases_from_descriptions(df):
+    """Analyzes use cases in GenAI descriptions"""
+    use_case_keywords = {
+        'Code Generation': ['code', 'coding', 'programming', 'script', 'develop', 'algorithm'],
+        'Content Creation': ['content', 'write', 'writing', 'draft', 'article', 'blog'],
+        'Data Analysis': ['data', 'analysis', 'analyze', 'analytics', 'statistics', 'insights'],
+        'Documentation': ['document', 'documentation', 'manual', 'guide', 'readme'],
+        'Research': ['research', 'study', 'investigate', 'explore', 'literature'],
+        'Summarization': ['summary', 'summarize', 'summarization', 'extract'],
+        'Translation': ['translate', 'translation', 'language', 'localize']
+    }
+    
+    descriptions = df['GenAI use case description'].dropna()
+    if descriptions.empty:
+        return Counter()
+        
+    descriptions_list = descriptions.astype(str).tolist()
+    
+    use_case_counts = Counter()
+    for description in descriptions_list:
+        description_lower = description.lower()
+        for use_case, keywords in use_case_keywords.items():
+            if any(re.search(r'\b' + re.escape(keyword) + r'\b', description_lower) for keyword in keywords):
+                use_case_counts[use_case] += 1
+    
+    return use_case_counts
+
+def create_download_excel(df):
+    """Create Excel file for download"""
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df.to_excel(writer, index=False, sheet_name='Processed Data')
+        
+        # Add summary sheet
+        if not df.empty:
+            summary = pd.DataFrame({
+                'Metric': ['Total Users', 'Average GenAI Efficiency (hours)', 'Average Utilization (%)', 
+                          'Top GenAI User', 'Top Quality Score'],
+                'Value': [
+                    len(df),
+                    round(df['GenAI_Efficiency'].mean(), 2) if 'GenAI_Efficiency' in df.columns else 'N/A',
+                    round(df['Utilization_Percentage'].mean(), 2) if 'Utilization_Percentage' in df.columns else 'N/A',
+                    df.loc[df['GenAI_Efficiency'].idxmax(), 'User'] if 'GenAI_Efficiency' in df.columns and not df['GenAI_Efficiency'].isna().all() else 'N/A',
+                    df.loc[df['Description_Quality_Score'].idxmax(), 'User'] if 'Description_Quality_Score' in df.columns and not df['Description_Quality_Score'].isna().all() else 'N/A'
+                ]
+            })
+            summary.to_excel(writer, index=False, sheet_name='Summary')
+    
+    return output.getvalue()
+
+def create_visualizations(result_df, project_analysis, ai_tool_counts, use_case_counts):
+    """Create visualization plots"""
+    plots = []
+    
+    # 1. GenAI Efficiency by User
+    if 'GenAI_Efficiency' in result_df.columns and not result_df.empty:
+        sorted_df = result_df.sort_values('GenAI_Efficiency', ascending=False).head(10)
+        fig1 = px.bar(
+            sorted_df, 
+            x='User', 
+            y='GenAI_Efficiency',
+            title='Top 10 Users by GenAI Efficiency Hours',
+            color='GenAI_Efficiency',
+            color_continuous_scale='Viridis'
+        )
+        fig1.update_layout(xaxis_tickangle=-45)
+        plots.append(fig1)
+    
+    # 2. Project Analysis
+    if project_analysis is not None and not project_analysis.empty:
+        top_projects = project_analysis.head(8)
+        fig2 = px.bar(
+            top_projects, 
+            x='Project', 
+            y='Total_GenAI_Hours',
+            title='Top Projects by GenAI Hours',
+            color='Champion_Score',
+            color_continuous_scale='RdYlGn'
+        )
+        fig2.update_layout(xaxis_tickangle=-45)
+        plots.append(fig2)
+    
+    # 3. AI Tools Usage
+    if ai_tool_counts:
+        ai_tools_df = pd.DataFrame({
+            'Tool': list(ai_tool_counts.keys()),
+            'Mentions': list(ai_tool_counts.values())
+        }).sort_values('Mentions', ascending=False).head(8)
+        
+        fig3 = px.bar(
+            ai_tools_df, 
+            x='Tool', 
+            y='Mentions',
+            title='Most Mentioned AI Tools',
+            color='Mentions',
+            color_continuous_scale='Blues'
+        )
+        plots.append(fig3)
+    
+    # 4. Use Cases Distribution
+    if use_case_counts:
+        use_cases_df = pd.DataFrame({
+            'Use Case': list(use_case_counts.keys()),
+            'Count': list(use_case_counts.values())
+        }).sort_values('Count', ascending=False)
+        
+        fig4 = px.pie(
+            use_cases_df, 
+            names='Use Case', 
+            values='Count',
+            title='GenAI Use Cases Distribution'
+        )
+        plots.append(fig4)
+    
+    # 5. Quality Score Distribution
+    if 'Description_Quality_Score' in result_df.columns and not result_df.empty:
+        fig5 = px.histogram(
+            result_df, 
+            x='Description_Quality_Score',
+            title='Distribution of Champion Scores',
+            nbins=20,
+            color_discrete_sequence=['#2E86AB']
+        )
+        plots.append(fig5)
+    
+    # 6. Utilization Analysis
+    if 'Utilization_Percentage' in result_df.columns and not result_df.empty:
+        sorted_util = result_df.sort_values('Utilization_Percentage', ascending=False).head(10)
+        fig6 = px.bar(
+            sorted_util, 
+            x='User', 
+            y='Utilization_Percentage',
+            title='Top 10 Users by Utilization Percentage',
+            color='Utilization_Percentage',
+            color_continuous_scale='RdYlGn'
+        )
+        fig6.update_layout(xaxis_tickangle=-45)
+        plots.append(fig6)
+    
+    return plots
+
+def process_file(file):
+    """Main processing function for Gradio"""
+    if file is None:
+        return None, "Please upload a file", None, None, None, None, None, None
+    
+    try:
+        # Read the file
+        if file.name.endswith('.csv'):
+            df = pd.read_csv(file.name)
+        else:
+            df = pd.read_excel(file.name)
+        
+        # Check required columns
+        required_columns = ['User', 'GenAI use case description', 'GenAI Efficiency (Log time in hours)']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            return None, f"Missing required columns: {', '.join(missing_columns)}", None, None, None, None, None, None
+        
+        # Process the data
+        result_df = process_genai_data(df)
+        project_analysis = analyze_projects_by_genai_hours(df)
+        ai_tool_counts = extract_ai_tools_from_descriptions(df)
+        use_case_counts = extract_use_cases_from_descriptions(df)
+        
+        # Create Excel download
+        excel_data = create_download_excel(result_df)
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        excel_filename = f"genai_processed_data_{timestamp}.xlsx"
+        
+        # Save Excel file temporarily
+        with open(excel_filename, 'wb') as f:
+            f.write(excel_data)
+        
+        # Create visualizations
+        plots = create_visualizations(result_df, project_analysis, ai_tool_counts, use_case_counts)
+        
+        # Create summary statistics
+        summary_stats = create_summary_stats(result_df, project_analysis, ai_tool_counts, use_case_counts)
+        
+        # Create insights text
+        insights = create_insights_text(result_df, project_analysis, ai_tool_counts, use_case_counts)
+        
+        return (
+            result_df,
+            "Processing completed successfully!",
+            excel_filename,
+            summary_stats,
+            insights,
+            plots[0] if len(plots) > 0 else None,
+            plots[1] if len(plots) > 1 else None,
+            plots[2:] if len(plots) > 2 else []
+        )
+        
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}", None, None, None, None, None, None
+
+def create_summary_stats(result_df, project_analysis, ai_tool_counts, use_case_counts):
+    """Create summary statistics"""
+    if result_df is None or result_df.empty:
+        return "No data to analyze"
+    
+    stats = []
+    stats.append(f"**📊 Summary Statistics**")
+    stats.append(f"• Total Users: {len(result_df)}")
+    
+    if 'GenAI_Efficiency' in result_df.columns:
+        avg_efficiency = result_df['GenAI_Efficiency'].mean()
+        total_efficiency = result_df['GenAI_Efficiency'].sum()
+        stats.append(f"• Total GenAI Hours: {round(total_efficiency, 2)}")
+        stats.append(f"• Average GenAI Efficiency: {round(avg_efficiency, 2)} hours")
+    
+    if 'Utilization_Percentage' in result_df.columns:
+        avg_util = result_df['Utilization_Percentage'].mean()
+        stats.append(f"• Average Utilization: {round(avg_util, 2)}%")
+    
+    if 'Description_Quality_Score' in result_df.columns:
+        avg_quality = result_df['Description_Quality_Score'].mean()
+        stats.append(f"• Average Champion Score: {round(avg_quality, 1)}/100")
+    
+    if ai_tool_counts:
+        top_tool = max(ai_tool_counts.items(), key=lambda x: x[1])[0]
+        stats.append(f"• Most Used AI Tool: {top_tool}")
+    
+    if use_case_counts:
+        top_use_case = max(use_case_counts.items(), key=lambda x: x[1])[0]
+        stats.append(f"• Top Use Case: {top_use_case}")
+    
+    if project_analysis is not None and not project_analysis.empty:
+        top_project = project_analysis.iloc[0]
+        stats.append(f"• Top Project: {top_project['Project']} ({round(top_project['Total_GenAI_Hours'], 2)} hours)")
+    
+    return "\n".join(stats)
+
+def create_insights_text(result_df, project_analysis, ai_tool_counts, use_case_counts):
+    """Create insights text"""
+    if result_df is None or result_df.empty:
+        return "No insights available"
+    
+    insights = []
+    insights.append("**🔍 Key Insights**")
+    
+    # Champion user
+    if 'GenAI_Efficiency' in result_df.columns and 'Description_Quality_Score' in result_df.columns:
+        # Calculate combined score for users
+        max_hours = result_df['GenAI_Efficiency'].max() or 1
+        max_quality = result_df['Description_Quality_Score'].max() or 1
+        
+        result_df['Hours_Score'] = (result_df['GenAI_Efficiency'] / max_hours) * 100
+        result_df['Quality_Score_Normalized'] = (result_df['Description_Quality_Score'] / max_quality) * 100
+        result_df['Combined_Score'] = (result_df['Hours_Score'] * 0.6) + (result_df['Quality_Score_Normalized'] * 0.4)
+        
+        champion_user = result_df.loc[result_df['Combined_Score'].idxmax()]
+        insights.append(f"🏆 **Champion User:** {champion_user['User']}")
+        insights.append(f"   - GenAI Hours: {round(champion_user['GenAI_Efficiency'], 2)}")
+        insights.append(f"   - Champion Score: {round(champion_user['Description_Quality_Score'], 1)}/100")
+        insights.append("")
+    
+    # Project insights
+    if project_analysis is not None and not project_analysis.empty:
+        top_project = project_analysis.iloc[0]
+        insights.append(f"🚀 **Top Project:** {top_project['Project']}")
+        insights.append(f"   - Total Hours: {round(top_project['Total_GenAI_Hours'], 2)}")
+        insights.append(f"   - Users Involved: {top_project['User_Count']}")
+        if 'Champion_Score' in top_project:
+            insights.append(f"   - Champion Score: {round(top_project['Champion_Score'], 1)}/100")
+        insights.append("")
+    
+    # Usage patterns
+    if 'GenAI_Efficiency' in result_df.columns:
+        active_users = len(result_df[result_df['GenAI_Efficiency'] > 0])
+        usage_rate = (active_users / len(result_df)) * 100
+        insights.append(f"📈 **Usage Analysis:**")
+        insights.append(f"   - Users with GenAI activity: {active_users}/{len(result_df)} ({round(usage_rate, 1)}%)")
+        
+        if active_users > 0:
+            high_users = len(result_df[result_df['GenAI_Efficiency'] >= 10])
+            insights.append(f"   - High-usage users (≥10 hours): {high_users}")
+        insights.append("")
+    
+    # Tool and use case insights
+    if ai_tool_counts and use_case_counts:
+        insights.append("🛠️ **Technology Adoption:**")
+        top_3_tools = dict(sorted(ai_tool_counts.items(), key=lambda x: x[1], reverse=True)[:3])
+        for tool, count in top_3_tools.items():
+            insights.append(f"   - {tool}: {count} mentions")
+        
+        insights.append("")
+        insights.append("💡 **Primary Use Cases:**")
+        top_3_cases = dict(sorted(use_case_counts.items(), key=lambda x: x[1], reverse=True)[:3])
+        for case, count in top_3_cases.items():
+            insights.append(f"   - {case}: {count} instances")
+    
+    return "\n".join(insights)
+
+# Create Gradio interface
+def create_gradio_app():
+    with gr.Blocks(title="GenAI Worklog Processor", theme=gr.themes.Soft()) as app:
+        gr.Markdown("""
+        # 🤖 GenAI Worklog Data Processor v1.1
+        
+        This application processes worklog data to extract insights about GenAI usage:
+        
+        ✅ Creates a list of unique users  
+        ✅ Concatenates GenAI use case descriptions for each user  
+        ✅ Captures GenAI efficiency values and metrics  
+        ✅ Identifies projects with highest GenAI usage  
+        ✅ Analyzes AI tools and use cases  
+        ✅ Identifies prompt champions based on quality metrics  
+        
+        **Required columns:** User, GenAI use case description, GenAI Efficiency (Log time in hours)  
+        **Optional columns:** Required, Logged, Date, Project, Project Category, Epic, Key
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(
+                    label="📁 Upload CSV or Excel File",
+                    file_types=[".csv", ".xlsx", ".xls"],
+                    type="filepath"
+                )
+                process_btn = gr.Button("🚀 Process Data", variant="primary", size="lg")
+            
+            with gr.Column(scale=1):
+                status_output = gr.Textbox(
+                    label="📋 Processing Status",
+                    interactive=False,
+                    lines=3
+                )
+        
+        with gr.Tabs():
+            with gr.TabItem("📊 Processed Data"):
+                processed_data = gr.Dataframe(
+                    label="Processed Results",
+                    interactive=False,
+                    wrap=True
+                )
+                download_file = gr.File(
+                    label="💾 Download Excel Report",
+                    interactive=False
+                )
+            
+            with gr.TabItem("📈 Summary & Insights"):
+                with gr.Row():
+                    with gr.Column():
+                        summary_stats = gr.Markdown(label="Summary Statistics")
+                    with gr.Column():
+                        insights_text = gr.Markdown(label="Key Insights")
+            
+            with gr.TabItem("📊 Visualizations"):
+                with gr.Row():
+                    plot1 = gr.Plot(label="GenAI Efficiency by User")
+                    plot2 = gr.Plot(label="Project Analysis")
+                
+                with gr.Row():
+                    plot3 = gr.Plot(label="AI Tools Usage")
+                    plot4 = gr.Plot(label="Use Cases Distribution")
+                
+                with gr.Row():
+                    plot5 = gr.Plot(label="Quality Score Distribution")
+                    plot6 = gr.Plot(label="Utilization Analysis")
+            
+            with gr.TabItem("ℹ️ How Champion Scores Work"):
+                gr.Markdown("""
+                ## 🏆 Champion Score Calculation
+                
+                The Champion Score evaluates the quality and comprehensiveness of GenAI usage descriptions on a scale of 0-100:
+                
+                ### 🛠️ Tools (20 points)
+                - **Basic mention** (10 pts): References one AI tool (GPT, Claude, etc.)
+                - **Multiple tools** (15 pts): Uses 2+ different AI tools  
+                - **Specific versions** (+5 pts): Mentions specific models (GPT-4, Claude-2, etc.)
+                
+                ### 💡 Use Case (30 points)
+                - **Category identification** (5 pts each): Code generation, content creation, data analysis, etc.
+                - **Context specificity** (+5 pts): Clear "for/to" statements showing purpose
+                - **Domain expertise** (+5 pts): Technical terms (API, database, algorithm, etc.)
+                - **Work integration** (+5 pts): References projects, tasks, tickets, stories
+                
+                ### ✍️ Prompt Quality (30 points)  
+                - **Length bonus**: 200+ chars (5 pts), 500+ chars (10 pts)
+                - **Prompt indicators** (10 pts): Quotes, mentions "prompt", "assist", "create", "generate"
+                - **Advanced techniques** (2 pts each): Step-by-step, chain of thought, few-shot, examples
+                
+                ### 🎯 Outcomes & Iteration (20 points)
+                - **Results mentioned** (2 pts each): "result", "output", "generated", "created", "improved"  
+                - **Iteration indicators** (2 pts each): "refine", "revise", "update", "feedback"
+                - **Quantified impact** (+5 pts): Percentages, time saved, metrics
+                
+                ### 🏅 Score Interpretation
+                - **🥇 90-100**: Exceptional - Comprehensive usage with advanced techniques
+                - **🥈 70-89**: Strong - Good tool usage with clear outcomes  
+                - **🥉 50-69**: Moderate - Basic usage with some detail
+                - **📝 30-49**: Basic - Simple usage descriptions
+                - **⚠️ 0-29**: Minimal - Very basic or unclear usage
+                
+                Higher scores indicate more sophisticated and effective GenAI adoption!
+                """)
+        
+        # Event handlers
+        def process_and_update(file):
+            if file is None:
+                return (
+                    None, "Please upload a file first", None, 
+                    "No data to display", "No insights available",
+                    None, None, None, None, None, None
+                )
+            
+            try:
+                # Read the file
+                if file.endswith('.csv'):
+                    df = pd.read_csv(file)
+                else:
+                    df = pd.read_excel(file)
+                
+                # Check required columns
+                required_columns = ['User', 'GenAI use case description', 'GenAI Efficiency (Log time in hours)']
+                missing_columns = [col for col in required_columns if col not in df.columns]
+                
+                if missing_columns:
+                    return (
+                        None, f"❌ Missing required columns: {', '.join(missing_columns)}", None,
+                        "Cannot process data", "Missing required columns",
+                        None, None, None, None, None, None
+                    )
+                
+                # Process the data
+                result_df = process_genai_data(df)
+                project_analysis = analyze_projects_by_genai_hours(df)
+                ai_tool_counts = extract_ai_tools_from_descriptions(df)
+                use_case_counts = extract_use_cases_from_descriptions(df)
+                
+                # Create Excel download
+                excel_data = create_download_excel(result_df)
+                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                excel_filename = f"genai_processed_data_{timestamp}.xlsx"
+                
+                # Save Excel file temporarily
+                with open(excel_filename, 'wb') as f:
+                    f.write(excel_data)
+                
+                # Create visualizations
+                plots = create_visualizations(result_df, project_analysis, ai_tool_counts, use_case_counts)
+                
+                # Create summary statistics and insights
+                summary_stats = create_summary_stats(result_df, project_analysis, ai_tool_counts, use_case_counts)
+                insights = create_insights_text(result_df, project_analysis, ai_tool_counts, use_case_counts)
+                
+                return (
+                    result_df,
+                    "✅ Processing completed successfully!",
+                    excel_filename,
+                    summary_stats,
+                    insights,
+                    plots[0] if len(plots) > 0 else None,
+                    plots[1] if len(plots) > 1 else None,
+                    plots[2] if len(plots) > 2 else None,
+                    plots[3] if len(plots) > 3 else None,
+                    plots[4] if len(plots) > 4 else None,
+                    plots[5] if len(plots) > 5 else None
+                )
+                
+            except Exception as e:
+                error_msg = f"❌ Error processing file: {str(e)}"
+                return (
+                    None, error_msg, None,
+                    "Error occurred", error_msg,
+                    None, None, None, None, None, None
+                )
+        
+        process_btn.click(
+            fn=process_and_update,
+            inputs=[file_input],
+            outputs=[
+                processed_data, status_output, download_file,
+                summary_stats, insights_text,
+                plot1, plot2, plot3, plot4, plot5, plot6
+            ]
+        )
+        
+        # Add examples
+        gr.Examples(
+            examples=[
+                ["sample_worklog.csv"],
+            ],
+            inputs=file_input,
+            label="📋 Example Files (if available)"
+        )
+        
+        gr.Markdown("""
+        ---
+        **Enhanced GenAI Worklog Processor** • Built with Gradio and Pandas
+        
+        💡 **Tips for best results:**
+        - Ensure your CSV/Excel file has the required columns
+        - GenAI descriptions should be detailed for better Champion Scores
+        - Include project information for comprehensive analysis
+        """)
+    
+    return app
+
+# Helper function to assign team categories (referenced in original code)
+def assign_team_category(row, max_quality, max_hours):
+    """Assign team category based on usage patterns"""
+    quality_score = row['Champion_Score']
+    hours = row['GenAI_Efficiency']
+    
+    # Normalize scores
+    quality_norm = (quality_score / max_quality) * 100 if max_quality > 0 else 0
+    hours_norm = (hours / max_hours) * 100 if max_hours > 0 else 0
+    
+    if quality_norm >= 70 and hours_norm >= 50:
+        return "🚀 Power Users", "High quality usage with significant hours"
+    elif quality_norm >= 70:
+        return "🎯 Quality Champions", "Excellent usage quality, moderate hours"
+    elif hours_norm >= 70:
+        return "⚡ High Volume", "Heavy usage, opportunity for quality improvement"
+    elif quality_norm >= 40 or hours_norm >= 30:
+        return "📈 Growing Users", "Developing GenAI skills and usage"
+    elif hours > 0:
+        return "🌱 Beginners", "Starting GenAI journey"
+    else:
+        return "💤 Inactive", "No recorded GenAI usage"
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_gradio_app()
+    app.launch(
+        share=True,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )