from record_team_audio import automate_meeting from flask import Flask, request, jsonify, send_file from record_team_video import run_meeting_recording import threading from datetime import datetime, timedelta # import pytz import time import os import requests from json_evaluation import json_report import os # import subprocess from helpers import * from resume_func import explain_resume_failure, ocr_pdf_to_text, resume_extract, check_resume, extract_json_from_txt, pdf_to_text, doc_to_text, docx_to_text, save_json_file,pdf_to_base64, check_resume_img,convert_to_pdf from match_cv import matching_cv, matching_cv_img, extract_cv, extract_cv_img, validate_cv, validate_cv_img from groq_module import chat_with_groq from dotenv import load_dotenv from flask_cors import CORS # Load environment variables load_dotenv() PORT_NO = int(os.getenv("PORT")) app = Flask(__name__) CORS(app) @app.route('/teams-audio-record', methods=['POST']) def start_audio_meeting_recording(): try: data = request.json meeting_link = data.get('meetingLink', '') node_url = data.get('apiUrl', '') interviewId = data.get('interviewId', None) uniqueId = data.get('uniqueId', '') timestamp = data.get('dateTime',None) timezone = data.get('timezone','') input_time, input_date = convert_timestamp_to_datetime(timestamp, timezone) result = is_upcoming(input_time, input_date) # If the result is True, start the thread if result: thread = threading.Thread(target=automate_meeting, args=(meeting_link, uniqueId, input_time, input_date, interviewId, node_url)) thread.start() return jsonify({ "success": True, "statusCode": 200, "message": "Bot scheduled successfully", }) else: return jsonify({ "success": False, "statusCode": 400, "message": "The meeting time is in the past, cannot schedule", }) except Exception as e: # Handle exceptions for the thread initialization return jsonify({ "success": False, "statusCode": 500, "message": f"An error occurred: {str(e)}" }) @app.route('/video-record', methods=['POST']) def start_video_meeting_recording(): try: data = request.json # meeting_link = data.get('meeting_link', '') # input_time = data.get('input_time', datetime.now().strftime("%H:%M")) # input_date = data.get('input_date', datetime.now().strftime("%Y-%m-%d")) meeting_link = data.get('meetingLink', '') node_url = data.get('apiUrl', '') interviewId = data.get('interviewId', None) uniqueId = data.get('uniqueId', '') meetingType = data.get('meetingType', '') timestamp = data.get('dateTime',None) timezone = data.get('timezone','') adjusted_timestamp = subtract_minutes_from_epoch(timestamp, 3) input_time, input_date = convert_timestamp_to_datetime(adjusted_timestamp, timezone) print("input_time: ",input_time) print("input_date: ",input_date) result = is_upcoming(input_time, input_date) # If the result is True, start the thread if result: # Run the recording process if meetingType == "teams": thread = threading.Thread(target=run_meeting_recording, args=(meeting_link,input_time, input_date, uniqueId, node_url,interviewId)) thread.start() return jsonify({ "success": True, "statusCode": 200, "message": "Bot scheduled successfully", }) else: return jsonify({ "success": False, "statusCode": 400, "message": "The meeting time is in the past, cannot schedule", }) except Exception as e: # Handle exceptions for the thread initialization return jsonify({ "success": False, "statusCode": 500, "message": f"An error occurred: {str(e)}" }) @app.route('/json_report', methods=['POST']) def report(): try: # Check if 'video' file is in the request if 'video' not in request.files: return jsonify({ "message": "No 'video' file in request", "statusCode": 400, "success": False }), 400 video_file = request.files['video'] # Check if the uploaded file is an MP4 file if not video_file.filename.lower().endswith('.mp4'): return jsonify({ "message": "Invalid file format. Please upload an MP4 file", "statusCode": 400, "success": False }), 400 print("File received:", video_file.filename) # Save the uploaded file temporarily video_file_path = 'temp_audio.mp4' video_file.save(video_file_path) # Ensure file was saved if not os.path.exists(video_file_path): return jsonify({ "message": "Failed to save uploaded file", "statusCode": 500, "success": False }), 500 print("Saved file:", video_file_path) # Convert MP4 to WAV audio_file_path = 'temp_audio.wav' output_image = "screenshot.jpg" print(f"++++++++++++++++++++++Converting {video_file_path} to {audio_file_path}+++++++++++++++++") mp4_to_wav(video_file_path, audio_file_path) # Ensure WAV file was created if not os.path.exists(audio_file_path): return jsonify({ "message": "WAV file not generated", "statusCode": 500, "success": False }), 500 print("WAV file created:", audio_file_path) print(f"+++++++GOING INSIDE JSON REPORT METHOD ++++++++++++++") json_data = json_report(audio_file_path) capture_screenshot(video_file_path, output_image) json_data['screenshot'] = output_image # return jsonify({'message': "Conversion successful", 'Json_report': json_data}), 200 return jsonify(json_data), 200 except Exception as e: print(f"Error occurred: {str(e)}") return jsonify({'message': 'An error occurred during processing', 'error': str(e)}), 500 @app.route('/resume_extract', methods=['POST']) def resume_cv_ext(): upload_folder = "uploads" # Ensure the upload folder exists if not os.path.exists(upload_folder): os.makedirs(upload_folder) # Extract file from the request file = request.files.get('cv') if not file or file.filename == '': return jsonify({"error": "No file part or no file selected"}), 400 # Validate file extension file_extension = file.filename.rsplit('.', 1)[1].lower() allowed_extensions = ['pdf', 'doc', 'docx'] if file_extension not in allowed_extensions: return jsonify({"error": "Invalid file format. Please upload a PDF, DOC, or DOCX file."}), 400 try: # Save the uploaded file temporarily file_path = os.path.join(upload_folder, file.filename) file.save(file_path) # Extract text based on file type extracted_text = None base_64_data = None img_data = 0 if file_extension == 'pdf': extracted_text = pdf_to_text(file_path) if len(extracted_text) < 100: base_64_data = pdf_to_base64(file_path) img_data = 1 elif file_extension == 'doc': extracted_text = doc_to_text(file_path) elif file_extension == 'docx': extracted_text = docx_to_text(file_path) if not extracted_text: return jsonify({"error": "Failed to extract text from the file."}), 500 attempt = 0 while attempt<3: # Perform CV matching if img_data == 0: json_data = extract_cv(extracted_text) else: json_data = extract_cv_img(base_64_data) if not json_data: return jsonify({"error": "Failed to extract JSON from the text."}), 500 print("json Data: ",json_data) last_name = (json_data.get('lastName') or '').strip() print("Last name 1: ",last_name) first_name = (json_data.get('firstName') or '').strip() email = (json_data.get('email') or '').strip() job_title = (json_data.get('jobTitle') or '').strip() technologies = json_data.get('technologies', []) experience = json_data.get('experience', 0) certifications = json_data.get('certifications', []) bio = json_data.get('bio', '') projects = json_data.get('projects', []) contry_code = '+91' contact_number = '09876543210' validation = validate_input(first_name,email, job_title, technologies,experience) if validation: final_resume_data = { "firstName": first_name, "lastName": last_name, "jobTitle": job_title, "email": email, "technologies": technologies, "experience": experience, "certifications": certifications, "bio": bio, "projects": projects, "countryCode": contry_code, "contactNumber": contact_number, } return jsonify({ "message": "Resume Extracted Successfully.", "statusCode": 200, "success": True, "resumeData": final_resume_data }), 200 else: print("Validation failed. Retrying...") attempt += 1 if attempt < 3: print(f"Retrying in {attempt} seconds...") time.sleep(attempt) else: return jsonify({ "message": "Failed to Extract data from cv.", "statusCode": 200, "success": False, }), 500 except Exception as e: return jsonify({"error": str(e)}), 400 @app.route('/analyze_and_submit', methods=['POST']) def analyze_and_submit(): upload_folder = "uploads" if not os.path.exists(upload_folder): os.makedirs(upload_folder) if 'file' not in request.files: return jsonify({"error": "No file part"}), 400 if 'companyProfileId' not in request.form: return jsonify({"error": "Required parameters not provided"}), 400 company_profile_id = request.form['companyProfileId'] file = request.files['file'] endpoint = request.form['endpoint'] addedById = request.form['addedById'] if file.filename == '': return jsonify({"error": "No selected file"}), 400 file_extension = file.filename.rsplit('.', 1)[1].lower() allowed_extensions = ['pdf', 'doc', 'docx'] if file_extension not in allowed_extensions: return jsonify({"error": "Invalid file format. Please upload a PDF, DOC, or DOCX file."}), 400 try: file_path = os.path.join(upload_folder, file.filename) file.save(file_path) if file_extension == 'pdf': extracted_text = pdf_to_text(file_path) elif file_extension == 'doc': extracted_text = doc_to_text(file_path) elif file_extension == 'docx': extracted_text = docx_to_text(file_path) if extracted_text: response_ext = resume_extract(extracted_text) json_data = extract_json_from_txt(response_ext) if json_data: save_json_file(json_data, file_path) external_api_data = { "firstName": json_data.get('firstName', ''), "lastName": json_data.get('lastName', ''), "jobTitle": json_data.get('jobTitle', ''), "email": json_data.get('email', ''), "technologies": json_data.get('technologies', []), "experience": json_data.get('experience', 0), "certify": json_data.get('certifications', []), "bio": json_data.get('bio', ''), "projects": json_data.get('projects', []), "countryCode": "+91", "contactNumber": "09876543210", "addedById": addedById, "companyProfileId": company_profile_id } headers = { 'Content-Type': 'application/json', } external_api_url = endpoint response = requests.post(external_api_url, json=external_api_data, headers=headers) print(f"External API Status Code: {response.status_code}") print(f"External API Response: {response.text}") if response.status_code in [200, 201]: try: api_response_json = response.json() print(f"Parsed API Response: {api_response_json}") if api_response_json.get('success'): return jsonify({ "message": "Resume Analyzed and Data Submitted Successfully.", "data": json_data, "api_response": api_response_json }), 200 else: return jsonify({ "error": "API returned a success status but indicated failure.", "api_error": api_response_json }), 500 except ValueError: return jsonify({ "error": "Failed to parse the API response as JSON.", "api_response": response.text }), 500 else: return jsonify({ "error": "Failed to submit data to the external API.", "api_error": response.text }), response.status_code else: return jsonify({"error": "Failed to parse JSON from the response."}), 500 else: return jsonify({"error": "Failed to extract text from the file."}), 500 except Exception as e: return jsonify({"error": str(e)}), 400 # To check if uploaded file is a resume or not @app.route('/is_resume_or_not', methods=['POST']) def check(): upload_folder = "uploads" os.makedirs(upload_folder, exist_ok=True) if 'file' not in request.files: return jsonify({"error": "No file part"}), 400 file = request.files['file'] if file.filename == '': return jsonify({"error": "No selected file"}), 400 ext = file.filename.rsplit('.', 1)[1].lower() if ext not in ['pdf', 'doc', 'docx']: return jsonify({"error": "Invalid file format. Only PDF, DOC, or DOCX are supported."}), 400 try: file_path = os.path.join(upload_folder, file.filename) file.save(file_path) print(f" File saved at: {file_path}") print(f" Detected file type: .{ext}") extracted_text = "" # Step 1: Try standard text extraction if ext == 'pdf': print(" Trying standard text extraction for PDF...") extracted_text = pdf_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: print(" PDF text too short. Running OCR fallback...") extracted_text = ocr_pdf_to_text(file_path) or "No text found" elif ext in ['doc', 'docx']: print(f" Trying standard text extraction for {ext.upper()}...") extracted_text = doc_to_text(file_path) if ext == 'doc' else docx_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: print("⚠ Text too short. Converting to PDF for OCR...") pdf_path = convert_to_pdf(file_path) if pdf_path: extracted_text = ocr_pdf_to_text(pdf_path) or "No text found" print(f"---------- EXTRACTED TEXT ---------------:\n{extracted_text}") # Step 2: Resume check print("🔍 Running resume detection...") is_resume = check_resume(extracted_text) if extracted_text else False if not is_resume: print(" Not a resume (as per LLM classification).") return jsonify({"valid": False}), 200 print(" Confirmed resume. Extracting fields...") # Step 3: Field extraction data = validate_cv(extracted_text) print(" Extracted fields from resume:") print(json.dumps(data, indent=2)) if not isinstance(data, dict) or data.get("error"): return jsonify({"valid": False}), 200 # Step 4: Validate fields is_valid = validate_input( (data.get("firstName") or '').strip(), (data.get("email") or '').strip(), (data.get("jobTitle") or '').strip(), data.get("technologies", []), data.get("experience", None) ) return jsonify({ "valid": bool(is_valid), }), 200 except Exception as e: return jsonify({"error": str(e)}), 400 # To check if uploaded file is a resume or not and shows message in frontend with REASON @app.route('/resume-check', methods=['POST']) def resume_check(): upload_folder = "uploads" os.makedirs(upload_folder, exist_ok=True) if 'file' not in request.files: return jsonify({ "success": False, "statusCode": 400, "message": "No file uploaded", "data": {"valid": False} }), 400 file = request.files['file'] if file.filename == '': return jsonify({ "success": False, "statusCode": 400, "message": "No file selected", "data": {"valid": False} }), 400 ext = file.filename.rsplit('.', 1)[1].lower() if ext not in ['pdf', 'doc', 'docx']: return jsonify({ "success": False, "statusCode": 422, "message": "Uploaded resume file is of invalid file format", "data": {"valid": False} }), 422 try: file_path = os.path.join(upload_folder, file.filename) file.save(file_path) # Step 1: Extract text extracted_text = "" if ext == 'pdf': extracted_text = pdf_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: extracted_text = ocr_pdf_to_text(file_path) or "" elif ext == 'doc': extracted_text = doc_to_text(file_path) elif ext == 'docx': extracted_text = docx_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: return jsonify({ "success": False, "statusCode": 422, "message": "No readable text found in the document", "data": {"valid": False} }), 422 # Step 2: Resume classification check is_resume = check_resume(extracted_text) if not is_resume: return jsonify({ "success": False, "statusCode": 422, "message": "Document is not in resume format or lacks resume-like content", "data": {"valid": False} }), 422 # Step 3: Extract fields data = validate_cv(extracted_text) if not isinstance(data, dict) or data.get("error"): return jsonify({ "success": False, "statusCode": 422, "message": "Resume structure invalid, required fields missing", "data": {"valid": False} }), 422 # Step 4: Field validation missing_fields = [] if not (data.get("firstName") or '').strip(): missing_fields.append("first name") if not (data.get("email") or '').strip(): missing_fields.append("email") if not (data.get("jobTitle") or '').strip(): missing_fields.append("job title") if missing_fields: return jsonify({ "success": False, "statusCode": 422, "message": f"Resume is missing fields: {', '.join(missing_fields)}", "data": {"valid": False} }), 422 # All checks passed return jsonify({ "success": True, "statusCode": 200, "message": "Uploaded document is a valid resume", "data": {"valid": True} }), 200 except Exception as e: error_message = str(e).lower() if 'api limit' in error_message or 'an error occurred' in error_message: return jsonify({ "success": False, "statusCode": 429, "message": "API limit exceeded", "data": {"valid": False} }), 429 return jsonify({ "success": False, "statusCode": 500, "message": f"Processing error: {str(e)}", "data": {"valid": False} }), 500 @app.route('/jd-generate', methods=['POST']) def jd_generate(): try: data = request.json # Input validation with original format job_title = (data.get('jobTitle') or '').strip() experience = data.get('experience', 0) technologies = data.get('technologies', []) if not job_title: return jsonify({"error": "Job title is required", "status": 400}), 400 attempt = 0 max_retries = 3 while attempt < max_retries: try: validity_check = f""" Analyze this job title candidate: "{job_title}" With these skills/technologies: {technologies if technologies else 'Not specified'} Rules: 1. FIRST determine the core role type (developer, writer, manager, etc.) from the title 2. THEN specialize it based on technologies/skills if relevant 3. For ambiguous cases (like "Content"), use technologies to determine specialization Examples: - "Content" + ["Blogging"] → "Content Writer" - "Content" + ["CMS", "SEO"] → "Content Manager" - "React" → "React Developer" - "Project" + 5y exp → "Project Manager" Output ONLY JSON: {{ "jobTitle": "accurate_title", // or "invalid" "reason": "brief explanation" }} """ # Added error handling for title validation try: validation_response = chat_with_groq(validity_check) validation_data = extract_json_from_string(validation_response) corrected_job_title = validation_data.get("jobTitle", "invalid") except Exception as e: print(f"Title validation failed: {str(e)}") corrected_job_title = "invalid" if corrected_job_title == "invalid": return jsonify({"job_desc": None, "message": "Invalid job title", "status": 400}), 400 job_title = corrected_job_title # Enhanced JD prompt (same output format) prompt = f""" Generate a professional job description for: - Position: {job_title} - Experience: {experience} years - Technologies: {', '.join(technologies) if technologies else 'Not specified'} Use this EXACT JSON format: {{ "jobTitle": "(same as input position)", "jobSummary": "2-3 sentence overview", "requirements": ["list", "of", "requirements"], "responsibilities": ["list", "of", "responsibilities"] }} """ # JD generation with better error handling try: jd_response = chat_with_groq(prompt) jd_data = extract_json_from_string(jd_response) if not jd_data: raise ValueError("Empty JD response") return jsonify({ "topic": job_title, "job_desc": jd_data }), 200 except Exception as e: print(f"JD generation attempt {attempt + 1} failed: {str(e)}") raise except Exception as e: attempt += 1 if attempt == max_retries: return jsonify({ "error": str(e), "status": 500 }), 500 time.sleep(1) except Exception as e: return jsonify({ "error": str(e), "status": 500 }), 500 # to match resume with job description @app.route('/resume_match', methods=['POST']) def matching_resume_jd(): upload_folder = "uploads" passing_criteria = 60 # Ensure the upload folder exists if not os.path.exists(upload_folder): os.makedirs(upload_folder) # Extract file from the request file = request.files.get('cv') if not file or file.filename == '': return jsonify({"error": "No file part or no file selected"}), 400 # Extract JSON fields from the request form (multipart/form-data) job_desc_id = request.form.get('jobId') title = (request.form.get('title') or '').strip() job_title = (request.form.get('jobTitle') or '').strip() description = (request.form.get('description') or '').strip() technologies = (request.form.get('technologies') or '').strip() experience = (request.form.get('experience') or '').strip() document = (request.form.get('document') or '').strip() company_profile_id = request.form.get('companyProfileId') external_api_url = request.form.get('externalApiUrl') added_by_id = request.form.get('addedById') # Validate required fields if not job_desc_id or not external_api_url or not added_by_id: return jsonify({"error": "Missing required fields"}), 400 # Validate file extension file_extension = file.filename.rsplit('.', 1)[1].lower() allowed_extensions = ['pdf', 'doc', 'docx'] if file_extension not in allowed_extensions: return jsonify({"error": "Invalid file format. Please upload a PDF, DOC, or DOCX file."}), 400 try: # Save the uploaded file temporarily file_path = os.path.join(upload_folder, file.filename) file.save(file_path) if file_extension == 'pdf': print(" Trying standard text extraction for PDF...") extracted_text = pdf_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: print("⚠ PDF text too short. Running OCR fallback...") extracted_text = ocr_pdf_to_text(file_path) elif file_extension in ['doc', 'docx']: print(f" Trying standard text extraction for {file_extension.upper()}...") extracted_text = doc_to_text(file_path) if file_extension == 'doc' else docx_to_text(file_path) if not extracted_text or len(extracted_text.strip()) < 100: print("⚠ Text too short. Converting to PDF for OCR...") pdf_path = convert_to_pdf(file_path) if pdf_path: extracted_text = ocr_pdf_to_text(pdf_path) print(f"---------- EXTRACTED TEXT ---------------:\n{extracted_text}") attempt = 0 if not extracted_text: return jsonify({"error": "Failed to extract text from the file.", "statusCode": 500}), 500 json_data = matching_cv(extracted_text, title, job_title, description, technologies, experience) print("-----------Resume match JSON DATA ---------------: ",json_data) if not json_data: return jsonify({ "message": "Resume Analyzed but could not extract sufficient data.", "screening_percentage": 0, "screening_status": False, "statusCode": 500, "api_response": {} }), 200 screening_percentage = json_data.get("Screening_percentage", 0) screening_status = screening_percentage > passing_criteria print("screening_percentage:", screening_percentage) print("screening_status:", screening_status) last_name = (json_data.get('lastName') or '').strip() print("Last name 1: ",last_name) last_name = '' if 'not' in last_name.lower() else last_name payload = { "externalApiData": { "jobId": job_desc_id, "screeningPercentage": screening_percentage, "screeningStatus": screening_status, }, "resourceApiData": { "firstName": json_data.get('firstName', ''), "lastName": last_name, "jobTitle": json_data.get('jobTitle', ''), "email": json_data.get('email', ''), "technologies": json_data.get('technologies', []), "experience": json_data.get('experience', 0), "certify": json_data.get('certifications', []), "bio": json_data.get('bio', ''), "projects": json_data.get('projects', []), "countryCode": "+91", "contactNumber": "09876543210", "addedById": added_by_id, "companyProfileId": company_profile_id, "document": document } } # External API headers headers = { 'Content-Type': 'application/json', } print("Payload:", payload) # Hit the external API response = requests.post(external_api_url, json=payload, headers=headers) if response.status_code in [200, 201]: api_response_json = response.json() if api_response_json.get('success'): return jsonify({ "message": "Resume Analyzed and Data Submitted Successfully.", "screening_percentage": screening_percentage, "screening_status": screening_status, "statusCode": response.status_code, "api_response": api_response_json }), 200 else: return jsonify({ "message": "Resume Analyzed but API indicated failure.", "screening_percentage": screening_percentage, "screening_status": screening_status, "statusCode": 500, "api_response": api_response_json }), 200 else: return jsonify({ "message": "Resume Analyzed but external API call failed.", "screening_percentage": screening_percentage, "screening_status": screening_status, "statusCode": response.status_code, "api_response": response.text }), response.status_code except Exception as e: return jsonify({ "message": "Exception occurred during processing.", "screening_percentage": 0, "screening_status": False, "statusCode": 500, "api_response": str(e) }), 500 if __name__ == '__main__': app.run(debug=True,port=PORT_NO,host='0.0.0.0')