Merge branch 'major-ic-contextmenu' into major

Author: mrvisscher

activity_browser/__main__.py

@@ -53,7 +53,7 @@ def loop(self):
 class ABLoader(QtWidgets.QWidget):
     def __init__(self):
         super().__init__()
-        self.setWindowFlags(Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint)
+        self.setWindowFlags(Qt.FramelessWindowHint)
         self.setWindowTitle("Activity Browser Launcher")
         self.setFixedSize(500, 300)
 

activity_browser/actions/__init__.py

@@ -55,6 +55,8 @@
 from .method.method_duplicate import MethodDuplicate
 from .method.method_delete import MethodDelete
 from .method.method_open import MethodOpen
+from .method.method_rename import MethodRename
+from .method.method_meta_modify import MethodMetaModify
 
 from .method.importer.method_importer_ecoinvent import MethodImporterEcoinvent
 from .method.importer.method_importer_bw2io import MethodImporterBW2IO

activity_browser/actions/method/method_duplicate.py

@@ -8,6 +8,8 @@
 from activity_browser.mod import bw2data as bd
 from activity_browser.ui.icons import qicons
 
+from .method_open import MethodOpen
+
 log = getLogger(__name__)
 
 
@@ -21,7 +23,7 @@ class MethodDuplicate(ABAction):
 
     @staticmethod
     @exception_dialogs
-    def run(methods: List[tuple], level: str):
+    def run(methods: List[tuple], level: str = None):
         # this action can handle only one selected method for now
         selected_method = methods[0]
 
@@ -57,6 +59,8 @@ def run(methods: List[tuple], level: str):
             method.copy(new_name)
             log.info(f"Copied method {method.name} into {new_name}")
 
+        MethodOpen.run(new_names)
+
 
 class TupleNameDialog(QtWidgets.QDialog):
     def __init__(self, parent=None):

activity_browser/actions/method/method_meta_modify.py

@@ -0,0 +1,29 @@
+from typing import List
+from logging import getLogger
+
+from qtpy import QtWidgets
+
+from activity_browser import application
+from activity_browser.actions.base import ABAction, exception_dialogs
+from activity_browser.mod import bw2data as bd
+from activity_browser.ui.icons import qicons
+
+log = getLogger(__name__)
+
+
+class MethodMetaModify(ABAction):
+    """
+    """
+
+    icon = qicons.delete
+    text = "Modify Impact Category metadata"
+
+    @staticmethod
+    @exception_dialogs
+    def run(method_name: tuple[str], key: str, value: str):
+        if method_name not in bd.methods:
+            log.warning(f"Can't modify metadata for method {method_name} - method not found")
+            return
+
+        bd.methods[method_name][key] = value
+        bd.methods.flush()

activity_browser/actions/method/method_rename.py

@@ -0,0 +1,83 @@
+from typing import List
+from logging import getLogger
+
+from qtpy import QtWidgets
+
+import bw2data as bd
+
+from activity_browser import signals
+from activity_browser.ui import widgets
+from activity_browser.actions.base import ABAction, exception_dialogs
+
+log = getLogger(__name__)
+
+
+class MethodRename(ABAction):
+    """
+    Renames an existing method in the Brightway2 data structure.
+
+    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.
+    - 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.
+
+    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.
+    """
+
+    text = "Rename Impact Category"
+
+    @staticmethod
+    @exception_dialogs
+    def run(method_name: tuple[str] | list[tuple[str]]):
+        # safeguard: only allow renaming one method at a time
+        if isinstance(method_name, list):
+            if len(method_name) != 1 or not isinstance(method_name[0], tuple):
+                raise ValueError("Can only rename one method at a time.")
+            method_name = method_name[0]
+
+        # check if method exists
+        if method_name not in bd.methods:
+            raise RuntimeError(f"Method {method_name} does not exist.")
+
+        method = bd.Method(method_name)
+
+        # open dialog to get new name
+        dialog = widgets.ABListEditDialog(method_name)
+        dialog.exec_()
+
+        # if dialog was cancelled, do nothing
+        if not dialog.result() == QtWidgets.QDialog.Accepted:
+            return
+
+        new_name = dialog.get_data(as_tuple=True)
+
+        # check new name validity
+        if len(new_name) == 0:
+            raise RuntimeError("Method name cannot be empty.")
+
+        if new_name in bd.methods:
+            raise RuntimeError(f"Method {new_name} already exists.")
+
+        # copy method to new name and process
+        method.copy(new_name).process()
+
+        # 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()

activity_browser/layouts/pages/impact_category_details/impact_category_details.py

@@ -8,6 +8,8 @@
 from activity_browser.ui import widgets, icons, delegates
 from activity_browser.bwutils import AB_metadata
 
+from .impact_category_header import ImpactCategoryHeader
+
 
 class ImpactCategoryDetailsPage(QtWidgets.QWidget):
     def __init__(self, name: tuple, parent=None):
@@ -17,54 +19,75 @@ def __init__(self, name: tuple, parent=None):
 
         self.setObjectName(" | ".join(name))
 
-        self.model = CharacterizationFactorsModel(self, self.build_df())
+        self.header = ImpactCategoryHeader(self)
+
+        self.model = CharacterizationFactorsModel(self)
         self.view = CharacterizationFactorsView(self)
         self.view.setModel(self.model)
 
+        self.build_layout()
+        self.connect_signals()
+        self.sync()
+
         # resizing name and categories columns
         self.view.resizeColumnToContents(0)
         self.view.resizeColumnToContents(1)
 
-        self.build_layout()
-        self.connect_signals()
-
     def connect_signals(self):
+        signals.method.renamed.connect(self.on_method_renamed)
         signals.method.deleted.connect(self.on_method_deleted)
         signals.meta.methods_changed.connect(self.sync)
 
+    def on_method_renamed(self, old_name, new_name):
+        if self.name == old_name:
+            self.name = new_name
+            self.setObjectName(" | ".join(new_name))
+            self.setWindowTitle(" | ".join(new_name))
+
     def on_method_deleted(self, method):
         if method.name == self.name:
             self.deleteLater()
 
     def sync(self):
+        if self.name not in bd.methods:
+            self.deleteLater()
+            return
+
         self.impact_category = bd.Method(self.name)
         self.model.setDataFrame(self.build_df())
+        self.header.sync()
 
     def build_layout(self):
         layout = QtWidgets.QVBoxLayout()
-        layout.addWidget(widgets.ABLabel.demiBold("Impact Category: " + " - ".join(self.name), self))
+        layout.addWidget(self.header)
         layout.addWidget(widgets.ABHLine(self))
         layout.addWidget(self.view)
         self.setLayout(layout)
 
     def build_df(self):
-        df = pd.DataFrame(self.impact_category.load(), columns=["id", "amount"])
+        df = pd.DataFrame(self.impact_category.load(), columns=["id", "data"])
+        df["amount"] = df["data"].apply(lambda x: x if isinstance(x, (float, int)) else x.get("amount"))
+        df["uncertainty"] = df["data"].apply(lambda x: 0 if isinstance(x, (float, int)) else x.get("uncertainty type"))
+
         other = AB_metadata.dataframe[["id", "name", "categories", "database", "unit"]]
 
-        df = df.merge(other, left_on="id", right_on="id").rename(columns={"id": "_id"})
+        df = df.merge(other, left_on="id", right_on="id").rename(columns={"id": "_id", "data": "_cf"})
         df["_impact_category_name"] = [self.name for i in range(len(df))]
 
-        cols = ["name", "categories", "database", "amount", "unit", "_id", "_impact_category_name"]
+        cols = ["name", "categories", "database", "amount", "unit", "uncertainty", "_id", "_impact_category_name", "_cf"]
         return df[cols]
 
 
 class CharacterizationFactorsView(widgets.ABTreeView):
     defaultColumnDelegates = {
         "amount": delegates.FloatDelegate,
         "categories": delegates.ListDelegate,
+        "uncertainty": delegates.UncertaintyDelegate,
     }
 
 
+
+
 class ExchangesItem(widgets.ABDataItem):
     def flags(self, col: int, key: str):
         """
@@ -78,7 +101,7 @@ def flags(self, col: int, key: str):
             QtCore.Qt.ItemFlags: The item flags.
         """
         flags = super().flags(col, key)
-        if key in ["amount"]:
+        if key in ["amount", "uncertainty"]:
             return flags | Qt.ItemFlag.ItemIsEditable
         return flags
 

activity_browser/layouts/pages/impact_category_details/impact_category_header.py

@@ -23,6 +23,8 @@ def sync(self):
         """
         Synchronizes the widget with the current state of the activity.
         """
+        self.impact_category = self.parent().impact_category
+
         self.clear_layout()
         self.layout().addLayout(self.build_grid())
 
@@ -46,9 +48,12 @@ def build_grid(self) -> QtWidgets.QGridLayout:
         grid.setSpacing(10)
         grid.setAlignment(QtCore.Qt.AlignmentFlag.AlignTop)
 
+        name_label = QtWidgets.QLabel(f"<a href='/'>{' | '.join(self.impact_category.name)}</a>",  self)
+        name_label.linkActivated.connect(lambda: actions.MethodRename.run(self.impact_category.name))
+
         setup = [
-            ("Name:", QtWidgets.QLabel(str(self.impact_category.name)),),
-            ("Unit:", QtWidgets.QLabel(str(self.impact_category.metadata.get("unit", "Undefined"))),),
+            ("Name:", name_label),
+            ("Unit:", ImpactCategoryUnit(self)),
         ]
 
         # Arrange widgets for display as a grid
@@ -59,25 +64,16 @@ def build_grid(self) -> QtWidgets.QGridLayout:
         return grid
 
 
-class ImpactCategoryName(QtWidgets.QLineEdit):
-    """
-    A widget that displays and edits the name of the activity.
-    """
+class ImpactCategoryUnit(QtWidgets.QLineEdit):
 
     def __init__(self, parent: ImpactCategoryHeader):
-        """
-        Initializes the ActivityName widget.
+        name = parent.impact_category.metadata.get("unit", "Undefined")
 
-        Args:
-            parent (ActivityHeader): The parent widget.
-        """
-        super().__init__(str(parent.impact_category.name), parent)
-        self.editingFinished.connect(self.change_name)
+        super().__init__(name, parent)
 
-    def change_name(self):
-        """
-        Changes the name of the activity if it has been modified.
-        """
-        if self.text() == self.parent().impact_category.name:
+        self.editingFinished.connect(self.change_unit)
+
+    def change_unit(self):
+        if self.text() == self.parent().impact_category.metadata.get("unit", "Undefined"):
             return
-        # actions.ActivityModify.run(self.parent().activity, "name", self.text())
+        actions.MethodMetaModify.run(self.parent().impact_category.name, "unit", self.text())

activity_browser/layouts/panes/impact_categories.py

@@ -52,15 +52,14 @@ def load(self):
         self.view.setColumnHidden(1, True)
         self.view.setColumnHidden(2, True)
         self.view.setColumnHidden(3, True)
+        self.view.sortByColumn(1, Qt.SortOrder.AscendingOrder)
 
     def sync(self):
         self.model.setDataFrame(self.build_df())
 
     def build_df(self):
-        df = pd.DataFrame.from_dict(bd.methods, orient="index")
-        df.index = df.index.to_flat_index()
-        df.index.name = "_method_name"
-        df = df.reset_index()
+        df = pd.DataFrame(bd.methods.values())
+        df["_method_name"] = bd.methods.keys()
 
         df["name"] = df["_method_name"].apply(lambda x: x[-1])
         df["groups"] = df["_method_name"].apply(lambda x: x[:-1])
@@ -78,6 +77,38 @@ class ImpactCategoriesView(widgets.ABTreeView):
         "groups": delegates.ListDelegate,
     }
 
+    class ContextMenu(widgets.ABMenu):
+        menuSetup = [
+            lambda m, p: m.add(actions.MethodOpen, p.selected_impact_categories,
+                               text="Open impact category" if len(p.selected_impact_categories) == 1 else "Open impact categories",
+                               enable=len(p.selected_impact_categories) > 0
+                               ),
+            lambda m, p: m.add(actions.MethodDelete, p.selected_impact_categories,
+                               text="Delete impact category" if len(
+                                   p.selected_impact_categories) == 1 else "Delete impact categories",
+                               enable=len(p.selected_impact_categories) > 0
+                               ),
+            lambda m, p: m.add(actions.MethodDuplicate, p.selected_impact_categories,
+                               text="Duplicate impact category",
+                               enable=len(p.selected_impact_categories) == 1
+                               ),
+            lambda m, p: m.add(actions.MethodRename, p.selected_impact_categories,
+                               text="Rename impact category",
+                               enable=len(p.selected_impact_categories) == 1
+                               ),
+        ]
+
+        @staticmethod
+        def get_functional_unit_amount(key):
+            from activity_browser.bwutils import refresh_node
+            excs = list(refresh_node(key).upstream(["production"]))
+            exc = excs[0] if len(excs) == 1 else {}
+            return exc.get("amount", 1.0)
+
+        @property
+        def database_name(self):
+            return self.parent().parent().database.name
+
     @property
     def selected_impact_categories(self):
         indices = [i for i in self.selectedIndexes() if i.column() == 0]

activity_browser/signals.py

@@ -23,6 +23,7 @@ class EdgeSignals(QObject):
 class MethodSignals(QObject):
     changed: SignalInstance = Signal(object)
     deleted: SignalInstance = Signal(object)
+    renamed: SignalInstance = Signal(tuple, tuple)
 
 
 class ParameterSignals(QObject):

activity_browser/ui/delegates/uncertainty.py

@@ -36,6 +36,11 @@ def createEditor(self, parent, option, index):
         elif hasattr(index.internalPointer(), "exchange"):
             item = index.internalPointer()
             actions.ExchangeUncertaintyModify.run([item.exchange])
+        elif index.internalPointer()["_impact_category_name"] is not None:
+            item = index.internalPointer()
+            actions.CFUncertaintyModify.run(
+                item["_impact_category_name"], [(item["_id"], item["_cf"]),]
+            )
 
     def setEditorData(self, editor: QtWidgets.QComboBox, index: QtCore.QModelIndex):
         """Simply use the wizard for updating uncertainties."""