config.ini

@@ -1,101 +0,0 @@
-[Seleccion]
-tipo_plc = AllenBradley
-codigo_columna_maestra = English_US
-idioma_var = Spanish
-idioma_var2 = English_US
-
-[TextContent]
-output_text = Ejecutando x1_importar_to_master.run()
-	Se han agregado 929 nuevas filas al archivo maestro.
-	Ejecutando x2_master_export2translate.run()
-	Archivo guardado exitosamente.
-	Archivo exportado para traducción: .\data\2_master_export2translate_allenbradley.xlsx
-	Ejecutando x3_llm_auto_translate.run()
-	Número total de textos a traducir: 621
-	Traduciendo : celdas desde: 0 a :20.
-	Traduciendo : celdas desde: 20 a :40.
-	Traduciendo : celdas desde: 40 a :60.
-	Traduciendo : celdas desde: 60 a :80.
-	Traduciendo : celdas desde: 80 a :100.
-	Traduciendo : celdas desde: 100 a :120.
-	Traduciendo : celdas desde: 120 a :140.
-	Traduciendo : celdas desde: 140 a :160.
-	Traduciendo : celdas desde: 160 a :180.
-	Traduciendo : celdas desde: 180 a :200.
-	Traduciendo : celdas desde: 200 a :220.
-	Traduciendo : celdas desde: 220 a :240.
-	Traduciendo : celdas desde: 240 a :260.
-	Error en el intento 1 de traducción de celdas desde 240 a 260: La cantidad de traducciones recibidas no coincide con la cantidad de textos enviados.. Reintentando...
-	Traduciendo : celdas desde: 260 a :280.
-	Traduciendo : celdas desde: 280 a :300.
-	Traduciendo : celdas desde: 300 a :320.
-	Traduciendo : celdas desde: 320 a :340.
-	Traduciendo : celdas desde: 340 a :360.
-	Traduciendo : celdas desde: 360 a :380.
-	Traduciendo : celdas desde: 380 a :400.
-	Traduciendo : celdas desde: 400 a :420.
-	Traduciendo : celdas desde: 420 a :440.
-	Traduciendo : celdas desde: 440 a :460.
-	Traduciendo : celdas desde: 460 a :480.
-	Traduciendo : celdas desde: 480 a :500.
-	Traduciendo : celdas desde: 500 a :520.
-	Traduciendo : celdas desde: 520 a :540.
-	Traduciendo : celdas desde: 540 a :560.
-	Traduciendo : celdas desde: 560 a :580.
-	Traduciendo : celdas desde: 580 a :600.
-	Traduciendo : celdas desde: 600 a :620.
-	Traduciendo : celdas desde: 620 a :621.
-	Afinidad: celdas desde: 0 a :20.
-	Error en el intento 1 de Afinidad de celdas desde 0 a 20: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.. Reintentando...
-	Error en todos los intentos de Afinidad de celdas desde 0 a 20: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.
-	Afinidad: celdas desde: 20 a :40.
-	Afinidad: celdas desde: 40 a :60.
-	Afinidad: celdas desde: 60 a :80.
-	Afinidad: celdas desde: 80 a :100.
-	Error en el intento 1 de Afinidad de celdas desde 80 a 100: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.. Reintentando...
-	Error en todos los intentos de Afinidad de celdas desde 80 a 100: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.
-	Afinidad: celdas desde: 100 a :120.
-	Afinidad: celdas desde: 120 a :140.
-	Error en el intento 1 de Afinidad de celdas desde 120 a 140: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.. Reintentando...
-	Error en todos los intentos de Afinidad de celdas desde 120 a 140: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.
-	Afinidad: celdas desde: 140 a :160.
-	Afinidad: celdas desde: 160 a :180.
-	Afinidad: celdas desde: 180 a :200.
-	Afinidad: celdas desde: 200 a :220.
-	Afinidad: celdas desde: 220 a :240.
-	Afinidad: celdas desde: 240 a :260.
-	Afinidad: celdas desde: 260 a :280.
-	Afinidad: celdas desde: 280 a :300.
-	Afinidad: celdas desde: 300 a :320.
-	Afinidad: celdas desde: 320 a :340.
-	Afinidad: celdas desde: 340 a :360.
-	Afinidad: celdas desde: 360 a :380.
-	Error en el intento 1 de Afinidad de celdas desde 360 a 380: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.. Reintentando...
-	Error en todos los intentos de Afinidad de celdas desde 360 a 380: La cantidad de afinidades recibidas no coincide con la cantidad de textos enviados.
-	Afinidad: celdas desde: 380 a :400.
-	Afinidad: celdas desde: 400 a :420.
-	Afinidad: celdas desde: 420 a :440.
-	Afinidad: celdas desde: 440 a :460.
-	Afinidad: celdas desde: 460 a :480.
-	Afinidad: celdas desde: 480 a :500.
-	Afinidad: celdas desde: 500 a :520.
-	Afinidad: celdas desde: 520 a :540.
-	Afinidad: celdas desde: 540 a :560.
-	Afinidad: celdas desde: 560 a :580.
-	Afinidad: celdas desde: 580 a :600.
-	Afinidad: celdas desde: 600 a :620.
-	Afinidad: celdas desde: 620 a :621.
-	Archivo guardado exitosamente.
-	Archivo traducido guardado en: .\data\3_master_export2translate_translated_allenbradley.xlsx
-	Ejecutando x4_integrate_translates_to_master.run()
-	Archivo guardado exitosamente.
-	Traducciones importadas y archivo maestro actualizado: .\data\1_hmi_master_translates_allenbradley.xlsx.
-	Ejecutando x5_complete_empty_cells_master.run()
-	Archivo guardado exitosamente.
-	Traducciones importadas y archivo maestro actualizado: .\data\1_hmi_master_translates_allenbradley.xlsx.
-	Ejecutando x6_update_from_master.run()
-	Archivo guardado exitosamente.
-	Se han actualizado las filas en C:/Trabajo/VM/31 - 9.3953 - Omega - Mexico - (ABradley)/Reporte/HMI/HMI_93953_25.xlsx desde el archivo maestro. 
-	
-	
-

funciones_comunes/funciones_base.py

@@ -14,67 +14,9 @@ IDIOMAS = {
     4: ("Russian", "ru-RU"),
     5: ("French", "fr-FR"),
     6: ("German", "de-DE"),
-    7: ("English_US", "en-US"),
 }
 
 
-# Función para obtener el shortcode a partir del código completo
-def idiomas_shortcodefromcode(code):
-    if code:
-        return code.split('-')[0]
-    return None  # O puedes lanzar una excepción si prefieres
-
-# Función para obtener el idioma a partir del código
-def idiomas_idiomafromcode(code):
-    for idx, (idioma, codigo) in IDIOMAS.items():
-        if codigo == code:
-            return idioma
-    return None  # O puedes lanzar una excepción si prefieres
-
-# Función para obtener el código a partir del idioma
-def idiomas_codefromidioma(idioma):
-    for idx, (nombre_idioma, codigo) in IDIOMAS.items():
-        if nombre_idioma == idioma:
-            return codigo
-    return None  # O lanzar una excepción
-
-# Función para verificar si un código existe
-def idiomas_existecode(code):
-    return any(codigo == code for idx, (idioma, codigo) in IDIOMAS.items())
-
-# Función para verificar si un idioma existe
-def idiomas_existeidioma(idioma):
-    return any(nombre_idioma == idioma for idx, (nombre_idioma, codigo) in IDIOMAS.items())
-
-# Función para obtener el idioma a partir del índice
-def idiomas_idiomafromindex(index):
-    if index in IDIOMAS:
-        return IDIOMAS[index][0]
-    else:
-        return None  # O lanzar una excepción
-
-# Función para obtener el código a partir del índice
-def idiomas_codefromindex(index):
-    if index in IDIOMAS:
-        return IDIOMAS[index][1]
-    else:
-        return None  # O lanzar una excepción
-
-# Función para obtener el índice a partir del código
-def idiomas_indexfromcode(code):
-    for idx, (idioma, codigo) in IDIOMAS.items():
-        if codigo == code:
-            return idx
-    return None  # O lanzar una excepción
-
-# Función para obtener el índice a partir del idioma
-def idiomas_indexfromidioma(idioma):
-    for idx, (nombre_idioma, codigo) in IDIOMAS.items():
-        if nombre_idioma == idioma:
-            return idx
-    return None  # O lanzar una excepción
-
-
 def mostrar_idiomas():
     print("Selecciona el idioma de destino:")
     for numero, (nombre, _) in IDIOMAS.items():
@@ -144,11 +86,18 @@ def es_columna_tipo_xxYY(columna):
     return bool(re.match(r"^[a-z]{2}-[A-Z]{2}$", columna))
 
 
-def compactar_celda_clave(tipo_PLC, celda_original):
+def compactar_celda_clave_siemens(celda_original):
-    if tipo_PLC == "siemens" :
+    if pd.isnull(celda_original):
-        return compactar_celda_clave_siemens(celda_original)
+        return celda_original
-    else :
+    
-        return compactar_celda_clave_ab(celda_original)
+    def reemplazar(match):
+        if match.group(1):  # Si hay contenido dentro de <>
+            return f"<{match.group(1)}>"
+        return "[[digits]]"
+    
+    # Reemplaza dígitos fuera de <> con [[digits]], y preserva el contenido dentro de <>
+    return re.sub(r"<(.*?)>|\d+", reemplazar, str(celda_original))
+
 
 def compactar_celda_traducida(tipo_PLC, celda_traducida):
     if tipo_PLC == "siemens" :
@@ -164,28 +113,15 @@ def obtener_digitos_celda_original(tipo_PLC, celda_original):
 
 def decompactar_celda_traducida(tipo_PLC, celda_original, celda_traducida):
     if tipo_PLC == "siemens" :
-        return decompactar_celda_traducida_siemens(celda_original, celda_traducida)
+        decompactar_celda_traducida_siemens(celda_original, celda_traducida)
     else :
-        return decompactar_celda_traducida_ab(celda_original, celda_traducida)
+        decompactar_celda_traducida_ab(celda_original, celda_traducida)
 
 def verificar_celda_traducida(tipo_PLC, celda_clave, celda_traducida):
     if tipo_PLC == "siemens" :
-        return verificar_celda_traducida_siemens(celda_clave, celda_traducida)
+        verificar_celda_traducida_siemens(celda_clave, celda_traducida)
     else :
-        return verificar_celda_traducida_ab(celda_clave, celda_traducida)
+        verificar_celda_traducida_ab(celda_clave, celda_traducida)
-
-def texto_requiere_traduccion(tipo_PLC, texto, logger):
-    if tipo_PLC == "siemens" :
-        return texto_requiere_traduccion_siemens(texto, logger)
-    else :
-        return texto_requiere_traduccion_ab(texto, logger)
-
-def texto_con_campos_especiales(tipo_PLC, texto):
-    if tipo_PLC == "siemens" :
-        return texto_con_campos_especiales_siemens(texto)
-    else :
-        return texto_con_campos_especiales_ab(texto)
-
 
 
 #           SIEMENS
@@ -207,25 +143,6 @@ def compactar_celda_clave_siemens(celda_original):
     return re.sub(r"<(.*?)>|\d+", reemplazar, str(celda_original))
 
 
-#           SIEMENS
-def texto_requiere_traduccion_siemens(texto, logger):
-    palabras = re.findall(r"\b\w{4,}\b", texto)
-    campos_especiales = re.findall(r"<.*?>", texto)
-    requiere_traduccion = len(palabras) > 0 or len(campos_especiales) != len(
-        re.findall(r"<#>", texto)
-    )
-    logger.debug(
-        f"Decisión de traducción para texto '{texto}': {'Sí' if requiere_traduccion else 'No'} (palabras > 3 letras: {len(palabras) > 0}, solo campos especiales: {len(campos_especiales) == len(re.findall(r'<#>', texto))})"
-    )
-    return requiere_traduccion
-
-#           SIEMENS
-def texto_con_campos_especiales_siemens(texto):
-    campos_especiales = len(re.findall(r"<#>", texto) )
-    return campos_especiales > 0
-
-
-
 #           SIEMENS
 #
 # Transforma:              "A[[digits]]/[[digits]]/[[digits]] Air - M<field ref="[[digits]]" /> - Necessaria Manutenzione Filtro" ->
@@ -235,7 +152,7 @@ def texto_con_campos_especiales_siemens(texto):
 def compactar_celda_traducida_siemens(celda_traducida):
     if pd.isnull(celda_traducida):
         return celda_traducida
-    celda_traducida = compactar_celda_clave_siemens(celda_traducida)
+    celda_traducida = compactar_celda_clave(celda_traducida)
 
     def reemplazar(match):
         if match.group(1):  # Si hay contenido dentro de <>
@@ -267,7 +184,7 @@ def obtener_digitos_celda_original_siemens(celda_original):
 #
 # Este procesamiento se aplica a las celdas traducidas para regresar al valor original
 def decompactar_celda_traducida_siemens(celda_original, celda_traducida):
-    digitos = obtener_digitos_celda_original_siemens(celda_original)
+    digitos = obtener_digitos_celda_original(celda_original)
     celda_destino = celda_traducida
     
     # Replace <> with digits
@@ -305,26 +222,6 @@ def verificar_celda_traducida_siemens(celda_clave, celda_traducida):
         text_error += f" - Tags en clave: {tags_clave}, Tags en traducida: {tags_traducida}"
         return False, text_error
 
-
-#           ALLEN BRADLEY
-def texto_requiere_traduccion_ab(texto, logger):
-    palabras = re.findall(r"\b\w{4,}\b", texto)
-    campos_especiales = re.findall(r"/\*.*?\*/", texto)
-    total_palabras_largas = len(palabras) > 0
-    total_campos_especiales = len(campos_especiales)
-    total_campos_marcados = len(re.findall(r"/\*#\*/", texto))
-    solo_campos_especiales = total_campos_especiales == total_campos_marcados
-    requiere_traduccion = total_palabras_largas or not solo_campos_especiales
-
-    logger.debug(
-        f"Decisión de traducción para texto '{texto}': {'Sí' if requiere_traduccion else 'No'} "
-        f"(palabras > 3 letras: {total_palabras_largas}, "
-        f"solo campos especiales: {solo_campos_especiales})"
-    )
-    return requiere_traduccion
-
-
-
 #           ALLEN BRADLEY
 # Transforma: "A271/47/6 Air - M/*field ref="0" */ - Necessaria Manutenzione Filtro" ->
 #             "A[[digits]]/[[digits]]/[[digits]] Air - M/*field ref="[[digits]]" */ - Necessaria Manutenzione Filtro"
@@ -420,47 +317,37 @@ def verificar_celda_traducida_ab(celda_clave, celda_traducida):
         return False, text_error
 
 
-#
-#           ALLEN BRADLEY
-#
-def texto_con_campos_especiales_ab(texto):
-    campos_especiales = len(re.findall(r"/\*#\*/", texto))
-    return campos_especiales > 0
-
-
 if __name__ == "__main__":
     # SIEMENS
-    print("****************** SIEMENS ***************************")
     celda_original = 'A271/47/6 Air - M<field ref="0" /> - Necessaria Manutenzione Filtro'
     celda_original = 'DB<field ref="0" />/DB<field ref="1" />/DB<field ref="2" />'
     celda_original = 'Text<field ref="0" />'
 
-    celda_clave = compactar_celda_clave_siemens(celda_original)
+    celda_clave = compactar_celda_clave(celda_original)
-    celda_tradc = compactar_celda_traducida_siemens(celda_original) + " TEXTO "
+    celda_tradc = compactar_celda_traducida(celda_original) + " TEXTO "
 
     print()
     print("Celda Original : " +celda_original)
     print("Celda Clave    : " + celda_clave)
     print("Celda Traducida: " + celda_tradc)
-    print("Digitos        : " + ','.join(obtener_digitos_celda_original_siemens(celda_original)))
+    print("Digitos        : " + ','.join(obtener_digitos_celda_original(celda_original)))
-    print("Celda          : " + decompactar_celda_traducida_siemens(celda_original, celda_tradc))
+    print("Celda          : " + decompactar_celda_traducida(celda_original, celda_tradc))
     print("Celda Original : " + celda_original)
 
-    print(verificar_celda_traducida_siemens(celda_clave=celda_clave, celda_traducida= celda_tradc))
+    print(verificar_celda_traducida(celda_clave=celda_clave, celda_traducida= celda_tradc))
 
     # ALLEN BRADLEY
-    print("****************** ALLEN BRADLEY ***************************")
+    celda_original = 'Z2-A5-128: Drive Unload Channel Overload /*N:3 {[PLC_Connection]Buttons[#1].Program_Nr} NOFILL DP:0*/ - /*S:0 {[PLC_Connection]Buttons[#1].Program_Description}*/'
-    celda_original = 'A271/47/6 /*N:4 {#1.#4.VFix[1]} NOFILL DP:1*/   m/min SPEED'
+    # Simulando una celda traducida después del procesamiento
+    celda_traducida = 'Z[[digits]]-A[[digits]]-[[digits]]: Drive Unload Channel Overload /*#*/ - /*#*/'
 
     celda_clave = compactar_celda_clave_ab(celda_original)
-    celda_tradc = compactar_celda_traducida_ab(celda_original) + " TEXTO "
+    celda_tradc = compactar_celda_traducida_ab(celda_traducida)
 
     print()
-    print("Celda Original : " +celda_original)
+    print("Celda Original             : " + celda_original)
-    print("Celda Clave    : " + celda_clave)
+    print("Celda Clave                : " + celda_clave)
-    print("Celda Traducida: " + celda_tradc)
+    print("Celda Traducida Compactada : " + celda_tradc)
-    print("Digitos        : " + ','.join(obtener_digitos_celda_original_ab(celda_original)))
+    print("Dígitos                    : " + ','.join(obtener_digitos_celda_original_ab(celda_original)))
-    print("Celda          : " + decompactar_celda_traducida_ab(celda_original, celda_tradc))
+    print("Celda Reconstituida        : " + decompactar_celda_traducida_ab(celda_original, celda_tradc))
-    print("Celda Original : " + celda_original)
+    print("Verificación               : ", verificar_celda_traducida_ab(celda_clave=celda_clave, celda_traducida=celda_tradc))
-
-    print(verificar_celda_traducida_ab(celda_clave=celda_clave, celda_traducida= celda_tradc))

menu_pasos_traduccion.py

@@ -8,262 +8,148 @@ import x3_llm_auto_translate
 import x4_integrate_translates_to_master
 import x5_complete_empty_cells_master
 import x6_update_from_master
-import sys
-import threading
-import configparser  # Para manejar el archivo de configuración
-import os  # Para verificar si el archivo existe
 
 # Crear la ventana principal
 ventana = tk.Tk()
 ventana.title("Ayuda para traducir textos de TIA Portal y Allen Bradley")
-ventana.geometry("800x600")  # Ajustamos el tamaño de la ventana
+ventana.geometry("600x550")  # Aumentamos el tamaño para acomodar los nuevos widgets
 
-# Diccionario para tipo_PLC
+# Opciones para tipo_PLC
-tipo_PLC_dict = {'Siemens': 'siemens', 'AllenBradley': 'allenbradley'}
+opciones_tipo_PLC = ['siemens', 'allenbradley']
 
 # Variables para almacenar las selecciones del usuario
 tipo_PLC_var = tk.StringVar()
-codigo_columna_maestra_var = tk.StringVar()
+idioma_maestra_var = tk.StringVar()
 idioma_var = tk.StringVar()
 idioma_var2 = tk.StringVar()
 
 # Crear listas de idiomas con sus códigos
-idiomas_lista = [(nombre, codigo) for _, (nombre, codigo) in fc.IDIOMAS.items()]
+idiomas_lista = sorted([(nombre, codigo) for _, (nombre, codigo) in fc.IDIOMAS.items()])
 
-# Ruta del archivo de configuración
+# Crear un combobox para seleccionar el tipo de PLC
-config_file = 'config.ini'
+label_tipo_PLC = tk.Label(ventana, text="Selecciona el tipo de PLC:")
+combo_tipo_PLC = ttk.Combobox(ventana, textvariable=tipo_PLC_var, state="readonly")
+combo_tipo_PLC["values"] = opciones_tipo_PLC
+combo_tipo_PLC.current(0)  # Selecciona 'siemens' por defecto
 
-# Función para cargar las opciones guardadas
+# Crear combobox para seleccionar el Idioma Columna Maestra
-def cargar_configuracion():
+label_maestra = tk.Label(ventana, text="Idioma Columna Maestra:")
-    config = configparser.ConfigParser()
+combo_maestra = ttk.Combobox(ventana, textvariable=idioma_maestra_var, state="readonly")
-    if os.path.exists(config_file):
+combo_maestra["values"] = [nombre for nombre, _ in idiomas_lista]
-        config.read(config_file)
+combo_maestra.current(0)  # Selecciona el primer idioma por defecto
-        # Cargar tipo_PLC
-        tipo_PLC_var.set(config.get('Seleccion', 'tipo_PLC', fallback='Siemens'))
-        # Cargar codigo_columna_maestra
-        codigo_columna_maestra_var.set(config.get('Seleccion', 'codigo_columna_maestra', fallback=idiomas_lista[0][0]))
-        # Cargar idioma_var
-        idioma_var.set(config.get('Seleccion', 'idioma_var', fallback=idiomas_lista[4][0]))
-        # Cargar idioma_var2
-        idioma_var2.set(config.get('Seleccion', 'idioma_var2', fallback=idiomas_lista[1][0]))
-    else:
-        # Valores por defecto si no existe el archivo
-        tipo_PLC_var.set('Siemens')
-        codigo_columna_maestra_var.set(idiomas_lista[0][0])
-        idioma_var.set(idiomas_lista[4][0])
-        idioma_var2.set(idiomas_lista[1][0])
 
-# Función para guardar las opciones seleccionadas
+# Crear comboboxes para seleccionar los idiomas
-def guardar_configuracion():
+label_idioma1 = tk.Label(ventana, text="Selecciona el idioma principal:")
-    config = configparser.ConfigParser()
+combo = ttk.Combobox(ventana, textvariable=idioma_var, state="readonly")
-    config['Seleccion'] = {
-        'tipo_PLC': tipo_PLC_var.get(),
-        'codigo_columna_maestra': codigo_columna_maestra_var.get(),
-        'idioma_var': idioma_var.get(),
-        'idioma_var2': idioma_var2.get()
-    }
-    # Guardar el contenido del cuadro de texto
-    config['TextContent'] = {
-        'output_text': output_text.get("1.0", tk.END)
-    }
-    with open(config_file, 'w') as configfile:
-        config.write(configfile)
-
-# Crear un Frame para la grilla de comboboxes
-frame_combos = tk.Frame(ventana)
-frame_combos.pack(pady=10)
-
-# Crear los labels y comboboxes
-label_tipo_PLC = tk.Label(frame_combos, text="Selecciona el tipo de PLC:")
-combo_tipo_PLC = ttk.Combobox(frame_combos, textvariable=tipo_PLC_var, state="readonly")
-combo_tipo_PLC["values"] = list(tipo_PLC_dict.keys())
-
-label_codigo_maestra = tk.Label(frame_combos, text="Idioma Columna Maestra:")
-combo_codigo_maestra = ttk.Combobox(frame_combos, textvariable=codigo_columna_maestra_var, state="readonly")
-combo_codigo_maestra["values"] = [nombre for nombre, _ in idiomas_lista]
-
-label1 = tk.Label(frame_combos, text="Idioma de Traducción:")
-combo = ttk.Combobox(frame_combos, textvariable=idioma_var, state="readonly")
 combo["values"] = [nombre for nombre, _ in idiomas_lista]
+combo.current(1)  # Selecciona el segundo idioma por defecto
 
-label2 = tk.Label(frame_combos, text="Selecciona segundo idioma:")
+label_idioma2 = tk.Label(ventana, text="Selecciona el segundo idioma:")
-combo2 = ttk.Combobox(frame_combos, textvariable=idioma_var2, state="readonly")
+combo2 = ttk.Combobox(ventana, textvariable=idioma_var2, state="readonly")
 combo2["values"] = [nombre for nombre, _ in idiomas_lista]
+combo2.current(2)  # Selecciona el tercer idioma por defecto
 
-# Organizar los labels y comboboxes en una grilla 2x2
+# Ubicar los widgets en la ventana
-label_tipo_PLC.grid(row=0, column=0, padx=5, pady=5, sticky='e')
+label_tipo_PLC.pack(pady=5)
-combo_tipo_PLC.grid(row=0, column=1, padx=5, pady=5, sticky='w')
+combo_tipo_PLC.pack(pady=5)
+label_maestra.pack(pady=5)
+combo_maestra.pack(pady=5)
+label_idioma1.pack(pady=5)
+combo.pack(pady=5)
+label_idioma2.pack(pady=5)
+combo2.pack(pady=5)
 
-label_codigo_maestra.grid(row=1, column=0, padx=5, pady=5, sticky='e')
+# Función para obtener el código del idioma seleccionado a partir del índice
-combo_codigo_maestra.grid(row=1, column=1, padx=5, pady=5, sticky='w')
+def obtener_codigo_idioma(indice):
+    return idiomas_lista[indice][1]
 
-label1.grid(row=0, column=2, padx=5, pady=5, sticky='e')
+# Funciones que se llamarán cuando se presionen los botones
-combo.grid(row=0, column=3, padx=5, pady=5, sticky='w')
+def accion_boton1():
+    tipo_PLC = tipo_PLC_var.get()
+    indice_maestra = combo_maestra.current()
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    print("Ejecutando x1_importar_to_master.py")
+    x1_importar_to_master.run(tipo_PLC, codigo_columna_maestra)
 
-label2.grid(row=1, column=2, padx=5, pady=5, sticky='e')
+def accion_boton2():
-combo2.grid(row=1, column=3, padx=5, pady=5, sticky='w')
+    tipo_PLC = tipo_PLC_var.get()
+    indice_maestra = combo_maestra.current()
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    print("Ejecutando x2_master_export2translate.py")
+    x2_master_export2translate.run(tipo_PLC, codigo_columna_maestra)
 
-# Función para actualizar combo_codigo_maestra según la selección en combo_tipo_PLC
+def accion_boton3():
-def actualizar_codigo_maestra(event):
+    tipo_PLC = tipo_PLC_var.get()
-    plc_seleccionado = tipo_PLC_var.get()
+    indice_maestra = combo_maestra.current()
-    if plc_seleccionado == 'Siemens':
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
-        # Buscar el índice de 'Italian' en idiomas_lista
+    traducir_todo = messagebox.askyesno("Traducir todo", "¿Desea traducir todas las celdas?")
-        indice_italiano = next((i for i, (nombre, _) in enumerate(idiomas_lista) if nombre == 'Italian'), None)
+    print("Ejecutando x3_llm_auto_translate.py")
-        if indice_italiano is not None:
+    x3_llm_auto_translate.run(tipo_PLC, codigo_columna_maestra, traducir_todo)
-            combo_codigo_maestra.current(indice_italiano)
-    elif plc_seleccionado == 'AllenBradley':
-        # Buscar el índice de 'English_US' en idiomas_lista
-        indice_ingles = next((i for i, (nombre, _) in enumerate(idiomas_lista) if nombre == 'English_US'), None)
-        if indice_ingles is not None:
-            combo_codigo_maestra.current(indice_ingles)
-    guardar_configuracion()  # Guardar la configuración cuando se cambia el tipo de PLC
 
-# Vincular la función al evento de cambio de selección en combo_tipo_PLC
+def accion_boton4():
-combo_tipo_PLC.bind('<<ComboboxSelected>>', actualizar_codigo_maestra)
+    tipo_PLC = tipo_PLC_var.get()
+    indice_maestra = combo_maestra.current()
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    print("Ejecutando x4_integrate_translates_to_master.py")
+    x4_integrate_translates_to_master.run(tipo_PLC, codigo_columna_maestra)
 
-# Vincular eventos de cambio en los comboboxes para guardar la configuración
+def accion_boton5():
-def on_combobox_changed(event):
+    tipo_PLC = tipo_PLC_var.get()
-    guardar_configuracion()
+    indice_maestra = combo_maestra.current()
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    indice_idioma1 = combo.current()
+    codigo_columna_secundaria = obtener_codigo_idioma(indice_idioma1)
+    print("Ejecutando x5_complete_empty_cells_master.py")
+    x5_complete_empty_cells_master.run(tipo_PLC, codigo_columna_maestra, codigo_columna_secundaria)
 
-combo_codigo_maestra.bind('<<ComboboxSelected>>', on_combobox_changed)
+def accion_boton6():
-combo.bind('<<ComboboxSelected>>', on_combobox_changed)
+    tipo_PLC = tipo_PLC_var.get()
-combo2.bind('<<ComboboxSelected>>', on_combobox_changed)
+    indice_maestra = combo_maestra.current()
-
+    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
-# Clase para redirigir la salida estándar a la caja de texto
+    print("Ejecutando x6_update_from_master.py")
-class RedirectText(object):
+    x6_update_from_master.run(tipo_PLC, codigo_columna_maestra)
-    def __init__(self, text_widget):
-        self.output = text_widget
-
-    def write(self, string):
-        self.output.insert(tk.END, string)
-        self.output.see(tk.END)  # Desplaza hacia el final
-
-    def flush(self):
-        pass  # No se requiere implementación para flush
-
-# Función para obtener el código del idioma seleccionado a partir del nombre
-def obtener_codigo_idioma_por_nombre(nombre_idioma):
-    for nombre, codigo in idiomas_lista:
-        if nombre == nombre_idioma:
-            return codigo
-    return None
-
-# Función para ejecutar las funciones run() y redirigir la salida
-def ejecutar_run(funcion_run):
-    # Obtener los parámetros necesarios
-    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    codigo_columna_maestra = obtener_codigo_idioma_por_nombre(codigo_columna_maestra_var.get())
-    codigo_idioma = obtener_codigo_idioma_por_nombre(idioma_var.get())
-    codigo_idioma2 = obtener_codigo_idioma_por_nombre(idioma_var2.get())
-
-    # Obtener los índices de los idiomas
-    indice_seleccionado = idiomas_lista.index((idioma_var.get(), codigo_idioma))
-    indice_seleccionado2 = idiomas_lista.index((idioma_var2.get(), codigo_idioma2))
-
-    # Redirigir stdout
-    original_stdout = sys.stdout
-    sys.stdout = RedirectText(output_text)
-
-    try:
-        # Ejecutar la función correspondiente
-        if funcion_run == x1_importar_to_master.run:
-            print("Ejecutando x1_importar_to_master.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra)
-        elif funcion_run == x2_master_export2translate.run:
-            print("Ejecutando x2_master_export2translate.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
-        elif funcion_run == x3_llm_auto_translate.run:
-            traducir_todo = messagebox.askyesno("Traducir todo", "¿Desea traducir todas las celdas?")
-            print("Ejecutando x3_llm_auto_translate.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, traducir_todo)
-        elif funcion_run == x4_integrate_translates_to_master.run:
-            print("Ejecutando x4_integrate_translates_to_master.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, 0.5)
-        elif funcion_run == x5_complete_empty_cells_master.run:
-            print("Ejecutando x5_complete_empty_cells_master.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, indice_seleccionado2)
-        elif funcion_run == x6_update_from_master.run:
-            print("Ejecutando x6_update_from_master.run()")
-            funcion_run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
-    finally:
-        # Restaurar stdout
-        sys.stdout = original_stdout
-        guardar_configuracion()  # Guardar el contenido del cuadro de texto
 
 # Crear los botones con el mismo ancho
 button_width = 70
-paso1 = tk.Button(ventana, text="1 - Importar al Master", command=lambda: threading.Thread(target=ejecutar_run, args=(x1_importar_to_master.run,)).start(), width=button_width)
+paso1 = tk.Button(ventana, text="1 - Importar al Master", command=accion_boton1, width=button_width)
-paso2 = tk.Button(ventana, text="2 - Exportar Idioma a 2_master_export2translate.xlsx.", command=lambda: threading.Thread(target=ejecutar_run, args=(x2_master_export2translate.run,)).start(), width=button_width)
+paso2 = tk.Button(
-paso3 = tk.Button(ventana, text="3 - Traducir y generar 3_master_export2translate_translated.xlsx.", command=lambda: threading.Thread(target=ejecutar_run, args=(x3_llm_auto_translate.run,)).start(), width=button_width)
+    ventana,
-paso4 = tk.Button(ventana, text="4 - Integrar las traducciones al 1_hmi_master_translates.", command=lambda: threading.Thread(target=ejecutar_run, args=(x4_integrate_translates_to_master.run,)).start(), width=button_width)
+    text="2 - Exportar idioma a '2_master_export2translate.xlsx'",
-paso5 = tk.Button(ventana, text="5 - Completar en 1_hmi_master_translates el idioma seleccionado usando el segundo idioma.", command=lambda: threading.Thread(target=ejecutar_run, args=(x5_complete_empty_cells_master.run,)).start(), width=button_width)
+    command=accion_boton2,
-paso6 = tk.Button(ventana, text="6 - Exportar usando un archivo exportado desde TIA Portal usando 1_hmi_master_translates.", command=lambda: threading.Thread(target=ejecutar_run, args=(x6_update_from_master.run,)).start(), width=button_width)
+    width=button_width
-
+)
-# Ubicar los botones en la ventana
+paso3 = tk.Button(
-paso1.pack(pady=(10,2))
+    ventana,
-paso2.pack(pady=2)
+    text="3 - Traducir y generar '3_master_export2translate_translated.xlsx'",
-paso3.pack(pady=2)
+    command=accion_boton3,
-paso4.pack(pady=2)
+    width=button_width
-paso5.pack(pady=2)
+)
-paso6.pack(pady=2)
+paso4 = tk.Button(
-
+    ventana,
-# Crear un Frame para el cuadro de texto, los scrollbars y el botón
+    text="4 - Integrar las traducciones al '1_hmi_master_translates'",
-frame_texto = tk.Frame(ventana)
+    command=accion_boton4,
-frame_texto.pack(fill='both', expand=True, pady=10)
+    width=button_width
-
+)
-# Crear los scrollbars
+paso5 = tk.Button(
-scrollbar_vertical = tk.Scrollbar(frame_texto, orient='vertical')
+    ventana,
-scrollbar_horizontal = tk.Scrollbar(frame_texto, orient='horizontal')
+    text="5 - Completar celdas vacías usando el segundo idioma",
-
+    command=accion_boton5,
-# Crear la caja de texto para mostrar la salida
+    width=button_width
-output_text = tk.Text(
+)
-    frame_texto,
+paso6 = tk.Button(
-    wrap='none',
+    ventana,
-    yscrollcommand=scrollbar_vertical.set,
+    text="6 - Exportar desde '1_hmi_master_translates' al PLC",
-    xscrollcommand=scrollbar_horizontal.set
+    command=accion_boton6,
+    width=button_width
 )
 
-# Configurar los scrollbars
+# Ubicar los botones en la ventana
-scrollbar_vertical.config(command=output_text.yview)
+paso1.pack(pady=5)
-scrollbar_horizontal.config(command=output_text.xview)
+paso2.pack(pady=5)
-
+paso3.pack(pady=5)
-# Crear el botón para borrar el contenido
+paso4.pack(pady=5)
-boton_limpiar = tk.Button(frame_texto, text="Borrar contenido", command=lambda: limpiar_texto())
+paso5.pack(pady=5)
-
+paso6.pack(pady=5)
-# Ubicar los widgets en frame_texto usando grid
-output_text.grid(row=0, column=0, sticky='nsew')
-scrollbar_vertical.grid(row=0, column=1, sticky='ns')
-scrollbar_horizontal.grid(row=1, column=0, sticky='ew')
-boton_limpiar.grid(row=1, column=1, padx=5, pady=5)
-
-# Configurar la expansión de filas y columnas
-frame_texto.grid_rowconfigure(0, weight=1)
-frame_texto.grid_columnconfigure(0, weight=1)
-
-# Función para borrar el contenido del cuadro de texto
-def limpiar_texto():
-    output_text.delete('1.0', tk.END)
-    guardar_configuracion()
-
-# Cargar las opciones guardadas al iniciar
-cargar_configuracion()
-
-# Cargar el contenido del cuadro de texto desde la configuración
-def cargar_texto():
-    config = configparser.ConfigParser()
-    if os.path.exists(config_file):
-        config.read(config_file)
-        texto = config.get('TextContent', 'output_text', fallback='')
-        output_text.insert('1.0', texto)
-
-cargar_texto()
-
-# Guardar la configuración al cerrar la ventana
-def on_closing():
-    guardar_configuracion()
-    ventana.destroy()
-
-ventana.protocol("WM_DELETE_WINDOW", on_closing)
 
 # Iniciar el bucle principal de la interfaz
 ventana.mainloop()

x2_master_export2translate.py

@@ -23,7 +23,7 @@ def exportar_para_traduccion(tipo_PLC, archivo_maestro, target_lang_code):
 
     print(f"Archivo exportado para traducción: {ruta_export}")
 
-def run(tipo_PLC, codigo_columna_maestra, seleccion_idioma):    
+def run(tipo_PLC, seleccion_idioma):    
     archivo_maestro = f".\\data\\1_hmi_master_translates_{tipo_PLC}.xlsx"
     if seleccion_idioma not in fc.IDIOMAS:
         print("Selección inválida.")

x3_llm_auto_translate.py

@@ -66,6 +66,18 @@ def translate_batch_ollama(texts, source_lang, target_lang):
     return translations
 
 
+def texto_requiere_traduccion(texto):
+    palabras = re.findall(r"\b\w{4,}\b", texto)
+    campos_especiales = re.findall(r"<.*?>", texto)
+    requiere_traduccion = len(palabras) > 0 or len(campos_especiales) != len(
+        re.findall(r"<#>", texto)
+    )
+    logger.debug(
+        f"Decisión de traducción para texto '{texto}': {'Sí' if requiere_traduccion else 'No'} (palabras > 3 letras: {len(palabras) > 0}, solo campos especiales: {len(campos_especiales) == len(re.findall(r'<#>', texto))})"
+    )
+    return requiere_traduccion
+
+
 def translate_batch_openai(texts_dict, source_lang, target_lang):
     system_prompt = read_system_prompt()
     texts_list = list(texts_dict.values())
@@ -98,13 +110,13 @@ def translate_batch_openai(texts_dict, source_lang, target_lang):
     return dict(zip(texts_dict.keys(), translations))
 
 
-def affinity_batch_openai(tipo_PLC, texts_dict):
+def affinity_batch_openai(texts_dict):
     system_prompt = (
         "Evaluate the semantic similarity between the following table of pairs of texts in json format on a scale from 0 to 1. "
         "Return the similarity scores for every row in JSON format as a list of numbers, without any additional text or formatting."
     )
     original_list = [
-        fc.compactar_celda_traducida(tipo_PLC, key) for key in texts_dict.keys()
+        fc.compactar_celda_traducida(key) for key in texts_dict.keys()
     ]
     re_translated_list = list(texts_dict.values())
 
@@ -155,13 +167,13 @@ def affinity_batch_openai(tipo_PLC, texts_dict):
 
 
 # Función que calcula la afinidad entre dos textos
-def calcular_afinidad(tipo_PLC, texto1, texto2):
+def calcular_afinidad(texto1, texto2):
     system_prompt = (
         "Evaluate the semantic similarity between the following pair of texts on a scale from 0 to 1. "
         "Return the similarity score as a single number."
     )
 
-    original_text = fc.compactar_celda_traducida(tipo_PLC, texto1)
+    original_text = fc.compactar_celda_traducida(texto1)
     compared_text = texto2
 
     request_payload = json.dumps({"original": original_text, "compared": compared_text})
@@ -210,25 +222,25 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
 
     texts_to_translate = {}
 
-    for index, row in df.iterrows():
+    for _, row in df.iterrows():
         celda_clave = str(row[source_col])
         source_translated_text = (
             str(row[source_translated_col])
             if source_translated_col in df.columns
             else ""
         )
-        celda_clave_compactada = fc.compactar_celda_traducida(tipo_PLC, celda_clave)
+        celda_clave_compactada = fc.compactar_celda_traducida(celda_clave)
 
         if traducir_todo:
-            if fc.texto_requiere_traduccion(tipo_PLC, celda_clave_compactada, logger):
+            if texto_requiere_traduccion(celda_clave_compactada):
-                df.at[index, source_translated_col] = ''  # Necesita ser traducida.
+                df[row,source_translated_col] = '' # Necesita ser traducida. En esta iteracion o en la siguiente.
                 texts_to_translate[celda_clave] = celda_clave_compactada
         else:
             if (
                 pd.isna(row[source_translated_col])
                 or source_translated_text.strip() == ""
             ):
-                if fc.texto_requiere_traduccion(tipo_PLC, celda_clave_compactada, logger) or fc.texto_con_campos_especiales(tipo_PLC, celda_clave_compactada):
+                if texto_requiere_traduccion(celda_clave_compactada):
                     texts_to_translate[celda_clave] = celda_clave_compactada
 
     num_texts = len(texts_to_translate)
@@ -250,7 +262,7 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
         for attempt in range(retries):
             try:
                 batch_translations = translate_batch_openai(
-                    batch_texts, fc.idiomas_idiomafromcode(codigo_columna_maestra) , target_lang
+                    batch_texts, "Italian", target_lang
                 )
                 translations.update(batch_translations)
                 break  # Si la traducción es exitosa, salimos del bucle de reintentos
@@ -283,7 +295,7 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
             df.at[index, target_col] = translations[celda_clave]
             # Realizar la traducción de verificación con Google Translate
             try:
-                google_translation = google_translate(translations[celda_clave], fc.idiomas_shortcodefromcode(codigo_columna_maestra))
+                google_translation = google_translate(translations[celda_clave], "it")
                 df.at[index, check_translate_col] = google_translation
             except Exception as e:
                 logger.error(
@@ -304,7 +316,7 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
         retries = 2  # Número de intentos totales (1 inicial + 1 reintento)
         for attempt in range(retries):
             try:
-                batch_affinities = affinity_batch_openai(tipo_PLC, batch_texts)
+                batch_affinities = affinity_batch_openai(batch_texts)
                 affinities.update(batch_affinities)
                 break  # Si la llamada es exitosa, salimos del bucle de reintentos
             except Exception as e:
@@ -326,7 +338,7 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
                     # Intentar individualmente si falla en batch
                     for key, value in batch_texts.items():
                         try:
-                            score = calcular_afinidad(tipo_PLC, key, value)
+                            score = calcular_afinidad(key, value)
                             affinities[key] = score
                         except Exception as ind_e:
                             affinities[key] = "0"

x5_complete_empty_cells_master.py

@@ -6,7 +6,7 @@ import logging
 from manejoArchivos import select_file
 
 
-def complete_emptys(tipo_PLC, archivo_maestro, target_lang_code, second_lang_code):
+def complete_emptys(archivo_maestro, target_lang_code, second_lang_code):
     if not os.path.exists(archivo_maestro):
         print("El archivo maestro no existe.")
         return
@@ -33,7 +33,7 @@ def complete_emptys(tipo_PLC, archivo_maestro, target_lang_code, second_lang_cod
             else:
                 df_maestro.loc[
                     df_maestro[df_maestro.columns[0]] == clave, master_col
-                ] = fc.compactar_celda_traducida(tipo_PLC, fila[df_maestro.columns[0]])
+                ] = fc.compactar_celda_traducida(fila[df_maestro.columns[0]])
                 logger.info(
                     f'Fila {index}, Columna {master_col}: " actualizado a "{fila[df_maestro.columns[0]]}"'
                 )

x6_update_from_master.py

@@ -6,7 +6,7 @@ import funciones_comunes as fc
 from manejoArchivos import select_file
 
 
-def update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang_code):
+def update_from_master(archivo_maestro, archivo_to_update, target_lang_code):
     if not os.path.exists(archivo_maestro):
         print("El archivo maestro no existe.")
         return
@@ -34,7 +34,7 @@ def update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang
                 df_maestro[col_clave] == clave, target_lang_code
             ].values[0]
             # Descompactamos
-            valor_traducido = fc.decompactar_celda_traducida(tipo_PLC,
+            valor_traducido = fc.decompactar_celda_traducida(
                 celda_original=valor_original, celda_traducida=valor_traducido_compacto
             )
 
@@ -43,7 +43,7 @@ def update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang
                 and fila[target_lang_code] != valor_traducido
             ):
                 # Salvamos en el file to Update
-                okToSave, Error = fc.verificar_celda_traducida(tipo_PLC,
+                okToSave, Error = fc.verificar_celda_traducida(
                     valor_original, valor_traducido_compacto
                 )
                 if okToSave:
@@ -76,7 +76,7 @@ def run(tipo_PLC, codigo_columna_maestra, seleccion_idioma) :
             print("Selección inválida.")
         else:
             _, target_lang_code = fc.IDIOMAS[seleccion_idioma]
-            update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang_code)
+            update_from_master(archivo_maestro, archivo_to_update, target_lang_code)
 
 if __name__ == "__main__":
     tipo_PLC = "siemens"