refactor (private methods)

Author: Gerit Wagner

docs/source/dev_docs/_autosummary/search_query.utils.rst

@@ -13,5 +13,4 @@ search\_query.utils
 
    .. autosummary::
 
-      format_query_string_pos
       format_query_string_positions

search_query/constants.py

@@ -63,6 +63,16 @@ def is_operator(self) -> bool:
         """Check if token is an operator"""
         return self.type in (TokenTypes.LOGIC_OPERATOR, TokenTypes.PROXIMITY_OPERATOR)
 
+    def get_operator_type(self) -> str:
+        """Get operator type"""
+        if self.value.upper() in {"&", "AND"}:
+            return Operators.AND
+        if self.value.upper() in {"|", "OR"}:
+            return Operators.OR
+        if self.value.upper() == "NOT":
+            return Operators.NOT
+        raise ValueError()
+
 
 @dataclass
 class ListToken:

search_query/pubmed/parser.py

@@ -96,42 +96,32 @@ def tokenize(self) -> None:
 
         self.combine_subsequent_terms()
 
-    def get_operator_type(self, operator: str) -> str:
-        """Get operator type"""
-        if operator.upper() in {"&", "AND"}:
-            return Operators.AND
-        if operator.upper() in {"|", "OR"}:
-            return Operators.OR
-        if operator.upper() == "NOT":
-            return Operators.NOT
-        raise ValueError()
-
     def parse_query_tree(self, tokens: list) -> Query:
         """Parse a query from a list of tokens"""
 
-        if self.is_compound_query(tokens):
+        if self._is_compound_query(tokens):
             query = self._parse_compound_query(tokens)
 
-        elif self.is_nested_query(tokens):
+        elif self._is_nested_query(tokens):
             query = self._parse_nested_query(tokens)
 
-        elif self.is_term_query(tokens):
+        elif self._is_term_query(tokens):
             query = self._parse_search_term(tokens)
 
         else:
             raise ValueError()
 
         return query
 
-    def is_term_query(self, tokens: list) -> bool:
+    def _is_term_query(self, tokens: list) -> bool:
         """Check if the query is a search term"""
         return tokens[0].type == TokenTypes.SEARCH_TERM and len(tokens) <= 2
 
-    def is_compound_query(self, tokens: list) -> bool:
+    def _is_compound_query(self, tokens: list) -> bool:
         """Check if the query is a compound query"""
         return bool(self._get_operator_indices(tokens))
 
-    def is_nested_query(self, tokens: list) -> bool:
+    def _is_nested_query(self, tokens: list) -> bool:
         """Check if the query is nested in parentheses"""
         return (
             tokens[0].type == TokenTypes.PARENTHESIS_OPEN
@@ -157,7 +147,7 @@ def _get_operator_indices(self, tokens: list) -> list:
                 i = i - 1
 
             if i == 0 and token.type == TokenTypes.LOGIC_OPERATOR:
-                operator = self.get_operator_type(token.value)
+                operator = token.get_operator_type()
                 if not first_operator_found:
                     first_operator = operator
                     first_operator_found = True
@@ -252,7 +242,7 @@ def _parse_search_term(self, tokens: list) -> Query:
 
     #     return field_values_list
 
-    def get_query_leaves(self, query: Query) -> list:
+    def _get_query_leaves(self, query: Query) -> list:
         """Retrieve all leaf nodes from a query,
         representing search terms and fields,
         and return them as a list"""
@@ -261,7 +251,7 @@ def get_query_leaves(self, query: Query) -> list:
 
         leaves = []
         for child in query.children:
-            leaves += self.get_query_leaves(child)
+            leaves += self._get_query_leaves(child)
         return leaves
 
     def parse(self) -> Query:
@@ -336,7 +326,7 @@ def get_operator_node_tokens(self, token_nr: int) -> list:
             )
         return operator_node_tokens
 
-    def parse_operator_node(self, token_nr: int) -> Query:
+    def _parse_operator_node(self, token_nr: int) -> Query:
         """Parse an operator node."""
 
         operator_node_tokens = self.get_operator_node_tokens(token_nr)
@@ -383,7 +373,7 @@ def parse(self) -> Query:
                 self.linter.messages[token_nr] = parser.linter.messages
 
             if query_element["type"] == ListTokenTypes.OPERATOR_NODE:
-                query_element["query"] = self.parse_operator_node(
+                query_element["query"] = self._parse_operator_node(
                     token_nr
                     # query_element["node_content"]
                 )

search_query/wos/parser.py

@@ -102,7 +102,7 @@ def tokenize(self) -> None:
             self.tokens.append(Token(value=value, type=token_type, position=position))
 
         self.combine_subsequent_terms()
-        self.add_unbalanced_quotes_to_adjacent_term()
+        self._add_unbalanced_quotes_to_adjacent_term()
 
     # Parse a query tree from tokens recursively
     # pylint: disable=too-many-branches
@@ -141,7 +141,7 @@ def parse_query_tree(
             # Handle closing parentheses
             elif token.type == TokenTypes.PARENTHESIS_CLOSED:
                 return (
-                    self.handle_closing_parenthesis(
+                    self._handle_closing_parenthesis(
                         children=children,
                         current_operator=current_operator,
                         search_field=search_field,
@@ -151,16 +151,12 @@ def parse_query_tree(
 
             # Handle operators
             elif token.type == TokenTypes.LOGIC_OPERATOR:
-                # Handle the operator
-                # and update all changes within the handler
-                (
-                    current_operator,
-                    current_negation,
-                ) = self.handle_operator(
-                    token=token,
-                    current_operator=current_operator,
-                    current_negation=current_negation,
-                )
+                current_operator = token.value.upper()
+
+                # Set a flag if the token is NOT and change to AND
+                if current_operator == "NOT":
+                    current_negation = True
+                    current_operator = "AND"
 
             # Handle search fields
             elif token.type == TokenTypes.FIELD:
@@ -169,7 +165,7 @@ def parse_query_tree(
             # Handle terms
             else:
                 # Add term nodes
-                children = self.add_term_node(
+                children = self._add_term_node(
                     index=index,
                     value=token.value,
                     search_field=search_field,
@@ -207,7 +203,7 @@ def parse_query_tree(
         # Raise an error if the code gets here
         raise NotImplementedError("Error in parsing the query tree")
 
-    def handle_closing_parenthesis(
+    def _handle_closing_parenthesis(
         self,
         children: list,
         current_operator: str,
@@ -235,24 +231,6 @@ def handle_closing_parenthesis(
             + str(children)
         )
 
-    def handle_operator(
-        self,
-        token: Token,
-        current_operator: str,
-        current_negation: bool,
-    ) -> typing.Tuple[str, bool]:
-        """Handle operators."""
-
-        # Set the current operator to the token
-        current_operator = token.value.upper()
-
-        # Set a flag if the token is NOT and change to AND
-        if current_operator == "NOT":
-            current_negation = True
-            current_operator = "AND"
-
-        return current_operator, current_negation
-
     def combine_subsequent_terms(self) -> None:
         """Combine subsequent terms in the list of tokens."""
         # Combine subsequent terms (without quotes)
@@ -304,7 +282,7 @@ def combine_subsequent_terms(self) -> None:
 
         self.tokens = combined_tokens
 
-    def add_unbalanced_quotes_to_adjacent_term(self) -> None:
+    def _add_unbalanced_quotes_to_adjacent_term(self) -> None:
         """Add unbalanced quotes to adjacent terms."""
 
         s = self.query_str
@@ -337,7 +315,7 @@ def add_unbalanced_quotes_to_adjacent_term(self) -> None:
         self.tokens = updated_tokens
 
     # pylint: disable=too-many-arguments
-    def add_term_node(
+    def _add_term_node(
         self,
         *,
         index: int,

test/test_wos_parser_internals.py

@@ -25,7 +25,7 @@ def test_handle_closing_parenthesis_single_child() -> None:
     """
     children = [Query(value="example", operator=False, platform=PLATFORM.WOS.value)]
     parser = WOSParser(query_str="", search_field_general="", mode="")
-    result = parser.handle_closing_parenthesis(children, current_operator="")
+    result = parser._handle_closing_parenthesis(children, current_operator="")
 
     assert result == children[0]
 
@@ -43,7 +43,7 @@ def test_handle_closing_parenthesis_with_operator() -> None:
     ]
     current_operator = "AND"
     parser = WOSParser(query_str="", search_field_general="", mode="")
-    result = parser.handle_closing_parenthesis(children, current_operator)
+    result = parser._handle_closing_parenthesis(children, current_operator)
 
     expected_result = Query(
         value=current_operator, operator=True, children=list(children)
@@ -54,66 +54,6 @@ def test_handle_closing_parenthesis_with_operator() -> None:
     assert result.children == expected_result.children
 
 
-def test_handle_operator_uppercase() -> None:
-    """
-    Test the `handle_operator` method with an uppercase operator.
-
-    This test verifies that the `handle_operator` method correctly handles
-    an uppercase operator and returns the expected values.
-    """
-    token = Token(value="AND", type=TokenTypes.LOGIC_OPERATOR, position=(0, 3))
-    current_operator = ""
-    current_negation = False
-
-    parser = WOSParser(query_str="", search_field_general="", mode="")
-    result_operator, result_negation = parser.handle_operator(
-        token, current_operator, current_negation
-    )
-
-    assert result_operator == "AND"
-    assert result_negation is False
-
-
-def test_handle_operator_near_with_distance() -> None:
-    """
-    Test the `handle_operator` method with a NEAR operator with distance.
-
-    This test verifies that the `handle_operator` method correctly handles
-    a NEAR operator with a given distance and returns the expected values.
-    """
-    token = Token(value="NEAR/2", type=TokenTypes.PROXIMITY_OPERATOR, position=(0, 6))
-    current_operator = ""
-    current_negation = False
-
-    parser = WOSParser(query_str="", search_field_general="", mode="")
-    result_operator, result_negation = parser.handle_operator(
-        token, current_operator, current_negation
-    )
-
-    assert result_operator == "NEAR/2"
-    assert result_negation is False
-
-
-def test_handle_operator_not() -> None:
-    """
-    Test the `handle_operator` method with the NOT operator.
-
-    This test verifies that the `handle_operator` method correctly handles
-    the NOT operator, sets the negation flag, and changes the operator to AND.
-    """
-    token = Token(value="NOT", type=TokenTypes.LOGIC_OPERATOR, position=(0, 3))
-    current_operator = ""
-    current_negation = False
-
-    parser = WOSParser(query_str="", search_field_general="", mode="")
-    result_operator, result_negation = parser.handle_operator(
-        token, current_operator, current_negation
-    )
-
-    assert result_operator == "AND"
-    assert result_negation is True
-
-
 def test_combine_subsequent_terms_single_term() -> None:
     """
     Test the `combine_subsequent_terms` method with a single term.
@@ -239,7 +179,7 @@ def test_add_term_node_without_current_operator() -> None:
     current_operator = ""
     children: typing.List[Query] = []
 
-    result = parser.add_term_node(
+    result = parser._add_term_node(
         index=index,
         value=value,
         search_field=search_field,
@@ -280,7 +220,7 @@ def test_add_term_node_with_current_operator() -> None:
     current_operator = "AND"
     children: typing.List[Query] = []
 
-    result = parser.add_term_node(
+    result = parser._add_term_node(
         index=index,
         value=value,
         search_field=search_field,
@@ -359,7 +299,7 @@ def test_add_term_node_with_near_operator() -> None:
         )
     ]
 
-    result = parser.add_term_node(
+    result = parser._add_term_node(
         index=index,
         value=value,
         search_field=search_field,
@@ -460,7 +400,7 @@ def test_add_term_node_with_existing_children() -> None:
         )
     ]
 
-    result = parser.add_term_node(
+    result = parser._add_term_node(
         index=index,
         value=value,
         search_field=search_field,
@@ -513,7 +453,7 @@ def test_add_term_node_with_current_negation() -> None:
     children: typing.List[Query] = []
     current_negation = True
 
-    result = parser.add_term_node(
+    result = parser._add_term_node(
         index=index,
         value=value,
         search_field=search_field,