Fix QueryBuilder filtering for AbstractCode (aiidateam#6866)

Adding an entry point for `AbstractCode` to make it queryable.Users searching
for `AbstractCode` (sub)classes want to get all the codes (`PortableCode`,
`InstalledCode` etc.) Unfortunately, because AbstractCode was introduced
later, its entry point is 'data.core.code.abstract', while the 'core.code'
entry point is claimed by the Legacy Code class. So to get all the code types,
including the Legacy Code, we adjust the filter to 'data.core.code'. Note,
this only make sense if `subclassing` parameter is True!

Fixes issue aiidateam#6687.

---------

Co-authored-by: unknown <[email protected]>
Co-authored-by: Alexander Goscinski <[email protected]>

Author: 3 people

pyproject.toml

@@ -103,6 +103,7 @@ requires-python = '>=3.9'
 'core.bool' = 'aiida.orm.nodes.data.bool:Bool'
 'core.cif' = 'aiida.orm.nodes.data.cif:CifData'
 'core.code' = 'aiida.orm.nodes.data.code.legacy:Code'
+'core.code.abstract' = 'aiida.orm.nodes.data.code.abstract:AbstractCode'
 'core.code.containerized' = 'aiida.orm.nodes.data.code.containerized:ContainerizedCode'
 'core.code.installed' = 'aiida.orm.nodes.data.code.installed:InstalledCode'
 'core.code.portable' = 'aiida.orm.nodes.data.code.portable:PortableCode'

src/aiida/orm/querybuilder.py

@@ -1338,6 +1338,14 @@ def _get_node_type_filter(classifiers: Classifier, subclassing: bool) -> dict:
 
     value = classifiers.ormclass_type_string
 
+    # Users searching for `AbstractCode` (sub)classes want to get all the codes (Portable, Installed etc.)
+    # Unfortunately, because AbstractCode was introduced later, its entry point is 'data.core.code.abstract',
+    # while the 'core.code' entry point is claimed by the Legacy Code class.
+    # So to get all the code types, including the Legacy Code, we adjust the filter to 'data.core.code'.
+    # Note, this only make sense if `subclassing` parameter is True!
+    if value == 'data.core.code.abstract.AbstractCode.':
+        value = 'data.core.code.'
+
     if not subclassing:
         filters = {'==': value}
     else:

tests/orm/nodes/data/test_data.py

@@ -154,7 +154,11 @@ def _generate_class_instance(data_class):
 
 @pytest.fixture(
     scope='function',
-    params=[entry_point for entry_point in plugins.get_entry_points('aiida.data') if entry_point.name != 'core.code'],
+    params=[
+        entry_point
+        for entry_point in plugins.get_entry_points('aiida.data')
+        if entry_point.name not in ('core.code', 'core.code.abstract')
+    ],
 )
 def data_plugin(request):
     """Fixture that parametrizes over all the registered entry points of the ``aiida.data`` entry point group."""

tests/orm/test_fields/fields_aiida.data.core.code.abstract.AbstractCode.yml

@@ -0,0 +1,25 @@
+append_text: QbStrField('append_text', dtype=<class 'str'>, is_attribute=True)
+attributes: QbDictField('attributes', dtype=typing.Optional[typing.Dict[str, typing.Any]],
+  is_attribute=False, is_subscriptable=True)
+computer: QbNumericField('computer', dtype=typing.Optional[int], is_attribute=False)
+ctime: QbNumericField('ctime', dtype=typing.Optional[datetime.datetime], is_attribute=False)
+default_calc_job_plugin: QbStrField('default_calc_job_plugin', dtype=typing.Optional[str],
+  is_attribute=True)
+description: QbStrField('description', dtype=<class 'str'>, is_attribute=True)
+extras: QbDictField('extras', dtype=typing.Optional[typing.Dict[str, typing.Any]],
+  is_attribute=False, is_subscriptable=True)
+label: QbStrField('label', dtype=<class 'str'>, is_attribute=True)
+mtime: QbNumericField('mtime', dtype=typing.Optional[datetime.datetime], is_attribute=False)
+node_type: QbStrField('node_type', dtype=typing.Optional[str], is_attribute=False)
+pk: QbNumericField('pk', dtype=typing.Optional[int], is_attribute=False)
+prepend_text: QbStrField('prepend_text', dtype=<class 'str'>, is_attribute=True)
+process_type: QbStrField('process_type', dtype=typing.Optional[str], is_attribute=False)
+repository_content: QbDictField('repository_content', dtype=typing.Optional[dict[str,
+  bytes]], is_attribute=False)
+repository_metadata: QbDictField('repository_metadata', dtype=typing.Optional[typing.Dict[str,
+  typing.Any]], is_attribute=False)
+source: QbDictField('source', dtype=typing.Optional[dict], is_attribute=True, is_subscriptable=True)
+use_double_quotes: QbField('use_double_quotes', dtype=<class 'bool'>, is_attribute=True)
+user: QbNumericField('user', dtype=typing.Optional[int], is_attribute=False)
+uuid: QbStrField('uuid', dtype=typing.Optional[str], is_attribute=False)
+with_mpi: QbField('with_mpi', dtype=typing.Optional[bool], is_attribute=True)

tests/orm/test_querybuilder.py

@@ -852,6 +852,76 @@ def test_empty_filters(self):
         qb = orm.QueryBuilder().append(orm.Data, filters={'or': [{}, {}]})
         assert qb.count() == count
 
+    @pytest.mark.usefixtures('suppress_internal_deprecations')
+    @pytest.mark.usefixtures('aiida_profile_clean')
+    def test_abstract_code_filtering(self, aiida_localhost, aiida_code, tmp_path):
+        """Test that querying for AbstractCode correctly returns all code instances.
+
+        This tests the fix for issue #6687, where QueryBuilder couldn't find codes
+        when looking for AbstractCode due to a node_type mismatch.
+        """
+        installed_code = aiida_code(
+            'core.code.installed',
+            label='installed-code',
+            computer=aiida_localhost,
+            filepath_executable='/bin/bash',
+        )
+        (tmp_path / 'fake_exec').touch()
+        portable_code = aiida_code(
+            'core.code.portable',
+            label='portable-code',
+            filepath_executable='fake_exec',
+            filepath_files=tmp_path,
+        )
+        legacy_code = aiida_code(
+            'core.code',
+            label='legacy-code',
+            remote_computer_exec=(aiida_localhost, '/bin/bash'),
+        )
+
+        qb = orm.QueryBuilder
+
+        # Verify specific code type queries work as expected
+        installed_results = qb().append(orm.InstalledCode).all(flat=True)
+        assert installed_code in installed_results
+        assert len(installed_results) == 1
+
+        portable_results = qb().append(orm.PortableCode).all(flat=True)
+        assert portable_code in portable_results
+        assert len(portable_results) == 1
+
+        # Using orm.Code actually matches all codes.
+        # for backwards compatibility reasons we will not fix this.
+        legacy_results = qb().append(orm.Code).all(flat=True)
+        assert legacy_code in legacy_results
+        assert len(legacy_results) == 3
+
+        # Turning off subclassing should however only match the one legacy Code
+        legacy_results = qb().append(orm.Code, subclassing=False).all(flat=True)
+        assert legacy_code in legacy_results
+        assert len(legacy_results) == 1
+
+        # AbstractCode query should find all code types
+        abstract_results = qb().append(orm.AbstractCode).all(flat=True)
+        assert (
+            installed_code in abstract_results
+        ), f'InstalledCode not found with AbstractCode query. Result: {abstract_results}'
+        assert (
+            portable_code in abstract_results
+        ), f'PortableCode not found with AbstractCode query. Result: {abstract_results}'
+        assert legacy_code in abstract_results, f'Code not found with AbstractCode query. Result: {abstract_results}'
+        assert len(abstract_results) == 3
+
+        # AbstractCode with basic filtering
+        qb_filtered = qb().append(orm.AbstractCode, filters={'label': 'installed-code'})
+        filtered_results = qb_filtered.all(flat=True)
+        assert installed_code in filtered_results
+        assert len(filtered_results) == 1
+
+        # QB should find no codes if subclassing is False
+        subclassing_off_results = qb().append(orm.AbstractCode, subclassing=False).all(flat=True)
+        assert len(subclassing_off_results) == 0
+
 
 class TestAttributes:
     @pytest.mark.requires_psql