Laura's UI changes

app.py

@@ -1,5 +1,6 @@
 import os
 import urllib.request
+from dataclasses import dataclass
 from time import sleep
 from typing import Dict, List, Generator
 
@@ -9,44 +10,68 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
+@dataclass(eq=True, frozen=True)
+class Config:
+    job_role: str
+    company: str 
+    job_description: str
+    behavioral_count: int
+    technical_count: int
+    situational_count: int 
+    case_count: int
+
 class MockInterviewer:
 
     def __init__(self) -> None:
         self._client = OpenAI(api_key=os.environ['OPENAI_API_KEY'])
-        self._assistant_id_cache: Dict[str, str] = {}
+        self._assistant_id_cache: Dict[Config, str] = {}
         self.clear_thread()
 
-    def chat_with_text(self, message: Dict, history: List[List], job_role: str, company: str) -> Generator:
-        yield self._chat(message.get('text'), job_role, company)
-
-    def chat_with_audio(self, audio: str, job_role: str, company: str) -> str:
+    def chat_with_text(
+        self, 
+        message: Dict, 
+        history: List[List],
+        job_role: str, 
+        company: str, 
+        job_description: str,
+        behavioral_count: int, 
+        technical_count: int, 
+        situational_count: int, 
+        case_count: int
+    ) -> Generator:
+        config = Config(job_role, company, job_description, behavioral_count, technical_count, situational_count, case_count)
+        yield self._chat(message, config)
+
+    def chat_with_audio(
+        self, 
+        audio: str,
+        job_role: str, 
+        company: str, 
+        job_description: str,
+        behavioral_count: int, 
+        technical_count: int, 
+        situational_count: int, 
+        case_count: int
+    ) -> str:
         with open(audio, 'rb') as audio_file:
             transcriptions = self._client.audio.transcriptions.create(
                 model='whisper-1',
                 file=audio_file,
             )
         os.remove(audio)
-        response = self._chat(transcriptions.text, job_role, company)
+        config = Config(job_role, company, job_description, behavioral_count, technical_count, situational_count, case_count)
+        response = self._chat(transcriptions.text, config)
         return [(transcriptions.text, response)]
     
     def clear_thread(self) -> None:
         print('Initializing new thread')
         self._thread = self._client.beta.threads.create() 
     
-    def _chat(self, message: str, job_role: str, company: str) -> str:
+    def _chat(self, message: str, config: Config) -> str:
         print('Started chat')
-        self._validate_fields(job_role, company)
-        assistant_id = self._init_assistant(job_role, company)
+        assistant_id = self._init_assistant(config)
         return self._send_message(message, assistant_id)
 
-    def _validate_fields(self, job_role: str, company: str) -> None:
-        if not job_role and not company:
-            raise gr.Error('Job Role and Company are required fields.')
-        if not job_role:
-            raise gr.Error('Job Role is a required field.')
-        if not company:
-            raise gr.Error('Company is a required field.')
-
     def _send_message(self, message: str, assistant_id: str) -> str:
         self._client.beta.threads.messages.create(thread_id=self._thread.id, role='user', content=message)
         print('Message created')
@@ -82,18 +107,18 @@ class MockInterviewer:
         os.remove(filename)
         return file_ids
 
-    def _init_assistant(self, job_role: str, company: str) -> str:
-        cache_key = self._create_cache_key(job_role, company)
+    def _init_assistant(self, config: Config) -> str:
+        cache_key = config
         if cache_key in self._assistant_id_cache:
             print(f'Fetched from cache for key {cache_key}')
             return self._assistant_id_cache.get(cache_key)
         else:
             print(f'Initializing new assistant for key {cache_key}')
-            file_ids = self._create_files(company)
+            file_ids = self._create_files(config.company)
 
             assistant = self._client.beta.assistants.create(
                 name='Mock Interviewer',
-                instructions=f'You are an AI mock interviewer for {job_role} roles at {company}. Please make it obvious this is your purpose. If you have been provided a file, use it as an interview guide.',
+                instructions=self._generate_assistant_instructions(config),
                 model='gpt-4-0125-preview',
                 tools=[
                     {
@@ -104,35 +129,73 @@ class MockInterviewer:
             
             self._assistant_id_cache[cache_key] = assistant.id
             return assistant.id
+    
+    def _generate_assistant_instructions(self, config: Config) -> str:
+        if config.job_role and config.company:
+            purpose = f'You are Ami, an AI mock interviewer for {config.job_role} roles at {config.company}.'
+        elif config.job_role:
+            purpose = f'You are Ami, an AI mock interviewer for {config.job_role} roles.'
+        elif config.company:
+            purpose = f'You are Ami, an AI mock interviewer for roles at {config.company}.'
+        else:
+            purpose = 'You are Ami, an AI mock interviewer.'
+        
+        if config.job_description:
+            specifics = f'Tailor your questions based on the following job posting: {config.job_description}.'
+        else:
+            specifics = ''
+
+        return f"{purpose} Please state your purpose when the candidate sends you the first message. If you have been provided a file, use it as an interview guide. {specifics} Ask {config.behavioral_count} number of behavioral questions, {config.technical_count} number of technical questions, {config.situational_count} number of situational questions, and {config.case_count} number of case-like questions. After the candidate gives a response, evaluate the response of the candidate by addressing the candidate as if you were giving feedback to them (i.e. address them as you). Keep in mind what your company values in candidates. Provide a detailed analysis of the candidate's response based on the question type. Also, rate the response on a scale from 1 to 10, where 1 is inadequate and 10 is exceptional."
 
-    def _create_cache_key(self, job_role: str, company: str) -> str:
-        return f'{job_role.lower()}+{company.lower()}'
+mock_interviewer = MockInterviewer()
 
-# Creating the Gradio interface
-with gr.Blocks() as demo:
-    mock_interviewer = MockInterviewer()
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="indigo",
+).set(
+    body_background_fill='*neutral_100',
+    body_background_fill_dark='*background_fill_secondary'
+)
 
+with gr.Blocks(theme=theme) as demo:
     with gr.Row():
-        job_role = gr.Textbox(label='Job Role', placeholder='Product Manager')
-        company = gr.Textbox(label='Company', placeholder='Amazon')
-
-    chat_interface = gr.ChatInterface(
-        fn=mock_interviewer.chat_with_text,
-        additional_inputs=[job_role, company],
-        title='I am your AI mock interviewer',
-        description='Make your selections above to configure me.',
-        multimodal=True,
-        retry_btn=None,
-        undo_btn=None).queue()
-
-    chat_interface.load(mock_interviewer.clear_thread)
-    chat_interface.clear_btn.click(mock_interviewer.clear_thread)
-
-    audio = gr.Audio(sources=['microphone'], type='filepath', editable=False)
-    audio.stop_recording(fn=mock_interviewer.chat_with_audio,
-                         inputs=[audio, job_role, company],
-                         outputs=[chat_interface.chatbot],
-                         api_name=False)
+        with gr.Column(variant='panel', scale=1):
+            config_title = gr.Markdown('### Interview Settings')
+            with gr.Accordion("Job Information", open=False):
+                job_role = gr.Textbox(label='Job Role', placeholder='Product Manager')
+                company = gr.Textbox(label='Company', placeholder='Amazon')
+                job_description = gr.TextArea(
+                    label='Job Description', 
+                    info='Please copy and paste any relevant job description and information here:', 
+                    placeholder='Key job responsibilities, basic qualifications, preferred qualifications, about the company, etc.'
+                )
+            with gr.Accordion("Question Preferences", open=False):
+                label='Question Type and Count'
+                info='Please indicate how many questions you would like asked on the following question types:',
+                behavioral_count = gr.Slider(label="Behavioral", maximum=10, value=1, step=1)
+                technical_count = gr.Slider(label="Technical", maximum=10, value=1, step=1)
+                situational_count = gr.Slider(label="Situational", maximum=10, value=1, step=1)
+                case_count = gr.Slider(label="Case", maximum=10, value=1, step=1)
+
+        with gr.Column(variant='panel', scale=6):
+            chat_interface = gr.ChatInterface(
+                fn=mock_interviewer.chat_with_text,
+                title="Hi! I'm Ami, your AI Mock Interviewer.",
+                description='You can begin by clicking record and introducing yourself!',
+                additional_inputs=[job_role, company, job_description, behavioral_count, technical_count, situational_count, case_count],
+                retry_btn=None,
+                undo_btn=None)
+            
+            chat_interface.chatbot.height= '45vh'
+
+            chat_interface.load(mock_interviewer.clear_thread)
+            chat_interface.clear_btn.click(mock_interviewer.clear_thread)
+
+            audio = gr.Audio(sources=['microphone'], type='filepath', editable=False)
+            audio.stop_recording(fn=mock_interviewer.chat_with_audio,
+                                inputs=[audio, job_role, company, job_description, behavioral_count, technical_count, situational_count, case_count],
+                                outputs=[chat_interface.chatbot],
+                                api_name=False)
 
 if __name__ == '__main__':
-    demo.launch().queue()
+    demo.launch()