app.py

import streamlit as st
import pandas as pd
from fpdf import FPDF

# Initialiser l'état de la session
if 'phases' not in st.session_state:
    st.session_state['phases'] = []

# Titre
st.title('Gestion des erreurs de mélange de béton')

st.header('Entrées les normes de calcul')
g2_norme = st.number_input('G2 norme', value=575.0, format="%.2f")
g1_norme = st.number_input('G1 norme', value=1000.0, format="%.2f")
sb_norme = st.number_input('SB norme', value=1237.0, format="%.2f")
cube_norme = st.number_input('Cube norme', value=1.5, format="%.2f")

# Section d'entrée pour la phase
st.header('Entrées pour la phase')
g2_input = st.number_input('G2', format="%.2f")
g1_input = st.number_input('G1', format="%.2f")
sb_input = st.number_input('SB', format="%.2f")
cubes_input = st.number_input('Cubes', value=1.5, format="%.2f")

# Ajouter la phase
if st.button('Ajouter la phase'):
    phase_data = {
        'G2': g2_input,
        'G1': g1_input,
        'SB': sb_input,
        'Cubes': cubes_input,
        'G2_Error': g2_input - (g2_norme / cube_norme * cubes_input),
        'G1_Error': (g1_input - g2_input) - (g1_norme / cube_norme * cubes_input),
        'SB_Error': (sb_input - g1_input) - (sb_norme / cube_norme * cubes_input),
    }
    st.session_state['phases'].append(phase_data)

# Afficher les phases
st.header('Phases')
phases_df = pd.DataFrame(st.session_state['phases'])
st.write(phases_df)

# Calculer les erreurs totales
st.header('Calcul des erreurs')
try:
    total_g2_error = phases_df['G2_Error'].sum()
    total_g1_error = phases_df['G1_Error'].sum()
    total_sb_error = phases_df['SB_Error'].sum()

    st.write(f"Erreur totale G2: {total_g2_error}")
    st.write(f"Erreur totale G1: {total_g1_error}")
    st.write(f"Erreur totale SB: {total_sb_error}")
except KeyError as e:
    st.error(f"Erreur dans les données: {e}")

# Correction des erreurs en fonction des cubes restants
st.header('Correction des erreurs')
remaining_cubes = st.number_input('Cubes restants', value=1.0, format="%.2f")

if st.button('Corriger les erreurs') or remaining_cubes > 0:
    try:
        correction_g2 = g2_norme / cube_norme * remaining_cubes - total_g2_error
        correction_g1 = g1_norme / cube_norme * remaining_cubes - total_g1_error
        correction_sb = sb_norme / cube_norme * remaining_cubes - total_sb_error

        st.write(f"Correction G2 par cube: {correction_g2}")
        st.write(f"Correction G1 par cube: {correction_g1}")
        st.write(f"Correction SB par cube: {correction_sb}")
    except ZeroDivisionError:
        st.error("Le nombre de cubes restants doit être supérieur à zéro pour corriger les erreurs.")
else:
    correction_g2 = correction_g1 = correction_sb = 0

# Générer un rapport détaillé des erreurs
st.header('Rapport détaillé des erreurs')
if st.button('Générer le rapport'):
    try:
        report = f"""
        ## Rapport détaillé des erreurs
        ### Erreurs totales
        - Erreur G2: {total_g2_error}
        - Erreur G1: {total_g1_error}
        - Erreur SB: {total_sb_error}
        
        ### Correction nécessaire
        - G2 par cube: {correction_g2}
        - G1 par cube: {correction_g1}
        - SB par cube: {correction_sb}
        
        ### Phases
        {phases_df.to_markdown()}
        """
        st.markdown(report)
    except Exception as e:
        st.error(f"Erreur lors de la génération du rapport: {e}")

# Enregistrer le rapport en PDF
st.header('Enregistrer le rapport en PDF')
if st.button('Enregistrer le rapport en PDF'):
    try:
        class PDF(FPDF):
            def header(self):
                self.set_font('Arial', 'B', 12)
                self.cell(0, 10, 'Rapport détaillé des erreurs de mélange de béton', 0, 1, 'C')
                self.ln(10)

            def chapter_title(self, title):
                self.set_font('Arial', 'B', 12)
                self.cell(0, 10, title, 0, 1, 'L')
                self.ln(5)

            def chapter_body(self, body):
                self.set_font('Arial', '', 12)
                self.multi_cell(0, 10, body)
                self.ln()

            def add_phase_table(self, df):
                self.set_font('Arial', 'B', 10)
                col_width = self.w / (len(df.columns) + 1)  # Largeur des colonnes
                th = self.font_size

                # Header
                for column in df.columns:
                    self.cell(col_width, th, column, border=1)
                self.ln(th)

                # Data
                self.set_font('Arial', '', 10)
                for i in range(len(df)):
                    self.cell(col_width, th, str(df.iloc[i]['G2']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['G1']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['SB']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['Cubes']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['G2_Error']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['G1_Error']), border=1)
                    self.cell(col_width, th, str(df.iloc[i]['SB_Error']), border=1)
                    self.ln(th)

        pdf = PDF()
        pdf.add_page()

        pdf.chapter_title("Erreurs totales")
        pdf.chapter_body(f"Erreur G2: {total_g2_error}\nErreur G1: {total_g1_error}\nErreur SB: {total_sb_error}")

        pdf.chapter_title("Correction nécessaire")
        pdf.chapter_body(f"G2 par cube: {correction_g2}\nG1 par cube: {correction_g1}\nSB par cube: {correction_sb}")

        pdf.chapter_title("Phases")
        pdf.add_phase_table(phases_df)

        pdf_file = "rapport_erreurs.pdf"
        pdf.output(pdf_file)
        st.write('Rapport PDF enregistré sous le nom rapport_erreurs.pdf')
        with open(pdf_file, "rb") as file:
            st.download_button(
                label="Télécharger le rapport PDF",
                data=file,
                file_name=pdf_file,
                mime="application/octet-stream"
            )
    except Exception as e:
        st.error(f"Erreur lors de l'enregistrement du rapport en PDF: {e}")