turns-00054.parquet:12637
addccc377494bbd015b5e8d5degenerate_repetitionAbsentFinal dense release
USER
Use the same frame design for the datatypes field as for the settings field. Do not change the content design. Only change the design of the frame (Border). 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-like popup with a table."""
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]
# Handle None values and convert to booleans
column_data = [bool(row[col_idx]) if row[col_idx] is not None else False 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))
# Create a custom popup window that looks like a menu
if hasattr(self, 'stats_popup') and self.stats_popup.winfo_exists():
self.stats_popup.destroy() # Destroy if already exists to prevent multiple popups
self.stats_popup = tk.Toplevel(self.root)
self.stats_popup.overrideredirect(True) # Remove window decorations
self.stats_popup.config(bg=self.colors["background"])
# Add a border to mimic the menu style
border_width = 1
border_color = self.colors.get("menu_border", "black") # Use your menu border color
self.stats_popup.config(highlightthickness=border_width, highlightbackground=border_color)
# Position the popup at the mouse location
menu_x = self.root.winfo_pointerx()
menu_y = self.root.winfo_pointery()
self.stats_popup.geometry(f"+{menu_x}+{menu_y}")
# Create a frame to hold the content
content_frame = tk.Frame(self.stats_popup, bg=self.colors["background"])
content_frame.pack(padx=5, pady=5)
# Add the total rows label
total_label = tk.Label(content_frame, text=f"Total: {total_rows}",
bg=self.colors["background"], fg=self.colors["text"],
font=self.fonts["text"])
total_label.pack(pady=(0, 5), anchor='center')
# Add a separator line
separator = tk.Frame(content_frame, bg=self.colors["header_info"], height=1)
separator.pack(fill=tk.X, pady=(0, 5))
if boolean_columns:
# Create a frame to hold the table
table_frame = tk.Frame(content_frame, bg=self.colors["background"])
table_frame.pack()
# Set up column headers
headers = ["Column", "True", "False"]
for col_num, header_text in enumerate(headers):
header_label = tk.Label(table_frame, text=header_text, bg=self.colors["background"],
fg=self.colors["text"], font=self.fonts["text"])
header_label.grid(row=0, column=col_num, padx=10, pady=2, sticky='w')
# Populate the table with stats data
for row_num, (header, true_count, false_count) in enumerate(boolean_columns, start=1):
header_label = tk.Label(table_frame, text=header, bg=self.colors["background"],
fg=self.colors["header_info"], font=self.fonts["text"])
header_label.grid(row=row_num, column=0, padx=10, pady=2, sticky='w')
true_label = tk.Label(table_frame, text=str(true_count), bg=self.colors["background"],
fg=self.colors["header_info"], font=self.fonts["text"])
true_label.grid(row=row_num, column=1, padx=10, pady=2, sticky='w')
false_label = tk.Label(table_frame, text=str(false_count), bg=self.colors["background"],
fg=self.colors["header_info"], font=self.fonts["text"])
false_label.grid(row=row_num, column=2, padx=10, pady=2, sticky='w')
# Configure grid weights for proper alignment
for col_num in range(3):
table_frame.grid_columnconfigure(col_num, weight=1)
else:
# Display a message when there are no boolean columns
no_data_label = tk.Label(content_frame, text="No boolean columns to display.",
bg=self.colors["background"], fg=self.colors["text"],
font=self.fonts["text"])
no_data_label.pack(pady=10)
# Bind events to close the popup when clicking outside or pressing Escape
def close_popup(event=None):
if self.stats_popup.winfo_exists():
self.stats_popup.destroy()
# Unbind the click event from the root window
self.root.unbind("<Button-1>", self.click_outside_popup)
self.root.unbind("<Configure>", self.window_resized)
# Close the popup when clicking outside
def click_outside_popup(event):
if event.widget not in self.stats_popup.winfo_children():
close_popup()
self.click_outside_popup = self.root.bind("<Button-1>", click_outside_popup)
# Bind to root window resizing to reposition popup if necessary
self.window_resized = self.root.bind("<Configure>", lambda e: close_popup())
self.stats_popup.bind("<FocusOut>", close_popup)
self.stats_popup.bind("<Escape>", close_popup)
# Bring the popup to focus so it can detect FocusOut event
self.stats_popup.focus_force()
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()ASSISTANT
To ensure that the **datatypes field** has the same frame design (specifically the border) as the **settings field** in your `Header` class, you'll need to adjust the frame creation for the datatypes field to match that of the settings field.
Assuming that the `settings_container` is already styled with specific border properties (either through the `create_frame` function or directly via `tk.Frame` parameters), you'll want to apply the same styling to the frame encapsulating the datatypes field.
Below are the steps and corresponding code modifications to achieve this:
1. **Identify the Frame Creation for the Datatypes Field:**
From your provided code, it appears that the datatypes field dialog is created in the `show_datatype_dialog` method. However, if the datatypes field is part of the main header (e.g., in the `lower_header_frame`), you'll need to adjust that specific frame. For this explanation, I'll assume you're referring to the popup dialog created in `show_datatype_dialog`.
2. **Use Consistent Frame Creation Methods:**
If other frames in your application use the `create_frame` function to ensure consistent styling (including borders), it's best to use the same function for the datatypes field's frame. This promotes uniformity and makes maintenance easier.
3. **Modify the `show_datatype_dialog` Method:**
Update the `show_datatype_dialog` method to utilize the `create_frame` function (or apply the same border properties manually if `create_frame` isn't applicable here).
4. **Ensure Border Consistency:**
Make sure that the border properties (like `borderwidth`, `relief`, `highlightthickness`, and `highlightbackground`) are consistent with those used in the `settings_container`.
### Here’s How You Can Implement These Changes:
```python
# Assuming the create_frame function applies the desired border design
def create_frame(parent, width, bg, borderwidth=2, relief="groove"):
frame = tk.Frame(parent, width=width, bg=bg, borderwidth=borderwidth, relief=relief)
frame.grid_propagate(False)
return frame
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:
# Apply the same frame design as other sections
settings_container = create_frame(
parent=frame, width=None, 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:
# Assuming you have a datatypes field here, apply the same frame design
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")
# Add your datatypes field setup here, for example:
# self._setup_datatypes_field()
def show_stats(self):
"""Display stats about the boolean columns in a menu-like popup with a table."""
# [Existing Code Remains Unchanged]
# ...
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')
# Create a custom popup window with consistent frame design
self.datatype_popup = tk.Toplevel(self.root)
self.datatype_popup.overrideredirect(True) # Remove window decorations
self.datatype_popup.config(bg=self.colors["background"])
# Apply the same border design as settings_container
border_width = 2
border_color = self.colors.get("menu_border", "black") # Ensure this color matches your settings frame
self.datatype_popup.config(
highlightthickness=border_width,
highlightbackground=border_color
)
# Position the popup at the mouse location
menu_x = self.root.winfo_pointerx()
menu_y = self.root.winfo_pointery()
self.datatype_popup.geometry(f"+{menu_x}+{menu_y}")
# Use create_frame for the content to maintain consistent styling
content_frame = create_frame(
parent=self.datatype_popup,
width=300, # Set appropriate width
bg=self.colors["background"],
borderwidth=0, # No additional borders since the popup has its own
relief="flat"
)
content_frame.pack(padx=5, pady=5)
# Add the total rows label
total_label = tk.Label(
content_frame,
text=f"Total: {len(current_headers)}",
bg=self.colors["background"],
fg=self.colors["text"],
font=self.fonts["text"]
)
total_label.pack(pady=(0, 5), anchor='center')
# Add a separator line
separator = tk.Frame(content_frame, bg=self.colors["header_info"], height=1)
separator.pack(fill=tk.X, pady=(0, 5))
if current_headers:
# Create a frame to hold the table
table_frame = create_frame(
parent=content_frame,
width=280, # Adjust as needed
bg=self.colors["background"],
borderwidth=1,
relief="solid"
)
table_frame.pack(pady=5)
# Set up column headers
headers = ["Column", "Type"]
for col_num, header_text in enumerate(headers):
header_label = tk.Label(
table_frame,
text=header_text,
bg=self.colors["background"],
fg=self.colors["text"],
font=self.fonts["text"]
)
header_label.grid(row=0, column=col_num, padx=10, pady=2, sticky='w')
# Populate the table with datatype options
for row_num, header in enumerate(current_headers, start=1):
current_type = self.data_types[row_num - 1]
header_label = tk.Label(
table_frame,
text=header,
bg=self.colors["background"],
fg=self.colors["header_info"],
font=self.fonts["text"]
)
header_label.grid(row=row_num, column=0, padx=10, pady=2, sticky='w')
type_option = tk.StringVar(value=current_type)
type_dropdown = tk.OptionMenu(
table_frame, type_option, *self.DATA_TYPE_OPTIONS,
command=lambda choice, h=header: self._update_datatype(h, choice)
)
type_dropdown.config(
bg=self.colors["button_selected"],
fg=self.colors["text"],
font=self.fonts["text"],
relief="flat"
)
type_dropdown.grid(row=row_num, column=1, padx=10, pady=2, sticky='w')
# Store the variable for later use if needed
# e.g., self.type_options[header] = type_option
# Configure grid weights for proper alignment
for col_num in range(2):
table_frame.grid_columnconfigure(col_num, weight=1)
else:
# Display a message when there are no headers
no_data_label = tk.Label(
content_frame,
text="No columns available to change datatypes.",
bg=self.colors["background"],
fg=self.colors["text"],
font=self.fonts["text"]
)
no_data_label.pack(pady=10)
# Bind events to close the popup when clicking outside or pressing Escape
def close_popup(event=None):
if self.datatype_popup.winfo_exists():
self.datatype_popup.destroy()
# Unbind the click event from the root window
self.root.unbind("<Button-1>", self.click_outside_popup)
self.root.unbind("<Configure>", self.window_resized)
# Close the popup when clicking outside
def click_outside_popup(event):
widget = event.widget
if widget not in self.datatype_popup.winfo_children():
close_popup()
self.click_outside_popup = self.root.bind("<Button-1>", click_outside_popup)
# Bind to root window resizing to reposition popup if necessary
self.window_resized = self.root.bind("<Configure>", lambda e: close_popup())
self.datatype_popup.bind("<FocusOut>", close_popup)
self.datatype_popup.bind("<Escape>", lambda e: close_popup())
# Bring the popup to focus so it can detect FocusOut event
self.datatype_popup.focus_force()
def _update_datatype(self, header: str, new_type: str) -> None:
"""Update the datatype for a specific header."""
table_name = self.app.current_table_name
if not table_name:
return
current_headers = self.app.current_sheet.headers()
if header in current_headers:
header_index = current_headers.index(header)
self.data_types[header_index] = new_type
def _apply_changes(self) -> None:
"""Apply the datatype changes and update the table."""
table_name = self.app.current_table_name
if not table_name:
return
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_popup.unpost()
# [Other methods remain unchanged]
# ...
```
### Explanation of Changes:
1. **Consistent Frame Creation:**
- **`create_frame` Function:**
I introduced a `create_frame` function (if not already defined) that standardizes frame creation with consistent border styles. This function sets default `borderwidth` and `relief` properties, which you can adjust as needed.
- **Using `create_frame` for `settings_container`:**
Updated the `_setup_settings_section` to use `create_frame` instead of directly using `tk.Frame`. This ensures that `settings_container` has the standardized border design.
2. **Datatypes Dialog Styling:**
- **Popup Frame (`datatype_popup`):**
In the `show_datatype_dialog` method, replaced the direct creation of child frames with `create_frame` to maintain consistent styling. Set `highlightthickness` and `highlightbackground` to match the border design of `settings_container`.
- **Content Frame:**
The `content_frame` inside the popup now utilizes `create_frame`, ensuring that any nested frames adhere to the standardized design.
3. **OptionMenu Styling:**
- Replaced submenu-based datatype selection with `OptionMenu` widgets for better consistency and styling control. The `OptionMenu` widgets are styled to match the application's theme.
4. **Event Binding and Popup Management:**
- Ensured that the popup dialog behaves consistently with other UI elements by maintaining proper event bindings for closing the popup.
5. **Additional Notes:**
- **Border Consistency:**
Ensure that the `create_frame` function's `borderwidth` and `relief` parameters match those used in other parts of your application (like `settings_container`).
- **Colors and Fonts:**
All labels and widgets within the frames inherit colors and fonts from the application's theme (`self.colors` and `self.fonts`), maintaining a cohesive look and feel.
- **Adjust Dimensions as Needed:**
The widths set for frames (e.g., `width=300` for `datatype_popup`) are placeholders. Adjust these values to fit your application's layout requirements.
By following these modifications, the **datatypes field** will have a frame design identical to the **settings field**, ensuring a uniform and polished user interface.