chainlit 0.2.110__py3-none-any.whl → 0.3.0__py3-none-any.whl

chainlit/frontend/dist/assets/index-bdffdaa0.css

@@ -1 +0,0 @@
-.markdown-body *:first-child{margin-top:0}.markdown-body *:last-child{margin-bottom:0}.markdown-body p{white-space:break-spaces}.DraftEditor-editorContainer,.DraftEditor-root,.public-DraftEditor-content{height:inherit;text-align:initial}.public-DraftEditor-content[contenteditable=true]{-webkit-user-modify:read-write-plaintext-only}.DraftEditor-root{position:relative}.DraftEditor-editorContainer{background-color:#fff0;border-left:.1px solid transparent;position:relative;z-index:1}.public-DraftEditor-block{position:relative}.DraftEditor-alignLeft .public-DraftStyleDefault-block{text-align:left}.DraftEditor-alignLeft .public-DraftEditorPlaceholder-root{left:0;text-align:left}.DraftEditor-alignCenter .public-DraftStyleDefault-block{text-align:center}.DraftEditor-alignCenter .public-DraftEditorPlaceholder-root{margin:0 auto;text-align:center;width:100%}.DraftEditor-alignRight .public-DraftStyleDefault-block{text-align:right}.DraftEditor-alignRight .public-DraftEditorPlaceholder-root{right:0;text-align:right}.public-DraftEditorPlaceholder-root{color:#9197a3;position:absolute;width:100%;z-index:1}.public-DraftEditorPlaceholder-hasFocus{color:#bdc1c9}.DraftEditorPlaceholder-hidden{display:none}.public-DraftStyleDefault-block{position:relative;white-space:pre-wrap}.public-DraftStyleDefault-ltr{direction:ltr;text-align:left}.public-DraftStyleDefault-rtl{direction:rtl;text-align:right}.public-DraftStyleDefault-listLTR{direction:ltr}.public-DraftStyleDefault-listRTL{direction:rtl}.public-DraftStyleDefault-ol,.public-DraftStyleDefault-ul{margin:16px 0;padding:0}.public-DraftStyleDefault-depth0.public-DraftStyleDefault-listLTR{margin-left:1.5em}.public-DraftStyleDefault-depth0.public-DraftStyleDefault-listRTL{margin-right:1.5em}.public-DraftStyleDefault-depth1.public-DraftStyleDefault-listLTR{margin-left:3em}.public-DraftStyleDefault-depth1.public-DraftStyleDefault-listRTL{margin-right:3em}.public-DraftStyleDefault-depth2.public-DraftStyleDefault-listLTR{margin-left:4.5em}.public-DraftStyleDefault-depth2.public-DraftStyleDefault-listRTL{margin-right:4.5em}.public-DraftStyleDefault-depth3.public-DraftStyleDefault-listLTR{margin-left:6em}.public-DraftStyleDefault-depth3.public-DraftStyleDefault-listRTL{margin-right:6em}.public-DraftStyleDefault-depth4.public-DraftStyleDefault-listLTR{margin-left:7.5em}.public-DraftStyleDefault-depth4.public-DraftStyleDefault-listRTL{margin-right:7.5em}.public-DraftStyleDefault-unorderedListItem{list-style-type:square;position:relative}.public-DraftStyleDefault-unorderedListItem.public-DraftStyleDefault-depth0{list-style-type:disc}.public-DraftStyleDefault-unorderedListItem.public-DraftStyleDefault-depth1{list-style-type:circle}.public-DraftStyleDefault-orderedListItem{list-style-type:none;position:relative}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-listLTR:before{left:-36px;position:absolute;text-align:right;width:30px}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-listRTL:before{position:absolute;right:-36px;text-align:left;width:30px}.public-DraftStyleDefault-orderedListItem:before{content:counter(ol0) ". ";counter-increment:ol0}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-depth1:before{content:counter(ol1,lower-alpha) ". ";counter-increment:ol1}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-depth2:before{content:counter(ol2,lower-roman) ". ";counter-increment:ol2}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-depth3:before{content:counter(ol3) ". ";counter-increment:ol3}.public-DraftStyleDefault-orderedListItem.public-DraftStyleDefault-depth4:before{content:counter(ol4,lower-alpha) ". ";counter-increment:ol4}.public-DraftStyleDefault-depth0.public-DraftStyleDefault-reset{counter-reset:ol0}.public-DraftStyleDefault-depth1.public-DraftStyleDefault-reset{counter-reset:ol1}.public-DraftStyleDefault-depth2.public-DraftStyleDefault-reset{counter-reset:ol2}.public-DraftStyleDefault-depth3.public-DraftStyleDefault-reset{counter-reset:ol3}.public-DraftStyleDefault-depth4.public-DraftStyleDefault-reset{counter-reset:ol4}body{margin:0;padding:0;font-family:Public Sans,sans-serif;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}code{font-family:source-code-pro,Menlo,Monaco,Consolas,Courier New,monospace}

chainlit/lc/chainlit_handler.py

@@ -1,271 +0,0 @@
-from typing import Any, Dict, List, Optional, Union
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.schema import AgentAction, AgentFinish, LLMResult
-from chainlit.sdk import get_sdk, Chainlit
-from chainlit.message import Message, ErrorMessage
-from chainlit.config import config
-from chainlit.types import LLMSettings
-
-IGNORE_LIST = ["AgentExecutor"]
-
-
-class ChainlitCallbackHandler(BaseCallbackHandler):
-    # Keep track of the formatted prompts to display them in the prompt playground.
-    prompts_per_session: Dict[str, List[str]]
-    # Keep track of the LLM settings for the last prompt
-    llm_settings_per_session: Dict[str, LLMSettings]
-    # Keep track of the call sequence, like [AgentExecutor, LLMMathChain, Calculator, ...]
-    sequence_per_session: Dict[str, List[str]]
-    # Keep track of the last prompt for each session
-    last_prompt_per_session: Dict[str, Union[str, None]]
-    # Keep track of the currently streamed message for the session
-    stream_per_session: Dict[str, Message]
-
-    # We want to handler to be called on every message
-    always_verbose: bool = True
-
-    def __init__(self) -> None:
-        # Initialize dictionaries to store session data
-        self.prompts_per_session = {}
-        self.llm_settings_per_session = {}
-        self.sequence_per_session = {}
-        self.last_prompt_per_session = {}
-        self.stream_per_session = {}
-
-    def get_streamed_message(self) -> Union[Message, None]:
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-        return self.stream_per_session.get(session_id, None)
-
-    def start_stream(self):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-        author, indent, llm_settings = self.get_message_params(sdk)
-
-        if author in IGNORE_LIST:
-            return
-        streamed_message = Message(
-            author=author, indent=indent, llm_settings=llm_settings, content=""
-        )
-        self.stream_per_session[session_id] = streamed_message
-
-    def send_token(self, token: str):
-        streamed_message = self.get_streamed_message()
-        if streamed_message:
-            streamed_message.stream_token(token)
-
-    def end_stream(self):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-        del self.stream_per_session[session_id]
-
-    def add_in_sequence(self, name: str):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-
-        # Initialize session sequences if not already present
-        if session_id not in self.sequence_per_session:
-            self.sequence_per_session[session_id] = []
-
-        sequence = self.sequence_per_session[session_id]
-
-        sequence.append(name)
-
-    def pop_sequence(self):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-
-        # Remove the last element from the sequences
-        if (
-            session_id in self.sequence_per_session
-            and self.sequence_per_session[session_id]
-        ):
-            self.sequence_per_session[session_id].pop()
-
-    def add_prompt(self, prompt: str, llm_settings: LLMSettings = None):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-
-        # Initialize session prompts if not already present
-        if session_id not in self.prompts_per_session:
-            self.prompts_per_session[session_id] = []
-
-        self.prompts_per_session[session_id].append(prompt)
-
-        if llm_settings:
-            self.llm_settings_per_session[session_id] = llm_settings
-
-    def pop_prompt(self):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-
-        # Remove the last prompt from the session
-        if (
-            session_id in self.prompts_per_session
-            and self.prompts_per_session[session_id]
-        ):
-            self.last_prompt_per_session[session_id] = self.prompts_per_session[
-                session_id
-            ].pop()
-
-    def consume_last_prompt(self):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        session_id = sdk.session["id"]
-
-        last_prompt = self.last_prompt_per_session.get(session_id)
-        self.last_prompt_per_session[session_id] = None
-        return last_prompt
-
-    def get_message_params(self, sdk: Chainlit):
-        llm_settings = self.llm_settings_per_session.get(sdk.session["id"])
-
-        sequence = self.sequence_per_session.get(sdk.session["id"])
-
-        indent = len(sequence) if sequence else 0
-
-        if sequence:
-            if config.lc_rename:
-                author = config.lc_rename(sequence[-1])
-            else:
-                author = sequence[-1]
-        else:
-            author = config.chatbot_name
-
-        return author, indent, llm_settings
-
-    def add_message(self, message, prompt: str = None, error=False):
-        sdk = get_sdk()
-        if not sdk:
-            return
-
-        author, indent, llm_settings = self.get_message_params(sdk)
-
-        if author in IGNORE_LIST:
-            return
-
-        if error:
-            ErrorMessage(author=author, content=message).send()
-            self.end_stream()
-            return
-
-        streamed_message = self.get_streamed_message()
-
-        if streamed_message:
-            streamed_message.prompt = prompt
-            streamed_message.llm_settings = llm_settings
-            streamed_message.send()
-            self.end_stream()
-        else:
-            Message(
-                author=author,
-                content=message,
-                indent=indent,
-                prompt=prompt,
-                llm_settings=llm_settings,
-            ).send()
-
-    # Callbacks for various events
-
-    def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
-    ) -> None:
-        self.add_prompt(prompts[0], kwargs.get("llm_settings"))
-
-    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
-        if not self.get_streamed_message():
-            self.start_stream()
-        self.send_token(token)
-
-    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
-        self.pop_prompt()
-        sdk = get_sdk()
-        if not sdk:
-            return
-        if response.llm_output is not None:
-            if "token_usage" in response.llm_output:
-                token_usage = response.llm_output["token_usage"]
-                if "total_tokens" in token_usage:
-                    sdk.update_token_count(token_usage["total_tokens"])
-
-    def on_llm_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        pass
-
-    def on_chain_start(
-        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
-    ) -> None:
-        self.add_in_sequence(serialized["name"])
-        # Useful to display details button in the UI
-        self.add_message("")
-
-    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
-        output_key = list(outputs.keys())[0]
-        if output_key:
-            prompt = self.consume_last_prompt()
-            self.add_message(outputs[output_key], prompt)
-        self.pop_sequence()
-
-    def on_chain_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        self.add_message(str(error), error=True)
-        self.pop_sequence()
-
-    def on_tool_start(
-        self, serialized: Dict[str, Any], inputs: Any, **kwargs: Any
-    ) -> None:
-        self.add_in_sequence(serialized["name"])
-        self.add_message("")
-
-    def on_tool_end(
-        self,
-        output: str,
-        observation_prefix: Optional[str] = None,
-        llm_prefix: Optional[str] = None,
-        **kwargs: Any,
-    ) -> None:
-        prompt = self.consume_last_prompt()
-        self.add_message(output, prompt)
-        self.pop_sequence()
-
-    def on_tool_error(
-        self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
-    ) -> None:
-        """Do nothing."""
-        self.add_message(str(error), error=True)
-        self.pop_sequence()
-
-    def on_text(self, text: str, **kwargs: Any) -> None:
-        pass
-
-    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
-        pass
-
-    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
-        """Run on agent end."""
-        pass

chainlit/lc/monkey.py

@@ -1,28 +0,0 @@
-import os
-from chainlit.config import config
-from chainlit.logger import logger
-
-
-# Check if LangChain is installed and set up cache and callback handler
-def patch():
-    try:
-        import langchain
-        from langchain.cache import SQLiteCache
-
-        if config.lc_cache_path:
-            langchain.llm_cache = SQLiteCache(database_path=config.lc_cache_path)
-            if not os.path.exists(config.lc_cache_path):
-                logger.info(f"LangChain cache enabled: {config.lc_cache_path}")
-
-        # New callback handler architecture
-        if langchain.__version__ > "0.0.153":
-            import chainlit.lc.new_monkey
-        # Old callback handler architecture
-        else:
-            import chainlit.lc.old_monkey
-
-        LANGCHAIN_INSTALLED = True
-    except ImportError:
-        LANGCHAIN_INSTALLED = False
-
-    return LANGCHAIN_INSTALLED

chainlit/lc/new_monkey.py

@@ -1,167 +0,0 @@
-import inspect
-import langchain
-from typing import List, Optional
-from langchain.llms.base import BaseLLM, update_cache, get_prompts
-from langchain.chat_models.base import BaseChatModel
-from langchain.schema import (
-    LLMResult,
-)
-from langchain.callbacks.manager import (
-    CallbackManager,
-    Callbacks,
-)
-from langchain.schema import (
-    BaseMessage,
-    LLMResult,
-    get_buffer_string,
-)
-from chainlit.lc.utils import get_llm_settings
-from chainlit.lc.chainlit_handler import ChainlitCallbackHandler
-
-# Monkey patch LangChain > 0.0.153
-chainlit_handler = ChainlitCallbackHandler()
-
-orig_configure = CallbackManager.configure
-
-
-def patched_configure(
-    inheritable_callbacks: Callbacks = None,
-    local_callbacks: Callbacks = None,
-    verbose: bool = False,
-):
-    cbm = orig_configure(inheritable_callbacks, local_callbacks, verbose)
-    cbm.add_handler(chainlit_handler, False)
-    return cbm
-
-
-CallbackManager.configure = patched_configure
-
-
-def patched_generate(
-    self,
-    prompts: List[str],
-    stop: Optional[List[str]] = None,
-    callbacks: Callbacks = None,
-) -> LLMResult:
-    """Run the LLM on the given prompt and input."""
-    # If string is passed in directly no errors will be raised but outputs will
-    # not make sense.
-    if not isinstance(prompts, list):
-        raise ValueError(
-            "Argument 'prompts' is expected to be of type List[str], received"
-            f" argument of type {type(prompts)}."
-        )
-    # PATCH
-    llm_settings = get_llm_settings(self, stop)
-    disregard_cache = self.cache is not None and not self.cache
-    callback_manager = CallbackManager.configure(
-        callbacks, self.callbacks, self.verbose
-    )
-    new_arg_supported = inspect.signature(self._generate).parameters.get("run_manager")
-    if langchain.llm_cache is None or disregard_cache:
-        # This happens when langchain.cache is None, but self.cache is True
-        if self.cache is not None and self.cache:
-            raise ValueError("Asked to cache, but no cache found at `langchain.cache`.")
-        # PATCH
-        run_manager = callback_manager.on_llm_start(
-            {"name": self.__class__.__name__}, prompts, llm_settings=llm_settings
-        )
-        try:
-            output = (
-                self._generate(prompts, stop=stop, run_manager=run_manager)
-                if new_arg_supported
-                else self._generate(prompts, stop=stop)
-            )
-        except (KeyboardInterrupt, Exception) as e:
-            run_manager.on_llm_error(e)
-            raise e
-        run_manager.on_llm_end(output)
-        return output
-    params = self.dict()
-    params["stop"] = stop
-    (
-        existing_prompts,
-        llm_string,
-        missing_prompt_idxs,
-        missing_prompts,
-    ) = get_prompts(params, prompts)
-    if len(missing_prompts) > 0:
-        # PATCH
-        run_manager = callback_manager.on_llm_start(
-            {"name": self.__class__.__name__},
-            missing_prompts,
-            llm_settings=llm_settings,
-        )
-        try:
-            new_results = (
-                self._generate(missing_prompts, stop=stop, run_manager=run_manager)
-                if new_arg_supported
-                else self._generate(missing_prompts, stop=stop)
-            )
-        except (KeyboardInterrupt, Exception) as e:
-            run_manager.on_llm_error(e)
-            raise e
-        run_manager.on_llm_end(new_results)
-        llm_output = update_cache(
-            existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
-        )
-    else:
-        # PATCH
-        run_manager = callback_manager.on_llm_start(
-            {"name": self.__class__.__name__},
-            prompts,
-            verbose=self.verbose,
-            llm_settings=llm_settings,
-        )
-        llm_output = {}
-        run_manager.on_llm_end(
-            LLMResult(generations=[], llm_output=llm_output), verbose=self.verbose
-        )
-
-    generations = [existing_prompts[i] for i in range(len(prompts))]
-    return LLMResult(generations=generations, llm_output=llm_output)
-
-
-BaseLLM.generate = patched_generate
-
-
-def patched_chat_generate(
-    self,
-    messages: List[List[BaseMessage]],
-    stop: Optional[List[str]] = None,
-    callbacks: Callbacks = None,
-) -> LLMResult:
-    """Top Level call"""
-
-    # PATCH
-    llm_settings = get_llm_settings(self, stop)
-
-    callback_manager = CallbackManager.configure(
-        callbacks, self.callbacks, self.verbose
-    )
-    message_strings = [get_buffer_string(m) for m in messages]
-
-    # PATCH
-    run_manager = callback_manager.on_llm_start(
-        {"name": self.__class__.__name__}, message_strings, llm_settings=llm_settings
-    )
-
-    new_arg_supported = inspect.signature(self._generate).parameters.get("run_manager")
-    try:
-        results = [
-            self._generate(m, stop=stop, run_manager=run_manager)
-            if new_arg_supported
-            else self._generate(m, stop=stop)
-            for m in messages
-        ]
-    except (KeyboardInterrupt, Exception) as e:
-        run_manager.on_llm_error(e)
-        raise e
-    llm_output = self._combine_llm_outputs([res.llm_output for res in results])
-    generations = [res.generations for res in results]
-    output = LLMResult(generations=generations, llm_output=llm_output)
-    run_manager.on_llm_end(output)
-    return output
-
-
-BaseChatModel.generate = patched_chat_generate

chainlit/lc/old_monkey.py

@@ -1,119 +0,0 @@
-import langchain
-from typing import List, Optional
-from langchain.llms import base as llm_base
-from langchain.chat_models.base import BaseChatModel
-from langchain.schema import (
-    LLMResult,
-    PromptValue,
-)
-from langchain.callbacks import get_callback_manager
-from chainlit.lc.chainlit_handler import ChainlitCallbackHandler
-from chainlit.lc.utils import get_llm_settings
-
-# Monkey patch LangChain <= 0.0.153
-
-
-def patched_generate(
-    self: llm_base.BaseLLM, prompts: List[str], stop: Optional[List[str]] = None
-) -> LLMResult:
-    """Run the LLM on the given prompt and input."""
-    # If string is passed in directly no errors will be raised but outputs will
-    # not make sense.
-
-    if not isinstance(prompts, list):
-        raise ValueError(
-            "Argument 'prompts' is expected to be of type List[str], received"
-            f" argument of type {type(prompts)}."
-        )
-    # PATCH
-    llm_settings = get_llm_settings(self, stop)
-    disregard_cache = self.cache is not None and not self.cache
-    if langchain.llm_cache is None or disregard_cache:
-        # This happens when langchain.cache is None, but self.cache is True
-        if self.cache is not None and self.cache:
-            raise ValueError("Asked to cache, but no cache found at `langchain.cache`.")
-        self.callback_manager.on_llm_start(
-            {"name": self.__class__.__name__},
-            prompts,
-            verbose=self.verbose,
-            llm_settings=llm_settings,
-        )
-        try:
-            output = self._generate(prompts, stop=stop)
-        except (KeyboardInterrupt, Exception) as e:
-            self.callback_manager.on_llm_error(e, verbose=self.verbose)
-            raise e
-        self.callback_manager.on_llm_end(output, verbose=self.verbose)
-        return output
-    params = self.dict()
-    params["stop"] = stop
-    (
-        existing_prompts,
-        llm_string,
-        missing_prompt_idxs,
-        missing_prompts,
-    ) = llm_base.get_prompts(params, prompts)
-
-    if len(missing_prompts) > 0:
-        self.callback_manager.on_llm_start(
-            {"name": self.__class__.__name__},
-            missing_prompts,
-            verbose=self.verbose,
-            llm_settings=llm_settings,
-        )
-        try:
-            new_results = self._generate(missing_prompts, stop=stop)
-        except (KeyboardInterrupt, Exception) as e:
-            self.callback_manager.on_llm_error(e, verbose=self.verbose)
-            raise e
-        self.callback_manager.on_llm_end(new_results, verbose=self.verbose)
-        llm_output = llm_base.update_cache(
-            existing_prompts, llm_string, missing_prompt_idxs, new_results, prompts
-        )
-    else:
-        # PATCH
-        self.callback_manager.on_llm_start(
-            {"name": self.__class__.__name__},
-            prompts,
-            verbose=self.verbose,
-            llm_settings=llm_settings,
-        )
-        llm_output = {}
-        self.callback_manager.on_llm_end(
-            LLMResult(generations=[], llm_output=llm_output), verbose=self.verbose
-        )
-    generations = [existing_prompts[i] for i in range(len(prompts))]
-    return LLMResult(generations=generations, llm_output=llm_output)
-
-
-llm_base.BaseLLM.generate = patched_generate
-
-
-def patched_generate_prompt(
-    self, prompts: List[PromptValue], stop: Optional[List[str]] = None
-) -> LLMResult:
-    prompt_messages = [p.to_messages() for p in prompts]
-    prompt_strings = [p.to_string() for p in prompts]
-
-    # PATCH
-    llm_settings = get_llm_settings(self, stop)
-    self.callback_manager.on_llm_start(
-        {"name": self.__class__.__name__},
-        prompt_strings,
-        verbose=self.verbose,
-        llm_settings=llm_settings,
-    )
-
-    try:
-        output = self.generate(prompt_messages, stop=stop)
-    except (KeyboardInterrupt, Exception) as e:
-        self.callback_manager.on_llm_error(e, verbose=self.verbose)
-        raise e
-    self.callback_manager.on_llm_end(output, verbose=self.verbose)
-    return output
-
-
-BaseChatModel.generate_prompt = patched_generate_prompt
-
-
-get_callback_manager()._callback_manager.add_handler(ChainlitCallbackHandler())

chainlit/lc/utils.py

@@ -1,38 +0,0 @@
-from typing import Any
-from chainlit.types import LLMSettings
-from typing import List, Optional
-
-
-def run_langchain_agent(agent: Any, input_str: str):
-    if hasattr(agent, "input_keys"):
-        input_key = agent.input_keys[0]
-        raw_res = agent({input_key: input_str})
-    else:
-        raw_res = agent(input_str)
-
-    if hasattr(agent, "output_keys"):
-        output_key = agent.output_keys[0]
-    else:
-        output_key = None
-
-    return raw_res, output_key
-
-
-def get_llm_settings(llm, stop: Optional[List[str]] = None):
-    if llm.__class__.__name__ == "OpenAI":
-        return LLMSettings(
-            model_name=llm.model_name,
-            stop=stop,
-            temperature=llm.temperature,
-            max_tokens=llm.max_tokens,
-            top_p=llm.top_p,
-            frequency_penalty=llm.frequency_penalty,
-            presence_penalty=llm.presence_penalty,
-        )
-    elif llm.__class__.__name__ == "ChatOpenAI":
-        return LLMSettings(
-            model_name=llm.model_name,
-            stop=stop,
-        )
-    else:
-        return None

chainlit/watch.py

@@ -1,54 +0,0 @@
-import os
-from watchdog_gevent.observers import GeventObserver
-from watchdog.events import FileSystemEventHandler
-from chainlit.config import config, load_module
-from chainlit.server import socketio
-from chainlit.logger import logger
-
-last_modified_time = 0
-is_watching = False
-
-
-class ChangeHandler(FileSystemEventHandler):
-    def on_modified(self, event):
-        global last_modified_time
-
-        # Get the modified time of the file
-        statbuf = os.stat(event.src_path)
-        current_modified_time = statbuf.st_mtime
-
-        file_ext = os.path.splitext(event.src_path)[1]
-
-        if not file_ext in [".py", ".md"]:
-            return
-
-        # Check if the file was modified more than 0.5 seconds ago
-        if (current_modified_time - last_modified_time) > 0.5:
-            logger.info(f"event type: {event.event_type} path : {event.src_path}")
-
-            # Load the module if the module name is specified in the config
-            if config.module_name:
-                load_module(config.module_name)
-
-            # Emit a "reload" event to the socket
-            socketio.emit("reload", {})
-
-        last_modified_time = current_modified_time
-
-
-def watch_directory():
-    global is_watching
-
-    # Return if already watching
-    if is_watching:
-        return
-
-    is_watching = True
-    event_handler = ChangeHandler()
-    observer = GeventObserver()
-
-    # Schedule the observer to watch the directory recursively
-    observer.schedule(event_handler, config.root, recursive=True)
-
-    # Start the observer
-    observer.start()