import pandas as pd import streamlit as st import datetime from datetime import datetime, timedelta import plotly.express as px import plotly.graph_objects as go import os import re import logging logging.basicConfig(filename='service_warnings.log', level=logging.WARNING) # Ladda serviceintervall @st.cache_data def load_service_intervals(): file_path = "service_intervall.csv" # Om filen inte finns, skapa en standardfil if not os.path.exists(file_path): st.warning("Serviceintervallfilen hittades inte. Skapar en standardfil...") default_content = """Märkeskod,Modell,Serviceintervall_dagar,Serviceintervall_miltal VOLVO,V90 Cross Country,365,20000 VOLVO,V90,365,20000 VOLVO,V70,365,20000 FORD,Transit,365,15000 FORD,Transit Custom,365,15000 FORD,Focus,365,16000 FORD,Mondeo,730,30000 VW,Caddy,365,20000 VW,Crafter,730,30000 RENAULT,Alaskan,365,20000 RENAULT,Trafic,365,20000 RENAULT,Master,730,30000 OPEL,Combo,365,20000 NISSAN,NV300,365,20000 NISSAN,Navara,365,20000 MERCEDES,Sprinter,730,30000 SKODA,Octavia,365,20000 SKODA,Yeti,365,20000 PEUGEOT,Partner,365,20000 CITROEN,Berlingo,365,20000 AUDI,E-Tron,730,30000 FIAT,Doblo,365,20000 KIA,Ceed,365,20000""" try: with open(file_path, 'w', encoding='utf-8') as f: f.write(default_content) st.success("Standard serviceintervallfil skapad!") except Exception as e: st.error(f"Kunde inte skapa standardfil: {e}") return pd.DataFrame(columns=['Märkeskod', 'Modell', 'Serviceintervall_dagar', 'Serviceintervall_miltal']) try: if not os.access(file_path, os.R_OK): logging.error(f"Kan inte läsa filen på {file_path}. Kontrollera filbehörigheter.") st.error(f"Kan inte läsa filen på {file_path}. Kontrollera filbehörigheter.") return pd.DataFrame(columns=['Märkeskod', 'Modell', 'Serviceintervall_dagar', 'Serviceintervall_miltal']) intervals = pd.read_csv(file_path, sep=',', encoding='utf-8') # Validera kolumner required_columns = ['Märkeskod', 'Modell', 'Serviceintervall_dagar', 'Serviceintervall_miltal'] if not all(col in intervals.columns for col in required_columns): logging.error(f"Serviceintervallfilen saknar obligatoriska kolumner: {required_columns}") st.error(f"Serviceintervallfilen saknar obligatoriska kolumner. Se till att den innehåller: {', '.join(required_columns)}") return pd.DataFrame(columns=required_columns) # Konvertera till numeriska värden intervals['Serviceintervall_dagar'] = pd.to_numeric(intervals['Serviceintervall_dagar'], errors='coerce') intervals['Serviceintervall_miltal'] = pd.to_numeric(intervals['Serviceintervall_miltal'], errors='coerce') # Kontrollera ogiltiga värden invalid_intervals = intervals[ intervals['Serviceintervall_dagar'].isna() | (intervals['Serviceintervall_dagar'] <= 0) | intervals['Serviceintervall_miltal'].isna() | (intervals['Serviceintervall_miltal'] <= 0) ] if not invalid_intervals.empty: logging.warning("Ogiltiga serviceintervall hittades i filen:\n" + invalid_intervals.to_string()) return intervals except Exception as e: logging.error(f"Fel vid laddning av serviceintervall: {str(e)}") st.error(f"Fel vid laddning av serviceintervall: {str(e)}") return pd.DataFrame(columns=['Märkeskod', 'Modell', 'Serviceintervall_dagar', 'Serviceintervall_miltal']) # Ladda data @st.cache_data def load_data(): file_path = "servicehistorik_full.csv" try: if not os.path.exists(file_path): logging.error(f"CSV-filen hittades inte på sökvägen: {file_path}") st.error(f"CSV-filen hittades inte på sökvägen: {file_path}") return pd.DataFrame(), None, None if not os.access(file_path, os.R_OK): logging.error(f"Kan inte läsa filen på {file_path}. Kontrollera filbehörigheter.") st.error(f"Kan inte läsa filen på {file_path}. Kontrollera filbehörigheter.") return pd.DataFrame(), None, None data = pd.read_csv(file_path, sep=',', encoding='utf-8') # Logga antal rader st.write(f"Antal rader i CSV-filen: {len(data)}") # Robust datumparsning för Orderdatum och Fakturadatum def parse_date_column(date_series, column_name): parsed_dates = [] invalid_rows = [] for idx, date_str in enumerate(date_series): if pd.isna(date_str): parsed_dates.append(pd.NaT) continue try: # Testa olika datumformat parsed_date = pd.to_datetime(date_str, format='%y-%m-%d', errors='coerce') if pd.notna(parsed_date): parsed_dates.append(parsed_date) continue parsed_date = pd.to_datetime(date_str, format='%Y-%m-%d', errors='coerce') if pd.notna(parsed_date): parsed_dates.append(parsed_date) continue parsed_date = pd.to_datetime(date_str, errors='coerce') if pd.notna(parsed_date): parsed_dates.append(parsed_date) continue parsed_dates.append(pd.NaT) invalid_rows.append((idx, date_str)) except Exception as e: parsed_dates.append(pd.NaT) invalid_rows.append((idx, date_str)) if invalid_rows: logging.warning(f"Ogiltiga datumvärden hittades i kolumn '{column_name}':\n" + pd.DataFrame(invalid_rows, columns=['Rad', 'Värde']).to_string()) return pd.Series(parsed_dates, index=date_series.index) data['Orderdatum'] = parse_date_column(data['Orderdatum'], 'Orderdatum') data['Fakturadatum'] = parse_date_column(data['Fakturadatum'], 'Fakturadatum') # Hantera Första_reg_datum def parse_date(date_str): if pd.isna(date_str): return pd.NaT try: parsed_date = pd.to_datetime(date_str, format='%y-%m-%d', errors='coerce') if pd.notna(parsed_date): return parsed_date parsed_date = pd.to_datetime(date_str, format='%Y-%m-%d', errors='coerce') if pd.notna(parsed_date): return parsed_date parsed_date = pd.to_datetime(date_str, errors='coerce') return parsed_date except: return pd.NaT data['Första_reg_datum'] = data['Första_reg_datum'].apply(parse_date) # Rensa modellnamn för att ta bort extra information def clean_model_name(model): if pd.isna(model): return model # Ta bort text som "Första reg. datum" och tekniska specifikationer model = re.sub(r'Första reg\. datum.*$', '', model).strip() # Ta bort extra specifikationer som "1.6 TDi Diesel Skåp" model = re.sub(r',.*$', '', model).strip() return model data['Modell'] = data['Modell'].apply(clean_model_name) # Kontrollera ogiltiga datum invalid_dates = data[data['Orderdatum'].isna() | data['Fakturadatum'].isna() | data['Första_reg_datum'].isna()] if not invalid_dates.empty: logging.warning("Rader med ogiltiga datumvärden:\n" + invalid_dates[['Reg.nr', 'Orderdatum', 'Fakturadatum', 'Första_reg_datum']].assign( Orderdatum=lambda x: x['Orderdatum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd'), Fakturadatum=lambda x: x['Fakturadatum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd'), Första_reg_datum=lambda x: x['Första_reg_datum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd') ).to_string()) # Konvertera mätarställning till numeriskt data['Mätarställning'] = pd.to_numeric(data['Mätarställning'], errors='coerce') # Extrahera årsmodell data['Årsmodell'] = data['Första_reg_datum'].dt.year # Validera årsmodell current_year = datetime.now().year invalid_years = data['Årsmodell'].notna() & ((data['Årsmodell'] < 1990) | (data['Årsmodell'] > current_year)) if invalid_years.any(): logging.warning(f"Vissa fordon har ogiltiga årsmodeller (före 1990 eller efter {current_year}):\n" + data[invalid_years][['Reg.nr', 'Första_reg_datum', 'Årsmodell']].assign( Första_reg_datum=lambda x: x['Första_reg_datum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd') ).to_string()) data.loc[invalid_years, 'Årsmodell'] = None # Validera mätarställning invalid_mileage = data['Mätarställning'].notna() & ((data['Mätarställning'] < 0) | (data['Mätarställning'] > 500000)) if invalid_mileage.any(): logging.warning("Vissa fordon har ogiltiga mätarställningar (negativa eller över 500,000 km):\n" + data[invalid_mileage][['Reg.nr', 'Fakturadatum', 'Mätarställning']].assign( Fakturadatum=lambda x: x['Fakturadatum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd') ).to_string()) data.loc[invalid_mileage, 'Mätarställning'] = None # Kontrollera dubblerade mätarställningar duplicate_mileage = data.groupby(['Reg.nr', 'Mätarställning']).size().reset_index(name='count') duplicate_mileage = duplicate_mileage[duplicate_mileage['count'] > 1] if not duplicate_mileage.empty: logging.warning("Vissa fordon har identiska mätarställningar i flera poster:\n" + duplicate_mileage[['Reg.nr', 'Mätarställning', 'count']].to_string()) # Logga data st.write(f"Totalt antal rader laddade: {len(data)}") st.write(f"Antal unika fordon: {len(data[['Reg.nr', 'Chassinummer']].drop_duplicates())}") # Förbered data för dashboard-visning unique_models = data[['Märkeskod', 'Modell']].drop_duplicates().sort_values(['Märkeskod', 'Modell']) reg_date_check = data[['Reg.nr', 'Märkeskod', 'Första_reg_datum', 'Årsmodell']].drop_duplicates().assign( Första_reg_datum=lambda x: x['Första_reg_datum'].apply(lambda d: d.strftime('%Y-%m-%d') if pd.notna(d) else 'Okänd') ) return data, unique_models, reg_date_check except FileNotFoundError: logging.error(f"Kunde inte hitta filen på {file_path}. Kontrollera att filen finns och att sökvägen är korrekt.") st.error(f"Kunde inte hitta filen på {file_path}. Kontrollera att filen finns och att sökvägen är korrekt.") return pd.DataFrame(), None, None except PermissionError: logging.error(f"Tillstånd nekades för att läsa filen på {file_path}. Kontrollera filbehörigheter.") st.error(f"Tillstånd nekades för att läsa filen på {file_path}. Kontrollera filbehörigheter.") return pd.DataFrame(), None, None except Exception as e: logging.error(f"Ett fel uppstod vid laddning av data: {str(e)}") st.error(f"Ett fel uppstod vid laddning av data: {str(e)}") return pd.DataFrame(), None, None # Beräkna nästa service def calculate_next_service(vehicle_data, intervals): if len(vehicle_data) == 0 or vehicle_data['Fakturadatum'].isna().all(): logging.warning(f"Ingen giltig servicedata för fordonet. Kan inte beräkna nästa service.") return None, None valid_services = vehicle_data[vehicle_data['Fakturadatum'].notna()] if valid_services.empty: logging.warning(f"Ingen giltig servicedata för fordonet. Kan inte beräkna nästa service.") return None, None # Använd den senaste giltiga serviceposten latest_service = valid_services.sort_values('Fakturadatum').iloc[-1] last_service_date = latest_service['Fakturadatum'] last_mileage = latest_service['Mätarställning'] # Kontrollera att last_service_date är giltigt if pd.isna(last_service_date): logging.warning(f"Senaste servicedatum är ogiltigt för fordonet. Kan inte beräkna nästa service.") return None, None # Hämta serviceintervall för bilmärke och modell brand = vehicle_data['Märkeskod'].iloc[0] model = vehicle_data['Modell'].iloc[0] matching_interval = intervals[ (intervals['Märkeskod'] == brand) & (intervals['Modell'] == model) ] if not matching_interval.empty: avg_time_interval = matching_interval['Serviceintervall_dagar'].iloc[0] avg_mileage_interval = matching_interval['Serviceintervall_miltal'].iloc[0] # Kontrollera att intervallen är giltiga if pd.isna(avg_time_interval) or avg_time_interval <= 0: logging.warning(f"Ogiltigt serviceintervall (dagar: {avg_time_interval}) för {brand} {model}. Använder standardvärde (365 dagar).") avg_time_interval = 365 if pd.isna(avg_mileage_interval) or avg_mileage_interval <= 0: logging.warning(f"Ogiltigt serviceintervall (miltal: {avg_mileage_interval}) för {brand} {model}. Använder standardvärde (15000 km).") avg_mileage_interval = 15000 else: # Fallback till standardvärden logging.warning(f"Ingen serviceintervall hittades för {brand} {model}. Använder standardvärden (365 dagar, 15000 km).") avg_time_interval = 365 avg_mileage_interval = 15000 # Beräkna nästa service try: next_service_by_date = last_service_date + timedelta(days=int(avg_time_interval)) next_service_by_mileage = last_mileage + avg_mileage_interval if pd.notna(last_mileage) else None except Exception as e: logging.error(f"Fel vid beräkning av nästa service för {brand} {model}: {str(e)}") return None, None return next_service_by_date, next_service_by_mileage # Formatera datum korrekt def format_date(date_value): if pd.isna(date_value): return None try: return date_value.strftime('%Y-%m-%d') except: return None # Formatera miltal till tusentalsseparerade km def format_mileage(mileage): if pd.isna(mileage): return None try: return f"{int(mileage):,} km".replace(",", " ") except: return None # Huvudapplikation def main(): st.set_page_config(page_title="Fordonsservicehanteringssystem", layout="wide") st.title("🚗 Fordonsservicehanteringssystem") # Debug-info st.write("Aktuell arbetskatalog:", os.getcwd()) st.write("Filer i mappen:", os.listdir('.')) # Ladda serviceintervall intervals = load_service_intervals() # Ladda servicedata data, unique_models, reg_date_check = load_data() if data.empty: st.error("Ingen data kunde laddas. Kontrollera CSV-filen och försök igen.") return st.sidebar.header("Meny") menu_option = st.sidebar.radio("Välj vy:", ["Översiktsdashboard", "Fordonsdetaljer", "Servicehistorik", "Statistik"]) st.sidebar.header("Filtrera på bilmärke") all_brands = sorted(data['Märkeskod'].dropna().unique()) st.sidebar.write(f"Tillgängliga märken: {all_brands}") selected_brands = st.sidebar.multiselect( "Välj bilmärken:", options=all_brands, default=all_brands ) if selected_brands: filtered_data = data[data['Märkeskod'].isin(selected_brands)] else: filtered_data = data logging.warning("Inga märken valda, visar alla fordon.") vehicles = filtered_data[['Reg.nr', 'Chassinummer', 'Modell', 'Årsmodell', 'Märkeskod']].drop_duplicates(subset=['Reg.nr', 'Chassinummer']) st.write(f"Antal unika fordon i filtrerad data: {len(vehicles)}") if vehicles.empty: st.error("Inga fordon hittades med de valda filtren. Kontrollera märkesval eller data.") return if menu_option == "Översiktsdashboard": # Beräkna fordonsstatus för dashboard vehicle_status = [] for _, vehicle in vehicles.iterrows(): reg_nr = vehicle['Reg.nr'] vehicle_data = filtered_data[filtered_data['Reg.nr'] == reg_nr] next_date, next_mileage = calculate_next_service(vehicle_data, intervals) if next_date: days_until_service = (next_date - datetime.now()).days status = "🔴 Försenad" if days_until_service < 0 else "🟡 Snart" if days_until_service < 30 else "🟢 OK" # Formatera datum korrekt latest_service_date = vehicle_data['Fakturadatum'].max() formatted_latest_service = format_date(latest_service_date) if pd.notna(latest_service_date) else None formatted_next_date = format_date(next_date) if pd.notna(next_date) else None vehicle_status.append({ 'Reg.nr': reg_nr, 'Märke': vehicle['Märkeskod'], 'Modell': vehicle['Modell'], 'Årsmodell': int(vehicle['Årsmodell']) if pd.notna(vehicle['Årsmodell']) else None, 'Senaste service': formatted_latest_service, 'Nästa service (datum)': formatted_next_date, 'Nästa service (km)': round(next_mileage) if pd.notna(next_mileage) else None, 'Status': status }) status_df = pd.DataFrame(vehicle_status) if status_df.empty: st.warning("Ingen servicedata tillgänglig för de valda fordonen.") else: # Konvertera kolumner till rätt datatyper status_df['Nästa service (km)'] = pd.to_numeric(status_df['Nästa service (km)'], errors='coerce') # 1. Fordon som behöver service st.header("Fordon som behöver service") need_service_df = status_df[status_df['Status'].isin(["🔴 Försenad", "🟡 Snart"])] if need_service_df.empty: st.info("Inga fordon behöver service just nu.") else: def color_status(val): color = 'red' if val == "🔴 Försenad" else 'orange' if val == "🟡 Snart" else 'green' return f'color: {color}' # Formatera för visning display_df = need_service_df.copy() display_df['Årsmodell'] = display_df['Årsmodell'].fillna('Okänd').astype(str).str.replace('.0', '', regex=False) display_df['Senaste service'] = display_df['Senaste service'].fillna('Okänd') display_df['Nästa service (datum)'] = display_df['Nästa service (datum)'].fillna('Okänd') display_df['Nästa service (km)'] = display_df['Nästa service (km)'].apply(lambda x: format_mileage(x) if pd.notna(x) else 'Okänd') st.dataframe(display_df.style.map(color_status, subset=['Status'])) # 2. Alla fordon st.header("Alla fordon") # Formatera för visning display_all_df = status_df.copy() display_all_df['Årsmodell'] = display_all_df['Årsmodell'].fillna('Okänd').astype(str).str.replace('.0', '', regex=False) display_all_df['Senaste service'] = display_all_df['Senaste service'].fillna('Okänd') display_all_df['Nästa service (datum)'] = display_all_df['Nästa service (datum)'].fillna('Okänd') display_all_df['Nästa service (km)'] = display_all_df['Nästa service (km)'].apply(lambda x: format_mileage(x) if pd.notna(x) else 'Okänd') st.dataframe(display_all_df.style.map(color_status, subset=['Status'])) # 3. Servicestatus per bilmärke st.header("Servicestatus per bilmärke") fig = px.bar(status_df, x='Märke', color='Status', title='Servicestatus per bilmärke', color_discrete_map={"🔴 Försenad": "red", "🟡 Snart": "orange", "🟢 OK": "green"}) st.plotly_chart(fig) # 4. Översiktsdashboard för Fordonsflotta st.header("Översiktsdashboard för Fordonsflotta") col1, col2, col3 = st.columns(3) col1.metric("Antal fordon", len(vehicles)) col2.metric("Service OK", len(status_df[status_df['Status'] == "🟢 OK"])) col3.metric("Behöver service", len(status_df[status_df['Status'] != "🟢 OK"])) # 5. Unika Märkeskod/Modell-kombinationer i servicehistorik st.header("Unika Märkeskod/Modell-kombinationer i servicehistorik") if unique_models is not None and not unique_models.empty: st.write(unique_models) else: st.warning("Ingen data om märkeskod/modell-kombinationer tillgänglig.") # 6. Kontroll av Första_reg_datum och Årsmodell st.header("Kontroll av Första_reg_datum och Årsmodell") if reg_date_check is not None and not reg_date_check.empty: st.write(reg_date_check) else: st.warning("Ingen data om första registreringsdatum och årsmodell tillgänglig.") # 7. Innehåll i service_intervall.csv st.header("Innehåll i service_intervall.csv") if intervals is not None and not intervals.empty: st.write(intervals) else: st.warning("Ingen data från serviceintervallfilen tillgänglig.") st.info("Skapa en service_intervall.csv-fil med följande kolumner: Märkeskod, Modell, Serviceintervall_dagar, Serviceintervall_miltal") elif menu_option == "Fordonsdetaljer": st.header("Fordonsdetaljer") selected_vehicle = st.selectbox("Välj fordon:", vehicles['Reg.nr'].unique(), key="vehicle_select") if selected_vehicle: vehicle_data = filtered_data[filtered_data['Reg.nr'] == selected_vehicle].sort_values('Fakturadatum', ascending=False) vehicle_info = vehicles[vehicles['Reg.nr'] == selected_vehicle].iloc[0] st.subheader(f"Information om {selected_vehicle}") col1, col2, col3, col4 = st.columns(4) col1.write(f"**Märke:** {vehicle_info['Märkeskod']}") col2.write(f"**Modell:** {vehicle_info['Modell']}") col3.write(f"**Årsmodell:** {int(vehicle_info['Årsmodell']) if pd.notna(vehicle_info['Årsmodell']) else 'Okänd'}") col4.write(f"**Chassinummer:** {vehicle_info['Chassinummer']}") next_date, next_mileage = calculate_next_service(vehicle_data, intervals) if next_date: days_until_service = (next_date - datetime.now()).days st.subheader("Servicestatus") col1, col2, col3 = st.columns(3) latest_service_date = vehicle_data['Fakturadatum'].max() col1.metric("Senaste service", format_date(latest_service_date) if pd.notna(latest_service_date) else "Okänd") col2.metric("Nästa service", format_date(next_date) if pd.notna(next_date) else "Okänd") col3.metric("Dagar kvar", days_until_service, delta=None, delta_color="inverse" if days_until_service < 30 else "normal") latest_mileage = vehicle_data['Mätarställning'].max() col1.metric("Senaste mätarställning", format_mileage(latest_mileage) if pd.notna(latest_mileage) else "Okänd") col2.metric("Nästa service (km)", format_mileage(next_mileage) if pd.notna(next_mileage) else "Okänd") if days_until_service < 0: st.error("Service är försenad! Boka service snarast.") elif days_until_service < 30: st.warning("Service behövs inom kort. Överväg att boka tid.") st.subheader("Servicehistorik") if not vehicle_data.empty: display_history = vehicle_data[['Fakturadatum', 'Mätarställning', 'Arbetsbeskrivningar', 'Totalt_inkl_moms']].copy() display_history['Fakturadatum'] = display_history['Fakturadatum'].apply(lambda d: format_date(d) if pd.notna(d) else 'Okänd') display_history['Mätarställning'] = display_history['Mätarställning'].apply(lambda x: format_mileage(x) if pd.notna(x) else 'Okänd') display_history['Totalt_inkl_moms'] = display_history['Totalt_inkl_moms'].apply(lambda x: f"{int(x):,} kr".replace(",", " ") if pd.notna(x) else 'Okänd') st.dataframe(display_history) else: st.info("Ingen servicehistorik tillgänglig för detta fordon.") elif menu_option == "Servicehistorik": st.header("Servicehistorik") col1, col2 = st.columns(2) with col1: start_date = st.date_input("Startdatum", datetime.now() - timedelta(days=365)) with col2: end_date = st.date_input("Slutdatum", datetime.now()) filtered_data_date = filtered_data[(filtered_data['Fakturadatum'] >= pd.to_datetime(start_date)) & (filtered_data['Fakturadatum'] <= pd.to_datetime(end_date))] if filtered_data_date.empty: st.warning("Ingen servicedata hittades för det valda datumintervallet.") else: display_data = filtered_data_date[['Märkeskod', 'Reg.nr', 'Fakturadatum', 'Mätarställning', 'Arbetsbeskrivningar', 'Totalt_inkl_moms']].copy() display_data['Fakturadatum'] = display_data['Fakturadatum'].apply(lambda d: format_date(d) if pd.notna(d) else 'Okänd') display_data['Mätarställning'] = display_data['Mätarställning'].apply(lambda x: format_mileage(x) if pd.notna(x) else 'Okänd') display_data['Totalt_inkl_moms'] = display_data['Totalt_inkl_moms'].apply(lambda x: f"{int(x):,} kr".replace(",", " ") if pd.notna(x) else 'Okänd') st.dataframe(display_data) st.subheader("Kostnadssammanställning") cost_summary = filtered_data_date.groupby(['Märkeskod', 'Reg.nr'])['Totalt_inkl_moms'].agg(['sum', 'count']).reset_index() cost_summary.columns = ['Märke', 'Reg.nr', 'Total kostnad', 'Antal service'] if not cost_summary.empty: cost_summary['Total kostnad'] = cost_summary['Total kostnad'].fillna(0) fig = px.bar(cost_summary, x='Reg.nr', y='Total kostnad', color='Märke', title='Servicekostnader per fordon') st.plotly_chart(fig) elif menu_option == "Statistik": st.header("Statistik och Analys") service_count = filtered_data.groupby(['Märkeskod', 'Modell']).size().reset_index(name='Antal service') if not service_count.empty: fig1 = px.bar(service_count, x='Modell', y='Antal service', color='Märkeskod', title='Antal service per fordonsmodell') st.plotly_chart(fig1) avg_cost = filtered_data.groupby(['Märkeskod', 'Modell'])['Totalt_inkl_moms'].mean().reset_index() if not avg_cost.empty: fig2 = px.bar(avg_cost, x='Modell', y='Totalt_inkl_moms', color='Märkeskod', title='Genomsnittlig servicekostnad per modell') st.plotly_chart(fig2) timeline_data = filtered_data.groupby([filtered_data['Fakturadatum'].dt.to_period('M'), 'Märkeskod']).size().reset_index(name='Antal service') if not timeline_data.empty: timeline_data['Fakturadatum'] = timeline_data['Fakturadatum'].astype(str) fig3 = px.line(timeline_data, x='Fakturadatum', y='Antal service', color='Märkeskod', title='Serviceaktivitet över tid') st.plotly_chart(fig3) if __name__ == "__main__": main()