langchain 0.3.19__tar.gz → 0.3.21__tar.gz

{langchain-0.3.19 → langchain-0.3.21}/PKG-INFO

@@ -1,23 +1,19 @@
 Metadata-Version: 2.1
 Name: langchain
-Version: 0.3.19
+Version: 0.3.21
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D0%22&expanded=true
 Project-URL: repository, https://github.com/langchain-ai/langchain
 Requires-Python: <4.0,>=3.9
-Requires-Dist: langchain-core<1.0.0,>=0.3.35
-Requires-Dist: langchain-text-splitters<1.0.0,>=0.3.6
+Requires-Dist: langchain-core<1.0.0,>=0.3.45
+Requires-Dist: langchain-text-splitters<1.0.0,>=0.3.7
 Requires-Dist: langsmith<0.4,>=0.1.17
 Requires-Dist: pydantic<3.0.0,>=2.7.4
 Requires-Dist: SQLAlchemy<3,>=1.4
 Requires-Dist: requests<3,>=2
 Requires-Dist: PyYAML>=5.3
-Requires-Dist: aiohttp<4.0.0,>=3.8.3
-Requires-Dist: tenacity!=8.4.0,<10,>=8.1.0
-Requires-Dist: numpy<2,>=1.26.4; python_version < "3.12"
-Requires-Dist: numpy<3,>=1.26.2; python_version >= "3.12"
 Requires-Dist: async-timeout<5.0.0,>=4.0.0; python_version < "3.11"
 Provides-Extra: community
 Requires-Dist: langchain-community; extra == "community"
@@ -25,6 +21,8 @@ Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic; extra == "anthropic"
 Provides-Extra: openai
 Requires-Dist: langchain-openai; extra == "openai"
+Provides-Extra: azure-ai
+Requires-Dist: langchain-azure-ai; extra == "azure-ai"
 Provides-Extra: cohere
 Requires-Dist: langchain-cohere; extra == "cohere"
 Provides-Extra: google-vertexai

{langchain-0.3.19 → langchain-0.3.21}/langchain/agents/openai_assistant/base.py

@@ -114,7 +114,7 @@ def _is_assistants_builtin_tool(
     tool: Union[Dict[str, Any], Type[BaseModel], Callable, BaseTool],
 ) -> bool:
     """Determine if tool corresponds to OpenAI Assistants built-in."""
-    assistants_builtin_tools = ("code_interpreter", "retrieval")
+    assistants_builtin_tools = ("code_interpreter", "file_search")
     return (
         isinstance(tool, dict)
         and ("type" in tool)
@@ -128,7 +128,7 @@ def _get_assistants_tool(
     """Convert a raw function/class to an OpenAI tool.
 
     Note that OpenAI assistants supports several built-in tools,
-    such as "code_interpreter" and "retrieval."
+    such as "code_interpreter" and "file_search".
     """
     if _is_assistants_builtin_tool(tool):
         return tool  # type: ignore
@@ -300,6 +300,8 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                 max_completion_tokens: Allow setting max_completion_tokens for this run.
                 max_prompt_tokens: Allow setting max_prompt_tokens for this run.
                 run_metadata: Metadata to associate with new run.
+                attachments: A list of files attached to the message, and the
+                    tools they should be added to.
             config: Runnable config. Defaults to None.
 
         Return:
@@ -333,6 +335,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
                             "role": "user",
                             "content": input["content"],
                             "metadata": input.get("message_metadata"),
+                            "attachments": input.get("attachments"),
                         }
                     ],
                     "metadata": input.get("thread_metadata"),
@@ -652,7 +655,7 @@ class OpenAIAssistantRunnable(RunnableSerializable[Dict, OutputType]):
         self, intermediate_steps: List[Tuple[OpenAIAssistantAction, str]]
     ) -> dict:
         last_action, last_output = intermediate_steps[-1]
-        run = await self._wait_for_run(last_action.run_id, last_action.thread_id)
+        run = self._wait_for_run(last_action.run_id, last_action.thread_id)
         required_tool_call_ids = set()
         if run.required_action:
             required_tool_call_ids = {

{langchain-0.3.19 → langchain-0.3.21}/langchain/chains/elasticsearch_database/prompts.py

@@ -9,7 +9,7 @@ ESQuery:"""
 
 DEFAULT_DSL_TEMPLATE = """Given an input question, create a syntactically correct Elasticsearch query to run. Unless the user specifies in their question a specific number of examples they wish to obtain, always limit your query to at most {top_k} results. You can order the results by a relevant column to return the most interesting examples in the database.
 
-Unless told to do not query for all the columns from a specific index, only ask for a the few relevant columns given the question.
+Unless told to do not query for all the columns from a specific index, only ask for a few relevant columns given the question.
 
 Pay attention to use only the column names that you can see in the mapping description. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which index. Return the query as valid json.
 

{langchain-0.3.19 → langchain-0.3.21}/langchain/chains/flare/base.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
+import logging
 import re
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
-import numpy as np
 from langchain_core.callbacks import (
     CallbackManagerForChainRun,
 )
@@ -23,6 +23,8 @@ from langchain.chains.flare.prompts import (
 )
 from langchain.chains.llm import LLMChain
 
+logger = logging.getLogger(__name__)
+
 
 def _extract_tokens_and_log_probs(response: AIMessage) -> Tuple[List[str], List[float]]:
     """Extract tokens and log probabilities from chat model response."""
@@ -57,7 +59,24 @@ def _low_confidence_spans(
     min_token_gap: int,
     num_pad_tokens: int,
 ) -> List[str]:
-    _low_idx = np.where(np.exp(log_probs) < min_prob)[0]
+    try:
+        import numpy as np
+
+        _low_idx = np.where(np.exp(log_probs) < min_prob)[0]
+    except ImportError:
+        logger.warning(
+            "NumPy not found in the current Python environment. FlareChain will use a "
+            "pure Python implementation for internal calculations, which may "
+            "significantly impact performance, especially for large datasets. For "
+            "optimal speed and efficiency, consider installing NumPy: pip install numpy"
+        )
+        import math
+
+        _low_idx = [  # type: ignore[assignment]
+            idx
+            for idx, log_prob in enumerate(log_probs)
+            if math.exp(log_prob) < min_prob
+        ]
     low_idx = [i for i in _low_idx if re.search(r"\w", tokens[i])]
     if len(low_idx) == 0:
         return []

{langchain-0.3.19 → langchain-0.3.21}/langchain/chains/hyde/base.py

@@ -5,9 +5,9 @@ https://arxiv.org/abs/2212.10496
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Dict, List, Optional
 
-import numpy as np
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseLanguageModel
@@ -20,6 +20,8 @@ from langchain.chains.base import Chain
 from langchain.chains.hyde.prompts import PROMPT_MAP
 from langchain.chains.llm import LLMChain
 
+logger = logging.getLogger(__name__)
+
 
 class HypotheticalDocumentEmbedder(Chain, Embeddings):
     """Generate hypothetical document for query, and then embed that.
@@ -54,7 +56,22 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
 
     def combine_embeddings(self, embeddings: List[List[float]]) -> List[float]:
         """Combine embeddings into final embeddings."""
-        return list(np.array(embeddings).mean(axis=0))
+        try:
+            import numpy as np
+
+            return list(np.array(embeddings).mean(axis=0))
+        except ImportError:
+            logger.warning(
+                "NumPy not found in the current Python environment. "
+                "HypotheticalDocumentEmbedder will use a pure Python implementation "
+                "for internal calculations, which may significantly impact "
+                "performance, especially for large datasets. For optimal speed and "
+                "efficiency, consider installing NumPy: pip install numpy"
+            )
+            if not embeddings:
+                return []
+            num_vectors = len(embeddings)
+            return [sum(dim_values) / num_vectors for dim_values in zip(*embeddings)]
 
     def embed_query(self, text: str) -> List[float]:
         """Generate a hypothetical document and embedded it."""

{langchain-0.3.19 → langchain-0.3.21}/langchain/chains/sql_database/prompt.py

@@ -10,7 +10,7 @@ Question: {input}"""
 
 _DEFAULT_TEMPLATE = """Given an input question, first create a syntactically correct {dialect} query to run, then look at the results of the query and return the answer. Unless the user specifies in his question a specific number of examples he wishes to obtain, always limit your query to at most {top_k} results. You can order the results by a relevant column to return the most interesting examples in the database.
 
-Never query for all the columns from a specific table, only ask for a the few relevant columns given the question.
+Never query for all the columns from a specific table, only ask for a few relevant columns given the question.
 
 Pay attention to use only the column names that you can see in the schema description. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which table.
 

{langchain-0.3.19 → langchain-0.3.21}/langchain/chat_models/base.py

@@ -108,6 +108,7 @@ def init_chat_model(
             - 'openai'              -> langchain-openai
             - 'anthropic'           -> langchain-anthropic
             - 'azure_openai'        -> langchain-openai
+            - 'azure_ai             -> langchain-ai
             - 'google_vertexai'     -> langchain-google-vertexai
             - 'google_genai'        -> langchain-google-genai
             - 'bedrock'             -> langchain-aws
@@ -356,6 +357,11 @@ def _init_chat_model_helper(
         from langchain_openai import AzureChatOpenAI
 
         return AzureChatOpenAI(model=model, **kwargs)
+    elif model_provider == "azure_ai":
+        _check_pkg("langchain_azure_ai")
+        from langchain_azure_ai import AzureAIChatCompletionsModel
+
+        return AzureAIChatCompletionsModel(model=model, **kwargs)
     elif model_provider == "cohere":
         _check_pkg("langchain_cohere")
         from langchain_cohere import ChatCohere
@@ -459,6 +465,7 @@ _SUPPORTED_PROVIDERS = {
     "openai",
     "anthropic",
     "azure_openai",
+    "azure_ai",
     "cohere",
     "google_vertexai",
     "google_genai",
@@ -875,7 +882,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         input: Any,
         config: Optional[RunnableConfig] = None,
         *,
-        version: Literal["v1", "v2"],
+        version: Literal["v1", "v2"] = "v2",
         include_names: Optional[Sequence[str]] = None,
         include_types: Optional[Sequence[str]] = None,
         include_tags: Optional[Sequence[str]] = None,

{langchain-0.3.19 → langchain-0.3.21}/langchain/evaluation/embedding_distance/base.py

@@ -1,9 +1,11 @@
 """A chain for comparing the output of two models using embeddings."""
 
+import functools
+import logging
 from enum import Enum
+from importlib import util
 from typing import Any, Dict, List, Optional
 
-import numpy as np
 from langchain_core.callbacks.manager import (
     AsyncCallbackManagerForChainRun,
     CallbackManagerForChainRun,
@@ -18,6 +20,34 @@ from langchain.evaluation.schema import PairwiseStringEvaluator, StringEvaluator
 from langchain.schema import RUN_KEY
 
 
+def _import_numpy() -> Any:
+    try:
+        import numpy as np
+
+        return np
+    except ImportError as e:
+        raise ImportError(
+            "Could not import numpy, please install with `pip install numpy`."
+        ) from e
+
+
+logger = logging.getLogger(__name__)
+
+
+@functools.lru_cache(maxsize=1)
+def _check_numpy() -> bool:
+    if bool(util.find_spec("numpy")):
+        return True
+    logger.warning(
+        "NumPy not found in the current Python environment. "
+        "langchain will use a pure Python implementation for embedding distance "
+        "operations, which may significantly impact performance, especially for large "
+        "datasets. For optimal speed and efficiency, consider installing NumPy: "
+        "pip install numpy"
+    )
+    return False
+
+
 def _embedding_factory() -> Embeddings:
     """Create an Embeddings object.
     Returns:
@@ -158,7 +188,7 @@ class _EmbeddingDistanceChainMixin(Chain):
             raise ValueError(f"Invalid metric: {metric}")
 
     @staticmethod
-    def _cosine_distance(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    def _cosine_distance(a: Any, b: Any) -> Any:
         """Compute the cosine distance between two vectors.
 
         Args:
@@ -179,7 +209,7 @@ class _EmbeddingDistanceChainMixin(Chain):
         return 1.0 - cosine_similarity(a, b)
 
     @staticmethod
-    def _euclidean_distance(a: np.ndarray, b: np.ndarray) -> np.floating:
+    def _euclidean_distance(a: Any, b: Any) -> Any:
         """Compute the Euclidean distance between two vectors.
 
         Args:
@@ -189,10 +219,15 @@ class _EmbeddingDistanceChainMixin(Chain):
         Returns:
             np.floating: The Euclidean distance.
         """
-        return np.linalg.norm(a - b)
+        if _check_numpy():
+            import numpy as np
+
+            return np.linalg.norm(a - b)
+
+        return sum((x - y) * (x - y) for x, y in zip(a, b)) ** 0.5
 
     @staticmethod
-    def _manhattan_distance(a: np.ndarray, b: np.ndarray) -> np.floating:
+    def _manhattan_distance(a: Any, b: Any) -> Any:
         """Compute the Manhattan distance between two vectors.
 
         Args:
@@ -202,10 +237,14 @@ class _EmbeddingDistanceChainMixin(Chain):
         Returns:
             np.floating: The Manhattan distance.
         """
-        return np.sum(np.abs(a - b))
+        if _check_numpy():
+            np = _import_numpy()
+            return np.sum(np.abs(a - b))
+
+        return sum(abs(x - y) for x, y in zip(a, b))
 
     @staticmethod
-    def _chebyshev_distance(a: np.ndarray, b: np.ndarray) -> np.floating:
+    def _chebyshev_distance(a: Any, b: Any) -> Any:
         """Compute the Chebyshev distance between two vectors.
 
         Args:
@@ -215,10 +254,14 @@ class _EmbeddingDistanceChainMixin(Chain):
         Returns:
             np.floating: The Chebyshev distance.
         """
-        return np.max(np.abs(a - b))
+        if _check_numpy():
+            np = _import_numpy()
+            return np.max(np.abs(a - b))
+
+        return max(abs(x - y) for x, y in zip(a, b))
 
     @staticmethod
-    def _hamming_distance(a: np.ndarray, b: np.ndarray) -> np.floating:
+    def _hamming_distance(a: Any, b: Any) -> Any:
         """Compute the Hamming distance between two vectors.
 
         Args:
@@ -228,9 +271,13 @@ class _EmbeddingDistanceChainMixin(Chain):
         Returns:
             np.floating: The Hamming distance.
         """
-        return np.mean(a != b)
+        if _check_numpy():
+            np = _import_numpy()
+            return np.mean(a != b)
 
-    def _compute_score(self, vectors: np.ndarray) -> float:
+        return sum(1 for x, y in zip(a, b) if x != y) / len(a)
+
+    def _compute_score(self, vectors: Any) -> float:
         """Compute the score based on the distance metric.
 
         Args:
@@ -240,8 +287,11 @@ class _EmbeddingDistanceChainMixin(Chain):
             float: The computed score.
         """
         metric = self._get_metric(self.distance_metric)
-        score = metric(vectors[0].reshape(1, -1), vectors[1].reshape(1, -1)).item()
-        return score
+        if _check_numpy() and isinstance(vectors, _import_numpy().ndarray):
+            score = metric(vectors[0].reshape(1, -1), vectors[1].reshape(1, -1)).item()
+        else:
+            score = metric(vectors[0], vectors[1])
+        return float(score)
 
 
 class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
@@ -292,9 +342,12 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         Returns:
             Dict[str, Any]: The computed score.
         """
-        vectors = np.array(
-            self.embeddings.embed_documents([inputs["prediction"], inputs["reference"]])
+        vectors = self.embeddings.embed_documents(
+            [inputs["prediction"], inputs["reference"]]
         )
+        if _check_numpy():
+            np = _import_numpy()
+            vectors = np.array(vectors)
         score = self._compute_score(vectors)
         return {"score": score}
 
@@ -313,13 +366,15 @@ class EmbeddingDistanceEvalChain(_EmbeddingDistanceChainMixin, StringEvaluator):
         Returns:
             Dict[str, Any]: The computed score.
         """
-        embedded = await self.embeddings.aembed_documents(
+        vectors = await self.embeddings.aembed_documents(
             [
                 inputs["prediction"],
                 inputs["reference"],
             ]
         )
-        vectors = np.array(embedded)
+        if _check_numpy():
+            np = _import_numpy()
+            vectors = np.array(vectors)
         score = self._compute_score(vectors)
         return {"score": score}
 
@@ -432,14 +487,15 @@ class PairwiseEmbeddingDistanceEvalChain(
         Returns:
             Dict[str, Any]: The computed score.
         """
-        vectors = np.array(
-            self.embeddings.embed_documents(
-                [
-                    inputs["prediction"],
-                    inputs["prediction_b"],
-                ]
-            )
+        vectors = self.embeddings.embed_documents(
+            [
+                inputs["prediction"],
+                inputs["prediction_b"],
+            ]
         )
+        if _check_numpy():
+            np = _import_numpy()
+            vectors = np.array(vectors)
         score = self._compute_score(vectors)
         return {"score": score}
 
@@ -458,13 +514,15 @@ class PairwiseEmbeddingDistanceEvalChain(
         Returns:
             Dict[str, Any]: The computed score.
         """
-        embedded = await self.embeddings.aembed_documents(
+        vectors = await self.embeddings.aembed_documents(
             [
                 inputs["prediction"],
                 inputs["prediction_b"],
             ]
         )
-        vectors = np.array(embedded)
+        if _check_numpy():
+            np = _import_numpy()
+            vectors = np.array(vectors)
         score = self._compute_score(vectors)
         return {"score": score}
 

{langchain-0.3.19 → langchain-0.3.21}/langchain/retrievers/document_compressors/embeddings_filter.py

@@ -1,6 +1,5 @@
 from typing import Callable, Dict, Optional, Sequence
 
-import numpy as np
 from langchain_core.callbacks.manager import Callbacks
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
@@ -69,6 +68,13 @@ class EmbeddingsFilter(BaseDocumentCompressor):
                 "To use please install langchain-community "
                 "with `pip install langchain-community`."
             )
+
+        try:
+            import numpy as np
+        except ImportError as e:
+            raise ImportError(
+                "Could not import numpy, please install with `pip install numpy`."
+            ) from e
         stateful_documents = get_stateful_documents(documents)
         embedded_documents = _get_embeddings_from_stateful_docs(
             self.embeddings, stateful_documents
@@ -104,6 +110,13 @@ class EmbeddingsFilter(BaseDocumentCompressor):
                 "To use please install langchain-community "
                 "with `pip install langchain-community`."
             )
+
+        try:
+            import numpy as np
+        except ImportError as e:
+            raise ImportError(
+                "Could not import numpy, please install with `pip install numpy`."
+            ) from e
         stateful_documents = get_stateful_documents(documents)
         embedded_documents = await _aget_embeddings_from_stateful_docs(
             self.embeddings, stateful_documents

{langchain-0.3.19 → langchain-0.3.21}/pyproject.toml

@@ -8,21 +8,17 @@ build-backend = "pdm.backend"
 authors = []
 requires-python = "<4.0,>=3.9"
 dependencies = [
-    "langchain-core<1.0.0,>=0.3.35",
-    "langchain-text-splitters<1.0.0,>=0.3.6",
+    "langchain-core<1.0.0,>=0.3.45",
+    "langchain-text-splitters<1.0.0,>=0.3.7",
     "langsmith<0.4,>=0.1.17",
     "pydantic<3.0.0,>=2.7.4",
     "SQLAlchemy<3,>=1.4",
     "requests<3,>=2",
     "PyYAML>=5.3",
-    "aiohttp<4.0.0,>=3.8.3",
-    "tenacity!=8.4.0,<10,>=8.1.0",
-    "numpy<2,>=1.26.4; python_version < \"3.12\"",
-    "numpy<3,>=1.26.2; python_version >= \"3.12\"",
     "async-timeout<5.0.0,>=4.0.0; python_version < \"3.11\"",
 ]
 name = "langchain"
-version = "0.3.19"
+version = "0.3.21"
 description = "Building applications with LLMs through composability"
 readme = "README.md"
 
@@ -39,6 +35,9 @@ anthropic = [
 openai = [
     "langchain-openai",
 ]
+azure-ai = [
+    "langchain-azure-ai",
+]
 cohere = [
     "langchain-cohere",
 ]
@@ -110,6 +109,7 @@ test = [
     "langchain-openai",
     "toml>=0.10.2",
     "packaging>=24.2",
+    "numpy<3,>=1.26.4",
 ]
 codespell = [
     "codespell<3.0.0,>=2.2.0",
@@ -140,6 +140,7 @@ typing = [
     "mypy-protobuf<4.0.0,>=3.0.0",
     "langchain-core",
     "langchain-text-splitters",
+    "numpy<3,>=1.26.4",
 ]
 dev = [
     "jupyter<2.0.0,>=1.0.0",

langchain-0.3.21/tests/unit_tests/callbacks/test_file.py

@@ -0,0 +1,45 @@
+import pathlib
+from typing import Any, Dict, List, Optional
+
+import pytest
+
+from langchain.callbacks import FileCallbackHandler
+from langchain.chains.base import CallbackManagerForChainRun, Chain
+
+
+class FakeChain(Chain):
+    """Fake chain class for testing purposes."""
+
+    be_correct: bool = True
+    the_input_keys: List[str] = ["foo"]
+    the_output_keys: List[str] = ["bar"]
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Input keys."""
+        return self.the_input_keys
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Output key of bar."""
+        return self.the_output_keys
+
+    def _call(
+        self,
+        inputs: Dict[str, str],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, str]:
+        return {"bar": "bar"}
+
+
+def test_filecallback(capsys: pytest.CaptureFixture, tmp_path: pathlib.Path) -> Any:
+    """Test the file callback handler."""
+    p = tmp_path / "output.log"
+    handler = FileCallbackHandler(str(p))
+    chain_test = FakeChain(callbacks=[handler])
+    chain_test.invoke({"foo": "bar"})
+    # Assert the output is as expected
+    assert p.read_text() == (
+        "\n\n\x1b[1m> Entering new FakeChain "
+        "chain...\x1b[0m\n\n\x1b[1m> Finished chain.\x1b[0m\n"
+    )

{langchain-0.3.19 → langchain-0.3.21}/tests/unit_tests/chat_models/test_base.py

@@ -133,6 +133,7 @@ def test_configurable() -> None:
             "extra_body": None,
             "include_response_headers": False,
             "stream_usage": False,
+            "use_responses_api": None,
         },
         "kwargs": {
             "tools": [
@@ -193,6 +194,7 @@ def test_configurable_with_default() -> None:
             "model": "claude-3-sonnet-20240229",
             "max_tokens": 1024,
             "temperature": None,
+            "thinking": None,
             "top_k": None,
             "top_p": None,
             "default_request_timeout": None,

{langchain-0.3.19 → langchain-0.3.21}/tests/unit_tests/load/test_load.py

@@ -167,3 +167,13 @@ def test_load_llmchain_with_non_serializable_arg() -> None:
     chain_obj = dumpd(chain)
     with pytest.raises(NotImplementedError):
         load(chain_obj, secrets_map={"OPENAI_API_KEY": "hello"})
+
+
+@pytest.mark.requires("openai", "langchain_openai")
+def test_loads_with_missing_secrets() -> None:
+    import openai
+
+    llm_string = '{"lc": 1, "type": "constructor", "id": ["langchain", "llms", "openai", "OpenAI"], "kwargs": {"model_name": "davinci", "temperature": 0.5, "max_tokens": 256, "top_p": 0.8, "n": 1, "best_of": 1, "openai_api_key": {"lc": 1, "type": "secret", "id": ["OPENAI_API_KEY"]}, "batch_size": 20, "max_retries": 2, "disallowed_special": "all"}, "name": "OpenAI"}'  # noqa: E501
+    # Should throw on instantiation, not deserialization
+    with pytest.raises(openai.OpenAIError):
+        loads(llm_string)

{langchain-0.3.19 → langchain-0.3.21}/tests/unit_tests/test_dependencies.py

@@ -33,15 +33,12 @@ def test_required_dependencies(uv_conf: Mapping[str, Any]) -> None:
         [
             "PyYAML",
             "SQLAlchemy",
-            "aiohttp",
             "async-timeout",
             "langchain-core",
             "langchain-text-splitters",
             "langsmith",
-            "numpy",
             "pydantic",
             "requests",
-            "tenacity",
         ]
     )
 
@@ -84,5 +81,6 @@ def test_test_group_dependencies(uv_conf: Mapping[str, Any]) -> None:
             "requests-mock",
             # TODO: temporary hack since cffi 1.17.1 doesn't work with py 3.9.
             "cffi",
+            "numpy",
         ]
     )