app.py

# libraries
from flask import Flask, render_template, request, redirect, url_for, flash, session, send_from_directory, jsonify
import os
import logging
from utility.utils import extract_text_from_images, Data_Extractor, json_to_llm_str, process_extracted_text, process_resume_data
from backup.backup import NER_Model
from paddleocr import PaddleOCR

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    handlers=[
        logging.StreamHandler()  # Remove FileHandler and log only to the console
    ]
)

# Flask App
app = Flask(__name__)
app.secret_key = 'your_secret_key'

app.config['UPLOAD_FOLDER'] = 'uploads/'
app.config['RESULT_FOLDER'] = 'results/'

UPLOAD_FOLDER = 'static/uploads/'
RESULT_FOLDER = 'static/results/'

os.makedirs(UPLOAD_FOLDER, exist_ok=True)
os.makedirs(RESULT_FOLDER, exist_ok=True)

if not os.path.exists(app.config['UPLOAD_FOLDER']):
    os.makedirs(app.config['UPLOAD_FOLDER'])

if not os.path.exists(app.config['RESULT_FOLDER']):
    os.makedirs(app.config['RESULT_FOLDER'])

# Set the PaddleOCR home directory to a writable location
os.environ['PADDLEOCR_HOME'] = '/tmp/.paddleocr' 

# Check if PaddleOCR home directory is writable
if not os.path.exists('/tmp/.paddleocr'):
    os.makedirs('/tmp/.paddleocr', exist_ok=True)
    logging.info("Created PaddleOCR home directory.")
else:
    logging.info("PaddleOCR home directory exists.")

@app.route('/')
def index():
    uploaded_files = session.get('uploaded_files', [])
    logging.info(f"Accessed index page, uploaded files: {uploaded_files}")
    return render_template('index.html', uploaded_files=uploaded_files)

@app.route('/process', methods=['GET','POST'])
def upload_file():
    try:
       
        # Check if the 'files' part exists in the request
        if 'files' not in request.files:
            print("No 'files' part in the request")
            logging.warning("No file part found in the request")
            return jsonify({'message': "No file part found in the request"})

        # Get all files from the request
        files = request.files.getlist('files')
        if not files or all(file.filename == '' for file in files):
            print("No files selected for upload")
            logging.warning("No files selected for upload")
            return jsonify({'message': "No files selected for upload"})

        uploaded_files = session.get('uploaded_files', [])
        for file in files:
            if file:
                filename = file.filename
                file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                print(f"Saving file to: {file_path}")
                try:
                    # Save the file
                    file.save(file_path)
                    uploaded_files.append(filename)
                    logging.info(f"Uploaded file: {filename} at {file_path}")
                except Exception as save_error:
                    logging.error(f"Error saving file {filename}: {save_error}")
                    return jsonify({'message': f"Error saving file {filename}"}), 500

        session['uploaded_files'] = uploaded_files  # Store uploaded files in session
        logging.info(f"Files successfully uploaded: {uploaded_files}")
        return process_file(uploaded_files)

    except Exception as e:
        logging.error(f"An error occurred during file upload: {e}")
        return jsonify({'message': 'File upload failed'}), 500

@app.route('/remove_file')
def remove_file():
    uploaded_files = session.get('uploaded_files', [])
    for filename in uploaded_files:
        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        if os.path.exists(file_path):
            os.remove(file_path)
            logging.info(f"Removed file: {filename}")
        else:
            logging.warning(f"File not found for removal: {file_path}")  # More specific log

    session.pop('uploaded_files', None)  
    print('Files successfully removed')
    logging.info("All uploaded files removed")
    return redirect(url_for('index'))

@app.route('/process_file/<filename>', methods=['GET', 'POST'])
def process_file(filename):
    try:
        uploaded_files = session.get('uploaded_files', [])
        if not uploaded_files:
            print('No files selected for processing')
            logging.warning("No files selected for processing")
            return redirect(url_for('index'))

        # Joining the base and the requested path
        file_paths = [os.path.join(app.config['UPLOAD_FOLDER'], filename) for filename in uploaded_files]
        logging.info(f"Processing files: {file_paths}")

        extracted_text = {}
        processed_Img = {}

        # Try to process using the main model (Mistral 7b)
        try:
            extracted_text, processed_Img = extract_text_from_images(file_paths)
            logging.info(f"Extracted text: {extracted_text}")
            logging.info(f"Processed images: {processed_Img}")

            #run the model code only if the text is extracted.
            if extracted_text:
                llmText = json_to_llm_str(extracted_text)
                logging.info(f"LLM text: {llmText}")

                #run the model code only if the text is extracted.
                LLMdata = Data_Extractor(llmText)
                print("Json Output from model------------>",LLMdata)
                logging.info(f"LLM data: {LLMdata}")
            else:
                raise ('The text is not detected in the OCR')

        except Exception as model_error:
            logging.error(f"Error during LLM processing: {model_error}")
            logging.info("Running backup model...")

            # Use backup model in case of errors
            LLMdata = {}
            extracted_text, processed_Img = extract_text_from_images(file_paths)
            logging.info(f"Extracted text (Backup): {extracted_text}")
            logging.info(f"Processed images (Backup): {processed_Img}")
            
            if extracted_text:
                text = json_to_llm_str(extracted_text)
                LLMdata = NER_Model(text)
                print("Json Output from model------------>",LLMdata)
                logging.info(f"NER model data: {LLMdata}")
            else:
                logging.warning("No extracted text available for backup model")

        # Process extracted text and structure the output
        cont_data = process_extracted_text(extracted_text)
        logging.info(f"Contextual data: {cont_data}")

        processed_data = process_resume_data(LLMdata, cont_data, extracted_text)
        logging.info(f"Processed data: {processed_data}")

        # Save data in session for later use
        session['processed_data'] = processed_data
        session['processed_Img'] = processed_Img

        print('Data processed and analyzed successfully')
        logging.info("Data processed and analyzed successfully")
        return jsonify({
        'data': [processed_data], 
        'process_image': processed_Img, 
        'success': True, 
        'message': 'Data processed and analyzed successfully'
    })

    except Exception as e:
        logging.error(f"An unexpected error occurred during file processing: {e}")
        print('An error occurred during file processing')
        return jsonify({'message': 'File processing failed'}), 500

@app.route('/uploads/<filename>')
def uploaded_file(filename):
    logging.info(f"Serving file: {filename}")
    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)

@app.route('/clear_folders', methods=['DELETE'])
def clear_folders():
    try:
        # Function to clear all files in a given folder
        def clear_folder(folder_path):
            if os.path.exists(folder_path):
                for filename in os.listdir(folder_path):
                    file_path = os.path.join(folder_path, filename)
                    try:
                        if os.path.isfile(file_path):
                            os.remove(file_path)
                            logging.info(f"Deleted file: {file_path}")
                        else:
                            logging.warning(f"{file_path} is not a file, skipping.")
                    except Exception as e:
                        logging.error(f"Error deleting file {file_path}: {e}")
                        return jsonify({'message': f"Error deleting file {file_path}"}), 500
            else:
                logging.warning(f"Folder {folder_path} does not exist.")
                return jsonify({'message': f"Folder {folder_path} does not exist"}), 404

        # Clear both the upload and result folders
        clear_folder(app.config['UPLOAD_FOLDER'])
        clear_folder(app.config['RESULT_FOLDER'])

        logging.info("Both upload and result folders cleared successfully.")
        return jsonify({'message': 'Both upload and result folders cleared successfully'}), 200

    except Exception as e:
        logging.error(f"An unexpected error occurred while clearing folders: {e}")
        return jsonify({'message': 'Failed to clear folders'}), 500

if __name__ == '__main__':
    logging.info("Starting Flask app")
    app.run(debug=True)