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

langchain_core/runnables/passthrough.py

@@ -96,22 +96,22 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
             )
 
             runnable = RunnableParallel(
-                origin=RunnablePassthrough(),
-                modified=lambda x: x+1
+                origin=RunnablePassthrough(), modified=lambda x: x + 1
             )
 
-            runnable.invoke(1) # {'origin': 1, 'modified': 2}
+            runnable.invoke(1)  # {'origin': 1, 'modified': 2}
 
 
-            def fake_llm(prompt: str) -> str: # Fake LLM for the example
+            def fake_llm(prompt: str) -> str:  # Fake LLM for the example
                 return "completion"
 
+
             chain = RunnableLambda(fake_llm) | {
-                'original': RunnablePassthrough(), # Original LLM output
-                'parsed': lambda text: text[::-1] # Parsing logic
+                "original": RunnablePassthrough(),  # Original LLM output
+                "parsed": lambda text: text[::-1],  # Parsing logic
             }
 
-            chain.invoke('hello') # {'original': 'completion', 'parsed': 'noitelpmoc'}
+            chain.invoke("hello")  # {'original': 'completion', 'parsed': 'noitelpmoc'}
 
     In some cases, it may be useful to pass the input through while adding some
     keys to the output. In this case, you can use the `assign` method:
@@ -120,17 +120,19 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
 
             from langchain_core.runnables import RunnablePassthrough
 
-            def fake_llm(prompt: str) -> str: # Fake LLM for the example
+
+            def fake_llm(prompt: str) -> str:  # Fake LLM for the example
                 return "completion"
 
+
             runnable = {
-                'llm1':  fake_llm,
-                'llm2':  fake_llm,
+                "llm1": fake_llm,
+                "llm2": fake_llm,
             } | RunnablePassthrough.assign(
-                total_chars=lambda inputs: len(inputs['llm1'] + inputs['llm2'])
+                total_chars=lambda inputs: len(inputs["llm1"] + inputs["llm2"])
             )
 
-            runnable.invoke('hello')
+            runnable.invoke("hello")
             # {'llm1': 'completion', 'llm2': 'completion', 'total_chars': 20}
 
     """
@@ -191,11 +193,16 @@ class RunnablePassthrough(RunnableSerializable[Other, Other]):
     @classmethod
     @override
     def is_lc_serializable(cls) -> bool:
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
-    @override
     def get_lc_namespace(cls) -> list[str]:
+        """Get the namespace of the langchain object.
+
+        Returns:
+            ``["langchain", "schema", "runnable"]``
+        """
         return ["langchain", "schema", "runnable"]
 
     @property
@@ -378,11 +385,15 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
             )
             from langchain_core.runnables.base import RunnableLambda
 
+
             def add_ten(x: dict[str, int]) -> dict[str, int]:
                 return {"added": x["input"] + 10}
 
+
             mapper = RunnableParallel(
-                {"add_step": RunnableLambda(add_ten),}
+                {
+                    "add_step": RunnableLambda(add_ten),
+                }
             )
 
             runnable_assign = RunnableAssign(mapper)
@@ -411,11 +422,17 @@ class RunnableAssign(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     @classmethod
     @override
     def is_lc_serializable(cls) -> bool:
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
     @override
     def get_lc_namespace(cls) -> list[str]:
+        """Get the namespace of the langchain object.
+
+        Returns:
+            ``["langchain", "schema", "runnable"]``
+        """
         return ["langchain", "schema", "runnable"]
 
     @override
@@ -688,13 +705,13 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
             from langchain_core.runnables.passthrough import RunnablePick
 
             input_data = {
-                'name': 'John',
-                'age': 30,
-                'city': 'New York',
-                'country': 'USA'
+                "name": "John",
+                "age": 30,
+                "city": "New York",
+                "country": "USA",
             }
 
-            runnable = RunnablePick(keys=['name', 'age'])
+            runnable = RunnablePick(keys=["name", "age"])
 
             output_data = runnable.invoke(input_data)
 
@@ -715,12 +732,17 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
     @classmethod
     @override
     def is_lc_serializable(cls) -> bool:
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
     @override
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object."""
+        """Get the namespace of the langchain object.
+
+        Returns:
+            ``["langchain", "schema", "runnable"]``
+        """
         return ["langchain", "schema", "runnable"]
 
     @override
@@ -730,7 +752,8 @@ class RunnablePick(RunnableSerializable[dict[str, Any], dict[str, Any]]):
         name = (
             name
             or self.name
-            or f"RunnablePick<{','.join([self.keys] if isinstance(self.keys, str) else self.keys)}>"  # noqa: E501
+            or "RunnablePick"
+            f"<{','.join([self.keys] if isinstance(self.keys, str) else self.keys)}>"
         )
         return super().get_name(suffix, name=name)
 

langchain_core/runnables/retry.py

@@ -66,17 +66,21 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
 
             import time
 
+
             def foo(input) -> None:
                 '''Fake function that raises an exception.'''
                 raise ValueError(f"Invoking foo failed. At time {time.time()}")
 
+
             runnable = RunnableLambda(foo)
 
             runnable_with_retries = runnable.with_retry(
-                retry_if_exception_type=(ValueError,), # Retry only on ValueError
-                wait_exponential_jitter=True, # Add jitter to the exponential backoff
-                stop_after_attempt=2, # Try twice
-                exponential_jitter_params={"initial": 2},  # if desired, customize backoff
+                retry_if_exception_type=(ValueError,),  # Retry only on ValueError
+                wait_exponential_jitter=True,  # Add jitter to the exponential backoff
+                stop_after_attempt=2,  # Try twice
+                exponential_jitter_params={
+                    "initial": 2
+                },  # if desired, customize backoff
             )
 
             # The method invocation above is equivalent to the longer form below:
@@ -111,7 +115,7 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
             chain = template | model
             retryable_chain = chain.with_retry()
 
-    """  # noqa: E501
+    """
 
     retry_exception_types: tuple[type[BaseException], ...] = (Exception,)
     """The exception types to retry on. By default all exceptions are retried.
@@ -234,31 +238,40 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     ) -> list[Union[Output, Exception]]:
         results_map: dict[int, Output] = {}
 
-        def pending(iterable: list[U]) -> list[U]:
-            return [item for idx, item in enumerate(iterable) if idx not in results_map]
-
         not_set: list[Output] = []
         result = not_set
         try:
             for attempt in self._sync_retrying():
                 with attempt:
-                    # Get the results of the inputs that have not succeeded yet.
+                    # Retry for inputs that have not yet succeeded
+                    # Determine which original indices remain.
+                    remaining_indices = [
+                        i for i in range(len(inputs)) if i not in results_map
+                    ]
+                    if not remaining_indices:
+                        break
+                    pending_inputs = [inputs[i] for i in remaining_indices]
+                    pending_configs = [config[i] for i in remaining_indices]
+                    pending_run_managers = [run_manager[i] for i in remaining_indices]
+                    # Invoke underlying batch only on remaining elements.
                     result = super().batch(
-                        pending(inputs),
+                        pending_inputs,
                         self._patch_config_list(
-                            pending(config), pending(run_manager), attempt.retry_state
+                            pending_configs, pending_run_managers, attempt.retry_state
                         ),
                         return_exceptions=True,
                         **kwargs,
                     )
-                    # Register the results of the inputs that have succeeded.
+                    # Register the results of the inputs that have succeeded, mapping
+                    # back to their original indices.
                     first_exception = None
-                    for i, r in enumerate(result):
+                    for offset, r in enumerate(result):
                         if isinstance(r, Exception):
                             if not first_exception:
                                 first_exception = r
                             continue
-                        results_map[i] = r
+                        orig_idx = remaining_indices[offset]
+                        results_map[orig_idx] = r
                     # If any exception occurred, raise it, to retry the failed ones
                     if first_exception:
                         raise first_exception
@@ -301,31 +314,39 @@ class RunnableRetry(RunnableBindingBase[Input, Output]):  # type: ignore[no-rede
     ) -> list[Union[Output, Exception]]:
         results_map: dict[int, Output] = {}
 
-        def pending(iterable: list[U]) -> list[U]:
-            return [item for idx, item in enumerate(iterable) if idx not in results_map]
-
         not_set: list[Output] = []
         result = not_set
         try:
             async for attempt in self._async_retrying():
                 with attempt:
-                    # Get the results of the inputs that have not succeeded yet.
+                    # Retry for inputs that have not yet succeeded
+                    # Determine which original indices remain.
+                    remaining_indices = [
+                        i for i in range(len(inputs)) if i not in results_map
+                    ]
+                    if not remaining_indices:
+                        break
+                    pending_inputs = [inputs[i] for i in remaining_indices]
+                    pending_configs = [config[i] for i in remaining_indices]
+                    pending_run_managers = [run_manager[i] for i in remaining_indices]
                     result = await super().abatch(
-                        pending(inputs),
+                        pending_inputs,
                         self._patch_config_list(
-                            pending(config), pending(run_manager), attempt.retry_state
+                            pending_configs, pending_run_managers, attempt.retry_state
                         ),
                         return_exceptions=True,
                         **kwargs,
                     )
-                    # Register the results of the inputs that have succeeded.
+                    # Register the results of the inputs that have succeeded, mapping
+                    # back to their original indices.
                     first_exception = None
-                    for i, r in enumerate(result):
+                    for offset, r in enumerate(result):
                         if isinstance(r, Exception):
                             if not first_exception:
                                 first_exception = r
                             continue
-                        results_map[i] = r
+                        orig_idx = remaining_indices[offset]
+                        results_map[orig_idx] = r
                     # If any exception occurred, raise it, to retry the failed ones
                     if first_exception:
                         raise first_exception

langchain_core/runnables/router.py

@@ -38,15 +38,12 @@ if TYPE_CHECKING:
 
 
 class RouterInput(TypedDict):
-    """Router input.
-
-    Attributes:
-        key: The key to route on.
-        input: The input to pass to the selected Runnable.
-    """
+    """Router input."""
 
     key: str
+    """The key to route on."""
     input: Any
+    """The input to pass to the selected Runnable."""
 
 
 class RouterRunnable(RunnableSerializable[RouterInput, Output]):
@@ -98,13 +95,17 @@ class RouterRunnable(RunnableSerializable[RouterInput, Output]):
     @classmethod
     @override
     def is_lc_serializable(cls) -> bool:
-        """Return whether this class is serializable."""
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
     @override
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object."""
+        """Get the namespace of the langchain object.
+
+        Returns:
+            ``["langchain", "schema", "runnable"]``
+        """
         return ["langchain", "schema", "runnable"]
 
     @override

langchain_core/runnables/schema.py

@@ -51,9 +51,11 @@ class BaseStreamEvent(TypedDict):
 
             from langchain_core.runnables import RunnableLambda
 
+
             async def reverse(s: str) -> str:
                 return s[::-1]
 
+
             chain = RunnableLambda(func=reverse)
 
             events = [event async for event in chain.astream_events("hello")]

langchain_core/runnables/utils.py

@@ -122,7 +122,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 +165,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 +182,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 +209,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 +221,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 +233,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 +254,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 +266,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 +305,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 +347,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 +468,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 +489,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 +551,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 +570,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 +591,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 +617,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(