initial commit

venv/Lib/site-packages/langchain_classic/callbacks/__init__.py

@@ -0,0 +1,130 @@
+"""**Callback handlers** allow listening to events in LangChain."""
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.callbacks import (
+    FileCallbackHandler,
+    StdOutCallbackHandler,
+    StreamingStdOutCallbackHandler,
+)
+from langchain_core.tracers.context import (
+    collect_runs,
+    tracing_v2_enabled,
+)
+from langchain_core.tracers.langchain import LangChainTracer
+
+from langchain_classic._api import create_importer
+from langchain_classic.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
+from langchain_classic.callbacks.streaming_stdout_final_only import (
+    FinalStreamingStdOutCallbackHandler,
+)
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.aim_callback import AimCallbackHandler
+    from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler
+    from langchain_community.callbacks.arize_callback import ArizeCallbackHandler
+    from langchain_community.callbacks.arthur_callback import ArthurCallbackHandler
+    from langchain_community.callbacks.clearml_callback import ClearMLCallbackHandler
+    from langchain_community.callbacks.comet_ml_callback import CometCallbackHandler
+    from langchain_community.callbacks.context_callback import ContextCallbackHandler
+    from langchain_community.callbacks.flyte_callback import FlyteCallbackHandler
+    from langchain_community.callbacks.human import HumanApprovalCallbackHandler
+    from langchain_community.callbacks.infino_callback import InfinoCallbackHandler
+    from langchain_community.callbacks.labelstudio_callback import (
+        LabelStudioCallbackHandler,
+    )
+    from langchain_community.callbacks.llmonitor_callback import (
+        LLMonitorCallbackHandler,
+    )
+    from langchain_community.callbacks.manager import (
+        get_openai_callback,
+        wandb_tracing_enabled,
+    )
+    from langchain_community.callbacks.mlflow_callback import MlflowCallbackHandler
+    from langchain_community.callbacks.openai_info import OpenAICallbackHandler
+    from langchain_community.callbacks.promptlayer_callback import (
+        PromptLayerCallbackHandler,
+    )
+    from langchain_community.callbacks.sagemaker_callback import (
+        SageMakerCallbackHandler,
+    )
+    from langchain_community.callbacks.streamlit import StreamlitCallbackHandler
+    from langchain_community.callbacks.streamlit.streamlit_callback_handler import (
+        LLMThoughtLabeler,
+    )
+    from langchain_community.callbacks.trubrics_callback import TrubricsCallbackHandler
+    from langchain_community.callbacks.wandb_callback import WandbCallbackHandler
+    from langchain_community.callbacks.whylabs_callback import WhyLabsCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
+    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
+    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
+    "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback",
+    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
+    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
+    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
+    "ContextCallbackHandler": "langchain_community.callbacks.context_callback",
+    "HumanApprovalCallbackHandler": "langchain_community.callbacks.human",
+    "InfinoCallbackHandler": "langchain_community.callbacks.infino_callback",
+    "MlflowCallbackHandler": "langchain_community.callbacks.mlflow_callback",
+    "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback",
+    "OpenAICallbackHandler": "langchain_community.callbacks.openai_info",
+    "LLMThoughtLabeler": (
+        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
+    ),
+    "StreamlitCallbackHandler": "langchain_community.callbacks.streamlit",
+    "WandbCallbackHandler": "langchain_community.callbacks.wandb_callback",
+    "WhyLabsCallbackHandler": "langchain_community.callbacks.whylabs_callback",
+    "get_openai_callback": "langchain_community.callbacks.manager",
+    "wandb_tracing_enabled": "langchain_community.callbacks.manager",
+    "FlyteCallbackHandler": "langchain_community.callbacks.flyte_callback",
+    "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback",
+    "LabelStudioCallbackHandler": "langchain_community.callbacks.labelstudio_callback",
+    "TrubricsCallbackHandler": "langchain_community.callbacks.trubrics_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "AimCallbackHandler",
+    "ArgillaCallbackHandler",
+    "ArizeCallbackHandler",
+    "ArthurCallbackHandler",
+    "AsyncIteratorCallbackHandler",
+    "ClearMLCallbackHandler",
+    "CometCallbackHandler",
+    "ContextCallbackHandler",
+    "FileCallbackHandler",
+    "FinalStreamingStdOutCallbackHandler",
+    "FlyteCallbackHandler",
+    "HumanApprovalCallbackHandler",
+    "InfinoCallbackHandler",
+    "LLMThoughtLabeler",
+    "LLMonitorCallbackHandler",
+    "LabelStudioCallbackHandler",
+    "LangChainTracer",
+    "MlflowCallbackHandler",
+    "OpenAICallbackHandler",
+    "PromptLayerCallbackHandler",
+    "SageMakerCallbackHandler",
+    "StdOutCallbackHandler",
+    "StreamingStdOutCallbackHandler",
+    "StreamlitCallbackHandler",
+    "TrubricsCallbackHandler",
+    "WandbCallbackHandler",
+    "WhyLabsCallbackHandler",
+    "collect_runs",
+    "get_openai_callback",
+    "tracing_v2_enabled",
+    "wandb_tracing_enabled",
+]

venv/Lib/site-packages/langchain_classic/callbacks/aim_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/argilla_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/arize_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/arthur_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/base.py

@@ -0,0 +1,29 @@
+"""Base callback handler that can be used to handle callbacks in langchain."""
+
+from __future__ import annotations
+
+from langchain_core.callbacks import (
+    AsyncCallbackHandler,
+    BaseCallbackHandler,
+    BaseCallbackManager,
+    CallbackManagerMixin,
+    Callbacks,
+    ChainManagerMixin,
+    LLMManagerMixin,
+    RetrieverManagerMixin,
+    RunManagerMixin,
+    ToolManagerMixin,
+)
+
+__all__ = [
+    "AsyncCallbackHandler",
+    "BaseCallbackHandler",
+    "BaseCallbackManager",
+    "CallbackManagerMixin",
+    "Callbacks",
+    "ChainManagerMixin",
+    "LLMManagerMixin",
+    "RetrieverManagerMixin",
+    "RunManagerMixin",
+    "ToolManagerMixin",
+]

venv/Lib/site-packages/langchain_classic/callbacks/clearml_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/comet_ml_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/confident_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/context_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/file.py

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

venv/Lib/site-packages/langchain_classic/callbacks/flyte_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/human.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/infino_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/labelstudio_callback.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/llmonitor_callback.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/manager.py

@@ -0,0 +1,87 @@
+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_v2_enabled,
+)
+from langchain_core.utils.env import env_var_is_set
+
+from langchain_classic._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_v2_enabled",
+    "wandb_tracing_enabled",
+]

venv/Lib/site-packages/langchain_classic/callbacks/mlflow_callback.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/openai_info.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/promptlayer_callback.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/sagemaker_callback.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/stdout.py

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

venv/Lib/site-packages/langchain_classic/callbacks/streaming_aiter.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import AsyncIterator
+from typing import Any, Literal, cast
+
+from langchain_core.callbacks import AsyncCallbackHandler
+from langchain_core.outputs import LLMResult
+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: LLMResult, **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("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

venv/Lib/site-packages/langchain_classic/callbacks/streaming_aiter_final_only.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core.outputs import LLMResult
+from typing_extensions import override
+
+from langchain_classic.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: list[str] | None = 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: LLMResult, **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)

venv/Lib/site-packages/langchain_classic/callbacks/streaming_stdout.py

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

venv/Lib/site-packages/langchain_classic/callbacks/streaming_stdout_final_only.py

@@ -0,0 +1,96 @@
+"""Callback Handler streams to stdout on new llm token."""
+
+import sys
+from typing import Any
+
+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: list[str] | None = 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()

venv/Lib/site-packages/langchain_classic/callbacks/streamlit/__init__.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from langchain_core.callbacks.base import BaseCallbackHandler
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks import LLMThoughtLabeler
+    from streamlit.delta_generator import DeltaGenerator
+
+
+def StreamlitCallbackHandler(  # noqa: N802
+    parent_container: DeltaGenerator,
+    *,
+    max_thought_containers: int = 4,
+    expand_new_thoughts: bool = True,
+    collapse_completed_thoughts: bool = True,
+    thought_labeler: LLMThoughtLabeler | None = 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.
+    expand_new_thoughts
+        Each LLM "thought" gets its own `st.expander`. This param controls whether that
+        expander is expanded by default.
+    collapse_completed_thoughts
+        If `True`, LLM thought expanders will be collapsed when completed.
+    thought_labeler
+        An optional custom LLMThoughtLabeler instance. If unspecified, the handler
+        will use the default thought labeling logic.
+
+    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,
+        )

venv/Lib/site-packages/langchain_classic/callbacks/streamlit/mutable_expander.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/streamlit/streamlit_callback_handler.py

@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/__init__.py

@@ -0,0 +1,36 @@
+"""Tracers that record execution of LangChain runs."""
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.tracers.langchain import LangChainTracer
+from langchain_core.tracers.stdout import (
+    ConsoleCallbackHandler,
+    FunctionCallbackHandler,
+)
+
+from langchain_classic._api import create_importer
+from langchain_classic.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",
+    "LoggingCallbackHandler",
+    "WandbTracer",
+]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/base.py

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

venv/Lib/site-packages/langchain_classic/callbacks/tracers/comet.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/evaluation.py

@@ -0,0 +1,8 @@
+"""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"]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/langchain.py

@@ -0,0 +1,8 @@
+"""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"]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/log_stream.py

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

venv/Lib/site-packages/langchain_classic/callbacks/tracers/logging.py

@@ -0,0 +1,56 @@
+__all__ = ["LoggingCallbackHandler"]
+
+import logging
+from typing import Any
+from uuid import UUID
+
+from langchain_core.exceptions import TracerException
+from langchain_core.tracers.stdout import FunctionCallbackHandler
+from langchain_core.utils.input import get_bolded_text, get_colored_text
+from typing_extensions import override
+
+
+class LoggingCallbackHandler(FunctionCallbackHandler):
+    """Tracer that logs via the input Logger."""
+
+    name: str = "logging_callback_handler"
+
+    def __init__(
+        self,
+        logger: logging.Logger,
+        log_level: int = logging.INFO,
+        extra: dict | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the LoggingCallbackHandler.
+
+        Args:
+            logger: the logger to use for logging
+            log_level: the logging level (default: logging.INFO)
+            extra: the extra context to log (default: None)
+            **kwargs: additional keyword arguments.
+        """
+        log_method = getattr(logger, logging.getLevelName(level=log_level).lower())
+
+        def callback(text: str) -> None:
+            log_method(text, extra=extra)
+
+        super().__init__(function=callback, **kwargs)
+
+    @override
+    def on_text(
+        self,
+        text: str,
+        *,
+        run_id: UUID,
+        parent_run_id: UUID | None = None,
+        **kwargs: Any,
+    ) -> None:
+        try:
+            crumbs_str = f"[{self.get_breadcrumbs(run=self._get_run(run_id=run_id))}] "
+        except TracerException:
+            crumbs_str = ""
+        self.function_callback(
+            f"{get_colored_text('[text]', color='blue')}"
+            f" {get_bolded_text(f'{crumbs_str}New text:')}\n{text}",
+        )

venv/Lib/site-packages/langchain_classic/callbacks/tracers/root_listeners.py

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

venv/Lib/site-packages/langchain_classic/callbacks/tracers/run_collector.py

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

venv/Lib/site-packages/langchain_classic/callbacks/tracers/schemas.py

@@ -0,0 +1,5 @@
+from langchain_core.tracers.schemas import Run
+
+__all__ = [
+    "Run",
+]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/stdout.py

@@ -0,0 +1,6 @@
+from langchain_core.tracers.stdout import (
+    ConsoleCallbackHandler,
+    FunctionCallbackHandler,
+)
+
+__all__ = ["ConsoleCallbackHandler", "FunctionCallbackHandler"]

venv/Lib/site-packages/langchain_classic/callbacks/tracers/wandb.py

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.tracers.wandb import WandbRunArgs, WandbTracer
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "WandbRunArgs": "langchain_community.callbacks.tracers.wandb",
+    "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__ = [
+    "WandbRunArgs",
+    "WandbTracer",
+]

venv/Lib/site-packages/langchain_classic/callbacks/trubrics_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/utils.py

@@ -0,0 +1,48 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.utils import (
+        BaseMetadataCallbackHandler,
+        _flatten_dict,
+        flatten_dict,
+        hash_string,
+        import_pandas,
+        import_spacy,
+        import_textstat,
+        load_json,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "import_spacy": "langchain_community.callbacks.utils",
+    "import_pandas": "langchain_community.callbacks.utils",
+    "import_textstat": "langchain_community.callbacks.utils",
+    "_flatten_dict": "langchain_community.callbacks.utils",
+    "flatten_dict": "langchain_community.callbacks.utils",
+    "hash_string": "langchain_community.callbacks.utils",
+    "load_json": "langchain_community.callbacks.utils",
+    "BaseMetadataCallbackHandler": "langchain_community.callbacks.utils",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "BaseMetadataCallbackHandler",
+    "_flatten_dict",
+    "flatten_dict",
+    "hash_string",
+    "import_pandas",
+    "import_spacy",
+    "import_textstat",
+    "load_json",
+]

venv/Lib/site-packages/langchain_classic/callbacks/wandb_callback.py

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

venv/Lib/site-packages/langchain_classic/callbacks/whylabs_callback.py

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