makes methods private

Author: justin-cechmanek

redisvl/query/aggregate.py

@@ -109,7 +109,7 @@ def __init__(
         self._alpha = alpha
         self._dtype = dtype
         self._num_results = num_results
-        self.set_stopwords(stopwords)
+        self._set_stopwords(stopwords)
 
         query_string = self._build_query_string()
         super().__init__(query_string)
@@ -149,7 +149,7 @@ def stopwords(self) -> Set[str]:
         """
         return self._stopwords.copy() if self._stopwords else set()
 
-    def set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
+    def _set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
         """Set the stopwords to use in the query.
         Args:
             stopwords (Optional[Union[str, Set[str]]]): The stopwords to use. If a string
@@ -164,7 +164,7 @@ def set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
             self._stopwords = set()
         elif isinstance(stopwords, str):
             try:
-                nltk.download("stopwords")
+                nltk.download("stopwords", quiet=True)
                 self._stopwords = set(nltk_stopwords.words(stopwords))
             except Exception as e:
                 raise ValueError(f"Error trying to load {stopwords} from nltk. {e}")
@@ -175,7 +175,7 @@ def set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
         else:
             raise TypeError("stopwords must be a set, list, or tuple of strings")
 
-    def tokenize_and_escape_query(self, user_query: str) -> str:
+    def _tokenize_and_escape_query(self, user_query: str) -> str:
         """Convert a raw user query to a redis full text query joined by ORs
         Args:
             user_query (str): The user query to tokenize and escape.
@@ -185,7 +185,6 @@ def tokenize_and_escape_query(self, user_query: str) -> str:
         Raises:
             ValueError: If the text string becomes empty after stopwords are removed.
         """
-
         escaper = TokenEscaper()
 
         tokens = [
@@ -212,7 +211,7 @@ def _build_query_string(self) -> str:
         # base KNN query
         knn_query = f"KNN {self._num_results} @{self._vector_field} ${self.VECTOR_PARAM} AS {self.DISTANCE_ID}"
 
-        text = f"(~@{self._text_field}:({self.tokenize_and_escape_query(self._text)})"
+        text = f"(~@{self._text_field}:({self._tokenize_and_escape_query(self._text)})"
 
         if filter_expression and filter_expression != "*":
             text += f" AND {filter_expression}"

redisvl/query/query.py

@@ -1,6 +1,8 @@
 from enum import Enum
 from typing import Any, Dict, List, Optional, Set, Tuple, Union
 
+import nltk
+from nltk.corpus import stopwords as nltk_stopwords
 from redis.commands.search.query import Query as RedisQuery
 
 from redisvl.query.filter import FilterExpression
@@ -741,22 +743,21 @@ def __init__(
         """
         self._text = text
         self._text_field = text_field_name
-        self._text_scorer = text_scorer
         self._num_results = num_results
 
-        self.set_stopwords(stopwords)
+        self._set_stopwords(stopwords)
         self.set_filter(filter_expression)
 
         if params:
             self._params = params
 
-        self._num_results = num_results
-
         # initialize the base query with the full query string and filter expression
         query_string = self._build_query_string()
         super().__init__(query_string)
 
-        # Handle query settings
+        # handle query settings
+        self.scorer(text_scorer)
+
         if return_fields:
             self.return_fields(*return_fields)
         self.paging(0, self._num_results).dialect(dialect)
@@ -774,15 +775,12 @@ def __init__(
     def stopwords(self):
         return self._stopwords
 
-    def set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
+    def _set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
         if not stopwords:
             self._stopwords = set()
         elif isinstance(stopwords, str):
             try:
-                import nltk
-                from nltk.corpus import stopwords as nltk_stopwords
-
-                nltk.download("stopwords")
+                nltk.download("stopwords", quiet=True)
                 self._stopwords = set(nltk_stopwords.words(stopwords))
             except Exception as e:
                 raise ValueError(f"Error trying to load {stopwords} from nltk. {e}")
@@ -793,9 +791,16 @@ def set_stopwords(self, stopwords: Optional[Union[str, Set[str]]] = "english"):
         else:
             raise TypeError("stopwords must be a set, list, or tuple of strings")
 
-    def tokenize_and_escape_query(self, user_query: str) -> str:
-        """Convert a raw user query to a redis full text query joined by ORs"""
+    def _tokenize_and_escape_query(self, user_query: str) -> str:
+        """Convert a raw user query to a redis full text query joined by ORs
+        Args:
+            user_query (str): The user query to tokenize and escape.
 
+        Returns:
+            str: The tokenized and escaped query string.
+        Raises:
+            ValueError: If the text string becomes empty after stopwords are removed.
+        """
         escaper = TokenEscaper()
 
         tokens = [
@@ -816,7 +821,7 @@ def _build_query_string(self) -> str:
         else:
             filter_expression = ""
 
-        text = f"@{self._text_field}:({self.tokenize_and_escape_query(self._text)})"
+        text = f"@{self._text_field}:({self._tokenize_and_escape_query(self._text)})"
         if filter_expression and filter_expression != "*":
             text += f" AND {filter_expression}"
         return text

tests/unit/test_query_types.py

@@ -203,14 +203,9 @@ def test_text_query():
     assert text_query._return_fields == return_fields
     assert text_query._num_results == 10
 
-    assert (
-        text_query._build_query_string()
-        == f"@{text_field_name}:({text_query.tokenize_and_escape_query(text_string)})"
-    )
     assert isinstance(text_query, Query)
     assert isinstance(text_query.query, Query)
     assert isinstance(text_query.params, dict)
-    assert text_query._text_scorer == "BM25STD"
     assert text_query.params == {}
     assert text_query._dialect == 2
     assert text_query._in_order == False
@@ -250,17 +245,9 @@ def test_text_query():
     # Test stopwords are configurable
     text_query = TextQuery(text_string, text_field_name, stopwords=None)
     assert text_query.stopwords == set([])
-    assert (
-        text_query._build_query_string()
-        == f"@{text_field_name}:({text_query.tokenize_and_escape_query(text_string)})"
-    )
 
     text_query = TextQuery(text_string, text_field_name, stopwords=["the", "a", "of"])
     assert text_query.stopwords == set(["the", "a", "of"])
-    assert (
-        text_query._build_query_string()
-        == f"@{text_field_name}:({text_query.tokenize_and_escape_query(text_string)})"
-    )
 
     text_query = TextQuery(text_string, text_field_name, stopwords="german")
     assert text_query.stopwords != set([])
@@ -273,21 +260,13 @@ def test_text_query():
 
     text_query = TextQuery(text_string, text_field_name, stopwords=["the", "a", "of"])
     assert text_query.stopwords == set(["the", "a", "of"])
-    assert (
-        text_query._build_query_string()
-        == f"@{text_field_name}:({text_query.tokenize_and_escape_query(text_string)})"
-    )
 
     text_query = TextQuery(text_string, text_field_name, stopwords="german")
     assert text_query.stopwords != set([])
 
     # test that filter expression is set correctly
     text_query.set_filter(filter_expression)
     assert text_query.filter == filter_expression
-    assert (
-        text_query._build_query_string()
-        == f"@{text_field_name}:({text_query.tokenize_and_escape_query(text_string)}) AND {filter_expression}"
-    )
 
     with pytest.raises(ValueError):
         text_query = TextQuery(text_string, text_field_name, stopwords="gibberish")