Python: Parseaza Docx La Html Cu Procesarea Stilurilor

import os
import re
import unidecode
from docx import Document


# Funcția pentru adăugarea conținutului la tag-ul meta
def add_content_to_meta(html_content, content_to_add):
    meta_pattern = r'<meta name="description" content="(.*?)">'
    match = re.search(meta_pattern, html_content)
    if match:
        old_meta_tag = match.group(0)
        new_content = re.sub(r'<em>(.*?)</em>', r'\1', content_to_add)  # Elimină tag-urile <em>
        new_meta_tag = f'<meta name="description" content="{new_content}">'
        updated_html_content = html_content.replace(old_meta_tag, new_meta_tag)
        return updated_html_content
    else:
        return html_content


# Funcția pentru conversia stilurilor paragrafelor din DOCX în HTML
def extract_data_from_docx(file_path):
    doc = Document(file_path)
    content = ""

    # Parcurge toate paragrafele din document și le adaugă la conținut
    for paragraph in doc.paragraphs:
        content += paragraph.text + "\n"

    # Utilizăm regex pentru a găsi titlurile și corpul fiecărui articol
    articles = re.split(r'^([A-Z][\w\s’\-\(\)]+)$', content, flags=re.MULTILINE | re.DOTALL)
    articles = [article.strip() for article in articles if article.strip()]

    data = []

    # Iterăm prin lista de articole pentru a extrage titlul și corpul corespunzător
    for i in range(0, len(articles), 2):
        title = articles[i]
        body = articles[i + 1].strip().split("\n")
        data.append((title, body))

    return data



def convert_docx_to_html_style(para):
    result = ""

    if para.runs:
        contains_bold = any(run.bold for run in para.runs)
        contains_italic = any(run.italic for run in para.runs)
        contains_regular = any(not run.bold and not run.italic for run in para.runs)

        if contains_bold and contains_italic and contains_regular:
            # Cazul 4: Textul conține atât bold, cât și italic și text regulat
            html_para = '<p class="text_obisnuit">'
            is_bold = False
            is_italic = False
            for run in para.runs:
                if run.bold and not is_bold:
                    html_para += '<span class="text_obisnuit2">'
                    is_bold = True
                if run.italic and not is_italic:
                    html_para += '<em>'
                    is_italic = True
                elif not run.bold and is_bold:
                    html_para += '</span>'
                    is_bold = False
                elif not run.italic and is_italic:
                    html_para += '</em>'
                    is_italic = False

                html_para += run.text

            if is_bold:
                html_para += '</span>'
            if is_italic:
                html_para += '</em>'

            html_para += '</p>\n'

        elif contains_bold and contains_regular:
            # Cazul 3: Textul conține atât bold, cât și text regulat
            html_para = '<p class="text_obisnuit">'
            is_bold = False
            for run in para.runs:
                if run.bold and not is_bold:
                    html_para += '<span class="text_obisnuit2">'
                    is_bold = True
                elif not run.bold and is_bold:
                    html_para += '</span>'
                    is_bold = False

                html_para += run.text

            if is_bold:
                html_para += '</span>'

            html_para += '</p>\n'

        elif contains_bold:
            # Cazul 2: Textul conține doar bold
            html_para = '<p class="text_obisnuit2">'
            for run in para.runs:
                html_para += run.text
            html_para += '</p>\n'

        elif contains_italic:
            # Cazul 5: Textul conține doar italic
            html_para = '<p class="text_obisnuit">'
            is_italic = False
            for run in para.runs:
                if run.italic and not is_italic:
                    html_para += '<em>'
                    is_italic = True
                elif not run.italic and is_italic:
                    html_para += '</em>'
                    is_italic = False

                html_para += run.text

            if is_italic:
                html_para += '</em>'

            html_para += '</p>\n'

        else:
            # Cazul 1: Textul este regulat (fără bold sau italic)
            html_para = '<p class="text_obisnuit">'
            for run in para.runs:
                html_para += run.text
            html_para += '</p>\n'

        result += html_para

    return result


def generate_filename(title):
    # Îndepărtează spațiile și caracterele speciale din titlu
    title = title.strip()
    title = re.sub(r'’s|’t', '', title)
    title = re.sub(r'[^a-zA-Z0-9\s]', '', title)

    # Transformă titlul în litere mici
    title = title.lower()

    title = title.replace(' ', '-')
    # Asigură că numele fișierului are o extensie .html
    filename = title + ".html"
    print("Filename:", filename)  # Afișează numele fișierului
    return filename

def update_and_save_html(title, body, template_path, output_directory):
    with open(template_path, "r", encoding="utf-8") as f:
        html_content = f.read()

    # Eliminarea sufixului " | Neculai Fantanaru (en)" din titlu
    title_without_suffix = title.replace(" | Neculai Fantanaru (en)", "")

    # Înlocuirea titlului în tagul <h1> cu titlul fără sufix
    html_content = html_content.replace('<h1 class="den_articol" itemprop="name">XXX</h1>', f'<h1 class="den_articol" itemprop="name">{title_without_suffix}</h1>')

    # Înlocuirea titlului în conținutul HTML
    new_title = title + " | Neculai Fantanaru (en)"
    html_content = html_content.replace("XXX", new_title, 2)
    print("Titlul a fost înlocuit.")

    # Găsirea poziției de început și sfârșit a blocului YYY
    start_marker = "<!-- ARTICOL START -->"
    end_marker = "<!-- ARTICOL FINAL -->"
    start = html_content.find(start_marker)
    end = html_content.find(end_marker)

    if start != -1 and end != -1:
        # Înlocuirea blocului YYY cu conținutul articolului, respectând formatarea cerută
        article_content = ""
        first_sentence = True
        for line in body:
            line = line.strip()
            # Începe prima propoziție cu <p class="text_obisnuit2">
            if first_sentence:
                article_content += f'\n\t<p class="text_obisnuit2"><em>{line}</em></p>'
                first_sentence = False
            elif line.startswith("Leadership:"):
                article_content += f'\n\t<p class="text_obisnuit2">{line}</p>'
            else:
                article_content += f'\n\t<p class="text_obisnuit">{line}</p>'
        html_content = html_content[:start + len(start_marker)] + article_content + html_content[end:]
        print("Corpul articolului a fost înlocuit conform cerințelor.")

    # Integrarea stilurilor de paragrafe din DOCX în HTML
    doc = Document("bebe.docx")
    for para in doc.paragraphs:
        html_style = convert_docx_to_html_style(para)
        html_content = html_content.replace("<p class=\"text_obisnuit\">{}</p>".format(para.text), html_style)

    # Eliminarea caracterelor speciale folosind unidecode
    html_content = unidecode.unidecode(html_content)

    # Crearea numelui de fișier bazat pe titlu
    filename = generate_filename(title)

    # Înlocuirea "zzz.html" cu numele fișierului generat în fiecare fișier HTML
    html_content = html_content.replace("zzz.html", filename)

    # Salvarea modificărilor în UTF-8
    with open(os.path.join(output_directory, filename), "w", encoding="utf-8") as f:
        f.write(html_content)
    print(f"Fișierul a fost salvat ca {filename}")

# Extragem datele din bebe.docx
articles_data = extract_data_from_docx("bebe.docx")

# Specifică directorul în care dorești să salvezi fișierele HTML
output_directory = "output"

# Actualizăm și salvăm fiecare articol într-un fișier HTML separat
for title, body in articles_data:
    update_and_save_html(title, body, "index.html", output_directory)

 # Deschide fișierul HTML pentru actualizare
    html_file_path = os.path.join(output_directory, generate_filename(title))
    with open(html_file_path, "r", encoding="utf-8") as html_file:
        html_content = html_file.read()

    # Colectează conținutul paragrafelor cu clasa "text_obisnuit2"
    content_to_add = ""
    paragraphs = re.findall(r'<p class="text_obisnuit2">(.*?)</p>', html_content)
    for paragraph in paragraphs:
        content_to_add += paragraph.strip() + ' '

    # Elimină tag-urile <em> din conținutul adăugat
    content_to_add_cleaned = re.sub(r'<em>(.*?)</em>', r'\1', content_to_add)

    # Adaugă conținutul curățat la tag-ul meta
    updated_html_content = add_content_to_meta(html_content, content_to_add_cleaned)

    # Actualizează fișierul HTML cu conținutul adăugat
    with open(html_file_path, "w", encoding="utf-8") as updated_html_file:
        updated_html_file.write(updated_html_content)

print("Conținutul a fost adăugat la tag-ul meta în fiecare fișier HTML, eliminând tag-urile <em>.")