s in a clear and concise manner. Your responses prioritize code efficiency, readability,…
- User
s 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. USER: When Filtering for something (for example gladiator) and then in the filtered view create a new row and type something in the new row it deletes the rest of the table. Please fix this. tksheet handbook: Hiding Rows
Note that once you have hidden rows you can use the function displayed_row_to_data(row) to retrieve a row data index from a displayed index. Display only certain rows
display_rows( rows: None | Literal["all"] | Iterator[int] = None, all_rows_displayed: None | bool = None, reset_row_positions: bool = True, refresh: bool = False, redraw: bool = False, deselect_all: bool = True, **kwargs, ) -> list[int] | None
Parameters:
rows (int, iterable, "all") are the rows to be displayed, omit the rows to be hidden. Use argument True with all_rows_displayed to display all rows, use False to display only the rows you've set using the rows arg. You can also use the keyword argument all_displayed instead of all_rows_displayed.Examples:
An example of row filtering using this function can be found here. More examples below:display all rows
self.sheet.display_rows("all")
display specific rows only
self.sheet.display_rows([2, 4, 7], all_displayed = False)
Hide specific rows
hide_rows( rows: int | set | Iterator[int] = set(), redraw: bool = True, deselect_all: bool = True, data_indexes: bool = False, ) -> Sheet
Parameters:
NOTE: rows (int) by default uses displayed row indexes, not data indexes. In other words the indexes of the rows displayed on the screen are the ones that are hidden, this is useful when used in conjunction with get_selected_rows(). data_indexes when False it makes the rows parameter indexes represent displayed rows and not the underlying Sheet data rows. When True the indexes represent data indexes.Example:
rows_to_hide = set(sheet.data_r(r) for r in sheet.get_selected_rows()) sheet.hide_rows( rows_to_hide, data_indexes=True, )
Unhide specific rows
show_rows( rows: int | Iterator[int], redraw: bool = True, deselect_all: bool = True, ) -> Sheet
Parameters:
NOTE: rows (int) uses data row indexes, not displayed indexes. In other words the indexes of the rows which represent the underlying data are shown.Notes:
Will return if all rows are currently displayed (Sheet.all_rows).Example:
converting displayed row indexes to data indexes using data_r(r)
rows = set(sheet.data_r(r) for r in sheet.get_selected_rows())
hiding rows
sheet.hide_rows( rows, data_indexes=True, )
showing them again
sheet.show_rows(rows)
Get or set the all rows displayed boolean
Get the bool
@property all_rows()
e.g. get_all_rows_displayed = sheet.all_rows.Set the bool
@all_rows.setter all_rows(a: bool)
e.g. sheet.all_rows = True.
all_rows_displayed(a: bool | None = None) -> bool
a (bool, None) Either set by using bool or get by leaving None e.g. all_rows_displayed().Displayed row index to data
Convert a displayed row index to a data index. If the internal all_rows_displayed attribute is True then it will simply return the provided argument.
displayed_row_to_data(r) data_r(r)
Get currently displayed rows
@property displayed_rows() -> list[int]
e.g. rows = sheet.displayed_rowsExample Header Dropdown Boxes and Row Filtering
A very simple demonstration of row filtering using header dropdown boxes.
from tksheet import ( Sheet, num2alpha as n2a, ) import tkinter as tk
class demo(tk.Tk): def init(self): tk.Tk.init(self) self.grid_columnconfigure(0, weight=1) self.grid_rowconfigure(0, weight=1) self.frame = tk.Frame(self) self.frame.grid_columnconfigure(0, weight=1) self.frame.grid_rowconfigure(0, weight=1) self.data = [ ["3", "c", "z"], ["1", "a", "x"], ["1", "b", "y"], ["2", "b", "y"], ["2", "c", "z"], ] self.sheet = Sheet( self.frame, data=self.data, column_width=180, theme="dark", height=700, width=1100, ) self.sheet.enable_bindings( "copy", "rc_select", "arrowkeys", "double_click_column_resize", "column_width_resize", "column_select", "row_select", "drag_select", "single_select", "select_all", ) self.frame.grid(row=0, column=0, sticky="nswe") self.sheet.grid(row=0, column=0, sticky="nswe")
self.sheet.dropdown( self.sheet.span(n2a(0), header=True, table=False), values=["all", "1", "2", "3"], set_value="all", selection_function=self.header_dropdown_selected, text="Header A Name", ) self.sheet.dropdown( self.sheet.span(n2a(1), header=True, table=False), values=["all", "a", "b", "c"], set_value="all", selection_function=self.header_dropdown_selected, text="Header B Name", ) self.sheet.dropdown( self.sheet.span(n2a(2), header=True, table=False), values=["all", "x", "y", "z"], set_value="all", selection_function=self.header_dropdown_selected, text="Header C Name", ) def header_dropdown_selected(self, event=None): hdrs = self.sheet.headers() # this function is run before header cell data is set by dropdown selection # so we have to get the new value from the event hdrs[event.loc] = event.value if all(dd == "all" for dd in hdrs): self.sheet.display_rows("all") else: rows = [ rn for rn, row in enumerate(self.data) if all(row[c] == e or e == "all" for c, e in enumerate(hdrs)) ] self.sheet.display_rows(rows=rows, all_displayed=False) self.sheet.redraw()app = demo() app.mainloop() Python Code: import ctypes import csv import json import tkinter as tk from pathlib import Path from tkinter import filedialog, messagebox, simpledialog, ttk from typing import Any, Optional
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}")
def custom_filter_design(master, style: ttk.Style, headers=None, filter_types=None, filter_font=None, filter_combobox_font=None, colors=None): """Creates a custom filter frame with all components.""" filter_frame = ttk.Frame(master, style="Custom.TFrame")
# Configure styles style.configure("Custom.TFrame", background=colors["background"], relief="flat", borderwidth=0) style.configure("TCombobox", relief="flat", borderwidth=0, background=colors["background"], fieldbackground=colors["background"]) style.map("TCombobox", fieldbackground=[('readonly', colors["background"])], background=[('readonly', colors["background"])]) style.configure("TEntry", relief="flat", borderwidth=0, background=colors["background"]) style.configure("Line.TFrame", background=colors["filter_line"]) # Create widgets header_combobox = ttk.Combobox(filter_frame, values=headers, width=15, font=filter_combobox_font, state="readonly") filtertype_combobox = ttk.Combobox(filter_frame, values=filter_types, width=15, font=filter_combobox_font, state="readonly") filter_entry = ttk.Entry(filter_frame, font=filter_font) underline = ttk.Frame(filter_frame, height=1, style="Line.TFrame") # Layout widgets header_combobox.grid(row=0, column=0, padx=(0, 30), pady=2, sticky='ew') filtertype_combobox.grid(row=0, column=1, padx=2, pady=2, sticky='ew') filter_entry.grid(row=1, column=0, columnspan=2, padx=2, pady=(2, 0), sticky='ew') underline.grid(row=2, column=0, columnspan=2, sticky='ew', pady=(0, 2)) # Prevent text selection in comboboxes for combobox in (header_combobox, filtertype_combobox): combobox.bind("<FocusIn>", lambda event: event.widget.selection_clear()) # Configure column weights filter_frame.columnconfigure((0, 1), weight=1) # Ensure the underline doesn't resize vertically underline.pack_propagate(False) return filter_frame, header_combobox, filtertype_combobox, filter_entrydef custom_scrollbar_design(style: ttk.Style, colors=None): """Configure custom scrollbar style.""" style.configure("Custom.Vertical.TScrollbar", troughcolor=colors["scrollbar_trough"], background=colors["scrollbar_background"], borderwidth=0, arrowcolor=colors["scrollbar_arrow"]) style.map("Custom.Vertical.TScrollbar", background=[('active', colors["scrollbar_active"])]) style.layout("Custom.Vertical.TScrollbar", [('Vertical.Scrollbar.trough', {'children': [('Vertical.Scrollbar.thumb', {'expand': '1', 'sticky': 'ns'})], 'sticky': 'ns'})])
class TableApp: """Table Editor with 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.style = ttk.Style() self.style.theme_use("default") self.setup_ui() self.load_tables() def config_dimensions(self): """Configure app dimensions.""" self.root.title("Database") self.root.geometry("1920x1080") self.root.minsize(1435, 910) self.sidebar_width = 400 self.spacer_frame_width = 100 self.header_height = 190 self.separator_height = 1 def config_fonts(self): """Configure app fonts.""" self.fonts = { "text": ("Literata", 12), "tksheet": ("Literata", 12, "normal"), "header_info": ("Literata", 10), "filter": ("Literata", 12), "filter_combobox": ("Literata", 8), } def config_colors(self): """Configure app colors.""" self.colors = { "text": "#333333", "background": "#FFFFFF", "sidebar": "#F7F8FC", "button": "#F7F8FC", "button_selected": "#EAEDEF", "separator": "#333333", "header_info": "#999999", "scrollbar_trough": "#F7F8FC", "scrollbar_background": "#c0c1c4", "scrollbar_arrow": "#333333", "scrollbar_active": "#878789", "filter_line": "#00bcf0", } def setup_ui(self): """Set up the user interface with a 3x2 grid layout.""" self.root.grid_rowconfigure(0, weight=0) self.root.grid_rowconfigure(1, weight=1) self.root.grid_columnconfigure(0, weight=0) self.root.grid_columnconfigure(1, weight=0, minsize=self.spacer_frame_width) self.root.grid_columnconfigure(2, weight=3) self.create_sidebar() self.create_header_frame() self.create_spacer_frame() self.create_table_frame() def create_sidebar(self): """Create the sidebar that spans both rows.""" sidebar = self._create_frame( parent=self.root, width=self.sidebar_width, bg=self.colors["sidebar"] ) sidebar.grid(row=0, column=0, rowspan=2, sticky='ns') sidebar.grid_propagate(False) sidebar.columnconfigure(0, weight=1) sidebar.rowconfigure(0, weight=1) functional_sidebar = self._create_frame( parent=sidebar, width=self.sidebar_width, bg=self.colors["sidebar"] ) functional_sidebar.grid(row=0, column=0, sticky='nsew') functional_sidebar.columnconfigure(0, weight=1) functional_sidebar.rowconfigure(0, weight=0) functional_sidebar.rowconfigure(1, weight=1) functional_sidebar.rowconfigure(2, weight=0) self._add_normal_buttons(functional_sidebar) self._add_scrollable_canvas(functional_sidebar) self._add_delete_table_section(functional_sidebar) def create_header_frame(self) -> None: """Create the header divided into upper and lower sub-frames.""" header_frame = self._create_and_configure_header_frame() upper_header_frame = self._create_upper_header(header_frame) self._create_upper_header_content(upper_header_frame) lower_header_frame = self._create_lower_header(header_frame) self._create_filter_controls(lower_header_frame) def _create_and_configure_header_frame(self) -> tk.Frame: """Create and configure the main header frame.""" header_frame = self._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.header_height) header_frame.grid_propagate(False) for i in range(2): header_frame.grid_rowconfigure(i, weight=0) for i in range(5): weight = 1 if i == 4 else 0 header_frame.grid_columnconfigure(i, weight=weight) return header_frame def _create_upper_header(self, parent: tk.Frame) -> tk.Frame: """Create the upper header frame.""" upper_header = self._create_frame(parent=parent, width=None, bg=self.colors["background"]) upper_header.grid(row=0, column=0, columnspan=5, sticky='ew', pady=(0, 10)) upper_header.grid_columnconfigure(5, weight=1) return upper_header def _create_upper_header_content(self, upper_header: tk.Frame) -> None: """Create and add content to the upper header frame.""" self._create_data_label(upper_header) self._create_table_name_label(upper_header) self._create_settings_label(upper_header) def _create_data_label(self, parent: tk.Frame) -> None: """Create and grid the 'Data >' label.""" data_label = tk.Label( parent, text="Data > ", bg=self.colors["background"], fg=self.colors["header_info"], font=self.fonts["header_info"] ) data_label.grid(row=0, column=0, padx=22, pady=(22, 0), sticky='nw') def _create_table_name_label(self, parent: tk.Frame) -> None: """Create and grid the table name label.""" self.table_name_label = tk.Label( parent, text=self.current_table_name if self.current_table_name else "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') def _create_settings_label(self, parent: tk.Frame) -> None: """Create and grid the settings label with its associated menu.""" settings_label = tk.Label( parent, text="...", bg=self.colors["background"], fg=self.colors["text"], cursor="hand2", anchor='e', font=self.fonts["text"] ) settings_label.grid(row=0, column=5, padx=40, pady=20, sticky='e') settings_menu = self._create_settings_menu() self._bind_settings_label_events(settings_label, settings_menu) def _create_settings_menu(self) -> tk.Menu: """Create the settings dropdown menu.""" menu = tk.Menu(self.root, tearoff=0) menu.add_command(label="Export Table", command=self.export_table) menu.add_command(label="Import Table", command=self.import_file) menu.add_command(label="Rename Headers", command=self.rename_headers) return menu def _bind_settings_label_events(self, label: tk.Label, menu: tk.Menu) -> None: """Bind events to the settings label.""" label.bind("<Button-1>", lambda e: menu.post(e.x_root, e.y_root)) label.bind("<Enter>", lambda _: label.config(bg=self.colors["button_selected"])) label.bind("<Leave>", lambda _: label.config(bg=self.colors["background"])) def _create_lower_header(self, parent: tk.Frame) -> tk.Frame: """Create the lower header frame.""" lower_header = self._create_frame(parent=parent, width=None, bg=self.colors["background"]) lower_header.grid(row=1, column=0, columnspan=5, sticky='ew') return lower_header def _create_filter_controls(self, parent: tk.Frame) -> None: """Create and add filter controls to the lower header frame.""" self._create_filter_label(parent) filter_frame, self.filter_header_dropdown, self.filter_option_dropdown, self.filter_text_entry = custom_filter_design(parent, self.style, headers=["All"] + self.headers.get(self.current_table_name, []), filter_types=[ "is", "is not", "contains", "does not contain", "starts with", "ends with", "is empty", "is not empty" ], filter_font=self.fonts["filter"], filter_combobox_font=self.fonts["filter_combobox"], colors=self.colors) filter_frame.grid(row=0, column=1, columnspan=4, padx=0, pady=0, sticky='ew') self.filter_header_var.set("All") self.filter_option_var.set("contains") self.filter_text_var.set("") self.filter_header_dropdown['textvariable'] = self.filter_header_var self.filter_option_dropdown['textvariable'] = self.filter_option_var self.filter_text_entry['textvariable'] = self.filter_text_var self.filter_header_dropdown.bind("<<ComboboxSelected>>", self.apply_filter) self.filter_option_dropdown.bind("<<ComboboxSelected>>", lambda event: [self.update_filter_text_state(event), self.apply_filter()]) self.filter_text_entry.bind("<KeyRelease>", self.apply_filter) self.filter_text_entry.bind("<Return>", self.apply_filter) def _create_filter_label(self, parent: tk.Frame) -> None: filter_label = tk.Label(parent, text="Filter: ", bg=self.colors["background"], fg=self.colors["text"]) filter_label.grid(row=0, column=0, padx=(100, 0), pady=20, sticky='e') def update_filter_text_state(self, event=None): """Enable or disable the filter text entry based on filter option.""" option = self.filter_option_var.get() if option in ["is empty", "is not empty"]: self.filter_text_var.set("") self.filter_text_entry.config(state='disabled') self.apply_filter() else: self.filter_text_entry.config(state='normal') def create_spacer_frame(self): """Create a spacer frame in column 1, row 1.""" spacer = self._create_frame( parent=self.root, width=self.spacer_frame_width, bg=self.colors["background"] ) spacer.grid(row=1, column=1, sticky='nsew') spacer.grid_propagate(False) def create_table_frame(self): """Create the table frame in column 2, row 1.""" self.table_frame = self._create_frame( parent=self.root, width=None, bg=self.colors["background"] ) self.table_frame.grid(row=1, column=2, sticky='nsew') self.table_frame.grid_rowconfigure(0, weight=1) self.table_frame.grid_columnconfigure(0, weight=1) def _create_frame( self, parent: tk.Widget, width: Optional[int], bg: str ) -> tk.Frame: """Create a frame with specified width and background.""" frame = tk.Frame(parent, width=width, bg=bg, bd=0, relief='flat') if width: frame.config(width=width) return frame def _add_normal_buttons(self, sidebar: tk.Frame): """Add buttons to the sidebar.""" normal_buttons_frame = self._create_frame( parent=sidebar, width=self.sidebar_width, bg=self.colors["sidebar"] ) normal_buttons_frame.grid(row=0, column=0, sticky='ew', padx=10, pady=(10, 0)) normal_buttons_frame.columnconfigure(0, weight=1) create_table_label = self._create_clickable_label( parent=normal_buttons_frame, text="Create New Table", command=self.create_new_table, anchor='center' ) create_table_label.grid(row=0, column=0, pady=10, sticky='ew') self.add_custom_hover(create_table_label) separator = tk.Frame(normal_buttons_frame, height=self.separator_height, bg=self.colors["separator"]) separator.grid(row=1, column=0, sticky='ew', pady=5) def _add_scrollable_canvas(self, sidebar: tk.Frame): """Add scrollable canvas for table labels within a single frame.""" scrollable_container = self._create_frame( parent=sidebar, width=self.sidebar_width, bg=self.colors["sidebar"] ) scrollable_container.grid(row=1, column=0, sticky='nsew', padx=10, pady=10) scrollable_container.columnconfigure(0, weight=1) scrollable_container.rowconfigure(0, weight=1) self.canvas = tk.Canvas( scrollable_container, bg=self.colors["sidebar"], highlightthickness=0 ) self.canvas.grid(row=0, column=0, sticky='nsew') custom_scrollbar_design(self.style, self.colors) self.scrollbar = ttk.Scrollbar( scrollable_container, orient="vertical", command=self.canvas.yview, style="Custom.Vertical.TScrollbar" ) self.scrollbar.grid(row=0, column=1, sticky='ns') self.canvas.configure(yscrollcommand=self.scrollbar.set) self.table_labels_frame = tk.Frame(self.canvas, bg=self.colors["sidebar"]) self.canvas.create_window((0, 0), window=self.table_labels_frame, anchor="nw") self.canvas.bind("<MouseWheel>", self._on_mouse_wheel) self.table_labels_frame.bind("<MouseWheel>", self._on_mouse_wheel) self.table_labels_frame.bind( "<Configure>", lambda event: ( self.canvas.configure(scrollregion=self.canvas.bbox("all")), self._update_scrollbar(scrollable_container, self.canvas, self.scrollbar) ) ) scrollable_container.bind( "<Configure>", lambda event: self._update_scrollbar(scrollable_container, self.canvas, self.scrollbar) ) def _on_mouse_wheel(self, event): """Handle mouse wheel scrolling only if scrollbar is visible.""" if self.scrollbar.winfo_viewable(): self.canvas.yview_scroll(int(-1 * (event.delta / 120)), "units") def _update_scrollbar(self, scrollbar_frame, canvas, scrollbar): """Update scrollbar visibility based on content size.""" canvas.update_idletasks() canvas_height = scrollbar_frame.winfo_height() content_height = self.table_labels_frame.winfo_reqheight() if content_height > canvas_height: scrollbar.grid() canvas.configure(yscrollcommand=scrollbar.set) canvas.bind("<MouseWheel>", lambda event: canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")) else: scrollbar.grid_remove() canvas.configure(yscrollcommand=lambda *args: None) canvas.unbind("<MouseWheel>") def _add_delete_table_section(self, sidebar: tk.Frame): """Add delete table option to the sidebar.""" delete_table_frame = self._create_frame( parent=sidebar, width=self.sidebar_width, bg=self.colors["sidebar"] ) delete_table_frame.grid(row=2, column=0, sticky='ew', padx=10, pady=(0, 10)) delete_table_frame.columnconfigure(0, weight=1) delete_table_frame.rowconfigure(1, weight=1) separator = tk.Frame(delete_table_frame, height=self.separator_height, bg=self.colors["separator"]) separator.grid(row=0, column=0, sticky='ew', pady=5) delete_table_label = self._create_clickable_label( parent=delete_table_frame, text="🗑 Delete Selected Table", command=self.delete_table, anchor='center' ) delete_table_label.grid(row=1, column=0, pady=10, sticky='ew') self.add_custom_hover(delete_table_label) def _create_clickable_label( self, parent: tk.Widget, text: str, command, allow_rename: bool = False, anchor: str = 'w' ) -> tk.Label: """Create a clickable label with optional rename functionality.""" cursor = "arrow" if allow_rename else "hand2" label = tk.Label( parent, text=text, bg=self.colors["button"], fg=self.colors["text"], cursor=cursor, anchor=anchor, font=self.fonts["text"] ) label.bind("<Button-1>", lambda _: command()) if allow_rename: label.bind("<Double-Button-1>", lambda _: self.begin_rename(text)) label.bind("<MouseWheel>", self._on_mouse_wheel) return label def add_custom_hover(self, widget: tk.Widget): """Add custom hover effects to a widget.""" widget.bind("<Enter>", lambda e: widget.config(bg=self.colors["button_selected"])) widget.bind("<Leave>", lambda e: widget.config(bg=self.colors["button"])) def initialize_data(self): """Initialize data structures.""" self.save_file_path = Path(__file__).parent / "Data.json" self.tables_data: dict[str, dict] = {} self.current_sheet: Sheet | None = None 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 self.table_labels: dict[str, tk.Label] = {} self.table_name_label = None self.filter_header_var = tk.StringVar(value="All") self.filter_option_var = tk.StringVar(value="contains") self.filter_text_var = tk.StringVar() def create_new_table(self): """Create a new table.""" existing_numbers = [int(name.split(" ")[1]) for name in self.tables_data if name.startswith("Table ") and name.split(" ")[1].isdigit()] next_number = max(existing_numbers, default=0) + 1 table_name = f"Table {next_number}" self.add_table(table_name) self.load_selected_table(table_name) def import_file(self): """Import table from file.""" file_path = filedialog.askopenfilename(title="Import File", filetypes=[("All Supported Files", "*.json *.csv"), ("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.") if not data or not isinstance(data, list) or not all(isinstance(row, list) for row in data): raise ValueError("Invalid data format in the file.") 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 from file data.""" table_name = Path(file_path).stem table_name = self.ensure_unique_table_name(table_name) self.headers[table_name] = headers self.tables_data[table_name] = {"headers": headers, "data": table_data} self.add_table(table_name, table_data) self.load_selected_table(table_name) self.save_data() def ensure_unique_table_name(self, table_name: str) -> str: """Ensure table name is unique.""" original_name = table_name counter = 1 while table_name in self.tables_data: table_name = f"{original_name} (New {counter})" counter += 1 return table_name def save_table_data(self, file_path: str, data: list[list[str]], format: str): """Save table data in specified format.""" match format: case 'csv': with open(file_path, 'w', newline='', encoding='utf-8') as file: csv.writer(file).writerows(data) case 'json': with open(file_path, 'w', encoding='utf-8') as file: json.dump(data, file, indent=4) case _: raise ValueError("Unsupported file format.") def export_table(self): """Export current table to file.""" if not self.current_table_name or self.current_table_name not in self.tables_data: messagebox.showwarning("No Table Selected", "Please select a table to export.") return file_path = filedialog.asksaveasfilename(title="Export File", 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_data[self.current_table_name]["data"] if file_path.endswith('.csv'): self.save_table_data(file_path, data, 'csv') elif file_path.endswith('.json'): with open(file_path, 'w', encoding='utf-8') as file: json.dump(data, file, indent=4) else: raise ValueError("Unsupported file format.") self.save_data() 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 add_table(self, table_name: str, data: list[list[str]] | None = None): """Add a new table.""" default_headers = ["Column 1", "Column 2", "Column 3", "Column 4", "Column 5"] self.headers[table_name] = default_headers self.tables_data[table_name] = {"headers": default_headers, "data": data or [["" for _ in range(5)] for _ in range(10)]} self.create_table_label(table_name) self.save_data() def create_table_label(self, table_name: str): """Create label for table.""" label = self._create_clickable_label(self.table_labels_frame, table_name, lambda: self.load_selected_table(table_name), True) label.pack(fill='x', padx=20, pady=5, expand=True) self.table_labels[table_name] = label self.add_custom_hover(label) def delete_table(self): """Delete selected table.""" if not self.current_table_name or self.current_table_name not in self.tables_data: messagebox.showwarning("No Table Selected", "Please select a valid 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.""" if self.current_table_name == table_name and self.current_sheet: self.current_sheet.destroy() self.current_sheet = None label = self.table_labels.get(table_name) if label: label.destroy() if table_name in self.tables_data: del self.tables_data[table_name] if table_name in self.headers: del self.headers[table_name] if table_name in self.table_labels: del self.table_labels[table_name] self.current_table_name = None self.selected_table_label = None self.save_data() def load_tables(self): """Load tables from file.""" if not self.save_file_path.exists(): return try: with self.save_file_path.open('r', encoding='utf-8') as file: all_data = json.load(file) except Exception as e: messagebox.showerror("Load Error", f"Failed to load tables: {e}") return for table_name, data in all_data.items(): if not isinstance(data, list) or not data: continue headers, table_data = data[0], data[1:] self.headers[table_name] = headers self.tables_data[table_name] = {"headers": headers, "data": table_data} self.create_table_label(table_name) def load_selected_table(self, table_name: str): """Display selected table.""" if self.current_sheet: self.current_sheet.pack_forget() self.current_sheet.destroy() self.current_sheet = None if self.selected_table_label: try: self.selected_table_label.config(bg=self.colors["button"]) except tk.TclError: self.selected_table_label = None if table_name not in self.tables_data: messagebox.showerror("Error", f"Table '{table_name}' does not exist.") self.current_table_name = None self.selected_table_label = None return table_info = self.tables_data[table_name] headers = table_info["headers"] data = table_info["data"] try: sheet = Sheet( self.table_frame, data=data, show_table=True, headers=headers, font=self.fonts["tksheet"], header_font=self.fonts["tksheet"], auto_resize_columns=True ) sheet.set_options(table_fg=self.colors["text"], header_fg=self.colors["text"]) sheet.enable_bindings() sheet.extra_bindings([("end_edit_cell", self.on_cell_edit)]) sheet.pack(expand=True, fill='both') self.current_sheet = sheet self.current_table_name = table_name if self.table_name_label: self.table_name_label.config(text=self.current_table_name) else: self.table_name_label = tk.Label( self.root, text=self.current_table_name, bg=self.colors["background"], fg=self.colors["text"], font=self.fonts["header_info"] ) self.table_name_label.grid(row=0, column=0, padx=(60, 10), pady=(5, 0), sticky='nw') label = self.table_labels.get(table_name) if label: self.selected_table_label = label try: self.selected_table_label.config(bg=self.colors["button_selected"]) except tk.TclError: self.selected_table_label = None messagebox.showerror("Error", f"Failed to update the label for '{table_name}'.") else: self.selected_table_label = None messagebox.showerror("Error", f"Label for '{table_name}' not found.") self.filter_header_var.set("All") self.filter_header_dropdown['values'] = ["All"] + headers self.filter_option_var.set("contains") self.update_filter_text_state() self.apply_filter() except Exception as e: messagebox.showerror("Sheet Error", f"Failed to load table '{table_name}': {e}") self.current_table_name = None self.selected_table_label = None def on_cell_edit(self, event=None): """Handle cell edits.""" if self.current_table_name and self.current_sheet: self.tables_data[self.current_table_name]["data"] = self.current_sheet.get_sheet_data() self.save_data() def save_data(self): """Save all tables data.""" all_data = {} for table_name, table_info in self.tables_data.items(): all_data[table_name] = [table_info["headers"]] + table_info["data"] try: with self.save_file_path.open('w', encoding='utf-8') as file: json.dump(all_data, file, indent=4) except Exception as e: print(f"Error saving data: {e}") def apply_filter(self, event=None): """Apply filter to table data based on selected criteria.""" if not self.current_table_name or not self.current_sheet: return header = self.filter_header_var.get() option = self.filter_option_var.get() text = self.filter_text_var.get().lower() original_data = self.tables_data[self.current_table_name]["data"] def row_matches(row): if header == "All": cells = row target_indices = range(len(cells)) else: try: target_indices = [self.headers[self.current_table_name].index(header)] except ValueError: return False for idx in target_indices: cell = str(row[idx]).lower() if option == "is": if cell == text: return True elif option == "is not": if cell != text: return True elif option == "contains": if text in cell: return True elif option == "does not contain": if text not in cell: return True elif option == "starts with": if cell.startswith(text): return True elif option == "ends with": if cell.endswith(text): return True elif option == "is empty": if cell == "": return True elif option == "is not empty": if cell != "": return True return False if option in ["is empty", "is not empty"]: filtered_data = [row for row in original_data if row_matches(row)] else: filtered_data = [row for row in original_data if row_matches(row)] try: self.current_sheet.set_sheet_data(filtered_data) except tk.TclError as e: print(f"Error applying filter: {e}") def rename_headers(self): """Rename table headers.""" 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(',')] if not header_list: messagebox.showerror("Invalid Headers", "Header list cannot be empty.") return self.headers[self.current_table_name] = header_list self.tables_data[self.current_table_name]["headers"] = header_list if self.current_sheet: try: self.current_sheet.headers(header_list) except tk.TclError as e: messagebox.showerror("Error", f"Failed to rename headers: {e}") self.filter_header_var.set("All") self.filter_header_dropdown['values'] = ["All"] + header_list self.apply_filter() self.save_data() def begin_rename(self, table_name: str): """Start renaming a table.""" 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.colors["text"], 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 event: self.end_rename(table_name)) self.rename_entry.bind('<FocusOut>', lambda event: self.cancel_rename()) def end_rename(self, old_name: str): """Finalize table renaming.""" 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_data 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 table name and resources.""" self.tables_data[new_name] = self.tables_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 event: self.load_selected_table(new_name)) label.bind("<Double-1>", lambda event: self.begin_rename(new_name)) self.table_labels[new_name] = label if self.selected_table_label == label: try: label.config(bg=self.colors["button_selected"]) except tk.TclError: pass self.save_data() def cancel_rename(self): """Cancel 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 label.""" def on_enter(event): if label != self.selected_table_label: try: label.config(bg=self.colors["button_selected"]) except tk.TclError: pass def on_leave(event): if label != self.selected_table_label: try: label.config(bg=self.colors["button"]) except tk.TclError: pass label.bind("<Enter>", on_enter) label.bind("<Leave>", on_leave)if name == "main": set_dpi_awareness() root = tk.Tk() app = TableApp(root) root.mainloop()
- Assistant
To fix the issue where adding a new row in a filtered view deletes the rest of the table, you should modify the
apply_filtermethod. Instead of setting the sheet data to the filtered data, we'll usedisplay_rowsto show only the matching rows while keeping the underlying data intact. This ensures that adding new rows won't affect the non-filtered data.Updated
apply_filterMethodReplace your existing
apply_filtermethod with the following code:def apply_filter(self, event=None): """Apply filter to table data based on selected criteria.""" if not self.current_table_name or not self.current_sheet: return header = self.filter_header_var.get() option = self.filter_option_var.get() text = self.filter_text_var.get().lower() original_data = self.tables_data[self.current_table_name]["data"] matching_indices = [] for idx, row in enumerate(original_data): if header == "All": cells_to_check = row else: try: target_idx = self.headers[self.current_table_name].index(header) cells_to_check = [row[target_idx]] except ValueError: continue match = False for cell in cells_to_check: cell = str(cell).lower() if option == "is" and cell == text: match = True elif option == "is not" and cell != text: match = True elif option == "contains" and text in cell: match = True elif option == "does not contain" and text not in cell: match = True elif option == "starts with" and cell.startswith(text): match = True elif option == "ends with" and cell.endswith(text): match = True elif option == "is empty" and cell == "": match = True elif option == "is not empty" and cell != "": match = True if match: break if match: matching_indices.append(idx) # Display only the matching rows self.current_sheet.display_rows(matching_indices, all_displayed=False) self.current_sheet.redraw()Explanation of Changes
-
Identify Matching Rows:
- Iterate through all rows in
original_data. - Determine which rows match the filter criteria based on the selected header, option, and text.
- Collect the indices of matching rows in
matching_indices.
- Iterate through all rows in
-
Display Matching Rows:
- Use
self.current_sheet.display_rows(matching_indices, all_displayed=False)to show only the filtered rows. - This approach hides non-matching rows without altering the underlying data.
- Use
-
Redraw the Sheet:
- Call
self.current_sheet.redraw()to refresh the sheet and apply the changes.
- Call
Benefits of This Approach
- Data Integrity: The original data remains unchanged, preventing accidental deletion of rows.
- Flexibility: Allows users to add new rows without affecting the entire table.
- Performance: Efficiently manages row visibility without reloading the entire dataset.
Additional Recommendations
-
Ensure Proper Data Binding: Since you're now managing row visibility instead of replacing data, make sure that any data manipulation (like adding or editing rows) correctly interacts with the full dataset.
-
Handle New Rows Appropriately: When adding a new row, append it to
self.tables_data[self.current_table_name]["data"]and refresh the view if it matches the current filter criteria.
By implementing these changes, your table should handle filtered views more gracefully, allowing users to add new rows without unintended side effects.
-