| import os
|
| import time
|
| import threading
|
| import tkinter as tk
|
| from tkinter import ttk, messagebox, filedialog
|
| from huggingface_hub import HfApi, hf_hub_download
|
|
|
|
|
|
|
|
|
|
|
| DATASET_ID = "IGNF/FLAIR-HUB"
|
| DEFAULT_DOWNLOAD_DIR = "./FLAIR-HUB_download"
|
|
|
| os.environ["HF_HUB_DISABLE_PROGRESS_BARS"] = "1"
|
|
|
| api = HfApi()
|
|
|
| checkbox_state = {}
|
| file_sizes = {}
|
| stop_flag = threading.Event()
|
| dataset_files = []
|
|
|
|
|
|
|
|
|
|
|
|
|
| def human_bytes(num):
|
| if num is None:
|
| return "unknown"
|
| for unit in ["B", "KB", "MB", "GB", "TB"]:
|
| if num < 1024:
|
| return f"{num:.1f} {unit}"
|
| num /= 1024
|
| return f"{num:.1f} PB"
|
|
|
|
|
| def parse_zip_metadata(path: str):
|
| """
|
| Parse data ZIP filename of the form:
|
| DOMAIN-YEAR_MODALITY_DATATYPE.zip
|
|
|
| Example:
|
| data/D004-2021_AERIAL_RGBI_IMS.zip
|
| -> domain=D004, year=2021, modality=AERIAL_RGBI, datatype=IMS
|
| """
|
| name = os.path.basename(path)
|
| if not name.lower().endswith(".zip"):
|
| return None
|
|
|
| if name == "GLOBAL_ALL_MTD.zip":
|
| return None
|
|
|
| stem = name[:-4]
|
| if "-" not in stem:
|
| return None
|
|
|
| domain, rest = stem.split("-", 1)
|
| parts = rest.split("_")
|
| year = parts[0] if parts and parts[0].isdigit() else None
|
|
|
| modality = None
|
| datatype = None
|
|
|
| if len(parts) >= 2:
|
| if len(parts) >= 3:
|
| datatype = parts[-1]
|
| modality = "_".join(parts[1:-1])
|
| else:
|
| modality = parts[1]
|
|
|
| return {
|
| "path": path,
|
| "name": name,
|
| "domain": domain,
|
| "year": year,
|
| "modality": modality,
|
| "datatype": datatype,
|
| }
|
|
|
|
|
|
|
|
|
|
|
|
|
| root = tk.Tk()
|
| root.title("FLAIR-HUB Dataset Download Tool")
|
| root.geometry("1100x780")
|
| root.minsize(860, 620)
|
|
|
| BG_MAIN = "#020617"
|
| BG_CARD = "#111827"
|
| ACCENT = "#98c220"
|
| ACCENT_H = "#b4de34"
|
| FG_TEXT = "#e5e7eb"
|
| FG_MUTED = "#9ca3af"
|
| BORDER = "#1f2937"
|
|
|
| LIST_BG = "#f9fafb"
|
| LIST_FG = "#111827"
|
| LIST_SEL_BG = "#d1fae5"
|
| LIST_SEL_FG = "#065f46"
|
|
|
| style = ttk.Style()
|
| if "clam" in style.theme_names():
|
| style.theme_use("clam")
|
|
|
| BASE_FONT = ("Segoe UI", 10)
|
| INFO_FONT = ("Consolas", 9)
|
| LOG_FONT = ("Consolas", 9)
|
|
|
| root.option_add("*Font", BASE_FONT)
|
| root.configure(bg=BG_MAIN)
|
|
|
| style.configure("TFrame", background=BG_MAIN)
|
| style.configure("Card.TFrame", background=BG_CARD)
|
|
|
| style.configure(
|
| "Treeview",
|
| background=LIST_BG,
|
| fieldbackground=LIST_BG,
|
| foreground=LIST_FG,
|
| rowheight=24,
|
| borderwidth=0,
|
| highlightthickness=0,
|
| )
|
| style.map(
|
| "Treeview",
|
| background=[("selected", LIST_SEL_BG)],
|
| foreground=[("selected", LIST_SEL_FG)],
|
| )
|
|
|
| style.configure(
|
| "Accent.TButton",
|
| background="#111827",
|
| foreground=FG_TEXT,
|
| padding=(10, 4),
|
| relief="flat",
|
| borderwidth=1,
|
| )
|
| style.map(
|
| "Accent.TButton",
|
| background=[
|
| ("active", "#1f2937"),
|
| ("pressed", "#111827"),
|
| ("disabled", "#111827"),
|
| ],
|
| foreground=[
|
| ("disabled", FG_MUTED),
|
| ],
|
| )
|
|
|
| style.configure(
|
| "Primary.TButton",
|
| background=ACCENT,
|
| foreground="#030712",
|
| padding=(12, 5),
|
| relief="flat",
|
| borderwidth=0,
|
| font=("Segoe UI", 10, "bold"),
|
| )
|
| style.map(
|
| "Primary.TButton",
|
| background=[
|
| ("active", ACCENT_H),
|
| ("pressed", ACCENT),
|
| ("disabled", "#4b5563"),
|
| ],
|
| foreground=[
|
| ("disabled", "#111827"),
|
| ],
|
| )
|
|
|
| style.configure(
|
| "Accent.Horizontal.TProgressbar",
|
| troughcolor=BG_MAIN,
|
| bordercolor=BG_MAIN,
|
| background=ACCENT,
|
| lightcolor=ACCENT,
|
| darkcolor=ACCENT,
|
| )
|
|
|
| root.update_idletasks()
|
| w = root.winfo_width()
|
| h = root.winfo_height()
|
| x = (root.winfo_screenwidth() // 2) - (w // 2)
|
| y = (root.winfo_screenheight() // 2) - (h // 2)
|
| root.geometry(f"{w}x{h}+{x}+{y}")
|
|
|
|
|
|
|
|
|
|
|
|
|
| main_paned = ttk.Panedwindow(root, orient=tk.VERTICAL)
|
| main_paned.pack(fill=tk.BOTH, expand=True, padx=10, pady=(8, 4))
|
|
|
| info_outer = tk.Frame(
|
| main_paned,
|
| bg=BG_MAIN,
|
| )
|
| info_frame = tk.Frame(
|
| info_outer,
|
| bg=BG_CARD,
|
| highlightbackground=BORDER,
|
| highlightthickness=1,
|
| bd=0,
|
| )
|
| info_frame.pack(fill=tk.BOTH, expand=True)
|
| main_paned.add(info_outer, weight=1)
|
|
|
| info_label = tk.Label(
|
| info_frame,
|
| text="Dataset Information",
|
| font=("Segoe UI", 11, "bold"),
|
| bg=BG_CARD,
|
| fg=FG_TEXT,
|
| )
|
| info_label.pack(anchor="w", pady=(8, 4), padx=8)
|
|
|
| info_text = tk.Text(
|
| info_frame,
|
| height=7,
|
| wrap="word",
|
| font=INFO_FONT,
|
| bg=BG_MAIN,
|
| fg=FG_TEXT,
|
| bd=0,
|
| relief="flat",
|
| )
|
| info_text.pack(fill=tk.BOTH, expand=True, padx=8, pady=(0, 8))
|
|
|
|
|
|
|
|
|
|
|
|
|
| files_outer = tk.Frame(root, bg=BG_MAIN)
|
| files_card = tk.Frame(
|
| files_outer,
|
| bg=BG_CARD,
|
| highlightbackground=BORDER,
|
| highlightthickness=1,
|
| bd=0,
|
| )
|
| files_card.pack(fill=tk.BOTH, expand=True)
|
| main_paned.add(files_outer, weight=3)
|
|
|
| tree_frame = ttk.Frame(files_card, style="Card.TFrame")
|
| tree_frame.pack(fill=tk.BOTH, expand=True, padx=6, pady=6)
|
|
|
| filter_bar = ttk.Frame(tree_frame, padding=(4, 4), style="Card.TFrame")
|
| filter_bar.pack(side=tk.TOP, fill=tk.X)
|
|
|
| filter_title = ttk.Label(
|
| filter_bar,
|
| text="Filters",
|
| font=("Segoe UI", 10, "bold"),
|
| background=BG_CARD,
|
| foreground=FG_TEXT,
|
| )
|
| filter_title.grid(row=0, column=0, padx=(0, 8), sticky="w")
|
|
|
| domain_var = tk.StringVar(value="All")
|
| year_var = tk.StringVar(value="All")
|
| modality_var = tk.StringVar(value="All")
|
| datatype_var = tk.StringVar(value="All")
|
|
|
| domain_label = ttk.Label(filter_bar, text="Domain", background=BG_CARD, foreground=FG_MUTED)
|
| year_label = ttk.Label(filter_bar, text="Year", background=BG_CARD, foreground=FG_MUTED)
|
| modality_label = ttk.Label(filter_bar, text="Modality", background=BG_CARD, foreground=FG_MUTED)
|
| datatype_label = ttk.Label(filter_bar, text="Data type", background=BG_CARD, foreground=FG_MUTED)
|
|
|
| domain_cb = ttk.Combobox(filter_bar, textvariable=domain_var, state="readonly", width=12, values=["All"])
|
| year_cb = ttk.Combobox(filter_bar, textvariable=year_var, state="readonly", width=8, values=["All"])
|
| modality_cb = ttk.Combobox(filter_bar, textvariable=modality_var, state="readonly", width=14, values=["All"])
|
| datatype_cb = ttk.Combobox(filter_bar, textvariable=datatype_var, state="readonly", width=10, values=["All"])
|
|
|
| domain_label.grid(row=0, column=1, sticky="w", padx=(0, 2))
|
| domain_cb.grid(row=0, column=2, padx=(2, 8))
|
|
|
| year_label.grid(row=0, column=3, sticky="w", padx=(0, 2))
|
| year_cb.grid(row=0, column=4, padx=(2, 8))
|
|
|
| modality_label.grid(row=0, column=5, sticky="w", padx=(0, 2))
|
| modality_cb.grid(row=0, column=6, padx=(2, 8))
|
|
|
| datatype_label.grid(row=0, column=7, sticky="w", padx=(0, 2))
|
| datatype_cb.grid(row=0, column=8, padx=(2, 8))
|
|
|
|
|
| def reset_filters():
|
| domain_var.set("All")
|
| year_var.set("All")
|
| modality_var.set("All")
|
| datatype_var.set("All")
|
| apply_filters()
|
|
|
|
|
| def show_metadata_only():
|
| domain_var.set("GLOBAL")
|
| year_var.set("All")
|
| modality_var.set("GLOBAL")
|
| datatype_var.set("MTD")
|
| apply_filters()
|
|
|
|
|
| metadata_btn = ttk.Button(filter_bar, text="Metadata", style="Accent.TButton", command=show_metadata_only)
|
| metadata_btn.grid(row=0, column=9, padx=(4, 0), sticky="w")
|
|
|
| reset_btn = ttk.Button(filter_bar, text="Reset", style="Accent.TButton", command=reset_filters)
|
| reset_btn.grid(row=0, column=10, padx=(4, 0), sticky="w")
|
|
|
| for col in range(11):
|
| filter_bar.columnconfigure(col, weight=0)
|
|
|
| files_split = ttk.Panedwindow(tree_frame, orient=tk.HORIZONTAL)
|
| files_split.pack(side=tk.TOP, fill=tk.BOTH, expand=True, pady=(4, 0))
|
|
|
| left_files_frame = ttk.Frame(files_split, padding=(0, 4), style="Card.TFrame")
|
| files_split.add(left_files_frame, weight=3)
|
|
|
| left_label = ttk.Label(
|
| left_files_frame,
|
| text="Available files",
|
| font=("Segoe UI", 10, "bold"),
|
| background=BG_CARD,
|
| foreground=FG_TEXT,
|
| )
|
| left_label.pack(anchor="w", padx=(2, 0))
|
|
|
| left_container = ttk.Frame(left_files_frame, style="Card.TFrame")
|
| left_container.pack(fill=tk.BOTH, expand=True, pady=(2, 0))
|
|
|
| left_scroll = ttk.Scrollbar(left_container, orient=tk.VERTICAL)
|
| left_scroll.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
| file_tree = ttk.Treeview(left_container, yscrollcommand=left_scroll.set, selectmode="none")
|
| file_tree.pack(fill=tk.BOTH, expand=True)
|
| left_scroll.config(command=file_tree.yview)
|
|
|
| file_tree["columns"] = ()
|
| file_tree.column("#0", anchor=tk.W, stretch=True)
|
| file_tree["show"] = "tree"
|
|
|
| right_selected_frame = ttk.Frame(files_split, padding=(8, 4), style="Card.TFrame")
|
| files_split.add(right_selected_frame, weight=2)
|
|
|
| right_title_bar = tk.Frame(right_selected_frame, bg=BG_CARD)
|
| right_title_bar.pack(fill=tk.X, pady=(0, 2))
|
|
|
| right_label = tk.Label(
|
| right_title_bar,
|
| text="Selected files",
|
| font=("Segoe UI", 10, "bold"),
|
| bg=BG_CARD,
|
| fg=FG_TEXT,
|
| )
|
| right_label.pack(side=tk.LEFT)
|
|
|
| badge_label = tk.Label(
|
| right_title_bar,
|
| text="[ 0 file — 0 ]",
|
| font=("Segoe UI", 9, "bold"),
|
| bg=ACCENT,
|
| fg="#111827",
|
| padx=8,
|
| pady=2,
|
| )
|
| badge_label.pack(side=tk.RIGHT, padx=4)
|
|
|
|
|
| selected_container = ttk.Frame(right_selected_frame, style="Card.TFrame")
|
| selected_container.pack(fill=tk.BOTH, expand=True, pady=(2, 0))
|
|
|
| selected_scroll = ttk.Scrollbar(selected_container, orient=tk.VERTICAL)
|
| selected_scroll.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
| selected_listbox = tk.Listbox(
|
| selected_container,
|
| height=10,
|
| font=LOG_FONT,
|
| bg=LIST_BG,
|
| fg=LIST_FG,
|
| bd=0,
|
| relief="flat",
|
| selectbackground=LIST_SEL_BG,
|
| selectforeground=LIST_SEL_FG,
|
| )
|
| selected_listbox.pack(fill=tk.BOTH, expand=True)
|
| selected_listbox.config(yscrollcommand=selected_scroll.set)
|
| selected_scroll.config(command=selected_listbox.yview)
|
|
|
| def update_selected_panel():
|
| """Refresh the right-hand 'selected files' list and the badge."""
|
| selected_listbox.delete(0, tk.END)
|
|
|
| total_bytes = 0
|
| selected_items = [m for m in dataset_files if checkbox_state.get(m["path"], False)]
|
|
|
| for meta in sorted(selected_items, key=lambda m: m["name"]):
|
| selected_listbox.insert(tk.END, meta["name"])
|
| if meta.get("size_bytes") is not None:
|
| total_bytes += meta["size_bytes"]
|
|
|
| count = len(selected_items)
|
| size_str = human_bytes(total_bytes) if total_bytes > 0 else "0"
|
|
|
| badge_label.config(
|
| text=f"[ {count} file{'s' if count != 1 else ''} — {size_str} ]"
|
| )
|
|
|
|
|
|
|
|
|
|
|
|
|
| bottom_outer = tk.Frame(root, bg=BG_MAIN)
|
| bottom_card = tk.Frame(
|
| bottom_outer,
|
| bg=BG_CARD,
|
| highlightbackground=BORDER,
|
| highlightthickness=1,
|
| bd=0,
|
| )
|
| bottom_card.pack(fill=tk.X, padx=10, pady=(2, 0))
|
| bottom_outer.pack(fill=tk.X)
|
|
|
| bottom_frame = ttk.Frame(bottom_card, padding=(10, 8), style="Card.TFrame")
|
| bottom_frame.pack(fill=tk.X)
|
|
|
| path_label = ttk.Label(bottom_frame, text="Download to:", background=BG_CARD, foreground=FG_MUTED)
|
| path_label.grid(row=0, column=0, sticky="w")
|
|
|
| download_path = ttk.Entry(bottom_frame)
|
| download_path.insert(0, DEFAULT_DOWNLOAD_DIR)
|
| download_path.grid(row=0, column=1, sticky="ew", padx=(6, 6))
|
|
|
|
|
| def choose_folder():
|
| folder = filedialog.askdirectory()
|
| if folder:
|
| download_path.delete(0, tk.END)
|
| download_path.insert(0, folder)
|
|
|
|
|
| browse_btn = ttk.Button(bottom_frame, text="📂 Browse…", style="Accent.TButton", command=choose_folder)
|
| browse_btn.grid(row=0, column=2, sticky="ew")
|
|
|
| btn_frame = ttk.Frame(bottom_frame, style="Card.TFrame")
|
| btn_frame.grid(row=0, column=3, sticky="e", padx=(10, 0))
|
|
|
| select_all_btn = ttk.Button(btn_frame, text="Select All", style="Accent.TButton")
|
| unselect_all_btn = ttk.Button(btn_frame, text="Unselect All", style="Accent.TButton")
|
| download_btn = ttk.Button(btn_frame, text="⬇ Download", style="Primary.TButton")
|
| stop_btn = ttk.Button(btn_frame, text="⛔ Stop", style="Accent.TButton", state="disabled")
|
|
|
| select_all_btn.pack(side=tk.LEFT, padx=(0, 4))
|
| unselect_all_btn.pack(side=tk.LEFT, padx=(0, 4))
|
| download_btn.pack(side=tk.LEFT, padx=(0, 4))
|
| stop_btn.pack(side=tk.LEFT)
|
|
|
| bottom_frame.columnconfigure(1, weight=1)
|
|
|
| status_outer = tk.Frame(root, bg=BG_MAIN)
|
| status_card = tk.Frame(
|
| status_outer,
|
| bg=BG_CARD,
|
| highlightbackground=BORDER,
|
| highlightthickness=1,
|
| bd=0,
|
| )
|
| status_card.pack(fill=tk.X, padx=10, pady=(4, 0))
|
| status_outer.pack(fill=tk.X)
|
|
|
| status_frame = ttk.Frame(status_card, padding=(10, 4), style="Card.TFrame")
|
| status_frame.pack(fill=tk.X)
|
|
|
| status_label = ttk.Label(status_frame, text="Ready.", background=BG_CARD, foreground=FG_MUTED)
|
| status_label.pack(side=tk.LEFT)
|
|
|
| progress = ttk.Progressbar(status_frame, mode="indeterminate", length=220, style="Accent.Horizontal.TProgressbar")
|
| progress.pack(side=tk.RIGHT)
|
|
|
| log_outer = tk.Frame(root, bg=BG_MAIN)
|
| log_card = tk.Frame(
|
| log_outer,
|
| bg=BG_CARD,
|
| highlightbackground=BORDER,
|
| highlightthickness=1,
|
| bd=0,
|
| )
|
| log_card.pack(fill=tk.BOTH, expand=True, padx=10, pady=(4, 8))
|
| log_outer.pack(fill=tk.BOTH, expand=True)
|
|
|
| log_frame = ttk.Frame(log_card, padding=4, style="Card.TFrame")
|
| log_frame.pack(fill=tk.BOTH, expand=True)
|
|
|
| log_scroll = ttk.Scrollbar(log_frame, orient=tk.VERTICAL)
|
| log_scroll.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
| log_text = tk.Text(
|
| log_frame,
|
| height=10,
|
| wrap="none",
|
| font=LOG_FONT,
|
| bg=BG_MAIN,
|
| fg=FG_TEXT,
|
| bd=0,
|
| relief="flat",
|
| )
|
| log_text.pack(fill=tk.BOTH, expand=True)
|
| log_text.config(state="disabled")
|
| log_scroll.config(command=log_text.yview)
|
| log_text.config(yscrollcommand=log_scroll.set)
|
|
|
|
|
| def append_log(line: str):
|
| log_text.config(state="normal")
|
| log_text.insert("end", line + "\n")
|
| log_text.see("end")
|
| log_text.config(state="disabled")
|
|
|
|
|
| def clear_log():
|
| log_text.config(state="normal")
|
| log_text.delete("1.0", "end")
|
| log_text.config(state="disabled")
|
|
|
|
|
|
|
|
|
|
|
|
|
| def refresh_checkboxes():
|
| """Update tree item text based on checkbox_state."""
|
| for iid in file_tree.get_children(""):
|
| checked = checkbox_state.get(iid, False)
|
| meta = next((f for f in dataset_files if f["path"] == iid), None)
|
| if meta is None:
|
| continue
|
| prefix = "☑ " if checked else "☐ "
|
| file_tree.item(iid, text=f"{prefix}{meta['name']}")
|
| update_selected_panel()
|
|
|
|
|
| def apply_filters(*_):
|
| """Rebuild the left tree based on current filter values."""
|
| file_tree.delete(*file_tree.get_children(""))
|
|
|
| d_filter = domain_var.get()
|
| y_filter = year_var.get()
|
| m_filter = modality_var.get()
|
| t_filter = datatype_var.get()
|
|
|
| for meta in dataset_files:
|
| if d_filter != "All" and meta["domain"] != d_filter:
|
| continue
|
| if y_filter != "All" and meta["year"] != y_filter:
|
| continue
|
| if m_filter != "All" and meta["modality"] != m_filter:
|
| continue
|
| if t_filter != "All" and meta["datatype"] != t_filter:
|
| continue
|
|
|
| path = meta["path"]
|
| if path not in checkbox_state:
|
| checkbox_state[path] = False
|
|
|
| checked = checkbox_state[path]
|
| prefix = "☑ " if checked else "☐ "
|
| file_tree.insert("", "end", iid=path, text=f"{prefix}{meta['name']}")
|
|
|
| update_selected_panel()
|
|
|
|
|
| def toggle_all(state: bool):
|
| """Select/unselect only currently visible (filtered) files."""
|
| for iid in file_tree.get_children(""):
|
| checkbox_state[iid] = state
|
| refresh_checkboxes()
|
| status_label.config(text=f"{'Selected' if state else 'Unselected'} filtered files.")
|
|
|
|
|
| def on_tree_click(event):
|
| region = file_tree.identify("region", event.x, event.y)
|
| column = file_tree.identify_column(event.x)
|
| row = file_tree.identify_row(event.y)
|
|
|
| if region == "tree" and column == "#0" and row:
|
| bbox = file_tree.bbox(row)
|
| if bbox and event.x > bbox[0] + 20:
|
| current = checkbox_state.get(row, False)
|
| checkbox_state[row] = not current
|
| refresh_checkboxes()
|
|
|
|
|
| file_tree.bind("<Button-1>", on_tree_click)
|
|
|
|
|
|
|
|
|
|
|
|
|
| def load_dataset():
|
| global file_sizes, dataset_files
|
| info_text.delete(1.0, tk.END)
|
| file_tree.delete(*file_tree.get_children(""))
|
| checkbox_state.clear()
|
| file_sizes = {}
|
| dataset_files = []
|
|
|
| status_label.config(text="Contacting Hugging Face API…")
|
| root.update_idletasks()
|
|
|
| try:
|
| info = api.dataset_info(DATASET_ID, files_metadata=True)
|
| except Exception as e:
|
| messagebox.showerror("Error", f"Failed to load: {e}")
|
| status_label.config(text="Failed to load dataset.")
|
| return
|
|
|
| created = info.created_at.strftime("%Y-%m-%d %H:%M") if info.created_at else "N/A"
|
| modified = info.lastModified.strftime("%Y-%m-%d %H:%M") if info.lastModified else "N/A"
|
| size = getattr(info, "usedStorage", 0) or 0
|
| size_str = f"{size/1e9:.2f} GB" if size > 1e9 else f"{size/1e6:.2f} MB"
|
|
|
| meta_info = f"""
|
| ID : {info.id}
|
| Author : {info.author or 'Unknown'}
|
| Created : {created}
|
| Modified : {modified}
|
| Size : {size_str}
|
| Downloads : {info.downloads or 0}
|
| Likes : {info.likes or 0}
|
| Tags : {', '.join(info.tags or [])}
|
| Tasks : {', '.join((info.cardData or {}).get('task_categories', []))}
|
| """.rstrip()
|
|
|
| info_text.insert(tk.END, meta_info)
|
|
|
| for s in info.siblings:
|
| path = s.rfilename
|
|
|
| if path.endswith("GLOBAL_ALL_MTD.zip"):
|
| size_attr = getattr(s, "size", None)
|
| m = {
|
| "path": path,
|
| "name": os.path.basename(path),
|
| "domain": "GLOBAL",
|
| "year": None,
|
| "modality": "GLOBAL",
|
| "datatype": "MTD",
|
| "size_bytes": size_attr,
|
| }
|
| dataset_files.append(m)
|
| if size_attr is not None:
|
| file_sizes[path] = size_attr
|
| continue
|
|
|
| if not path.startswith("data/"):
|
| continue
|
| if not path.lower().endswith(".zip"):
|
| continue
|
|
|
| m = parse_zip_metadata(path)
|
| if m is None:
|
| continue
|
|
|
| size_attr = getattr(s, "size", None)
|
| m["size_bytes"] = size_attr
|
| dataset_files.append(m)
|
|
|
| if size_attr is not None:
|
| file_sizes[path] = size_attr
|
|
|
| domains = sorted({f["domain"] for f in dataset_files if f["domain"]})
|
| years = sorted({f["year"] for f in dataset_files if f["year"]})
|
| modalities = sorted({f["modality"] for f in dataset_files if f["modality"]})
|
| datatypes = sorted({f["datatype"] for f in dataset_files if f["datatype"]})
|
|
|
| domain_cb["values"] = ["All"] + domains
|
| year_cb["values"] = ["All"] + years
|
| modality_cb["values"] = ["All"] + modalities
|
| datatype_cb["values"] = ["All"] + datatypes
|
|
|
| domain_var.set("All")
|
| year_var.set("All")
|
| modality_var.set("All")
|
| datatype_var.set("All")
|
|
|
| apply_filters()
|
|
|
| status_label.config(text=f"Loaded {len(dataset_files)} ZIP files from FLAIR-HUB (tiles + metadata).")
|
| append_log("=== Dataset loaded: FLAIR-HUB (data/*.zip + GLOBAL_ALL_MTD.zip) ===")
|
|
|
|
|
|
|
|
|
|
|
|
|
| def stop_download():
|
| stop_flag.set()
|
| status_label.config(text="⏹ Stop requested. Finishing current file…")
|
| stop_btn.config(state="disabled")
|
| append_log("⛔ Stop requested by user.")
|
|
|
|
|
| def download_selected():
|
| folder = download_path.get().strip()
|
| os.makedirs(folder, exist_ok=True)
|
|
|
| files_to_download = [
|
| iid for iid in file_tree.get_children("")
|
| if checkbox_state.get(iid, False)
|
| ]
|
|
|
| if not files_to_download:
|
| messagebox.showinfo("No Selection", "No files selected (in current filter).")
|
| return
|
|
|
| total = len(files_to_download)
|
| stop_flag.clear()
|
|
|
| download_btn.config(state="disabled")
|
| select_all_btn.config(state="disabled")
|
| unselect_all_btn.config(state="disabled")
|
| browse_btn.config(state="disabled")
|
| stop_btn.config(state="normal")
|
|
|
| progress["mode"] = "indeterminate"
|
| progress.start(15)
|
| status_label.config(text=f"🚀 Launching download: {total} file(s)…")
|
| append_log(f"=== Download session started: {total} file(s) ===")
|
|
|
| def worker():
|
| t_session = time.time()
|
| processed = 0
|
|
|
| for index, fid in enumerate(files_to_download, start=1):
|
| if stop_flag.is_set():
|
| append_log("⛔ Download stopped by user.")
|
| break
|
|
|
| processed += 1
|
|
|
| meta = next((f for f in dataset_files if f["path"] == fid), None)
|
| name = meta["name"] if meta else fid
|
| planned = meta["size_bytes"] if meta else None
|
| size_info = human_bytes(planned) if planned else "unknown"
|
|
|
| def set_label(f=name, i=index):
|
| status_label.config(text=f"({i}/{total}) Downloading: {f}")
|
| root.after(0, set_label)
|
|
|
| root.after(
|
| 0,
|
| lambda f=name, i=index, s=size_info: append_log(
|
| f"▶ [{i}/{total}] {f} :: size ~ {s}"
|
| ),
|
| )
|
|
|
| t0 = time.time()
|
| local_path = None
|
| error = None
|
|
|
| try:
|
| local_path = hf_hub_download(
|
| repo_id=DATASET_ID,
|
| repo_type="dataset",
|
| filename=fid,
|
| local_dir=folder,
|
| force_download=True,
|
| )
|
| except Exception as e:
|
| error = e
|
|
|
| elapsed = max(time.time() - t0, 1e-3)
|
|
|
| size_bytes = planned
|
| if size_bytes is None and local_path and os.path.exists(local_path):
|
| try:
|
| size_bytes = os.path.getsize(local_path)
|
| except OSError:
|
| size_bytes = None
|
|
|
| if size_bytes and elapsed > 0:
|
| speed_mbps = (size_bytes / elapsed) / (1024 * 1024)
|
| else:
|
| speed_mbps = None
|
|
|
| if error is None:
|
| size_h = human_bytes(size_bytes)
|
| if speed_mbps is not None:
|
| summary = f" ✅ Avg speed: {speed_mbps:.1f} MB/s | {size_h} in {elapsed:.1f}s"
|
| else:
|
| summary = f" ✅ {size_h} in {elapsed:.1f}s"
|
| else:
|
| summary = f" ❌ ERROR: {error}"
|
|
|
| def push_summary(line=summary):
|
| append_log(line)
|
| append_log("")
|
| root.after(0, push_summary)
|
|
|
| def finish():
|
| progress.stop()
|
| stop_btn.config(state="disabled")
|
| download_btn.config(state="normal")
|
| select_all_btn.config(state="normal")
|
| unselect_all_btn.config(state="normal")
|
| browse_btn.config(state="normal")
|
|
|
| session_time = time.time() - t_session
|
| append_log(f"=== Download session ended :: {session_time:.1f}s ===")
|
|
|
| if stop_flag.is_set():
|
| status_label.config(text="⛔ Download stopped.")
|
| messagebox.showinfo("Stopped", "Downloads were stopped.")
|
| else:
|
| status_label.config(text=f"✅ Completed. Processed {processed} file(s).")
|
| messagebox.showinfo(
|
| "Download Complete",
|
| f"Download finished.\nProcessed {processed} file(s) in {session_time:.1f}s.",
|
| )
|
|
|
| root.after(0, finish)
|
|
|
| threading.Thread(target=worker, daemon=True).start()
|
|
|
|
|
|
|
|
|
|
|
|
|
| select_all_btn.config(command=lambda: toggle_all(True))
|
| unselect_all_btn.config(command=lambda: toggle_all(False))
|
| download_btn.config(command=download_selected)
|
| stop_btn.config(command=stop_download)
|
|
|
| domain_cb.bind("<<ComboboxSelected>>", apply_filters)
|
| year_cb.bind("<<ComboboxSelected>>", apply_filters)
|
| modality_cb.bind("<<ComboboxSelected>>", apply_filters)
|
| datatype_cb.bind("<<ComboboxSelected>>", apply_filters)
|
|
|
| load_dataset()
|
|
|
| root.mainloop()
|
|
|
