Merge branch 'main' into cli

Author: Gerit Wagner

search_query/constants.py

@@ -467,7 +467,7 @@ class QueryErrorCode(Enum):
         "W0006",
         "implicit-near-value",
         "The value of NEAR operator is implicit",
-        """**Typical fix**: The parser automatically sets implicit NEAR values to the default of 15.
+        """**Typical fix**: The parser automatically sets NEAR values to 15 (default).
 
 **Problematic query**:
 
@@ -486,7 +486,9 @@ class QueryErrorCode(Enum):
         ["all", PLATFORM.PUBMED],
         "W0007",
         "implicit-precedence",
-        "Operator changed at the same level (currently relying on implicit operator precedence, explicit parentheses are recommended)",
+        "Operator changed at the same level "
+        "(currently relying on implicit operator precedence, "
+        "explicit parentheses are recommended)",
         "",
     )
 

search_query/parser_base.py

@@ -291,7 +291,6 @@ def add_artificial_parentheses_for_operator_precedence(
                 art_par += 1
 
         if index == len(self.tokens):
-            print(output)
             output = self.flatten_redundant_artificial_nesting(output)
             self.tokens = output
 

search_query/parser_ebsco.py

@@ -70,9 +70,8 @@ def combine_subsequent_tokens(self) -> None:
                     and self.tokens[i + 1].type == TokenTypes.SEARCH_TERM
                 ):
                     # Iterate over subsequent search_terms and combine
-                    next_token, _, next_position = self.tokens[i + 1]
-                    combined_value += f" {next_token}"
-                    end_position = next_position[1]
+                    combined_value += f" {self.tokens[i + 1].value}"
+                    end_position = self.tokens[i + 1].position[1]
                     i += 1
 
                 combined_tokens.append(
@@ -270,16 +269,21 @@ def parse_query_tree(
         current_operator: typing.Optional[Query] = None
 
         while tokens:
-            token, token_type, position = tokens.pop(0)
+            token = tokens.pop(0)
 
-            if token_type == TokenTypes.FIELD:
+            if token.type == TokenTypes.FIELD:
                 # Create new search_field used by following search_terms
-                search_field = SearchField(token, position=position)
+                search_field = SearchField(token.value, position=token.position)
 
-            elif token_type == TokenTypes.SEARCH_TERM:
+            elif token.type == TokenTypes.SEARCH_TERM:
                 # Create new search_term and in case tree is empty, sets first root
                 term_node = self.create_query_node(
-                    token, False, position, search_field, None, search_field_par
+                    token.value,
+                    False,
+                    token.position,
+                    search_field,
+                    None,
+                    search_field_par,
                 )
 
                 # Append search_term to tree
@@ -289,22 +293,24 @@ def parse_query_tree(
 
                 search_field = None
 
-            elif token_type == TokenTypes.PROXIMITY_OPERATOR:
+            elif token.type == TokenTypes.PROXIMITY_OPERATOR:
                 # Split token into NEAR/WITHIN and distance
-                token, distance = self.convert_proximity_operators(token, token_type)
+                token.value, distance = self.convert_proximity_operators(
+                    token.value, token.type
+                )
 
                 # Create new proximity_operator from token (N3, W1, N13, ...)
                 proximity_node = self.create_query_node(
-                    token, True, position, search_field, distance
+                    token.value, True, token.position, search_field, distance
                 )
 
                 # Set proximity_operator as tree node
                 root, current_operator = self.append_operator(root, proximity_node)
 
-            elif token_type == TokenTypes.LOGIC_OPERATOR:
+            elif token.type == TokenTypes.LOGIC_OPERATOR:
                 # Create new operator node
                 new_operator_node = self.create_query_node(
-                    token, True, position, search_field, None
+                    token.value, True, token.position, search_field, None
                 )
 
                 if not current_operator:
@@ -313,7 +319,7 @@ def parse_query_tree(
                         root, new_operator_node
                     )
 
-            elif token_type == TokenTypes.PARENTHESIS_OPEN:
+            elif token.type == TokenTypes.PARENTHESIS_OPEN:
                 # Recursively parse the group inside parentheses
                 # Set search_field_par as search field regarding the whole subtree
                 # If subtree is done, reset search_field_par
@@ -327,7 +333,7 @@ def parse_query_tree(
                     root, current_operator, subtree
                 )
 
-            elif token_type == TokenTypes.PARENTHESIS_CLOSED:
+            elif token.type == TokenTypes.PARENTHESIS_CLOSED:
                 # Return subtree
                 root = self.check_for_none(root)
                 return root