NOT query: require two children

Author: Gerit Wagner

search_query/query_not.py

@@ -1,10 +1,14 @@
 #!/usr/bin/env python
 """NOT Query"""
 import typing
+from typing import cast
+from typing import List
+from typing import Union
 
 from search_query.constants import Operators
 from search_query.query import Query
 from search_query.query import SearchField
+from search_query.query_term import Term
 
 # pylint: disable=duplicate-code
 
@@ -26,9 +30,13 @@ def __init__(
         search field: search field to which the query should be applied
         """
 
+        query_children = [
+            c if isinstance(c, Query) else Term(value=c) for c in children
+        ]
+
         super().__init__(
             value=Operators.NOT,
-            children=children,
+            children=cast(List[Union[str, Query]], query_children),
             search_field=search_field
             if isinstance(search_field, SearchField)
             else SearchField(search_field)
@@ -38,6 +46,8 @@ def __init__(
             platform=platform,
         )
 
+        self.children = query_children
+
     @property
     def children(self) -> typing.List[Query]:
         """Children property."""

test/conftest.py

@@ -20,9 +20,11 @@ def query_setup() -> dict:
     test_node = Term(
         "testvalue", position=(1, 10), search_field=SearchField(Fields.TITLE)
     )
-    query_robot = NotQuery(["robot*"], search_field=SearchField(Fields.TITLE))
+    query_robot = NotQuery(
+        ['"Machine Learning"', "robot*"], search_field=SearchField(Fields.TITLE)
+    )
     query_ai = OrQuery(
-        ['"AI"', '"Artificial Intelligence"', '"Machine Learning"', query_robot],
+        ['"AI"', '"Artificial Intelligence"'],
         search_field=SearchField(Fields.TITLE),
     )
     query_health = OrQuery(

test/test_query.py

@@ -292,10 +292,11 @@ def test_children_setter() -> None:
 
     # Test for NotQuery ---------------------------------------------
     not_query = NotQuery(
-        ["ethics"],
+        ["AI", "ethics"],
         search_field="abstract",
     )
-    assert not_query.children[0].value == "ethics"
+    assert not_query.children[0].value == "AI"
+    assert not_query.children[1].value == "ethics"
 
     with pytest.raises(TypeError):
         not_query.children = "not_a_list"  # type: ignore

test/test_query_translation.py

@@ -28,21 +28,21 @@ def test_or_query(query_setup: dict) -> None:
     query_ai = query_setup["query_ai"]
     assert (
         query_ai.to_generic_string()
-        == 'OR[title]["AI"[title], "Artificial Intelligence"[title], "Machine Learning"[title], NOT[title][robot*[title]]]'
+        == 'OR[title]["AI"[title], "Artificial Intelligence"[title]]'
     )
 
 
 def test_and_query(query_setup: dict) -> None:
     query_complete = query_setup["query_complete"]
     assert (
         query_complete.to_generic_string()
-        == 'AND[title][OR[title]["AI"[title], "Artificial Intelligence"[title], "Machine Learning"[title], NOT[title][robot*[title]]], OR[title]["health care"[title], medicine[title]], OR[abstract][ethic*[abstract], moral*[abstract]]]'
+        == 'AND[title][OR[title]["AI"[title], "Artificial Intelligence"[title]], OR[title]["health care"[title], medicine[title]], OR[abstract][ethic*[abstract], moral*[abstract]]]'
     )
 
 
 def test_not_query(query_setup: dict) -> None:
     query_robot = query_setup["query_robot"]
-    assert query_robot.to_generic_string() == "NOT[title][robot*[title]]"
+    assert query_robot.to_generic_string() == 'NOT[title]["Machine Learning", robot*]'
 
 
 def test_nested_queries(query_setup: dict) -> None:
@@ -67,7 +67,7 @@ def test_translation_wos_part(query_setup: dict) -> None:
 
 def test_translation_wos_complete(query_setup: dict) -> None:
     query_complete = query_setup["query_complete"]
-    expected = '(TI=("AI" OR "Artificial Intelligence" OR "Machine Learning" NOT robot*) AND TI=("health care" OR medicine) AND AB=(ethic* OR moral*))'
+    expected = 'TI=("AI" OR "Artificial Intelligence") AND TI=("health care" OR medicine) AND AB=(ethic* OR moral*)'
     translated_query = query_complete.translate(PLATFORM.WOS.value)
     assert translated_query.to_string() == expected
 
@@ -81,7 +81,7 @@ def test_translation_pubmed_part(query_setup: dict) -> None:
 
 def test_translation_pubmed_complete(query_setup: dict) -> None:
     query_complete = query_setup["query_complete"]
-    expected = '(("AI"[ti] OR "Artificial Intelligence"[ti] OR "Machine Learning"[ti] NOT robot*[ti]) AND ("health care"[ti] OR medicine[ti]) AND (ethic*[tiab] OR moral*[tiab]))'
+    expected = '(("AI"[ti] OR "Artificial Intelligence"[ti]) AND ("health care"[ti] OR medicine[ti]) AND (ethic*[tiab] OR moral*[tiab]))'
     translated_query = query_complete.translate(PLATFORM.PUBMED.value)
     assert translated_query.to_string() == expected