forked from JulieChv/Analyse_Reseaux
679 lines
21 KiB
Python
679 lines
21 KiB
Python
import os
|
|
import sys
|
|
import subprocess
|
|
from datetime import datetime
|
|
from threading import Thread
|
|
import tkinter as tk
|
|
from tkinter import ttk, filedialog, messagebox
|
|
from pathlib import Path
|
|
|
|
def make_scrollable(parent):
|
|
canvas = tk.Canvas(parent, highlightthickness=0)
|
|
scrollbar = ttk.Scrollbar(parent, orient="vertical", command=canvas.yview)
|
|
|
|
scrollable_frame = ttk.Frame(canvas)
|
|
|
|
scrollable_frame.bind(
|
|
"<Configure>",
|
|
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
|
|
)
|
|
|
|
canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
|
|
def on_configure(event):
|
|
canvas.itemconfig("frame", width=canvas.winfo_width())
|
|
canvas.create_window((0,0), window=scrollable_frame, anchor="nw", tags="frame")
|
|
canvas.bind("<Configure>", on_configure)
|
|
canvas.configure(yscrollcommand=scrollbar.set)
|
|
|
|
canvas.pack(side="left", fill="both", expand=True)
|
|
scrollbar.pack(side="right", fill="y")
|
|
|
|
canvas.bind_all("<MouseWheel>", lambda e: canvas.yview_scroll(int(-1*(e.delta/120)), "units"))
|
|
|
|
return scrollable_frame
|
|
|
|
class ToolTip:
|
|
def __init__(self, widget, text):
|
|
self.widget = widget
|
|
self.text = text
|
|
self.tipwindow = None
|
|
|
|
widget.bind("<Enter>", self.show)
|
|
widget.bind("<Leave>", self.hide)
|
|
|
|
def show(self, event=None):
|
|
if self.tipwindow or not self.text:
|
|
return
|
|
|
|
x = self.widget.winfo_rootx() + 20
|
|
y = self.widget.winfo_rooty() + 20
|
|
|
|
self.tipwindow = tw = tk.Toplevel(self.widget)
|
|
tw.wm_overrideredirect(True)
|
|
tw.wm_geometry(f"+{x}+{y}")
|
|
|
|
label = tk.Label(
|
|
tw,
|
|
text=self.text,
|
|
justify="left",
|
|
background="#ffffe0",
|
|
relief="solid",
|
|
borderwidth=1,
|
|
font=("Arial", 9),
|
|
padx=8,
|
|
pady=4
|
|
)
|
|
label.pack()
|
|
|
|
def hide(self, event=None):
|
|
if self.tipwindow:
|
|
self.tipwindow.destroy()
|
|
self.tipwindow = None
|
|
|
|
# Contenu fenêtre Analyse Switch Multi
|
|
def open_switch_gui_multi(app, OUTPUT_DIR, HELP_FILE_SW, SWITCH_DIR, SWITCH_MAIN):
|
|
app2 = tk.Toplevel(app)
|
|
app2.title("Analyse Configuration Switch - Plusieurs switch")
|
|
app2.geometry("800x450")
|
|
app2.resizable(True, True)
|
|
|
|
rapport_uplink = tk.BooleanVar()
|
|
schema_infra = tk.BooleanVar()
|
|
rapport_stack = tk.BooleanVar()
|
|
rapport_interfaces = tk.BooleanVar()
|
|
|
|
content = make_scrollable(app2)
|
|
|
|
def open_output_folder():
|
|
if sys.platform == "win32":
|
|
os.startfile(OUTPUT_DIR)
|
|
elif sys.platform == "darwin":
|
|
subprocess.run(["open", OUTPUT_DIR])
|
|
else:
|
|
subprocess.run(["xdg-open", OUTPUT_DIR])
|
|
|
|
def open_help():
|
|
if not os.path.exists(HELP_FILE_SW):
|
|
messagebox.showerror("Erreur", "Le fichier d'aide est introuvable.")
|
|
return
|
|
|
|
if sys.platform == "win32":
|
|
os.startfile(HELP_FILE_SW)
|
|
elif sys.platform == "darwin":
|
|
subprocess.run(["open", HELP_FILE_SW])
|
|
else:
|
|
subprocess.run(["xdg-open", HELP_FILE_SW])
|
|
|
|
def get_selected_switch(vars_dict):
|
|
for sw, var in vars_dict.items():
|
|
if var.get():
|
|
return sw
|
|
return None
|
|
|
|
def run_parser_multi():
|
|
selections = []
|
|
|
|
for name, vars_dict in file_selections.items():
|
|
sw = get_selected_switch(vars_dict)
|
|
if sw:
|
|
selections.append({
|
|
"type": "file",
|
|
"name": name,
|
|
"switch": sw
|
|
})
|
|
|
|
# for name, vars_dict in dir_selections.items():
|
|
# sw = get_selected_switch(vars_dict)
|
|
# if sw:
|
|
# selections.append({
|
|
# "type": "dir",
|
|
# "name": name,
|
|
# "switch": sw
|
|
# })
|
|
|
|
if not selections:
|
|
messagebox.showwarning(
|
|
"Aucune sélection",
|
|
"Veuillez sélectionner au moins un fichier ou dossier."
|
|
)
|
|
return
|
|
|
|
content.config(cursor="watch")
|
|
progress_bar = ttk.Progressbar(content, mode="indeterminate")
|
|
progress_bar.pack(pady=10, fill="x", padx=10)
|
|
progress_bar.start(10)
|
|
|
|
def process():
|
|
try:
|
|
for item in selections:
|
|
input_path = str(INPUT_DIR / item["name"])
|
|
|
|
cmd = [
|
|
sys.executable,
|
|
SWITCH_MAIN,
|
|
item["switch"],
|
|
input_path
|
|
]
|
|
|
|
if rapport_uplink.get():
|
|
cmd.append("-u")
|
|
if schema_infra.get():
|
|
cmd.append("-d")
|
|
if rapport_stack.get():
|
|
cmd.append("-s")
|
|
if rapport_interfaces.get():
|
|
cmd.append("-i")
|
|
|
|
cmd.append("-o")
|
|
if item["type"] == "file":
|
|
base_name = os.path.splitext(item["name"])[0]
|
|
cmd.append(base_name)
|
|
else:
|
|
cmd.append(item["name"])
|
|
|
|
print("Commande exécutée :", " ".join(cmd))
|
|
subprocess.run(cmd, cwd=SWITCH_DIR, check=True)
|
|
|
|
def on_success():
|
|
progress_bar.stop()
|
|
progress_bar.destroy()
|
|
content.config(cursor="")
|
|
messagebox.showinfo("Succès", "Tous les traitements sont terminés.")
|
|
open_output_folder()
|
|
app2.destroy()
|
|
|
|
app2.after(0, on_success)
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
def on_error():
|
|
progress_bar.stop()
|
|
progress_bar.destroy()
|
|
content.config(cursor="")
|
|
messagebox.showerror(
|
|
"Erreur",
|
|
f"Erreur lors de l'exécution du traitement.\n\n{e}"
|
|
)
|
|
|
|
app2.after(0, on_error)
|
|
|
|
Thread(target=process, daemon=True).start()
|
|
|
|
def create_table(parent, title, items, mode):
|
|
"""
|
|
mode = 'file'
|
|
"""
|
|
|
|
style = ttk.Style()
|
|
|
|
style.configure(
|
|
"Table.TFrame",
|
|
background="white",
|
|
borderwidth=1,
|
|
relief="solid"
|
|
)
|
|
|
|
style.configure(
|
|
"Table.TLabel",
|
|
background="white"
|
|
)
|
|
|
|
style.configure(
|
|
"Table.TCheckbutton",
|
|
background="white"
|
|
)
|
|
|
|
style.map(
|
|
"Table.TCheckbutton",
|
|
background=[("disabled", "#f0f0f0")],
|
|
foreground=[("disabled", "#a0a0a0")]
|
|
)
|
|
|
|
ttk.Label(
|
|
parent,
|
|
text=title,
|
|
font=("Arial", 10, "bold")
|
|
).pack(anchor="w", padx=10, pady=(0, 4))
|
|
|
|
table = ttk.Frame(parent, style="Table.TFrame")
|
|
table.pack(fill="x", padx=10)
|
|
|
|
table.columnconfigure(0, weight=1)
|
|
if mode == "file": n = "Fichier source"
|
|
else : n = "Dossier source"
|
|
headers = [n, "HPE"]
|
|
for col, text in enumerate(headers):
|
|
ttk.Label(
|
|
table,
|
|
text=text,
|
|
style="Table.TLabel",
|
|
font=("Arial", 9, "bold")
|
|
).grid(row=0, column=col, padx=8, pady=6, sticky="e" if col > 0 else "w")
|
|
|
|
ttk.Separator(table, orient="horizontal").grid(
|
|
row=1, column=0, columnspan=4, sticky="ew", pady=(0, 2)
|
|
)
|
|
|
|
selections = {}
|
|
grid_row = 2
|
|
|
|
for name in items:
|
|
ttk.Label(
|
|
table,
|
|
text=name,
|
|
style="Table.TLabel"
|
|
).grid(row=grid_row, column=0, sticky="w", padx=8, pady=4)
|
|
|
|
var_hpe = tk.BooleanVar()
|
|
# var_autre = tk.BooleanVar()
|
|
|
|
def make_command(active, others):
|
|
def cmd():
|
|
if active.get():
|
|
for var in others:
|
|
var.set(False)
|
|
return cmd
|
|
|
|
cb_hpe = ttk.Checkbutton(
|
|
table,
|
|
variable=var_hpe,
|
|
style="Table.TCheckbutton",
|
|
command=make_command(var_hpe, [])
|
|
)
|
|
# cb_autre = ttk.Checkbutton(
|
|
# table,
|
|
# variable=var_autre,
|
|
# style="Table.TCheckbutton",
|
|
# command=make_command(var_autre, [var_hpe])
|
|
|
|
cb_hpe.grid(row=grid_row, column=1, sticky="n", padx=8)
|
|
# cb_autre.grid(row=grid_row, column=2, sticky="n", padx=8)
|
|
|
|
# elif mode == "file":
|
|
# cb_autre.state(["disabled"])
|
|
if mode == "dir":
|
|
cb_hpe.state(["disabled"])
|
|
|
|
selections[name] = {
|
|
"HPE": var_hpe,
|
|
# "autre": var_autre
|
|
}
|
|
|
|
# Séparateur interligne
|
|
ttk.Separator(table, orient="horizontal").grid(
|
|
row=grid_row + 1,
|
|
column=0,
|
|
columnspan=4,
|
|
sticky="ew"
|
|
)
|
|
|
|
grid_row += 2
|
|
|
|
return selections
|
|
|
|
INPUT_DIR = Path(OUTPUT_DIR).parent / "input"
|
|
|
|
if not INPUT_DIR.exists():
|
|
messagebox.showerror("Erreur", f"Dossier input introuvable : {INPUT_DIR}")
|
|
return
|
|
|
|
header_frame = ttk.Frame(content)
|
|
header_frame.pack(fill="x", padx=10, pady=5)
|
|
ttk.Button(
|
|
header_frame,
|
|
text="Help",
|
|
width=6,
|
|
command=open_help
|
|
).pack(side="right")
|
|
ttk.Label(
|
|
header_frame,
|
|
text="Génération de fichiers JSON au format normalisé YANG à partir des logs de plusieurs switches",
|
|
font=("Arial", 8, "bold")
|
|
).pack(side="left")
|
|
|
|
ttk.Label(
|
|
content,
|
|
text="/!\\ Mettre les fichiers/dossiers de configurations dans le dossier `./Parseurs_logs_Switch/src/input/`",
|
|
font=("Arial", 9, "italic"),
|
|
).pack(anchor="w", padx=10, pady=(0, 10))
|
|
|
|
ttk.Label(
|
|
content,
|
|
text="Sélectionnez les fichiers de configuration source à traiter :",
|
|
font=("Arial", 10)
|
|
).pack(anchor="w", padx=10)
|
|
|
|
files = [item.name for item in INPUT_DIR.iterdir() if item.is_file()]
|
|
# dirs = [item.name for item in INPUT_DIR.iterdir() if item.is_dir()]
|
|
|
|
file_selections = create_table(
|
|
content,
|
|
"🗎 Liste des fichiers de configuration source",
|
|
files,
|
|
mode="file"
|
|
)
|
|
|
|
# dir_selections = create_table(
|
|
# content,
|
|
# "🗁 Liste des dossiers de configuration source",
|
|
# dirs,
|
|
# mode="dir"
|
|
# )
|
|
|
|
ttk.Checkbutton(
|
|
content,
|
|
text="Générer le schéma d'infrastructure",
|
|
variable=schema_infra
|
|
).pack(anchor="w", padx=10, pady=(10, 0))
|
|
schema_infra.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
content,
|
|
text="Générer le rapport des liens inter-switches en Excel",
|
|
variable=rapport_uplink
|
|
).pack(anchor="w", padx=10, pady=(0, 0))
|
|
rapport_uplink.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
content,
|
|
text="Générer le rapport des stack en Excel",
|
|
variable=rapport_stack
|
|
).pack(anchor="w", padx=10, pady=(0, 0))
|
|
rapport_stack.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
content,
|
|
text="Générer le rapport des interfaces en Excel",
|
|
variable=rapport_interfaces
|
|
).pack(anchor="w", padx=10, pady=(0, 10))
|
|
rapport_interfaces.set(True)
|
|
|
|
ttk.Label(
|
|
content,
|
|
text="Dossier de sortie :",
|
|
).pack(anchor="w", padx=10)
|
|
|
|
ttk.Button(
|
|
content,
|
|
text="Ouvrir le dossier de sortie",
|
|
command=open_output_folder
|
|
).pack(anchor="w", padx=10)
|
|
|
|
ttk.Button(
|
|
content,
|
|
text="Lancer le traitement",
|
|
command=run_parser_multi
|
|
).pack(pady=15)
|
|
|
|
content.mainloop()
|
|
|
|
# Contenu fenêtre Analyse Switch
|
|
def open_switch_gui(root, BASE_DIR):
|
|
SWITCH_DIR = os.path.join(
|
|
BASE_DIR,
|
|
"Parseurs_logs_Switch"
|
|
)
|
|
|
|
SWITCH_MAIN = os.path.join(
|
|
SWITCH_DIR,
|
|
"src",
|
|
"main.py"
|
|
)
|
|
|
|
HELP_FILE_SW = os.path.join(BASE_DIR, "help_Switch.md")
|
|
|
|
OUTPUT_DIR = os.path.join(SWITCH_DIR, "src", "output")
|
|
os.makedirs(OUTPUT_DIR, exist_ok=True)
|
|
|
|
app = tk.Toplevel(root)
|
|
app.title("Analyse Configuration Switch")
|
|
app.geometry("800x550")
|
|
app.resizable(True, True)
|
|
|
|
switch_var = tk.StringVar()
|
|
input_var = tk.StringVar()
|
|
output_var = tk.StringVar()
|
|
|
|
rapport_uplink = tk.BooleanVar()
|
|
schema_infra = tk.BooleanVar()
|
|
rapport_stack = tk.BooleanVar()
|
|
rapport_interfaces = tk.BooleanVar()
|
|
|
|
def browse_input():
|
|
sw_type = switch_var.get()
|
|
if sw_type == "":
|
|
messagebox.showerror("Erreur", "Veuillez d'abord sélectionner un type de switch.")
|
|
return
|
|
path = filedialog.askopenfilename(title="Sélectionnez le fichier d'entrée", parent=app)
|
|
input_var.set(path)
|
|
|
|
def update_output_label(*args):
|
|
if switch_var.get() == "":
|
|
output_label_var.set("Fichier de sortie :")
|
|
return
|
|
else :
|
|
sw = switch_var.get().lower()
|
|
|
|
if output_var.get():
|
|
s_json1 = os.path.join(OUTPUT_DIR, f"{sw}_current_{output_var.get()}.json")
|
|
s_json2 = os.path.join(OUTPUT_DIR, f"{sw}_saved_{output_var.get()}.json")
|
|
s_uplink = os.path.join(OUTPUT_DIR, f"rapport_uplink_{sw}_{output_var.get()}.xlsx")
|
|
s_stack = os.path.join(OUTPUT_DIR, f"rapport_stack_{sw}_{output_var.get()}.xlsx")
|
|
s_interfaces = os.path.join(OUTPUT_DIR, f"rapport_interfaces_{sw}_{output_var.get()}.xlsx")
|
|
s_schema = os.path.join(OUTPUT_DIR, f"schema_infra_{sw}_{output_var.get()}.xlsx")
|
|
else:
|
|
dt = datetime.now().strftime("%Y%m%d")
|
|
s_json1 = os.path.join(OUTPUT_DIR, f"{sw}_current_{dt}.json")
|
|
s_json2 = os.path.join(OUTPUT_DIR, f"{sw}_saved_{dt}.json")
|
|
s_uplink = os.path.join(OUTPUT_DIR, f"rapport_uplink_{sw}_{dt}.xlsx")
|
|
s_stack = os.path.join(OUTPUT_DIR, f"rapport_stack_{sw}_{dt}.xlsx")
|
|
s_interfaces = os.path.join(OUTPUT_DIR, f"rapport_interfaces_{sw}_{dt}.xlsx")
|
|
s_schema = os.path.join(OUTPUT_DIR, f"schema_infra_{sw}_{dt}.xlsx")
|
|
|
|
output_label_var.set("Fichier de sortie :\n" + s_json1 + "\n" + s_json2 + ("\n" + s_uplink if rapport_uplink.get() else "") + ("\n" + s_stack if rapport_stack.get() else "") + ("\n" + s_interfaces if rapport_interfaces.get() else "") + ("\n" + s_schema if schema_infra.get() else ""))
|
|
app.update_idletasks()
|
|
|
|
def open_output_folder():
|
|
if sys.platform == "win32":
|
|
os.startfile(OUTPUT_DIR)
|
|
elif sys.platform == "darwin":
|
|
subprocess.run(["open", OUTPUT_DIR])
|
|
else:
|
|
subprocess.run(["xdg-open", OUTPUT_DIR])
|
|
|
|
def open_help():
|
|
if not os.path.exists(HELP_FILE_SW):
|
|
messagebox.showerror("Erreur", "Le fichier d'aide est introuvable.")
|
|
return
|
|
|
|
if sys.platform == "win32":
|
|
os.startfile(HELP_FILE_SW)
|
|
elif sys.platform == "darwin":
|
|
subprocess.run(["open", HELP_FILE_SW])
|
|
else:
|
|
subprocess.run(["xdg-open", HELP_FILE_SW])
|
|
|
|
def run_parser():
|
|
if not switch_var.get():
|
|
messagebox.showerror("Erreur", "Veuillez sélectionner un type de switch.")
|
|
return
|
|
|
|
if not input_var.get():
|
|
messagebox.showerror("Erreur", "Veuillez sélectionner un fichier d'entrée.")
|
|
return
|
|
|
|
app.config(cursor="watch")
|
|
progress_bar = ttk.Progressbar(app, mode="indeterminate")
|
|
progress_bar.pack(pady=10, fill="x", padx=10)
|
|
progress_bar.start(10)
|
|
app.update_idletasks()
|
|
def process():
|
|
cmd = [
|
|
sys.executable,
|
|
SWITCH_MAIN,
|
|
switch_var.get(),
|
|
input_var.get()
|
|
]
|
|
|
|
if output_var.get():
|
|
cmd.extend(["-o", output_var.get()])
|
|
|
|
if rapport_uplink.get():
|
|
cmd.append("-u")
|
|
if schema_infra.get():
|
|
cmd.append("-d")
|
|
if rapport_stack.get():
|
|
cmd.append("-s")
|
|
if rapport_interfaces.get():
|
|
cmd.append("-i")
|
|
|
|
# print("Commande exécutée :", " ".join(cmd))
|
|
# print("Dossier courant (cwd) :", SWITCH_DIR)
|
|
|
|
try:
|
|
subprocess.run(
|
|
cmd,
|
|
cwd=SWITCH_DIR,
|
|
check=True
|
|
)
|
|
|
|
def on_success():
|
|
progress_bar.stop()
|
|
progress_bar.destroy()
|
|
app.config(cursor="")
|
|
messagebox.showinfo("Succès", "Traitement terminé avec succès.")
|
|
open_output_folder()
|
|
app.destroy()
|
|
|
|
app.after(0, on_success)
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
def on_error():
|
|
progress_bar.stop()
|
|
progress_bar.destroy()
|
|
app.config(cursor="")
|
|
messagebox.showerror(
|
|
"Erreur",
|
|
f"Erreur lors de l'exécution du traitement.\n\n"
|
|
)
|
|
|
|
app.after(0, on_error)
|
|
|
|
Thread(target=process, daemon=True).start()
|
|
|
|
header_frame = ttk.Frame(app)
|
|
header_frame.pack(fill="x", padx=10, pady=5)
|
|
|
|
ttk.Button(
|
|
header_frame,
|
|
text="Help",
|
|
width=6,
|
|
command=open_help
|
|
).pack(side="right")
|
|
|
|
ttk.Label(
|
|
header_frame,
|
|
text="Génération d'un fichier JSON au format normalisé YANG à partir des logs d'un switch",
|
|
font=("Arial", 8, "bold")
|
|
).pack(side="left")
|
|
|
|
ttk.Button(
|
|
app,
|
|
text="Plusieurs Switches",
|
|
command=lambda: open_switch_gui_multi(app, OUTPUT_DIR, HELP_FILE_SW, SWITCH_DIR, SWITCH_MAIN)
|
|
).pack(anchor="w", padx=10)
|
|
|
|
|
|
ttk.Label(app, text="Type de switch").pack(anchor="w", padx=10, pady=5)
|
|
ttk.Combobox(
|
|
app,
|
|
values=["HPE"],
|
|
textvariable=switch_var,
|
|
state="readonly"
|
|
).pack(fill="x", padx=10)
|
|
|
|
|
|
input_label_var = tk.StringVar()
|
|
input_label_var.set("Fichier de logs source")
|
|
input_label_frame = ttk.Frame(app)
|
|
input_label_frame.pack(anchor="w", padx=5, pady=5)
|
|
info_label = ttk.Label(
|
|
input_label_frame,
|
|
text="ⓘ",
|
|
cursor="hand2"
|
|
)
|
|
info_label.pack(side="right")
|
|
ttk.Label(
|
|
input_label_frame,
|
|
textvariable=input_label_var
|
|
).pack(side="left", padx=(5, 0))
|
|
ToolTip(
|
|
info_label,
|
|
"/!\\ Mettre le fichier/dossier de configurations\n"
|
|
"dans le dossier `/Parseurs_config_Firewall/src/input/` /!\\"
|
|
)
|
|
|
|
def update_input_label(*args):
|
|
switch_type = switch_var.get().lower()
|
|
input_label_var.set("Fichier de configuration source")
|
|
|
|
switch_var.trace_add("write", update_input_label)
|
|
input_frame = ttk.Frame(app)
|
|
input_frame.pack(fill="x", padx=10)
|
|
|
|
ttk.Entry(input_frame, textvariable=input_var).pack(side="left", fill="x", expand=True)
|
|
ttk.Button(input_frame, text="Parcourir", command=browse_input).pack(side="right")
|
|
|
|
ttk.Label(app, text="Nom de sortie (optionnel)").pack(anchor="w", padx=10, pady=5)
|
|
ttk.Entry(app, textvariable=output_var).pack(fill="x", padx=10)
|
|
|
|
ttk.Checkbutton(
|
|
app,
|
|
text="Générer le schéma d'infrastructure",
|
|
variable=schema_infra
|
|
).pack(anchor="w", padx=10, pady=(10, 0))
|
|
schema_infra.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
app,
|
|
text="Générer le rapport des liens inter-switches en Excel",
|
|
variable=rapport_uplink
|
|
).pack(anchor="w", padx=10, pady=(0, 0))
|
|
rapport_uplink.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
app,
|
|
text="Générer le rapport des stack en Excel",
|
|
variable=rapport_stack
|
|
).pack(anchor="w", padx=10, pady=(0, 0))
|
|
rapport_stack.set(True)
|
|
|
|
ttk.Checkbutton(
|
|
app,
|
|
text="Générer le rapport des interfaces en Excel",
|
|
variable=rapport_interfaces
|
|
).pack(anchor="w", padx=10, pady=(0, 10))
|
|
rapport_interfaces.set(True)
|
|
|
|
output_label_var = tk.StringVar()
|
|
ttk.Label(app, textvariable=output_label_var).pack(anchor="w", padx=10)
|
|
switch_var.trace_add("write", update_output_label)
|
|
output_var.trace_add("write", update_output_label)
|
|
schema_infra.trace_add("write", update_output_label)
|
|
rapport_uplink.trace_add("write", update_output_label)
|
|
rapport_stack.trace_add("write", update_output_label)
|
|
rapport_interfaces.trace_add("write", update_output_label)
|
|
update_output_label()
|
|
|
|
ttk.Button(
|
|
app,
|
|
text="Ouvrir le dossier de sortie",
|
|
command=open_output_folder
|
|
).pack(anchor="w", padx=10)
|
|
|
|
ttk.Button(
|
|
app,
|
|
text="Lancer le traitement",
|
|
command=run_parser
|
|
).pack(pady=15)
|
|
|
|
app.mainloop() |