alc-aiidalab-widgets 0.0.1__tar.gz

alc_aiidalab_widgets-0.0.1/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, UKRI Science and Technology Facilities Council
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

alc_aiidalab_widgets-0.0.1/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.3
+Name: alc-aiidalab-widgets
+Version: 0.0.1
+Summary: Commonly used components for ALC managed AiiDAlab plugins
+Keywords: aiida,workflows,ALC
+Author: Dr. Benjamin T. Speake
+Author-email: Dr. Benjamin T. Speake <benjamin.speake@stfc.ac.uk>
+License: BSD 3-Clause License
+         
+         Copyright (c) 2026, UKRI Science and Technology Facilities Council
+         
+         Redistribution and use in source and binary forms, with or without
+         modification, are permitted provided that the following conditions are met:
+         
+         1. Redistributions of source code must retain the above copyright notice, this
+            list of conditions and the following disclaimer.
+         
+         2. Redistributions in binary form must reproduce the above copyright notice,
+            this list of conditions and the following disclaimer in the documentation
+            and/or other materials provided with the distribution.
+         
+         3. Neither the name of the copyright holder nor the names of its
+            contributors may be used to endorse or promote products derived from
+            this software without specific prior written permission.
+         
+         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+         AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+         IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+         DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+         FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+         DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+         SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+         CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+         OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+         OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Framework :: AiiDA
+Classifier: Development Status :: 1 - Planning
+Requires-Dist: aiidalab-widgets-base
+Requires-Dist: ipywidgets
+Requires-Dist: traitlets
+Requires-Dist: aiida-core>=2.6
+Requires-Dist: weas-widget
+Requires-Dist: pytest>=8.0 ; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.11.0 ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Requires-Dist: sphinx>=8.0.2 ; extra == 'docs'
+Requires-Python: >=3.10
+Project-URL: Source, https://github.com/stfc/alc-aiidalab-widgets
+Provides-Extra: dev
+Provides-Extra: docs
+Description-Content-Type: text/markdown
+
+# alc-aiidalab-widgets
+
+[![Release](https://img.shields.io/github/v/release/stfc/alc-aiidalab-widgets)](https://github.com/stfc/alc-aiidalab-widgets/releases)
+[![PyPI](https://img.shields.io/pypi/v/alc-aiidalab-widgets)](https://pypi.org/project/alc-aiidalab-widgets/)
+
+[![Pipeline Status](https://github.com/stfc/alc-aiidalab-widgets/actions/workflows/testing.yml/badge.svg?branch=main)](https://github.com/stfc/alc-aiidalab-widgets/actions)
+[![Docs status](https://github.com/stfc/alc-aiidalab-widgets/actions/workflows/docs.yml/badge.svg?branch=main)](https://stfc.github.io/alc-aiidalab-widgets/)
+<!-- [![Coverage Status]( https://coveralls.io/repos/github/stfc/alc-aiidalab-widgets/badge.svg?branch=main)](https://coveralls.io/github/stfc/alc-aiidalab-widgets?branch=main) -->
+
+<!-- [![DOI](https://zenodo.org/badge/1094975386.svg)](https://doi.org/10.5281/zenodo.19188755) -->
+
+This is a collection of commonly used widgets used across AiiDAlab plugins developed by
+the Ada Lovelace Centre (STFC). It provides re-usable components and consistent styling
+which can be deployed to any new or developing AiiDAlab plugin. It can be installed via
+pip,
+
+``` sh
+pip install alc-aiidalab-widgets
+```
+
+and then imported within any python project as,
+
+``` python
+import alc_aiidalab_widgets
+```
+
+## For Developers
+
+### Style Checking
+
+This package uses pre-commit hooks to check for style consistency, to use these the ``pre-commit`` tool is required.
+This can be installed alongside the base package by running,
+
+``` sh
+pip install .[dev]
+```
+
+or separately via,
+
+``` sh
+pip install pre-commit 
+```
+
+Once installed run,
+
+``` sh
+pre-commit install 
+```
+
+in the base repository to enable the pre-commit hooks.
+This will now run style and formatting checks on every commit.
+
+### Testing
+
+This package uses [pytest](https://docs.pytest.org/en/stable/)
+to run all unit tests which is included in the ```[dev]``` optional
+package dependencies. Once installed it can be run from the project root directory.
+The CI workflows are configured to ensure all tests pass
+before a pull request can be accepted into the main repository.
+It is important that any new additions to the code base are accompanied
+by appropriate testing, maintaining a high code coverage. The coverage
+can be checked via,
+
+``` sh
+pytest --cov=aiidalab_alc 
+```
+
+### Documentation
+
+The documentation, including a User Guide, Developer Guide and an API reference,
+is built using [sphinx](https://www.sphinx-doc.org/). The source
+for which is contained in the ```docs/``` directory. At present
+only the html generator has been fully tested. All required packages can
+be installed alongside the core package via,
+
+``` sh
+pip install .[docs]
+```
+
+and then the documentation can be built using sphinx-build,
+
+``` sh
+sphinx-build -b html docs/src/ docs/build/html 
+```
+
+from the root directory.
+
+## License
+
+[BSD 3-Clause License](LICENSE)
+
+## Funding
+
+Contributors to this project were funded by
+
+<div align="center">
+    <a href="https://adalovelacecentre.ac.uk/">
+        <img src="images/alc.svg" alt="ALC Logo" style="width: 30%">
+    </a>
+</div>

alc_aiidalab_widgets-0.0.1/README.md

@@ -0,0 +1,100 @@
+# alc-aiidalab-widgets
+
+[![Release](https://img.shields.io/github/v/release/stfc/alc-aiidalab-widgets)](https://github.com/stfc/alc-aiidalab-widgets/releases)
+[![PyPI](https://img.shields.io/pypi/v/alc-aiidalab-widgets)](https://pypi.org/project/alc-aiidalab-widgets/)
+
+[![Pipeline Status](https://github.com/stfc/alc-aiidalab-widgets/actions/workflows/testing.yml/badge.svg?branch=main)](https://github.com/stfc/alc-aiidalab-widgets/actions)
+[![Docs status](https://github.com/stfc/alc-aiidalab-widgets/actions/workflows/docs.yml/badge.svg?branch=main)](https://stfc.github.io/alc-aiidalab-widgets/)
+<!-- [![Coverage Status]( https://coveralls.io/repos/github/stfc/alc-aiidalab-widgets/badge.svg?branch=main)](https://coveralls.io/github/stfc/alc-aiidalab-widgets?branch=main) -->
+
+<!-- [![DOI](https://zenodo.org/badge/1094975386.svg)](https://doi.org/10.5281/zenodo.19188755) -->
+
+This is a collection of commonly used widgets used across AiiDAlab plugins developed by
+the Ada Lovelace Centre (STFC). It provides re-usable components and consistent styling
+which can be deployed to any new or developing AiiDAlab plugin. It can be installed via
+pip,
+
+``` sh
+pip install alc-aiidalab-widgets
+```
+
+and then imported within any python project as,
+
+``` python
+import alc_aiidalab_widgets
+```
+
+## For Developers
+
+### Style Checking
+
+This package uses pre-commit hooks to check for style consistency, to use these the ``pre-commit`` tool is required.
+This can be installed alongside the base package by running,
+
+``` sh
+pip install .[dev]
+```
+
+or separately via,
+
+``` sh
+pip install pre-commit 
+```
+
+Once installed run,
+
+``` sh
+pre-commit install 
+```
+
+in the base repository to enable the pre-commit hooks.
+This will now run style and formatting checks on every commit.
+
+### Testing
+
+This package uses [pytest](https://docs.pytest.org/en/stable/)
+to run all unit tests which is included in the ```[dev]``` optional
+package dependencies. Once installed it can be run from the project root directory.
+The CI workflows are configured to ensure all tests pass
+before a pull request can be accepted into the main repository.
+It is important that any new additions to the code base are accompanied
+by appropriate testing, maintaining a high code coverage. The coverage
+can be checked via,
+
+``` sh
+pytest --cov=aiidalab_alc 
+```
+
+### Documentation
+
+The documentation, including a User Guide, Developer Guide and an API reference,
+is built using [sphinx](https://www.sphinx-doc.org/). The source
+for which is contained in the ```docs/``` directory. At present
+only the html generator has been fully tested. All required packages can
+be installed alongside the core package via,
+
+``` sh
+pip install .[docs]
+```
+
+and then the documentation can be built using sphinx-build,
+
+``` sh
+sphinx-build -b html docs/src/ docs/build/html 
+```
+
+from the root directory.
+
+## License
+
+[BSD 3-Clause License](LICENSE)
+
+## Funding
+
+Contributors to this project were funded by
+
+<div align="center">
+    <a href="https://adalovelacecentre.ac.uk/">
+        <img src="images/alc.svg" alt="ALC Logo" style="width: 30%">
+    </a>
+</div>

alc_aiidalab_widgets-0.0.1/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["uv-build"]
+build-backend = "uv_build"
+
+
+[project]
+version = "0.0.1"
+name = "alc-aiidalab-widgets"
+description = "Commonly used components for ALC managed AiiDAlab plugins"
+authors = [
+    { name = "Dr. Benjamin T. Speake", email = "benjamin.speake@stfc.ac.uk" },
+]
+
+readme = "README.md"
+license = { file = "LICENSE" }
+keywords = ["aiida", "workflows", "ALC"]
+classifiers = [
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Framework :: AiiDA",
+    "Development Status :: 1 - Planning",
+]
+requires-python = ">=3.10"
+dependencies = [
+    "aiidalab-widgets-base",
+    "ipywidgets",
+    "traitlets",
+    "aiida-core>=2.6",
+    "weas-widget",
+]
+
+[project.urls]
+Source = "https://github.com/stfc/alc-aiidalab-widgets"
+
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-cov>=6.0", "ruff>=0.11.0", "pre-commit"]
+docs = ["sphinx>=8.0.2"]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 88
+indent-width = 4
+exclude = ["docs/src/conf.py"]
+
+[tool.ruff.lint.per-file-ignores]
+
+[tool.ruff.lint]
+select = [
+    # flake8-bugbear
+    "B",
+    # pylint
+    "C",
+    "R",
+    # pydocstyle
+    "D",
+    # pycodestyle
+    "E",
+    "W",
+    # Pyflakes
+    "F",
+    "FA",
+    # isort
+    "I",
+    # pep8-naming
+    "N",
+    # pyupgrade
+    "UP",
+]
+ignore = ["C901"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.pylint]
+max-args = 10

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/__init__.py

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

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/__init__.py

@@ -0,0 +1 @@
+"""Module providing reusable and extensible widget implementations."""

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/code_setup.py

@@ -0,0 +1,54 @@
+"""Defines a resource setup widget based on foundations from aiidalab-widgets-base."""
+
+from aiidalab_widgets_base.computational_resources import ResourceSetupBaseWidget
+from aiidalab_widgets_base.utils import StatusHTML
+from ipywidgets import HTML, Text, VBox, dlink
+from traitlets import HasTraits, Unicode, observe
+
+
+class CodeSetupWidget(VBox, HasTraits):
+    """Widget to setup a new code instance.
+
+    Extends the existing ResourceSetupBaseWidget from aiidalab-widgets-base with the
+    ability to alter the database source link. By default using this widget will
+    point to the provided ALC resources database contained within the
+    https://github.com/stfc/alc-ux repository.
+    """
+
+    _database_source = Unicode(
+        "",
+        allow_none=False,
+    )
+
+    def __init__(self, **kwargs):
+        """CodeSetupWidget constructor."""
+        self.source = Text(
+            value=self._database_source, description="Source: ", layout={"width": "80%"}
+        )
+        dlink((self.source, "value"), (self, "_database_source"))
+        self.resource_widget = ResourceSetupBaseWidget()
+        self.setup_message = StatusHTML(clear_after=15)
+        dlink(
+            (self.resource_widget, "message"),
+            (self.setup_message, "message"),
+        )
+
+        self.source.value = "https://raw.githubusercontent.com/stfc/alc-ux/refs/heads/main/resources/remotes.json"
+
+        children = [
+            HTML("<hr>"),
+            self.source,
+            HTML("<hr>"),
+            self.resource_widget,
+            self.setup_message,
+        ]
+        super().__init__(children=children, **kwargs)
+        return
+
+    @observe("_database_source")
+    def _update_database_source(self, _):
+        """Update the database source in the ResourceSetupBaseWidget."""
+        self.resource_widget.comp_resources_database.database_source = (
+            self._database_source
+        )
+        return

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/database.py

@@ -0,0 +1,185 @@
+"""Module for components relating to AiiDA database management."""
+
+import datetime
+
+import ipywidgets as ipw
+from aiida.orm import (
+    CalcFunctionNode,
+    CalcJobNode,
+    Node,
+    QueryBuilder,
+    WorkChainNode,
+)
+from traitlets import HasTraits, Instance
+
+
+class AiiDADatabaseQueryWidget(ipw.VBox, HasTraits):
+    """Widget for AiiDA database searching."""
+
+    data_object = Instance(Node, allow_none=True)
+
+    def __init__(self, title: str = "", query: list | None = None):
+        """AiiDADatabaseQueryWidget constructor.
+
+        Creates a widgets for searching specific nodes within the AiiDA database,
+        based on an input query list of node types. It also provides further options
+        for tailoring the search.
+
+        Parameters
+        ----------
+        title: str
+            The widget's title
+        query: List | None
+            A list of AiiDA node types to search for in the database, if None will
+            default to search for CalcJobNodes and WorkChainNodes.
+        """
+        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_node, 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_node(self, _) -> None:
+        """Update the selected node."""
+        self.data_object = self.results.value or None
+        return
+
+    def disable(self, val: bool) -> None:
+        """Disable the widget."""
+        self.results.disabled = True
+        # self.
+        return

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/file_handling.py

@@ -0,0 +1,97 @@
+"""Module for providing widgets 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:
+            try:
+                self.file_dict = self.file_upload.value[
+                    list(self.file_upload.value.keys())[0]
+                ]
+                self.file_handle.value = self.file_dict["metadata"]["name"]
+            except AttributeError:
+                self.file_dict = self.file_upload.value[0]
+                self.file_handle.value = self.file_dict["name"]
+            finally:
+                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:
+            try:
+                return self.file_dict["metadata"]["name"]
+            except KeyError:
+                return self.file_dict["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

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/loading.py

@@ -0,0 +1,26 @@
+"""Temporary widgets used to fill wait times."""
+
+from ipywidgets import HTML, HBox, Label, Layout
+
+
+class LoadingWidget(HBox):
+    """Widget for displaying a loading spinner."""
+
+    def __init__(self, message="Loading", **kwargs):
+        """LoadingWidget constructor."""
+        super().__init__(
+            children=[
+                Label(message),
+                HTML(
+                    value="<i class='fa fa-spinner fa-spin fa-2x fa-fw'/>",
+                    layout=Layout(margin="12px 0 6px"),
+                ),
+            ],
+            layout=Layout(
+                justify_content="center",
+                align_items="center",
+                **kwargs.pop("layout", {}),
+            ),
+            **kwargs,
+        )
+        self.add_class("loading")

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/structure.py

@@ -0,0 +1,80 @@
+"""Defines a widget for visualisation of chemical structures."""
+
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+from aiida.orm import StructureData
+from ase import Atoms
+from ase import io as ase_io
+from ipywidgets import HTML, VBox
+from weas_widget import WeasWidget
+
+
+class StructureViewWidget(VBox):
+    """Visualise atom structure using weas_widget."""
+
+    def __init__(self, **kwargs):
+        """StructureViewWidget constructor."""
+        super().__init__(**kwargs)
+        self.message = HTML("<p>No Structure Currently Loaded</p>")
+        self.viewer = None
+        self.children = [
+            self.message,
+        ]
+
+    def assign_structure_from_file(self, fname: str, content: bytes) -> None:
+        """Visualise the given structure from a file.
+
+        Parameters
+        ----------
+        fname: str
+            The structure file path.
+        content: bytes
+            The content of the file.
+        """
+        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):
+                self.message = HTML("<p>Could not visualise structure...</p>")
+                self.children = [
+                    self.message,
+                ]
+            except Exception as e:
+                raise e
+            else:
+                self.viewer = WeasWidget()
+                self.viewer.from_ase(structure)
+                self.children = [
+                    self.viewer,
+                ]
+        return
+
+    def assign_structure_from_ase(self, structure: Atoms) -> None:
+        """Visualise the given ASE structure.
+
+        Parameters
+        ----------
+        structure: Atoms
+            The ASE atoms structure object.
+        """
+        self.viewer = WeasWidget()
+        self.viewer.from_ase(structure)
+        self.children = [
+            self.viewer,
+        ]
+        return
+
+    def assign_structure_from_structuredata(self, structure: StructureData) -> None:
+        """Visualise the given AiiDA StructureData object.
+
+        Parameters
+        ----------
+        structure: StructureData
+            The AiiDA StructureData object.
+        """
+        self.assign_structure_from_ase(structure._get_object_ase())
+        return

alc_aiidalab_widgets-0.0.1/src/alc_aiidalab_widgets/widgets/tables.py

@@ -0,0 +1,60 @@
+"""Widgets used for displaying tabular information."""
+
+from aiida.orm import ArrayData
+from ipywidgets import HTML, Dropdown, VBox
+
+
+class XYZArrayDataTableWidget(VBox):
+    """
+    Custom widget to display array data produced from ChemShell jobs.
+
+    Create a table based widget for displaying different arrays within
+    an ArrayData object assuming that all the data is XYZ based i.e
+    atomic positions of forces.
+    """
+
+    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> </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