90 lines
3.4 KiB
Python
90 lines
3.4 KiB
Python
import glob
|
|
import logging
|
|
import os
|
|
from itertools import chain, cycle
|
|
|
|
logger = logging.getLogger()
|
|
|
|
|
|
def alterna_valori(*valori: any, ping_pong: bool = False) -> any:
|
|
"""
|
|
Genera una sequenza ciclica di valori, con opzione per una sequenza "ping-pong".
|
|
|
|
Args:
|
|
*valori (any): Uno o più valori da ciclare.
|
|
ping_pong (bool, optional): Se True, la sequenza sarà valori -> valori al contrario.
|
|
Ad esempio, per (1, 2, 3) diventa 1, 2, 3, 2, 1, 2, 3, ...
|
|
Se False, la sequenza è semplicemente ciclica.
|
|
Defaults to False.
|
|
|
|
Yields:
|
|
any: Il prossimo valore nella sequenza ciclica.
|
|
|
|
"""
|
|
if not valori:
|
|
return
|
|
|
|
if ping_pong:
|
|
# Crea la sequenza ping-pong: valori + valori al contrario (senza ripetere primo e ultimo)
|
|
forward = valori
|
|
backward = valori[-2:0:-1] # Esclude ultimo e primo elemento
|
|
ping_pong_sequence = chain(forward, backward)
|
|
yield from cycle(ping_pong_sequence)
|
|
else:
|
|
yield from cycle(valori)
|
|
|
|
|
|
async def read_error_lines_from_logs(base_path: str, pattern: str) -> tuple[list[str], list[str]]:
|
|
"""
|
|
Reads error and warning lines from log files matching a given pattern within a base path.
|
|
|
|
This asynchronous function searches for log files, reads their content, and categorizes
|
|
lines starting with 'Error' as errors and all other non-empty lines as warnings.
|
|
|
|
Args:
|
|
base_path (str): The base directory where log files are located.
|
|
pattern (str): The glob-style pattern to match log filenames (e.g., "*.txt", "prefix_*_output_error.txt").
|
|
|
|
Returns:
|
|
tuple[list[str], list[str]]: A tuple containing two lists:
|
|
- The first list contains all extracted error messages.
|
|
- The second list contains all extracted warning messages."""
|
|
import aiofiles
|
|
|
|
# Costruisce il path completo con il pattern
|
|
search_pattern = os.path.join(base_path, pattern)
|
|
|
|
# Trova tutti i file che corrispondono al pattern
|
|
matching_files = glob.glob(search_pattern)
|
|
|
|
if not matching_files:
|
|
logger.warning(f"Nessun file trovato per il pattern: {search_pattern}")
|
|
return [], []
|
|
|
|
all_errors = []
|
|
all_warnings = []
|
|
|
|
for file_path in matching_files:
|
|
try:
|
|
# Use async file I/O to prevent blocking the event loop
|
|
async with aiofiles.open(file_path, encoding="utf-8") as file:
|
|
content = await file.read()
|
|
lines = content.splitlines()
|
|
# Usando dict.fromkeys() per mantenere l'ordine e togliere le righe duplicate per i warnings
|
|
non_empty_lines = [line.strip() for line in lines if line.strip()]
|
|
|
|
# Fix: Accumulate errors and warnings from all files instead of overwriting
|
|
file_errors = [line for line in non_empty_lines if line.startswith("Error")]
|
|
file_warnings = [line for line in non_empty_lines if not line.startswith("Error")]
|
|
|
|
all_errors.extend(file_errors)
|
|
all_warnings.extend(file_warnings)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Errore durante la lettura del file {file_path}: {e}")
|
|
|
|
# Remove duplicates from warnings while preserving order
|
|
unique_warnings = list(dict.fromkeys(all_warnings))
|
|
|
|
return all_errors, unique_warnings
|