langgraph-checkpointer-couchbase 1.0.5__tar.gz → 1.0.7__tar.gz

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/.github/workflows/release.yaml

@@ -1,8 +1,8 @@
 name: Publish Package to PyPI
 on:
   push:
-    branches:
-      - main
+    tags:
+      - "v*"
   workflow_dispatch:
   
 jobs:
@@ -29,10 +29,6 @@ jobs:
       - name: Hatch build
         run: hatch build
 
-      - name: Get hatch version
-        id: hatch_version_step
-        run: echo "VERSION=$(hatch version)" >> $GITHUB_OUTPUT
-
       - name: Publish release distributions to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
 
@@ -40,6 +36,6 @@ jobs:
         id: create_release
         uses: softprops/action-gh-release@v2
         with:
-          tag_name: v${{ steps.hatch_version_step.outputs.VERSION }} 
+          tag_name: ${{ github.ref_name }} 
           draft: false
           prerelease: false

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-checkpointer-couchbase
-Version: 1.0.5
+Version: 1.0.7
 Project-URL: Documentation, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase#readme
 Project-URL: Issues, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase/issues
 Project-URL: Source, https://github.com/couchbase-ecosystem/langgraph-checkpointer-couchbase
@@ -95,58 +95,72 @@ with CouchbaseSaver.from_conn_info(
         bucket_name=os.getenv("CB_BUCKET") or "test",
         scope_name=os.getenv("CB_SCOPE") or "langgraph",
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "1"}}
-        
-        # Run the agent
-        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
-        
-        # Retrieve checkpoints
-        latest_checkpoint = checkpointer.get(config)
-        latest_checkpoint_tuple = checkpointer.get_tuple(config)
-        checkpoint_tuples = list(checkpointer.list(config))
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "1"}}
+    
+    # Run the agent
+    res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
+    
+    # Retrieve checkpoints
+    latest_checkpoint = checkpointer.get(config)
+    latest_checkpoint_tuple = checkpointer.get_tuple(config)
+    checkpoint_tuples = list(checkpointer.list(config))
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
 ```
 
 ### Asynchronous Usage
 
 ```python
 import os
+from acouchbase.cluster import Cluster as ACluster
+from couchbase.auth import PasswordAuthenticator
+from couchbase.options import ClusterOptions
 from langgraph_checkpointer_couchbase import AsyncCouchbaseSaver
 from langgraph.graph import create_react_agent
 
-async with AsyncCouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
+auth = PasswordAuthenticator(
+    os.getenv("CB_USERNAME") or "Administrator",
+    os.getenv("CB_PASSWORD") or "password",
+)
+options = ClusterOptions(auth)
+cluster = await ACluster.connect(os.getenv("CB_CLUSTER") or "couchbase://localhost", options)
+
+bucket_name = os.getenv("CB_BUCKET") or "test"
+scope_name = os.getenv("CB_SCOPE") or "langgraph"
+
+async with AsyncCouchbaseSaver.from_cluster(
+        cluster=cluster,
+        bucket_name=bucket_name,
+        scope_name=scope_name,
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "2"}}
-        
-        # Run the agent asynchronously
-        res = await graph.ainvoke(
-            {"messages": [("human", "what's the weather in nyc")]}, config
-        )
-
-        # Retrieve checkpoints asynchronously
-        latest_checkpoint = await checkpointer.aget(config)
-        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
-        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "2"}}
+    
+    # Run the agent asynchronously
+    res = await graph.ainvoke(
+        {"messages": [("human", "what's the weather in nyc")]}, config
+    )
+
+    # Retrieve checkpoints asynchronously
+    latest_checkpoint = await checkpointer.aget(config)
+    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
+    checkpoint_tuples = [c async for c in checkpointer.alist(config)]
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
+
+# Close the cluster when done
+await cluster.close()
 ```
 
 ## Configuration Options

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/README.md

@@ -68,58 +68,72 @@ with CouchbaseSaver.from_conn_info(
         bucket_name=os.getenv("CB_BUCKET") or "test",
         scope_name=os.getenv("CB_SCOPE") or "langgraph",
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "1"}}
-        
-        # Run the agent
-        res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
-        
-        # Retrieve checkpoints
-        latest_checkpoint = checkpointer.get(config)
-        latest_checkpoint_tuple = checkpointer.get_tuple(config)
-        checkpoint_tuples = list(checkpointer.list(config))
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "1"}}
+    
+    # Run the agent
+    res = graph.invoke({"messages": [("human", "what's the weather in sf")]}, config)
+    
+    # Retrieve checkpoints
+    latest_checkpoint = checkpointer.get(config)
+    latest_checkpoint_tuple = checkpointer.get_tuple(config)
+    checkpoint_tuples = list(checkpointer.list(config))
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
 ```
 
 ### Asynchronous Usage
 
 ```python
 import os
+from acouchbase.cluster import Cluster as ACluster
+from couchbase.auth import PasswordAuthenticator
+from couchbase.options import ClusterOptions
 from langgraph_checkpointer_couchbase import AsyncCouchbaseSaver
 from langgraph.graph import create_react_agent
 
-async with AsyncCouchbaseSaver.from_conn_info(
-        cb_conn_str=os.getenv("CB_CLUSTER") or "couchbase://localhost",
-        cb_username=os.getenv("CB_USERNAME") or "Administrator",
-        cb_password=os.getenv("CB_PASSWORD") or "password",
-        bucket_name=os.getenv("CB_BUCKET") or "test",
-        scope_name=os.getenv("CB_SCOPE") or "langgraph",
+auth = PasswordAuthenticator(
+    os.getenv("CB_USERNAME") or "Administrator",
+    os.getenv("CB_PASSWORD") or "password",
+)
+options = ClusterOptions(auth)
+cluster = await ACluster.connect(os.getenv("CB_CLUSTER") or "couchbase://localhost", options)
+
+bucket_name = os.getenv("CB_BUCKET") or "test"
+scope_name = os.getenv("CB_SCOPE") or "langgraph"
+
+async with AsyncCouchbaseSaver.from_cluster(
+        cluster=cluster,
+        bucket_name=bucket_name,
+        scope_name=scope_name,
     ) as checkpointer:
-        # Create the agent with checkpointing
-        graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
-        
-        # Configure with a unique thread ID
-        config = {"configurable": {"thread_id": "2"}}
-        
-        # Run the agent asynchronously
-        res = await graph.ainvoke(
-            {"messages": [("human", "what's the weather in nyc")]}, config
-        )
-
-        # Retrieve checkpoints asynchronously
-        latest_checkpoint = await checkpointer.aget(config)
-        latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
-        checkpoint_tuples = [c async for c in checkpointer.alist(config)]
-
-        print(latest_checkpoint)
-        print(latest_checkpoint_tuple)
-        print(checkpoint_tuples)
+    # Create the agent with checkpointing
+    graph = create_react_agent(model, tools=tools, checkpointer=checkpointer)
+    
+    # Configure with a unique thread ID
+    config = {"configurable": {"thread_id": "2"}}
+    
+    # Run the agent asynchronously
+    res = await graph.ainvoke(
+        {"messages": [("human", "what's the weather in nyc")]}, config
+    )
+
+    # Retrieve checkpoints asynchronously
+    latest_checkpoint = await checkpointer.aget(config)
+    latest_checkpoint_tuple = await checkpointer.aget_tuple(config)
+    checkpoint_tuples = [c async for c in checkpointer.alist(config)]
+
+    print(latest_checkpoint)
+    print(latest_checkpoint_tuple)
+    print(checkpoint_tuples)
+
+# Close the cluster when done
+await cluster.close()
 ```
 
 ## Configuration Options

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/langgraph_checkpointer_couchbase/async_cb_saver.py

@@ -1,12 +1,14 @@
 from contextlib import asynccontextmanager
 from datetime import timedelta
 from typing import Any, AsyncIterator, Dict, Optional, Sequence, Tuple
+import logging
 
 from langchain_core.runnables import RunnableConfig
 from acouchbase.cluster import Cluster as ACluster
 from acouchbase.bucket import Bucket as ABucket
 from couchbase.auth import PasswordAuthenticator
 from couchbase.options import ClusterOptions, QueryOptions, UpsertOptions
+from couchbase.exceptions import CollectionAlreadyExistsException
 
 from langgraph.checkpoint.base import (
     BaseCheckpointSaver,
@@ -18,6 +20,8 @@ from langgraph.checkpoint.base import (
 )
 from .utils import _encode_binary, _decode_binary
 
+logger = logging.getLogger(__name__)
+
 class AsyncCouchbaseSaver(BaseCheckpointSaver):
     """A checkpoint saver that stores checkpoints in a Couchbase database."""
 
@@ -35,9 +39,35 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         self.cluster = cluster
         self.bucket_name = bucket_name
         self.scope_name = scope_name
+        self.bucket = self.cluster.bucket(bucket_name)
+        self.scope = self.bucket.scope(scope_name)
         self.checkpoints_collection_name = checkpoints_collection_name
         self.checkpoint_writes_collection_name = checkpoint_writes_collection_name
 
+    async def create_collections(self):
+        """Create collections in the Couchbase bucket if they do not exist."""
+
+        collection_manager = self.bucket.collections()
+        try:
+            await collection_manager.create_collection(self.scope_name, self.checkpoints_collection_name)
+        except CollectionAlreadyExistsException as _:
+            pass
+        except Exception as e:
+            logger.exception("Error creating collections")
+            raise e
+        finally:
+            self.checkpoints_collection =  self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
+        
+        try:
+            await collection_manager.create_collection(self.scope_name, self.checkpoint_writes_collection_name)
+        except CollectionAlreadyExistsException as _:
+            pass
+        except Exception as e:
+            logger.exception("Error creating collections")
+            raise e
+        finally:
+            self.checkpoint_writes_collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
+
     @classmethod
     @asynccontextmanager
     async def from_conn_info(
@@ -69,15 +99,25 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             cls.bucket_name = bucket_name
             cls.scope_name = scope_name
 
-            saver = AsyncCouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
-            cls.bucket = cluster.bucket(bucket_name)
-            await cls.bucket.on_connect()
+            bucket = cluster.bucket(bucket_name)
+            await bucket.on_connect()
+
+            saver = AsyncCouchbaseSaver(
+                cluster,
+                bucket_name,
+                scope_name,
+                checkpoints_collection_name,
+                checkpoint_writes_collection_name,
+            )
+
+            await saver.create_collections()
             
             yield saver
         finally:
             if cluster:
                 await cluster.close()
 
+
     @classmethod
     @asynccontextmanager
     async def from_cluster(
@@ -98,9 +138,18 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             AsyncCouchbaseSaver: An instance of the AsyncCouchbaseSaver
         """        
         
-        saver = AsyncCouchbaseSaver(cluster, bucket_name, scope_name, checkpoints_collection_name, checkpoint_writes_collection_name)
-        cls.bucket = cluster.bucket(bucket_name)
-        await cls.bucket.on_connect()
+        bucket = cluster.bucket(bucket_name)
+        await bucket.on_connect()
+
+        saver = AsyncCouchbaseSaver(
+            cluster,
+            bucket_name,
+            scope_name,
+            checkpoints_collection_name,
+            checkpoint_writes_collection_name,
+        )
+
+        await saver.create_collections()
         
         yield saver
 
@@ -123,10 +172,10 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         checkpoint_id = get_checkpoint_id(config)
 
         if checkpoint_id:
-            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
+            query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
             query_params = [thread_id, checkpoint_ns, checkpoint_id]
         else:
-            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
+            query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
             query_params = [thread_id, checkpoint_ns]
 
         result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
@@ -140,7 +189,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             }
             checkpoint = self.serde.loads_typed((doc["type"], _decode_binary(doc["checkpoint"])))
 
-            serialized_writes_query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
+            serialized_writes_query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
             serialized_writes_params = [thread_id, checkpoint_ns, doc["checkpoint_id"] or ""]
             
             serialized_writes_result = self.cluster.query(serialized_writes_query, QueryOptions(positional_parameters=serialized_writes_params))
@@ -149,7 +198,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             async for write_doc in serialized_writes_result:
                 checkpoint_writes = write_doc.get(self.checkpoint_writes_collection_name, {})
                 if "task_id" not in checkpoint_writes:
-                    print("Error: 'task_id' is not present in checkpoint_writes")
+                    logger.warning("'task_id' is not present in checkpoint_writes")
                 else:
                     pending_writes.append(
                         (
@@ -200,7 +249,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
             AsyncIterator[CheckpointTuple]: An asynchronous iterator of checkpoint tuples.
         """
 
-        query = f"SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE 1=1"
+        query = f"SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE 1=1"
         query_params = []
 
         if config is not None:
@@ -294,6 +343,8 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
 
         upsert_key = f"{thread_id}::{checkpoint_ns}::{checkpoint_id}"
 
+        # ensure bucket connected (idempotent)
+        await self.bucket.on_connect()
         collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
         await collection.upsert(upsert_key, (doc), UpsertOptions(timeout=timedelta(seconds=5)))
 
@@ -324,6 +375,7 @@ class AsyncCouchbaseSaver(BaseCheckpointSaver):
         checkpoint_ns = config["configurable"]["checkpoint_ns"]
         checkpoint_id = config["configurable"]["checkpoint_id"]
 
+        await self.bucket.on_connect()
         collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
 
         for idx, (channel, value) in enumerate(writes):

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/langgraph_checkpointer_couchbase/couchbase_saver.py

@@ -1,6 +1,7 @@
 from contextlib import contextmanager
 from datetime import timedelta
 from typing import Any, Dict, Iterator, Optional, Sequence, Tuple
+import logging
 
 from langchain_core.runnables import RunnableConfig
 from couchbase.cluster import Cluster
@@ -19,6 +20,8 @@ from langgraph.checkpoint.base import (
 )
 
 from .utils import _encode_binary, _decode_binary
+
+logger = logging.getLogger(__name__)
 class CouchbaseSaver(BaseCheckpointSaver):
     """A checkpoint saver that stores checkpoints in a Couchbase database.
     
@@ -118,7 +121,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
         except CollectionAlreadyExistsException as _:
             pass
         except Exception as e:
-            print(f"Error creating collections: {e}")
+            logger.exception("Error creating collections")
             raise e
         finally:
             self.checkpoints_collection = self.bucket.scope(self.scope_name).collection(self.checkpoints_collection_name)
@@ -128,7 +131,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
         except CollectionAlreadyExistsException as _:
             pass
         except Exception as e:
-            print(f"Error creating collections: {e}")
+            logger.exception("Error creating collections")
             raise e
         finally:
             self.checkpoint_writes_collection = self.bucket.scope(self.scope_name).collection(self.checkpoint_writes_collection_name)
@@ -153,10 +156,10 @@ class CouchbaseSaver(BaseCheckpointSaver):
         checkpoint_id = get_checkpoint_id(config)
 
         if checkpoint_id:
-            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
+            query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3 ORDER BY checkpoint_id DESC LIMIT 1'
             query_params = [thread_id, checkpoint_ns, checkpoint_id]
         else:
-            query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
+            query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 ORDER BY checkpoint_id DESC LIMIT 1'
             query_params = [thread_id, checkpoint_ns]
 
         result = self.cluster.query(query, QueryOptions(positional_parameters=query_params))
@@ -173,7 +176,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
             checkpoint_data = _decode_binary(doc["checkpoint"])
             checkpoint = self.serde.loads_typed((doc["type"], checkpoint_data))
 
-            serialized_writes_query = f'SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
+            serialized_writes_query = f'SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoint_writes_collection_name}` WHERE thread_id = $1 AND checkpoint_ns = $2 AND checkpoint_id = $3'
             serialized_writes_params = [thread_id, checkpoint_ns, doc["checkpoint_id"] or ""]
             serialized_writes_result = self.cluster.query(serialized_writes_query, QueryOptions(positional_parameters=serialized_writes_params))
 
@@ -181,7 +184,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
             for write_doc in serialized_writes_result:
                 checkpoint_writes = write_doc.get(self.checkpoint_writes_collection_name, {})
                 if "task_id" not in checkpoint_writes:
-                    print("Error: 'task_id' is not present in checkpoint_writes")
+                    logger.warning("'task_id' is not present in checkpoint_writes")
                 else:
                     # Decode and deserialize value data
                     value_data = _decode_binary(checkpoint_writes["value"])
@@ -238,7 +241,7 @@ class CouchbaseSaver(BaseCheckpointSaver):
             Iterator[CheckpointTuple]: An iterator of checkpoint tuples.
         """
 
-        query = f"SELECT * FROM {self.bucket_name}.{self.scope_name}.`{self.checkpoints_collection_name}` WHERE 1=1"
+        query = f"SELECT * FROM `{self.bucket_name}`.`{self.scope_name}`.`{self.checkpoints_collection_name}` WHERE 1=1"
         query_params = []
 
         if config is not None:

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-checkpointer-couchbase"
-version = "1.0.5"
+version = "1.0.7"
 description = ''
 readme = "README.md"
 requires-python = ">=3.8"

{langgraph_checkpointer_couchbase-1.0.5 → langgraph_checkpointer_couchbase-1.0.7}/tests/agent_e2e_test.py

@@ -4,7 +4,7 @@ from langchain_core.runnables import ConfigurableField
 from langchain_core.tools import tool
 from langchain_openai import ChatOpenAI
 from langgraph.prebuilt import create_react_agent
-from langgraph_checkpoint_couchbase import CouchbaseSaver, AsyncCouchbaseSaver
+from langgraph_checkpointer_couchbase import CouchbaseSaver, AsyncCouchbaseSaver
 from dotenv import load_dotenv
 import os
 load_dotenv()