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

langchain/smith/evaluation/string_run_evaluator.py

@@ -28,8 +28,7 @@ def _get_messages_from_run_dict(messages: list[dict]) -> list[BaseMessage]:
     first_message = messages[0]
     if "lc" in first_message:
         return [load(dumpd(message)) for message in messages]
-    else:
-        return messages_from_dict(messages)
+    return messages_from_dict(messages)
 
 
 class StringRunMapper(Serializable):
@@ -47,7 +46,8 @@ class StringRunMapper(Serializable):
     def __call__(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if not run.outputs:
-            raise ValueError(f"Run {run.id} has no outputs to evaluate.")
+            msg = f"Run {run.id} has no outputs to evaluate."
+            raise ValueError(msg)
         return self.map(run)
 
 
@@ -63,9 +63,11 @@ class LLMStringRunMapper(StringRunMapper):
                 # Runs from Tracer have messages as a list of lists of dicts
                 chat_messages = _get_messages_from_run_dict(messages[0])
             else:
-                raise ValueError(f"Could not extract messages to evaluate {messages}")
+                msg = f"Could not extract messages to evaluate {messages}"
+                raise ValueError(msg)
             return get_buffer_string(chat_messages)
-        raise ValueError(f"Could not extract messages to evaluate {messages}")
+        msg = f"Could not extract messages to evaluate {messages}"
+        raise ValueError(msg)
 
     def serialize_inputs(self, inputs: dict) -> str:
         if "prompts" in inputs:  # Should we even accept this?
@@ -75,15 +77,18 @@ class LLMStringRunMapper(StringRunMapper):
         elif "messages" in inputs:
             input_ = self.serialize_chat_messages(inputs["messages"])
         else:
-            raise ValueError("LLM Run must have either messages or prompts as inputs.")
+            msg = "LLM Run must have either messages or prompts as inputs."
+            raise ValueError(msg)
         return input_
 
     def serialize_outputs(self, outputs: dict) -> str:
         if not outputs.get("generations"):
-            raise ValueError("Cannot evaluate LLM Run without generations.")
+            msg = "Cannot evaluate LLM Run without generations."
+            raise ValueError(msg)
         generations: list[dict] = outputs["generations"]
         if not generations:
-            raise ValueError("Cannot evaluate LLM run with empty generations.")
+            msg = "Cannot evaluate LLM run with empty generations."
+            raise ValueError(msg)
         first_generation: dict = generations[0]
         if isinstance(first_generation, list):
             # Runs from Tracer have generations as a list of lists of dicts
@@ -98,30 +103,25 @@ class LLMStringRunMapper(StringRunMapper):
     def map(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if run.run_type != "llm":
-            raise ValueError("LLM RunMapper only supports LLM runs.")
-        elif not run.outputs:
+            msg = "LLM RunMapper only supports LLM runs."
+            raise ValueError(msg)
+        if not run.outputs:
             if run.error:
-                raise ValueError(
-                    f"Cannot evaluate errored LLM run {run.id}: {run.error}"
-                )
-            else:
-                raise ValueError(
-                    f"Run {run.id} has no outputs. Cannot evaluate this run."
-                )
-        else:
-            try:
-                inputs = self.serialize_inputs(run.inputs)
-            except Exception as e:
-                raise ValueError(
-                    f"Could not parse LM input from run inputs {run.inputs}"
-                ) from e
-            try:
-                output_ = self.serialize_outputs(run.outputs)
-            except Exception as e:
-                raise ValueError(
-                    f"Could not parse LM prediction from run outputs {run.outputs}"
-                ) from e
-            return {"input": inputs, "prediction": output_}
+                msg = f"Cannot evaluate errored LLM run {run.id}: {run.error}"
+                raise ValueError(msg)
+            msg = f"Run {run.id} has no outputs. Cannot evaluate this run."
+            raise ValueError(msg)
+        try:
+            inputs = self.serialize_inputs(run.inputs)
+        except Exception as e:
+            msg = f"Could not parse LM input from run inputs {run.inputs}"
+            raise ValueError(msg) from e
+        try:
+            output_ = self.serialize_outputs(run.outputs)
+        except Exception as e:
+            msg = f"Could not parse LM prediction from run outputs {run.outputs}"
+            raise ValueError(msg) from e
+        return {"input": inputs, "prediction": output_}
 
 
 class ChainStringRunMapper(StringRunMapper):
@@ -139,45 +139,47 @@ class ChainStringRunMapper(StringRunMapper):
     def _get_key(self, source: dict, key: Optional[str], which: str) -> str:
         if key is not None:
             return source[key]
-        elif len(source) == 1:
+        if len(source) == 1:
             return next(iter(source.values()))
-        else:
-            raise ValueError(
-                f"Could not map run {which} with multiple keys: "
-                f"{source}\nPlease manually specify a {which}_key"
-            )
+        msg = (
+            f"Could not map run {which} with multiple keys: "
+            f"{source}\nPlease manually specify a {which}_key"
+        )
+        raise ValueError(msg)
 
     def map(self, run: Run) -> dict[str, str]:
         """Maps the Run to a dictionary."""
         if not run.outputs:
-            raise ValueError(
+            msg = (
                 f"Run with ID {run.id} lacks outputs required for evaluation."
                 " Ensure the Run has valid outputs."
             )
+            raise ValueError(msg)
         if self.input_key is not None and self.input_key not in run.inputs:
-            raise ValueError(
+            msg = (
                 f"Run with ID {run.id} is missing the expected input key"
                 f" '{self.input_key}'.\nAvailable input keys in this Run"
                 f"  are: {run.inputs.keys()}.\nAdjust the evaluator's"
                 f" input_key or ensure your input data includes key"
                 f" '{self.input_key}'."
             )
-        elif self.prediction_key is not None and self.prediction_key not in run.outputs:
+            raise ValueError(msg)
+        if self.prediction_key is not None and self.prediction_key not in run.outputs:
             available_keys = ", ".join(run.outputs.keys())
-            raise ValueError(
+            msg = (
                 f"Run with ID {run.id} doesn't have the expected prediction key"
                 f" '{self.prediction_key}'. Available prediction keys in this Run are:"
                 f" {available_keys}. Adjust the evaluator's prediction_key or"
                 " ensure the Run object's outputs the expected key."
             )
+            raise ValueError(msg)
 
-        else:
-            input_ = self._get_key(run.inputs, self.input_key, "input")
-            prediction = self._get_key(run.outputs, self.prediction_key, "prediction")
-            return {
-                "input": input_,
-                "prediction": prediction,
-            }
+        input_ = self._get_key(run.inputs, self.input_key, "input")
+        prediction = self._get_key(run.outputs, self.prediction_key, "prediction")
+        return {
+            "input": input_,
+            "prediction": prediction,
+        }
 
 
 class ToolStringRunMapper(StringRunMapper):
@@ -185,7 +187,8 @@ class ToolStringRunMapper(StringRunMapper):
 
     def map(self, run: Run) -> dict[str, str]:
         if not run.outputs:
-            raise ValueError(f"Run {run.id} has no outputs to evaluate.")
+            msg = f"Run {run.id} has no outputs to evaluate."
+            raise ValueError(msg)
         return {"input": run.inputs["input"], "prediction": run.outputs["output"]}
 
 
@@ -207,36 +210,35 @@ class StringExampleMapper(Serializable):
     def map(self, example: Example) -> dict[str, str]:
         """Maps the Example, or dataset row to a dictionary."""
         if not example.outputs:
-            raise ValueError(
-                f"Example {example.id} has no outputs to use as a reference."
-            )
+            msg = f"Example {example.id} has no outputs to use as a reference."
+            raise ValueError(msg)
         if self.reference_key is None:
             if len(example.outputs) > 1:
-                raise ValueError(
+                msg = (
                     f"Example {example.id} has multiple outputs, so you must"
                     " specify a reference_key."
                 )
-            else:
-                output = list(example.outputs.values())[0]
+                raise ValueError(msg)
+            output = next(iter(example.outputs.values()))
         elif self.reference_key not in example.outputs:
-            raise ValueError(
+            msg = (
                 f"Example {example.id} does not have reference key"
                 f" {self.reference_key}."
             )
+            raise ValueError(msg)
         else:
             output = example.outputs[self.reference_key]
         return {
             "reference": self.serialize_chat_messages([output])
             if isinstance(output, dict) and output.get("type") and output.get("data")
-            else output
+            else output,
         }
 
     def __call__(self, example: Example) -> dict[str, str]:
         """Maps the Run and Example to a dictionary."""
         if not example.outputs:
-            raise ValueError(
-                f"Example {example.id} has no outputs to use as areference label."
-            )
+            msg = f"Example {example.id} has no outputs to use as areference label."
+            raise ValueError(msg)
         return self.map(example)
 
 
@@ -271,16 +273,19 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
         if example and self.example_mapper and self.string_evaluator.requires_reference:
             evaluate_strings_inputs.update(self.example_mapper(example))
         elif self.string_evaluator.requires_reference:
-            raise ValueError(
+            msg = (
                 f"Evaluator {self.name} requires an reference"
                 " example from the dataset,"
                 f" but none was provided for run {run.id}."
             )
+            raise ValueError(msg)
         return evaluate_strings_inputs
 
     def _prepare_output(self, output: dict[str, Any]) -> dict[str, Any]:
         evaluation_result = EvaluationResult(
-            key=self.name, comment=output.get("reasoning"), **output
+            key=self.name,
+            comment=output.get("reasoning"),
+            **output,
         )
         if RUN_KEY in output:
             # TODO: Not currently surfaced. Update
@@ -351,7 +356,8 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
         """Evaluate an example."""
         try:
             result = await self.acall(
-                {"run": run, "example": example}, include_run_info=True
+                {"run": run, "example": example},
+                include_run_info=True,
             )
             return self._prepare_evaluator_output(result)
         except Exception as e:
@@ -402,12 +408,12 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
             run_mapper: StringRunMapper = LLMStringRunMapper()
         elif run_type == "chain":
             run_mapper = ChainStringRunMapper(
-                input_key=input_key, prediction_key=prediction_key
+                input_key=input_key,
+                prediction_key=prediction_key,
             )
         else:
-            raise ValueError(
-                f"Unsupported run type {run_type}. Expected one of 'llm' or 'chain'."
-            )
+            msg = f"Unsupported run type {run_type}. Expected one of 'llm' or 'chain'."
+            raise ValueError(msg)
 
         # Configure how example rows are fed as a reference string to the evaluator
         if (
@@ -417,11 +423,12 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
         ):
             example_mapper = StringExampleMapper(reference_key=reference_key)
         elif evaluator.requires_reference:
-            raise ValueError(
+            msg = (
                 f"Evaluator {evaluator.evaluation_name} requires a reference"
                 " example from the dataset. Please specify the reference key from"
                 " amongst the dataset outputs keys."
             )
+            raise ValueError(msg)
         else:
             example_mapper = None
         return cls(

langchain/storage/__init__.py

@@ -44,8 +44,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "create_kv_docstore",
-    "create_lc_store",
     "EncoderBackedStore",
     "InMemoryByteStore",
     "InMemoryStore",
@@ -54,4 +52,6 @@ __all__ = [
     "RedisStore",
     "UpstashRedisByteStore",
     "UpstashRedisStore",
+    "create_kv_docstore",
+    "create_lc_store",
 ]

langchain/storage/_lc_store.py

@@ -17,7 +17,8 @@ def _dump_as_bytes(obj: Serializable) -> bytes:
 def _dump_document_as_bytes(obj: Document) -> bytes:
     """Return a bytes representation of a document."""
     if not isinstance(obj, Document):
-        raise TypeError("Expected a Document instance")
+        msg = "Expected a Document instance"
+        raise TypeError(msg)
     return dumps(obj).encode("utf-8")
 
 
@@ -25,7 +26,8 @@ def _load_document_from_bytes(serialized: bytes) -> Document:
     """Return a document from a bytes representation."""
     obj = loads(serialized.decode("utf-8"))
     if not isinstance(obj, Document):
-        raise TypeError(f"Expected a Document instance. Got {type(obj)}")
+        msg = f"Expected a Document instance. Got {type(obj)}"
+        raise TypeError(msg)
     return obj
 
 

langchain/storage/encoder_backed.py

@@ -106,7 +106,9 @@ class EncoderBackedStore(BaseStore[K, V]):
         await self.store.amdelete(encoded_keys)
 
     def yield_keys(
-        self, *, prefix: Optional[str] = None
+        self,
+        *,
+        prefix: Optional[str] = None,
     ) -> Union[Iterator[K], Iterator[str]]:
         """Get an iterator over keys that match the given prefix."""
         # For the time being this does not return K, but str
@@ -114,7 +116,9 @@ class EncoderBackedStore(BaseStore[K, V]):
         yield from self.store.yield_keys(prefix=prefix)
 
     async def ayield_keys(
-        self, *, prefix: Optional[str] = None
+        self,
+        *,
+        prefix: Optional[str] = None,
     ) -> Union[AsyncIterator[K], AsyncIterator[str]]:
         """Get an iterator over keys that match the given prefix."""
         # For the time being this does not return K, but str

langchain/storage/file_system.py

@@ -75,34 +75,37 @@ class LocalFileStore(ByteStore):
             Path: The full path for the given key.
         """
         if not re.match(r"^[a-zA-Z0-9_.\-/]+$", key):
-            raise InvalidKeyException(f"Invalid characters in key: {key}")
-        full_path = os.path.abspath(self.root_path / key)
-        common_path = os.path.commonpath([str(self.root_path), full_path])
-        if common_path != str(self.root_path):
-            raise InvalidKeyException(
-                f"Invalid key: {key}. Key should be relative to the full path."
-                f"{self.root_path} vs. {common_path} and full path of {full_path}"
+            msg = f"Invalid characters in key: {key}"
+            raise InvalidKeyException(msg)
+        full_path = (self.root_path / key).resolve()
+        root_path = self.root_path.resolve()
+        common_path = os.path.commonpath([root_path, full_path])
+        if common_path != str(root_path):
+            msg = (
+                f"Invalid key: {key}. Key should be relative to the full path. "
+                f"{root_path} vs. {common_path} and full path of {full_path}"
             )
+            raise InvalidKeyException(msg)
 
-        return Path(full_path)
+        return full_path
 
-    def _mkdir_for_store(self, dir: Path) -> None:
+    def _mkdir_for_store(self, dir_path: Path) -> None:
         """Makes a store directory path (including parents) with specified permissions
 
         This is needed because `Path.mkdir()` is restricted by the current `umask`,
         whereas the explicit `os.chmod()` used here is not.
 
         Args:
-            dir: (Path) The store directory to make
+            dir_path: (Path) The store directory to make
 
         Returns:
             None
         """
-        if not dir.exists():
-            self._mkdir_for_store(dir.parent)
-            dir.mkdir(exist_ok=True)
+        if not dir_path.exists():
+            self._mkdir_for_store(dir_path.parent)
+            dir_path.mkdir(exist_ok=True)
             if self.chmod_dir is not None:
-                os.chmod(dir, self.chmod_dir)
+                dir_path.chmod(self.chmod_dir)
 
     def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
         """Get the values associated with the given keys.
@@ -122,7 +125,7 @@ class LocalFileStore(ByteStore):
                 values.append(value)
                 if self.update_atime:
                     # update access time only; preserve modified time
-                    os.utime(full_path, (time.time(), os.stat(full_path).st_mtime))
+                    os.utime(full_path, (time.time(), full_path.stat().st_mtime))
             else:
                 values.append(None)
         return values
@@ -141,7 +144,7 @@ class LocalFileStore(ByteStore):
             self._mkdir_for_store(full_path.parent)
             full_path.write_bytes(value)
             if self.chmod_file is not None:
-                os.chmod(full_path, self.chmod_file)
+                full_path.chmod(self.chmod_file)
 
     def mdelete(self, keys: Sequence[str]) -> None:
         """Delete the given keys and their associated values.

langchain/storage/in_memory.py

@@ -7,7 +7,7 @@ primarily for unit testing purposes.
 from langchain_core.stores import InMemoryBaseStore, InMemoryByteStore, InMemoryStore
 
 __all__ = [
-    "InMemoryStore",
     "InMemoryBaseStore",
     "InMemoryByteStore",
+    "InMemoryStore",
 ]

langchain/storage/upstash_redis.py

@@ -22,6 +22,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "UpstashRedisStore",
     "UpstashRedisByteStore",
+    "UpstashRedisStore",
 ]

langchain/text_splitter.py

@@ -27,24 +27,24 @@ from langchain_text_splitters.sentence_transformers import (
 from langchain_text_splitters.spacy import SpacyTextSplitter
 
 __all__ = [
-    "TokenTextSplitter",
-    "TextSplitter",
-    "Tokenizer",
-    "Language",
-    "RecursiveCharacterTextSplitter",
-    "RecursiveJsonSplitter",
-    "LatexTextSplitter",
-    "PythonCodeTextSplitter",
-    "KonlpyTextSplitter",
-    "SpacyTextSplitter",
-    "NLTKTextSplitter",
-    "split_text_on_tokens",
-    "SentenceTransformersTokenTextSplitter",
+    "CharacterTextSplitter",
     "ElementType",
+    "HTMLHeaderTextSplitter",
     "HeaderType",
+    "KonlpyTextSplitter",
+    "Language",
+    "LatexTextSplitter",
     "LineType",
-    "HTMLHeaderTextSplitter",
     "MarkdownHeaderTextSplitter",
     "MarkdownTextSplitter",
-    "CharacterTextSplitter",
+    "NLTKTextSplitter",
+    "PythonCodeTextSplitter",
+    "RecursiveCharacterTextSplitter",
+    "RecursiveJsonSplitter",
+    "SentenceTransformersTokenTextSplitter",
+    "SpacyTextSplitter",
+    "TextSplitter",
+    "TokenTextSplitter",
+    "Tokenizer",
+    "split_text_on_tokens",
 ]

langchain/tools/__init__.py

@@ -39,7 +39,7 @@ _DEPRECATED_TOOLS = {"PythonAstREPLTool", "PythonREPLTool"}
 
 
 def _import_python_tool_PythonAstREPLTool() -> Any:
-    raise ImportError(
+    msg = (
         "This tool has been moved to langchain experiment. "
         "This tool has access to a python REPL. "
         "For best practices make sure to sandbox this tool. "
@@ -47,10 +47,11 @@ def _import_python_tool_PythonAstREPLTool() -> Any:
         "To keep using this code as is, install langchain experimental and "
         "update relevant imports replacing 'langchain' with 'langchain_experimental'"
     )
+    raise ImportError(msg)
 
 
 def _import_python_tool_PythonREPLTool() -> Any:
-    raise ImportError(
+    msg = (
         "This tool has been moved to langchain experiment. "
         "This tool has access to a python REPL. "
         "For best practices make sure to sandbox this tool. "
@@ -58,36 +59,33 @@ def _import_python_tool_PythonREPLTool() -> Any:
         "To keep using this code as is, install langchain experimental and "
         "update relevant imports replacing 'langchain' with 'langchain_experimental'"
     )
+    raise ImportError(msg)
 
 
 def __getattr__(name: str) -> Any:
     if name == "PythonAstREPLTool":
         return _import_python_tool_PythonAstREPLTool()
-    elif name == "PythonREPLTool":
+    if name == "PythonREPLTool":
         return _import_python_tool_PythonREPLTool()
-    else:
-        from langchain_community import tools
+    from langchain_community import tools
 
-        # If not in interactive env, raise warning.
-        if not is_interactive_env():
-            warnings.warn(
-                "Importing tools from langchain is deprecated. Importing from "
-                "langchain will no longer be supported as of langchain==0.2.0. "
-                "Please import from langchain-community instead:\n\n"
-                f"`from langchain_community.tools import {name}`.\n\n"
-                "To install langchain-community run "
-                "`pip install -U langchain-community`.",
-                category=LangChainDeprecationWarning,
-            )
+    # If not in interactive env, raise warning.
+    if not is_interactive_env():
+        warnings.warn(
+            "Importing tools from langchain is deprecated. Importing from "
+            "langchain will no longer be supported as of langchain==0.2.0. "
+            "Please import from langchain-community instead:\n\n"
+            f"`from langchain_community.tools import {name}`.\n\n"
+            "To install langchain-community run "
+            "`pip install -U langchain-community`.",
+            stacklevel=2,
+            category=LangChainDeprecationWarning,
+        )
 
-        return getattr(tools, name)
+    return getattr(tools, name)
 
 
 __all__ = [
-    "StructuredTool",
-    "BaseTool",
-    "tool",
-    "Tool",
     "AINAppOps",
     "AINOwnerOps",
     "AINRuleOps",
@@ -105,6 +103,7 @@ __all__ = [
     "BaseRequestsTool",
     "BaseSQLDatabaseTool",
     "BaseSparkSQLTool",
+    "BaseTool",
     "BearlyInterpreterTool",
     "BingSearchResults",
     "BingSearchRun",
@@ -140,8 +139,6 @@ __all__ = [
     "GoogleSearchRun",
     "GoogleSerperResults",
     "GoogleSerperRun",
-    "SearchAPIResults",
-    "SearchAPIRun",
     "HumanInputRun",
     "IFTTTWebhook",
     "InfoPowerBITool",
@@ -168,20 +165,21 @@ __all__ = [
     "OpenAPISpec",
     "OpenWeatherMapQueryRun",
     "PubmedQueryRun",
-    "RedditSearchRun",
     "QueryCheckerTool",
     "QueryPowerBITool",
     "QuerySQLCheckerTool",
     "QuerySQLDataBaseTool",
     "QuerySparkSQLTool",
     "ReadFileTool",
+    "RedditSearchRun",
     "RequestsDeleteTool",
     "RequestsGetTool",
     "RequestsPatchTool",
     "RequestsPostTool",
     "RequestsPutTool",
-    "SteamWebAPIQueryRun",
     "SceneXplainTool",
+    "SearchAPIResults",
+    "SearchAPIRun",
     "SearxSearchResults",
     "SearxSearchRun",
     "ShellTool",
@@ -190,9 +188,12 @@ __all__ = [
     "SlackScheduleMessage",
     "SlackSendMessage",
     "SleepTool",
-    "StdInInquireTool",
     "StackExchangeTool",
+    "StdInInquireTool",
+    "SteamWebAPIQueryRun",
     "SteamshipImageGenerationTool",
+    "StructuredTool",
+    "Tool",
     "VectorStoreQATool",
     "VectorStoreQAWithSourcesTool",
     "WikipediaQueryRun",
@@ -203,4 +204,5 @@ __all__ = [
     "ZapierNLAListActions",
     "ZapierNLARunAction",
     "format_tool_to_openai_function",
+    "tool",
 ]

langchain/tools/ainetwork/app.py

@@ -24,7 +24,7 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
+    "AINAppOps",
     "AppOperationType",
     "AppSchema",
-    "AINAppOps",
 ]

langchain/tools/ainetwork/base.py

@@ -22,6 +22,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "OperationType",
     "AINBaseTool",
+    "OperationType",
 ]

langchain/tools/ainetwork/owner.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "RuleSchema",
     "AINOwnerOps",
+    "RuleSchema",
 ]

langchain/tools/ainetwork/rule.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "RuleSchema",
     "AINRuleOps",
+    "RuleSchema",
 ]

langchain/tools/ainetwork/transfer.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "TransferSchema",
     "AINTransfer",
+    "TransferSchema",
 ]

langchain/tools/ainetwork/value.py

@@ -23,6 +23,6 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "ValueSchema",
     "AINValueOps",
+    "ValueSchema",
 ]