langchain-core 0.3.74__py3-none-any.whl → 0.3.76__py3-none-any.whl

langchain_core/runnables/branch.py

@@ -12,6 +12,10 @@ from typing import (
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import override
 
+from langchain_core.beta.runnables.context import (
+    CONTEXT_CONFIG_PREFIX,
+    CONTEXT_CONFIG_SUFFIX_SET,
+)
 from langchain_core.runnables.base import (
     Runnable,
     RunnableLike,
@@ -44,10 +48,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
 
     If no condition evaluates to True, the default branch is run on the input.
 
-    Parameters:
-        branches: A list of (condition, Runnable) pairs.
-        default: A Runnable to run if no condition is met.
-
     Examples:
 
         .. code-block:: python
@@ -61,13 +61,15 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
                 lambda x: "goodbye",
             )
 
-            branch.invoke("hello") # "HELLO"
-            branch.invoke(None) # "goodbye"
+            branch.invoke("hello")  # "HELLO"
+            branch.invoke(None)  # "goodbye"
 
     """
 
     branches: Sequence[tuple[Runnable[Input, bool], Runnable[Input, Output]]]
+    """A list of (condition, Runnable) pairs."""
     default: Runnable[Input, Output]
+    """A Runnable to run if no condition is met."""
 
     def __init__(
         self,
@@ -136,7 +138,7 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
         super().__init__(
             branches=branches_,
             default=default_,
-        )  # type: ignore[call-arg]
+        )
 
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
@@ -144,12 +146,17 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
 
     @classmethod
     def is_lc_serializable(cls) -> bool:
-        """RunnableBranch is serializable if all its branches are 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.
+
+        Returns:
+            ``["langchain", "schema", "runnable"]``
+        """
         return ["langchain", "schema", "runnable"]
 
     @override
@@ -174,11 +181,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
     @property
     @override
     def config_specs(self) -> list[ConfigurableFieldSpec]:
-        from langchain_core.beta.runnables.context import (
-            CONTEXT_CONFIG_PREFIX,
-            CONTEXT_CONFIG_SUFFIX_SET,
-        )
-
         specs = get_unique_config_specs(
             spec
             for step in (
@@ -260,7 +262,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
     async def ainvoke(
         self, input: Input, config: Optional[RunnableConfig] = None, **kwargs: Any
     ) -> Output:
-        """Async version of invoke."""
         config = ensure_config(config)
         callback_manager = get_async_callback_manager_for_config(config)
         run_manager = await callback_manager.on_chain_start(
@@ -321,9 +322,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
 
         Yields:
             The output of the branch that was run.
-
-        Raises:
-            BaseException: If an error occurs during the execution of the Runnable.
         """
         config = ensure_config(config)
         callback_manager = get_callback_manager_for_config(config)
@@ -408,9 +406,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
 
         Yields:
             The output of the branch that was run.
-
-        Raises:
-            BaseException: If an error occurs during the execution of the Runnable.
         """
         config = ensure_config(config)
         callback_manager = get_async_callback_manager_for_config(config)

langchain_core/runnables/config.py

@@ -12,21 +12,22 @@ from contextvars import Context, ContextVar, Token, copy_context
 from functools import partial
 from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union, cast
 
+from langsmith.run_helpers import _set_tracing_context, get_tracing_context
 from typing_extensions import ParamSpec, TypedDict
 
+from langchain_core.callbacks.manager import AsyncCallbackManager, CallbackManager
 from langchain_core.runnables.utils import (
     Input,
     Output,
     accepts_config,
     accepts_run_manager,
 )
+from langchain_core.tracers.langchain import LangChainTracer
 
 if TYPE_CHECKING:
     from langchain_core.callbacks.base import BaseCallbackManager, Callbacks
     from langchain_core.callbacks.manager import (
-        AsyncCallbackManager,
         AsyncCallbackManagerForChainRun,
-        CallbackManager,
         CallbackManagerForChainRun,
     )
 else:
@@ -125,9 +126,10 @@ def _set_config_context(
 
     Args:
         config (RunnableConfig): The config to set.
-    """
-    from langchain_core.tracers.langchain import LangChainTracer
 
+    Returns:
+        The token to reset the config and the previous tracing context.
+    """
     config_token = var_child_runnable_config.set(config)
     current_context = None
     if (
@@ -147,8 +149,6 @@ def _set_config_context(
         )
         and (run := tracer.run_map.get(str(parent_run_id)))
     ):
-        from langsmith.run_helpers import _set_tracing_context, get_tracing_context
-
         current_context = get_tracing_context()
         _set_tracing_context({"parent": run})
     return config_token, current_context
@@ -160,9 +160,10 @@ def set_config_context(config: RunnableConfig) -> Generator[Context, None, None]
 
     Args:
         config (RunnableConfig): The config to set.
-    """
-    from langsmith.run_helpers import _set_tracing_context
 
+    Yields:
+        The config context.
+    """
     ctx = copy_context()
     config_token, _ = ctx.run(_set_config_context, config)
     try:
@@ -402,7 +403,7 @@ def call_func_with_variable_args(
         Callable[[Input, CallbackManagerForChainRun], Output],
         Callable[[Input, CallbackManagerForChainRun, RunnableConfig], Output],
     ],
-    input: Input,  # noqa: A002
+    input: Input,
     config: RunnableConfig,
     run_manager: Optional[CallbackManagerForChainRun] = None,
     **kwargs: Any,
@@ -439,7 +440,7 @@ def acall_func_with_variable_args(
             Awaitable[Output],
         ],
     ],
-    input: Input,  # noqa: A002
+    input: Input,
     config: RunnableConfig,
     run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
     **kwargs: Any,
@@ -475,8 +476,6 @@ def get_callback_manager_for_config(config: RunnableConfig) -> CallbackManager:
     Returns:
         CallbackManager: The callback manager.
     """
-    from langchain_core.callbacks.manager import CallbackManager
-
     return CallbackManager.configure(
         inheritable_callbacks=config.get("callbacks"),
         inheritable_tags=config.get("tags"),
@@ -495,8 +494,6 @@ def get_async_callback_manager_for_config(
     Returns:
         AsyncCallbackManager: The async callback manager.
     """
-    from langchain_core.callbacks.manager import AsyncCallbackManager
-
     return AsyncCallbackManager.configure(
         inheritable_callbacks=config.get("callbacks"),
         inheritable_tags=config.get("tags"),
@@ -598,9 +595,6 @@ async def run_in_executor(
 
     Returns:
         Output: The output of the function.
-
-    Raises:
-        RuntimeError: If the function raises a StopIteration.
     """
 
     def wrapper() -> T:

langchain_core/runnables/configurable.py

@@ -51,17 +51,15 @@ if TYPE_CHECKING:
 class DynamicRunnable(RunnableSerializable[Input, Output]):
     """Serializable Runnable that can be dynamically configured.
 
-    A DynamicRunnable should be initiated using the `configurable_fields` or
-    `configurable_alternatives` method of a Runnable.
-
-    Parameters:
-        default: The default Runnable to use.
-        config: The configuration to use.
+    A DynamicRunnable should be initiated using the ``configurable_fields`` or
+    ``configurable_alternatives`` method of a Runnable.
     """
 
     default: RunnableSerializable[Input, Output]
+    """The default Runnable to use."""
 
     config: Optional[RunnableConfig] = None
+    """The configuration to use."""
 
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
@@ -70,11 +68,17 @@ class DynamicRunnable(RunnableSerializable[Input, Output]):
     @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
@@ -322,9 +326,6 @@ class RunnableConfigurableFields(DynamicRunnable[Input, Output]):
     A RunnableConfigurableFields should be initiated using the
     `configurable_fields` method of a Runnable.
 
-    Parameters:
-        fields: The configurable fields to use.
-
     Here is an example of using a RunnableConfigurableFields with LLMs:
 
         .. code-block:: python
@@ -382,6 +383,7 @@ class RunnableConfigurableFields(DynamicRunnable[Input, Output]):
     """
 
     fields: dict[str, AnyConfigurableField]
+    """The configurable fields to use."""
 
     @property
     def config_specs(self) -> list[ConfigurableFieldSpec]:
@@ -501,7 +503,7 @@ class RunnableConfigurableAlternatives(DynamicRunnable[Input, Output]):
             ).configurable_alternatives(
                 ConfigurableField(id="prompt"),
                 default_key="joke",
-                poem=PromptTemplate.from_template("Write a short poem about {topic}")
+                poem=PromptTemplate.from_template("Write a short poem about {topic}"),
             )
 
             # When invoking the created RunnableSequence, you can pass in the
@@ -511,7 +513,9 @@ class RunnableConfigurableAlternatives(DynamicRunnable[Input, Output]):
 
             # The `with_config` method brings in the desired Prompt Runnable in your
             # Runnable Sequence.
-            chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "bears"})
+            chain.with_config(configurable={"prompt": "poem"}).invoke(
+                {"topic": "bears"}
+            )
 
 
     Equivalently, you can initialize RunnableConfigurableAlternatives directly
@@ -520,20 +524,28 @@ class RunnableConfigurableAlternatives(DynamicRunnable[Input, Output]):
         .. code-block:: python
 
             from langchain_core.runnables import ConfigurableField
-            from langchain_core.runnables.configurable import RunnableConfigurableAlternatives
+            from langchain_core.runnables.configurable import (
+                RunnableConfigurableAlternatives,
+            )
             from langchain_openai import ChatOpenAI
 
             prompt = RunnableConfigurableAlternatives(
-                which=ConfigurableField(id='prompt'),
+                which=ConfigurableField(id="prompt"),
                 default=PromptTemplate.from_template("Tell me a joke about {topic}"),
-                default_key='joke',
+                default_key="joke",
                 prefix_keys=False,
-                alternatives={"poem":PromptTemplate.from_template("Write a short poem about {topic}")}
+                alternatives={
+                    "poem": PromptTemplate.from_template(
+                        "Write a short poem about {topic}"
+                    )
+                },
             )
             chain = prompt | ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
-            chain.with_config(configurable={"prompt": "poem"}).invoke({"topic": "bears"})
+            chain.with_config(configurable={"prompt": "poem"}).invoke(
+                {"topic": "bears"}
+            )
 
-    """  # noqa: E501
+    """
 
     which: ConfigurableField
     """The ConfigurableField to use to choose between alternatives."""
@@ -680,7 +692,10 @@ def make_options_spec(
     spec: Union[ConfigurableFieldSingleOption, ConfigurableFieldMultiOption],
     description: Optional[str],
 ) -> ConfigurableFieldSpec:
-    """Make a ConfigurableFieldSpec for a ConfigurableFieldSingleOption or ConfigurableFieldMultiOption.
+    """Make options spec.
+
+    Make a ConfigurableFieldSpec for a ConfigurableFieldSingleOption or
+    ConfigurableFieldMultiOption.
 
     Args:
         spec: The ConfigurableFieldSingleOption or ConfigurableFieldMultiOption.
@@ -688,7 +703,7 @@ def make_options_spec(
 
     Returns:
         The ConfigurableFieldSpec.
-    """  # noqa: E501
+    """
     with _enums_for_spec_lock:
         if enum := _enums_for_spec.get(spec):
             pass

langchain_core/runnables/fallbacks.py

@@ -5,11 +5,12 @@ import inspect
 import typing
 from collections.abc import AsyncIterator, Iterator, Sequence
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import override
 
+from langchain_core.callbacks.manager import AsyncCallbackManager, CallbackManager
 from langchain_core.runnables.base import Runnable, RunnableSerializable
 from langchain_core.runnables.config import (
     RunnableConfig,
@@ -56,12 +57,12 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             from langchain_core.chat_models.openai import ChatOpenAI
             from langchain_core.chat_models.anthropic import ChatAnthropic
 
-            model = ChatAnthropic(
-                model="claude-3-haiku-20240307"
-            ).with_fallbacks([ChatOpenAI(model="gpt-3.5-turbo-0125")])
+            model = ChatAnthropic(model="claude-3-haiku-20240307").with_fallbacks(
+                [ChatOpenAI(model="gpt-3.5-turbo-0125")]
+            )
             # Will usually use ChatAnthropic, but fallback to ChatOpenAI
             # if ChatAnthropic fails.
-            model.invoke('hello')
+            model.invoke("hello")
 
             # And you can also use fallbacks at the level of a chain.
             # Here if both LLM providers fail, we'll fallback to a good hardcoded
@@ -71,12 +72,16 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             from langchain_core.output_parser import StrOutputParser
             from langchain_core.runnables import RunnableLambda
 
+
             def when_all_is_lost(inputs):
-                return ("Looks like our LLM providers are down. "
-                        "Here's a nice 🦜️ emoji for you instead.")
+                return (
+                    "Looks like our LLM providers are down. "
+                    "Here's a nice 🦜️ emoji for you instead."
+                )
+
 
             chain_with_fallback = (
-                PromptTemplate.from_template('Tell me a joke about {topic}')
+                PromptTemplate.from_template("Tell me a joke about {topic}")
                 | model
                 | StrOutputParser()
             ).with_fallbacks([RunnableLambda(when_all_is_lost)])
@@ -136,6 +141,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     @classmethod
     @override
     def is_lc_serializable(cls) -> bool:
+        """Return True as this class is serializable."""
         return True
 
     @classmethod
@@ -143,13 +149,18 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
     def get_lc_namespace(cls) -> list[str]:
         """Get the namespace of the langchain object.
 
-        Defaults to ["langchain", "schema", "runnable"].
+        Returns:
+            ``["langchain", "schema", "runnable"]``
         """
         return ["langchain", "schema", "runnable"]
 
     @property
     def runnables(self) -> Iterator[Runnable[Input, Output]]:
-        """Iterator over the Runnable and its fallbacks."""
+        """Iterator over the Runnable and its fallbacks.
+
+        Yields:
+            The Runnable then its fallbacks.
+        """
         yield self.runnable
         yield from self.fallbacks
 
@@ -262,8 +273,6 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
         return_exceptions: bool = False,
         **kwargs: Optional[Any],
     ) -> list[Output]:
-        from langchain_core.callbacks.manager import CallbackManager
-
         if self.exception_key is not None and not all(
             isinstance(input_, dict) for input_ in inputs
         ):
@@ -356,8 +365,6 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
         return_exceptions: bool = False,
         **kwargs: Optional[Any],
     ) -> list[Output]:
-        from langchain_core.callbacks.manager import AsyncCallbackManager
-
         if self.exception_key is not None and not all(
             isinstance(input_, dict) for input_ in inputs
         ):
@@ -397,7 +404,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             )
         )
 
-        to_return = {}
+        to_return: dict[int, Union[Output, BaseException]] = {}
         run_again = dict(enumerate(inputs))
         handled_exceptions: dict[int, BaseException] = {}
         first_to_raise = None
@@ -447,7 +454,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
         if not return_exceptions and sorted_handled_exceptions:
             raise sorted_handled_exceptions[0][1]
         to_return.update(handled_exceptions)
-        return [output for _, output in sorted(to_return.items())]  # type: ignore[misc]
+        return [cast("Output", output) for _, output in sorted(to_return.items())]
 
     @override
     def stream(
@@ -569,7 +576,7 @@ class RunnableWithFallbacks(RunnableSerializable[Input, Output]):
             async for chunk in stream:
                 yield chunk
                 try:
-                    output = output + chunk
+                    output = output + chunk  # type: ignore[operator]
                 except TypeError:
                     output = None
         except BaseException as e:

langchain_core/runnables/graph.py

@@ -19,6 +19,8 @@ from typing import (
 )
 from uuid import UUID, uuid4
 
+from langchain_core.load.serializable import to_json_not_implemented
+from langchain_core.runnables.base import Runnable, RunnableSerializable
 from langchain_core.utils.pydantic import _IgnoreUnserializable, is_basemodel_subclass
 
 if TYPE_CHECKING:
@@ -62,19 +64,16 @@ def is_uuid(value: str) -> bool:
 
 
 class Edge(NamedTuple):
-    """Edge in a graph.
-
-    Parameters:
-        source: The source node id.
-        target: The target node id.
-        data: Optional data associated with the edge. Defaults to None.
-        conditional: Whether the edge is conditional. Defaults to False.
-    """
+    """Edge in a graph."""
 
     source: str
+    """The source node id."""
     target: str
+    """The target node id."""
     data: Optional[Stringifiable] = None
+    """Optional data associated with the edge. Defaults to None."""
     conditional: bool = False
+    """Whether the edge is conditional. Defaults to False."""
 
     def copy(
         self, *, source: Optional[str] = None, target: Optional[str] = None
@@ -97,24 +96,21 @@ class Edge(NamedTuple):
 
 
 class Node(NamedTuple):
-    """Node in a graph.
-
-    Parameters:
-        id: The unique identifier of the node.
-        name: The name of the node.
-        data: The data of the node.
-        metadata: Optional metadata for the node. Defaults to None.
-    """
+    """Node in a graph."""
 
     id: str
+    """The unique identifier of the node."""
     name: str
+    """The name of the node."""
     data: Union[type[BaseModel], RunnableType, None]
+    """The data of the node."""
     metadata: Optional[dict[str, Any]]
+    """Optional metadata for the node. Defaults to None."""
 
     def copy(
         self,
         *,
-        id: Optional[str] = None,  # noqa: A002
+        id: Optional[str] = None,
         name: Optional[str] = None,
     ) -> Node:
         """Return a copy of the node with optional new id and name.
@@ -135,16 +131,12 @@ class Node(NamedTuple):
 
 
 class Branch(NamedTuple):
-    """Branch in a graph.
-
-    Parameters:
-        condition: A callable that returns a string representation of the condition.
-        ends: Optional dictionary of end node ids for the branches. Defaults
-            to None.
-    """
+    """Branch in a graph."""
 
     condition: Callable[..., str]
+    """A callable that returns a string representation of the condition."""
     ends: Optional[dict[str, str]]
+    """Optional dictionary of end node ids for the branches. Defaults to None."""
 
 
 class CurveStyle(Enum):
@@ -168,7 +160,7 @@ class CurveStyle(Enum):
 class NodeStyles:
     """Schema for Hexadecimal color codes for different node types.
 
-    Parameters:
+    Args:
         default: The default color code. Defaults to "fill:#f2f0ff,line-height:1.2".
         first: The color code for the first node. Defaults to "fill-opacity:0".
         last: The color code for the last node. Defaults to "fill:#bfb6fc".
@@ -182,12 +174,14 @@ class NodeStyles:
 class MermaidDrawMethod(Enum):
     """Enum for different draw methods supported by Mermaid."""
 
-    PYPPETEER = "pyppeteer"  # Uses Pyppeteer to render the graph
-    API = "api"  # Uses Mermaid.INK API to render the graph
+    PYPPETEER = "pyppeteer"
+    """Uses Pyppeteer to render the graph"""
+    API = "api"
+    """Uses Mermaid.INK API to render the graph"""
 
 
 def node_data_str(
-    id: str,  # noqa: A002
+    id: str,
     data: Union[type[BaseModel], RunnableType, None],
 ) -> str:
     """Convert the data of a node to a string.
@@ -199,8 +193,6 @@ def node_data_str(
     Returns:
         A string representation of the data.
     """
-    from langchain_core.runnables.base import Runnable
-
     if not is_uuid(id) or data is None:
         return id
     data_str = data.get_name() if isinstance(data, Runnable) else data.__name__
@@ -220,9 +212,6 @@ def node_data_json(
     Returns:
         A dictionary with the type of the data and the data itself.
     """
-    from langchain_core.load.serializable import to_json_not_implemented
-    from langchain_core.runnables.base import Runnable, RunnableSerializable
-
     if node.data is None:
         json: dict[str, Any] = {}
     elif isinstance(node.data, RunnableSerializable):
@@ -269,7 +258,7 @@ def node_data_json(
 class Graph:
     """Graph of nodes and edges.
 
-    Parameters:
+    Args:
         nodes: Dictionary of nodes in the graph. Defaults to an empty dictionary.
         edges: List of edges in the graph. Defaults to an empty list.
     """
@@ -328,7 +317,7 @@ class Graph:
     def add_node(
         self,
         data: Union[type[BaseModel], RunnableType, None],
-        id: Optional[str] = None,  # noqa: A002
+        id: Optional[str] = None,
         *,
         metadata: Optional[dict[str, Any]] = None,
     ) -> Node:
@@ -475,6 +464,10 @@ class Graph:
 
         If there is no such node, or there are multiple, return None.
         When drawing the graph, this node would be the origin.
+
+        Returns:
+            The first node, or None if there is no such node or multiple
+            candidates.
         """
         return _first_node(self)
 
@@ -483,6 +476,10 @@ class Graph:
 
         If there is no such node, or there are multiple, return None.
         When drawing the graph, this node would be the destination.
+
+        Returns:
+            The last node, or None if there is no such node or multiple
+            candidates.
         """
         return _last_node(self)
 
@@ -513,8 +510,13 @@ class Graph:
             self.remove_node(last_node)
 
     def draw_ascii(self) -> str:
-        """Draw the graph as an ASCII art string."""
-        from langchain_core.runnables.graph_ascii import draw_ascii
+        """Draw the graph as an ASCII art string.
+
+        Returns:
+            The ASCII art string.
+        """
+        # Import locally to prevent circular import
+        from langchain_core.runnables.graph_ascii import draw_ascii  # noqa: PLC0415
 
         return draw_ascii(
             {node.id: node.name for node in self.nodes.values()},
@@ -558,7 +560,8 @@ class Graph:
         Returns:
             The PNG image as bytes if output_file_path is None, None otherwise.
         """
-        from langchain_core.runnables.graph_png import PngDrawer
+        # Import locally to prevent circular import
+        from langchain_core.runnables.graph_png import PngDrawer  # noqa: PLC0415
 
         default_node_labels = {node.id: node.name for node in self.nodes.values()}
 
@@ -613,7 +616,8 @@ class Graph:
             The Mermaid syntax string.
 
         """
-        from langchain_core.runnables.graph_mermaid import draw_mermaid
+        # Import locally to prevent circular import
+        from langchain_core.runnables.graph_mermaid import draw_mermaid  # noqa: PLC0415
 
         graph = self.reid()
         first_node = graph.first_node()
@@ -684,7 +688,10 @@ class Graph:
             The PNG image as bytes.
 
         """
-        from langchain_core.runnables.graph_mermaid import draw_mermaid_png
+        # Import locally to prevent circular import
+        from langchain_core.runnables.graph_mermaid import (  # noqa: PLC0415
+            draw_mermaid_png,
+        )
 
         mermaid_syntax = self.draw_mermaid(
             curve_style=curve_style,