Update app.py

app.py

@@ -7,13 +7,13 @@ import zlib
 import base64
 import statistics
 import traceback
-import numpy as np
+import sys
+# On importe le nécessaire, mais on chargera l'IA prudemment
 from bs4 import BeautifulSoup
 from midiutil import MIDIFile
 
 app = FastAPI()
 
-# Configuration Web
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -27,27 +27,34 @@ BRAIN_FILE = "solfa_brain.pkl"
 TEMPO = 100
 VELOCITY = 100
 
-# --- VOTRE MOTEUR (ADAPTÉ POUR LE WEB) ---
+# --- MOTEUR PRINCIPAL ---
 class MasterEngine:
     def __init__(self):
-        print(f"🧠 Chargement du cerveau IA...")
+        self.model = None
+        self.forbidden = set("bkghjqwxyzncuvBKGHJQWXYZNCUV1234567890")
+        
+        # Tentative de chargement sécurisée
+        print("🛠️ Initialisation du moteur...")
         try:
+            # On vérifie d'abord si sklearn est installé
+            import sklearn
+            print(f"ℹ️ Version Scikit-learn du serveur: {sklearn.__version__}")
+            
             with open(BRAIN_FILE, "rb") as f:
                 self.model = pickle.load(f)
-            print("✅ Cerveau chargé !")
+            print("✅ Cerveau IA chargé avec succès !")
         except Exception as e:
-            print(f"⚠️ Cerveau introuvable ou erreur ({e}). Mode sans IA.")
+            print(f"⚠️ AVERTISSEMENT : Le cerveau IA n'a pas pu être chargé.")
+            print(f"⚠️ Raison : {e}")
+            print("⚠️ -> Passage automatique en mode ALGORITHMIQUE STRICT (Sans IA)")
             self.model = None
-            
-        self.forbidden = set("bkghjqwxyzncuvBKGHJQWXYZNCUV1234567890")
-        
-        # Mapping Solfège Chromatique
+
+        # Mapping Solfège
         self.chromatic_map = {
             'd': 0, 'di': 1, 'de': 11, 'r': 2, 'ri': 3, 'ra': 1, 'm': 4, 'ma': 3,
             'f': 5, 'fi': 6, 's': 7, 'si': 8, 'se': 6, 'l': 9, 'li': 10, 'la': 8, 't': 11, 'ta': 10
         }
         
-        # Tonalités
         self.key_signatures = {
             'C': 60, 'D': 62, 'E': 64, 'F': 65, 'G': 67, 'A': 69, 'B': 71,
             'CB': 59, 'DB': 61, 'EB': 63, 'GB': 66, 'AB': 68, 'BB': 70,
@@ -66,21 +73,28 @@ class MasterEngine:
         return [notes/length, seps/length, mods/length, bad, density]
 
     def is_music_ai(self, text):
-        """L'IA décide"""
+        """Utilise l'IA si dispo, sinon renvoie False"""
         if not self.model: return False
-        if "dia" in text.lower() and len(text) < 20: return False # Méta-donnée
-        feats = self.extract_features(text)
+        if "dia" in text.lower() and len(text) < 20: return False 
         try:
+            feats = self.extract_features(text)
             return self.model.predict([feats])[0] == 1
         except:
             return False
 
     def is_music_fallback(self, text):
-        """Roue de secours si l'IA est trop stricte"""
+        """ALGO STRICT : Utilisé si l'IA plante ou est absente"""
         clean = text.lower()
-        if any(bad in clean for bad in ["hira", "ffpm", "p.", "andri"]): return False
+        
+        # 1. Liste noire de mots malgaches courants (Paroles)
+        bad_words = ["dia", "fa", "ny", "ho", "tsy", "misy", "hira", "ffpm", "p.", "andri"]
+        if any(w in clean.split() for w in bad_words): return False
+        
+        # 2. Vérification des notes
         notes = len(re.findall(r"[drmfslt]", clean))
-        seps = len(re.findall(r"[:|]", clean))
+        seps = len(re.findall(r"[:|]", clean)) # Séparateurs de mesure
+        
+        # Une ligne de solfa DOIT avoir des séparateurs et au moins 3 notes
         return notes >= 3 and seps >= 1
 
     def clean_rhythm_text(self, text):
@@ -141,18 +155,16 @@ class MasterEngine:
 
     def generate_midi_bytes(self, html_content):
         try:
-            # 1. Extraction et Décompression (Logique de votre script)
-            # On tente d'abord la décompression si c'est le format compressé
+            # 1. DECOMPRESSION & PARSING
             match = re.search(r'const b="([^"]+)"', html_content)
+            soup = None
             if match:
                 try:
                     svg = zlib.decompress(base64.b64decode(match.group(1))).decode('utf-8')
                     soup = BeautifulSoup(svg, 'html.parser')
-                except:
-                    # Fallback si échec décompression
-                    soup = BeautifulSoup(html_content, 'html.parser')
-            else:
-                # Si pas compressé, on parse direct
+                except: pass
+            
+            if not soup:
                 soup = BeautifulSoup(html_content, 'html.parser')
             
             raw_items = []
@@ -165,9 +177,15 @@ class MasterEngine:
                         raw_items.append({'x': x, 'y': y, 'text': txt})
                     except: pass
             
+            # Fallback Regex si parsing HTML échoue
+            if not raw_items:
+                raw_matches = re.findall(r'<text[^>]*y="([\d\.]+)"[^>]*>([^<]+)</text>', str(soup))
+                for y_str, txt in raw_matches:
+                    raw_items.append({'x': 0, 'y': float(y_str), 'text': txt})
+
             if not raw_items: return None
 
-            # 2. Reconstitution Lignes
+            # 2. RECONSTITUTION LIGNES
             lines_map = {}
             for item in raw_items:
                 found = False
@@ -177,50 +195,50 @@ class MasterEngine:
                 if not found: lines_map[item['y']] = [item]
 
             all_lines_obj = []
-            full_text_blob = "" 
+            full_text_blob = ""
             
             for ky in sorted(lines_map.keys()):
                 row = sorted(lines_map[ky], key=lambda i: i['x'])
                 txt_parts = []
                 last_x = -100
                 for i in row:
-                    if i['x'] - last_x > 12: txt_parts.append(" ") 
+                    if i['x'] - last_x > 12: txt_parts.append(" ")
                     txt_parts.append(i['text'])
                     last_x = i['x'] + len(i['text'])*5
                 full_line = "".join(txt_parts).strip()
                 all_lines_obj.append({'y': ky, 'text': full_line})
                 full_text_blob += " " + full_line
 
-            # 3. Détection Tonalité
+            # 3. TONALITE
             root_note = 60
             m = re.search(r"D[oô]\s*dia\s*([A-G][b#]?)", full_text_blob, re.IGNORECASE)
             if m:
                 k = m.group(1).upper()
                 root_note = self.key_signatures.get(k, 60)
 
-            # 4. Filtrage (VOTRE LOGIQUE EXACTE ICI)
+            # 4. FILTRAGE
             valid_lines = []
             
-            # Essai 1 : L'IA
-            if self.model:
-                for obj in all_lines_obj:
-                    if self.is_music_ai(obj['text']):
-                        valid_lines.append(obj)
-            
-            method = "IA"
-            # Essai 2 : Fallback si l'IA ne trouve rien (ou n'est pas chargée)
-            if len(valid_lines) < 4:
-                method = "FORCE"
-                valid_lines = []
-                for obj in all_lines_obj:
-                    if self.is_music_fallback(obj['text']):
-                        valid_lines.append(obj)
+            # Strategie : On privilégie le Fallback algorithmique car il est plus sûr si l'IA déconne
+            # L'IA sert de validation supplémentaire si elle est là
+            for obj in all_lines_obj:
+                txt = obj['text']
+                is_ok = False
+                
+                # Test Algorithmique d'abord (Rapide et sûr)
+                if self.is_music_fallback(txt):
+                    is_ok = True
+                
+                # Test IA si chargé (pour récupérer des cas limites)
+                elif self.model and self.is_music_ai(txt):
+                    is_ok = True
+                
+                if is_ok:
+                    valid_lines.append(obj)
 
-            if not valid_lines: 
-                print("❌ Aucune ligne valide trouvée.")
-                return None
+            if not valid_lines: return None
 
-            # 5. Groupement
+            # 5. GROUPEMENT
             threshold = self.safe_threshold([l['y'] for l in valid_lines])
             systems = []
             current = []
@@ -234,7 +252,7 @@ class MasterEngine:
                 if len(current) == 4: systems.append(current); current = []
             if current: systems.append(current)
 
-            # 6. Génération MIDI
+            # 6. MIDI
             midi = MIDIFile(1)
             midi.addTempo(0, 0, TEMPO)
             cursor = 0.0
@@ -260,8 +278,7 @@ class MasterEngine:
                                 midi.addNote(0, channel, int(n[0]), n[1], n[2], VELOCITY)
                                 has_notes = True
                             active_notes = []
-                            trk_cursor += 1.0
-                            continue
+                            trk_cursor += 1.0; continue
 
                         for val, dur in notes_in_beat:
                             if val == 'SUSTAIN':
@@ -272,7 +289,6 @@ class MasterEngine:
                                     has_notes = True
                                 active_notes = []
                                 active_notes.append([val, trk_cursor, dur])
-                            
                             trk_cursor += dur
                     
                     for n in active_notes:
@@ -280,31 +296,26 @@ class MasterEngine:
                         has_notes = True
                     
                     if trk_cursor - cursor > max_dur: max_dur = trk_cursor - cursor
-                
                 cursor += max_dur + 0.2
 
             if has_notes:
                 buffer = io.BytesIO()
                 midi.writeFile(buffer)
-                print(f"✅ Génération réussie ({method}): {len(systems)} systèmes.")
                 return buffer.getvalue()
             
             return None
 
         except Exception as e:
-            print(f"⚠️ Erreur interne: {e}")
             traceback.print_exc()
             return None
 
-# --- INSTANCE GLOBALE ---
+# Initialisation du moteur (chargement sécurisé)
 engine = MasterEngine()
 
-# --- ROUTE API ---
 @app.post("/convert")
 async def convert_solfa(html_code: str = Form(...)):
     midi_data = engine.generate_midi_bytes(html_code)
-    
     if midi_data:
         return Response(content=midi_data, media_type="audio/midi")
     else:
-        return Response(status_code=400, content="Échec de la génération (Pas de notes trouvées)")
+        return Response(status_code=400, content="Echec generation")