update pnp pimpinan struktur dan jurusan

scrapping/jurusan_scrap.py

@@ -5,7 +5,6 @@ from dotenv import load_dotenv
 from supabase import create_client
 from datetime import datetime
 import os, re, tempfile
-import logging
 
 load_dotenv()
 
@@ -13,26 +12,24 @@ SUPABASE_URL = os.environ.get("NEXT_PUBLIC_SUPABASE_URL")
 SUPABASE_KEY = os.environ.get("SUPABASE_SERVICE_KEY")
 SUPABASE_BUCKET = os.environ.get("NEXT_PUBLIC_SUPABASE_STORAGE_BUCKET", "pnp-bot-storage")
 
+
 def is_valid_prodi(nama):
-    """Validate if a string represents a valid study program name"""
-    if not nama or len(nama.strip()) < 3:
-        return False
-    
-    pattern = r'^(D[-\s]?[2-4]|Diploma[-\s]?[2-4]|Magister|Sarjana Terapan|Teknologi Rekayasa|Prodi D3)\b'
-    return bool(re.match(pattern, nama.strip(), re.I))
+    return bool(re.match(
+        r'^(D[-\s]?[2-4]|Diploma[-\s]?[2-4]|Magister|Sarjana Terapan|Teknologi Rekayasa|Prodi D3)\b',
+        nama, re.I
+    ))
+
 
 class JurusanSpider(scrapy.Spider):
     name = "jurusan"
     custom_settings = {
-        'DOWNLOAD_DELAY': 2,
+        'DOWNLOAD_DELAY': 1,
         'USER_AGENT': 'PNPBot/1.0',
         'ROBOTSTXT_OBEY': True,
         'LOG_LEVEL': 'INFO',
+        'HTTPCACHE_ENABLED': False,
         'CONCURRENT_REQUESTS': 1,
-        'DOWNLOAD_TIMEOUT': 100,
-        'RETRY_TIMES': 3,
-        'DEPTH_LIMIT': 3,  # Prevent infinite crawling
-        'DUPEFILTER_CLASS': 'scrapy.dupefilters.RFPDupeFilter',
+        'RETRY_TIMES': 3
     }
 
     domain_to_name = {
@@ -45,99 +42,46 @@ class JurusanSpider(scrapy.Spider):
         'ti.pnp.ac.id': 'Teknologi_Informasi',
     }
 
+    allowed_domains = list(domain_to_name.keys())
     start_urls = [f"https://{d}/" for d in domain_to_name.keys()]
 
-    def __init__(self, *args, **kwargs):
-        super(JurusanSpider, self).__init__(*args, **kwargs)
-        
-        # Validate environment variables
-        if not all([SUPABASE_URL, SUPABASE_KEY]):
-            raise ValueError("Missing required environment variables: SUPABASE_URL, SUPABASE_KEY")
-            
-        try:
-            self.supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
-        except Exception as e:
-            self.logger.error(f"Failed to initialize Supabase client: {e}")
-            raise
-            
+    def __init__(self):
+        self.supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
         self.bucket = SUPABASE_BUCKET
         self.timestamp = datetime.now().strftime("%Y%m%d_%H%M")
         self.per_jurusan_pages = {}
         self.rekap_prodi = {}
-        self.processed_urls = set()  # Track processed URLs
 
     def parse(self, response):
-        """Parse main department pages"""
-        if response.status != 200:
-            self.logger.warning(f"Non-200 response from {response.url}: {response.status}")
-            return
-
         domain = response.url.split("//")[1].split("/")[0]
         jurusan = self.domain_to_name.get(domain, domain)
-        
-        try:
-            soup = BeautifulSoup(response.text, "html.parser")
-        except Exception as e:
-            self.logger.error(f"Failed to parse HTML from {response.url}: {e}")
-            return
+        soup = BeautifulSoup(response.text, "html.parser")
 
         program_studi = []
 
-        # Extract study programs
-        for a_tag in soup.find_all("a"):
-            try:
-                item = a_tag.get_text(strip=True)
-                href = a_tag.get("href")
-                
-                if item and is_valid_prodi(item) and item not in program_studi:
-                    program_studi.append(item)
-                    if href:
-                        prodi_url = response.urljoin(href)
-                        if prodi_url not in self.processed_urls:
-                            self.processed_urls.add(prodi_url)
-                            self.logger.info(f"[🧩] Found prodi: {item} ({prodi_url}) in {jurusan}")
-                            yield scrapy.Request(
-                                prodi_url, 
-                                callback=self.parse_detail, 
-                                meta={"jurusan": jurusan, "url": prodi_url},
-                                dont_filter=False
-                            )
-            except Exception as e:
-                self.logger.warning(f"Error processing link in {response.url}: {e}")
-                continue
+        for a_tag in soup.find_all("a", href=True):
+            item = a_tag.get_text(strip=True)
+            href = a_tag["href"]
+            if item and is_valid_prodi(item) and item not in program_studi:
+                program_studi.append(item)
+                prodi_url = response.urljoin(href)
+                self.logger.info(f"[🧩] Ditemukan prodi: {item} ({prodi_url}) di jurusan {jurusan}")
+                yield response.follow(href, callback=self.parse_detail,
+                                      meta={"jurusan": jurusan, "url": prodi_url})
 
-        # Store initial results
         self.rekap_prodi[jurusan] = program_studi
 
-        # Follow internal links with better filtering
+        # Follow semua link internal
         for a in soup.find_all("a", href=True):
-            try:
-                href = a["href"]
-                full_url = None
-                
-                if href.startswith("http") and domain in href:
-                    full_url = href
-                elif href.startswith("/"):
-                    full_url = response.urljoin(href)
-                
-                if full_url and full_url not in self.processed_urls:
-                    # Skip certain file types and external links
-                    if any(ext in full_url.lower() for ext in ['.pdf', '.doc', '.xls', '.ppt', '.jpg', '.png', '.gif']):
-                        continue
-                        
-                    self.processed_urls.add(full_url)
-                    yield scrapy.Request(
-                        full_url, 
-                        callback=self.parse_detail, 
-                        meta={"jurusan": jurusan, "url": full_url}
-                    )
-            except Exception as e:
-                self.logger.warning(f"Error processing internal link: {e}")
-                continue
+            yield response.follow(a["href"], callback=self.parse_detail,
+                                  meta={"jurusan": jurusan, "url": response.urljoin(a["href"])})
+
+    def parse_detail(self, response):
+        jurusan = response.meta["jurusan"]
+        url = response.meta["url"]
+        soup = BeautifulSoup(response.text, "html.parser")
 
-    def clean_html(self, soup):
-        """Clean HTML content by removing unwanted elements"""
-        # Remove unwanted elements
+        # Bersihkan elemen yang tidak diperlukan
         for selector in [
             'header', 'footer', 'nav', 'aside', 'menu',
             '.header', '.footer', '.navbar', '.nav', '.sidebar', '.menu',
@@ -149,280 +93,118 @@ class JurusanSpider(scrapy.Spider):
             for tag in soup.select(selector):
                 tag.decompose()
 
-        # Remove empty containers
         for element in soup.find_all(True):
             if not element.get_text(strip=True) and not element.find_all(True):
                 element.decompose()
 
-    def parse_detail(self, response):
-        """Parse detailed pages"""
-        if response.status != 200:
-            return
-
-        jurusan = response.meta["jurusan"]
-        url = response.meta["url"]
-        
-        try:
-            soup = BeautifulSoup(response.text, "html.parser")
-        except Exception as e:
-            self.logger.error(f"Failed to parse HTML from {url}: {e}")
-            return
-
-        self.clean_html(soup)
-
         title_tag = soup.find("title") or soup.find("h1")
         page_title = title_tag.get_text(strip=True) if title_tag else "Halaman"
 
-        # Handle specific TI pages
-        if url == "https://ti.pnp.ac.id/index.php/dosen-staf-pengajar/":
-            content_text = self.parse_ti_dosen_page(soup, url)
-        elif url == "https://ti.pnp.ac.id/index.php/pimpinan-jurusan/":
-            content_text = self.parse_ti_leadership_page(soup, url)
-        else:
-            content_text = self.parse_general_page(soup, url, jurusan, page_title)
-
-        if content_text:
-            self.per_jurusan_pages.setdefault(jurusan, []).append({
-                "url": url,
-                "title": page_title,
-                "content": content_text
-            })
-
-    def parse_ti_dosen_page(self, soup, url):
-        """Parse TI dosen page specifically"""
-        dosen_list = []
-
-        # Find names in gallery captions
-        for nama_tag in soup.find_all("dd", class_="wp-caption-text"):
-            nama = nama_tag.get_text(strip=True)
-            if nama and nama not in dosen_list:
-                dosen_list.append(nama)
-
-        # Create narrative text
-        naratif = ["## Daftar Dosen dan Staf Pengajar"]
-        for nama in dosen_list:
-            naratif.append(f"- {nama}")
-
-        return f"""# Dosen dan Staf Pengajar Teknologi Informasi
+        # Selalu inisialisasi content_text
+        content_text = f"# {page_title}\nURL: {url}\nJurusan: {jurusan}\nTanggal Akses: {datetime.now().strftime('%d %B %Y %H:%M')}\n\n"
 
-URL: {url}
-Jurusan: Teknologi Informasi
-Tanggal Akses: {datetime.now().strftime('%d %B %Y %H:%M')}
-
-{chr(10).join(naratif)}"""
+        # Special case: dosen TI
+        if url == "https://ti.pnp.ac.id/index.php/dosen-staf-pengajar/":
+            dosen_list = [n.get_text(strip=True) for n in soup.find_all("dd", class_="wp-caption-text") if n.get_text(strip=True)]
+            naratif = ["## Daftar Dosen dan Staf Pengajar"] + [f"- {n}" for n in dosen_list]
+            content_text += "\n".join(naratif)
+            self.per_jurusan_pages.setdefault(jurusan, []).append({"url": url, "title": "Dosen dan Staf Pengajar Teknologi Informasi", "content": content_text})
+            return
 
-    def parse_ti_leadership_page(self, soup, url):
-        """Parse TI leadership page specifically"""
-        leadership_data = {
-            "Pimpinan Jurusan": [],
-            "Koordinator Program Studi": [],
-            "Kepala Labor": []
-        }
-        
-        # Extract all member items
-        member_items = soup.find_all(class_="member-item")
-        
-        for member in member_items:
-            try:
+        # Special case: pimpinan jurusan TI
+        if url == "https://ti.pnp.ac.id/index.php/pimpinan-jurusan/":
+            leadership_data = {"Pimpinan Jurusan": [], "Koordinator Program Studi": [], "Kepala Labor": []}
+            for member in soup.find_all(class_="member-item"):
                 name_tag = member.find(class_="item-title")
                 name = name_tag.get_text(strip=True) if name_tag else "N/A"
-                
                 position_tag = member.find(class_="small-text")
                 position = position_tag.get_text(strip=True) if position_tag else "N/A"
-                
-                # Categorize based on position
-                if any(role in position for role in ["Ketua Jurusan", "Sekretaris Jurusan"]):
+                if "Ketua Jurusan" in position or "Sekretaris Jurusan" in position:
                     leadership_data["Pimpinan Jurusan"].append({"nama": name, "jabatan": position})
-                elif any(role in position for role in ["Koordinator Program Studi", "Koordinator PSDKU"]):
+                elif "Koordinator Program Studi" in position or "Koordinator PSDKU" in position:
                     leadership_data["Koordinator Program Studi"].append({"nama": name, "jabatan": position})
                 elif "Kepala Labor" in position:
                     leadership_data["Kepala Labor"].append({"nama": name, "jabatan": position})
-            except Exception as e:
-                self.logger.warning(f"Error parsing member item: {e}")
-                continue
-        
-        # Generate narrative
-        naratif = []
-        for section, members in leadership_data.items():
-            if members:
-                naratif.append(f"\n## {section}")
-                for member in members:
-                    naratif.append(f"- {member['jabatan']}: {member['nama']}")
-        
-        return f"""# Pimpinan Jurusan Teknologi Informasi
-
-URL: {url}
-Jurusan: Teknologi Informasi
-Tanggal Akses: {datetime.now().strftime('%d %B %Y %H:%M')}
-
-{chr(10).join(naratif)}"""
-
-    def parse_general_page(self, soup, url, jurusan, page_title):
-        """Parse general pages"""
-        body_text = []
-        for element in soup.find_all(["p", "h1", "h2", "h3", "h4", "h5", "h6", "li"]):
-            txt = element.get_text(strip=True)
-            if txt and len(txt) > 10:  # Filter out very short text
-                body_text.append(txt)
-
-        content_text = f"""# {page_title}
 
-URL: {url}
-Jurusan: {jurusan.replace('_', ' ')}
-Tanggal Akses: {datetime.now().strftime('%d %B %Y %H:%M')}
-
-{chr(10).join(body_text)}"""
-
-        # Extract faculty information from tables
-        dosen_entries = self.extract_faculty_info(soup)
-        if dosen_entries:
-            content_text += f"\n\n## Daftar Dosen\n\n{chr(10).join(dosen_entries)}"
+            naratif = ["## Pimpinan Jurusan"] + [f"- {x['jabatan']}: {x['nama']}" for x in leadership_data["Pimpinan Jurusan"]]
+            naratif += ["\n## Koordinator Program Studi"] + [f"- {x['jabatan']}: {x['nama']}" for x in leadership_data["Koordinator Program Studi"]]
+            naratif += ["\n## Kepala Labor"] + [f"- {x['jabatan']}: {x['nama']}" for x in leadership_data["Kepala Labor"]]
+            content_text += "\n".join(naratif)
+            self.per_jurusan_pages.setdefault(jurusan, []).append({"url": url, "title": "Pimpinan Jurusan Teknologi Informasi", "content": content_text})
+            return
 
-        # Add general tables
-        tables_content = self.extract_tables(soup)
-        if tables_content:
-            content_text += f"\n\n## Tabel Data\n\n{tables_content}"
+        # Ambil body text
+        for p in soup.find_all(["p", "h1", "h2", "h3", "h4", "h5", "h6", "li"]):
+            txt = p.get_text(strip=True)
+            if txt:
+                content_text += txt + "\n"
 
-        return content_text
+        # Ambil tabel
+        for i, table in enumerate(soup.find_all("table")):
+            content_text += f"\n\nTabel {i+1}\n\n"
+            for row in table.find_all("tr"):
+                cols = row.find_all(["td", "th"])
+                row_data = [col.get_text(strip=True) for col in cols]
+                content_text += " | ".join(row_data) + "\n"
 
-    def extract_faculty_info(self, soup):
-        """Extract faculty information from tables and text"""
-        dosen_entries = []
-        
-        # Extract from tables
-        for table in soup.find_all("table"):
-            try:
-                headers = [th.get_text(strip=True).lower() for th in table.find_all("th")]
-                if any(keyword in " ".join(headers) for keyword in ["dosen", "jabatan", "nip", "nama"]):
-                    for row in table.find_all("tr")[1:]:
-                        cols = row.find_all(["td", "th"])
-                        if len(cols) >= 1:
-                            nama_dosen = cols[0].get_text(strip=True)
-                            jabatan = cols[1].get_text(strip=True) if len(cols) > 1 else "-"
-                            if nama_dosen and len(nama_dosen) > 3:
-                                dosen_entries.append(f"Nama: {nama_dosen} | Jabatan: {jabatan}")
-            except Exception as e:
-                self.logger.warning(f"Error extracting faculty from table: {e}")
-                continue
+        self.per_jurusan_pages.setdefault(jurusan, []).append({"url": url, "title": page_title, "content": content_text})
 
-        return list(set(dosen_entries))  # Remove duplicates
+        # Follow link dari halaman detail juga
+        for a in soup.find_all("a", href=True):
+            yield response.follow(a["href"], callback=self.parse_detail,
+                                  meta={"jurusan": jurusan, "url": response.urljoin(a["href"])})
 
-    def extract_tables(self, soup):
-        """Extract table data"""
-        tables_content = []
-        
-        for i, table in enumerate(soup.find_all("table")):
+    def closed(self, reason):
+        # Simpan per jurusan
+        for jurusan, pages in self.per_jurusan_pages.items():
+            filename = f"{jurusan.replace(' ', '_').upper()}_{self.timestamp}.txt"
             try:
-                table_data = [f"### Tabel {i+1}"]
-                for row in table.find_all("tr"):
-                    cols = row.find_all(["td", "th"])
-                    if cols:
-                        row_data = [col.get_text(strip=True) for col in cols]
-                        table_data.append(" | ".join(row_data))
-                
-                if len(table_data) > 1:  # Only add if table has content
-                    tables_content.extend(table_data)
-                    tables_content.append("")  # Add spacing
+                with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False, suffix=".txt") as f:
+                    for page in pages:
+                        f.write(page["content"] + "\n\n---\n\n")
+                    temp_path = f.name
+                self.supabase.storage.from_(self.bucket).upload(path=filename, file=temp_path,
+                                                                file_options={"content-type": "text/plain"})
+                self.logger.info(f"✅ Uploaded file jurusan: {filename}")
             except Exception as e:
-                self.logger.warning(f"Error extracting table {i}: {e}")
-                continue
-        
-        return "\n".join(tables_content)
+                self.logger.error(f"❌ Gagal upload {filename}: {e}")
+            finally:
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
 
-    def upload_to_supabase(self, filename, content, content_type="text/plain"):
-        """Upload content to Supabase storage"""
+        # Simpan rekap
+        rekap_filename = f"REKAP_PROGRAM_STUDI_{self.timestamp}.txt"
         try:
             with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", delete=False, suffix=".txt") as f:
-                f.write(content)
+                f.write(f"# REKAP PROGRAM STUDI PNP\nDiperbarui pada: {datetime.now().strftime('%d %B %Y %H:%M')}\n\n")
+                total_prodi = 0
+                jumlah_jurusan = 0
+                for jurusan, daftar in self.rekap_prodi.items():
+                    valid_prodi = [p.strip() for p in daftar if is_valid_prodi(p)]
+                    if not valid_prodi:
+                        continue
+                    jurusan_baca = jurusan.replace("_", " ")
+                    f.write(f"{jurusan_baca}:\n")
+                    for p in sorted(set(valid_prodi)):
+                        f.write(f"- {p}\n")
+                    jumlah_prodi = len(valid_prodi)
+                    f.write(f"Jumlah program studi jurusan {jurusan_baca}: {jumlah_prodi}\n\n")
+                    total_prodi += jumlah_prodi
+                    jumlah_jurusan += 1
+                f.write(f"Jumlah jurusan di Politeknik Negeri Padang: {jumlah_jurusan}\n")
+                f.write(f"Jumlah seluruh program studi Politeknik Negeri Padang: {total_prodi}\n")
                 temp_path = f.name
-
-            result = self.supabase.storage.from_(self.bucket).upload(
-                path=filename,
-                file=temp_path,
-                file_options={"content-type": content_type}
-            )
-            
-            self.logger.info(f"✅ Uploaded: {filename}")
-            return True
-            
+            self.supabase.storage.from_(self.bucket).upload(path=rekap_filename, file=temp_path,
+                                                            file_options={"content-type": "text/plain"})
+            self.logger.info(f"✅ Uploaded file rekap: {rekap_filename}")
         except Exception as e:
-            self.logger.error(f"❌ Upload failed for {filename}: {e}")
-            return False
+            self.logger.error(f"❌ Gagal upload rekap: {e}")
         finally:
-            if 'temp_path' in locals() and os.path.exists(temp_path):
+            if os.path.exists(temp_path):
                 os.remove(temp_path)
 
-    def closed(self, reason):
-        """Called when spider closes"""
-        self.logger.info(f"Spider closed: {reason}")
-        
-        # Upload files per department
-        for jurusan, pages in self.per_jurusan_pages.items():
-            if not pages:
-                continue
-                
-            filename = f"{jurusan.replace(' ', '_').upper()}_{self.timestamp}.txt"
-            content = ""
-            
-            for page in pages:
-                content += f"{page['content']}\n\n---\n\n"
-            
-            self.upload_to_supabase(filename, content)
-
-        # Create and upload summary
-        self.create_and_upload_summary()
-
-    def create_and_upload_summary(self):
-        """Create and upload program study summary"""
-        rekap_filename = f"REKAP_PROGRAM_STUDI_{self.timestamp}.txt"
-        
-        content_lines = [
-            f"# REKAP PROGRAM STUDI PNP",
-            f"Diperbarui pada: {datetime.now().strftime('%d %B %Y %H:%M')}",
-            ""
-        ]
-        
-        total_prodi = 0
-        jumlah_jurusan = 0
-
-        for jurusan, daftar in self.rekap_prodi.items():
-            valid_prodi = [p.strip() for p in daftar if is_valid_prodi(p)]
-            
-            if not valid_prodi:
-                continue
-
-            jurusan_display = jurusan.replace("_", " ")
-            content_lines.append(f"## {jurusan_display}:")
-            
-            for prodi in sorted(set(valid_prodi)):
-                content_lines.append(f"- {prodi}")
-            
-            jumlah_prodi = len(set(valid_prodi))
-            content_lines.append(f"Jumlah program studi: {jumlah_prodi}")
-            content_lines.append("")
-
-            total_prodi += jumlah_prodi
-            jumlah_jurusan += 1
-
-        content_lines.extend([
-            f"**Total Jurusan di PNP: {jumlah_jurusan}**",
-            f"**Total Program Studi di PNP: {total_prodi}**"
-        ])
-
-        content = "\n".join(content_lines)
-        self.upload_to_supabase(rekap_filename, content)
 
 if __name__ == "__main__":
-    # Add logging configuration
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s [%(name)s] %(levelname)s: %(message)s'
-    )
-    
-    try:
-        process = CrawlerProcess()
-        process.crawl(JurusanSpider)
-        process.start()
-    except Exception as e:
-        logging.error(f"Failed to run spider: {e}")
-        raise
+    process = CrawlerProcess()
+    process.crawl(JurusanSpider)
+    process.start()

scrapping/pnp_scrap.py

@@ -192,26 +192,52 @@ class PNPContentSpider(scrapy.Spider):
                     # Simple description format
                     content = f"## Pimpinan {idx}\n\n{leader['description']}"
                 else:
-                    # Structured data format
-                    position = leader.get("Posisi", f"Pimpinan {idx}")
-                    content = f"## {position}\n\n"
+                    # Structured data format - create narrative
+                    position = leader.get("Posisi", "")
+                    nama = leader.get("Nama", "")
+                    nidn = leader.get("NIDN", "")
+                    jabatan_akademik = leader.get("Jabatan Akademik", "")
+                    jurusan = leader.get("Jurusan", "")
+                    program_studi = leader.get("Program Studi", "")
                     
-                    # Format key information in a logical order
-                    ordered_keys = ['Nama', 'NIDN', 'Jabatan Akademik', 'Jurusan', 'Program Studi']
+                    # Create narrative starting with position
+                    if position and nama:
+                        content = f"## {position}\n\n"
+                        narrative = f"{position} Politeknik Negeri Padang adalah {nama}."
+                    elif nama:
+                        content = f"## Pimpinan {idx}\n\n"
+                        narrative = f"Pimpinan ini adalah {nama}."
+                    else:
+                        content = f"## Pimpinan {idx}\n\n"
+                        narrative = "Informasi pimpinan:"
+                    
+                    # Add academic position
+                    if jabatan_akademik:
+                        narrative += f" Secara akademik, beliau menjabat sebagai {jabatan_akademik}."
+                    
+                    # Add department information
+                    if jurusan:
+                        narrative += f" Beliau berasal dari Jurusan {jurusan}."
+                    
+                    # Add study program
+                    if program_studi:
+                        narrative += f" Program studi yang diampu adalah {program_studi}."
+                    
+                    # Add NIDN
+                    if nidn:
+                        narrative += f" NIDN beliau adalah {nidn}."
                     
-                    # Add ordered information first
-                    for key in ordered_keys:
-                        if key in leader:
-                            content += f"**{key}**: {leader[key]}\n\n"
+                    content += narrative + "\n\n"
                     
-                    # Add remaining information
+                    # Add any remaining information that wasn't included in narrative
+                    used_keys = ['Posisi', 'Nama', 'NIDN', 'Jabatan Akademik', 'Jurusan', 'Program Studi', 'description']
                     for key, value in leader.items():
-                        if key not in ordered_keys and key not in ['Posisi', 'description']:
+                        if key not in used_keys:
                             content += f"**{key}**: {value}\n\n"
                     
                     # Add description if exists
                     if 'description' in leader:
-                        content += f"\n{leader['description']}\n\n"
+                        content += f"**Informasi Tambahan**: {leader['description']}\n\n"
                 
                 formatted_content.append(content.strip())