220 lines
9.4 KiB
Python
220 lines
9.4 KiB
Python
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) |