CDS Request UI

2025-02-25 00:34 UTC o3-mini-high Open in ChatGPT ↗

You

create a python simple UI copying exactly the ui of Copernicus datastore that will help me easily create CDS requests

https://cds.climate.copernicus.eu/datasets/reanalysis-era5-land?tab=download

ChatGPT

Below is an example of how you might build a Python desktop application—using Tkinter—that mimics the key elements of the Copernicus Data Store download page for reanalysis-era5-land. This simple UI lets you choose (or enter) the dataset parameters (such as variable, date, time, area, and file format) and then “generates” a JSON‐formatted CDS request. You can later pass this JSON to the CDS API.

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # Title label (mimicking the header of the Copernicus page)
        title_label = ttk.Label(root, text="Copernicus Data Store – Reanalysis ERA5 Land", font=("Arial", 16, "bold"))
        title_label.pack(pady=10)

        # Dataset frame (the dataset is pre-defined)
        dataset_frame = ttk.Frame(root)
        dataset_frame.pack(pady=5, fill='x', padx=10)
        ttk.Label(dataset_frame, text="Dataset:").grid(row=0, column=0, sticky="w")
        self.dataset_var = tk.StringVar(value="reanalysis-era5-land")
        dataset_entry = ttk.Entry(dataset_frame, textvariable=self.dataset_var, state='readonly', width=30)
        dataset_entry.grid(row=0, column=1, sticky="w")

        # Variable selection (dropdown similar to the online options)
        variable_frame = ttk.Labelframe(root, text="Variable")
        variable_frame.pack(pady=5, fill='x', padx=10)
        self.variable_options = ["2m_temperature", "2m_dewpoint_temperature", "total_precipitation", "snowfall"]
        self.selected_variable = tk.StringVar(value=self.variable_options[0])
        variable_dropdown = ttk.Combobox(variable_frame, textvariable=self.selected_variable,
                                         values=self.variable_options, state='readonly', width=28)
        variable_dropdown.pack(pady=5, padx=10)

        # Year input (for simplicity, a text entry is used)
        year_frame = ttk.Labelframe(root, text="Year")
        year_frame.pack(pady=5, fill='x', padx=10)
        self.year_var = tk.StringVar()
        year_entry = ttk.Entry(year_frame, textvariable=self.year_var, width=10)
        year_entry.insert(0, "2020")
        year_entry.pack(pady=5, padx=10)

        # Month input
        month_frame = ttk.Labelframe(root, text="Month")
        month_frame.pack(pady=5, fill='x', padx=10)
        self.month_var = tk.StringVar()
        month_entry = ttk.Entry(month_frame, textvariable=self.month_var, width=10)
        month_entry.insert(0, "01")
        month_entry.pack(pady=5, padx=10)

        # Day input
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(pady=5, fill='x', padx=10)
        self.day_var = tk.StringVar()
        day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=10)
        day_entry.insert(0, "01")
        day_entry.pack(pady=5, padx=10)

        # Time input (HH:MM format)
        time_frame = ttk.Labelframe(root, text="Time (HH:MM)")
        time_frame.pack(pady=5, fill='x', padx=10)
        self.time_var = tk.StringVar()
        time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=10)
        time_entry.insert(0, "12:00")
        time_entry.pack(pady=5, padx=10)

        # Area input – four text fields for [North, West, South, East]
        area_frame = ttk.Labelframe(root, text="Area (North, West, South, East)")
        area_frame.pack(pady=5, fill='x', padx=10)
        self.area_vars = [tk.StringVar(), tk.StringVar(), tk.StringVar(), tk.StringVar()]
        labels = ["North", "West", "South", "East"]
        for i, label in enumerate(labels):
            ttk.Label(area_frame, text=label).grid(row=0, column=i, padx=5)
            entry = ttk.Entry(area_frame, textvariable=self.area_vars[i], width=8)
            entry.grid(row=1, column=i, padx=5, pady=5)
            # Optionally, you could pre-fill these with default coordinates

        # Format selection (dropdown for output file type)
        format_frame = ttk.Labelframe(root, text="Format")
        format_frame.pack(pady=5, fill='x', padx=10)
        self.format_options = ["netcdf", "grib"]
        self.selected_format = tk.StringVar(value=self.format_options[0])
        format_dropdown = ttk.Combobox(format_frame, textvariable=self.selected_format,
                                       values=self.format_options, state='readonly', width=28)
        format_dropdown.pack(pady=5, padx=10)

        # Button to generate the CDS request
        generate_button = ttk.Button(root, text="Generate CDS Request", command=self.generate_request)
        generate_button.pack(pady=10)

        # Text area to display the resulting JSON
        self.output_text = tk.Text(root, height=10, width=80)
        self.output_text.pack(pady=5, padx=10)

    def generate_request(self):
        # Build the request dictionary using all the values from the UI
        request = {
            "dataset": self.dataset_var.get(),
            "variable": self.selected_variable.get(),
            "year": self.year_var.get(),
            "month": self.month_var.get(),
            "day": self.day_var.get(),
            "time": self.time_var.get(),
            "area": [var.get() for var in self.area_vars if var.get() != ""],
            "format": self.selected_format.get()
        }
        # Convert the dictionary into a pretty-printed JSON string
        request_json = json.dumps(request, indent=4)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, request_json)
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    app = CDSRequestUI(root)
    root.mainloop()

How It Works

• Dataset & Variable: The dataset is fixed as reanalysis-era5-land (as seen on the CDS page) and the variable is chosen from a dropdown list (feel free to add more options).
• Date & Time: Separate entries let you specify the year, month, day, and time.
• Area: Four fields allow you to enter the geographic bounding box (North, West, South, East).
• Format: A dropdown lets you choose the desired file format (e.g. netcdf or grib).
• Generate Button: When clicked, the button gathers all input values, builds a JSON-formatted request, and displays it in the text box.

You can extend or adjust the interface (for example, by using multiple selection widgets or more complex layouts) so that it exactly matches the CDS webpage as needed. This example should serve as a strong starting point for building a Python tool that helps you easily create CDS requests.

You

although the window is created, I see nothing

ChatGPT

If the window appears but you see nothing inside, here are a few troubleshooting tips and adjustments to try:

1. Set an Explicit Window Size:
   Sometimes the window may be too small for its contents. Try setting a default size using the geometry method:

   root = tk.Tk()
   root.geometry("800x600")

   This forces the window to be 800×600 pixels, which can help reveal the widgets.

2. Check Your Environment:
   Make sure you’re running the script in a standard Python environment (for example, via a terminal or command prompt) rather than an IDE that might have its own event loop (like Jupyter Notebook). Some IDEs or notebooks don’t always handle Tkinter windows as expected.

3. Verify No Errors Occur:
   Confirm there are no errors in your console that might stop widget creation before the main loop starts.

Below is an updated version of the code that sets an explicit window size:

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # Title label
        title_label = ttk.Label(root, text="Copernicus Data Store – Reanalysis ERA5 Land", font=("Arial", 16, "bold"))
        title_label.pack(pady=10)

        # Dataset frame
        dataset_frame = ttk.Frame(root)
        dataset_frame.pack(pady=5, fill='x', padx=10)
        ttk.Label(dataset_frame, text="Dataset:").grid(row=0, column=0, sticky="w")
        self.dataset_var = tk.StringVar(value="reanalysis-era5-land")
        dataset_entry = ttk.Entry(dataset_frame, textvariable=self.dataset_var, state='readonly', width=30)
        dataset_entry.grid(row=0, column=1, sticky="w")

        # Variable selection
        variable_frame = ttk.Labelframe(root, text="Variable")
        variable_frame.pack(pady=5, fill='x', padx=10)
        self.variable_options = ["2m_temperature", "2m_dewpoint_temperature", "total_precipitation", "snowfall"]
        self.selected_variable = tk.StringVar(value=self.variable_options[0])
        variable_dropdown = ttk.Combobox(variable_frame, textvariable=self.selected_variable,
                                         values=self.variable_options, state='readonly', width=28)
        variable_dropdown.pack(pady=5, padx=10)

        # Year input
        year_frame = ttk.Labelframe(root, text="Year")
        year_frame.pack(pady=5, fill='x', padx=10)
        self.year_var = tk.StringVar()
        year_entry = ttk.Entry(year_frame, textvariable=self.year_var, width=10)
        year_entry.insert(0, "2020")
        year_entry.pack(pady=5, padx=10)

        # Month input
        month_frame = ttk.Labelframe(root, text="Month")
        month_frame.pack(pady=5, fill='x', padx=10)
        self.month_var = tk.StringVar()
        month_entry = ttk.Entry(month_frame, textvariable=self.month_var, width=10)
        month_entry.insert(0, "01")
        month_entry.pack(pady=5, padx=10)

        # Day input
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(pady=5, fill='x', padx=10)
        self.day_var = tk.StringVar()
        day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=10)
        day_entry.insert(0, "01")
        day_entry.pack(pady=5, padx=10)

        # Time input (HH:MM format)
        time_frame = ttk.Labelframe(root, text="Time (HH:MM)")
        time_frame.pack(pady=5, fill='x', padx=10)
        self.time_var = tk.StringVar()
        time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=10)
        time_entry.insert(0, "12:00")
        time_entry.pack(pady=5, padx=10)

        # Area input – four text fields for [North, West, South, East]
        area_frame = ttk.Labelframe(root, text="Area (North, West, South, East)")
        area_frame.pack(pady=5, fill='x', padx=10)
        self.area_vars = [tk.StringVar(), tk.StringVar(), tk.StringVar(), tk.StringVar()]
        labels = ["North", "West", "South", "East"]
        for i, label in enumerate(labels):
            ttk.Label(area_frame, text=label).grid(row=0, column=i, padx=5)
            entry = ttk.Entry(area_frame, textvariable=self.area_vars[i], width=8)
            entry.grid(row=1, column=i, padx=5, pady=5)

        # Format selection
        format_frame = ttk.Labelframe(root, text="Format")
        format_frame.pack(pady=5, fill='x', padx=10)
        self.format_options = ["netcdf", "grib"]
        self.selected_format = tk.StringVar(value=self.format_options[0])
        format_dropdown = ttk.Combobox(format_frame, textvariable=self.selected_format,
                                       values=self.format_options, state='readonly', width=28)
        format_dropdown.pack(pady=5, padx=10)

        # Generate button
        generate_button = ttk.Button(root, text="Generate CDS Request", command=self.generate_request)
        generate_button.pack(pady=10)

        # Output text area
        self.output_text = tk.Text(root, height=10, width=80)
        self.output_text.pack(pady=5, padx=10)

    def generate_request(self):
        request = {
            "dataset": self.dataset_var.get(),
            "variable": self.selected_variable.get(),
            "year": self.year_var.get(),
            "month": self.month_var.get(),
            "day": self.day_var.get(),
            "time": self.time_var.get(),
            "area": [var.get() for var in self.area_vars if var.get() != ""],
            "format": self.selected_format.get()
        }
        request_json = json.dumps(request, indent=4)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, request_json)
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("800x600")  # Set a default size for the window
    app = CDSRequestUI(root)
    root.mainloop()

Try running this updated script. If you still see nothing inside the window, let me know what environment you’re using (for example, the operating system, Python version, and IDE) so I can help troubleshoot further.

You

Add the ability to select all days of a month, and to select years using radio buttons/toggles like on the ads webpage

ChatGPT

Below is an updated version of the code that adds two new features:

1. Year Selection via Toggle Buttons:
   Instead of a free-form text entry for the year, a set of checkbuttons is provided so you can toggle one or more years (mimicking the toggle behavior on the CDS page).

2. All Days Option:
   In the “Day” frame you now see a text entry for a specific day and a checkbutton labeled “All Days.” When the toggle is active, the day entry is disabled and the generated request will mark the day as “all.”

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # Title label
        title_label = ttk.Label(root, text="Copernicus Data Store – Reanalysis ERA5 Land", font=("Arial", 16, "bold"))
        title_label.pack(pady=10)

        # Dataset frame
        dataset_frame = ttk.Frame(root)
        dataset_frame.pack(pady=5, fill='x', padx=10)
        ttk.Label(dataset_frame, text="Dataset:").grid(row=0, column=0, sticky="w")
        self.dataset_var = tk.StringVar(value="reanalysis-era5-land")
        dataset_entry = ttk.Entry(dataset_frame, textvariable=self.dataset_var, state='readonly', width=30)
        dataset_entry.grid(row=0, column=1, sticky="w")

        # Variable selection
        variable_frame = ttk.Labelframe(root, text="Variable")
        variable_frame.pack(pady=5, fill='x', padx=10)
        self.variable_options = ["2m_temperature", "2m_dewpoint_temperature", "total_precipitation", "snowfall"]
        self.selected_variable = tk.StringVar(value=self.variable_options[0])
        variable_dropdown = ttk.Combobox(variable_frame, textvariable=self.selected_variable,
                                         values=self.variable_options, state='readonly', width=28)
        variable_dropdown.pack(pady=5, padx=10)

        # Year selection using toggle (check) buttons
        year_frame = ttk.Labelframe(root, text="Select Year(s)")
        year_frame.pack(pady=5, fill='x', padx=10)
        self.year_options = ["2020", "2021", "2022", "2023"]
        self.year_vars = {}
        for i, year in enumerate(self.year_options):
            var = tk.BooleanVar(value=False)
            self.year_vars[year] = var
            cb = ttk.Checkbutton(year_frame, text=year, variable=var)
            cb.grid(row=0, column=i, padx=5, pady=5)

        # Month input
        month_frame = ttk.Labelframe(root, text="Month")
        month_frame.pack(pady=5, fill='x', padx=10)
        self.month_var = tk.StringVar()
        month_entry = ttk.Entry(month_frame, textvariable=self.month_var, width=10)
        month_entry.insert(0, "01")
        month_entry.pack(pady=5, padx=10)

        # Day input with "All Days" toggle
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(pady=5, fill='x', padx=10)
        self.day_var = tk.StringVar()
        self.day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=10)
        self.day_entry.insert(0, "01")
        self.day_entry.grid(row=0, column=0, padx=5, pady=5)
        self.all_days_var = tk.BooleanVar(value=False)
        all_days_cb = ttk.Checkbutton(day_frame, text="All Days", variable=self.all_days_var, command=self.toggle_day_entry)
        all_days_cb.grid(row=0, column=1, padx=5, pady=5)

        # Time input
        time_frame = ttk.Labelframe(root, text="Time (HH:MM)")
        time_frame.pack(pady=5, fill='x', padx=10)
        self.time_var = tk.StringVar()
        time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=10)
        time_entry.insert(0, "12:00")
        time_entry.pack(pady=5, padx=10)

        # Area input – four text fields for [North, West, South, East]
        area_frame = ttk.Labelframe(root, text="Area (North, West, South, East)")
        area_frame.pack(pady=5, fill='x', padx=10)
        self.area_vars = [tk.StringVar(), tk.StringVar(), tk.StringVar(), tk.StringVar()]
        labels = ["North", "West", "South", "East"]
        for i, label in enumerate(labels):
            ttk.Label(area_frame, text=label).grid(row=0, column=i, padx=5)
            entry = ttk.Entry(area_frame, textvariable=self.area_vars[i], width=8)
            entry.grid(row=1, column=i, padx=5, pady=5)

        # Format selection
        format_frame = ttk.Labelframe(root, text="Format")
        format_frame.pack(pady=5, fill='x', padx=10)
        self.format_options = ["netcdf", "grib"]
        self.selected_format = tk.StringVar(value=self.format_options[0])
        format_dropdown = ttk.Combobox(format_frame, textvariable=self.selected_format,
                                       values=self.format_options, state='readonly', width=28)
        format_dropdown.pack(pady=5, padx=10)

        # Generate button
        generate_button = ttk.Button(root, text="Generate CDS Request", command=self.generate_request)
        generate_button.pack(pady=10)

        # Output text area
        self.output_text = tk.Text(root, height=10, width=80)
        self.output_text.pack(pady=5, padx=10)

    def toggle_day_entry(self):
        # Disable or enable the day entry based on the All Days toggle
        if self.all_days_var.get():
            self.day_entry.config(state='disabled')
        else:
            self.day_entry.config(state='normal')

    def generate_request(self):
        # Collect selected years from the checkbuttons
        selected_years = [year for year, var in self.year_vars.items() if var.get()]

        # Determine day value: if All Days is selected, use "all"
        day_value = "all" if self.all_days_var.get() else self.day_var.get()

        request = {
            "dataset": self.dataset_var.get(),
            "variable": self.selected_variable.get(),
            "years": selected_years,
            "month": self.month_var.get(),
            "day": day_value,
            "time": self.time_var.get(),
            "area": [var.get() for var in self.area_vars if var.get() != ""],
            "format": self.selected_format.get()
        }
        request_json = json.dumps(request, indent=4)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, request_json)
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("800x600")
    app = CDSRequestUI(root)
    root.mainloop()

How It Works

• Year Selection:
  A frame labeled “Select Year(s)” displays toggle (check) buttons for a list of predefined years. The request gathers all years that have been toggled on.

• Day Selection:
  The day frame shows a text entry (defaulting to “01”) along with a checkbutton. When “All Days” is selected, the day entry is disabled and the request uses "all" for the day.

• Generating the Request:
  Clicking the Generate CDS Request button collects all selections, builds a JSON object (with "years" as a list and "day" as either a single value or "all"), and displays it.

Feel free to adjust the list of years, variables, or any other parameters as needed.

You

like this

ChatGPT

Below is a sample Tkinter application that creates a UI similar to the CDS “Year” and “Month” selection (as shown in your screenshot), with:

• Year checkbuttons from 1950 to 2025 (arranged in a grid).
• A “Clear all” link/button for Year.
• Month checkbuttons for all 12 months (arranged in a row or two rows).
• A “Clear all” link/button for Month.
• Other parameters (e.g., variable, day, time, area, format) are kept from previous examples, but feel free to remove or modify them to suit your needs.

---

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # Title label
        title_label = ttk.Label(root, text="Copernicus Data Store – Reanalysis ERA5 Land",
                                font=("Arial", 16, "bold"))
        title_label.pack(pady=10)

        # Dataset frame
        dataset_frame = ttk.Frame(root)
        dataset_frame.pack(pady=5, fill='x', padx=10)
        ttk.Label(dataset_frame, text="Dataset:").grid(row=0, column=0, sticky="w")
        self.dataset_var = tk.StringVar(value="reanalysis-era5-land")
        dataset_entry = ttk.Entry(dataset_frame, textvariable=self.dataset_var,
                                  state='readonly', width=30)
        dataset_entry.grid(row=0, column=1, sticky="w")

        # Variable selection
        variable_frame = ttk.Labelframe(root, text="Variable")
        variable_frame.pack(pady=5, fill='x', padx=10)
        self.variable_options = ["2m_temperature", "2m_dewpoint_temperature",
                                 "total_precipitation", "snowfall"]
        self.selected_variable = tk.StringVar(value=self.variable_options[0])
        variable_dropdown = ttk.Combobox(variable_frame, textvariable=self.selected_variable,
                                         values=self.variable_options, state='readonly', width=28)
        variable_dropdown.pack(pady=5, padx=10)

        # YEAR SELECTION (1950 - 2025) with "Clear all" link
        year_container = ttk.Labelframe(root, text="Year")
        year_container.pack(pady=5, fill='x', padx=10)

        # A frame at the top for the label + "Clear all" link
        top_year_frame = ttk.Frame(year_container)
        top_year_frame.pack(fill='x', padx=5, pady=5)

        self.clear_years_btn = ttk.Button(top_year_frame, text="Clear all",
                                          command=self.clear_all_years)
        self.clear_years_btn.pack(side="right")

        # Grid of year checkbuttons
        years_frame = ttk.Frame(year_container)
        years_frame.pack(pady=5, padx=5)

        self.start_year = 1950
        self.end_year = 2025
        self.year_vars = {}
        years_list = range(self.start_year, self.end_year + 1)

        num_cols = 8  # how many columns you want in the grid
        for idx, yr in enumerate(years_list):
            var = tk.BooleanVar(value=False)
            self.year_vars[yr] = var
            cb = ttk.Checkbutton(years_frame, text=str(yr), variable=var)
            row = idx // num_cols
            col = idx % num_cols
            cb.grid(row=row, column=col, padx=5, pady=2, sticky="w")

        # MONTH SELECTION (January - December) with "Clear all" link
        month_container = ttk.Labelframe(root, text="Month")
        month_container.pack(pady=5, fill='x', padx=10)

        # A frame at the top for the label + "Clear all" link
        top_month_frame = ttk.Frame(month_container)
        top_month_frame.pack(fill='x', padx=5, pady=5)

        self.clear_months_btn = ttk.Button(top_month_frame, text="Clear all",
                                           command=self.clear_all_months)
        self.clear_months_btn.pack(side="right")

        months_frame = ttk.Frame(month_container)
        months_frame.pack(pady=5, padx=5)

        self.month_list = ["January", "February", "March", "April", "May", "June",
                           "July", "August", "September", "October", "November", "December"]
        self.month_vars = {}
        for i, m in enumerate(self.month_list):
            var = tk.BooleanVar(value=False)
            self.month_vars[m] = var
            cb = ttk.Checkbutton(months_frame, text=m, variable=var)
            cb.grid(row=0, column=i, padx=5, pady=2, sticky="w")

        # Day input with "All Days" toggle (optional)
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(pady=5, fill='x', padx=10)
        self.day_var = tk.StringVar()
        self.day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=10)
        self.day_entry.insert(0, "01")
        self.day_entry.grid(row=0, column=0, padx=5, pady=5)
        self.all_days_var = tk.BooleanVar(value=False)
        all_days_cb = ttk.Checkbutton(day_frame, text="All Days",
                                      variable=self.all_days_var,
                                      command=self.toggle_day_entry)
        all_days_cb.grid(row=0, column=1, padx=5, pady=5)

        # Time input
        time_frame = ttk.Labelframe(root, text="Time (HH:MM)")
        time_frame.pack(pady=5, fill='x', padx=10)
        self.time_var = tk.StringVar()
        time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=10)
        time_entry.insert(0, "12:00")
        time_entry.pack(pady=5, padx=10)

        # Area input – four text fields for [North, West, South, East]
        area_frame = ttk.Labelframe(root, text="Area (North, West, South, East)")
        area_frame.pack(pady=5, fill='x', padx=10)
        self.area_vars = [tk.StringVar(), tk.StringVar(), tk.StringVar(), tk.StringVar()]
        labels = ["North", "West", "South", "East"]
        for i, label in enumerate(labels):
            ttk.Label(area_frame, text=label).grid(row=0, column=i, padx=5)
            entry = ttk.Entry(area_frame, textvariable=self.area_vars[i], width=8)
            entry.grid(row=1, column=i, padx=5, pady=5)

        # Format selection
        format_frame = ttk.Labelframe(root, text="Format")
        format_frame.pack(pady=5, fill='x', padx=10)
        self.format_options = ["netcdf", "grib"]
        self.selected_format = tk.StringVar(value=self.format_options[0])
        format_dropdown = ttk.Combobox(format_frame, textvariable=self.selected_format,
                                       values=self.format_options, state='readonly', width=28)
        format_dropdown.pack(pady=5, padx=10)

        # Generate button
        generate_button = ttk.Button(root, text="Generate CDS Request",
                                     command=self.generate_request)
        generate_button.pack(pady=10)

        # Output text area
        self.output_text = tk.Text(root, height=10, width=80)
        self.output_text.pack(pady=5, padx=10)

    # -- Utility methods --

    def toggle_day_entry(self):
        """Disable or enable the day entry based on the All Days toggle."""
        if self.all_days_var.get():
            self.day_entry.config(state='disabled')
        else:
            self.day_entry.config(state='normal')

    def clear_all_years(self):
        """Uncheck all year checkbuttons."""
        for yr in self.year_vars:
            self.year_vars[yr].set(False)

    def clear_all_months(self):
        """Uncheck all month checkbuttons."""
        for m in self.month_vars:
            self.month_vars[m].set(False)

    def generate_request(self):
        """Build and display the request JSON from the current UI selections."""
        # Collect selected years
        selected_years = [str(yr) for yr, var in self.year_vars.items() if var.get()]

        # Collect selected months
        selected_months = [m for m, var in self.month_vars.items() if var.get()]

        # Day selection
        day_value = "all" if self.all_days_var.get() else self.day_var.get()

        # Build the request dictionary
        request = {
            "dataset": self.dataset_var.get(),
            "variable": self.selected_variable.get(),
            "years": selected_years,
            "months": selected_months,
            "day": day_value,
            "time": self.time_var.get(),
            "area": [v.get() for v in self.area_vars if v.get() != ""],
            "format": self.selected_format.get()
        }

        # Convert to pretty-printed JSON
        request_json = json.dumps(request, indent=4)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, request_json)
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("900x800")  # Make the window large enough
    app = CDSRequestUI(root)
    root.mainloop()

Explanation

1. Year Selection

   • A Labelframe titled “Year” holds a grid of checkbuttons from 1950 to 2025.
   • Each year is a BooleanVar, stored in self.year_vars.
   • The “Clear all” button calls clear_all_years(), which sets each year’s BooleanVar to False.

2. Month Selection

   • Another Labelframe titled “Month” holds a row of checkbuttons for all 12 months.
   • Each month is also a BooleanVar, stored in self.month_vars.
   • The “Clear all” button calls clear_all_months(), which sets each month’s BooleanVar to False.

3. Day + “All Days”

   • A text entry lets you type a specific day.
   • A Checkbutton labeled “All Days” disables the day entry if checked and sets the day to "all" in the final request.

4. Other Fields

   • Time: Simple entry for HH:MM.
   • Area: Four entries for bounding box coordinates (North, West, South, East).
   • Format: A dropdown for netcdf or grib.

5. Generate Request

   • Clicking Generate CDS Request gathers all selections, creates a JSON structure, and displays it in the text box.

This layout mimics the “Year” and “Month” selection style from your screenshot. Feel free to tweak spacing, fonts, or the exact arrangement of widgets to more closely match the Copernicus Data Store appearance.

You

1.optimise the grid to take the least amount of vertical space 2.add vertical scrolling 3. the months should appear as indices on the request, not as strings

ChatGPT

Below is an updated version of the Tkinter application that addresses your three requests:

1. Optimize the year grid to take minimal vertical space (by increasing the number of columns).
2. Add vertical scrolling for the year list, in case the user’s window or screen is smaller.
3. Use month indices in the request (1–12) instead of month names.

---

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # Title label
        title_label = ttk.Label(
            root,
            text="Copernicus Data Store – Reanalysis ERA5 Land",
            font=("Arial", 16, "bold")
        )
        title_label.pack(pady=10)

        # Dataset frame
        dataset_frame = ttk.Frame(root)
        dataset_frame.pack(pady=5, fill='x', padx=10)
        ttk.Label(dataset_frame, text="Dataset:").grid(row=0, column=0, sticky="w")
        self.dataset_var = tk.StringVar(value="reanalysis-era5-land")
        dataset_entry = ttk.Entry(
            dataset_frame,
            textvariable=self.dataset_var,
            state='readonly',
            width=30
        )
        dataset_entry.grid(row=0, column=1, sticky="w")

        # Variable selection
        variable_frame = ttk.Labelframe(root, text="Variable")
        variable_frame.pack(pady=5, fill='x', padx=10)
        self.variable_options = ["2m_temperature", "2m_dewpoint_temperature",
                                 "total_precipitation", "snowfall"]
        self.selected_variable = tk.StringVar(value=self.variable_options[0])
        variable_dropdown = ttk.Combobox(
            variable_frame,
            textvariable=self.selected_variable,
            values=self.variable_options,
            state='readonly',
            width=28
        )
        variable_dropdown.pack(pady=5, padx=10)

        # -- YEAR SELECTION WITH SCROLLING --
        year_container = ttk.Labelframe(root, text="Year")
        # Fill horizontally AND vertically, so the frame can expand and scroll
        year_container.pack(pady=5, fill='both', expand=True, padx=10)

        # A canvas for scrolling
        self.year_canvas = tk.Canvas(year_container)
        self.year_canvas.pack(side="left", fill="both", expand=True)

        # Scrollbar
        self.year_scrollbar = ttk.Scrollbar(
            year_container,
            orient="vertical",
            command=self.year_canvas.yview
        )
        self.year_scrollbar.pack(side="right", fill="y")
        self.year_canvas.configure(yscrollcommand=self.year_scrollbar.set)

        # A frame inside the canvas where checkbuttons will go
        self.years_frame = ttk.Frame(self.year_canvas)
        # Create a window in the canvas to hold that frame
        self.year_canvas.create_window((0, 0), window=self.years_frame, anchor="nw")

        # Bind the frame's size change to update the scroll region
        self.years_frame.bind("<Configure>", self._on_years_frame_configure)

        # "Clear all" link for years
        top_year_frame = ttk.Frame(self.years_frame)
        top_year_frame.grid(row=0, column=0, columnspan=999, sticky="w", padx=5, pady=5)
        self.clear_years_btn = ttk.Button(
            top_year_frame, text="Clear all", command=self.clear_all_years
        )
        self.clear_years_btn.pack(side="right")

        # Year checkbuttons: 1950–2025
        self.start_year = 1950
        self.end_year = 2025
        self.year_vars = {}
        years_list = range(self.start_year, self.end_year + 1)

        # Increase columns to minimize vertical space
        num_cols = 12
        # We start placing year checkbuttons at row=1 to leave row=0 for the "Clear all" button
        row_offset = 1

        for idx, yr in enumerate(years_list):
            var = tk.BooleanVar(value=False)
            self.year_vars[yr] = var
            cb = ttk.Checkbutton(self.years_frame, text=str(yr), variable=var)
            # Compute row & column
            row = (idx // num_cols) + row_offset
            col = idx % num_cols
            cb.grid(row=row, column=col, padx=5, pady=2, sticky="w")

        # -- MONTH SELECTION (AS INDICES) --
        month_container = ttk.Labelframe(root, text="Month")
        month_container.pack(pady=5, fill='x', padx=10)

        top_month_frame = ttk.Frame(month_container)
        top_month_frame.pack(fill='x', padx=5, pady=5)

        self.clear_months_btn = ttk.Button(
            top_month_frame, text="Clear all", command=self.clear_all_months
        )
        self.clear_months_btn.pack(side="right")

        months_frame = ttk.Frame(month_container)
        months_frame.pack(pady=5, padx=5)

        # Month list with indices (1..12) instead of names
        self.month_list = [
            (1, "January"),   (2, "February"), (3, "March"),    (4, "April"),
            (5, "May"),       (6, "June"),     (7, "July"),     (8, "August"),
            (9, "September"), (10, "October"), (11, "November"), (12, "December")
        ]
        self.month_vars = {}
        for i, (m_idx, m_name) in enumerate(self.month_list):
            var = tk.BooleanVar(value=False)
            self.month_vars[m_idx] = var
            cb = ttk.Checkbutton(months_frame, text=m_name, variable=var)
            cb.grid(row=0, column=i, padx=5, pady=2, sticky="w")

        # Day input with "All Days" toggle
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(pady=5, fill='x', padx=10)
        self.day_var = tk.StringVar()
        self.day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=10)
        self.day_entry.insert(0, "01")
        self.day_entry.grid(row=0, column=0, padx=5, pady=5)
        self.all_days_var = tk.BooleanVar(value=False)
        all_days_cb = ttk.Checkbutton(
            day_frame, text="All Days", variable=self.all_days_var,
            command=self.toggle_day_entry
        )
        all_days_cb.grid(row=0, column=1, padx=5, pady=5)

        # Time input
        time_frame = ttk.Labelframe(root, text="Time (HH:MM)")
        time_frame.pack(pady=5, fill='x', padx=10)
        self.time_var = tk.StringVar()
        time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=10)
        time_entry.insert(0, "12:00")
        time_entry.pack(pady=5, padx=10)

        # Area input – four text fields for [North, West, South, East]
        area_frame = ttk.Labelframe(root, text="Area (North, West, South, East)")
        area_frame.pack(pady=5, fill='x', padx=10)
        self.area_vars = [tk.StringVar(), tk.StringVar(), tk.StringVar(), tk.StringVar()]
        labels = ["North", "West", "South", "East"]
        for i, label in enumerate(labels):
            ttk.Label(area_frame, text=label).grid(row=0, column=i, padx=5)
            entry = ttk.Entry(area_frame, textvariable=self.area_vars[i], width=8)
            entry.grid(row=1, column=i, padx=5, pady=5)

        # Format selection
        format_frame = ttk.Labelframe(root, text="Format")
        format_frame.pack(pady=5, fill='x', padx=10)
        self.format_options = ["netcdf", "grib"]
        self.selected_format = tk.StringVar(value=self.format_options[0])
        format_dropdown = ttk.Combobox(
            format_frame,
            textvariable=self.selected_format,
            values=self.format_options,
            state='readonly',
            width=28
        )
        format_dropdown.pack(pady=5, padx=10)

        # Generate button
        generate_button = ttk.Button(
            root,
            text="Generate CDS Request",
            command=self.generate_request
        )
        generate_button.pack(pady=10)

        # Output text area
        self.output_text = tk.Text(root, height=10, width=80)
        self.output_text.pack(pady=5, padx=10)

    # -------------------------------------------------------------------------
    # Event Handlers and Utility Methods
    # -------------------------------------------------------------------------
    def _on_years_frame_configure(self, event):
        """
        Update the scrollable region to encompass the entire 'years_frame'.
        """
        self.year_canvas.configure(scrollregion=self.year_canvas.bbox("all"))

    def toggle_day_entry(self):
        """Disable or enable the day entry based on the All Days toggle."""
        if self.all_days_var.get():
            self.day_entry.config(state='disabled')
        else:
            self.day_entry.config(state='normal')

    def clear_all_years(self):
        """Uncheck all year checkbuttons."""
        for yr in self.year_vars:
            self.year_vars[yr].set(False)

    def clear_all_months(self):
        """Uncheck all month checkbuttons."""
        for m in self.month_vars:
            self.month_vars[m].set(False)

    def generate_request(self):
        """Build and display the request JSON from the current UI selections."""
        # Collect selected years
        selected_years = [str(yr) for yr, var in self.year_vars.items() if var.get()]

        # Collect selected months (which are now indices 1..12)
        selected_months = [m_idx for m_idx, var in self.month_vars.items() if var.get()]

        # Day selection
        day_value = "all" if self.all_days_var.get() else self.day_var.get()

        # Build the request dictionary
        request = {
            "dataset": self.dataset_var.get(),
            "variable": self.selected_variable.get(),
            "years": selected_years,
            "months": selected_months,  # This will be a list of integers
            "day": day_value,
            "time": self.time_var.get(),
            "area": [v.get() for v in self.area_vars if v.get() != ""],
            "format": self.selected_format.get()
        }

        # Convert to pretty-printed JSON
        request_json = json.dumps(request, indent=4)
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, request_json)
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    # Make the window large enough so you can see more columns/rows at once
    root.geometry("1000x800")
    app = CDSRequestUI(root)
    root.mainloop()

Key Changes

1. Year Grid With More Columns

   • num_cols = 12 is used to reduce the number of rows, thus minimizing vertical space.
   • You can adjust num_cols to suit your screen or preference (e.g., 15, 20, etc.).

2. Vertical Scrolling for Years

   • A Canvas + Scrollbar combination wraps the frame holding the year checkbuttons (years_frame).
   • When years_frame changes size (bind <Configure>), we update the scroll region so the scrollbar knows how far to scroll.

3. Month Indices

   • Instead of storing "January", "February", ... as strings, we store (1, "January"), (2, "February"), ....
   • In the final request, "months" is a list of integers corresponding to checked months.

You can further tweak the spacing, fonts, and window size to achieve the exact look you want.

You

this is what a valid request looks like {‘variable’: [‘2m_temperature’], ‘year’: ‘2025’, ‘month’: [‘01’], ‘day’: [‘01’, ‘02’, ‘03’, ‘04’, ‘05’, ‘06’, ‘07’, ‘08’, ‘09’, ‘10’, ‘11’, ‘12’, ‘13’, ‘14’, ‘15’, ‘16’, ‘17’, ‘18’, ‘19’, ‘20’, ‘21’, ‘22’, ‘23’, ‘24’, ‘25’, ‘26’, ‘27’, ‘28’, ‘29’, ‘30’, ‘31’], ‘time’: [‘00:00’, ‘01:00’, ‘02:00’, ‘03:00’, ‘04:00’, ‘05:00’, ‘06:00’, ‘07:00’, ‘08:00’, ‘09:00’, ‘10:00’, ‘11:00’, ‘12:00’, ‘13:00’, ‘14:00’, ‘15:00’, ‘16:00’, ‘17:00’, ‘18:00’, ‘19:00’, ‘20:00’, ‘21:00’, ‘22:00’, ‘23:00’], ‘data_format’: ‘grib’, ‘area’: [-20.4281081, -43.28306098, -21.23747331, -42.41469862], ‘download_format’: ‘unarchived’}

ChatGPT

Below is a minimal Tkinter example that creates a UI and produces a request dictionary in exactly the format you showed (including keys like variable, year, month, day, time, data_format, area, and download_format). It also demonstrates “All Days” and “All Hours” toggles to quickly generate lists for all days ('01' to '31') and all hours ('00:00' to '23:00').

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # --- VARIABLE ---
        var_frame = ttk.Labelframe(root, text="Variable")
        var_frame.pack(padx=10, pady=5, fill="x")
        self.variable_var = tk.StringVar(value="2m_temperature")
        ttk.Label(var_frame, text="Variable:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        variable_entry = ttk.Entry(var_frame, textvariable=self.variable_var, width=20)
        variable_entry.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- YEAR ---
        year_frame = ttk.Labelframe(root, text="Year")
        year_frame.pack(padx=10, pady=5, fill="x")
        self.year_var = tk.StringVar(value="2025")
        ttk.Label(year_frame, text="Year:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        year_entry = ttk.Entry(year_frame, textvariable=self.year_var, width=6)
        year_entry.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- MONTH ---
        # We'll store it as a single zero-padded string in a list, e.g. ['01']
        month_frame = ttk.Labelframe(root, text="Month")
        month_frame.pack(padx=10, pady=5, fill="x")
        self.month_var = tk.StringVar(value="01")
        ttk.Label(month_frame, text="Month (01-12):").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        month_entry = ttk.Entry(month_frame, textvariable=self.month_var, width=4)
        month_entry.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- DAY ---
        # "All Days" => ['01', '02', ..., '31']
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(padx=10, pady=5, fill="x")
        self.day_var = tk.StringVar(value="01")
        ttk.Label(day_frame, text="Day (01-31):").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        self.day_entry = ttk.Entry(day_frame, textvariable=self.day_var, width=4)
        self.day_entry.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        self.all_days_var = tk.BooleanVar(value=False)
        all_days_check = ttk.Checkbutton(day_frame, text="All Days", variable=self.all_days_var, command=self.toggle_days)
        all_days_check.grid(row=0, column=2, padx=5, pady=5, sticky="w")

        # --- TIME ---
        # "All Hours" => ['00:00', '01:00', ..., '23:00']
        time_frame = ttk.Labelframe(root, text="Time")
        time_frame.pack(padx=10, pady=5, fill="x")
        self.time_var = tk.StringVar(value="12:00")
        ttk.Label(time_frame, text="Time (HH:MM):").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        self.time_entry = ttk.Entry(time_frame, textvariable=self.time_var, width=6)
        self.time_entry.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        self.all_hours_var = tk.BooleanVar(value=False)
        all_hours_check = ttk.Checkbutton(time_frame, text="All Hours", variable=self.all_hours_var, command=self.toggle_hours)
        all_hours_check.grid(row=0, column=2, padx=5, pady=5, sticky="w")

        # --- DATA FORMAT ---
        format_frame = ttk.Labelframe(root, text="Data Format")
        format_frame.pack(padx=10, pady=5, fill="x")
        self.data_format_var = tk.StringVar(value="grib")  # or "netcdf"
        ttk.Label(format_frame, text="Data Format:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        format_combo = ttk.Combobox(format_frame, textvariable=self.data_format_var,
                                    values=["grib", "netcdf"], state="readonly", width=10)
        format_combo.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- AREA ---
        # We expect a list of 4 floats: [North, West, South, East]
        # The example has negative values, but let's keep it general
        area_frame = ttk.Labelframe(root, text="Area (N, W, S, E)")
        area_frame.pack(padx=10, pady=5, fill="x")
        self.north_var = tk.StringVar(value="-20.4281081")
        self.west_var = tk.StringVar(value="-43.28306098")
        self.south_var = tk.StringVar(value="-21.23747331")
        self.east_var = tk.StringVar(value="-42.41469862")

        ttk.Label(area_frame, text="North:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.north_var, width=10).grid(row=0, column=1, padx=5, pady=5, sticky="w")

        ttk.Label(area_frame, text="West:").grid(row=0, column=2, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.west_var, width=10).grid(row=0, column=3, padx=5, pady=5, sticky="w")

        ttk.Label(area_frame, text="South:").grid(row=1, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.south_var, width=10).grid(row=1, column=1, padx=5, pady=5, sticky="w")

        ttk.Label(area_frame, text="East:").grid(row=1, column=2, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.east_var, width=10).grid(row=1, column=3, padx=5, pady=5, sticky="w")

        # --- DOWNLOAD FORMAT ---
        # The example sets 'download_format': 'unarchived'
        # We'll just fix it as 'unarchived', but you could also make this a combobox.
        self.download_format = "unarchived"

        # --- GENERATE BUTTON ---
        generate_button = ttk.Button(root, text="Generate CDS Request", command=self.generate_request)
        generate_button.pack(pady=10)

        # --- OUTPUT TEXT ---
        self.output_text = tk.Text(root, width=80, height=10)
        self.output_text.pack(padx=10, pady=5)

    # ------------------ TOGGLE LOGIC FOR DAYS/HOURS ------------------
    def toggle_days(self):
        """If 'All Days' is selected, disable the day entry."""
        if self.all_days_var.get():
            self.day_entry.config(state='disabled')
        else:
            self.day_entry.config(state='normal')

    def toggle_hours(self):
        """If 'All Hours' is selected, disable the time entry."""
        if self.all_hours_var.get():
            self.time_entry.config(state='disabled')
        else:
            self.time_entry.config(state='normal')

    # ------------------ GENERATE THE FINAL REQUEST ------------------
    def generate_request(self):
        # variable -> always a list (even if only one item)
        variable_list = [self.variable_var.get()]

        # year -> single string
        year_str = self.year_var.get().strip()

        # month -> single zero-padded string in a list, e.g. ['01']
        month_str = self.month_var.get().strip().zfill(2)
        month_list = [month_str]

        # day -> either a single day in a list, or all 31 days
        if self.all_days_var.get():
            # produce ['01', '02', ..., '31']
            day_list = [f"{d:02d}" for d in range(1, 32)]
        else:
            # single day
            day_str = self.day_var.get().strip().zfill(2)
            day_list = [day_str]

        # time -> either a single time in a list, or all 24 hours
        if self.all_hours_var.get():
            # produce ['00:00','01:00',...,'23:00']
            time_list = [f"{h:02d}:00" for h in range(24)]
        else:
            time_list = [self.time_var.get().strip()]

        # data_format -> from combo
        data_format_str = self.data_format_var.get()

        # area -> 4 floats
        try:
            area_vals = [
                float(self.north_var.get().strip()),
                float(self.west_var.get().strip()),
                float(self.south_var.get().strip()),
                float(self.east_var.get().strip()),
            ]
        except ValueError:
            messagebox.showerror("Error", "Please enter valid numeric values for area.")
            return

        # download_format -> 'unarchived' (fixed for this example)
        download_format_str = self.download_format

        # Build the final request exactly like your example
        request = {
            "variable": variable_list,   # e.g. ['2m_temperature']
            "year": year_str,            # e.g. '2025'
            "month": month_list,         # e.g. ['01']
            "day": day_list,             # e.g. ['01','02','03',...,'31']
            "time": time_list,           # e.g. ['00:00','01:00',...,'23:00']
            "data_format": data_format_str,  # 'grib' or 'netcdf'
            "area": area_vals,           # e.g. [-20.428..., -43.283..., ...]
            "download_format": download_format_str  # e.g. 'unarchived'
        }

        # Display it in the text box
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, json.dumps(request, indent=4))
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("600x700")
    app = CDSRequestUI(root)
    root.mainloop()

Explanation of Key Points

1. variable

   • Always a list (even if only one variable). In the UI, we store a single string but wrap it in a list when generating the request.

2. year

   • A single string (e.g. "2025"). The user can type any valid year into the entry.

3. month

   • A list of zero-padded strings (e.g. ["01"]). In the UI, we take the typed month (like "1"), then zero-pad it ("01") and put it in a list.

4. day

   • If “All Days” is toggled, we generate ["01","02",...,"31"]. Otherwise, we create a single zero-padded string (like ["01"]).

5. time

   • If “All Hours” is toggled, we generate all 24 hours in HH:00 format (["00:00","01:00",...,"23:00"]). Otherwise, we store whatever the user typed in a single-element list.

6. data_format

   • Renamed from the usual "format" key to "data_format", as in your example. The combobox is set to either "grib" or "netcdf".

7. area

   • A list of 4 floats. The user can type in negative or positive numbers. We parse them in the order: [North, West, South, East]. Adjust the order if needed.

8. download_format

   • In your example, it’s always "unarchived". We hard-code that in the code, but you could easily make it a combobox if you need to switch between "archived" and "unarchived".

Running this script will produce a JSON request exactly in the structure you provided once you click Generate CDS Request. Feel free to adjust default values or expand the UI for multiple variables, multiple months, etc.

You

bring back the grid of years and months

ChatGPT

Below is an updated version that “brings back” the grid‐based selection for years and months. In this version, the year grid uses Radiobuttons (so only one year can be selected, as required by the valid request) and the month grid uses Checkbuttons (so you can select one or more months, which will be converted to zero‐padded indices in the request). The year grid is placed in a scrollable canvas to minimize vertical space.

import tkinter as tk
from tkinter import ttk, messagebox
import json

class CDSRequestUI:
    def __init__(self, root):
        self.root = root
        self.root.title("CDS Request Builder")

        # --- VARIABLE ---
        var_frame = ttk.Labelframe(root, text="Variable")
        var_frame.pack(padx=10, pady=5, fill="x")
        self.variable_var = tk.StringVar(value="2m_temperature")
        ttk.Label(var_frame, text="Variable:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        variable_combo = ttk.Combobox(var_frame, textvariable=self.variable_var,
                                      values=["2m_temperature", "2m_dewpoint_temperature", "total_precipitation", "snowfall"],
                                      state="readonly", width=20)
        variable_combo.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- YEAR GRID (Radiobuttons in a scrollable canvas) ---
        year_container = ttk.Labelframe(root, text="Year")
        year_container.pack(padx=10, pady=5, fill="both", expand=True)

        # Canvas and scrollbar for years
        self.year_canvas = tk.Canvas(year_container, height=100)
        self.year_canvas.pack(side="left", fill="both", expand=True)
        year_scrollbar = ttk.Scrollbar(year_container, orient="vertical", command=self.year_canvas.yview)
        year_scrollbar.pack(side="right", fill="y")
        self.year_canvas.configure(yscrollcommand=year_scrollbar.set)

        # Frame inside canvas for radiobuttons
        self.years_frame = ttk.Frame(self.year_canvas)
        self.year_canvas.create_window((0, 0), window=self.years_frame, anchor="nw")
        self.years_frame.bind("<Configure>", lambda e: self.year_canvas.configure(scrollregion=self.year_canvas.bbox("all")))

        # Radiobutton variable for year (only one year can be selected)
        self.year_var = tk.StringVar(value="2025")
        self.start_year = 1950
        self.end_year = 2025
        years_list = [str(y) for y in range(self.start_year, self.end_year + 1)]
        num_cols = 12  # Increase columns to use minimal vertical space
        for idx, yr in enumerate(years_list):
            rb = ttk.Radiobutton(self.years_frame, text=yr, variable=self.year_var, value=yr)
            row = idx // num_cols
            col = idx % num_cols
            rb.grid(row=row, column=col, padx=5, pady=2, sticky="w")

        # Optional: Button to clear year selection (set to empty string)
        clear_years_btn = ttk.Button(self.years_frame, text="Clear", command=lambda: self.year_var.set(""))
        clear_years_btn.grid(row=(len(years_list) // num_cols) + 1, column=0, columnspan=num_cols, sticky="w", padx=5, pady=5)

        # --- MONTH GRID (Checkbuttons) ---
        month_container = ttk.Labelframe(root, text="Month")
        month_container.pack(padx=10, pady=5, fill="x")
        # We'll show months as zero-padded indices ("01", "02", ... "12")
        self.month_vars = {}
        for m in range(1, 13):
            var = tk.BooleanVar(value=False)
            self.month_vars[m] = var
            month_label = f"{m:02d}"
            cb = ttk.Checkbutton(month_container, text=month_label, variable=var)
            cb.grid(row=0, column=m-1, padx=5, pady=2, sticky="w")
        # Optional: Button to clear month selection
        clear_months_btn = ttk.Button(month_container, text="Clear all", command=self.clear_all_months)
        clear_months_btn.grid(row=1, column=0, columnspan=12, pady=5, sticky="w")

        # --- DAY ---
        day_frame = ttk.Labelframe(root, text="Day")
        day_frame.pack(padx=10, pady=5, fill="x")
        self.day_entry = ttk.Entry(day_frame, width=4)
        self.day_entry.insert(0, "01")
        self.day_entry.grid(row=0, column=0, padx=5, pady=5, sticky="w")
        self.all_days_var = tk.BooleanVar(value=False)
        all_days_cb = ttk.Checkbutton(day_frame, text="All Days", variable=self.all_days_var, command=self.toggle_day_entry)
        all_days_cb.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- TIME ---
        time_frame = ttk.Labelframe(root, text="Time")
        time_frame.pack(padx=10, pady=5, fill="x")
        self.time_entry = ttk.Entry(time_frame, width=6)
        self.time_entry.insert(0, "12:00")
        self.time_entry.grid(row=0, column=0, padx=5, pady=5, sticky="w")
        self.all_hours_var = tk.BooleanVar(value=False)
        all_hours_cb = ttk.Checkbutton(time_frame, text="All Hours", variable=self.all_hours_var, command=self.toggle_time_entry)
        all_hours_cb.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- DATA FORMAT ---
        format_frame = ttk.Labelframe(root, text="Data Format")
        format_frame.pack(padx=10, pady=5, fill="x")
        self.data_format_var = tk.StringVar(value="grib")  # or "netcdf"
        ttk.Label(format_frame, text="Data Format:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        format_combo = ttk.Combobox(format_frame, textvariable=self.data_format_var, values=["grib", "netcdf"], state="readonly", width=10)
        format_combo.grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # --- AREA ---
        area_frame = ttk.Labelframe(root, text="Area (N, W, S, E)")
        area_frame.pack(padx=10, pady=5, fill="x")
        self.north_var = tk.StringVar(value="-20.4281081")
        self.west_var = tk.StringVar(value="-43.28306098")
        self.south_var = tk.StringVar(value="-21.23747331")
        self.east_var = tk.StringVar(value="-42.41469862")
        ttk.Label(area_frame, text="North:").grid(row=0, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.north_var, width=10).grid(row=0, column=1, padx=5, pady=5, sticky="w")
        ttk.Label(area_frame, text="West:").grid(row=0, column=2, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.west_var, width=10).grid(row=0, column=3, padx=5, pady=5, sticky="w")
        ttk.Label(area_frame, text="South:").grid(row=1, column=0, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.south_var, width=10).grid(row=1, column=1, padx=5, pady=5, sticky="w")
        ttk.Label(area_frame, text="East:").grid(row=1, column=2, padx=5, pady=5, sticky="w")
        ttk.Entry(area_frame, textvariable=self.east_var, width=10).grid(row=1, column=3, padx=5, pady=5, sticky="w")

        # --- DOWNLOAD FORMAT (fixed) ---
        self.download_format = "unarchived"

        # --- GENERATE BUTTON ---
        generate_button = ttk.Button(root, text="Generate CDS Request", command=self.generate_request)
        generate_button.pack(pady=10)

        # --- OUTPUT TEXT ---
        self.output_text = tk.Text(root, width=80, height=10)
        self.output_text.pack(padx=10, pady=5)

    # --- Utility Methods ---
    def clear_all_months(self):
        for m in self.month_vars:
            self.month_vars[m].set(False)

    def toggle_day_entry(self):
        if self.all_days_var.get():
            self.day_entry.config(state="disabled")
        else:
            self.day_entry.config(state="normal")

    def toggle_time_entry(self):
        if self.all_hours_var.get():
            self.time_entry.config(state="disabled")
        else:
            self.time_entry.config(state="normal")

    def generate_request(self):
        # variable: always a list
        variable_list = [self.variable_var.get()]
        # year: single string (from the radiobutton grid)
        year_str = self.year_var.get().strip()
        if not year_str:
            messagebox.showerror("Error", "Please select a year.")
            return
        # month: checkbuttons return a list of zero-padded strings for selected months
        selected_months = [f"{m:02d}" for m, var in self.month_vars.items() if var.get()]
        if not selected_months:
            messagebox.showerror("Error", "Please select at least one month.")
            return
        # day: either all days or single day in a list
        if self.all_days_var.get():
            day_list = [f"{d:02d}" for d in range(1, 32)]
        else:
            day_str = self.day_entry.get().strip().zfill(2)
            day_list = [day_str]
        # time: either all hours or a single time in a list
        if self.all_hours_var.get():
            time_list = [f"{h:02d}:00" for h in range(24)]
        else:
            time_list = [self.time_entry.get().strip()]
        # data_format: from combobox
        data_format_str = self.data_format_var.get()
        # area: parse the 4 entries as floats
        try:
            area_vals = [float(self.north_var.get().strip()),
                         float(self.west_var.get().strip()),
                         float(self.south_var.get().strip()),
                         float(self.east_var.get().strip())]
        except ValueError:
            messagebox.showerror("Error", "Please enter valid numeric values for area.")
            return

        # Build the final request dictionary
        request = {
            "variable": variable_list,        # e.g. ['2m_temperature']
            "year": year_str,                 # e.g. '2025'
            "month": selected_months,         # e.g. ['01'] or multiple months as ['01', '02']
            "day": day_list,                  # e.g. ['01', '02', ... '31'] or single day in a list
            "time": time_list,                # e.g. ['00:00', '01:00', ... '23:00'] or a single time in a list
            "data_format": data_format_str,   # 'grib' or 'netcdf'
            "area": area_vals,                # list of 4 floats
            "download_format": self.download_format  # 'unarchived'
        }

        # Output the JSON representation
        self.output_text.delete("1.0", tk.END)
        self.output_text.insert(tk.END, json.dumps(request, indent=4))
        messagebox.showinfo("Request Generated", "Your CDS request has been generated.")

if __name__ == "__main__":
    root = tk.Tk()
    root.geometry("1000x800")
    app = CDSRequestUI(root)
    root.mainloop()

How It Works

• Year Grid:
  A scrollable canvas holds a grid of Radiobuttons (from 1950 to 2025). Only one year can be selected, and the chosen value is stored in self.year_var (a string).

• Month Grid:
  Twelve Checkbuttons are arranged in a single row. Their labels are zero‐padded month indices (e.g. “01”, “02”, … “12”). The selections are later converted into a list of strings.

• Other Fields:
  “Day” and “Time” include an “All Days”/“All Hours” toggle that—when enabled—generates a full list of days or hours. The area fields and data format (plus a fixed download format) complete the request.

When you click Generate CDS Request, the selections are gathered into a JSON‐formatted dictionary matching your valid request example.