SYSTEM: You are a Python 3.12 programmer, capable of analyzing problems in depth and explaining solutions in a clear and concise manner. Your responses prioritize code efficiency, readability, and simplicity. You leverage the latest Python features. When addressing tasks, you break them down into clear steps and present only essential information, ensuring users receive focused, expert guidance tailored to their needs. You only print the parts of the code you changed in a way that makes them easy to copy paste in the code base. Lets think step by step. USER: Modify the code so that the column names in the menu use self.colors["text"] and the other parts of the menu like the Datatypes and the boolean values use self.colors["header_info"]. Example:

Total: 10
Present: True: 10, False: 8

Present: boolean

Should be self.colors["text"] : Total:, Present:
Should be self.colors["header_info"] : 10, 8, boolean

Python 3.12 Code: class Header:
    """Class for handling header UI."""

    DATA_TYPE_OPTIONS = ["string", "integer", "float", "boolean"]

    def __init__(self, root: tk.Tk, app: 'TableApp'):
        self.root = root
        self.app = app
        self.style = app.style
        self.colors = app.colors
        self.fonts = app.fonts
        self.dimensions = app.dimensions
        self.table_name_label = None
        self.lower_header_frame = None
        self.result = None
        self._setup_header()

    def _setup_header(self) -> None:
        header_frame = self._setup_main_frame()
        self._setup_upper_section(header_frame)
        self._setup_lower_section(header_frame)

    def _setup_main_frame(self) -> tk.Frame:
        header_frame = create_frame(parent=self.root, width=None, bg=self.colors["background"])
        header_frame.grid(row=0, column=1, columnspan=2, sticky="ew")
        header_frame.config(height=self.dimensions["header_height"])
        header_frame.grid_propagate(False)
        header_frame.grid_rowconfigure(0, weight=0)
        header_frame.grid_rowconfigure(1, weight=0)
        for i in range(5):
            header_frame.grid_columnconfigure(i, weight=1 if i == 4 else 0)
        return header_frame

    def _setup_upper_section(self, parent: tk.Frame) -> None:
        upper_frame = create_frame(parent=parent, width=None, bg=self.colors["background"])
        upper_frame.grid(row=0, column=0, columnspan=6, sticky="ew", pady=(0, 10))
        upper_frame.grid_columnconfigure(5, weight=1)
        self._add_upper_content(upper_frame)

    def _add_upper_content(self, frame: tk.Frame) -> None:
        tk.Label(frame, text="Data > ", bg=self.colors["background"],
                 fg=self.colors["header_info"], font=self.fonts["header_info"]).grid(
            row=0, column=0, padx=22, pady=(22, 0), sticky="nw")

        self.table_name_label = tk.Label(frame, text=self.app.current_table_name or "No Table Selected",
                                         bg=self.colors["background"], fg=self.colors["text"],
                                         font=self.fonts["header_info"])
        self.table_name_label.grid(row=0, column=0, padx=(88, 10), pady=(22, 0), sticky="nw")

        self._setup_settings_section(frame)

    def _setup_settings_section(self, frame: tk.Frame) -> None:
        settings_container = tk.Frame(frame, bg=self.colors["background"])
        settings_container.grid(row=0, column=5, padx=(0, 40), pady=(22, 0), sticky="ne")

        common_label_options = {
            'bg': self.colors["background"],
            'fg': self.colors["text"],
            'font': self.fonts["text"],
            'cursor': "hand2",
        }

        label_s = tk.Label(
            settings_container,
            text="S",
            **common_label_options
        )
        label_i = tk.Label(
            settings_container,
            text="I",
            **common_label_options
        )
        label_e = tk.Label(
            settings_container,
            text="E",
            **common_label_options
        )
        label_d = tk.Label(
            settings_container,
            text="D",
            **common_label_options
        )

        label_s.pack(side=tk.LEFT, padx=5)
        label_i.pack(side=tk.LEFT, padx=5)
        label_e.pack(side=tk.LEFT, padx=5)
        label_d.pack(side=tk.LEFT, padx=5)

        label_s.bind("<Button-1>", lambda e: self.show_stats())
        label_i.bind("<Button-1>", lambda e: self.app.table_io.import_file())
        label_e.bind("<Button-1>", lambda e: self.app.table_io.export_table())
        label_d.bind("<Button-1>", lambda e: self.show_datatype_dialog())

        def on_label_enter(event):
            event.widget.config(bg=self.colors["button_selected"])

        def on_label_leave(event):
            event.widget.config(bg=self.colors["background"])

        labels = [label_s, label_i, label_e, label_d]

        for label in labels:
            label.bind("<Enter>", on_label_enter)
            label.bind("<Leave>", on_label_leave)

    def _setup_lower_section(self, parent: tk.Frame) -> None:
        self.lower_header_frame = create_frame(parent=parent, width=None, bg=self.colors["background"])
        self.lower_header_frame.grid(row=1, column=0, columnspan=5, sticky="ew")

    def show_stats(self):
        """Display stats about the boolean columns in a menu similar to datatype dialog."""
        table_name = self.app.current_table_name
        if not table_name:
            messagebox.showwarning("No Table Selected", "Please select a table to view stats.")
            return

        if not self.app.current_sheet:
            messagebox.showwarning("No Data", "No data available to show stats.")
            return

        data = self.app.current_sheet.get_sheet_data()
        current_headers = self.app.current_sheet.headers()
        data_types = self.app.data_manager.tables_data[table_name].get("data_types", [])

        while len(data_types) < len(current_headers):
            data_types.append('string')

        total_rows = len(data)
        boolean_columns = []
        for col_idx, dtype in enumerate(data_types):
            if dtype == 'boolean':
                header = current_headers[col_idx]
                column_data = [row[col_idx] for row in data]
                true_count = sum(1 for val in column_data if val is True)
                false_count = sum(1 for val in column_data if val is False)
                boolean_columns.append((header, true_count, false_count))

        self.root.option_add('*Menu.disabledForeground', self.colors["text"])
        self.root.option_add('*Menu.font', self.fonts["text"])

        self.stats_menu = tk.Menu(self.root, tearoff=0, bg=self.colors["background"],
                                  fg=self.colors["text"], font=self.fonts["text"])

        menu_x = self.root.winfo_pointerx()
        menu_y = self.root.winfo_pointery()

        self.stats_menu.add_command(
            label=f"Total: {total_rows}",
            state='disabled',
            foreground=self.colors["header_info"],
            background=self.colors["background"]
        )

        if boolean_columns:
            for header, true_count, false_count in boolean_columns:
                stats_text = f"{header}: True: {true_count}, False: {false_count}"
                self.stats_menu.add_command(
                    label=stats_text,
                    state='disabled',
                    foreground=self.colors["text"],
                    background=self.colors["background"]
                )
        else:
            pass

        self.stats_menu.post(menu_x, menu_y)

    def update_true_counter(self, count_text: str) -> None:
        pass

    def show_datatype_dialog(self) -> None:
        """Show dropdown menu for changing column data types."""
        table_name = self.app.current_table_name
        if not table_name:
            messagebox.showwarning("No Table Selected", "Please select a table to change datatypes.")
            return

        current_headers = self.app.current_sheet.headers() if self.app.current_sheet else []
        self.app.data_manager.headers[table_name] = current_headers
        self.data_types = self.app.data_manager.tables_data[table_name].get("data_types", []).copy()

        while len(self.data_types) < len(current_headers):
            self.data_types.append('string')

        self.datatype_menu = tk.Menu(self.root, tearoff=0, bg=self.colors["background"],
                                     fg=self.colors["text"], font=self.fonts["text"])

        self.menu_x = self.root.winfo_pointerx()
        self.menu_y = self.root.winfo_pointery()

        self._populate_datatype_menu(current_headers)

        self.datatype_menu.post(self.menu_x, self.menu_y)

    def _populate_datatype_menu(self, headers):
        """Populate the datatype menu with headers and their current types."""
        self.datatype_menu.delete(0, 'end')

        for header in headers:
            header_index = headers.index(header)
            current_type = self.data_types[header_index]
            submenu = tk.Menu(self.datatype_menu, tearoff=0, bg=self.colors["background"],
                              fg=self.colors["text"], font=self.fonts["text"])
            self.datatype_menu.add_cascade(label=f"{header}: {current_type}", menu=submenu)

            for dtype in self.DATA_TYPE_OPTIONS:
                submenu.add_command(
                    label=dtype,
                    command=lambda h=header, t=dtype: self._update_datatype(h, t),
                    background=self.colors["button_selected"] if dtype == current_type
                    else self.colors["background"]
                )

        self.datatype_menu.add_separator()
        self.datatype_menu.add_command(label="Apply Changes",
                                       command=self._apply_changes)

    def _update_datatype(self, header: str, new_type: str) -> None:
        """Update the datatype for a specific header."""
        current_headers = self.app.current_sheet.headers()
        header_index = current_headers.index(header)
        self.data_types[header_index] = new_type

        self._populate_datatype_menu(current_headers)

        self.datatype_menu.post(self.menu_x, self.menu_y)

    def _apply_changes(self) -> None:
        """Apply the datatype changes and update the table."""
        table_name = self.app.current_table_name
        self.app.data_manager.tables_data[table_name]["data_types"] = self.data_types
        self.app.data_manager.save_data()
        self.app.table_display.apply_column_data_types(self.data_types)
        self.app.table_display.process_and_save_current_sheet_data()
        self.app.refresh_table()
        self.datatype_menu.unpost()