langchain-core 0.3.75__py3-none-any.whl → 0.3.77__py3-none-any.whl

langchain_core/stores.py

@@ -16,6 +16,8 @@ from typing import (
     Union,
 )
 
+from typing_extensions import override
+
 from langchain_core.exceptions import LangChainException
 from langchain_core.runnables import run_in_executor
 
@@ -52,24 +54,24 @@ class BaseStore(ABC, Generic[K, V]):
 
             from langchain.storage import BaseStore
 
-            class MyInMemoryStore(BaseStore[str, int]):
 
-                def __init__(self):
-                    self.store = {}
+            class MyInMemoryStore(BaseStore[str, int]):
+                def __init__(self) -> None:
+                    self.store: dict[str, int] = {}
 
-                def mget(self, keys):
+                def mget(self, keys: Sequence[str]) -> list[int | None]:
                     return [self.store.get(key) for key in keys]
 
-                def mset(self, key_value_pairs):
+                def mset(self, key_value_pairs: Sequence[tuple[str, int]]) -> None:
                     for key, value in key_value_pairs:
                         self.store[key] = value
 
-                def mdelete(self, keys):
+                def mdelete(self, keys: Sequence[str]) -> None:
                     for key in keys:
                         if key in self.store:
                             del self.store[key]
 
-                def yield_keys(self, prefix=None):
+                def yield_keys(self, prefix: str | None = None) -> Iterator[str]:
                     if prefix is None:
                         yield from self.store.keys()
                     else:
@@ -206,27 +208,13 @@ class InMemoryBaseStore(BaseStore[str, V], Generic[V]):
         """
         return self.mget(keys)
 
+    @override
     def mset(self, key_value_pairs: Sequence[tuple[str, V]]) -> None:
-        """Set the values for the given keys.
-
-        Args:
-            key_value_pairs (Sequence[tuple[str, V]]): A sequence of key-value pairs.
-
-        Returns:
-            None
-        """
         for key, value in key_value_pairs:
             self.store[key] = value
 
+    @override
     async def amset(self, key_value_pairs: Sequence[tuple[str, V]]) -> None:
-        """Async set the values for the given keys.
-
-        Args:
-            key_value_pairs (Sequence[tuple[str, V]]): A sequence of key-value pairs.
-
-        Returns:
-            None
-        """
         return self.mset(key_value_pairs)
 
     def mdelete(self, keys: Sequence[str]) -> None:
@@ -295,13 +283,13 @@ class InMemoryStore(InMemoryBaseStore[Any]):
             from langchain.storage import InMemoryStore
 
             store = InMemoryStore()
-            store.mset([('key1', 'value1'), ('key2', 'value2')])
-            store.mget(['key1', 'key2'])
+            store.mset([("key1", "value1"), ("key2", "value2")])
+            store.mget(["key1", "key2"])
             # ['value1', 'value2']
-            store.mdelete(['key1'])
+            store.mdelete(["key1"])
             list(store.yield_keys())
             # ['key2']
-            list(store.yield_keys(prefix='k'))
+            list(store.yield_keys(prefix="k"))
             # ['key2']
 
     """
@@ -321,13 +309,13 @@ class InMemoryByteStore(InMemoryBaseStore[bytes]):
             from langchain.storage import InMemoryByteStore
 
             store = InMemoryByteStore()
-            store.mset([('key1', b'value1'), ('key2', b'value2')])
-            store.mget(['key1', 'key2'])
+            store.mset([("key1", b"value1"), ("key2", b"value2")])
+            store.mget(["key1", "key2"])
             # [b'value1', b'value2']
-            store.mdelete(['key1'])
+            store.mdelete(["key1"])
             list(store.yield_keys())
             # ['key2']
-            list(store.yield_keys(prefix='k'))
+            list(store.yield_keys(prefix="k"))
             # ['key2']
 
     """

langchain_core/sys_info.py

@@ -1,12 +1,18 @@
-"""**sys_info** prints information about the system and langchain packages for debugging purposes."""  # noqa: E501
+"""**sys_info** implementation.
 
+sys_info prints information about the system and langchain packages for
+debugging purposes.
+"""
+
+import pkgutil
+import platform
+import sys
 from collections.abc import Sequence
+from importlib import metadata, util
 
 
 def _get_sub_deps(packages: Sequence[str]) -> list[str]:
     """Get any specified sub-dependencies."""
-    from importlib import metadata
-
     sub_deps = set()
     underscored_packages = {pkg.replace("-", "_") for pkg in packages}
 
@@ -33,11 +39,6 @@ def print_sys_info(*, additional_pkgs: Sequence[str] = ()) -> None:
     Args:
         additional_pkgs: Additional packages to include in the output.
     """
-    import pkgutil
-    import platform
-    import sys
-    from importlib import metadata, util
-
     # Packages that do not start with "langchain" prefix.
     other_langchain_packages = [
         "langserve",

langchain_core/tools/base.py

@@ -81,6 +81,8 @@ TOOL_MESSAGE_BLOCK_TYPES = (
     "json",
     "search_result",
     "custom_tool_call_output",
+    "document",
+    "file",
 )
 
 
@@ -271,15 +273,12 @@ def _function_annotations_are_pydantic_v1(
 
 
 class _SchemaConfig:
-    """Configuration for Pydantic models generated from function signatures.
-
-    Attributes:
-        extra: Whether to allow extra fields in the model.
-        arbitrary_types_allowed: Whether to allow arbitrary types in the model.
-    """
+    """Configuration for Pydantic models generated from function signatures."""
 
     extra: str = "forbid"
+    """Whether to allow extra fields in the model."""
     arbitrary_types_allowed: bool = True
+    """Whether to allow arbitrary types in the model."""
 
 
 def create_schema_from_function(
@@ -506,7 +505,12 @@ class ChildTool(BaseTool):
     """
 
     def __init__(self, **kwargs: Any) -> None:
-        """Initialize the tool."""
+        """Initialize the tool.
+
+        Raises:
+            TypeError: If ``args_schema`` is not a subclass of pydantic ``BaseModel`` or
+                dict.
+        """
         if (
             "args_schema" in kwargs
             and kwargs["args_schema"] is not None
@@ -543,6 +547,8 @@ class ChildTool(BaseTool):
         """
         if isinstance(self.args_schema, dict):
             json_schema = self.args_schema
+        elif self.args_schema and issubclass(self.args_schema, BaseModelV1):
+            json_schema = self.args_schema.schema()
         else:
             input_schema = self.get_input_schema()
             json_schema = input_schema.model_json_schema()
@@ -628,9 +634,10 @@ class ChildTool(BaseTool):
             The parsed and validated input.
 
         Raises:
-            ValueError: If string input is provided with JSON schema or if
-                InjectedToolCallId is required but not provided.
-            NotImplementedError: If args_schema is not a supported type.
+            ValueError: If string input is provided with JSON schema ``args_schema``.
+            ValueError: If InjectedToolCallId is required but ``tool_call_id`` is not
+                provided.
+            TypeError: If args_schema is not a Pydantic ``BaseModel`` or dict.
         """
         input_args = self.args_schema
         if isinstance(tool_input, str):
@@ -655,10 +662,7 @@ class ChildTool(BaseTool):
                 return tool_input
             if issubclass(input_args, BaseModel):
                 for k, v in get_all_basemodel_annotations(input_args).items():
-                    if (
-                        _is_injected_arg_type(v, injected_type=InjectedToolCallId)
-                        and k not in tool_input
-                    ):
+                    if _is_injected_arg_type(v, injected_type=InjectedToolCallId):
                         if tool_call_id is None:
                             msg = (
                                 "When tool includes an InjectedToolCallId "
@@ -673,10 +677,7 @@ class ChildTool(BaseTool):
                 result_dict = result.model_dump()
             elif issubclass(input_args, BaseModelV1):
                 for k, v in get_all_basemodel_annotations(input_args).items():
-                    if (
-                        _is_injected_arg_type(v, injected_type=InjectedToolCallId)
-                        and k not in tool_input
-                    ):
+                    if _is_injected_arg_type(v, injected_type=InjectedToolCallId):
                         if tool_call_id is None:
                             msg = (
                                 "When tool includes an InjectedToolCallId "
@@ -725,6 +726,9 @@ class ChildTool(BaseTool):
 
         Add run_manager: Optional[CallbackManagerForToolRun] = None
         to child implementations to enable tracing.
+
+        Returns:
+            The result of the tool execution.
         """
 
     async def _arun(self, *args: Any, **kwargs: Any) -> Any:
@@ -732,6 +736,9 @@ class ChildTool(BaseTool):
 
         Add run_manager: Optional[AsyncCallbackManagerForToolRun] = None
         to child implementations to enable tracing.
+
+        Returns:
+            The result of the tool execution.
         """
         if kwargs.get("run_manager") and signature(self._run).parameters.get(
             "run_manager"
@@ -1285,7 +1292,7 @@ class InjectedToolCallId(InjectedToolArg):
 
 
 def _is_injected_arg_type(
-    type_: type, injected_type: Optional[type[InjectedToolArg]] = None
+    type_: Union[type, TypeVar], injected_type: Optional[type[InjectedToolArg]] = None
 ) -> bool:
     """Check if a type annotation indicates an injected argument.
 
@@ -1306,20 +1313,22 @@ def _is_injected_arg_type(
 
 def get_all_basemodel_annotations(
     cls: Union[TypeBaseModel, Any], *, default_to_bound: bool = True
-) -> dict[str, type]:
+) -> dict[str, Union[type, TypeVar]]:
     """Get all annotations from a Pydantic BaseModel and its parents.
 
     Args:
         cls: The Pydantic BaseModel class.
         default_to_bound: Whether to default to the bound of a TypeVar if it exists.
+
+    Returns:
+        A dictionary of field names to their type annotations.
     """
     # cls has no subscript: cls = FooBar
     if isinstance(cls, type):
-        # Gather pydantic field objects (v2: model_fields / v1: __fields__)
-        fields = getattr(cls, "model_fields", {}) or getattr(cls, "__fields__", {})
+        fields = get_fields(cls)
         alias_map = {field.alias: name for name, field in fields.items() if field.alias}
 
-        annotations: dict[str, type] = {}
+        annotations: dict[str, Union[type, TypeVar]] = {}
         for name, param in inspect.signature(cls).parameters.items():
             # Exclude hidden init args added by pydantic Config. For example if
             # BaseModel(extra="allow") then "extra_data" will part of init sig.
@@ -1355,8 +1364,8 @@ def get_all_basemodel_annotations(
                 continue
 
             # if class = FooBar inherits from Baz[str]:
-            # parent = Baz[str],
-            # parent_origin = Baz,
+            # parent = class Baz[str],
+            # parent_origin = class Baz,
             # generic_type_vars = (type vars in Baz)
             # generic_map = {type var in Baz: str}
             generic_type_vars: tuple = getattr(parent_origin, "__parameters__", ())
@@ -1373,11 +1382,11 @@ def get_all_basemodel_annotations(
 
 
 def _replace_type_vars(
-    type_: type,
+    type_: Union[type, TypeVar],
     generic_map: Optional[dict[TypeVar, type]] = None,
     *,
     default_to_bound: bool = True,
-) -> type:
+) -> Union[type, TypeVar]:
     """Replace TypeVars in a type annotation with concrete types.
 
     Args:
@@ -1393,7 +1402,7 @@ def _replace_type_vars(
         if type_ in generic_map:
             return generic_map[type_]
         if default_to_bound:
-            return type_.__bound__ or Any
+            return type_.__bound__ if type_.__bound__ is not None else Any
         return type_
     if (origin := get_origin(type_)) and (args := get_args(type_)):
         new_args = tuple(

langchain_core/tools/convert.py

@@ -92,12 +92,13 @@ def tool(
             positional argument.
         description: Optional description for the tool.
             Precedence for the tool description value is as follows:
-                - `description` argument
-                    (used even if docstring and/or `args_schema` are provided)
-                - tool function docstring
-                    (used even if `args_schema` is provided)
-                - `args_schema` description
-                    (used only if `description` / docstring are not provided)
+
+            - ``description`` argument
+                (used even if docstring and/or ``args_schema`` are provided)
+            - tool function docstring
+                (used even if ``args_schema`` is provided)
+            - ``args_schema`` description
+                (used only if `description` / docstring are not provided)
         *args: Extra positional arguments. Must be empty.
         return_direct: Whether to return directly from the tool rather
             than continuing the agent loop. Defaults to False.
@@ -119,6 +120,17 @@ def tool(
             whether to raise ValueError on invalid Google Style docstrings.
             Defaults to True.
 
+    Raises:
+        ValueError: If too many positional arguments are provided.
+        ValueError: If a runnable is provided without a string name.
+        ValueError: If the first argument is not a string or callable with
+            a ``__name__`` attribute.
+        ValueError: If the function does not have a docstring and description
+            is not provided and ``infer_schema`` is False.
+        ValueError: If ``parse_docstring`` is True and the function has an invalid
+            Google-style docstring and ``error_on_invalid_docstring`` is True.
+        ValueError: If a Runnable is provided that does not have an object schema.
+
     Returns:
         The tool.
 
@@ -134,11 +146,13 @@ def tool(
                 # Searches the API for the query.
                 return
 
+
             @tool("search", return_direct=True)
             def search_api(query: str) -> str:
                 # Searches the API for the query.
                 return
 
+
             @tool(response_format="content_and_artifact")
             def search_api(query: str) -> tuple[str, dict]:
                 return "partial json of results", {"full": "object of results"}
@@ -171,18 +185,15 @@ def tool(
                     "bar": {
                         "title": "Bar",
                         "description": "The bar.",
-                        "type": "string"
+                        "type": "string",
                     },
                     "baz": {
                         "title": "Baz",
                         "description": "The baz.",
-                        "type": "integer"
-                    }
+                        "type": "integer",
+                    },
                 },
-                "required": [
-                    "bar",
-                    "baz"
-                ]
+                "required": ["bar", "baz"],
             }
 
         Note that parsing by default will raise ``ValueError`` if the docstring
@@ -216,7 +227,7 @@ def tool(
                 \"\"\"
                 return bar
 
-    """  # noqa: D214, D410, D411
+    """  # noqa: D214, D410, D411  # We're intentionally showing bad formatting in examples
 
     def _create_tool_factory(
         tool_name: str,
@@ -304,7 +315,7 @@ def tool(
 
     if runnable is not None:
         # tool is used as a function
-        # tool_from_runnable = tool("name", runnable)
+        # for instance tool_from_runnable = tool("name", runnable)
         if not name_or_callable:
             msg = "Runnable without name for tool constructor"
             raise ValueError(msg)

langchain_core/tools/simple.py

@@ -64,11 +64,7 @@ class Tool(BaseTool):
             The input arguments for the tool.
         """
         if self.args_schema is not None:
-            if isinstance(self.args_schema, dict):
-                json_schema = self.args_schema
-            else:
-                json_schema = self.args_schema.model_json_schema()
-            return json_schema["properties"]
+            return super().args
         # For backwards compatibility, if the function signature is ambiguous,
         # assume it takes a single string input.
         return {"tool_input": {"type": "string"}}
@@ -76,7 +72,19 @@ class Tool(BaseTool):
     def _to_args_and_kwargs(
         self, tool_input: Union[str, dict], tool_call_id: Optional[str]
     ) -> tuple[tuple, dict]:
-        """Convert tool input to pydantic model."""
+        """Convert tool input to pydantic model.
+
+        Args:
+            tool_input: The input to the tool.
+            tool_call_id: The ID of the tool call.
+
+        Raises:
+            ToolException: If the tool input is invalid.
+
+        Returns:
+            the pydantic model args and kwargs.
+
+        """
         args, kwargs = super()._to_args_and_kwargs(tool_input, tool_call_id)
         # For backwards compatibility. The tool must be run with a single input
         all_args = list(args) + list(kwargs.values())
@@ -96,7 +104,17 @@ class Tool(BaseTool):
         run_manager: Optional[CallbackManagerForToolRun] = None,
         **kwargs: Any,
     ) -> Any:
-        """Use the tool."""
+        """Use the tool.
+
+        Args:
+            *args: Positional arguments to pass to the tool
+            config: Configuration for the run
+            run_manager: Optional callback manager to use for the run
+            **kwargs: Keyword arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
         if self.func:
             if run_manager and signature(self.func).parameters.get("callbacks"):
                 kwargs["callbacks"] = run_manager.get_child()
@@ -113,7 +131,17 @@ class Tool(BaseTool):
         run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
         **kwargs: Any,
     ) -> Any:
-        """Use the tool asynchronously."""
+        """Use the tool asynchronously.
+
+        Args:
+            *args: Positional arguments to pass to the tool
+            config: Configuration for the run
+            run_manager: Optional callback manager to use for the run
+            **kwargs: Keyword arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
         if self.coroutine:
             if run_manager and signature(self.coroutine).parameters.get("callbacks"):
                 kwargs["callbacks"] = run_manager.get_child()

langchain_core/tools/structured.py

@@ -67,16 +67,6 @@ class StructuredTool(BaseTool):
 
     # --- Tool ---
 
-    @property
-    def args(self) -> dict:
-        """The tool's input arguments."""
-        if isinstance(self.args_schema, dict):
-            json_schema = self.args_schema
-        else:
-            input_schema = self.get_input_schema()
-            json_schema = input_schema.model_json_schema()
-        return json_schema["properties"]
-
     def _run(
         self,
         *args: Any,
@@ -84,7 +74,17 @@ class StructuredTool(BaseTool):
         run_manager: Optional[CallbackManagerForToolRun] = None,
         **kwargs: Any,
     ) -> Any:
-        """Use the tool."""
+        """Use the tool.
+
+        Args:
+            *args: Positional arguments to pass to the tool
+            config: Configuration for the run
+            run_manager: Optional callback manager to use for the run
+            **kwargs: Keyword arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
         if self.func:
             if run_manager and signature(self.func).parameters.get("callbacks"):
                 kwargs["callbacks"] = run_manager.get_child()
@@ -101,7 +101,17 @@ class StructuredTool(BaseTool):
         run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
         **kwargs: Any,
     ) -> Any:
-        """Use the tool asynchronously."""
+        """Use the tool asynchronously.
+
+        Args:
+            *args: Positional arguments to pass to the tool
+            config: Configuration for the run
+            run_manager: Optional callback manager to use for the run
+            **kwargs: Keyword arguments to pass to the tool
+
+        Returns:
+            The result of the tool execution
+        """
         if self.coroutine:
             if run_manager and signature(self.coroutine).parameters.get("callbacks"):
                 kwargs["callbacks"] = run_manager.get_child()
@@ -164,6 +174,9 @@ class StructuredTool(BaseTool):
 
         Raises:
             ValueError: If the function is not provided.
+            ValueError: If the function does not have a docstring and description
+                is not provided.
+            TypeError: If the ``args_schema`` is not a ``BaseModel`` or dict.
 
         Examples:
 

langchain_core/tracers/base.py

@@ -520,11 +520,11 @@ class BaseTracer(_TracerCore, BaseCallbackHandler, ABC):
         return retrieval_run
 
     def __deepcopy__(self, memo: dict) -> BaseTracer:
-        """Deepcopy the tracer."""
+        """Return self."""
         return self
 
     def __copy__(self) -> BaseTracer:
-        """Copy the tracer."""
+        """Return self."""
         return self
 
 

langchain_core/tracers/context.py

@@ -43,7 +43,11 @@ run_collector_var: ContextVar[Optional[RunCollectorCallbackHandler]] = ContextVa
 def tracing_enabled(
     session_name: str = "default",  # noqa: ARG001
 ) -> Generator[TracerSessionV1, None, None]:
-    """Throw an error because this has been replaced by tracing_v2_enabled."""
+    """Throw an error because this has been replaced by ``tracing_v2_enabled``.
+
+    Raises:
+        RuntimeError: Always, because this function is deprecated.
+    """
     msg = (
         "tracing_enabled is no longer supported. Please use tracing_enabled_v2 instead."
     )