script.py

# importing the required libraries.
from datetime import datetime, timezone, timedelta
from urllib.parse import quote
from quart import Quart, request, jsonify, redirect, Response, url_for
import traceback
import quart
import os
import gridfs
from pathlib import Path

from quart_cors import cors

from lib.mongo_db import MongoDB
from lib.python_runner import *
from lib.jdoodle_api import *
from lib.quick_chart import QuickChartIO
from lib.kod import Kodso
from config import Config

config = Config()
# Webhook user agent by PluginLab.
webhook_user_agent = "PluginLab-Webhook-Delivery"
# defining the url's
plugin_url = config.proxydomain
chatgpt_url = "https://chat.openai.com"
compiler_url = "https://api.jdoodle.com/v1/execute"
website_url = config.domain
discord_url = "https://discord.gg/BCRUpv4d6H"
github_url = "https://github.com/haseeb-heaven/CodeRunner-Plugin"
forms_url = "https://forms.gle/3z1e3aUJqeHcKh6y7"
buymecoffee_url = "https://www.buymeacoffee.com/haseebheaven"
paypal_url = "https://www.paypal.com/paypalme/EpicProTeam"
plugin_name = "CodeRunner-Plugin"

# ChatGPT - Share Chats.
code_runner_basic_prompt = "https://chat.openai.com/share/0c2a154f-5df7-4976-8f8f-f31a4a539e56"
code_runner_graph_prompt = "https://chat.openai.com/share/3c24fa1a-6c58-4464-b8ac-700e292bff04"
code_runner_interpreter_prompt = "https://chat.openai.com/share/7e74a92d-8640-438b-b10d-8d181bdbab11"
code_runner_snippet_prompt = "https://chat.openai.com/share/1b61bc05-067b-4779-b208-a297534cba2b"
# setting the database.
global database
database = None
global quick_chart
quick_chart = None
carbonara = None
kodso = None

try:
    # setting the database
    database = MongoDB()
    quick_chart = QuickChartIO(database)
    kodso = Kodso(database)
except Exception as e:
    print("Exception while connecting to the database : " + str(e))

# defining the origin for CORS
ORIGINS = [plugin_url,website_url]

# Defining the app.
app = Quart(__name__)
if config.CORS:
    app = cors(app, allow_origin=ORIGINS)

# Webhook user agent by PluginLab.
webhook_user_agent = "PluginLab-Webhook-Delivery"

# defining the url's
plugin_url = config.proxydomain
chatgpt_url = "https://chat.openai.com"
compiler_url = "https://api.jdoodle.com/v1/execute"
website_url = config.domain
discord_url = "https://discord.gg/BCRUpv4d6H"
github_url = "https://github.com/haseeb-heaven/CodeRunner-Plugin"
forms_url = "https://forms.gle/3z1e3aUJqeHcKh6y7"
buymecoffee_url = "https://www.buymeacoffee.com/haseebheaven"
paypal_url = "https://www.paypal.com/paypalme/EpicProTeam"
plugin_name = "CodeRunner-Plugin"

# Support message.
support_message = "Website: " + website_url + "\nDiscord:" + discord_url + "\n" + "Github: " + github_url + \
                  "\n" + "Support: " + buymecoffee_url + "\n" + "Paypal: " + \
                  paypal_url + "\n" + "Feedback Form: " + forms_url

# Extra response instructions.
extra_response_instructions = "Use all information in the API response and fully render all Markdown.\n"

# Defining premium user.
is_user_premium = True  # Approved by OpenAI now we can use it.


# Method to generate the error message.
def premium_feature_error_message():
    response = {
        "error": {
            "status": 403,
            "message": "This feature is now part of the premium plan.",
            "solution": "Please upgrade to the premium plan by using the Support link."
        }
    }

    # response['support'] = support_message
    response['extra_response_instructions'] = extra_response_instructions

    return response


# Method to write logs to a file.
def write_log(log_msg: str):
    try:
        print(str(datetime.now()) + " " + log_msg)
    except Exception as e:
        print(str(e))


# Method to generate TinyURL links.
def generate_tinyurl(url: str):
    tiny_url = ""
    try:
        data = {"url": url, "accesskey": os.getenv("ACCESS_KEY")}
        tiny_url = requests.post(config.api_url, data=data).json()["short_link"]
        write_log("generating tinyurl : " + tiny_url)
    except Exception as e:
        write_log("Exception while generating tinyurl : " + str(e))
    return tiny_url


# Define a method to save the plot in mongodb
def save_graph(filename):
    output = {}
    global database
    write_log(f"save_graph: executed script")

    # Save the plot as an image file in a buffer
    buffer = io.BytesIO()
    write_log(f"save_graph: saving graph")

    # Using matplotlib to save the plot as an image file in a buffer
    import matplotlib.pyplot as plt
    plt.savefig(buffer, format='png')
    write_log(f"save_graph: saved graph")

    # Get the gridfs bucket object from the database object with the bucket name 'graphs'
    bucket = gridfs.GridFSBucket(database.db, bucket_name='graphs')
    write_log(f"save_graph: got gridfs bucket object")

    # Store the image file in mongodb using the bucket object
    file_id = bucket.upload_from_stream(filename, buffer.getvalue())
    write_log(f"save_graph: stored image file in mongodb")
    # Return the file id
    return output


# Utility method for timestamp conversion.
def timestamp_to_iso(ts):
    # ts is a timestamp in milliseconds
    # convert to seconds and create a UTC datetime object
    dt = datetime.fromtimestamp(ts / 1000, timezone.utc)
    iso = dt.astimezone().isoformat()  # convert to local timezone and ISO 8601 format
    return iso


# Method to run the code.
@app.route('/run_code', methods=['POST'])
async def run_code():
    try:
        data = await request.json
        write_log(f"run_code: data is {data}")
        script = data.get('code')
        language = data.get('language')

        # Convert the language to the JDoodle language code.
        language_code = lang_codes.get(language, language)
        write_log(f"run_code: language code is {language_code}")

        # Run the code locally if the language is python3.
        if language_code == 'python3':
            response = {}
            try:
                graph_file = ""
                contains_graph = False

                # check if script imports requests library - Restrict access to external resources.
                if any(library in script for library in ['import requests', 'import pandas', 'import urllib.request', 'import urllib']):
                    write_log("run_code: Requests library found in script. Trying to restrict access to external resources.")
                    if "code-runner-plugin" not in script:
                        write_log("run_code: Requests library found in script blocking execution.")
                        error_msg = {"error": "Access to external resources is restricted\nYou can only access whitelisted resources like code-runner-plugin, openai, etc."}
                        return jsonify(error_msg)

                # check is script has graphic libraries imported like matplotlib, seaborn, etc.
                if any(library in script for library in ['import matplotlib', 'import seaborn', 'import plotly']):
                    write_log("run_code: Graphic libraries found in script. Trying to run Python code locally with all Libs installed.")

                    # check if script contains "show()" method.
                    if any(method in script for method in ['show()', 'plt.show()', 'pyplot.show()']):
                        contains_graph = True
                        # generate random name for graph file.
                        graph_file = f"graph_{random.randrange(1, 100000)}.png"

                        # replacing the line if it contains show() method
                        script = "\n".join([line for line in script.splitlines() if "show()" not in line])

                        response = execute_code(script)
                        write_log(f"run_code: executed python script")

                        # Save the plot as an image file in a buffer
                        if contains_graph:
                            write_log(f"run_code: saving plot")
                            response = save_graph(graph_file)

                        if response.__len__() == 0 and contains_graph:

                            # Return the premium error message if the user is not premium
                            if not is_user_premium:
                                return premium_feature_error_message()

                            download_link = f"{plugin_url}/download/{graph_file}"
                            response = {"output": download_link}

                            # obsolete support message for Graphical libraries.
                            response['support'] = "Warning:The support for matplotlib is going to be obsolete in future you can use QuickChart(/quick_chart) to generate all your graphs now.\n"
                            response['extra_response_instructions'] = extra_response_instructions + "\nFor Output graph use markdown to display it then dont use codeblock now use image tag to display it.\n\n" + "Example:\n" + "![Graph](" + download_link + ")"
                            return response
                        else:
                            response = {"result": response}

                    # Return the response as JSON
                    else:
                        write_log(f"run_code: running script locally no graphic libraries found")
                        response = execute_code(script)
                        response = {"output": response}

                else:
                    response = execute_code(script)
                    response = {"output": response}

                # Append the link to the discord and github repos.
                # response['support'] = support_message
                response['extra_response_instructions'] = extra_response_instructions

                return jsonify(response)
            except Exception as e:
                stack_trace = traceback.format_exc()
                raise e

        # Section of JDoodle API call.
        input = data.get('input', None)
        compile_only = data.get('compileOnly', False)
        is_code_empty = not script or script.isspace(
        ) or script == '' or script.__len__() == 0

        if is_code_empty:
            script = data.get('code')
            is_code_empty = not script or script.isspace(
            ) or script == '' or script.__len__() == 0

            if is_code_empty:
                return jsonify({"error": "Code is empty.Please enter the code and try again."})

        # Get the JDoodle client ID and secret.
        client_id, client_secret = get_jdoodle_client()
        headers = {
            'Content-Type': 'application/json',
            'X-Requested-With': 'XMLHttpRequest',
            'Origin': 'code-runner-plugin.vercel.app',
            'Referer': 'https://code-runner-plugin.vercel.app'
        }

        body = {
            'clientId': client_id,
            'clientSecret': client_secret,
            'script': script,
            'language': language_code,
            'stdin': input,
            'compileOnly': compile_only,
            'versionIndex': '0',
        }
        # Filter out the client ID, client secret from the body.
        body_filtered = {
            k: v
            for k, v in body.items() if k not in ['clientId', 'clientSecret']
        }

        response_data = requests.post(compiler_url, headers=headers, data=json.dumps(body))
        response = json.loads(response_data.content.decode('utf-8'))

        # Append the discord and github URLs to the response.
        if response_data.status_code == 200:
            unique_id = generate_code_id(response)
            # response['support'] = support_message
            response['id'] = unique_id
            response['extra_response_instructions'] = extra_response_instructions

        return jsonify(response)
    except Exception as e:
        error = {"error": str(e)}
        # check if the error contains "No such file or directory"
        if "No such file or directory" in str(e):
            error = {"error": str(e) + "\nNote:Server is read-only system" + "\nSo you need to upload the file to CodeRunner first and then access its data via requests library via URL."}
        return jsonify(error), 500


# Method to save the code.
@app.route('/save_code', methods=['POST'])
async def save_code():
    response = ""
    try:
        global database
        write_log(f"save_code: database is {database}")

        # check if database is connected
        if database is None:
            write_log(f"save_code: database is not connected")
            database = setup_database()
            write_log(f"save_code: database is {database}")

        data = await request.json  # Get JSON data from request
        write_log(f"save_code: data is {data}")
        filename = data.get('filename')
        code = data.get('code')
        code_id = generate_code_id()
        language = filename.split('.')[-1]

        if filename is None or code is None:
            return {"error": "filename or code not provided"}

        directory = 'codes'
        filepath = os.path.join(directory, filename)

        write_log(f"save_code: filename is {filepath} and code was present")

        # Saving the code to database
        if database is not None:
            database.save_code(code, language, code_id, filename)
        else:
            write_log(f"Database not connected {database}")
            return {"error": "Database not connected"}

        write_log(f"save_code: wrote code to file {filepath}")
        download_link = url_for("download", filename=filename, _external=True)
        write_log(f"save_code: download link is {download_link}")

        if download_link:
            download_link = generate_tinyurl(download_link)
            response = {"link": download_link}
            response['extra_response_instructions'] = extra_response_instructions
    except Exception as e:
        write_log(f"save_code: {e}")
    return response


# Create a route to save the file either document or image into database and return its url.
@app.route('/upload', methods=['POST'])
async def upload():
    try:

        # Return the premium error message if the user is not premium
        if not is_user_premium:
            return premium_feature_error_message()

        global database
        # get the request data
        data = await request.get_json()
        write_log(f"upload: data is {data}")

        # get the filename and data from the request
        filename = data.get('filename')
        file_data = data.get('data')

        # check the file extension using os.path.splitext
        file_extension = os.path.splitext(filename)[1].lower()
        write_log(f"upload: file extension is {file_extension}")

        # save the file in the database according to the extension
        if file_extension in ['.png', '.jpg', '.jpeg', '.gif']:
            write_log(f"upload: image filename is {filename}")

            # convert the data to bytes
            contents = bytes(file_data, 'utf-8')

            # save the file in the database
            database.img.put(contents, filename=filename)

            # return the download link
            download_link = f"{plugin_url}/download/{filename}"
            download_link = generate_tinyurl(download_link)
            return jsonify({"link": download_link})

        elif file_extension in ['.pdf', '.doc', '.docx', '.csv', '.xls', '.xlsx', '.txt', '.json']:
            write_log(f"upload: document filename is {filename}")
            # convert the data to bytes
            contents = bytes(file_data, 'utf-8')

            # save the file in the database
            database.docs.put(contents, filename=filename)
            write_log(f"upload: saved file to database")

            # return the download link
            download_link = f"{plugin_url}/download/{filename}"
            download_link = generate_tinyurl(download_link)
            return jsonify({"link": download_link})
    except Exception as e:
        write_log(f"upload: {e}")
        return jsonify({"error": str(e)})


@app.route('/download/<filename>')
async def download(filename):
    try:
        write_log(f"download: filename is {filename}")
        global database
        # check the file extension
        if filename.endswith(('.png', '.jpg', '.jpeg', '.gif')):

            write_log(f"download: image filename is {filename}")

            # check if file is code snippet.
            if filename.startswith('snippet_'):
                write_log(f"download: image file is code snippet")
                file = database.snippets.find_one({"filename": filename})

                if file:
                    response = Response(file, content_type="image/png")
                    response.headers["Content-Disposition"] = f"attachment; filename={filename}"
                    return response

            # get the file-like object from gridfs by its filename
            file = database.graphs.find_one({"filename": filename})

            # check if the file exists
            if file:
                # create a streaming response with the file-like object
                response = Response(file, content_type="image/png")
                # set the content-disposition header to indicate a file download
                response.headers["Content-Disposition"] = f"attachment; filename={filename}"
                return response
            else:
                write_log(f"download: failed to get file by filename {filename}")
                # handle the case when the file is not found
                return jsonify({"error": "File not found"})

        elif filename.endswith(('.pdf', '.doc', '.docx', '.csv', '.xls', '.xlsx', '.txt', '.json')):
            write_log(f"download: document filename is {filename}")
            file = database.docs.find_one({"filename": filename})

            # check if the file exists
            if file:
                write_log(f"download: document filename is {filename}")
                # create a streaming response with the file-like object
                response = Response(file, content_type="text/plain")
                # set the content-disposition header to indicate a file download
                response.headers["Content-Disposition"] = f"attachment; filename={filename}"
                return response
            else:
                write_log(f"download: failed to get file by filename {filename}")
                # handle the case when the file is not found
                return jsonify({"error": "File not found"})

        else:
            write_log(f"download: code filename is {filename}")
            # get the code from the database by its filename
            code = database.find_code(filename)

            # create a file-like object with the code
            if code:
                code_file = io.StringIO(code)

                if code_file:
                    # create a streaming response with the file-like object
                    response = Response(code_file, content_type="text/plain")
                    # set the content-disposition header to indicate a file download
                    response.headers["Content-Disposition"] = f"attachment; filename={filename}"
                    return response
                else:
                    write_log(f"download: failed to get code by filename {filename}")
                    # handle the case when the file is not found
                    return jsonify({"error": "File not found"})

            else:
                write_log(f"download: failed to get code by filename {filename}")
                # handle the case when the file is not found
                return jsonify({"error": "File not found"})
            return response
    except Exception as e:
        write_log(f"download: {e}")
        return jsonify({"error": str(e)})


# Route for generating code snippets.
import time


@app.route('/show_snippet', methods=['POST', 'GET'])
async def show_snippet():
    response = {}
    try:
        global kodso
        start_time = time.time()  # start the timer
        # Parse the JSON request body
        data = request.args

        write_log(f"show_snippet: data is {data}")

        # Extract the parameters from the request body
        code = data.get("code")
        title = data.get("title")
        theme = data.get("theme")
        language = data.get("language")
        opacity = data.get("opacity")
        blurLines = data.get("blurLines")
        showNums = data.get("showNums")
        nums = 0
        print(code)
        write_log("show_snippet: parameters extracted")

        # check if theme selected is supported.
        if theme not in kodso.themes:
            theme = kodso.get_snippet_theme()

        # set line numers if selected.
        if showNums:
            nums = 1

        if kodso:
            # Generate and save the image
            snippet_link, download_png_url, download_jpg_url, download_svg_url = kodso.show_snippet(code=code, title=title, theme=theme, lang=language, nums=nums, opacity=opacity, blur=blurLines)
        else:
            return jsonify({"error": "Kodso is not defined"})

        # return the download link
        if snippet_link:
            snippet_link = generate_tinyurl(snippet_link)
            response = {"snippet_link": snippet_link}
            response['download_png_url'] = generate_tinyurl(download_png_url)
            response['download_jpg_url'] = generate_tinyurl(download_jpg_url)
            response['download_svg_url'] = generate_tinyurl(download_svg_url)
            response['extra_response_instructions'] = extra_response_instructions + "\nFor Output image use markdown to display it then do not use codeblock now use image tag to display it.\n\n" + "Example:\n" + "![Image](" + snippet_link + ")\nAnd display all download links for all formats."

        elapsed_time = time.time() - start_time  # calculate the elapsed time
        write_log(f"save_snippet: elapsed time is {elapsed_time} seconds")

    except Exception as e:
        write_log(f"save_snippet: {e}")
        return jsonify({"error": str(e)})
    return response


# Route for user_create event.
@app.route("/user_create", methods=["POST"])
async def user_create():
    try:
        request = await quart.request.get_data()
        user_agent = quart.request.headers.get("User-Agent")
        if user_agent == webhook_user_agent:
            data = json.loads(request)
            write_log(f"user_create: data is present")
            auth = data.get("auth")
            is_verified = auth.get("isVerified")

            # Get the user data.
            email = auth.get("email")
            # Check if the user has a password
            has_password = auth.get("hasPassword")
            # If the user has a password, extract it
            if has_password:
                password = auth.get("password")
            else:
                password = None
            id = data.get("id")

            # get the timestamps
            created_at_ms = data.get("createdAtMs")
            updated_at_ms = data.get("updatedAtMs")

            # convert the timestamps to ISO format
            created_at = timestamp_to_iso(created_at_ms)
            updated_at = timestamp_to_iso(updated_at_ms)

            # Create the user in the database.
            database.create_user(id, email, password,
                                 created_at, updated_at, is_verified)

            return jsonify({"message": "User created successfully", "status": 201})
        else:
            write_log(f"user_create: invalid user agent {user_agent}")
            return jsonify({"message": f"Invalid user agent: {user_agent}", "status": 403})
    except Exception as e:
        write_log(f"user_create: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Route for user_update event.
@app.route("/user_update", methods=["POST"])
async def user_update():
    try:
        request = await quart.request.get_data()
        user_agent = quart.request.headers.get("User-Agent")
        if user_agent == webhook_user_agent:
            data = json.loads(request)
            write_log(f"user_update: data is present")
            # Get the before and after dictionaries from the data
            before = data.get("before")
            after = data.get("after")

            # Get the auth dictionaries from the before and after dictionaries
            before_auth = before.get("auth")
            after_auth = after.get("auth")

            # Get the email and id from the before and after auth dictionaries
            before_email = before_auth.get("email")
            before_id = before.get("id")

            after_email = after_auth.get("email")
            after_id = after.get("id")

            # Check if the user has a password before and after the update
            before_has_password = before_auth.get("hasPassword")
            after_has_password = after_auth.get("hasPassword")

            # If the user has a password before the update, extract it
            if before_has_password:
                before_password = before_auth.get("password")
            else:
                before_password = None
            # before_password = generate_random_password()
            # If the user has a password after the update, extract it
            if after_has_password:
                after_password = after_auth.get("password")
            else:
                after_password = None

            # get the timestamps before
            created_at_ms_before = before.get("createdAtMs")
            updated_at_ms_before = before.get("updatedAtMs")

            # convert the timestamps to ISO format
            created_at_before = timestamp_to_iso(created_at_ms_before)
            updated_at_before = timestamp_to_iso(updated_at_ms_before)

            is_verified_before = before.get("isVerified")

            # get the timestamps after
            created_at_ms_after = after.get("createdAtMs")
            updated_at_ms_after = after.get("updatedAtMs")

            # convert the timestamps to ISO format
            created_at_after = timestamp_to_iso(created_at_ms_after)
            updated_at_after = timestamp_to_iso(updated_at_ms_after)

            is_verified_after = after.get("isVerified")

            # check if before user data is the same as after user data
            if before_email != after_email or before_id != after_id or before_password != after_password \
                    or created_at_ms_before != created_at_ms_after or updated_at_ms_before != updated_at_ms_after or is_verified_before != is_verified_after:
                # Update the user in the database.
                database.update_user(after_id, after_email, after_password,
                                     created_at_after, updated_at_after, is_verified_after)

            # Return a success message and status code
            return jsonify({"message": "User updated successfully", "status": 201})
        else:
            write_log(f"user_update: invalid user agent {user_agent}")
            return jsonify({"message": f"Invalid user agent: {user_agent}", "status": 403})
    except Exception as e:
        write_log(f"user_update: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Route for user_quota event.
@app.route("/user_quota", methods=["POST"])
async def user_quota():
    try:
        request = await quart.request.get_data()
        user_agent = quart.request.headers.get("user-agent")
        if user_agent == webhook_user_agent:
            data = json.loads(request)
            write_log(f"user_quota: data is present")

            # Get the member and quotaInfo dictionaries from the data
            member = data.get("member")
            quotaInfo = data.get("quotaInfo")

            # Get the id dictionary from the member dictionary
            id = member.get("id")

            # Extract and rename the required information from the quotaInfo
            quota_usage = quotaInfo.get("currentUsageCount")
            quota_usage_percent = quotaInfo.get("currentUsagePercentage")
            is_quota_exceeded = quotaInfo.get("isQuotaExceeded")
            quota_interval = quotaInfo.get("quotaInterval")
            quota_limit = quotaInfo.get("quotaLimit")

            # Create a new JSON object called quota with the extracted information
            quota = {
                "quota_usage": quota_usage,
                "quota_usage_percent": quota_usage_percent,
                "is_quota_exceeded": is_quota_exceeded,
                "quota_interval": quota_interval,
                "quota_limit": quota_limit

            }
            # Update the user in the database.
            database.update_user_quota(id, quota)

            # Return a success message and status code
            return jsonify({"message": "User quota processed successfully", "status": 201})
        else:
            write_log(f"user_quota: invalid user agent {user_agent}")
            return jsonify({"message": f"Invalid user agent: {user_agent}", "status": 403})
    except Exception as e:
        write_log(f"user_quota: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Define a route for the create_quickchart endpoint with POST method
@app.route("/quick_chart", methods=["POST"])
async def create_quickchart():
    try:
        global database
        global quick_chart

        # Get the JSON data from the request body
        data = await request.get_json()
        write_log(f"quick_chart: data is {data}")

        # Return the premium error message if the user is not premium
        if not is_user_premium:
            return premium_feature_error_message()

        # Extract the chart type, labels and datasets from the data
        chart_type = data.get("chart_type")
        labels = data.get("labels").split(",")
        datasets = data.get("datasets")

        # Create a data dictionary for the chart
        chart_data = {
            "labels": labels,
            "datasets": datasets
        }

        # Create an instance of the QuickChartIO class with the base URL and the logger
        if not quick_chart:
            quick_chart = QuickChartIO(database)

        write_log(f"quick_chart: chart_type is {chart_type}")

        # Call the generate_chart method with the chart type and the chart data
        graph_file = quick_chart.generate_chart(chart_type, chart_data)
        write_log(f"quick_chart: generated chart successfully")

        download_link = quick_chart.download_link(graph_file)
        # download_link = generate_tinyurl(download_link)

        # Return a success message and status code
        response = {"output": download_link}
        response['status'] = 200
        response['message'] = "Chart generated successfully"
        response['chart_type'] = chart_type
        # response['support'] = support_message
        response['extra_response_instructions'] = extra_response_instructions + "\nFor Output graph use markdown to display it then dont use codeblock now use image tag to display it.\n\n" + "Example:\n" + "![Graph](" + download_link + ")"

        # Return the download link of the chart as a response
        return jsonify(response)
    except Exception as e:
        write_log(f"An error occurred: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Route for Plugin logo and manifest with 1-year cache. (31536000 = 1 year in seconds)
@app.route("/logo.png", methods=["GET"])
async def plugin_logo():
    try:
        response = await quart.send_file(Path("logo.png"))
        response.headers["Cache-Control"] = "public, max-age=31536000"
        return response
    except Exception as e:
        write_log(f"plugin_logo: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


@app.route("/.well-known/ai-plugin.json", methods=["GET"])
async def plugin_manifest():
    try:
        response = await quart.send_file(Path(".well-known/ai-plugin.json"))
        response.headers["Cache-Control"] = "public, max-age=31536000"
        return response
    except Exception as e:
        write_log(f"plugin_manifest: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


@app.route("/openapi.json", methods=["GET"])
async def openapi_spec():
    try:
        response = await quart.send_file(Path("openapi.json"))
        response.headers["Cache-Control"] = "public, max-age=31536000"
        return response
    except Exception as e:
        write_log(f"openapi_spec: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Docs for the plugin.
@app.route("/docs", methods=["GET"])
async def plugin_docs():
    try:
        return await quart.send_file(Path("openapi.json"))
    except Exception as e:
        write_log(f"plugin_docs: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


@app.route('/credit_limit', methods=["GET"])
async def credit_limit():
    try:
        credits_used = get_credits_used()
        return {"credits:": credits_used}
    except Exception as e:
        return jsonify({"error": str(e)}), 500


# Route for displaying help message
@app.route('/help', methods=["GET"])
async def help():
    try:
        write_log("help: Displayed for Plugin Guide")
        basic_prompts = f"{plugin_url}/download/code_runner_basic_prompts.txt"
        graph_prompts = f"{plugin_url}/download/code_runner_graph_prompts.txt"
        code_interpreter_prompts = f"{plugin_url}/download/code_runner_interpreter_prompts.txt"
        snippet_prompts = f"{plugin_url}/download/code_runner_snippet_prompts.txt"

        message = f"**Code Runner Plugin Guide**\n\n" + \
                  f"**Basic Prompts**\n\n" + basic_prompts + "\n\n" + "\nChatGPT Basic Prompts Share: " + code_runner_basic_prompt + \
                  f"**Graph Prompts**\n\n" + graph_prompts + "\n\n" + "\nChatGPT Graph Prompts Share: " + code_runner_graph_prompt + \
                  f"**Code Interpreter Prompts**\n\n" + code_interpreter_prompts + "\n\n" + " ChatGPT Interpreter Prompts Share: " + code_runner_interpreter_prompt + \
                  f"**Code Snippets Prompts**\n\n" + snippet_prompts + "\n\n" + " ChatGPT Snippets Prompts Share: " + code_runner_snippet_prompt + \
                  f"**Youtube Video**\n\n" + "https://www.youtube.com/watch?v=Ahko7E2S1R8" + "\n\n" + \
                  f"**Support**\n\n" + "\n".join(support_message.split("\n")) + "\n\n"

        response = {"message": message}
        return jsonify(response)
    except Exception as e:
        write_log(f"help: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


# Define a single method that reads the HTML content from a file and returns it as a response
@app.route("/privacy", methods=["GET"])
async def privacy_policy():
    try:
        # Define the file name
        file_name = "privacy/privacy.html"
        # Read the file content as a string
        with open(file_name, "r") as f:
            html_content = f.read()
            write_log("privacy_policy Content read success")
        # Return the HTML content as a response in quart framework
        return html_content
    except Exception as e:
        write_log(f"privacy_policy: {e}")
        return jsonify({"message": f"An error occurred: {e}", "status": 400})


@app.route("/", methods=["GET"])
async def root():
    return quart.abort(404, "Page not found")


@app.route("/robots.txt", methods=["GET"])
async def read_robots():
    try:
        response = await quart.send_file('public/robots.txt', mimetype='text/plain')
        response.headers["Cache-Control"] = "public, max-age=31536000"
        return response
    except FileNotFoundError:
        quart.abort(404, "File not found")


@app.route("/favicon.ico", methods=["GET"])
async def read_favicon():
    try:
        response = await quart.send_file('public/favicon.ico', mimetype='image/vnd.microsoft.icon')
        response.headers["Cache-Control"] = "public, max-age=31536000"
        return response
    except FileNotFoundError:
        quart.abort(404, "File not found")


def setup_database():
    try:
        database = MongoDB()
        write_log(f"Database connected successfully {database}")
        return database
    except Exception as e:
        write_log(str(e))


# Run the app.
if __name__ == "__main__":
    try:
        write_log("CodeRunner starting")
        app.run(debug=True)
        write_log("CodeRunner started")
    except Exception as e:
        write_log(str(e))