Add CalculationTools base and entry point aiida.tools.calculations

aiida/orm/node/process/calculation/calcjob.py

@@ -57,6 +57,40 @@ class CalcJobNode(CalculationNode):
     JOB_STATE_KEY = 'state'
     JOB_STATE_ATTRIBUTE_KEY = 'attributes.{}'.format(JOB_STATE_KEY)
 
+    # An optional entry point for a CalculationTools instance
+    _tools = None
+
+    @property
+    def tools(self):
+        """Return the calculation tools that are registered for the process type associated with this calculation.
+
+        If the entry point name stored in the `process_type` of the CalcJobNode has an accompanying entry point in the
+        `aiida.tools.calculations` entry point category, it will attempt to load the entry point and instantiate it
+        passing the node to the constructor. If the entry point does not exist, cannot be resolved or loaded, a warning
+        will be logged and the base CalculationTools class will be instantiated and returned.
+
+        :return: CalculationTools instance
+        """
+        from aiida.common.exceptions import MultipleEntryPointError, MissingEntryPointError, LoadingEntryPointError
+        from aiida.plugins.entry_point import is_valid_entry_point_string, get_entry_point_from_string, load_entry_point
+        from aiida.tools.calculations import CalculationTools
+
+        if self._tools is None:
+            entry_point_string = self.process_type
+
+            if is_valid_entry_point_string(entry_point_string):
+                entry_point = get_entry_point_from_string(entry_point_string)
+
+                try:
+                    tools_class = load_entry_point('aiida.tools.calculations', entry_point.name)
+                    self._tools = tools_class(self)
+                except (MultipleEntryPointError, MissingEntryPointError, LoadingEntryPointError) as exception:
+                    self._tools = CalculationTools(self)
+                    self.logger.warning('could not load the calculation tools entry point {}: {}'.format(
+                        entry_point.name, exception))
+
+        return self._tools
+
     def __dir__(self):
         """
         Allow to list all valid attributes, adding also the use_* methods

aiida/orm/node/process/process.py

@@ -44,6 +44,13 @@ class ProcessNode(Sealable, Node):
     # Specific sub classes should be marked as cacheable when appropriate
     _cacheable = False
 
+    def __str__(self):
+        base = super(ProcessNode, self).__str__()
+        if self.process_type:
+            return '{} ({})'.format(base, self.process_type)
+
+        return '{}'.format(base)
+
     @classproperty
     def _updatable_attributes(cls):
         return super(ProcessNode, cls)._updatable_attributes + (

aiida/tools/calculations/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# pylint: disable=wildcard-import,undefined-variable
+"""Calculation tool plugins for Calculation classes."""
+
+from .base import *
+
+__all__ = (base.__all__)

aiida/tools/calculations/base.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+"""Base class for CalculationTools
+
+Sub-classes can be registered in the `aiida.tools.calculations` category to enable the `CalcJobNode` class from being
+able to find the tools plugin, load it and expose it through the `tools` property of the `CalcJobNode`.
+"""
+
+__all__ = ('CalculationTools',)
+
+
+class CalculationTools(object):
+    """Base class for CalculationTools."""
+
+    # pylint: disable=too-few-public-methods
+
+    def __init__(self, node):
+        self._node = node

setup.json

@@ -197,6 +197,8 @@
       "tcod = aiida.tools.dbexporters.tcod"
     ],
     "aiida.tests": [],
+    "aiida.tools.calculations": [
+    ],
     "aiida.tools.dbimporters": [
       "cod = aiida.tools.dbimporters.plugins.cod:CodDbImporter",
       "icsd = aiida.tools.dbimporters.plugins.icsd:IcsdDbImporter",