the scrollbar for the sidebar shows only up when i set the self.sidebar_width to atleast 600 why is that . Please fix this. Only print the code that needs to be changed. Lets think step by step. Python 3.12 code: import ctypes
import csv
import json
from pathlib import Path
import tkinter as tk
from tkinter import filedialog, messagebox, simpledialog
from tkinter import ttk
from tksheet import Sheet

def set_dpi_awareness():
"""Enable DPI awareness for high DPI settings."""
try:
ctypes.windll.shcore.SetProcessDpiAwareness(1)
except Exception as e:
print(f"Error setting DPI awareness: {e}")

class TableApp:
"""Table Editor application with a sidebar and table management."""

def __init__(self, root: tk.Tk):
    """Initialize the TableApp."""
    self.root = root
    self.config_dimensions()
    self.config_fonts()
    self.config_colors()
    self.initialize_data()
    self.setup_ui()
    self.load_tables()

def config_dimensions(self):
    """Configure application dimensions."""
    # Window dimensions
    self.root.title("Table Editor with Sidebar")
    self.root.geometry("1920x1080")
    self.root.minsize(1200, 560)

    # Component dimensions
    self.sidebar_width = 400
    self.static_frame_width = 100
    self.header_height = 190

def config_fonts(self):
    """Configure application fonts."""
    font_name, font_size, font_style = "Literata", 12, "normal"
    self.default_font = (font_name, font_size, font_style)
    self.root.option_add("*Font", f"{font_name} {font_size}")

def config_colors(self):
    """Configure application colors."""
    self.text_color = "#333333"
    self.background_color = "#FFFFFF"
    self.sidebar_color = "#F7F8FC"
    self.button_color = "#F7F8FC"
    self.button_color_selected = "#EAEDEF"

def setup_ui(self):
    """Set up the user interface components."""
    self.create_sidebar()
    self.create_main_frame()
    self.create_header_frame()
    self.create_table_frame()

def create_sidebar(self):
    """Create the sidebar with navigation and actions."""
    sidebar = self._create_frame(
        parent=self.root,
        width=self.sidebar_width,
        bg=self.sidebar_color,
        side='left',
        anchor='nw',
        fill='y'
    )
    
    self._create_frame(
        parent=self.root,
        width=self.static_frame_width,
        bg=self.background_color,
        side='left',
        anchor='nw',
        fill='y'
    )
    sidebar.pack_propagate(False)

    self._add_normal_buttons(sidebar)
    self._add_scrollable_canvas(sidebar)
    self._add_delete_table_section(sidebar)

def _create_frame(
    self,
    parent: tk.Widget,
    width: int | None,
    bg: str,
    side: str,
    anchor: str,
    fill: str,
    expand: bool = False
) -> tk.Frame:
    """Create and pack a frame with specified properties."""
    frame = tk.Frame(parent, width=width, bg=bg, bd=0, relief='flat')
    frame.pack(side=side, anchor=anchor, fill=fill, expand=expand)
    return frame

def _add_normal_buttons(self, sidebar: tk.Frame):
    """Add navigation buttons to the sidebar."""
    normal_buttons_frame = self._create_frame(
        parent=sidebar,
        width=None,
        bg=self.sidebar_color,
        side='top',
        anchor='nw',
        fill='x'
    )

    create_table_label = self._create_clickable_label(
        parent=normal_buttons_frame,
        text="Create New Table",
        command=self.create_new_table
    )
    create_table_label.pack(fill='x')
    self.add_custom_hover(create_table_label)

    self._add_separator(normal_buttons_frame)

def _add_scrollable_canvas(self, sidebar: tk.Frame):
    """Add a scrollable canvas to display table labels."""
    scrollbar_frame = self._create_frame(
        parent=sidebar,
        width=None,
        bg=self.sidebar_color,
        side='top',
        anchor='nw',
        fill='both',
        expand=True
    )

    canvas = tk.Canvas(scrollbar_frame, bg=self.sidebar_color, highlightthickness=0)
    canvas.pack(side="left", fill="both", expand=True)

    scrollbar = ttk.Scrollbar(scrollbar_frame, orient="vertical", command=canvas.yview)
    scrollbar.pack(side="right", fill="y")

    canvas.configure(yscrollcommand=scrollbar.set)

    self.table_labels_frame = tk.Frame(canvas, bg=self.sidebar_color)
    canvas.create_window((0, 0), window=self.table_labels_frame, anchor="nw")

    self._bind_scrollbar_events(canvas, scrollbar, scrollbar_frame)

def _bind_scrollbar_events(self, canvas: tk.Canvas, scrollbar: ttk.Scrollbar, scrollbar_frame: tk.Frame):
    """Manage scrollbar visibility based on content size."""
    def configure_scrollbar(event: tk.Event | None = None):
        canvas.update_idletasks()
        canvas_height = scrollbar_frame.winfo_height()
        content_height = self.table_labels_frame.winfo_reqheight()

        if content_height > canvas_height:
            scrollbar.pack(side="right", fill="y")
        else:
            scrollbar.pack_forget()

        canvas.configure(scrollregion=canvas.bbox("all"))

    self.table_labels_frame.bind("<Configure>", configure_scrollbar)
    scrollbar_frame.bind("<Configure>", configure_scrollbar)

def _add_delete_table_section(self, sidebar: tk.Frame):
    """Add the delete table option to the sidebar."""
    self._add_separator(sidebar)

    delete_table_label = self._create_clickable_label(
        parent=sidebar,
        text="Delete Selected Table",
        command=self.delete_table
    )
    delete_table_label.pack(fill='x', side='bottom')
    self.add_custom_hover(delete_table_label)

def _add_separator(self, parent: tk.Widget):
    """Add a horizontal separator to the parent widget."""
    separator = ttk.Separator(parent, orient='horizontal')
    separator.pack(fill='x')

def _create_clickable_label(self, parent: tk.Widget, text: str, command, allow_rename: bool = False) -> tk.Label:
    """Create a clickable label with optional rename capability."""
    label = tk.Label(
        parent,
        text=text,
        bg=self.button_color,
        fg=self.text_color,
        cursor="hand2" if not allow_rename else "arrow",
        anchor='w',
    )
    label.bind("<Button-1>", lambda _: command())
    if allow_rename:
        label.bind("<Double-1>", lambda _: self.begin_rename(text))
    return label

def create_main_frame(self):
    """Create the main frame for displaying tables."""
    self.main_frame = tk.Frame(self.root)
    self.main_frame.pack(expand=True, fill='both', side='right')

def create_header_frame(self):
    """Create the header with filter and action buttons."""
    header_frame = tk.Frame(self.main_frame, height=self.header_height, bg=self.background_color)
    header_frame.pack(fill='x')
    header_frame.pack_propagate(False) 

    tk.Label(header_frame, text="Filter:", bg=self.background_color, fg=self.text_color).pack(
        side='left')
    
    self.filter_entry = tk.Entry(header_frame, fg=self.text_color)
    self.filter_entry.pack(side='left')
    self.filter_entry.bind("<KeyRelease>", lambda _: self.apply_filter())

    rename_headers = self._create_clickable_label(
        parent=header_frame,
        text="Rename Headers",
        command=self.rename_headers,
        allow_rename=False
    )
    rename_headers.pack(side='left', fill='x')

    import_table = self._create_clickable_label(
        parent=header_frame,
        text="Import Table",
        command=self.import_file,
        allow_rename=False
    )
    import_table.pack(side='right', fill='x')

    export_table = self._create_clickable_label(
        parent=header_frame,
        text="Export Table",
        command=self.export_table,
        allow_rename=False
    )
    export_table.pack(side='right', fill='x')

def create_table_frame(self):
    """Create the frame to hold the active table."""
    self.table_frame = tk.Frame(self.main_frame, bg=self.background_color)
    self.table_frame.pack(expand=True, fill='both')

def initialize_data(self):
    """Initialize data structures and directories."""
    self.save_file_dir = Path("tables")
    self.save_file_dir.mkdir(exist_ok=True)

    self.tables: dict[str, Sheet] = {}
    self.table_labels: dict[str, tk.Label] = {}
    self.original_data: dict[str, list[list[str]]] = {}
    self.headers: dict[str, list[str]] = {}
    self.current_table_name: str | None = None
    self.rename_entry: tk.Entry | None = None
    self.selected_table_label: tk.Label | None = None

def create_new_table(self):
    """Create a new table and select it."""
    table_name = f"Table {len(self.tables) + 1}"
    self.add_table(table_name)
    self.load_selected_table(table_name)

def import_file(self):
    """Import a table from a CSV or JSON file."""
    file_path = filedialog.askopenfilename(
        title="Open File",
        filetypes=[("JSON files", "*.json"), ("CSV files", "*.csv")]
    )
    if not file_path:
        return

    try:
        if file_path.endswith('.csv'):
            with open(file_path, newline='', encoding='utf-8') as csvfile:
                data = list(csv.reader(csvfile))
        elif file_path.endswith('.json'):
            with open(file_path, 'r', encoding='utf-8') as jsonfile:
                data = json.load(jsonfile)
        else:
            raise ValueError("Unsupported file format.")

        headers, table_data = data[0], data[1:]
        self.add_table_from_data(file_path, headers, table_data)
    except Exception as e:
        messagebox.showerror("File Import Error", str(e))

def add_table_from_data(self, file_path: str, headers: list[str], table_data: list[list[str]]):
    """Add a table using existing data from a file."""
    table_name = Path(file_path).stem
    table_name = self.ensure_unique_table_name(table_name)

    self.add_table(table_name, table_data)
    self.headers[table_name] = headers
    self.load_selected_table(table_name)
    self.save_data(table_name)

def ensure_unique_table_name(self, table_name: str) -> str:
    """Ensure the table name is unique by appending suffixes if necessary."""
    original_name = table_name
    counter = 1
    while table_name in self.tables:
        table_name = f"{original_name} (New {counter})"
        counter += 1
    return table_name

def export_table(self):
    """Export the current table to a CSV or JSON file."""
    if not self.current_table_name:
        messagebox.showwarning("No Table Selected", "Please select a table to export.")
        return

    file_path = filedialog.asksaveasfilename(
        title="Save As",
        defaultextension=".json",
        filetypes=[("JSON files", "*.json"), ("CSV files", "*.csv")],
        initialfile=self.current_table_name
    )
    if not file_path:
        return

    try:
        data = [self.headers[self.current_table_name]] + self.tables[self.current_table_name].get_sheet_data()
        if file_path.endswith('.csv'):
            self.save_as_csv(file_path, data)
        elif file_path.endswith('.json'):
            self.save_as_json(file_path, data)
        else:
            raise ValueError("Unsupported file format.")

        messagebox.showinfo("Export Successful", f"Table '{self.current_table_name}' has been exported successfully.")
    except Exception as e:
        messagebox.showerror("Export Failed", f"An error occurred during export: {e}")

def save_as_csv(self, file_path: str, data: list[list[str]]):
    """Save table data as a CSV file."""
    with open(file_path, 'w', newline='', encoding='utf-8') as csvfile:
        csv.writer(csvfile).writerows(data)

def save_as_json(self, file_path: str, data: list[list[str]]):
    """Save table data as a JSON file."""
    with open(file_path, 'w', encoding='utf-8') as jsonfile:
        json.dump(data, jsonfile, indent=4)

def add_table(self, table_name: str, data: list[list[str]] | None = None):
    """Add a new table to the application."""
    default_data = [["" for _ in range(5)] for _ in range(10)]
    sheet = Sheet(
        self.table_frame,
        data=data or default_data,
        show_table=True,
        headers=None,
        font=self.default_font,
        header_font=self.default_font,
        auto_resize_columns=True
    )
    sheet.set_options(table_fg=self.text_color, header_fg=self.text_color)
    sheet.enable_bindings()
    sheet.extra_bindings([("end_edit_cell", lambda _: self.save_data(table_name))])
    sheet.pack_forget()

    self.tables[table_name] = sheet
    self.original_data[table_name] = sheet.get_sheet_data()
    self.headers.setdefault(table_name, sheet.headers())

    self.create_table_label(table_name)

def create_table_label(self, table_name: str):
    """Create a label for the table in the sidebar."""
    label = self._create_clickable_label(
        parent=self.table_labels_frame,
        text=table_name,
        command=lambda: self.load_selected_table(table_name),
        allow_rename=True
    )
    label.pack(fill='x')
    self.table_labels[table_name] = label
    self.add_custom_hover(label)

def delete_table(self):
    """Delete the currently selected table."""
    if not self.current_table_name:
        messagebox.showwarning("No Table Selected", "Please select a table to delete.")
        return

    if messagebox.askyesno("Delete Table", f"Are you sure you want to delete the table '{self.current_table_name}'?"):
        self.remove_table(self.current_table_name)

def remove_table(self, table_name: str):
    """Remove a table from the application."""
    self.tables[table_name].destroy()
    self.table_labels[table_name].destroy()
    del self.tables[table_name]
    del self.original_data[table_name]
    del self.headers[table_name]
    del self.table_labels[table_name]
    (self.save_file_dir / f"{table_name}.json").unlink(missing_ok=True)
    self.current_table_name = None
    self.selected_table_label = None

def load_tables(self):
    """Load existing tables from the save directory."""
    for file_path in self.save_file_dir.glob("*.json"):
        table_name = file_path.stem
        with file_path.open('r', encoding='utf-8') as file:
            data = json.load(file)

        headers, table_data = data.pop(0), data
        self.add_table(table_name, table_data)
        self.headers[table_name] = headers

def load_selected_table(self, table_name: str):
    """Display the selected table and hide others."""
    for name, sheet in self.tables.items():
        if name == table_name:
            sheet.pack(expand=True, fill='both')
            self.current_table_name = name
            sheet.headers(self.headers[name])
            self.apply_filter()
            self.selected_table_label = self.table_labels[name]
            self.selected_table_label.config(bg=self.button_color_selected)
        else:
            sheet.pack_forget()
            self.table_labels[name].config(bg=self.button_color)

def save_data(self, table_name: str):
    """Save the current data of a table."""
    data = [self.headers[table_name]] + self.tables[table_name].get_sheet_data()
    file_path = self.save_file_dir / f"{table_name}.json"
    with file_path.open('w', encoding='utf-8') as file:
        json.dump(data, file)
    print(f"Data for {table_name} saved successfully.")

def apply_filter(self):
    """Filter table data based on the filter entry."""
    if not self.current_table_name:
        return

    term = self.filter_entry.get().lower()
    original_data = self.original_data[self.current_table_name]
    filtered_data = [
        row for row in original_data
        if any(term in str(cell).lower() for cell in row)
    ]
    self.tables[self.current_table_name].set_sheet_data(filtered_data)

def rename_headers(self):
    """Rename the headers of the selected table."""
    if not self.current_table_name:
        messagebox.showwarning("No Table Selected", "Please select a table to rename headers.")
        return

    current_headers = self.headers[self.current_table_name]
    new_headers = simpledialog.askstring(
        "Rename Headers",
        "Enter new headers (comma-separated):",
        initialvalue=", ".join(current_headers)
    )
    if new_headers:
        header_list = [header.strip() for header in new_headers.split(',')]
        self.headers[self.current_table_name] = header_list
        self.tables[self.current_table_name].headers(header_list)
        self.save_data(self.current_table_name)

def begin_rename(self, table_name: str):
    """Start renaming a table by replacing its label with an entry."""
    if table_name not in self.table_labels:
        messagebox.showerror("Error", f"Table '{table_name}' not found.")
        return

    label = self.table_labels[table_name]
    self.cancel_rename()

    self.rename_entry = tk.Entry(
        self.table_labels_frame,
        bg=label.cget("bg"),
        fg=self.text_color,
        relief='flat'
    )
    self.rename_entry.insert(0, table_name)
    self.rename_entry.place(
        x=label.winfo_x(),
        y=label.winfo_y(),
        width=label.winfo_width(),
        height=label.winfo_height()
    )
    self.rename_entry.focus()
    self.rename_entry.select_range(0, tk.END)
    self.rename_entry.bind('<Return>', lambda _: self.end_rename(table_name))
    self.rename_entry.bind('<FocusOut>', lambda _: self.cancel_rename())

def end_rename(self, old_name: str):
    """Finalize the renaming of a table."""
    new_name = self.rename_entry.get().strip()

    if not new_name:
        messagebox.showerror("Invalid Name", "Table name cannot be empty.")
        self.rename_entry.focus_set()
        return

    if new_name in self.tables and new_name != old_name:
        messagebox.showerror("Duplicate Name", f"A table named '{new_name}' already exists.")
        self.rename_entry.focus_set()
        return

    if new_name != old_name:
        self.update_table_name(old_name, new_name)
        self.load_selected_table(new_name)

    self.cancel_rename()

def update_table_name(self, old_name: str, new_name: str):
    """Update the table's name and associated resources."""
    self.tables[new_name] = self.tables.pop(old_name)
    self.original_data[new_name] = self.original_data.pop(old_name)
    self.headers[new_name] = self.headers.pop(old_name)

    label = self.table_labels.pop(old_name)
    label.config(text=new_name)
    label.bind("<Button-1>", lambda _: self.load_selected_table(new_name))
    label.bind("<Double-1>", lambda _: self.begin_rename(new_name))

    self.table_labels[new_name] = label

    if self.selected_table_label == label:
        label.config(bg=self.button_color_selected)

    current_file = self.save_file_dir / f"{old_name}.json"
    new_file = self.save_file_dir / f"{new_name}.json"
    current_file.rename(new_file)

def cancel_rename(self):
    """Cancel the ongoing rename operation."""
    if self.rename_entry:
        self.rename_entry.destroy()
        self.rename_entry = None

def add_custom_hover(self, label: tk.Label):
    """Add hover effects to a label."""
    def on_enter(_: tk.Event):
        if label != self.selected_table_label:
            label.config(bg=self.button_color_selected)

    def on_leave(_: tk.Event):
        if label != self.selected_table_label:
            label.config(bg=self.button_color)

    label.bind("<Enter>", on_enter)
    label.bind("<Leave>", on_leave)

if name == "main":
set_dpi_awareness()
root = tk.Tk()
app = TableApp(root)
root.mainloop()