Controller refactor

.github/conda-envs/test.yml

@@ -5,3 +5,4 @@ dependencies:
   - pytest
   - pytest-qt
   - pytest-mock
+  - pytest-env

activity_browser/__init__.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 import sys
-import traceback
 
-from .logger import log
+from .logger import log, exception_hook, log_file_location
+from activity_browser.mod import bw2data
 from .application import application
 from .signals import signals
 from .settings import ab_settings, project_settings
@@ -12,17 +12,23 @@
 from .plugin import Plugin
 
 
+def load_settings() -> None:
+    if ab_settings.settings:
+        bw2data.projects.switch_dir(ab_settings.current_bw_dir)
+        bw2data.projects.set_current(ab_settings.startup_project)
+    log.info(f'Brightway2 data directory: {bw2data.projects.base_dir}')
+    log.info(f'Brightway2 current project: {bw2data.projects.current}')
+
+
 def run_activity_browser():
-    log.info(f'The Activity Browser log file can be found at {log.log_file_path()}')
     log.info(f'Activity Browser version: {version}')
+    if log_file_location:
+        log.info(f'The log file can be found at {log_file_location}')
 
     application.main_window = MainWindow(application)
-    project_controller.load_settings()
+    load_settings()
     application.show()
 
-    def exception_hook(*args):
-        log.warning(''.join(traceback.format_exception(*args)))
-
     sys.excepthook = exception_hook
 
     sys.exit(application.exec_())

activity_browser/actions/__init__.py

@@ -6,6 +6,7 @@
 from .activity.activity_duplicate_to_loc import ActivityDuplicateToLoc
 from .activity.activity_delete import ActivityDelete
 from .activity.activity_duplicate_to_db import ActivityDuplicateToDB
+from .activity.activity_modify import ActivityModify
 
 from .calculation_setup.cs_new import CSNew
 from .calculation_setup.cs_delete import CSDelete
@@ -39,10 +40,16 @@
 from .parameter.parameter_new import ParameterNew
 from .parameter.parameter_new_automatic import ParameterNewAutomatic
 from .parameter.parameter_rename import ParameterRename
+from .parameter.parameter_delete import ParameterDelete
+from .parameter.parameter_modify import ParameterModify
+from .parameter.parameter_uncertainty_remove import ParameterUncertaintyRemove
+from .parameter.parameter_uncertainty_modify import ParameterUncertaintyModify
+from .parameter.parameter_clear_broken import ParameterClearBroken
 
 from .project.project_new import ProjectNew
 from .project.project_duplicate import ProjectDuplicate
 from .project.project_delete import ProjectDelete
+from .project.project_switch import ProjectSwitch
 
 from .default_install import DefaultInstall
 from .biosphere_update import BiosphereUpdate

activity_browser/actions/activity/activity_delete.py

@@ -1,10 +1,12 @@
-from typing import Union, Callable, List
+from typing import List
 
-from PySide2 import QtWidgets, QtCore
+from PySide2 import QtWidgets
 
-from activity_browser import application, activity_controller
+from activity_browser import application
+from activity_browser.mod import bw2data as bd
+from activity_browser.mod.bw2data.parameters import ActivityParameter, Group, GroupDependency, parameters
 from activity_browser.ui.icons import qicons
-from activity_browser.actions.base import ABAction
+from activity_browser.actions.base import ABAction, exception_dialogs
 
 
 class ActivityDelete(ABAction):
@@ -14,15 +16,13 @@ class ActivityDelete(ABAction):
     will be removed
     """
     icon = qicons.delete
-    title = 'Delete ***'
-    activity_keys: List[tuple]
+    text = 'Delete ***'
 
-    def __init__(self, activity_keys: Union[List[tuple], Callable], parent: QtCore.QObject):
-        super().__init__(parent, activity_keys=activity_keys)
-
-    def onTrigger(self, toggled):
+    @staticmethod
+    @exception_dialogs
+    def run(activity_keys: List[tuple]):
         # retrieve activity objects from the controller using the provided keys
-        activities = activity_controller.get_activities(self.activity_keys)
+        activities = [bd.get_activity(key) for key in activity_keys]
 
         # check for downstream processes
         if any(len(act.upstream()) > 0 for act in activities):
@@ -42,4 +42,24 @@ def onTrigger(self, toggled):
             if choice == QtWidgets.QMessageBox.No: return
 
         # use the activity controller to delete multiple activities
-        activity_controller.delete_activities(self.activity_keys)
+        for act in activities:
+            db, code = act.key
+
+            try:
+                group_name = ActivityParameter.get(
+                    (ActivityParameter.database == db) & (ActivityParameter.code == code)).group
+
+                # remove activity parameters from its group
+                parameters.remove_from_group(group_name, act)
+
+                # Also clear the group if there are no more parameters in it
+                if not ActivityParameter.select().where(ActivityParameter.group == group_name).exists():
+                    Group.delete().where(Group.name == group_name).execute()
+                    GroupDependency.delete().where(GroupDependency.group == group_name).execute()
+            except ActivityParameter.DoesNotExist:
+                # no parameters found for this activity
+                pass
+
+            act.upstream().delete()
+
+            act.delete()

activity_browser/actions/activity/activity_duplicate.py

@@ -2,23 +2,24 @@
 
 from PySide2 import QtCore
 
-from activity_browser import activity_controller
+from activity_browser.mod.bw2data import get_activity
+from activity_browser.bwutils import commontasks
 from activity_browser.ui.icons import qicons
-from activity_browser.actions.base import ABAction
+from activity_browser.actions.base import ABAction, exception_dialogs
 
 
 class ActivityDuplicate(ABAction):
     """
     Duplicate one or multiple activities using their keys. Proxy action to call the controller.
     """
     icon = qicons.copy
-    title = 'Duplicate ***'
-    activity_keys: List[tuple]
-
-    def __init__(self, activity_keys: Union[List[tuple], Callable], parent: QtCore.QObject):
-        super().__init__(parent, activity_keys=activity_keys)
-
-    def onTrigger(self, toggled):
-        activity_controller.duplicate_activities(self.activity_keys)
+    text = 'Duplicate ***'
 
+    @staticmethod
+    @exception_dialogs
+    def run(activity_keys: List[tuple]):
+        activities = [get_activity(key) for key in activity_keys]
 
+        for activity in activities:
+            new_code = commontasks.generate_copy_code(activity.key)
+            activity.copy(new_code)

activity_browser/actions/activity/activity_duplicate_to_db.py

@@ -1,10 +1,14 @@
-from typing import Union, Callable, List
+from typing import List
 
-from PySide2 import QtWidgets, QtCore
+from PySide2 import QtWidgets
 
-from activity_browser import application, project_settings, activity_controller
+from activity_browser import application, project_settings
+from activity_browser.mod import bw2data as bd
 from activity_browser.ui.icons import qicons
-from activity_browser.actions.base import ABAction
+from activity_browser.actions.base import ABAction, exception_dialogs
+from activity_browser.bwutils import commontasks
+
+from .activity_open import ActivityOpen
 
 
 class ActivityDuplicateToDB(ABAction):
@@ -14,16 +18,32 @@ class ActivityDuplicateToDB(ABAction):
     duplicate the activities to the chosen database.
     """
     icon = qicons.duplicate_to_other_database
-    title = 'Duplicate to other database'
-    activity_keys: List[tuple]
-
-    def __init__(self, activity_keys: Union[List[tuple], Callable], parent: QtCore.QObject):
-        super().__init__(parent, activity_keys=activity_keys)
+    text = 'Duplicate to other database'
 
-    def onTrigger(self, toggled):
+    @classmethod
+    @exception_dialogs
+    def run(cls, activity_keys: List[tuple], to_db: str = None):
         # get bw activity objects from keys
-        activities = activity_controller.get_activities(self.activity_keys)
+        activities = [bd.get_activity(key) for key in activity_keys]
+
+        if to_db and not cls.confirm_db(to_db): return
+
+        target_db = to_db or cls.request_db(activities)
+
+        if not target_db: return
+
+        new_activity_keys = []
+
+        # otherwise move all supplied activities to the db using the controller
+        for activity in activities:
+            new_code = commontasks.generate_copy_code((target_db, activity["code"]))
+            new_activity = activity.copy(code=new_code, database=target_db)
+            new_activity_keys.append(new_activity.key)
 
+        ActivityOpen.run(new_activity_keys)
+
+    @staticmethod
+    def request_db(activities):
         # get valid databases (not the original database, or locked databases)
         origin_db = next(iter(activities)).get("database")
         target_dbs = [db for db in project_settings.get_editable_databases() if db != origin_db]
@@ -48,9 +68,15 @@ def onTrigger(self, toggled):
         )
 
         # return if the user didn't choose, or canceled
-        if not target_db or not ok: return
+        if not ok: return
 
-        # otherwise move all supplied activities to the db using the controller
-        for activity in activities:
-            activity_controller.duplicate_activity_to_db(target_db, activity)
+        return target_db
 
+    @staticmethod
+    def confirm_db(to_db: str):
+        user_choice = QtWidgets.QMessageBox.question(
+            application.main_window,
+            "Duplicate to new database",
+            f"Copy to {to_db} and open as new tab?",
+        )
+        return user_choice == user_choice.Yes