infinity-sdk 0.7.3__tar.gz → 0.7.4__tar.gz

{infinity_sdk-0.7.3/python/infinity_sdk/infinity_sdk.egg-info → infinity_sdk-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infinity-sdk
-Version: 0.7.3
+Version: 0.7.4
 Summary: infinity
 License-Expression: Apache-2.0
 Requires-Python: <3.14,>=3.11
@@ -97,7 +97,7 @@ Infinity supports two working modes, embedded mode and client-server mode. The f
 
 2. Install the `infinity-sdk` package:
    ```bash
-   pip install infinity-sdk==0.7.3
+   pip install infinity-sdk==0.7.4
    ```
 
 3. Use Infinity to conduct a dense vector search:

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/README.md

@@ -96,7 +96,7 @@ If you are on Windows 10+, you must enable WSL or WSL2 to deploy Infinity using
 ### Install Infinity client
 
 ```
-pip install infinity-sdk==0.7.3
+pip install infinity-sdk==0.7.4
 ```
 
 ### Run a vector search

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-sdk"
-version = "0.7.3"
+version = "0.7.4"
 description = "infinity"
 readme = "python/infinity_sdk/README.md"
 license = "Apache-2.0"

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/README.md

@@ -63,7 +63,7 @@ Infinity supports two working modes, embedded mode and client-server mode. The f
 
 2. Install the `infinity-sdk` package:
    ```bash
-   pip install infinity-sdk==0.7.3
+   pip install infinity-sdk==0.7.4
    ```
 
 3. Use Infinity to conduct a dense vector search:

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/__init__.py

@@ -28,6 +28,7 @@ from infinity.common import (
     NetworkAddress,
 )
 from infinity.errors import ErrorCode
+from infinity.filter_utils import quote_string_literal, regex_filter
 from infinity.infinity import InfinityConnection
 from infinity.remote_thrift.infinity import RemoteThriftInfinityConnection
 
@@ -40,7 +41,9 @@ __all__ = [
     "InfinityException",
     "NetworkAddress",
     "RemoteThriftInfinityConnection",
-    "connect"
+    "connect",
+    "quote_string_literal",
+    "regex_filter"
 ]
 
 

infinity_sdk-0.7.4/python/infinity_sdk/infinity/filter_utils.py

@@ -0,0 +1,50 @@
+# Copyright(C) 2026 InfiniFlow, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helpers that build filter expressions."""
+
+from __future__ import annotations
+
+__all__ = ["quote_string_literal", "regex_filter"]
+
+
+def quote_string_literal(value: str) -> str:
+    """Quote a value as a string literal for a filter expression.
+
+    A backslash is passed through unchanged, which is what a regular expression
+    needs, so only the quote itself has to be doubled.
+    """
+    if not isinstance(value, str):
+        raise TypeError(f"Expected a string, but got {type(value).__name__}")
+    return "'" + value.replace("'", "''") + "'"
+
+
+def regex_filter(column: str, pattern: str) -> str:
+    """Build a ``regex(column, pattern)`` filter.
+
+    The pattern is evaluated by RE2 on the rows the filter is applied to. When
+    ``column`` has a full-text index built with a sparse gram analyzer
+    (``sparsegram-3-12``, optionally ``-fold``), the server additionally
+    narrows those rows with the literals the pattern proves mandatory before
+    the regular expression runs, so the regular expression only sees
+    candidates. The narrowing never removes a row the pattern would have
+    matched, and a column without such an index keeps a plain scan.
+
+    Example::
+
+        table.filter(regex_filter("doc", r"colou?r of the (sky|sea)"))
+    """
+    if not isinstance(column, str) or not column:
+        raise ValueError("column must be a non-empty string")
+    return f"regex({column}, {quote_string_literal(pattern)})"

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/http_utils.py

@@ -66,9 +66,10 @@ functions = [
     "ltrim",
     "rtrim",
     "reverse",
+    "regex",
 ]
 
-bool_functions = ["filter_text", "filter_fulltext", "or", "and", "not"]
+bool_functions = ["filter_text", "filter_fulltext", "or", "and", "not", "regex"]
 
 
 def function_return_type(function_name, param_type):
@@ -79,7 +80,7 @@ def function_return_type(function_name, param_type):
             return param_type
         else:
             return 'Float64'
-    elif function_name in ["filter_text", "filter_fulltext", "or", "and", "not"]:
+    elif function_name in ["filter_text", "filter_fulltext", "or", "and", "not", "regex"]:
         return 'boolean'
     elif function_name == "trunc":
         return 'string'

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/huqie.txt.trie

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: infinity_sdk-0.7.3/python/infinity_sdk/infinity/huqie.txt.trie
+name: infinity_sdk-0.7.4/python/infinity_sdk/infinity/huqie.txt.trie
 size: 54775939 bytes
 sha256: 32ab213044af4aee58c46b4bfa4d2b61ba740ce8c894bb96e80fad00f145bcc4

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/index.py

@@ -75,6 +75,51 @@ class InitParameter:
         return ttypes.InitParameter(self.param_name, self.param_value)
 
 
+SPARSEGRAM_DEFAULT_MIN_GRAM = 3
+SPARSEGRAM_DEFAULT_MAX_GRAM = 12
+
+
+def sparsegram_analyzer(min_gram: int = SPARSEGRAM_DEFAULT_MIN_GRAM,
+                        max_gram: int = SPARSEGRAM_DEFAULT_MAX_GRAM,
+                        fold_case: bool = False) -> str:
+    """Build the analyzer name of a sparse gram full-text index.
+
+    The analyzer emits content-defined n-grams of the whole value instead of
+    tokens, which is what lets ``regex(column, pattern)`` filters use the index:
+    the literals the pattern proves mandatory are turned into gram lookups
+    before the regular expression runs, so the regular expression only verifies
+    candidates. Chinese, Japanese and Korean values additionally get one and two
+    character grams, so a single character or a two character word can narrow as
+    well.
+
+    Args:
+        min_gram: Shortest window considered, in characters. Defaults to 3.
+        max_gram: Longest window considered, in characters. Defaults to 12.
+            Raising it adds rare, high information grams for little index space.
+        fold_case: Emit the ASCII-lowercased form of every gram too. Required for
+            a case insensitive pattern such as ``(?i)nobel prize`` to use the
+            index at all; without it such a pattern falls back to a scan.
+
+    Returns:
+        An analyzer name such as ``"sparsegram-3-12"`` or
+        ``"sparsegram-3-12-fold"``.
+
+    Note:
+        The name is stored in the index definition, so build a new index to
+        change it.
+    """
+    for name, value in (("min_gram", min_gram), ("max_gram", max_gram)):
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise InfinityException(ErrorCode.INVALID_INDEX_PARAM, f"{name} should be an integer, but got {value!r}")
+    if min_gram < 1 or max_gram < min_gram:
+        raise InfinityException(ErrorCode.INVALID_INDEX_PARAM,
+                                f"Expected 1 <= min_gram <= max_gram, but got min_gram={min_gram} and max_gram={max_gram}")
+    if not isinstance(fold_case, bool):
+        raise InfinityException(ErrorCode.INVALID_INDEX_PARAM, f"fold_case should be a boolean, but got {fold_case!r}")
+    name = f"sparsegram-{min_gram}-{max_gram}"
+    return f"{name}-fold" if fold_case else name
+
+
 class IndexInfo:
     def __init__(self, target_name: str, index_type: IndexType, params: dict = None):
         self.target_name = target_name
@@ -87,6 +132,24 @@ class IndexInfo:
         else:
             self.params = None
 
+    @staticmethod
+    def sparsegram(target_name: str,
+                   min_gram: int = SPARSEGRAM_DEFAULT_MIN_GRAM,
+                   max_gram: int = SPARSEGRAM_DEFAULT_MAX_GRAM,
+                   fold_case: bool = False) -> "IndexInfo":
+        """Build a full-text index that makes `regex()` filters use grams.
+
+        Shorthand for ``IndexInfo(target_name, IndexType.FullText,
+        {"analyzer": sparsegram_analyzer(...)})``.
+
+        Example::
+
+            table.create_index("idx", IndexInfo.sparsegram("doc", fold_case=True))
+            table.filter(regex_filter("doc", r"(?i)colou?r of the (sky|sea)"))
+        """
+        return IndexInfo(target_name, IndexType.FullText,
+                         {"analyzer": sparsegram_analyzer(min_gram, max_gram, fold_case)})
+
     def __str__(self):
         return f"IndexInfo({self.target_name}, {self.index_type}, {self.params})"
 

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/infinity_http.py

@@ -794,6 +794,8 @@ class table_http:
                         for idx in range(len(value[key])):
                             if isinstance(value[key][idx], np.ndarray):
                                 value[key][idx] = value[key][idx].tolist()
+                            elif isinstance(value[key][idx], (np.integer, np.floating, np.longdouble)):
+                                value[key][idx] = value[key][idx].item()
                     elif isinstance(value[key], SparseVector):
                         value[key] = value[key].to_dict()
 

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/rag_tokenizer.py

@@ -37,6 +37,7 @@ import math
 import os
 import re
 import string
+import unicodedata
 
 import datrie
 from hanziconv import HanziConv
@@ -65,6 +66,33 @@ _SNOWBALL_LANGUAGE_MAP = {
     "turkish": "turkish",
 }
 
+# Languages tokenized with diacritics folded to ASCII and no stemming.
+# SPLIT_CHAR only keeps ASCII letter runs whole, so accented words would
+# otherwise be fragmented before indexing ('škola' -> 'š kola'), and
+# neither language has a Snowball stemmer.
+_DIACRITIC_FOLDING_LANGUAGES = {"slovak", "czech"}
+
+
+def _fold_char(char: str) -> str:
+    # Latin-1 Supplement and Latin Extended-A letters whose NFD decomposition
+    # is one ASCII letter plus combining marks fold to that letter (Š -> S,
+    # ď -> d); everything else (æ, ø, ł, ß, non-Latin scripts) is kept. Same
+    # rule as RAGAnalyzer::FoldDiacritics in the C++ analyzer.
+    if not (0xC0 <= ord(char) < 0x180):
+        return char
+    decomposed = unicodedata.normalize("NFD", char)
+    base = decomposed[0]
+    if base.isascii() and base.isalpha() and all(unicodedata.combining(c) for c in decomposed[1:]):
+        return base
+    return char
+
+
+def fold_diacritics(text: str) -> str:
+    """Fold Latin diacritics to ASCII: 'škola' -> 'skola'."""
+    if text.isascii():
+        return text
+    return "".join(_fold_char(c) for c in text)
+
 
 class RagTokenizer:
     def key_(self, line):
@@ -122,6 +150,7 @@ class RagTokenizer:
         self.stemmer = SnowballStemmer("english")
         self.lemmatizer = WordNetLemmatizer()
         self._use_lemmatizer = True  # WordNet only supports English
+        self._fold_diacritics = False
 
         self.SPLIT_CHAR = r"([ ,\.<>/?;:'\[\]\\`!@#$%^&*\(\)\{\}\|_+=《》，。？、；‘’：“”【】~！￥%……（）——-]+|[a-zA-Z0-9,\.-]+)"
 
@@ -163,6 +192,14 @@ class RagTokenizer:
                       Case-insensitive.
         """
         lang_key = language.strip().lower()
+
+        self._fold_diacritics = lang_key in _DIACRITIC_FOLDING_LANGUAGES
+        if self._fold_diacritics:
+            # Folded to ASCII in tokenize() and left unstemmed: there is no
+            # Snowball stemmer for these languages (see _normalize_token).
+            logging.debug("Tokenizer language set to '%s' (diacritics folding, no stemming)", language)
+            return
+
         snowball_lang = _SNOWBALL_LANGUAGE_MAP.get(lang_key)
 
         if snowball_lang is not None:
@@ -389,8 +426,11 @@ class RagTokenizer:
 
         When the lemmatizer is enabled (English), applies lemmatization
         before stemming.  For other Snowball-supported languages, only
-        stemming is applied.  Non-alphabetic tokens are returned as-is.
+        stemming is applied.  Non-alphabetic tokens are returned as-is,
+        and so is every token of a diacritic-folding language.
         """
+        if self._fold_diacritics:
+            return t
         if re.match(r"[a-zA-Z_-]+$", t):
             if self._use_lemmatizer:
                 return self.stemmer.stem(self.lemmatizer.lemmatize(t))
@@ -421,6 +461,8 @@ class RagTokenizer:
         return txt_lang_pairs
 
     def tokenize(self, line: str) -> str:
+        if self._fold_diacritics:
+            line = fold_diacritics(line)
         line = re.sub(r"\W+", " ", line)
         line = self._strQ2B(line).lower()
         line = self._tradi2simp(line)

{infinity_sdk-0.7.3 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/remote_thrift/client.py

@@ -165,8 +165,8 @@ class ThriftInfinityClient:
         # version: 0.6.13, client_version: 34
         # version: 0.6.15, client_version: 35
         # version: 0.7.0, 0.7.1, 0.7.2, client_version: 36
-        # version: 0.7.3, client_version: 37
-        res = self.client.Connect(ConnectRequest(client_version=37))  # 0.7.3
+        # version: 0.7.3, 0.7.4, client_version: 37
+        res = self.client.Connect(ConnectRequest(client_version=37))  # 0.7.4
         if res.error_code != 0:
             raise InfinityException(res.error_code, res.error_msg)
         self.session_id = res.session_id