from openai import OpenAI

client = OpenAI(api_key="XXX") # supply your API key however you choose

message = {"role":"user", "content": input("This is the beginning of your chat with AI. [To exit, send \"###\".]\n\nYou:")}

conversation = [{"role": "system", "content": "DIRECTIVE_FOR_gpt-3.5-turbo"}]

while(message["content"]!="###"):
    conversation.append(message)
    completion = client.chat.completions.create(model="gpt-3.5-turbo", messages=conversation) 
    message["content"] = input(f"Assistant: {completion.choices[0].message.content} \nYou:")
    print()
    conversation.append(completion.choices[0].message)

assistant = client.beta.assistants.create(
  instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.",
#   model="gpt-4-1106-preview",
  model="gpt-3.5-turbo", # use a cheaper model
  tools=[{"type": "code_interpreter"}]
)

# Upload a file with an "assistants" purpose
file = client.files.create(
  file=open("input.txt", "rb"),
  purpose='assistants'
)

# Create an assistant using the file ID
assistant = client.beta.assistants.create(
  instructions="You are a personal math tutor. When asked a math question, write and run code to answer the question.",
#   model="gpt-4-1106-preview",
  model="gpt-3.5-turbo", # use a cheaper model
  tools=[{"type": "code_interpreter"}],
  file_ids=[file.id]
)

thread = client.beta.threads.create(
  messages=[
    {
      "role": "user",
      "content": "Create 3 data visualizations based on the trends in this file.",
      "file_ids": [file.id]
    }
  ]
)

# Run the assistant on the thread
run = client.beta.threads.runs.create(
  thread_id=thread.id,
  assistant_id=assistant.id
)

# Get the thread
thread = client.beta.threads.retrieve(thread.id)

# Print the messages
for message in thread.messages:
  print(message.content)

[ThreadMessage(
    id='msg_adN5zDKj3SZsFt6FDrEGCIh9',
    assistant_id=None,
    content=[MessageContentText(
        text=Text(annotations=[], value='Create 1 data visualizations based on the trends in this file.'),
        type='text'
    )],
    created_at=1700121819,
    file_ids=['file-kwq6JAns0HrtZiCDdZi1TZle'],
    metadata={},
    object='thread.message',
    role='user',
    run_id=None,
    thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
)]

[
    ThreadMessage(
        id='msg_jm5CCVRIOJWC5iPCh8voaSuV', 
        assistant_id='asst_Kca5bKsMgJDT2qw67x824Cbt', 
        content=[
            MessageContentImageFile(
                image_file=ImageFile(file_id='file-UGVhdJHm6onKw4MPnxWVmZHM'), 
                type='image_file'
            ), 
            MessageContentText(
                text=Text(
                    annotations=[], 
                    value='The scatter plot above shows the relationship between the two numerical columns in the data file. Each point represents a data point with the x-coordinate corresponding to the values in column 1 and the y-coordinate corresponding to the values in column 2. Without additional information about the data, it is challenging to interpret any specific trends or patterns from this visualization.\n\nIf you provide more context or specify the type of visualization you would like to see, I can assist you further.'
                ), 
                type='text'
            )
        ], 
        created_at=1700122082, 
        file_ids=[], 
        metadata={}, 
        object='thread.message', 
        role='assistant', 
        run_id='run_d0bg4GvYvzPm16UuA9BSgum9', 
        thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
    ), 
    ThreadMessage(
        id='msg_XqaoSp1EnYUCfgVGmC7y62L8', 
        assistant_id='asst_Kca5bKsMgJDT2qw67x824Cbt', 
        content=[
            MessageContentText(
                text=Text(
                    annotations=[], 
                    value='Based on the data in the file, it appears that there are two numerical columns without any header information. Without knowing the context or meaning of the data, it is difficult to identify specific trends or patterns. However, I can still generate a basic visualization to provide an overview of the data.'
                ), 
                type='text'
            )
        ], 
        created_at=1700122077, 
        file_ids=[], 
        metadata={}, 
        object='thread.message', 
        role='assistant', 
        run_id='run_d0bg4GvYvzPm16UuA9BSgum9', 
        thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
    ), 
    ThreadMessage(
        id='msg_Qd4RwduRtIyie0L1LP8AJ1c0', 
        assistant_id='asst_Kca5bKsMgJDT2qw67x824Cbt', 
        content=[
            MessageContentImageFile(
                image_file=ImageFile(file_id='file-6n8uPi7buOJCqomQceZtXrcu'), 
                type='image_file'
            ), 
            MessageContentText(
                text=Text(
                    annotations=[], 
                    value='The line chart above shows the relationship between the variables in the data file. Each point on the chart represents the values of the two variables for a specific data point. The chart helps visualize any trends or patterns in the data.\n\nPlease let me know if there is anything else I can help you with.'
                ), 
                type='text'
            )
        ], 
        created_at=1700121835, 
        file_ids=[], 
        metadata={}, 
        object='thread.message', 
        role='assistant', 
        run_id='run_I5WfDBDybUilwBDfsFnnPGLt', 
        thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
    ), 
    ThreadMessage(
        id='msg_C5oNrcFxDfiAeoA3Y3ssv5CQ', 
        assistant_id='asst_Kca5bKsMgJDT2qw67x824Cbt', 
        content=[
            MessageContentText(
                text=Text(
                    annotations=[], 
                    value="The data file contains two columns named `-0.45963489857655115` and `-0.6802488378393142`. To create a data visualization based on the trends in this file, we can plot a line chart to show the relationship between these two variables.\n\nLet's plot the line chart using the data."
                ), 
                type='text'
            )
        ], 
        created_at=1700121829, 
        file_ids=[], 
        metadata={}, 
        object='thread.message', 
        role='assistant', 
        run_id='run_I5WfDBDybUilwBDfsFnnPGLt', 
        thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
    ), 
    ThreadMessage(
        id='msg_adN5zDKj3SZsFt6FDrEGCIh9', 
        assistant_id=None, 
        content=[
            MessageContentText(
                text=Text(
                    annotations=[], 
                    value='Create 1 data visualizations based on the trends in this file.'
                ), 
                type='text'
            )
        ], 
        created_at=1700121819, 
        file_ids=['file-kwq6JAns0HrtZiCDdZi1TZle'], 
        metadata={}, 
        object='thread.message', 
        role='user', 
        run_id=None, 
        thread_id='thread_l39atOePQfskPzf0dMPCdwLK'
    )
]

from openai import OpenAI

client = OpenAI()

image_data = client.files.content("file-6n8uPi7buOJCqomQceZtXrcu")
image_data_bytes = image_data.read()

with open("./my-image.png", "wb") as file:
    file.write(image_data_bytes)

assistant = client.beta.assistants.create(
  instructions="You are a weather bot. Use the provided functions to answer questions.",
  model="gpt-4-1106-preview",
  tools=[{
      "type": "function",
    "function": {
      "name": "getCurrentWeather",
      "description": "Get the weather in location",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city and state e.g. San Francisco, CA"},
          "unit": {"type": "string", "enum": ["c", "f"]}
        },
        "required": ["location"]
      }
    }
  }, {
    "type": "function",
    "function": {
      "name": "getNickname",
      "description": "Get the nickname of a city",
      "parameters": {
        "type": "object",
        "properties": {
          "location": {"type": "string", "description": "The city and state e.g. San Francisco, CA"},
        },
        "required": ["location"]
      }
    } 
  }]
)

{
  "id": "run_abc123",
  "object": "thread.run",
  "assistant_id": "asst_abc123",
  "thread_id": "thread_abc123",
  "status": "requires_action",
  "required_action": {
    "type": "submit_tool_outputs",
    "submit_tool_outputs": {
      "tool_calls": [
        {
          "id": "call_abc123",
          "type": "function",
          "function": {
            "name": "getCurrentWeather",
            "arguments": "{\"location\":\"San Francisco\"}"
          }
        },
        {
          "id": "call_abc456",
          "type": "function",
          "function": {
            "name": "getNickname",
            "arguments": "{\"location\":\"Los Angeles\"}"
          }
        }
      ]
    }
  },

assistant = client.beta.assistants.create(
  instructions="You are a customer support chatbot. Use your knowledge base to best respond to customer queries.",
  model="gpt-4-1106-preview",
  tools=[{"type": "retrieval"}]
)

# Upload a file with an "assistants" purpose
file = client.files.create(
  file=open("knowledge.pdf", "rb"),
  purpose='assistants'
)

# Add the file to the assistant
assistant = client.beta.assistants.create(
  instructions="You are a customer support chatbot. Use your knowledge base to best respond to customer queries.",
  model="gpt-4-1106-preview",
  tools=[{"type": "retrieval"}],
  file_ids=[file.id]
)

message = client.beta.threads.messages.create(
  thread_id=thread.id,
  role="user",
  content="I can not find in the PDF manual how to turn off this device.",
  file_ids=[file.id]
)

import json
import os
from openai import OpenAI
from prompts import assistant_instructions
from dotenv import load_dotenv
load_dotenv()

OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')


# Init OpenAI Client
client = OpenAI(api_key=OPENAI_API_KEY)

# Create or load assistant
def create_assistant(client):
  assistant_file_path = 'assistant.json'

  # If there is an assistant.json file already, then load that assistant
  if os.path.exists(assistant_file_path):
    with open(assistant_file_path, 'r') as file:
      assistant_data = json.load(file)
      assistant_id = assistant_data['assistant_id']
      print("Loaded existing assistant ID.")
  else:
    # If no assistant.json is present, create a new assistant using the below specifications

    # To change the knowledge document, modify the file name below to match your document
    # If you want to add multiple files, paste this function into ChatGPT and ask for it to add support for multiple files
    file = client.files.create(file=open("my_cover.pdf", "rb"),
                               purpose='assistants')

    assistant = client.beta.assistants.create(
        # Getting assistant prompt from "prompts.py" file, edit on left panel if you want to change the prompt
        instructions=assistant_instructions,
        model="gpt-3.5-turbo-1106",
        tools=[
            {
                "type": "retrieval"  # This adds the knowledge base as a tool
            },
        ],
        file_ids=[file.id])

    # Create a new assistant.json file to load on future runs
    with open(assistant_file_path, 'w') as file:
      json.dump({'assistant_id': assistant.id}, file)
      print("Created a new assistant and saved the ID.")

    assistant_id = assistant.id

  return assistant_id

import json
import os
import time
from selenium.webdriver.support import expected_conditions as EC

import openai
from openai import OpenAI
from selenium.webdriver import Keys
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait

import functions
import finding_jobs


# Check OpenAI version compatibility
from packaging import version
from dotenv import load_dotenv
load_dotenv()

required_version = version.parse("1.1.1")
current_version = version.parse(openai.__version__)
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
if current_version < required_version:
  raise ValueError(
      f"Error: OpenAI version {openai.__version__} is less than the required version 1.1.1"
  )
else:
  print("OpenAI version is compatible.")

# Initialize OpenAI client
client = OpenAI(api_key=OPENAI_API_KEY)

# Create or load assistant
assistant_id = functions.create_assistant(
    client)  # this function comes from "functions.py"

def create_thread(client):
    # Function to create a new thread and return its ID
    try:
        response = client.beta.threads.create()  # No assistant_id needed
        thread_id = response.id
        return thread_id
    except Exception as e:
        print(f"Error creating thread: {e}")
        return None


def chat(user_input, assistant_id, thread_id=None):
    if thread_id is None:
        thread_id = create_thread(client)
        if thread_id is None:
            return json.dumps({"error": "Failed to create a new thread"})

    print(f"Received message: {user_input} in thread {thread_id}")

    # Run the Assistant
    try:
        # Add the user's message to the thread
        client.beta.threads.messages.create(
            thread_id=thread_id,
            role="user",
            content=user_input
        )

        # Start the Assistant Run
        run = client.beta.threads.runs.create(
            thread_id=thread_id,
            assistant_id=assistant_id
        )

        # Check if the Run requires action (function call)
        while True:
            run_status = client.beta.threads.runs.retrieve(
                thread_id=thread_id,
                run_id=run.id
            )

            if run_status.status == 'completed':
                break
            elif run_status.status == 'requires_action':
                # Here you can handle specific actions if your assistant requires them
                # ...
                time.sleep(1)  # Wait for a second before checking again

        # Retrieve and return the latest message from the assistant
        messages = client.beta.threads.messages.list(thread_id=thread_id)
        assistant_message = messages.data[0].content[0].text.value

        # 将换行符替换为一个空格
        formatted_message = assistant_message.replace("\n", " ")

        # response_data = json.dumps({"response": assistant_message, "thread_id": thread_id})
        return formatted_message

    except Exception as e:
        print(f"An error occurred: {e}")
        error_response = json.dumps({"error": str(e)})
        return error_response


if __name__ == '__main__':
    assistant_id = functions.create_assistant(client)

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

def open_browser_with_options(url, browser):
    options = Options()
    options.add_experimental_option("detach", True)

    if browser == "chrome":
        driver = webdriver.Chrome(options=options)
        driver.maximize_window()
    else:
        raise ValueError("Browser type not supported")

    driver.get(url)

# Variables
url = "https://www.zhipin.com/web/geek/job-recommend?ka=header-job-recommend"
browser_type = "chrome"

# Test case
open_browser_with_options(url, browser_type)

print(”Hello \n Welcome to the Agent System. \n We provide you with the following chatbots:”)
# load the json file
# for all bots in it, display the name of the file and a brief description of it.
# add one extra line as “Create a new agent”
# then ask the user to select based on the index
selected_index = input(“\n Please enter the index of your choice:)
# then load the selected one or redo the process
Assistant_id = load(selected_index)
# if the user choose create a new agent, then ask it to specify the above informations including: name, description, file_path, the tools used and the prompt. All optional with an auto name/description/prompt/tool generator (Refer to GPT store on how to build one)