Updated the groq_api to deploy in streamlit , commanded the logger

app.py

@@ -3,7 +3,7 @@ import streamlit as st
 import cv_question
 import cv_short
 import cv_analyzer_search
-from logger import setup_logger
+# from logger import setup_logger
 
 # def initialize_session_state():
     # """Initialize all session state variables with default values."""
@@ -31,27 +31,27 @@ def clear_session_state():
     
 def main():
     # Setup logger for app
-    app_logger = setup_logger('app_logger', 'app.log')
+    # app_logger = setup_logger('app_logger', 'app.log')
     
     # initialize_session_state()
     
     # Sidebar
     st.sidebar.title("Navigation")
-    app_logger.info("Sidebar navigation displayed")
+    # app_logger.info("Sidebar navigation displayed")
     
     # Add reset button in sidebar
     if st.sidebar.button("Reset All Data"):
         clear_session_state()
         st.sidebar.success("All data has been reset!")
-        app_logger.info("Session state reset")
+        # app_logger.info("Session state reset")
     
     # Navigation
     page = st.sidebar.radio("Go to", ["CV Shortlisting", "Interview Questions","CV Analyser + JobSearch"])
-    app_logger.info(f"Page selected: {page}")
+    # app_logger.info(f"Page selected: {page}")
     
     try:
         if page == "CV Shortlisting":
-            app_logger.info("Navigating to CV Shortlisting")
+            # app_logger.info("Navigating to CV Shortlisting")
             cv_short.create_cv_shortlisting_page()
             
         elif page == "Interview Questions":
@@ -60,14 +60,14 @@ def main():
             #     st.warning("Please complete the CV shortlisting process first.")
             #     app_logger.warning("Attempted to access Interview Questions without completing CV shortlisting")
             # else:
-                app_logger.info("Navigating to Interview Questions")
+                # app_logger.info("Navigating to Interview Questions")
                 cv_question.create_interview_questions_page()
 
         elif page == "CV Analyser + JobSearch":
             cv_analyzer_search.Job_assistant()
                 
     except Exception as e:
-        app_logger.error(f"Error occurred: {e}")
+        # app_logger.error(f"Error occurred: {e}")
         st.error(f"An error occurred: {e}")
         
 if __name__ == "__main__":

cv_analyzer_search.py

@@ -29,8 +29,8 @@ def make_clickable_link(link):
 groq_api_key = st.secrets["GROQ_API_KEY"]
 
 # Configure logging
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+# logger = logging.getLogger(__name__)
 
 class JobSuggestionEngine:
     def __init__(self):
@@ -48,7 +48,7 @@ class JobSuggestionEngine:
                 Extracting JSON from LLM
         """
         try:
-            logger.debug("Extracting JSON from LLM response")
+            # logger.debug("Extracting JSON from LLM response")
             # Clean and extract JSON
             json_match = re.search(r'\{.*\}', text, re.DOTALL)
             if json_match:
@@ -57,12 +57,12 @@ class JobSuggestionEngine:
         
         except Exception as e:
             st.error(f"JSON Extraction Error: {e}")
-            logger.error(f"JSON Extraction Error: {e}")
+            # logger.error(f"JSON Extraction Error: {e}")
             return {}
     
     def generate_job_suggestions(self, resume_data: cv) -> List[Dict[str, str]]:
 
-        logger.info("Generating job suggestions based on resume")
+        # logger.info("Generating job suggestions based on resume")
 
         prompt = f"""Based on the following resume details, provide job suggestions:
 
@@ -91,7 +91,7 @@ class JobSuggestionEngine:
             """
         try:
 
-            logger.debug(f"Calling Groq API with prompt: {prompt[:100]}...") # start of api call
+            # logger.debug(f"Calling Groq API with prompt: {prompt[:100]}...") # start of api call
             
             # API call to the Groq client for chat completions
             chat_completion = self.client.chat.completions.create(
@@ -111,14 +111,14 @@ class JobSuggestionEngine:
             response_text = chat_completion.choices[0].message.content
             suggestions_data = self._extract_json(response_text)
 
-            logger.info(f"Job suggestions generated: {len(suggestions_data.get('job_suggestions', []))} found")
+            # logger.info(f"Job suggestions generated: {len(suggestions_data.get('job_suggestions', []))} found")
             
             # Return job suggestions, if not found -> empty list 
             return suggestions_data.get('job_suggestions', [])
         
         except Exception as e:
             st.error(f"Job Suggestion Error: {e}")
-            logger.error(f"Job Suggestion Error: {e}")
+            # logger.error(f"Job Suggestion Error: {e}")
             return []
 
 def Job_assistant():
@@ -181,14 +181,14 @@ def Job_assistant():
                 try:
                     # Extract resume text
                     resume_text = process_file(uploaded_resume)
-                    logger.info("Resume extracted successfully")
+                    # logger.info("Resume extracted successfully")
                     
                     # Extract structured CV data
                     candidates = extract_cv_data(resume_text)
                     
                     if not candidates:
                         st.error("Could not extract resume data")
-                        logger.error("No candidates extracted from resume")
+                        # logger.error("No candidates extracted from resume")
                         st.stop()
                     
                     st.session_state.resume_data = candidates[0]
@@ -201,17 +201,17 @@ def Job_assistant():
                 
                 except Exception as e:
                     st.error(f"Resume Processing Error: {e}")
-                    logger.error(f"Resume Processing Error: {e}")
+                    # logger.error(f"Resume Processing Error: {e}")
                     st.stop()
             
             # Initialize Job Suggestion Engine
             if st.session_state.resume_data:
                 suggestion_engine = JobSuggestionEngine()
-                logger.info("Job_Suggestion_Engine initialized")
+                # logger.info("Job_Suggestion_Engine initialized")
                 
                 # Generate Job Suggestions
                 job_suggestions = suggestion_engine.generate_job_suggestions(resume_data)
-                logger.info(f"Generated {len(job_suggestions)} job suggestions")
+                # logger.info(f"Generated {len(job_suggestions)} job suggestions")
 
                 st.session_state.job_suggestions = job_suggestions
 
@@ -227,14 +227,14 @@ def Job_assistant():
             try:
                     # Extract resume text
                     resume_text = process_file(uploaded_resume)
-                    logger.info("Resume text extracted again for improvement suggestions")
+                    # logger.info("Resume text extracted again for improvement suggestions")
 
                     # Initialize Resume Improvement Engine
                     improvement_engine = ResumeImprovementEngine()
                     
                     # Generate Improvement Suggestions
                     improvement_suggestions = improvement_engine.generate_resume_improvement_suggestions(resume_text)
-                    logger.info("Resume improvement suggestions generated")
+                    # logger.info("Resume improvement suggestions generated")
                     st.session_state.improvement_suggestions = improvement_suggestions
 
                     # Display Suggestions
@@ -304,7 +304,7 @@ def Job_assistant():
                 
             except Exception as e:
                     st.error(f"Resume Improvement Analysis Error: {e}")
-                    logger.error(f"Resume Improvement Analysis Error: {e}")
+                    # logger.error(f"Resume Improvement Analysis Error: {e}")
 
 
     with tab2:
@@ -386,7 +386,7 @@ def Job_assistant():
                 
                 except Exception as e:
                     st.error(f"Job Search Error: {e}")
-                    logger.error(f"Job Search Error: {e}")
+                    # logger.error(f"Job Search Error: {e}")
         # col1, col2, col3, col4 = st.columns(4)
         
         # with col1:

cv_short.py

@@ -5,26 +5,26 @@ import streamlit as st
 import pandas as pd
 
 # Configure logging
-logging.basicConfig(level=logging.DEBUG , format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+# logging.basicConfig(level=logging.DEBUG , format='%(asctime)s - %(levelname)s - %(message)s')
+# logger = logging.getLogger(__name__)
 
 
 class CVAnalyzer:
 
     def __init__(self):
         # Initialize Groq LLM
-        logger.info("Initializing CVAnalyzer")
+        # logger.info("Initializing CVAnalyzer")
 
         self.llm = extr.initialize_llm()  # Updated to use the new function
         
-        logger.info(" LLM initialized")
+        # logger.info(" LLM initialized")
         # Initialize embeddings (if needed)
         # self.embeddings = HuggingFaceEmbeddings(
         #     model_name="sentence-transformers/all-mpnet-base-v2"
         # )
 
     def load_document(self, file_path: str) -> str:
-        logger.info(f"Loading document from file: {file_path}")
+        # logger.info(f"Loading document from file: {file_path}")
 
         """Load document based on file type."""
 
@@ -34,22 +34,22 @@ class CVAnalyzer:
             loader = TextLoader(file_path)
         documents = loader.load()
 
-        logger.info(f"Document loaded from {file_path}")
+        # logger.info(f"Document loaded from {file_path}")
 
         return " ".join([doc.page_content for doc in documents])
 
     def extract_cv_info(self, cv_text: str) -> list[extr.cv]: # referring to cv class in extraction.py
-        logger.info("Extracting CV information")
+        # logger.info("Extracting CV information")
 
         """Extract structured information from CV text using new extraction method."""
 
         extracted_data = extr.extract_cv_data(cv_text)
-        logger.info(f"Extracted {len(extracted_data)} candidate(s) from CV")
+        # logger.info(f"Extracted {len(extracted_data)} candidate(s) from CV")
         return extracted_data
         # return extr.extract_cv_data(cv_text) 
 
     def calculate_match_score(self, cv_info: dict, jd_requirements: dict) -> dict:
-        logger.info(f"Calculating match score for CV: {cv_info.get('name', 'Unknown')}")
+        # logger.info(f"Calculating match score for CV: {cv_info.get('name', 'Unknown')}")
 
         """Calculate match score between CV and job requirements."""
 
@@ -80,7 +80,7 @@ class CVAnalyzer:
             if component != "overall_score"
         )
         
-        logger.debug(f"Match score for {cv_info.get('name', 'Unknown')}: {score_components['overall_score']:.2%}")
+        # logger.debug(f"Match score for {cv_info.get('name', 'Unknown')}: {score_components['overall_score']:.2%}")
 
         return score_components
 
@@ -209,7 +209,7 @@ class CVAnalyzer:
 
 
 def create_cv_shortlisting_page():
-    logger.info("Starting CV shortlisting system")
+    # logger.info("Starting CV shortlisting system")
 
     # Initialize session state if not already initialized
     if 'jd_text' not in st.session_state:
@@ -261,7 +261,7 @@ def create_cv_shortlisting_page():
         st.session_state.uploaded_files = uploaded_files
 
     if st.button("Analyze CVs") and uploaded_files and jd_text:
-        logger.info("Analyzing uploaded CVs")
+        # logger.info("Analyzing uploaded CVs")
         with st.spinner('Analyzing CVs...'):
             analyzer = CVAnalyzer()
             
@@ -301,10 +301,11 @@ def create_cv_shortlisting_page():
                         st.session_state.results.append(result)
                         
                 except Exception as e:
-                    logger.error(f"Error processing CV: {str(e)}")
+                    st.error(f"Error processing CV: {str(e)}")
+                    # logger.error(f"Error processing CV: {str(e)}")
             
         # Display results
-        logger.info(f"Displaying analyzed results for {len(results)} candidate(s)")
+        # logger.info(f"Displaying analyzed results for {len(results)} candidate(s)")
         
         if st.session_state.results:
             df = pd.DataFrame(st.session_state.results)
@@ -312,6 +313,6 @@ def create_cv_shortlisting_page():
             st.dataframe(df)
             st.session_state.analysis_complete = True
         else:
-            logger.warning("No valid candidates found in uploaded CVs")
+            # logger.warning("No valid candidates found in uploaded CVs")
             st.error("No valid results found from CV analysis")
             st.session_state.analysis_complete = False

resume_advance_analysis.py

@@ -6,8 +6,8 @@ import re
 import os
 import logging
 
-logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
+# logger = logging.getLogger(__name__)
 
 
 os.environ['GROQ_API_KEY'] = os.getenv("GROQ_API_KEY")
@@ -22,7 +22,7 @@ class ResumeImprovementEngine:
         #     max_tokens=4096
         # )
         self.client = Groq(api_key=groq_api_key)
-        logger.info("ResumeImprovementEngine initialized with Groq API key.")
+        # logger.info("ResumeImprovementEngine initialized with Groq API key.")
 
     def generate_resume_improvement_suggestions(self, resume_text: str) -> dict[str, Any]:
             """
@@ -79,7 +79,7 @@ class ResumeImprovementEngine:
             """
             
             try:
-                logger.info("Sending request to Groq for resume improvement.")
+                # logger.info("Sending request to Groq for resume improvement.")
                 # Make API call to generate improvement suggestions
                 chat_completion = self.client.chat.completions.create(
                     messages=[
@@ -99,19 +99,19 @@ class ResumeImprovementEngine:
                     stream=False
                 )
 
-                logger.info("Groq API response received.")
+                # logger.info("Groq API response received.")
                 
                 # Extract and parse the JSON response
                 response_text = chat_completion.choices[0].message.content
                 suggestions = self._extract_json(response_text)
 
-                logger.debug(f"Improvement suggestions received: {suggestions}")
+                # logger.debug(f"Improvement suggestions received: {suggestions}")
                 
                 return suggestions
             
             except Exception as e:
                 st.error(f"Resume Improvement Error: {e}")
-                logger.error(f"Resume Improvement Error: {e}")
+                # logger.error(f"Resume Improvement Error: {e}")
                 return {}
             
     
@@ -126,19 +126,19 @@ class ResumeImprovementEngine:
             Dict of extracted JSON or empty dict
         """
         try:
-            logger.debug("Extracting JSON from response text.")
+            # logger.debug("Extracting JSON from response text.")
 
             json_match = re.search(r'\{.*\}', text, re.DOTALL | re.MULTILINE)
             if json_match:
                 return json.loads(json_match.group(0))
             
-            logger.warning("No valid JSON found in response text.")
+            # logger.warning("No valid JSON found in response text.")
 
             return {}
         
         except Exception as e:
             st.error(f"JSON Extraction Error: {e}")
-            logger.error(f"JSON Extraction Error: {e}")
+            # logger.error(f"JSON Extraction Error: {e}")
             return {}