Moved multiple instances of 'pylint: disable=broad-exception-caught' to top of file

functions/github.py

@@ -12,6 +12,8 @@ from pathlib import Path
 
 import requests
 
+# pylint: disable=broad-exception-caught
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -99,12 +101,12 @@ def get_github_repositories(github_url: str) -> Dict:
                 json.dump(result, f, indent=2, ensure_ascii=False)
 
             logger.info("GitHub repositories saved to %s", output_file)
-        except Exception as save_error: # pylint: disable=broad-exception-caught
+        except Exception as save_error:
             logger.warning("Failed to save GitHub repositories to file: %s", str(save_error))
 
         return result
 
-    except Exception as e: # pylint: disable=broad-exception-caught
+    except Exception as e:
         logger.error("Error retrieving GitHub repositories: %s", str(e))
 
         return {
@@ -146,7 +148,7 @@ def _extract_github_username(github_url: str) -> Optional[str]:
 
         return None
 
-    except Exception as e: # pylint: disable=broad-exception-caught
+    except Exception as e:
         logger.warning("Error extracting username from URL %s: %s", github_url, str(e))
 
         return None

functions/gradio.py

@@ -13,6 +13,8 @@ from functions.job_call import summarize_job_call
 from functions.writer_agent import write_resume
 from configuration import DEFAULT_GITHUB_PROFILE
 
+# pylint: disable=broad-exception-caught
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -82,6 +84,7 @@ def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
 
     # Process LinkedIn PDF file
     if linkedin_pdf is not None:
+
         # Handle both file objects and mock file objects with path strings
         file_path = linkedin_pdf.name
         file_display_name = Path(file_path).name
@@ -103,6 +106,7 @@ def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
                 shutil.copy2(file_path, default_pdf_path)
                 result += " ✅ Saved as new default LinkedIn profile\n"
                 logger.info("Saved uploaded LinkedIn PDF as new default: %s", default_pdf_path)
+
             except Exception as save_error:
                 result += f" ⚠️  Could not save as default: {str(save_error)}\n"
                 logger.warning("Failed to save LinkedIn PDF as default: %s", str(save_error))
@@ -190,7 +194,7 @@ def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
             result += "\n✅ Resume generated successfully\n"
             logger.info("Resume generation completed successfully")
 
-        except Exception as e: # pylint: disable=broad-exception-caught
+        except Exception as e:
             result += f"\n❌ Resume generation failed: {str(e)}\n"
             logger.error("Resume generation failed: %s", str(e))
     else:

functions/job_call.py

@@ -5,6 +5,8 @@ import logging
 from openai import OpenAI
 from configuration import JOB_CALL_EXTRACTION_PROMPT
 
+# pylint: disable=broad-exception-caught
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -47,7 +49,7 @@ def summarize_job_call(job_call: str) -> str:
     try:
         response = client.chat.completions.create(**completion_args)
 
-    except Exception as e: # pylint: disable=broad-exception-caught
+    except Exception as e:
         response = None
         logger.error('Error during Modal API call: %s', e)
 

functions/linkedin_resume.py

@@ -13,6 +13,8 @@ import json
 from pathlib import Path
 import PyPDF2
 
+# pylint: disable=broad-exception-caught
+
 # Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -66,7 +68,7 @@ def extract_text_from_linkedin_pdf(pdf_file) -> dict:
                 page_text = page.extract_text()
                 extracted_text += page_text + "\n\n"
 
-            except Exception as e: # pylint: disable=broad-exception-caught
+            except Exception as e:
                 logger.warning("Error extracting text from page %d: %s", page_num + 1, str(e))
 
                 continue
@@ -115,12 +117,12 @@ def extract_text_from_linkedin_pdf(pdf_file) -> dict:
 
             logger.info("LinkedIn resume extraction saved to %s", output_file)
 
-        except Exception as save_error: # pylint: disable=broad-exception-caught
+        except Exception as save_error:
             logger.warning("Failed to save LinkedIn resume extraction to file: %s", str(save_error))
 
         return result
 
-    except Exception as e: # pylint: disable=broad-exception-caught
+    except Exception as e:
         logger.error("Error processing PDF file: %s", str(e))
 
         return {

functions/writer_agent.py

@@ -6,6 +6,8 @@ import os
 from smolagents import CodeAgent
 from configuration import AGENT_MODEL, INSTRUCTIONS
 
+# pylint: disable=broad-exception-caught
+
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
@@ -65,7 +67,7 @@ def write_resume(content: str, user_instructions: str = None) -> str:
 
             logger.info("Resume saved to: %s", resume_file_path)
 
-        except Exception as e: # pylint: disable=broad-exception-caught
+        except Exception as e:
             logger.error("Failed to save resume to file: %s", e)
 
     return submitted_answer

tests/test_linkedin_resume.py

@@ -8,45 +8,55 @@ import os
 from unittest.mock import patch, MagicMock
 from functions import linkedin_resume as ca
 
+# pylint: disable=protected-access
+
 
 class TestCleanExtractedText(unittest.TestCase):
     """Test cases for the _clean_extracted_text function."""
-    
+
     def test_normalize_multiple_newlines(self):
         """Test normalization of multiple newlines."""
+
         raw = "Line 1\n\nLine 2\n\n\nLine 3"
         expected = "Line 1\nLine 2\nLine 3"
         self.assertEqual(ca._clean_extracted_text(raw), expected)
-    
+
     def test_remove_artifacts(self):
         """Test removal of PDF artifacts."""
+
         raw = "  123  \n|---|\nSome text\n"
         expected = "Some text"
         self.assertEqual(ca._clean_extracted_text(raw), expected)
-    
+
     def test_normalize_spaces(self):
         """Test normalization of multiple spaces."""
+
         raw = "A  B   C"
         expected = "A B C"
         self.assertEqual(ca._clean_extracted_text(raw), expected)
-    
+
     def test_empty_string(self):
         """Test handling of empty string."""
+
         self.assertEqual(ca._clean_extracted_text(""), "")
-    
+
     def test_none_input(self):
         """Test handling of None input."""
+
         self.assertEqual(ca._clean_extracted_text(None), "")
 
 
 class TestStructureResumeText(unittest.TestCase):
     """Test cases for the _structure_resume_text function."""
-    
+
     def test_basic_structure(self):
         """Test basic resume text structuring."""
-        text = "Contact Info\nJohn Doe\nSummary\nExperienced dev\nExperience\nCompany X\nEducation\nMIT\nSkills\nPython, C++"
+
+        text = "Contact Info\nJohn Doe\nSummary\nExperienced dev" + \
+               "\nExperience\nCompany X\nEducation\nMIT\nSkills\nPython, C++"
+
         result = ca._structure_resume_text(text)
-        
+
         self.assertIn("contact_info", result["sections"])
         self.assertIn("summary", result["sections"])
         self.assertIn("experience", result["sections"])
@@ -54,21 +64,23 @@ class TestStructureResumeText(unittest.TestCase):
         self.assertIn("skills", result["sections"])
         self.assertGreater(result["word_count"], 0)
         self.assertGreaterEqual(result["section_count"], 5)
-    
+
     def test_empty_text(self):
         """Test handling of empty text."""
+
         result = ca._structure_resume_text("")
         self.assertEqual(result["sections"], {})
         self.assertEqual(result["full_text"], "")
         self.assertEqual(result["word_count"], 0)
         self.assertEqual(result["section_count"], 0)
-    
+
     def test_contains_required_fields(self):
         """Test that result contains all required fields."""
+
         text = "Some basic text"
         result = ca._structure_resume_text(text)
-        
-        required_fields = ["sections", "full_text", "llm_formatted", "summary", 
+
+        required_fields = ["sections", "full_text", "llm_formatted", "summary",
                           "format", "word_count", "section_count"]
         for field in required_fields:
             self.assertIn(field, result)
@@ -76,9 +88,10 @@ class TestStructureResumeText(unittest.TestCase):
 
 class TestFormatForLLM(unittest.TestCase):
     """Test cases for the _format_for_llm function."""
-    
+
     def test_section_formatting(self):
         """Test proper formatting of sections for LLM."""
+
         sections = {
             "summary": "A summary.",
             "contact_info": "Contact details.",
@@ -86,9 +99,8 @@ class TestFormatForLLM(unittest.TestCase):
             "education": "School info.",
             "skills": "Python, C++"
         }
-        full_text = "..."
-        formatted = ca._format_for_llm(sections, full_text)
-        
+        formatted = ca._format_for_llm(sections)
+
         self.assertIn("[SUMMARY]", formatted)
         self.assertIn("[CONTACT INFO]", formatted)
         self.assertIn("[EXPERIENCE]", formatted)
@@ -96,46 +108,50 @@ class TestFormatForLLM(unittest.TestCase):
         self.assertIn("[SKILLS]", formatted)
         self.assertTrue(formatted.startswith("=== RESUME CONTENT ==="))
         self.assertTrue(formatted.endswith("=== END RESUME ==="))
-    
+
     def test_empty_sections(self):
         """Test handling of empty sections."""
+
         sections = {}
-        full_text = "test"
-        formatted = ca._format_for_llm(sections, full_text)
-        
+        formatted = ca._format_for_llm(sections)
+
         self.assertTrue(formatted.startswith("=== RESUME CONTENT ==="))
         self.assertTrue(formatted.endswith("=== END RESUME ==="))
 
 
 class TestGetLLMContextFromResume(unittest.TestCase):
     """Test cases for the get_llm_context_from_resume function."""
-    
+
     def test_success_with_llm_formatted(self):
         """Test successful extraction with LLM formatted text."""
+
         extraction_result = {
             "status": "success",
             "structured_text": {"llm_formatted": "LLM text", "full_text": "Full text"}
         }
         result = ca.get_llm_context_from_resume(extraction_result)
         self.assertEqual(result, "LLM text")
-    
+
     def test_fallback_to_full_text(self):
         """Test fallback to full text when LLM formatted not available."""
+
         extraction_result = {
             "status": "success",
             "structured_text": {"full_text": "Full text"}
         }
         result = ca.get_llm_context_from_resume(extraction_result)
         self.assertEqual(result, "Full text")
-    
+
     def test_error_status(self):
         """Test handling of error status."""
+
         extraction_result = {"status": "error"}
         result = ca.get_llm_context_from_resume(extraction_result)
         self.assertEqual(result, "")
-    
+
     def test_missing_structured_text(self):
         """Test handling of missing structured_text."""
+
         extraction_result = {"status": "success"}
         result = ca.get_llm_context_from_resume(extraction_result)
         self.assertEqual(result, "")
@@ -143,50 +159,54 @@ class TestGetLLMContextFromResume(unittest.TestCase):
 
 class TestExtractTextFromLinkedInPDF(unittest.TestCase):
     """Test cases for the extract_text_from_linkedin_pdf function."""
-    
+
     def test_none_input(self):
         """Test handling of None input."""
+
         result = ca.extract_text_from_linkedin_pdf(None)
         self.assertEqual(result["status"], "error")
         self.assertIn("No PDF file provided", result["message"])
-    
+
     @patch('PyPDF2.PdfReader')
     @patch('builtins.open')
     def test_successful_extraction(self, mock_open, mock_pdf_reader):
         """Test successful PDF text extraction with mocked PyPDF2."""
+
         # Create a temporary file
         with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
             tmp_path = tmp.name
-        
+
         try:
             # Mock file reading
             mock_file = MagicMock()
             mock_file.read.return_value = b"fake pdf content"
             mock_open.return_value.__enter__.return_value = mock_file
-            
+
             # Mock PDF reader and page
             mock_page = MagicMock()
-            mock_page.extract_text.return_value = "Contact Info\nJohn Doe\nSummary\nDeveloper\nExperience\nCompany X"
-            
+            mock_page.extract_text.return_value = "Contact Info\nJohn Doe\nSummary" + \
+                                                   "\nDeveloper\nExperience\nCompany X"
+
             mock_reader_instance = MagicMock()
             mock_reader_instance.pages = [mock_page]
             mock_pdf_reader.return_value = mock_reader_instance
-            
+
             # Test the function
             result = ca.extract_text_from_linkedin_pdf(tmp_path)
-            
+
             self.assertEqual(result["status"], "success")
             self.assertIn("structured_text", result)
             self.assertIn("metadata", result)
             self.assertIn("contact_info", result["structured_text"]["sections"])
-            
+
         finally:
             # Clean up
             if os.path.exists(tmp_path):
                 os.remove(tmp_path)
-    
+
     def test_nonexistent_file(self):
         """Test handling of non-existent file."""
+
         result = ca.extract_text_from_linkedin_pdf("/nonexistent/path.pdf")
         self.assertEqual(result["status"], "error")
         self.assertIn("Failed to extract text from PDF", result["message"])