langchain 0.3.25__py3-none-any.whl → 0.3.27__py3-none-any.whl

langchain/chains/openai_functions/extraction.py

@@ -25,7 +25,7 @@ def _get_extraction_function(entity_schema: dict) -> dict:
         "parameters": {
             "type": "object",
             "properties": {
-                "info": {"type": "array", "items": _convert_schema(entity_schema)}
+                "info": {"type": "array", "items": _convert_schema(entity_schema)},
             },
             "required": ["info"],
         },
@@ -63,18 +63,18 @@ Passage:
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -84,7 +84,7 @@ def create_extraction_chain(
     llm: BaseLanguageModel,
     prompt: Optional[BasePromptTemplate] = None,
     tags: Optional[list[str]] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> Chain:
     """Creates a chain that extracts information from a passage.
 
@@ -103,7 +103,7 @@ def create_extraction_chain(
     extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
     output_parser = JsonKeyOutputFunctionsParser(key_name="info")
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=extraction_prompt,
         llm_kwargs=llm_kwargs,
@@ -111,7 +111,6 @@ def create_extraction_chain(
         tags=tags,
         verbose=verbose,
     )
-    return chain
 
 
 @deprecated(
@@ -133,18 +132,18 @@ def create_extraction_chain(
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -153,7 +152,7 @@ def create_extraction_chain_pydantic(
     pydantic_schema: Any,
     llm: BaseLanguageModel,
     prompt: Optional[BasePromptTemplate] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> Chain:
     """Creates a chain that extracts information from a passage using pydantic schema.
 
@@ -178,20 +177,21 @@ def create_extraction_chain_pydantic(
         openai_schema = pydantic_schema.schema()
 
     openai_schema = _resolve_schema_references(
-        openai_schema, openai_schema.get("definitions", {})
+        openai_schema,
+        openai_schema.get("definitions", {}),
     )
 
     function = _get_extraction_function(openai_schema)
     extraction_prompt = prompt or ChatPromptTemplate.from_template(_EXTRACTION_TEMPLATE)
     output_parser = PydanticAttrOutputFunctionsParser(
-        pydantic_schema=PydanticSchema, attr_name="info"
+        pydantic_schema=PydanticSchema,
+        attr_name="info",
     )
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=extraction_prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         verbose=verbose,
     )
-    return chain

langchain/chains/openai_functions/openapi.py

@@ -23,14 +23,6 @@ if TYPE_CHECKING:
     from openapi_pydantic import Parameter
 
 
-def _get_description(o: Any, prefer_short: bool) -> Optional[str]:
-    summary = getattr(o, "summary", None)
-    description = getattr(o, "description", None)
-    if prefer_short:
-        return summary or description
-    return description or summary
-
-
 def _format_url(url: str, path_params: dict) -> str:
     expected_path_param = re.findall(r"{(.*?)}", url)
     new_params = {}
@@ -59,13 +51,12 @@ def _format_url(url: str, path_params: dict) -> str:
                 sep = ","
                 new_val = ""
             new_val += sep.join(kv_strs)
+        elif param[0] == ".":
+            new_val = f".{val}"
+        elif param[0] == ";":
+            new_val = f";{clean_param}={val}"
         else:
-            if param[0] == ".":
-                new_val = f".{val}"
-            elif param[0] == ";":
-                new_val = f";{clean_param}={val}"
-            else:
-                new_val = val
+            new_val = val
         new_params[param] = new_val
     return url.format(**new_params)
 
@@ -77,7 +68,7 @@ def _openapi_params_to_json_schema(params: list[Parameter], spec: OpenAPISpec) -
         if p.param_schema:
             schema = spec.get_schema(p.param_schema)
         else:
-            media_type_schema = list(p.content.values())[0].media_type_schema
+            media_type_schema = next(iter(p.content.values())).media_type_schema
             schema = spec.get_schema(media_type_schema)
         if p.description and not schema.description:
             schema.description = p.description
@@ -102,11 +93,12 @@ def openapi_spec_to_openai_fn(
     """
     try:
         from langchain_community.tools import APIOperation
-    except ImportError:
-        raise ImportError(
+    except ImportError as e:
+        msg = (
             "Could not import langchain_community.tools. "
             "Please install it with `pip install langchain-community`."
         )
+        raise ImportError(msg) from e
 
     if not spec.paths:
         return [], lambda: None
@@ -134,7 +126,8 @@ def openapi_spec_to_openai_fn(
             for param_loc, arg_name in param_loc_to_arg_name.items():
                 if params_by_type[param_loc]:
                     request_args[arg_name] = _openapi_params_to_json_schema(
-                        params_by_type[param_loc], spec
+                        params_by_type[param_loc],
+                        spec,
                     )
             request_body = spec.get_request_body_for_operation(op)
             # TODO: Support more MIME types.
@@ -144,10 +137,10 @@ def openapi_spec_to_openai_fn(
                     if media_type_object.media_type_schema:
                         schema = spec.get_schema(media_type_object.media_type_schema)
                         media_types[media_type] = json.loads(
-                            schema.json(exclude_none=True)
+                            schema.json(exclude_none=True),
                         )
                 if len(media_types) == 1:
-                    media_type, schema_dict = list(media_types.items())[0]
+                    media_type, schema_dict = next(iter(media_types.items()))
                     key = "json" if media_type == "application/json" else "data"
                     request_args[key] = schema_dict
                 elif len(media_types) > 1:
@@ -173,6 +166,7 @@ def openapi_spec_to_openai_fn(
         fn_args: dict,
         headers: Optional[dict] = None,
         params: Optional[dict] = None,
+        timeout: Optional[int] = 30,
         **kwargs: Any,
     ) -> Any:
         method = _name_to_call_map[name]["method"]
@@ -192,7 +186,7 @@ def openapi_spec_to_openai_fn(
                 _kwargs["params"].update(params)
             else:
                 _kwargs["params"] = params
-        return requests.request(method, url, **_kwargs)
+        return requests.request(method, url, **_kwargs, timeout=timeout)
 
     return functions, default_call_api
 
@@ -229,11 +223,11 @@ class SimpleRequestChain(Chain):
         _text = f"Calling endpoint {_pretty_name} with arguments:\n" + _pretty_args
         _run_manager.on_text(_text)
         api_response: Response = self.request_method(name, args)
-        if api_response.status_code != 200:
+        if api_response.status_code != requests.codes.ok:
             response = (
                 f"{api_response.status_code}: {api_response.reason}"
-                + f"\nFor {name} "
-                + f"Called with args: {args.get('params', '')}"
+                f"\nFor {name} "
+                f"Called with args: {args.get('params', '')}"
             )
         else:
             try:
@@ -248,7 +242,7 @@ class SimpleRequestChain(Chain):
     message=(
         "This function is deprecated and will be removed in langchain 1.0. "
         "See API reference for replacement: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.openapi.get_openapi_chain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.openai_functions.openapi.get_openapi_chain.html"
     ),
     removal="1.0",
 )
@@ -258,7 +252,7 @@ def get_openapi_chain(
     prompt: Optional[BasePromptTemplate] = None,
     request_chain: Optional[Chain] = None,
     llm_chain_kwargs: Optional[dict] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
     headers: Optional[dict] = None,
     params: Optional[dict] = None,
     **kwargs: Any,
@@ -352,10 +346,11 @@ def get_openapi_chain(
     try:
         from langchain_community.utilities.openapi import OpenAPISpec
     except ImportError as e:
-        raise ImportError(
+        msg = (
             "Could not import langchain_community.utilities.openapi. "
             "Please install it with `pip install langchain-community`."
-        ) from e
+        )
+        raise ImportError(msg) from e
     if isinstance(spec, str):
         for conversion in (
             OpenAPISpec.from_url,
@@ -365,21 +360,23 @@ def get_openapi_chain(
             try:
                 spec = conversion(spec)
                 break
-            except ImportError as e:
-                raise e
-            except Exception:
+            except ImportError:
+                raise
+            except Exception:  # noqa: S110
                 pass
         if isinstance(spec, str):
-            raise ValueError(f"Unable to parse spec from source {spec}")
+            msg = f"Unable to parse spec from source {spec}"
+            raise ValueError(msg)  # noqa: TRY004
     openai_fns, call_api_fn = openapi_spec_to_openai_fn(spec)
     if not llm:
-        raise ValueError(
+        msg = (
             "Must provide an LLM for this chain.For example,\n"
             "from langchain_openai import ChatOpenAI\n"
             "llm = ChatOpenAI()\n"
         )
+        raise ValueError(msg)
     prompt = prompt or ChatPromptTemplate.from_template(
-        "Use the provided API's to respond to this user query:\n\n{query}"
+        "Use the provided API's to respond to this user query:\n\n{query}",
     )
     llm_chain = LLMChain(
         llm=llm,
@@ -392,7 +389,10 @@ def get_openapi_chain(
     )
     request_chain = request_chain or SimpleRequestChain(
         request_method=lambda name, args: call_api_fn(
-            name, args, headers=headers, params=params
+            name,
+            args,
+            headers=headers,
+            params=params,
         ),
         verbose=verbose,
     )

langchain/chains/openai_functions/qa_with_structure.py

@@ -22,7 +22,8 @@ class AnswerWithSources(BaseModel):
 
     answer: str = Field(..., description="Answer to the question that was asked")
     sources: list[str] = Field(
-        ..., description="List of sources used to answer the question"
+        ...,
+        description="List of sources used to answer the question",
     )
 
 
@@ -32,7 +33,7 @@ class AnswerWithSources(BaseModel):
     message=(
         "This function is deprecated. Refer to this guide on retrieval and question "
         "answering with structured responses: "
-        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"  # noqa: E501
+        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"
     ),
 )
 def create_qa_with_structure_chain(
@@ -40,7 +41,7 @@ def create_qa_with_structure_chain(
     schema: Union[dict, type[BaseModel]],
     output_parser: str = "base",
     prompt: Optional[Union[PromptTemplate, ChatPromptTemplate]] = None,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
 ) -> LLMChain:
     """Create a question answering chain that returns an answer with sources
      based on schema.
@@ -57,20 +58,22 @@ def create_qa_with_structure_chain(
     """
     if output_parser == "pydantic":
         if not (isinstance(schema, type) and is_basemodel_subclass(schema)):
-            raise ValueError(
+            msg = (
                 "Must provide a pydantic class for schema when output_parser is "
                 "'pydantic'."
             )
+            raise ValueError(msg)
         _output_parser: BaseLLMOutputParser = PydanticOutputFunctionsParser(
-            pydantic_schema=schema
+            pydantic_schema=schema,
         )
     elif output_parser == "base":
         _output_parser = OutputFunctionsParser()
     else:
-        raise ValueError(
+        msg = (
             f"Got unexpected output_parser: {output_parser}. "
             f"Should be one of `pydantic` or `base`."
         )
+        raise ValueError(msg)
     if isinstance(schema, type) and is_basemodel_subclass(schema):
         if hasattr(schema, "model_json_schema"):
             schema_dict = cast(dict, schema.model_json_schema())
@@ -89,7 +92,7 @@ def create_qa_with_structure_chain(
             content=(
                 "You are a world class algorithm to answer "
                 "questions in a specific format."
-            )
+            ),
         ),
         HumanMessage(content="Answer question using the following context"),
         HumanMessagePromptTemplate.from_template("{context}"),
@@ -98,14 +101,13 @@ def create_qa_with_structure_chain(
     ]
     prompt = prompt or ChatPromptTemplate(messages=messages)  # type: ignore[arg-type]
 
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=_output_parser,
         verbose=verbose,
     )
-    return chain
 
 
 @deprecated(
@@ -114,11 +116,13 @@ def create_qa_with_structure_chain(
     message=(
         "This function is deprecated. Refer to this guide on retrieval and question "
         "answering with sources: "
-        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"  # noqa: E501
+        "https://python.langchain.com/docs/how_to/qa_sources/#structure-sources-in-model-response"
     ),
 )
 def create_qa_with_sources_chain(
-    llm: BaseLanguageModel, verbose: bool = False, **kwargs: Any
+    llm: BaseLanguageModel,
+    verbose: bool = False,  # noqa: FBT001,FBT002
+    **kwargs: Any,
 ) -> LLMChain:
     """Create a question answering chain that returns an answer with sources.
 
@@ -131,5 +135,8 @@ def create_qa_with_sources_chain(
         Chain (LLMChain) that can be used to answer questions with citations.
     """
     return create_qa_with_structure_chain(
-        llm, AnswerWithSources, verbose=verbose, **kwargs
+        llm,
+        AnswerWithSources,
+        verbose=verbose,
+        **kwargs,
     )

langchain/chains/openai_functions/tagging.py

@@ -91,14 +91,13 @@ def create_tagging_chain(
     prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
     output_parser = JsonOutputFunctionsParser()
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         **kwargs,
     )
-    return chain
 
 
 @deprecated(
@@ -164,11 +163,10 @@ def create_tagging_chain_pydantic(
     prompt = prompt or ChatPromptTemplate.from_template(_TAGGING_TEMPLATE)
     output_parser = PydanticOutputFunctionsParser(pydantic_schema=pydantic_schema)
     llm_kwargs = get_llm_kwargs(function)
-    chain = LLMChain(
+    return LLMChain(
         llm=llm,
         prompt=prompt,
         llm_kwargs=llm_kwargs,
         output_parser=output_parser,
         **kwargs,
     )
-    return chain

langchain/chains/openai_tools/extraction.py

@@ -34,18 +34,18 @@ If a property is not present and is not required in the function parameters, do
         """
             from pydantic import BaseModel, Field
             from langchain_anthropic import ChatAnthropic
-    
+
             class Joke(BaseModel):
                 setup: str = Field(description="The setup of the joke")
-                punchline: str = Field(description="The punchline to the joke") 
-    
+                punchline: str = Field(description="The punchline to the joke")
+
             # Or any other chat model that supports tools.
             # Please reference to to the documentation of structured_output
-            # to see an up to date list of which models support 
+            # to see an up to date list of which models support
             # with_structured_output.
             model = ChatAnthropic(model="claude-3-opus-20240229", temperature=0)
             structured_llm = model.with_structured_output(Joke)
-            structured_llm.invoke("Tell me a joke about cats. 
+            structured_llm.invoke("Tell me a joke about cats.
                 Make sure to call the Joke function.")
             """
     ),
@@ -71,10 +71,9 @@ def create_extraction_chain_pydantic(
         [
             ("system", system_message),
             ("user", "{input}"),
-        ]
+        ],
     )
     functions = [convert_pydantic_to_openai_function(p) for p in pydantic_schemas]
     tools = [{"type": "function", "function": d} for d in functions]
     model = llm.bind(tools=tools)
-    chain = prompt | model | PydanticToolsParser(tools=pydantic_schemas)
-    return chain
+    return prompt | model | PydanticToolsParser(tools=pydantic_schemas)

langchain/chains/qa_generation/base.py

@@ -19,7 +19,7 @@ from langchain.chains.qa_generation.prompt import PROMPT_SELECTOR
     since="0.2.7",
     alternative=(
         "example in API reference with more detail: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html"  # noqa: E501
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.qa_generation.base.QAGenerationChain.html"
     ),
     removal="1.0",
 )
@@ -66,7 +66,7 @@ class QAGenerationChain(Chain):
     llm_chain: LLMChain
     """LLM Chain that generates responses from user input and context."""
     text_splitter: TextSplitter = Field(
-        default=RecursiveCharacterTextSplitter(chunk_overlap=500)
+        default=RecursiveCharacterTextSplitter(chunk_overlap=500),
     )
     """Text splitter that splits the input into chunks."""
     input_key: str = "text"
@@ -117,7 +117,8 @@ class QAGenerationChain(Chain):
     ) -> dict[str, list]:
         docs = self.text_splitter.create_documents([inputs[self.input_key]])
         results = self.llm_chain.generate(
-            [{"text": d.page_content} for d in docs], run_manager=run_manager
+            [{"text": d.page_content} for d in docs],
+            run_manager=run_manager,
         )
         qa = [json.loads(res[0].text) for res in results.generations]
         return {self.output_key: qa}

langchain/chains/qa_generation/prompt.py

@@ -1,5 +1,3 @@
-# flake8: noqa
-from langchain.chains.prompt_selector import ConditionalPromptSelector, is_chat_model
 from langchain_core.prompts.chat import (
     ChatPromptTemplate,
     HumanMessagePromptTemplate,
@@ -7,6 +5,8 @@ from langchain_core.prompts.chat import (
 )
 from langchain_core.prompts.prompt import PromptTemplate
 
+from langchain.chains.prompt_selector import ConditionalPromptSelector, is_chat_model
+
 templ1 = """You are a smart assistant designed to help high school teachers come up with reading comprehension questions.
 Given a piece of text, you must come up with a question and answer pair that can be used to test a student's reading comprehension abilities.
 When coming up with this question/answer pair, you must respond in the following format:
@@ -18,10 +18,10 @@ When coming up with this question/answer pair, you must respond in the following
 ```
 
 Everything between the ``` must be valid json.
-"""
+"""  # noqa: E501
 templ2 = """Please come up with a question/answer pair, in the specified JSON format, for the following text:
 ----------------
-{text}"""
+{text}"""  # noqa: E501
 CHAT_PROMPT = ChatPromptTemplate.from_messages(
     [
         SystemMessagePromptTemplate.from_template(templ1),
@@ -42,7 +42,7 @@ Everything between the ``` must be valid json.
 
 Please come up with a question/answer pair, in the specified JSON format, for the following text:
 ----------------
-{text}"""
+{text}"""  # noqa: E501
 PROMPT = PromptTemplate.from_template(templ)
 
 PROMPT_SELECTOR = ConditionalPromptSelector(

langchain/chains/qa_with_sources/base.py

@@ -70,7 +70,7 @@ class BaseQAWithSourcesChain(Chain, ABC):
             document_variable_name="summaries",
         )
         reduce_documents_chain = ReduceDocumentsChain(
-            combine_documents_chain=combine_results_chain
+            combine_documents_chain=combine_results_chain,
         )
         combine_documents_chain = MapReduceDocumentsChain(
             llm_chain=llm_question_chain,
@@ -93,7 +93,9 @@ class BaseQAWithSourcesChain(Chain, ABC):
         """Load chain from chain type."""
         _chain_kwargs = chain_type_kwargs or {}
         combine_documents_chain = load_qa_with_sources_chain(
-            llm, chain_type=chain_type, **_chain_kwargs
+            llm,
+            chain_type=chain_type,
+            **_chain_kwargs,
         )
         return cls(combine_documents_chain=combine_documents_chain, **kwargs)
 
@@ -118,7 +120,7 @@ class BaseQAWithSourcesChain(Chain, ABC):
         """
         _output_keys = [self.answer_key, self.sources_answer_key]
         if self.return_source_documents:
-            _output_keys = _output_keys + ["source_documents"]
+            _output_keys = [*_output_keys, "source_documents"]
         return _output_keys
 
     @model_validator(mode="before")
@@ -133,7 +135,9 @@ class BaseQAWithSourcesChain(Chain, ABC):
         """Split sources from answer."""
         if re.search(r"SOURCES?:", answer, re.IGNORECASE):
             answer, sources = re.split(
-                r"SOURCES?:|QUESTION:\s", answer, flags=re.IGNORECASE
+                r"SOURCES?:|QUESTION:\s",
+                answer,
+                flags=re.IGNORECASE,
             )[:2]
             sources = re.split(r"\n", sources)[0].strip()
         else:
@@ -164,7 +168,9 @@ class BaseQAWithSourcesChain(Chain, ABC):
             docs = self._get_docs(inputs)  # type: ignore[call-arg]
 
         answer = self.combine_documents_chain.run(
-            input_documents=docs, callbacks=_run_manager.get_child(), **inputs
+            input_documents=docs,
+            callbacks=_run_manager.get_child(),
+            **inputs,
         )
         answer, sources = self._split_sources(answer)
         result: dict[str, Any] = {
@@ -198,7 +204,9 @@ class BaseQAWithSourcesChain(Chain, ABC):
         else:
             docs = await self._aget_docs(inputs)  # type: ignore[call-arg]
         answer = await self.combine_documents_chain.arun(
-            input_documents=docs, callbacks=_run_manager.get_child(), **inputs
+            input_documents=docs,
+            callbacks=_run_manager.get_child(),
+            **inputs,
         )
         answer, sources = self._split_sources(answer)
         result: dict[str, Any] = {