Simatic_XML_Parser_to_SCL/x0_main.py

import argparse
import subprocess
import os
import sys
import locale
import glob # <--- Importar glob para buscar archivos

# (Función get_console_encoding y variable CONSOLE_ENCODING como en la respuesta anterior)
def get_console_encoding():
    """Obtiene la codificación preferida de la consola, con fallback."""
    try:
        return locale.getpreferredencoding(False)
    except Exception:
        return 'cp1252'

CONSOLE_ENCODING = get_console_encoding()
# Descomenta la siguiente línea si quieres ver la codificación detectada:
# print(f"Detected console encoding: {CONSOLE_ENCODING}")

# (Función run_script como en la respuesta anterior, usando CONSOLE_ENCODING)
def run_script(script_name, xml_arg):
    """Runs a given script with the specified XML file argument."""
    script_path = os.path.join(os.path.dirname(__file__), script_name)
    command = [sys.executable, script_path, xml_arg]
    print(f"\n--- Running {script_name} with argument: {xml_arg} ---")
    try:
        result = subprocess.run(command,
                                check=True,
                                capture_output=True,
                                text=True,
                                encoding=CONSOLE_ENCODING,
                                errors='replace') # 'replace' para evitar errores

        # Imprimir stdout y stderr
        # Eliminar saltos de línea extra al final si existen
        stdout_clean = result.stdout.strip()
        stderr_clean = result.stderr.strip()
        if stdout_clean:
            print(stdout_clean)
        if stderr_clean:
            print("--- Stderr ---")
            print(stderr_clean)
            print("--------------")
        print(f"--- {script_name} finished successfully ---")
        return True
    except FileNotFoundError:
        print(f"Error: Script '{script_path}' not found.")
        return False
    except subprocess.CalledProcessError as e:
        print(f"Error running {script_name}:")
        print(f"Return code: {e.returncode}")
        stdout_decoded = e.stdout.decode(CONSOLE_ENCODING, errors='replace').strip() if isinstance(e.stdout, bytes) else (e.stdout or "").strip()
        stderr_decoded = e.stderr.decode(CONSOLE_ENCODING, errors='replace').strip() if isinstance(e.stderr, bytes) else (e.stderr or "").strip()
        if stdout_decoded:
             print("--- Stdout ---")
             print(stdout_decoded)
        if stderr_decoded:
             print("--- Stderr ---")
             print(stderr_decoded)
        print("--------------")
        return False
    except Exception as e:
        print(f"An unexpected error occurred while running {script_name}: {e}")
        return False

# --- NUEVA FUNCIÓN PARA SELECCIONAR ARCHIVO ---
def select_xml_file():
    """Busca archivos .xml, los lista y pide al usuario que elija uno."""
    print("No XML file specified. Searching for XML files in current directory...")
    # Buscar archivos .xml en el directorio actual (.)
    xml_files = sorted(glob.glob('*.xml')) # sorted para orden alfabético

    if not xml_files:
        print("Error: No .xml files found in the current directory.")
        sys.exit(1)

    print("\nAvailable XML files:")
    for i, filename in enumerate(xml_files, start=1):
        print(f"  {i}: {filename}")

    while True:
        try:
            choice = input(f"Enter the number of the file to process (1-{len(xml_files)}): ")
            choice_num = int(choice)
            if 1 <= choice_num <= len(xml_files):
                selected_file = xml_files[choice_num - 1]
                print(f"Selected: {selected_file}")
                return selected_file
            else:
                print("Invalid choice. Please enter a number from the list.")
        except ValueError:
            print("Invalid input. Please enter a number.")
        except EOFError: # Manejar si la entrada se cierra inesperadamente
             print("\nSelection cancelled.")
             sys.exit(1)
# --- FIN NUEVA FUNCIÓN ---


if __name__ == "__main__":
    # Imports necesarios para esta sección
    import os
    import sys
    import glob # Asegúrate de que glob esté importado al principio del archivo

    # Directorio base donde buscar los archivos XML (relativo al script)
    base_search_dir = "XML Project"
    script_dir = os.path.dirname(__file__) # Directorio donde está x0_main.py
    xml_project_dir = os.path.join(script_dir, base_search_dir)

    print(f"Buscando archivos XML recursivamente en: '{xml_project_dir}'")

    # Verificar si el directorio 'XML Project' existe
    if not os.path.isdir(xml_project_dir):
        print(f"Error: El directorio '{xml_project_dir}' no existe o no es un directorio.")
        print("Por favor, crea el directorio 'XML Project' en la misma carpeta que este script y coloca tus archivos XML dentro.")
        sys.exit(1)

    # Buscar todos los archivos .xml recursivamente dentro de xml_project_dir
    # Usamos os.path.join para construir la ruta de búsqueda correctamente
    # y '**/*.xml' para la recursividad con glob
    search_pattern = os.path.join(xml_project_dir, '**', '*.xml')
    xml_files_found = glob.glob(search_pattern, recursive=True)

    if not xml_files_found:
        print(f"No se encontraron archivos XML en '{xml_project_dir}' o sus subdirectorios.")
        sys.exit(0) # Salir limpiamente si no hay archivos

    print(f"Se encontraron {len(xml_files_found)} archivos XML para procesar:")
    # Ordenar para un procesamiento predecible (opcional)
    xml_files_found.sort()
    for xml_file in xml_files_found:
        # Imprimir la ruta relativa desde el directorio del script para claridad
        print(f" - {os.path.relpath(xml_file, script_dir)}")

    # Scripts a ejecutar en secuencia (asegúrate que los nombres son correctos)
    script1 = "x1_to_json.py"
    script2 = "x2_process.py"
    script3 = "x3_generate_scl.py"

    # Procesar cada archivo encontrado
    processed_count = 0
    failed_count = 0
    for xml_filepath in xml_files_found:
        print(f"\n--- Iniciando pipeline para: {os.path.relpath(xml_filepath, script_dir)} ---")

        # Usar la ruta absoluta para evitar problemas si los scripts cambian de directorio
        absolute_xml_filepath = os.path.abspath(xml_filepath)

        # Ejecutar los scripts en secuencia para el archivo actual
        # La función run_script ya está definida en tu script x0_main.py
        success = True
        if not run_script(script1, absolute_xml_filepath):
            print(f"\nPipeline falló en el script '{script1}' para el archivo: {os.path.relpath(xml_filepath, script_dir)}")
            success = False
        elif not run_script(script2, absolute_xml_filepath):
            print(f"\nPipeline falló en el script '{script2}' para el archivo: {os.path.relpath(xml_filepath, script_dir)}")
            success = False
        elif not run_script(script3, absolute_xml_filepath):
            print(f"\nPipeline falló en el script '{script3}' para el archivo: {os.path.relpath(xml_filepath, script_dir)}")
            success = False

        if success:
            print(f"--- Pipeline completado exitosamente para: {os.path.relpath(xml_filepath, script_dir)} ---")
            processed_count += 1
        else:
            failed_count += 1
            print(f"--- Pipeline falló para: {os.path.relpath(xml_filepath, script_dir)} ---")


    print("\n--- Resumen Final del Procesamiento ---")
    print(f"Total de archivos XML encontrados: {len(xml_files_found)}")
    print(f"Archivos procesados exitosamente por el pipeline completo: {processed_count}")
    print(f"Archivos que fallaron en algún punto del pipeline: {failed_count}")
    print("---------------------------------------")
    xml_filename = None

    # Comprobar si se pasó un argumento de línea de comandos
    # sys.argv[0] es el nombre del script, sys.argv[1] sería el primer argumento
    if len(sys.argv) > 1:
        # Si hay argumentos, usar argparse para parsearlo (permite -h, etc.)
        parser = argparse.ArgumentParser(
            description="Run the Simatic XML processing pipeline."
        )
        parser.add_argument(
            "xml_file",
            # Ya no necesitamos nargs='?' ni default aquí porque sabemos que hay un argumento
            help="Path to the XML file to process.",
        )
        # Parsear solo los argumentos conocidos, ignorar extras si los hubiera
        args, unknown = parser.parse_known_args()
        xml_filename = args.xml_file
        print(f"XML file specified via argument: {xml_filename}")
    else:
        # Si no hay argumentos, llamar a la función interactiva
        xml_filename = select_xml_file()

    # --- El resto del script continúa igual, usando xml_filename ---

    # Verificar si el archivo XML de entrada (seleccionado o pasado) existe
    if not os.path.exists(xml_filename):
        print(f"Error: Selected or specified XML file not found: {xml_filename}")
        sys.exit(1)

    print(f"\nStarting pipeline for: {xml_filename}")

    # Run scripts sequentially (asegúrate que los nombres son correctos)
    script1 = "x1_to_json.py"
    script2 = "x2_process.py"
    script3 = "x3_generate_scl.py"

    if run_script(script1, xml_filename):
        if run_script(script2, xml_filename):
            if run_script(script3, xml_filename):
                print("\nPipeline completed successfully.")
            else:
                print("\nPipeline failed at script:", script3)
        else:
            print("\nPipeline failed at script:", script2)
    else:
        print("\nPipeline failed at script:", script1)