hazelcast-python-client 5.4.0__tar.gz → 5.5.0__tar.gz

{hazelcast_python_client-5.4.0/hazelcast_python_client.egg-info → hazelcast_python_client-5.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hazelcast-python-client
-Version: 5.4.0
+Version: 5.5.0
 Summary: Hazelcast Python Client
 Home-page: https://github.com/hazelcast/hazelcast-python-client
 Author: Hazelcast Inc. Developers
@@ -15,7 +15,6 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.6
 Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
@@ -173,6 +172,7 @@ Features
 -  Distributed, CRDT based counter, called **PNCounter**
 -  Distributed concurrency primitives from CP Subsystem such as
    **FencedLock**, **Semaphore**, **AtomicLong**
+-  Similarity search using **VectorCollection** (Beta)
 -  Integration with `Hazelcast Cloud <https://cloud.hazelcast.com/>`__
 -  Support for serverless and traditional web service architectures with
    **Unisocket** and **Smart** operation modes
@@ -245,11 +245,18 @@ following:
 -  `Supported Java virtual machine <https://docs.hazelcast.com/hazelcast/latest/deploy/versioning-compatibility#supported-java-virtual-machines>`
 -  `Apache Maven <https://maven.apache.org/>`
 
-Following commands starts the tests:
+Set the environment variables for credentials:
 
 .. code:: bash
 
-    python run_tests.py
+    export HZ_SNAPSHOT_INTERNAL_USERNAME=YOUR_MAVEN_USERNAME
+    export HZ_SNAPSHOT_INTERNAL_PASSWORD=YOUR_MAVEN_PASSWORD
+
+Following command starts the tests:
+
+.. code:: bash
+
+    python3 run_tests.py
 
 Test script automatically downloads ``hazelcast-remote-controller`` and
 Hazelcast. The script uses Maven to download those.
@@ -262,7 +269,7 @@ License
 Copyright
 ---------
 
-Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved.
+Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved.
 
 Visit `hazelcast.com <https://hazelcast.com>`__ for more
 information.

{hazelcast_python_client-5.4.0 → hazelcast_python_client-5.5.0}/README.rst

@@ -143,6 +143,7 @@ Features
 -  Distributed, CRDT based counter, called **PNCounter**
 -  Distributed concurrency primitives from CP Subsystem such as
    **FencedLock**, **Semaphore**, **AtomicLong**
+-  Similarity search using **VectorCollection** (Beta)
 -  Integration with `Hazelcast Cloud <https://cloud.hazelcast.com/>`__
 -  Support for serverless and traditional web service architectures with
    **Unisocket** and **Smart** operation modes
@@ -215,11 +216,18 @@ following:
 -  `Supported Java virtual machine <https://docs.hazelcast.com/hazelcast/latest/deploy/versioning-compatibility#supported-java-virtual-machines>`
 -  `Apache Maven <https://maven.apache.org/>`
 
-Following commands starts the tests:
+Set the environment variables for credentials:
 
 .. code:: bash
 
-    python run_tests.py
+    export HZ_SNAPSHOT_INTERNAL_USERNAME=YOUR_MAVEN_USERNAME
+    export HZ_SNAPSHOT_INTERNAL_PASSWORD=YOUR_MAVEN_PASSWORD
+
+Following command starts the tests:
+
+.. code:: bash
+
+    python3 run_tests.py
 
 Test script automatically downloads ``hazelcast-remote-controller`` and
 Hazelcast. The script uses Maven to download those.
@@ -232,7 +240,7 @@ License
 Copyright
 ---------
 
-Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved.
+Copyright (c) 2008-2023, Hazelcast, Inc. All Rights Reserved.
 
 Visit `hazelcast.com <https://hazelcast.com>`__ for more
 information.

{hazelcast_python_client-5.4.0 → hazelcast_python_client-5.5.0}/hazelcast/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "5.4.0"
+__version__ = "5.5.0"
 
 # Set the default handler to "hazelcast" loggers
 # to avoid "No handlers could be found" warnings.

{hazelcast_python_client-5.4.0 → hazelcast_python_client-5.5.0}/hazelcast/client.py

@@ -21,6 +21,7 @@ from hazelcast.protocol.codec import (
     client_add_distributed_object_listener_codec,
     client_get_distributed_objects_codec,
     client_remove_distributed_object_listener_codec,
+    dynamic_config_add_vector_collection_config_codec,
 )
 from hazelcast.proxy import (
     EXECUTOR_SERVICE,
@@ -35,6 +36,7 @@ from hazelcast.proxy import (
     RINGBUFFER_SERVICE,
     SET_SERVICE,
     TOPIC_SERVICE,
+    VECTOR_SERVICE,
     Executor,
     FlakeIdGenerator,
     List,
@@ -50,6 +52,7 @@ from hazelcast.proxy import (
 )
 from hazelcast.proxy.base import Proxy
 from hazelcast.proxy.map import Map
+from hazelcast.proxy.vector_collection import VectorCollection
 from hazelcast.reactor import AsyncoreReactor
 from hazelcast.serialization import SerializationServiceV1
 from hazelcast.sql import SqlService, _InternalSqlService
@@ -60,6 +63,8 @@ from hazelcast.util import AtomicInteger, RoundRobinLB
 
 __all__ = ("HazelcastClient",)
 
+from hazelcast.vector import IndexConfig
+
 _logger = logging.getLogger(__name__)
 
 
@@ -373,6 +378,21 @@ class HazelcastClient:
         """
         return self._proxy_manager.get_or_create(TOPIC_SERVICE, name)
 
+    def create_vector_collection_config(self, name: str, indexes: typing.List[IndexConfig]) -> None:
+        # check that indexes have different names
+        if indexes:
+            index_names = set(index.name for index in indexes)
+            if len(index_names) != len(indexes):
+                raise AssertionError("index names must be unique")
+
+        request = dynamic_config_add_vector_collection_config_codec.encode_request(name, indexes)
+        invocation = Invocation(request, response_handler=lambda m: m)
+        self._invocation_service.invoke(invocation)
+        invocation.future.result()
+
+    def get_vector_collection(self, name: str) -> VectorCollection:
+        return self._proxy_manager.get_or_create(VECTOR_SERVICE, name)
+
     def new_transaction(
         self, timeout: float = 120, durability: int = 1, type: int = TWO_PHASE
     ) -> Transaction:

{hazelcast_python_client-5.4.0 → hazelcast_python_client-5.5.0}/hazelcast/protocol/__init__.py

@@ -130,7 +130,7 @@ class PagingPredicateHolder:
             anchor_data_list.append((key, value))
 
         anchor_data_list_holder = AnchorDataListHolder(page_list, anchor_data_list)
-        predicate_data = to_data(predicate)
+        predicate_data = to_data(predicate._internal_predicate)
         comparator_data = to_data(predicate.comparator)
         iteration_type = predicate.iteration_type
 

{hazelcast_python_client-5.4.0 → hazelcast_python_client-5.5.0}/hazelcast/protocol/builtin.py

@@ -295,6 +295,10 @@ class FixSizedTypesCodec:
     def decode_short(buf, offset):
         return LE_INT16.unpack_from(buf, offset)[0]
 
+    @staticmethod
+    def encode_float(buf, offset, value):
+        LE_FLOAT.pack_into(buf, offset, value)
+
     @staticmethod
     def decode_float(buf, offset):
         return LE_FLOAT.unpack_from(buf, offset)[0]
@@ -535,6 +539,31 @@ class LongArrayCodec:
         return result
 
 
+class FloatArrayCodec:
+    @staticmethod
+    def encode(buf, arr, is_final=False):
+        n = len(arr)
+        size = SIZE_OF_FRAME_LENGTH_AND_FLAGS + n * FLOAT_SIZE_IN_BYTES
+        b = bytearray(size)
+        LE_INT.pack_into(b, 0, size)
+        if is_final:
+            LE_UINT16.pack_into(b, INT_SIZE_IN_BYTES, _IS_FINAL_FLAG)
+        for i in range(n):
+            FixSizedTypesCodec.encode_float(
+                b, SIZE_OF_FRAME_LENGTH_AND_FLAGS + i * FLOAT_SIZE_IN_BYTES, arr[i]
+            )
+        buf.extend(b)
+
+    @staticmethod
+    def decode(msg):
+        b = msg.next_frame().buf
+        n = len(b) // FLOAT_SIZE_IN_BYTES
+        result = []
+        for i in range(n):
+            result.append(FixSizedTypesCodec.decode_float(b, i * FLOAT_SIZE_IN_BYTES))
+        return result
+
+
 class MapCodec:
     @staticmethod
     def encode(buf, m, key_encoder, value_encoder, is_final=False):

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/custom/vector_document_codec.py

@@ -0,0 +1,26 @@
+from hazelcast.protocol.builtin import CodecUtil
+from hazelcast.protocol.client_message import END_FRAME_BUF, END_FINAL_FRAME_BUF, BEGIN_FRAME_BUF
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.vector import VectorDocument
+from hazelcast.protocol.builtin import ListMultiFrameCodec
+from hazelcast.protocol.codec.custom.vector_pair_codec import VectorPairCodec
+
+
+class VectorDocumentCodec:
+    @staticmethod
+    def encode(buf, vector_document, is_final=False):
+        buf.extend(BEGIN_FRAME_BUF)
+        DataCodec.encode(buf, vector_document.value)
+        ListMultiFrameCodec.encode(buf, vector_document.vectors, VectorPairCodec.encode)
+        if is_final:
+            buf.extend(END_FINAL_FRAME_BUF)
+        else:
+            buf.extend(END_FRAME_BUF)
+
+    @staticmethod
+    def decode(msg):
+        msg.next_frame()
+        value = DataCodec.decode(msg)
+        vectors = ListMultiFrameCodec.decode(msg, VectorPairCodec.decode)
+        CodecUtil.fast_forward_to_end_frame(msg)
+        return VectorDocument(value, vectors)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/custom/vector_index_config_codec.py

@@ -0,0 +1,47 @@
+from hazelcast.protocol.builtin import FixSizedTypesCodec, CodecUtil
+from hazelcast.serialization.bits import *
+from hazelcast.protocol.client_message import END_FRAME_BUF, END_FINAL_FRAME_BUF, SIZE_OF_FRAME_LENGTH_AND_FLAGS, create_initial_buffer_custom
+from hazelcast.vector import VectorIndexConfig
+from hazelcast.protocol.builtin import StringCodec
+
+_METRIC_ENCODE_OFFSET = 2 * SIZE_OF_FRAME_LENGTH_AND_FLAGS
+_METRIC_DECODE_OFFSET = 0
+_DIMENSION_ENCODE_OFFSET = _METRIC_ENCODE_OFFSET + INT_SIZE_IN_BYTES
+_DIMENSION_DECODE_OFFSET = _METRIC_DECODE_OFFSET + INT_SIZE_IN_BYTES
+_MAX_DEGREE_ENCODE_OFFSET = _DIMENSION_ENCODE_OFFSET + INT_SIZE_IN_BYTES
+_MAX_DEGREE_DECODE_OFFSET = _DIMENSION_DECODE_OFFSET + INT_SIZE_IN_BYTES
+_EF_CONSTRUCTION_ENCODE_OFFSET = _MAX_DEGREE_ENCODE_OFFSET + INT_SIZE_IN_BYTES
+_EF_CONSTRUCTION_DECODE_OFFSET = _MAX_DEGREE_DECODE_OFFSET + INT_SIZE_IN_BYTES
+_USE_DEDUPLICATION_ENCODE_OFFSET = _EF_CONSTRUCTION_ENCODE_OFFSET + INT_SIZE_IN_BYTES
+_USE_DEDUPLICATION_DECODE_OFFSET = _EF_CONSTRUCTION_DECODE_OFFSET + INT_SIZE_IN_BYTES
+_INITIAL_FRAME_SIZE = _USE_DEDUPLICATION_ENCODE_OFFSET + BOOLEAN_SIZE_IN_BYTES - SIZE_OF_FRAME_LENGTH_AND_FLAGS
+
+
+class VectorIndexConfigCodec:
+    @staticmethod
+    def encode(buf, vector_index_config, is_final=False):
+        initial_frame_buf = create_initial_buffer_custom(_INITIAL_FRAME_SIZE)
+        FixSizedTypesCodec.encode_int(initial_frame_buf, _METRIC_ENCODE_OFFSET, vector_index_config.metric)
+        FixSizedTypesCodec.encode_int(initial_frame_buf, _DIMENSION_ENCODE_OFFSET, vector_index_config.dimension)
+        FixSizedTypesCodec.encode_int(initial_frame_buf, _MAX_DEGREE_ENCODE_OFFSET, vector_index_config.max_degree)
+        FixSizedTypesCodec.encode_int(initial_frame_buf, _EF_CONSTRUCTION_ENCODE_OFFSET, vector_index_config.ef_construction)
+        FixSizedTypesCodec.encode_boolean(initial_frame_buf, _USE_DEDUPLICATION_ENCODE_OFFSET, vector_index_config.use_deduplication)
+        buf.extend(initial_frame_buf)
+        CodecUtil.encode_nullable(buf, vector_index_config.name, StringCodec.encode)
+        if is_final:
+            buf.extend(END_FINAL_FRAME_BUF)
+        else:
+            buf.extend(END_FRAME_BUF)
+
+    @staticmethod
+    def decode(msg):
+        msg.next_frame()
+        initial_frame = msg.next_frame()
+        metric = FixSizedTypesCodec.decode_int(initial_frame.buf, _METRIC_DECODE_OFFSET)
+        dimension = FixSizedTypesCodec.decode_int(initial_frame.buf, _DIMENSION_DECODE_OFFSET)
+        max_degree = FixSizedTypesCodec.decode_int(initial_frame.buf, _MAX_DEGREE_DECODE_OFFSET)
+        ef_construction = FixSizedTypesCodec.decode_int(initial_frame.buf, _EF_CONSTRUCTION_DECODE_OFFSET)
+        use_deduplication = FixSizedTypesCodec.decode_boolean(initial_frame.buf, _USE_DEDUPLICATION_DECODE_OFFSET)
+        name = CodecUtil.decode_nullable(msg, StringCodec.decode)
+        CodecUtil.fast_forward_to_end_frame(msg)
+        return VectorIndexConfig(name, metric, dimension, max_degree, ef_construction, use_deduplication)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/custom/vector_pair_codec.py

@@ -0,0 +1,34 @@
+from hazelcast.protocol.builtin import FixSizedTypesCodec, CodecUtil
+from hazelcast.serialization.bits import *
+from hazelcast.protocol.client_message import END_FRAME_BUF, END_FINAL_FRAME_BUF, SIZE_OF_FRAME_LENGTH_AND_FLAGS, create_initial_buffer_custom
+from hazelcast.vector import VectorPair
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import FloatArrayCodec
+
+_TYPE_ENCODE_OFFSET = 2 * SIZE_OF_FRAME_LENGTH_AND_FLAGS
+_TYPE_DECODE_OFFSET = 0
+_INITIAL_FRAME_SIZE = _TYPE_ENCODE_OFFSET + BYTE_SIZE_IN_BYTES - SIZE_OF_FRAME_LENGTH_AND_FLAGS
+
+
+class VectorPairCodec:
+    @staticmethod
+    def encode(buf, vector_pair, is_final=False):
+        initial_frame_buf = create_initial_buffer_custom(_INITIAL_FRAME_SIZE)
+        FixSizedTypesCodec.encode_byte(initial_frame_buf, _TYPE_ENCODE_OFFSET, vector_pair.type)
+        buf.extend(initial_frame_buf)
+        StringCodec.encode(buf, vector_pair.name)
+        CodecUtil.encode_nullable(buf, vector_pair.vector, FloatArrayCodec.encode)
+        if is_final:
+            buf.extend(END_FINAL_FRAME_BUF)
+        else:
+            buf.extend(END_FRAME_BUF)
+
+    @staticmethod
+    def decode(msg):
+        msg.next_frame()
+        initial_frame = msg.next_frame()
+        type = FixSizedTypesCodec.decode_byte(initial_frame.buf, _TYPE_DECODE_OFFSET)
+        name = StringCodec.decode(msg)
+        vector = CodecUtil.decode_nullable(msg, FloatArrayCodec.decode)
+        CodecUtil.fast_forward_to_end_frame(msg)
+        return VectorPair(name, type, vector)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/custom/vector_search_options_codec.py

@@ -0,0 +1,40 @@
+from hazelcast.protocol.builtin import FixSizedTypesCodec, CodecUtil
+from hazelcast.serialization.bits import *
+from hazelcast.protocol.client_message import END_FRAME_BUF, END_FINAL_FRAME_BUF, SIZE_OF_FRAME_LENGTH_AND_FLAGS, create_initial_buffer_custom
+from hazelcast.vector import VectorSearchOptions
+from hazelcast.protocol.builtin import MapCodec
+from hazelcast.protocol.builtin import StringCodec
+
+_INCLUDE_VALUE_ENCODE_OFFSET = 2 * SIZE_OF_FRAME_LENGTH_AND_FLAGS
+_INCLUDE_VALUE_DECODE_OFFSET = 0
+_INCLUDE_VECTORS_ENCODE_OFFSET = _INCLUDE_VALUE_ENCODE_OFFSET + BOOLEAN_SIZE_IN_BYTES
+_INCLUDE_VECTORS_DECODE_OFFSET = _INCLUDE_VALUE_DECODE_OFFSET + BOOLEAN_SIZE_IN_BYTES
+_LIMIT_ENCODE_OFFSET = _INCLUDE_VECTORS_ENCODE_OFFSET + BOOLEAN_SIZE_IN_BYTES
+_LIMIT_DECODE_OFFSET = _INCLUDE_VECTORS_DECODE_OFFSET + BOOLEAN_SIZE_IN_BYTES
+_INITIAL_FRAME_SIZE = _LIMIT_ENCODE_OFFSET + INT_SIZE_IN_BYTES - SIZE_OF_FRAME_LENGTH_AND_FLAGS
+
+
+class VectorSearchOptionsCodec:
+    @staticmethod
+    def encode(buf, vector_search_options, is_final=False):
+        initial_frame_buf = create_initial_buffer_custom(_INITIAL_FRAME_SIZE)
+        FixSizedTypesCodec.encode_boolean(initial_frame_buf, _INCLUDE_VALUE_ENCODE_OFFSET, vector_search_options.include_value)
+        FixSizedTypesCodec.encode_boolean(initial_frame_buf, _INCLUDE_VECTORS_ENCODE_OFFSET, vector_search_options.include_vectors)
+        FixSizedTypesCodec.encode_int(initial_frame_buf, _LIMIT_ENCODE_OFFSET, vector_search_options.limit)
+        buf.extend(initial_frame_buf)
+        MapCodec.encode_nullable(buf, vector_search_options.hints, StringCodec.encode, StringCodec.encode)
+        if is_final:
+            buf.extend(END_FINAL_FRAME_BUF)
+        else:
+            buf.extend(END_FRAME_BUF)
+
+    @staticmethod
+    def decode(msg):
+        msg.next_frame()
+        initial_frame = msg.next_frame()
+        include_value = FixSizedTypesCodec.decode_boolean(initial_frame.buf, _INCLUDE_VALUE_DECODE_OFFSET)
+        include_vectors = FixSizedTypesCodec.decode_boolean(initial_frame.buf, _INCLUDE_VECTORS_DECODE_OFFSET)
+        limit = FixSizedTypesCodec.decode_int(initial_frame.buf, _LIMIT_DECODE_OFFSET)
+        hints = MapCodec.decode_nullable(msg, StringCodec.decode, StringCodec.decode)
+        CodecUtil.fast_forward_to_end_frame(msg)
+        return VectorSearchOptions(include_value, include_vectors, limit, hints)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/custom/vector_search_result_codec.py

@@ -0,0 +1,37 @@
+from hazelcast.protocol.builtin import FixSizedTypesCodec, CodecUtil
+from hazelcast.serialization.bits import *
+from hazelcast.protocol.client_message import END_FRAME_BUF, END_FINAL_FRAME_BUF, SIZE_OF_FRAME_LENGTH_AND_FLAGS, create_initial_buffer_custom
+from hazelcast.vector import VectorSearchResult
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.builtin import ListMultiFrameCodec
+from hazelcast.protocol.codec.custom.vector_pair_codec import VectorPairCodec
+
+_SCORE_ENCODE_OFFSET = 2 * SIZE_OF_FRAME_LENGTH_AND_FLAGS
+_SCORE_DECODE_OFFSET = 0
+_INITIAL_FRAME_SIZE = _SCORE_ENCODE_OFFSET + FLOAT_SIZE_IN_BYTES - SIZE_OF_FRAME_LENGTH_AND_FLAGS
+
+
+class VectorSearchResultCodec:
+    @staticmethod
+    def encode(buf, vector_search_result, is_final=False):
+        initial_frame_buf = create_initial_buffer_custom(_INITIAL_FRAME_SIZE)
+        FixSizedTypesCodec.encode_float(initial_frame_buf, _SCORE_ENCODE_OFFSET, vector_search_result.score)
+        buf.extend(initial_frame_buf)
+        DataCodec.encode(buf, vector_search_result.key)
+        CodecUtil.encode_nullable(buf, vector_search_result.value, DataCodec.encode)
+        ListMultiFrameCodec.encode_nullable(buf, vector_search_result.vectors, VectorPairCodec.encode)
+        if is_final:
+            buf.extend(END_FINAL_FRAME_BUF)
+        else:
+            buf.extend(END_FRAME_BUF)
+
+    @staticmethod
+    def decode(msg):
+        msg.next_frame()
+        initial_frame = msg.next_frame()
+        score = FixSizedTypesCodec.decode_float(initial_frame.buf, _SCORE_DECODE_OFFSET)
+        key = DataCodec.decode(msg)
+        value = CodecUtil.decode_nullable(msg, DataCodec.decode)
+        vectors = ListMultiFrameCodec.decode_nullable(msg, VectorPairCodec.decode)
+        CodecUtil.fast_forward_to_end_frame(msg)
+        return VectorSearchResult(key, value, score, vectors)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/dynamic_config_add_vector_collection_config_codec.py

@@ -0,0 +1,18 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import ListMultiFrameCodec
+from hazelcast.protocol.codec.custom.vector_index_config_codec import VectorIndexConfigCodec
+
+# hex: 0x1B1400
+_REQUEST_MESSAGE_TYPE = 1774592
+# hex: 0x1B1401
+_RESPONSE_MESSAGE_TYPE = 1774593
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, index_configs):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    ListMultiFrameCodec.encode(buf, index_configs, VectorIndexConfigCodec.encode, True)
+    return OutboundMessage(buf, False)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_clear_codec.py

@@ -0,0 +1,15 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+
+# hex: 0x240A00
+_REQUEST_MESSAGE_TYPE = 2361856
+# hex: 0x240A01
+_RESPONSE_MESSAGE_TYPE = 2361857
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name, True)
+    return OutboundMessage(buf, False)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_delete_codec.py

@@ -0,0 +1,17 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+
+# hex: 0x240700
+_REQUEST_MESSAGE_TYPE = 2361088
+# hex: 0x240701
+_RESPONSE_MESSAGE_TYPE = 2361089
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key, True)
+    return OutboundMessage(buf, False, True)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_get_codec.py

@@ -0,0 +1,24 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+from hazelcast.protocol.builtin import CodecUtil
+
+# hex: 0x240400
+_REQUEST_MESSAGE_TYPE = 2360320
+# hex: 0x240401
+_RESPONSE_MESSAGE_TYPE = 2360321
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key, True)
+    return OutboundMessage(buf, True, True)
+
+
+def decode_response(msg):
+    msg.next_frame()
+    return CodecUtil.decode_nullable(msg, VectorDocumentCodec.decode)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_optimize_codec.py

@@ -0,0 +1,17 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import CodecUtil
+
+# hex: 0x240900
+_REQUEST_MESSAGE_TYPE = 2361600
+# hex: 0x240901
+_RESPONSE_MESSAGE_TYPE = 2361601
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, index_name):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    CodecUtil.encode_nullable(buf, index_name, StringCodec.encode, True)
+    return OutboundMessage(buf, True)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_put_all_codec.py

@@ -0,0 +1,19 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import EntryListCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+
+# hex: 0x240300
+_REQUEST_MESSAGE_TYPE = 2360064
+# hex: 0x240301
+_RESPONSE_MESSAGE_TYPE = 2360065
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, entries):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    EntryListCodec.encode(buf, entries, DataCodec.encode, VectorDocumentCodec.encode, True)
+    return OutboundMessage(buf, False, True)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_put_codec.py

@@ -0,0 +1,25 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+from hazelcast.protocol.builtin import CodecUtil
+
+# hex: 0x240100
+_REQUEST_MESSAGE_TYPE = 2359552
+# hex: 0x240101
+_RESPONSE_MESSAGE_TYPE = 2359553
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key, value):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key)
+    VectorDocumentCodec.encode(buf, value, True)
+    return OutboundMessage(buf, False, True)
+
+
+def decode_response(msg):
+    msg.next_frame()
+    return CodecUtil.decode_nullable(msg, VectorDocumentCodec.decode)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_put_if_absent_codec.py

@@ -0,0 +1,25 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+from hazelcast.protocol.builtin import CodecUtil
+
+# hex: 0x240200
+_REQUEST_MESSAGE_TYPE = 2359808
+# hex: 0x240201
+_RESPONSE_MESSAGE_TYPE = 2359809
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key, value):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key)
+    VectorDocumentCodec.encode(buf, value, True)
+    return OutboundMessage(buf, False, True)
+
+
+def decode_response(msg):
+    msg.next_frame()
+    return CodecUtil.decode_nullable(msg, VectorDocumentCodec.decode)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_remove_codec.py

@@ -0,0 +1,24 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+from hazelcast.protocol.builtin import CodecUtil
+
+# hex: 0x240500
+_REQUEST_MESSAGE_TYPE = 2360576
+# hex: 0x240501
+_RESPONSE_MESSAGE_TYPE = 2360577
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key, True)
+    return OutboundMessage(buf, False, True)
+
+
+def decode_response(msg):
+    msg.next_frame()
+    return CodecUtil.decode_nullable(msg, VectorDocumentCodec.decode)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_search_near_vector_codec.py

@@ -0,0 +1,26 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import ListMultiFrameCodec
+from hazelcast.protocol.codec.custom.vector_pair_codec import VectorPairCodec
+from hazelcast.protocol.codec.custom.vector_search_options_codec import VectorSearchOptionsCodec
+from hazelcast.protocol.codec.custom.vector_search_result_codec import VectorSearchResultCodec
+
+# hex: 0x240800
+_REQUEST_MESSAGE_TYPE = 2361344
+# hex: 0x240801
+_RESPONSE_MESSAGE_TYPE = 2361345
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, vectors, options):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    ListMultiFrameCodec.encode(buf, vectors, VectorPairCodec.encode)
+    VectorSearchOptionsCodec.encode(buf, options, True)
+    return OutboundMessage(buf, True)
+
+
+def decode_response(msg):
+    msg.next_frame()
+    return ListMultiFrameCodec.decode(msg, VectorSearchResultCodec.decode)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_set_codec.py

@@ -0,0 +1,19 @@
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer
+from hazelcast.protocol.builtin import StringCodec
+from hazelcast.protocol.builtin import DataCodec
+from hazelcast.protocol.codec.custom.vector_document_codec import VectorDocumentCodec
+
+# hex: 0x240600
+_REQUEST_MESSAGE_TYPE = 2360832
+# hex: 0x240601
+_RESPONSE_MESSAGE_TYPE = 2360833
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+
+
+def encode_request(name, key, value):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name)
+    DataCodec.encode(buf, key)
+    VectorDocumentCodec.encode(buf, value, True)
+    return OutboundMessage(buf, False, True)

hazelcast_python_client-5.5.0/hazelcast/protocol/codec/vector_collection_size_codec.py

@@ -0,0 +1,22 @@
+from hazelcast.protocol.builtin import FixSizedTypesCodec
+from hazelcast.protocol.client_message import OutboundMessage, REQUEST_HEADER_SIZE, create_initial_buffer, RESPONSE_HEADER_SIZE
+from hazelcast.protocol.builtin import StringCodec
+
+# hex: 0x240B00
+_REQUEST_MESSAGE_TYPE = 2362112
+# hex: 0x240B01
+_RESPONSE_MESSAGE_TYPE = 2362113
+
+_REQUEST_INITIAL_FRAME_SIZE = REQUEST_HEADER_SIZE
+_RESPONSE_RESPONSE_OFFSET = RESPONSE_HEADER_SIZE
+
+
+def encode_request(name):
+    buf = create_initial_buffer(_REQUEST_INITIAL_FRAME_SIZE, _REQUEST_MESSAGE_TYPE)
+    StringCodec.encode(buf, name, True)
+    return OutboundMessage(buf, True)
+
+
+def decode_response(msg):
+    initial_frame = msg.next_frame()
+    return FixSizedTypesCodec.decode_long(initial_frame.buf, _RESPONSE_RESPONSE_OFFSET)