Removed default document loading logic

functions/gradio.py

@@ -5,13 +5,11 @@ Functions for handling Gradio UI interactions and processing user inputs.
 """
 
 import logging
-import shutil
 from pathlib import Path
-from functions.linkedin_resume import extract_text_from_linkedin_pdf, check_default_linkedin_pdf
+from functions.linkedin_resume import extract_text_from_linkedin_pdf
 from functions.github import get_github_repositories
-from functions.job_call import load_default_job_call, summarize_job_call
+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
 
@@ -20,35 +18,12 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def process_with_default_option(
-    use_default_pdf,
-    linkedin_pdf,
-    github_profile,
-    job_post,
-    user_instructions
-):
-    """Process inputs with consideration for default PDF option."""
-
-    has_default, default_path = check_default_linkedin_pdf()
-
-    # Determine which PDF file to use
-    pdf_file = None
-
-    if use_default_pdf and has_default:
-        pdf_file = MockFile(default_path)
-
-    elif linkedin_pdf is not None:
-        pdf_file = linkedin_pdf
-
-    return process_inputs(pdf_file, github_profile, job_post, user_instructions)
-
-
 def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
     """
     Process the input files and URLs from the Gradio interface.
 
     Args:
-        linkedin_pdf: Uploaded LinkedIn resume export PDF file or mock file object with path
+        linkedin_pdf: Uploaded LinkedIn resume export PDF file
         github_url (str): GitHub profile URL
         job_post_text (str): Job post text content
         user_instructions (str): Additional instructions from the user
@@ -62,33 +37,12 @@ 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
 
         result += "✅ LinkedIn Resume PDF provided\n"
         logger.info("Processing LinkedIn PDF: %s", file_display_name)
 
-        # Save uploaded file as new default (only if it's not already the default)
-        project_root = Path(__file__).parent.parent
-        default_pdf_path = project_root / "data" / "linkedin_profile.pdf"
-
-        # Check if this is an uploaded file (not the default file)
-        if not isinstance(linkedin_pdf, MockFile):
-            try:
-                # Create data directory if it doesn't exist
-                default_pdf_path.parent.mkdir(exist_ok=True)
-
-                # Copy uploaded file to default location
-                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))
-
         # Extract and structure text from the PDF
         extraction_result = extract_text_from_linkedin_pdf(file_path)
 
@@ -107,24 +61,12 @@ def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
         logger.info("No LinkedIn PDF file provided")
 
     # Process GitHub profile
-    # Use default GitHub profile if none provided
     if github_url and github_url.strip():
-        github_url_to_use = github_url.strip()
-
-    else:
-        github_url_to_use = DEFAULT_GITHUB_PROFILE
-
-    if github_url_to_use:
-        if github_url and github_url.strip():
-            result += "✅ GitHub Profile URL provided\n"
-
-        else:
-            result += "✅ Using default GitHub Profile URL\n"
-
-        logger.info("Processing GitHub URL: %s", github_url_to_use)
+        result += "✅ GitHub Profile URL provided\n"
+        logger.info("Processing GitHub URL: %s", github_url.strip())
 
         # Retrieve repositories from GitHub
-        github_result = get_github_repositories(github_url_to_use)
+        github_result = get_github_repositories(github_url.strip())
 
         if github_result["status"] == "success":
             result += "  ✅ GitHub list download successful\n\n"
@@ -144,42 +86,15 @@ def process_inputs(linkedin_pdf, github_url, job_post_text, user_instructions):
     if job_post_text and job_post_text.strip():
         result += "✅ Job post text provided\n"
         logger.info("Job post text provided (%d characters)", len(job_post_text))
-        job_text_to_use = job_post_text.strip()
-
-    else:
-        result += "ℹ️ No job post provided, attempting to use default\n"
-        logger.info("No job post text provided, trying default")
-
-        # Try to load default job call
-        default_job = load_default_job_call()
 
-        if default_job:
-            job_text_to_use = default_job
+        summary = summarize_job_call(job_post_text.strip())
+        result += "  ✅ Job post summary generated\n"
+        logger.info("Job post summary generated (%d characters)", len(summary))
 
-        else:
-            result += "ℹ️ No default job post available, proceeding without job post\n"
-            logger.info("No default job post available, proceeding without job analysis")
-            job_text_to_use = None
-
-    # Generate job summary (will use default if job_text_to_use is None)
-    summary = None
-
-    if job_text_to_use:
-        summary = summarize_job_call(job_text_to_use)
-
-        if summary:
-            if job_post_text and job_post_text.strip():
-                result += "  ✅ Job post summary generated\n"
-            else:
-                result += "✅ Using default job post\n"
-                result += "  ✅ Job post summary generated\n"
-            logger.info("Job post summary generated (%d characters)", len(summary))
-        else:
-            result += "  ❌ Job post summary generation failed\n"
-            logger.warning("Job post summary generation failed")
     else:
-        result += "ℹ️ Proceeding without job post analysis\n"
-        logger.info("No job post available for analysis")
+        result += "❌ Job post not provided\n"
+        logger.info("No job post text provided")
+        summary = None
 
     # Process user instructions
     if user_instructions and user_instructions.strip():
@@ -227,17 +142,6 @@ def get_processed_data(linkedin_pdf, github_url, job_post_text, instructions):
     job_post_text = job_post_text.strip() if job_post_text and job_post_text.strip() else None
     instructions = instructions.strip() if instructions and instructions.strip() else None
 
-    # If no job post text provided, try to get default
-    if not job_post_text:
-        default_job = load_default_job_call()
-
-        if default_job:
-            job_post_text = default_job
-        else:
-            # No job post provided and no default available
-            logger.info("No job post provided and no default available")
-            job_post_text = None
-
     processed_data = {
         "linkedin": None,
         "github": None,
@@ -248,8 +152,6 @@ def get_processed_data(linkedin_pdf, github_url, job_post_text, instructions):
 
     # Process LinkedIn PDF
     if linkedin_pdf is not None:
-
-        # Handle both file objects and mock file objects with path strings
         file_path = linkedin_pdf.name
         extraction_result = extract_text_from_linkedin_pdf(file_path)
 
@@ -270,10 +172,3 @@ def get_processed_data(linkedin_pdf, github_url, job_post_text, instructions):
             processed_data["errors"].append(f"GitHub: {github_result['message']}")
 
     return processed_data
-
-
-class MockFile:
-    """Mock file object that mimics uploaded file interface with just a file path."""
-
-    def __init__(self, path):
-        self.name = path

functions/writer_agent.py

@@ -11,7 +11,7 @@ from configuration import INFERENCE_URL, AGENT_MODEL, AGENT_INSTRUCTIONS
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-def write_resume(content: str, user_instructions: str = None, job_summary: str = None) -> str:
+def write_resume(content: str, user_instructions: str = None, job_summary: dict = None) -> str:
 
     """
     Generates a resume based on the provided content.
@@ -19,7 +19,7 @@ def write_resume(content: str, user_instructions: str = None, job_summary: str =
     Args:
         content (str): The content to be used for generating the resume.
         user_instructions (str, optional): Additional instructions from the user.
-        job_summary (str, optional): Extracted/summarized job call information.
+        job_summary (dict, optional): Extracted/summarized job call information.
 
     Returns:
         str: The generated resume.
@@ -46,9 +46,9 @@ def write_resume(content: str, user_instructions: str = None, job_summary: str =
         # Prepare instructions - combine default with user instructions and job summary
         instructions = AGENT_INSTRUCTIONS
 
-        if job_summary is not None and job_summary.strip():
-            instructions += f"\n\nJob Requirements and Details:\n{job_summary.strip()}"
-            logger.info("Added job summary to agent prompt (%d characters)", len(job_summary))
+        if job_summary is not None:
+            instructions += f"\n\nJob Requirements and Details:\n{json.dumps(job_summary)}"
+            logger.info("Added job summary to agent prompt")
 
         if user_instructions and user_instructions.strip():
 

resumate.py

@@ -13,14 +13,8 @@ Upon submission, the input values are processed and displayed in the output box.
 To run:
     python resumate.py
 """
-from pathlib import Path
-
 import gradio as gr
-from functions.gradio import check_default_linkedin_pdf, process_with_default_option
-
-
-# Check if default PDF exists at startup
-has_default, default_path = check_default_linkedin_pdf()
+from functions.gradio import process_inputs
 
 with gr.Blocks() as demo:
     gr.Markdown("# Resumate: tailored resume generator")
@@ -41,21 +35,6 @@ with gr.Blocks() as demo:
     **Tip**: Make sure your LinkedIn profile is complete and up-to-date before exporting for best results!
     """)
 
-    # Default PDF option
-    if has_default:
-        use_default_pdf = gr.Checkbox(
-            label=f"Use default LinkedIn PDF ({Path(default_path).name})",
-            value=False,
-            info="Use the default LinkedIn PDF stored in the data directory"
-        )
-    else:
-        use_default_pdf = gr.Checkbox(
-            label="Use default LinkedIn PDF (not available)",
-            value=False,
-            interactive=False,
-            info="No default LinkedIn PDF found in data directory"
-        )
-
     linkedin_pdf = gr.File(
         label="LinkedIn Resume Export PDF",
         file_types=[".pdf"],
@@ -102,8 +81,8 @@ with gr.Blocks() as demo:
     output = gr.Textbox(label="Output", lines=5, max_lines=50, show_copy_button=True)
 
     submit_btn.click( # pylint: disable=no-member
-        process_with_default_option,
-        inputs=[use_default_pdf, linkedin_pdf, github_profile, job_post, user_instructions],
+        process_inputs,
+        inputs=[linkedin_pdf, github_profile, job_post, user_instructions],
         outputs=output
     )
 

tests/test_gradio.py

@@ -10,12 +10,8 @@ from functions import gradio
 class TestProcessInputs(unittest.TestCase):
     """Test cases for the process_inputs function."""
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_no_inputs_provided(self, mock_load_default):
-        """Test when no inputs are provided and default job is available."""
-        # Mock default job call loading to return content
-        mock_load_default.return_value = "Default job content from sample_job.txt"
-
+    def test_no_inputs_provided(self):
+        """Test when no inputs are provided."""
         with patch('functions.gradio.get_github_repositories') as mock_github, \
              patch('functions.gradio.summarize_job_call') as mock_summarize:
             mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
@@ -24,18 +20,13 @@ class TestProcessInputs(unittest.TestCase):
             result = gradio.process_inputs(None, "", "", "")
 
             self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-            self.assertIn("✅ Using default GitHub Profile URL", result)
-            self.assertIn("ℹ️ No job post provided, attempting to use default", result)
-            self.assertIn("✅ Using default job post", result)
+            self.assertIn("❌ No GitHub profile URL provided", result)
+            self.assertIn("❌ Job post not provided", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_no_inputs_no_default_job(self, mock_load_default):
-        """Test when no inputs are provided and no default job is available."""
-        # Mock default job call loading to return None (no default available)
-        mock_load_default.return_value = None
-
+    def test_no_inputs_no_default_job(self):
+        """Test when no inputs are provided (same as test_no_inputs_provided now)."""
         with patch('functions.gradio.get_github_repositories') as mock_github, \
              patch('functions.gradio.summarize_job_call') as mock_summarize:
             mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
@@ -44,10 +35,9 @@ class TestProcessInputs(unittest.TestCase):
             result = gradio.process_inputs(None, "", "", "")
 
             self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-            self.assertIn("✅ Using default GitHub Profile URL", result)
-            self.assertIn("ℹ️ No job post provided, attempting to use default", result)
-            self.assertIn("ℹ️ No default job post available, proceeding without job post", result)
-            self.assertIn("ℹ️ Proceeding without job post analysis", result)
+            self.assertIn("❌ No GitHub profile URL provided", result)
+            self.assertIn("❌ Job post not provided", result)
+            self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
@@ -177,12 +167,8 @@ class TestProcessInputs(unittest.TestCase):
         # Verify write_resume was NOT called since no LinkedIn data
         mock_write_resume.assert_not_called()
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_whitespace_only_inputs(self, mock_load_default):
-        """Test inputs with only whitespace and default job available."""
-        # Mock default job call loading to return content
-        mock_load_default.return_value = "Default job content from sample_job.txt"
-
+    def test_whitespace_only_inputs(self):
+        """Test inputs with only whitespace."""
         with patch('functions.gradio.get_github_repositories') as mock_github, \
              patch('functions.gradio.summarize_job_call') as mock_summarize:
             mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
@@ -191,18 +177,13 @@ class TestProcessInputs(unittest.TestCase):
             result = gradio.process_inputs(None, "   ", "   ", "   ")
 
             self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-            self.assertIn("✅ Using default GitHub Profile URL", result)
-            self.assertIn("ℹ️ No job post provided, attempting to use default", result)
-            self.assertIn("✅ Using default job post", result)
+            self.assertIn("❌ No GitHub profile URL provided", result)
+            self.assertIn("❌ Job post not provided", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_whitespace_only_inputs_no_default(self, mock_load_default):
-        """Test inputs with only whitespace and no default job available."""
-        # Mock default job call loading to return None
-        mock_load_default.return_value = None
-
+    def test_whitespace_only_inputs_no_default(self):
+        """Test inputs with only whitespace (same as test_whitespace_only_inputs now)."""
         with patch('functions.gradio.get_github_repositories') as mock_github, \
              patch('functions.gradio.summarize_job_call') as mock_summarize:
             mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
@@ -211,10 +192,8 @@ class TestProcessInputs(unittest.TestCase):
             result = gradio.process_inputs(None, "   ", "   ", "   ")
 
             self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-            self.assertIn("✅ Using default GitHub Profile URL", result)
-            self.assertIn("ℹ️ No job post provided, attempting to use default", result)
-            self.assertIn("ℹ️ No default job post available, proceeding without job post", result)
-            self.assertIn("ℹ️ Proceeding without job post analysis", result)
+            self.assertIn("❌ No GitHub profile URL provided", result)
+            self.assertIn("❌ Job post not provided", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
@@ -302,26 +281,18 @@ class TestProcessInputs(unittest.TestCase):
 class TestGetProcessedData(unittest.TestCase):
     """Test cases for the get_processed_data function."""
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_no_inputs(self, mock_load_default):
+    def test_no_inputs(self):
         """Test with no inputs provided."""
-        # Mock the default job call loading
-        mock_load_default.return_value = "Default job call content from sample_job.txt"
-
         result = gradio.get_processed_data(None, "", "", "")
 
         self.assertIsNone(result["linkedin"])
         self.assertIsNone(result["github"])
-        self.assertEqual(result["job_post"], "Default job call content from sample_job.txt")
+        self.assertIsNone(result["job_post"])
         self.assertIsNone(result["user_instructions"])
         self.assertEqual(len(result["errors"]), 0)
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_no_inputs_no_default_job(self, mock_load_default):
-        """Test with no inputs provided and no default job available."""
-        # Mock the default job call loading to return None
-        mock_load_default.return_value = None
-
+    def test_no_inputs_no_default_job(self):
+        """Test with no inputs provided (same as test_no_inputs now)."""
         result = gradio.get_processed_data(None, "", "", "")
 
         self.assertIsNone(result["linkedin"])
@@ -430,23 +401,19 @@ class TestGetProcessedData(unittest.TestCase):
             self.assertIn("LinkedIn: LinkedIn error", result["errors"])
             self.assertIn("GitHub: GitHub error", result["errors"])
 
-    @patch('functions.gradio.load_default_job_call')
-    def test_job_post_whitespace_handling(self, mock_load_default):
+    def test_job_post_whitespace_handling(self):
         """Test job post whitespace handling."""
-        # Mock the default job call loading
-        mock_load_default.return_value = "Default job content"
-
         # Test with leading/trailing whitespace
         result = gradio.get_processed_data(None, "", "  Job content  ", "")
         self.assertEqual(result["job_post"], "Job content")
 
-        # Test with only whitespace - should load default
+        # Test with only whitespace - should be None
         result = gradio.get_processed_data(None, "", "   ", "")
-        self.assertEqual(result["job_post"], "Default job content")
+        self.assertIsNone(result["job_post"])
 
-        # Test with empty string - should load default
+        # Test with empty string - should be None
         result = gradio.get_processed_data(None, "", "", "")
-        self.assertEqual(result["job_post"], "Default job content")
+        self.assertIsNone(result["job_post"])
 
     def test_github_url_whitespace_handling(self):
         """Test GitHub URL whitespace handling."""