hey i have this code :
import os
import urllib.request
from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline
from utils.pdf_parser import parse_pdf
from mongodb_connection import connect_to_mongodb
import json

# Path to the PDF resume
resume_path = "/workspace/react/Api/data/resumes/test.pdf"
print(f"Resume path: {resume_path}")

# Parse the text from the PDF resume
print("Parsing text from the PDF resume...")
text = parse_pdf(resume_path)
print("Parsed text:")
print(text)

# Extract named entities using bert-base-ner
print("Extracting named entities using bert-base-ner...")
tokenizer = AutoTokenizer.from_pretrained("dslim/bert-base-NER")
model = AutoModelForTokenClassification.from_pretrained("dslim/bert-base-NER")
nlp = pipeline("ner", model=model, tokenizer=tokenizer)
ner_results = nlp(text)
print("Named entities:")
print(ner_results)

# Convert the named entities to a JSON format
print("Converting named entities to JSON format...")
""" categories = ["Education / training", "Obtained degree", "Teaching experience", "Certification", "Work experience/employment history", "Interests/hobbies", "Language(s)"] """
categories = ["Name", "Email", "Phone Number", "Address", "Summary", "Education", "Experience", "Skills", "Certifications", "Languages", "Interests"]
doc = {
    "name": "",
    "email": "",
    "phone": "",
    "summary": "",
    "education": [],
    "experience": [],
    "certifications": [],
    "interests": [],
    "languages": [],
    "skills": []
}
for category in categories:
    category_entities = []
    for entity in ner_results:
        if entity["entity"] == category:
            category_entities.append(entity)
    for entity in category_entities:
        if entity["entity"] == "Name":
            doc["name"] = entity["word"]
        elif entity["entity"] == "Email":
            doc["email"] = entity["word"]
        elif entity["entity"] == "Phone Number":
            doc["phone"] = entity["word"]
        elif entity["entity"] == "Summary":
            doc["summary"] = entity["word"]
        elif entity["entity"] == "Education / training":
            education = {
                "category": "Education / training",
                "degree": "",
                "major": "",
                "school": "",
                "graduation_year": ""
            }
            for sub_entity in entity["sub_entities"]:
                if sub_entity["entity"] == "Degree":
                    education["degree"] = sub_entity["word"]
                elif sub_entity["entity"] == "Major":
                    education["major"] = sub_entity["word"]
                elif sub_entity["entity"] == "School":
                    education["school"] = sub_entity["word"]
                elif sub_entity["entity"] == "Graduation Year":
                    education["graduation_year"] = sub_entity["word"]
            doc["education"].append(education)
        elif entity["entity"] == "Obtained degree":
            degree = {
                "category": "Obtained degree",
                "degree": "",
                "major": "",
                "school": "",
                "graduation_year": ""
            }
            for sub_entity in entity["sub_entities"]:
                if sub_entity["entity"] == "Degree":
                    degree["degree"] = sub_entity["word"]
                elif sub_entity["entity"] == "Major":
                    degree["major"] = sub_entity["word"]
                elif sub_entity["entity"] == "School":
                    degree["school"] = sub_entity["word"]
                elif sub_entity["entity"] == "Graduation Year":
                    degree["graduation_year"] = sub_entity["word"]
            doc["education"].append(degree)
        elif entity["entity"] == "Teaching experience":
            experience = {
                "category": "Teaching experience",
                "title": "",
                "school": "",
                "start_date": "",
                "end_date": "",
                "description": ""
            }
            for sub_entity in entity["sub_entities"]:
                if sub_entity["entity"] == "Title":
                    experience["title"] = sub_entity["word"]
                elif sub_entity["entity"] == "School":
                    experience["school"] = sub_entity["word"]
                elif sub_entity["entity"] == "Start Date":
                    experience["start_date"] = sub_entity["word"]
                elif sub_entity["entity"] == "End Date":
                    experience["end_date"] = sub_entity["word"]
                elif sub_entity["entity"] == "Description":
                    experience["description"] = sub_entity["word"]
            doc["experience"].append(experience)
        elif entity["entity"] == "Certification":
            certification = {
                "category": "Certification",
                "name": "",
                "issuing_organization": "",
                "issue_date": "",
                "expiration_date": ""
            }
            for sub_entity in entity["sub_entities"]:
                if sub_entity["entity"] == "Name":
                    certification["name"] = sub_entity["word"]
                elif sub_entity["entity"] == "Issuing Organization":
                    certification["issuing_organization"] = sub_entity["word"]
                elif sub_entity["entity"] == "Issue Date":
                    certification["issue_date"] = sub_entity["word"]
                elif sub_entity["entity"] == "Expiration Date":
                    certification["expiration_date"] = sub_entity["word"]
            doc["certifications"].append(certification)
        elif entity["entity"] == "Work experience/employment history":
            experience = {
                "category": "Work experience/employment history",
                "title": "",
                "company": "",
                "start_date": "",
                "end_date": "",
                "description": ""
            }
            for sub_entity in entity["sub_entities"]:
                if sub_entity["entity"] == "Title":
                    experience["title"] = sub_entity["word"]
                elif sub_entity["entity"] == "Company":
                    experience["company"] = sub_entity["word"]
                elif sub_entity["entity"] == "Start Date":
                    experience["start_date"] = sub_entity["word"]
                elif sub_entity["entity"] == "End Date":
                    experience["end_date"] = sub_entity["word"]
                elif sub_entity["entity"] == "Description":
                    experience["description"] = sub_entity["word"]
            doc["experience"].append(experience)
        elif entity["entity"] == "Interests/hobbies":
            interest = {
                "category": "Interests/hobbies",
                "name": entity["word"]
            }
            doc["interests"].append(interest)
        elif entity["entity"] == "Language(s)":
            language = {
                "category": "Language(s)",
                "name": entity["word"]
            }
            doc["languages"].append(language)
        elif entity["entity"] == "Skills":
            skill = {
                "category": "Skills",
                "name": entity["word"]
            }
            doc["skills"].append(skill)



print(doc)

# Store the named entities in a MongoDB database
""" print("Storing named entities in MongoDB...")
collection = connect_to_mongodb() """

""" # Insert the JSON document into MongoDB
result = collection.insert_one(doc)

print(f"Inserted document with id: {result.inserted_id}") """


that do this :

 this code extracts named entities from a PDF resume using the BERT model and stores them in a MongoDB database. It first parses the text from the PDF file, then extracts named entities using the BERT model. The named entities are then organized into a Python dictionary with predefined categories, and this dictionary is stored in a MongoDB database. The code demonstrates how to use the BERT model and MongoDB to extract and store information from PDF resumes.



bu ti wnat to change the model to work with this model :
import gradio as gr
import os
import sys
import json 
import requests

MODEL = "gpt-3.5-turbo"
API_URL = os.getenv("API_URL")
DISABLED = os.getenv("DISABLED") == 'True'
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
NUM_THREADS = int(os.getenv("NUM_THREADS"))

print (NUM_THREADS)

def exception_handler(exception_type, exception, traceback):
    print("%s: %s" % (exception_type.__name__, exception))
sys.excepthook = exception_handler
sys.tracebacklimit = 0

#https://github.com/gradio-app/gradio/issues/3531#issuecomment-1484029099
def parse_codeblock(text):
    lines = text.split("\n")
    for i, line in enumerate(lines):
        if "```" in line:
            if line != "```":
                lines[i] = f'<pre><code class="{lines[i][3:]}">'
            else:
                lines[i] = '</code></pre>'
        else:
            if i > 0:
                lines[i] = "<br/>" + line.replace("<", "&lt;").replace(">", "&gt;")
    return "".join(lines)
    
def predict(inputs, top_p, temperature, chat_counter, chatbot, history, request:gr.Request):
    payload = {
        "model": MODEL,
        "messages": [{"role": "user", "content": f"{inputs}"}],
        "temperature" : 1.0,
        "top_p":1.0,
        "n" : 1,
        "stream": True,
        "presence_penalty":0,
        "frequency_penalty":0,
    }

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {OPENAI_API_KEY}",
        "Headers": f"{request.kwargs['headers']}"
    }

    # print(f"chat_counter - {chat_counter}")
    if chat_counter != 0 :
        messages = []
        for i, data in enumerate(history):
            if i % 2 == 0:
                role = 'user'
            else:
                role = 'assistant'
            message = {}
            message["role"] = role
            message["content"] = data
            messages.append(message)
        
        message = {}
        message["role"] = "user" 
        message["content"] = inputs
        messages.append(message)
        payload = {
            "model": MODEL,
            "messages": messages,
            "temperature" : temperature,
            "top_p": top_p,
            "n" : 1,
            "stream": True,
            "presence_penalty":0,
            "frequency_penalty":0,
        }

    chat_counter += 1

    history.append(inputs)
    token_counter = 0 
    partial_words = "" 
    counter = 0

    try:
        # make a POST request to the API endpoint using the requests.post method, passing in stream=True
        response = requests.post(API_URL, headers=headers, json=payload, stream=True)
        response_code = f"{response}"
        #if response_code.strip() != "<Response [200]>":
        #    #print(f"response code - {response}")
        #    raise Exception(f"Sorry, hitting rate limit. Please try again later. {response}")
        
        for chunk in response.iter_lines():
            #Skipping first chunk
            if counter == 0:
                counter += 1
                continue
                #counter+=1
            # check whether each line is non-empty
            if chunk.decode() :
                chunk = chunk.decode()
                # decode each line as response data is in bytes
                if len(chunk) > 12 and "content" in json.loads(chunk[6:])['choices'][0]['delta']:
                    partial_words = partial_words + json.loads(chunk[6:])['choices'][0]["delta"]["content"]
                    if token_counter == 0:
                        history.append(" " + partial_words)
                    else:
                        history[-1] = partial_words
                    token_counter += 1
                    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=False), gr.update(interactive=False)  # resembles {chatbot: chat, state: history}  
    except Exception as e:
        print (f'error found: {e}')
    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=True), gr.update(interactive=True)
    print(json.dumps({"chat_counter": chat_counter, "payload": payload, "partial_words": partial_words, "token_counter": token_counter, "counter": counter}))
                   

def reset_textbox():
    return gr.update(value='', interactive=False), gr.update(interactive=False)

title = """<h1 align="center">GPT-3.5 Chatbot</h1>"""
if DISABLED:
    title = """<h1 align="center" style="color:red">This app has reached OpenAI's usage limit. We are currently requesting an increase in our quota. Please check back in a few days.</h1>"""
description = """Language models can be conditioned to act like dialogue agents through a conversational prompt that typically takes the form:
```
User: <utterance>
Assistant: <utterance>
User: <utterance>
Assistant: <utterance>
...
```
In this app, you can explore the outputs of a gpt-3.5 LLM.
"""

theme = gr.themes.Default(primary_hue="green")                

with gr.Blocks(css = """#col_container { margin-left: auto; margin-right: auto;}
                #chatbot {height: 520px; overflow: auto;}""",
              theme=theme) as demo:
    gr.HTML(title)
    gr.HTML("""<h3 align="center">This app provides you full access to GPT-3.5 (4096 token limit). You don't need any OPENAI API key.</h1>""")
    #gr.HTML('''<center><a href="https://huggingface.co/spaces/yuntian-deng/ChatGPT?duplicate=true"><img src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>Duplicate the Space and run securely with your OpenAI API Key</center>''')
    with gr.Column(elem_id = "col_container", visible=False) as main_block:
        #API Key is provided by OpenAI 
        #openai_api_key = gr.Textbox(type='password', label="Enter only your OpenAI API key here")
        chatbot = gr.Chatbot(elem_id='chatbot') #c
        inputs = gr.Textbox(placeholder= "Hi there!", label= "Type an input and press Enter") #t
        state = gr.State([]) #s
        with gr.Row():
            with gr.Column(scale=7):
                b1 = gr.Button(visible=not DISABLED).style(full_width=True)
            with gr.Column(scale=3):
                server_status_code = gr.Textbox(label="Status code from OpenAI server", )
    
        #inputs, top_p, temperature, top_k, repetition_penalty
        with gr.Accordion("Parameters", open=False):
            top_p = gr.Slider( minimum=-0, maximum=1.0, value=1.0, step=0.05, interactive=True, label="Top-p (nucleus sampling)",)
            temperature = gr.Slider( minimum=-0, maximum=5.0, value=1.0, step=0.1, interactive=True, label="Temperature",)
            #top_k = gr.Slider( minimum=1, maximum=50, value=4, step=1, interactive=True, label="Top-k",)
            #repetition_penalty = gr.Slider( minimum=0.1, maximum=3.0, value=1.03, step=0.01, interactive=True, label="Repetition Penalty", )
            chat_counter = gr.Number(value=0, visible=False, precision=0)
    
    with gr.Column(elem_id = "user_consent_container") as user_consent_block:
        # Get user consent
        accept_checkbox = gr.Checkbox(visible=False)
        js = "(x) => confirm('By clicking \"OK\", I agree that my data may be published or shared.')"
        with gr.Accordion("User Consent for Data Collection, Use, and Sharing", open=True):
            gr.HTML("""
            <div>
                <p>By using our app, which is powered by OpenAI's API, you acknowledge and agree to the following terms regarding the data you provide:</p>
                <ol>
                    <li><strong>Collection:</strong> We may collect information, including the inputs you type into our app, the outputs generated by OpenAI's API, and certain technical details about your device and connection (such as browser type, operating system, and IP address) provided by your device's request headers.</li>
                    <li><strong>Use:</strong> We may use the collected data for research purposes, to improve our services, and to develop new products or services, including commercial applications, and for security purposes, such as protecting against unauthorized access and attacks.</li>
                    <li><strong>Sharing and Publication:</strong> Your data, including the technical details collected from your device's request headers, may be published, shared with third parties, or used for analysis and reporting purposes.</li>
                    <li><strong>Data Retention:</strong> We may retain your data, including the technical details collected from your device's request headers, for as long as necessary.</li>
                </ol>
                <p>By continuing to use our app, you provide your explicit consent to the collection, use, and potential sharing of your data as described above. If you do not agree with our data collection, use, and sharing practices, please do not use our app.</p>
            </div>
            """)
            accept_button = gr.Button("I Agree")

        def enable_inputs():
            return user_consent_block.update(visible=False), main_block.update(visible=True)

    accept_button.click(None, None, accept_checkbox, _js=js, queue=False)
    accept_checkbox.change(fn=enable_inputs, inputs=[], outputs=[user_consent_block, main_block], queue=False)

    inputs.submit(reset_textbox, [], [inputs, b1], queue=False)
    inputs.submit(predict, [inputs, top_p, temperature, chat_counter, chatbot, state], [chatbot, state, chat_counter, server_status_code, inputs, b1],)  #openai_api_key
    b1.click(reset_textbox, [], [inputs, b1], queue=False)
    b1.click(predict, [inputs, top_p, temperature, chat_counter, chatbot, state], [chatbot, state, chat_counter, server_status_code, inputs, b1],)  #openai_api_key
             
    demo.queue(max_size=20, concurrency_count=NUM_THREADS, api_open=False).launch(share=False)