langchain-core 1.0.0a1__py3-none-any.whl → 1.0.0a3__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

@@ -23,6 +23,13 @@ class EventData(TypedDict, total=False):
     won't be known until the *END* of the Runnable when it has finished streaming
     its inputs.
     """
+    error: NotRequired[BaseException]
+    """The error that occurred during the execution of the Runnable.
+
+    This field is only available if the Runnable raised an exception.
+
+    .. versionadded:: 1.0.0
+    """
     output: Any
     """The output of the Runnable that generated the event.
 
@@ -51,9 +58,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")]