app.py

# import gradio as gr
# import json
# import os
# import sys
# import csv
# import requests
# import json
# import pandas as pd
# import concurrent.futures
# from tqdm import tqdm
# import shutil
# import numpy as np
# from matplotlib import pyplot as plt
# import pickle


# # Read list to memory
# def read_list():
#     # for reading also binary mode is important
#     with open('mean_aoc_all_papers.pkl', 'rb') as fp:
#         n_list = pickle.load(fp)
#         return n_list

# mean_citation_list = read_list()

# def generate_plot_maoc(input_maoc):
#   sns.set(font_scale = 8)
#   sns.set(rc={'figure.figsize':(10,6)})
#   sns.set_style(style='whitegrid')

#   ax = sns.histplot(mean_citation_list, bins=100, kde=True, color='skyblue')
#   kdeline = ax.lines[0]
#   xs = kdeline.get_xdata()
#   ys = kdeline.get_ydata()

#   interpolated_y_maoc = np.interp(input_maoc, kdeline.get_xdata(), kdeline.get_ydata())
#   ax.scatter(input_maoc, interpolated_y_maoc,c='r', marker='*',linewidths=5, zorder=2)
#   ax.vlines(input_maoc, 0, interpolated_y_maoc, color='tomato', ls='--', lw=2)
#   epsilon = 0.3
#   ax.text(input_maoc + epsilon, interpolated_y_maoc + epsilon, 'Your paper', {'color': '#DC143C', 'fontsize': 13})
#   ax.set_xlabel("mean Age of Citation(mAoC)",fontsize=15)
#   ax.set_ylabel("Number of papers",fontsize=15)
#   ax.tick_params(axis='both', which='major', labelsize=12)
#   return plt

# # sent a request
# def request_to_respose(request_url):
#   request_response = requests.get(request_url, headers={'x-api-key': 'qZWKkOKyzP5g9fgjyMmBt1MN2NTC6aT61UklAiyw'})
#   return request_response

# def return_clear():
#   return None, None, None, None, None


# def compute_output(ssid_paper_id):
#   output_num_ref = 0
#   output_maoc = 0
#   oldest_paper_list = ""

#   request_url = f'https://api.semanticscholar.org/graph/v1/paper/{ssid_paper_id}?fields=references,title,venue,year'
#   r = request_to_respose(request_url)
#   if r.status_code == 200: # if successful request
#     s2_ref_paper_keys = [reference_paper_tuple['paperId'] for reference_paper_tuple in r.json()['references']]
#     filtered_s2_ref_paper_keys = [s2_ref_paper_key for s2_ref_paper_key in s2_ref_paper_keys if s2_ref_paper_key is not None]
#     total_references = len(s2_ref_paper_keys)
#     none_references = (len(s2_ref_paper_keys) - len(filtered_s2_ref_paper_keys))
#     s2_ref_paper_keys = filtered_s2_ref_paper_keys

#     print(r.json())

#     s2_paper_key, title, venue, year = r.json()['paperId'], r.json()['title'], r.json()['venue'], r.json()['year']
#     reference_year_list = []
#     reference_title_list = []
#     for ref_paper_key in s2_ref_paper_keys:
#       request_url_ref = f'https://api.semanticscholar.org/graph/v1/paper/{ref_paper_key}?fields=references,title,venue,year'
#       r_ref = request_to_respose(request_url_ref)
#       if r_ref.status_code == 200:
#         s2_paper_key_ref, title_ref, venue_ref, year_ref = r_ref.json()['paperId'], r_ref.json()['title'], r_ref.json()['venue'], r_ref.json()['year']
#         reference_year_list.append(year_ref)
#         reference_title_list.append(title_ref)
    
#     print(f'Number of references for which we got the year = {len(reference_year_list)}')
#     output_num_ref = len(reference_year_list)
#     aoc_list = [year - year_ref for year_ref in reference_year_list]
#     output_maoc = sum(aoc_list)/len(aoc_list)

#     sorted_ref_title_list = [x for _,x in sorted(zip(reference_year_list,reference_title_list))]
#     sorted_ref_year_list = [x for x,_ in sorted(zip(reference_year_list,reference_title_list))]
#     text = ""
#     sorted_ref_title_list = sorted_ref_title_list[:min(len(sorted_ref_title_list), 5)]
#     sorted_ref_year_list = sorted_ref_year_list[:min(len(sorted_ref_year_list), 5)]
#     for i in range(len(sorted_ref_year_list)):
#       text += '[' + str(sorted_ref_year_list[i]) + ']' + " Title: " + sorted_ref_title_list[i] + '\n'
    
#     oldest_paper_list = text
#     plot_maoc = generate_plot_maoc(output_maoc)
#     print(plot_maoc)
  
#   return output_num_ref, output_maoc, oldest_paper_list, gr.update(value=plot_maoc)


# with gr.Blocks() as demo:
#   ss_paper_id = gr.Textbox(label='Semantic Scholar ID',placeholder="Enter the Semantic Scholar ID here and press enter...", lines=1)
#   submit_btn = gr.Button("Generate")
#   with gr.Row():
#     num_ref = gr.Textbox(label="Number of references")
#     mAoc = gr.Textbox(label="Mean AoC")
#   with gr.Row():
#     oldest_paper_list = gr.Textbox(label="Top 5 oldest papers cited:",lines=5)
#   with gr.Row():
#     mAocPlot = gr.Plot(label="Plot")
  
#   clear_btn = gr.Button("Clear")
  
#   submit_btn.click(fn = compute_output, inputs = [ss_paper_id], outputs = [num_ref, mAoc, oldest_paper_list, mAocPlot])
#   # clear_btn.click(lambda: None, None, None, queue=False)
#   clear_btn.click(fn = return_clear, inputs=[], outputs=[ss_paper_id, num_ref, mAoc, oldest_paper_list, mAocPlot])

# demo.launch()

import openai
import gradio

openai.api_key = "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"

messages = [{"role": "system", "content": "Anhub Online Education Tutor for Any Subjects:"}]

def CustomChatGPT(user_input):
    messages.append({"role": "user", "content": user_input})
    response = openai.ChatCompletion.create(
        model = "gpt-3.5-turbo",
        messages = messages
    )
    ChatGPT_reply = response["choices"][0]["message"]["content"]
    messages.append({"role": "assistant", "content": ChatGPT_reply})
    return ChatGPT_reply

demo = gradio.Interface(fn=CustomChatGPT, inputs = "text", outputs = "text", title = "Anhub Metaverse Education Online Tutor for Any Subjects and any Languages @ 24 x 7:")



demo.launch()