Branch 2.6.2 (#479)

* Improve parameter deleting (#478)

* Delete database group after deleting database

* Clean up activity group on activity delete

* Try and delete group if activity param is removed

* Add controller method for clearing activity param

* Trigger removal of parameter with signal

* Recalculate after editing parameter

* Recalculate even if formula is the same

* Drop unused method for recalculating

* Ensure delete goes before select

* Use applymap instead of apply (#476)

Author: dgdekoning

activity_browser/app/bwutils/superstructure/excel.py

@@ -78,8 +78,7 @@ def import_from_excel(document_path: Union[str, Path], import_sheet: int = 1):
         raise ValueError("Missing required column(s) for superstructure: {}".format(diff.to_list()))
 
     # Convert specific columns that may have tuples as strings
-    data["from categories"] = data["from categories"].apply(lambda x: convert_tuple_str(x))
-    data["from key"] = data["from key"].apply(lambda x: convert_tuple_str(x))
-    data["to categories"] = data["to categories"].apply(lambda x: convert_tuple_str(x))
-    data["to key"] = data["to key"].apply(lambda x: convert_tuple_str(x))
+    columns = ["from categories", "from key", "to categories", "to key"]
+    data.loc[:, columns] = data[columns].applymap(convert_tuple_str)
+
     return data

activity_browser/app/controller.py

@@ -3,7 +3,7 @@
 from typing import Iterable, Optional
 
 import brightway2 as bw
-from bw2data.parameters import ActivityParameter
+from bw2data.parameters import ActivityParameter, Group
 from PySide2 import QtWidgets
 from PySide2.QtCore import QObject, Slot
 from bw2data.backends.peewee import sqlite3_lci_db
@@ -79,6 +79,7 @@ def connect_signals(self):
         signals.parameter_modified.connect(self.modify_parameter)
         signals.parameter_uncertainty_modified.connect(self.modify_parameter_uncertainty)
         signals.parameter_pedigree_modified.connect(self.modify_parameter_pedigree)
+        signals.clear_activity_parameter.connect(self.clear_broken_activity_parameter)
         # Calculation Setups
         signals.new_calculation_setup.connect(self.new_calculation_setup)
         signals.rename_calculation_setup.connect(self.rename_calculation_setup)
@@ -267,7 +268,8 @@ def copy_database(self, name, parent):
             except ValueError as e:
                 QtWidgets.QMessageBox.information(parent, "Not possible", str(e))
 
-    def delete_database(self, name):
+    @Slot(str, name="deleteDatabase")
+    def delete_database(self, name: str) -> None:
         ok = QtWidgets.QMessageBox.question(
             None,
             "Delete database?",
@@ -277,6 +279,7 @@ def delete_database(self, name):
         if ok == QtWidgets.QMessageBox.Yes:
             project_settings.remove_db(name)
             del bw.databases[name]
+            Group.delete().where(Group.name == name).execute()
             self.change_project(bw.projects.current, reload=True)
 
     @Slot(str, QObject, name="relinkDatabase")
@@ -360,7 +363,8 @@ def new_activity(database_name: str) -> None:
             signals.database_changed.emit(database_name)
             signals.databases_changed.emit()
 
-    def delete_activity(self, key):
+    @Slot(tuple, name="deleteActivity")
+    def delete_activity(self, key: tuple) -> None:
         act = bw.get_activity(key)
         nu = len(act.upstream())
         if nu:
@@ -583,19 +587,27 @@ def modify_parameter(param: ParameterBase, field: str, value: object) -> None:
         else:
             param.data[field] = value
         param.save()
+        bw.parameters.recalculate()
         signals.parameters_changed.emit()
 
     @staticmethod
     def delete_activity_parameter(key: tuple) -> None:
         """Remove all activity parameters and underlying exchange parameters
         for the given key.
         """
-        query = ActivityParameter.select(ActivityParameter.group).where(
-            ActivityParameter.database == key[0],
-            ActivityParameter.code == key[1],
-        )
-        for p in query.iterator():
-            bw.parameters.remove_from_group(p.group, key)
+        query = (ActivityParameter
+                 .select(ActivityParameter.group)
+                 .where(ActivityParameter.database == key[0],
+                        ActivityParameter.code == key[1])
+                 .tuples())
+        groups = set(p[0] for p in query.iterator())
+        for group in groups:
+            bw.parameters.remove_from_group(group, key)
+            exists = (ActivityParameter.select()
+                      .where(ActivityParameter.group == group)
+                      .exists())
+            if not exists:
+                Group.delete().where(Group.name == group).execute()
         bw.parameters.recalculate()
         signals.parameters_changed.emit()
 
@@ -618,6 +630,28 @@ def modify_parameter_pedigree(param: ParameterBase, pedigree: dict) -> None:
         param.save()
         signals.parameters_changed.emit()
 
+    @staticmethod
+    @Slot(str, str, str, name="deleteRemnantParameters")
+    def clear_broken_activity_parameter(database: str, code: str, group: str) -> None:
+        """Take the given information and attempt to remove all of the
+        downstream parameter information.
+        """
+        with bw.parameters.db.atomic() as txn:
+            bw.parameters.remove_exchanges_from_group(group, None, False)
+            ActivityParameter.delete().where(
+                ActivityParameter.database == database,
+                ActivityParameter.code == code
+            ).execute()
+            # Do commit to ensure .exists() call does not include deleted params
+            txn.commit()
+            exists = (ActivityParameter.select()
+                      .where(ActivityParameter.group == group)
+                      .exists())
+            if not exists:
+                # Also clear Group if it is not in use anymore
+                Group.delete().where(Group.name == group).execute()
+
+# MetaDataStore
     @staticmethod
     @Slot(name="triggerMetadataReset")
     def reset_metadata() -> None:
@@ -633,6 +667,7 @@ def update_metadata(key: tuple) -> None:
     def print_convenience_information(db_name: str) -> None:
         AB_metadata.print_convenience_information(db_name)
 
+# Presamples
     @staticmethod
     @Slot(str, name="removePresamplesPackage")
     def remove_presamples_package(name_id: str) -> None:

activity_browser/app/signals.py

@@ -71,6 +71,7 @@ class Signals(QObject):
     parameter_pedigree_modified = Signal(object, object)
     parameter_scenario_sync = Signal(int, object)
     parameter_superstructure_built = Signal(int, object)
+    clear_activity_parameter = Signal(str, str, str)
 
     # Presamples
     presample_package_created = Signal(str)

activity_browser/app/ui/tables/delegates/formula.py

@@ -247,7 +247,4 @@ def setModelData(self, editor: QtWidgets.QWidget, model: QtCore.QAbstractItemMod
         if dialog.result() == QtWidgets.QDialog.Rejected:
             # Cancel was clicked, do not store anything.
             return
-        if model.data(index, QtCore.Qt.DisplayRole) == dialog.formula:
-            # The text in the dialog is the same as what is already there.
-            return
         model.setData(index, dialog.formula, QtCore.Qt.EditRole)

activity_browser/app/ui/tables/parameters.py

@@ -438,7 +438,10 @@ def parse_parameter(cls, parameter) -> dict:
             act = bw.get_activity(row["key"])
         except:
             # Can occur if an activity parameter exists for a removed activity.
-            print("Activity {} no longer exists, ignoring parameter.".format(row["key"]))
+            print("Activity {} no longer exists, removing parameter.".format(row["key"]))
+            signals.clear_activity_parameter.emit(
+                parameter.database, parameter.code, parameter.group
+            )
             return {}
         row["product"] = act.get("reference product") or act.get("name")
         row["activity"] = act.get("name")
@@ -581,10 +584,11 @@ def delete_parameter(self, proxy) -> None:
             group = self.get_current_group(proxy)
             bw.parameters.remove_from_group(group, act)
             # Also clear the group if there are no more parameters in it
-            if not (ActivityParameter.select()
-                    .where(ActivityParameter.group == group).exists()):
+            exists = (ActivityParameter.select()
+                      .where(ActivityParameter.group == group).exists())
+            if not exists:
                 with bw.parameters.db.atomic():
-                    Group.get(name=group).delete_instance()
+                    Group.delete().where(Group.name == group).execute()
 
         bw.parameters.recalculate()
         signals.parameters_changed.emit()
@@ -681,18 +685,3 @@ def parameterize_exchanges(self, key: tuple) -> None:
             bw.parameters.add_exchanges_to_group(group, act)
             ActivityParameter.recalculate_exchanges(group)
         signals.parameters_changed.emit()
-
-    @staticmethod
-    @Slot()
-    def recalculate_exchanges():
-        """ Will iterate through all activity parameters and rerun the
-        formula interpretation for all exchanges.
-        """
-        for param in ActivityParameter.select().iterator():
-            try:
-                act = bw.get_activity((param.database, param.code))
-                bw.parameters.add_exchanges_to_group(param.group, act)
-                ActivityParameter.recalculate_exchanges(param.group)
-            except:
-                continue
-        signals.parameters_changed.emit()