Update src/app_job_copy_1.py

src/app_job_copy_1.py

@@ -12,6 +12,7 @@ from langchain_core.output_parsers import StrOutputParser # Not directly used in
 from langchain_core.prompts import PromptTemplate # Not directly used in provided snippet
 import gspread
 import tempfile
+import time
 from google.oauth2 import service_account
 import tiktoken
 
@@ -138,7 +139,8 @@ def setup_llm():
     system = """You are an expert Tech Recruitor, your task is to analyse the Candidate profile and determine if it matches with the job details and provide a score(out of 10) indicating how compatible the
     the profile is according to job.
     First of all check the location of the candidate, if the location is not in the range of the job location then reject the candidate directly without any further analysis.
-    for example if the job location is New York and the candidate is in San Francisco then reject the candidate. Similarly for other states as well.
+    for example if the job location is New York and the candidate is in San Francisco or outside the new york state then directly reject the candidate without any further analysis. Similarly for other states as well.
+
 Try to ensure following points while estimating the candidate's fit score:
 For education:
 Tier1 - MIT, Stanford, CMU, UC Berkeley, Caltech, Harvard, IIT Bombay, IIT Delhi, Princeton, UIUC, University of Washington, Columbia, University of Chicago, Cornell, University of Michigan (Ann Arbor), UT Austin - Maximum points
@@ -247,7 +249,7 @@ def process_candidates_for_job(job_row, candidates_df, llm_chain=None):
         "Locations": job_row.get("Locations", ""), "Tech_Stack": job_row["Tech Stack"], "Industry": job_row.get("Industry", "")
     }
     
-    with st.spinner("Sourcing candidates based on tech stack..."):
+    with st.spinner("Finding matching candidates based on tech stack..."):
         matching_candidates = get_matching_candidates(job_row["Tech Stack"], candidates_df)
     
     if not matching_candidates:
@@ -287,9 +289,7 @@ def process_candidates_for_job(job_row, candidates_df, llm_chain=None):
     f"**Selected Candidate:** [{response_dict['Name']}]({response_dict['LinkedIn']}) "
     f"(Score: {response_dict['Fit Score']:.3f}, Location: {response_dict['Location']})"
 )
-        else:
-            # This st.write will also be visible during processing and cleared later.
-            st.write(f"Rejected candidate: {response_dict['Name']} with score: {response_dict['Fit Score']:.3f}, Location: {response_dict['Location']})")
+        
         candidates_progress.progress((i + 1) / len(matching_candidates))
 
     candidates_progress.empty()
@@ -359,12 +359,12 @@ def main():
         
         jobs_df = pd.DataFrame(job_data[1:], columns=job_data[0]).drop(["Link"], axis=1, errors='ignore')
         jobs_df1 = jobs_df[["Company","Role","One liner","Locations","Tech Stack","Workplace","Industry","YOE"]]
+        jobs_df1 = jobs_df1.fillna("Unknown")
         candidates_df = pd.DataFrame(candidate_data[1:], columns=candidate_data[0]).fillna("Unknown")
         candidates_df.drop_duplicates(subset=['LinkedIn URL'], keep='first', inplace=True)
         
         with st.expander("Preview uploaded data"):
-            st.subheader("Jobs Data Preview"); st.dataframe(jobs_df1.head(3))
-            # st.subheader("Candidates Data Preview"); st.dataframe(candidates_df.head(3))
+            st.subheader("Jobs Data Preview"); st.dataframe(jobs_df1.head(5))
         
         # Column mapping (simplified, ensure your CSVs have these exact names or adjust)
         # candidates_df = candidates_df.rename(columns={...}) # Add if needed
@@ -375,244 +375,195 @@ def main():
         st.error(f"Error processing files or data: {e}")
     st.divider()
     
-def display_job_selection(jobs_df, candidates_df, sh): # 'sh' is the Google Sheets client
-    st.subheader("Select a job to Source for potential matches")
+def display_job_selection(jobs_df, candidates_df, sh):
+    st.subheader("Select a job to view potential matches")
     job_options = [f"{row['Role']} at {row['Company']}" for _, row in jobs_df.iterrows()]
-    
+
     if not job_options:
         st.warning("No jobs found to display.")
         return
 
-    selected_job_index = st.selectbox("Jobs:", range(len(job_options)), format_func=lambda x: job_options[x], key="job_selectbox")
-    
+    # Select job
+    selected_job_index = st.selectbox("Jobs:", range(len(job_options)),
+                                      format_func=lambda x: job_options[x], key="job_selectbox")
     job_row = jobs_df.iloc[selected_job_index]
-    job_row_stack = parse_tech_stack(job_row["Tech Stack"]) # Assuming parse_tech_stack is defined
-    
-    col_job_details_display, _ = st.columns([2,1]) 
+    job_row_stack = parse_tech_stack(job_row["Tech Stack"])
+
+    # Display job details
+    col_job_details_display, _ = st.columns([2, 1])
     with col_job_details_display:
         st.subheader(f"Job Details: {job_row['Role']}")
         job_details_dict = {
-            "Company": job_row["Company"], "Role": job_row["Role"], "Description": job_row.get("One liner", "N/A"),
-            "Locations": job_row.get("Locations", "N/A"), "Industry": job_row.get("Industry", "N/A"),
-            "Tech Stack": display_tech_stack(job_row_stack) # Assuming display_tech_stack is defined
+            "Company": job_row["Company"],
+            "Role": job_row["Role"],
+            "Description": job_row.get("One liner", "N/A"),
+            "Locations": job_row.get("Locations", "N/A"),
+            "Industry": job_row.get("Industry", "N/A"),
+            "Tech Stack": display_tech_stack(job_row_stack)
         }
-        for key, value in job_details_dict.items(): st.markdown(f"**{key}:** {value}")
+        for key, value in job_details_dict.items():
+            st.markdown(f"**{key}:** {value}")
 
-    # State keys for the selected job
-    job_processed_key = f"job_{selected_job_index}_processed_successfully" 
+    # State keys
+    job_processed_key = f"job_{selected_job_index}_processed_successfully"
     job_is_processing_key = f"job_{selected_job_index}_is_currently_processing"
+    st.session_state.setdefault(job_processed_key, False)
+    st.session_state.setdefault(job_is_processing_key, False)
 
-    # Initialize states if they don't exist for this job
-    if job_processed_key not in st.session_state: st.session_state[job_processed_key] = False
-    if job_is_processing_key not in st.session_state: st.session_state[job_is_processing_key] = False
-    
+    # Check existing sheet data
     sheet_name = f"{job_row['Role']} at {job_row['Company']}".strip()[:100]
     worksheet_exists = False
-    existing_candidates_from_sheet = [] # This will store raw data from sheet
+    existing_candidates_from_sheet = []
     try:
-        cand_worksheet = sh.worksheet(sheet_name)
+        with st.spinner("Checking for Ideal Candidates..."):
+            time .sleep(20) # Simulate some delay for checking
+        cand_ws = sh.worksheet(sheet_name)
         worksheet_exists = True
-        existing_data = cand_worksheet.get_all_values() # Get all values as list of lists
-        if len(existing_data) > 1: # Has data beyond header
-            existing_candidates_from_sheet = existing_data # Store raw data
-    except gspread.exceptions.WorksheetNotFound:
+        data = cand_ws.get_all_values()
+        if len(data) > 1:
+            existing_candidates_from_sheet = data
+    except Exception:
         pass
 
-    # --- Processing Control Area ---
-    # Show controls if not successfully processed in this session OR if sheet exists (allow re-process/overwrite)
-    if not st.session_state.get(job_processed_key, False) or existing_candidates_from_sheet: 
-        
-        if existing_candidates_from_sheet and not st.session_state.get(job_is_processing_key, False) and not st.session_state.get(job_processed_key, False):
-             st.info(f"Processing ('{sheet_name}')")
-
+    # Controls
+    if not st.session_state[job_processed_key] or existing_candidates_from_sheet:
         col_find, col_stop = st.columns(2)
         with col_find:
-            if st.button(f"Find Matching Candidates for this Job", key=f"find_btn_{selected_job_index}", disabled=st.session_state.get(job_is_processing_key, False)):
-                if not os.environ.get("OPENAI_API_KEY") or st.session_state.llm_chain is None: # Assuming llm_chain is in session_state
-                    st.error("OpenAI API key not set or LLM not initialized. Please check sidebar.")
+            if st.button("Find Matching Candidates for this Job", key=f"find_btn_{selected_job_index}",
+                         disabled=st.session_state[job_is_processing_key]):
+                if not os.environ.get("OPENAI_API_KEY") or st.session_state.llm_chain is None:
+                    st.error("OpenAI API key not set or LLM not initialized.")
                 else:
                     st.session_state[job_is_processing_key] = True
-                    st.session_state.stop_processing_flag = False # Reset for new run, assuming stop_processing_flag is used
-                    st.session_state.Selected_Candidates[selected_job_index] = [] # Clear previous run for this job
-                    st.session_state[job_processed_key] = False # Mark as not successfully processed yet for this attempt
+                    st.session_state.stop_processing_flag = False
+                    st.session_state.Selected_Candidates[selected_job_index] = []
+                    st.session_state[job_processed_key] = False
                     st.rerun()
-        
         with col_stop:
-            if st.session_state.get(job_is_processing_key, False): # Show STOP only if "Find" was clicked and currently processing
+            if st.session_state[job_is_processing_key]:
                 if st.button("STOP Processing", key=f"stop_btn_{selected_job_index}"):
-                    st.session_state.stop_processing_flag = True # Assuming stop_processing_flag is used
+                    st.session_state.stop_processing_flag = True
                     st.warning("Stop request sent. Processing will halt shortly.")
 
-    # --- Actual Processing Logic ---
-    if st.session_state.get(job_is_processing_key, False):
-        with st.spinner(f"Sourcing candidates for {job_row['Role']} at {job_row['Company']}..."):
-            # Assuming process_candidates_for_job is defined and handles stop_processing_flag
-            processed_candidates_list = process_candidates_for_job(
-                job_row, candidates_df, st.session_state.llm_chain # Assuming llm_chain from session_state
-            )
-        
-        st.session_state[job_is_processing_key] = False # Mark as no longer actively processing
-
-        if not st.session_state.get('stop_processing_flag', False): # If processing was NOT stopped
-            if processed_candidates_list:
-                # Ensure Fit Score is float for reliable sorting
-                for cand in processed_candidates_list:
-                    if 'Fit Score' in cand and isinstance(cand['Fit Score'], str):
-                        try: cand['Fit Score'] = float(cand['Fit Score'])
-                        except ValueError: cand['Fit Score'] = 0.0 # Default if conversion fails
-                    elif 'Fit Score' not in cand:
-                        cand['Fit Score'] = 0.0
-
-                processed_candidates_list.sort(key=lambda x: x.get("Fit Score", 0.0), reverse=True)
-                st.session_state.Selected_Candidates[selected_job_index] = processed_candidates_list
-                st.session_state[job_processed_key] = True # Mark as successfully processed
-
-                # Save to Google Sheet
+    # Processing
+    if st.session_state[job_is_processing_key]:
+        with st.spinner(f"Processing candidates for {job_row['Role']} at {job_row['Company']}..."):
+            processed_list = process_candidates_for_job(job_row, candidates_df, st.session_state.llm_chain)
+        st.session_state[job_is_processing_key] = False
+
+        if not st.session_state.get('stop_processing_flag', False):
+            if processed_list:
+                processed_list.sort(key=lambda x: x.get("Fit Score", 0.0), reverse=True)
+                st.session_state.Selected_Candidates[selected_job_index] = processed_list
+                st.session_state[job_processed_key] = True
                 try:
-                    target_worksheet = None
-                    if not worksheet_exists:
-                        target_worksheet = sh.add_worksheet(title=sheet_name, rows=max(100, len(processed_candidates_list) + 10), cols=20)
-                    else:
-                        target_worksheet = sh.worksheet(sheet_name)
-                    
-                    headers = list(processed_candidates_list[0].keys())
-                    # Ensure all values are converted to strings for gspread
-                    rows_to_write = [headers] + [[str(candidate.get(h, "")) for h in headers] for candidate in processed_candidates_list]
-                    target_worksheet.clear()
-                    target_worksheet.update('A1', rows_to_write)
+                    target_ws = sh.worksheet(sheet_name) if worksheet_exists else sh.add_worksheet(
+                        title=sheet_name, rows=max(100, len(processed_list)+10), cols=20)
+                    headers = list(processed_list[0].keys())
+                    rows = [headers] + [[str(c.get(h, "")) for h in headers] for c in processed_list]
+                    target_ws.clear()
+                    target_ws.update('A1', rows)
                     st.success(f"Results saved to Google Sheet: '{sheet_name}'")
                 except Exception as e:
                     st.error(f"Error writing to Google Sheet '{sheet_name}': {e}")
             else:
                 st.info("No suitable candidates found after processing.")
-                st.session_state.Selected_Candidates[selected_job_index] = [] 
-                st.session_state[job_processed_key] = True # Mark as processed, even if no results
-        else: # If processing WAS stopped
-            st.info("Processing was stopped by user. Results (if any) were not saved. You can try processing again.")
-            st.session_state.Selected_Candidates[selected_job_index] = [] # Clear any partial results
-            st.session_state[job_processed_key] = False # Not successfully processed
-        
-        st.session_state.pop('stop_processing_flag', None) # Clean up flag
-        st.rerun() # Rerun to update UI based on new state
-
-    # --- Display Results Area ---
-    should_display_results_area = False
-    final_candidates_to_display = [] # Initialize to ensure it's always defined
-
-    if st.session_state.get(job_is_processing_key, False):
-        should_display_results_area = False # Not if actively processing
-    elif st.session_state.get(job_processed_key, False): # If successfully processed in this session
-        should_display_results_area = True
-        final_candidates_to_display = st.session_state.Selected_Candidates.get(selected_job_index, [])
-    elif existing_candidates_from_sheet: # If not processed in this session, but sheet has data
-        should_display_results_area = True
-        headers = existing_candidates_from_sheet[0]
-        parsed_sheet_candidates = []
-        for row_idx, row_data in enumerate(existing_candidates_from_sheet[1:]): # Skip header row
-            candidate_dict = {}
-            for col_idx, header_name in enumerate(headers):
-                candidate_dict[header_name] = row_data[col_idx] if col_idx < len(row_data) else None
-            
-            # Convert Fit Score from string to float for consistent handling
-            if 'Fit Score' in candidate_dict and isinstance(candidate_dict['Fit Score'], str):
-                try:
-                    candidate_dict['Fit Score'] = float(candidate_dict['Fit Score'])
-                except ValueError:
-                    st.warning(f"Could not convert Fit Score '{candidate_dict['Fit Score']}' to float for candidate in sheet row {row_idx+2}.")
-                    candidate_dict['Fit Score'] = 0.0 # Default if conversion fails
-            elif 'Fit Score' not in candidate_dict:
-                 candidate_dict['Fit Score'] = 0.0
-
-
-            parsed_sheet_candidates.append(candidate_dict)
-        final_candidates_to_display = sorted(parsed_sheet_candidates, key=lambda x: x.get("Fit Score", 0.0), reverse=True)
-        if not st.session_state.get(job_processed_key, False): # Inform if loading from sheet and not explicitly processed
-             st.info(f"Displaying: '{sheet_name}'.")
-    
-    if should_display_results_area:
-        st.subheader("Selected Candidates")
-        
-        # Display token usage if it was just processed (job_processed_key is True and tokens exist)
-        if st.session_state.get(job_processed_key, False) and \
-           (st.session_state.get('total_input_tokens', 0) > 0 or st.session_state.get('total_output_tokens', 0) > 0):
-            display_token_usage() # Assuming display_token_usage is defined
-
-        if final_candidates_to_display:
-            for i, candidate in enumerate(final_candidates_to_display):
-                score_display = candidate.get('Fit Score', 'N/A')
-                if isinstance(score_display, (float, int)): 
-                    score_display = f"{score_display:.3f}"
-                # If score_display is still a string (e.g. 'N/A' or failed float conversion), it will be displayed as is.
-
-                expander_title = f"{i+1}. {candidate.get('Name', 'N/A')} (Score: {score_display})"
-                
-                with st.expander(expander_title):
-                    text_to_copy = f"""Candidate: {candidate.get('Name', 'N/A')} (Score: {score_display})
-Summary: {candidate.get('summary', 'N/A')}
-Current: {candidate.get('Current Title & Company', 'N/A')}
-Education: {candidate.get('Educational Background', 'N/A')}
-Experience: {candidate.get('Years of Experience', 'N/A')}
-Location: {candidate.get('Location', 'N/A')}
-LinkedIn: {candidate.get('LinkedIn', 'N/A')}
-Justification: {candidate.get('justification', 'N/A')}
-"""
-                    js_text_to_copy = json.dumps(text_to_copy)
-                    button_unique_id = f"copy_btn_job{selected_job_index}_cand{i}"
-
-                    copy_button_html = f"""
-                    <script>
-                        function copyToClipboard_{button_unique_id}() {{
-                            const textToCopy = {js_text_to_copy};
-                            navigator.clipboard.writeText(textToCopy).then(function() {{
-                                const btn = document.getElementById('{button_unique_id}');
-                                if (btn) {{ // Check if button exists
-                                    const originalText = btn.innerText;
-                                    btn.innerText = 'Copied!';
-                                    setTimeout(function() {{ btn.innerText = originalText; }}, 1500);
-                                }}
-                            }}, function(err) {{
-                                console.error('Could not copy text: ', err);
-                                alert('Failed to copy text. Please use Ctrl+C or your browser\\'s copy function.');
-                            }});
-                        }}
-                    </script>
-                    <button id="{button_unique_id}" onclick="copyToClipboard_{button_unique_id}()">📋 Copy Details</button>
-                    """
-                    
-                    expander_cols = st.columns([0.82, 0.18]) 
-                    with expander_cols[1]: 
-                        st.components.v1.html(copy_button_html, height=40) 
-                    
-                    with expander_cols[0]: 
-                        st.markdown(f"**Summary:** {candidate.get('summary', 'N/A')}")
-                        st.markdown(f"**Current:** {candidate.get('Current Title & Company', 'N/A')}")
-                        st.markdown(f"**Education:** {candidate.get('Educational Background', 'N/A')}")
-                        st.markdown(f"**Experience:** {candidate.get('Years of Experience', 'N/A')}")
-                        st.markdown(f"**Location:** {candidate.get('Location', 'N/A')}")
-                        if 'LinkedIn' in candidate and candidate.get('LinkedIn'):
-                            st.markdown(f"**[LinkedIn Profile]({candidate['LinkedIn']})**") 
-                        else:
-                            st.markdown("**LinkedIn Profile:** N/A")
-                    
-                    if 'justification' in candidate and candidate.get('justification'):
+                st.session_state.Selected_Candidates[selected_job_index] = []
+                st.session_state[job_processed_key] = True
+        else:
+            st.info("Processing was stopped by user.")
+            st.session_state[job_processed_key] = False
+            st.session_state.Selected_Candidates[selected_job_index] = []
+        st.session_state.pop('stop_processing_flag', None)
+        st.rerun()
+
+    # Display results
+    should_display = False
+    final_candidates = []
+    if not st.session_state[job_is_processing_key]:
+        if st.session_state[job_processed_key]:
+            should_display = True
+            final_candidates = st.session_state.Selected_Candidates[selected_job_index]
+        elif existing_candidates_from_sheet:
+            should_display = True
+            headers = existing_candidates_from_sheet[0]
+            for row in existing_candidates_from_sheet[1:]:
+                cand = {headers[i]: row[i] if i < len(row) else None for i in range(len(headers))}
+                try: cand['Fit Score'] = float(cand.get('Fit Score',0))
+                except: cand['Fit Score'] = 0.0
+                final_candidates.append(cand)
+            final_candidates.sort(key=lambda x: x.get('Fit Score',0.0), reverse=True)
+            if not st.session_state[job_processed_key]:
+                st.info(f"Displaying: '{sheet_name}'.")
+
+    if should_display:
+        # Prepare combined text for Copy All
+        combined_text = ""
+        for cand in final_candidates:
+            combined_text += f"Name: {cand.get('Name','N/A')}\nLinkedIn URL: {cand.get('LinkedIn','N/A')}\n\n"
+
+        # Header and Copy All button side by side
+        col_title, col_copyall = st.columns([3,1])
+        with col_title:
+            st.subheader("Selected Candidates")
+        with col_copyall:
+            # Use HTML component to reliably include script and button
+            import json
+            html = f'''
+            <button id="copy-all-btn">📋 Copy All</button>
+            <script>
+            const combinedText = {json.dumps(combined_text)};
+            document.getElementById("copy-all-btn").onclick = () => {{
+                navigator.clipboard.writeText(combinedText);
+            }};
+            </script>
+            '''
+            st.components.v1.html(html, height=60)
+
+        # Token usage
+        if st.session_state.get(job_processed_key) and (
+           st.session_state.get('total_input_tokens',0) > 0 or st.session_state.get('total_output_tokens',0) > 0):
+            display_token_usage()
+
+        # List individual candidates
+        for i, candidate in enumerate(final_candidates):
+            score = candidate.get('Fit Score',0.0)
+            score_display = f"{score:.3f}" if isinstance(score,(int,float)) else score
+            exp_title = f"{i+1}. {candidate.get('Name','N/A')} (Score: {score_display})"
+            with st.expander(exp_title):
+                text_copy = f"Candidate: {candidate.get('Name','N/A')}\nLinkedIn: {candidate.get('LinkedIn','N/A')}\n"
+                btn = f"copy_btn_job{selected_job_index}_cand{i}"
+                js = f'''
+                <script>
+                function copyToClipboard_{btn}() {{ navigator.clipboard.writeText(`{text_copy}`); }}
+                </script>
+                <button onclick="copyToClipboard_{btn}()">📋 Copy Details</button>
+                '''
+                cols = st.columns([0.82,0.18])
+                with cols[1]: st.components.v1.html(js, height=40)
+                with cols[0]:
+                    st.markdown(f"**Summary:** {candidate.get('summary','N/A')}")
+                    st.markdown(f"**Current:** {candidate.get('Current Title & Company','N/A')}")
+                    st.markdown(f"**Education:** {candidate.get('Educational Background','N/A')}")
+                    st.markdown(f"**Experience:** {candidate.get('Years of Experience','N/A')}")
+                    st.markdown(f"**Location:** {candidate.get('Location','N/A')}")
+                    if candidate.get('LinkedIn'):
+                        st.markdown(f"**[LinkedIn Profile]({candidate['LinkedIn']})**")
+                    if candidate.get('justification'):
                         st.markdown("**Justification:**")
                         st.info(candidate['justification'])
-                        
-        elif st.session_state.get(job_processed_key, False): # Processed but no candidates
-            st.info("No candidates met the criteria for this job after processing.")
-        
-        # This "Reset" button is now governed by should_display_results_area
+
+        # Reset
         if st.button("Reset and Process Again", key=f"reset_btn_{selected_job_index}"):
             st.session_state[job_processed_key] = False
-            st.session_state.pop(job_is_processing_key, None) 
-            if selected_job_index in st.session_state.Selected_Candidates:
-                del st.session_state.Selected_Candidates[selected_job_index]
-            try:
-                sh.worksheet(sheet_name).clear()
-                st.info(f"Cleared Google Sheet '{sheet_name}' as part of reset.")
-            except: pass # Ignore if sheet not found or error
+            st.session_state.pop(job_is_processing_key, None)
+            st.session_state.Selected_Candidates.pop(selected_job_index, None)
+            try: sh.worksheet(sheet_name).clear()
+            except: pass
             st.rerun()
 
+
+
 if __name__ == "__main__":
     main()