langchain 0.3.27__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/callbacks/confident_callback.py

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

langchain/callbacks/context_callback.py

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

langchain/callbacks/file.py

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

langchain/callbacks/flyte_callback.py

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

langchain/callbacks/human.py

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

langchain/callbacks/infino_callback.py

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

langchain/callbacks/labelstudio_callback.py

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

langchain/callbacks/llmonitor_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.llmonitor_callback import (
-        LLMonitorCallbackHandler,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "LLMonitorCallbackHandler",
-]

langchain/callbacks/manager.py

@@ -1,89 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langchain_core.callbacks import Callbacks
-from langchain_core.callbacks.manager import (
-    AsyncCallbackManager,
-    AsyncCallbackManagerForChainGroup,
-    AsyncCallbackManagerForChainRun,
-    AsyncCallbackManagerForLLMRun,
-    AsyncCallbackManagerForRetrieverRun,
-    AsyncCallbackManagerForToolRun,
-    AsyncParentRunManager,
-    AsyncRunManager,
-    BaseRunManager,
-    CallbackManager,
-    CallbackManagerForChainGroup,
-    CallbackManagerForChainRun,
-    CallbackManagerForLLMRun,
-    CallbackManagerForRetrieverRun,
-    CallbackManagerForToolRun,
-    ParentRunManager,
-    RunManager,
-    ahandle_event,
-    atrace_as_chain_group,
-    handle_event,
-    trace_as_chain_group,
-)
-from langchain_core.tracers.context import (
-    collect_runs,
-    tracing_enabled,
-    tracing_v2_enabled,
-)
-from langchain_core.utils.env import env_var_is_set
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.callbacks.manager import (
-        get_openai_callback,
-        wandb_tracing_enabled,
-    )
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {
-    "get_openai_callback": "langchain_community.callbacks.manager",
-    "wandb_tracing_enabled": "langchain_community.callbacks.manager",
-}
-
-_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "AsyncCallbackManager",
-    "AsyncCallbackManagerForChainGroup",
-    "AsyncCallbackManagerForChainRun",
-    "AsyncCallbackManagerForLLMRun",
-    "AsyncCallbackManagerForRetrieverRun",
-    "AsyncCallbackManagerForToolRun",
-    "AsyncParentRunManager",
-    "AsyncRunManager",
-    "BaseRunManager",
-    "CallbackManager",
-    "CallbackManagerForChainGroup",
-    "CallbackManagerForChainRun",
-    "CallbackManagerForLLMRun",
-    "CallbackManagerForRetrieverRun",
-    "CallbackManagerForToolRun",
-    "Callbacks",
-    "ParentRunManager",
-    "RunManager",
-    "ahandle_event",
-    "atrace_as_chain_group",
-    "collect_runs",
-    "env_var_is_set",
-    "get_openai_callback",
-    "handle_event",
-    "trace_as_chain_group",
-    "tracing_enabled",
-    "tracing_v2_enabled",
-    "wandb_tracing_enabled",
-]

langchain/callbacks/mlflow_callback.py

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

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,75 +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
-
-# 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:
-        return True
-
-    def __init__(self) -> None:
-        self.queue = asyncio.Queue()
-        self.done = asyncio.Event()
-
-    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()
-
-    async def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        if token is not None and token != "":
-            self.queue.put_nowait(token)
-
-    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
-        self.done.set()
-
-    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]:
-        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,91 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from langchain_core.outputs import LLMResult
-
-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:
-        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:
-        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
-
-    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
-
-    async def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
-        if self.answer_reached:
-            self.done.set()
-
-    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,91 +0,0 @@
-"""Callback Handler streams to stdout on new llm token."""
-
-import sys
-from typing import Any, Optional
-
-from langchain_core.callbacks import StreamingStdOutCallbackHandler
-
-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:
-        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:
-        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
-
-    def on_llm_start(
-        self,
-        serialized: dict[str, Any],
-        prompts: list[str],
-        **kwargs: Any,
-    ) -> None:
-        """Run when LLM starts running."""
-        self.answer_reached = False
-
-    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()