# ANSI AMARILLO = "\033[94m" ROJO = "\033[91m" RESET = "\033[0m" import locale import platform from datetime import datetime, timedelta, timezone # Intentar establecer el locale al español try: locale.setlocale(locale.LC_TIME, 'es_MX.utf8') except: try: locale.setlocale(locale.LC_TIME, 'Spanish_Mexico') except: pass # Si no se puede, se queda en inglés # Detectar si estamos en Windows es_windows = platform.system() == "Windows" # Diccionario de traducción manual de meses al español MESES_ES = { "January": "enero", "February": "febrero", "March": "marzo", "April": "abril", "May": "mayo", "June": "junio", "July": "julio", "August": "agosto", "September": "septiembre", "October": "octubre", "November": "noviembre", "December": "diciembre" } def interpretar_fecha_taf(cadena_taf, desfase_horario=-6): dia = int(cadena_taf[:2]) hora = int(cadena_taf[2:4]) minuto = int(cadena_taf[4:6]) fecha_actual = datetime.now(timezone.utc) año = fecha_actual.year mes = fecha_actual.month zona_utc = timezone.utc try: fecha_utc = datetime(año, mes, dia, hora, minuto, tzinfo=zona_utc) except ValueError: # Si el día es inválido, asumimos que es del mes anterior if mes == 1: mes = 12 año -= 1 else: mes -= 1 fecha_utc = datetime(año, mes, dia, hora, minuto, tzinfo=zona_utc) # Convertir a hora local zona_local = timezone(timedelta(hours=desfase_horario)) fecha_local = fecha_utc.astimezone(zona_local) # Formato de fecha if es_windows: formato = "%#d de %B del %Y a las %#I:%M %p" else: formato = "%-d de %B del %Y a las %-I:%M %p" # Formatear fecha_formateada = fecha_local.strftime(formato) # Reemplazar nombre del mes si está en inglés for mes_en, mes_es in MESES_ES.items(): if mes_en in fecha_formateada: fecha_formateada = fecha_formateada.replace(mes_en, mes_es) break return fecha_formateada.lower() def obtener_taf_y_guardar(icao='MMAA'): url = f"https://aviationweather.gov/api/data/taf?ids={icao}&format=raw" response = requests.get(url) if response.status_code == 200: taf_data = response.text.strip() return taf_data else: raise Exception(f"Error al obtener TAF: {response.status_code}") def interpretar_validez_taf(cadena_validez, desfase_horario=-6): # Diccionario de traducción manual de meses al español MESES_ES = { "January": "enero", "February": "febrero", "March": "marzo", "April": "abril", "May": "mayo", "June": "junio", "July": "julio", "August": "agosto", "September": "septiembre", "October": "octubre", "November": "noviembre", "December": "diciembre" } # Separar inicio y fin (formato DDHH/DDHH) inicio_str, fin_str = cadena_validez.split('/') dia_ini, hora_ini = int(inicio_str[:2]), int(inicio_str[2:]) dia_fin, hora_fin = int(fin_str[:2]), int(fin_str[2:]) # Ajustar si hora es 24 -> hora 0 y día + 1 if hora_ini == 24: hora_ini = 0 dia_ini += 1 if hora_fin == 24: hora_fin = 0 dia_fin += 1 # Obtener año y mes actuales (UTC) ahora = datetime.now(timezone.utc) año, mes = ahora.year, ahora.month # Crear datetime en UTC con corrección por mes inválido utc = timezone.utc try: inicio_utc = datetime(año, mes, dia_ini, hora_ini, 0, tzinfo=utc) except ValueError: if mes == 1: mes_inicio = 12 año_inicio = año - 1 else: mes_inicio = mes - 1 año_inicio = año inicio_utc = datetime(año_inicio, mes_inicio, dia_ini, hora_ini, 0, tzinfo=utc) try: fin_utc = datetime(año, mes, dia_fin, hora_fin, 0, tzinfo=utc) except ValueError: if mes == 1: mes_fin = 12 año_fin = año - 1 else: mes_fin = mes - 1 año_fin = año fin_utc = datetime(año_fin, mes_fin, dia_fin, hora_fin, 0, tzinfo=utc) # Convertir a hora local zona_local = timezone(timedelta(hours=desfase_horario)) inicio_local = inicio_utc.astimezone(zona_local) fin_local = fin_utc.astimezone(zona_local) # Formato de salida es_windows = platform.system() == "Windows" if es_windows: formato = "%#d de %B a las %#I:%M %p" else: formato = "%-d de %B a las %-I:%M %p" inicio_formato = inicio_local.strftime(formato) fin_formato = fin_local.strftime(formato) # Traducir nombres de meses for mes_en, mes_es in MESES_ES.items(): if mes_en in inicio_formato: inicio_formato = inicio_formato.replace(mes_en, mes_es) if mes_en in fin_formato: fin_formato = fin_formato.replace(mes_en, mes_es) # Reemplazar am/pm por estilo español inicio_formato = inicio_formato.replace("AM", "a. m.").replace("PM", "p. m.").replace("am", "a. m.").replace("pm", "p. m.") fin_formato = fin_formato.replace("AM", "a. m.").replace("PM", "p. m.").replace("am", "a. m.").replace("pm", "p. m.") return f"del {inicio_formato.lower()} al {fin_formato.lower()}" def interpretar_viento_taf(viento): ROJO = "\033[91m" RESET = "\033[0m" if viento == '00000KT': return "Vientos en calma" tiene_rachas = "G" in viento # Detectar si dirección es variable if viento.startswith("VRB"): direccion = "variable" if tiene_rachas: velocidad = int(viento[3:5]) * 1.852 rachas = int(viento.split("G")[1][0:2]) * 1.852 else: velocidad = int(viento[3:5]) * 1.852 rachas = None else: grados = int(viento[0:3]) if len(viento) >= 8 and tiene_rachas: velocidad = int(viento[3:5]) * 1.852 rachas = int(viento.split("G")[1][0:2]) * 1.852 elif len(viento) >= 8: velocidad = int(viento[3:6]) * 1.852 rachas = None else: velocidad = int(viento[3:5]) * 1.852 rachas = None # Dirección cardinal if grados == 0: direccion = "norte" elif grados < 90: direccion = "noreste" elif grados == 90: direccion = "este" elif grados < 180: direccion = "sureste" elif grados == 180: direccion = "sur" elif grados < 270: direccion = "suroeste" elif grados == 270: direccion = "oeste" else: direccion = "noroeste" velocidad = int(velocidad) if rachas: rachas = int(rachas) # Escala Beaufort simplificada if velocidad <= 2: descripcion = "calmados" elif velocidad <= 5: descripcion = "suaves" elif velocidad <= 12: descripcion = "suaves" elif velocidad <= 20: descripcion = "moderados" elif velocidad <= 29: descripcion = "moderados" elif velocidad <= 39: descripcion = "vivos" elif velocidad <= 61: descripcion = "fuertes" elif velocidad <= 87: descripcion = "muy fuertes" elif velocidad <= 116: descripcion = "masivos" else: descripcion = "huracanados" # Construir mensaje base con la preposición correcta if direccion == "variable": mensaje = f"Vientos {descripcion} con dirección variable a {velocidad} kilómetros por hora" else: mensaje = f"Vientos {descripcion} del {direccion} a {velocidad} kilómetros por hora" if rachas: mensaje += f" con rachas de {rachas} kilómetros por hora" if velocidad >= 13 or tiene_rachas: mensaje = ROJO + "⚠️" + mensaje + RESET return mensaje def interpretar_visibilidad_taf(vis): visibilidad_reportable = { "0SM": "0 km", "1/16SM": "0.1 km", "1/8SM": "0.2 km", "3/16SM": "0.3 km", "1/4SM": "0.4 km", "5/16SM": "0.5 km", "3/8SM": "0.6 km", "1/2SM": "0.8 km", "5/8SM": "1 km", "3/4SM": "1.2 km", "7/8SM": "1.4 km", "1SM": "1.6 km", "1 1/8SM": "1.8 km", "1 1/4SM": "2 km", "1 3/8SM": "2.2 km", "1 1/2SM": "2.4 km", "1 5/8SM": "2.6 km", "1 3/4SM": "2.8 km", "1 7/8SM": "3 km", "2SM": "3.2 km", "2": "3.2 km", "2 1/4SM": "3.6 km", "2 1/2SM": "4 km", "2 3/4SM": "4.4 km", "3SM": "4.8 km", "4SM": "6.4 km", "5SM": "8 km", "6SM": "9.6 km"} if vis[0] == 'P': visibilidad = visibilidad_reportable[vis[1:]] return "la visibilidad horizontal es mayor a " + visibilidad else: visibilidad = visibilidad_reportable[vis] return "la visibilidad horizontal es de " +visibilidad # tiempo signficativo presente def traducir_tiempo_significativo_taf(lista_taf): diccionario = { # Precipitación "-DZ": "llovizna ligera", "DZ": "llovizna moderada", "+DZ": "llovizna fuerte", "FZDZ": "llovizna helada", "-RA": "lluvia ligera", "RA": "lluvia moderada", "+RA": "lluvia fuerte", "SHRA": "chubascos de lluvia", "-SN": "nieve ligera", "SN": "nieve moderada", "+SN": "nieve fuerte", "DRSN": "nieve arrastrada por viento", "BLSN": "nieve levantada por viento", "SHSN": "chubascos de nieve", "TSSN": "tormenta eléctrica con nieve", "SG": "granitos de nieve", "-SG": "granitos de nieve ligeros", "+SG": "granitos de nieve intensos", "IC": "cristales de hielo", "-PE": "pelotitas de hielo ligeras", "PE": "pelotitas de hielo moderadas", "+PE": "pelotitas de hielo fuertes", "SHPE": "chubascos de pelotitas de hielo", "TSPE": "tormenta eléctrica con pelotitas de hielo", "GR": "granizo", "SHGR": "chubascos de granizo", "TSGR": "tormenta eléctrica con granizo", "GS": "granizo pequeño", "SHGS": "chubascos de granizo pequeño", "TSGS": "tormenta eléctrica con granizo pequeño", # Tormentas y chubascos "TS": "tormenta eléctrica", "VCTS": "tormenta eléctrica en la vecindad", "-TSRA": "tormenta eléctrica con lluvia ligera", "TSRA": "tormenta eléctrica con lluvia moderada", "+TSRA": "tormenta eléctrica con lluvia fuerte", "-TSSN": "tormenta eléctrica con nieve ligera", "+TSSN": "tormenta eléctrica con nieve fuerte", # Obscurecimiento "BR": "neblina", "FG": "niebla", "VCFG": "niebla en la vecindad", "MIFG": "niebla superficial", "PRFG": "niebla parcial", "BCFG": "bancos de niebla", "FZFG": "niebla helada", "FU": "humo", "VA": "cenizas volcánicas", "VCVA": "cenizas volcánicas en la vecindad", "DU": "polvo", "DRDU": "polvo arrastrado por viento", "BLDU": "polvo levantado por viento", "SA": "arena", "DRSA": "arena arrastrada", "BLSA": "arena levantada por viento", "HZ": "bruma", "PY": "rocío de hielo", "BLPY": "rocío de hielo levantado", # Levantamientos por viento "VCBLSN": "nieve levantada en la vecindad", "VCBLSA": "arena levantada en la vecindad", "VCBLDU": "polvo levantado en la vecindad", # Otros fenómenos "PO": "remolinos de polvo", "VCPO": "remolinos en la vecindad", "SQ": "turbonadas", "FC": "tromba marina o tornado", "+FC": "tornado intenso", "SS": "tormenta de arena", "+SS": "tormenta de arena intensa", "VCSS": "tormenta de arena en la vecindad", "DS": "tormenta de polvo", "+DS": "tormenta de polvo intensa", "VCDS": "tormenta de polvo en la vecindad", } traducciones = [] i = 0 while i < len(lista_taf): codigo = lista_taf[i] if codigo == "VC": if i + 1 < len(lista_taf): siguiente_codigo = lista_taf[i + 1] traduccion_siguiente = diccionario.get(siguiente_codigo, "") if traduccion_siguiente: traducciones.append(f"{traduccion_siguiente} en la vecindad") i += 2 continue traducciones.append("en la vecindad") elif codigo in diccionario: traducciones.append(diccionario[codigo]) i += 1 return ", ".join(traducciones) if traducciones else "" # Diccionario para traducir día de la semana al español dias_semana = { 0: 'lunes', 1: 'martes', 2: 'miércoles', 3: 'jueves', 4: 'viernes', 5: 'sábado', 6: 'domingo' } def obtener_dia_semana_local(dia, hora_utc): hoy = datetime.now() - timedelta(hours=6) # Ajustamos hora local directamente try: fecha_utc = datetime(hoy.year, hoy.month, dia, hora_utc) except ValueError: if hoy.month == 12: fecha_utc = datetime(hoy.year + 1, 1, dia, hora_utc) else: fecha_utc = datetime(hoy.year, hoy.month + 1, dia, hora_utc) fecha_local = fecha_utc - timedelta(hours=6) # Traducción manual de día de la semana dia_semana_index = fecha_local.weekday() if dia_semana_index == 0: dia_semana = "lunes" elif dia_semana_index == 1: dia_semana = "martes" elif dia_semana_index == 2: dia_semana = "miércoles" elif dia_semana_index == 3: dia_semana = "jueves" elif dia_semana_index == 4: dia_semana = "viernes" elif dia_semana_index == 5: dia_semana = "sábado" else: dia_semana = "domingo" return fecha_local.day, fecha_local.hour, dia_semana def formatear_hora(hora): if hora == 0: return "12:00 am" elif hora < 12: return f"{hora}:00 am" elif hora == 12: return "12:00 pm" else: return f"{hora - 12}:00 pm" def obtener_temperatura_maxima(lista): for item in lista: if item.startswith("TX"): temp = int(item[2:4]) dia = int(item[5:7]) hora = int(item[7:9]) dia_local, hora_local, dia_semana = obtener_dia_semana_local(dia, hora) hora_str = formatear_hora(hora_local) return f"Temperatura máxima: {temp} grados centígrados, el {dia_semana} {dia_local} a las {hora_str}" return "Temperatura máxima No disponible" def obtener_temperatura_minima(lista): for item in lista: if item.startswith("TN"): temp = int(item[2:4]) dia = int(item[5:7]) hora = int(item[7:9]) dia_local, hora_local, dia_semana = obtener_dia_semana_local(dia, hora) hora_str = formatear_hora(hora_local) return f"Temperatura mínima: {temp} grados centígrados, el {dia_semana} {dia_local} a las {hora_str}" return "Temperatura minima No disponible" def interpretar_cobertura_nubosa(lista): lineas = [] for item in lista: for prefijo in ["VV", "SKC", "FEW", "SCT", "BKN", "OVC"]: if item.startswith(prefijo): if prefijo == "VV": descripcion = "Visibilidad vertical" lineas.append(descripcion) break elif prefijo == "SKC": descripcion = "Cielo despejado" lineas.append(descripcion) break elif prefijo == "FEW": descripcion = "Cielo con algunas nubes" elif prefijo == "SCT": descripcion = "Cielo medio nublado" elif prefijo == "BKN": descripcion = "Cielo nublado" elif prefijo == "OVC": descripcion = "Cielo cerrado" altura_txt = item[len(prefijo):len(prefijo)+3] tipo_nube = item[len(prefijo)+3:] try: altura_cientos = int(altura_txt) if altura_cientos < 65: capa = "con nubes bajas" elif altura_cientos <= 200: capa = "con nubes medias" else: capa = "con nubes altas" except ValueError: capa = "" if "CB" in tipo_nube: tipo_nube_es = " del tipo cumulonimbus" elif "TCU" in tipo_nube: tipo_nube_es = " del tipo cúmulos desarrollados verticalmente" else: tipo_nube_es = "" linea = f"{descripcion} {capa}{tipo_nube_es}".strip() lineas.append(linea) break return lineas def interpretar_y_segmentar_taf(lista_palabras): explicaciones = { "TEMPO": "Cambio temporal en el pronóstico.", "FM": "Cambio rápido y sostenido en el pronóstico.", "BECMG": "Cambio gradual en el pronóstico.", "PROB": "Probabilidad de que ocurran ciertas condiciones en el pronóstico." } descripciones = [] segmentos = [] bloque_actual = [] for palabra in lista_palabras: es_cambio = False for clave in explicaciones: if palabra.startswith(clave): if bloque_actual: segmentos.append(bloque_actual) bloque_actual = [palabra] if explicaciones[clave] not in descripciones: descripciones.append(explicaciones[clave]) es_cambio = True break if not es_cambio: bloque_actual.append(palabra) if bloque_actual: segmentos.append(bloque_actual) return descripciones, segmentos def imprimir_pronostico_con_tabla(TAF, bloques, filas): import re TAF = bloques[0] cambios = { "COR": "CORREGIDO", "AMD": "MODIFICADO POR CAMBIOS IMPORTANTES", "RTD": "RETRASADO", "CNL": "CANCELADO", "NIL": "NO DISPONIBLE" } U = { "MMAA": "Areopuerto internacional de Acapulco de Juarez", "MMZH": "Aeropuerto Internacional de Zihuatanejo", "MMMX": "Aeropuerto internacional Benito Juarez" } AMARILLO = "\033[30m" ROJO = "\033[91m" RESET = "\033[0m" AZUL = "\033[94m" def limpiar_ansi(texto): return re.sub(r'\033\[[0-9;]*m', '', texto) pronostico = "PRONÓSTICO METEOROLÓGICO AERONÁUTICO" for clave, valor in cambios.items(): if clave in TAF: pronostico += f" {valor}" TAF.remove(clave) break encabezado_raw = [ f"Ubicación: {U.get(TAF[1], TAF[1])}", f"Realización: {interpretar_fecha_taf(TAF[2])}", f"Validez: {interpretar_validez_taf(TAF[3])}", obtener_temperatura_maxima(TAF), obtener_temperatura_minima(TAF), interpretar_viento_taf(TAF[4]), f"Visibilidad horizontal: {interpretar_visibilidad_taf(TAF[5])}" ] fenomeno = traducir_tiempo_significativo_taf(TAF) if fenomeno: encabezado_raw.append(f"{ROJO}⚠️Presencia de {fenomeno}{RESET}") encabezado_raw.extend(interpretar_cobertura_nubosa(TAF)) # Cálculo de anchos reales encabezado_limpio = [limpiar_ansi(f"• {linea}") for linea in encabezado_raw] ancho_encabezado = max(len(linea) for linea in encabezado_limpio) ancho_col1 = max(len("Tipo de cambio"), max(len(limpiar_ansi(f[0])) for f in filas)) ancho_col2 = max( len("Detalles"), max(len(limpiar_ansi("• " + linea)) for f in filas for linea in f[1].splitlines()) ) ancho_tabla = ancho_col1 + ancho_col2 + 7 ancho_total = max(ancho_encabezado + 6, ancho_tabla) # Parte superior print("╔" + "═" * (ancho_total - 2) + "╗") print(f"║{AMARILLO}{pronostico:^{ancho_total - 2}}{RESET}║") print("╠" + "═" * (ancho_total - 2) + "╣") for linea in encabezado_raw: texto = f"• {linea}" texto_limpio = limpiar_ansi(texto) print(f"║ {AMARILLO}{texto}{RESET}{' ' * (ancho_total - len(texto_limpio) - 4)} ║") # Tabla de cambios print("╠" + "═" * (ancho_col1 + 2) + "╦" + "═" * (ancho_col2 + 2) + "╣") print(f"║ {AMARILLO}{'Tipo de cambio':<{ancho_col1}}{RESET} ║ {AMARILLO}{'Detalles':<{ancho_col2}}{RESET} ║") print("╠" + "═" * (ancho_col1 + 2) + "╬" + "═" * (ancho_col2 + 2) + "╣") for i, (tipo, detalle) in enumerate(filas): lineas = detalle.splitlines() # Primera línea (puede contener ANSI azul) linea0_limpia = limpiar_ansi(lineas[0]) relleno0 = ' ' * (ancho_col2 - len(linea0_limpia)) print(f"║ {AMARILLO}{tipo:<{ancho_col1}}{RESET} ║ {lineas[0]}{relleno0} ║") # Líneas siguientes con viñeta for linea in lineas[1:]: texto_limpio = limpiar_ansi(f"• {linea}") relleno = ' ' * (ancho_col2 - len(texto_limpio)) print(f"║ {'':<{ancho_col1}} ║ {AMARILLO}• {linea}{RESET}{relleno} ║") if i != len(filas) - 1: print("╠" + "═" * (ancho_col1 + 2) + "╬" + "═" * (ancho_col2 + 2) + "╣") print("╚" + "═" * (ancho_col1 + 2) + "╩" + "═" * (ancho_col2 + 2) + "╝") # Créditos credito = "Elaborado por: " + U.get(TAF[1], TAF[1]) print("╔" + "═" * (ancho_total - 2) + "╗") print(f"║{AMARILLO}{credito:^{ancho_total - 2}}{RESET}║") print("╚" + "═" * (ancho_total - 2) + "╝") TAF = obtener_taf_y_guardar("MMAA") # Paso 1: limpiar espacios dobles TAF = ' '.join(TAF.split()) # Paso 2: convertir a lista lista_palabras = TAF.split() # Paso 3: aplicar función descripciones, bloques = interpretar_y_segmentar_taf(lista_palabras) TAF = bloques[0] # Generar las filas de la tabla de cambios filas = [] AZUL = "\033[94m" for bloque in bloques: primera_palabra = bloque[0] if primera_palabra.startswith("TEMPO"): detalle = f"{AZUL}Cambio temporal en el pronóstico{RESET}\n" detalle += "Validez: " + interpretar_validez_taf(bloque[1]) for palabra in bloque: if "KT" in palabra: detalle += f"\n{interpretar_viento_taf(palabra)}" break for palabra in bloque: if "SM" in palabra: detalle += f"\n{interpretar_visibilidad_taf(palabra)}" break fenomeno = traducir_tiempo_significativo_taf(bloque) if fenomeno: detalle += f"\n{ROJO}⚠️Presencia de {fenomeno}{RESET}" if any(p.startswith(("VV", "SKC", "FEW", "SCT", "BKN", "OVC")) for p in bloque): capas = interpretar_cobertura_nubosa(bloque) for capa in capas: detalle += f"\n{capa}" filas.append(("TEMPO", detalle)) elif primera_palabra.startswith("FM"): detalle = f"{AZUL}Cambio rápido y sostenido en el pronóstico{RESET}\n" detalle += "Inicio del cambio: " + interpretar_fecha_taf(bloque[0][2:]) for palabra in bloque: if "KT" in palabra: detalle += f"\n{interpretar_viento_taf(palabra)}" break for palabra in bloque: if "SM" in palabra: detalle += f"\n{interpretar_visibilidad_taf(palabra)}" break fenomeno = traducir_tiempo_significativo_taf(bloque) if fenomeno: detalle += f"\n{ROJO}⚠️Presencia de {fenomeno}{RESET}" if any(p.startswith(("VV", "SKC", "FEW", "SCT", "BKN", "OVC")) for p in bloque): capas = interpretar_cobertura_nubosa(bloque) for capa in capas: detalle += f"\n{capa}" filas.append(("FM", detalle)) elif primera_palabra.startswith("BECMG"): detalle = f"{AZUL}Cambio gradual en el pronóstico{RESET}\n" detalle += "Se dará gradualmente del: " + interpretar_validez_taf(bloque[1]) for palabra in bloque: if "KT" in palabra: detalle += f"\n{interpretar_viento_taf(palabra)}" break for palabra in bloque: if "SM" in palabra: detalle += f"\n{interpretar_visibilidad_taf(palabra)}" break fenomeno = traducir_tiempo_significativo_taf(bloque) if fenomeno: detalle += f"\n{ROJO}⚠️Presencia de {fenomeno}{RESET}" if any(p.startswith(("VV", "SKC", "FEW", "SCT", "BKN", "OVC")) for p in bloque): capas = interpretar_cobertura_nubosa(bloque) for capa in capas: detalle += f"\n{capa}" filas.append(("BECMG", detalle)) elif primera_palabra.startswith("PROB40"): detalle = f"{AZUL}Probabilidad del 40% de condiciones{RESET}\n" detalle += "Validez: " + interpretar_validez_taf(bloque[1]) for palabra in bloque: if "KT" in palabra: detalle += f"\n{interpretar_viento_taf(palabra)}" break for palabra in bloque: if "SM" in palabra: detalle += f"\n{interpretar_visibilidad_taf(palabra)}" break fenomeno = traducir_tiempo_significativo_taf(bloque) if fenomeno: detalle += f"\n{ROJO}⚠️Presencia de {fenomeno}{RESET}" if any(p.startswith(("VV", "SKC", "FEW", "SCT", "BKN", "OVC")) for p in bloque): capas = interpretar_cobertura_nubosa(bloque) for capa in capas: detalle += f"\n{capa}" filas.append(("PROB40", detalle)) elif primera_palabra.startswith("PROB30"): detalle = f"{AZUL}Probabilidad del 30% de condiciones{RESET}\n" detalle += "Validez: " + interpretar_validez_taf(bloque[1]) for palabra in bloque: if "KT" in palabra: detalle += f"\n{interpretar_viento_taf(palabra)}" break for palabra in bloque: if "SM" in palabra: detalle += f"\n{interpretar_visibilidad_taf(palabra)}" break fenomeno = traducir_tiempo_significativo_taf(bloque) if fenomeno: detalle += f"\n{ROJO}⚠️Presencia de {fenomeno}{RESET}" if any(p.startswith(("VV", "SKC", "FEW", "SCT", "BKN", "OVC")) for p in bloque): capas = interpretar_cobertura_nubosa(bloque) for capa in capas: detalle += f"\n{capa}" filas.append(("PROB30", detalle)) imprimir_pronostico_con_tabla(TAF, bloques, filas) print("Fuente: https://aviationweather.gov/data/taf/?ids=MMAA") print("Asistencia: thewhediaz@gmail.com")