V1.1.0 (#134)

* WIP: generate models and conversions

* update quantization param + match any condition + test

* update versions

* consistent naming

* use old grpc types generator

* fix: update type hints

* disable match-any in backward comp test

---------

Co-authored-by: George Panchuk <george.panchuk@qdrant.tech>

.github/workflows/integration-tests.yml

@@ -45,7 +45,7 @@ jobs:
         shell: bash
       - name: Backward compatibility integration tests
         run: |
-          QDRANT_VERSION='v0.11.7' ./tests/integration-tests.sh
+          QDRANT_VERSION='v1.0.3' ./tests/integration-tests.sh
         shell: bash
       - name: Check conversion coverage
         run: |

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qdrant_client"
-version = "1.0.5"
+version = "1.1.0"
 description = "Client library for the Qdrant vector search engine"
 authors = ["Andrey Vasnetsov <andrey@qdrant.tech>"]
 packages = [

qdrant_client/conversions/common_types.py

@@ -20,6 +20,7 @@
 OptimizersConfigDiff = Union[rest.OptimizersConfigDiff, grpc.OptimizersConfigDiff]
 CollectionParamsDiff = Union[rest.CollectionParamsDiff, grpc.CollectionParamsDiff]
 WalConfigDiff = Union[rest.WalConfigDiff, grpc.WalConfigDiff]
+QuantizationConfig = Union[rest.QuantizationConfig, grpc.QuantizationConfig]
 PointId = Union[int, str, grpc.PointId]
 PayloadSchemaType = Union[
     rest.PayloadSchemaType, rest.PayloadSchemaParams, int

qdrant_client/conversions/conversion.py

@@ -145,6 +145,9 @@ def convert_collection_config(cls, model: grpc.CollectionConfig) -> rest.Collect
             optimizer_config=cls.convert_optimizer_config(model.optimizer_config),
             params=cls.convert_collection_params(model.params),
             wal_config=cls.convert_wal_config(model.wal_config),
+            quantization_config=cls.convert_quantization_config(model.quantization_config)
+            if model.HasField("quantization_config")
+            else None,
         )
 
     @classmethod
@@ -313,6 +316,9 @@ def convert_search_params(cls, model: grpc.SearchParams) -> rest.SearchParams:
         return rest.SearchParams(
             hnsw_ef=model.hnsw_ef if model.HasField("hnsw_ef") else None,
             exact=model.exact if model.HasField("exact") else None,
+            quantization=cls.convert_quantization_search_params(model.quantization)
+            if model.HasField("quantization")
+            else None,
         )
 
     @classmethod
@@ -325,11 +331,14 @@ def convert_create_collection(cls, model: grpc.CreateCollection) -> rest.CreateC
             vectors=cls.convert_vectors_config(model.vectors_config)
             if model.HasField("vectors_config")
             else None,
+            shard_number=model.shard_number,
             collection_name=model.collection_name,
             hnsw_config=cls.convert_hnsw_config(model.hnsw_config),
             wal_config=cls.convert_wal_config(model.wal_config),
             optimizers_config=cls.convert_optimizer_config(model.optimizers_config),
-            shard_number=model.shard_number,
+            quantization_config=cls.convert_quantization_config(model.quantization_config)
+            if model.HasField("quantization_config")
+            else None,
         )
 
     @classmethod
@@ -409,6 +418,10 @@ def convert_match(cls, model: grpc.Match) -> rest.Match:
             return rest.MatchValue(value=val)
         if name == "text":
             return rest.MatchText(text=val)
+        if name == "keywords":
+            return rest.MatchAny(any=list(val.strings))
+        if name == "integers":
+            return rest.MatchAny(any=list(val.integers))
         raise ValueError(f"invalid Match model: {model}")  # pragma: no cover
 
     @classmethod
@@ -717,6 +730,35 @@ def convert_read_consistency_type(
             return rest.ReadConsistencyType.QUORUM
         raise ValueError(f"invalid ReadConsistencyType model: {model}")  # pragma: no cover
 
+    @classmethod
+    def convert_scalar_quantization_config(
+        cls, model: grpc.ScalarQuantization
+    ) -> rest.ScalarQuantizationConfig:
+        return rest.ScalarQuantizationConfig(
+            type=rest.ScalarType.INT8,
+            quantile=model.quantile if model.HasField("quantile") else None,
+            always_ram=model.always_ram if model.HasField("always_ram") else None,
+        )
+
+    @classmethod
+    def convert_quantization_config(
+        cls, model: grpc.QuantizationConfig
+    ) -> rest.QuantizationConfig:
+        name = model.WhichOneof("quantization")
+        val = getattr(model, name)
+        if name == "scalar":
+            return rest.ScalarQuantization(scalar=cls.convert_scalar_quantization_config(val))
+        raise ValueError(f"invalid QuantizationConfig model: {model}")  # pragma: no cover
+
+    @classmethod
+    def convert_quantization_search_params(
+        cls, model: grpc.QuantizationSearchParams
+    ) -> rest.QuantizationSearchParams:
+        return rest.QuantizationSearchParams(
+            ignore=model.ignore if model.HasField("ignore") else None,
+            rescore=model.rescore if model.HasField("rescore") else None,
+        )
+
 
 # ----------------------------------------
 #
@@ -857,6 +899,9 @@ def convert_search_params(cls, model: rest.SearchParams) -> grpc.SearchParams:
         return grpc.SearchParams(
             hnsw_ef=model.hnsw_ef,
             exact=model.exact,
+            quantization=cls.convert_quantization_search_params(model.quantization)
+            if model.quantization is not None
+            else None,
         )
 
     @classmethod
@@ -882,6 +927,9 @@ def convert_create_collection(
             wal_config=cls.convert_wal_config_diff(model.wal_config)
             if model.wal_config is not None
             else None,
+            quantization_config=cls.convert_quantization_config(model.quantization_config)
+            if model.quantization_config is not None
+            else None,
         )
 
     @classmethod
@@ -915,7 +963,7 @@ def convert_point_struct(cls, model: rest.PointStruct) -> grpc.PointStruct:
         return grpc.PointStruct(
             id=cls.convert_extended_point_id(model.id),
             vectors=cls.convert_vector_struct(model.vector),
-            payload=cls.convert_payload(model.payload),
+            payload=cls.convert_payload(model.payload) if model.payload is not None else None,
         )
 
     @classmethod
@@ -967,6 +1015,9 @@ def convert_collection_config(cls, model: rest.CollectionConfig) -> grpc.Collect
             hnsw_config=cls.convert_hnsw_config(model.hnsw_config),
             optimizer_config=cls.convert_optimizers_config(model.optimizer_config),
             wal_config=cls.convert_wal_config(model.wal_config),
+            quantization_config=cls.convert_quantization_config(model.quantization_config)
+            if model.quantization_config is not None
+            else None,
         )
 
     @classmethod
@@ -1063,6 +1114,14 @@ def convert_match(cls, model: rest.Match) -> grpc.Match:
                 return grpc.Match(keyword=model.value)
         if isinstance(model, rest.MatchText):
             return grpc.Match(text=model.text)
+        if isinstance(model, rest.MatchAny):
+            if len(model.any) == 0:
+                return grpc.Match(keywords=[])
+            if isinstance(model.any[0], str):
+                return grpc.Match(keywords=grpc.RepeatedStrings(strings=model.any))
+            if isinstance(model.any[0], int):
+                return grpc.Match(integers=grpc.RepeatedIntegers(integers=model.any))
+            raise ValueError(f"invalid MatchAny model: {model}")  # pragma: no cover
 
         raise ValueError(f"invalid Match model: {model}")  # pragma: no cover
 
@@ -1374,3 +1433,33 @@ def convert_write_ordering(cls, model: rest.WriteOrdering) -> grpc.WriteOrdering
             return grpc.WriteOrdering(type=grpc.WriteOrderingType.Strong)
         else:
             raise ValueError(f"invalid WriteOrdering model: {model}")  # pragma: no cover
+
+    @classmethod
+    def convert_scalar_quantization_config(
+        cls, model: rest.ScalarQuantizationConfig
+    ) -> grpc.ScalarQuantization:
+        return grpc.ScalarQuantization(
+            type=grpc.QuantizationType.Int8,
+            quantile=model.quantile,
+            always_ram=model.always_ram,
+        )
+
+    @classmethod
+    def convert_quantization_config(
+        cls, model: rest.QuantizationConfig
+    ) -> grpc.QuantizationConfig:
+        if isinstance(model, rest.ScalarQuantization):
+            return grpc.QuantizationConfig(
+                scalar=cls.convert_scalar_quantization_config(model.scalar)
+            )
+        else:
+            raise ValueError(f"invalid QuantizationConfig model: {model}")
+
+    @classmethod
+    def convert_quantization_search_params(
+        cls, model: rest.QuantizationSearchParams
+    ) -> grpc.QuantizationSearchParams:
+        return grpc.QuantizationSearchParams(
+            ignore=model.ignore,
+            rescore=model.rescore,
+        )