How programmatically select a table row?

[mh-firouzjah]

Hi there
I'm new to beeware and toga, simply started this by the guide of ChatGPT and asking anything from that bot.
I have a table that loads data form multiple CSV files in a view and I want to be able to edit some of those fields and save the changes to the appropriate CSV file. the code is working finally. but the problem is after saving the changes I have to refresh the view to sort the rows again, here I loose the focus on the selected row of the table and there is not such a table.select or similar method to let me select a row programmatically (say using my code).

also there was another issue for me, I was looking for an dialog box to ask user to enter their intended values using that such a dialog box but I couldn't find such a thing in toga so I ended up using a different approach and I added some label and inputs and not visual variables to let user enter their data.

thanks for your attention.

[l-o-u-i-s-g]

There are examples of dialogs here:
https://github.com/beeware/toga/blob/main/examples/dialogs/dialogs/app.py

I have no idea about the tables, I'm still experimenting with this framework myself but I will surely later make my own table widget with fields editable on the spot. As I see it, a table is just a box containing other boxes. So rows are boxes and in each row you could possibly put input boxes. Not sure how well this would work thought. Perhaps there are big performances hits on having that many input widget on one screen.

[freakboy3742]

A table is not "just a box containing other boxes". It is a distinct widget, with a platform-specific implementation.

[l-o-u-i-s-g]

Sorry I didn't mean to offend you! I understand you created a platform-specific implementation. But if one wants to get creative he could theoretically create a table with boxes ..

[freakboy3742]

There's no offence - your answer was just wrong. It's on the level of answering "the moon is made of cheese" in an astronomy forum - it's just wrong. Given the original poster was asking as a result of ChatGPT-generated code (which is prone to some wild hallucination), I wanted to avoid any further misinformation or misunderstanding.

[mh-firouzjah]

I will surely later make my own table widget with fields editable on the spot

Actually I had tried to change the selected row's fields to toga.TextInput but that doesn't work as I expected and there TextInput did not showed up in place of the field in the row, there was a hidden input at the right bottom of the window that when I started typing text it appeared but again the entered text did nothing. also there was a warning message in termial:
UserWarning: GTK does not support the use of widgets in cells warnings.warn("GTK does not support the use of widgets in cells")

Overall the project was fine and cool and I ended up with a working app. awesome!
I still have a lot to learn in the era of GUI app development specially with toga/beeware.
Many thanks to @freakboy3742.

[freakboy3742]

What you're thinking of as a "dialog box" is effectively a secondary window that has known content. What you've got implemented as the on-page row modification widgets could be constructed as the content of a secondary window that is displayed and populated in response to selecting a row in the table.

As for committing values - the key here is to understand the ListSource structure that is used by Toga to represent Table data. When you instantiate a table, Toga takes that data and turns it into a ListSource - a collection of Row objects that can be managed like a list. This is distinct from the original "list of dicts" or whatever you've used to populate the table in the first place.

The Row object is what is returned when you ask for table.selection; if you modify that row object, the table will update automatically. If you're planning to save the values in the table to disk, it's the ListSource that you should be saving - this is what is returned by table.data.

[mh-firouzjah]

if you modify that row object, the table will update automatically.

This solution might work in most cases, but it doesn't solve my issue. The table I'm working on needs to be sorted by a specific field (profit/price). When I update the price and profit fields, the changes are reflected in the table, which is great. However, after the update, the table needs to be refreshed and re-sorted, which causes it to lose focus on the selected row. I didn't know the table gets updated automatically, but this is not the problem in my case.

[freakboy3742]

I'm not sure this changes anything - if anything, it makes the case for working with the ListSource stronger. If you extend ListSource to do sort ordering based on your requested fields, then the source (and thus the table) will automatically update ordering and refresh when the data changes (although that will depend on your sort method flagging that a refresh is required)

[mh-firouzjah]

this the code base.

#! /hdd/Projects/.venv/bin/python

import csv
from pathlib import Path

import toga
from toga.style import Pack
from toga.style.pack import COLUMN, ROW

# Define weights
WEIGHT_RATIO = 0.85
WEIGHT_PROFIT = 0.15


def humanize_number(number):
    suffixes = ["", "K", "M", "B", "T", "Q"]
    magnitude = 0
    while number >= 1000:
        magnitude += 1
        number /= 1000.0
    return f"{number:.2f}{suffixes[magnitude]}"


def dehumanize_number(humanized):
    suffixes = {"K": 1e3, "M": 1e6, "B": 1e9, "T": 1e12, "Q": 1e15}
    if humanized[-1] in suffixes or humanized[-1].upper() in suffixes:
        return float(humanized[:-1]) * suffixes[humanized[-1]]
    return float(humanized)


class HamsterSuggester(toga.App):
    def startup(self):
        font_size = 14

        main_box = toga.Box(style=Pack(direction=COLUMN, padding=10, font_size=font_size))

        self.selected_item_label = toga.Label(
            "Selected Item: None",
            style=Pack(padding=5, font_size=font_size),
        )
        profit_label = toga.Label("Profit:")
        self.profit_input = toga.TextInput(placeholder="Profit", style=Pack(padding=5))
        price_label = toga.Label("Price:")
        self.price_input = toga.TextInput(placeholder="Price", style=Pack(padding=5))
        self.save_button = toga.Button(
            "Save",
            on_press=self.save_changes,
            style=Pack(padding=5),
        )
        refresh_button = toga.Button(
            "Refresh",
            on_press=self.refresh_data,
            style=Pack(padding=5),
        )

        # Create a box for the input fields and buttons
        input_box = toga.Box(style=Pack(direction=ROW, alignment="center", padding=5))
        input_box.add(profit_label)
        input_box.add(self.profit_input)
        input_box.add(price_label)
        input_box.add(self.price_input)
        input_box.add(self.save_button)
        input_box.add(refresh_button)

        # Create the table with headings and set up the event handler
        self.table = toga.Table(
            headings=[
                "Name",
                "Profit",
                "Price",
                "Profit to Price Ratio",
                "File Name",
                "Accurate Price",
            ],
            style=Pack(flex=1, font_size=font_size),
            multiple_select=False,
        )

        main_box.add(self.selected_item_label)
        main_box.add(input_box)
        main_box.add(self.table)

        # Read CSV files and populate the table
        self.read_csv_files()

        self.main_window = toga.MainWindow(title=self.formal_name)
        self.main_window.content = main_box
        self.main_window.show()

    def refresh_data(self, widget):
        """Refresh the data displayed in the table."""
        try:
            self.read_csv_files()  # Reload data from CSV files
            self.clear_selection()  # Clear the selection after refreshing data
        except ValueError as e:
            self.main_window.error_dialog("Error", str(e))

    def clear_selection(self):
        """Clear the current selection and reset the input fields and label."""
        self.selected_item_label.text = "Selected Item: None"
        self.price_input.value = ""
        self.profit_input.value = ""
        self.selected_row = None

    def read_csv_files(self):
        # Change the current working directory to the script's directory
        script_dir = Path(__file__).parent.resolve()
        files_pattern = "*.csv"
        all_files = script_dir.glob(files_pattern)
        data = []

        for file in all_files:
            try:
                with file.open(newline="", encoding="utf-8") as csvfile:
                    reader = csv.DictReader(csvfile)
                    for row in reader:
                        row["profit"] = float(row["profit"].replace("k", "e3"))
                        row["price"] = float(row["price"].replace("k", "e3"))
                        row["profit_to_price_ratio"] = row["profit"] / row["price"]
                        row["file_name"] = file.name
                        data.append(row)
            except Exception as e:
                self.main_window.error_dialog("Error", f"Error reading {file}: {e}")
                continue

        if not data:
            msg = (
                "No valid CSV files were found or all files were skipped due to missing columns. "
                f"Current directory: {script_dir}"
            )
            self.main_window.error_dialog("Error", msg)

        # Sort data
        sorted_data = self.calculate_scores(data)
        self.populate_table(sorted_data)

    def normalize(self, data, key):
        values = [row[key] for row in data]
        min_val = min(values)
        max_val = max(values)
        for row in data:
            row[f"normalized_{key}"] = (
                (row[key] - min_val) / (max_val - min_val) if max_val != min_val else 0.5
            )

    def calculate_scores(self, data):
        self.normalize(data, "profit_to_price_ratio")
        self.normalize(data, "profit")

        for row in data:
            row["score"] = (
                WEIGHT_RATIO * row["normalized_profit_to_price_ratio"]
                + WEIGHT_PROFIT * row["normalized_profit"]
            )

        return sorted(data, key=lambda x: x["score"], reverse=True)

    def populate_table(self, data):
        self.table.data = [
            (
                row["name"],
                humanize_number(row["profit"]),
                humanize_number(row["price"]),
                f'{row["profit_to_price_ratio"]:e}',
                row["file_name"],
                row["price"],
            )
            for row in data
        ]

        # Add event listeners for selection
        self.table.on_select = self.on_row_select

    def on_row_select(self, widget):
        selected_row = widget.selection
        if selected_row:
            self.selected_item_label.text = f"Selected Item: {selected_row.name}"
            self.profit_input.value = str(selected_row.profit)
            self.price_input.value = str(int(selected_row.accurate_price))
            self.selected_row = selected_row

    def save_changes(self, widget):
        if self.profit_input.value and self.price_input.value:
            try:
                new_profit = float(dehumanize_number(self.profit_input.value))
                new_price = float(self.price_input.value)
            except ValueError:
                self.main_window.error_dialog("Invalid Input", "Please enter valid numbers.")
                return

            self.selected_row.price = new_price
            self.selected_row.profit = new_profit
            self.selected_row.profit_to_price_ratio = f"{new_profit / new_price:e}"

            # Update the corresponding CSV file
            self.update_csv(self.selected_row)
            # Refresh the view
            self.refresh_data()

    def update_csv(self, updated_row):
        # Resolve the file path relative to the script's directory
        script_dir = Path(__file__).parent.resolve()
        file_path = script_dir / updated_row.file_name

        if not file_path.exists():
            self.main_window.error_dialog("File Not Found", f"The file {file_path} does not exist.")
            return

        rows = []
        with file_path.open(mode="r", newline="", encoding="utf-8") as csvfile:
            reader = csv.DictReader(csvfile)
            for csv_row in reader:
                # Update the row corresponding to the item name
                if csv_row["name"] == updated_row.name:
                    csv_row["price"] = str(updated_row.price)
                    csv_row["profit"] = str(updated_row.profit)
                rows.append(csv_row)

        # Write the updated contents back to the CSV file
        with file_path.open(mode="w", newline="", encoding="utf-8") as csvfile:
            writer = csv.DictWriter(csvfile, fieldnames=reader.fieldnames)
            writer.writeheader()
            writer.writerows(rows)


def main():
    return HamsterSuggester(
        "Hamster Suggester",
        "https://github.com/mh-firouzjah/hamsterkombat-card-suggester",
    )


if __name__ == "__main__":
    main().main_loop()

[freakboy3742]

While I'm happy to provide guidance, or even debug a small segment of code, I wasn't offering to write your entire project for you. If you've got a specific question about your code, you'll need to ask it.

[mh-firouzjah]

I'm done with that. it works fine and I'm satisfied with.
I pasted the code so everyone reading this issue could have working example (not a complete solution for the issue)