langgraph-api 0.2.72__tar.gz → 0.2.75__tar.gz

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.72
+Version: 0.2.75
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.2.75/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.75"

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/api/assistants.py

@@ -2,6 +2,8 @@ from typing import Any
 from uuid import uuid4
 
 import structlog
+
+# TODO: Remove dependency on langchain-core here.
 from langchain_core.runnables.utils import create_model
 from langgraph.pregel import Pregel
 from pydantic import TypeAdapter

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/asyncio.py

@@ -6,7 +6,6 @@ from functools import partial
 from typing import Any, Generic, TypeVar
 
 import structlog
-from langgraph.utils.future import chain_future
 
 T = TypeVar("T")
 
@@ -130,11 +129,15 @@ def run_coroutine_threadsafe(
 
 def call_soon_in_main_loop(coro: Coroutine[Any, Any, T]) -> asyncio.Future[T]:
     """Run a coroutine in the main event loop."""
+    from langgraph_api.utils import future as lg_future
+
     if _MAIN_LOOP is None:
         raise RuntimeError("No event loop set")
     main_loop_fut = asyncio.ensure_future(coro, loop=_MAIN_LOOP)
     this_loop_fut = asyncio.get_running_loop().create_future()
-    _MAIN_LOOP.call_soon_threadsafe(chain_future, main_loop_fut, this_loop_fut)
+    _MAIN_LOOP.call_soon_threadsafe(
+        lg_future.chain_future, main_loop_fut, this_loop_fut
+    )
     return this_loop_fut
 
 

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/cron_scheduler.py

@@ -2,10 +2,10 @@ import asyncio
 from random import random
 
 import structlog
-from langchain_core.runnables.config import run_in_executor
 
 from langgraph_api.models.run import create_valid_run
 from langgraph_api.utils import next_cron_date
+from langgraph_api.utils.config import run_in_executor
 from langgraph_api.worker import set_auth_ctx_for_run
 from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Crons

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/graph.py

@@ -14,19 +14,18 @@ from uuid import UUID, uuid5
 
 import orjson
 import structlog
-from langchain_core.runnables.config import run_in_executor, var_child_runnable_config
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.constants import CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_STORE
 from langgraph.graph import StateGraph
 from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
-from langgraph.utils.config import ensure_config
 from starlette.exceptions import HTTPException
 
 from langgraph_api import asyncio as lg_asyncio
 from langgraph_api import config
 from langgraph_api.js.base import BaseRemotePregel, is_js_path
 from langgraph_api.schema import Config
+from langgraph_api.utils.config import run_in_executor, var_child_runnable_config
 
 if TYPE_CHECKING:
     from langchain_core.embeddings import Embeddings
@@ -123,10 +122,12 @@ async def get_graph(
     store: BaseStore | None = None,
 ) -> AsyncIterator[Pregel]:
     """Return the runnable."""
+    from langgraph_api.utils import config as lg_config
+
     assert_graph_exists(graph_id)
     value = GRAPHS[graph_id]
     if graph_id in FACTORY_ACCEPTS_CONFIG:
-        config = ensure_config(config)
+        config = lg_config.ensure_config(config)
         if store is not None and not config["configurable"].get(CONFIG_KEY_STORE):
             config["configurable"][CONFIG_KEY_STORE] = store
         if checkpointer is not None and not config["configurable"].get(

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/logging.py

@@ -15,7 +15,6 @@ log_env = Config()
 LOG_JSON = log_env("LOG_JSON", cast=bool, default=False)
 LOG_COLOR = log_env("LOG_COLOR", cast=bool, default=True)
 LOG_LEVEL = log_env("LOG_LEVEL", cast=str, default="INFO")
-LOG_DICT_TRACEBACKS = log_env("LOG_DICT_TRACEBACKS", cast=bool, default=True)
 
 logging.getLogger().setLevel(LOG_LEVEL.upper())
 logging.getLogger("psycopg").setLevel(logging.WARNING)
@@ -104,11 +103,7 @@ shared_processors = [
     AddApiVersion(),
     structlog.processors.TimeStamper(fmt="iso", utc=True),
     structlog.processors.StackInfoRenderer(),
-    (
-        structlog.processors.dict_tracebacks
-        if LOG_JSON and LOG_DICT_TRACEBACKS
-        else structlog.processors.format_exc_info
-    ),
+    structlog.processors.format_exc_info,
     structlog.processors.UnicodeDecoder(),
     AddLoggingContext(),
 ]

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/state.py

@@ -1,8 +1,14 @@
-from langchain_core.runnables.config import RunnableConfig
+from __future__ import annotations
+
+import typing
+
 from langgraph.types import StateSnapshot
 
 from langgraph_api.schema import Checkpoint, ThreadState
 
+if typing.TYPE_CHECKING:
+    from langchain_core.runnables.config import RunnableConfig
+
 
 def runnable_config_to_checkpoint(
     config: RunnableConfig | None,

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/store.py

@@ -8,12 +8,12 @@ from random import choice
 from typing import Any
 
 import structlog
-from langchain_core.runnables.config import run_in_executor
 from langgraph.graph import StateGraph
 from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
 
 from langgraph_api import config
+from langgraph_api.utils.config import run_in_executor
 
 logger = structlog.stdlib.get_logger(__name__)
 

{langgraph_api-0.2.72 → langgraph_api-0.2.75}/langgraph_api/stream.py

@@ -7,12 +7,12 @@ import langgraph.version
 import langsmith
 import structlog
 from langchain_core.messages import (
+    # TODO: Remove explicit dependency
     BaseMessage,
     BaseMessageChunk,
     convert_to_messages,
     message_chunk_to_message,
 )
-from langchain_core.runnables.config import run_in_executor
 from langgraph.errors import (
     EmptyChannelError,
     EmptyInputError,
@@ -33,6 +33,7 @@ from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
+from langgraph_api.utils.config import run_in_executor
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.ops import Runs
 
@@ -320,7 +321,6 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                     resumable=resumable,
                 )
         except Exception as e:
-            g = e
             if isinstance(e, ExceptionGroup):
                 e = e.exceptions[0]
             await Runs.Stream.publish(
@@ -329,7 +329,7 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                 await run_in_executor(None, json_dumpb, e),
                 resumable=resumable,
             )
-            raise e from g
+            raise e
 
 
 def get_feedback_urls(run_id: str, feedback_keys: list[str]) -> dict[str, str]:

langgraph_api-0.2.75/langgraph_api/utils/config.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+import typing
+from collections import ChainMap
+from concurrent.futures import Executor
+from contextvars import copy_context
+from os import getenv
+from typing import Any, ParamSpec, TypeVar, cast
+
+from langgraph.constants import CONF
+
+if typing.TYPE_CHECKING:
+    from langchain_core.runnables import RunnableConfig
+
+try:
+    from langchain_core.runnables.config import (
+        var_child_runnable_config,
+    )
+except ImportError:
+    var_child_runnable_config = None
+
+CONFIG_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "run_name",
+    "max_concurrency",
+    "recursion_limit",
+    "configurable",
+    "run_id",
+]
+
+COPIABLE_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "configurable",
+]
+
+DEFAULT_RECURSION_LIMIT = int(getenv("LANGGRAPH_DEFAULT_RECURSION_LIMIT", "25"))
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def _is_not_empty(value: Any) -> bool:
+    if isinstance(value, list | tuple | dict):
+        return len(value) > 0
+    else:
+        return value is not None
+
+
+def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
+    """Return a config with all keys, merging any provided configs.
+
+    Args:
+        *configs: Configs to merge before ensuring defaults.
+
+    Returns:
+        RunnableConfig: The merged and ensured config.
+    """
+    empty = dict(
+        tags=[],
+        metadata=ChainMap(),
+        callbacks=None,
+        recursion_limit=DEFAULT_RECURSION_LIMIT,
+        configurable={},
+    )
+    if var_child_runnable_config is not None and (
+        var_config := var_child_runnable_config.get()
+    ):
+        empty.update(
+            {
+                k: v.copy() if k in COPIABLE_KEYS else v  # type: ignore[attr-defined]
+                for k, v in var_config.items()
+                if _is_not_empty(v)
+            },
+        )
+    for config in configs:
+        if config is None:
+            continue
+        for k, v in config.items():
+            if _is_not_empty(v) and k in CONFIG_KEYS:
+                if k == CONF:
+                    empty[k] = cast(dict, v).copy()
+                else:
+                    empty[k] = v  # type: ignore[literal-required]
+        for k, v in config.items():
+            if _is_not_empty(v) and k not in CONFIG_KEYS:
+                empty[CONF][k] = v
+    for key, value in empty[CONF].items():
+        if (
+            not key.startswith("__")
+            and isinstance(value, str | int | float | bool)
+            and key not in empty["metadata"]
+        ):
+            empty["metadata"][key] = value
+    return empty
+
+
+async def run_in_executor(
+    executor_or_config: Executor | RunnableConfig | None,
+    func: typing.Callable[P, T],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    """Run a function in an executor.
+
+    Args:
+        executor_or_config: The executor or config to run in.
+        func (Callable[P, Output]): The function.
+        *args (Any): The positional arguments to the function.
+        **kwargs (Any): The keyword arguments to the function.
+
+    Returns:
+        Output: The output of the function.
+
+    Raises:
+        RuntimeError: If the function raises a StopIteration.
+    """
+
+    def wrapper() -> T:
+        try:
+            return func(*args, **kwargs)
+        except StopIteration as exc:
+            # StopIteration can't be set on an asyncio.Future
+            # it raises a TypeError and leaves the Future pending forever
+            # so we need to convert it to a RuntimeError
+            raise RuntimeError from exc
+
+    if executor_or_config is None or isinstance(executor_or_config, dict):
+        # Use default executor with context copied from current context
+        return await asyncio.get_running_loop().run_in_executor(
+            None,
+            functools.partial(copy_context().run, wrapper),
+        )
+
+    return await asyncio.get_running_loop().run_in_executor(executor_or_config, wrapper)

langgraph_api-0.2.75/langgraph_api/utils/future.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import contextvars
+import inspect
+import sys
+import types
+from collections.abc import Awaitable, Coroutine, Generator
+from typing import TypeVar, cast
+
+T = TypeVar("T")
+AnyFuture = asyncio.Future | concurrent.futures.Future
+
+CONTEXT_NOT_SUPPORTED = sys.version_info < (3, 11)
+EAGER_NOT_SUPPORTED = sys.version_info < (3, 12)
+
+
+def _get_loop(fut: asyncio.Future) -> asyncio.AbstractEventLoop:
+    # Tries to call Future.get_loop() if it's available.
+    # Otherwise fallbacks to using the old '_loop' property.
+    try:
+        get_loop = fut.get_loop
+    except AttributeError:
+        pass
+    else:
+        return get_loop()
+    return fut._loop
+
+
+def _convert_future_exc(exc: BaseException) -> BaseException:
+    exc_class = type(exc)
+    if exc_class is concurrent.futures.CancelledError:
+        return asyncio.CancelledError(*exc.args)
+    elif exc_class is concurrent.futures.TimeoutError:
+        return TimeoutError(*exc.args)
+    elif exc_class is concurrent.futures.InvalidStateError:
+        return asyncio.InvalidStateError(*exc.args)
+    else:
+        return exc
+
+
+def _set_concurrent_future_state(
+    concurrent: concurrent.futures.Future,
+    source: AnyFuture,
+) -> None:
+    """Copy state from a future to a concurrent.futures.Future."""
+    assert source.done()
+    if source.cancelled():
+        concurrent.cancel()
+    if not concurrent.set_running_or_notify_cancel():
+        return
+    exception = source.exception()
+    if exception is not None:
+        concurrent.set_exception(_convert_future_exc(exception))
+    else:
+        result = source.result()
+        concurrent.set_result(result)
+
+
+def _copy_future_state(source: AnyFuture, dest: asyncio.Future) -> None:
+    """Internal helper to copy state from another Future.
+
+    The other Future may be a concurrent.futures.Future.
+    """
+    if dest.done():
+        return
+    assert source.done()
+    if dest.cancelled():
+        return
+    if source.cancelled():
+        dest.cancel()
+    else:
+        exception = source.exception()
+        if exception is not None:
+            dest.set_exception(_convert_future_exc(exception))
+        else:
+            result = source.result()
+            dest.set_result(result)
+
+
+def _chain_future(source: AnyFuture, destination: AnyFuture) -> None:
+    """Chain two futures so that when one completes, so does the other.
+
+    The result (or exception) of source will be copied to destination.
+    If destination is cancelled, source gets cancelled too.
+    Compatible with both asyncio.Future and concurrent.futures.Future.
+    """
+    if not asyncio.isfuture(source) and not isinstance(
+        source, concurrent.futures.Future
+    ):
+        raise TypeError("A future is required for source argument")
+    if not asyncio.isfuture(destination) and not isinstance(
+        destination, concurrent.futures.Future
+    ):
+        raise TypeError("A future is required for destination argument")
+    source_loop = _get_loop(source) if asyncio.isfuture(source) else None
+    dest_loop = _get_loop(destination) if asyncio.isfuture(destination) else None
+
+    def _set_state(future: AnyFuture, other: AnyFuture) -> None:
+        if asyncio.isfuture(future):
+            _copy_future_state(other, future)
+        else:
+            _set_concurrent_future_state(future, other)
+
+    def _call_check_cancel(destination: AnyFuture) -> None:
+        if destination.cancelled():
+            if source_loop is None or source_loop is dest_loop:
+                source.cancel()
+            else:
+                source_loop.call_soon_threadsafe(source.cancel)
+
+    def _call_set_state(source: AnyFuture) -> None:
+        if destination.cancelled() and dest_loop is not None and dest_loop.is_closed():
+            return
+        if dest_loop is None or dest_loop is source_loop:
+            _set_state(destination, source)
+        else:
+            if dest_loop.is_closed():
+                return
+            dest_loop.call_soon_threadsafe(_set_state, destination, source)
+
+    destination.add_done_callback(_call_check_cancel)
+    source.add_done_callback(_call_set_state)
+
+
+def chain_future(source: AnyFuture, destination: AnyFuture) -> AnyFuture:
+    # adapted from asyncio.run_coroutine_threadsafe
+    try:
+        _chain_future(source, destination)
+        return destination
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except BaseException as exc:
+        if isinstance(destination, concurrent.futures.Future):
+            if destination.set_running_or_notify_cancel():
+                destination.set_exception(exc)
+        else:
+            destination.set_exception(exc)
+        raise
+
+
+def _ensure_future(
+    coro_or_future: Coroutine[None, None, T] | Awaitable[T],
+    *,
+    loop: asyncio.AbstractEventLoop,
+    name: str | None = None,
+    context: contextvars.Context | None = None,
+    lazy: bool = True,
+) -> asyncio.Task[T]:
+    called_wrap_awaitable = False
+    if not asyncio.iscoroutine(coro_or_future):
+        if inspect.isawaitable(coro_or_future):
+            coro_or_future = cast(
+                Coroutine[None, None, T], _wrap_awaitable(coro_or_future)
+            )
+            called_wrap_awaitable = True
+        else:
+            raise TypeError(
+                "An asyncio.Future, a coroutine or an awaitable is required."
+                f" Got {type(coro_or_future).__name__} instead."
+            )
+
+    try:
+        if CONTEXT_NOT_SUPPORTED:
+            return loop.create_task(coro_or_future, name=name)
+        elif EAGER_NOT_SUPPORTED or lazy:
+            return loop.create_task(coro_or_future, name=name, context=context)
+        else:
+            return asyncio.eager_task_factory(
+                loop, coro_or_future, name=name, context=context
+            )
+    except RuntimeError:
+        if not called_wrap_awaitable:
+            coro_or_future.close()
+        raise
+
+
+@types.coroutine
+def _wrap_awaitable(awaitable: Awaitable[T]) -> Generator[None, None, T]:
+    """Helper for asyncio.ensure_future().
+
+    Wraps awaitable (an object with __await__) into a coroutine
+    that will later be wrapped in a Task by ensure_future().
+    """
+    return (yield from awaitable.__await__())
+
+
+def run_coroutine_threadsafe(
+    coro: Coroutine[None, None, T],
+    loop: asyncio.AbstractEventLoop,
+    *,
+    lazy: bool,
+    name: str | None = None,
+    context: contextvars.Context | None = None,
+) -> asyncio.Future[T]:
+    """Submit a coroutine object to a given event loop.
+
+    Return an asyncio.Future to access the result.
+    """
+
+    if asyncio._get_running_loop() is loop:
+        return _ensure_future(coro, loop=loop, name=name, context=context, lazy=lazy)
+    else:
+        future: asyncio.Future[T] = asyncio.Future(loop=loop)
+
+        def callback() -> None:
+            try:
+                chain_future(
+                    _ensure_future(coro, loop=loop, name=name, context=context),
+                    future,
+                )
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as exc:
+                future.set_exception(exc)
+                raise
+
+        loop.call_soon_threadsafe(callback, context=context)
+        return future

langgraph_api-0.2.72/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.72"