x

libs/core/Makefile

@@ -73,3 +73,29 @@ help:
 	@echo 'tests                        - run unit tests'
 	@echo 'test TEST_FILE=<test_file>   - run all tests in file'
 	@echo 'test_watch                   - run unit tests in watch mode'
+
+##########
+# CUSTOM #
+##########
+
+bench-imports:
+	time poetry run python -c "from typing import Any"
+	time poetry run python -c "from typing import Any"
+	time poetry run python -c "from langchain_core import __version__"
+	time poetry run python -c "from langchain_core.tools import tool"
+	time poetry run python -c "from langchain_core.messages import AIMessage"
+	time poetry run python -c "from langchain_core.documents import Document"
+	time poetry run python -c "from langchain_core._api import deprecated"
+	time poetry run python -c "from langchain_core._api import beta"
+	time poetry run python -c "from langchain_core.callbacks import BaseCallbackHandler"
+	time poetry run python -c "from langchain_core.document_loaders import BaseLoader"
+	time poetry run python -c "from langchain_core.embeddings import Embeddings"
+	time poetry run python -c "from langchain_core.language_models import BaseChatModel"
+	time poetry run python -c "from langchain_core.language_models import BaseLLM"
+	time poetry run python -c "from langchain_core.load import loads"
+	time poetry run python -c "from langchain_core.output_parsers import BaseOutputParser"
+	time poetry run python -c "from langchain_core.prompts import ChatPromptTemplate"
+	time poetry run python -c "from langchain_core.runnables import RunnableSerializable"
+	time poetry run python -c "from langchain_core.tools import BaseTool"
+	time poetry run python -c "from langchain_core.tracers import BaseTracer"
+	time poetry run python -c "from langchain_core.vectorstores import VectorStore"

libs/core/it.py

@@ -0,0 +1 @@
+from langchain_core.tools import tool

libs/core/langchain_core/callbacks/__init__.py

@@ -6,43 +6,180 @@
 
     BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler
 """
+from typing import TYPE_CHECKING, Any
 
-from langchain_core.callbacks.base import (
+if TYPE_CHECKING:
-    AsyncCallbackHandler,
+
-    BaseCallbackHandler,
+    from langchain_core.callbacks.base import (
-    BaseCallbackManager,
+        AsyncCallbackHandler,
-    CallbackManagerMixin,
+        BaseCallbackHandler,
-    Callbacks,
+        BaseCallbackManager,
-    ChainManagerMixin,
+        CallbackManagerMixin,
-    LLMManagerMixin,
+        Callbacks,
-    RetrieverManagerMixin,
+        ChainManagerMixin,
-    RunManagerMixin,
+        LLMManagerMixin,
-    ToolManagerMixin,
+        RetrieverManagerMixin,
-)
+        RunManagerMixin,
-from langchain_core.callbacks.file import FileCallbackHandler
+        ToolManagerMixin,
-from langchain_core.callbacks.manager import (
+    )
-    AsyncCallbackManager,
+    from langchain_core.callbacks.file import FileCallbackHandler
-    AsyncCallbackManagerForChainGroup,
+    from langchain_core.callbacks.manager import (
-    AsyncCallbackManagerForChainRun,
+        AsyncCallbackManager,
-    AsyncCallbackManagerForLLMRun,
+        AsyncCallbackManagerForChainGroup,
-    AsyncCallbackManagerForRetrieverRun,
+        AsyncCallbackManagerForChainRun,
-    AsyncCallbackManagerForToolRun,
+        AsyncCallbackManagerForLLMRun,
-    AsyncParentRunManager,
+        AsyncCallbackManagerForRetrieverRun,
-    AsyncRunManager,
+        AsyncCallbackManagerForToolRun,
-    BaseRunManager,
+        AsyncParentRunManager,
-    CallbackManager,
+        AsyncRunManager,
-    CallbackManagerForChainGroup,
+        BaseRunManager,
-    CallbackManagerForChainRun,
+        CallbackManager,
-    CallbackManagerForLLMRun,
+        CallbackManagerForChainGroup,
-    CallbackManagerForRetrieverRun,
+        CallbackManagerForChainRun,
-    CallbackManagerForToolRun,
+        CallbackManagerForLLMRun,
-    ParentRunManager,
+        CallbackManagerForRetrieverRun,
-    RunManager,
+        CallbackManagerForToolRun,
-    adispatch_custom_event,
+        ParentRunManager,
-    dispatch_custom_event,
+        RunManager,
-)
+        adispatch_custom_event,
-from langchain_core.callbacks.stdout import StdOutCallbackHandler
+        dispatch_custom_event,
-from langchain_core.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+    )
+    from langchain_core.callbacks.stdout import StdOutCallbackHandler
+    from langchain_core.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+
+def __getattr__(name: str) -> Any:
+    if name == "dispatch_custom_event":
+        from langchain_core.callbacks.manager import dispatch_custom_event
+
+        return dispatch_custom_event
+    if name == "adispatch_custom_event":
+        from langchain_core.callbacks.manager import adispatch_custom_event
+
+        return adispatch_custom_event
+    if name == "RetrieverManagerMixin":
+        from langchain_core.callbacks.base import RetrieverManagerMixin
+
+        return RetrieverManagerMixin
+    if name == "LLMManagerMixin":
+        from langchain_core.callbacks.base import LLMManagerMixin
+
+        return LLMManagerMixin
+    if name == "ChainManagerMixin":
+        from langchain_core.callbacks.base import ChainManagerMixin
+
+        return ChainManagerMixin
+    if name == "ToolManagerMixin":
+        from langchain_core.callbacks.base import ToolManagerMixin
+
+        return ToolManagerMixin
+    if name == "Callbacks":
+        from langchain_core.callbacks.base import Callbacks
+
+        return Callbacks
+    if name == "CallbackManagerMixin":
+        from langchain_core.callbacks.base import CallbackManagerMixin
+
+        return CallbackManagerMixin
+    if name == "RunManagerMixin":
+        from langchain_core.callbacks.base import RunManagerMixin
+
+        return RunManagerMixin
+    if name == "BaseCallbackHandler":
+        from langchain_core.callbacks.base import BaseCallbackHandler
+
+        return BaseCallbackHandler
+    if name == "AsyncCallbackHandler":
+        from langchain_core.callbacks.base import AsyncCallbackHandler
+
+        return AsyncCallbackHandler
+    if name == "BaseCallbackManager":
+        from langchain_core.callbacks.manager import BaseCallbackManager
+
+        return BaseCallbackManager
+    if name == "BaseRunManager":
+        from langchain_core.callbacks.manager import BaseRunManager
+
+        return BaseRunManager
+    if name == "RunManager":
+        from langchain_core.callbacks.manager import RunManager
+
+        return RunManager
+    if name == "ParentRunManager":
+        from langchain_core.callbacks.manager import ParentRunManager
+
+        return ParentRunManager
+    if name == "AsyncRunManager":
+        from langchain_core.callbacks.manager import AsyncRunManager
+
+        return AsyncRunManager
+    if name == "AsyncParentRunManager":
+        from langchain_core.callbacks.manager import AsyncParentRunManager
+
+        return AsyncParentRunManager
+    if name == "CallbackManagerForLLMRun":
+        from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+
+        return CallbackManagerForLLMRun
+    if name == "AsyncCallbackManagerForLLMRun":
+        from langchain_core.callbacks.manager import AsyncCallbackManagerForLLMRun
+
+        return AsyncCallbackManagerForLLMRun
+    if name == "CallbackManagerForChainRun":
+        from langchain_core.callbacks.manager import CallbackManagerForChainRun
+
+        return CallbackManagerForChainRun
+    if name == "AsyncCallbackManagerForChainRun":
+        from langchain_core.callbacks.manager import AsyncCallbackManagerForChainRun
+
+        return AsyncCallbackManagerForChainRun
+    if name == "CallbackManagerForToolRun":
+        from langchain_core.callbacks.manager import CallbackManagerForToolRun
+
+        return CallbackManagerForToolRun
+    if name == "AsyncCallbackManagerForToolRun":
+        from langchain_core.callbacks.manager import AsyncCallbackManagerForToolRun
+
+        return AsyncCallbackManagerForToolRun
+    if name == "CallbackManagerForRetrieverRun":
+        from langchain_core.callbacks.manager import CallbackManagerForRetrieverRun
+
+        return CallbackManagerForRetrieverRun
+    if name == "AsyncCallbackManagerForRetrieverRun":
+        from langchain_core.callbacks.manager import AsyncCallbackManagerForRetrieverRun
+
+        return AsyncCallbackManagerForRetrieverRun
+    if name == "CallbackManager":
+        from langchain_core.callbacks.manager import CallbackManager
+
+        return CallbackManager
+    if name == "CallbackManagerForChainGroup":
+        from langchain_core.callbacks.manager import CallbackManagerForChainGroup
+
+        return CallbackManagerForChainGroup
+    if name == "AsyncCallbackManager":
+        from langchain_core.callbacks.manager import AsyncCallbackManager
+
+        return AsyncCallbackManager
+    if name == "AsyncCallbackManagerForChainGroup":
+        from langchain_core.callbacks.manager import AsyncCallbackManagerForChainGroup
+
+        return AsyncCallbackManagerForChainGroup
+    if name == "StdOutCallbackHandler":
+        from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+        return StdOutCallbackHandler
+    if name == "StreamingStdOutCallbackHandler":
+        from langchain_core.callbacks.streaming_stdout import (
+            StreamingStdOutCallbackHandler,
+        )
+
+        return StreamingStdOutCallbackHandler
+    if name == "FileCallbackHandler":
+        from langchain_core.callbacks.file import FileCallbackHandler
+
+        return FileCallbackHandler
+    msg = f"module {__name__} has no attribute {name}"
+    raise AttributeError(msg)
 
 __all__ = [
     "dispatch_custom_event",

libs/core/langchain_core/tools/__init__.py

@@ -19,43 +19,144 @@ tool for the job.
 
 from __future__ import annotations
 
-from langchain_core.tools.base import (
+from typing import TYPE_CHECKING
-    FILTERED_ARGS as FILTERED_ARGS,
+
-)
+if TYPE_CHECKING:
-from langchain_core.tools.base import (
+    from typing import Any
-    BaseTool as BaseTool,
+
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.base import (
+        FILTERED_ARGS as FILTERED_ARGS,
-    BaseToolkit as BaseToolkit,
+    )
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.base import (
+        BaseTool as BaseTool,
-    InjectedToolArg as InjectedToolArg,
+    )
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.base import InjectedToolCallId as InjectedToolCallId
+        BaseToolkit as BaseToolkit,
-from langchain_core.tools.base import SchemaAnnotationError as SchemaAnnotationError
+    )
-from langchain_core.tools.base import (
+    from langchain_core.tools.base import (
-    ToolException as ToolException,
+        InjectedToolArg as InjectedToolArg,
-)
+    )
-from langchain_core.tools.base import (
+    from langchain_core.tools.base import InjectedToolCallId as InjectedToolCallId
-    _get_runnable_config_param as _get_runnable_config_param,
+    from langchain_core.tools.base import SchemaAnnotationError as SchemaAnnotationError
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.base import (
+        ToolException as ToolException,
-    create_schema_from_function as create_schema_from_function,
+    )
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.convert import (
+        _get_runnable_config_param as _get_runnable_config_param,
-    convert_runnable_to_tool as convert_runnable_to_tool,
+    )
-)
+    from langchain_core.tools.base import (
-from langchain_core.tools.convert import tool as tool
+        create_schema_from_function as create_schema_from_function,
-from langchain_core.tools.render import ToolsRenderer as ToolsRenderer
+    )
-from langchain_core.tools.render import (
+    from langchain_core.tools.convert import (
-    render_text_description as render_text_description,
+        convert_runnable_to_tool as convert_runnable_to_tool,
-)
+    )
-from langchain_core.tools.render import (
+    from langchain_core.tools.convert import tool as tool
-    render_text_description_and_args as render_text_description_and_args,
+    from langchain_core.tools.render import ToolsRenderer as ToolsRenderer
-)
+    from langchain_core.tools.render import (
-from langchain_core.tools.retriever import RetrieverInput as RetrieverInput
+        render_text_description as render_text_description,
-from langchain_core.tools.retriever import (
+    )
-    create_retriever_tool as create_retriever_tool,
+    from langchain_core.tools.render import (
-)
+        render_text_description_and_args as render_text_description_and_args,
-from langchain_core.tools.simple import Tool as Tool
+    )
-from langchain_core.tools.structured import StructuredTool as StructuredTool
+    from langchain_core.tools.retriever import RetrieverInput as RetrieverInput
+    from langchain_core.tools.retriever import (
+        create_retriever_tool as create_retriever_tool,
+    )
+    from langchain_core.tools.simple import Tool as Tool
+    from langchain_core.tools.structured import StructuredTool as StructuredTool
+
+def __getattr__(name: str) -> Any:
+    if name == "FILTERED_ARGS":
+        from langchain_core.tools.base import FILTERED_ARGS
+
+        return FILTERED_ARGS
+    if name == "BaseTool":
+        from langchain_core.tools.base import BaseTool
+
+        return BaseTool
+    if name == "BaseToolkit":
+        from langchain_core.tools.base import BaseToolkit
+
+        return BaseToolkit
+    if name == "InjectedToolArg":
+        from langchain_core.tools.base import InjectedToolArg
+
+        return InjectedToolArg
+    if name == "InjectedToolCallId":
+        from langchain_core.tools.base import InjectedToolCallId
+
+        return InjectedToolCallId
+    if name == "SchemaAnnotationError":
+        from langchain_core.tools.base import SchemaAnnotationError
+
+        return SchemaAnnotationError
+    if name == "ToolException":
+        from langchain_core.tools.base import ToolException
+
+        return ToolException
+    if name == "_get_runnable_config_param":
+        from langchain_core.tools.base import _get_runnable_config_param
+
+        return _get_runnable_config_param
+    if name == "create_schema_from_function":
+        from langchain_core.tools.base import create_schema_from_function
+
+        return create_schema_from_function
+    if name == "convert_runnable_to_tool":
+        from langchain_core.tools.convert import convert_runnable_to_tool
+
+        return convert_runnable_to_tool
+    if name == "tool":
+        from langchain_core.tools.convert import tool
+
+        return tool
+    if name == "ToolsRenderer":
+        from langchain_core.tools.render import ToolsRenderer
+
+        return ToolsRenderer
+    if name == "render_text_description":
+        from langchain_core.tools.render import render_text_description
+
+        return render_text_description
+    if name == "render_text_description_and_args":
+        from langchain_core.tools.render import render_text_description_and_args
+
+        return render_text_description_and_args
+    if name == "RetrieverInput":
+        from langchain_core.tools.retriever import RetrieverInput
+
+        return RetrieverInput
+    if name == "create_retriever_tool":
+        from langchain_core.tools.retriever import create_retriever_tool
+
+        return create_retriever_tool
+    if name == "Tool":
+        from langchain_core.tools.simple import Tool
+
+        return Tool
+    if name == "StructuredTool":
+        from langchain_core.tools.structured import StructuredTool
+
+        return StructuredTool
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+__all__ = [
+    "FILTERED_ARGS",
+    "BaseTool",
+    "BaseToolkit",
+    "InjectedToolArg",
+    "InjectedToolCallId",
+    "SchemaAnnotationError",
+    "ToolException",
+    "_get_runnable_config_param",
+    "create_schema_from_function",
+    "convert_runnable_to_tool",
+    "tool",
+    "ToolsRenderer",
+    "render_text_description",
+    "render_text_description_and_args",
+    "RetrieverInput",
+    "create_retriever_tool",
+    "Tool",
+    "StructuredTool",
+]

libs/core/langchain_core/utils/utils.py

@@ -8,11 +8,13 @@ import os
 import warnings
 from collections.abc import Sequence
 from importlib.metadata import version
-from typing import Any, Callable, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
 
 from packaging.version import parse
 from pydantic import SecretStr
-from requests import HTTPError, Response
+
+if TYPE_CHECKING:
+    from requests import Response
 
 from langchain_core.utils.pydantic import (
     is_pydantic_v1_subclass,
@@ -57,7 +59,7 @@ def xor_args(*arg_groups: tuple[str, ...]) -> Callable:
     return decorator
 
 
-def raise_for_status_with_text(response: Response) -> None:
+def raise_for_status_with_text(response: "Response") -> None:
     """Raise an error with the response text.
 
     Args:
@@ -66,6 +68,7 @@ def raise_for_status_with_text(response: Response) -> None:
     Raises:
         ValueError: If the response has an error status code.
     """
+    from requests import HTTPError
     try:
         response.raise_for_status()
     except HTTPError as e: