chainlit 1.0.401__py3-none-any.whl → 2.0.4__py3-none-any.whl

chainlit/playground/__init__.py

@@ -1,2 +0,0 @@
-from .config import add_llm_provider, get_llm_providers
-from .provider import *

chainlit/playground/config.py

@@ -1,40 +0,0 @@
-from typing import Dict
-
-from chainlit.playground.provider import BaseProvider
-from chainlit.playground.providers import (
-    Anthropic,
-    AzureChatOpenAI,
-    AzureOpenAI,
-    ChatOpenAI,
-    OpenAI,
-    ChatVertexAI,
-    GenerationVertexAI,
-    Gemini,
-)
-
-providers = {
-    AzureChatOpenAI.id: AzureChatOpenAI,
-    AzureOpenAI.id: AzureOpenAI,
-    ChatOpenAI.id: ChatOpenAI,
-    OpenAI.id: OpenAI,
-    Anthropic.id: Anthropic,
-    ChatVertexAI.id: ChatVertexAI,
-    GenerationVertexAI.id: GenerationVertexAI,
-    Gemini.id: Gemini,
-}  # type: Dict[str, BaseProvider]
-
-
-def has_llm_provider(id: str):
-    return id in providers
-
-
-def add_llm_provider(provider: BaseProvider):
-    if not provider.is_configured():
-        raise ValueError(
-            f"{provider.name} LLM provider requires the following environment variables: {', '.join(provider.env_vars.values())}"
-        )
-    providers[provider.id] = provider
-
-
-def get_llm_providers():
-    return [provider for provider in providers.values() if provider.is_configured()]

chainlit/playground/provider.py

@@ -1,108 +0,0 @@
-import os
-from typing import Any, Dict, List, Optional, Union
-
-from chainlit.config import config
-from chainlit.telemetry import trace_event
-from chainlit.types import GenerationRequest
-from fastapi import HTTPException
-from literalai import BaseGeneration, ChatGeneration, GenerationMessage
-from pydantic.dataclasses import dataclass
-
-from chainlit import input_widget
-
-
-@dataclass
-class BaseProvider:
-    id: str
-    name: str
-    env_vars: Dict[str, str]
-    inputs: List[input_widget.InputWidget]
-    is_chat: bool
-
-    # Convert the message to string format
-    def message_to_string(self, message: GenerationMessage):
-        return message["content"]
-
-    # Concatenate multiple messages with a joiner
-    def concatenate_messages(self, messages: List[GenerationMessage], joiner="\n\n"):
-        return joiner.join([self.message_to_string(m) for m in messages])
-
-    # Format the template based on the prompt inputs
-    def _format_template(self, template: str, inputs: Optional[Dict]):
-        return template.format(**(inputs or {}))
-
-    # Create a prompt based on the request
-    def create_generation(self, request: GenerationRequest):
-        if request.chatGeneration and request.chatGeneration.messages:
-            messages = request.chatGeneration.messages
-        else:
-            messages = None
-
-        if self.is_chat:
-            if messages:
-                return messages
-            elif request.completionGeneration and request.completionGeneration.prompt:
-                return [
-                    GenerationMessage(
-                        content=request.completionGeneration.prompt,
-                        role="user",
-                    ),
-                ]
-            else:
-                raise HTTPException(
-                    status_code=422, detail="Could not create generation"
-                )
-        else:
-            if request.completionGeneration:
-                return request.completionGeneration.prompt
-            elif messages:
-                return self.concatenate_messages(messages)
-            else:
-                raise HTTPException(status_code=422, detail="Could not create prompt")
-
-    # Create a completion event
-    async def create_completion(self, request: GenerationRequest):
-        trace_event("completion")
-
-    # Get the environment variable based on the request
-    def get_var(self, request: GenerationRequest, var: str) -> Union[str, None]:
-        user_env = config.project.user_env or []
-
-        if var in user_env:
-            return request.userEnv.get(var)
-        else:
-            return os.environ.get(var)
-
-    # Check if the environment variable is available
-    def _is_env_var_available(self, var: str) -> bool:
-        user_env = config.project.user_env or []
-        return var in os.environ or var in user_env
-
-    # Check if the provider is configured
-    def is_configured(self):
-        for var in self.env_vars.values():
-            if not self._is_env_var_available(var):
-                return False
-        return True
-
-    # Validate the environment variables in the request
-    def validate_env(self, request: GenerationRequest):
-        return {k: self.get_var(request, v) for k, v in self.env_vars.items()}
-
-    # Check if the required settings are present
-    def require_settings(self, settings: Dict[str, Any]):
-        for _input in self.inputs:
-            if _input.id not in settings:
-                raise HTTPException(
-                    status_code=422,
-                    detail=f"Field {_input.id} is a required setting but is not found.",
-                )
-
-    # Convert the provider to dictionary format
-    def to_dict(self):
-        return {
-            "id": self.id,
-            "name": self.name,
-            "inputs": [input_widget.to_dict() for input_widget in self.inputs],
-            "is_chat": self.is_chat,
-        }

chainlit/playground/providers/__init__.py

@@ -1,13 +0,0 @@
-from .anthropic import Anthropic
-from .huggingface import HFFlanT5
-from .openai import (
-    AzureChatOpenAI,
-    AzureOpenAI,
-    ChatOpenAI,
-    OpenAI,
-)
-from .vertexai import (
-    ChatVertexAI,
-    GenerationVertexAI,
-    Gemini
-)

chainlit/playground/providers/anthropic.py

@@ -1,118 +0,0 @@
-from chainlit.input_widget import Select, Slider, Tags
-from chainlit.playground.provider import BaseProvider
-from fastapi import HTTPException
-from fastapi.responses import StreamingResponse
-from literalai import GenerationMessage
-
-
-class AnthropicProvider(BaseProvider):
-    def message_to_string(self, message: GenerationMessage) -> str:
-        import anthropic
-
-        if message["role"] == "user":
-            message_text = f"{anthropic.HUMAN_PROMPT} {message['content']}"
-        elif message["role"] == "assistant":
-            message_text = f"{anthropic.AI_PROMPT} {message['content']}"
-        elif message["role"] == "function":
-            message_text = f"{anthropic.AI_PROMPT} {message['content']}"
-        elif message["role"] == "system":
-            message_text = (
-                f"{anthropic.HUMAN_PROMPT} <admin>{message['content']}</admin>"
-            )
-        else:
-            raise HTTPException(
-                status_code=400, detail=f"Got unknown type {message['role']}"
-            )
-        return message_text
-
-    async def create_completion(self, request):
-        await super().create_completion(request)
-        import anthropic
-
-        env_settings = self.validate_env(request=request)
-
-        llm_settings = request.generation.settings
-        self.require_settings(llm_settings)
-
-        prompt = self.concatenate_messages(self.create_generation(request), joiner="")
-
-        if not prompt.endswith(anthropic.AI_PROMPT):
-            prompt += anthropic.AI_PROMPT
-
-        client = anthropic.AsyncAnthropic(**env_settings)
-
-        llm_settings["stream"] = True
-
-        try:
-            stream = await client.completions.create(prompt=prompt, **llm_settings)
-        except anthropic.APIConnectionError as e:
-            raise HTTPException(
-                status_code=503,
-                detail=e.__cause__,
-            )
-        except anthropic.RateLimitError as e:
-            raise HTTPException(
-                status_code=429,
-            )
-        except anthropic.APIStatusError as e:
-            raise HTTPException(status_code=e.status_code, detail=e.response)
-
-        async def create_event_stream():
-            async for data in stream:
-                token = data.completion
-                yield token
-
-        return StreamingResponse(create_event_stream())
-
-
-Anthropic = AnthropicProvider(
-    id="anthropic-chat",
-    name="Anthropic",
-    env_vars={"api_key": "ANTHROPIC_API_KEY"},
-    inputs=[
-        Select(
-            id="model",
-            label="Model",
-            values=["claude-2", "claude-instant-1"],
-            initial_value="claude-2",
-        ),
-        Slider(
-            id="max_tokens_to_sample",
-            label="Max Tokens To Sample",
-            min=1.0,
-            max=100000,
-            step=1.0,
-            initial=1000,
-        ),
-        Tags(
-            id="stop_sequences",
-            label="Stop Sequences",
-            initial=[],
-        ),
-        Slider(
-            id="temperature",
-            label="Temperature",
-            min=0.0,
-            max=1.0,
-            step=0.01,
-            initial=1,
-        ),
-        Slider(
-            id="top_p",
-            label="Top P",
-            min=0.0,
-            max=1.0,
-            step=0.01,
-            initial=0.7,
-        ),
-        Slider(
-            id="top_k",
-            label="Top K",
-            min=0.0,
-            max=2048.0,
-            step=1.0,
-            initial=0,
-        ),
-    ],
-    is_chat=True,
-)

chainlit/playground/providers/huggingface.py

@@ -1,75 +0,0 @@
-from typing import Optional
-
-from chainlit.input_widget import Slider
-from chainlit.playground.provider import BaseProvider
-from chainlit.sync import make_async
-from fastapi import HTTPException
-from fastapi.responses import StreamingResponse
-from pydantic.dataclasses import dataclass
-
-
-@dataclass
-class BaseHuggingFaceProvider(BaseProvider):
-    repo_id: Optional[str] = None
-    task = "text2text-generation"
-
-    async def create_completion(self, request):
-        await super().create_completion(request)
-        from huggingface_hub.inference_api import InferenceApi
-
-        env_settings = self.validate_env(request=request)
-        llm_settings = request.generation.settings
-        self.require_settings(llm_settings)
-
-        client = InferenceApi(
-            repo_id=self.repo_id,
-            token=env_settings["api_token"],
-            task=self.task,
-        )
-
-        prompt = self.create_generation(request)
-
-        response = await make_async(client)(inputs=prompt, params=llm_settings)
-
-        if "error" in response:
-            raise HTTPException(
-                status_code=500,
-                detail=f"Error raised by inference API: {response['error']}",
-            )
-        if client.task == "text2text-generation":
-
-            def create_event_stream():
-                yield response[0]["generated_text"]
-
-            return StreamingResponse(create_event_stream())
-        else:
-            raise HTTPException(status_code=400, detail="Unsupported task")
-
-
-flan_hf_env_vars = {"api_token": "HUGGINGFACE_API_TOKEN"}
-
-HFFlanT5 = BaseHuggingFaceProvider(
-    id="huggingface_hub",
-    repo_id="declare-lab/flan-alpaca-large",
-    name="Flan Alpaca Large",
-    env_vars=flan_hf_env_vars,
-    inputs=[
-        Slider(
-            id="temperature",
-            label="Temperature",
-            min=0.0,
-            max=1.0,
-            step=0.01,
-            initial=0.9,
-        ),
-        Slider(
-            id="max_length",
-            label="Completion max length",
-            min=1.0,
-            max=5000,
-            step=1.0,
-            initial=256,
-        ),
-    ],
-    is_chat=False,
-)

chainlit/playground/providers/langchain.py

@@ -1,89 +0,0 @@
-from typing import List, Union
-
-from chainlit.input_widget import InputWidget
-from chainlit.playground.provider import BaseProvider
-from chainlit.sync import make_async
-from fastapi.responses import StreamingResponse
-from literalai import GenerationMessage
-
-
-class LangchainGenericProvider(BaseProvider):
-    from langchain.chat_models.base import BaseChatModel
-    from langchain.llms.base import LLM
-    from langchain.schema import BaseMessage
-
-    llm: Union[LLM, BaseChatModel]
-
-    def __init__(
-        self,
-        id: str,
-        name: str,
-        llm: Union[LLM, BaseChatModel],
-        inputs: List[InputWidget] = [],
-        is_chat: bool = False,
-    ):
-        super().__init__(
-            id=id,
-            name=name,
-            env_vars={},
-            inputs=inputs,
-            is_chat=is_chat,
-        )
-        self.llm = llm
-
-    def prompt_message_to_langchain_message(self, message: GenerationMessage):
-        from langchain.schema.messages import (
-            AIMessage,
-            FunctionMessage,
-            HumanMessage,
-            SystemMessage,
-        )
-
-        content = "" if message["content"] is None else message["content"]
-        if message["role"] == "user":
-            return HumanMessage(content=content)  # type: ignore
-        elif message["role"] == "assistant":
-            return AIMessage(content=content)  # type: ignore
-        elif message["role"] == "system":
-            return SystemMessage(content=content)  # type: ignore
-        elif message["role"] == "tool":
-            return FunctionMessage(
-                content=content,  # type: ignore
-                name=message["name"] if message["name"] else "function",
-            )
-        else:
-            raise ValueError(f"Got unknown type {message['role']}")
-
-    def format_message(self, message, prompt):
-        message = super().format_message(message, prompt)
-        return self.prompt_message_to_langchain_message(message)
-
-    def message_to_string(self, message: BaseMessage) -> str:  # type: ignore[override]
-        return str(getattr(message, "content", ""))
-
-    async def create_completion(self, request):
-        from langchain.schema.messages import BaseMessageChunk
-
-        await super().create_completion(request)
-
-        messages = self.create_generation(request)
-
-        # https://github.com/langchain-ai/langchain/issues/14980
-        result = await make_async(self.llm.stream)(
-            input=messages, **request.generation.settings
-        )
-
-        def create_event_stream():
-            try:
-                for chunk in result:
-                    if isinstance(chunk, BaseMessageChunk):
-                        yield chunk.content
-                    else:
-                        yield chunk
-            except Exception as e:
-                # The better solution would be to return a 500 error, but
-                # langchain raises the error in the stream, and the http
-                # headers have already been sent.
-                yield f"Failed to create completion: {str(e)}"
-
-        return StreamingResponse(create_event_stream())