Merge remote-tracking branch 'upstream/main' into feat/support-aiida-resource-registry

Author: GeigerJ2

.github/workflows/nightly.yml

@@ -114,7 +114,10 @@ jobs:
       matrix:
         # Currently supported RMQ versions per:
         # https://www.rabbitmq.com/docs/which-erlang#compatibility-matrix
-        rabbitmq-version: ['3.11', '3.12', '3.13', '4.0']
+        # Version 3.10 is currently used by AiiDAlab.
+        # Version 4.3 broke aiida-core, so the latest supported is 4.2:
+        # https://github.com/aiidateam/aiida-core/issues/7375
+        rabbitmq-version: ['3.10', '4.2']
 
     services:
       rabbitmq:

pyproject.toml

@@ -245,7 +245,7 @@ notebook = [
 # https://github.com/python/typeshed?tab=readme-ov-file#package-versioning-for-third-party-stubs
 pre-commit = [
   'aiida-core[tests]',
-  'mypy~=1.19.0',
+  'mypy~=2.1.0',
   'packaging~=23.0',
   'pre-commit~=3.5',
   'sqlalchemy[mypy]~=2.0',

src/aiida/orm/nodes/data/array/trajectory.py

@@ -830,7 +830,7 @@ def collapse_into_unit_cell(point, cell):
             xmin, ymin, zmin = _x.min(), _y.min(), _z.min()
             xmax, ymax, zmax = _x.max(), _y.max(), _z.max()
 
-            _xi, _yi, _zi = np.mgrid[xmin:xmax:60j, ymin:ymax:30j, zmin:zmax:30j]  # type: ignore[misc]
+            _xi, _yi, _zi = np.mgrid[xmin:xmax:60j, ymin:ymax:30j, zmin:zmax:30j]
             coords = np.vstack([item.ravel() for item in [_xi, _yi, _zi]])
             density = kde(coords).reshape(_xi.shape)
 

src/aiida/orm/nodes/data/data.py

@@ -354,3 +354,13 @@ def _get_converters(self):
         valid_format_names = [i[len(exporter_prefix) :] for i in method_names if i.startswith(exporter_prefix)]
         valid_formats = {k: getattr(self, exporter_prefix + k) for k in valid_format_names}
         return valid_formats
+
+    @classmethod
+    def _get_patched_node_type_field(cls):
+        node_type_field = super()._get_patched_node_type_field()
+        if cls.__name__ == 'Data':
+            # `Data` is not to be used directly! It is only ever used when a subclass
+            # from an uninstalled plugin regresses to `Data`, in which case, the node
+            # type should not be validated against a `Literal`, only as a `str`.
+            return (str, node_type_field[1])
+        return node_type_field

src/aiida/orm/nodes/node.py

@@ -1074,6 +1074,12 @@ def _patch_attributes_model(cls):
             cls.AttributesModel = AttributesModel  # type: ignore[misc]
         cls.AttributesModel.model_rebuild(force=True)
 
+    @classmethod
+    def _get_patched_node_type_field(cls):
+        """Return a copy of the `node_type` field cast as the literal type for this class."""
+        node_type_field = deepcopy(cls.BaseNodeModel.model_fields['node_type'])
+        return (Literal[cls.class_node_type], node_type_field)
+
     @classmethod
     def _patch_read_model(cls):
         """Patch `ReadModel` by wiring the subclass-specific `attributes` model.
@@ -1107,9 +1113,8 @@ def _patch_read_model(cls):
             }
 
         attributes_field = deepcopy(cls.ReadModel.model_fields['attributes'])
-        node_type_field = deepcopy(cls.BaseNodeModel.model_fields['node_type'])
-        model_fields['node_type'] = (Literal[cls.class_node_type], node_type_field)
         model_fields['attributes'] = (cls.AttributesModel, attributes_field)
+        model_fields['node_type'] = cls._get_patched_node_type_field()
 
         ReadModel = cast(  # noqa: N806
             type[Node.ReadModel],
@@ -1130,23 +1135,28 @@ def _patch_constructor_model(cls):
         """Patch `ConstructorModel` by synthesizing it from `BaseNodeModel` and `ConstructorArgsModel`."""
         if not cls.supports_constructor_model:
             return
-        node_type_field = deepcopy(cls.BaseNodeModel.model_fields['node_type'])
+
         args_field = OrmMetadataField(
             description='The constructor arguments.',
             write_only=True,
         )
+        model_fields: dict[str, Any] = {
+            'args': (cls.ConstructorArgsModel, args_field),
+            'node_type': cls._get_patched_node_type_field(),
+        }
+
         ConstructorModel = cast(  # noqa: N806
             type[Node.BaseNodeModel],
             pdt.create_model(
                 'ConstructorModel',
                 __base__=cls.BaseNodeModel,
                 __module__=cls.__module__,
-                node_type=(Literal[cls.class_node_type], node_type_field),
-                args=(cls.ConstructorArgsModel, args_field),
+                **model_fields,
             ),
         )
         ConstructorModel.__qualname__ = f'{cls.__name__}.ConstructorModel'
         ConstructorModel.model_rebuild(force=True)
+
         cls._ConstructorModel = ConstructorModel
 
     @classmethod

src/aiida/orm/utils/links.py

@@ -176,10 +176,10 @@ def validate_link(
 
     type_source, type_target, outdegree, indegree = link_mapping[link_type]
 
-    if not isinstance(source, type_source) or not isinstance(target, type_target):
+    if not isinstance(source, type_source) or not isinstance(target, type_target):  # type: ignore[unreachable]
         raise ValueError(f'cannot add a {link_type} link from {type(source)} to {type(target)}')
 
-    if outdegree == 'unique_triple' or indegree == 'unique_triple':
+    if outdegree == 'unique_triple' or indegree == 'unique_triple':  # type: ignore[unreachable]
         # For a `unique_triple` degree we just have to check if an identical triple already exist, either in the cache
         # or stored, in which case, the new proposed link is a duplicate and thus illegal
         duplicate_link_triple = link_triple_exists(source, target, link_type, link_label, backend)

src/aiida/orm/utils/node.py

@@ -28,7 +28,7 @@ def load_node_class(type_string):
     :param type_string: the `type` string of the node
     :return: a sub class of `Node`
     """
-    from aiida.orm import Data, Node
+    from aiida.orm import Data, Node, ProcessNode
     from aiida.plugins.entry_point import load_entry_point
 
     if type_string == '':
@@ -47,17 +47,20 @@ def load_node_class(type_string):
     if base_path.startswith('node.'):
         base_path = base_path.removeprefix('node.')
 
-    # Data nodes are the only ones with sub classes that are still external, so if the plugin is not available
-    # we fall back on the base node type
+    # If the Data plugin is not available we fall back on the base Data class
     if base_path.startswith('data.'):
         entry_point_name = base_path.removeprefix('data.')
         try:
             return load_entry_point('aiida.data', entry_point_name)
         except exceptions.MissingEntryPointError:
             return Data
 
+    # If the Process plugin is not available we fall back on the base ProcessNode class
     if base_path.startswith('process'):
-        return load_entry_point('aiida.node', base_path)
+        try:
+            return load_entry_point('aiida.node', base_path)
+        except exceptions.MissingEntryPointError:
+            return ProcessNode
 
     # At this point we really have an anomalous type string. At some point, storing nodes with unresolvable type strings
     # was allowed, for example by creating a sub class in a shell and then storing an instance. Attempting to load the

src/aiida/orm/utils/remote.py

@@ -15,6 +15,7 @@
 
 from aiida import orm
 from aiida.cmdline.utils import echo
+from aiida.common.exceptions import NotExistent
 from aiida.orm.nodes.data.remote.base import RemoteData
 
 if t.TYPE_CHECKING:
@@ -52,7 +53,7 @@ def clean_mapping_remote_paths(path_mapping, silent=False):
     :param path_mapping: a dictionary where the keys are the computer UUIDs and the values are lists of remote folders
         It's designed to accept the output of `get_calcjob_remote_paths`
     :param transport: the transport to use to clean the remote folders
-    :param silent: if True, the `echo` output will be suppressed
+    :param silent: if True, the success message output will be suppressed
     """
 
     user = orm.User.collection.get_default()
@@ -63,7 +64,16 @@ def clean_mapping_remote_paths(path_mapping, silent=False):
     for computer_uuid, paths in path_mapping.items():
         counter = 0
         computer = orm.load_computer(uuid=computer_uuid)
-        transport = orm.AuthInfo.collection.get(dbcomputer_id=computer.pk, aiidauser_id=user.pk).get_transport()
+        try:
+            authinfo = orm.AuthInfo.collection.get(dbcomputer_id=computer.pk, aiidauser_id=user.pk)
+        except NotExistent:
+            echo.echo_warning(
+                f'Skipping {len(paths)} remote folders on `{computer.label}`: '
+                f'computer is not configured for user `{user.email}`'
+            )
+            continue
+
+        transport = authinfo.get_transport()
 
         with transport:
             for remote_folder in paths:

src/aiida/tools/archive/create.py

@@ -239,7 +239,7 @@ def querybuilder():
             elif isinstance(entry, orm.Computer):
                 starting_uuids[EntityTypes.COMPUTER].add(entry.uuid)
                 entity_ids[EntityTypes.COMPUTER].add(entry.pk)
-            elif isinstance(entry, orm.User):
+            elif isinstance(entry, orm.User):  # type: ignore[unreachable]
                 starting_uuids[EntityTypes.USER].add(entry.email)
                 entity_ids[EntityTypes.USER].add(entry.pk)
             else:

src/aiida/tools/graph/age_entities.py

@@ -200,7 +200,7 @@ def _check_self_and_other(self, other: Self) -> None:
         if self._identifier_type != other.identifier_type:
             raise TypeError('The two instances do not have the same identifier type!')
 
-    def _check_input_for_set(self, input_for_set: _NodeOrGroupCls | int) -> Any:
+    def _check_input_for_set(self, input_for_set: orm.Node | orm.Group | int) -> Any:
         if isinstance(input_for_set, self._aiida_cls):
             return getattr(input_for_set, self._identifier)