Update app.py

app.py

@@ -7,6 +7,7 @@ from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.enum.table import WD_TABLE_ALIGNMENT
 from docx.oxml.ns import nsdecls
 from docx.oxml import parse_xml
+import math
 
 # Configuration des identifiants ConvertAPI
 convertapi.api_credentials = 'secret_8wCI6pgOP9AxLVJG'
@@ -33,22 +34,89 @@ class EvaluationGymnique:
         # Liste vide pour les éléments techniques
         self.elements_techniques = []
         self.appreciations = ["M", "PM", "NM", "NR"]
+        
+        # Paramètres dynamiques pour la mise en page
+        self.base_font_size = 10  # Taille de base pour les polices
+        self.base_header_font_size = 14  # Taille de base pour l'en-tête
+        self.base_row_height = 1  # Hauteur de base pour les lignes en cm
+        self.table_font_size = 9  # Taille de base pour les tableaux
+        
+        # Espace disponible sur une page A4 (en cm)
+        self.available_height = 27.7  # 29.7 - marges
+        
+        # Estimation de l'espace fixe occupé par les éléments autres que le tableau principal
+        self.fixed_elements_height = 14  # Estimation en cm
+    
+    def calculate_dynamic_sizing(self):
+        """Calcule les tailles dynamiques en fonction du nombre d'éléments techniques"""
+        # Nombre d'éléments techniques
+        num_elements = len(self.elements_techniques)
+        
+        # Calcul de l'espace nécessaire pour le tableau principal
+        # Chaque élément nécessite une ligne + une ligne d'en-tête
+        required_table_height = (num_elements + 1) * self.base_row_height
+        
+        # Espace disponible pour le tableau principal
+        available_space = self.available_height - self.fixed_elements_height
+        
+        # Facteur d'ajustement
+        if required_table_height > available_space and num_elements > 0:
+            adjustment_factor = available_space / required_table_height
+            # Ajuster les tailles en fonction du nombre d'éléments
+            if num_elements <= 5:
+                # Ajustements mineurs pour peu d'éléments
+                self.dynamic_font_size = max(self.base_font_size - 1, 7)
+                self.dynamic_header_font_size = max(self.base_header_font_size - 1, 12)
+                self.dynamic_table_font_size = max(self.table_font_size - 1, 7)
+                self.dynamic_row_height = self.base_row_height * 0.9
+                self.spacing_factor = 0.9
+            elif num_elements <= 10:
+                # Ajustements moyens
+                self.dynamic_font_size = max(self.base_font_size - 2, 6.5)
+                self.dynamic_header_font_size = max(self.base_header_font_size - 2, 11)
+                self.dynamic_table_font_size = max(self.table_font_size - 2, 6.5)
+                self.dynamic_row_height = self.base_row_height * 0.75
+                self.spacing_factor = 0.7
+            elif num_elements <= 15:
+                # Ajustements significatifs
+                self.dynamic_font_size = max(self.base_font_size - 3, 6)
+                self.dynamic_header_font_size = max(self.base_header_font_size - 3, 10)
+                self.dynamic_table_font_size = max(self.table_font_size - 3, 6)
+                self.dynamic_row_height = self.base_row_height * 0.6
+                self.spacing_factor = 0.5
+            else:
+                # Ajustements maximaux pour beaucoup d'éléments
+                self.dynamic_font_size = max(self.base_font_size - 4, 5.5)
+                self.dynamic_header_font_size = max(self.base_header_font_size - 4, 9)
+                self.dynamic_table_font_size = max(self.table_font_size - 4, 5.5)
+                self.dynamic_row_height = max(self.base_row_height * 0.5, 0.4)  # Minimum 0.4 cm
+                self.spacing_factor = 0.3
+        else:
+            # Aucun ajustement nécessaire
+            self.dynamic_font_size = self.base_font_size
+            self.dynamic_header_font_size = self.base_header_font_size
+            self.dynamic_table_font_size = self.table_font_size
+            self.dynamic_row_height = self.base_row_height
+            self.spacing_factor = 1.0
     
     def ajouter_entete_colore(self):
         header_paragraph = self.document.add_paragraph()
         header_paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        header_paragraph.space_after = Pt(6)
+        header_paragraph.space_after = Pt(6 * self.spacing_factor)
         header_run = header_paragraph.add_run("ÉVALUATION GYMNASTIQUE")
         header_run.bold = True
-        header_run.font.size = Pt(14)
+        header_run.font.size = Pt(self.dynamic_header_font_size)
         header_run.font.color.rgb = RGBColor(0, 32, 96)
         
         header_table = self.document.add_table(rows=3, cols=2)
         header_table.style = 'Table Grid'
         header_table.autofit = False
         
+        # Ajustement dynamique de la hauteur des lignes
+        row_height = Cm(0.8 * (self.dynamic_row_height / self.base_row_height))
         for row in header_table.rows:
-            row.height = Cm(0.8)
+            row.height = row_height
+            
         for row in header_table.rows:
             for cell in row.cells:
                 shading_elm = parse_xml(f'<w:shd {nsdecls("w")} w:fill="D9E2F3"/>')
@@ -59,73 +127,72 @@ class EvaluationGymnique:
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Centre d'examen: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.centre_examen).font.size = Pt(10)
+        paragraph.add_run(self.centre_examen).font.size = Pt(self.dynamic_font_size)
         
         cell = header_table.cell(0, 1)
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Examen: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.type_examen).font.size = Pt(10)
+        paragraph.add_run(self.type_examen).font.size = Pt(self.dynamic_font_size)
         
         # Deuxième ligne
         cell = header_table.cell(1, 0)
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Série: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.serie).font.size = Pt(10)
+        paragraph.add_run(self.serie).font.size = Pt(self.dynamic_font_size)
         
         cell = header_table.cell(1, 1)
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Établissement: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.etablissement).font.size = Pt(10)
+        paragraph.add_run(self.etablissement).font.size = Pt(self.dynamic_font_size)
         
         # Troisième ligne
         cell = header_table.cell(2, 0)
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Session: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.session).font.size = Pt(10)
+        paragraph.add_run(self.session).font.size = Pt(self.dynamic_font_size)
         
         cell = header_table.cell(2, 1)
         paragraph = cell.paragraphs[0]
         run = paragraph.add_run("Candidat: ")
         run.bold = True
-        run.font.size = Pt(10)
+        run.font.size = Pt(self.dynamic_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
-        paragraph.add_run(self.nom_candidat).font.size = Pt(10)
+        paragraph.add_run(self.nom_candidat).font.size = Pt(self.dynamic_font_size)
         
-        self.document.add_paragraph().space_after = Pt(4)
+        # Espace après l'en-tête ajusté dynamiquement
+        self.document.add_paragraph().space_after = Pt(4 * self.spacing_factor)
     
     def creer_tableau_elements(self):
         table = self.document.add_table(rows=len(self.elements_techniques) + 1, cols=5)
         table.style = 'Table Grid'
         table.alignment = WD_TABLE_ALIGNMENT.CENTER
         
+        # Configuration des largeurs de colonnes (proportionnelle)
+        total_width = 18  # Largeur totale approximative en cm
+        
         # Configuration des largeurs de colonnes
-        for cell in table.columns[0].cells:
-            cell.width = Cm(8)
-        for cell in table.columns[1].cells:
-            cell.width = Cm(3)
-        for cell in table.columns[2].cells:
-            cell.width = Cm(2)
-        for cell in table.columns[3].cells:
-            cell.width = Cm(2.5)
-        for cell in table.columns[4].cells:
-            cell.width = Cm(2.5)
+        col_widths = [8, 3, 2, 2.5, 2.5]  # Largeurs originales
+        for i, width in enumerate(col_widths):
+            for cell in table.columns[i].cells:
+                cell.width = Cm(width)
         
+        # Ajustement dynamique de la hauteur des lignes
         for row in table.rows:
-            row.height = Cm(1)
+            row.height = Cm(self.dynamic_row_height)
         
         # En-tête du tableau
         header_row = table.rows[0]
@@ -140,7 +207,7 @@ class EvaluationGymnique:
             cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
             run = cell.paragraphs[0].runs[0]
             run.bold = True
-            run.font.size = Pt(9)
+            run.font.size = Pt(self.dynamic_table_font_size)
             run.font.color.rgb = RGBColor(0, 32, 96)
         table.cell(0, 1).merge(table.cell(0, 2))
         
@@ -151,14 +218,14 @@ class EvaluationGymnique:
             element_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.LEFT
             run = element_cell.paragraphs[0].runs[0]
             run.bold = True
-            run.font.size = Pt(9)
+            run.font.size = Pt(self.dynamic_table_font_size)
             
             categorie_cell = table.cell(i, 1)
             categorie_cell.text = element["categorie"]
             categorie_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
             run = categorie_cell.paragraphs[0].runs[0]
             run.bold = True
-            run.font.size = Pt(9)
+            run.font.size = Pt(self.dynamic_table_font_size)
             run.italic = True
             
             points_cell = table.cell(i, 2)
@@ -166,29 +233,34 @@ class EvaluationGymnique:
             points_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
             run = points_cell.paragraphs[0].runs[0]
             run.bold = True
-            run.font.size = Pt(9)
+            run.font.size = Pt(self.dynamic_table_font_size)
             run.italic = True
     
     def ajouter_note_jury(self):
         para = self.document.add_paragraph()
-        para.space_before = Pt(4)
-        para.space_after = Pt(4)
+        para.space_before = Pt(4 * self.spacing_factor)
+        para.space_after = Pt(4 * self.spacing_factor)
         run = para.add_run("NB1 : Zone réservée aux membres du jury ! Le jury cochera le point correspondant au niveau de réalisation de l'élément gymnique par le candidat.")
         run.bold = True
         run.font.color.rgb = RGBColor(255, 0, 0)
-        run.font.size = Pt(8)
+        run.font.size = Pt(max(self.dynamic_font_size - 2, 5.5))  # Minimum 5.5pt
     
     def creer_tableau_recapitulatif(self):
         note_table = self.document.add_table(rows=3, cols=13)
         note_table.style = 'Table Grid'
         note_table.alignment = WD_TABLE_ALIGNMENT.CENTER
         
+        # Ajuster la hauteur des lignes
         for row in note_table.rows:
-            row.height = Cm(0.6)
+            row.height = Cm(0.6 * (self.dynamic_row_height / self.base_row_height))
+            
         for cell in note_table.rows[0].cells:
             shading_elm = parse_xml(f'<w:shd {nsdecls("w")} w:fill="BDD7EE"/>')
             cell._tc.get_or_add_tcPr().append(shading_elm)
         
+        # Taille de police pour le tableau récapitulatif (légèrement plus petite)
+        recap_font_size = max(self.dynamic_table_font_size - 1, 5)
+        
         for col, (type_lettre, points) in enumerate([("A", "1pt"), ("B", "1,5pt"), ("C", "2pts"), ("D", "2,5pts"), ("E", "3pts")]):
             idx = col * 2
             if idx + 1 < len(note_table.columns):
@@ -198,7 +270,7 @@ class EvaluationGymnique:
                 cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                 for run in cell.paragraphs[0].runs:
                     run.bold = True
-                    run.font.size = Pt(8)
+                    run.font.size = Pt(recap_font_size)
                     run.font.color.rgb = RGBColor(0, 32, 96)
         
         for col, (titre, points) in enumerate([("ROV", "2pts"), ("Projet", "2pts"), ("Réalisation", "16pts")], 10):
@@ -208,7 +280,7 @@ class EvaluationGymnique:
                 cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                 for run in cell.paragraphs[0].runs:
                     run.bold = True
-                    run.font.size = Pt(8)
+                    run.font.size = Pt(recap_font_size)
                     run.font.color.rgb = RGBColor(0, 32, 96)
         
         for col in range(5):
@@ -219,14 +291,14 @@ class EvaluationGymnique:
                 neg_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                 for run in neg_cell.paragraphs[0].runs:
                     run.italic = True
-                    run.font.size = Pt(8)
+                    run.font.size = Pt(recap_font_size)
                 
                 note_cell = note_table.cell(1, idx + 1)
                 note_cell.text = "Note"
                 note_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                 for run in note_cell.paragraphs[0].runs:
                     run.italic = True
-                    run.font.size = Pt(8)
+                    run.font.size = Pt(recap_font_size)
         
         for col in range(10, 13):
             if col < len(note_table.columns):
@@ -235,14 +307,7 @@ class EvaluationGymnique:
                 cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
                 for run in cell.paragraphs[0].runs:
                     run.italic = True
-                    run.font.size = Pt(9)
-        
-        for col, type_lettre in enumerate(["A", "B", "C", "D", "E"]):
-            idx = col * 2
-            if idx < len(note_table.columns):
-                neg_cell = note_table.cell(2, idx)
-                neg_cell.text = ""
-                neg_cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
+                    run.font.size = Pt(recap_font_size)
     
     def ajouter_note_candidat_avec_cadre(self):
         note_table = self.document.add_table(rows=1, cols=1)
@@ -254,17 +319,21 @@ class EvaluationGymnique:
         cell._tc.get_or_add_tcPr().append(shading_elm)
         
         p = cell.paragraphs[0]
+        
+        # Pour les notes de bas, on adapte encore plus la taille si nécessaire
+        font_size = max(6 * self.spacing_factor, 5)
+        
         run = p.add_run("NB2: Après le choix des catégories d'éléments gymniques par le candidat, ce dernier remplira la colonne de pointage selon l'orientation suivante: A (0.25; 0.5; 0.75; 1) B (0.25; 0.5; 0.75; 1; 1.25; 1.5) C (0.5; 0.75; 1; 1.25; 1.5; 2) D (0.75; 1; 1.25; 1.5; 2; 2.5) et E (0.75; 1; 1.5; 2; 2.5; 3) également, le candidat devra fournir 2 copies de son projet sur une page! (appréciations: NR, NM, PM, M).")
         run.italic = True
-        run.font.size = Pt(6)
+        run.font.size = Pt(font_size)
     
     def ajouter_zone_note(self):
         zone_note = self.document.add_table(rows=1, cols=2)
         zone_note.style = 'Table Grid'
         zone_note.alignment = WD_TABLE_ALIGNMENT.RIGHT
         
-        # Définir une largeur fixe pour les deux cellules
-        cell_width = Cm(1.5)
+        # Ajuster la taille selon le nombre d'éléments
+        cell_width = Cm(1.5 * self.spacing_factor)
         
         cell_libelle = zone_note.cell(0, 0)
         cell_libelle.width = cell_width
@@ -272,7 +341,7 @@ class EvaluationGymnique:
         cell_libelle.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.RIGHT
         run = cell_libelle.paragraphs[0].runs[0]
         run.bold = True
-        run.font.size = Pt(9)
+        run.font.size = Pt(self.dynamic_table_font_size)
         run.font.color.rgb = RGBColor(0, 32, 96)
         
         cell_saisie = zone_note.cell(0, 1)
@@ -284,23 +353,34 @@ class EvaluationGymnique:
         cell_saisie.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
         run = cell_saisie.paragraphs[0].runs[0]
         run.bold = True
-        run.font.size = Pt(9)
-        
-        # Ajouter plus d'espace avant la liste des correcteurs
-        self.document.add_paragraph().space_after = Pt(5)
-        self.document.add_paragraph().space_after = Pt(5)
+        run.font.size = Pt(self.dynamic_table_font_size)
     
     def ajouter_lignes_correcteurs(self):
-        para_intro = self.document.add_paragraph()
-        para_intro.space_before = Pt(4)
-        
-        for role in ["Projet", "principal", "ROV"]:
+        # Si beaucoup d'éléments, fusionner tous les correcteurs sur une seule ligne
+        if len(self.elements_techniques) > 12:
             para = self.document.add_paragraph()
-            para.space_before = Pt(2)
-            para.space_after = Pt(2)
-            run = para.add_run(f"Correcteur {role} : ")
+            para.space_before = Pt(2 * self.spacing_factor)
+            para.space_after = Pt(2 * self.spacing_factor)
+            run = para.add_run("Correcteurs: ")
             run.bold = True
-            para.add_run(".................................................................")
+            run.font.size = Pt(self.dynamic_font_size)
+            para.add_run("Projet / Principal / ROV").font.size = Pt(self.dynamic_font_size)
+        else:
+            # Format standard avec une ligne par correcteur
+            para_intro = self.document.add_paragraph()
+            para_intro.space_before = Pt(2 * self.spacing_factor)
+            
+            for role in ["Projet", "principal", "ROV"]:
+                para = self.document.add_paragraph()
+                para.space_before = Pt(2 * self.spacing_factor)
+                para.space_after = Pt(2 * self.spacing_factor)
+                run = para.add_run(f"Correcteur {role} : ")
+                run.bold = True
+                run.font.size = Pt(self.dynamic_font_size)
+                
+                # Ajuster le nombre de points en fonction du nombre d'éléments
+                points_count = max(20, 50 - len(self.elements_techniques) * 2)
+                para.add_run("." * points_count).font.size = Pt(self.dynamic_font_size)
     
     # Méthodes de modification des données
     def modifier_centre_examen(self, nom):
@@ -329,13 +409,30 @@ class EvaluationGymnique:
         })
     
     def generer_document(self, nom_fichier="evaluation_gymnastique.docx"):
+        # Calculer les paramètres dynamiques en fonction du nombre d'éléments
+        self.calculate_dynamic_sizing()
+        
+        # Générer le document avec les paramètres dynamiques
         self.ajouter_entete_colore()
         self.creer_tableau_elements()
-        self.ajouter_note_jury()
-        self.creer_tableau_recapitulatif()
-        self.ajouter_lignes_correcteurs()
-        self.ajouter_zone_note()
+        
+        # Pour les documents très chargés, réorganiser les éléments
+        if len(self.elements_techniques) > 15:
+            # Version simplifiée et compacte
+            self.ajouter_note_jury()
+            self.creer_tableau_recapitulatif()
+            self.ajouter_zone_note()
+            self.ajouter_lignes_correcteurs()  # Version compacte des correcteurs
+        else:
+            # Version standard
+            self.ajouter_note_jury()
+            self.creer_tableau_recapitulatif()
+            self.ajouter_lignes_correcteurs()
+            self.ajouter_zone_note()
+        
+        # Toujours inclure la note candidat
         self.ajouter_note_candidat_avec_cadre()
+        
         self.document.save(nom_fichier)
         return nom_fichier