modificado ubicacion de funciones_comunes como from ...Library.Python import funciones_comunes as fc. Unidos manejo de archivos a funciones_comunes

config.ini

@@ -95,7 +95,6 @@ output_text = Ejecutando x1_importar_to_master.run()
 	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. 
+	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/__init__.py

@@ -1 +0,0 @@
-from .funciones_base import *

funciones_comunes/funciones_base.py

@@ -1,466 +0,0 @@
-import re
-import time
-import pandas as pd
-from openpyxl import load_workbook
-import logging
-import os
-
-# Diccionario de idiomas
-IDIOMAS = {
-    0: ("Italian", "it-IT"),
-    1: ("English", "en-GB"),
-    2: ("Portuguese", "pt-PT"),
-    3: ("Spanish", "es-ES"),
-    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():
-        print(f"{numero}: {nombre}")
-
-
-def configurar_logger():
-    logger = logging.getLogger("translate_logger")
-    logger.setLevel(logging.DEBUG)
-    os.makedirs(".\\logs", exist_ok=True)
-    fh = logging.FileHandler(".\\logs\\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
-
-#
-# Salvar archivo Excel controlando que no este abierto. Sino espera.
-#
-def save_dataframe_with_retries(df, output_path, max_retries=5, retry_delay=5):
-    """
-    Guarda un DataFrame en un archivo Excel, reintentando si el archivo está en uso.
-
-    :param df: El DataFrame a guardar.
-    :param output_path: La ruta del archivo donde se guardará el DataFrame.
-    :param max_retries: El número máximo de reintentos en caso de error.
-    :param retry_delay: El tiempo de espera (en segundos) entre cada reintento.
-    """
-    retries = 0
-    while retries < max_retries:
-        try:
-            df.to_excel(output_path, sheet_name="User Texts", index=False)
-            print("Archivo guardado exitosamente.")
-            return
-        except PermissionError as e:
-            print(
-                f"Error de permiso: {e}. Por favor cierre el archivo. Reintentando en {retry_delay} segundos..."
-            )
-            retries += 1
-            time.sleep(retry_delay)
-
-    print(f"No se pudo guardar el archivo después de {max_retries} intentos.")
-
-
-def cambiar_nombre_hoja(archivo_excel, nombre_hoja_actual, nombre_hoja_nuevo):
-    # Cargar el archivo Excel existente
-    libro = load_workbook(archivo_excel)
-
-    # Verificar si la hoja existe en el archivo
-    if nombre_hoja_actual in libro.sheetnames:
-        # Obtener la hoja actual
-        hoja = libro[nombre_hoja_actual]
-        # Cambiar el nombre de la hoja
-        hoja.title = nombre_hoja_nuevo
-        # Guardar los cambios en el archivo Excel
-        libro.save(archivo_excel)
-        print(
-            f"El nombre de la hoja ha sido cambiado de '{nombre_hoja_actual}' a '{nombre_hoja_nuevo}'."
-        )
-    else:
-        print(f"La hoja '{nombre_hoja_actual}' no existe en el archivo.")
-
-# Verificar si la columna es del tipo "xx-YY" usando una expresión regular
-def es_columna_tipo_xxYY(columna):
-    # Verificar si la columna es del tipo "xx-YY" usando una expresión regular
-    return bool(re.match(r"^[a-z]{2}-[A-Z]{2}$", columna))
-
-
-def compactar_celda_clave(tipo_PLC, celda_original):
-    if tipo_PLC == "siemens" :
-        return compactar_celda_clave_siemens(celda_original)
-    else :
-        return compactar_celda_clave_ab(celda_original)
-
-def compactar_celda_traducida(tipo_PLC, celda_traducida):
-    if tipo_PLC == "siemens" :
-        return compactar_celda_traducida_siemens(celda_traducida)
-    else :
-        return compactar_celda_traducida_ab(celda_traducida)
-
-def obtener_digitos_celda_original(tipo_PLC, celda_original):
-    if tipo_PLC == "siemens" :
-        return obtener_digitos_celda_original_siemens(celda_original)
-    else :
-        return obtener_digitos_celda_original_ab(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)
-    else :
-        return 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)
-    else :
-        return 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
-#
-# Transforma:                                               "A271/47/6 Air - M<field ref="0" /> - Necessaria Manutenzione Filtro" ->
-#                          "A[[digits]]/[[digits]]/[[digits]] Air - M<field ref="[[digits]]" /> - Necessaria Manutenzione Filtro"
-#
-#  Este procesamiento se aplica a las celdas clave
-def compactar_celda_clave_siemens(celda_original):
-    if pd.isnull(celda_original):
-        return 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))
-
-
-#           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" ->
-#                          "A<>/<>/<> Air - M<#>" /> - Necessaria Manutenzione Filtro"
-#
-# Este procesamiento se aplica a las celdas traducidas
-def compactar_celda_traducida_siemens(celda_traducida):
-    if pd.isnull(celda_traducida):
-        return celda_traducida
-    celda_traducida = compactar_celda_clave_siemens(celda_traducida)
-
-    def reemplazar(match):
-        if match.group(1):  # Si hay contenido dentro de <>
-            return "<#>"
-        return "<>"
-    
-    # Reemplaza <...> con <#> y [[digits]] con <>
-    return re.sub(r"<(.*?)>|\[\[digits\]\]", reemplazar, str(celda_traducida))
-
-#           SIEMENS
-# de "A271/47/6 Air - M<field ref="0" /> - Necessaria Manutenzione Filtro" -> [271,47,6]
-# Obtener la secuencias de dígitos por [[digits]]
-def obtener_digitos_celda_original_siemens(celda_original):
-    if pd.isnull(celda_original):
-        return []
-    
-    # Primero, reemplazamos temporalmente el contenido de los tags con un marcador
-    texto_sin_tags = re.sub(r'<[^>]*>', '<<TAG>>', str(celda_original))
-    
-    # Ahora buscamos los dígitos
-    digitos = re.findall(r'\d+', texto_sin_tags)
-    
-    return digitos
-
-#           SIEMENS
-#                                           Original                                                                  Traducida
-# Transforma:              "A271/47/6 Air - M<field ref="0" /> - Necessaria Manutenzione Filtro" , "A<>/<>/<> Air - M<#> - Filter Maintenance Required" ->
-#                          "A271/47/6 Air - M<field ref="0" /> - Necessaria Manutenzione Filtro"
-#
-# 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)
-    celda_destino = celda_traducida
-    
-    # Replace <> with digits
-    for d in digitos:
-        celda_destino = celda_destino.replace("<>", d, 1)
-    
-    # Replace <#> with original content within <>
-    original_tags = re.findall(r"<.*?>", celda_original)
-    translated_tags = re.findall(r"<#>", celda_destino)
-    
-    for orig, trans in zip(original_tags, translated_tags):
-        celda_destino = celda_destino.replace(trans, orig, 1)
-    
-    return celda_destino
-
-
-#
-#           SIEMENS
-#
-def verificar_celda_traducida_siemens(celda_clave, celda_traducida):
-    # Contar los placeholders de dígitos
-    digitos_clave = celda_clave.count("[[digits]]")
-    digitos_traducida = celda_traducida.count("<>")
-    
-    # Contar los placeholders de tags
-    tags_clave = sum(1 for tag in re.findall(r"<.*?>", celda_clave) if tag != "[[digits]]")
-    tags_traducida = celda_traducida.count("<#>")
-    
-    # Verificar si las cantidades coinciden
-    if digitos_clave == digitos_traducida and tags_clave == tags_traducida:
-        return True , ""
-    else:
-        text_error = f"Error de verificación:" + f" - Celda clave: {celda_clave}" + f" - Celda traducida: {celda_traducida}"
-        text_error += f" - Dígitos en clave: {digitos_clave}, Dígitos en traducida: {digitos_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"
-#
-# Este procesamiento se aplica a las celdas clave
-def compactar_celda_clave_ab(celda_original):
-    if pd.isnull(celda_original):
-        return 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))
-
-
-#           ALLEN BRADLEY
-# Transforma: "A[[digits]]/[[digits]]/[[digits]] Air - M/*field ref="[[digits]]" */ - Necessaria Manutenzione Filtro" ->
-#             "A<>/<>/<> Air - M/*#*/ - Necessaria Manutenzione Filtro"
-#
-# Este procesamiento se aplica a las celdas traducidas
-def compactar_celda_traducida_ab(celda_traducida):
-    if pd.isnull(celda_traducida):
-        return celda_traducida
-    celda_traducida = compactar_celda_clave_ab(celda_traducida)
-
-    def reemplazar(match):
-        if match.group(1):  # Si hay contenido dentro de /*...*/
-            return "/*#*/"
-        return "<>"
-
-    # Reemplaza /*...*/ con /*#*/ y [[digits]] con <>
-    return re.sub(r"/\*(.*?)\*/|\[\[digits\]\]", reemplazar, str(celda_traducida))
-
-
-#           ALLEN BRADLEY
-# De "A271/47/6 Air - M/*field ref="0" */ - Necessaria Manutenzione Filtro" -> [271,47,6]
-# Obtener las secuencias de dígitos para [[digits]]
-def obtener_digitos_celda_original_ab(celda_original):
-    if pd.isnull(celda_original):
-        return []
-
-    # Reemplazamos temporalmente el contenido de los comentarios con un marcador
-    texto_sin_tags = re.sub(r'/\*[^*]*\*/', '<<TAG>>', str(celda_original))
-
-    # Ahora buscamos los dígitos
-    digitos = re.findall(r'\d+', texto_sin_tags)
-
-    return digitos
-
-
-#           ALLEN BRADLEY
-# Transformación para regresar al valor original
-def decompactar_celda_traducida_ab(celda_original, celda_traducida):
-    digitos = obtener_digitos_celda_original_ab(celda_original)
-    celda_destino = celda_traducida
-
-    # Reemplaza <> con dígitos
-    for d in digitos:
-        celda_destino = celda_destino.replace("<>", d, 1)
-
-    # Reemplaza /*#*/ con el contenido original dentro de /*...*/
-    original_tags = re.findall(r"/\*.*?\*/", celda_original)
-    translated_tags = re.findall(r"/\*#\*/", celda_destino)
-
-    for orig, trans in zip(original_tags, translated_tags):
-        celda_destino = celda_destino.replace(trans, orig, 1)
-
-    return celda_destino
-
-
-#
-#           ALLEN BRADLEY
-#
-def verificar_celda_traducida_ab(celda_clave, celda_traducida):
-    # Contar los placeholders de dígitos
-    digitos_clave = celda_clave.count("[[digits]]")
-    digitos_traducida = celda_traducida.count("<>")
-
-    # Contar los placeholders de comentarios
-    tags_clave = sum(1 for tag in re.findall(r"/\*.*?\*/", celda_clave) if tag != "[[digits]]")
-    tags_traducida = celda_traducida.count("/*#*/")
-
-    # Verificar si las cantidades coinciden
-    if digitos_clave == digitos_traducida and tags_clave == tags_traducida:
-        return True, ""
-    else:
-        text_error = f"Error de verificación:" + f" - Celda clave: {celda_clave}" + f" - Celda traducida: {celda_traducida}"
-        text_error += f" - Dígitos en clave: {digitos_clave}, Dígitos en traducida: {digitos_traducida}"
-        text_error += f" - Comentarios en clave: {tags_clave}, Comentarios en traducida: {tags_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_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_siemens(celda_original)))
-    print("Celda          : " + decompactar_celda_traducida_siemens(celda_original, celda_tradc))
-    print("Celda Original : " + celda_original)
-
-    print(verificar_celda_traducida_siemens(celda_clave=celda_clave, celda_traducida= celda_tradc))
-
-    # ALLEN BRADLEY
-    print("****************** ALLEN BRADLEY ***************************")
-    celda_original = 'A271/47/6 /*N:4 {#1.#4.VFix[1]} NOFILL DP:1*/   m/min SPEED'
-
-    celda_clave = compactar_celda_clave_ab(celda_original)
-    celda_tradc = compactar_celda_traducida_ab(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_ab(celda_original)))
-    print("Celda          : " + decompactar_celda_traducida_ab(celda_original, celda_tradc))
-    print("Celda Original : " + celda_original)
-
-    print(verificar_celda_traducida_ab(celda_clave=celda_clave, celda_traducida= celda_tradc))

manejoArchivos.py

@@ -1,50 +0,0 @@
-import pandas as pd
-import tkinter as tk
-from tkinter import filedialog
-import os
-import subprocess
-
-def select_file(extension = "txt"):
-    """
-    Opens a file dialog to select a .db file and returns the selected file path.
-    """
-    root = tk.Tk()
-    root.withdraw()  # Use to hide the tkinter root window
-
-    # Open file dialog and return the selected file path
-    file_path = filedialog.askopenfilename(
-        title=f"Select a .{extension} file",
-        filetypes=((f"{extension} files", f"*.{extension}"), ("All files", "*.*"))
-    )
-    return file_path
-
-def open_file_explorer(path):
-    """
-    Opens the file explorer at the given path, correctly handling paths with spaces.
-    """
-    # Normalize the path to ensure it's in the correct format
-    normalized_path = os.path.normpath(path)
-
-    # Check if the path is a directory or a file and format the command accordingly
-    if os.path.isdir(normalized_path):
-        # If it's a directory, use the 'explorer' command directly
-        command = f'explorer "{normalized_path}"'
-    else:
-        # If it's a file, use the 'explorer /select,' command to highlight the file in its folder
-        command = f'explorer /select,"{normalized_path}"'
-
-    # Execute the command using subprocess.run, with shell=True to handle paths with spaces correctly
-    subprocess.run(command, shell=True)
-
-def select_directory():
-    """
-    Opens a file dialog to select a directory and returns the selected directory path.
-    """
-    root = tk.Tk()
-    root.withdraw()  # Use to hide the tkinter root window
-
-    # Open directory dialog and return the selected directory path
-    directory_path = filedialog.askdirectory(
-        title="Select a directory"
-    )
-    return directory_path

menu_pasos_traduccion.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 from tkinter import ttk
 from tkinter import messagebox
-import funciones_comunes as fc
+from ...Library.Python import funciones_comunes as fc
 import x1_importar_to_master
 import x2_master_export2translate
 import x3_llm_auto_translate

x1_importar_to_master.py

@@ -1,8 +1,7 @@
 import pandas as pd
 import os
 import re
-from manejoArchivos import select_file
+from ...Library.Python import funciones_comunes as fc
-import funciones_comunes as fc
 
 def preprocesar_importacion(tipo_PLC, codigo_columna_maestra, df_importacion):
     # Iterar sobre las filas del DataFrame de importación
@@ -87,7 +86,7 @@ def importar(tipo_PLC, codigo_columna_maestra, archivo_maestro, archivo_importac
 def run(tipo_PLC, codigo_columna_maestra) :
     # Cargar el archivo maestro y el archivo de importación
     archivo_maestro = f".\\data\\1_hmi_master_translates_{tipo_PLC}.xlsx"
-    archivo_importacion = select_file("xlsx")
+    archivo_importacion = fc.select_file("xlsx")
     if archivo_importacion:
         importar(tipo_PLC, codigo_columna_maestra, archivo_maestro, archivo_importacion)
    

x2_master_export2translate.py

@@ -1,7 +1,6 @@
 import pandas as pd
 import os
-from manejoArchivos import select_file
+from ...Library.Python import funciones_comunes as fc
-import funciones_comunes as fc
 
 def exportar_para_traduccion(tipo_PLC, archivo_maestro, target_lang_code):
     if not os.path.exists(archivo_maestro):

x3_llm_auto_translate.py

@@ -10,7 +10,7 @@ from google.cloud import translate_v2 as translate
 from google.oauth2 import service_account
 import html
 from tqdm import tqdm
-import funciones_comunes as fc
+from ...Library.Python import funciones_comunes as fc
 import time
 
 

x4_integrate_translates_to_master.py

@@ -1,9 +1,8 @@
-import funciones_comunes as fc
+from ...Library.Python import funciones_comunes as fc
 import pandas as pd
 import os
 import re
 import logging
-from manejoArchivos import select_file
 
 def revertir_transformaciones(texto, digitos, secciones):
     # Revertir <> a [[digits]]

x5_complete_empty_cells_master.py

@@ -1,10 +1,8 @@
-import funciones_comunes as fc
+from ...Library.Python import funciones_comunes as fc
 import pandas as pd
 import os
 import re
 import logging
-from manejoArchivos import select_file
-
 
 def complete_emptys(tipo_PLC, archivo_maestro, target_lang_code, second_lang_code):
     if not os.path.exists(archivo_maestro):

x6_update_from_master.py

@@ -2,8 +2,7 @@ import pandas as pd
 import os
 import re
 import logging
-import funciones_comunes as fc
+from ...Library.Python import funciones_comunes as fc
-from manejoArchivos import select_file
 
 
 def update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang_code):
@@ -70,7 +69,7 @@ def update_from_master(tipo_PLC, archivo_maestro, archivo_to_update, target_lang
 
 def run(tipo_PLC, codigo_columna_maestra, seleccion_idioma) :
     archivo_maestro = f".\\data\\1_hmi_master_translates_{tipo_PLC}.xlsx"
-    archivo_to_update = select_file("xlsx")
+    archivo_to_update = fc.select_file("xlsx")
     if archivo_to_update:
         if seleccion_idioma not in fc.IDIOMAS:
             print("Selección inválida.")