Python: Diacritics (àâîșt) - automatically convert words to text with diacritics

# VERSIUNEA: "Diacritice-Gata"

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
# Citim cuvintele din dictionar.txt și le convertim la lowercase
with open('dictionar.txt', 'r', encoding='utf-8') as f:
    dictionar = [word.lower() for word in f.read().split(', ')]

# Citim cuvintele din dictionar-2.txt și le convertim la lowercase
with open('dictionar-2.txt', 'r', encoding='utf-8') as f:
    dictionar_2 = [word.lower() for word in 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()
                print(f"Verificăm cuvântul: {cuvant} ({cuvant_fara_diacritice})")
                if cuvant_fara_diacritice in dictionar_2:
                    idx = dictionar_2.index(cuvant_fara_diacritice)
                    cuvant_nou = dictionar[idx] if cuvant[0].islower() else dictionar[idx].capitalize()
                    print(f"Înlocuim {cuvant} cu {cuvant_nou}")
                    linie_finala.append(cuvant_nou)
                else:
                    print(f"Cuvântul {cuvant} nu a fost găsit în dicționar.")
                    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)
    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 in CUVINTE_SARITE:
            continue  # Sărim peste acest cuvânt

        pattern = re.compile(r'\b' + re.escape(cuv_baza) + r'\b')
        if not any(pattern.search(d) for d in dictionar) and not any(pattern.search(d) for d in dictionar_2) and cuv_baza not in CUVINTE_ADD:
            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:
                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_ADD:
                CUVINTE_ADD.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 add_cuvant():
    tag_ranges = text_input.tag_ranges("evidentiat")
    if tag_ranges:
        for start_index, end_index in zip(tag_ranges[0::2], tag_ranges[1::2]):
            cuvant = text_input.get(start_index, end_index)
            cuvant_baza = elimina_sufix(cuvant).lower()
            cuvant_baza = elimina_operatori(cuvant_baza)

            este_inclus = False
            for cuvant_existent in dictionar + dictionar_2:
                if re.search(r'\b' + re.escape(cuvant_baza) + r'\b', cuvant_existent, flags=re.IGNORECASE):
                    este_inclus = True
                    break

            if not este_inclus:
                CUVINTE_ADD.append(cuvant_baza)
                with open('dictionar.txt', 'a', encoding='utf-8') as f:
                    f.write(f", {cuvant}")

                # Adăugăm cuvântul add î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}")

                # Actualizăm dictionarul intern pentru a include noul cuvânt
                dictionar.append(cuvant_baza)
                dictionar_2.append(cuvant_fara_diacritice)

                # Ștergem tag-urile de evidențiere pentru cuvantul actual
                text_input.tag_remove("evidentiat", start_index, end_index)

                print(f"Am adăugat cuvântul '{cuvant}' în dicționar.")
                print(f"Am adăugat cuvântul '{cuvant_fara_diacritice}' în dictionar-2.txt.")

        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_ADD = []

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


CUVINTE_SARITE = []

def skip_cuvant():
    tag_ranges = text_input.tag_ranges("evidentiat")
    if tag_ranges:
        start_index = tag_ranges[0]
        end_index = tag_ranges[1]
        cuvant_sarit = text_input.get(start_index, end_index)
        CUVINTE_SARITE.append(cuvant_sarit.lower())
        text_input.tag_remove("evidentiat", start_index, end_index)
        verifica_text(text_input.get("1.0", tk.END).split())
    else:
        messagebox.showinfo("Eroare", "Nu există cuvinte evidențiate pentru a fi sărite.")



# 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_add = tk.Button(menu_frame, text="Add", command=add_cuvant)
btn_add.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()