Implement method deletion and renaming updates in calculation setups

Author: mrvisscher

activity_browser/actions/method/method_delete.py

@@ -1,3 +1,4 @@
+from os import name
 from typing import List
 from logging import getLogger
 
@@ -13,9 +14,17 @@
 
 class MethodDelete(ABAction):
     """
-    ABAction to remove one or multiple methods. First check whether the method is a node or leaf. If it's a node, also
-    include all underlying methods. Ask the user for confirmation, and return if canceled. Otherwise, remove all found
-    methods.
+    Delete one or more impact assessment methods (impact categories).
+
+    Flow:
+    - Confirm with the user.
+    - Deregister all selected methods from Brightway.
+    - Update all Brightway calculation setups by removing the deleted methods from their
+      'ia' list (if present), and serialize the updated setups.
+
+    Notes:
+    - Calculation setups can store method identifiers either as tuples (recommended) or
+      sometimes as strings for single-level names; the cleanup accounts for both.
     """
 
     icon = qicons.delete
@@ -44,7 +53,41 @@ def run(methods: List[tuple]):
         if warning == QtWidgets.QMessageBox.No:
             return
 
-        # instruct the controller to delete the selected methods
+        # collect names for calculation setup cleanup
+        to_remove = {m.name for m in all_methods}
+
+        # delete all methods by deregistering them
         for method in all_methods:
             method.deregister()
             log.info(f"Deleted method {method.name}")
+
+        # remove deleted methods from all calculation setups
+        MethodDelete.remove_methods_from_calculation_setups(to_remove)
+
+    @staticmethod
+    def remove_methods_from_calculation_setups(method_names: set[tuple]) -> None:
+        """
+        Remove given method names from all calculation setups' 'ia' lists and serialize.
+        """
+        try:
+            changed_any = False
+
+            for cs_name, cs in bd.calculation_setups.items():
+                ia = cs.get("ia", [])
+                
+                for name in method_names:
+                    if name not in ia:
+                        continue  # name not present, skip
+                    
+                    ia.remove(name)
+                    changed_any = True
+                    
+                    log.info(
+                        f"Updated calculation setup '{cs_name}': removed impact category {name}"
+                    )
+
+            
+            if changed_any:
+                bd.calculation_setups.serialize()
+        except Exception:
+            log.exception("Failed to update calculation setups after method rename")

activity_browser/actions/method/method_rename.py

@@ -14,28 +14,19 @@
 
 class MethodRename(ABAction):
     """
-    Renames an existing method in the Brightway2 data structure.
+    Rename an existing impact assessment method (impact category).
 
-    This method allows renaming a single method by prompting the user for a new name.
-    It ensures that only one method is renamed at a time, validates the new name, and
-    updates the method in the Brightway2 database.
-
-    Args:
-        method_name (tuple[str] | list[tuple[str]]): The name of the method to rename.
-            If a list is provided, it must contain exactly one tuple.
-
-    Steps:
-    - Ensure only one method is being renamed at a time.
-    - Check if the method exists in the Brightway2 database.
-    - Open a dialog to prompt the user for the new method name.
-    - Validate the new name to ensure it is not empty and does not already exist.
+    Flow:
+    - Ensure only one method is selected and it exists.
+    - Prompt the user for the new name and validate it.
     - Copy the method to the new name and process it.
-    - Emit a signal to notify that the method has been renamed.
-    - Deregister the old method.
+    - Update all Brightway calculation setups by replacing the old method in 'ia' lists with
+      the new name and serialize the updates.
+    - Emit a rename signal and deregister the old method.
 
     Raises:
-        ValueError: If more than one method is provided for renaming.
-        RuntimeError: If the method does not exist, the new name is empty, or the new name already exists.
+    - ValueError: If more than one method is provided for renaming.
+    - RuntimeError: If the method does not exist, the new name is empty, or the new name already exists.
     """
 
     text = "Rename Impact Category"
@@ -57,14 +48,13 @@ def run(method_name: tuple[str] | list[tuple[str]]):
 
         # open dialog to get new name
         dialog = widgets.ABListEditDialog(
-            method_name, 
-            title="Rename Impact Category", 
-            parent=application.main_window
+            method_name,
+            title="Rename Impact Category",
+            parent=application.main_window,
         )
-        dialog.exec_()
 
-        # if dialog was cancelled, do nothing
-        if not dialog.result() == QtWidgets.QDialog.Accepted:
+        # execute the dialog and check for acceptance
+        if dialog.exec_() != QtWidgets.QDialog.Accepted:
             return
 
         new_name = dialog.get_data(as_tuple=True)
@@ -82,9 +72,41 @@ def run(method_name: tuple[str] | list[tuple[str]]):
         # copy method to new name and process
         method.copy(new_name).process()
 
+        # Update any calculation setups that reference this method
+        MethodRename.rename_method_in_calculation_setups(method_name, new_name)
+
         # this should not happen like this, as the model and therefore signals should be handled declaritavely,
         # but since method renaming is not native to bw2data we have to do it manually here
         signals.method.renamed.emit(method_name, new_name)
 
         # deregister old method
         method.deregister()
+
+    @staticmethod
+    def rename_method_in_calculation_setups(old_name: tuple, new_name: tuple) -> None:
+        """Replace occurrences of old_name with new_name in all CS 'ia' lists and serialize.
+
+        Handles both tuple and single-string method keys. Best-effort: logs on failure
+        without blocking the rename flow.
+        """
+        try:
+            changed_any = False
+
+            for cs_name, cs in bd.calculation_setups.items():
+                ia = cs.get("ia", [])
+                
+                if old_name not in ia:
+                    continue
+
+                i = ia.index(old_name)
+                ia[i] = new_name
+
+                changed_any = True
+                log.info(
+                    f"Updated calculation setup '{cs_name}': renamed impact category {old_name} -> {new_name}"
+                )
+            
+            if changed_any:
+                bd.calculation_setups.serialize()
+        except Exception:
+            log.exception("Failed to update calculation setups after method rename")

tests/actions/test_method_actions.py

@@ -181,3 +181,66 @@ def test_method_new(monkeypatch, basic_database):
     # Verify the method is empty
     method_obj = Method(new_method)
     assert len(method_obj.load()) == 0
+
+
+def test_calculation_setups_updated_on_method_delete(monkeypatch, basic_database):
+    # ensure method exists and is present in calculation setup
+    method = ("basic_method",)
+
+    from bw2data import methods as bw_methods
+    import bw2data as bd
+
+    assert method in bw_methods
+    # Ensure the calculation setup references the method (arrange precondition)
+    cs = bd.calculation_setups["basic_calculation_setup"]
+    cs["ia"] = [method]
+    bd.calculation_setups["basic_calculation_setup"] = cs
+    bd.calculation_setups.serialize()
+
+    # auto-confirm deletion
+    monkeypatch.setattr(
+        QtWidgets.QMessageBox,
+        "warning",
+        staticmethod(lambda *args, **kwargs: QtWidgets.QMessageBox.Yes),
+    )
+
+    actions.MethodDelete.run([method])
+
+    # method removed
+    assert method not in bw_methods
+    # calculation setup no longer references deleted method
+    cs = bd.calculation_setups["basic_calculation_setup"]
+    assert method not in cs.get("ia", [])
+
+
+def test_calculation_setups_updated_on_method_rename(monkeypatch, basic_database):
+    # prepare rename dialog to accept and return new name
+    from activity_browser.ui.widgets import ABListEditDialog
+    import bw2data as bd
+
+    old = ("basic_method",)
+    new = ("renamed_method",)
+
+    # Ensure the calculation setup references the old method (arrange precondition)
+    cs = bd.calculation_setups["basic_calculation_setup"]
+    cs["ia"] = [old]
+    bd.calculation_setups["basic_calculation_setup"] = cs
+    bd.calculation_setups.serialize()
+
+    monkeypatch.setattr(
+        ABListEditDialog,
+        "exec_",
+        staticmethod(lambda *args, **kwargs: QtWidgets.QDialog.Accepted),
+    )
+    monkeypatch.setattr(
+        ABListEditDialog,
+        "get_data",
+        staticmethod(lambda *args, **kwargs: new),
+    )
+
+    actions.MethodRename.run(old)
+
+    # setups reference the new method name
+    cs = bd.calculation_setups["basic_calculation_setup"]
+    assert new in cs.get("ia", [])
+    assert old not in cs.get("ia", [])