Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

You are a Python programmer tasked with refactoring code. You are proficient in…

  1. User

    SYSTEM: You are a Python programmer tasked with refactoring code. You are proficient in Python 3.12 and use modern features where appropriate. Your code is clear, easy to read, and free of unnecessary verbosity. You follow PEP 8, 20 and 257 to ensure high quality python code. You remove comments and instead focus on simple and clear one line docstrings to describe every function. A big focus for you is reducing redundancy. You think through your task step by step. USER: import tkinter as tk from tkinter import ttk, messagebox, font import sqlite3 import sys

    if sys.platform.startswith('win'): try: import ctypes ctypes.windll.shcore.SetProcessDpiAwareness(1) except Exception as e: print("Error setting DPI awareness:", e)

    def run_query(query, parameters=()): with sqlite3.connect('media.db') as conn: cursor = conn.cursor() result = cursor.execute(query, parameters) if query.strip().lower().startswith("select"): return result.fetchall() conn.commit()

    def create_tables(): create_movies_table_sql = ''' CREATE TABLE IF NOT EXISTS movies ( id INTEGER PRIMARY KEY AUTOINCREMENT, movie TEXT, year TEXT, present BOOLEAN, watched BOOLEAN, notes TEXT ); ''' create_series_table_sql = ''' CREATE TABLE IF NOT EXISTS series ( id INTEGER PRIMARY KEY AUTOINCREMENT, series TEXT, seasons TEXT, year TEXT, present BOOLEAN, seasons_present TEXT, complete BOOLEAN, watched BOOLEAN, seasons_seen TEXT, notes TEXT ); ''' run_query(create_movies_table_sql) run_query(create_series_table_sql)

    class MediaTracker(tk.Tk): def init(self): super().init()

        self.configure(bg='white')
    
        if sys.platform.startswith('win'):
            try:
                scaling = self.winfo_fpixels('1i') / 72
                self.tk.call('tk', 'scaling', scaling)
            except Exception as e:
                print("Error setting scaling:", e)
    
        self.title("Movies and Series Tracker")
        self.geometry("1200x600")
    
        try:
            self.custom_font = font.Font(family='Literata', size=12)
        except:
            self.custom_font = font.Font(family='Arial', size=12)
    
        font_line_space = self.custom_font.metrics('linespace')
        desired_padding = 4
        row_height = font_line_space + desired_padding
    
        style = ttk.Style()
        style.theme_use("default")
    
        style.layout(
            'Custom.Treeview',
            [('Custom.Treeview.treearea', {'sticky': 'nsew'})]
        )
        style.configure(
            "Custom.Treeview",
            font=self.custom_font,
            rowheight=row_height,
            borderwidth=0,
            relief='flat',
            highlightthickness=0,
            background='white',
            fieldbackground='white'
        )
    
        style.configure(
            "Custom.Treeview.Heading",
            font=(
                self.custom_font.cget("family"),
                self.custom_font.cget("size"),
                "bold"
            ),
            background='#F7F8FC',
            relief='solid',
            borderwidth=0,
            anchor='center'
        )
        style.map(
            "Custom.Treeview.Heading",
            background=[('active', 'white')],
            relief=[('active', 'solid')]
        )
    
        style.configure("Custom.TButton", font=self.custom_font)
    
        self.sidebar_bg = '#F7F8FC'
    
        self.grid_rowconfigure(1, weight=1)
        self.grid_columnconfigure(2, weight=1)
    
        self.header = tk.Frame(self, bg='white', height=50)
        self.header.grid(row=0, column=1, columnspan=3, sticky='ew')
        self.header.grid_propagate(False)
    
        self.header_label = tk.Label(
            self.header,
            text="Movies",
            bg='white',
            font=self.custom_font,
            anchor='w',
            padx=10
        )
        self.header_label.pack(fill='x', pady=10)
    
        self.sidebar = tk.Frame(self, width=150, bg=self.sidebar_bg)
        self.sidebar.grid(row=0, column=0, rowspan=2, sticky='ns')
        self.sidebar.grid_propagate(False)
    
        self.spacer = tk.Frame(self, width=60, bg='white')
        self.spacer.grid(row=1, column=1, sticky='ns')
        self.spacer.grid_propagate(False)
    
        self.content = tk.Frame(self, bg='white')
        self.content.grid(row=1, column=2, sticky='nsew')
    
        self.button_bar = tk.Frame(self, width=50, bg='white')
        self.button_bar.grid(row=1, column=3, sticky='ns')
        self.button_bar.grid_propagate(False)
    
        self.create_sidebar_label("Movies", self.show_movies)
        self.create_sidebar_label("Series", self.show_series)
    
        self.add_button = ttk.Button(
            self.button_bar,
            text="+",
            command=self.add_entry,
            width=3,
            style="Custom.TButton"
        )
        self.add_button.pack(pady=20)
    
        self.delete_button = ttk.Button(
            self.button_bar,
            text="-",
            command=self.delete_entry,
            width=3,
            style="Custom.TButton"
        )
        self.delete_button.pack(pady=10)
    
        self.tree = None
        self.scrollbar = None
        self.current_table = None
        self.current_row_id = None
    
        self.boolean_columns = {
            'movies': ['Present', 'Watched'],
            'series': ['Present', 'Complete', 'Watched']
        }
    
        self.show_movies()
    
    def create_sidebar_label(self, text, command):
        label = tk.Label(
            self.sidebar,
            text=text,
            bg=self.sidebar_bg,
            font=self.custom_font,
            cursor="hand2",
            anchor='w',
            padx=10,
            pady=5
        )
        label.pack(pady=10, padx=0, fill='x')
        label.bind("<Enter>", lambda e: label.config(bg='#EAEDEF'))
        label.bind("<Leave>", lambda e: label.config(bg=self.sidebar_bg))
        label.bind("<Button-1>", lambda e: command())
    
    def clear_content(self):
        if self.tree:
            self.tree.destroy()
            self.tree = None
        if self.scrollbar:
            self.scrollbar.destroy()
            self.scrollbar = None
    
    def setup_treeview(self, columns, headings):
        self.tree = ttk.Treeview(
            self.content,
            columns=columns,
            show='headings',
            selectmode='browse',
            style="Custom.Treeview"
        )
        for col, head in zip(columns, headings):
            self.tree.heading(col, text=head, anchor='center')
            if head.lower() == 'notes':
                self.tree.column(col, width=300, anchor='w')
            elif head in self.boolean_columns.get(self.current_table, []):
                self.tree.column(col, width=100, anchor='center')
            else:
                self.tree.column(col, width=150, anchor='center')
    
        self.scrollbar = ttk.Scrollbar(
            self.content,
            orient="vertical",
            command=self.tree.yview
        )
        self.tree.configure(yscrollcommand=self.scrollbar.set)
        self.scrollbar.pack(side='right', fill='y')
        self.tree.pack(fill='both', expand=True)
    
        self.tree.bind('<<TreeviewSelect>>', self.on_row_select)
        self.tree.bind('<Double-1>', self.on_double_click)
        self.tree.bind('<Button-1>', self.on_single_click)
        self.tree.bind("<Motion>", self.treeview_click_cursor)
    
    def treeview_click_cursor(self, event):
        region = self.tree.identify("region", event.x, event.y)
        if region == "cell":
            column = self.tree.identify_column(event.x)
            try:
                col_index = int(column.replace('#', '')) - 1
                column_name = self.tree['columns'][col_index]
                if column_name in self.boolean_columns.get(self.current_table, []):
                    self.tree.configure(cursor="hand2")
                else:
                    self.tree.configure(cursor="")
            except (IndexError, ValueError):
                self.tree.configure(cursor="")
        else:
            self.tree.configure(cursor="")
    
    def load_movie_data(self):
        self.clear_content()
        columns = ["Movie", "Year", "Present", "Watched", "Notes"]
        headings = ["Movie", "Year", "Present", "Watched", "Notes"]
        self.setup_treeview(columns, headings)
        self.current_table = 'movies'
        self.header_label.config(text="Movies")
        for row in run_query('SELECT * FROM movies'):
            record_id = row[0]
            movie, year, present, watched, notes = row[1], row[2], row[3], row[4], row[5]
            display_row = [
                movie,
                year,
                self.bool_to_checkbox(present),
                self.bool_to_checkbox(watched),
                notes
            ]
            self.tree.insert('', 'end', iid=str(record_id), values=display_row)
    
    def load_series_data(self):
        self.clear_content()
        columns = [
            "Series", "Seasons", "Year", "Present",
            "Seasons Present", "Complete", "Watched",
            "Seasons Seen", "Notes"
        ]
        headings = [
            "Series", "Seasons", "Year", "Present",
            "Seasons Present", "Complete", "Watched",
            "Seasons Seen", "Notes"
        ]
        self.setup_treeview(columns, headings)
        self.current_table = 'series'
        self.header_label.config(text="Series")
        for row in run_query('SELECT * FROM series'):
            record_id = row[0]
            (
                series, seasons, year, present, seasons_present,
                complete, watched, seasons_seen, notes
            ) = row[1], row[2], row[3], row[4], row[5], row[6], row[7], row[8], row[9]
            display_row = [
                series,
                seasons,
                year,
                self.bool_to_checkbox(present),
                seasons_present,
                self.bool_to_checkbox(complete),
                self.bool_to_checkbox(watched),
                seasons_seen,
                notes
            ]
            self.tree.insert('', 'end', iid=str(record_id), values=display_row)
    
    def show_movies(self):
        self.load_movie_data()
    
    def show_series(self):
        self.load_series_data()
    
    def add_entry(self):
        if self.current_table == 'movies':
            run_query(
                "INSERT INTO movies (movie, year, present, watched, notes) "
                "VALUES (?, ?, ?, ?, ?)",
                ('', '', False, False, '')
            )
            self.load_movie_data()
        elif self.current_table == 'series':
            run_query(
                """INSERT INTO series
                (series, seasons, year, present, seasons_present, complete, 
                watched, seasons_seen, notes)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
                ('', '', '', False, '', False, False, '', '')
            )
            self.load_series_data()
    
    def delete_entry(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showwarning("No selection", "Please select a row to delete.")
            return
    
        row_id = selected_item[0]
        if self.current_table == 'movies':
            run_query("DELETE FROM movies WHERE id = ?", (row_id,))
            self.load_movie_data()
        elif self.current_table == 'series':
            run_query("DELETE FROM series WHERE id = ?", (row_id,))
            self.load_series_data()
    
    def on_row_select(self, event):
        selected_item = self.tree.selection()
        if selected_item:
            self.current_row_id = selected_item[0]
        else:
            self.current_row_id = None
    
    def on_single_click(self, event):
        region = self.tree.identify("region", event.x, event.y)
        if region != "cell":
            return
        row_id = self.tree.identify_row(event.y)
        column = self.tree.identify_column(event.x)
        if not row_id or not column:
            return
        try:
            col_index = int(column.replace('#', '')) - 1
        except ValueError:
            return
        if col_index < 0 or col_index >= len(self.tree['columns']):
            return
        column_name = self.tree['columns'][col_index]
        if self.current_table and column_name in self.boolean_columns.get(self.current_table, []):
            current_value = self.tree.set(row_id, column_name)
            new_value = not self.checkbox_to_bool(current_value)
            self.tree.set(row_id, column_name, self.bool_to_checkbox(new_value))
            row_values = self.tree.item(row_id)['values']
            self.update_database(row_values)
    
    def on_double_click(self, event):
        item = self.tree.identify_row(event.y)
        column = self.tree.identify_column(event.x)
        if not item:
            return
        try:
            col_num = int(column.replace('#', '')) - 1
        except ValueError:
            return
        if (
            (self.current_table == 'movies' and
             self.tree['columns'][col_num] in self.boolean_columns['movies']) or
            (self.current_table == 'series' and
             self.tree['columns'][col_num] in self.boolean_columns['series'])
        ):
            return
        if col_num < 0 or col_num >= len(self.tree['columns']):
            return
        column_name = self.tree['columns'][col_num]
        value = self.tree.set(item, column_name)
        if self.current_table and column_name in self.boolean_columns.get(self.current_table, []):
            return
        bbox = self.tree.bbox(item, column)
        if not bbox:
            return
        x, y, width, height = bbox
        entry = tk.Entry(
            self.content,
            font=self.custom_font,
            relief='flat',
            borderwidth=0,
            highlightthickness=0,
            bg='white'
        )
        entry.place(x=x, y=y, width=width, height=height)
        entry.insert(0, value)
        entry.focus()
    
        def save_edit(event_inner):
            new_value = entry.get()
            entry.destroy()
            self.tree.set(item, column_name, new_value)
            row_values = self.tree.item(item)['values']
            self.update_database(row_values)
    
        entry.bind('<Return>', save_edit)
        entry.bind('<FocusOut>', save_edit)
    
    def update_database(self, row_values):
        if self.current_table == 'movies':
            present = self.checkbox_to_bool(row_values[2])
            watched = self.checkbox_to_bool(row_values[3])
            query = (
                "UPDATE movies SET movie = ?, year = ?, present = ?, "
                "watched = ?, notes = ? WHERE id = ?"
            )
            parameters = (
                row_values[0], row_values[1], present, watched,
                row_values[4], self.current_row_id
            )
        elif self.current_table == 'series':
            present = self.checkbox_to_bool(row_values[3])
            complete = self.checkbox_to_bool(row_values[5])
            watched = self.checkbox_to_bool(row_values[6])
            query = (
                """UPDATE series SET series = ?, seasons = ?, year = ?, present = ?,
                seasons_present = ?, complete = ?, watched = ?, seasons_seen = ?,
                notes = ? WHERE id = ?"""
            )
            parameters = (
                row_values[0], row_values[1], row_values[2],
                present, row_values[4],
                complete, watched,
                row_values[7], row_values[8], self.current_row_id
            )
        run_query(query, parameters)
    
    @staticmethod
    def bool_to_checkbox(value):
        return '☑' if value else '☐'
    
    @staticmethod
    def checkbox_to_bool(value):
        return True if value == '☑' else False
    

    if name == "main": create_tables() app = MediaTracker() app.mainloop()

  2. Assistant

    Here's the refactored version of your code, focusing on clarity and reducing redundancy:

    import tkinter as tk
    from tkinter import ttk, messagebox, font
    import sqlite3
    import sys
    
    if sys.platform.startswith('win'):
        try:
            import ctypes
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception as e:
            print("Error setting DPI awareness:", e)
    
    
    def run_query(query, parameters=()):
        """Executes a SQL query with optional parameters."""
        with sqlite3.connect('media.db') as conn:
            cursor = conn.cursor()
            result = cursor.execute(query, parameters)
            return result.fetchall() if query.strip().lower().startswith("select") else conn.commit()
    
    
    def create_tables():
        """Creates database tables for movies and series."""
        queries = [
            '''
            CREATE TABLE IF NOT EXISTS movies (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                movie TEXT,
                year TEXT,
                present BOOLEAN,
                watched BOOLEAN,
                notes TEXT
            );
            ''',
            '''
            CREATE TABLE IF NOT EXISTS series (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                series TEXT,
                seasons TEXT,
                year TEXT,
                present BOOLEAN,
                seasons_present TEXT,
                complete BOOLEAN,
                watched BOOLEAN,
                seasons_seen TEXT,
                notes TEXT
            );
            '''
        ]
        for query in queries:
            run_query(query)
    
    
    class MediaTracker(tk.Tk):
        def __init__(self):
            super().__init__()
            self.configure(bg='white')
            self.setup_dpi_scaling()
            self.setup_window()
            self.setup_fonts()
            self.setup_styles()
            self.create_ui_elements()
            self.boolean_columns = {'movies': ['Present', 'Watched'], 'series': ['Present', 'Complete', 'Watched']}
            self.current_table, self.current_row_id, self.tree, self.scrollbar = None, None, None, None
            self.show_movies()
    
        def setup_dpi_scaling(self):
            """Configures DPI scaling for Windows."""
            if sys.platform.startswith('win'):
                try:
                    scaling = self.winfo_fpixels('1i') / 72
                    self.tk.call('tk', 'scaling', scaling)
                except Exception as e:
                    print("Error setting scaling:", e)
    
        def setup_window(self):
            """Initializes main window properties."""
            self.title("Movies and Series Tracker")
            self.geometry("1200x600")
    
        def setup_fonts(self):
            """Sets default fonts."""
            try:
                self.custom_font = font.Font(family='Literata', size=12)
            except:
                self.custom_font = font.Font(family='Arial', size=12)
    
        def setup_styles(self):
            """Configures ttk styles."""
            style = ttk.Style()
            style.theme_use("default")
            style.configure(
                "Custom.Treeview",
                font=self.custom_font,
                rowheight=self.custom_font.metrics('linespace') + 4,
                borderwidth=0, relief='flat',
                highlightthickness=0, background='white',
                fieldbackground='white'
            )
            style.configure("Custom.Treeview.Heading", font=(self.custom_font.cget("family"), self.custom_font.cget("size"), "bold"))
            style.configure("Custom.TButton", font=self.custom_font)
    
        def create_ui_elements(self):
            """Initializes UI elements."""
            self.create_frames()
            self.create_sidebar_buttons()
            self.create_control_buttons()
    
        def create_frames(self):
            """Creates application frames."""
            self.header = tk.Frame(self, bg='white', height=50)
            self.header.grid(row=0, column=1, columnspan=3, sticky='ew')
    
            self.header_label = tk.Label(self.header, text="Movies", bg='white', font=self.custom_font, anchor='w', padx=10)
            self.header_label.pack(fill='x', pady=10)
    
            self.sidebar = tk.Frame(self, width=150, bg='#F7F8FC')
            self.sidebar.grid(row=0, column=0, rowspan=2, sticky='ns')
    
            self.spacer = tk.Frame(self, width=60, bg='white')
            self.spacer.grid(row=1, column=1, sticky='ns')
    
            self.content = tk.Frame(self, bg='white')
            self.content.grid(row=1, column=2, sticky='nsew')
    
            self.button_bar = tk.Frame(self, width=50, bg='white')
            self.button_bar.grid(row=1, column=3, sticky='ns')
    
        def create_sidebar_buttons(self):
            """Creates sidebar buttons."""
            self.create_sidebar_label("Movies", self.show_movies)
            self.create_sidebar_label("Series", self.show_series)
    
        def create_sidebar_label(self, text, command):
            """Creates a label for the sidebar."""
            label = tk.Label(self.sidebar, text=text, bg='#F7F8FC', font=self.custom_font, cursor="hand2", anchor='w', padx=10, pady=5)
            label.pack(pady=10, fill='x')
            label.bind("<Enter>", lambda _: label.config(bg='#EAEDEF'))
            label.bind("<Leave>", lambda _: label.config(bg='#F7F8FC'))
            label.bind("<Button-1>", lambda _: command())
    
        def create_control_buttons(self):
            """Creates control buttons."""
            self.add_button = ttk.Button(self.button_bar, text="+", command=self.add_entry, width=3, style="Custom.TButton")
            self.add_button.pack(pady=20)
    
            self.delete_button = ttk.Button(self.button_bar, text="-", command=self.delete_entry, width=3, style="Custom.TButton")
            self.delete_button.pack(pady=10)
    
        def clear_content(self):
            """Clears content in the main display area."""
            if self.tree:
                self.tree.destroy()
                self.tree = None
            if self.scrollbar:
                self.scrollbar.destroy()
                self.scrollbar = None
    
        def setup_treeview(self, columns):
            """Initializes the Treeview widget."""
            self.tree = ttk.Treeview(self.content, columns=columns, show='headings', selectmode='browse', style="Custom.Treeview")
            for col in columns:
                self.tree.heading(col, text=col, anchor='center')
                self.tree.column(col, width=300 if col == 'Notes' else 150 if col.lower() in ['movie', 'series', 'year'] else 100, anchor='center')
    
            self.scrollbar = ttk.Scrollbar(self.content, orient="vertical", command=self.tree.yview)
            self.tree.configure(yscrollcommand=self.scrollbar.set)
            self.scrollbar.pack(side='right', fill='y')
            self.tree.pack(fill='both', expand=True)
    
            self.tree.bind('<<TreeviewSelect>>', self.on_row_select)
            self.tree.bind('<Double-1>', self.on_double_click)
            self.tree.bind('<Button-1>', self.on_single_click)
            self.tree.bind("<Motion>", self.treeview_click_cursor)
    
        def treeview_click_cursor(self, event):
            """Changes cursor appearance on Treeview interaction."""
            region = self.tree.identify("region", event.x, event.y)
            if region == "cell":
                column_index = int(self.tree.identify_column(event.x).replace('#', '')) - 1
                column_name = self.tree['columns'][column_index]
                cursor_style = "hand2" if column_name in self.boolean_columns.get(self.current_table, []) else ""
                self.tree.configure(cursor=cursor_style)
            else:
                self.tree.configure(cursor="")
    
        def load_data(self, query, columns, table_name):
            """Loads data from the database into the Treeview."""
            self.clear_content()
            self.setup_treeview(columns)
            self.current_table = table_name
            self.header_label.config(text=table_name.capitalize())
            for row in run_query(query):
                record_id, *row_data = row
                display_row = [self.bool_to_checkbox(row_data[i]) if columns[i] in self.boolean_columns.get(table_name, []) else row_data[i] for i in range(len(columns))]
                self.tree.insert('', 'end', iid=str(record_id), values=display_row)
    
        def show_movies(self):
            """Displays movie data."""
            columns = ["Movie", "Year", "Present", "Watched", "Notes"]
            self.load_data('SELECT * FROM movies', columns, 'movies')
    
        def show_series(self):
            """Displays series data."""
            columns = ["Series", "Seasons", "Year", "Present", "Seasons Present", "Complete", "Watched", "Seasons Seen", "Notes"]
            self.load_data('SELECT * FROM series', columns, 'series')
    
        def add_entry(self):
            """Adds a blank entry to the current table."""
            data = ('', '', False, False, '') if self.current_table == 'movies' else ('', '', '', False, '', False, False, '', '')
            columns = ['movie', 'year', 'present', 'watched', 'notes'] if self.current_table == 'movies' else ['series', 'seasons', 'year', 'present', 'seasons_present', 'complete', 'watched', 'seasons_seen', 'notes']
            query = f"INSERT INTO {self.current_table} ({', '.join(columns)}) VALUES ({', '.join(['?']*len(columns))})"
            run_query(query, data)
            self.show_movies() if self.current_table == 'movies' else self.show_series()
    
        def delete_entry(self):
            """Deletes the selected entry from the current table."""
            selected_item = self.tree.selection()
            if selected_item:
                run_query(f"DELETE FROM {self.current_table} WHERE id = ?", (selected_item[0],))
                self.show_movies() if self.current_table == 'movies' else self.show_series()
            else:
                messagebox.showwarning("No selection", "Please select a row to delete.")
    
        def on_row_select(self, event):
            """Handles row selection event."""
            selected_item = self.tree.selection()
            self.current_row_id = selected_item[0] if selected_item else None
    
        def on_single_click(self, event):
            """Processes single click events."""
            region = self.tree.identify("region", event.x, event.y)
            if region == "cell":
                self.toggle_checkbox(event)
    
        def on_double_click(self, event):
            """Processes double click events."""
            row_id = self.tree.identify_row(event.y)
            column = self.tree.identify_column(event.x)
            col_index = int(column.replace('#', '')) - 1 if column else -1
            if col_index >= 0 and col_index < len(self.tree['columns']):
                column_name = self.tree['columns'][col_index]
                if column_name not in self.boolean_columns.get(self.current_table, []):
                    self.edit_cell(row_id, column, column_name)
    
        def toggle_checkbox(self, event):
            """Toggles boolean value on checkbox click."""
            row_id, col_index = self.get_click_info(event)
            if row_id is not None and col_index is not None:
                column_name = self.tree['columns'][col_index]
                if column_name in self.boolean_columns.get(self.current_table, []):
                    current_value = self.tree.set(row_id, column_name)
                    new_value = not self.checkbox_to_bool(current_value)
                    self.tree.set(row_id, column_name, self.bool_to_checkbox(new_value))
                    self.save_changes(row_id)
    
        def get_click_info(self, event):
            """Gets row id and column index from click event."""
            row_id = self.tree.identify_row(event.y)
            try:
                column = self.tree.identify_column(event.x)
                col_index = int(column.replace('#', '')) - 1
            except (ValueError, IndexError):
                return None, None
            return row_id, col_index
    
        def edit_cell(self, row_id, column, column_name):
            """Edits a cell in the Treeview."""
            value, bbox = self.tree.set(row_id, column_name), self.tree.bbox(row_id, column)
            if bbox:
                x, y, width, height = bbox
                entry = tk.Entry(self.content, font=self.custom_font, relief='flat', borderwidth=0, highlightthickness=0, bg='white')
                entry.place(x=x, y=y, width=width, height=height)
                entry.insert(0, value)
                entry.focus()
                entry.bind('<Return>', lambda _: self.save_edit(entry, row_id, column_name))
                entry.bind('<FocusOut>', lambda _: self.save_edit(entry, row_id, column_name))
    
        def save_edit(self, entry, row_id, column_name):
            """Saves edits made to a cell."""
            new_value = entry.get()
            entry.destroy()
            self.tree.set(row_id, column_name, new_value)
            self.save_changes(row_id)
    
        def save_changes(self, row_id):
            """Saves changes to the database."""
            row_values = self.tree.item(row_id)['values']
            columns = self.tree['columns']
            assignments = [f"{col} = ?" for col in columns]
            params = [self.checkbox_to_bool(row_values[i]) if columns[i] in self.boolean_columns.get(self.current_table, []) else row_values[i] for i in range(len(columns))]
            params.append(row_id)
            run_query(f"UPDATE {self.current_table} SET {', '.join(assignments)} WHERE id = ?", params)
    
        @staticmethod
        def bool_to_checkbox(value):
            """Converts a boolean to a checkbox symbol."""
            return '☑' if value else '☐'
    
        @staticmethod
        def checkbox_to_bool(value):
            """Converts a checkbox symbol to a boolean."""
            return True if value == '☑' else False
    
    
    if __name__ == "__main__":
        create_tables()
        app = MediaTracker()
        app.mainloop()
    

    Key Changes:

    • Centralized repeated code via helper methods (load_data, edit_cell, get_click_info).
    • Simplified column setup in the setup_treeview based on standardized options.
    • Combined similar functionalities and removed redundant logic.
    • Improved readability and conformance with PEP guidelines.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.