init

.gitignore

@@ -0,0 +1,3 @@
+.venv
+.env
+__pychache__

Dockerfile

@@ -0,0 +1,15 @@
+# Use an official Python runtime as a parent image
+FROM python:3.10.9
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the current directory contents into the container at /app
+COPY requirements.txt /app
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,55 @@
+from modules.functions import call_llm
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+from typing import List, Set
+from typing_extensions import TypedDict, Literal
+
+app = FastAPI(debug=True)
+
+
+class Message(TypedDict):
+    role: Literal["system", "user", "assistant"]
+    content: str
+
+
+class Output(TypedDict):
+    type: str
+    content: str
+
+
+class History(BaseModel):
+    history: List[Message] = Field(
+        examples=[
+            [
+                {"role": "user", "content": "Tell me a joke."},
+                {
+                    "role": "assistant",
+                    "content": "Why did the scarecrow win an award? Because he was outstanding in his field!",
+                },
+                {"role": "user", "content": "Tell me another joke."},
+            ]
+        ]
+    )
+
+
+class Response(BaseModel):
+    response: List[Output] = Field(
+        examples=[
+            [
+                {
+                    "type": "text",
+                    "content": "### Nifty 50 Annual Return for Past 10 Years...",
+                },
+                {
+                    "type": "plotly",
+                    "content": '{"data":[{"x":[null,6.75517596225125.....}',
+                },
+            ]
+        ]
+    )
+
+
+@app.post("/response")
+async def get_response(history: History) -> Response:
+    print(history)
+    return call_llm(history.history)  # type: ignore

modules/functions.py

@@ -0,0 +1,184 @@
+import json
+import requests
+import plotly.graph_objs as go
+import re
+import os
+
+import json
+from openai import OpenAI
+
+
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
+or_client = OpenAI(api_key=OPENROUTER_API_KEY, base_url="https://openrouter.ai/api/v1")
+
+
+def chat_with_llama(messages, model="meta-llama/llama-3-70b-instruct:nitro"):
+    response = or_client.chat.completions.create(
+        model=model,
+        messages=messages,
+        max_tokens=4096,
+    )
+
+    response_message = response.choices[0].message.content
+
+    print(response_message, "\n\n\n")
+
+    return response_message
+
+
+SysPrompt = """
+You are a helpful expert ai assistant capable of executing python code in an interactive jupyter environment. Use the provided tools as needed to complete the given task. use markdown step to add detailed explanations in markdown format before the code. Use plotly as default charting library unless specified. Use IPython.display to render HTML and other compatible files.
+You should output only in the following xml format to perform any of the following steps:
+## Output Format:
+
+<execute_python>python code here</execute_python>
+<markdown>any explanations in markdown format</markdown>
+
+
+these are the preinstalled Libraries in current environment:
+pandas
+matplotlib
+plotly
+yfinance
+numpy
+seaborn
+scikit-learn
+statsmodels
+geopandas
+geopy
+folium
+IPython
+"""
+
+
+# Function to execute code asynchronously
+def execute_code(code):
+    headers = {"accept": "application/json", "Content-Type": "application/json"}
+
+    data = {"session_token": "", "code": code}
+
+    response = requests.post(
+        "https://pvanand-code-execution.hf.space/execute",
+        headers=headers,
+        data=json.dumps(data),
+    )
+
+    if response.status_code == 200:
+        # Code execution returned results
+        if response.json()["status"] == "success":
+            output = response.json()["value"]
+        else:
+            # Code execution failed
+            output = [
+                {
+                    "error": {
+                        "ename": "Execution request failed",
+                        "evalue": response.json()["value"],
+                        "traceback": [],
+                    }
+                }
+            ]
+            print(response.json()["value"])
+    else:
+        output = []
+    return output
+
+
+def extract_steps(text):
+    steps = []
+    pattern = re.compile(r"<(\w+)>(.*?)</\1>", re.DOTALL)
+    matches = pattern.findall(text)
+
+    for tag, content in matches:
+        if tag == "execute_python":
+            content = re.sub(r"```python|```", "", content).strip()
+        steps.append({"type": tag, "content": content.strip()})
+
+    return steps
+
+
+def execute_llm_code(code):
+    try:
+        output = execute_code(code)
+    except Exception as e:
+        # st.error("Exception occurred: " + str(e))
+        output = None
+    return output
+
+
+def call_llm(history, model="meta-llama/llama-3-70b-instruct:nitro"):
+    # Simulate LLM call_llm
+    history.insert(0, {"role": "system", "content": SysPrompt})
+    response = chat_with_llama(history, model=model)
+    llm_steps = extract_steps(response)
+    result = []
+    if llm_steps:
+        for step in llm_steps:
+            if step["type"] == "execute_python":
+                output = execute_llm_code(code=step["content"])
+                if output != None:
+                    clear_output = process_execution_output(execution_output=output)
+                    result += clear_output
+                else:
+                    pass
+            else:
+                result.append({"type": "text", "content": str(step["content"])})
+        return {"response": result}
+    else:
+        return {"response": [response]}
+
+
+def process_execution_output(execution_output):
+    OUTPUT = []
+    # st.write(output)
+    if isinstance(execution_output, str):
+        pass
+    # Code Execution Output Only
+
+    else:
+        for item in execution_output:
+            if "text" in item:
+                exclude_list = [
+                    "%%",
+                    "NoneType",
+                    "YFTzMissingError",
+                    "Failed download",
+                    "FutureWarning",
+                ]
+                if not list(filter(lambda x: x in str(item["text"]), exclude_list)):
+                    OUTPUT.append({"type": "text", "content": item["text"]})
+
+            elif "data" in item:
+
+                if "image/png" in item["data"]:
+                    OUTPUT.append(
+                        {"type": "image", "content": item["data"]["image/png"]}
+                    )
+
+                elif "application/vnd.plotly.v1+json" in item["data"]:
+                    plotly_data = item["data"]["application/vnd.plotly.v1+json"]
+                    if isinstance(plotly_data, str):
+                        plotly_data = json.loads(plotly_data)
+                    go_json = str(go.Figure(plotly_data).to_json())
+                    OUTPUT.append({"type": "plotly", "content": go_json})
+
+                elif "<folium.folium.Map at 0x7f2aef096f50>" in item["data"]:
+                    OUTPUT.append(
+                        {"type": "FoliumMap", "content": item["data"]["text/html"]}
+                    )
+
+                # None of the above and not an empty script then render html
+                elif "text/html" in item["data"]:
+                    script_tag_only = (
+                        item["data"]["text/html"].strip()[:7] == "<script"
+                    )  # TODO: Check full script tag
+                    if not script_tag_only:
+                        # st.html(item["data"]["text/html"])
+                        OUTPUT.append(
+                            {"type": "HTML", "content": item["data"]["text/html"]}
+                        )
+
+            elif "error" in item:
+                pass
+            # st.error(f"Error: {item['error']['ename']} - {item['error']['evalue']}")
+    return OUTPUT

requirements.txt

@@ -0,0 +1,44 @@
+annotated-types==0.7.0
+anyio==4.4.0
+certifi==2024.7.4
+charset-normalizer==3.3.2
+click==8.1.7
+distro==1.9.0
+dnspython==2.6.1
+email_validator==2.2.0
+exceptiongroup==1.2.2
+fastapi==0.112.0
+fastapi-cli==0.0.5
+h11==0.14.0
+httpcore==1.0.5
+httptools==0.6.1
+httpx==0.27.0
+idna==3.7
+Jinja2==3.1.4
+kaleido==0.2.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+mdurl==0.1.2
+openai==1.37.1
+packaging==24.1
+plotly==5.23.0
+pydantic==2.8.2
+pydantic_core==2.20.1
+Pygments==2.18.0
+python-dotenv==1.0.1
+python-multipart==0.0.9
+PyYAML==6.0.1
+requests==2.32.3
+rich==13.7.1
+shellingham==1.5.4
+sniffio==1.3.1
+starlette==0.37.2
+tenacity==9.0.0
+tqdm==4.66.4
+typer==0.12.3
+typing_extensions==4.12.2
+urllib3==2.2.2
+uvicorn==0.30.5
+uvloop==0.19.0
+watchfiles==0.22.0
+websockets==12.0