Upload 21 files

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+WORKDIR $HOME/app
+COPY --chown=user . $HOME/app
+COPY ./requirements.txt ~/app/requirements.txt
+RUN pip install -r requirements.txt
+COPY . .
+CMD ["chainlit", "run", "app.py", "--port", "7860"]

app.py

@@ -0,0 +1,216 @@
+import openai
+import json
+import ast
+import os
+import chainlit as cl
+from functions.FunctionManager import FunctionManager
+import inspect
+import os
+import tiktoken
+import importlib
+import json
+from chainlit import user_session
+
+# Get all subdirectories under the 'plugins' directory, ignoring directories named '__pycache__'
+plugin_dirs = [d for d in os.listdir('plugins')
+               if os.path.isdir(os.path.join('plugins', d)) and d != '__pycache__']
+
+functions = []
+
+# Iterate through each subdirectory (i.e., each plugin)
+for dir in plugin_dirs:
+    # Try to read the plugin's configuration file
+    try:
+        with open(f'plugins/{dir}/config.json', 'r') as f:
+            config = json.load(f)
+        enabled = config.get('enabled', True)
+    except FileNotFoundError:
+        # If the configuration file does not exist, we assume this plugin should be imported
+        enabled = True
+
+    # Check if this plugin should be imported
+    if not enabled:
+        continue
+
+    # Dynamically import each plugin's functions module
+    module = importlib.import_module(f'plugins.{dir}.functions')
+
+    # Get all functions in the module and add them to the functions list
+    functions.extend([
+        obj for name, obj in inspect.getmembers(module)
+        if inspect.isfunction(obj)
+    ])
+
+function_manager = FunctionManager(functions=functions)
+print("functions:", function_manager.generate_functions_array())
+
+max_tokens = 5000
+
+
+def __truncate_conversation(conversation) -> None:
+    """
+    Truncate the conversation
+    """
+    # Take the first one out
+    system_con = conversation[0]
+    # Remove the first one
+    conversation = conversation[1:]
+    while True:
+        if (get_token_count(conversation) > max_tokens
+                and len(conversation) > 1):
+            # Don't remove the first message
+            conversation.pop(1)
+        else:
+            break
+    # Add the first one back
+    conversation.insert(0, system_con)
+    return conversation
+
+# https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb
+
+
+def get_token_count(conversation) -> int:
+    """
+    Get token count
+    """
+    encoding = tiktoken.encoding_for_model('gpt-3.5-turbo')
+
+    num_tokens = 0
+    for message in conversation:
+        # every message follows <im_start>{role/name}\n{content}<im_end>\n
+        num_tokens += 4
+        for key, value in message.items():
+            num_tokens += len(encoding.encode(str(value)))
+            if key == "name":  # if there's a name, the role is omitted
+                num_tokens += -1  # role is always required and always 1 token
+    num_tokens += 2  # every reply is primed with <im_start>assistant
+    return num_tokens
+
+
+MAX_ITER = 5
+
+
+async def on_message(user_message: object):
+    print("==================================")
+    print(user_message)
+    print("==================================")
+    user_message = str(user_message)
+    message_history = cl.user_session.get("message_history")
+    message_history.append({"role": "user", "content": user_message})
+
+    cur_iter = 0
+
+    while cur_iter < MAX_ITER:
+
+        # OpenAI call
+        openai_message = {"role": "", "content": ""}
+        function_ui_message = None
+        content_ui_message = cl.Message(content="")
+        stream_resp = None
+        send_message = __truncate_conversation(message_history)
+        try:
+            async for stream_resp in await openai.ChatCompletion.acreate(
+                    model="gpt-3.5-turbo",
+                    messages=send_message,
+                    stream=True,
+                    function_call="auto",
+                    functions=function_manager.generate_functions_array(),
+                    temperature=0.3
+            ):  # type: ignore
+                new_delta = stream_resp.choices[0]["delta"]
+                openai_message, content_ui_message, function_ui_message = await process_new_delta(
+                    new_delta, openai_message, content_ui_message,
+                    function_ui_message)
+        except Exception as e:
+            print(e)
+            cur_iter += 1
+            continue
+
+        if stream_resp is None:
+            break
+
+        message_history.append(openai_message)
+        if function_ui_message is not None:
+            await function_ui_message.send()
+
+        if stream_resp.choices[0]["finish_reason"] == "stop":
+            break
+        elif stream_resp.choices[0]["finish_reason"] != "function_call":
+            raise ValueError(stream_resp.choices[0]["finish_reason"])
+        # if code arrives here, it means there is a function call
+        function_name = openai_message.get("function_call").get("name")
+        print(openai_message.get("function_call"))
+        try:
+            arguments = json.loads(
+                openai_message.get("function_call").get("arguments"))
+        except:
+            arguments = ast.literal_eval(
+                openai_message.get("function_call").get("arguments"))
+
+        function_response = await function_manager.call_function(
+            function_name, arguments)
+        # print(function_response)
+
+        message_history.append({
+            "role": "function",
+            "name": function_name,
+            "content": function_response,
+        })
+
+        await cl.Message(
+            author=function_name,
+            content=str(function_response),
+            language="json",
+            indent=1,
+        ).send()
+        cur_iter += 1
+
+
+async def process_new_delta(new_delta, openai_message, content_ui_message,
+                            function_ui_message):
+    if "role" in new_delta:
+        openai_message["role"] = new_delta["role"]
+    if "content" in new_delta:
+        new_content = new_delta.get("content") or ""
+        openai_message["content"] += new_content
+        await content_ui_message.stream_token(new_content)
+    if "function_call" in new_delta:
+        if "name" in new_delta["function_call"]:
+            openai_message["function_call"] = {
+                "name": new_delta["function_call"]["name"]
+            }
+            await content_ui_message.send()
+            function_ui_message = cl.Message(
+                author=new_delta["function_call"]["name"],
+                content="",
+                indent=1,
+                language="json")
+            await function_ui_message.stream_token(
+                new_delta["function_call"]["name"])
+
+        if "arguments" in new_delta["function_call"]:
+            if "arguments" not in openai_message["function_call"]:
+                openai_message["function_call"]["arguments"] = ""
+            openai_message["function_call"]["arguments"] += new_delta[
+                "function_call"]["arguments"]
+            await function_ui_message.stream_token(
+                new_delta["function_call"]["arguments"])
+    return openai_message, content_ui_message, function_ui_message
+
+
+@cl.on_chat_start
+def start_chat():
+    cl.user_session.set(
+        "message_history",
+        [{
+            "role": "system",
+            "content": """
+                you are now chatting with an AI assistant. The assistant is helpful, creative, clever, and very friendly.
+            """
+        }],
+    )
+
+
+@cl.on_message
+async def run_conversation(user_message: object):
+    await on_message(user_message)

chainlit.md

@@ -0,0 +1,14 @@
+# Welcome to Chainlit! 🚀🤖
+
+Hi there, Developer! 👋 We're excited to have you on board. Chainlit is a powerful tool designed to help you prototype, debug and share applications built on top of LLMs.
+
+## Useful Links 🔗
+
+- **Documentation:** Get started with our comprehensive [Chainlit Documentation](https://docs.chainlit.io) 📚
+- **Discord Community:** Join our friendly [Chainlit Discord](https://discord.gg/ZThrUxbAYw) to ask questions, share your projects, and connect with other developers! 💬
+
+We can't wait to see what you create with Chainlit! Happy coding! 💻😊
+
+## Welcome screen
+
+To modify the welcome screen, edit the `chainlit.md` file at the root of your project. If you do not want a welcome screen, just leave this file empty.

functions/FunctionManager.py

@@ -0,0 +1,168 @@
+import inspect
+import json
+import re
+
+import requests
+import openai
+
+
+class FunctionManager:
+    def __init__(self, functions=None):
+        self.functions = {}
+        self.excluded_functions = {'inspect', 'create_engine'}  # 添加这行
+        if functions:
+            for func in functions:
+                self.functions[func.__name__] = func
+
+    def add_function(self, func):
+        self.functions[func.__name__] = func
+
+    def generate_functions_array(self):
+        type_mapping = {
+            "str": "string",
+            "int": "integer",
+            "float": "number",
+            "bool": "boolean",
+            "list": "array",
+            "dict": "object"
+        }
+        functions_array = []
+
+        for function_name, function in self.functions.items():
+            if function_name in self.excluded_functions:  # 添加这行
+                continue
+            # 获取函数的文档字符串和参数列表
+            docstring = function.__doc__
+            parameters = inspect.signature(function).parameters
+
+            # 提取函数描述
+            docstring_lines = docstring.strip().split(
+                '\n') if docstring else []
+            function_description = docstring_lines[0].strip(
+            ) if docstring_lines else ''
+
+            # 解析参数列表并生成函数描述
+            function_info = {
+                "name": function_name,
+                "description": function_description,
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "required": []  # Add a required field
+                }
+            }
+
+            for parameter_name, parameter in parameters.items():
+                # 获取参数的注释
+                parameter_annotation = parameter.annotation
+                if parameter_annotation == inspect.Parameter.empty:
+                    continue
+
+                # 如果注解是一个类型，获取它的名字
+                # 如果注解是一个字符串，直接使用它
+                if isinstance(parameter_annotation, type):
+                    parameter_annotation_name = parameter_annotation.__name__.lower(
+                    )
+                else:
+                    parameter_annotation_name = parameter_annotation.lower()
+
+                # 提取参数描述
+                param_description_pattern = rf"{parameter_name}: (.+)"
+                param_description_match = [
+                    re.search(param_description_pattern, line)
+                    for line in docstring_lines
+                ]
+                param_description = next(
+                    (match.group(1)
+                     for match in param_description_match if match), '')
+
+                # 添加参数描述
+                parameter_description = {
+                    "type":
+                    type_mapping.get(parameter_annotation_name,
+                                     parameter_annotation_name),
+                    "description":
+                    param_description
+                }
+                function_info["parameters"]["properties"][
+                    parameter_name] = parameter_description
+
+                # If the parameter has no default value, add it to the required field.
+                if parameter.default == inspect.Parameter.empty:
+                    function_info["parameters"]["required"].append(
+                        parameter_name)
+
+            functions_array.append(function_info)
+
+        return functions_array
+
+    async def call_function(self, function_name, args_dict):
+        if function_name not in self.functions:
+            raise ValueError(f"Function '{function_name}' not found")
+
+        function = self.functions[function_name]
+        # {"role": "function", "name": "get_current_weather", "content": "{\"temperature\": "22", \"unit\": \"celsius\", \"description\": \"Sunny\"}"}
+        print(function, args_dict)
+        res = await function(**args_dict)
+        # 如果返回的内容是元祖或者列表或者字典，那么就返回一个json字符串
+        if isinstance(res, (tuple, list, dict)):
+            res = json.dumps(res)
+        return res
+
+
+# 测试
+def get_current_weather(location: str, unit: str = "celsius"):
+    """
+    Get the current weather in a given location.
+
+    Parameters:
+        - location: The city and state, e.g. San Francisco, CA
+        - unit: The unit of temperature (celsius or fahrenheit)
+    """
+    return {"temperature": "22", "unit": "celsius", "description": "Sunny"}
+
+
+# 定义一个方法来根据传进来的url地址，读取网页的内容
+def get_html(url: str):
+    # 定义一个请求头，模拟浏览器访问
+    """
+    Get the html content of the url.if user provide the url,then return the html content of the url.
+    Parameters:
+        url: The url of the website. (required)
+    """
+    headers = {
+        'User-Agent':
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) '
+        'AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36'
+    }
+    # 发送请求
+    response = requests.get(url, headers=headers)
+    # 返回网页内容
+    return response.text
+
+
+def search_by_bard(content: str):
+    """
+    Search the content(translate to English language) by bard.if the input content that you don't know how to say, you can use this function.
+    Parameters:
+        content: The content to search.please change the content language to English.(required)
+    """
+    print(content)
+    response = openai.ChatCompletion.create(model="bard",
+                                            messages=[{
+                                                'role': 'user',
+                                                'content': content
+                                            }],
+                                            stream=False,
+                                            temperature=0)
+    print(response)
+    return {'content': response['choices'][0]['message']['content']}
+
+
+if __name__ == "__main__":
+    function_manager = FunctionManager(functions=[search_by_bard])
+    functions_array = function_manager.generate_functions_array()
+    print(functions_array)
+
+    # result = function_manager.call_function('get_current_weather', {'location': 'San Francisco, CA', 'unit': 'celsius'})
+    # print(result)

plugins/common/config.json

@@ -0,0 +1,3 @@
+{
+    "enabled": true
+}

plugins/common/functions.py

@@ -0,0 +1,63 @@
+import os
+import chainlit as cl
+
+
+async def need_file_upload():
+    """
+    When the user's question mentions handling files, you need to upload files, you can call this function.
+    Parameters: None
+    """
+    if not os.path.exists('./tmp'):
+        os.mkdir('./tmp')
+    files = await cl.AskFileMessage(
+        content="Please upload a text file to begin!",
+        max_size_mb=50,
+        accept=[
+            "text/plain",
+            "image/png",
+            "image/jpeg",
+            "application/pdf",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",  # for .xlsx files
+            "application/vnd.ms-excel",  # for .xls files
+            "text/csv",  # for .csv files
+            # More MIME types here as needed.
+        ]).send()
+    file = files[0]
+
+    # 保存文件到paths目录下
+    # 判断paths目录是否存在
+    file_path = f"./tmp/{file.name}"
+    # 保存文件
+    content = file.content
+    file_name = file.name
+    file_type = file.type
+    # 保存文件
+    # content是bytes类型
+    with open(file_path, "wb") as f:
+        f.write(content)
+    return {
+        'type': 'file',
+        'path': file_path,
+        'name': file_name,
+        'file_type': file_type
+    }
+
+
+async def show_images(paths: str):
+    """
+    If your return contains images in png or jpg format, you can call this function to display the images.
+    Parameters: paths: The paths of the images as a comma-separated string.(required)
+    """
+    path_list = paths.split(',')
+    elments = []
+    for i, path in enumerate(path_list):
+        tmp_image = cl.Image(name=f"image{i}",
+                             path=path.strip(),
+                             display="inline")
+        tmp_image.size = "large"
+        elments.append(tmp_image)
+
+    await cl.Message(content="",
+                     elements=elments).send()  # type: ignore
+
+    return {'description': '图片已经显示成功了，下面的回复中不再需要展示它了'}

plugins/python/config.json

@@ -0,0 +1,3 @@
+{
+    "enabled": true
+}

plugins/python/executor.py

@@ -0,0 +1,93 @@
+import abc
+import sys
+import io
+import ast
+import subprocess
+from contextlib import redirect_stdout
+from loguru import logger
+
+logger.configure(
+    handlers=[
+        {
+            "sink": sys.stderr,
+            "format": "<green>{time}</green> <level>{message}</level>",
+            "colorize": True,
+        }
+    ]
+)
+
+
+class Executor(abc.ABC):
+    @abc.abstractmethod
+    def execute(self, code: str) -> str:
+        pass
+
+
+class PythonExecutor(Executor):
+    locals = {}
+
+    def execute(self, code: str) -> str:
+        logger.info("Executing Python code: {}", code)
+        output = io.StringIO()
+
+        # Parse the code into an AST.
+        tree = ast.parse(code, mode="exec")
+
+        try:
+            # Redirect standard output to our StringIO instance.
+            with redirect_stdout(output):
+                for node in tree.body:
+                    # Compile and execute each node.
+                    exec(
+                        compile(
+                            ast.Module(body=[node], type_ignores=[]), "<ast>", "exec"
+                        ),
+                        None,
+                        PythonExecutor.locals,
+                    )
+
+                    # If the node is an expression, print its result.
+                    if isinstance(node, ast.Expr):
+                        eval_result = eval(
+                            compile(ast.Expression(body=node.value), "<ast>", "eval"),
+                            None,
+                            PythonExecutor.locals,
+                        )
+                        if eval_result is not None:
+                            print(eval_result)
+        except Exception as e:
+            logger.error("Error executing Python code: {}", e)
+            return str(e)
+
+        # Retrieve the output and return it.
+        return output.getvalue()
+
+
+class CppExecutor(Executor):
+    def execute(self, code: str) -> str:
+        with open("script.cpp", "w") as f:
+            f.write(code)
+        try:
+            subprocess.run(["g++", "script.cpp"], check=True)
+            output = subprocess.run(
+                ["./a.out"], capture_output=True, text=True, check=True
+            )
+            return output.stdout
+        except subprocess.CalledProcessError as e:
+            # Here we include e.stderr in the output.
+            raise subprocess.CalledProcessError(e.returncode, e.cmd, output=e.stderr)
+
+
+class RustExecutor(Executor):
+    def execute(self, code: str) -> str:
+        with open("script.rs", "w") as f:
+            f.write(code)
+        try:
+            subprocess.run(["rustc", "script.rs"], check=True)
+            output = subprocess.run(
+                ["./script"], capture_output=True, text=True, check=True
+            )
+            return output.stdout
+        except subprocess.CalledProcessError as e:
+            # Here we include e.stderr in the output.
+            raise subprocess.CalledProcessError(e.returncode, e.cmd, output=e.stderr)

plugins/python/functions.py

@@ -0,0 +1,52 @@
+import asyncio
+import subprocess
+import sys
+import chainlit as cl
+import os
+from .executor import PythonExecutor
+
+
+async def python_exec(code: str, language: str = "python"):
+    """
+    Exexute code. \nNote: This endpoint current supports a REPL-like environment for Python only.\n\nArgs:\n    request (CodeExecutionRequest): The request object containing the code to execute.\n\nReturns:\n    CodeExecutionResponse: The result of the code execution.
+    Parameters: code: (str, required): A Python code snippet for execution in a Jupyter environment, where variables and imports from previously executed code are accessible. The code must not rely on external variables/imports not available in this environment, and must print a dictionary `{"type": "<type>", "path": "<path>", "status": "<status>"}` as the last operation. `<type>` can be "image", "file", or "content", `<path>` is the file path (not needed if `<type>` is "content"), `<status>` indicates execution status. Display operations should save output as a file with path returned in the dictionary. If tabular data is generated, it should be directly returned as a string. The code must end with a `print` statement.the end must be print({"type": "<type>", "path": "<path>", "status": "<status>"})
+    """
+
+    myexcutor = PythonExecutor()
+    code_output = myexcutor.execute(code)
+    print(f"REPL execution result: {code_output}")
+    response = {"result": code_output.strip()}
+    return response
+
+async def need_install_package(package_name: str) -> dict:
+    """
+    If the user's question mentions installing packages, and the packages need to be installed, 
+    you can call this function.
+    Parameters: package_name: The name of the package.(required)
+    """
+    # check if package is already installed
+    cmd_check = [sys.executable, '-m', 'pip', 'show', package_name]
+    proc = subprocess.Popen(cmd_check,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+    out, _ = proc.communicate()
+    if out:
+        return {'description': f"{package_name} is already installed"}
+
+    # install package if it's not installed
+    cmd_install = [sys.executable, '-m', 'pip', 'install', package_name]
+    process = await asyncio.create_subprocess_exec(
+        *cmd_install,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE)
+
+    stdout, stderr = await process.communicate()
+
+    if process.returncode != 0:
+        await cl.Message(content=f"Failed to install {package_name}.").send()
+        return {
+            'description':
+            f"Error installing {package_name}: {stderr.decode()}"
+        }
+    await cl.Message(content=f"Successfully installed {package_name}.").send()
+    return {'description': f"{package_name} has been successfully installed"}

plugins/vue/config.json

@@ -0,0 +1,3 @@
+{
+    "enabled": true
+}

plugins/vue/functions.py

@@ -0,0 +1,103 @@
+import subprocess
+
+async def vue_install_package(path: str, package_name: str):
+    """
+    This function is used to install a package in the Vue project.
+    Parameters: 
+        package_name : The name of the package.
+        path : The path of the project.
+    """
+    try:
+        subprocess.run(["npm", "install", package_name], cwd=path)
+        return {
+            "status": "true",
+            "description": "Package installed successfully.",
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+
+async def vue_create_directory(path: str, directory_name: str):
+    """
+    This function is used to create a directory in the Vue project.
+    Parameters: 
+        path : The path of the project.
+        directory_name : The name of the directory.
+    """
+    try:
+        subprocess.run(["mkdir", directory_name], cwd=path)
+        return {
+            "status": "true",
+            "description": "Directory created successfully.",
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+    
+async def vue_create_file(path: str, file_name: str):
+    """
+    This function is used to create a file in the Vue project.
+    Parameters: 
+        path : The path of the project.
+        file_name : The name of the file.
+    """
+    try:
+        subprocess.run(["touch", file_name], cwd=path)
+        return {
+            "status": "true",
+            "description": "File created successfully.",
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+    
+async def vue_get_project_file_list(path: str):
+    """
+    This function is used to get the file list of the Vue project.
+    Parameters: 
+        project_name : The name of the project.
+        path : The path of the project.
+    """
+    # 使用ls命令获取文件列表
+    try:
+        tree = subprocess.run(["ls", path], capture_output=True)
+        return {
+            "status": "true",
+            "description": tree.stdout.decode(),
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+    
+    
+async def get_vue_project_file_content(path: str, file_name: str):
+    """
+    This function is used to get the content of a file in the Vue project.
+    Parameters: 
+        path : The path of the file you want to write to.
+        file_name : The name of the file.
+    """
+    try:
+        with open(f"{path}/{file_name}", "r") as f:
+            content = f.read()
+        return {
+            "status": "true",
+            "description": content,
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+      
+async def write_vue_project_file_content(path: str, file_name: str, content: str):
+    """
+    This function is used to write content to a file in the Vue project.
+    Parameters: 
+        path : The path of the file you want to write to.
+        file_name : The name of the file.
+        content : The content to write.
+    """
+    try:
+        with open(f"{path}/{file_name}", "w") as f:
+            f.write(content)
+        return {
+            "status": "true",
+            "description": "File content written successfully.",
+        }
+    except Exception as e:
+        return {"status": "false", "description": str(e)}
+    

requirements.txt

@@ -0,0 +1,8 @@
+chainlit==0.5.2
+loguru==0.5.3
+tiktoken==0.4.0
+prompt_toolkit==3.0.39
+scikit-learn
+pandas
+matplotlib
+numpy