sf-vector-sdk 0.2.2__tar.gz → 0.2.3__tar.gz

{sf_vector_sdk-0.2.2 → sf_vector_sdk-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sf-vector-sdk
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python SDK for the Vector Gateway service (embeddings and vector search)
 Requires-Python: >=3.11
 Requires-Dist: redis>=5.0.0

{sf_vector_sdk-0.2.2 → sf_vector_sdk-0.2.3}/vector_sdk/__init__.py

@@ -166,7 +166,7 @@ from vector_sdk.types import (
     validate_model,
 )
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"
 
 __all__ = [
     # Clients (New API)

{sf_vector_sdk-0.2.2 → sf_vector_sdk-0.2.3}/vector_sdk/namespaces/embeddings.py

@@ -154,26 +154,21 @@ class EmbeddingsNamespace(BaseNamespace):
         Raises:
             TimeoutError: If no result is received within the timeout
         """
-        channel = f"embedding:result:{request_id}"
-        pubsub = self._redis.pubsub()
-        pubsub.subscribe(channel)
-
-        try:
-            start_time = datetime.utcnow()
-            while True:
-                message = pubsub.get_message(timeout=1.0)
-                if message and message["type"] == "message":
-                    data = json.loads(message["data"])
-                    return EmbeddingResult.from_dict(data)
-
-                elapsed = (datetime.utcnow() - start_time).total_seconds()
-                if elapsed >= timeout:
-                    raise TimeoutError(
-                        f"No result received for {request_id} within {timeout}s"
-                    )
-        finally:
-            pubsub.unsubscribe(channel)
-            pubsub.close()
+        list_key = f"embedding:response:{request_id}"
+
+        # BRPOP blocks until result is available or timeout
+        result = self._redis.brpop(list_key, timeout=timeout)
+
+        if result is None:
+            raise TimeoutError(
+                f"No result received for {request_id} within {timeout}s"
+            )
+
+        # result = (key, value)
+        data = json.loads(result[1])
+        # Cleanup the response list
+        self._redis.delete(list_key)
+        return EmbeddingResult.from_dict(data)
 
     def create_and_wait(
         self,
@@ -189,8 +184,8 @@ class EmbeddingsNamespace(BaseNamespace):
         """
         Create embeddings and wait for the result.
 
-        This method subscribes to the result channel BEFORE submitting the request,
-        ensuring no race condition where the result is published before we're listening.
+        Uses BRPOP for efficient blocking wait - no race condition since the result
+        is pushed to a list that persists until consumed.
 
         Args:
             texts: List of text inputs
@@ -205,43 +200,22 @@ class EmbeddingsNamespace(BaseNamespace):
         Returns:
             The embedding result
         """
-        # Generate request ID upfront so we can subscribe before submitting
         request_id = str(uuid.uuid4())
-        channel = f"embedding:result:{request_id}"
-
-        # Subscribe BEFORE submitting to avoid race condition
-        pubsub = self._redis.pubsub()
-        pubsub.subscribe(channel)
-
-        try:
-            # Now submit the request (subscription is already active)
-            self.create(
-                texts=texts,
-                content_type=content_type,
-                priority=priority,
-                storage=storage,
-                metadata=metadata,
-                request_id=request_id,
-                embedding_model=embedding_model,
-                embedding_dimensions=embedding_dimensions,
-            )
 
-            # Wait for message with timeout
-            start_time = datetime.utcnow()
-            while True:
-                message = pubsub.get_message(timeout=1.0)
-                if message and message["type"] == "message":
-                    data = json.loads(message["data"])
-                    return EmbeddingResult.from_dict(data)
-
-                elapsed = (datetime.utcnow() - start_time).total_seconds()
-                if elapsed >= timeout:
-                    raise TimeoutError(
-                        f"No result received for {request_id} within {timeout}s"
-                    )
-        finally:
-            pubsub.unsubscribe(channel)
-            pubsub.close()
+        # Submit the request first
+        self.create(
+            texts=texts,
+            content_type=content_type,
+            priority=priority,
+            storage=storage,
+            metadata=metadata,
+            request_id=request_id,
+            embedding_model=embedding_model,
+            embedding_dimensions=embedding_dimensions,
+        )
+
+        # Wait for result via BRPOP
+        return self.wait_for(request_id, timeout)
 
     def get_queue_depth(self) -> dict[str, int]:
         """

{sf_vector_sdk-0.2.2 → sf_vector_sdk-0.2.3}/vector_sdk/namespaces/search.py

@@ -151,26 +151,21 @@ class SearchNamespace(BaseNamespace):
         Raises:
             TimeoutError: If no result is received within the timeout
         """
-        channel = f"query:result:{request_id}"
-        pubsub = self._redis.pubsub()
-        pubsub.subscribe(channel)
-
-        try:
-            start_time = datetime.utcnow()
-            while True:
-                message = pubsub.get_message(timeout=1.0)
-                if message and message["type"] == "message":
-                    data = json.loads(message["data"])
-                    return QueryResult.from_dict(data)
-
-                elapsed = (datetime.utcnow() - start_time).total_seconds()
-                if elapsed >= timeout:
-                    raise TimeoutError(
-                        f"No query result received for {request_id} within {timeout}s"
-                    )
-        finally:
-            pubsub.unsubscribe(channel)
-            pubsub.close()
+        list_key = f"query:response:{request_id}"
+
+        # BRPOP blocks until result is available or timeout
+        result = self._redis.brpop(list_key, timeout=timeout)
+
+        if result is None:
+            raise TimeoutError(
+                f"No query result received for {request_id} within {timeout}s"
+            )
+
+        # result = (key, value)
+        data = json.loads(result[1])
+        # Cleanup the response list
+        self._redis.delete(list_key)
+        return QueryResult.from_dict(data)
 
     def query_and_wait(
         self,
@@ -193,8 +188,8 @@ class SearchNamespace(BaseNamespace):
         """
         Submit a search query and wait for the result.
 
-        This method subscribes to the result channel BEFORE submitting the request,
-        ensuring no race condition where the result is published before we're listening.
+        Uses BRPOP for efficient blocking wait - no race condition since the result
+        is pushed to a list that persists until consumed.
 
         Args:
             query_text: The text to search for
@@ -217,42 +212,25 @@ class SearchNamespace(BaseNamespace):
             The query result
         """
         request_id = str(uuid.uuid4())
-        channel = f"query:result:{request_id}"
-
-        pubsub = self._redis.pubsub()
-        pubsub.subscribe(channel)
-
-        try:
-            self.query(
-                query_text=query_text,
-                database=database,
-                top_k=top_k,
-                min_score=min_score,
-                filters=filters,
-                namespace=namespace,
-                collection=collection,
-                database_name=database_name,
-                include_vectors=include_vectors,
-                include_metadata=include_metadata,
-                embedding_model=embedding_model,
-                embedding_dimensions=embedding_dimensions,
-                priority=priority,
-                metadata=metadata,
-                request_id=request_id,
-            )
 
-            start_time = datetime.utcnow()
-            while True:
-                message = pubsub.get_message(timeout=1.0)
-                if message and message["type"] == "message":
-                    data = json.loads(message["data"])
-                    return QueryResult.from_dict(data)
-
-                elapsed = (datetime.utcnow() - start_time).total_seconds()
-                if elapsed >= timeout:
-                    raise TimeoutError(
-                        f"No query result received for {request_id} within {timeout}s"
-                    )
-        finally:
-            pubsub.unsubscribe(channel)
-            pubsub.close()
+        # Submit the request first
+        self.query(
+            query_text=query_text,
+            database=database,
+            top_k=top_k,
+            min_score=min_score,
+            filters=filters,
+            namespace=namespace,
+            collection=collection,
+            database_name=database_name,
+            include_vectors=include_vectors,
+            include_metadata=include_metadata,
+            embedding_model=embedding_model,
+            embedding_dimensions=embedding_dimensions,
+            priority=priority,
+            metadata=metadata,
+            request_id=request_id,
+        )
+
+        # Wait for result via BRPOP
+        return self.wait_for(request_id, timeout)