Update document handling

app.py

@@ -128,6 +128,114 @@ def get_latest_version(spec: str) -> str:
     else:
         raise HTTPException(req.status_code, "An error has occured while getting latest version")
 
+def create_nested_structure(chapters, text, real_toc_indexes):
+    """Crée une structure hiérarchique où les sous-sections sont imbriquées dans leurs sections parentes."""
+    result = {}
+    
+    # Trier les chapitres par numéro de section
+    sorted_chapters = sorted(chapters, key=lambda x: [int(p) if p.isdigit() else p for p in x.split()[0].split('.')])
+    
+    # Préparer les contenus des chapitres
+    chapter_contents = {}
+    for i, chapter in enumerate(sorted_chapters):
+        current_index = real_toc_indexes[chapter]
+        
+        # Déterminer l'index de fin
+        end_index = len(text)
+        if i < len(sorted_chapters) - 1:
+            next_chapter = sorted_chapters[i + 1]
+            end_index = real_toc_indexes[next_chapter]
+        
+        # Extraire et nettoyer le contenu
+        content = text[current_index + 1:end_index]
+        cleaned_content = "\n".join(content).strip()
+        chapter_contents[chapter] = cleaned_content
+    
+    # Fonction récursive pour construire la structure hiérarchique
+    def insert_section(root, section_path, title, content):
+        """Insère une section dans l'arborescence hiérarchique."""
+        parts = section_path.split('.')
+        
+        # Ignorer les sections sans titre réel (seulement si le titre est vide ou juste des espaces)
+        if not title.strip():
+            # Si c'est une section sans titre mais avec du contenu, on peut le fusionner avec sa première sous-section
+            # ou simplement l'ignorer selon votre besoin
+            return None
+        
+        # Cas de base: section de premier niveau
+        if len(parts) == 1:
+            key = section_path + " " + title
+            if key not in root:
+                root[key] = {"content": content, "subsections": {}}
+            else:
+                root[key]["content"] = content
+            return root[key]
+        
+        # Trouver ou créer le parent
+        parent_path = '.'.join(parts[:-1])
+        for key in root.keys():
+            if key.startswith(parent_path + " "):
+                # Parent trouvé, insérer dans ses sous-sections
+                section_key = section_path + " " + title
+                if section_key not in root[key]["subsections"]:
+                    root[key]["subsections"][section_key] = {"content": content, "subsections": {}}
+                else:
+                    root[key]["subsections"][section_key]["content"] = content
+                return root[key]["subsections"][section_key]
+        
+        # Parent non trouvé, il faut le créer d'abord
+        # Rechercher le titre du parent
+        parent_title = ""
+        for chapter in sorted_chapters:
+            if chapter.split()[0] == parent_path:
+                parts = chapter.split(maxsplit=1)
+                parent_title = parts[1] if len(parts) > 1 else ""
+                break
+        
+        # Si le parent n'a pas de titre, on cherche un parent plus haut
+        if not parent_title.strip():
+            # On peut soit ignorer cette branche, soit essayer de trouver un parent valide plus haut
+            grand_parent_parts = parent_path.split('.')
+            if len(grand_parent_parts) > 1:
+                grand_parent_path = '.'.join(grand_parent_parts[:-1])
+                for key in root.keys():
+                    if key.startswith(grand_parent_path + " "):
+                        # On a trouvé un grand-parent valide, on insère directement dedans
+                        section_key = section_path + " " + title
+                        if section_key not in root[key]["subsections"]:
+                            root[key]["subsections"][section_key] = {"content": content, "subsections": {}}
+                        return root[key]["subsections"][section_key]
+            # Si on n'a pas trouvé de grand-parent valide, on insère à la racine
+            section_key = section_path + " " + title
+            root[section_key] = {"content": content, "subsections": {}}
+            return root[section_key]
+        
+        # Créer le parent récursivement
+        parent_section = insert_section(root, parent_path, parent_title, "")
+        
+        # Si le parent n'a pas pu être créé (car sans titre), on insère à la racine
+        if parent_section is None:
+            section_key = section_path + " " + title
+            root[section_key] = {"content": content, "subsections": {}}
+            return root[section_key]
+        
+        # Maintenant insérer cette section dans le parent nouvellement créé
+        section_key = section_path + " " + title
+        parent_section["subsections"][section_key] = {"content": content, "subsections": {}}
+        return parent_section["subsections"][section_key]
+    
+    # Traiter chaque chapitre
+    for chapter in sorted_chapters:
+        parts = chapter.split(maxsplit=1)
+        section_num = parts[0]
+        section_title = parts[1] if len(parts) > 1 else ""
+        
+        # Ne traiter que les sections avec un titre
+        if section_title.strip():
+            insert_section(result, section_num, section_title, chapter_contents[chapter])
+    
+    return result
+
 class SpecRequest(BaseModel):
     specification: str
     version: Optional[str] = None
@@ -137,7 +245,7 @@ def main_page():
     return FileResponse(os.path.join("templates", "index.html"))
 
 @app.post("/from-search")
-def get_file_from_spec_id_version(req: SpecRequest) -> Dict[str, str]:
+def get_file_from_spec_id_version(req: SpecRequest) -> Dict:
     spec = req.specification
     version = req.version
     if not version:
@@ -176,13 +284,4 @@ def get_file_from_spec_id_version(req: SpecRequest) -> Dict[str, str]:
         except ValueError as e:
             real_toc_indexes[chapter] = -float("inf")
 
-    document = {}
-    toc = list(real_toc_indexes.keys())
-    index_toc = list(real_toc_indexes.values())
-    curr_index = 0
-    for x in range(1, len(toc)):
-        document[toc[curr_index].replace("\t", " ")] = re.sub(r"[\ \t]+", " ", "\n".join(text[index_toc[curr_index]+1:index_toc[x]]))
-        curr_index = x
-
-    document[toc[curr_index].replace("\t"," ")] = re.sub(r"\s+", " ", " ".join(text[index_toc[curr_index]+1:]))
-    return document
+    return create_nested_structure(chapters, text, real_toc_indexes)

static/script.js

@@ -25,12 +25,6 @@ function handleSpecSearch(){
     let body = {"specification": document.getElementById("specInput").value};
     if(versCheck && document.getElementById("versionInput").value.length > 0){
         body["version"] = document.getElementById("versionInput").value;
-    } else {
-        fetch("https://organizedprogrammers-3gppdocfinder.hf.space/find",
-            {method: "POST", headers: {"Content-Type": "application/json"}, body: JSON.stringify({"doc_id": body.specification})}
-        ).then(data => data.json())
-        .then(resp => body['version'] = resp.version)
-        .catch(error => console.error(error))
     }
     
     fetch("/from-search", {
@@ -91,57 +85,57 @@ function handleFileSelect(event) {
     reader.readAsText(file);
 }
 
-function renderDocument(tab, jsonContent) {
+function renderDocument(tab, data) {
     const container = document.querySelector(`#${tab} #document-container`);
     container.innerHTML = '';
-
-    // Parcourir tous les éléments du JSON
-    Object.entries(jsonContent).forEach(([key, value]) => {
-        // Déterminer le niveau de titre basé sur la clé
-        if (key.match(/^\d+$/)) {
-            // Section principale (ex: "1 Scope")
-            const section = document.createElement('div');
-            section.className = 'section';
-
-            const title = document.createElement('h2');
-            title.textContent = key;
-            section.appendChild(title);
-
-            const content = document.createElement('div');
-            content.innerHTML = formatText(value);
-            section.appendChild(content);
-
-            container.appendChild(section);
-        } else if (key.match(/^\d+\.\d+$/)) {
-            // Sous-section (ex: "3.1 Definitions")
-            const subsection = document.createElement('div');
-            subsection.className = 'subsection';
-
-            const title = document.createElement('h3');
-            title.textContent = key;
-            subsection.appendChild(title);
-
-            const content = document.createElement('div');
-            content.innerHTML = formatText(value);
-            subsection.appendChild(content);
-
-            container.appendChild(subsection);
-        } else {
-            // Autres éléments
-            const div = document.createElement('div');
-            const title = document.createElement('h3');
-            title.textContent = key;
-            div.appendChild(title);
-
+    
+    function renderSection(sectionKey, sectionData, level) {
+        const sectionDiv = document.createElement('div');
+        sectionDiv.className = `section level-${level}`;
+        
+        // Extraire le numéro et le titre de la clé
+        const parts = sectionKey.split(/\s(.+)/); // Divise à partir du premier espace
+        const sectionNumber = parts[0];
+        const sectionTitle = parts[1] || "";
+        
+        // Créer l'en-tête de section
+        const header = document.createElement(`h${Math.min(level + 1, 6)}`);
+        header.textContent = sectionKey; // Utiliser la clé complète comme titre
+        sectionDiv.appendChild(header);
+        
+        // Ajouter le contenu
+        if (sectionData.content) {
             const content = document.createElement('div');
-            content.innerHTML = formatText(value);
-            div.appendChild(content);
-
-            container.appendChild(div);
+            content.className = 'content';
+            content.textContent = sectionData.content;
+            sectionDiv.appendChild(content);
+        }
+        
+        // Ajouter les sous-sections récursivement
+        if (sectionData.subsections && Object.keys(sectionData.subsections).length > 0) {
+            const subsectionsDiv = document.createElement('div');
+            subsectionsDiv.className = 'subsections';
+            
+            for (const [subKey, subData] of Object.entries(sectionData.subsections)) {
+                const subSection = renderSection(subKey, subData, level + 1);
+                subsectionsDiv.appendChild(subSection);
+            }
+            
+            sectionDiv.appendChild(subsectionsDiv);
         }
-    });
+        
+        return sectionDiv;
+    }
+    
+    // Parcourir les sections de premier niveau
+    for (const [sectionKey, sectionData] of Object.entries(data)) {
+        const sectionElement = renderSection(sectionKey, sectionData, 1);
+        container.appendChild(sectionElement);
+    }
 }
 
+
+
 function formatText(text) {
     if (!text) return '';
 

static/style.css

@@ -7,6 +7,11 @@ body {
     color: #333;
 }
 
+div[class^='section level']{
+    padding: 10px;
+    border: 1px solid #bbb;
+}
+
 .header {
     margin-bottom: 30px;
     padding-bottom: 15px;