batch-bridge 0.0.1rc0__py3-none-any.whl

batch_bridge/__init__.py

@@ -0,0 +1,10 @@
+"""BatchBridge: A library for batch processing with LangGraph.
+
+This library provides functionality for batching items and processing them in bulk,
+integrating with LangGraph's interrupt semantics for efficient batch handling.
+"""
+
+from batch_bridge._base import Bridge, wait
+from batch_bridge._openai import patch_openai
+
+__all__ = ["Bridge", "wait", "patch_openai"]

batch_bridge/_base.py

@@ -0,0 +1,310 @@
+import asyncio
+import datetime
+import os
+import typing
+import uuid
+from collections import defaultdict
+
+from langgraph.config import get_config
+from langgraph.constants import CONF, CONFIG_KEY_TASK_ID
+from langgraph.errors import GraphInterrupt
+from langgraph.graph import StateGraph
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.types import Command, Send, interrupt
+from langgraph_api.graph import register_graph_sync
+from langgraph_sdk import get_client
+from typing_extensions import Annotated, TypedDict
+
+from batch_bridge.errors import BatchIngestException
+from batch_bridge.types import InFlightBatch, QueueItem, RemoveBatch, T, U, V
+
+if typing.TYPE_CHECKING:
+    pass
+
+DEFAULT_THREAD_ID = "b0be531d-55f6-4b87-a309-23d2ed28d9da"
+USE_CRONS = os.getenv("LANGSMITH_LANGGRAPH_API_VARIANT") != "local_dev"
+
+
+_langgraph_client = get_client()
+
+
+class CompiledBridge(CompiledStateGraph, typing.Generic[T, U]):
+    def __init__(
+        self,
+        *args: typing.Any,
+        graph_id: str = "BatchBridge",
+        __output_coercer__: typing.Callable[[U], typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> None:
+        graph_id_ = kwargs.pop("__graph_id__", graph_id)
+        super().__init__(*args, **kwargs)
+        if graph_id_ is not None:
+            self.__graph_id__ = graph_id_
+        else:
+            self.__graph_id__ = graph_id
+        self.__output_coercer__ = __output_coercer__
+
+    async def wait(self, item: T, *, thread_id: str = DEFAULT_THREAD_ID) -> U:
+        result = await wait(item, bridge_id=self.__graph_id__, thread_id=thread_id)
+        if self.__output_coercer__ is not None:
+            result = self.__output_coercer__(result)
+        return result
+
+
+class Bridge:
+    """A bridge for batch processing."""
+
+    def __new__(
+        self,
+        submit: typing.Callable[[list[T]], typing.Awaitable[U]],
+        poll: typing.Callable[[U], typing.Awaitable[V]],
+        *,
+        should_submit: typing.Optional[
+            typing.Callable[[list[T], typing.Optional[datetime.datetime]], bool]
+        ] = None,
+        graph_id: str = "BatchBridge",
+        __output_coercer__: typing.Callable[[U], V] | None = None,
+        # job_ttl: typing.Optional[datetime.timedelta] = MISSING, # type: ignore
+    ) -> CompiledBridge:
+        if not asyncio.iscoroutinefunction(submit):
+            raise ValueError("submit must be a coroutine function")
+        if not asyncio.iscoroutinefunction(poll):
+            raise ValueError("poll must be a coroutine function")
+        if should_submit is None:
+            should_submit = _submit_after_minute
+
+        class InputSchema(TypedDict):
+            tasks: typing.Annotated[list[QueueItem[T]], _reduce_batch]
+            event: typing.Optional[typing.Literal["poll", "submit"]]
+            in_flight: Annotated[list[InFlightBatch[T]], _reduce_in_flight]
+
+        class State(InputSchema):
+            last_submit_time: datetime.datetime
+
+        async def route_entry(
+            state: State,
+        ) -> typing.Union[
+            typing.Literal["check_should_submit"],
+            typing.Sequence[typing.Union[Send, typing.Literal["check_should_submit"]]],
+        ]:
+            # The bridge stuff can be triggered when:
+            # 1. A new task is enqueued
+            # 2. A auto-cron to poll tasks is triggered
+            if state.get("event") == "submit":
+                return "check_should_submit"
+            elif state.get("event") == "poll":
+                result = [
+                    *[
+                        Send("poll_batch", batch_val)
+                        for batch_val in state["in_flight"]
+                    ],
+                    "check_should_submit",
+                ]
+                return result
+            else:
+                raise ValueError("Invalid event")
+
+        async def create_batch(state: State) -> dict:
+            tasks = state.get("tasks", [])
+            task_values = [task["task"] for task in tasks]
+            batch_payload = await submit(task_values)
+            # Start the poller
+            batch_id = str(uuid.uuid4())
+            configurable = get_config()[CONF]
+            assistant_id = configurable["assistant_id"]
+            if USE_CRONS:
+                await _langgraph_client.crons.create(
+                    assistant_id=assistant_id,
+                    schedule="* * * * * *",
+                    input={
+                        "event": "poll",
+                        "in_flight": InFlightBatch(
+                            batch_id=batch_id,
+                            batch_payload=batch_payload,
+                            origins=[task["origin"] for task in tasks],
+                        ),
+                    },
+                    multitask_strategy="reject",
+                )
+            else:
+                await _langgraph_client.runs.create(
+                    assistant_id=assistant_id,
+                    input={
+                        "event": "poll",
+                        "in_flight": InFlightBatch(
+                            batch_id=batch_id,
+                            batch_payload=batch_payload,
+                            origins=[task["origin"] for task in tasks],
+                        ),
+                    },
+                    multitask_strategy="reject",
+                    after_seconds=30,
+                )
+            return {
+                "last_submit_time": datetime.datetime.now(datetime.timezone.utc),
+                "tasks": "__clear__",
+                "in_flight": [],
+            }
+
+        async def check_should_submit(state: State):
+            last_submit_time = state.get("last_submit_time") or datetime.datetime.now(
+                datetime.timezone.utc
+            )
+            if state.get("tasks"):
+                resp = await should_submit(state["tasks"], last_submit_time)
+                goto = "create_batch" if resp else "__end__"
+            else:
+                goto = "__end__"
+            return Command(update={"last_submit_time": last_submit_time}, goto=goto)
+
+        async def poll_batch(state: InFlightBatch) -> dict:
+            try:
+                poll_result = await poll(state["batch_payload"])
+            except BatchIngestException as e:
+                poll_result = e
+
+            if poll_result is not None:
+                # Now we need to re-trigger ALL the original tasks
+                to_resume = defaultdict(dict)
+                if isinstance(poll_result, Exception):
+                    detail = (
+                        poll_result.detail
+                        if isinstance(poll_result, BatchIngestException)
+                        else str(poll_result)
+                    )
+                    response = {
+                        "__batch_bridge__": {
+                            "kind": "exception",
+                            "detail": detail,
+                        }
+                    }
+                    for origin in state["origins"]:
+                        to_resume[(origin["assistant_id"], origin["thread_id"])][
+                            origin["task_id"]
+                        ] = response
+                else:
+                    for origin, result in zip(state["origins"], poll_result):
+                        to_resume[(origin["assistant_id"], origin["thread_id"])][
+                            origin["task_id"]
+                        ] = result
+                await asyncio.gather(
+                    *[
+                        _langgraph_client.runs.create(
+                            thread_id=thread_id,
+                            assistant_id=assistant_id,
+                            command={"resume": task_resumes},
+                        )
+                        for (assistant_id, thread_id), task_resumes in to_resume.items()
+                    ],
+                    # Ignore errors here - we'll just move on
+                    return_exceptions=True,
+                )
+                # Stop polling for this batch in particular
+                if USE_CRONS:
+                    configurable = get_config()[CONF]
+                    await _langgraph_client.crons.delete(configurable["cron_id"])
+                return {
+                    "in_flight": RemoveBatch(state["batch_id"]),
+                }
+
+        compiled: CompiledBridge[typing.Any, typing.Any] = CompiledBridge(
+            **(
+                StateGraph(State, input=InputSchema)
+                .add_node(poll_batch)
+                .add_node(create_batch)
+                .add_node(check_should_submit)
+                .add_conditional_edges(
+                    "__start__", route_entry, ["poll_batch", "check_should_submit"]
+                )
+                .compile(name=graph_id)
+                .__dict__
+            ),
+            graph_id=graph_id,
+            __output_coercer__=__output_coercer__,
+        )
+
+        register_graph_sync(graph_id, compiled)
+
+        return compiled
+
+    def __init__(
+        self,
+        submit: typing.Callable[[list[T]], typing.Awaitable[U]],
+        poll: typing.Callable[[U], typing.Awaitable[V]],
+        *,
+        should_submit: typing.Optional[
+            typing.Callable[[list[T], typing.Optional[datetime.datetime]], bool]
+        ] = None,
+        graph_id: str = "BatchBridge",
+        # job_ttl: typing.Optional[datetime.timedelta] = MISSING, # type: ignore
+    ) -> None:
+        """This is cool."""
+        ...
+
+
+async def wait(
+    item: T,
+    *,
+    bridge_id: str,  # Graph ID (~ assistant_id) of the graph in your deployment.
+    thread_id: str = DEFAULT_THREAD_ID,
+) -> None:
+    configurable = get_config()[CONF]
+    task_id = configurable[CONFIG_KEY_TASK_ID]
+    assistant_id = configurable["assistant_id"]
+    origin_thread_id = configurable["thread_id"]
+    task = {
+        "task": item,
+        "origin": {
+            "assistant_id": assistant_id,
+            "thread_id": origin_thread_id,
+            "task_id": task_id,
+        },
+    }
+    try:
+        result = interrupt(task)
+        if isinstance(result, dict) and (out_of_band := result.get("__batch_bridge__")):
+            if out_of_band["kind"] == "exception":
+                raise BatchIngestException(out_of_band["detail"])
+            raise NotImplementedError(f"Unknown out of band type: {out_of_band}")
+        return result
+    except GraphInterrupt:
+        await _langgraph_client.runs.create(
+            thread_id=thread_id,
+            assistant_id=bridge_id,
+            if_not_exists="create",
+            multitask_strategy="enqueue",
+            input={
+                "event": "submit",
+                "tasks": task,
+            },
+        )
+        raise
+
+
+def _reduce_batch(
+    existing: list[T] | None, new: T | typing.Literal["__clear__"]
+) -> list[T]:
+    if new == "__clear__":
+        return []
+    existing = existing if existing is not None else []
+    return [*existing, new]
+
+
+def _reduce_in_flight(
+    existing: list[InFlightBatch[T]] | None, new: InFlightBatch[T] | RemoveBatch
+) -> list[InFlightBatch[T]]:
+    if isinstance(new, RemoveBatch):
+        return [batch for batch in existing if batch["batch_id"] != new.batch_id]
+    if isinstance(new, dict) and "batch_id" in new:
+        new = [new]
+    existing = existing if existing is not None else []
+    return [*existing, *new]
+
+
+async def _submit_after_minute(tasks: list, last_submit: datetime.datetime) -> bool:
+    if not tasks:
+        return False
+    # Main goal here is to avoid getting rate limited
+    return (
+        datetime.datetime.now(datetime.timezone.utc) - last_submit
+    ).total_seconds() > 60

batch_bridge/_openai.py

@@ -0,0 +1,187 @@
+import io
+import json
+import typing
+
+from openai import AsyncOpenAI
+from typing_extensions import TypedDict
+
+from examples.batch_bridge.errors import BatchIngestException
+from batch_bridge._base import Bridge, CompiledBridge
+import functools
+
+if typing.TYPE_CHECKING:
+    from openai import AsyncOpenAI
+    from openai.types import ChatModel
+    from openai.types.chat import (
+        ChatCompletion,
+        ChatCompletionAudioParam,
+        ChatCompletionMessageParam,
+        ChatCompletionModality,
+        ChatCompletionPredictionContentParam,
+        ChatCompletionReasoningEffort,
+        ChatCompletionToolChoiceOptionParam,
+        ChatCompletionToolParam,
+    )
+    from openai.types.chat.completion_create_params import (
+        ResponseFormat,
+    )
+
+    CompletionOutputs = ChatCompletion
+else:
+    CompletionOutputs = typing.Any
+
+
+class CompletionInputs(TypedDict, total=False):
+    messages: typing.Required[typing.Sequence["ChatCompletionMessageParam"]]
+    model: typing.Required[typing.Union[str, "ChatModel"]]
+    audio: typing.Optional["ChatCompletionAudioParam"]
+    frequency_penalty: typing.Optional[float]
+    logit_bias: typing.Optional[dict[str, int]]
+    logprobs: typing.Optional[bool]
+    max_completion_tokens: typing.Optional[int]
+    max_tokens: typing.Optional[int]
+    metadata: typing.Optional[dict[str, str]]
+    modalities: typing.Optional[list["ChatCompletionModality"]]
+    n: typing.Optional[int]
+    parallel_tool_calls: bool
+    prediction: typing.Optional["ChatCompletionPredictionContentParam"]
+    presence_penalty: typing.Optional[float]
+    reasoning_effort: "ChatCompletionReasoningEffort"
+    response_format: "ResponseFormat"
+    seed: typing.Optional[int]
+    service_tier: typing.Optional[typing.Literal["auto", "default"]]
+    stop: typing.Union[typing.Optional[str], list[str]]
+    store: typing.Optional[bool]
+    temperature: typing.Optional[float]
+    tool_choice: "ChatCompletionToolChoiceOptionParam"
+    tools: typing.Sequence["ChatCompletionToolParam"]
+    top_logprobs: typing.Optional[int]
+    top_p: typing.Optional[float]
+    user: str
+
+
+class Task(TypedDict, total=False):
+    custom_id: str
+    method: str
+    url: str
+    body: CompletionInputs
+
+
+def patch_openai(client: typing.Optional["AsyncOpenAI"] = None) -> AsyncOpenAI:
+    from openai import AsyncOpenAI
+    from openai._types import NotGiven
+
+    if client is None:
+        client = AsyncOpenAI()
+    bridge = OpenAIBridge(client)
+
+    @functools.wraps(client.chat.completions.create)
+    async def async_openai_completions(
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Any:
+        to_send = {k: v for k, v in kwargs.items() if not isinstance(v, NotGiven)}
+        return await bridge.wait(CompletionInputs(**to_send))
+
+    client.chat.completions.create = async_openai_completions
+
+    return client
+
+
+def OpenAIBridge(
+    client: typing.Optional["AsyncOpenAI"] = None,
+    *,
+    graph_id: str = "BatchBridge",
+) -> CompiledBridge[CompletionInputs, CompletionOutputs]:
+    handler = OpenAIHandler(client)
+    return Bridge(
+        handler.submit,
+        handler.poll,
+        graph_id=graph_id,
+        __output_coercer__=handler.coerce_response,
+    )
+
+
+class OpenAIHandler:
+    def __init__(self, client: AsyncOpenAI):
+        from openai import AsyncOpenAI
+        from openai.types.chat import ChatCompletion
+
+        if client is None:
+            client = AsyncOpenAI()
+        self.client = client
+        self.coerce_response = lambda response: ChatCompletion(**response)
+
+    async def submit(self, tasks: list[list[CompletionInputs]]) -> dict:
+        """
+        Submits a batch of tasks to OpenAI using an in-memory JSONL file.
+
+        Args:
+            tasks (list[list[dict[str, str]]]): list of tasks to be submitted.
+
+        Returns:
+            dict: The created batch object from the API.
+        """
+        # Create in-memory JSONL string from tasks
+        # Task is a list of messages
+        jsonl_str = "\n".join(
+            json.dumps(
+                Task(
+                    custom_id=str(i),
+                    method="POST",
+                    url="/v1/chat/completions",
+                    body=task,
+                )
+            )
+            for i, task in enumerate(tasks)
+        )
+        jsonl_bytes = jsonl_str.encode("utf-8")
+        in_memory_file = io.BytesIO(jsonl_bytes)
+
+        # Upload the in-memory file for batch processing
+        batch_input_file = await self.client.files.create(
+            file=in_memory_file, purpose="batch"
+        )
+        batch_input_file_id = batch_input_file.id
+
+        # Create the batch job with a 24h completion window
+        batch_object = await self.client.batches.create(
+            input_file_id=batch_input_file_id,
+            endpoint="/v1/chat/completions",
+            completion_window="24h",
+            metadata={"description": "nightly eval job"},
+        )
+
+        return batch_object.id
+
+    async def poll(self, batch_id: str) -> typing.Optional[list[dict[str, str]]]:
+        """
+            Polls a batch job and, if complete, retrieves and parses the results.
+
+            Args:
+            batch_id (str): The ID of the batch job to poll.
+
+        Returns:
+            list[dict[str, str]] or None: The list of parsed results if the job is complete; otherwise, None.
+        """
+        batch_obj = await self.client.batches.retrieve(batch_id)
+        if batch_obj.status == "failed":
+            raise BatchIngestException(f"Batch {batch_id} failed")
+        if batch_obj.status != "completed":
+            return None
+
+        result_file_id = batch_obj.output_file_id
+        result_content = (await self.client.files.content(result_file_id)).content
+
+        # Parse JSONL content from the result file into a list of objects
+        results = []
+        for line in result_content.decode("utf-8").splitlines():
+            if line.strip():
+                data = json.loads(line)
+                if (response := data.get("response")) and (
+                    body := response.get("body")
+                ):
+                    results.append(body)
+                else:
+                    results.append(data)
+        return results

batch_bridge/errors.py

@@ -0,0 +1,6 @@
+"""Shared exceptions."""
+
+
+class BatchIngestException(Exception):
+    def __init__(self, detail: str):
+        self.detail = detail

batch_bridge/types.py

@@ -0,0 +1,28 @@
+import typing
+
+from typing_extensions import TypedDict
+
+T = typing.TypeVar("T")
+U = typing.TypeVar("U")
+V = typing.TypeVar("V")
+
+
+class Origin(TypedDict):
+    assistant_id: str
+    thread_id: str
+    task_id: str  # UUID
+
+
+class InFlightBatch(TypedDict, typing.Generic[T]):
+    batch_id: str
+    batch_payload: T
+    origins: typing.Sequence[Origin]
+
+
+class QueueItem(TypedDict, typing.Generic[T]):
+    origin: Origin
+    task: T
+
+
+class RemoveBatch(typing.NamedTuple):
+    batch_id: str

batch_bridge-0.0.1rc0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: batch-bridge
+Version: 0.0.1rc0
+Summary: Prebuilt utilities for memory management and retrieval.
+License: MIT License
+        
+        Copyright (c) 2025 LangChain
+        
+        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.
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: langgraph-api>=0.0.33
+Requires-Dist: langgraph>=0.2.66
+Description-Content-Type: text/markdown
+
+# BatchBridge
+
+BatchBridge is a library for efficient batch processing with LangGraph. It provides a mechanism to collect items, process them in batches, and handle results asynchronously using LangGraph's interrupt semantics.
+
+## What is BatchBridge?
+
+Batch APIs can cut AI inference costs by 50% or more, but they're difficult to use in agent workflows. They force you to manually aggregate requests and design your entire agent loop around batch processing rather than focusing on individual tasks. This makes your code more complex, harder to maintain, and less shareable.
+
+BatchBridge solves this by making batch APIs work like standard completion APIs in LangGraph. Your code makes normal API calls while BatchBridge handles batching, submission, polling, and resumption behind the scenes. This lets you design and improve an agent using single completions, then make a one-line change to let it economically scale.
+
+We aim to give you significant cost savings with minimal code complexity.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Since BatchBridge relies on LangGraph's durable execution and cron functionality, it must be
+run on the LangGraph platform.
+
+
+## Example with OpenAI's Batch API
+
+BatchBridge has a native integration with OpenAI's Batch API:
+
+```python
+from batch_bridge import patch_openai
+from openai import AsyncOpenAI
+from langgraph.graph import StateGraph
+from typing_extensions import Annotated, TypedDict
+
+# Patch the client at the global level
+client = patch_openai(AsyncOpenAI())
+
+
+class State(TypedDict):
+    messages: Annotated[list[dict], lambda x, y: x + y]
+
+
+async def my_model(state: State):
+    # This will:
+    # 1. submit the message to our bridge graph
+    # 2. Interrupt this agent graph.
+    # 3. resume once the bridge graph detects that the batch is complete
+    result = await client.chat.completions.create(
+        model="gpt-4o-mini", messages=state["messages"]
+    )
+    return {"messages": [result]}
+
+
+graph = StateGraph(State).add_node(my_model).add_edge("__start__", "my_model").compile()
+```
+
+## Basic Usage
+
+Under the hood, BatchBridge relies on two basic functions:
+a submit() function and a poll() function.
+
+Here's a simple example of how to use BatchBridge:
+
+```python
+from datetime import datetime, timedelta
+from batch_bridge import Batcher
+
+# Define functions for batch processing
+def submit_batch(items):
+    """Submit a batch of items for processing."""
+    # In a real implementation, this would submit to an external API
+    # and return a batch ID
+    print(f"Submitting batch of {len(items)} items")
+    return "batch_123"
+
+def poll_batch(batch_id):
+    """Poll for the results of a batch."""
+    # In a real implementation, this would check the status of the batch
+    # and return results when available
+    import time
+    time.sleep(2)  # Simulate processing time
+    return [f"Processed: {item}" for item in ["item1", "item2"]]
+
+# Create a batcher with default flush criteria
+batcher = Batcher(
+    submit_func=submit_batch,
+    poll_func=poll_batch,
+)
+```
+
+## License
+
+MIT

batch_bridge-0.0.1rc0.dist-info/RECORD

@@ -0,0 +1,9 @@
+batch_bridge/__init__.py,sha256=Iw5iz6Z5ev599n9NEppOEsbsJTZW4ZTvHTbsWM91U5o,368
+batch_bridge/_base.py,sha256=NUpFnguVA-1naZ-aLRaHhLzdsohh6OyYuNJydzpO6Ic,11580
+batch_bridge/_openai.py,sha256=aRbKB3OZJcWRI3eOhwsp7B56JXngkDy767w5WjoSqI4,6215
+batch_bridge/errors.py,sha256=jVMWhYIwltJbG0wawGk3EO0C_mCsKXVeusRrP98dDmo,132
+batch_bridge/types.py,sha256=G1SMbyc0FZI7eWV_YbYxCR920JuuTCeaFP1aec75g8g,488
+batch_bridge-0.0.1rc0.dist-info/METADATA,sha256=HKtOffXaOb1znRqoqiXJ4MrOYaGpqMaxWAD-uLkzywM,4567
+batch_bridge-0.0.1rc0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+batch_bridge-0.0.1rc0.dist-info/licenses/LICENSE,sha256=mK8TUeqFbgCMg1vImjEpBZYKMYBy-VBzK_NGx0ECfH0,1066
+batch_bridge-0.0.1rc0.dist-info/RECORD,,

batch_bridge-0.0.1rc0.dist-info/WHEEL

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

batch_bridge-0.0.1rc0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 LangChain
+
+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.