import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
import plotly.graph_objects as go
from io import BytesIO # Importa BytesIO per gestire file in memoria
try:
import scipy.stats # Per correlazione spearman opzionale
SCIPY_AVAILABLE = True
except ImportError:
SCIPY_AVAILABLE = False
# Sposta l'avviso della libreria scipy dopo il caricamento del file,
# così non appare se non viene caricato nessun file.
# st.sidebar.warning("Libreria 'scipy' non trovata...") # Rimosso da qui
# --- Configuration ---
st.set_page_config(layout="wide", page_title="Dashboard Analisi Clima")
# --- Constants & Helper Functions ---
SCORE_BUCKETS = {
(0, 2.5): "Critico",
(2.5, 4.5): "Neutrale",
(4.5, 7): "Positivo" # Assumendo scala fino a 6, ma 7 copre > 4.5
}
BUCKET_COLORS = {"Critico": "#d62728", "Neutrale": "#ff7f0e", "Positivo": "#2ca02c"}
THRESHOLD_LOW = 3.0 # Leggermente aggiustato per bullet chart
THRESHOLD_HIGH = 4.5 # Leggermente aggiustato per bullet chart
PLOTLY_TEMPLATE = "plotly_white" # "seaborn" #"plotly_dark" # "ggplot2" # "plotly_white"
def categorize_score(score):
if pd.isna(score):
return "Non Risposto"
# Ajust range slightly to handle edge cases like 2.5 exactly
if 0 <= score <= 2.5: return "Critico"
if 2.5 < score <= 4.5: return "Neutrale"
if 4.5 < score <= 7: return "Positivo" # Assuming max score is around 6
return "Sconosciuto" # Should not happen with numeric data in expected range
@st.cache_data
# Modifica la funzione per accettare l'oggetto file caricato invece del percorso
def load_and_prepare_data(uploaded_file_object):
if uploaded_file_object is None:
return None, None, None, None, None, None, None
try:
# Legge direttamente dall'oggetto file in memoria
# Explicitly try different encodings if default fails
try:
# Usa BytesIO per permettere a read_csv di rileggere se necessario
file_content = BytesIO(uploaded_file_object.getvalue())
df_orig = pd.read_csv(file_content, delimiter=';', encoding='utf-8')
except UnicodeDecodeError:
try:
file_content.seek(0) # Riavvolgi il buffer
df_orig = pd.read_csv(file_content, delimiter=';', encoding='latin-1')
except UnicodeDecodeError:
file_content.seek(0) # Riavvolgi il buffer
df_orig = pd.read_csv(file_content, delimiter=';', encoding='iso-8859-1')
# Rimuovi FileNotFoundError dato che non usiamo più un percorso fisso
# except FileNotFoundError:
# st.error(f"Errore: File non trovato...") # Rimosso
# return None, None, None, None, None, None, None
except Exception as e:
st.error(f"Errore durante la lettura del CSV caricato: {e}")
return None, None, None, None, None, None, None
# --- Il resto della funzione di preparazione dati rimane invariato ---
original_columns = df_orig.columns.tolist()
unnamed_cols = [col for col in df_orig.columns if str(col).startswith('Unnamed:')]
df = df_orig.drop(columns=unnamed_cols)
cleaned_original_columns = df.columns.tolist() # Update after drop
header_row_index = 0 # Assuming header is the first row after loading
new_header = df.iloc[header_row_index].tolist()
df = df[header_row_index + 1:].reset_index(drop=True)
# Clean the header: replace NaN/None with placeholders, ensure strings, strip whitespace
cleaned_header = []
for i, col in enumerate(new_header):
col_str = str(col).strip() if pd.notna(col) else ""
if not col_str: # If empty after stripping
if i < len(cleaned_original_columns) and not cleaned_original_columns[i].startswith('Unnamed:'):
cleaned_header.append(str(cleaned_original_columns[i]).strip()) # Use original name if meaningful
else:
cleaned_header.append(f"Colonna_Sconosciuta_{i}") # Placeholder
else:
cleaned_header.append(col_str)
# *** START: Enhanced Duplicate Column Handling ***
counts = {}
final_header = []
original_to_final_map = {} # Map original cleaned name to final unique name
for i, col_name in enumerate(cleaned_header):
original_name = col_name # Keep track of the name before potential suffix
if col_name in counts:
counts[col_name] += 1
new_name = f"{col_name}_{counts[col_name]}"
final_header.append(new_name)
# Store mapping if original name was intended as a question
# Heuristic: assume non-demographic columns are potential questions
if i >= 3: # Assuming first 3 are demo - adjust if needed
original_to_final_map[original_name] = original_to_final_map.get(original_name, []) + [new_name]
else:
counts[col_name] = 0
final_header.append(col_name)
if i >= 3:
original_to_final_map[original_name] = [col_name] # First occurrence
df.columns = final_header
# *** END: Enhanced Duplicate Column Handling ***
# --- Category Mapping ---
def get_category_from_original(original_col_name, potential_category_source):
col_name_str = str(original_col_name).strip()
source_str = str(potential_category_source).strip()
if pd.notna(potential_category_source) and not source_str.isdigit() and 'domanda' not in source_str.lower():
base_name = source_str.split('.')[0].strip()
if base_name: return base_name
if '.' in col_name_str:
base_name = col_name_str.split('.')[0].strip()
suffix = col_name_str.split('.')[-1]
if suffix.isdigit():
if base_name: return base_name
elif not col_name_str.isdigit() and 'domanda' not in col_name_str.lower():
if col_name_str: return col_name_str
return "Categoria Sconosciuta"
question_to_category_map = {}
demographic_indices = list(range(min(3, len(final_header)))) # Safer range for demo indices
for i, final_col_name in enumerate(final_header):
if i not in demographic_indices:
# Find the original cleaned header name before potential suffix was added
original_cleaned_name = final_col_name
if '_' in final_col_name:
parts = final_col_name.rsplit('_', 1)
if parts[1].isdigit() and int(parts[1]) == counts.get(parts[0], -1):
original_cleaned_name = parts[0]
# Use original column name from the CSV *before* taking row 0 as header for category inference
original_csv_col = cleaned_original_columns[i] if i < len(cleaned_original_columns) else original_cleaned_name
category = get_category_from_original(original_csv_col, original_csv_col)
category = category.replace("Parità di genere", "Parità Genere")
question_to_category_map[final_col_name] = category # Map the *final unique* column name
# --- Demographic Columns ---
demographic_map = {}
if len(final_header) > 0: demographic_map[final_header[0]] = 'Genere'
if len(final_header) > 1: demographic_map[final_header[1]] = 'Fascia_Eta'
if len(final_header) > 2: demographic_map[final_header[2]] = 'Sede'
# Check if default demo columns actually exist before renaming
valid_demo_map = {k: v for k, v in demographic_map.items() if k in df.columns}
df.rename(columns=valid_demo_map, inplace=True)
demographic_cols = list(valid_demo_map.values())
# Filter out potential summary rows
if 'Sede' in df.columns:
anomalous_sede = ['Media', 'Mediana', 'Media sezione', 'Totale', 'Scarto quadratico medio']
df = df[~df['Sede'].astype(str).str.strip().str.lower().isin([s.lower() for s in anomalous_sede])]
# Fill missing demographic data
for col in demographic_cols:
if col in df.columns:
df[col] = df[col].astype(str).fillna('Non specificato').replace(['nan', 'None', ''], 'Non specificato')
# Identify question columns based on the map (using final unique names)
question_cols = list(question_to_category_map.keys())
question_cols = [col for col in question_cols if col in df.columns] # Ensure they exist
# --- Type Conversion ---
for col in question_cols:
if df[col].dtype == 'object':
df[col] = df[col].astype(str).str.replace(',', '.', regex=False)
df[col] = df[col].replace(['nan', 'N/A', '', '-', 'None'], np.nan, regex=False)
df[col] = pd.to_numeric(df[col], errors='coerce')
numeric_question_cols = df[question_cols].select_dtypes(include=np.number).columns.tolist()
# Determine response scale dynamically
response_scale = (1, 6) # Default fallback
if numeric_question_cols:
valid_numeric_cols = [col for col in numeric_question_cols if col in df.columns]
if valid_numeric_cols:
# Drop rows where ALL numeric questions are NaN before calculating min/max
df_numeric_only = df[valid_numeric_cols].dropna(how='all')
if not df_numeric_only.empty:
min_val = df_numeric_only.min(skipna=True).min(skipna=True)
max_val = df_numeric_only.max(skipna=True).max(skipna=True)
if pd.notna(min_val) and pd.notna(max_val):
response_scale = (min_val, max_val)
# --- Identify Overall Satisfaction Question ---
overall_satisfaction_question = None
possible_satisfaction_cats = ['Riepilogo', 'Generale', 'Soddisfazione Complessiva']
# Use final unique names from numeric_question_cols
possible_satisfaction_cols = [q for q in numeric_question_cols
if question_to_category_map.get(q) in possible_satisfaction_cats]
if possible_satisfaction_cols:
overall_satisfaction_question = possible_satisfaction_cols[0]
else:
keywords = ['soddisfazione', 'complessivamente', 'generale', 'valutazione']
for q in numeric_question_cols:
# Check original cleaned name for keywords if available, else the final name
original_cleaned_name = q.rsplit('_', 1)[0] if '_' in q and q.rsplit('_', 1)[1].isdigit() else q
q_check = original_cleaned_name.lower() # Check original name primarily
if any(keyword in q_check for keyword in keywords):
overall_satisfaction_question = q # Assign the final unique name
st.info(f"Domanda soddisfazione generale identificata: '{q}' (basata su '{original_cleaned_name}')")
break
if not overall_satisfaction_question and numeric_question_cols:
st.warning("Impossibile identificare automaticamente la domanda sulla soddisfazione generale. Alcune analisi potrebbero essere limitate.")
return df, demographic_cols, question_cols, question_to_category_map, numeric_question_cols, response_scale, overall_satisfaction_question
# --- Inizio Script Principale ---
# Aggiungi il widget per caricare il file
st.sidebar.title('Sondaggio')
uploaded_file = st.sidebar.file_uploader("Carica il tuo file CSV", type="csv")
st.sidebar.divider()
# Procedi solo se un file è stato caricato
if uploaded_file is not None:
# Sposta l'avviso della libreria scipy qui, così appare solo se si procede
if not SCIPY_AVAILABLE:
st.sidebar.warning("Libreria 'scipy' non trovata. La correlazione Spearman non sarà disponibile. Installa con: pip install scipy")
# --- Load Data ---
# Chiama la funzione di caricamento passando l'oggetto file caricato
try:
df_full, demographic_cols, question_cols, question_to_category_map, numeric_question_cols, response_scale, overall_satisfaction_question = load_and_prepare_data(uploaded_file)
if df_full is None:
st.error("Caricamento o preparazione dati fallito. Controlla il file CSV.")
st.stop() # Ferma l'esecuzione se il caricamento fallisce
elif df_full.empty:
st.warning("Il file CSV caricato risulta vuoto dopo la pulizia iniziale.")
# Si potrebbe fermare qui o continuare mostrando avvisi di dati vuoti
# st.stop()
except Exception as e:
st.error(f"Errore critico durante l'inizializzazione dei dati dal file caricato: {e}")
st.exception(e) # Stampa traceback completo per debug
st.stop() # Ferma l'esecuzione in caso di errore critico
# --- DA QUI IN POI, IL CODICE DEL DASHBOARD RIMANE INVARIATO ---
# --- MA VIENE ESEGUITO SOLO SE uploaded_file IS NOT None ---
# --- App Title ---
st.title("🚀 Dashboard Analisi Clima")
# ==============================================================================
# --- Sidebar ---
# ==============================================================================
st.sidebar.title("Filtri & Controlli")
st.sidebar.subheader("👤 Filtri Demografici")
selected_filters = {}
if demographic_cols:
# Use df_full for filter options to show all possibilities
for demo_col in demographic_cols:
# Ensure the column exists in df_full before creating filter
if demo_col in df_full.columns:
unique_values = sorted(df_full[demo_col].astype(str).unique())
if len(unique_values) > 1:
selected_filters[demo_col] = st.sidebar.multiselect(
f"{demo_col}",
options=unique_values,
default=unique_values
)
else:
# If only one value, no need for multiselect, just store it
selected_filters[demo_col] = unique_values
else:
st.sidebar.warning(f"Colonna demografica '{demo_col}' definita ma non trovata nel DataFrame.")
# Apply filters - start from df_full each time filters change
df_filtered = df_full.copy()
for col, selected_values in selected_filters.items():
# Check if the column exists in df_filtered before applying the filter
if col in df_filtered.columns and selected_values:
# Ensure selected_values are strings for comparison if the column is string
if df_filtered[col].dtype == 'object':
selected_values_str = [str(v) for v in selected_values]
df_filtered = df_filtered[df_filtered[col].astype(str).isin(selected_values_str)]
else: # Keep original type for non-object columns if filtering is needed
df_filtered = df_filtered[df_filtered[col].isin(selected_values)]
else:
st.sidebar.warning("Nessuna colonna demografica valida trovata per i filtri.")
df_filtered = df_full.copy() if df_full is not None else pd.DataFrame() # Use full data if available, else empty
st.sidebar.divider()
st.sidebar.subheader("📊 Metriche Chiave (Filtrate)")
# Recalculate total respondents after filtering
total_respondents_filtered = len(df_filtered) if df_filtered is not None else 0
st.sidebar.metric("Rispondenti Filtrati", total_respondents_filtered)
# --- Calculate metrics only if df_filtered is not empty ---
avg_overall_filtered = np.nan
avg_scores_per_category_f = pd.Series(dtype=float)
driver_df = pd.DataFrame() # Initialize empty driver dataframe
# Default correlation method
corr_method_sidebar = 'pearson'
if SCIPY_AVAILABLE:
corr_method_sidebar = 'spearman' # Prefer Spearman if scipy is available
if df_filtered is not None and not df_filtered.empty and numeric_question_cols:
# Ensure overall satisfaction question exists in the filtered numeric columns
if overall_satisfaction_question and overall_satisfaction_question in df_filtered.columns and pd.api.types.is_numeric_dtype(df_filtered[overall_satisfaction_question]):
overall_sat_data = df_filtered[overall_satisfaction_question].dropna()
if not overall_sat_data.empty:
avg_overall_filtered = overall_sat_data.mean()
midpoint = (response_scale[0] + response_scale[1]) / 2 if response_scale else 3.5 # Fallback midpoint
delta_vs_mid = avg_overall_filtered - midpoint
st.sidebar.metric("Soddisfazione Generale Media", f"{avg_overall_filtered:.2f}", f"{delta_vs_mid:+.2f} vs Midpoint ({midpoint:.1f})")
else:
st.sidebar.metric("Soddisfazione Generale Media", "N/D (no data)")
else:
st.sidebar.metric("Soddisfazione Generale Media", "N/D (Domanda non trovata/valida)")
# Calculate category averages on filtered data
numeric_cols_in_filtered = [col for col in numeric_question_cols if col in df_filtered.columns]
if numeric_cols_in_filtered:
avg_scores_per_question_f = df_filtered[numeric_cols_in_filtered].mean(axis=0, skipna=True)
df_avg_scores_f = pd.DataFrame({'Domanda': avg_scores_per_question_f.index, 'Punteggio Medio': avg_scores_per_question_f.values})
df_avg_scores_f['Categoria'] = df_avg_scores_f['Domanda'].map(question_to_category_map).fillna("Senza Categoria")
df_avg_scores_f.dropna(subset=['Punteggio Medio'], inplace=True)
if not df_avg_scores_f.empty:
# Exclude "Senza Categoria" from min/max display if desired
avg_scores_valid_cat = df_avg_scores_f[df_avg_scores_f['Categoria'] != "Senza Categoria"]
if not avg_scores_valid_cat.empty:
avg_scores_per_category_f = avg_scores_valid_cat.groupby('Categoria')['Punteggio Medio'].mean().sort_values()
if not avg_scores_per_category_f.empty:
min_cat_score = avg_scores_per_category_f.iloc[0]
max_cat_score = avg_scores_per_category_f.iloc[-1]
delta_min = f"{min_cat_score - avg_overall_filtered:.2f} vs Sod. Gen." if not np.isnan(avg_overall_filtered) else None
delta_max = f"{max_cat_score - avg_overall_filtered:.2f} vs Sod. Gen." if not np.isnan(avg_overall_filtered) else None
st.sidebar.metric(f"⚠️ Cat. Punteggio MIN", f"{avg_scores_per_category_f.index[0]} ({min_cat_score:.2f})", delta_min, delta_color="inverse")
st.sidebar.metric(f"✅ Cat. Punteggio MAX", f"{avg_scores_per_category_f.index[-1]} ({max_cat_score:.2f})", delta_max, delta_color="normal")
else:
st.sidebar.text("N/D per Categorie (Vuote dopo agg.)")
else:
st.sidebar.text("N/D per Categorie (Solo 'Senza Cat.')")
else:
st.sidebar.text("N/D per Categorie (No medie domande)")
else:
st.sidebar.text("N/D per Categorie (No colonne numeriche)")
# --- Calculate Driver Data (Correlation) ---
if overall_satisfaction_question and overall_satisfaction_question in df_filtered.columns and pd.api.types.is_numeric_dtype(df_filtered[overall_satisfaction_question]):
# Ensure overall satisfaction has variance
if df_filtered[overall_satisfaction_question].nunique(dropna=True) > 1:
driver_candidate_cols = [col for col in numeric_cols_in_filtered if col != overall_satisfaction_question and df_filtered[col].nunique(dropna=True) > 1]
if driver_candidate_cols:
try:
# Calculate correlations
correlations = df_filtered[driver_candidate_cols].corrwith(df_filtered[overall_satisfaction_question], method=corr_method_sidebar).dropna()
# Calculate average scores for the same candidates
avg_scores_drivers = df_filtered[driver_candidate_cols].mean(skipna=True)
# Combine into driver_df
if not correlations.empty:
driver_df = pd.DataFrame({'Correlazione': correlations})
# Add avg scores safely, aligning index
driver_df = driver_df.join(avg_scores_drivers.rename('Punteggio Medio'), how='inner') # Inner join ensures only questions with both corr and avg score remain
if not driver_df.empty:
driver_df['Categoria'] = driver_df.index.map(question_to_category_map).fillna("Senza Categoria")
driver_df.dropna(subset=['Categoria', 'Correlazione', 'Punteggio Medio'], inplace=True) # Drop if essential data missing
if not driver_df.empty:
driver_df['Domanda'] = driver_df.index
driver_df['Domanda_Breve'] = driver_df['Domanda'].apply(lambda x: str(x)[:47] + "..." if len(str(x)) > 50 else str(x))
driver_df['Correlazione_Abs'] = driver_df['Correlazione'].abs()
else:
driver_df = pd.DataFrame() # Ensure it's empty if join fails
else:
st.sidebar.info("Nessuna correlazione significativa calcolata per i driver.")
except Exception as e:
st.sidebar.warning(f"Errore nel calcolo correlazioni driver: {e}")
else:
st.sidebar.info("Nessuna domanda candidata (con varianza) trovata per l'analisi driver.")
else:
st.sidebar.info("La domanda di soddisfazione generale non ha varianza nei dati filtrati.")
else: # If df_filtered is empty or no numeric questions
st.sidebar.text("Dati insufficienti o non disponibili per le metriche.")
if total_respondents_filtered == 0:
st.sidebar.text("Nessun rispondente selezionato.")
st.sidebar.metric("Soddisfazione Generale Media", "N/D")
st.sidebar.text("N/D per Categorie")
st.sidebar.divider()
st.sidebar.info("Utilizza i filtri per esplorare i dati. Le metriche e i grafici si aggiornano dinamicamente.")
# ==============================================================================
# --- Create Tabs ---
# ==============================================================================
tab_list = [
"🎯 Sintesi Chiave",
"🗺️ Mappa Domande", # New Tab for Question Map
"👥 Demografia Dettagliata",
"📊 Generale & Categorie",
"🔍 Confronti & Driver",
"📈 Grafici Avanzati"
]
tabs = st.tabs(tab_list)
# Assign tabs to variables dynamically for easier access
tab_summary = tabs[0]
tab_map = tabs[1]
tab_demo = tabs[2]
tab_overall = tabs[3]
tab_comp = tabs[4]
tab_advanced = tabs[5]
# ==============================================================================
# --- TAB Summary: Key Takeaways ---
# ==============================================================================
with tab_summary:
# Content remains largely the same, but relies on variables calculated in sidebar
st.header("🎯 Sintesi Chiave (Basata sui Filtri Correnti)")
if df_filtered is None or df_filtered.empty:
st.warning("Nessun dato disponibile con i filtri selezionati.")
else:
st.markdown(f"Analisi basata su **{total_respondents_filtered}** rispondenti.")
col_s1, col_s2, col_s3 = st.columns([2, 1, 1]) # Adjusted columns for gauge
with col_s1:
st.subheader("Punti Salienti:")
if not np.isnan(avg_overall_filtered):
max_scale = response_scale[1] if response_scale else 6 # Fallback max scale
st.markdown(f"- **Soddisfazione Generale:** {avg_overall_filtered:.2f} / {max_scale:.0f}")
else:
st.markdown(f"- **Soddisfazione Generale:** N/D")
if not avg_scores_per_category_f.empty:
st.markdown(f"- **Area Più Forte:** {avg_scores_per_category_f.index[-1]} (Media: {avg_scores_per_category_f.iloc[-1]:.2f})")
st.markdown(f"- **Area Più Debole:** {avg_scores_per_category_f.index[0]} (Media: {avg_scores_per_category_f.iloc[0]:.2f})")
else:
st.markdown("- Dati categorie non disponibili.")
# Driver info from pre-calculated driver_df
if not driver_df.empty:
try:
# Top positive driver
top_driver = driver_df.sort_values('Correlazione', ascending=False).iloc[0]
st.markdown(f"- **Driver Positivo Principale:** {top_driver['Domanda_Breve']} (Corr: {top_driver['Correlazione']:.2f})")
# Top area for improvement (high correlation, low score) - using dynamic means
avg_corr_summary = driver_df['Correlazione'].mean()
avg_score_summary = driver_df['Punteggio Medio'].mean()
potential_improvement_df = driver_df[(driver_df['Correlazione'] > avg_corr_summary) & (driver_df['Punteggio Medio'] < avg_score_summary)]
if not potential_improvement_df.empty:
potential_improvement = potential_improvement_df.sort_values('Punteggio Medio').iloc[0] # Lowest score among high-impact, low-perf
st.markdown(f"- **Focus Miglioramento:** {potential_improvement['Domanda_Breve']} (Score: {potential_improvement['Punteggio Medio']:.2f}, Corr: {potential_improvement['Correlazione']:.2f})")
else:
st.markdown("- *Focus Miglioramento:* (Nessun driver critico trovato con medie correnti)")
except IndexError:
st.markdown("- *Driver Principali:* (Errore nell'accesso ai dati driver)")
except Exception as e:
st.markdown(f"- *Driver Principali:* (Errore: {e})")
else:
st.markdown("- *Driver Principali:* (Dati non disponibili o insufficienti)")
with col_s2:
st.subheader("Sentiment") # Combined Pie and Gauge
if overall_satisfaction_question and overall_satisfaction_question in df_filtered.columns:
overall_satisfaction_data_f = df_filtered[overall_satisfaction_question].dropna()
if pd.api.types.is_numeric_dtype(overall_satisfaction_data_f) and not overall_satisfaction_data_f.empty:
# Sentiment Pie Chart
bucket_counts = overall_satisfaction_data_f.apply(categorize_score).value_counts()
# Add 'Non Risposto' if it exists
# non_risposto_count = df_filtered[overall_satisfaction_question].isna().sum() # Needs careful handling if mixing counts and percentages
bucket_counts = bucket_counts.reindex(list(BUCKET_COLORS.keys()) + ["Non Risposto"], fill_value=0) # Ensure all buckets + Non Risposto
bucket_perc = (bucket_counts / bucket_counts.sum() * 100) if bucket_counts.sum() > 0 else bucket_counts
# Define colors including for "Non Risposto"
plot_colors = BUCKET_COLORS.copy()
plot_colors["Non Risposto"] = "#bbbbbb" # Grey for non-responded
fig_sentiment_pie = px.pie(values=bucket_perc.values, names=bucket_perc.index,
title="Distribuzione Sentiment", hole=0.4,
color=bucket_perc.index, color_discrete_map=plot_colors,
template=PLOTLY_TEMPLATE)
fig_sentiment_pie.update_traces(textinfo='percent+label', sort=False, # Keep defined order
pull=[0.05 if name=="Critico" else 0 for name in bucket_perc.index])
fig_sentiment_pie.update_layout(showlegend=False, margin=dict(t=30, b=10, l=10, r=10), height=250) # Compact layout
st.plotly_chart(fig_sentiment_pie, use_container_width=True)
else:
st.write("Dati soddisfazione non numerici/vuoti.")
else:
st.write("Domanda soddisfazione non trovata.")
with col_s3:
st.subheader("Valore Medio")
if not np.isnan(avg_overall_filtered):
min_scale, max_scale = response_scale if response_scale else (1, 6)
midpoint = (min_scale + max_scale) / 2
fig_gauge = go.Figure(go.Indicator(
mode = "gauge+number",
value = avg_overall_filtered,
domain = {'x': [0, 1], 'y': [0, 1]},
title = {'text': "Soddisfazione Generale", 'font': {'size': 16}},
gauge = {
'axis': {'range': [min_scale, max_scale], 'tickwidth': 1, 'tickcolor': "darkblue"},
'bar': {'color': "steelblue"},
'bgcolor': "white",
'borderwidth': 2,
'bordercolor': "gray",
'steps': [
{'range': [min_scale, THRESHOLD_LOW], 'color': BUCKET_COLORS['Critico']},
{'range': [THRESHOLD_LOW, THRESHOLD_HIGH], 'color': BUCKET_COLORS['Neutrale']},
{'range': [THRESHOLD_HIGH, max_scale], 'color': BUCKET_COLORS['Positivo']}],
'threshold': {
'line': {'color': "black", 'width': 3},
'thickness': 0.9,
'value': midpoint } # Show midpoint
}))
fig_gauge.update_layout(height=250, margin=dict(t=40, b=10, l=10, r=10)) # Compact layout
st.plotly_chart(fig_gauge, use_container_width=True)
else:
st.write(" ") # Placeholder
st.write(" ")
st.info("Gauge non disponibile (media N/D).")
st.markdown("---")
st.subheader("Riflessioni Rapide:")
satisfaction_text = f"{avg_overall_filtered:.2f}" if not np.isnan(avg_overall_filtered) else "N/D"
strongest_area_text = f"{avg_scores_per_category_f.index[-1]}" if not avg_scores_per_category_f.empty else "N/D"
weakest_area_text = f"{avg_scores_per_category_f.index[0]}" if not avg_scores_per_category_f.empty else "N/D"
st.info(f"""
Questa sintesi evidenzia i risultati principali per il gruppo selezionato ({total_respondents_filtered} persone).
La soddisfazione generale si attesta a **{satisfaction_text}**.
Le aree di forza (**{strongest_area_text}**) e di debolezza (**{weakest_area_text}**)
richiedono attenzione specifica. Esplora le altre schede per dettagli, confronti e visualizzazioni avanzate.
""")
# ==============================================================================
# --- TAB Map: Category -> Question Mapping ---
# ==============================================================================
with tab_map:
st.header("🗺️ Mappa Categorie e Domande")
st.write("Questa sezione mostra quali domande appartengono a ciascuna categoria identificata durante il caricamento dei dati.")
if question_to_category_map:
# Create DataFrame from the mapping dictionary
map_df = pd.DataFrame(question_to_category_map.items(), columns=['Domanda', 'Categoria'])
# Sort for better readability
map_df = map_df.sort_values(by=['Categoria', 'Domanda']).reset_index(drop=True)
st.dataframe(map_df, use_container_width=True)
# Optional: Display grouped by category
st.divider()
st.subheader("Domande Raggruppate per Categoria")
categories_in_map = map_df['Categoria'].unique()
for category in sorted(categories_in_map):
with st.expander(f"**{category}**"):
questions_in_cat = map_df[map_df['Categoria'] == category]['Domanda'].tolist()
for q in questions_in_cat:
st.markdown(f"- {q}")
else:
st.warning("La mappa tra domande e categorie non è disponibile.")
# ==============================================================================
# --- TAB Demo: Demographics ---
# ==============================================================================
with tab_demo:
st.header("👥 Analisi Demografica Dettagliata (Filtrata)")
if df_filtered is None or df_filtered.empty:
st.warning("Nessun dato disponibile con i filtri selezionati.")
elif not demographic_cols:
st.warning("Nessuna colonna demografica configurata per l'analisi.")
else:
st.write(f"Visualizzazione basata su **{len(df_filtered)}** rispondenti selezionati.")
valid_demo_cols_plots = [col for col in demographic_cols if col in df_filtered.columns] # Use only valid cols for plotting
if not valid_demo_cols_plots:
st.warning("Nessuna colonna demografica valida trovata nei dati filtrati per la visualizzazione.")
else:
# --- Basic Distribution Pies ---
st.subheader("Distribuzione Base")
num_demo_cols = len(valid_demo_cols_plots)
cols_pie = st.columns(num_demo_cols)
pie_colors = [px.colors.qualitative.Pastel1, px.colors.qualitative.Pastel2, px.colors.qualitative.Set3] # Cycle through color schemes
for i, demo_col in enumerate(valid_demo_cols_plots):
with cols_pie[i % num_demo_cols]: # Cycle through columns
if not df_filtered[demo_col].dropna().empty:
# Define order for age if applicable
category_orders = {}
if 'Eta' in demo_col:
age_order_guess = ['Fino a 30 anni', '31-40 anni', '41-50 anni', 'Oltre i 50 anni', 'Non specificato']
actual_ages = df_filtered[demo_col].unique()
ordered_actual = [age for age in age_order_guess if age in actual_ages]
ordered_actual.extend(sorted([age for age in actual_ages if age not in age_order_guess]))
category_orders={demo_col: ordered_actual}
fig_pie = px.pie(df_filtered.dropna(subset=[demo_col]), names=demo_col, hole=0.4,
color_discrete_sequence=pie_colors[i % len(pie_colors)], template=PLOTLY_TEMPLATE,
title=f"Per {demo_col}", category_orders=category_orders)
fig_pie.update_traces(textposition='inside', textinfo='percent+label')
fig_pie.update_layout(showlegend=False, title_x=0.5, margin=dict(t=40, b=0, l=0, r=0), height=300)
st.plotly_chart(fig_pie, use_container_width=True)
else:
st.write(f"Dati '{demo_col}' non disponibili.")
st.markdown("---")
# --- Hierarchical Views: Sunburst & Treemap ---
st.subheader("Visualizzazioni Gerarchiche/Proporzionali")
if len(valid_demo_cols_plots) >= 2: # Need at least 2 demographics for interesting hierarchy
chart_type_hier = st.radio("Scegli tipo grafico gerarchico:", ["Sunburst", "Treemap"], horizontal=True, key="hier_chart_sel")
# Aggregate counts for combinations
try:
df_grouped_hier = df_filtered.groupby(valid_demo_cols_plots, observed=True).size().reset_index(name='Conteggio')
if not df_grouped_hier.empty:
# Use first valid demo col for coloring
color_col_hier = valid_demo_cols_plots[0]
if chart_type_hier == "Sunburst":
fig_hier = px.sunburst(df_grouped_hier, path=valid_demo_cols_plots, values='Conteggio',
title=f"Distribuzione Combinata (Sunburst): {', '.join(valid_demo_cols_plots)}",
template=PLOTLY_TEMPLATE,
color=color_col_hier,
color_discrete_sequence=px.colors.qualitative.Pastel)
fig_hier.update_layout(margin=dict(t=50, l=25, r=25, b=25))
st.plotly_chart(fig_hier, use_container_width=True)
elif chart_type_hier == "Treemap":
fig_hier = px.treemap(df_grouped_hier, path=[px.Constant("Tutti")] + valid_demo_cols_plots, values='Conteggio',
title=f"Distribuzione Combinata (Treemap): {', '.join(valid_demo_cols_plots)}",
template=PLOTLY_TEMPLATE,
color=color_col_hier,
color_discrete_sequence=px.colors.qualitative.Pastel)
fig_hier.update_layout(margin=dict(t=50, l=25, r=25, b=25))
st.plotly_chart(fig_hier, use_container_width=True)
else:
st.info("Nessun dato aggregato per la visualizzazione gerarchica.")
except Exception as e:
st.error(f"Errore durante l'aggregazione per il grafico gerarchico: {e}")
else:
st.info("Sono necessarie almeno due colonne demografiche valide per le visualizzazioni gerarchiche.")
# ==============================================================================
# --- TAB Overall: Overall, Categories & Questions ---
# ==============================================================================
with tab_overall:
st.header("📊 Analisi Generale, Categorie e Domande (Filtrata)")
if df_filtered is None or df_filtered.empty:
st.warning("Nessun dato disponibile con i filtri selezionati.")
else:
# --- Overall Satisfaction Distribution ---
st.subheader("⭐ Soddisfazione Generale Complessiva")
if overall_satisfaction_question and overall_satisfaction_question in df_filtered.columns:
overall_satisfaction_data_f = df_filtered[overall_satisfaction_question].dropna()
if pd.api.types.is_numeric_dtype(overall_satisfaction_data_f) and not overall_satisfaction_data_f.empty:
col_ov1, col_ov2 = st.columns([2,1])
with col_ov1:
# Bar chart of distribution
overall_counts_f = overall_satisfaction_data_f.value_counts().sort_index()
fig_overall_satisfaction = px.bar(overall_counts_f, x=overall_counts_f.index, y=overall_counts_f.values,
labels={'x': f'Punteggio ({response_scale[0]:.0f}-{response_scale[1]:.0f})', 'y': 'Numero Risposte'},
text_auto=True, color_discrete_sequence=px.colors.sequential.Blues_r, template=PLOTLY_TEMPLATE,
title="Distribuzione Punteggi Soddisfazione Generale")
fig_overall_satisfaction.update_layout(xaxis = dict(tickmode = 'linear', dtick=1), title_x=0.5)
st.plotly_chart(fig_overall_satisfaction, use_container_width=True)
with col_ov2:
# Sentiment display
st.write(" ")
st.write(" ")
st.write("**Distribuzione Sentiment:**")
bucket_counts = overall_satisfaction_data_f.apply(categorize_score).value_counts()
bucket_counts = bucket_counts.reindex(list(BUCKET_COLORS.keys()) + ["Non Risposto"], fill_value=0)
total_valid_responses = bucket_counts.sum()
if total_valid_responses > 0:
bucket_perc = (bucket_counts / total_valid_responses * 100)
plot_colors = BUCKET_COLORS.copy()
plot_colors["Non Risposto"] = "#bbbbbb"
for bucket in plot_colors.keys(): # Iterate in defined order
if bucket in bucket_perc.index: # Check if bucket exists
perc = bucket_perc.get(bucket, 0)
count = bucket_counts.get(bucket, 0)
st.markdown(f"■ **{bucket}:** {perc:.1f}% ({count})", unsafe_allow_html=True)
else:
st.write("Nessuna risposta valida per il sentiment.")
else: st.warning("Dati soddisfazione generale non disponibili/numerici.")
else: st.warning("Domanda soddisfazione generale non trovata.")
st.markdown("---")
# --- Category Averages ---
st.subheader("📈 Punteggio Medio per Categoria")
if not avg_scores_per_category_f.empty:
cat_avg_chart_type = st.radio("Visualizza medie categorie come:", ["Bar Chart", "Bullet Chart"], horizontal=True, key="cat_avg_type")
if cat_avg_chart_type == "Bar Chart":
avg_scores_plot = avg_scores_per_category_f.copy()
color_map = []
for score in avg_scores_plot.values:
if score > THRESHOLD_HIGH: color_map.append(BUCKET_COLORS["Positivo"])
elif score < THRESHOLD_LOW: color_map.append(BUCKET_COLORS["Critico"])
else: color_map.append(BUCKET_COLORS["Neutrale"])
fig_avg_category = go.Figure(go.Bar(
x=avg_scores_plot.values, y=avg_scores_plot.index, orientation='h',
text=[f'{score:.2f}' for score in avg_scores_plot.values], marker_color=color_map ))
fig_avg_category.update_traces(textposition='outside')
fig_avg_category.update_layout(
xaxis_title=f'Punteggio Medio ({response_scale[0]:.0f}-{response_scale[1]:.0f})', yaxis_title='Categoria',
yaxis={'categoryorder':'total ascending'}, template=PLOTLY_TEMPLATE, title="Medie Categorie (Colorate per Soglia)")
if not np.isnan(avg_overall_filtered):
fig_avg_category.add_vline(x=avg_overall_filtered, line_width=2, line_dash="dash", line_color="grey", annotation_text="Media Sod. Gen.")
st.plotly_chart(fig_avg_category, use_container_width=True)
elif cat_avg_chart_type == "Bullet Chart":
st.write("Grafico Bullet: Confronta la media di categoria con la media generale e le soglie.")
min_scale, max_scale = response_scale if response_scale else (1, 6)
avg_scores_plot = avg_scores_per_category_f.copy().sort_values(ascending=False)
for category, score in avg_scores_plot.items():
fig_bullet = go.Figure(go.Indicator(
mode = "gauge+number+delta",
value = score,
delta = {'reference': avg_overall_filtered, 'suffix': ' vs Media Gen.'} if not np.isnan(avg_overall_filtered) else None,
title = {'text': category, 'font': {'size': 14}},
gauge = {
'shape': "bullet",
'axis': {'range': [min_scale, max_scale]},
'threshold': {
'line': {'color': "black", 'width': 2},
'thickness': 0.75,
'value': avg_overall_filtered if not np.isnan(avg_overall_filtered) else (min_scale+max_scale)/2 },
'bgcolor': "white",
'steps': [
{'range': [min_scale, THRESHOLD_LOW], 'color': BUCKET_COLORS['Critico']},
{'range': [THRESHOLD_LOW, THRESHOLD_HIGH], 'color': BUCKET_COLORS['Neutrale']},
{'range': [THRESHOLD_HIGH, max_scale], 'color': BUCKET_COLORS['Positivo']}],
'bar': {'color': 'darkblue', 'thickness': 0.5}
}))
fig_bullet.update_layout(height=100, margin=dict(l=200, r=50, t=30, b=10))
st.plotly_chart(fig_bullet, use_container_width=True)
else:
st.warning("Impossibile calcolare medie per categoria (potrebbero essere tutte 'Senza Categoria' o vuote).")
st.markdown("---")
# --- Detailed Question Analysis ---
st.subheader("❓ Analisi Dettagliata per Domanda")
# Get categories present in the calculated averages
categories_with_averages = avg_scores_per_category_f.index.unique().tolist()
if not categories_with_averages:
# Fallback: get categories from the original map if averages failed
if question_to_category_map:
categories_with_averages = sorted(list(set(question_to_category_map.values())))
if "Senza Categoria" in categories_with_averages: categories_with_averages.remove("Senza Categoria")
if "Categoria Sconosciuta" in categories_with_averages: categories_with_averages.remove("Categoria Sconosciuta")
else:
categories_with_averages = []
if categories_with_averages: # Proceed only if there are valid categories
col_q1, col_q2 = st.columns([1,1])
with col_q1:
selected_category = st.selectbox("Seleziona Categoria:", options=categories_with_averages, key="cat_select_q")
with col_q2:
plot_type = st.radio("Tipo Grafico Domande:", ["Distribuzione % (Stacked)", "Conteggi (Bar)", "Box Plot"], horizontal=True, key="q_plot_type")
if selected_category:
st.write(f"**Dettaglio Domande: '{selected_category}'**")
# Find questions mapped to the selected category, ensuring they are numeric and exist
questions_in_category = [q for q, cat in question_to_category_map.items()
if cat == selected_category and q in df_filtered.columns and q in numeric_question_cols]
if not questions_in_category:
st.write("Nessuna domanda numerica valida trovata per questa categoria nei dati filtrati.")
else:
# Prepare data for box plot if selected
if plot_type == "Box Plot":
df_box_cat = df_filtered[questions_in_category].copy()
if not df_box_cat.empty:
df_box_melted = df_box_cat.melt(var_name='Domanda', value_name='Punteggio')
# Shorten question names for y-axis
df_box_melted['Domanda_Breve'] = df_box_melted['Domanda'].apply(lambda x: x[:67]+"..." if len(x) > 70 else x)
df_box_melted.dropna(subset=['Punteggio'], inplace=True)
if not df_box_melted.empty:
fig_box = px.box(df_box_melted, x='Punteggio', y='Domanda_Breve', orientation='h',
title=f"Distribuzione Punteggi per Domanda in '{selected_category}'",
template=PLOTLY_TEMPLATE, points=False) # points="all" can be noisy
fig_box.update_layout(yaxis={'categoryorder':'total descending'}, height=max(400, len(questions_in_category)*50)) # Dynamic height
st.plotly_chart(fig_box, use_container_width=True)
else:
st.warning("Nessun dato valido per il Box Plot dopo il dropna.")
else:
st.warning("DataFrame vuoto per il Box Plot.")
else: # Stacked or Counts Bar Chart
for question in questions_in_category:
question_data_f = df_filtered[question].dropna()
if pd.api.types.is_numeric_dtype(question_data_f) and not question_data_f.empty:
avg_q = question_data_f.mean()
q_display = question if len(question) < 100 else question[:97] + "..."
st.markdown(f"**{q_display}** (Media: {avg_q:.2f})")
if plot_type == "Conteggi (Bar)":
counts_q = question_data_f.value_counts().sort_index()
if not counts_q.empty:
fig_q = px.bar(counts_q, x=counts_q.index, y=counts_q.values,
labels={'x': 'Punteggio', 'y': 'Numero Risposte'}, text_auto='.2s',
height=250, template=PLOTLY_TEMPLATE, color_discrete_sequence=px.colors.sequential.Blues_r)
fig_q.update_layout(xaxis = dict(tickmode = 'linear', dtick=1), margin=dict(t=5, b=5, l=5, r=5))
st.plotly_chart(fig_q, use_container_width=True)
else: st.caption("Nessun dato per questo grafico.")
elif plot_type == "Distribuzione % (Stacked)":
counts_q_norm = question_data_f.value_counts(normalize=True).sort_index() * 100
if not counts_q_norm.empty:
counts_q_df = counts_q_norm.reset_index()
counts_q_df.columns = ['Punteggio', 'Percentuale']
counts_q_df['Punteggio'] = counts_q_df['Punteggio'].astype(str) # For discrete colors
# Define a color map for the scores in the stacked bar
unique_scores = sorted(counts_q_df['Punteggio'].astype(float).unique())
colors = px.colors.sequential.Blues_r
score_color_map = {str(score): colors[min(len(colors)-1, int((score - response_scale[0]) / (response_scale[1] - response_scale[0]) * len(colors)))]
for score in unique_scores}
fig_q = px.bar(counts_q_df, x='Percentuale', y=[' ']*len(counts_q_df), # Single bar
color='Punteggio', orientation='h',
text=[f"{p:.1f}%" for p in counts_q_df['Percentuale']],
height=150, template=PLOTLY_TEMPLATE,
color_discrete_map=score_color_map # Apply color map
)
fig_q.update_layout(xaxis_ticksuffix="%", yaxis_title="", xaxis_title="% Rispondenti",
legend_title="Punteggio", showlegend=True, margin=dict(t=5, b=5, l=5, r=5),
xaxis_range=[0,100], yaxis_visible=False,
legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1))
fig_q.update_traces(textposition='inside', textfont_color='white') # Ensure text is visible
st.plotly_chart(fig_q, use_container_width=True)
else: st.caption("Nessun dato per questo grafico.")
else:
st.caption(f"Dati per '{question[:50]}...' non numerici o vuoti.")
else:
st.info("Nessuna categoria valida trovata per l'analisi dettagliata delle domande.")
# ==============================================================================
# --- TAB Comparisons: Comparisons, Drivers & More ---
# ==============================================================================
with tab_comp:
st.header("🔍 Confronti Demografici & Analisi Driver (Filtrata)")
if df_filtered is None or df_filtered.empty:
st.warning("Nessun dato disponibile con i filtri selezionati.")
elif not numeric_question_cols:
st.warning("Nessuna domanda numerica trovata per le analisi di confronto.")
else:
# --- Prepare Melted Data ---
@st.cache_data # Cache the melting process
def get_melted_data(df, id_vars, value_vars, cat_map):
if not value_vars: return pd.DataFrame()
cols_to_melt = [col for col in id_vars + value_vars if col in df.columns]
value_vars_valid = [col for col in value_vars if col in cols_to_melt]
id_vars_valid = [col for col in id_vars if col in cols_to_melt]
if not value_vars_valid or not id_vars_valid: return pd.DataFrame() # Need both ID and Value vars
df_melted = df[cols_to_melt].melt(id_vars=id_vars_valid, value_vars=value_vars_valid, var_name='Domanda', value_name='Punteggio')
df_melted['Categoria'] = df_melted['Domanda'].map(cat_map).fillna("Senza Categoria")
df_melted.dropna(subset=['Punteggio'], inplace=True)
return df_melted
numeric_cols_in_filtered = [col for col in numeric_question_cols if col in df_filtered.columns]
valid_demographic_cols = [col for col in demographic_cols if col in df_filtered.columns]
df_melted_f = pd.DataFrame() # Initialize empty
if valid_demographic_cols and numeric_cols_in_filtered:
df_melted_f = get_melted_data(df_filtered, valid_demographic_cols, numeric_cols_in_filtered, question_to_category_map)
# --- Demographic Comparisons (Violin / Box Plots) ---
st.subheader("🎻 Confronti Demografici (Distribuzione Punteggi per Categoria)")
if not df_melted_f.empty and valid_demographic_cols:
col_comp1, col_comp2 = st.columns(2)
with col_comp1:
# Select demographic group for comparison
comparison_group_v_options = [col for col in valid_demographic_cols if df_filtered[col].nunique() > 1] # Only those with multiple values
if comparison_group_v_options:
comparison_group_v = st.selectbox("Confronta Distribuzioni per:", comparison_group_v_options, key="dist_group")
else:
comparison_group_v = None
st.info("Nessuna colonna demografica con valori multipli per il confronto.")
with col_comp2:
dist_plot_type = st.radio("Tipo Grafico Distribuzione:", ["Violin Plot", "Box Plot"], horizontal=True, key="dist_plot_type")
if comparison_group_v: # Proceed only if a valid comparison group is selected
# Select categories to show (use averages calculated in sidebar)
categories_with_averages = avg_scores_per_category_f.index.unique().tolist()
if categories_with_averages:
default_cats_dist = avg_scores_per_category_f.nsmallest(3).index.tolist()
default_cats_dist = [cat for cat in default_cats_dist if cat in categories_with_averages] # Ensure defaults are valid
selected_cats_dist = st.multiselect("Seleziona Categorie da Visualizzare:", options=categories_with_averages, default=default_cats_dist, key="cat_dist")
if selected_cats_dist:
# Filter melted data for selected categories and ensure comparison group is not NA
df_dist = df_melted_f[(df_melted_f['Categoria'].isin(selected_cats_dist)) &
(df_melted_f[comparison_group_v].notna()) &
(df_melted_f[comparison_group_v] != 'Non specificato')] # Exclude 'Non specificato'? Optional.
if not df_dist.empty:
# Ensure hover data columns exist
hover_data = [col for col in valid_demographic_cols if col in df_dist.columns]
plot_func = px.violin if dist_plot_type == "Violin Plot" else px.box
caption_text = ("Il grafico a violino mostra la densità della distribuzione..." if dist_plot_type == "Violin Plot"
else "Il box plot mostra mediana, quartili...")
fig_dist = plot_func(df_dist, x='Categoria', y='Punteggio', color=comparison_group_v,
points=False, # 'all', False, 'outliers'
hover_data=hover_data,
category_orders={'Categoria': selected_cats_dist}, # Use selected order
template=PLOTLY_TEMPLATE, title=f"Distribuzione Punteggi per {comparison_group_v}")
fig_dist.update_layout(yaxis_range=[response_scale[0]-0.5, response_scale[1]+0.5])
st.plotly_chart(fig_dist, use_container_width=True)
st.caption(caption_text)
else:
st.warning(f"Nessun dato per le categorie e gruppo '{comparison_group_v}' selezionati.")
else:
st.info("Seleziona almeno una categoria per visualizzare il confronto.")
else:
st.warning("Medie per categoria non disponibili.")
else:
st.info("Dati o colonne demografiche insufficienti per i confronti.")
st.markdown("---")
# --- Driver Analysis ---
st.subheader("🎯 Analisi Driver (Impatto vs Performance)")
if not driver_df.empty: # Use pre-calculated driver_df from sidebar
driver_plot_type = st.radio("Visualizza Analisi Driver come:", ["Scatter Plot", "Density Heatmap", "Bar Chart (Top/Bottom)"], horizontal=True, key="driver_plot_type")
if driver_plot_type == "Scatter Plot":
# (Code for Scatter Plot - seems okay, uses driver_df)
fig_scatter_drivers = px.scatter(driver_df, x='Punteggio Medio', y='Correlazione',
color='Categoria',
size='Correlazione_Abs', size_max=18,
hover_data=['Domanda_Breve', 'Punteggio Medio', 'Correlazione'],
template=PLOTLY_TEMPLATE, title=f"Driver: Impatto (Corr. {corr_method_sidebar.capitalize()}) vs Performance")
avg_corr = driver_df['Correlazione'].mean()
avg_score_all_q = driver_df['Punteggio Medio'].mean()
fig_scatter_drivers.add_vline(x=avg_score_all_q, line_width=1, line_dash="dash", line_color="grey", annotation_text="Media Perf.")
fig_scatter_drivers.add_hline(y=avg_corr, line_width=1, line_dash="dash", line_color="grey", annotation_text="Media Impatto")
fig_scatter_drivers.update_layout(xaxis_title="Performance (Punteggio Medio Domanda)", yaxis_title=f"Impatto (Corr. {corr_method_sidebar.capitalize()} con Sod. Gen.)")
st.plotly_chart(fig_scatter_drivers, use_container_width=True)
st.caption("Quadranti (vs medie): Alto Dx (Verde)=Forza Chiave; Alto Sx (Giallo)=Priorità Alta; Basso Sx (Rosso)=Priorità Bassa; Basso Dx (Blu)=Mantenimento Secondario. Dimensione = forza correlazione.")
elif driver_plot_type == "Density Heatmap":
# (Code for Density Heatmap - seems okay, uses driver_df)
fig_density_driver = px.density_heatmap(driver_df, x="Punteggio Medio", y="Correlazione",
marginal_x="histogram", marginal_y="histogram",
text_auto=False,
template=PLOTLY_TEMPLATE, title=f"Densità Driver: Impatto (Corr. {corr_method_sidebar.capitalize()}) vs Performance")
avg_corr = driver_df['Correlazione'].mean()
avg_score_all_q = driver_df['Punteggio Medio'].mean()
fig_density_driver.add_vline(x=avg_score_all_q, line_width=1, line_dash="dash", line_color="grey")
fig_density_driver.add_hline(y=avg_corr, line_width=1, line_dash="dash", line_color="grey")
fig_density_driver.update_layout(xaxis_title="Performance (Punteggio Medio Domanda)", yaxis_title=f"Impatto (Corr. {corr_method_sidebar.capitalize()} con Sod. Gen.)")
st.plotly_chart(fig_density_driver, use_container_width=True)
st.caption("Mostra dove si concentrano le domande nel piano Impatto-Performance.")
elif driver_plot_type == "Bar Chart (Top/Bottom)":
# (Code for Bar Chart - seems okay, uses driver_df)
top_n = st.slider("Numero Top/Bottom Driver da mostrare:", min_value=3, max_value=15, value=8, key="driver_topn")
driver_df_unique = driver_df.loc[~driver_df.index.duplicated(keep='first')]
top_drivers = driver_df_unique.sort_values('Correlazione', ascending=False).head(top_n)
bottom_drivers = driver_df_unique.sort_values('Correlazione', ascending=True).head(top_n) # Gets most negative
# Combine and ensure uniqueness (in case a driver is both top N pos and top N neg in small datasets)
drivers_to_plot = pd.concat([top_drivers, bottom_drivers]).drop_duplicates().sort_values('Correlazione')
if not drivers_to_plot.empty:
fig_drivers_bar = px.bar(drivers_to_plot, x='Correlazione', y='Domanda_Breve', orientation='h',
color='Categoria', template=PLOTLY_TEMPLATE, height=max(400, len(drivers_to_plot)*30),
title=f"Top/Bottom {top_n} Domande per Correlazione ({corr_method_sidebar.capitalize()}) con Sod. Gen.")
fig_drivers_bar.update_layout(yaxis={'categoryorder':'total ascending'}, xaxis_title=f"Correlazione {corr_method_sidebar.capitalize()}", yaxis_title="Domanda")
st.plotly_chart(fig_drivers_bar, use_container_width=True)
st.caption(f"Mostra le domande con la correlazione ({corr_method_sidebar}) più forte (positiva e negativa) con la soddisfazione generale.")
else:
st.warning("Nessun dato driver da mostrare nel grafico a barre.")
else:
st.warning("Impossibile calcolare l'analisi dei driver. Verifica la presenza e la varianza della domanda di soddisfazione generale e delle altre domande numeriche.")
st.markdown("---")
# --- Anomaly Detection & Recommendations ---
st.subheader("⚠️ Rilevamento Potenziali Punti d'Attenzione & Suggerimenti 💡")
# Use melted data calculated earlier
if not df_melted_f.empty and valid_demographic_cols and not avg_scores_per_category_f.empty:
col_anom, col_sugg = st.columns(2)
with col_anom:
st.write("**Possibili Punti d'Attenzione (Z-Score per Gruppo/Categoria):**")
try:
# Calculate overall category means and std deviations on the *filtered* dataset
overall_cat_stats = df_melted_f.groupby('Categoria')['Punteggio'].agg(['mean', 'std']).reset_index()
# Rename columns *before* merge
overall_cat_stats = overall_cat_stats.rename(columns={'mean': 'mean_overall', 'std': 'std_overall'})
# Calculate group means within the filtered dataset
group_means = df_melted_f.groupby(valid_demographic_cols + ['Categoria'], observed=True)['Punteggio'].mean().reset_index()
# Rename columns *before* merge
group_means = group_means.rename(columns={'Punteggio': 'mean_group'})
if not group_means.empty and not overall_cat_stats.empty:
# Merge using the renamed columns
merged_stats = pd.merge(group_means, overall_cat_stats, on='Categoria', how='left')
# Calculate Z-score only if std is not NaN and greater than a small epsilon
merged_stats_valid_std = merged_stats[merged_stats['std_overall'].notna() & (merged_stats['std_overall'] > 0.01)].copy() # Use copy to avoid SettingWithCopyWarning
if not merged_stats_valid_std.empty:
# *** CORRECTION HERE: Use correct column names ***
merged_stats_valid_std['Z_Score'] = (merged_stats_valid_std['mean_group'] - merged_stats_valid_std['mean_overall']) / merged_stats_valid_std['std_overall']
z_score_threshold = st.slider("Soglia Z-Score per Attenzione:", min_value=1.0, max_value=3.0, value=1.75, step=0.25, key="zscore_thresh")
potential_anomalies = merged_stats_valid_std[abs(merged_stats_valid_std['Z_Score']) > z_score_threshold].sort_values(by='Z_Score')
if not potential_anomalies.empty:
st.write(f"Gruppi/Categorie con punteggio medio deviante (> {z_score_threshold:.2f} dev. std. dalla media della categoria):")
for _, row in potential_anomalies.head(10).iterrows(): # Limit display
group_desc_parts = [f"{col}={row[col]}" for col in valid_demographic_cols]
group_desc = " / ".join(group_desc_parts)
direction = "⚠️ Basso" if row['Z_Score'] < 0 else "✅ Alto"
# Use mean_group and Z_Score from the row
st.markdown(f"- {direction}: **{group_desc}** in **'{row['Categoria']}'** (Media Gruppo: {row['mean_group']:.2f}, Z: {row['Z_Score']:.2f})")
else:
st.info(f"Nessun punto d'attenzione rilevato con soglia Z-Score > {z_score_threshold:.2f} nei dati filtrati.")
else:
st.info("Deviazione standard non calcolabile o nulla per le categorie, impossibile calcolare Z-score.")
else:
st.info("Dati insufficienti per calcolare medie di gruppo o statistiche di categoria.")
except KeyError as e:
st.error(f"Errore Chiave durante il calcolo Z-Score: '{e}'. Verifica i nomi delle colonne dopo il merge.")
st.dataframe(merged_stats.head()) # Display merged df head for debugging
except Exception as e:
st.error(f"Errore generico durante il calcolo Z-Score: {e}")
with col_sugg:
# Suggestions part remains the same, using driver_df calculated in sidebar
st.write("**Suggerimenti Basati sui Driver & Punteggi Bassi:**")
if not avg_scores_per_category_f.empty:
lowest_cat_name = avg_scores_per_category_f.index[0]
lowest_cat_score = avg_scores_per_category_f.iloc[0]
st.markdown(f"**Area più debole (media bassa):** '{lowest_cat_name}' ({lowest_cat_score:.2f}).")
if not driver_df.empty:
avg_corr = driver_df['Correlazione'].mean()
avg_score_all_q = driver_df['Punteggio Medio'].mean()
low_score_threshold = avg_score_all_q
high_impact_threshold = avg_corr
critical_drivers = driver_df[
(driver_df['Punteggio Medio'] < low_score_threshold) &
(driver_df['Correlazione'] > high_impact_threshold)
].sort_values('Correlazione', ascending=False)
if not critical_drivers.empty:
st.markdown("**Priorità Alte (Bassa Performance, Alto Impatto):**")
for _, row in critical_drivers.head(5).iterrows():
st.markdown(f"- *{row['Domanda_Breve']}* (Cat: {row['Categoria']}, Score: {row['Punteggio Medio']:.2f}, Corr: {row['Correlazione']:.2f})")
st.warning("Intervenire su queste domande potrebbe avere il maggior impatto positivo sulla soddisfazione generale.")
else:
st.info("Nessuna domanda trovata nel quadrante 'Priorità Alte' con le soglie attuali.")
# Generic suggestions
suggestions = {
"Stress e benessere": "Considerare iniziative per la gestione dello stress, flessibilità lavorativa, e supporto psicologico.",
# ... (rest of suggestions map) ...
"Apertura e inclusione": "Programmi D&I, garantire libertà di espressione e sicurezza psicologica."
}
default_suggestion = "Approfondire le cause specifiche tramite focus group o interviste mirate."
st.markdown("**Possibili Azioni Generiche per l'Area più Debole:**")
st.info(suggestions.get(lowest_cat_name, default_suggestion))
else: st.write("Nessun dato medio per categoria disponibile per generare suggerimenti.")
else:
st.info("Dati insufficienti per rilevare anomalie o fornire suggerimenti.")
# ==============================================================================
# --- TAB Advanced: More Complex Visualizations ---
# ==============================================================================
with tab_advanced:
st.header("📈 Grafici Avanzati (Filtrati)")
if df_filtered is None or df_filtered.empty:
st.warning("Nessun dato disponibile con i filtri selezionati.")
elif not numeric_question_cols:
st.warning("Nessuna domanda numerica trovata per le analisi avanzate.")
else:
# Use the melted data prepared in the Comparisons tab if available
if 'df_melted_f' not in locals() or df_melted_f.empty:
# Try to recreate df_melted_f if not available
numeric_cols_in_filtered = [col for col in numeric_question_cols if col in df_filtered.columns]
valid_demographic_cols = [col for col in demographic_cols if col in df_filtered.columns]
if valid_demographic_cols and numeric_cols_in_filtered:
df_melted_f = get_melted_data(df_filtered, valid_demographic_cols, numeric_cols_in_filtered, question_to_category_map)
else:
df_melted_f = pd.DataFrame()
if df_melted_f.empty and not numeric_cols_in_filtered: # Check again if still empty or no numerics
st.warning("Dati insufficienti per i grafici avanzati.")
else:
# --- 1. Correlation Heatmap ---
st.subheader("🔥 Heatmap di Correlazione tra Domande Numeriche")
corr_method_options = ['pearson']
if SCIPY_AVAILABLE:
corr_method_options.append('spearman')
corr_method_adv = st.radio("Metodo Correlazione:", corr_method_options, horizontal=True, key="corr_method_adv")
numeric_cols_in_filtered_adv = [col for col in numeric_question_cols if col in df_filtered.columns and df_filtered[col].nunique(dropna=True) > 1]
if len(numeric_cols_in_filtered_adv) > 1:
# Etichette univoche e leggibili
corr_labels = {
q: (f"{str(q)[:27]}..." if len(str(q)) > 30 else str(q)) + f" [{i}]"
for i, q in enumerate(numeric_cols_in_filtered_adv)
}
df_corr = df_filtered[numeric_cols_in_filtered_adv].rename(columns=corr_labels)
try:
corr_matrix = df_corr.corr(method=corr_method_adv)
if not corr_matrix.empty:
fig_heatmap = px.imshow(
corr_matrix,
text_auto=".2f",
aspect="auto",
color_continuous_scale='RdBu_r',
range_color=[-1, 1],
template=PLOTLY_TEMPLATE,
title=f"Heatmap Correlazione ({corr_method_adv.capitalize()}) tra Domande"
)
heatmap_height = max(600, len(numeric_cols_in_filtered_adv) * 20)
fig_heatmap.update_layout(height=heatmap_height, xaxis_tickangle=-45)
st.plotly_chart(fig_heatmap, use_container_width=True)
st.caption("Rosso = correlazione negativa, Blu = correlazione positiva.")
else:
st.warning("Matrice di correlazione vuota.")
except Exception as e:
st.warning(f"Errore nel calcolo heatmap: {e}")
else:
st.info("Servono almeno due domande numeriche con varianza per la heatmap.")
st.markdown("---")
# --- 2. Radar Chart ---
st.subheader("🕸️ Radar Chart: Confronto Medie Categorie per Gruppo Demografico")
if not avg_scores_per_category_f.empty and valid_demographic_cols and not df_melted_f.empty:
radar_demo_options = [col for col in valid_demographic_cols if df_filtered[col].nunique() > 1]
if radar_demo_options:
radar_demo_col = st.selectbox("Seleziona Gruppo Demografico per Confronto Radar:", radar_demo_options, key="radar_demo")
available_groups = sorted(df_filtered[radar_demo_col].astype(str).unique())
available_groups = [g for g in available_groups if g != 'Non specificato'] # Exclude 'Non specificato'?
if len(available_groups) > 1:
groups_to_compare = st.multiselect(f"Seleziona '{radar_demo_col}' da confrontare:", options=available_groups, default=available_groups[:min(len(available_groups), 3)], key="radar_groups")
if groups_to_compare:
radar_data = df_melted_f[df_melted_f[radar_demo_col].isin(groups_to_compare)]
avg_radar = radar_data.groupby(['Categoria', radar_demo_col], observed=True)['Punteggio'].mean().unstack()
avg_radar = avg_radar.dropna(axis=0, how='all') # Drop categories with no data
if not avg_radar.empty:
categories_radar = avg_radar.index.tolist()
fig_radar = go.Figure()
color_sequence = px.colors.qualitative.Plotly # Use a color sequence
for i, group in enumerate(groups_to_compare):
if group in avg_radar.columns:
fig_radar.add_trace(go.Scatterpolar(
r=avg_radar[group].values, theta=categories_radar, fill='toself', name=str(group),
line_color=color_sequence[i % len(color_sequence)] # Cycle through colors
))
min_scale_radar, max_scale_radar = response_scale if response_scale else (1, 6)
fig_radar.update_layout(
polar=dict(radialaxis=dict(visible=True, range=[min_scale_radar-0.5, max_scale_radar+0.5])),
showlegend=True, title=f"Confronto Medie Categorie Radar per {radar_demo_col}", template=PLOTLY_TEMPLATE )
st.plotly_chart(fig_radar, use_container_width=True)
else: st.warning(f"Nessun dato medio disponibile per i gruppi selezionati.")
else: st.info(f"Seleziona almeno un gruppo.")
else: st.info(f"Solo un gruppo disponibile in '{radar_demo_col}'.")
else: st.info("Nessuna colonna demografica con valori multipli per il confronto Radar.")
else: st.info("Dati insufficienti (medie categorie, demo, melted) per il grafico Radar.")
st.markdown("---")
# --- 3. Parallel Coordinates Plot ---
# (Code for Parallel Coordinates - kept similar, relies on df_melted_f)
st.subheader("|| Parrallel Coordinates: Pattern Medie Categorie per Gruppo")
st.warning("Attenzione: Questo grafico può essere lento o illeggibile con molti dati/categorie.")
if not avg_scores_per_category_f.empty and valid_demographic_cols and not df_melted_f.empty:
cats_parallel_options = avg_scores_per_category_f.index.unique().tolist()
if cats_parallel_options:
default_cats_parallel = cats_parallel_options[:min(len(cats_parallel_options), 8)]
cats_parallel = st.multiselect("Seleziona Categorie (Dimensioni):", cats_parallel_options, default=default_cats_parallel, key="par_cats")
if cats_parallel:
parallel_demo_options = [col for col in valid_demographic_cols if df_filtered[col].nunique() > 1]
if parallel_demo_options:
parallel_demo_col = st.selectbox("Colora Linee per Gruppo Demografico:", parallel_demo_options, key="par_demo")
# Calculate mean scores per selected category and chosen demo group
df_parallel_prep = df_melted_f[df_melted_f['Categoria'].isin(cats_parallel)]
df_parallel = df_parallel_prep.groupby([parallel_demo_col, 'Categoria'], observed=True)['Punteggio'].mean().unstack()
df_parallel = df_parallel.dropna().reset_index()
if not df_parallel.empty and parallel_demo_col in df_parallel.columns:
# Map group names to numerical values for continuous color scale
unique_groups_par = df_parallel[parallel_demo_col].unique()
group_map = {name: i for i, name in enumerate(unique_groups_par)}
df_parallel['color_val'] = df_parallel[parallel_demo_col].map(group_map)
dimensions = []
for cat in cats_parallel:
if cat in df_parallel.columns:
dimensions.append(dict(
range = [response_scale[0], response_scale[1]] if response_scale else [1,6],
label = str(cat)[:20] + '...' if len(str(cat))>20 else str(cat),
values = df_parallel[cat] ))
if dimensions:
color_palette_par = px.colors.qualitative.Plotly
fig_parallel = go.Figure(data=
go.Parcoords(
line = dict(color = df_parallel['color_val'],
colorscale = color_palette_par, # Use qualitative scale directly
showscale = False),
dimensions = dimensions ))
fig_parallel.update_layout( title=f"Medie Categorie per {parallel_demo_col} (Parallel Coordinates)", template=PLOTLY_TEMPLATE)
st.plotly_chart(fig_parallel, use_container_width=True)
# Manual legend
st.write(f"**Legenda Colori ({parallel_demo_col}):**")
cols_legend = st.columns(min(len(group_map), 5))
i = 0
for name, num in group_map.items():
color = color_palette_par[num % len(color_palette_par)]
with cols_legend[i % min(len(group_map), 5)]:
st.markdown(f"■ {name}", unsafe_allow_html=True)
i += 1
else: st.warning("Nessuna dimensione valida per Parallel Coordinates.")
else: st.warning(f"Nessun dato medio aggregato per {parallel_demo_col}.")
else: st.info("Nessuna colonna demografica con valori multipli per colorare le linee.")
else: st.info("Seleziona almeno una categoria (dimensione).")
else: st.info("Nessuna categoria disponibile per Parallel Coordinates.")
else: st.info("Dati insufficienti (medie categorie, demo, melted) per Parallel Coordinates.")
st.markdown("---")
# --- 4. Stacked Area Chart ---
# (Code for Stacked Area Chart - kept similar, relies on df_melted_f)
st.subheader("📊 Stacked Area Chart: Distribuzione Risposte per Categoria su Gruppo Ordinato")
if not df_melted_f.empty and valid_demographic_cols:
ordered_demo_options = [col for col in valid_demographic_cols if 'Eta' in col or 'Anzianita' in col]
if not ordered_demo_options: ordered_demo_options = valid_demographic_cols # Fallback
if ordered_demo_options:
area_demo_col = st.selectbox("Seleziona Gruppo Demografico Ordinato:", ordered_demo_options, key="area_demo")
area_cat_options = avg_scores_per_category_f.index.unique().tolist()
if area_cat_options:
area_category = st.selectbox("Seleziona Categoria:", area_cat_options, key="area_cat")
df_area_prep = df_melted_f[(df_melted_f['Categoria'] == area_category) & df_melted_f[area_demo_col].notna()].copy()
if not df_area_prep.empty:
df_area_prep['Sentiment'] = df_area_prep['Punteggio'].apply(categorize_score)
df_area = df_area_prep.groupby([area_demo_col, 'Sentiment'], observed=True).size().reset_index(name='Conteggio')
df_area['Percentuale'] = df_area.groupby(area_demo_col)['Conteggio'].transform(lambda x: x / float(x.sum()) * 100 if x.sum() > 0 else 0)
category_orders = {}
group_order = None
if 'Eta' in area_demo_col:
age_order_guess = ['Fino a 30 anni', '31-40 anni', '41-50 anni', 'Oltre i 50 anni', 'Non specificato']
actual_groups = df_area[area_demo_col].unique()
group_order = [g for g in age_order_guess if g in actual_groups]
group_order.extend(sorted([g for g in actual_groups if g not in age_order_guess]))
category_orders={area_demo_col: group_order}
# Ensure Sentiment order for stacking
sentiment_order = ["Critico", "Neutrale", "Positivo", "Non Risposto"]
category_orders['Sentiment'] = [s for s in sentiment_order if s in df_area['Sentiment'].unique()]
plot_colors = BUCKET_COLORS.copy()
plot_colors["Non Risposto"] = "#bbbbbb"
if not df_area.empty:
fig_area = px.area(df_area, x=area_demo_col, y='Percentuale', color='Sentiment',
title=f"Distribuzione Sentiment (%) per '{area_category}' per {area_demo_col}",
labels={'Percentuale': '% Rispondenti'},
category_orders=category_orders,
color_discrete_map=plot_colors,
template=PLOTLY_TEMPLATE)
fig_area.update_layout(yaxis_range=[0, 100], yaxis_ticksuffix="%")
st.plotly_chart(fig_area, use_container_width=True)
else: st.warning("Nessun dato aggregato per l'Area Chart.")
else: st.warning(f"Nessun dato trovato per la categoria '{area_category}'.")
else: st.info("Nessuna categoria valida trovata.")
else: st.info("Nessuna colonna demografica disponibile per l'Area Chart.")
else: st.info("Dati insufficienti (melted, demo) per l'Area Chart.")
# --- Download Button ---
st.sidebar.divider()
st.sidebar.subheader("📥 Download Dati Filtrati")
if df_filtered is not None and not df_filtered.empty:
output = BytesIO()
try:
df_to_download = df_filtered.copy()
df_to_download.to_csv(output, index=False, encoding='utf-8', sep=';')
output.seek(0)
st.sidebar.download_button(label="Scarica Dati Filtrati Correnti (CSV)", data=output,
file_name='dati_sondaggio_filtrati_avanzato.csv', mime='text/csv', key='download_csv')
except Exception as e:
st.sidebar.error(f"Errore durante la creazione del CSV: {e}")
else:
st.sidebar.info("Nessun dato filtrato da scaricare.")
# --- Footer ---
st.markdown("---")
# Use a dynamic timestamp
try:
current_time_str = pd.Timestamp.now(tz='Europe/Rome').strftime('%Y-%m-%d %H:%M:%S %Z')
except Exception: # Fallback if timezone fails
current_time_str = pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')
st.caption(f"Dashboard Analisi Clima")
# Altrimenti (se uploaded_file is None), non mostra nulla tranne l'uploader
else:
st.title("🚀 Dashboard Analisi Clima")
st.info("Per iniziare, carica un file CSV usando il widget qui sopra.")