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

{infinity_sdk-0.7.2/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.2
+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.2
+   pip install infinity-sdk==0.7.4
    ```
 
 3. Use Infinity to conduct a dense vector search:

{infinity_sdk-0.7.2 → 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.2
+pip install infinity-sdk==0.7.4
 ```
 
 ### Run a vector search

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

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-sdk"
-version = "0.7.2"
+version = "0.7.4"
 description = "infinity"
 readme = "python/infinity_sdk/README.md"
 license = "Apache-2.0"
@@ -71,6 +71,55 @@ filterwarnings = [
     'ignore:function ham\(\) is deprecated:DeprecationWarning',
 ]
 
+[tool.ruff.lint]
+ignore = [
+    "RUF059",
+    "UP031",
+    "LOG015",
+    "BLE001",
+    "TRY002",
+    "B006",
+    "B023",
+    "S110",
+    "RUF012",
+    "RUF013",
+    "B017",
+    "C408",
+    "TRY201",
+    "SIM103",
+    "TRY203",
+    "SIM115",
+    "SIM118",
+    "EXE001",
+    "PT014",
+    "PLW0602",
+    "PERF402",
+    "PLR1722",
+    "PLW1510",
+    "SIM102",
+    "UP007",
+    "FURB132",
+    "SIM113",
+    "TRY004",
+    "B015",
+    "DTZ001",
+    "PERF102",
+    "PLW0127",
+    "SIM101",
+    "SIM210",
+    "UP022",
+    "B008",
+    "C417",
+    "C418",
+    "DTZ005",
+    "ISC004",
+    "N999",
+    "PLR0133",
+    "RUF015",
+    "SIM117",
+    "SIM211",
+]
+
 [tool.ruff.lint.per-file-ignores]
 "python/infinity_embedded/local_infinity/client.py" = ["F403", "F405"]
 "python/infinity_embedded/local_infinity/query_builder.py" = ["F403", "F405"]

{infinity_sdk-0.7.2 → 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.2
+   pip install infinity-sdk==0.7.4
    ```
 
 3. Use Infinity to conduct a dense vector search:

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

@@ -17,17 +17,33 @@
 # __version__ = importlib.metadata.version("infinity_sdk")
 
 import logging
+
 # import pkg_resources
 # __version__ = pkg_resources.get_distribution("infinity_sdk").version
-
-from infinity.common import URI, NetworkAddress, LOCAL_HOST, LOCAL_INFINITY_PATH, InfinityException
+from infinity.common import (
+    LOCAL_HOST,
+    LOCAL_INFINITY_PATH,
+    URI,
+    InfinityException,
+    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
-from infinity.errors import ErrorCode
 
 __all__ = [
-    "URI", "NetworkAddress", "LOCAL_HOST", "LOCAL_INFINITY_PATH", "InfinityException",
-    "InfinityConnection", "RemoteThriftInfinityConnection", "ErrorCode", "connect"
+    "LOCAL_HOST",
+    "LOCAL_INFINITY_PATH",
+    "URI",
+    "ErrorCode",
+    "InfinityConnection",
+    "InfinityException",
+    "NetworkAddress",
+    "RemoteThriftInfinityConnection",
+    "connect",
+    "quote_string_literal",
+    "regex_filter"
 ]
 
 

{infinity_sdk-0.7.2 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/common.py

@@ -11,9 +11,10 @@
 # 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.
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Union
-from dataclasses import dataclass, field
+
 import numpy as np
 
 
@@ -102,13 +103,13 @@ LOCAL_HOST = NetworkAddress("127.0.0.1", 23817)
 LOCAL_INFINITY_PATH = "/var/infinity"
 
 
-class ConflictType(object):
+class ConflictType:
     Ignore = 0
     Error = 1
     Replace = 2
 
 
-class SortType(object):
+class SortType:
     Asc = 0
     Desc = 1
 

{infinity_sdk-0.7.2 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/connection_pool.py

@@ -12,13 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 from threading import Lock
+
 import infinity
 from infinity.common import NetworkAddress
-import logging
 
 
-class ConnectionPool(object):
+class ConnectionPool:
     def __init__(self, uri=NetworkAddress("127.0.0.1", 23817), max_size=16):
         self.uri_ = uri
         self.max_size_ = max_size

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.2 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/http_utils.py

@@ -1,6 +1,7 @@
 import ast
 import re
 from enum import Enum
+
 from infinity.common import ConflictType
 from infinity.table import ExplainType
 
@@ -65,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):
@@ -78,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.2 → 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.2/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.2 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/index.py

@@ -14,11 +14,12 @@
 
 from enum import Enum
 
-import infinity.remote_thrift.infinity_thrift_rpc.ttypes as ttypes
+from sqlglot import maybe_parse
+
 from infinity.common import InfinityException
 from infinity.errors import ErrorCode
+from infinity.remote_thrift.infinity_thrift_rpc import ttypes
 from infinity.remote_thrift.utils import parse_expr
-from sqlglot import maybe_parse
 
 
 class IndexType(Enum):
@@ -74,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
@@ -86,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.2 → infinity_sdk-0.7.4}/python/infinity_sdk/infinity/infinity.py

@@ -14,7 +14,6 @@
 from abc import ABC, abstractmethod
 
 
-
 # abstract class
 class InfinityConnection(ABC):
     def __init__(self, uri):

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

@@ -1,28 +1,45 @@
+import ast
+import logging
 import re
 import time
+from collections import namedtuple
+from dataclasses import dataclass
+from typing import Any
 
-import requests
-import logging
-import ast
-from numpy import dtype
-from .http_utils import (
-    baseHeader, baseResponse, baseData, default_url, baseCreateOptions, baseDropOptions,
-    index_type_transfrom, ExplainType_transfrom, is_list, is_date, is_time, is_datetime,
-    is_sparse, str2sparse, type_to_dtype, function_return_type, is_float, functions, bool_functions
-)
-
-from infinity.common import ConflictType, InfinityException, SparseVector, SortType, FDE
-from typing import Optional, Any
-from infinity.errors import ErrorCode
-from infinity.utils import deprecated_api
 import numpy as np
 import pandas as pd
 import polars as pl
 import pyarrow as pa
+import requests
+from numpy import dtype
+
+from infinity.common import FDE, ConflictType, InfinityException, SortType, SparseVector
+from infinity.errors import ErrorCode
 from infinity.table import ExplainType
-from typing import List
-from dataclasses import dataclass
-from collections import namedtuple
+from infinity.utils import deprecated_api
+
+from .http_utils import (
+    ExplainType_transfrom,
+    baseCreateOptions,
+    baseData,
+    baseDropOptions,
+    baseHeader,
+    baseResponse,
+    bool_functions,
+    default_url,
+    function_return_type,
+    functions,
+    index_type_transfrom,
+    is_date,
+    is_datetime,
+    is_float,
+    is_list,
+    is_sparse,
+    is_time,
+    str2sparse,
+    type_to_dtype,
+)
+
 
 def is_json_function(col_name: str) -> bool:
     """Check if column name is a JSON extraction function"""
@@ -40,7 +57,7 @@ def is_json_function(col_name: str) -> bool:
     return any(col_name_lower.startswith(func) for func in json_functions)
 
 
-def _parse_cast_target_type(cast_expr: str) -> Optional[str]:
+def _parse_cast_target_type(cast_expr: str) -> str | None:
     if not cast_expr.lower().startswith("cast("):
         return None
 
@@ -180,7 +197,6 @@ class http_network_util:
                 pass
 
         logging.debug("----------------------------------------------")
-        return
 
     def get_database_result(self, resp, expect={}):
         try:
@@ -778,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()
 
@@ -1044,7 +1062,7 @@ class table_http_result:
         self._highlight = highlight
         return self
 
-    def sort(self, order_by_expr_list: Optional[List[list[str, SortType]]]):
+    def sort(self, order_by_expr_list: list[list[str, SortType]] | None):
         for order_by_expr in order_by_expr_list:
             tmp = {}
             if len(order_by_expr) != 2:
@@ -1084,7 +1102,7 @@ class table_http_result:
         self._option = option
         return self
 
-    def match_text(self, fields: str, query: str, topn: int, opt_params: Optional[dict] = None):
+    def match_text(self, fields: str, query: str, topn: int, opt_params: dict | None = None):
         tmp_match_expr = {"match_method": "text", "fields": fields, "matching_text": query, "topn": topn}
         if opt_params is not None:
             tmp_match_expr["params"] = opt_params
@@ -1096,7 +1114,7 @@ class table_http_result:
         return self.match_text(*args, **kwargs)
 
     def match_tensor(self, column_name: str, query_data, query_data_type: str, topn: int,
-                     extra_option: Optional[dict] = None):
+                     extra_option: dict | None = None):
         tmp_match_tensor = {"match_method": "tensor", "field": column_name, "query_tensor": query_data,
                             "element_type": query_data_type, "topn": topn}
         if extra_option is not None:
@@ -1105,7 +1123,7 @@ class table_http_result:
         return self
 
     def match_sparse(self, vector_column_name: str, sparse_data: SparseVector | dict, distance_type: str, topn: int,
-                     opt_params: Optional[dict] = None):
+                     opt_params: dict | None = None):
         tmp_match_sparse = {"match_method": "sparse", "fields": vector_column_name,
                             "query_vector": sparse_data.to_dict(), "metric_type": distance_type, "topn": topn}
         if opt_params is not None:
@@ -1118,7 +1136,7 @@ class table_http_result:
         return self
 
     def match_dense(self, fields: str, query_vector: list, element_type: str, metric_type: str, top_k: int,
-                    opt_params: Optional[dict] = None):
+                    opt_params: dict | None = None):
         tmp_match_dense = {"match_method": "dense", "fields": fields, "query_vector": query_vector,
                            "element_type": element_type, "metric_type": metric_type, "topn": top_k}
         if opt_params is not None:
@@ -1130,7 +1148,7 @@ class table_http_result:
         deprecated_api("knn is deprecated, please use match_dense instead")
         return self.match_dense(*args, **kwargs)
 
-    def fusion(self, method: str, topn: int, fusion_params: Optional[dict] = None):
+    def fusion(self, method: str, topn: int, fusion_params: dict | None = None):
         tmp_fusion_expr = {"fusion_method": method, "topn": topn}
         if method == "match_tensor":
             tmp_new_params = {"field": fusion_params["field"], "query_tensor": fusion_params["query_tensor"],
@@ -1184,18 +1202,12 @@ class table_http_result:
                 if len(tup) == line_i + 1:
                     continue
 
-                if v is None:
-                    new_tup = tup + (v,)
-                elif isinstance(v, (int, float)):
+                if v is None or isinstance(v, (int, float)):
                     new_tup = tup + (v,)
                 elif is_list(v) and not is_json_function(col_name):
                     # Don't parse lists for JSON extraction functions - keep them as strings
                     new_tup = tup + (ast.literal_eval(v),)
-                elif is_date(v):
-                    new_tup = tup + (v,)
-                elif is_time(v):
-                    new_tup = tup + (v,)
-                elif is_datetime(v):
+                elif is_date(v) or is_time(v) or is_datetime(v):
                     new_tup = tup + (v,)
                 elif is_sparse(v):  # sparse vector
                     sparse_vec = str2sparse(v)
@@ -1312,7 +1324,7 @@ class table_http_result:
 
 
 @dataclass
-class database_result():
+class database_result:
     def __init__(self, list=[], database_name: str = "", error_code=ErrorCode.OK, columns=[], index_names=[],
                  node_name="", node_role="", node_status="", index_type=None, index_comment=None, deleted_rows=0,
                  data={}, nodes=[], error_msg="", snapshots=[], config_value: Any = None):