aiidalab-chemshell 0.0.1__py3-none-any.whl

aiidalab_chemshell/__init__.py

@@ -0,0 +1,5 @@
+"""The main AiiDAlab ChemShell python package."""
+
+from importlib.metadata import version
+
+__version__ = version("aiidalab-chemshell")

aiidalab_chemshell/common/__init__.py

@@ -0,0 +1 @@
+"""Package for general common components."""

aiidalab_chemshell/common/chemshell.py

@@ -0,0 +1,53 @@
+"""Module containing common settings for configuring ChemShell."""
+
+from enum import Enum, auto
+
+
+class BasisSetOptions(Enum):
+    """Pre-defined basis set levels for simplified ChemShell inputs."""
+
+    FAST = 0
+    BALANCED = auto()
+    QUALITY = auto()
+
+    @property
+    def label(self) -> str:
+        """Convert enum value to a string representation for ChemShell input."""
+        match self:
+            case BasisSetOptions.FAST:
+                return "3-21G"
+            case BasisSetOptions.BALANCED:
+                return "cc-pvdz"
+            case BasisSetOptions.QUALITY:
+                return "aug-cc-pvtz"
+            case "":
+                return ""
+
+
+class WorkflowOptions(Enum):
+    """Enum defining the available ChemShell based AiiDA workflows."""
+
+    GEOMETRY = 0
+    NEB = auto()
+
+    @property
+    def label(self) -> str:
+        """Convert enum value into a more human readable string."""
+        match self:
+            case WorkflowOptions.GEOMETRY:
+                return "Geometry Optimisation"
+            case WorkflowOptions.NEB:
+                return "Nudged Elastic Band"
+            case _:
+                return ""
+
+    @property
+    def tab_label(self) -> str:
+        """Create a tab title for the given enum option."""
+        match self:
+            case WorkflowOptions.GEOMETRY:
+                return "Optimisation"
+            case WorkflowOptions.NEB:
+                return "NEB"
+            case _:
+                return "ChemShell"

aiidalab_chemshell/common/database.py

@@ -0,0 +1,170 @@
+"""Module for components relating to AiiDA database management."""
+
+import datetime
+
+import ipywidgets as ipw
+import traitlets as tl
+from aiida.orm import (
+    CalcFunctionNode,
+    CalcJobNode,
+    Node,
+    QueryBuilder,
+    WorkChainNode,
+)
+
+
+class AiiDADatabaseWidget(ipw.VBox, tl.HasTraits):
+    """Widget for AiiDA database querying."""
+
+    data_object = tl.Instance(Node, allow_none=True)
+
+    def __init__(self, title: str = "", query: list | None = None):
+        if query is None:
+            query = []
+        self.title = title
+        self.query_type = tuple(query)
+
+        qbuilder = QueryBuilder().append((CalcJobNode, WorkChainNode), project="label")
+
+        self.drop_down = ipw.Dropdown(
+            options=sorted({"All"}.union({i[0] for i in qbuilder.iterall() if i[0]})),
+            value="All",
+            description="Process Label",
+            disabled=True,
+            style={"description_width": "120px"},
+            layout={"width": "50%"},
+        )
+        self.drop_down.observe(self.search, names="value")
+
+        # Disable process labels selection if we are not looking for the calculated
+        # structures.
+        def disable_drop_down(change):
+            self.drop_down.disabled = not change["new"] == "calculated"
+
+        # Select structures kind.
+        self.mode = ipw.RadioButtons(
+            options=["all", "uploaded", "calculated"], layout={"width": "25%"}
+        )
+        self.mode.observe(self.search, names="value")
+        self.mode.observe(disable_drop_down, names="value")
+
+        # Date range.
+        # Note: there is Date picker widget, but it currently does not work in Safari:
+        # https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20List.html#Date-picker
+        date_text = ipw.HTML(value="<p>Select the date range:</p>")
+        self.start_date_widget = ipw.Text(
+            value="", description="From: ", style={"description_width": "120px"}
+        )
+        self.end_date_widget = ipw.Text(value="", description="To: ")
+
+        # Search button.
+        btn_search = ipw.Button(
+            description="Search",
+            button_style="info",
+            layout={"width": "initial", "margin": "2px 0 0 2em"},
+        )
+        btn_search.on_click(self.search)
+
+        age_selection = ipw.VBox(
+            [
+                date_text,
+                ipw.HBox([self.start_date_widget, self.end_date_widget, btn_search]),
+            ],
+            layout={"border": "1px solid #fafafa", "padding": "1em"},
+        )
+
+        h_line = ipw.HTML("<hr>")
+        box = ipw.VBox([age_selection, h_line, ipw.HBox([self.mode, self.drop_down])])
+
+        self.results = ipw.Dropdown(layout={"width": "900px"})
+        self.results.observe(self._on_select_structure, names="value")
+        self.search()
+        super().__init__([box, h_line, self.results])
+
+    def search(self, _=None) -> None:
+        """Search structures in the AiiDA database."""
+        qbuild = QueryBuilder()
+
+        # If the date range is valid, use it for the search
+        try:
+            start_date = datetime.datetime.strptime(
+                self.start_date_widget.value, "%Y-%m-%d"
+            )
+            end_date = datetime.datetime.strptime(
+                self.end_date_widget.value, "%Y-%m-%d"
+            ) + datetime.timedelta(hours=24)
+
+        # Otherwise revert to the standard (i.e. last 7 days)
+        except ValueError:
+            start_date = datetime.datetime.now() - datetime.timedelta(days=7)
+            end_date = datetime.datetime.now() + datetime.timedelta(hours=24)
+
+            self.start_date_widget.value = start_date.strftime("%Y-%m-%d")
+            self.end_date_widget.value = end_date.strftime("%Y-%m-%d")
+
+        filters = {}
+        filters["ctime"] = {"and": [{">": start_date}, {"<=": end_date}]}
+
+        if self.mode.value == "uploaded":
+            qbuild2 = (
+                QueryBuilder()
+                .append(self.query_type, project=["id"], tag="structures")
+                .append(Node, with_outgoing="structures")
+            )
+            processed_nodes = [n[0] for n in qbuild2.all()]
+            if processed_nodes:
+                filters["id"] = {"!in": processed_nodes}
+            qbuild.append(self.query_type, filters=filters)
+
+        elif self.mode.value == "calculated":
+            if self.drop_down.value == "All":
+                qbuild.append((CalcJobNode, WorkChainNode), tag="calcjobworkchain")
+            else:
+                qbuild.append(
+                    (CalcJobNode, WorkChainNode),
+                    filters={"label": self.drop_down.value},
+                    tag="calcjobworkchain",
+                )
+            qbuild.append(
+                self.query_type,
+                with_incoming="calcjobworkchain",
+                filters=filters,
+            )
+
+        elif self.mode.value == "edited":
+            qbuild.append(CalcFunctionNode)
+            qbuild.append(
+                self.query_type,
+                with_incoming=CalcFunctionNode,
+                filters=filters,
+            )
+
+        elif self.mode.value == "all":
+            qbuild.append(self.query_type, filters=filters)
+
+        qbuild.order_by({self.query_type: {"ctime": "desc"}})
+        matches = {n[0] for n in qbuild.iterall()}
+        matches = sorted(matches, reverse=True, key=lambda n: n.ctime)
+
+        options = [(f"Select a Node ({len(matches)} found)", False)]
+        for mch in matches:
+            label = f"PK: {mch.pk}"
+            label += " | " + mch.ctime.strftime("%Y-%m-%d %H:%M")
+            label += " | " + mch.base.extras.get("formula", "")
+            label += " | " + mch.node_type.split(".")[-2]
+            label += " | " + mch.label
+            label += " | " + mch.description
+            options.append((label, mch))
+
+        self.results.options = options
+        return
+
+    def _on_select_structure(self, _) -> None:
+        self.data_object = self.results.value or None
+        return
+
+    def disable(self, val: bool) -> None:
+        """Disable the widget."""
+        self.results.disabled = True
+        # self.
+        return

aiidalab_chemshell/common/file_handling.py

@@ -0,0 +1,89 @@
+"""Module for providing functionality to deal with files."""
+
+from io import BytesIO
+
+import traitlets as tl
+from aiida.orm import SinglefileData
+from ipywidgets import FileUpload, HBox, Text
+
+
+class FileUploadWidget(HBox, tl.HasTraits):
+    """A widget for uploading files."""
+
+    file = tl.Instance(SinglefileData, allow_none=True)
+
+    def __init__(self, description: str = "File: ", **kwargs):
+        """
+        FileUploadWidget constructor.
+
+        Parameters
+        ----------
+        **kwargs :
+            Keyword arguments passed to the parent class's constructor.
+        """
+        super().__init__(**kwargs)
+        self.file_dict = None
+
+        self.file_upload = FileUpload(
+            accept="",
+            multiple=False,
+            description="Upload",
+            layout={"width": "20%"},
+        )
+        self.file_handle = Text(
+            value="",
+            placeholder="",
+            description=description,
+            disabled=True,
+            layout={"width": "70%"},
+        )
+        self.children = [self.file_handle, self.file_upload]
+
+        self.file_upload.observe(self._on_file_upload, names="value")
+
+        return
+
+    @property
+    def has_file(self) -> bool:
+        """True if a file has been uploaded."""
+        return self.file is not None
+
+    def _on_file_upload(self, _):
+        """Handle file upload events."""
+        if self.file_upload.value:
+            self.file_dict = self.file_upload.value[
+                list(self.file_upload.value.keys())[0]
+            ]
+            self.file_handle.value = self.file_dict["metadata"]["name"]
+            self.file = self.get_aiida_file_object()
+        else:
+            self.file_handle.value = ""
+        return
+
+    def get_file_contents(self) -> BytesIO | None:
+        """Get the contents of the uploaded file as a BytesIO object."""
+        if self.file_dict is not None:
+            return BytesIO(self.file_dict["content"])
+        return None
+
+    def filename(self) -> str:
+        """Get the name of the uploaded file."""
+        if self.file_dict is not None:
+            return self.file_dict["metadata"]["name"]
+        return ""
+
+    def get_aiida_file_object(self):
+        """Get the uploaded file as an AiiDA SinglefileData object."""
+        if self.file_dict is not None:
+            return SinglefileData(
+                file=self.get_file_contents(),
+                filename=self.filename(),
+                label=self.filename(),
+                description=self.file_handle.description,
+            )
+        return None
+
+    def disable(self, val: bool) -> None:
+        """Disable the file upload widget."""
+        self.file_upload.disabled = val
+        return

aiidalab_chemshell/common/navigation.py

@@ -0,0 +1,81 @@
+"""Module handling navigation controls within the app."""
+
+from functools import partial
+
+import ipywidgets as ipw
+
+from aiidalab_chemshell.utils import open_link_in_new_tab
+
+_APPS_DIRECTORY = "/apps/apps/"
+
+
+class QuickAccessButtons(ipw.HBox):
+    """Quick access buttons present in the apps header and start banner."""
+
+    def __init__(self, **kwargs):
+        """
+        QuickAccessButtons constructor.
+
+        Parameters
+        ----------
+        **kwargs :
+            Keyword arguments passed to the `ipywidgets.HBox.__init__()`.
+        """
+        self.new_calc_link = ipw.Button(
+            description="New Calculation",
+            disabled=False,
+            button_style="success",
+            tooltip="Start a new calculation",
+            icon="plus",
+        )
+        self.new_calc_link.on_click(
+            partial(
+                open_link_in_new_tab,
+                _APPS_DIRECTORY + "aiidalab-chemshell/notebooks/main.ipynb",
+            )
+        )
+
+        self.history_link = ipw.Button(
+            description="History",
+            disabled=False,
+            button_style="primary",
+            tooltip="View Calculation History",
+            icon="history",
+        )
+        self.history_link.on_click(
+            partial(
+                open_link_in_new_tab,
+                _APPS_DIRECTORY + "aiidalab-chemshell/notebooks/history.ipynb",
+            )
+        )
+
+        self.resource_setup_link = ipw.Button(
+            description="Setup Resources",
+            disabled=False,
+            button_style="primary",
+            tooltip="Configure Computational Resources",
+            icon="cogs",
+        )
+        self.resource_setup_link.on_click(
+            partial(open_link_in_new_tab, _APPS_DIRECTORY + "home/code_setup.ipynb")
+        )
+
+        self.docs_link = ipw.Button(
+            description="Documentation",
+            disabled=False,
+            button_style="info",
+            tooltip="Open Documentation",
+            icon="book",
+        )
+        self.docs_link.on_click(
+            partial(open_link_in_new_tab, "https://github.com/stfc/aiidalab-chemshell")
+        )
+
+        children = [
+            self.new_calc_link,
+            self.history_link,
+            self.resource_setup_link,
+            self.docs_link,
+        ]
+        super().__init__(children=children, layout={"margin": "auto"}, **kwargs)
+        return

aiidalab_chemshell/common/node_viewers.py

@@ -0,0 +1,166 @@
+"""Defines a custom AiiDA node visualiser."""
+
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+import ase
+from aiida.orm import ArrayData, Node, ProcessNode, SinglefileData, StructureData
+from aiidalab_widgets_base.loaders import LoadingWidget
+from aiidalab_widgets_base.viewers import AIIDA_VIEWER_MAPPING
+from IPython.display import clear_output, display
+from ipywidgets import HTML, DOMWidget, Dropdown, Output, VBox
+from traitlets import Instance, observe
+
+
+class CustomAiidaNodeViewWidget(VBox):
+    """
+    Custom viewer based on a specific AiiDA node type.
+
+    An extension of the aiida_widgets_base.viewers.AiidaNodeViewWidget
+    enabling more customisability when registering viewers with nodes
+    returned from ChemShell jobs. The main outline is taken from the base
+    aiidalab_widgets_base viewer with an extended viewer() method which
+    allows handling of node types which the base viewer has no registered
+    visualisation widgets.
+    """
+
+    node = Instance(Node, allow_none=True)
+
+    def __init__(self, **kwargs):
+        """CustomAiidaNodeViewWidget Constructor."""
+        self._output = Output()
+        self.node_views = {}
+        self.node_view_loading_message = LoadingWidget("Loading Node View")
+        super().__init__(**kwargs)
+        self.add_class("aiida-node-view-widget")
+
+    @observe("node")
+    def _observe_node(self, change):
+        if not ((node := change["new"]) and node != change["old"]):
+            return
+        if node.uuid in self.node_views:
+            self.children = [self.node_views[node.uuid]]
+            return
+        self.children = [self.node_view_loading_message]
+        node_view = self._viewer(node)
+        if isinstance(node_view, DOMWidget):
+            self.node_views[node.uuid] = node_view
+            self.children = [node_view]
+        else:
+            with self._output:
+                clear_output()
+                if change["new"]:
+                    display(node_view)
+            self.children = [self._output]
+
+    def _viewer(self, node: Node, **kwargs):
+        """Create a viewer based on the type of Node being visualised."""
+        _viewer = AIIDA_VIEWER_MAPPING.get(node.node_type)
+        if isinstance(node, ProcessNode):
+            # Allow to register specific viewers based on node.process_type
+            _viewer = AIIDA_VIEWER_MAPPING.get(node.process_type, _viewer)
+
+        if _viewer:
+            return _viewer(node, **kwargs)
+
+        # Handle custom ChemShell specific visualisation
+        if isinstance(node, SinglefileData):
+            # Singlefile data output generally refers to a structure file
+            # output from ChemShell jobs
+            structure = self._get_structure_data_object_from_file(
+                node.filename, node.content
+            )
+            if structure:
+                _viewer = AIIDA_VIEWER_MAPPING.get(structure.node_type)
+                if _viewer:
+                    return _viewer(structure, **kwargs)
+
+        if isinstance(node, ArrayData):
+            return AiidaArrayDataViewWidget(node, **kwargs)
+        # No viewer registered for this type, return node itself
+        return node
+
+    def _get_structure_data_object_from_file(
+        self, fname: str, content: bytes
+    ) -> StructureData | None:
+        """
+        Create an ase strucure object from a structure file.
+
+        Parameters
+        ----------
+        fname   : str
+            The file name the structure is being read from.
+        content : bytes
+            The content of the structure file byte encoded.
+
+        Return
+        ------
+        structure : ase.Atoms | None
+            The ASE atomic structure object or None if the file could not be read.
+        """
+        suffix = "".join(Path(fname).suffixes)
+        with NamedTemporaryFile(suffix=suffix) as tmpf:
+            tmpf.write(content)
+            tmpf.flush()
+            try:
+                structure = ase.io.read(tmpf.name, index=":")[0]
+            except (KeyError, ase.io.formats.UnknownFileTypeError):
+                node = None
+            else:
+                # ASE doesn't correctly interpret atomic units so convert all units to
+                # angstrom
+                for i in range(len(structure)):
+                    structure.positions[i] = structure.positions[i] * 0.529177
+                node = StructureData()
+                node.set_ase(structure)
+        return node
+
+
+class AiidaArrayDataViewWidget(VBox):
+    """Custom widget to display array data produced from ChemShell jobs."""
+
+    def __init__(self, array: ArrayData, **kwargs):
+        """AiidaArrayDataViewWidget Constructor.
+
+        Parameters
+        ----------
+        array : ArrayData
+            The AiiDA ArrayData object to display.
+        """
+        super().__init__(**kwargs)
+        self.array = array
+        self.array_names = array.get_arraynames()
+
+        self.array_selector = Dropdown(
+            options=self.array_names,
+            description="Array Label:",
+            disabled=False,
+            layout={"width": "30%"},
+        )
+        self._render_array({"new": self.array_selector.index, "old": -1})
+        self.array_selector.observe(self._render_array, "index")
+
+        return
+
+    def _render_array(self, change) -> None:
+        """Create a HTML table based on the currently selected array."""
+        index = change["new"]
+        if index == change["old"]:
+            return
+        values = self.array.get_array(self.array_names[index])
+        # Construct HTML Table
+        html = "<table style='width:100%; border: 1px solid #ddd; text-align: left; "
+        html += "border-collapse: collapse;'>"
+        html += "<tr style='background-color: #2196F3; color: white;'>"
+        html += "<th>Atom Index</th><th>X</th><th>Y</th><th>Z</th></tr>"
+
+        for idx, row in enumerate(values):
+            bg_color = "#f9f9f9" if idx % 2 == 0 else "#ffffff"
+            html += f"<tr style='background-color: {bg_color};'>"
+            html += f"<td><b>{idx}</b></td><td>{row[0]:.6f}</td><td>{row[1]:.6f}</td>"
+            html += f"<td>{row[2]:.6f}</td>"
+            html += "</tr>"
+        html += "</table>"
+
+        self.children = [self.array_selector, HTML(html)]
+        return

aiidalab_chemshell/history.py

@@ -0,0 +1,124 @@
+"""Defines the process history applicaion page."""
+
+from datetime import datetime
+
+from aiida.orm import CalcJobNode, WorkChainNode
+from aiidalab_widgets_base import ProcessNodesTreeWidget
+from IPython.display import display
+from ipywidgets import HTML, VBox, dlink
+
+from aiidalab_chemshell.common.database import AiiDADatabaseWidget
+from aiidalab_chemshell.common.navigation import QuickAccessButtons
+from aiidalab_chemshell.common.node_viewers import CustomAiidaNodeViewWidget
+from aiidalab_chemshell.models.process import ProcessModel
+
+
+class HistoryApp:
+    """The process history page's main app."""
+
+    def __init__(self):
+        """HistoryApp constructor."""
+        self.model = HistoryModel()
+        self.view = HistoryAppView(self.model)
+        display(self.view)
+
+
+class HistoryModel(ProcessModel):
+    """MVC Model for process history app data management."""
+
+    pass
+
+
+class HistoryAppView(VBox):
+    """Main view for the process history page."""
+
+    def __init__(self, model: HistoryModel, **kwargs):
+        """
+        HistoryAppView Constructor.
+
+        Parameters
+        ----------
+        model : HistoryModel
+            The MVC model component to associate with this view app.
+        """
+        self.model = model
+        logo = HTML(
+            """
+            <div class="app-container logo" style="width: 300px;">
+                <img src="../images/alc.svg" alt="ALC AiiDAlab App Logo" />
+            </div>
+            """,
+            layout={"margin": "auto"},
+        )
+
+        subtitle = HTML(
+            """
+            <h2 id='subtitle'>AiiDAlab ChemShell</h2>
+            """
+        )
+
+        nav_btns = QuickAccessButtons()
+
+        header = VBox(
+            children=[
+                logo,
+                subtitle,
+            ],
+            layout={"margin": "auto"},
+        )
+
+        footer = HTML(
+            f"""
+            <footer>
+                Copyright (c) {datetime.now().year} Ada Lovelace Centre
+                (STFC) <br>
+            </footer>
+            """,
+            layout={"align-content": "right"},
+        )
+        h_line = HTML("<hr>")
+
+        self.guide = HTML(
+            """
+            <h3>ChemShell Process History</h3>
+            <p>
+            Search through past ChemShell processes and visualise inputs, outputs and
+            provenance relationships.
+            </p>
+            """
+        )
+        self.lookup_widget = AiiDADatabaseWidget(
+            "Process Lookup", [CalcJobNode, WorkChainNode]
+        )
+        self.lookup_widget.observe(self._update_node_view, "data_object")
+
+        self.node_tree = ProcessNodesTreeWidget()
+        dlink((self.model, "process_uuid"), (self.node_tree, "value"))
+        self.node_view = CustomAiidaNodeViewWidget()
+        dlink(
+            (self.node_tree, "selected_nodes"),
+            (self.node_view, "node"),
+            transform=lambda nodes: nodes[0] if nodes else None,
+        )
+
+        super().__init__(
+            layout={},
+            children=[
+                header,
+                nav_btns,
+                self.guide,
+                self.lookup_widget,
+                h_line,
+                self.node_tree,
+                self.node_view,
+                footer,
+            ],
+            **kwargs,
+        )
+        return
+
+    def _update_node_view(self, _) -> None:
+        """Update the node view to the currently selected process node."""
+        if self.lookup_widget.data_object is not None:
+            self.model.process_uuid = self.lookup_widget.data_object.uuid
+        return