MDANSE-GUI 0.1.0a1__py3-none-any.whl

MDANSE_GUI/BackEnd.py

@@ -0,0 +1,108 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+import copy
+from icecream import ic
+from qtpy.QtCore import Slot, QObject, QMutex, Signal
+
+from MDANSE.Framework.Jobs.IJob import IJob
+from MDANSE.Framework.Converters.Converter import Converter
+from MDANSE.Framework.InstrumentResolutions.IInstrumentResolution import (
+    IInstrumentResolution,
+)
+from MDANSE.Framework.Configurators.IConfigurator import IConfigurator
+from MDANSE.Framework.Formats.IFormat import IFormat
+from MDANSE.Framework.Handlers.IHandler import IHandler
+from MDANSE.Framework.InputData.IInputData import IInputData
+from MDANSE.Framework.OutputVariables.IOutputVariable import IOutputVariable
+from MDANSE.Framework.Projectors.IProjector import IProjector
+from MDANSE.Framework.QVectors.IQVectors import IQVectors
+
+
+from MDANSE_GUI.DataViewModel.TrajectoryHolder import DataTreeModel
+from MDANSE_GUI.DataViewModel.JobHolder import JobHolder
+from MDANSE_GUI.DataViewModel.ActionsHolder import ActionsSuperModel
+
+
+class BackEnd(QObject):
+    """The main window of the MDANSE GUI,
+    inherits QMainWindow.
+
+    Args:
+        QMainWindow - the base class.
+    """
+
+    new_trajectory = Signal(str)
+    all_converters = Signal(object)
+    selected_converter = Signal(object)
+    selected_action = Signal(object)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.lock = QMutex()
+        self.data_holders = {}
+        self.createTrajectoryHolder()
+        self.createJobHolder()
+        self.createActionsHolder()
+
+    def createTrajectoryHolder(self):
+        self.trajectory_holder = DataTreeModel(parent=self)
+        self.data_holders["trajectory"] = self.trajectory_holder
+        self.new_trajectory.connect(self.trajectory_holder.acceptNewTrajectory)
+
+    def createActionsHolder(self):
+        self.actions_holder = ActionsSuperModel(parent=self)
+        self.actions_holder.buildModels(
+            [
+                IJob,
+                Converter,
+                IInstrumentResolution,
+                IConfigurator,
+                IFormat,
+                IHandler,
+                IInputData,
+                IOutputVariable,
+                IProjector,
+                IQVectors,
+            ]
+        )
+
+    def createJobHolder(self):
+        self.job_holder = JobHolder(parent=self)
+        self.data_holders["jobs"] = self.job_holder
+
+    @Slot(str)
+    def loadFile(self, fname: str):
+        ic(f"LoadFile triggered in BackEnd. File name is {fname}.")
+        if len(fname) < 2:
+            ic(f"Strangely short file name - not proceeding.")
+            return None
+        self.new_trajectory.emit(fname)
+
+    @Slot(str)
+    def returnActions(self, key: str):
+        """This slot will make Backend emit a signal that will
+        create a Dialog for a specific trajectory converter.
+        The type of the converter is chosen by the 'key' input
+        parameter.
+
+        Arguments:
+            key -- a string specifying which converter is needed.
+        """
+        ic("returnActions has been triggered in BackEnd")
+        thing = self._reverse_actions[str(key).split()[-1]]
+        self.selected_action.emit(thing)

MDANSE_GUI/DataViewModel/ActionsHolder.py

@@ -0,0 +1,135 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+import typing
+
+from icecream import ic
+from qtpy.QtGui import QStandardItemModel, QStandardItem
+from qtpy.QtCore import QObject, Slot, Qt, QMutex
+from qtpy.QtWidgets import QTreeView
+
+from MDANSE.Framework.Jobs.IJob import IJob
+
+from MDANSE_GUI.SubclassViewer import JobTree
+from MDANSE_GUI.DataViewModel.TrajectoryHolder import DataTreeItem
+
+
+class ActionsHolder(QStandardItemModel):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.mutex = QMutex()
+        self._node_numbers = []
+        self._nodes = {}
+        self._next_number = 1
+        # the nodes used for structuring the data tree
+        # will be kept here
+        self._sections = {}
+        self._section_names = []
+
+    @Slot(object)
+    def append_object(self, thing):
+        self.mutex.lock()
+        self._nodes[self._next_number] = thing
+        self._node_numbers.append(self._next_number)
+        retval = int(self._next_number)
+        self._next_number += 1
+        self.mutex.unlock()
+        return retval
+
+
+class ActionsSuperModel(QObject):
+    """This object will create and store all the possible
+    tree models of actions. These will be assigned to the
+    ActionsTree widget, depending on which data object
+    has been selected."""
+
+    def __init__(
+        self,
+        viewer: typing.Optional["QTreeView"] = None,
+        parent: typing.Optional["QObject"] = None,
+    ) -> None:
+        super().__init__(parent)
+
+        self.viewer = viewer
+        self.models = {}
+        self.currentItem = None
+        self.currentModel = None
+
+    def setViewer(self, viewer):
+        self.viewer = viewer
+
+    @Slot(DataTreeItem)
+    def switchModel(self, item: DataTreeItem):
+        """Changes the model behind the viewer to match
+        the item selected in the DataView.
+
+        Arguments:
+            ancestor -- name of the MDANSE object type
+                        selected in the DataView.
+        """
+        ic("received item:", item)
+        ancestor = item.ancestors()[-1]
+        try:
+            current_model = self.models[ancestor]
+        except KeyError:
+            current_model = JobTree()
+        self.viewer.setModel(current_model)
+        self.current_model = current_model
+        self.currentItem = item
+
+    def buildModels(self, parent_classes: list):
+        """Creates several subtrees out of the registry tree.
+        Each tree will only contain nodes that share the same
+        ancestor.
+
+        Arguments:
+            registry -- an existing RegistryTree instance
+            which has been used to scan the MDANSE registry
+        """
+        for parent_class in parent_classes:
+            model = JobTree()
+            model.populateTree(parent_class=parent_class)
+            self.models[parent_class.__name__] = model
+        ic("Build the following models:", self.models.keys())
+        self.current_model = self.models["IJob"]
+
+    def copyNodeIntoModel(self, thing: typing.Any, model: ActionsHolder):
+        node_parents = thing.category
+        rootnode = None
+        for name in node_parents:
+            if name not in model._section_names:
+                section_node = QStandardItem()
+                section_node.setText(name)
+                if rootnode is None:
+                    model.appendRow(section_node)
+                else:
+                    rootnode.appendRow(section_node)
+                model._section_names.append(name)
+                model._sections[name] = section_node
+                rootnode = section_node
+            else:
+                rootnode = model._sections[name]
+        node_text = thing.label
+        node_number = model.append_object(thing)
+        ic(node_number)
+        newitem = QStandardItem()
+        newitem.setText(node_text)
+        newitem.setData(node_number)
+        if rootnode is None:
+            model.appendRow(newitem)
+        else:
+            rootnode.appendRow(newitem)

MDANSE_GUI/DataViewModel/JobHolder.py

@@ -0,0 +1,175 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+from icecream import ic
+
+from qtpy.QtGui import QStandardItemModel, QStandardItem
+from qtpy.QtCore import QObject, Slot, Signal, QProcess, QThread, QMutex
+
+from MDANSE_GUI.DataViewModel.JobStatusQt import JobStatusQt
+
+
+class JobThread(QThread):
+    """A wrapper object for a single MDANSE analysis job.
+    It is created to run a single instance of the job,
+    and exits once the job has completed processing."""
+
+    job_failure = Signal(str)
+
+    def __init__(self, *args, command=None, parameters={}):
+        super().__init__(*args)
+        ic("JobThread starts init")
+        self._command = command
+        self._parameters = parameters
+        ic(f"JobThread.run will create a job instance of command {command}")
+        if isinstance(self._command, type):
+            self._job = self._command()
+        else:
+            self._job = self._command
+        self._job.build_configuration()
+        ic(f"JobThread._parameters: {self._parameters}")
+        # here we try to create and connect a JobStatusQt
+        status = JobStatusQt(parent=self)
+        self._job._status = status
+        self._status = status
+        ic("JobThread finished init")
+
+    def run(self):
+        try:
+            self._job.run(self._parameters)
+        except Exception as inst:
+            ic("JobThread has entered exception handling!")
+            error_message = ""
+            error_message += str(type(inst))
+            error_message += str(inst.args)  # arguments stored in .args
+            error_message += str(inst)  # __str__ allows args to be printed directly,
+            ic("JobThread is about to emit the failure message")
+            self.job_failure.emit(error_message)
+        else:
+            ic("JobThread.run did not raise an exception. JobThread.run will exit now")
+        self.exec()  # this starts event handling - will it help?
+
+
+class JobEntry(QObject):
+    """This coordinates all the objects that make up one line on the list
+    of current jobs. It is used for reporting the task progress to the GUI."""
+
+    def __init__(self, *args, command=None):
+        super().__init__(*args)
+        self._command = command
+        self._parameters = {}
+        self.has_started = False
+        self.has_finished = False
+        self.success = None
+        self.percent_complete = 0
+        self._output = None
+        self.reference = None
+        self.total_steps = 99
+        self._prog_item = QStandardItem()
+        self._stat_item = QStandardItem()
+
+    @property
+    def parameters(self):
+        return self._parameters
+
+    @parameters.setter
+    def set_parameters(self, input: dict):
+        self._parameters = input
+
+    def update_fields(self):
+        self._prog_item.setText(f"{self.percent_complete} percent complete")
+
+    @Slot(bool)
+    def on_finished(self, success: bool):
+        print("Item received on_finished!")
+        self.success = success
+        self.has_finished = True
+        self._stat_item.setText("Stopped")
+        if success:
+            self.percent_complete = 100
+            self._stat_item.setText("Completed!")
+        self.update_fields()
+
+    @Slot(int)
+    def on_started(self, target_steps: int):
+        print("Item received on_started!")
+        self.total_steps = target_steps
+        self.has_started = True
+        self._stat_item.setText("Starting")
+        self.update_fields()
+
+    @Slot(int)
+    def on_update(self, completed_steps: int):
+        print("Item received on_update!")
+        self.percent_complete = completed_steps / self.total_steps * 99
+        self._stat_item.setText("Running")
+        self.update_fields()
+
+    @Slot()
+    def on_oscillate(self):
+        """For jobs with unknown duration, the progress bar will bounce."""
+
+
+class JobHolder(QStandardItemModel):
+    """All the job INSTANCES that are started by the GUI
+    are added to this model."""
+
+    def __init__(self, parent: QObject = None):
+        super().__init__(parent=parent)
+        self.lock = QMutex()
+        self.existing_threads = []
+        self.existing_jobs = []
+
+    @Slot(str)
+    def reportError(self, err: str):
+        ic(err)
+
+    @Slot(object)
+    def addItem(self, new_entry: QProcess):
+        traj = JobEntry(new_entry.basename, trajectory=new_entry)
+        self.appendRow([traj])
+
+    @Slot(list)
+    def startThread(self, job_vars: list):
+        try:
+            th_ref = JobThread(command=job_vars[0], parameters=job_vars[1])
+        except:
+            ic(f"Failed to create JobThread using {job_vars}")
+            return
+        th_ref.job_failure.connect(self.reportError)
+        item_th = JobEntry(command=job_vars[0])
+        th_ref._status._communicator.target.connect(item_th.on_started)  # int
+        th_ref._status._communicator.progress.connect(item_th.on_update)  # int
+        th_ref._status._communicator.finished.connect(item_th.on_finished)  # bool
+        th_ref._status._communicator.oscillate.connect(item_th.on_oscillate)  # nothing
+        ic("Thread ready to start!")
+        try:
+            task_name = str(job_vars[0].__name__)
+        except AttributeError:
+            task_name = str(job_vars[0].__class__.__name__)
+        self.appendRow(
+            [
+                QStandardItem(task_name),
+                item_th._prog_item,
+                item_th._stat_item,
+            ]
+        )
+        # nrows = self.rowCount()
+        # index = self.indexFromItem(item_th._item)
+        # print(f"Index: {index}")
+        th_ref.start()
+        self.existing_threads.append(th_ref)
+        self.existing_jobs.append(item_th)

MDANSE_GUI/DataViewModel/JobStatusQt.py

@@ -0,0 +1,65 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+from icecream import ic
+from qtpy.QtCore import QObject, Slot, Signal, QProcess, QThread, QMutex
+
+from MDANSE.Framework.Status import Status
+
+
+class JobCommunicator(QObject):
+    target = Signal(int)
+    progress = Signal(int)
+    finished = Signal(bool)
+    oscillate = Signal()
+
+
+class JobStatusQt(Status):
+    def __init__(self, *args, **kwargs):
+        qparent = kwargs.pop("parent", None)
+        super().__init__()
+        self._state = {}  # for compatibility with JobStatus
+        self._progress_meter = 0
+        self._mutex = QMutex()
+        self._communicator = JobCommunicator(parent=qparent)
+
+    @property
+    def state(self):
+        return self._state
+
+    def finish_status(self):
+        ic()
+        self._communicator.finished.emit(True)
+
+    def start_status(self):
+        ic()
+        try:
+            temp = int(self._nSteps)
+        except:
+            self._communicator.oscillate.emit()
+        else:
+            self._communicator.target.emit(temp)
+
+    def stop_status(self):
+        ic()
+        self._communicator.finished.emit(False)
+
+    def update_status(self):
+        self._mutex.lock()
+        self._progress_meter += 1
+        temp = int(self._progress_meter)
+        self._mutex.unlock()
+        self._communicator.progress.emit(temp)

MDANSE_GUI/DataViewModel/TrajectoryHolder.py

@@ -0,0 +1,143 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+import hashlib
+import os
+
+from icecream import ic
+from qtpy.QtGui import QStandardItemModel, QStandardItem
+from qtpy.QtCore import QObject, Slot
+
+from MDANSE.Framework.InputData import InputFileData
+from MDANSE.Framework.InputData.HDFTrajectoryInputData import HDFTrajectoryInputData
+
+# class TrajectoryItem(QStandardItem):
+
+#     def __init__(self, *args, trajectory = None):
+#         super().__init__(*args)
+#         self._trajectory = trajectory
+
+
+# class TrajectoryHolder(QStandardItemModel):
+
+#     def __init__(self, parent: QObject = None):
+#         super().__init__(parent=parent)
+
+#     @Slot(object)
+#     def addItem(self, new_entry: InputFileData):
+#         traj = TrajectoryItem(new_entry.basename, trajectory = new_entry)
+#         self.appendRow([traj])
+
+#     @Slot(object)
+#     def acceptNewTrajectory(self, new_trajectory):
+
+
+class FileObject:
+    def __init__(self, hash_function=hashlib.sha256):
+        self.filename = ""
+        self.absolute_path = ""
+        self.extension = ".*"
+        self.relative_path = "."
+        self.hash_function = hash_function
+        self.hash = -1
+
+    def setFilename(self, fname: str):
+        abspath, filename = os.path.split(fname)
+        self.extension = str(filename).split(".")[-1]
+        self.filename = filename
+        self.absolute_path = abspath
+        self.hash = self.calculateHash(fname)
+
+    def calculateHash(self, fname, chunk_size=1024 * 512):
+        hash_object = self.hash_function()
+        with open(fname, "br") as source:
+            while chunk := source.read(chunk_size):
+                hash_object.update(chunk)
+        return hash_object.hexdigest()
+
+
+class DataTreeItem(QStandardItem):
+    def __init__(self, *args, **kwargs):
+        new_kwargs = {}
+        for key, val in kwargs.items():
+            if key not in ["mdanse_tag"]:
+                new_kwargs[key] = val
+        super().__init__(*args, **new_kwargs)
+
+        self.mdanse_tag = kwargs.get("mdanse_tag", "unknown")
+
+        self.original_input = []
+        self.processing_used = ""
+        self.processing_parameters = {}
+
+    def showHistory(self):
+        history = ";".join(self.ancestors())
+        return history
+
+    def ancestors(self):
+        parent = self.parent()
+        if parent is None:
+            return [self.mdanse_tag]
+        else:
+            return parent.ancestors() + [self.mdanse_tag]
+
+
+class TrajectoryItem(DataTreeItem):
+    def __init__(self, *args, **kwargs):
+        new_kwargs = {}
+        for key, val in kwargs.items():
+            if key not in ["fname", "trajectory"]:
+                new_kwargs[key] = val
+        super().__init__(*args, **new_kwargs)
+
+        self.filename = kwargs.get("fname", "NULL")
+        self.trajectory = kwargs.get("trajectory", None)
+        self.original_input = []
+        self.processing_used = ""
+        self.processing_parameters = {}
+        self.file_info = FileObject()
+
+        if self.filename != "NULL":
+            self.file_info.setFilename(self.filename)
+        self.setText(os.path.split(self.filename)[1])
+
+
+class AnalysisItem(DataTreeItem):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+class DataTreeModel(QStandardItemModel):
+    def __init__(self, parent: QObject = None):
+        super().__init__(parent=parent)
+        self._trajectory_objects = {}
+
+    @Slot(object)
+    def addItem(self, new_entry: InputFileData):
+        traj = TrajectoryItem(new_entry.basename, trajectory=new_entry)
+        self.appendRow([traj])
+
+    @Slot(str)
+    def acceptNewTrajectory(self, fname: str):
+        ic(f"Received {fname}")
+        data = HDFTrajectoryInputData(fname)
+        ic()
+        item = TrajectoryItem(fname=fname, trajectory=data, mdanse_tag="hdf_trajectory")
+        ic("Created TrajectoryItem")
+        self.appendRow(item)
+        tkey = item.file_info.hash
+        self._trajectory_objects[tkey] = data
+        ic("assigned new trajectory to the dictionary")

MDANSE_GUI/DataViewModel/__init__.py

@@ -0,0 +1,15 @@
+#    This file is part of MDANSE_GUI.
+#
+#    MDANSE_GUI is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#