added concurrency

app.py

@@ -5,6 +5,7 @@ import os
 import time
 from typing import List, Dict, Any
 from dotenv import load_dotenv
+import concurrent.futures
 
 # Load environment variables
 load_dotenv(".env.local")
@@ -115,6 +116,38 @@ def process_skill_quality(text: str) -> Dict:
     
     return result
 
+def process_skill_quality_batch(sentences):
+    """Process multiple sentences through the skill quality endpoint concurrently"""
+    results = []
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future_to_sentence = {
+            executor.submit(process_skill_quality, sentence): sentence 
+            for sentence in sentences
+        }
+        
+        for future in concurrent.futures.as_completed(future_to_sentence):
+            sentence = future_to_sentence[future]
+            try:
+                quality_score = future.result()
+                is_leadership = quality_score["leadership_token"] == "Yes"
+                is_collaboration = not is_leadership and quality_score["collaboration_token"] == "Yes"
+                results.append({
+                    "sentence": sentence,
+                    "is_leadership": is_leadership,
+                    "is_collaboration": is_collaboration,
+                    "raw_score": quality_score
+                })
+            except Exception as e:
+                print(f"Error processing sentence: {sentence[:30]}... - {str(e)}")
+                results.append({
+                    "sentence": sentence,
+                    "is_leadership": False,
+                    "is_collaboration": False,
+                    "raw_score": {"leadership": 0, "leadership_token": "No", "collaboration": 0, "collaboration_token": "No"}
+                })
+    
+    return results
+
 def process_resume(resume_text: str, job_skills: List[str], progress=None, progress_base=0.4, progress_cap=0.9) -> Dict:
     """Process resume using the resume endpoint"""
     payload = {"inputs": resume_text}
@@ -152,7 +185,7 @@ def process_resume(resume_text: str, job_skills: List[str], progress=None, progr
     all_skills = []
     processed_sentences = 0
     
-    # Process skill quality for each role description
+    # Process skill quality for each role description concurrently
     for job in result:
         if "skills" in job:
             for skill in job["skills"]:
@@ -160,28 +193,22 @@ def process_resume(resume_text: str, job_skills: List[str], progress=None, progr
                 skill["text"] = skill.get("name", "Unknown Skill")
                 all_skills.append(skill)
         
-        # Process skill quality for each bullet point in the job description
-        if "description" in job:
-            quality_scores = []
-            for sentence in job.get("description", []):
-                quality_score = process_skill_quality(sentence)
-                # Prioritize leadership over collaboration if both are "Yes"
-                is_leadership = quality_score["leadership_token"] == "Yes"
-                is_collaboration = not is_leadership and quality_score["collaboration_token"] == "Yes"
-                quality_scores.append({
-                    "sentence": sentence,
-                    "is_leadership": is_leadership,
-                    "is_collaboration": is_collaboration
-                })
-                
-                # Update progress
-                processed_sentences += 1
-                try:
-                    if progress is not None and total_sentences > 0:
-                        progress_value = progress_base + (progress_step * processed_sentences)
-                        progress(progress_value, desc=f"Processing {processed_sentences}/{total_sentences} sentences...")
-                except:
-                    pass
+        # Process skill quality for sentences in parallel
+        if "description" in job and job["description"]:
+            # Get all sentences for this job
+            sentences = job.get("description", [])
+            
+            # Process all sentences for this job concurrently
+            quality_scores = process_skill_quality_batch(sentences)
+            
+            # Update progress after batch processing
+            processed_sentences += len(sentences)
+            try:
+                if progress is not None and total_sentences > 0:
+                    progress_value = progress_base + (progress_step * processed_sentences)
+                    progress(progress_value, desc=f"Processing {processed_sentences}/{total_sentences} sentences...")
+            except:
+                pass
             
             job["quality_scores"] = quality_scores
     
@@ -257,36 +284,53 @@ def create_html_output(job_result: Dict, resume_results: List[Dict]) -> str:
     html += "</div>"
     return html
 
+def process_single_resume(file_path, job_skills, progress=None, resume_index=0, total_resumes=1):
+    """Process a single resume file"""
+    progress_base = 0.4 + (0.5 * resume_index / total_resumes)
+    progress_cap = 0.4 + (0.5 * (resume_index + 1) / total_resumes)
+    
+    with open(file_path, 'r', encoding='utf-8') as f:
+        resume_content = f.read()
+    
+    return process_resume(resume_content, job_skills, 
+                        progress=progress, progress_base=progress_base, progress_cap=progress_cap)
+
 def process_inputs(job_description: str, input_type: str, resume_text: str, resume_files: List[str], progress=gr.Progress()) -> str:
     """Main processing function"""
     # Process job description
     progress(0.1, desc="Processing job description...")
     job_result = process_job_description(job_description)
+    job_skills = [skill['text'] for skill in job_result['skills']]
     
     # Process resumes based on input type
     resume_results = []
     if input_type == "Paste Text":
         # Process single resume from text input
         progress(0.4, desc="Processing resume structure...")
-        resume_result = process_resume(resume_text, [skill['text'] for skill in job_result['skills']], 
+        resume_result = process_resume(resume_text, job_skills, 
                                       progress=progress, progress_base=0.4, progress_cap=0.9)
         resume_results.append(resume_result)
     else:
-        # Process multiple resumes from file uploads
+        # Process multiple resumes from file uploads in parallel
         resume_count = len(resume_files)
-        progress_segment = 0.5 / resume_count
+        progress(0.4, desc=f"Processing {resume_count} resumes in parallel...")
         
-        for i, file_path in enumerate(resume_files):
-            progress_base = 0.4 + (progress_segment * i)
-            progress_cap = 0.4 + (progress_segment * (i + 1))
-            
-            progress(progress_base, desc=f"Processing resume {i+1} of {resume_count}...")
-            with open(file_path, 'r', encoding='utf-8') as f:
-                resume_content = f.read()
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            # Submit all resume processing tasks
+            future_to_resume = {
+                executor.submit(
+                    process_single_resume, 
+                    file_path, 
+                    job_skills, 
+                    progress, 
+                    i, 
+                    resume_count
+                ): i for i, file_path in enumerate(resume_files)
+            }
             
-            resume_result = process_resume(resume_content, [skill['text'] for skill in job_result['skills']], 
-                                          progress=progress, progress_base=progress_base, progress_cap=progress_cap)
-            resume_results.append(resume_result)
+            # Collect results as they complete
+            for future in concurrent.futures.as_completed(future_to_resume):
+                resume_results.append(future.result())
     
     # Create HTML output
     progress(0.9, desc="Generating results...")