Use rather than for variable names

Author: cbornet

libs/core/langchain_core/runnables/base.py

@@ -778,14 +778,14 @@ def batch(
 
         configs = get_config_list(config, len(inputs))
 
-        def invoke(value: Input, config: RunnableConfig) -> Union[Output, Exception]:
+        def invoke(input_: Input, config: RunnableConfig) -> Union[Output, Exception]:
             if return_exceptions:
                 try:
-                    return self.invoke(value, config, **kwargs)
+                    return self.invoke(input_, config, **kwargs)
                 except Exception as e:
                     return e
             else:
-                return self.invoke(value, config, **kwargs)
+                return self.invoke(input_, config, **kwargs)
 
         # If there's only one input, don't bother with the executor
         if len(inputs) == 1:
@@ -832,15 +832,17 @@ def batch_as_completed(
         configs = get_config_list(config, len(inputs))
 
         def invoke(
-            i: int, value: Input, config: RunnableConfig
+            i: int, input_: Input, config: RunnableConfig
         ) -> tuple[int, Union[Output, Exception]]:
             if return_exceptions:
                 try:
-                    out: Union[Output, Exception] = self.invoke(value, config, **kwargs)
+                    out: Union[Output, Exception] = self.invoke(
+                        input_, config, **kwargs
+                    )
                 except Exception as e:
                     out = e
             else:
-                out = self.invoke(value, config, **kwargs)
+                out = self.invoke(input_, config, **kwargs)
 
             return (i, out)
 
@@ -966,24 +968,24 @@ async def abatch_as_completed(
         semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency else None
 
         async def ainvoke_task(
-            i: int, value: Input, config: RunnableConfig
+            i: int, input_: Input, config: RunnableConfig
         ) -> tuple[int, Union[Output, Exception]]:
             if return_exceptions:
                 try:
                     out: Union[Output, Exception] = await self.ainvoke(
-                        value, config, **kwargs
+                        input_, config, **kwargs
                     )
                 except Exception as e:
                     out = e
             else:
-                out = await self.ainvoke(value, config, **kwargs)
+                out = await self.ainvoke(input_, config, **kwargs)
             return (i, out)
 
         coros = [
-            gated_coro(semaphore, ainvoke_task(i, value, config))
+            gated_coro(semaphore, ainvoke_task(i, input_, config))
             if semaphore
-            else ainvoke_task(i, value, config)
-            for i, (value, config) in enumerate(zip(inputs, configs))
+            else ainvoke_task(i, input_, config)
+            for i, (input_, config) in enumerate(zip(inputs, configs))
         ]
 
         for coro in asyncio.as_completed(coros):
@@ -1909,7 +1911,7 @@ def _call_with_config(
             Callable[[Input, CallbackManagerForChainRun], Output],
             Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output],
         ],
-        value: Input,
+        input_: Input,
         config: Optional[RunnableConfig],
         run_type: Optional[str] = None,
         serialized: Optional[dict[str, Any]] = None,
@@ -1923,7 +1925,7 @@ def _call_with_config(
         callback_manager = get_callback_manager_for_config(config)
         run_manager = callback_manager.on_chain_start(
             serialized,
-            value,
+            input_,
             run_type=run_type,
             name=config.get("run_name") or self.get_name(),
             run_id=config.pop("run_id", None),
@@ -1936,7 +1938,7 @@ def _call_with_config(
                     context.run(
                         call_func_with_variable_args,  # type: ignore[arg-type]
                         func,
-                        value,
+                        input_,
                         config,
                         run_manager,
                         **kwargs,
@@ -1959,7 +1961,7 @@ async def _acall_with_config(
                 Awaitable[Output],
             ],
         ],
-        value: Input,
+        input_: Input,
         config: Optional[RunnableConfig],
         run_type: Optional[str] = None,
         serialized: Optional[dict[str, Any]] = None,
@@ -1973,7 +1975,7 @@ async def _acall_with_config(
         callback_manager = get_async_callback_manager_for_config(config)
         run_manager = await callback_manager.on_chain_start(
             serialized,
-            value,
+            input_,
             run_type=run_type,
             name=config.get("run_name") or self.get_name(),
             run_id=config.pop("run_id", None),
@@ -1982,7 +1984,7 @@ async def _acall_with_config(
             child_config = patch_config(config, callbacks=run_manager.get_child())
             with set_config_context(child_config) as context:
                 coro = acall_func_with_variable_args(
-                    func, value, config, run_manager, **kwargs
+                    func, input_, config, run_manager, **kwargs
                 )
                 output: Output = await coro_with_context(coro, context)
         except BaseException as e:
@@ -3741,7 +3743,7 @@ def invoke(
         )
 
         def _invoke_step(
-            step: Runnable[Input, Any], value: Input, config: RunnableConfig, key: str
+            step: Runnable[Input, Any], input_: Input, config: RunnableConfig, key: str
         ) -> Any:
             child_config = patch_config(
                 config,
@@ -3751,7 +3753,7 @@ def _invoke_step(
             with set_config_context(child_config) as context:
                 return context.run(
                     step.invoke,
-                    value,
+                    input_,
                     child_config,
                 )
 
@@ -3793,15 +3795,15 @@ async def ainvoke(
         )
 
         async def _ainvoke_step(
-            step: Runnable[Input, Any], value: Input, config: RunnableConfig, key: str
+            step: Runnable[Input, Any], input_: Input, config: RunnableConfig, key: str
         ) -> Any:
             child_config = patch_config(
                 config,
                 callbacks=run_manager.get_child(f"map:key:{key}"),
             )
             with set_config_context(child_config) as context:
                 return await coro_with_context(
-                    step.ainvoke(value, child_config), context, create_task=True
+                    step.ainvoke(input_, child_config), context, create_task=True
                 )
 
         # gather results from all steps
@@ -4598,7 +4600,7 @@ def __repr__(self) -> str:
 
     def _invoke(
         self,
-        value: Input,
+        input_: Input,
         run_manager: CallbackManagerForChainRun,
         config: RunnableConfig,
         **kwargs: Any,
@@ -4607,7 +4609,7 @@ def _invoke(
             output: Optional[Output] = None
             for chunk in call_func_with_variable_args(
                 cast("Callable[[Input], Iterator[Output]]", self.func),
-                value,
+                input_,
                 config,
                 run_manager,
                 **kwargs,
@@ -4621,18 +4623,18 @@ def _invoke(
                         output = chunk
         else:
             output = call_func_with_variable_args(
-                self.func, value, config, run_manager, **kwargs
+                self.func, input_, config, run_manager, **kwargs
             )
         # If the output is a Runnable, invoke it
         if isinstance(output, Runnable):
             recursion_limit = config["recursion_limit"]
             if recursion_limit <= 0:
                 msg = (
-                    f"Recursion limit reached when invoking {self} with input {value}."
+                    f"Recursion limit reached when invoking {self} with input {input_}."
                 )
                 raise RecursionError(msg)
             output = output.invoke(
-                value,
+                input_,
                 patch_config(
                     config,
                     callbacks=run_manager.get_child(),
@@ -4921,13 +4923,13 @@ async def _atransform(
                 raise TypeError(msg)
 
             def func(
-                value: Input,
+                input_: Input,
                 run_manager: AsyncCallbackManagerForChainRun,
                 config: RunnableConfig,
                 **kwargs: Any,
             ) -> Output:
                 return call_func_with_variable_args(
-                    self.func, value, config, run_manager.get_sync(), **kwargs
+                    self.func, input_, config, run_manager.get_sync(), **kwargs
                 )
 
             @wraps(func)

libs/core/langchain_core/runnables/configurable.py

@@ -178,16 +178,16 @@ def batch(
 
         def invoke(
             prepared: tuple[Runnable[Input, Output], RunnableConfig],
-            value: Input,
+            input_: Input,
         ) -> Union[Output, Exception]:
             bound, config = prepared
             if return_exceptions:
                 try:
-                    return bound.invoke(value, config, **kwargs)
+                    return bound.invoke(input_, config, **kwargs)
                 except Exception as e:
                     return e
             else:
-                return bound.invoke(value, config, **kwargs)
+                return bound.invoke(input_, config, **kwargs)
 
         # If there's only one input, don't bother with the executor
         if len(inputs) == 1:
@@ -221,16 +221,16 @@ async def abatch(
 
         async def ainvoke(
             prepared: tuple[Runnable[Input, Output], RunnableConfig],
-            value: Input,
+            input_: Input,
         ) -> Union[Output, Exception]:
             bound, config = prepared
             if return_exceptions:
                 try:
-                    return await bound.ainvoke(value, config, **kwargs)
+                    return await bound.ainvoke(input_, config, **kwargs)
                 except Exception as e:
                     return e
             else:
-                return await bound.ainvoke(value, config, **kwargs)
+                return await bound.ainvoke(input_, config, **kwargs)
 
         coros = map(ainvoke, prepared, inputs)
         return await gather_with_concurrency(configs[0].get("max_concurrency"), *coros)

libs/core/langchain_core/runnables/retry.py

@@ -178,15 +178,15 @@ def _patch_config_list(
 
     def _invoke(
         self,
-        value: Input,
+        input_: Input,
         run_manager: "CallbackManagerForChainRun",
         config: RunnableConfig,
         **kwargs: Any,
     ) -> Output:
         for attempt in self._sync_retrying(reraise=True):
             with attempt:
                 result = super().invoke(
-                    value,
+                    input_,
                     self._patch_config(config, run_manager, attempt.retry_state),
                     **kwargs,
                 )
@@ -202,15 +202,15 @@ def invoke(
 
     async def _ainvoke(
         self,
-        value: Input,
+        input_: Input,
         run_manager: "AsyncCallbackManagerForChainRun",
         config: RunnableConfig,
         **kwargs: Any,
     ) -> Output:
         async for attempt in self._async_retrying(reraise=True):
             with attempt:
                 result = await super().ainvoke(
-                    value,
+                    input_,
                     self._patch_config(config, run_manager, attempt.retry_state),
                     **kwargs,
                 )

libs/core/langchain_core/runnables/router.py

@@ -148,22 +148,22 @@ def batch(
         if not inputs:
             return []
 
-        keys = [value["key"] for value in inputs]
-        actual_inputs = [value["input"] for value in inputs]
+        keys = [input_["key"] for input_ in inputs]
+        actual_inputs = [input_["input"] for input_ in inputs]
         if any(key not in self.runnables for key in keys):
             msg = "One or more keys do not have a corresponding runnable"
             raise ValueError(msg)
 
         def invoke(
-            runnable: Runnable, value: Input, config: RunnableConfig
+            runnable: Runnable, input_: Input, config: RunnableConfig
         ) -> Union[Output, Exception]:
             if return_exceptions:
                 try:
-                    return runnable.invoke(value, config, **kwargs)
+                    return runnable.invoke(input_, config, **kwargs)
                 except Exception as e:
                     return e
             else:
-                return runnable.invoke(value, config, **kwargs)
+                return runnable.invoke(input_, config, **kwargs)
 
         runnables = [self.runnables[key] for key in keys]
         configs = get_config_list(config, len(inputs))
@@ -185,22 +185,22 @@ async def abatch(
         if not inputs:
             return []
 
-        keys = [value["key"] for value in inputs]
-        actual_inputs = [value["input"] for value in inputs]
+        keys = [input_["key"] for input_ in inputs]
+        actual_inputs = [input_["input"] for input_ in inputs]
         if any(key not in self.runnables for key in keys):
             msg = "One or more keys do not have a corresponding runnable"
             raise ValueError(msg)
 
         async def ainvoke(
-            runnable: Runnable, value: Input, config: RunnableConfig
+            runnable: Runnable, input_: Input, config: RunnableConfig
         ) -> Union[Output, Exception]:
             if return_exceptions:
                 try:
-                    return await runnable.ainvoke(value, config, **kwargs)
+                    return await runnable.ainvoke(input_, config, **kwargs)
                 except Exception as e:
                     return e
             else:
-                return await runnable.ainvoke(value, config, **kwargs)
+                return await runnable.ainvoke(input_, config, **kwargs)
 
         runnables = [self.runnables[key] for key in keys]
         configs = get_config_list(config, len(inputs))