[feat](app): support more efficient plant filtering

app.py

@@ -73,21 +73,43 @@ INTERFACE_TEXTS = {
     },
 }
 
-# Import and process plant data
-df = pd.read_csv("plants.csv")
-
-# Convert columns to Categorical type and remove rows with NaN in 'gold' column
-df["species"] = pd.Categorical(df["species"])
-df["tier"] = pd.Categorical(df["tier"])
-df = df.dropna(subset=["gold"])
-df = df.astype(
-    {
-        "gold": int,
-        "gems": int,
-    }
+
+def process_csv(file_path):
+    """import and process plants data"""
+    df = pd.read_csv(file_path)
+    df["species"] = pd.Categorical(df["species"])
+    df["tier"] = pd.Categorical(df["tier"])
+    # df = df.dropna(subset=["gold"])
+    df = df.astype(
+        {
+            "gold": int,
+            "gems": int,
+        }
+    )
+    return df
+
+
+df = process_csv("plants.csv")
+
+GOLD_PLANTS = set(
+    row["species"]
+    for _, row in df.iterrows()
+    if row["gold"] != 0 and row["tier"] != "feeble"
+)
+GEMS_PLANTS = set(
+    row["species"]
+    for _, row in df.iterrows()
+    if row["gems"] != 0 and row["tier"] != "feeble"
 )
 
 
+def check_currency(plant, currency):
+    if currency == "gold":
+        return plant in GOLD_PLANTS
+    elif currency == "gems":
+        return plant in GEMS_PLANTS
+
+
 def calculator(currency, budget, strategy, extra_rate, *amount):
     """
     Calculate the optimal solution of plant sales based on the given budget
@@ -95,10 +117,11 @@ def calculator(currency, budget, strategy, extra_rate, *amount):
 
     Args:
         *args (tuple): A tuple containing:
+            - currency (str): The currency used for purchasing plants ("gold" or "gems").
             - budget (int): Gabby's gold budget.
             - strategy (str): The selected strategy for selling plants ("MaximizeStock" or "MinimizeStock").
             - extra_rate (int): The premium rate for selling plants.
-            - stocks (list of int): Stock levels of each plant type.
+            - amount (list of int): Stock levels of each plant type.
 
     Returns:
         str: A description of the optimal solution, including which plants to sell,
@@ -122,7 +145,7 @@ def calculator(currency, budget, strategy, extra_rate, *amount):
     sold_prices = np.array(price * (1 + extra_rate))
 
     # Initialize the master problem
-    model = Model("BewilderingBlossom")
+    model = Model("BewilderingBlooms")
 
     # Decision variables in master problem
     x = [
@@ -157,7 +180,7 @@ def calculator(currency, budget, strategy, extra_rate, *amount):
         # Final solution processing
         solution = []
         total_price = 0
-        # total_count = 0
+        total_count = 0
 
         if model.getStatus() == "optimal":
             for i, var in enumerate(x):
@@ -166,12 +189,12 @@ def calculator(currency, budget, strategy, extra_rate, *amount):
                         f"{plants_names[i]} ({sold_prices[i]} {currency}): {v}\n"
                     )
                     total_price += v * sold_prices[i]
-                    # total_count += v
+                    total_count += v
 
             if optimal_total_value == budget:
-                return f"Great! Found a combination of items with a total value equal to the budget ({budget} {currency}).😃\n\n{''.join(solution)}\nTotal value: {int(total_price)} {currency}\n"  # Count: {int(model.getObjVal())}
+                return f"Great! Found a combination of items with a total value equal to the budget ({budget} {currency}).😃\n\n{''.join(solution)}\nTotal value: {int(total_price)} {currency}\nTotal count: {total_count}"  # Count: {int(model.getObjVal())}
 
-            return f"Oops! {int(budget - optimal_total_value)} {currency} short of the target value ({budget} {currency}).😣\n\n{''.join(solution)}\nTotal value: {int(total_price)} {currency}\n"  # Count: {int(model.getObjVal())}
+            return f"Oops! {int(budget - optimal_total_value)} {currency} short of the target value ({budget} {currency}).😣\n\n{''.join(solution)}\nTotal value: {int(total_price)} {currency}\nTotal count: {total_count}"  # Count: {int(model.getObjVal())}
 
         return "No solution found for the second optimization!"
 
@@ -180,14 +203,87 @@ def calculator(currency, budget, strategy, extra_rate, *amount):
 
 # 高亮每种植物的最高品质
 css = """
-.first-gold-box {background-color: #fafad2}
-.first-gems-box {background-color: #fed9b4}
+.highlight-first-gold {background-color: #fafad2}
+.highlight-first-gems {background-color: #fed9b4}
 """
 
+
+def show_checkboxgroup(currency, select_all=False):
+    """
+    根据选定的货币显示选择框。
+    """
+    plants_tuples: list[tuple[str, str]] = [
+        (PLANTS_LABLES[pl], pl)
+        for pl in PLANTS_LABLES.keys()
+        if check_currency(pl, currency)
+    ]
+
+    if select_all:
+        default_value = [v for (n, v) in plants_tuples if select_all]
+    else:
+        default_value = None
+
+    checkbox_group_component = gr.CheckboxGroup(
+        choices=plants_tuples,
+        value=default_value,
+        type="value",
+        label="Plants",
+        info="Select plants",
+        interactive=True,
+    )
+    return checkbox_group_component
+
+
+def show_plant_boxes(currency, plants=None):
+    _inventory = {}
+    species_set = set()
+    species_count = 0
+    new_species = False
+
+    for _, row in df.iterrows():
+        if (
+            row[currency] != 0
+            and row["tier"] != "feeble"
+            and (not plants or row["species"] in plants)
+        ):
+            species_set.add(row["species"])
+            inventory_key = f"{row['species']}_{row['tier']}"
+            _inventory[inventory_key] = gr.Number(
+                label=PLANTS_LABLES[row["species"]],
+                info=f"{PLANTS_TIERS[row['tier']]} ${row[currency]}",
+                value=0,
+                precision=0,
+                minimum=0,
+                maximum=500,
+                step=10,
+                visible=True,
+                elem_classes=(
+                    f"highlight-first-{currency}"
+                    if len(species_set) > species_count
+                    else None
+                ),
+            )
+            species_count = len(species_set)
+        else:
+            _inventory[f"{row['species']}_{row['tier']}"] = gr.Number(visible=False)
+
+    return list(_inventory.values())
+
+
+def handle_currency(currency):
+    """
+    根据选定的货币类型更新库存组件"""
+    return [False, show_checkboxgroup(currency)] + show_plant_boxes(currency, None)
+
+
+def handle_select_all(initial_state, currency):
+    return [(not initial_state)] + [show_checkboxgroup(currency, not initial_state)]
+
+
 with gr.Blocks(css=css) as demo:
     gr.Markdown(
         """
-        <center><font size=8>HP-Magic-Awakened Herbologist Toolkit👾</font></center>
+        <center><font size=8>HPMA Bewildering Blooms Calculator👨🏻‍🌾</font></center>
 
         This program is essentially a solver for a variant of the knapsack problem. 
         Another more versatile [application](https://huggingface.co/spaces/oh-my-dear-ai/easy-knapsack-problem).
@@ -244,65 +340,30 @@ with gr.Blocks(css=css) as demo:
             info="Select a strategy:",
         )
 
-        # TODO: Add a checkbox group for selecting plants
-        # selected_plants = gr.CheckboxGroup(
-        #     choices=list(PLANTS_LABLES.values()),
-        #     type="index",
-        #     label="Plants",
-        #     info="Select plants:",
-        #     value=list(PLANTS_LABLES.values()),
-        #     interactive=True,
-        # )
-
-    def show_plant_boxes(currency):
-        inventory = {}
-        species_set = set()
-        species_count = 0
-        new_species = False
-
-        for _, row in df.iterrows():
-            # Check if the plant should be shown based on the selected currency
-            if row[currency] != 0 and row["tier"] != "feeble":
-                species_set.add(row["species"])
-                new_species = len(species_set) > species_count
-                # Create the Number component for the plant inventory
-
-                inventory[f"{row['species']}_{row['tier']}"] = gr.Number(
-                    label=PLANTS_LABLES[row["species"]],
-                    info=f"{PLANTS_TIERS[row['tier']]} ${row[currency]}",
-                    value=0,
-                    precision=0,
-                    minimum=0,
-                    maximum=500,
-                    step=10,
-                    visible=True,
-                    elem_classes=(f"first-{currency}-box" if new_species else None),
-                )
-                species_count = len(species_set)
-            else:
-                # If not shown, create a dummy invisible component
-                inventory[f"{row['species']}_{row['tier']}"] = gr.Number(visible=False)
-
-        # Return the updated inventory components
-        return list(inventory.values())
+        plants_filter = show_checkboxgroup(currency_radio.value)
+
+        with gr.Row():
+            select_all_state = gr.State(False)
+            select_all_button = gr.Button(value="Select All⭕", size="sm")
+            filter_button = gr.Button(value="Filter Plants🔍", size="lg")
 
     # Create the dynamic plant inventory inputs
     with gr.Row() as inventory_row:
-        inventory = show_plant_boxes(currency_radio.value)
+        inventory = show_plant_boxes(currency_radio.value, plants_filter.value)
 
     # Add a row for the Clear and Calculate buttons
     with gr.Row():
-        clear_btn = gr.ClearButton(inventory, size="sm", value="❌Clear")
+        inventory_clear_btn = gr.ClearButton(inventory, size="sm", value="❌Clear")
 
-    # Add a button to trigger the calculation
-    submit_btn = gr.Button(value="🛠Calculate")
+        # Add a button to trigger the calculation
+        inventory_submit_btn = gr.Button(value="🛠Calculate")
 
     # Add a row for the result textbox
     with gr.Row():
         result = gr.Textbox(label="Output")
 
     # Set up the button click event to call the calculator function
-    submit_btn.click(
+    inventory_submit_btn.click(
         calculator,
         inputs=[currency_radio, budget, selected_strategy, acquisition_rate]
         + inventory,
@@ -312,11 +373,25 @@ with gr.Blocks(css=css) as demo:
 
     # Update the inventory when the currency changes
     currency_radio.change(
-        fn=lambda selected_currency: show_plant_boxes(
-            selected_currency
-        ),  # Adjusted function to return only the components
+        fn=handle_currency,  # Adjusted function to return only the components
         inputs=[currency_radio],
-        outputs=inventory,  # Update each child in the inventory_row
+        outputs=[
+            select_all_state,
+            plants_filter,
+        ]
+        + inventory,  # Update each child in the inventory_row
+    )
+
+    filter_button.click(
+        fn=show_plant_boxes,
+        inputs=[currency_radio, plants_filter],
+        outputs=inventory,
+    )
+
+    select_all_button.click(
+        fn=handle_select_all,
+        inputs=[select_all_state, currency_radio],
+        outputs=[select_all_state, plants_filter],
     )
 
 # Launch the Gradio application