Funcion de LLM mejorada

import_translate2master.py

@@ -0,0 +1,68 @@
+import pandas as pd
+import os
+import re
+import logging
+from manejoArchivos import select_file
+
+def configurar_logger(ruta_log):
+    logger = logging.getLogger('importacion_logger')
+    logger.setLevel(logging.INFO)
+    fh = logging.FileHandler(ruta_log, encoding='utf-8')
+    fh.setLevel(logging.INFO)
+    formatter = logging.Formatter('%(asctime)s - %(message)s')
+    fh.setFormatter(formatter)
+    logger.addHandler(fh)
+    return logger
+
+def revertir_transformaciones(texto, digitos, secciones):
+    # Revertir <> a [[digits]]
+    for digito in digitos:
+        texto = texto.replace('<>', digito, 1)
+    # Revertir <#> a <...> usando las secciones originales
+    for seccion in secciones:
+        texto = texto.replace('<#>', f'<{seccion}>', 1)
+    return texto
+
+def importar_traduccion(archivo_maestro, archivo_traduccion):
+    if not os.path.exists(archivo_maestro):
+        print("El archivo maestro no existe.")
+        return
+
+    df_maestro = pd.read_excel(archivo_maestro)
+    df_traduccion = pd.read_excel(archivo_traduccion)
+
+    # Configurar el logger
+    directorio = os.path.dirname(archivo_maestro)
+    nombre_log = os.path.join(directorio, 'importacion_traduccion.log')
+    logger = configurar_logger(nombre_log)
+
+    # Iterar sobre las filas del archivo de traducción para revertir transformaciones y actualizar el maestro
+    for index, fila in df_traduccion.iterrows():
+        clave = fila[df_maestro.columns[0]]
+        if clave in df_maestro[df_maestro.columns[0]].values:
+            # Obtener los dígitos y secciones originales de la clave
+            digitos = re.findall(r'\d+', str(clave))
+            secciones = re.findall(r'<(.*?)>', str(clave))
+            
+            # Actualizar solo las columnas que existen en df_maestro y df_traduccion
+            for columna in df_traduccion.columns[1:]:
+                if columna in df_maestro.columns:
+                    valor_traducido = fila[columna]
+                    if pd.isnull(valor_traducido):
+                        continue  # Omitir celdas vacías
+                    valor_original = df_maestro.loc[df_maestro[df_maestro.columns[0]] == clave, columna].values[0]
+                    valor_revertido = revertir_transformaciones(valor_traducido, digitos, secciones)
+                    
+                    if pd.notnull(valor_original) and str(valor_original) != valor_revertido:
+                        df_maestro.loc[df_maestro[df_maestro.columns[0]] == clave, columna] = valor_revertido
+                        logger.info(f'Fila {index}, Columna {columna}: "{valor_original}" actualizado a "{valor_revertido}"')
+
+    # Guardar el archivo maestro actualizado
+    df_maestro.to_excel(archivo_maestro, index=False)
+    print(f"Traducciones importadas y archivo maestro actualizado: {archivo_maestro}. Detalles de los cambios en {nombre_log}")
+
+
+if __name__ == "__main__":
+    archivo_maestro = "hmi_master_translates.xlsx"
+    archivo_traduccion = "master_export2translate.xlsx"
+    importar_traduccion(archivo_maestro, archivo_traduccion)

llm_translate_text.py

@@ -0,0 +1,169 @@
+import pandas as pd
+from openai import OpenAI
+import os
+import re
+import logging
+from openai_api_key import api_key
+from master_export2translate import transformar_texto
+
+client = OpenAI(api_key=api_key())
+
+# Diccionario de idiomas
+IDIOMAS = {
+    1: ("English", "en"),
+    2: ("Portuguese", "pt"),
+    3: ("Spanish", "es"),
+    4: ("Russian", "ru"),
+    5: ("French", "fr"),
+    6: ("German", "de"),
+}
+
+
+def configurar_logger():
+    logger = logging.getLogger("translate_logger")
+    logger.setLevel(logging.DEBUG)  # Cambiado a DEBUG para más información
+    fh = logging.FileHandler("translate_log.log", encoding="utf-8")
+    fh.setLevel(logging.DEBUG)
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+    fh.setFormatter(formatter)
+    logger.addHandler(fh)
+    return logger
+
+
+logger = configurar_logger()
+
+
+def mostrar_idiomas():
+    print("Selecciona el idioma de destino:")
+    for numero, (nombre, _) in IDIOMAS.items():
+        print(f"{numero}: {nombre}")
+
+
+def translate_text(text, source_lang, target_lang):
+    logger.info(
+        f"Solicitando traducción de {source_lang} a {target_lang} para el texto: {text}"
+    )
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": f"You are a translator."},
+            {
+                "role": "user",
+                "content": f"Translate the following text from {source_lang} to {target_lang} while preserving special fields like <> and <#>. This texts are for an HMI industrial machine: {text}",
+            },
+        ],
+        max_tokens=150,
+        temperature=0.3,
+    )
+    translated_text = response.choices[0].message.content.strip()
+    logger.info(f"Respuesta recibida: {translated_text}")
+    return translated_text
+
+
+def translate_batch(texts, source_lang, target_lang):
+    joined_text = "\n".join(texts)
+    logger.info(
+        f"Solicitando traducción de {source_lang} a {target_lang} para el lote de textos:\n{joined_text}"
+    )
+    response = client.chat.completions.create(
+        model="gpt-3.5-turbo",
+        messages=[
+            {"role": "system", "content": f"You are a translator."},
+            {
+                "role": "user",
+                "content": f"Translate the following texts from {source_lang} to {target_lang} while preserving special fields like <> and <#>:\n\n{joined_text}",
+            },
+        ],
+        max_tokens=1500,
+        temperature=0.3,
+    )
+    translations = response.choices[0].message.content.strip().split("\n")
+    logger.info(f"Respuestas recibidas:\n{translations}")
+    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 main(file_path, target_lang_code, traducir_todo, batch_size=10):
+    df = pd.read_excel(file_path)
+    source_col = "it-IT"
+    target_col = f"{target_lang_code} Translated"
+
+    if target_col in df.columns and not traducir_todo:
+        df[target_col] = df[target_col]
+    else:
+        df[target_col] = None
+
+    texts_to_translate = []
+    indices_to_translate = []
+
+    if traducir_todo:
+        for index, text in df[source_col].astype(str).items():
+            processed_text = transformar_texto(text)
+            if texto_requiere_traduccion(processed_text):
+                texts_to_translate.append(text)
+                indices_to_translate.append(index)
+    else:
+        for index, text in (
+            df.loc[df[target_col].isnull(), source_col].astype(str).items()
+        ):
+            processed_text = transformar_texto(text)
+            if texto_requiere_traduccion(processed_text):
+                texts_to_translate.append(text)
+                indices_to_translate.append(index)
+
+    num_texts = len(texts_to_translate)
+    logger.info(f"Número total de textos a traducir: {num_texts}")
+
+    translations = []
+    for start_idx in range(0, num_texts, batch_size):
+        end_idx = min(start_idx + batch_size, num_texts)
+        batch_texts = texts_to_translate[start_idx:end_idx]
+        batch_translations = translate_batch(batch_texts, "Italian", target_lang_code)
+        translations.extend(batch_translations)
+
+    logger.info(f"Número total de traducciones recibidas: {len(translations)}")
+
+    if len(translations) != len(indices_to_translate):
+        logger.warning(
+            f"Desajuste entre el número de traducciones ({len(translations)}) y el número de índices ({len(indices_to_translate)})"
+        )
+
+    for i, index in enumerate(indices_to_translate):
+        if i < len(translations):
+            df.at[index, target_col] = translations[i]
+        else:
+            logger.error(f"No hay traducción disponible para el índice {index}")
+
+    output_path = os.path.join(
+        os.path.dirname(file_path), "master_export2translate_translated.xlsx"
+    )
+    df.to_excel(output_path, index=False)
+    logger.info(f"Archivo traducido guardado en: {output_path}")
+    print(f"Archivo traducido guardado en: {output_path}")
+
+
+if __name__ == "__main__":
+    batch_size = 10
+    translate_file = "master_export2translate.xlsx"
+
+    mostrar_idiomas()
+    seleccion_idioma = int(input("Introduce el número del idioma de destino: "))
+    if seleccion_idioma not in IDIOMAS:
+        print("Selección inválida.")
+    else:
+        _, target_lang_code = IDIOMAS[seleccion_idioma]
+        traducir_todo = (
+            input("¿Desea traducir todas las celdas (s/n)? ").strip().lower() == "s"
+        )
+        main(translate_file, target_lang_code, traducir_todo, batch_size)

master_export2translate.py

@@ -0,0 +1,37 @@
+import pandas as pd
+import os
+import re
+from manejoArchivos import select_file
+
+def transformar_texto(texto):
+    # Sustituir [[digits]] por <>
+    texto_transformado = re.sub(r'\[\[digits\]\]', '<>', texto)
+    # Sustituir cualquier <...> por <#>
+    texto_transformado = re.sub(r'<.*?>', '<#>', texto_transformado)
+    return texto_transformado
+
+def exportar_para_traduccion(archivo_maestro):
+    if not os.path.exists(archivo_maestro):
+        print("El archivo maestro no existe.")
+        return
+
+    df_maestro = pd.read_excel(archivo_maestro)
+
+    # Crear un nuevo DataFrame para la exportación
+    df_export = pd.DataFrame()
+
+    # Copiar la primera columna tal cual
+    df_export[df_maestro.columns[0]] = df_maestro[df_maestro.columns[0]]
+
+    # Transformar las demás columnas
+    for columna in df_maestro.columns[1:]:
+        df_export[columna] = df_maestro[columna].apply(lambda x: transformar_texto(str(x)) if pd.notnull(x) else x)
+
+    # Guardar el archivo exportado
+    ruta_export = os.path.join(os.path.dirname(archivo_maestro), 'master_export2translate.xlsx')
+    df_export.to_excel(ruta_export, index=False)
+    print(f"Archivo exportado para traducción: {ruta_export}")
+
+if __name__ == "__main__":
+    archivo_maestro = "hmi_master_translates.xlsx"
+    exportar_para_traduccion(archivo_maestro)

openai_api_key.py

@@ -0,0 +1,3 @@
+# Configura tu clave API de OpenAI
+def api_key():
+  return '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'