address linter messages

Author: Gerit Wagner

search_query/generic/serializer.py

@@ -15,7 +15,7 @@ def to_string_generic(query: Query) -> str:
 
     result = ""
     query_content = query.value
-    if hasattr(query, "distance") and query.distance:
+    if hasattr(query, "distance"):  # and isinstance(query.distance, int):
         query_content += f"/{query.distance}"
     if query.search_field:
         query_content += f"[{query.search_field}]"

search_query/pubmed/linter.py

@@ -228,24 +228,29 @@ def _print_unequal_precedence_warning(self, index: int) -> None:
         for idx, op in enumerate(precedence_list):
             if idx == 0:
                 precedence_lines.append(
-                    f"Operator {Colors.GREEN}{op}{Colors.END} at position {idx + 1} is evaluated first "
+                    f"Operator {Colors.GREEN}{op}{Colors.END} "
+                    f"at position {idx + 1} is evaluated first "
                     f"because it is the leftmost operator."
                 )
             elif idx == len(precedence_list) - 1:
                 precedence_lines.append(
-                    f"Operator {Colors.ORANGE}{op}{Colors.END} at position {idx + 1} is evaluated last "
+                    f"Operator {Colors.ORANGE}{op}{Colors.END} "
+                    f"at position {idx + 1} is evaluated last "
                     f"because it is the rightmost operator."
                 )
             else:
                 precedence_lines.append(
-                    f"Operator {Colors.ORANGE}{op}{Colors.END} at position {idx + 1} is evaluated next."
+                    f"Operator {Colors.ORANGE}{op}{Colors.END} "
+                    f"at position {idx + 1} is evaluated next."
                 )
 
         precedence_info = "\n".join(precedence_lines)
 
         details = (
-            "The query uses multiple operators, but without parentheses to make the intended logic explicit. "
-            "PubMed evaluates queries strictly from left to right without applying traditional operator precedence. "
+            "The query uses multiple operators, but without parentheses "
+            "to make the intended logic explicit. "
+            "PubMed evaluates queries strictly from left to right "
+            "without applying traditional operator precedence. "
             "This can lead to unexpected interpretations of the query.\n\n"
             "Specifically:\n"
             f"{precedence_info}\n\n"
@@ -410,7 +415,10 @@ def check_invalid_proximity_operator(self) -> None:
                 search_phrase_token.value[0] == '"'
                 and search_phrase_token.value[-1] == '"'
             ):
-                details = "Proximity search requires 2 or more search terms enclosed in double quotes."
+                details = (
+                    "Proximity search requires 2 or "
+                    "more search terms enclosed in double quotes."
+                )
                 self.add_linter_message(
                     QueryErrorCode.INVALID_PROXIMITY_USE,
                     positions=[self.tokens[index - 1].position],

search_query/pubmed/parser.py

@@ -208,9 +208,9 @@ def _parse_search_term(self, tokens: list) -> Query:
         if len(tokens) > 1 and tokens[1].type == TokenTypes.FIELD:
             if ":~" in tokens[1].value:
                 # Parse NEAR query
-                field_value, prox_value = self.PROXIMITY_REGEX.match(
+                field_value, distance = self.PROXIMITY_REGEX.match(
                     tokens[1].value
-                ).groups()
+                ).groups()  # type: ignore
                 field_value = "[" + field_value + "]"
                 return NEARQuery(
                     value=Operators.NEAR,
@@ -226,7 +226,9 @@ def _parse_search_term(self, tokens: list) -> Query:
                         )
                     ],
                     position=(tokens[0].position[0], tokens[1].position[1]),
-                    distance=prox_value,
+                    # TODO : pass int (ensuring valid NEAR distances)
+                    # or string (preventing errors during parsing)?
+                    distance=distance,  # type: ignore
                     platform="deactivated",
                 )
 

search_query/pubmed/serializer.py

@@ -20,13 +20,16 @@ def to_string_pubmed(query: Query) -> str:
     if query.value == Operators.NEAR:
         # Serialize near query
         distance = query.distance if hasattr(query, "distance") else 0
+        assert query.children[0].search_field
         return (
             f"{query.children[0].value}"
             f"{query.children[0].search_field.value[:-1]}"
             f":~{distance}]"
         )
     if query.value == Operators.RANGE:
         # Serialize range query
+        assert query.children[0].search_field
+        assert query.children[1]
         return (
             f"{query.children[0].value}:{query.children[1].value}"
             f"{query.children[0].search_field.value}"

search_query/pubmed/translator.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 """Pubmed query translator."""
+import typing
 from collections import defaultdict
 from itertools import permutations
 
@@ -119,6 +120,7 @@ def _combine_tiab(cls, query: "Query") -> None:
         for child in query.children:
             cls._combine_tiab(child)
 
+    # pylint: disable=too-many-locals, too-many-branches
     @classmethod
     def _collapse_near_queries(cls, query: Query) -> Query:
         """Recursively collapse NEAR queries in the query tree."""
@@ -132,11 +134,12 @@ def _collapse_near_queries(cls, query: Query) -> Query:
             query.children.pop()
             return query
 
-        elif query.value == Operators.OR:
+        if query.value == Operators.OR:
             # Extract NEAR queries
-            near_queries = []
-            other_queries = []
+            near_queries: typing.List[Query] = []
+            other_queries: typing.List[Query] = []
             for child in query.children:
+                # pylint: disable=unidiomatic-typecheck
                 (near_queries if type(child) is NEARQuery else other_queries).append(
                     child
                 )
@@ -152,11 +155,13 @@ def _collapse_near_queries(cls, query: Query) -> Query:
 
             combined_near_queries = []
             for distance, queries in grouped_queries.items():
-                # For each group, extract term pairs from NEAR queries and map them to corresponding fields
+                # For each group, extract term pairs from NEAR queries and
+                # map them to corresponding fields
                 term_field_map = defaultdict(set)
                 for q in queries:
                     term_a = q.children[0].value
                     term_b = q.children[1].value
+                    assert q.children[0].search_field
                     term_field_map[(min(term_a, term_b), max(term_a, term_b))].add(
                         q.children[0].search_field.value
                     )
@@ -175,7 +180,7 @@ def _collapse_near_queries(cls, query: Query) -> Query:
                                 children=[
                                     Term(
                                         value=f'"{term_a} {term_b}"',
-                                        search_field=field,
+                                        search_field=SearchField(value=field),
                                         platform="deactivated",
                                     )
                                 ],
@@ -210,6 +215,7 @@ def translate_search_fields_to_generic(cls, query: Query) -> Query:
         if query.children:
             if query.value == Operators.NEAR:
                 # Expand NEAR queries
+                assert query.children[0].search_field
                 search_field_set = syntax_str_to_generic_search_field_set(
                     query.children[0].search_field.value
                 )
@@ -254,22 +260,25 @@ def _expand_combined_fields(cls, query: Query, search_fields: set) -> Query:
                 )
             )
         return OrQuery(
-            children=query_children,
+            children=query_children,  # type: ignore
             search_field=None,
         )
 
     @classmethod
     def _expand_near_query(cls, query: Query, search_fields: set) -> Query:
         """Expand NEAR query into an OR query"""
-        if type(query) is not NEARQuery:
+        if type(query) is not NEARQuery:  # pylint: disable=unidiomatic-typecheck
             return query
+        distance = 0
+        if hasattr(query, "distance"):
+            distance = int(query.distance)  # type: ignore
 
-        distance = query.distance if hasattr(query, "distance") else 0
         query_children = []
         search_terms = query.children[0].value.strip('"').split()
         # Handle [tiab] by generating NEAR queries for both 'title' and 'abstract'
         for search_field in sorted(list(search_fields)):
-            # Get all possible ordered pairs of search terms in the proximity search phrase
+            # Get all possible ordered pairs of search terms
+            # in the proximity search phrase
             pairs = list(permutations(search_terms, 2))
             for pair in pairs:
                 # Create binary near query for each pair
@@ -290,7 +299,7 @@ def _expand_near_query(cls, query: Query, search_fields: set) -> Query:
                     )
                 )
         return OrQuery(
-            children=query_children,
+            children=query_children,  # type: ignore
             search_field=None,
         )
 

search_query/query.py

@@ -31,7 +31,7 @@ def __init__(
         position: typing.Optional[typing.Tuple[int, int]] = None,
         platform: str = "generic",
     ) -> None:
-        if type(self) is Query:
+        if type(self) is Query:  # pylint: disable=unidiomatic-typecheck
             raise TypeError(
                 "The base Query type cannot be instantiated directly. "
                 "Use Query.create() or the appropriate query subclass."
@@ -80,6 +80,7 @@ def create(
     ) -> Query:
         """Factory method for query creation."""
         if not operator:
+            # pylint: disable=import-outside-toplevel
             from search_query.query_term import Term
 
             return Term(
@@ -96,33 +97,33 @@ def create(
             "platform": platform,
         }
 
+        # pylint: disable=import-outside-toplevel
         if value == Operators.AND:
             from search_query.query_and import AndQuery
 
-            return AndQuery(**args)
+            return AndQuery(**args)  # type: ignore
 
-        elif value == Operators.OR:
+        if value == Operators.OR:
             from search_query.query_or import OrQuery
 
-            return OrQuery(**args)
+            return OrQuery(**args)  # type: ignore
 
-        elif value == Operators.NOT:
+        if value == Operators.NOT:
             from search_query.query_not import NotQuery
 
-            return NotQuery(**args)
+            return NotQuery(**args)  # type: ignore
 
-        elif value in {Operators.NEAR, Operators.WITHIN}:
+        if value in {Operators.NEAR, Operators.WITHIN}:
             from search_query.query_near import NEARQuery
 
-            return NEARQuery(value=value, distance=distance, **args)
+            return NEARQuery(value=value, distance=distance, **args)  # type: ignore
 
-        elif value == Operators.RANGE:
+        if value == Operators.RANGE:
             from search_query.query_range import RangeQuery
 
-            return RangeQuery(**args)
+            return RangeQuery(**args)  # type: ignore
 
-        else:
-            raise ValueError(f"Invalid operator value: {value}")
+        raise ValueError(f"Invalid operator value: {value}")
 
     def _validate_platform_constraints(self) -> None:
         if self.platform == "deactivated":
@@ -319,14 +320,17 @@ def search_field(self, sf: typing.Optional[SearchField]) -> None:
         """Set search field property."""
         self._search_field = copy.deepcopy(sf) if sf else None
 
-    def replace(self, new_query) -> None:
-        if self.get_parent():
-            for index, child in enumerate(self.get_parent().children):
+    def replace(self, new_query: Query) -> None:
+        """Replace this query with a new query in the parent's children list."""
+        parent = self.get_parent()
+        if parent:
+            children = parent.children
+            assert children
+            for index, child in enumerate(children):
                 if child is self:
-                    self.get_parent().children[index] = new_query
+                    children[index] = new_query
                     return
-        else:
-            raise RuntimeError("Root node of a query cannot be replaced")
+        raise RuntimeError("Root node of a query cannot be replaced")
 
     def selects(self, *, record_dict: dict) -> bool:
         """Indicates whether the query selects a given record."""

search_query/query_near.py

@@ -50,6 +50,9 @@ def __init__(
             platform=platform,
         )
         self.children = query_children
+        # assert isinstance(distance, int) and distance >= 0, (
+        #     "distance must be a non-negative integer"
+        # )
         self.distance: int = distance
 
     @property

search_query/query_not.py

@@ -49,7 +49,7 @@ def __init__(
             platform=platform,
         )
 
-        self.children = query_children
+        self.children = query_children  # type: ignore
 
     @property
     def children(self) -> typing.List[Query]:

search_query/serializer_structured.py

@@ -36,7 +36,7 @@ def to_string_structured(query: Query, *, level: int = 0) -> str:
         search_field = f"[{query.search_field}]"
 
     query_value = query.value
-    if hasattr(query, "distance") and query.distance:
+    if hasattr(query, "distance"):  # and isinstance(query.distance, int):
         query_value += f"/{query.distance}"
     result = _reindent(f"{query_value} {search_field}", level)
 

search_query/wos/translator.py

@@ -53,7 +53,7 @@ def _expand_combined_fields(cls, query: Query, search_fields: set) -> None:
 
         query.replace(
             OrQuery(
-                children=query_children,
+                children=query_children,  # type: ignore
             )
         )