Con algunas mejoras

funciones_comunes/funciones_base.py

@@ -14,8 +14,59 @@ IDIOMAS = {
     4: ("Russian", "ru-RU"),
     5: ("French", "fr-FR"),
     6: ("German", "de-DE"),
+    7: ("English_US", "en-US"),
 }
 
+# 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:")
@@ -86,18 +137,11 @@ def es_columna_tipo_xxYY(columna):
     return bool(re.match(r"^[a-z]{2}-[A-Z]{2}$", columna))
 
 
-def compactar_celda_clave_siemens(celda_original):
+def compactar_celda_clave(tipo_PLC, celda_original):
-    if pd.isnull(celda_original):
+    if tipo_PLC == "siemens" :
-        return celda_original
+        return compactar_celda_clave_siemens(celda_original)
-    
+    else :
-    def reemplazar(match):
+        return compactar_celda_clave_ab(celda_original)
-        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" :
@@ -113,15 +157,15 @@ def obtener_digitos_celda_original(tipo_PLC, celda_original):
 
 def decompactar_celda_traducida(tipo_PLC, celda_original, celda_traducida):
     if tipo_PLC == "siemens" :
-        decompactar_celda_traducida_siemens(celda_original, celda_traducida)
+        return decompactar_celda_traducida_siemens(celda_original, celda_traducida)
     else :
-        decompactar_celda_traducida_ab(celda_original, celda_traducida)
+        return decompactar_celda_traducida_ab(celda_original, celda_traducida)
 
 def verificar_celda_traducida(tipo_PLC, celda_clave, celda_traducida):
     if tipo_PLC == "siemens" :
-        verificar_celda_traducida_siemens(celda_clave, celda_traducida)
+        return verificar_celda_traducida_siemens(celda_clave, celda_traducida)
     else :
-        verificar_celda_traducida_ab(celda_clave, celda_traducida)
+        return verificar_celda_traducida_ab(celda_clave, celda_traducida)
 
 
 #           SIEMENS
@@ -152,7 +196,7 @@ def compactar_celda_clave_siemens(celda_original):
 def compactar_celda_traducida_siemens(celda_traducida):
     if pd.isnull(celda_traducida):
         return celda_traducida
-    celda_traducida = compactar_celda_clave(celda_traducida)
+    celda_traducida = compactar_celda_clave_siemens(celda_traducida)
 
     def reemplazar(match):
         if match.group(1):  # Si hay contenido dentro de <>
@@ -184,7 +228,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(celda_original)
+    digitos = obtener_digitos_celda_original_siemens(celda_original)
     celda_destino = celda_traducida
     
     # Replace <> with digits
@@ -319,35 +363,37 @@ def verificar_celda_traducida_ab(celda_clave, celda_traducida):
 
 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(celda_original)
+    celda_clave = compactar_celda_clave_siemens(celda_original)
-    celda_tradc = compactar_celda_traducida(celda_original) + " TEXTO "
+    celda_tradc = compactar_celda_traducida_siemens(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(celda_original)))
+    print("Digitos        : " + ','.join(obtener_digitos_celda_original_siemens(celda_original)))
-    print("Celda          : " + decompactar_celda_traducida(celda_original, celda_tradc))
+    print("Celda          : " + decompactar_celda_traducida_siemens(celda_original, celda_tradc))
     print("Celda Original : " + celda_original)
 
-    print(verificar_celda_traducida(celda_clave=celda_clave, celda_traducida= celda_tradc))
+    print(verificar_celda_traducida_siemens(celda_clave=celda_clave, celda_traducida= celda_tradc))
 
     # 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}*/'
+    print("****************** ALLEN BRADLEY ***************************")
-    # Simulando una celda traducida después del procesamiento
+    celda_original = 'A271/47/6 /*N:4 {#1.#4.VFix[1]} NOFILL DP:1*/   m/min SPEED'
-    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_traducida)
+    celda_tradc = compactar_celda_traducida_ab(celda_original) + " TEXTO "
 
     print()
     print("Celda Original : " +celda_original)
     print("Celda Clave    : " + celda_clave)
-    print("Celda Traducida Compactada : " + celda_tradc)
+    print("Celda Traducida: " + celda_tradc)
-    print("Dígitos                    : " + ','.join(obtener_digitos_celda_original_ab(celda_original)))
+    print("Digitos        : " + ','.join(obtener_digitos_celda_original_ab(celda_original)))
-    print("Celda Reconstituida        : " + decompactar_celda_traducida_ab(celda_original, celda_tradc))
+    print("Celda          : " + decompactar_celda_traducida_ab(celda_original, celda_tradc))
-    print("Verificación               : ", verificar_celda_traducida_ab(celda_clave=celda_clave, celda_traducida=celda_tradc))
+    print("Celda Original : " + celda_original)
+
+    print(verificar_celda_traducida_ab(celda_clave=celda_clave, celda_traducida= celda_tradc))

menu_pasos_traduccion.py

@@ -14,49 +14,66 @@ ventana = tk.Tk()
 ventana.title("Ayuda para traducir textos de TIA Portal y Allen Bradley")
 ventana.geometry("600x550")  # Aumentamos el tamaño para acomodar los nuevos widgets
 
-# Opciones para tipo_PLC
+# Diccionario para tipo_PLC
-opciones_tipo_PLC = ['siemens', 'allenbradley']
+tipo_PLC_dict = {'Siemens': 'siemens', 'AllenBradley': 'allenbradley'}
 
 # Variables para almacenar las selecciones del usuario
 tipo_PLC_var = tk.StringVar()
-idioma_maestra_var = tk.StringVar()
+codigo_columna_maestra_var = tk.StringVar()
 idioma_var = tk.StringVar()
 idioma_var2 = tk.StringVar()
 
 # Crear listas de idiomas con sus códigos
-idiomas_lista = sorted([(nombre, codigo) for _, (nombre, codigo) in fc.IDIOMAS.items()])
+idiomas_lista = [(nombre, codigo) for _, (nombre, codigo) in fc.IDIOMAS.items()]
 
 # Crear un combobox para seleccionar el tipo de PLC
 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["values"] = list(tipo_PLC_dict.keys())
-combo_tipo_PLC.current(0)  # Selecciona 'siemens' por defecto
+combo_tipo_PLC.current(0)  # Selecciona 'Siemens' por defecto
 
-# Crear combobox para seleccionar el Idioma Columna Maestra
+# Crear combobox para seleccionar el código de columna maestra
-label_maestra = tk.Label(ventana, text="Idioma Columna Maestra:")
+label_codigo_maestra = tk.Label(ventana, text="Idioma Columna Maestra:")
-combo_maestra = ttk.Combobox(ventana, textvariable=idioma_maestra_var, state="readonly")
+combo_codigo_maestra = ttk.Combobox(ventana, textvariable=codigo_columna_maestra_var, state="readonly")
-combo_maestra["values"] = [nombre for nombre, _ in idiomas_lista]
+combo_codigo_maestra["values"] = [nombre for nombre, _ in idiomas_lista]
-combo_maestra.current(0)  # Selecciona el primer idioma por defecto
+combo_codigo_maestra.current(0)  # Selecciona el primer idioma por defecto
 
 # Crear comboboxes para seleccionar los idiomas
-label_idioma1 = tk.Label(ventana, text="Selecciona el idioma principal:")
+label1 = tk.Label(ventana, text="Idioma de Traducción:")
 combo = ttk.Combobox(ventana, textvariable=idioma_var, state="readonly")
 combo["values"] = [nombre for nombre, _ in idiomas_lista]
-combo.current(1)  # Selecciona el segundo idioma por defecto
+combo.current(4)  # Selecciona el quinto idioma por defecto
 
-label_idioma2 = tk.Label(ventana, text="Selecciona el segundo idioma:")
+label2 = tk.Label(ventana, text="Selecciona segundo idioma:")
 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
+combo2.current(1)  # Selecciona el segundo idioma por defecto
+
+# Función para actualizar combo_codigo_maestra según la selección en combo_tipo_PLC
+def actualizar_codigo_maestra(event):
+    plc_seleccionado = tipo_PLC_var.get()
+    if plc_seleccionado == 'Siemens':
+        # Buscar el índice de 'Italiano' en idiomas_lista
+        indice_italiano = next((i for i, (nombre, _) in enumerate(idiomas_lista) if nombre == 'Italian'), None)
+        if indice_italiano is not None:
+            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)
+
+# Vincular la función al evento de cambio de selección en combo_tipo_PLC
+combo_tipo_PLC.bind('<<ComboboxSelected>>', actualizar_codigo_maestra)
 
 # Ubicar los widgets en la ventana
 label_tipo_PLC.pack(pady=5)
 combo_tipo_PLC.pack(pady=5)
-label_maestra.pack(pady=5)
+label_codigo_maestra.pack(pady=5)
-combo_maestra.pack(pady=5)
+combo_codigo_maestra.pack(pady=5)
-label_idioma1.pack(pady=5)
+label1.pack(pady=5)
 combo.pack(pady=5)
-label_idioma2.pack(pady=5)
+label2.pack(pady=5)
 combo2.pack(pady=5)
 
 # Función para obtener el código del idioma seleccionado a partir del índice
@@ -65,91 +82,90 @@ def obtener_codigo_idioma(indice):
 
 # Funciones que se llamarán cuando se presionen los botones
 def accion_boton1():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
     print("Ejecutando x1_importar_to_master.py")
     x1_importar_to_master.run(tipo_PLC, codigo_columna_maestra)
 
 def accion_boton2():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
-    print("Ejecutando x2_master_export2translate.py")
+    indice_seleccionado = combo.current()
-    x2_master_export2translate.run(tipo_PLC, codigo_columna_maestra)
+    x2_master_export2translate.run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
 
 def accion_boton3():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
+    indice_seleccionado = combo.current()
     traducir_todo = messagebox.askyesno("Traducir todo", "¿Desea traducir todas las celdas?")
-    print("Ejecutando x3_llm_auto_translate.py")
+    x3_llm_auto_translate.run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, traducir_todo)
-    x3_llm_auto_translate.run(tipo_PLC, codigo_columna_maestra, traducir_todo)
 
 def accion_boton4():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
-    print("Ejecutando x4_integrate_translates_to_master.py")
+    indice_seleccionado = combo.current()
-    x4_integrate_translates_to_master.run(tipo_PLC, codigo_columna_maestra)
+    x4_integrate_translates_to_master.run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, 0.5)
 
 def accion_boton5():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
-    indice_idioma1 = combo.current()
+    indice_seleccionado = combo.current()
-    codigo_columna_secundaria = obtener_codigo_idioma(indice_idioma1)
+    indice_seleccionado2 = combo2.current()
-    print("Ejecutando x5_complete_empty_cells_master.py")
+    x5_complete_empty_cells_master.run(tipo_PLC, codigo_columna_maestra, indice_seleccionado, indice_seleccionado2)
-    x5_complete_empty_cells_master.run(tipo_PLC, codigo_columna_maestra, codigo_columna_secundaria)
 
 def accion_boton6():
-    tipo_PLC = tipo_PLC_var.get()
+    tipo_PLC = tipo_PLC_dict[tipo_PLC_var.get()]
-    indice_maestra = combo_maestra.current()
+    indice_codigo_maestra = combo_codigo_maestra.current()
-    codigo_columna_maestra = obtener_codigo_idioma(indice_maestra)
+    codigo_columna_maestra = obtener_codigo_idioma(indice_codigo_maestra)
-    print("Ejecutando x6_update_from_master.py")
+    indice_seleccionado = combo.current()
-    x6_update_from_master.run(tipo_PLC, codigo_columna_maestra)
+    x6_update_from_master.run(tipo_PLC, codigo_columna_maestra, indice_seleccionado)
 
 # Crear los botones con el mismo ancho
 button_width = 70
 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'",
+    text="2 - Exportar Idioma a 2_master_export2translate.xlsx.",
     command=accion_boton2,
     width=button_width
 )
 paso3 = tk.Button(
     ventana,
-    text="3 - Traducir y generar '3_master_export2translate_translated.xlsx'",
+    text="3 - Traducir y generar 3_master_export2translate_translated.xlsx.",
     command=accion_boton3,
     width=button_width
 )
 paso4 = tk.Button(
     ventana,
-    text="4 - Integrar las traducciones al '1_hmi_master_translates'",
+    text="4 - Integrar las traducciones al 1_hmi_master_translates.",
     command=accion_boton4,
     width=button_width
 )
 paso5 = tk.Button(
     ventana,
-    text="5 - Completar celdas vacías usando el segundo idioma",
+    text="5 - Completar en 1_hmi_master_translates el idioma seleccionado usando el segundo idioma.",
     command=accion_boton5,
     width=button_width
 )
 paso6 = tk.Button(
     ventana,
-    text="6 - Exportar desde '1_hmi_master_translates' al PLC",
+    text="6 - Exportar usando un archivo exportado desde TIA Portal usando 1_hmi_master_translates.",
     command=accion_boton6,
     width=button_width
 )
 
 # Ubicar los botones en la ventana
-paso1.pack(pady=5)
+paso1.pack(pady=(10,2))
-paso2.pack(pady=5)
+paso2.pack(pady=2)
-paso3.pack(pady=5)
+paso3.pack(pady=2)
-paso4.pack(pady=5)
+paso4.pack(pady=2)
-paso5.pack(pady=5)
+paso5.pack(pady=2)
-paso6.pack(pady=5)
+paso6.pack(pady=2)
 
 # 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, seleccion_idioma):    
+def run(tipo_PLC, codigo_columna_maestra, 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

@@ -229,7 +229,7 @@ def main(tipo_PLC, codigo_columna_maestra, file_path, target_lang_code, target_l
             if source_translated_col in df.columns
             else ""
         )
-        celda_clave_compactada = fc.compactar_celda_traducida(celda_clave)
+        celda_clave_compactada = fc.compactar_celda_traducida(tipo_PLC, celda_clave)
 
         if traducir_todo:
             if texto_requiere_traduccion(celda_clave_compactada):
@@ -262,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, "Italian", target_lang
+                    batch_texts, fc.idiomas_idiomafromcode(codigo_columna_maestra) , target_lang
                 )
                 translations.update(batch_translations)
                 break  # Si la traducción es exitosa, salimos del bucle de reintentos

x5_complete_empty_cells_master.py

@@ -6,7 +6,7 @@ import logging
 from manejoArchivos import select_file
 
 
-def complete_emptys(archivo_maestro, target_lang_code, second_lang_code):
+def complete_emptys(tipo_PLC, 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(archivo_maestro, target_lang_code, second_lang_code):
             else:
                 df_maestro.loc[
                     df_maestro[df_maestro.columns[0]] == clave, master_col
-                ] = fc.compactar_celda_traducida(fila[df_maestro.columns[0]])
+                ] = fc.compactar_celda_traducida(tipo_PLC, 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(archivo_maestro, archivo_to_update, target_lang_code):
+def update_from_master(tipo_PLC, 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(archivo_maestro, archivo_to_update, target_lang_code):
                 df_maestro[col_clave] == clave, target_lang_code
             ].values[0]
             # Descompactamos
-            valor_traducido = fc.decompactar_celda_traducida(
+            valor_traducido = fc.decompactar_celda_traducida(tipo_PLC,
                 celda_original=valor_original, celda_traducida=valor_traducido_compacto
             )
 
@@ -43,7 +43,7 @@ def update_from_master(archivo_maestro, archivo_to_update, target_lang_code):
                 and fila[target_lang_code] != valor_traducido
             ):
                 # Salvamos en el file to Update
-                okToSave, Error = fc.verificar_celda_traducida(
+                okToSave, Error = fc.verificar_celda_traducida(tipo_PLC,
                     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(archivo_maestro, archivo_to_update, target_lang_code)
+            update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang_code)
 
 if __name__ == "__main__":
     tipo_PLC = "siemens"