python add text diacritics form

# ROMANIAN: https://neculaifantanaru.com/python-adauga-text-diacritice-form.html

# ENGLISH: https://neculaifantanaru.com/python-add-text-diacritics-form.html

import tkinter as tk
import re
from tkinter import messagebox, simpledialog
from unidecode import unidecode  # Importați unidecode

punctuation = re.compile("[:;,\.\"'”“\?!]")

# Citim cuvintele din dictionar.txt
with open('dictionar.txt', 'r', encoding='utf-8') as f:
    dictionar = f.read().split(', ')

# Citim cuvintele din dictionar-2.txt
with open('dictionar-2.txt', 'r', encoding='utf-8') as f:
    dictionar_2 = f.read().split(', ')

def get_words(text, lower=False):
    words = re.findall(r'\b\w+(?:-\w+)?\b', text)  # Ajustăm expresia regulată aici
    if lower:
        return [word.lower() for word in words]
    return words

def replace(text, old, new):
    if old[0].isupper():
        new = new.capitalize()
    return re.sub(r'\b' + re.escape(old) + r'\b', new, text, flags=re.IGNORECASE)

def adauga_diacritice():
    # Extragem textul din widget-ul Text
    text_original = text_input.get("1.0", tk.END)

    # Împărțim textul în linii
    linii = text_original.split('\n')

    # Procesăm fiecare linie separat
    linii_procesate = []
    for linie in linii:
        cuvinte_linie = re.split(r'(\W+)', linie)  # Folosim regex pentru a extrage cuvintele și semnele de punctuație separat
        linie_finala = []
        for cuvant in cuvinte_linie:
            if cuvant and cuvant[0].isalpha():  # Verificăm dacă este cuvânt
                cuvant_fara_diacritice = unidecode(cuvant).lower()
                if cuvant_fara_diacritice in dictionar_2:
                    idx = dictionar_2.index(cuvant_fara_diacritice)
                    if cuvant[0].isupper():
                        linie_finala.append(dictionar[idx].capitalize())
                    else:
                        linie_finala.append(dictionar[idx])
                else:
                    linie_finala.append(cuvant)
            else:
                linie_finala.append(cuvant)  # Adăugăm semnele de punctuație fără modificări
        linii_procesate.append(''.join(linie_finala))

    # Construim textul final, păstrând alineatele
    text_final = '\n'.join(linii_procesate)

    # Calculăm diferențele dintre textul original și cel procesat
    diacritice_adaugate = sum(1 for char1, char2 in zip(text_original, text_final) if char1 != char2)
    cuvinte_modificate = sum(1 for word1, word2 in zip(get_words(text_original), get_words(text_final)) if word1 != word2)

    # Ștergem conținutul actual și adăugăm textul procesat
    text_input.delete("1.0", tk.END)
    text_input.insert(tk.END, text_final)

    # Afișăm mesajul corespunzător
    if diacritice_adaugate == 0:
        messagebox.showinfo("Informare", "Nu s-au găsit diacritice de adăugat.")
    else:
        messagebox.showinfo("Informare", f"S-au adăugat {diacritice_adaugate} diacritice la {cuvinte_modificate} cuvinte.")



def elimina_sufix(cuvant):
    for sufix in SUFIXE:
        if cuvant.endswith(sufix):
            return cuvant[:-len(sufix)]
    return cuvant

def elimina_operatori(cuvant):
    operatori = [":", '"', "'", ".", "”", "“", ",", ";", "?", "!"]
    while cuvant and cuvant[0] in operatori:
        cuvant = cuvant[1:]
    while cuvant and cuvant[-1] in operatori:
        cuvant = cuvant[:-1]
    return cuvant

import pprint

def verifica_text(cuvinte_text):
    text_input.tag_remove("evidentiat", "1.0", tk.END)
    text_input.tag_remove("negasit", "1.0", tk.END)  # Adăugăm această linie pentru a șterge eticheta anterioară
    cuvant_gasit = False

    words = get_words(text_input.get("1.0", tk.END))

    for cuv in words:
        cuv_baza = elimina_sufix(cuv).lower()
        cuv_baza = elimina_operatori(cuv_baza)

        if cuv_baza not in [d.lower() for d in dictionar] and cuv_baza not in [d.lower() for d in dictionar_2] and cuv_baza not in CUVINTE_SKIP:
            start_indices = [match.start() for match in re.finditer(r'\b' + re.escape(cuv) + r'\b', text_input.get("1.0", tk.END))]

            for start_index in start_indices:
                # Convertim indexul absolut în formatul linie.colonă pentru widget-ul Text
                line_col_start = text_input.index(f"1.0 + {start_index} chars")
                line_col_end = text_input.index(f"{line_col_start} + {len(cuv)} chars")

                if not cuvant_gasit:
                    text_input.tag_add("evidentiat", line_col_start, line_col_end)
                    text_input.tag_configure("evidentiat", background="yellow", font=("Arial", 12, "bold"))
                    cuvant_gasit = True
                    print(f"Cuvântul '{cuv}' nu a fost găsit în dicționare.")
                else:
                    text_input.tag_add("negasit", line_col_start, line_col_end)
                    text_input.tag_configure("negasit", foreground="red")

    if not cuvant_gasit:
        messagebox.showinfo("Informare", "Totul este ok!")


def modifica_cuvant():
    global continut_dictionar, dictionar, dictionar_2
    start_index = text_input.tag_ranges("evidentiat")[0]
    end_index = text_input.tag_ranges("evidentiat")[1]
    cuvant = text_input.get(start_index, end_index)

    cuvant_modificat = simpledialog.askstring("Modificare cuvânt", f"Modificați cuvântul '{cuvant}':")
    if cuvant_modificat:
        cuvant_modificat = elimina_sufix(cuvant_modificat).lower()
        cuvant_modificat = elimina_operatori(cuvant_modificat)

        if cuvant_modificat:
            text_input.delete(start_index, end_index)
            text_input.insert(start_index, cuvant_modificat)
            cuvant_baza = elimina_sufix(cuvant).lower()
            cuvant_baza = elimina_operatori(cuvant_baza)
            continut_dictionar += f", {cuvant_modificat}"
            with open('dictionar.txt', 'a', encoding='utf-8') as f:
                f.write(f", {cuvant_modificat}")
            if cuvant_baza in CUVINTE_SKIP:
                CUVINTE_SKIP.remove(cuvant_baza)

            # Adăugăm cuvântul modificat în dictionar-2.txt fără diacritice
            cuvant_fara_diacritice = unidecode(cuvant_modificat)
            with open('dictionar-2.txt', 'a', encoding='utf-8') as f:
                f.write(f", {cuvant_fara_diacritice}")

            # Actualizăm dicționarele globale
            dictionar.append(cuvant_modificat)
            dictionar_2.append(cuvant_fara_diacritice)

            # Re-verificăm textul după modificare
            verifica_text(text_input.get("1.0", tk.END).split())


def skip_cuvant():
    tag_ranges = text_input.tag_ranges("evidentiat")
    if tag_ranges:
        start_index = tag_ranges[0]
        end_index = tag_ranges[1]
        cuvant = text_input.get(start_index, end_index)
        cuvant_baza = elimina_sufix(cuvant).lower()
        cuvant_baza = elimina_operatori(cuvant_baza)
        if cuvant_baza not in continut_dictionar and cuvant_baza not in CUVINTE_SKIP:
            CUVINTE_SKIP.append(cuvant_baza)
            with open('dictionar.txt', 'a', encoding='utf-8') as f:
                f.write(f", {cuvant}")

            # Adăugăm cuvântul skip în dictionar-2.txt fără diacritice
            cuvant_fara_diacritice = unidecode(cuvant)
            with open('dictionar-2.txt', 'a', encoding='utf-8') as f:
                f.write(f", {cuvant_fara_diacritice}")

        verifica_text(text_input.get("1.0", tk.END).split())
    else:
        messagebox.showinfo("Eroare", "Nu există cuvinte evidențiate pentru a fi ignorate.")


def make_diacritic_word_dictionary():
    with open("dictionar.txt", "r", encoding="utf-8") as f1, open("dictionar-2.txt", "r", encoding="utf-8") as f2:
        d = get_words(f1.read(), lower=True)
        d2 = get_words(f2.read(), lower=True)
    return {w2: w for w, w2 in zip(d, d2) if w != w2}

plain_2_diacritic = make_diacritic_word_dictionary()

SUFIXE = ["-mi", "-a", "-ti", "-au"]
CUVINTE_SKIP = []

with open('dictionar.txt', 'r', encoding='utf-8') as f:
    continut_dictionar = f.read().lower()


# inceput form


root = tk.Tk()
root.title("Adăugare Diacritice")
root.geometry("600x400")

frame = tk.Frame(root, bg="lightgray")
frame.pack(pady=20, fill=tk.BOTH, expand=True)

# Creăm un nou frame pentru butoane
menu_frame = tk.Frame(frame, bg="lightgray")
menu_frame.pack(pady=10, fill=tk.X)

btn_verifica = tk.Button(menu_frame, text="Verificare", command=lambda: verifica_text(text_input.get("1.0", tk.END).split()))
btn_verifica.pack(side=tk.LEFT, padx=10)

btn_modifica = tk.Button(menu_frame, text="Modificare", command=modifica_cuvant)
btn_modifica.pack(side=tk.LEFT, padx=10)

btn_skip = tk.Button(menu_frame, text="Skip", command=skip_cuvant)
btn_skip.pack(side=tk.LEFT, padx=10)

btn_diacritice = tk.Button(menu_frame, text="Diacritice", command=adauga_diacritice)
btn_diacritice.pack(side=tk.LEFT, padx=10)


text_input = tk.Text(frame, height=15, width=50, wrap=tk.WORD, padx=20, pady=20)  # Adăugăm pady=20 aici
text_input.pack(pady=10, side=tk.LEFT, fill=tk.BOTH, expand=True)


scrollbar = tk.Scrollbar(frame, command=text_input.yview)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

text_input.config(yscrollcommand=scrollbar.set)

root.mainloop()