velocity-python 0.1.120__tar.gz → 0.1.121__tar.gz

{velocity_python-0.1.120 → velocity_python-0.1.121}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.120
+Version: 0.1.121
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.120 → velocity_python-0.1.121}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.120"
+version = "0.1.121"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.120 → velocity_python-0.1.121}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.120"
+__version__ = version = "0.1.121"
 
 import importlib as _importlib
 

{velocity_python-0.1.120 → velocity_python-0.1.121}/src/velocity/aws/facets.py

@@ -35,10 +35,13 @@ Facets AND together; the values of one facet OR together. Kinds:
               3660 days), ``year`` (this calendar year). Evaluated in the
               database's session time zone.
 ``text``      a write-in, case-insensitive, against ``field::text``:
-              ``match`` is ``contains`` (default), ``equals`` or ``starts``.
+              ``match`` is ``contains`` (default), ``equals``, ``starts`` or
+              ``words`` — every whitespace-separated word of the term must
+              appear, in any order ("school rock" finds "School of Rock").
               The user's ``%`` and ``_`` are literal. With ``fields`` (a list
               of columns) the term is matched against each, OR'd — one box
-              that searches subject *or* snippet.
+              that searches subject *or* snippet; for ``words`` each word may
+              be in either column.
 ``domain``    a domain and every subdomain of it: each value (``example.com``)
               matches ``field`` equal to it or ending in ``.example.com``,
               case-insensitively; values OR together. "This top-level
@@ -70,7 +73,7 @@ from velocity.db.servers.tablehelper import TableHelper
 PARAM_KEY = "facets"
 
 KINDS = ("values", "contains", "presence", "since", "text", "domain")
-MATCHES = ("contains", "equals", "starts")
+MATCHES = ("contains", "equals", "starts", "words")
 PRESENCE = ("present", "absent")
 
 MAX_FACETS = 40
@@ -224,17 +227,35 @@ def _kind_text(column: str, entry: Dict[str, Any], field: str) -> Optional[Predi
     match = str(entry.get("match") or "contains").lower()
     if match not in MATCHES:
         raise FacetError(f"facet {field}: match must be one of {MATCHES}")
+    columns = _columns(entry, column, field)
+
+    def like_any(pattern: str) -> Predicate:
+        if len(columns) == 1:
+            return f"{columns[0]}::text ILIKE %s", (pattern,)
+        parts = " OR ".join(f"{name}::text ILIKE %s" for name in columns)
+        return f"({parts})", tuple(pattern for _ in columns)
+
+    if match == "words":
+        words: List[str] = []
+        for word in value.split():
+            if word not in words:
+                words.append(word)
+        built = []
+        for word in words:
+            escaped_word = _LIKE_SPECIAL.sub(r"\\\1", word)
+            built.append(like_any(f"%{escaped_word}%"))
+        if len(built) == 1:
+            return built[0]
+        sql = " AND ".join(part for part, _ in built)
+        return f"({sql})", tuple(p for _, params in built for p in params)
+
     escaped = _LIKE_SPECIAL.sub(r"\\\1", value)
     pattern = {
         "contains": f"%{escaped}%",
         "starts": f"{escaped}%",
         "equals": escaped,
     }[match]
-    columns = _columns(entry, column, field)
-    if len(columns) == 1:
-        return f"{columns[0]}::text ILIKE %s", (pattern,)
-    parts = " OR ".join(f"{name}::text ILIKE %s" for name in columns)
-    return f"({parts})", tuple(pattern for _ in columns)
+    return like_any(pattern)
 
 
 def _kind_domain(column: str, entry: Dict[str, Any], field: str) -> Optional[Predicate]:

{velocity_python-0.1.120 → velocity_python-0.1.121}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.120
+Version: 0.1.121
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.120 → velocity_python-0.1.121}/tests/test_facets.py

@@ -81,6 +81,39 @@ def test_text_matches_are_case_insensitive_and_escape_like_wildcards():
         facets.predicate({"field": "x", "kind": "text", "value": "a", "match": "regex"})
 
 
+def test_words_match_requires_every_word_in_any_order():
+    assert facets.predicate(
+        {"field": "subject", "kind": "text", "value": "school rock", "match": "words"}
+    ) == (
+        "(subject::text ILIKE %s AND subject::text ILIKE %s)",
+        ("%school%", "%rock%"),
+    )
+    # one word is the plain contains form; repeats and extra whitespace collapse
+    assert facets.predicate(
+        {"field": "subject", "kind": "text", "value": "  rock  rock ", "match": "words"}
+    ) == ("subject::text ILIKE %s", ("%rock%",))
+    # over several columns each word may sit in either one
+    sql, params = facets.predicate(
+        {
+            "field": "subject",
+            "kind": "text",
+            "value": "school rock",
+            "match": "words",
+            "fields": ["subject", "snippet"],
+        }
+    )
+    assert sql == (
+        "((subject::text ILIKE %s OR snippet::text ILIKE %s) AND "
+        "(subject::text ILIKE %s OR snippet::text ILIKE %s))"
+    )
+    assert params == ("%school%", "%school%", "%rock%", "%rock%")
+    # the user's wildcards stay literal per word
+    _sql, params = facets.predicate(
+        {"field": "s", "kind": "text", "value": "50%_off now", "match": "words"}
+    )
+    assert params == ("%50\\%\\_off%", "%now%")
+
+
 def test_text_over_several_fields_ors_one_term_across_them():
     sql, params = facets.predicate(
         {