Upload 2 files

src/01_TagesMuetter_RobertaBovoEdition.py

@@ -0,0 +1,2026 @@
+from distutils import filelist
+from os import path
+from unicodedata import numeric
+import numpy as np
+import pandas as pd
+import os
+import sys
+
+pd.set_option("future.no_silent_downcasting", True)
+import copy
+import xlsxwriter
+import streamlit as st
+
+import streamlit as ste  # cerchiamo di fare in modo che rimanga una soluzione temporanea
+
+# from streamlit.uploaded_file_manager import UploadedFile as FileUploadBase
+from st_aggrid import AgGrid
+from st_aggrid.grid_options_builder import GridOptionsBuilder
+from this import d
+from datetime import date, datetime
+
+from typing import Optional, List, Dict, Any
+import re
+
+# Get the absolute path to the script's directory
+current_dir = os.path.dirname(os.path.abspath(__file__))
+# Get the parent directory
+parent_dir = os.path.dirname(current_dir)
+# Add parent directory to sys.path
+sys.path.append(parent_dir)
+
+from interface import makeInterface
+from helpertools_TM import helpers
+from reportmaker import ReportGenerator
+from valoriEtErrori import valoriEtErrori
+
+st.set_page_config(
+    page_title="Controllo Errori TAGESMÜTTER", layout="wide", page_icon="🤗"
+)  # 👽9
+st.markdown("# CONTROLLO ERRORI TAGESMUETTER")
+st.markdown('## Roberta Bovo Special Edition 🤗 (ver. 4.1.0)')
+
+# Add vertical spacing to create better separation from file uploader
+st.markdown("<div style='margin-bottom: 50px;'></div>", unsafe_allow_html=True)
+
+# st.write(f"{ReportGenerator.get_version(1)}, {helpers.get_version(1)}, {makeInterface.get_version(1)}")
+
+# st.sidebar.markdown(f"### Impostazioni controlli TAGESMÜTTER") # ffff
+
+
+class trovaErrori:
+    def __init__(self, df, interface, df_gemeinden, df_allegato666):
+        self.checks = interface.checks
+        self.df_allegato666 = df_allegato666
+        self.uploaded_allegato666 = interface.uploaded_allegato666
+        self.ANNO_RIFERIMENTO = interface.ANNO_RIFERIMENTO
+        self.ERRORDICT = valoriEtErrori.ERRORDICT[self.ANNO_RIFERIMENTO]
+        self.COSTANTI = valoriEtErrori.COSTANTI[self.ANNO_RIFERIMENTO]
+        self.df_gemeinden = df_gemeinden
+        self.df = df
+        self.dffinal = pd.DataFrame
+        self.df_bambini_che_impediscono_controllo_superamento_ore = pd.DataFrame
+        
+
+        # let the show start
+        self.check_data()
+
+    def check_data(self) -> None:
+        """
+        Checks the data for errors and performs necessary operations.
+
+        This method iterates through the selected checks, calls the corresponding error checking methods,
+        and updates the status of the checks.
+        """
+        global NO_ZERO
+        column_name = "Ore di assistenza ai sensi della delibera n. 666/2019"
+        NO_ZERO = self.df[column_name].astype("float") > 0
+
+        with interface.TAB2:
+            for check, enabled in self.checks.items():
+                if enabled:
+                    if interface.DEBUGGENERAL:
+                        st.write(check)
+                    try:
+                        # Call the method with the same name as the check.
+                        # I used the 'getattr' function to call the functions in the 'checks' dictionary instead of using 'eval'.
+                        getattr(self, check)()
+                    except AttributeError as ae:
+                        st.error(f"La funzione {check} non esiste; errore: {ae}.")
+                        if interface.TOLLERANZAZERO or interface.DEBUGWARNINGS:
+                            st.error("Elaborazione interrotta")
+                            st.stop()
+                    except TypeError as te:
+                        st.error(
+                            f"Il metodo {check} ha problemi con i tipi di dati; errore: {te}."
+                        )
+                        if interface.TOLLERANZAZERO or interface.DEBUGWARNINGS:
+                            st.error("Elaborazione interrotta")
+                            st.stop()
+                    except Exception as e:
+                        st.error(
+                            f"La funzione {check} non è stata eseguita; errore generico: {e}."
+                        )
+                        if interface.TOLLERANZAZERO or interface.DEBUGWARNINGS:
+                            st.error("Elaborazione interrotta")
+                            st.stop()
+
+    # da qui in poi sono i controlli da eseguire
+    def errCodFisc1(self) -> None:  # refactored
+        """
+        Controlla la validità del codice fiscale.
+
+        Questa funzione rimuove eventuali spazi bianchi all'inizio e alla fine del codice fiscale,
+        quindi controlla se il formato è corretto utilizzando una regex. Se un codice fiscale
+        non è valido, viene segnalato ed aggiunto a una tabella temporanea.
+        """
+
+        # rimuove eventuali spazi bianchi all'inizio e alla fine del codice fiscale
+        self.df["Codice fiscale"] = self.df["Codice fiscale"].str.strip()
+
+        # definiamo condizione logica per trovare codice fiscale invalido usando regex
+        codinvalido = (
+            self.df["Codice fiscale"].str.match(
+                r"[A-Z|a-z][A-Z|a-z][A-Z|a-z][A-Z|a-z][A-Z|a-z][A-Z|a-z]\d\d[A-Z|a-z]\d\d[A-Z|a-z]\d\d\d[A-Z|a-z]"
+            )
+            == False
+        )
+        cond_mask = codinvalido & NO_ZERO
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "errore formato del codice fiscale",
+                "Elenco dei bambini che hanno un codice fiscale nel formato non corretto",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            # settiamo il flag bool per la tabella finale
+            self.df.loc[cond_mask, "errCodFisc1"] = True
+
+    def errCodFisc2(self) -> None:  # refactored
+        """
+        Validates the correctness of the "Codice fiscale" (fiscal code) for each child in the DataFrame.
+
+        This method performs the following operations:
+        1. Validates the format of the "Codice fiscale" using a regular expression.
+        2. Filters records with valid "Codice fiscale".
+        3. Determines gender based on the "Codice fiscale" and validates the day of birth.
+        4. Validates the month of birth encoded in the "Codice fiscale" against the actual birth date.
+        5. Validates that the year of birth encoded in the "Codice fiscale" matches the actual birth date.
+        6. Aggregates and identifies records with inconsistencies.
+        7. Displays the errors in an expandable section within Streamlit.
+        8. Provides options to download the error data and displays it in an interactive grid.
+        9. Flags the erroneous records in the main DataFrame.
+
+        Raises:
+            KeyError: If expected columns are missing from `self.df`.
+            ValueError: If data types are incompatible for the operations.
+            Exception: For any other exceptions that occur during execution.
+        """
+        try:
+            # Step 1: Precompile the regex pattern for performance
+            codice_fiscale_pattern: re.Pattern = re.compile(
+                r"^[A-Za-z]{6}\d{2}[A-Za-z]\d{2}[A-Za-z]\d{3}[A-Za-z]$"
+            )
+
+            # Step 2: Validate the format of "Codice fiscale" using the compiled regex
+            codvalido: pd.Series = self.df["Codice fiscale"].str.match(
+                codice_fiscale_pattern, na=False  # Treat NaN as non-matching
+            )
+
+            # Step 3: Filter records with valid "Codice fiscale"
+            dfcod: pd.DataFrame = self.df.loc[codvalido].copy()
+
+            # Ensure required columns are present
+            required_columns = {"Codice fiscale", "Data di nascita", "Cognome", "Nome"}
+            if not required_columns.issubset(dfcod.columns):
+                missing = required_columns - set(dfcod.columns)
+                raise KeyError(f"Colonne mancanti: {missing}")
+
+            # Step 4: Extract components from "Codice fiscale"
+            cf = dfcod["Codice fiscale"]
+
+            # Extract and convert day code
+            giorno_nascita_code: pd.Series = cf.str[9:11].astype(int)
+
+            # Determine gender based on day code
+            is_male: pd.Series = giorno_nascita_code < 40
+            is_female: pd.Series = giorno_nascita_code >= 40
+
+            # Extract actual day from "Data di nascita"
+            data_nascita = pd.to_datetime(dfcod["Data di nascita"], errors="coerce")
+            actual_day: pd.Series = data_nascita.dt.day
+            actual_month: pd.Series = data_nascita.dt.month
+            actual_year: pd.Series = data_nascita.dt.year
+
+            # Step 5: Validate day of birth
+            day_mismatch_male: pd.Series = is_male & (actual_day != giorno_nascita_code)
+            day_mismatch_female: pd.Series = is_female & (
+                actual_day != (giorno_nascita_code - 40)
+            )
+
+            # Step 6: Validate year of birth
+            year_code: pd.Series = 2000 + cf.str[6:8].astype(int)
+            year_mismatch: pd.Series = actual_year != year_code
+
+            # Step 7: Validate month of birth
+            mese_mapping: Dict[str, int] = {
+                "A": 1,
+                "B": 2,
+                "C": 3,
+                "D": 4,
+                "E": 5,
+                "H": 6,
+                "L": 7,
+                "M": 8,
+                "P": 9,
+                "R": 10,
+                "S": 11,
+                "T": 12,
+                # Invalid or unused letters mapped to 99
+                "F": 99,
+                "G": 99,
+                "I": 99,
+                "J": 99,
+                "K": 99,
+                "N": 99,
+                "O": 99,
+                "Q": 99,
+                "U": 99,
+                "V": 99,
+                "W": 99,
+                "X": 99,
+                "Y": 99,
+                "Z": 99,
+            }
+
+            mese_codice: pd.Series = (
+                cf.str[8].str.upper().map(mese_mapping).fillna(99).astype(int)
+            )
+            month_mismatch: pd.Series = actual_month != mese_codice
+
+            # Step 8: Aggregate all mismatches
+            cond_mask: pd.Series = (
+                day_mismatch_male | day_mismatch_female | month_mismatch | year_mismatch
+            )
+            dob_col = "Data di nascita"
+            start_col = "Data inizio contratto (o data inizio assistenza se diversa)"
+            # Check if any errors are found
+            if cond_mask.any():
+                num_errori: int = cond_mask.sum()
+                # Sort the dataframe and create a temporary dataframe for display
+                results: pd.DataFrame = dfcod.loc[cond_mask].copy()
+
+                # Convert date columns to strings if required by the interface
+                results = helper.convert_dates_if_needed(results, [])
+
+                # st.write(results)
+                interface.make_expander(
+                    "errore data nascita per codice fiscale",
+                    "Elenco dei bambini per cui risulta un'incongruenza relativa alla data di nascita dichiarata e il codice fiscale.\nATTENZIONE: il bambino potrebbe apparire più volte, a seconda di quanti errori vengono trovati.",
+                    num_errori,
+                    results,
+                )
+
+                self.df.loc[
+                    self.df["Codice fiscale"].isin(results["Codice fiscale"]),
+                    "errCodFisc2",
+                ] = True
+
+        except KeyError as ke:
+            st.error(f"Chiave mancante nel DataFrame: {ke}")
+            st.stop()  # Stop further execution
+
+        except ValueError as ve:
+            st.error(f"Valore non valido o incompatibile: {ve}")
+            st.stop()  # Stop further execution
+
+        except Exception as e:
+            st.error(f"Si è verificato un errore inaspettato: {e}")
+            st.stop()  # Stop further execution
+
+    def errCalcoloNumeroBimbi(self) -> None:  # not refactored
+        """
+        Identifies and processes errors related to the calculation of the number of children
+        and their corresponding assistance hours for the reference year.
+
+        This method performs the following operations:
+        1. Resets the index of the main DataFrame.
+        2. Filters records for the reference year (2023).
+        3. Creates a DataFrame (`df666`) excluding duplicate tax codes ("Codice fiscale")
+           while ensuring that the assistance hours are greater than zero.
+        4. Aggregates data to calculate the sum of assistance days and counts of children per municipality.
+        5. Merges aggregated data to form a consolidated DataFrame (`dfx`).
+        6. Merges with additional datasets (`df_gemeinden` and `df_allegato666`) for comprehensive analysis.
+        7. Cleans and formats the consolidated DataFrame.
+        8. Inserts comparison columns to verify consistency between different data sources.
+        9. Calculates and appends summary rows to the DataFrame.
+        10. Displays the final table in an expandable section within Streamlit and provides download options.
+
+        Raises:
+            KeyError: If expected columns are missing from `self.df`, `df_gemeinden`, or `df_allegato666`.
+            Exception: For any other exceptions that occur during DataFrame operations.
+        """
+        # Step 1: Reset the index of the main DataFrame to ensure it's clean
+        self.df = self.df.reset_index(drop=True)
+
+        # Step 2: Proceed only if the reference year is 2023
+        if self.ANNO_RIFERIMENTO in ["2023","2024","2025"]:
+            # Initialize an empty DataFrame `df666` with specified columns
+            df666: pd.DataFrame = pd.DataFrame(
+                columns=[
+                    "Comune",
+                    "Cognome e nome bambino",
+                    "Codice fiscale",
+                    "Ore di assistenza ai sensi della delibera n. 666/2019",
+                ]
+            )
+
+            # Iterate through each record to populate `df666`
+            for ind in self.df.index:
+                # Check if the assistance hours are greater than zero
+                if (
+                    self.df["Ore di assistenza ai sensi della delibera n. 666/2019"][
+                        ind
+                    ]
+                    > 0
+                ):
+                    if df666.empty:
+                        # If `df666` is empty, add the current record
+                        df666 = self.df.loc[[ind]]
+                    else:
+                        # Check for duplicate "Codice fiscale" and "Com_code" to avoid duplicates
+                        is_duplicate: bool = (
+                            (self.df["Codice fiscale"][ind] == df666["Codice fiscale"])
+                            & (self.df["Com_code"][ind] == df666["Com_code"])
+                        ).any()
+                        if not is_duplicate:
+                            # Concatenate the current record if it's not a duplicate
+                            df666 = pd.concat([df666, self.df.loc[[ind]]])
+                        else:
+                            continue  # Skip duplicate records
+
+            # Step 3: Aggregate the sum of assistance days per municipality
+            df1: pd.DataFrame = self.df.groupby("Com_code", as_index=False)[
+                "GiorniAssistenzaAnnoRiferimento"
+            ].apply(lambda x: x[x > 0].sum())
+
+            # Step 4: Count the number of children per municipality with assistance hours > 0
+            df2: pd.DataFrame = df666.groupby("Com_code", as_index=False)[
+                "Ore di assistenza ai sensi della delibera n. 666/2019"
+            ].count()
+
+            # Step 5: Sum the assistance hours per municipality
+            df2bis: pd.DataFrame = self.df.groupby("Com_code", as_index=False)[
+                "Ore di assistenza ai sensi della delibera n. 666/2019"
+            ].apply(lambda x: x[x > 0].sum())
+
+            # Step 6: Sum the assistance hours per municipality again (redundant step)
+            df4: pd.DataFrame = self.df.groupby("Com_code", as_index=False)[
+                "Ore di assistenza ai sensi della delibera n. 666/2019"
+            ].apply(lambda x: x[x > 0].sum())
+
+            # Step 7: Merge all aggregated DataFrames into a consolidated DataFrame `dfx`
+            dfx: pd.DataFrame = pd.merge(df1, df2, on="Com_code", how="outer")
+            dfx = pd.merge(dfx, df2bis, on="Com_code", how="outer")
+            dfx = pd.merge(dfx, df4, on="Com_code", how="outer")
+
+            # Step 8: Rename the columns for clarity
+            dfx.columns = [
+                "Com_code",
+                f"Somma Giorni Assistenza Anno Riferimento {self.ANNO_RIFERIMENTO}",
+                "Numero bambini report Comuni",
+                "Ore di assistenza report Comuni",
+                f"Ore totali rendicontate per il {self.ANNO_RIFERIMENTO}",
+            ]
+            # Sort the DataFrame by "Com_code" in ascending order
+            dfx = dfx.sort_values(by="Com_code", ascending=True)
+
+            # Step 9: Merge with `df_gemeinden` on "Com_code"
+            dfx = pd.merge(dfx, df_gemeinden, on="Com_code", how="outer")
+
+            # Step 10: Merge with `df_allegato666` on "Com_code"
+            lingua: str = df_allegato666.iloc[
+                0, 8
+            ]  # Assuming column index 8 contains language code
+            dfx = pd.merge(dfx, df_allegato666, on="Com_code", how="outer")
+
+            # Step 11: Drop unnecessary columns and rename others for consistency
+            columns_to_drop: list = [
+                "Comune provenienza bambino",
+                f"Somma Giorni Assistenza Anno Riferimento {self.ANNO_RIFERIMENTO}",
+                f"Ore totali rendicontate per il {self.ANNO_RIFERIMENTO}",
+                "PLZ",
+                "Bezirk",
+                "Costo orario",
+                "Costo del servizio",
+                "Entrate compartecipazione",
+                "Ore tariffa maggiorata",
+                "Entrate maggiorazione",
+            ]
+            dfx = dfx.drop(columns=columns_to_drop, axis=1)
+            dfx = dfx.rename(
+                columns={
+                    "Numero utenti": "Numero utenti allegato 666",
+                    "Ore di servizio": "Ore di servizio allegato 666",
+                }
+            )
+
+            # Step 12: Sort and rename columns based on the language code
+            if lingua == "001":
+                dfx = dfx.sort_values(by="Comune")
+                dfx = dfx.rename(columns={"Comune": "Comune provenienza bambino"})
+                dfx = dfx.drop("Gemeinde", axis=1)
+            elif lingua == "006":
+                dfx = dfx.sort_values(by="Gemeinde")
+                dfx = dfx.rename(columns={"Gemeinde": "Comune provenienza bambino"})
+                dfx = dfx.drop("Comune", axis=1)
+
+            # Step 13: Reorder columns to the desired sequence
+            columns_order: list = dfx.columns.tolist()
+            columns_order.insert(
+                1, columns_order.pop(columns_order.index("Comune provenienza bambino"))
+            )
+            columns_order.insert(
+                2, columns_order.pop(columns_order.index("Numero utenti allegato 666"))
+            )
+            columns_order.insert(
+                3,
+                columns_order.pop(columns_order.index("Numero bambini report Comuni")),
+            )
+            columns_order.insert(
+                4,
+                columns_order.pop(columns_order.index("Ore di servizio allegato 666")),
+            )
+            columns_order.insert(
+                5,
+                columns_order.pop(
+                    columns_order.index("Ore di assistenza report Comuni")
+                ),
+            )
+            dfx = dfx[columns_order]
+
+            # Step 14: Replace NaN or empty values with zero
+            dfx = dfx.fillna(0).infer_objects(copy=False)
+
+            # Step 15: Insert comparison columns to verify consistency between data sources
+            dfx.insert(
+                4,
+                "Confronto bambini",
+                dfx["Numero utenti allegato 666"]
+                == dfx["Numero bambini report Comuni"],
+            )
+            dfx.insert(
+                7,
+                "Confronto ore",
+                dfx["Ore di servizio allegato 666"]
+                == dfx["Ore di assistenza report Comuni"],
+            )
+
+            # Step 16: Calculate the sum for specified columns and append as a summary row
+            columns_to_sum: list = [
+                "Numero utenti allegato 666",
+                "Numero bambini report Comuni",
+                "Ore di servizio allegato 666",
+                "Ore di assistenza report Comuni",
+            ]
+            sum_values: pd.Series = dfx[columns_to_sum].sum()
+            sum_df: pd.DataFrame = pd.DataFrame([sum_values], index=["Somma"])
+            dfx = pd.concat([dfx, sum_df])
+
+            # For columns not included in the sum, add NaN in the summary row
+            for col in dfx.columns:
+                if col not in columns_to_sum:
+                    dfx.loc["Somma", col] = pd.NA
+
+            # Step 17: Display the final table in an expandable section within Streamlit
+
+            expndr = st.expander("Tabella conteggio bimbi per comune e tipologia ore")
+            with expndr:
+                st.info("Conteggio dei bambini per tipologia di ora e per comune")
+
+                # Add an empty row for formatting purposes
+                riga_vuota: dict = {"Annotazione": "  "}
+                nuova_riga_df: pd.DataFrame = pd.DataFrame(riga_vuota, index=[0])
+                dfx = pd.concat([dfx, nuova_riga_df], ignore_index=True)
+
+                # Add a row indicating the generation date of the file
+                riga_vuota = {
+                    "Annotazione": f"file generato in data: {date.today().strftime('%d/%m/%Y')}"
+                }
+                nuova_riga_df = pd.DataFrame(riga_vuota, index=[0])
+                dfx = pd.concat([dfx, nuova_riga_df], ignore_index=True)
+
+                # Build grid options for AgGrid
+                gridOptions = interface.buildGrid(dfx)
+
+                # Provide an option to download the consolidated DataFrame as an Excel file
+                interface.download_excel_file(
+                    dfx,
+                    "calcolo_bimbi_per_tipologia_comune_ore.xlsx",
+                    "mantieniColonneErrore",
+                )
+
+                # Display the DataFrame in an interactive grid
+                AgGrid(dfx, gridOptions=gridOptions, enable_enterprise_modules=True)
+                # Note: No flag is set here as it's not required
+
+                # we take only the rows where we found an inconsistency
+                self.df_calcolo_666 = dfx[
+                    (dfx["Confronto bambini"] == False)
+                    | (dfx["Confronto ore"] == False)
+                ]
+
+        # Note: Ensure that all referenced variables and methods (e.g., df_gemeinden, df_allegato666, NO_ZERO, etc.) are defined within the class or passed appropriately.
+
+    def errOreRendicontateZero(self) -> None:  # refactored
+        """
+        Metodo per trovare e elencare i bambini con ore totali rendicontate a zero.
+
+        Parameters:
+            None
+
+        Returns:
+            None
+        """
+
+        condizione: pd.Series = (
+            self.df["Ore di assistenza ai sensi della delibera n. 666/2019"] == 0
+        )
+        cond_mask: pd.Series = condizione & NO_ZERO
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "bambini con ore totali rendicontate uguali a zero",
+                "Elenco dei bambini che hanno un valore di zero nelle ore rendicontate per l'anno {self.ANNO_RIFERIMENTO}",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            # settiamo la colonna bool
+            self.df.loc[condizione, "errOreRendicontateZero"] = True
+
+    def errDateAnnoRiferimento(self) -> None:  # refactored
+        """
+        Check for incongruences in the start and end dates of the contract compared to the reference year.
+        """
+        # Check if the start date is after the reference year
+        condizione_anno_inizio: pd.Series = self.df[
+            "Data inizio contratto (o data inizio assistenza se diversa)"
+        ].dt.year > int(self.ANNO_RIFERIMENTO)
+
+        # Check if the end date is before the reference year
+        condizione_anno_fine: pd.Series = self.df[
+            "Data fine contratto (o data fine assistenza se diversa)"
+        ].dt.year < int(self.ANNO_RIFERIMENTO)
+
+        # Combine the conditions and apply the NO_ZERO filter
+        cond_mask: pd.Series = (condizione_anno_inizio | condizione_anno_fine) & NO_ZERO
+
+        # If there are any incongruences, create an expander section to display them
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                f"incongruenze data inizio o data fine in relazione all'anno di riferimento",
+                "Elenco delle righe per cui sono state trovate incongruenze di data inizio o fine con anno di riferimento\n\r(data inizio > {self.ANNO_RIFERIMENTO} oppure data fine < {self.ANNO_RIFERIMENTO}",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            # Set the flag for incongruences in the original dataframe
+            self.df.loc[condizione_logica, "errDateAnnoRiferimento"] = True
+
+    def errInizioMinoreFine(self) -> None:  # refactored
+        """
+        Check if start date > end date.
+        """
+        start_col = "Data inizio contratto (o data inizio assistenza se diversa)"
+        end_col = "Data fine contratto (o data fine assistenza se diversa)"
+        if start_col not in self.df.columns or end_col not in self.df.columns:
+            return
+
+        bad_mask = self.df[start_col] > self.df[end_col]
+        cond_mask = bad_mask & NO_ZERO
+
+        if cond_mask.any():
+
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "errore date contrattuali",
+                "Elenco dei bambini per cui è stato trovato un errore secondo la condizione:  (dataInizio > dataFine)",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            # Set the flag for errors in the original dataframe
+            self.df.loc[cond_mask, "errInizioMinoreFine"] = True
+
+    def errAgeChild(self) -> None:  # refactored
+        """
+        Check if the child is younger than 90 days at the start of the contract.
+        Sets 'errAgeChild' = True if discovered.
+        """
+        start_col = "Data inizio contratto (o data inizio assistenza se diversa)"
+        dob_col = "Data di nascita"
+        if start_col not in self.df.columns or dob_col not in self.df.columns:
+            return
+
+        # Convert to datetime
+        self.df[start_col] = pd.to_datetime(self.df[start_col], errors="coerce")
+        self.df[dob_col] = pd.to_datetime(self.df[dob_col], errors="coerce")
+
+        age_mask = (self.df[start_col] - self.df[dob_col]).dt.days < 90
+        cond_mask = age_mask & NO_ZERO
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "errore età bambino (< 90 giorni)",
+                "Elenco dei bambini per cui è stato trovato l'errore secondo la condizione: il bambino ha meno di 3 mesi",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            self.df.loc[cond_mask, "errAgeChild"] = True
+
+    def errFineAssistenzaMax4Anni(self) -> None:  # refactored
+        """
+        End date must not exceed 4 years (1464 days) from birthdate.
+        """
+        end_col = "Data fine contratto (o data fine assistenza se diversa)"
+        dob_col = "Data di nascita"
+        if end_col not in self.df.columns or dob_col not in self.df.columns:
+            return
+
+        too_long = (self.df[end_col] - self.df[dob_col]).dt.days > 1464
+        cond_mask = too_long & NO_ZERO
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "errore fine contratto assistenza",
+                "Elenco dei bambini per cui è stato trovato l'errore secondo la condizione: data fine contratto non può essere oltre 4 anni da data di nascita",
+                len(self.df[cond_mask]),
+                dftemp,
+            )
+
+            # Set the flag for incongruences in the original dataframe
+            self.df.loc[cond_mask, "errFineAssistenzaMax4Anni"] = True
+
+    def errKindergarten(self) -> None:  # refactored
+        """
+        Validates kindergarten-related data for each child in the DataFrame.
+
+        This method performs the following operations:
+        1. Checks if the child's birth date is earlier than a specified control date.
+        2. Verifies that the contract end date is within an acceptable range based on the birth year.
+        3. Applies additional conditions based on the reference year.
+        4. Aggregates and identifies records with inconsistencies.
+        5. Displays the errors in an expandable section within Streamlit.
+        6. Provides options to download the error data and displays it in an interactive grid.
+        7. Flags the erroneous records in the main DataFrame.
+
+        --> #modificato in '04.09' il 24/6/2024 su richiesta RobertaB
+
+        If child's birth date < KONTROLLEKINDERGARTEN_DATANASCITA_2,
+        end date must not exceed a certain limit (04.09. of birth_year + 3).
+
+        Raises:
+            KeyError: If expected columns are missing from `self.df`.
+            ValueError: If data types are incompatible for the operations.
+            Exception: For any other exceptions that occur during execution.
+        """
+        try:
+            dob_col = "Data di nascita"
+            end_col = "Data fine contratto (o data fine assistenza se diversa)"
+            # Ensure necessary columns are present
+            required_columns = {dob_col, end_col, "Cognome", "Nome"}
+            if not required_columns.issubset(self.df.columns):
+                missing = required_columns - set(self.df.columns)
+                raise KeyError(
+                    f"Colonne mancanti: {missing}. Impossibile proseguire con il controllo 'Kindergarten'"
+                )
+                return
+
+            # Convert
+            self.df[dob_col] = pd.to_datetime(self.df[dob_col], errors="coerce")
+            self.df[end_col] = pd.to_datetime(self.df[end_col], errors="coerce")
+
+            # Define control date from constants
+            kontrolle_date: pd.Timestamp = pd.to_datetime(
+                self.COSTANTI["KONTROLLEKINDERGARTEN_DATANASCITA_2"], format="%d.%m.%Y"
+            )
+
+            # Step 1: Check if "Data di nascita" is earlier than the control date
+            # Condition: child born before this date
+            older_kids = self.df[dob_col] < kontrolle_date
+
+            # Step 2: Compute the acceptable contract end date ("04.09.{birth_year + 3}")
+            # Extract birth year and compute birth_year + 3
+            # Acceptable end date: 04.09.(birth_year + 3)
+            birth_year_plus_3 = self.df[dob_col].dt.year + 3
+
+            # Create date '04.09.YYYY'
+            acceptance_date = pd.to_datetime(
+                "04.09." + birth_year_plus_3.astype(str),
+                format="%d.%m.%Y",
+                errors="coerce",
+            )
+
+            # Compare "Data fine contratto..." with the acceptable end date
+            bad_end_date = self.df[end_col] > acceptance_date
+
+            cond_mask = older_kids & bad_end_date & NO_ZERO
+
+            # Step 3: Check if any errors are found
+            if cond_mask.any():
+                num_errori: int = cond_mask.sum()
+
+                # Sort the dataframe and create a temporary dataframe for display
+                dftemp = self.df.loc[cond_mask].copy()
+
+                dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+                interface.make_expander(
+                    "errore Kindergarten",
+                    "Elenco dei bambini per cui è stato trovato l'errore secondo la condizione: dataFine > 04.09 dell'anno di nascita + 3 anni",
+                    num_errori,
+                    dftemp,
+                )
+
+                # Flag the erroneous records in the main DataFrame
+                # erroneous_cf = dftemp_sorted["Data di nascita"].unique()  # Adjust if "Codice fiscale" is needed
+                self.df.loc[
+                    cond_mask,
+                    "errKindergarten",
+                ] = True
+
+        except KeyError as ke:
+            st.error(f"Chiave mancante nel DataFrame: {ke}")
+            st.stop()  # Stop further execution
+
+        except ValueError as ve:
+            st.error(f"Valore non valido o incompatibile: {ve}")
+            st.stop()  # Stop further execution
+
+        except Exception as e:
+            st.error(f"Si è verificato un errore inaspettato: {e}")
+            st.stop()  # Stop further execution
+
+    def errGesamtstundenVertragszeitraum(self) -> None:  # not refactored
+        """
+        Identifies and handles errors related to overlapping contract periods
+        across different municipalities for the same "Codice fiscale" (tax code).
+
+        This method performs the following steps:
+        1. Finds tax codes present in multiple municipalities.
+        2. Identifies overlapping contract periods for these tax codes across different municipalities.
+        3. Filters and sorts the relevant data for reporting.
+        4. Checks if the calculated hours exceed the reported hours based on a reference year.
+        5. If errors are found, it displays warnings, provides detailed information, and
+           allows downloading the error data as an Excel file.
+
+        The method updates the DataFrame `self.df` by setting a flag for rows where
+        the proportion of calculated hours is less than the sum of reported hours.
+
+        Raises:
+            KeyError: If expected columns are missing from `self.df`.
+            ValueError: If data types are incompatible for calculations.
+        """
+        # Step 1: Identify tax codes ("Codice fiscale") present in multiple municipalities
+        # Group by "Codice fiscale" and count the number of unique "Comune" (municipality) entries
+        multi_city_codes: List[str] = self.df.groupby("Codice fiscale")[
+            "Comune"
+        ].nunique()
+        multi_city_codes = multi_city_codes[multi_city_codes > 1].index.tolist()
+
+        # Filter the DataFrame to include only rows with tax codes in multiple municipalities
+        df_multi = self.df[self.df["Codice fiscale"].isin(multi_city_codes)]
+
+        # Step 2: Find overlapping contract periods in different municipalities
+        # Merge the DataFrame with itself on "Codice fiscale" to compare different records
+        merged_df = df_multi.merge(df_multi, on="Codice fiscale", suffixes=("_1", "_2"))
+        # Keep only rows where the municipality is different
+        merged_df = merged_df[merged_df["Comune_1"] != merged_df["Comune_2"]]
+
+        # Define the condition for overlapping contract periods
+        overlap_condition = (
+            merged_df["Data inizio contratto (o data inizio assistenza se diversa)_1"]
+            <= merged_df["Data fine contratto (o data fine assistenza se diversa)_2"]
+        ) & (
+            merged_df["Data fine contratto (o data fine assistenza se diversa)_1"]
+            >= merged_df[
+                "Data inizio contratto (o data inizio assistenza se diversa)_2"
+            ]
+        )
+
+        # Apply the overlap condition to filter overlapping pairs
+        overlapping_pairs = merged_df[overlap_condition]
+
+        # Extract unique tax codes that have overlapping periods
+        result_codes_list = overlapping_pairs["Codice fiscale"].unique().tolist()
+
+        # Step 3: Filter the original DataFrame for the identified tax codes
+        filtered_df = self.df[self.df["Codice fiscale"].isin(result_codes_list)]
+        result_df = filtered_df[
+            [
+                "Cognome",
+                "Nome",
+                "Comune",
+                "Data inizio contratto (o data inizio assistenza se diversa)",
+                "Data fine contratto (o data fine assistenza se diversa)",
+                "filename",
+            ]
+        ].reset_index(drop=True)
+
+        # Sort the result DataFrame by "Cognome" and "Nome"
+        result_df = result_df.sort_values(by=["Cognome", "Nome"])
+        self.df_bambini_che_impediscono_controllo_superamento_ore = result_df
+
+        # Step 4: Calculate the number of days in the reference year
+        # Assuming self.ANNO_RIFERIMENTO is a string representing the year, e.g., "2023"
+        nrGiorniAnnoRiferimento = pd.Period(
+            f"{self.ANNO_RIFERIMENTO}-12-31", freq="D"
+        ).day_of_year
+
+        # Calculate the condition where calculated hours exceed reported hours
+        # Note: 1920 is a constant multiplier; adjust as necessary
+        condizioneerrore2 = (
+            (
+                1920
+                * (
+                    self.df.groupby("Codice fiscale")[
+                        "GiorniAssistenzaAnnoRiferimento"
+                    ].transform("sum")
+                )
+                / nrGiorniAnnoRiferimento  # Note: 365 only if not a leap year
+            )
+        ) < self.df.groupby("Codice fiscale")[
+            "Ore di assistenza ai sensi della delibera n. 666/2019"
+        ].transform(
+            "sum"
+        ).astype(
+            "float"
+        )
+
+        # Combine the above condition with another condition (NO_ZERO)
+        # Assuming NO_ZERO is defined elsewhere in the class
+        cond_mask = condizioneerrore2 & NO_ZERO
+
+        # Step 5: If any rows meet the error condition, process and report them
+        if cond_mask.any():
+            dfx = self.df[cond_mask].copy()
+            # Insert a new column "Ore calcolate" with the calculated hours
+            dfx.insert(
+                loc=11,
+                column="Ore calcolate",
+                value=round(
+                    (dfx["GiorniAssistenzaAnnoRiferimento"] * 1920)
+                    / nrGiorniAnnoRiferimento,
+                    2,
+                ),
+            )
+
+            # create a temporary dataframe for display
+            dftemp = dfx.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            # non usiamo la funzione perche' vogliamo la lista dei bimbi che impediscono il controllo nell'expander
+            with st.expander(
+                f"Trovate {len(dftemp)} occorrenze per errore Proportion Maximalstunden überschritten"
+            ):
+                if not self.df_bambini_che_impediscono_controllo_superamento_ore.empty:
+                    st.warning(
+                        "Attenzione: i seguenti bambini non sono stati considerati per il controllo poiché hanno periodi uguali o sovrapposti per comuni diversi."
+                    )
+                    st.write(self.df_bambini_che_impediscono_controllo_superamento_ore)
+
+                st.info(
+                    f"Elenco dei bambini per cui la proporzione delle ore per i giorni di assistenza è inferiore alla somma delle ore rendicontate per il {self.ANNO_RIFERIMENTO}. Secondo la formula: (1920*(giorniAssistenzaAnnoRiferimento)/{nrGiorniAnnoRiferimento}) < (oreTotaliRendicontate {self.ANNO_RIFERIMENTO})"
+                )
+                # st.write(dftemp)
+                # Create a grid display of the sorted dataframe
+                interface.make_grid(
+                    dftemp.sort_values(by=["Cognome", "Nome"]),
+                    "errore Proportion Maximalstunden überschritten",
+                )
+
+                interface.download_excel_file(
+                    dftemp.sort_values(by=["Cognome", "Nome"]),
+                    "errore Proportion Maximalstunden überschritten.xlsx",
+                )
+
+                # Set a boolean flag in the original DataFrame for the identified errors
+                self.df.loc[cond_mask, "errGesamtstundenVertragszeitraum"] = True
+
+    def errSuperatoOreMassime1920(self) -> None:  # refactored
+        """
+        Identifies and handles cases where the total rendered hours per child exceed 1920.
+
+        This method performs the following operations:
+        1. Calculates the total hours rendered per child based on the "Codice fiscale".
+        2. Identifies records where the total hours exceed 1920 and meet the `NO_ZERO` condition.
+        3. If such records exist, it:
+            a. Displays an expandable section in Streamlit with relevant information.
+            b. Provides an option to download the error data as an Excel file.
+            c. Displays the error data in a grid format.
+            d. Flags the identified records in the main DataFrame.
+
+        Raises:
+            KeyError: If expected columns are missing from `self.df`.
+            AttributeError: If required attributes or methods are not defined in the class.
+        """
+        # Step 1: Calculate the total rendered hours per child ("Codice fiscale")
+        # Group by "Codice fiscale" and sum the "Ore di assistenza ai sensi della delibera n. 666/2019"
+        total_hours = (
+            self.df.groupby("Codice fiscale")[
+                "Ore di assistenza ai sensi della delibera n. 666/2019"
+            ]
+            .transform("sum")
+            .astype(float)
+        )
+
+        # Define the condition where total hours exceed 1920
+        condizionelogica2: pd.Series = total_hours > 1920
+
+        # Combine with another condition `NO_ZERO` to filter relevant records
+        # Assuming `NO_ZERO` is a boolean Series defined elsewhere in the class
+        cond_mask: pd.Series = condizionelogica2 & NO_ZERO
+
+        # Step 2: Check if any records meet the error condition
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "errore ore complessive maggiore di 1920",
+                f"Elenco dei bambini per cui la somma delle ore totali rendicontate per il {self.ANNO_RIFERIMENTO} è maggiore di 1920.",
+                len(dftemp[cond_mask]),
+                dftemp,
+            )
+
+            # Step 4: Flag the identified records in the main DataFrame
+            # This sets a boolean flag 'errSuperatoOreMassime1920' to True for affected rows
+            self.df.loc[cond_mask, "errSuperatoOreMassime1920"] = True
+
+    def errBambinoInPiuComuni(self) -> None:  # refactored
+        """
+        Identifies and handles cases where a child ("Bambino") is present in more than one municipality.
+
+        This method performs the following operations:
+        1. Determines if any child is associated with multiple municipalities based on the "Codice fiscale".
+        2. If such cases exist, it:
+            a. Displays an expandable section in Streamlit with relevant information.
+            b. Provides an option to download the error data as an Excel file.
+            c. Displays the error data in a grid format.
+            d. Flags the identified records in the main DataFrame.
+
+        Raises:
+            KeyError: If expected columns ("Codice fiscale", "Comune", "Cognome", "Nome", etc.) are missing from `self.df`.
+            AttributeError: If required attributes or methods (e.g., `converti_date_in_stringhe`, `download_excel_file`, `make_grid`) are not defined in the class.
+        """
+        # Step 1: Identify children present in multiple municipalities
+        # Group the DataFrame by "Codice fiscale" and count the number of unique "Comune" entries
+        condizionlogica1: pd.Series = (
+            self.df.groupby("Codice fiscale")["Comune"].transform("nunique") > 1
+        )
+
+        # Note: Previously combined with `NO_ZERO`, but removed to include all cases of multiple municipalities
+        cond_mask: pd.Series = condizionlogica1
+
+        # Step 2: Check if any records meet the condition of being in multiple municipalities
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "bambini presenti in più comuni",
+                "Elenco dei bambini trovati in più comuni (in più file Excel)",
+                len(dftemp[cond_mask]),
+                dftemp,
+            )
+
+            # Step 4: Flag the identified records in the main DataFrame
+            # This sets a boolean flag 'errBambinoInPiuComuni' to True for affected rows
+            self.df.loc[cond_mask, "errBambinoInPiuComuni"] = True
+
+    def errPresentiAnnotazioni(self) -> None:  # refactored
+        """
+        Identifies and handles cases where a child ("Bambino") has annotations in their "Cognome" (Surname) or "Nome" (Name).
+
+        This method performs the following operations:
+        1. Detects special characters in the "Cognome" and "Nome" columns indicating annotations.
+        2. Filters the DataFrame based on the detection and an additional condition `NO_ZERO`.
+        3. If such records exist, it:
+            a. Displays an expandable section in Streamlit with relevant information.
+            b. Provides an option to download the error data as an Excel file.
+            c. Displays the error data in a grid format.
+            d. Flags the identified records in the main DataFrame.
+
+        Raises:
+            KeyError: If expected columns ("Cognome", "Nome", etc.) are missing from `self.df`.
+            AttributeError: If required attributes or methods (e.g., `converti_date_in_stringhe`, `download_excel_file`, `make_grid`) are not defined in the class.
+        """
+        # Step 1: Detect annotations in the "Cognome" and "Nome" columns using regex for special characters
+        # The regex pattern looks for any of the specified special characters
+        annotation_pattern: str = r"[@_!#$%^&*()<>?/|}{~:]"
+        condizione: pd.Series = self.df["Cognome"].str.contains(
+            annotation_pattern, regex=True, na=False
+        ) & self.df["Nome"].str.contains(annotation_pattern, regex=True, na=False)
+
+        # Step 2: Combine the annotation condition with an additional condition `NO_ZERO`
+        # `NO_ZERO` is assumed to be a boolean Series defined elsewhere in the class
+        cond_mask: pd.Series = condizione & NO_ZERO
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "bambini con annotazioni",
+                "Elenco dei bambini che hanno una annotazione, o direttamente nel nome o nella colonna del numero progressivo (dal quale viene cancellato e aggiunto al nome)",
+                len(dftemp[cond_mask]),
+                dftemp,
+            )
+
+            # Step 4d: Flag the identified records in the main DataFrame
+            # This sets a boolean flag 'errPresentiAnnotazioni' to True for affected rows
+            self.df.loc[cond_mask, "errPresentiAnnotazioni"] = True
+
+    def errNomeComuneTagesmutter(self) -> None:  # refactored
+        """
+        Identifies and handles cases where a child's residence city does not match the official list of cities.
+
+        This method performs the following operations:
+        1. Reads the official list of cities from an Excel file.
+        2. Checks if the city in the "Comune di residenza assistente domiciliare all'infanzia" column
+           matches either the "Gemeinde" or "Comune" column in the official list.
+        3. If mismatches are found, it:
+            a. Displays an expandable section in Streamlit with relevant information.
+            b. Provides an option to download the error data as an Excel file.
+            c. Displays the error data in a grid format.
+            d. Flags the identified records in the main DataFrame.
+
+        Raises:
+            FileNotFoundError: If the "GemeindenComuni.xlsx" file is not found.
+            KeyError: If expected columns are missing from either the main DataFrame or the official list.
+            Exception: For any other exceptions that occur during the execution.
+        """
+        # Step 1: Read the official list of cities from an Excel file
+        try:
+            dfGemeinden: pd.DataFrame = pd.read_excel("GemeindenComuni.xlsx")
+        except FileNotFoundError as fnf_error:
+            st.error(f"File not found: {fnf_error}")
+            return
+        except Exception as e:
+            st.error(f"An error occurred while reading 'GemeindenComuni.xlsx': {e}")
+            return
+
+        # Ensure that the necessary columns exist in dfGemeinden
+        required_columns_gemeinden = {"Gemeinde", "Comune"}
+        if not required_columns_gemeinden.issubset(dfGemeinden.columns):
+            st.error(
+                f"The official list must contain the columns: {required_columns_gemeinden}"
+            )
+            return
+
+        # Ensure that the necessary column exists in the main DataFrame
+        required_columns_main = {
+            "Comune di residenza assistente domiciliare all'infanzia",
+            "Cognome",
+            "Nome",
+            "filename",
+        }
+        if not required_columns_main.issubset(self.df.columns):
+            st.error(
+                f"The main DataFrame must contain the columns: {required_columns_main}"
+            )
+            return
+
+        # Step 2: Check if the city matches either "Gemeinde" or "Comune" in dfGemeinden
+        # Create boolean Series indicating matches
+        condizione1: pd.Series = self.df[
+            "Comune di residenza assistente domiciliare all'infanzia"
+        ].isin(dfGemeinden["Gemeinde"])
+        condizione2: pd.Series = self.df[
+            "Comune di residenza assistente domiciliare all'infanzia"
+        ].isin(dfGemeinden["Comune"])
+        condizione: pd.Series = condizione1 | condizione2
+
+        # Step 3: Identify records where the city does not match the official list
+        cond_mask: pd.Series = ~condizione
+
+        if cond_mask.any():
+            # create a temporary dataframe for display
+            dftemp = self.df.loc[cond_mask].copy()
+
+            dftemp = helper.convert_dates_if_needed(dftemp, [])
+
+            interface.make_expander(
+                "casi con un nome comune Tagesmutter non corrispondente alla lista ufficiale",
+                "Elenco delle occorrenze con comune Tagesmutter non corrispondente",
+                len(dftemp[cond_mask]),
+                dftemp,
+            )
+
+            # Step 4d: Flag the identified records in the main DataFrame
+            # This sets a boolean flag 'errNomeComuneTagesmutter' to True for affected rows
+            self.df.loc[condizione_logica, "errNomeComuneTagesmutter"] = True
+
+        # Optional: Clean up by deleting the official list DataFrame to free memory
+        del dfGemeinden
+
+
+class caricaEtControlla:
+    def __init__(self, interface, ERRORDICT, df_gemeinden, df_traeger):
+        self.filelist = interface.uploaded_files
+        self.ANNO_RIFERIMENTO = interface.ANNO_RIFERIMENTO
+        self.checks = interface.checks
+        self.ERRORDICT = ERRORDICT
+        self.df_gemeinden = df_gemeinden
+        self.df_traeger = df_traeger
+        self.errori = {}
+        self.errori["critici"] = {}
+        self.errori["non critici"] = {}
+        self.ComuneTedesco = interface.COMUNETEDESCO
+
+        interface.STATUS.info(
+            "Sono stati caricati " + str(len(self.filelist)) + " files"
+        )
+
+    def process_data(self):
+        """
+        Method to load, clean, check for errors, remove duplicates, convert datatypes and rename columns
+        """
+        self.pippo1 = ""
+        self.pippo2 = ""
+        self.dataframes = []
+        contatorefile = 0
+        df = pd.DataFrame
+        with interface.TAB1:
+            for file in self.filelist:
+                c1, c2 = st.columns([3, 2])
+                try:
+                    interface.STATUS2.info("[*] " + file.name + " caricato")
+                    if self.ANNO_RIFERIMENTO in ["2023","2024","2025","2026"]:
+                        # i file excel contengono due sheet nascosti (lista comuni)
+                        # quindi dobbiamo caricare solo quello che si chiama o "deu" o "ita"
+                        try:
+                            df = pd.read_excel(file, sheet_name="ita", usecols="A:M")
+                        except:
+                            self.pippo1 = "ita"
+                            pass
+                        try:
+                            df = pd.read_excel(file, sheet_name="deu", usecols="A:M")
+                        except:
+                            self.pippo2 = "deu"
+                            pass
+                    if self.pippo1 == "ita" and self.pippo2 == "deu":
+                        st.error(
+                            f"file {file.name} non ha il foglio con nome o ita o deu e non viene usato"
+                        )
+                        # alla prima occorrenza di un errore per un dato filename, inizializziamo la lista di errori
+                        if file.name not in self.errori["critici"]:
+                            self.errori["critici"][file.name] = []
+
+                        self.errori["critici"][file.name].append(
+                            "Non ha il foglio con nome o ita o deu e non viene usato"
+                        )
+
+                        self.pippo1 = ""
+                        self.pippo2 = ""
+                        if interface.TOLLERANZAZERO:
+                            st.error("Elaborazione interrotta")
+                            st.stop()
+                        continue
+                        # st.write(df)
+
+                except Exception as e:
+                    st.error(
+                        file.name
+                        + " non è un file Excel o non corrisponde alle aspettative"
+                    )
+
+                    if file.name not in self.errori:
+                        self.errori["critici"][file.name] = []
+                    self.errori["critici"][file.name].append(
+                        "Non è un file Excel o non corrisponde alle aspettative"
+                    )
+
+                    st.error(e)
+                    if interface.TOLLERANZAZERO:
+                        st.error("Elaborazione interrotta")
+                        st.stop()
+                    continue
+
+                contatorefile += 1
+                c1.markdown("<div style='margin-top: 8px; margin-bottom: 20px; border-top: 3px solid #cccccc; width: 100%;'></div>", unsafe_allow_html=True)
+                c2.markdown("<div style='margin-top: 8px; margin-bottom: 20px; border-top: 3px solid #cccccc; width: 100%;'></div>", unsafe_allow_html=True)
+
+                c1.info(f"**Sto elaborando {file.name}...**")
+
+                df, flag = self.prepare_data(df, file, c2)
+                if flag == 1:
+                    pass
+                elif flag == 2:
+                    c2.error("----> ERRORE - vedi riga sotto...")
+                else:
+                    c2.success("----> OK")
+
+                if df is not None:
+                    df = self.compute_hours(df)
+                    df = self.calcola_giorni_esatti(df)
+                    df = self.make_bool_columns(df)
+                    # df = self.check_data(df)
+                    # st.write(df)
+                    self.dataframes.append(df)
+                    # st.write(df)
+                    # c2.success("Elaborazione OK")
+
+            try:
+                # all loaded excel data gets concatenated in a new dataframe
+                self.data = pd.concat(self.dataframes, ignore_index=True)
+            except Exception as e:
+                st.error(
+                    f"Errore durante concatenamento dei dataframe caricati: errore: {e}"
+                )
+                st.error("Elaborazione interrotta")
+                st.stop()
+                if interface.TOLLERANZAZERO:
+                    st.error("Elaborazione interrotta")
+                    st.stop()
+                pass
+
+            interface.STATUS2.info(
+                f"Vengono usati {contatorefile} file Excel per l'elaborazione"
+            )
+
+    def prepare_data(self, df, file, c2):
+        # estraiamo comune e nome ente da dove ci aspettiamo che siano
+        # nel dataframe creato dal singolo file Excel
+        flag = None
+        # st.write(df)
+        if self.ANNO_RIFERIMENTO in ["2023","2024", "2025"]:
+            df.columns = [
+                "Numero progressivo",
+                "Cognome",
+                "Nome",
+                "Data di nascita",
+                "Codice fiscale",
+                "CognomeAssDom",
+                "NomeAssDom",
+                "Comune di residenza assistente domiciliare all'infanzia",
+                "Data inizio contratto (o data inizio assistenza se diversa)",
+                "Data fine contratto (o data fine assistenza se diversa)",
+                "Ore di assistenza ai sensi della delibera n. 666/2019",
+                "Colonna_L_da_cancellare_dopo",
+                "Codice Comune_TM",
+            ]
+
+            codice_ente = df.iloc[2, 12]
+            #st.write(f"codice_ente {df.iloc[2, 12]}")
+            codice_comune = df.iloc[4, 12]
+            #st.write(f"codice_comune {df.iloc[4, 12]}")
+            anno = df.iloc[0, 5]
+
+        #st.write("pippo" + self.ComuneTedesco)
+        try:
+            #st.write("pippo" + self.ComuneTedesco)
+            if self.ComuneTedesco:
+                nome_comune = df_gemeinden[df_gemeinden["Com_code"] == codice_comune][
+                    "Gemeinde"
+                ].values[0]
+            else:
+                nome_comune = df_gemeinden[df_gemeinden["Com_code"] == codice_comune][
+                    "Comune"
+                ].values[0]
+        except:
+            st.error(
+                f"Errore: manca il codice comune dell'ente nel file {file.name}, il file non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append("Manca il codice comune dell'ente")
+
+            flag = 2
+            return None, flag
+
+        try:
+            nome_ente = df_traeger[df_traeger["Coop_code"] == codice_ente][
+                "Körperschaft"
+            ].values[0]
+        except:
+            st.error(
+                f"Errore: manca il codice ente nel file {file.name}, il file non verra' usato"
+            )
+
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append("Manca il codice dell'ente")
+
+            flag = 2
+            return None, flag
+
+        if codice_comune not in self.df_gemeinden["Com_code"].values:
+            # c2.warning("ATTENZIONE!")
+            st.warning(
+                f"L'ente '{nome_ente}' ha inserito un codice comune non corretto: '{codice_comune}'. \n\r Il file non verra' usato. \n\rIl nome file e': {file.name}"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                "Trovato codice comune non corretto"
+            )
+
+            flag = 2
+            if interface.TOLLERANZAZERO or interface.DEBUGWARNINGS:
+                st.error("Elaborazione terminata")
+                st.stop()
+
+            return None, flag
+
+        # creiamo due nuove colonne e le riempiamo con comune ed ente
+        # estratti prima
+        df.insert(1, "Comune", nome_comune)
+        df.insert(1, "Ente", nome_ente)
+        df.insert(1, "Com_code", codice_comune)
+        df.insert(1, "Anno", anno)
+
+        # scriviamo anche il nome del file perché non si sa mai che non possa servire
+        df.insert(0, "filename", file.name)
+
+        # cancelliamo le righe che non ci servono
+        df = df.drop(labels=range(0, 8), axis=0)
+
+        # dobbiamo intercettare se c'è un * nella colonna del numero progressivo
+        # sostituire l'asterisco con 99 e aggiungere l'asterisco al nome
+        cond = df["Numero progressivo"] == "*"
+        df.loc[cond, "Cognome"] += " *"
+        df.loc[cond, "Numero \nprogressivo"] = 99
+
+        # prima convertiamo la colonna in numerica, forzando NaN sui non numerici
+        df["Numero progressivo"] = pd.to_numeric(
+            df["Numero progressivo"], errors="coerce"
+        )
+
+        # selezioniamo solo le righe che hanno un valore nella colonna del **Codice fiscale**
+        # in questo modo eliminiamo le righe inutili
+        validi = df["Codice fiscale"].notna()
+
+        # teniamo solo record validi
+        if not df[validi].empty:
+            df = df[validi]
+        else:
+            c2.warning("Attenzione!")
+            st.error(
+                f"Il file Excel '{file.name}' non contiene dati validi - il file non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append("Non contiene dati validi")
+
+            flag = 2
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.error("Elaborazione interrotta")
+                st.stop()
+            return None, flag
+
+        # controlliamo subito se mancano valore per le ore rendicontate
+        # se mancano, non usiamo l'Excel
+        if df["Ore di assistenza ai sensi della delibera n. 666/2019"].isnull().sum():
+            somma = (
+                df["Ore di assistenza ai sensi della delibera n. 666/2019"]
+                .isnull()
+                .sum()
+            )
+            c2.warning("Attenzione!")
+            st.error(
+                f"Il file Excel '{file.name}' contiene {somma} valori mancanti per le ore rendicontate - il file non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                "Trovati {somma} valori mancanti per le ore rendicontate"
+            )
+
+            flag = 2
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.error("Elaborazione interrotta")
+                st.stop()
+            return None, flag
+
+
+        # Check if numbers in "Numero progressivo" are not continuous, i.e. a number is missing, like the "3" in  "1, 2, 4, 5, etc."
+        # Only apply to rows with valid numeric values in "Numero progressivo"
+        valid_rows = df["Numero progressivo"].notna()
+        missing_nums = np.array([])  # Initialize missing_nums here to avoid UnboundLocalError
+        
+        if valid_rows.any():
+            # Get unique valid numeric values and sort them
+            unique_nums = df.loc[valid_rows, "Numero progressivo"].unique()
+            unique_nums = np.sort(unique_nums)
+            
+            # Check if the sequence is continuous
+            if len(unique_nums) >= 2:  # Need at least 2 numbers to check continuity
+                expected_sequence = np.arange(unique_nums[0], unique_nums[-1] + 1)
+                missing_nums = np.setdiff1d(expected_sequence, unique_nums)
+            
+            if len(missing_nums) > 0:
+                if interface.MOSTRAERRORIINTEGRITA:
+                    c2.warning("ATTENZIONE! Vedi riga sotto...")
+                flag = 1
+                st.warning(
+                    f"Attenzione: l'ente '{nome_ente.upper()}' ha inserito numeri progressivi non continui nel file {file.name}. "
+                    f"Mancano i numeri: {', '.join(map(str, missing_nums))}"
+                )
+                if file.name not in self.errori:
+                    self.errori["non critici"][file.name] = []
+                self.errori["non critici"][file.name].append(
+                f"Trovati numeri progressivi non continui. Mancano: {', '.join(map(str, missing_nums.astype(int)))}"
+                )
+                
+                with st.expander(f"Numeri progressivi non continui nel file {file.name}"):
+                    st.write(
+                    f"Attenzione: nella sequenza dei numeri progressivi mancano i seguenti numeri: {', '.join(map(str, missing_nums.astype(int)))}"
+                )
+                    # Display the sequence found in the file
+                    st.write("Sequenza trovata nel file:")
+                    st.write(unique_nums)
+
+
+
+        # Check only rows where "Numero progressivo" is present
+        valid_progressivi = df["Numero progressivo"].notna()
+        duplicates = df[valid_progressivi]["Numero progressivo"].duplicated(keep=False)
+
+        if not df[valid_progressivi][duplicates].empty:
+            if interface.MOSTRAERRORIINTEGRITA:
+                c2.warning("ATTENZIONE! Vedi riga sotto...")
+                flag = 1
+                st.warning(
+                    f"Attenzione: l'ente '{nome_ente.upper()}' ha inserito numeri progressivi duplicati nel file {file.name}"
+                )
+            if file.name not in self.errori:
+                self.errori["non critici"][file.name] = []
+            self.errori["non critici"][file.name].append(
+                "Trovati numeri non progressivi"
+            )
+
+            df_no_index = (
+                df.loc[
+                    valid_progressivi & duplicates,
+                    ["Numero progressivo", "Cognome", "Nome"],
+                ]
+                .groupby("Numero progressivo", as_index=False)
+                .first()
+            )
+            df_no_index["Numero progressivo"] = df_no_index[
+                "Numero progressivo"
+            ].astype(int)
+
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.error("Elaborazione terminata")
+                st.stop()
+
+
+            with st.expander(
+                f"Record con numeri progressivi duplicati: {len(df_no_index)} occorrenze"
+            ):
+                st.write(
+                    "Attenzione: i seguenti record hanno numeri progressivi duplicati e potrebbero richiedere attenzione."
+                )
+                st.write(df_no_index)
+
+        condizione_righe_vuote = (
+            ~df["Numero progressivo"].isna() & df["Codice fiscale"].isna()
+        )
+
+        if not df[condizione_righe_vuote].empty:
+            conta_righe = condizione_righe_vuote.sum()
+            # c2.warning("Attenzione!")
+            st.warning(
+                f"Attenzione: l'ente '{nome_ente.upper()}' ha inserito numeri progressivi per righe vuote \n\r{conta_righe} righe vuote sono state eliminate e l'elaborazione prosegue"
+            )
+            if file.name not in self.errori:
+                self.errori["non critici"][file.name] = []
+            self.errori["non critici"][file.name].append(
+                "Trovati numeri progressivi per righe vuote. Le righe vuote sono state eliminate."
+            )
+
+            flag = 1
+
+        df = df[~condizione_righe_vuote]
+        if interface.DEBUGGENERAL:
+            st.write(df)
+
+        condizione_nr_progressivo_assente_ma_righe_con_dati = (
+            df["Numero progressivo"].isna() & ~df["Codice fiscale"].isna()
+        )
+
+        if not df[condizione_nr_progressivo_assente_ma_righe_con_dati].empty:
+            conta_righe = condizione_nr_progressivo_assente_ma_righe_con_dati.sum()
+            c2.warning("Attenzione!")
+            st.warning(
+                f"Attenzione: l'ente '{nome_ente.upper()}' ha inserito righe con dati ma senza numero progressivo"  # nel file {file.name}"
+            )
+            if file.name not in self.errori:
+                self.errori["non critici"][file.name] = []
+            self.errori["non critici"][file.name].append(
+                "Trovate righe con dati ma senza numero progressivo"
+            )
+
+            flag = 1
+
+
+        # Check for duplicate children with same Tagesmütter and same start date
+        same_child_same_tagesmutter_same_startdate = (
+            df.duplicated(
+            subset=[
+                "Cognome",
+                "Nome",
+                "CognomeAssDom",
+                "NomeAssDom",
+                "Data inizio contratto (o data inizio assistenza se diversa)",
+            ],
+            keep=False,
+            )
+        )
+        
+        if same_child_same_tagesmutter_same_startdate.any():
+            count_duplicates = same_child_same_tagesmutter_same_startdate.sum()
+            #c2.warning("Attenzione!")
+            st.warning(
+            f"Attenzione: l'ente '{nome_ente.upper()}' ha inserito lo stesso bambino con la stessa Tagesmutter e stessa data di inizio {count_duplicates} volte"
+            )
+            
+            if file.name not in self.errori:
+                self.errori["non critici"][file.name] = []
+            self.errori["non critici"][file.name].append(
+            f"Trovati {count_duplicates} record duplicati con lo stesso bambino, stessa Tagesmutter e stessa data di inizio"
+            )
+            
+            # Display the duplicate records for debugging
+#            if interface.DEBUGGENERAL
+            with st.expander(
+                f"Record duplicati (stesso bambino, stessa Tagesmutter e stessa data di inizio): {count_duplicates} occorrenze"
+                ):
+                st.write(
+                    "Attenzione: i seguenti record sono duplicati e potrebbero richiedere attenzione."
+                )
+                dups = df[same_child_same_tagesmutter_same_startdate].sort_values(
+                    by=[
+                    "Cognome",
+                    "Nome",
+                    "CognomeAssDom",
+                    "NomeAssDom",
+                    "Data inizio contratto (o data inizio assistenza se diversa)",
+                    ]
+                )
+                st.write(dups)
+            
+            flag = 1
+
+
+        df = df[~condizione_nr_progressivo_assente_ma_righe_con_dati]
+        if interface.DEBUGGENERAL:
+            st.write(df)
+
+        # elimiamo colonne che sono servono più
+        df = df.drop(["Numero \nprogressivo"], axis=1)
+
+        # se troviamo data fine vuota la mettiamo al 31/12 dell'anno riferimento
+        condizione = pd.isnull(
+            df["Data fine contratto (o data fine assistenza se diversa)"]
+        )
+        df.loc[
+            condizione, "Data fine contratto (o data fine assistenza se diversa)"
+        ] = datetime(
+            int(self.ANNO_RIFERIMENTO), 12, 31, 0, 0, 0
+        )  # str(self.ANNO_RIFERIMENTO) + "-12-31 00:00:00"
+
+        try:
+            df = self.validate_dates(df, "Data di nascita", file)
+            if df is None:
+                return None, flag
+
+        except Exception as e:
+            c2.error("Errore!")
+            st.error(
+                f"{file.name} --> Unexpected error occurred: {e}.\n\rIl file Excel non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                "Trovato errore critico non identificato"
+            )
+
+            flag = 2
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.stop()
+            return None, flag
+
+        try:
+            df = self.validate_dates(
+                df, "Data fine contratto (o data fine assistenza se diversa)", file
+            )
+            if df is None:
+                return None, flag
+
+        except Exception as e:
+            c2.warning("Errore!")
+            st.error(
+                f"{file.name} --> data fine contratto contiene valori non data; errore: {e}.\n\rIl file Excel non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                "Data fine contratto contiene valori non data"
+            )
+
+            flag = 2
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.stop()
+            return None, flag
+
+        try:
+            df = self.validate_dates(
+                df, "Data inizio contratto (o data inizio assistenza se diversa)", file
+            )
+            if df is None:
+                return None, flag
+        except Exception as e:
+            c2.warning("Errore!")
+            st.error(
+                f"{file.name} --> data inizio contratto contiene valori non data; errore: {e}.\n\rIl file Excel non verra' usato"
+            )
+
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                "Data inizio contratto contiene valori non data"
+            )
+
+            flag = 2
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.stop()
+            return None, flag
+
+        # sostituiamo tutti i NaN con *0*
+        df = df.fillna(0)
+
+        # assicuriamo che codice fiscale sia in maiuscolo
+        df["Codice fiscale"] = df["Codice fiscale"].str.upper()
+
+        if "Colonna_L_da_cancellare_dopo" in df.columns:
+            del df["Colonna_L_da_cancellare_dopo"]
+
+        # c2.success("OK")
+        return df, flag
+
+    # Function to check for incorrect year format
+    def is_incorrect_year(self, date_str: str) -> bool:
+        """
+        Check if the year part of a date string is in the correct format.
+
+        Args:
+            date_str (str): The date string to be checked.
+
+        Returns:
+            bool: True if the year length is not 4, False otherwise.
+        """
+        year_part = str(date_str).split("-")[-3]
+        return len(year_part) != 4  # Check if the year length is not 4
+
+    # Function to check and convert date formats with year validation
+    def validate_dates(
+        self, df: pd.DataFrame, date_column: str, file
+    ) -> Optional[pd.DataFrame]:
+        """
+        Validate and convert date formats in a specified column of a DataFrame.
+
+        Args:
+            df (pd.DataFrame): The input DataFrame containing the date column.
+            date_column (str): The name of the column to be validated and converted.
+            file (FileStorage): The uploaded file object for displaying errors.
+
+        Returns:
+            pd.DataFrame or None: The modified DataFrame if all dates are valid, otherwise None.
+        """
+
+        if not isinstance(df, pd.DataFrame):
+            st.write(type(df))
+            raise ValueError("The input 'df' must be a pandas DataFrame.")
+
+        if date_column not in df.columns:
+            st.write(df.columns)
+            raise KeyError(
+                f"The specified date_column '{date_column}' does not exist in the DataFrame."
+            )
+
+        # Create a new column for the parsed dates
+        df["Parsed Date"] = pd.to_datetime(
+            df[date_column], format="%d-%m-%Y", errors="coerce"
+        )  # .dt.strftime('%d-%m-%Y')#.dt.date
+
+        # Identify rows with invalid dates in the new column
+        invalid_dates_df = df[df["Parsed Date"].isna()]
+
+        if not invalid_dates_df.empty:
+            # Display the error message with original wrong dates and additional row information
+            st.error(
+                f"{file.name} --> {date_column} contiene valori non data; errore: dati non validi.\n\rIl file Excel non verra' usato"
+            )
+
+            # st.write(f"Righe con {date_column} invalide:", invalid_dates_df)  # Show the full rows
+            with st.expander(f"Righe con {date_column} invalide:"):
+                st.write(invalid_dates_df)
+            if file.name not in self.errori:
+                self.errori["critici"][file.name] = []
+            self.errori["critici"][file.name].append(
+                f"{date_column} contiene valori non data"
+            )
+
+            if interface.DEBUGWARNINGS or interface.TOLLERANZAZERO:
+                st.stop()
+
+            df.drop("Parsed Date", axis=1, inplace=True)
+            flag = 1
+            # st.write(df)
+            return None
+
+        df[date_column] = df["Parsed Date"]
+        df.drop("Parsed Date", axis=1, inplace=True)
+
+        return df
+
+    def compute_hours(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Compute the number of hours based on contract start and end dates.
+
+        Args:
+            df (pd.DataFrame): The input DataFrame containing the date columns.
+
+        Returns:
+            pd.DataFrame: Modified DataFrame with computed hours.
+        """
+        ar = int(self.ANNO_RIFERIMENTO)  # Convert anno riferimento to an integer
+
+        df["inizioNorm"] = df[
+            "Data inizio contratto (o data inizio assistenza se diversa)"
+        ]  # intanto inseriamo i valori che ci sono
+
+        df["fineNorm"] = df["Data fine contratto (o data fine assistenza se diversa)"]
+
+        # If the start date is before the reference year, set it to January 1st of the reference year
+        iniz = df["inizioNorm"].dt.year < ar  # Logical condition
+        df.loc[iniz, "inizioNorm"] = "01-01-" + str(
+            ar
+        )  # Find values less than the reference year and replace with 01/01
+        fin = df["fineNorm"].dt.year > ar  # Logical condition
+        df.loc[fin, "fineNorm"] = "12-31-" + str(ar)  # Replace
+        df.insert(
+            9, "GiorniAssistenzaAnnoRiferimento", 0
+        )  # Add a column and set the reference year
+        return df
+
+    def calcola_giorni_esatti(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Calculates the exact number of days of assistance for each person in the given DataFrame.
+
+        Args:
+        - df (pandas.DataFrame): The DataFrame containing the assistance data for each person.
+
+        Returns:
+        - pandas.DataFrame: The input DataFrame with an additional column containing the exact number of days of assistance for each person.
+        """
+
+        df = df.reset_index(drop=True)
+        df = df.sort_values(
+            by="Data inizio contratto (o data inizio assistenza se diversa)"
+        )  # importante sort, altrimento non calcola giusto
+        # Group the DataFrame by Codice fiscale
+        for codice_fiscale, group in df.groupby("Codice fiscale"):
+            if interface.DEBUGGENERAL:
+                st.info(f"codice fiscale={codice_fiscale}")
+
+            # Initialize variables for the earliest startdate and latest enddate
+            earliest_startdate = group.iloc[0]["inizioNorm"]
+            latest_enddate = group.iloc[0]["fineNorm"]
+
+            if interface.DEBUGGENERAL:
+                st.info(f"earliest startdate={earliest_startdate}")
+                st.info(f"latest enddate={latest_enddate}")
+
+            # Initialize variable for total effective days
+            total_effective_days = 0
+
+            # Iterate through each row in the group
+            for index, row in group.iterrows():
+                if interface.DEBUGGENERAL:
+                    st.info(f"index={index}")
+                # If the enddate is earlier than the latest enddate, skip this row
+                if row["fineNorm"] < latest_enddate:
+                    continue
+
+                # If the startdate is later than the latest enddate, add the effective days between the earliest startdate and latest enddate to the total effective days
+                elif row["inizioNorm"] > latest_enddate:
+                    total_effective_days += (
+                        latest_enddate - earliest_startdate
+                    ).days + 1
+                    earliest_startdate = row["inizioNorm"]
+
+                # Update the latest enddate
+                latest_enddate = row["fineNorm"]
+                indx = index
+                if interface.DEBUGGENERAL:
+                    st.info(f"temp total effective days={total_effective_days}")
+                    st.info(f"temp earliest startdate{earliest_startdate}")
+
+            # Add the effective days between the earliest startdate and latest enddate to the total effective days
+            total_effective_days += (latest_enddate - earliest_startdate).days
+
+            # Insert the number of days of assistance into the appropriate row of the DataFrame
+            # We use the last index in the group because it is the only one that we need to update, and the function that sums the values is correct because it will sum the value with zeros
+            if interface.DEBUGGENERAL:
+                st.info(f"last index={indx}")
+            if interface.DEBUGGENERAL:
+                st.info(f"giorni totali={total_effective_days}")
+
+            # df["GiorniAssistenzaAnnoRiferimento"][indx] = total_effective_days + 1
+            # OR IT WORKS ALSO WITH -->
+            df.loc[group.index[-1], "GiorniAssistenzaAnnoRiferimento"] = (
+                total_effective_days + 1
+            )
+
+        return df
+
+    def get_data(self) -> pd.DataFrame:
+        """
+        Method to return the processed data.
+        Returns:
+            pd.DataFrame: The DataFrame containing the processed data.
+        """
+        return self.data
+
+    def make_bool_columns(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Adds boolean columns for each error in ERRORDICT for the given year of reference.
+
+        Args:
+            df (pd.DataFrame): The DataFrame to add boolean columns to.
+        Returns:
+            pd.DataFrame: The DataFrame with added boolean columns.
+        """
+        for error_key in self.ERRORDICT[self.ANNO_RIFERIMENTO].keys():
+            df[error_key] = np.nan
+            df[error_key] = df[error_key].astype("boolean")
+
+        return df
+
+
+if __name__ == "__main__":
+
+    valori = valoriEtErrori()
+    interface = makeInterface(valori)
+    helper = helpers(interface, valori.ERRORDICT)
+    # trova_errori = trovaErrori()
+
+    dtype_spec = {
+        "Com_code": str  # non vogliamo convertire questa colonna to number perche' nell'Excel trovaimo come stringa
+    }
+    try:
+
+        # Get the directory where the script is located
+        #   script_dir = os.path.dirname(os.path.abspath(__file__))
+
+        # Build the full path to the Excel file
+        #   file_path = os.path.join(script_dir, "GemeindenMitKodex.xlsx")
+        #st.write(file_path)
+
+        # Read the file
+        try:
+            df_gemeinden = pd.read_excel("src/GemeindenMitKodex.xlsx", dtype=dtype_spec)
+            #st.write(f"Columns 1: {df_gemeinden.columns} ({type(df_gemeinden.columns)})")
+            _df_gemeinden_backup = df_gemeinden.copy()
+        except Exception as e:
+            st.error(f"Primo; errore: {e}")
+        
+        try:
+            df_gemeinden = df_gemeinden[df_gemeinden["PLZ"] != 9999]
+            #st.write(f"Columns 2: {df_gemeinden.columns} ({type(df_gemeinden.columns)})")
+            if not isinstance(df_gemeinden, pd.DataFrame):
+                st.error("ATTENZIONE: df_gemeinden è stato sovrascritto — non è più un DataFrame!")
+                df_gemeinden = _df_gemeinden_backup.copy()
+                st.warning("df_gemeinden è stato ripristinato dalla copia di backup.")
+        except Exception as e:
+            st.write(df_gemeinden)
+            st.error(f"Secondo; errore: {e}")
+        #df_gemeinden = pd.read_excel(
+        #    "GemeindenMitKodex.xlsx", dtype=dtype_spec
+        #)
+        #df_gemeinden = df_gemeinden[df_gemeinden["PLZ"] != 9999]
+
+    except Exception as e:
+        #st.write(file_path)
+        #st.write(f"dtype_spec: {dtype_spec} ({type(dtype_spec)})")
+
+        st.error(f"Errore durante caricamento file dei comuni; Errore: {e}")
+        st.error("Chiamare Stefan")
+        st.stop()
+
+    try:
+        #script_dir = os.path.dirname(os.path.abspath(__file__))
+        # Build the full path to the Excel file
+        #file_path = os.path.join(script_dir, "TM_TraegerMitKodex.xlsx")
+        df_traeger = pd.read_excel("src/TM_TraegerMitKodex.xlsx", dtype=dtype_spec)
+
+    except Exception as e:
+        st.error(f"Errore durante caricamento anagrafica enti; errore: {e}")
+        st.error("Chiamare Stefan")
+        st.stop()
+
+    if interface.submit:
+        if not interface.uploaded_allegato666:
+            st.error("L'allegato 666 non e' stato caricato - elaborazione interrotta")
+            df_allegato666 = None
+            st.stop()
+        else:
+            try:
+                df_allegato666 = pd.read_excel(interface.uploaded_allegato666)
+                if df_allegato666.columns[24] != 666:
+                    st.error(
+                        f"Non e' stato trovato il valore di controllo nell'allegato 666; l'elaborazione viene terminata."
+                    )
+                    st.stop()
+                df_allegato666 = df_allegato666.drop(labels=range(0, 8), axis=0)
+                df_allegato666 = df_allegato666.drop(labels=range(124, 129), axis=0)
+                cols_to_drop = df_allegato666.columns[10:]
+                df_allegato666 = df_allegato666.drop(columns=cols_to_drop)
+                df_allegato666 = df_allegato666.drop(columns="Unnamed: 8")
+
+                # ridefiniamo i nomi delle colonne
+                df_allegato666.columns = [
+                    "Comune provenienza bambino",
+                    "Numero utenti",
+                    "Ore di servizio",
+                    "Costo orario",
+                    "Costo del servizio",
+                    "Entrate compartecipazione",
+                    "Ore tariffa maggiorata",
+                    "Entrate maggiorazione",
+                    "Com_code",
+                ]
+                if interface.DEBUGGENERAL:
+                    st.write(df_allegato666)
+            except Exception as e:
+                st.error(
+                    f"Errore durante il caricamento dell'allegato 666: errore: {e}"
+                )
+                st.error("Impossibile proseguire")
+                st.stop()
+
+        if len(interface.uploaded_files) == 0:
+            st.error("Nessun file caricato!")
+        else:
+            interface.make_tabs()
+            processor = caricaEtControlla(
+                interface, valori.ERRORDICT, df_gemeinden, df_traeger
+            )
+            processor.process_data()
+
+            trova_errori = trovaErrori(
+                processor.get_data(), interface, df_gemeinden, df_allegato666
+            )
+            # st.write(processor.errori)
+            with interface.TAB3:
+                reportmaker = ReportGenerator(processor, trova_errori, interface)
+                reportmaker.genera_report()
+                reportmaker.display_final_table()
+
+            interface.STATUS2.write("")
+            interface.STATUS.write("")
+            interface.STATUS3.success(
+                "[*] Tutti i dati sono stati elaborati -  PER INIZIARE DA CAPO: RICARICARE LA PAGINA"
+            )
+            # st.balloons()