langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/callbacks/openai_info.py

@@ -1,25 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.openai_info import OpenAICallbackHandler
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "OpenAICallbackHandler": "langchain_community.callbacks.openai_info",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "OpenAICallbackHandler",
-]

langchain/callbacks/promptlayer_callback.py

@@ -1,27 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.promptlayer_callback import (
-        PromptLayerCallbackHandler,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "PromptLayerCallbackHandler",
-]

langchain/callbacks/sagemaker_callback.py

@@ -1,27 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.sagemaker_callback import (
-        SageMakerCallbackHandler,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "SageMakerCallbackHandler",
-]

langchain/callbacks/stdout.py

@@ -1,3 +0,0 @@
-from langchain_core.callbacks.stdout import StdOutCallbackHandler
-
-__all__ = ["StdOutCallbackHandler"]

langchain/callbacks/streaming_aiter.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncIterator
-from typing import Any, Literal, Union, cast
-
-from langchain_core.callbacks import AsyncCallbackHandler
-from langchain_core.outputs import LLMResult
-from langchain_core.v1.messages import AIMessage
-from typing_extensions import override
-
-# TODO If used by two LLM runs in parallel this won't work as expected
-
-
-class AsyncIteratorCallbackHandler(AsyncCallbackHandler):
-    """Callback handler that returns an async iterator."""
-
-    queue: asyncio.Queue[str]
-
-    done: asyncio.Event
-
-    @property
-    def always_verbose(self) -> bool:
-        """Always verbose."""
-        return True
-
-    def __init__(self) -> None:
-        """Instantiate AsyncIteratorCallbackHandler."""
-        self.queue = asyncio.Queue()
-        self.done = asyncio.Event()
-
-    @override
-    async def on_llm_start(
-        self,
-        serialized: dict[str, Any],
-        prompts: list[str],
-        **kwargs: Any,
-    ) -> None:
-        # If two calls are made in a row, this resets the state
-        self.done.clear()
-
-    @override
-    async def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        if token is not None and token != "":
-            self.queue.put_nowait(token)
-
-    @override
-    async def on_llm_end(
-        self, response: Union[LLMResult, AIMessage], **kwargs: Any
-    ) -> None:
-        self.done.set()
-
-    @override
-    async def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
-        self.done.set()
-
-    # TODO implement the other methods
-
-    async def aiter(self) -> AsyncIterator[str]:
-        """Asynchronous iterator that yields tokens."""
-        while not self.queue.empty() or not self.done.is_set():
-            # Wait for the next token in the queue,
-            # but stop waiting if the done event is set
-            done, other = await asyncio.wait(
-                [
-                    # NOTE: If you add other tasks here, update the code below,
-                    # which assumes each set has exactly one task each
-                    asyncio.ensure_future(self.queue.get()),
-                    asyncio.ensure_future(self.done.wait()),
-                ],
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-
-            # Cancel the other task
-            if other:
-                other.pop().cancel()
-
-            # Extract the value of the first completed task
-            token_or_done = cast("Union[str, Literal[True]]", done.pop().result())
-
-            # If the extracted value is the boolean True, the done event was set
-            if token_or_done is True:
-                break
-
-            # Otherwise, the extracted value is a token, which we yield
-            yield token_or_done

langchain/callbacks/streaming_aiter_final_only.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Optional, Union
-
-from langchain_core.outputs import LLMResult
-from langchain_core.v1.messages import AIMessage
-from typing_extensions import override
-
-from langchain.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
-
-DEFAULT_ANSWER_PREFIX_TOKENS = ["Final", "Answer", ":"]
-
-
-class AsyncFinalIteratorCallbackHandler(AsyncIteratorCallbackHandler):
-    """Callback handler that returns an async iterator.
-    Only the final output of the agent will be iterated.
-    """
-
-    def append_to_last_tokens(self, token: str) -> None:
-        """Append token to the last tokens."""
-        self.last_tokens.append(token)
-        self.last_tokens_stripped.append(token.strip())
-        if len(self.last_tokens) > len(self.answer_prefix_tokens):
-            self.last_tokens.pop(0)
-            self.last_tokens_stripped.pop(0)
-
-    def check_if_answer_reached(self) -> bool:
-        """Check if the answer has been reached."""
-        if self.strip_tokens:
-            return self.last_tokens_stripped == self.answer_prefix_tokens_stripped
-        return self.last_tokens == self.answer_prefix_tokens
-
-    def __init__(
-        self,
-        *,
-        answer_prefix_tokens: Optional[list[str]] = None,
-        strip_tokens: bool = True,
-        stream_prefix: bool = False,
-    ) -> None:
-        """Instantiate AsyncFinalIteratorCallbackHandler.
-
-        Args:
-            answer_prefix_tokens: Token sequence that prefixes the answer.
-                Default is ["Final", "Answer", ":"]
-            strip_tokens: Ignore white spaces and new lines when comparing
-                answer_prefix_tokens to last tokens? (to determine if answer has been
-                reached)
-            stream_prefix: Should answer prefix itself also be streamed?
-        """
-        super().__init__()
-        if answer_prefix_tokens is None:
-            self.answer_prefix_tokens = DEFAULT_ANSWER_PREFIX_TOKENS
-        else:
-            self.answer_prefix_tokens = answer_prefix_tokens
-        if strip_tokens:
-            self.answer_prefix_tokens_stripped = [
-                token.strip() for token in self.answer_prefix_tokens
-            ]
-        else:
-            self.answer_prefix_tokens_stripped = self.answer_prefix_tokens
-        self.last_tokens = [""] * len(self.answer_prefix_tokens)
-        self.last_tokens_stripped = [""] * len(self.answer_prefix_tokens)
-        self.strip_tokens = strip_tokens
-        self.stream_prefix = stream_prefix
-        self.answer_reached = False
-
-    @override
-    async def on_llm_start(
-        self,
-        serialized: dict[str, Any],
-        prompts: list[str],
-        **kwargs: Any,
-    ) -> None:
-        # If two calls are made in a row, this resets the state
-        self.done.clear()
-        self.answer_reached = False
-
-    @override
-    async def on_llm_end(
-        self, response: Union[LLMResult, AIMessage], **kwargs: Any
-    ) -> None:
-        if self.answer_reached:
-            self.done.set()
-
-    @override
-    async def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        # Remember the last n tokens, where n = len(answer_prefix_tokens)
-        self.append_to_last_tokens(token)
-
-        # Check if the last n tokens match the answer_prefix_tokens list ...
-        if self.check_if_answer_reached():
-            self.answer_reached = True
-            if self.stream_prefix:
-                for t in self.last_tokens:
-                    self.queue.put_nowait(t)
-            return
-
-        # If yes, then put tokens from now on
-        if self.answer_reached:
-            self.queue.put_nowait(token)

langchain/callbacks/streaming_stdout.py

@@ -1,5 +0,0 @@
-"""Callback Handler streams to stdout on new llm token."""
-
-from langchain_core.callbacks import StreamingStdOutCallbackHandler
-
-__all__ = ["StreamingStdOutCallbackHandler"]

langchain/callbacks/streaming_stdout_final_only.py

@@ -1,96 +0,0 @@
-"""Callback Handler streams to stdout on new llm token."""
-
-import sys
-from typing import Any, Optional
-
-from langchain_core.callbacks import StreamingStdOutCallbackHandler
-from typing_extensions import override
-
-DEFAULT_ANSWER_PREFIX_TOKENS = ["Final", "Answer", ":"]
-
-
-class FinalStreamingStdOutCallbackHandler(StreamingStdOutCallbackHandler):
-    """Callback handler for streaming in agents.
-    Only works with agents using LLMs that support streaming.
-
-    Only the final output of the agent will be streamed.
-    """
-
-    def append_to_last_tokens(self, token: str) -> None:
-        """Append token to the last tokens."""
-        self.last_tokens.append(token)
-        self.last_tokens_stripped.append(token.strip())
-        if len(self.last_tokens) > len(self.answer_prefix_tokens):
-            self.last_tokens.pop(0)
-            self.last_tokens_stripped.pop(0)
-
-    def check_if_answer_reached(self) -> bool:
-        """Check if the answer has been reached."""
-        if self.strip_tokens:
-            return self.last_tokens_stripped == self.answer_prefix_tokens_stripped
-        return self.last_tokens == self.answer_prefix_tokens
-
-    def __init__(
-        self,
-        *,
-        answer_prefix_tokens: Optional[list[str]] = None,
-        strip_tokens: bool = True,
-        stream_prefix: bool = False,
-    ) -> None:
-        """Instantiate FinalStreamingStdOutCallbackHandler.
-
-        Args:
-            answer_prefix_tokens: Token sequence that prefixes the answer.
-                Default is ["Final", "Answer", ":"]
-            strip_tokens: Ignore white spaces and new lines when comparing
-                answer_prefix_tokens to last tokens? (to determine if answer has been
-                reached)
-            stream_prefix: Should answer prefix itself also be streamed?
-        """
-        super().__init__()
-        if answer_prefix_tokens is None:
-            self.answer_prefix_tokens = DEFAULT_ANSWER_PREFIX_TOKENS
-        else:
-            self.answer_prefix_tokens = answer_prefix_tokens
-        if strip_tokens:
-            self.answer_prefix_tokens_stripped = [
-                token.strip() for token in self.answer_prefix_tokens
-            ]
-        else:
-            self.answer_prefix_tokens_stripped = self.answer_prefix_tokens
-        self.last_tokens = [""] * len(self.answer_prefix_tokens)
-        self.last_tokens_stripped = [""] * len(self.answer_prefix_tokens)
-        self.strip_tokens = strip_tokens
-        self.stream_prefix = stream_prefix
-        self.answer_reached = False
-
-    @override
-    def on_llm_start(
-        self,
-        serialized: dict[str, Any],
-        prompts: list[str],
-        **kwargs: Any,
-    ) -> None:
-        """Run when LLM starts running."""
-        self.answer_reached = False
-
-    @override
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        """Run on new LLM token. Only available when streaming is enabled."""
-
-        # Remember the last n tokens, where n = len(answer_prefix_tokens)
-        self.append_to_last_tokens(token)
-
-        # Check if the last n tokens match the answer_prefix_tokens list ...
-        if self.check_if_answer_reached():
-            self.answer_reached = True
-            if self.stream_prefix:
-                for t in self.last_tokens:
-                    sys.stdout.write(t)
-                sys.stdout.flush()
-            return
-
-        # ... if yes, then print tokens from now on
-        if self.answer_reached:
-            sys.stdout.write(token)
-            sys.stdout.flush()

langchain/callbacks/streamlit/__init__.py

@@ -1,86 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-from langchain_core.callbacks.base import BaseCallbackHandler
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks import LLMThoughtLabeler
-    from streamlit.delta_generator import DeltaGenerator
-
-
-def StreamlitCallbackHandler(
-    parent_container: DeltaGenerator,
-    *,
-    max_thought_containers: int = 4,
-    expand_new_thoughts: bool = True,
-    collapse_completed_thoughts: bool = True,
-    thought_labeler: Optional[LLMThoughtLabeler] = None,
-) -> BaseCallbackHandler:
-    """Callback Handler that writes to a Streamlit app.
-
-    This CallbackHandler is geared towards
-    use with a LangChain Agent; it displays the Agent's LLM and tool-usage "thoughts"
-    inside a series of Streamlit expanders.
-
-    Parameters
-    ----------
-    parent_container
-        The `st.container` that will contain all the Streamlit elements that the
-        Handler creates.
-    max_thought_containers
-        The max number of completed LLM thought containers to show at once. When this
-        threshold is reached, a new thought will cause the oldest thoughts to be
-        collapsed into a "History" expander. Defaults to 4.
-    expand_new_thoughts
-        Each LLM "thought" gets its own `st.expander`. This param controls whether that
-        expander is expanded by default. Defaults to True.
-    collapse_completed_thoughts
-        If True, LLM thought expanders will be collapsed when completed.
-        Defaults to True.
-    thought_labeler
-        An optional custom LLMThoughtLabeler instance. If unspecified, the handler
-        will use the default thought labeling logic. Defaults to None.
-
-    Returns
-    -------
-    A new StreamlitCallbackHandler instance.
-
-    Note that this is an "auto-updating" API: if the installed version of Streamlit
-    has a more recent StreamlitCallbackHandler implementation, an instance of that class
-    will be used.
-
-    """
-    # If we're using a version of Streamlit that implements StreamlitCallbackHandler,
-    # delegate to it instead of using our built-in handler. The official handler is
-    # guaranteed to support the same set of kwargs.
-    try:
-        from streamlit.external.langchain import StreamlitCallbackHandler
-
-        # This is the official handler, so we can just return it.
-        return StreamlitCallbackHandler(
-            parent_container,
-            max_thought_containers=max_thought_containers,
-            expand_new_thoughts=expand_new_thoughts,
-            collapse_completed_thoughts=collapse_completed_thoughts,
-            thought_labeler=thought_labeler,
-        )
-    except ImportError:
-        try:
-            from langchain_community.callbacks.streamlit.streamlit_callback_handler import (  # noqa: E501
-                StreamlitCallbackHandler as _InternalStreamlitCallbackHandler,
-            )
-        except ImportError as e:
-            msg = (
-                "To use the StreamlitCallbackHandler, please install "
-                "langchain-community with `pip install langchain-community`."
-            )
-            raise ImportError(msg) from e
-
-        return _InternalStreamlitCallbackHandler(
-            parent_container,
-            max_thought_containers=max_thought_containers,
-            expand_new_thoughts=expand_new_thoughts,
-            collapse_completed_thoughts=collapse_completed_thoughts,
-            thought_labeler=thought_labeler,
-        )

langchain/callbacks/streamlit/mutable_expander.py

@@ -1,33 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.streamlit.mutable_expander import (
-        ChildRecord,
-        ChildType,
-        MutableExpander,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "ChildType": "langchain_community.callbacks.streamlit.mutable_expander",
-    "ChildRecord": "langchain_community.callbacks.streamlit.mutable_expander",
-    "MutableExpander": "langchain_community.callbacks.streamlit.mutable_expander",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ChildRecord",
-    "ChildType",
-    "MutableExpander",
-]

langchain/callbacks/streamlit/streamlit_callback_handler.py

@@ -1,49 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.streamlit.streamlit_callback_handler import (
-        LLMThought,
-        LLMThoughtLabeler,
-        LLMThoughtState,
-        StreamlitCallbackHandler,
-        ToolRecord,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "LLMThoughtState": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-    "ToolRecord": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-    "LLMThoughtLabeler": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-    "LLMThought": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-    "StreamlitCallbackHandler": (
-        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
-    ),
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "LLMThought",
-    "LLMThoughtLabeler",
-    "LLMThoughtState",
-    "StreamlitCallbackHandler",
-    "ToolRecord",
-]

langchain/callbacks/tracers/__init__.py

@@ -1,38 +0,0 @@
-"""Tracers that record execution of LangChain runs."""
-
-from typing import TYPE_CHECKING, Any
-
-from langchain_core.tracers.langchain import LangChainTracer
-from langchain_core.tracers.langchain_v1 import LangChainTracerV1
-from langchain_core.tracers.stdout import (
-    ConsoleCallbackHandler,
-    FunctionCallbackHandler,
-)
-
-from langchain._api import create_importer
-from langchain.callbacks.tracers.logging import LoggingCallbackHandler
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.tracers.wandb import WandbTracer
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"WandbTracer": "langchain_community.callbacks.tracers.wandb"}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "ConsoleCallbackHandler",
-    "FunctionCallbackHandler",
-    "LangChainTracer",
-    "LangChainTracerV1",
-    "LoggingCallbackHandler",
-    "WandbTracer",
-]

langchain/callbacks/tracers/base.py

@@ -1,6 +0,0 @@
-"""Base interfaces for tracing runs."""
-
-from langchain_core.exceptions import TracerException
-from langchain_core.tracers.base import BaseTracer
-
-__all__ = ["BaseTracer", "TracerException"]

langchain/callbacks/tracers/comet.py

@@ -1,30 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.tracers.comet import (
-        CometTracer,
-        import_comet_llm_api,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "import_comet_llm_api": "langchain_community.callbacks.tracers.comet",
-    "CometTracer": "langchain_community.callbacks.tracers.comet",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "CometTracer",
-    "import_comet_llm_api",
-]

langchain/callbacks/tracers/evaluation.py

@@ -1,8 +0,0 @@
-"""A tracer that runs evaluators over completed runs."""
-
-from langchain_core.tracers.evaluation import (
-    EvaluatorCallbackHandler,
-    wait_for_all_evaluators,
-)
-
-__all__ = ["EvaluatorCallbackHandler", "wait_for_all_evaluators"]

langchain/callbacks/tracers/langchain.py

@@ -1,8 +0,0 @@
-"""A Tracer implementation that records to LangChain endpoint."""
-
-from langchain_core.tracers.langchain import (
-    LangChainTracer,
-    wait_for_all_tracers,
-)
-
-__all__ = ["LangChainTracer", "wait_for_all_tracers"]

langchain/callbacks/tracers/langchain_v1.py

@@ -1,3 +0,0 @@
-from langchain_core.tracers.langchain_v1 import LangChainTracerV1
-
-__all__ = ["LangChainTracerV1"]

langchain/callbacks/tracers/log_stream.py

@@ -1,9 +0,0 @@
-from langchain_core.tracers.log_stream import (
-    LogEntry,
-    LogStreamCallbackHandler,
-    RunLog,
-    RunLogPatch,
-    RunState,
-)
-
-__all__ = ["LogEntry", "LogStreamCallbackHandler", "RunLog", "RunLogPatch", "RunState"]