langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/smith/evaluation/string_run_evaluator.py

@@ -16,6 +16,7 @@ from langchain_core.load.serializable import Serializable
 from langchain_core.messages import BaseMessage, get_buffer_string, messages_from_dict
 from langsmith import EvaluationResult, RunEvaluator
 from langsmith.schemas import DataType, Example, Run
+from typing_extensions import override
 
 from langchain.chains.base import Chain
 from langchain.evaluation.schema import StringEvaluator
@@ -28,8 +29,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 +47,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,11 +64,22 @@ 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:
+        """Serialize inputs.
+
+        Args:
+            inputs: The inputs from the run, expected to contain prompts or messages.
+        Returns:
+            The serialized input text from the prompts or messages.
+        Raises:
+            ValueError: If neither prompts nor messages are found in the inputs.
+        """
         if "prompts" in inputs:  # Should we even accept this?
             input_ = "\n\n".join(inputs["prompts"])
         elif "prompt" in inputs:
@@ -75,15 +87,30 @@ 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:
+        """Serialize outputs.
+
+        Args:
+            outputs: The outputs from the run, expected to contain generations.
+
+        Returns:
+            The serialized output text from the first generation.
+
+        Raises:
+            ValueError: If no generations are found in the outputs,
+            or if the generations are empty.
+        """
         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 +125,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,53 +161,57 @@ 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):
     """Map an input to the tool."""
 
+    @override
     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 +233,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)
 
 
@@ -254,10 +279,12 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
     """The evaluation chain."""
 
     @property
+    @override
     def input_keys(self) -> list[str]:
         return ["run", "example"]
 
     @property
+    @override
     def output_keys(self) -> list[str]:
         return ["feedback"]
 
@@ -271,16 +298,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
@@ -325,6 +355,7 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
             feedback.evaluator_info[RUN_KEY] = output[RUN_KEY]
         return feedback
 
+    @override
     def evaluate_run(
         self,
         run: Run,
@@ -342,6 +373,7 @@ class StringRunEvaluatorChain(Chain, RunEvaluator):
                 # TODO: Add run ID once we can declare it via callbacks
             )
 
+    @override
     async def aevaluate_run(
         self,
         run: Run,
@@ -351,7 +383,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 +435,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 +450,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

@@ -46,6 +46,7 @@ class EncoderBackedStore(BaseStore[K, V]):
         store.mset([(1, 3.14), (2, 2.718)])
         values = store.mget([1, 2])  # Retrieves [3.14, 2.718]
         store.mdelete([1, 2])  # Deletes the keys 1 and 2
+
     """
 
     def __init__(
@@ -106,7 +107,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 +117,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",
 ]