deps: bump astrapy from 1.5.2 to 2.0.1 (#1881)

* deps: bump astrapy from 1.5.2 to 2.0.1

Bumps [astrapy](https://github.com/datastax/astrapy) from 1.5.2 to 2.0.1.
- [Release notes](https://github.com/datastax/astrapy/releases)
- [Commits](datastax/astrapy@v1.5.2...v2.0.1)

---
updated-dependencies:
- dependency-name: astrapy
  dependency-version: 2.0.1
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <[email protected]>

* refactor: replaces instances of namespace with keyspace

---------

Signed-off-by: dependabot[bot] <[email protected]>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Collin Dutter <[email protected]>

Author: dependabot[bot]

griptape/drivers/vector/astradb_vector_store_driver.py

@@ -56,8 +56,10 @@ def client(self) -> astrapy.DataAPIClient:
 
     @lazy_property()
     def collection(self) -> astrapy.Collection:
+        if self.token is None:
+            raise ValueError("Astra DB token must be provided.")
         return self.client.get_database(
-            self.api_endpoint, token=self.token, namespace=self.astra_db_namespace
+            self.api_endpoint, token=self.token, keyspace=self.astra_db_namespace
         ).get_collection(self.collection_name)
 
     def delete_vector(self, vector_id: str) -> None:
@@ -96,7 +98,7 @@ def upsert_vector(
         """
         document = {
             k: v
-            for k, v in {"$vector": vector, "_id": vector_id, "namespace": namespace, "meta": meta}.items()
+            for k, v in {"$vector": vector, "_id": vector_id, "keyspace": namespace, "meta": meta}.items()
             if v is not None
         }
         if vector_id is not None:
@@ -115,11 +117,11 @@ def load_entry(self, vector_id: str, *, namespace: Optional[str] = None) -> Opti
         Returns:
             The vector entry (a `BaseVectorStoreDriver.Entry`) if found, otherwise None.
         """
-        find_filter = {k: v for k, v in {"_id": vector_id, "namespace": namespace}.items() if v is not None}
+        find_filter = {k: v for k, v in {"_id": vector_id, "keyspace": namespace}.items() if v is not None}
         match = self.collection.find_one(filter=find_filter, projection={"*": 1})
         if match is not None:
             return BaseVectorStoreDriver.Entry(
-                id=match["_id"], vector=match.get("$vector"), meta=match.get("meta"), namespace=match.get("namespace")
+                id=match["_id"], vector=match.get("$vector"), meta=match.get("meta"), namespace=match.get("keyspace")
             )
         return None
 
@@ -132,10 +134,10 @@ def load_entries(self, *, namespace: Optional[str] = None) -> list[BaseVectorSto
         Returns:
             A list of vector (`BaseVectorStoreDriver.Entry`) entries.
         """
-        find_filter: dict[str, str] = {} if namespace is None else {"namespace": namespace}
+        find_filter: dict[str, str] = {} if namespace is None else {"keyspace": namespace}
         return [
             BaseVectorStoreDriver.Entry(
-                id=match["_id"], vector=match.get("$vector"), meta=match.get("meta"), namespace=match.get("namespace")
+                id=match["_id"], vector=match.get("$vector"), meta=match.get("meta"), namespace=match.get("keyspace")
             )
             for match in self.collection.find(filter=find_filter, projection={"*": 1})
         ]
@@ -165,7 +167,7 @@ def query_vector(
             with their `score` attribute set to the vector similarity to the query.
         """
         query_filter: Optional[dict[str, Any]] = kwargs.get("filter")
-        find_filter_ns: dict[str, Any] = {} if namespace is None else {"namespace": namespace}
+        find_filter_ns: dict[str, Any] = {} if namespace is None else {"keyspace": namespace}
         find_filter = {**(query_filter or {}), **find_filter_ns}
         find_projection: Optional[dict[str, int]] = {"*": 1} if include_vectors else None
         ann_limit = count or BaseVectorStoreDriver.DEFAULT_QUERY_COUNT
@@ -182,7 +184,7 @@ def query_vector(
                 vector=match.get("$vector"),
                 score=match["$similarity"],
                 meta=match.get("meta"),
-                namespace=match.get("namespace"),
+                namespace=match.get("keyspace"),
             )
             for match in matches
         ]

pyproject.toml

@@ -59,7 +59,7 @@ drivers-vector-pgvector = [
   "psycopg2-binary>=2.9.9",
 ]
 drivers-vector-qdrant = ["qdrant-client>=1.10.1"]
-drivers-vector-astra-db = ["astrapy>=1.4"]
+drivers-vector-astra-db = ["astrapy>=2.0"]
 drivers-embedding-amazon-bedrock = ["boto3>=1.34.119"]
 drivers-embedding-amazon-sagemaker = ["boto3>=1.34.119"]
 drivers-embedding-huggingface = [

tests/unit/drivers/vector/test_astra_db_vector_store_driver.py

@@ -50,7 +50,7 @@ def one_document(
             "_id": "doc_id",
             "$vector": [3.0, 2.0, 1.0],
             "meta": "doc_meta",
-            "namespace": "doc_namespace",
+            "keyspace": "doc_namespace",
             "$similarity": 10,
         }
 
@@ -60,7 +60,7 @@ def one_entry(self, one_document):
             id=one_document["_id"],
             vector=one_document["$vector"],
             meta=one_document["meta"],
-            namespace=one_document["namespace"],
+            namespace=one_document["keyspace"],
         )
 
     @pytest.fixture()
@@ -69,7 +69,7 @@ def one_query_entry(self, one_document):
             id=one_document["_id"],
             vector=one_document["$vector"],
             meta=one_document["meta"],
-            namespace=one_document["namespace"],
+            namespace=one_document["keyspace"],
             score=one_document["$similarity"],
         )
 
@@ -91,31 +91,31 @@ def test_load_entry(self, driver, mock_collection, one_entry):
         entry = driver.load_entry("vector_id", namespace="some_namespace")
         assert entry == one_entry
         mock_collection.return_value.find_one.assert_called_once_with(
-            filter={"_id": "vector_id", "namespace": "some_namespace"},
+            filter={"_id": "vector_id", "keyspace": "some_namespace"},
             projection={"*": 1},
         )
 
     def test_load_entry_empty(self, driver, mock_collection_findnothing):
         entry = driver.load_entry("vector_id", namespace="some_namespace")
         assert entry is None
         mock_collection_findnothing.return_value.find_one.assert_called_once_with(
-            filter={"_id": "vector_id", "namespace": "some_namespace"},
+            filter={"_id": "vector_id", "keyspace": "some_namespace"},
             projection={"*": 1},
         )
 
     def test_load_entries(self, driver, mock_collection, one_entry):
         entries = driver.load_entries(namespace="some_namespace")
         assert entries == [one_entry]
         mock_collection.return_value.find.assert_called_once_with(
-            filter={"namespace": "some_namespace"},
+            filter={"keyspace": "some_namespace"},
             projection={"*": 1},
         )
 
     def test_query_vector_allparams(self, driver, mock_collection, one_query_entry):
         entries1 = driver.query_vector([0.0, 0.5], count=999, namespace="some_namespace", include_vectors=True)
         assert entries1 == [one_query_entry]
         mock_collection.return_value.find.assert_called_once_with(
-            filter={"namespace": "some_namespace"},
+            filter={"keyspace": "some_namespace"},
             sort={"$vector": [0.0, 0.5]},
             limit=999,
             projection={"*": 1},
@@ -138,7 +138,7 @@ def test_query_allparams(self, driver, mock_collection, one_query_entry):
         assert entries1 == [one_query_entry]
         query_vector = driver.embedding_driver.embed("some query")
         mock_collection.return_value.find.assert_called_once_with(
-            filter={"namespace": "some_namespace"},
+            filter={"keyspace": "some_namespace"},
             sort={"$vector": query_vector},
             limit=999,
             projection={"*": 1},