ACTUALLY switched to Resume Roasting

app.py

@@ -1,22 +1,15 @@
-from dotenv import load_dotenv
-import os
+import yaml
 from smolagents import CodeAgent, HfApiModel
 from smolagents.tools import Tool
-import yaml
-
-# Load environment variables from .env in the root
-load_dotenv()
-
-# Retrieve the Hugging Face token from the environment
-hf_token = os.getenv("HF_TOKEN")
+from tools.resumescraper import ResumeScraperTool
 
 class FinalAnswerTool(Tool):
     name = "final_answer"
-    description = "Use this tool to provide your final answer"
+    description = "Use this tool to provide your final roast"
     inputs = {
         "answer": {
             "type": "string",
-            "description": "The final answer to the problem"
+            "description": "The final roast for the resume"
         }
     }
     output_type = "string"
@@ -24,29 +17,11 @@ class FinalAnswerTool(Tool):
     def forward(self, answer: str) -> str:
         return answer
 
-class LinkedInScraperTool(Tool):
-    name = "linkedin_scraper"
-    description = "Scrapes LinkedIn profiles to extract professional information"
-    inputs = {
-        "linkedin_url": {
-            "type": "string",
-            "description": "The URL of the LinkedIn profile"
-        }
-    }
-    output_type = "object"
-
-    def forward(self, linkedin_url: str):
-        # Dummy implementation; replace with actual scraping logic
-        return {
-            "experience": "10 years in industry",
-            "skills": "Python, AI",
-            "description": "Experienced professional with a robust background in technology."
-        }
-
 def create_agent():
     final_answer = FinalAnswerTool()
-    linkedin_scraper = LinkedInScraperTool()
+    resume_scraper = ResumeScraperTool()
     
+    # Use Qwen/Qwen2.5-Coder-32B-Instruct for roasting
     model = HfApiModel(
         max_tokens=2096,
         temperature=0.5,
@@ -59,7 +34,7 @@ def create_agent():
         
     agent = CodeAgent(
         model=model,
-        tools=[linkedin_scraper, final_answer],
+        tools=[resume_scraper, final_answer],
         max_steps=6,
         verbosity_level=1,
         prompt_templates=prompt_templates

main.py

@@ -1,21 +1,58 @@
 import gradio as gr
+import io
+from PyPDF2 import PdfReader
 from app import create_agent
 
-def roast_profile(linkedin_url):
+def extract_text_from_pdf(file_obj) -> str:
+    reader = PdfReader(file_obj)
+    text = ""
+    for page in reader.pages:
+        page_text = page.extract_text()
+        if page_text:
+            text += page_text + "\n"
+    return text
+
+def process_resume(input_method, resume_text, pdf_file):
+    if input_method == "Text":
+        text = resume_text
+    else:
+        if pdf_file is None:
+            return "No PDF uploaded."
+        # Check if pdf_file is a string (i.e. a file path) or a file-like object
+        if isinstance(pdf_file, str):
+            with open(pdf_file, "rb") as f:
+                file_bytes = f.read()
+        else:
+            file_bytes = pdf_file.read()
+        file_obj = io.BytesIO(file_bytes)
+        text = extract_text_from_pdf(file_obj)
+    
+    if not text.strip():
+        return "No resume text found."
+    
     agent = create_agent()
-    response = agent.run(
-        f"Scrape this LinkedIn profile: {linkedin_url} and create a humorous but not mean-spirited roast based on their experience, skills, and description. Keep it professional and avoid personal attacks."
-    )
+    # Instruct the agent to roast the resume using the resume text.
+    response = agent.run(f"Roast this resume: {text}")
     return response
 
-demo = gr.Interface(
-    fn=roast_profile,
-    inputs=gr.Textbox(label="LinkedIn Profile URL"),
-    outputs=gr.Textbox(label="Roast Result"),
-    title="LinkedIn Profile Roaster",
-    description="Enter a LinkedIn profile URL and get a humorous professional roast!",
-    examples=[["https://www.linkedin.com/in/example-profile"]]
-)
 
-if __name__ == "__main__":
-    demo.launch(share=True)
+def toggle_inputs(method):
+    if method == "Text":
+        return gr.update(visible=True), gr.update(visible=False)
+    else:
+        return gr.update(visible=False), gr.update(visible=True)
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Resume Roaster")
+    gr.Markdown("Enter your resume as text or upload a PDF to receive a humorous, professional roast!")
+    
+    input_method = gr.Radio(choices=["Text", "PDF"], label="Input Method", value="Text")
+    resume_text = gr.Textbox(label="Resume Text", lines=10, visible=True)
+    pdf_file = gr.File(label="Upload Resume PDF", file_types=[".pdf"], visible=False)
+    output = gr.Textbox(label="Roast Result", lines=10)
+    submit_btn = gr.Button("Roast It!")
+    
+    input_method.change(fn=toggle_inputs, inputs=input_method, outputs=[resume_text, pdf_file])
+    submit_btn.click(fn=process_resume, inputs=[input_method, resume_text, pdf_file], outputs=output)
+    
+demo.launch(share=True)

prompts.yaml

@@ -1,22 +1,16 @@
 system_prompt: |
-  You are a witty professional roaster who analyzes LinkedIn profiles.
-  Your job is to create humorous but not mean-spirited roasts based on people's professional experiences.
-  Focus on gentle teasing about common LinkedIn behaviors like:
-  - Overuse of buzzwords
-  - Lengthy job titles
-  - Humble brags
-  - Excessive use of emojis
-  - Connection collecting
-  Avoid personal attacks or inappropriate content.
+  You are a witty professional roaster who analyzes resumes.
+  Your job is to create a humorous, professional roast of a resume.
+  Focus on teasing overly verbose descriptions, excessive buzzwords, and generic statements,
+  while keeping the tone light and appropriate for a professional setting.
 
 task_prompt: |
-  Using the provided LinkedIn profile information, create a humorous roast that:
-  1. References specific details from their profile
-  2. Keeps the tone light and professional
-  3. Focuses on common LinkedIn behaviors and professional quirks
-  4. Avoids mean-spirited or personal attacks
-  5. Would be appropriate to share in a professional setting
+  Using the provided resume details, craft a roast that:
+  1. References key sections such as Summary, Experience, Education, and Skills.
+  2. Is humorous but not mean-spirited.
+  3. Maintains a professional tone.
+  4. Adds creative flair that makes the roast both entertaining and insightful.
 
 final_answer:
-  pre_messages: "Here is your final roast:"
+  pre_messages: "Final Roast:"
   post_messages: ""

tools/LinkedInScraperTool.py

@@ -1,77 +0,0 @@
-from bs4 import BeautifulSoup
-import requests
-from typing import Dict
-from smolagents.tools import Tool
-
-class LinkedInScraperTool(Tool):
-    name = "linkedin_scraper"
-    description = "Scrapes LinkedIn profiles to extract professional information"
-    inputs = {"linkedin_url": str}
-    outputs = dict
-
-    def __call__(self, linkedin_url: str) -> dict:
-        try:
-            # Add headers to mimic a browser request
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-            }
-            
-            response = requests.get(linkedin_url, headers=headers)
-            soup = BeautifulSoup(response.text, 'html.parser')
-            
-            # Extract profile information
-            profile_data = {
-                'name': self._extract_name(soup),
-                'headline': self._extract_headline(soup),
-                'about': self._extract_about(soup),
-                'experience': self._extract_experience(soup),
-                'education': self._extract_education(soup),
-                'skills': self._extract_skills(soup)
-            }
-            
-            return profile_data
-            
-        except Exception as e:
-            return {"error": f"Failed to scrape profile: {str(e)}"}
-    
-    def _extract_name(self, soup):
-        name_element = soup.find('h1', {'class': 'text-heading-xlarge'})
-        return name_element.text.strip() if name_element else "Name not found"
-    
-    def _extract_headline(self, soup):
-        headline_element = soup.find('div', {'class': 'text-body-medium'})
-        return headline_element.text.strip() if headline_element else "Headline not found"
-    
-    def _extract_about(self, soup):
-        about_element = soup.find('div', {'class': 'pv-about-section'})
-        return about_element.text.strip() if about_element else "About section not found"
-    
-    def _extract_experience(self, soup):
-        experience_elements = soup.find_all('li', {'class': 'experience-item'})
-        experience = []
-        for exp in experience_elements:
-            title_element = exp.find('h3', {'class': 'experience-title'})
-            company_element = exp.find('p', {'class': 'experience-company'})
-            if title_element and company_element:
-                experience.append({
-                    'title': title_element.text.strip(),
-                    'company': company_element.text.strip()
-                })
-        return experience if experience else ["Experience not found"]
-    
-    def _extract_education(self, soup):
-        education_elements = soup.find_all('li', {'class': 'education-item'})
-        education = []
-        for edu in education_elements:
-            school_element = edu.find('h3', {'class': 'education-school'})
-            degree_element = edu.find('p', {'class': 'education-degree'})
-            if school_element and degree_element:
-                education.append({
-                    'school': school_element.text.strip(),
-                    'degree': degree_element.text.strip()
-                })
-        return education if education else ["Education not found"]
-    
-    def _extract_skills(self, soup):
-        skills_elements = soup.find_all('span', {'class': 'skill-name'})
-        return [skill.text.strip() for skill in skills_elements] if skills_elements else ["Skills not found"]