langchain-core 1.0.0a2__py3-none-any.whl → 1.0.0a4__py3-none-any.whl

langchain_core/runnables/utils.py

@@ -18,11 +18,12 @@ from typing import (
     NamedTuple,
     Optional,
     Protocol,
+    TypeGuard,
     TypeVar,
     Union,
 )
 
-from typing_extensions import TypeGuard, override
+from typing_extensions import override
 
 # Re-export create-model for backwards compatibility
 from langchain_core.utils.pydantic import create_model  # noqa: F401
@@ -122,7 +123,12 @@ def accepts_context(callable: Callable[..., Any]) -> bool:  # noqa: A002
 
 @lru_cache(maxsize=1)
 def asyncio_accepts_context() -> bool:
-    """Cache the result of checking if asyncio.create_task accepts a ``context`` arg."""
+    """Cache the result of checking if asyncio.create_task accepts a ``context`` arg.
+
+    Returns:
+        bool: True if ``asyncio.create_task`` accepts a context argument, False
+            otherwise.
+    """
     return accepts_context(asyncio.create_task)
 
 
@@ -160,14 +166,11 @@ class IsLocalDict(ast.NodeVisitor):
         self.keys = keys
 
     @override
-    def visit_Subscript(self, node: ast.Subscript) -> Any:
+    def visit_Subscript(self, node: ast.Subscript) -> None:
         """Visit a subscript node.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if (
             isinstance(node.ctx, ast.Load)
@@ -180,14 +183,11 @@ class IsLocalDict(ast.NodeVisitor):
             self.keys.add(node.slice.value)
 
     @override
-    def visit_Call(self, node: ast.Call) -> Any:
+    def visit_Call(self, node: ast.Call) -> None:
         """Visit a call node.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if (
             isinstance(node.func, ast.Attribute)
@@ -210,14 +210,11 @@ class IsFunctionArgDict(ast.NodeVisitor):
         self.keys: set[str] = set()
 
     @override
-    def visit_Lambda(self, node: ast.Lambda) -> Any:
+    def visit_Lambda(self, node: ast.Lambda) -> None:
         """Visit a lambda function.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if not node.args.args:
             return
@@ -225,14 +222,11 @@ class IsFunctionArgDict(ast.NodeVisitor):
         IsLocalDict(input_arg_name, self.keys).visit(node.body)
 
     @override
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
         """Visit a function definition.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if not node.args.args:
             return
@@ -240,14 +234,11 @@ class IsFunctionArgDict(ast.NodeVisitor):
         IsLocalDict(input_arg_name, self.keys).visit(node)
 
     @override
-    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
         """Visit an async function definition.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if not node.args.args:
             return
@@ -264,14 +255,11 @@ class NonLocals(ast.NodeVisitor):
         self.stores: set[str] = set()
 
     @override
-    def visit_Name(self, node: ast.Name) -> Any:
+    def visit_Name(self, node: ast.Name) -> None:
         """Visit a name node.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if isinstance(node.ctx, ast.Load):
             self.loads.add(node.id)
@@ -279,14 +267,11 @@ class NonLocals(ast.NodeVisitor):
             self.stores.add(node.id)
 
     @override
-    def visit_Attribute(self, node: ast.Attribute) -> Any:
+    def visit_Attribute(self, node: ast.Attribute) -> None:
         """Visit an attribute node.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         if isinstance(node.ctx, ast.Load):
             parent = node.value
@@ -321,42 +306,33 @@ class FunctionNonLocals(ast.NodeVisitor):
         self.nonlocals: set[str] = set()
 
     @override
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
         """Visit a function definition.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         visitor = NonLocals()
         visitor.visit(node)
         self.nonlocals.update(visitor.loads - visitor.stores)
 
     @override
-    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> Any:
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
         """Visit an async function definition.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         visitor = NonLocals()
         visitor.visit(node)
         self.nonlocals.update(visitor.loads - visitor.stores)
 
     @override
-    def visit_Lambda(self, node: ast.Lambda) -> Any:
+    def visit_Lambda(self, node: ast.Lambda) -> None:
         """Visit a lambda function.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         visitor = NonLocals()
         visitor.visit(node)
@@ -372,14 +348,11 @@ class GetLambdaSource(ast.NodeVisitor):
         self.count = 0
 
     @override
-    def visit_Lambda(self, node: ast.Lambda) -> Any:
+    def visit_Lambda(self, node: ast.Lambda) -> None:
         """Visit a lambda function.
 
         Args:
             node: The node to visit.
-
-        Returns:
-            Any: The result of the visit.
         """
         self.count += 1
         if hasattr(ast, "unparse"):
@@ -496,6 +469,9 @@ class AddableDict(dict[str, Any]):
 
         Args:
             other: The other dictionary to add.
+
+        Returns:
+            A dictionary that is the result of adding the two dictionaries.
         """
         chunk = AddableDict(self)
         for key in other:
@@ -514,6 +490,9 @@ class AddableDict(dict[str, Any]):
 
         Args:
             other: The other dictionary to be added to.
+
+        Returns:
+            A dictionary that is the result of adding the two dictionaries.
         """
         chunk = AddableDict(other)
         for key in self:
@@ -573,22 +552,18 @@ async def aadd(addables: AsyncIterable[Addable]) -> Optional[Addable]:
 
 
 class ConfigurableField(NamedTuple):
-    """Field that can be configured by the user.
-
-    Parameters:
-        id: The unique identifier of the field.
-        name: The name of the field. Defaults to None.
-        description: The description of the field. Defaults to None.
-        annotation: The annotation of the field. Defaults to None.
-        is_shared: Whether the field is shared. Defaults to False.
-    """
+    """Field that can be configured by the user."""
 
     id: str
-
+    """The unique identifier of the field."""
     name: Optional[str] = None
+    """The name of the field. Defaults to None."""
     description: Optional[str] = None
+    """The description of the field. Defaults to None."""
     annotation: Optional[Any] = None
+    """The annotation of the field. Defaults to None."""
     is_shared: bool = False
+    """Whether the field is shared. Defaults to False."""
 
     @override
     def __hash__(self) -> int:
@@ -596,24 +571,20 @@ class ConfigurableField(NamedTuple):
 
 
 class ConfigurableFieldSingleOption(NamedTuple):
-    """Field that can be configured by the user with a default value.
-
-    Parameters:
-        id: The unique identifier of the field.
-        options: The options for the field.
-        default: The default value for the field.
-        name: The name of the field. Defaults to None.
-        description: The description of the field. Defaults to None.
-        is_shared: Whether the field is shared. Defaults to False.
-    """
+    """Field that can be configured by the user with a default value."""
 
     id: str
+    """The unique identifier of the field."""
     options: Mapping[str, Any]
+    """The options for the field."""
     default: str
-
+    """The default value for the field."""
     name: Optional[str] = None
+    """The name of the field. Defaults to None."""
     description: Optional[str] = None
+    """The description of the field. Defaults to None."""
     is_shared: bool = False
+    """Whether the field is shared. Defaults to False."""
 
     @override
     def __hash__(self) -> int:
@@ -621,24 +592,20 @@ class ConfigurableFieldSingleOption(NamedTuple):
 
 
 class ConfigurableFieldMultiOption(NamedTuple):
-    """Field that can be configured by the user with multiple default values.
-
-    Parameters:
-        id: The unique identifier of the field.
-        options: The options for the field.
-        default: The default values for the field.
-        name: The name of the field. Defaults to None.
-        description: The description of the field. Defaults to None.
-        is_shared: Whether the field is shared. Defaults to False.
-    """
+    """Field that can be configured by the user with multiple default values."""
 
     id: str
+    """The unique identifier of the field."""
     options: Mapping[str, Any]
+    """The options for the field."""
     default: Sequence[str]
-
+    """The default values for the field."""
     name: Optional[str] = None
+    """The name of the field. Defaults to None."""
     description: Optional[str] = None
+    """The description of the field. Defaults to None."""
     is_shared: bool = False
+    """Whether the field is shared. Defaults to False."""
 
     @override
     def __hash__(self) -> int:
@@ -651,26 +618,22 @@ AnyConfigurableField = Union[
 
 
 class ConfigurableFieldSpec(NamedTuple):
-    """Field that can be configured by the user. It is a specification of a field.
-
-    Parameters:
-        id: The unique identifier of the field.
-        annotation: The annotation of the field.
-        name: The name of the field. Defaults to None.
-        description: The description of the field. Defaults to None.
-        default: The default value for the field. Defaults to None.
-        is_shared: Whether the field is shared. Defaults to False.
-        dependencies: The dependencies of the field. Defaults to None.
-    """
+    """Field that can be configured by the user. It is a specification of a field."""
 
     id: str
+    """The unique identifier of the field."""
     annotation: Any
-
+    """The annotation of the field."""
     name: Optional[str] = None
+    """The name of the field. Defaults to None."""
     description: Optional[str] = None
+    """The description of the field. Defaults to None."""
     default: Any = None
+    """The default value for the field. Defaults to None."""
     is_shared: bool = False
+    """Whether the field is shared. Defaults to False."""
     dependencies: Optional[list[str]] = None
+    """The dependencies of the field. Defaults to None."""
 
 
 def get_unique_config_specs(

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,7 @@ TOOL_MESSAGE_BLOCK_TYPES = (
     "json",
     "search_result",
     "custom_tool_call_output",
+    "document",
 )
 
 
@@ -271,15 +272,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 +504,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 +546,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 +633,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 +661,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 +676,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 +725,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 +735,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"
@@ -1265,7 +1271,7 @@ class InjectedToolCallId(InjectedToolArg):
 
     .. code-block:: python
 
-        from typing_extensions import Annotated
+        from typing import Annotated
         from langchain_core.messages import ToolMessage
         from langchain_core.tools import tool, InjectedToolCallId
 
@@ -1285,7 +1291,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 +1312,23 @@ 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: