langgraph_checkpoint_cosmosdb 0.2.6__py3-none-any.whl

langgraph_checkpoint_cosmosdb/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langgraph_checkpoint_cosmosdb/__init__.py

@@ -0,0 +1,7 @@
+
+
+from langgraph_checkpoint_cosmosdb.cosmosdbSaver import CosmosDBSaver
+from .cosmosSerializer import CosmosSerializer
+
+__all__ = ["CosmosDBSaver", "CosmosSerializer"]
+

langgraph_checkpoint_cosmosdb/cosmosSerializer.py

@@ -0,0 +1,24 @@
+import base64
+
+class CosmosSerializer:
+    def __init__(self, serde):
+        self.serde = serde
+    
+    def dumps_typed(self, obj):
+        type_, data = self.serde.dumps_typed(obj)
+        data_base64 = base64.b64encode(data).decode('utf-8')
+        return type_, data_base64
+
+    def loads_typed(self, data):
+        type_name, serialized_obj = data
+        serialized_obj = base64.b64decode(serialized_obj.encode('utf-8'))
+        return self.serde.loads_typed((type_name, serialized_obj))
+
+    def dumps(self, obj):
+        data = self.serde.dumps(obj)
+        data_base64 = base64.b64encode(data).decode('utf-8')
+        return data_base64
+
+    def loads(self, serialized_obj):
+        serialized_obj = base64.b64decode(serialized_obj.encode('utf-8'))
+        return self.serde.loads(serialized_obj)

langgraph_checkpoint_cosmosdb/cosmosdbSaver.py

@@ -0,0 +1,453 @@
+# create cosmosdb Saver (langgraph checkpointer) basis dynamodb implementation in included code include=src/langgraph_dynamodb_saver/dynamodbSaver.py 
+# in case of cosmosdb PK becomes partition_key and SK will be id.
+# @!
+
+import copy
+from contextlib import contextmanager
+from typing import Any, Iterator, List, Optional, Tuple, Union
+
+from langchain_core.runnables import RunnableConfig
+
+from langgraph.checkpoint.base import WRITES_IDX_MAP, BaseCheckpointSaver, ChannelVersions, Checkpoint, CheckpointMetadata, CheckpointTuple, PendingWrite, get_checkpoint_id
+from langgraph.checkpoint.serde.base import SerializerProtocol
+from azure.cosmos import CosmosClient, exceptions, PartitionKey
+from azure.cosmos.exceptions import CosmosHttpResponseError
+from azure.identity import DefaultAzureCredential, CredentialUnavailableError
+from langgraph_checkpoint_cosmosdb.cosmosSerializer import CosmosSerializer
+import os
+import asyncio
+
+COSMOSDB_KEY_SEPARATOR = "$"
+
+def _make_cosmosdb_checkpoint_key(thread_id: str, checkpoint_ns: str, checkpoint_id: str) -> str:
+    return COSMOSDB_KEY_SEPARATOR.join([
+        "checkpoint", thread_id, checkpoint_ns, checkpoint_id
+    ])
+
+
+def _make_cosmosdb_checkpoint_writes_key(thread_id: str, checkpoint_ns: str, checkpoint_id: str, task_id: str, idx: Optional[int]) -> str:
+    if idx is None:
+        return COSMOSDB_KEY_SEPARATOR.join([
+            "writes", thread_id, checkpoint_ns, checkpoint_id, task_id
+        ])
+
+    return COSMOSDB_KEY_SEPARATOR.join([
+        "writes", thread_id, checkpoint_ns, checkpoint_id, task_id, str(idx)
+    ])
+
+
+def _parse_cosmosdb_checkpoint_key(cosmosdb_key: str) -> dict:
+    namespace, thread_id, checkpoint_ns, checkpoint_id = cosmosdb_key.split(
+        COSMOSDB_KEY_SEPARATOR
+    )
+    if namespace != "checkpoint":
+        raise ValueError("Expected checkpoint key to start with 'checkpoint'")
+
+    return {
+        "thread_id": thread_id,
+        "checkpoint_ns": checkpoint_ns,
+        "checkpoint_id": checkpoint_id,
+    }
+
+
+def _parse_cosmosdb_checkpoint_writes_key(cosmosdb_key: str) -> dict:
+    namespace, thread_id, checkpoint_ns, checkpoint_id, task_id, idx = cosmosdb_key.split(
+        COSMOSDB_KEY_SEPARATOR
+    )
+    if namespace != "writes":
+        raise ValueError("Expected checkpoint key to start with 'writes'")
+
+    return {
+        "thread_id": thread_id,
+        "checkpoint_ns": checkpoint_ns,
+        "checkpoint_id": checkpoint_id,
+        "task_id": task_id,
+        "idx": idx,
+    }
+
+
+def _filter_keys(keys: List[str], before: Optional[RunnableConfig], limit: Optional[int]) -> list:
+    if before:
+        keys = [
+            k
+            for k in keys
+            if _parse_cosmosdb_checkpoint_key(k)["checkpoint_id"]
+            < before["configurable"]["checkpoint_id"]
+        ]
+
+    keys = sorted(
+        keys,
+        key=lambda k: _parse_cosmosdb_checkpoint_key(k)["checkpoint_id"],
+        reverse=True,
+    )
+    if limit:
+        keys = keys[:limit]
+    return keys
+
+
+def _load_writes(serde: CosmosSerializer, task_id_to_data: dict[tuple[str, str], dict]) -> list[PendingWrite]:
+    writes = [
+        (
+            task_id,
+            data["channel"],
+            serde.loads_typed((data["type"], data["value"])),
+        )
+        for (task_id, _), data in task_id_to_data.items()
+    ]
+    return writes
+
+
+def _parse_cosmosdb_checkpoint_data(serde: CosmosSerializer, key: str, data: dict, pending_writes: Optional[List[PendingWrite]] = None) -> Optional[CheckpointTuple]:
+    if not data:
+        return None
+
+    parsed_key = _parse_cosmosdb_checkpoint_key(key)
+    thread_id = parsed_key["thread_id"]
+    checkpoint_ns = parsed_key["checkpoint_ns"]
+    checkpoint_id = parsed_key["checkpoint_id"]
+    config = {
+        "configurable": {
+            "thread_id": thread_id,
+            "checkpoint_ns": checkpoint_ns,
+            "checkpoint_id": checkpoint_id,
+        }
+    }
+
+    checkpoint = serde.loads_typed((data["type"], data["checkpoint"]))
+    metadata = serde.loads_typed(data["metadata"])
+    parent_checkpoint_id = data.get("parent_checkpoint_id", "")
+    parent_config = (
+        {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": parent_checkpoint_id,
+            }
+        }
+        if parent_checkpoint_id
+        else None
+    )
+    return CheckpointTuple(
+        config=config,
+        checkpoint=checkpoint,
+        metadata=metadata,
+        parent_config=parent_config,
+        pending_writes=pending_writes,
+    )
+
+
+class CosmosDBSaver(BaseCheckpointSaver):
+    container: Any
+
+    def __init__(
+        self,
+        database_name: str,
+        container_name: str,
+        reducer=None,
+        messages_key: str = "messages",
+    ):
+        """
+        Args:
+            database_name:  CosmosDB database name.
+            container_name: CosmosDB container name.
+            reducer:        Optional ``MessageReducer`` from ``agentstate-reducer``.
+                            When set, the reducer is applied to the ``messages_key``
+                            channel of every checkpoint before it is persisted.
+            messages_key:   Name of the state channel that holds the message list.
+                            Defaults to ``"messages"``.
+        """
+        super().__init__()
+        self.reducer = reducer
+        self.messages_key = messages_key
+        endpoint = os.getenv("COSMOSDB_ENDPOINT")
+        if not endpoint:
+            raise ValueError("COSMOSDB_ENDPOINT environment variable is not set")
+        key = os.getenv("COSMOSDB_KEY")
+
+        try:
+            if key:
+                # Use key-based authentication
+                self.client = CosmosClient(endpoint, key)
+                self.database = self.client.create_database_if_not_exists(database_name)
+                self.container = self.database.create_container_if_not_exists(
+                    id=container_name,
+                    partition_key=PartitionKey(path="/partition_key")
+                )
+            else:
+                # Use default credentials (e.g., Azure Managed Identity)
+                credential = DefaultAzureCredential()
+                self.client = CosmosClient(endpoint, credential=credential)
+                self.database = self.client.get_database_client(database_name)
+                self.container = self.database.get_container_client(container_name)
+        except CredentialUnavailableError as e:
+            raise RuntimeError(
+                "Failed to obtain default credentials. Ensure the environment is correctly configured for DefaultAzureCredential."
+            ) from e
+        except Exception as e:
+            raise RuntimeError("An unexpected error occurred during CosmosClient initialization.") from e
+
+        self.cosmos_serde = CosmosSerializer(self.serde)
+        self.database = self.client.get_database_client(database_name)
+        self.container = self.database.create_container_if_not_exists(
+            id=container_name,
+            partition_key=PartitionKey(path="/partition_key")
+        )
+
+    @classmethod
+    @contextmanager
+    def from_conn_info(cls, *, endpoint: str, key: str, database_name: str, container_name: str) -> Iterator["CosmosDBSaver"]:
+        saver = None
+        try:
+            saver = CosmosDBSaver(endpoint, key, database_name, container_name)
+            yield saver
+        finally:
+            pass
+
+    def _apply_reducer(self, checkpoint: Checkpoint) -> Checkpoint:
+        """Return a checkpoint with the messages channel reduced (non-mutating)."""
+        if self.reducer is None:
+            return checkpoint
+        channel_values = checkpoint.get("channel_values", {})
+        messages = channel_values.get(self.messages_key)
+        if not messages:
+            return checkpoint
+        result = self.reducer.reduce(existing=messages, new=[])
+        new_channel_values = dict(channel_values)
+        new_channel_values[self.messages_key] = result.surviving
+        new_checkpoint = copy.copy(checkpoint)
+        new_checkpoint["channel_values"] = new_channel_values
+        return new_checkpoint
+
+    def put(self, config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, new_versions: ChannelVersions) -> RunnableConfig:
+        checkpoint = self._apply_reducer(checkpoint)
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"]["checkpoint_ns"]
+        checkpoint_id = checkpoint["id"]
+        parent_checkpoint_id = config["configurable"].get("checkpoint_id")
+        key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, checkpoint_id)
+        partition_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, '')
+       
+        type_, serialized_checkpoint = self.cosmos_serde.dumps_typed(checkpoint)
+        serialized_metadata = self.cosmos_serde.dumps_typed(metadata)
+        data = {
+            "partition_key": partition_key,
+            "id": key,
+            "checkpoint": serialized_checkpoint,
+            "type": type_,
+            "metadata": serialized_metadata,
+            "parent_checkpoint_id": parent_checkpoint_id
+            if parent_checkpoint_id
+            else "",
+        }
+        try:
+            self.container.create_item(data)
+        except CosmosHttpResponseError as e:
+            print(f"Unexpected error ({e.status_code}): {e.message}")
+            raise
+        
+        return {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": checkpoint_ns,
+                "checkpoint_id": checkpoint_id,
+            }
+        }
+
+    def put_writes(self, config: RunnableConfig, writes: List[Tuple[str, Any]], task_id: str) -> None:
+       
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = config["configurable"]["checkpoint_id"]
+
+         # Decide on the operation: upsert or insert
+        is_upsert = all(w[0] in WRITES_IDX_MAP for w in writes)
+
+        for idx, (channel, value) in enumerate(writes):
+            key = _make_cosmosdb_checkpoint_writes_key(
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id,
+                task_id,
+                WRITES_IDX_MAP.get(channel, idx),
+            )
+            partition_key = _make_cosmosdb_checkpoint_writes_key(
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id, 
+                '',
+                ''
+            )
+            type_, serialized_value = self.cosmos_serde.dumps_typed(value)
+
+            data = {"partition_key": partition_key,"id": key, "channel": channel, "type": type_, "value": serialized_value}
+           
+            if is_upsert:
+                self.container.upsert_item(data)
+            else:   
+                try:
+                    self.container.create_item(data)
+                except CosmosHttpResponseError as e:
+                    if e.status_code != 409:  # Conflict: Item already exists
+                        print(f"Unexpected error ({e.status_code}): {e.message}")
+                        raise
+
+    def get_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+       
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_id = get_checkpoint_id(config)
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+
+        partition_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, '')
+        checkpoint_key = self._get_checkpoint_key(
+            self.container, thread_id, checkpoint_ns, checkpoint_id
+        )
+        if not checkpoint_key:
+            return None
+        
+        checkpoint_id = _parse_cosmosdb_checkpoint_key(checkpoint_key)["checkpoint_id"]
+
+        query = "SELECT * FROM c WHERE c.partition_key=@partition_key AND c.id=@checkpoint_key"
+        parameters = [
+            {"name": "@partition_key", "value": partition_key},
+            {"name": "@checkpoint_key", "value": checkpoint_key}
+        ]
+        items = list(self.container.query_items(query=query, parameters=parameters, enable_cross_partition_query=True))
+        checkpoint_data = items[0] if items else {}
+
+        pending_writes = self._load_pending_writes(
+            thread_id, checkpoint_ns, checkpoint_id
+        )
+        return _parse_cosmosdb_checkpoint_data(
+            self.cosmos_serde, checkpoint_key, checkpoint_data, pending_writes=pending_writes
+        )
+
+    def list(self, config: Optional[RunnableConfig], *, filter: Optional[dict[str, Any]] = None, before: Optional[RunnableConfig] = None, limit: Optional[int] = None) -> Iterator[CheckpointTuple]:
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+
+        partition_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, '')
+
+        query = "SELECT * FROM c WHERE c.partition_key=@partition_key"
+        parameters = [
+            {"name": "@partition_key", "value": partition_key}
+        ]
+        items = list(self.container.query_items(query=query, parameters=parameters, enable_cross_partition_query=True))
+        
+        for data in items:
+            if data and "checkpoint" in data and "metadata" in data:
+                key = data["id"]
+                checkpoint_id = _parse_cosmosdb_checkpoint_key(key)[
+                    "checkpoint_id"
+                ]
+                pending_writes = self._load_pending_writes(
+                    thread_id, checkpoint_ns, checkpoint_id
+                )
+                yield _parse_cosmosdb_checkpoint_data(
+                    self.cosmos_serde, key, data, pending_writes=pending_writes
+                )
+
+    def _load_pending_writes(self, thread_id: str, checkpoint_ns: str, checkpoint_id: str) -> List[PendingWrite]:
+        
+        partition_key = _make_cosmosdb_checkpoint_writes_key(
+                thread_id,
+                checkpoint_ns,
+                checkpoint_id, 
+                '',
+                ''
+            )
+
+
+        query = "SELECT * FROM c WHERE c.partition_key=@partition_key"
+        parameters = [
+            {"name": "@partition_key", "value": partition_key}
+        ]
+        writes = list(self.container.query_items(query=query, parameters=parameters, enable_cross_partition_query=True))
+        
+        parsed_keys = [
+            _parse_cosmosdb_checkpoint_writes_key(write["id"]) for write in writes
+        ]
+        pending_writes = _load_writes(
+            self.cosmos_serde,
+            {
+                (parsed_key["task_id"], parsed_key["idx"]): write
+                for write, parsed_key in sorted(
+                    zip(writes, parsed_keys), key=lambda x: x[1]["idx"]
+                )
+            },
+        )
+        return pending_writes
+
+    def _get_checkpoint_key(self, container, thread_id: str, checkpoint_ns: str, checkpoint_id: Optional[str]) -> Optional[str]:
+        if checkpoint_id:
+            return _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, checkpoint_id)
+        
+        partition_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_ns, '')
+
+        query = "SELECT * FROM c WHERE c.partition_key=@partition_key"
+        parameters = [
+            {"name": "@partition_key", "value": partition_key}
+        ]
+        all_keys = list(container.query_items(query=query, parameters=parameters, enable_cross_partition_query=True))
+        
+        if not all_keys:
+            return None
+        latest_key = max(
+            all_keys,
+            key=lambda k: _parse_cosmosdb_checkpoint_key(k["id"])["checkpoint_id"],
+        )
+        return latest_key["id"]
+
+
+    async def aget_tuple(self, config: RunnableConfig) -> Optional[CheckpointTuple]:
+        return await asyncio.to_thread(self.get_tuple, config)
+
+    async def asnapshot(self, checkpoint: Checkpoint, config: RunnableConfig) -> None:
+        await asyncio.to_thread(
+            self.put,
+            config,
+            checkpoint,
+            CheckpointMetadata(),
+            ChannelVersions()
+        )
+
+    async def awrite(self, write: PendingWrite, config: RunnableConfig) -> None:
+        await asyncio.to_thread(
+            self.put_writes,
+            config,
+            [(write.channel, write.value)],
+            write.task_id
+        )
+
+    async def alist(self, config: Optional[RunnableConfig], *, filter: Optional[dict[str, Any]] = None, before: Optional[RunnableConfig] = None, limit: Optional[int] = None) -> Iterator[CheckpointTuple]:
+        return await asyncio.to_thread(
+            lambda: list(self.list(config=config, filter=filter, before=before, limit=limit))
+        )
+
+    async def aput(self, config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, new_versions: ChannelVersions) -> RunnableConfig:
+        return await asyncio.to_thread(self.put, config, checkpoint, metadata, new_versions)
+
+    async def aput_writes(self, config: RunnableConfig, writes: Union[List[PendingWrite], List[Tuple[str, Any]]], task_id: Optional[str] = None) -> None:
+        await asyncio.to_thread(self.put_writes, config, writes, task_id)
+
+    async def adelete(self, thread_id: str, checkpoint_namespace: str, checkpoint_id: str) -> None:
+        checkpoint_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_namespace, checkpoint_id)
+        writes_key_prefix = _make_cosmosdb_checkpoint_writes_key(thread_id, checkpoint_namespace, checkpoint_id, "", "")
+        partition_key = _make_cosmosdb_checkpoint_key(thread_id, checkpoint_namespace, '')
+        try:
+            await asyncio.to_thread(self.container.delete_item, item=checkpoint_key, partition_key=partition_key)
+        except CosmosHttpResponseError as e:
+            if e.status_code != 404:
+                raise
+        query = "SELECT c.id FROM c WHERE STARTSWITH(c.id, @prefix)"
+        parameters = [{"name": "@prefix", "value": writes_key_prefix}]
+        items = await asyncio.to_thread(
+            lambda: list(self.container.query_items(query=query, parameters=parameters, enable_cross_partition_query=True))
+        )
+        for item in items:
+            try:
+                await asyncio.to_thread(self.container.delete_item, item=item["id"], partition_key=writes_key_prefix)
+            except CosmosHttpResponseError as e:
+                if e.status_code != 404:
+                    raise
+
+

langgraph_checkpoint_cosmosdb-0.2.6.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: langgraph_checkpoint_cosmosdb
+Version: 0.2.6
+Summary: Azure CosmosDB checkpoint saver implementation for LangGraph
+Author-email: Kamal <skamalj@github.com>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: azure-cosmos
+Requires-Dist: azure-identity
+Requires-Dist: langchain-core
+Requires-Dist: langgraph
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: reducer
+Requires-Dist: agentstate-reducer>=0.1.1; extra == 'reducer'
+Description-Content-Type: text/markdown
+
+# LangGraph Checkpoint CosmosDB
+
+This project provides an implementation of a checkpoint saver for LangGraph using Azure CosmosDB. 
+
+## Features
+- Save and retrieve langgraph checkpoints in Azure CosmosDB.
+- Suppports both sync and async saver functionality
+
+## Installation
+
+To install the package, ensure you have Python 3.9 or higher, and run:
+
+```pip install langgraph-checkpoint-cosmosdb```
+
+## Usage
+
+### Setting Up Environment
+
+To use the `CosmosDBSaver`
+- You need to set CosmosDB endpoint and key if you want it to create your specified database and container.
+```
+export COSMOSDB_ENDPOINT='your_cosmosdb_endpoint'
+export COSMOSDB_KEY='your_cosmosdb_key'
+```
+- If database and container already exists then this can work via default RBAC credentials. Ex. az login or by setting TENANT_ID, CLIENT_ID and CLIENT_SECRET in environment.
+    - For user-assigned managed identity, ensure AZURE_CLIENT_ID environment variable is set to the identity's client ID. 
+    - Note that in this case error will be thrown if database and container do not exist.
+  
+
+
+## Import
+
+```
+from langgraph_checkpoint_cosmosdb import CosmosDBSaver
+```
+
+## Initialize the saver
+Database and Container is created if it does not exists
+```
+saver = CosmosDBSaver(database_name='your_database', container_name='your_container')
+```
+
+## Limitations
+List function does not support filters. You can only pass config on thread id to get the list.
+
+```
+print(list(memory.list(config=config)))
+```
+## License
+
+This project is licensed under the MIT License.

langgraph_checkpoint_cosmosdb-0.2.6.dist-info/RECORD

@@ -0,0 +1,7 @@
+langgraph_checkpoint_cosmosdb/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+langgraph_checkpoint_cosmosdb/__init__.py,sha256=G3i7a_V2qq_cHqTX5o0qJgvoom_Iv0zIedUn5iiqiOk,176
+langgraph_checkpoint_cosmosdb/cosmosSerializer.py,sha256=m9XQ45IaQ02xGmQ-TT0Wxj4kG5NMlDmQ5rFJEMXg5gs,829
+langgraph_checkpoint_cosmosdb/cosmosdbSaver.py,sha256=eV_n2SuX_BCUoc_lfqqfK1OGUt9dq0kXZK02_99dJ0I,18902
+langgraph_checkpoint_cosmosdb-0.2.6.dist-info/METADATA,sha256=8HSE7d9-zzGmpbhKAr9Jcw-AEF1NgJuMyTiCpD9XqP8,2338
+langgraph_checkpoint_cosmosdb-0.2.6.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+langgraph_checkpoint_cosmosdb-0.2.6.dist-info/RECORD,,

langgraph_checkpoint_cosmosdb-0.2.6.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any