Add FakePromptCopyLLM and FakeStaticLLM

[aruno14]

Hello,

First, thank you for your work.
In one of my project I had to create two FakeLLM. I think it could be useful for other users, so I share it here. If you think it can be useful, you can add it to the library.

• FakeStaticLLM: Output always the same string.
• FakePromptCopyLLM: Output the prompt.

I put complete fape.py below.

"""Fake LLM wrapper for testing purposes."""
from typing import Any, List, Mapping, Optional

from langchain.llms.base import LLM

class FakeStaticLLM(LLM):
    """Fake Static LLM wrapper for testing purposes."""

    response:str

    @property
    def _llm_type(self) -> str:
        """Return type of llm."""
        return "fake-static"

    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
        """Return static response."""
        return self.response

    @property
    def _identifying_params(self) -> Mapping[str, Any]:
        return {}
    

class FakePromptCopyLLM(LLM):
    """Fake Prompt Copy LLM wrapper for testing purposes."""

    @property
    def _llm_type(self) -> str:
        """Return type of llm."""
        return "fake-prompt-copy"

    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
        """Return prompt."""
        return prompt

    @property
    def _identifying_params(self) -> Mapping[str, Any]:
        return {}

class FakeListLLM(LLM):
    """Fake LLM wrapper for testing purposes."""

    responses: List
    i: int = 0

    @property
    def _llm_type(self) -> str:
        """Return type of llm."""
        return "fake-list"

    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
        """First try to lookup in queries, else return 'foo' or 'bar'."""
        response = self.responses[self.i]
        self.i += 1
        return response

    @property
    def _identifying_params(self) -> Mapping[str, Any]:
        return {}

[frangin2003]

This is a very good idea. Using FakeListLLM only, Langchain is still using the tools so a good way to verify an approach without harnessing (and paying) APIs like OpenAI