add pdf

app.py

@@ -1,5 +1,6 @@
 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:
@@ -8,36 +9,29 @@ if 'phases' not in st.session_state:
 # Titre
 st.title('Gestion des erreurs de mélange de béton')
 
-
-
-
-
-
-
-st.header('Entrées les norme de calcul')
-g1_norme = st.number_input('G1 norme',value=575.0 ,format="%.2f")
-g2_norme= st.number_input('G2 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")
+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')
-g1_input = st.number_input('G1',format="%.2f")
-
-g2_input = st.number_input('G2',format="%.2f")
-sb_input = st.number_input('SB',  format="%.2f")
+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 = {
-        'G1': g1_input,
         'G2': g2_input,
+        'G1': g1_input,
         'SB': sb_input,
         'Cubes': cubes_input,
-        'G1_Error': g1_input- (g1_norme/cube_norme * cubes_input) ,
-        'G2_Error':  (g2_input - g1_input)-(g2_norme/cube_norme * cubes_input) ,
-        'SB_Error':  (sb_input - g2_input)-(sb_norme /cube_norme* 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)
 
@@ -49,12 +43,12 @@ st.write(phases_df)
 # Calculer les erreurs totales
 st.header('Calcul des erreurs')
 try:
-    total_g1_error = phases_df['G1_Error'].sum()
     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 G1: {total_g1_error}")
     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}")
@@ -62,17 +56,20 @@ except KeyError as 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'):
+
+if st.button('Corriger les erreurs') or remaining_cubes > 0:
     try:
-        correction_g1 = g1_norme/cube_norme *remaining_cubes -   total_g1_error 
-        correction_g2 = g2_norme/cube_norme *remaining_cubes - total_g2_error
-        correction_sb = sb_norme/cube_norme *remaining_cubes - total_sb_error
+        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 G1 par cube: {correction_g1}")
         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')
@@ -81,13 +78,13 @@ if st.button('Générer le rapport'):
         report = f"""
         ## Rapport détaillé des erreurs
         ### Erreurs totales
-        - Erreur G1: {total_g1_error}
         - Erreur G2: {total_g2_error}
+        - Erreur G1: {total_g1_error}
         - Erreur SB: {total_sb_error}
         
         ### Correction nécessaire
-        - G1 par cube: {correction_g1}
         - G2 par cube: {correction_g2}
+        - G1 par cube: {correction_g1}
         - SB par cube: {correction_sb}
         
         ### Phases
@@ -97,12 +94,69 @@ if st.button('Générer le rapport'):
     except Exception as e:
         st.error(f"Erreur lors de la génération du rapport: {e}")
 
-# Enregistrer le rapport
-st.header('Enregistrer le rapport')
-if st.button('Enregistrer le rapport'):
+# Enregistrer le rapport en PDF
+st.header('Enregistrer le rapport en PDF')
+if st.button('Enregistrer le rapport en PDF'):
     try:
-        with open("rapport_erreurs.txt", "w") as file:
-            file.write(report)
-        st.write('Rapport enregistré sous le nom rapport_erreurs.txt')
+        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: {e}")
+        st.error(f"Erreur lors de l'enregistrement du rapport en PDF: {e}")

requirements.txt

@@ -0,0 +1 @@
+fpdf2