from flask import Flask, request, render_template, jsonify, flash, redirect, url_for, Response, session, send_file import cv2 import pytesseract from PIL import Image from PIL.ExifTags import TAGS from ultralytics import YOLO import os import re import numpy as np from werkzeug.utils import secure_filename import tempfile import numpy as np from huggingface_hub import hf_hub_download from supervision import Detections import requests from skimage.metrics import structural_similarity as ssim import xml.etree.ElementTree as ET from pyzbar.pyzbar import decode import supervision as sv from pyzbar.pyzbar import decode from pyaadhaar.utils import isSecureQr from pyaadhaar.decode import AadhaarSecureQr import shutil import firebase_admin from firebase_admin import credentials, firestore import json import csv from datetime import datetime import io import secrets import traceback from dotenv import load_dotenv current_analysis_data = {} load_dotenv() #=========================================================================== # Clear the /tmp directory on startup print("Attempting to clear temporary cache directory...") tmp_path = '/tmp' # Check if the /tmp directory exists if os.path.exists(tmp_path): # Loop through all files and subdirectories in /tmp for item in os.listdir(tmp_path): item_path = os.path.join(tmp_path, item) try: # If it's a directory, delete it if os.path.isdir(item_path): shutil.rmtree(item_path) # If it's a file, delete it else: os.unlink(item_path) except Exception as e: print(f"Error while deleting {item_path}: {e}") print("Successfully cleared temporary cache directory.") #=============================================================================== #=============================================================================== # Loading general object detection model (YOLO v8) try: general_model = YOLO("yolov8n.pt") except: general_model = None print("Warning: General YOLO model not loaded. Install ultralytics and download yolov8n.pt") # Loading the custom YOLO Object Detection model from the Hub try: # Define where to find your model file on the Hub REPO_ID = "ConiferousYogi/Weights_for_Aadhar_Card_Fraud_Detection" FILENAME = "models/best.pt" COMMIT_SHA = "8e491271abe6e223322b307f6a5f33892a0914b6" print("Downloading custom object detection model from the Hub...") local_model_path = hf_hub_download( repo_id=REPO_ID, filename=FILENAME, revision=COMMIT_SHA ) object_detection_model = YOLO(local_model_path) print("Custom object detection model loaded successfully.") print(f"Object Detection Model classes: {object_detection_model.names}") except Exception as e: object_detection_model = None print(f"Warning: Custom Object Detection model could not be loaded. Error: {e}") #=============================================================================================================== # Loading the pre-trained Aadhaar-specific YOLO model try: repo_config = dict( repo_id="arnabdhar/YOLOv8-nano-aadhar-card", filename="model.pt" ) # Loading the pre-trained YOLO Aadhar model aadhaar_model = YOLO(hf_hub_download(**repo_config)) id2label = aadhaar_model.names print(f"Text extraction model loaded successfully from Hugging Face.") print(f"Text model classes: {id2label}") except Exception as e: aadhaar_model=None print(f"Warning: Text extraction model could not be loaded. Error: {e}") #===================================================================================== # Initializing Firebase try: # Check for the Hugging Face secret first creds_json_str = os.getenv('FIREBASE_CREDENTIALS_JSON') if creds_json_str: print("Loading Firebase credentials from environment variable (for deployment).") creds_dict = json.loads(creds_json_str) cred = credentials.Certificate(creds_dict) else: # If not found, fall back to the local file path from .env local_creds_path = os.getenv('FIREBASE_CREDS_PATH') if local_creds_path and os.path.exists(local_creds_path): print(f"Loading Firebase credentials from local file: {local_creds_path}") cred = credentials.Certificate(local_creds_path) else: raise FileNotFoundError("Firebase credentials not found in environment or local .env file.") firebase_admin.initialize_app(cred) db = firestore.client() print("Successfully connected to Firebase.") except Exception as e: print(f"Error connecting to Firebase: {e}") db = None #================================================================================================== # Initializing tesseract tesseract_path = os.getenv("TESSERACT_PATH", r"C:\Program Files\Tesseract-OCR\tesseract.exe") pytesseract.pytesseract.tesseract_cmd = tesseract_path app = Flask(__name__) app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', secrets.token_hex(32)) app.config['UPLOAD_FOLDER'] = 'uploads' app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024 # 16MB max file size # # Session configuration for production # app.config['SESSION_COOKIE_SECURE'] = True # Set to True if using HTTPS # app.config['SESSION_COOKIE_HTTPONLY'] = True # app.config['SESSION_COOKIE_SAMESITE'] = 'Lax' # app.config['PERMANENT_SESSION_LIFETIME'] = 3600 # 1 hour os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True) try: model = YOLO("yolov8n.pt") except: model = None print("Warning: YOLO model not loaded. Install ultralytics and download yolov8n.pt") # # Loading the pre-trained YOLO Object Detection model # try: # OBJECT_DETECTION_MODEL_PATH = "./models/best.pt" # object_detection_model = YOLO(OBJECT_DETECTION_MODEL_PATH) # print("Object detection model loaded successfully.") # print(f"Object Detection Model classes: {object_detection_model.names}") # except Exception as e: # object_detection_model = None # print("Warning: YOLO model not loaded. Install ultralytics and download yolov8n.pt") # print(f"Warning: Custom Object Detection model not loaded. Error: {e}") # Allowed file extensions ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'bmp'} def allowed_file(filename): return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS # Cayley Table for Verhoeff Checksum _d = ( (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (1, 2, 3, 4, 0, 6, 7, 8, 9, 5), (2, 3, 4, 0, 1, 7, 8, 9, 5, 6), (3, 4, 0, 1, 2, 8, 9, 5, 6, 7), (4, 0, 1, 2, 3, 9, 5, 6, 7, 8), (5, 9, 8, 7, 6, 0, 4, 3, 2, 1), (6, 5, 9, 8, 7, 1, 0, 4, 3, 2), (7, 6, 5, 9, 8, 2, 1, 0, 4, 3), (8, 7, 6, 5, 9, 3, 2, 1, 0, 4), (9, 8, 7, 6, 5, 4, 3, 2, 1, 0) ) # permutation table for Verhoeff Checksum _p = ( (0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (1, 5, 7, 6, 2, 8, 3, 0, 9, 4), (5, 8, 0, 3, 7, 9, 6, 1, 4, 2), (8, 9, 1, 6, 0, 4, 3, 5, 2, 7), (9, 4, 5, 3, 1, 2, 6, 8, 7, 0), (4, 2, 8, 6, 5, 7, 3, 9, 0, 1), (2, 7, 9, 3, 8, 0, 6, 4, 1, 5), (7, 0, 4, 6, 9, 1, 3, 2, 5, 8) ) _inv = (0, 4, 3, 2, 1, 5, 6, 7, 8, 9) def generate_checksum(num_str): c = 0 num_digits = [int(d) for d in num_str] for i, digit in enumerate(reversed(num_digits)): c = _d[c][_p[(i % 8)][digit]] return _inv[c] def validate_checksum(num_str_with_checksum): c = 0 num_digits = [int(d) for d in num_str_with_checksum] for i, digit in enumerate(reversed(num_digits)): c = _d[c][_p[(i % 8)][digit]] return c == 0 def get_exif_data(image_path): """Extract EXIF metadata from image""" try: image = Image.open(image_path) exif_data = {} if hasattr(image, '_getexif'): info = image._getexif() if info: for tag, value in info.items(): decoded = TAGS.get(tag, tag) exif_data[decoded] = value return exif_data except Exception as e: return {"error": str(e)} def detect_objects_yolo(image_path): #Detecting objects in image using YOLO try: if general_model is None: return {"error": "YOLO model not available"} img = cv2.imread(image_path) results = general_model(img) labels = [general_model.names[int(cls)] for cls in results[0].boxes.cls] human_detected = "person" in labels return { "detected_objects": labels, "human_detected": human_detected, "fraud_indicator": not human_detected if labels else False } except Exception as e: return {"error": str(e)} #========================================================================================================= # Verifying if the image is of frudulent Aadhar card or not using object detection def run_object_verification(image_path, object_model_raw_results): if object_detection_model is None: return {"error": "Object detection model not available."} try: detected_objects = [] is_tampered = False confidences = [] for box in object_model_raw_results.boxes: class_id = int(box.cls[0]) class_name = object_detection_model.names[class_id] confidence = float(box.conf[0]) detected_objects.append(class_name) if class_name == 'Tampered': is_tampered = True confidences.append(confidence) return { "detected_objects": list(set(detected_objects)), "is_tampered": is_tampered, "confidences":confidences } except Exception as e: return {"error": f"Object verification failed: {str(e)}"} #====================================================================================== def decode_aadhaar_qr(image_path): try: img = cv2.imread(image_path) gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) code = decode(gray) if not code: return {"error": "QR Code not found or could not be read"} qrData = code[0].data isSecureQR = (isSecureQr(qrData)) if isSecureQR: secure_qr = AadhaarSecureQr(int(qrData)) decoded_secure_qr_data = secure_qr.decodeddata() if decoded_secure_qr_data: return decoded_secure_qr_data else: return {"error": "QR Code could not be found or could not be read."} else: # handling the case when QR code is not secured => Old QR # isSecureQr is false return {"error": "The detected QR code is not a secure Aadhaar QR code."} except Exception as e: return {"error": str(e)} #==================================================================================================== def extract_aadhaar_data(image_path, text_model_raw_results): try: detections = Detections.from_ultralytics(text_model_raw_results) image = np.array(Image.open(image_path)) aadhaar_data = {} confidences = [] key_mapping = { 'NAME': 'Name', 'AADHAR_NUMBER': 'Aadhaar Number', 'GENDER': 'Gender', 'DATE_OF_BIRTH': 'Date of Birth', 'ADDRESS': 'Address' } # The loop will now run for ALL detected fields for bbox, conf, cls_name in zip(detections.xyxy, detections.confidence, detections.data['class_name']): confidences.append(float(conf)) x1, y1, x2, y2 = map(int, bbox) roi = image[y1:y2, x1:x2] if roi.size == 0: continue cls_name_str = str(cls_name) config = '--psm 7 -c tessedit_char_whitelist=0123456789 ' if cls_name_str == 'AADHAR_NUMBER' else '--psm 6' text = pytesseract.image_to_string(roi, lang="eng+hin", config=config).strip() normalized_key = key_mapping.get(cls_name_str, cls_name_str) aadhaar_data[normalized_key] = text print(f"Final Aadhaar Data: {aadhaar_data}") return {"data": aadhaar_data, "confidences": confidences} except Exception as e: return {"error": f"OCR failed: {str(e)}"} #================================================================================================ def validate_aadhaar_number(aadhaar_data): # Validating Aadhaar number using Verhoeff checksum try: if not aadhaar_data.get("Aadhaar Number"): result = {"valid": False, "reason": "No Aadhaar number found"} print(f"Validation result: {result}") return result clean_number = aadhaar_data["Aadhaar Number"].replace(" ", "") if len(clean_number) != 12: return {"valid": False, "reason": f"Invalid length: {len(clean_number)} (should be 12)"} if not clean_number.isdigit(): return {"valid": False, "reason": "Contains non-digit characters"} is_valid = validate_checksum(clean_number) return { "valid": is_valid, "reason": "Valid Aadhaar number" if is_valid else "Invalid checksum", "clean_number": clean_number } except Exception as e: result = {"valid":False, "reason":f"Error: {str(e)}"} print(f"Validation error: {result}") return result #=================================================================================================== def create_annotated_image(image_path, text_model_results, object_model_results): try: image = cv2.imread(image_path) # Annotations from the text extraction model (Blue boxes) text_detections = Detections.from_ultralytics(text_model_results) text_box_annotator = sv.BoxAnnotator(color=sv.Color.BLUE, thickness=2) text_label_annotator = sv.LabelAnnotator(color=sv.Color.BLUE, text_color=sv.Color.WHITE, text_scale=0.5) image = text_box_annotator.annotate(scene=image.copy(), detections=text_detections) image = text_label_annotator.annotate(scene=image, detections=text_detections) # Annotations from your custom object verification model (Red boxes) object_detections = Detections.from_ultralytics(object_model_results) object_box_annotator = sv.BoxAnnotator(color=sv.Color.RED, thickness=2) object_label_annotator = sv.LabelAnnotator(color=sv.Color.RED, text_color=sv.Color.WHITE, text_scale=0.5) image = object_box_annotator.annotate(scene=image, detections=object_detections) image = object_label_annotator.annotate(scene=image, detections=object_detections) # Saving the annotated image to the static folder annotated_filename = "annotated_" + os.path.basename(image_path) save_path = os.path.join('static', annotated_filename) cv2.imwrite(save_path, image) return annotated_filename except Exception as e: print(f"Error creating annotated image: {e}") return None #================================================================================================================ def analyze_aadhar_pair(front_path, back_path): # running the text extaction model on both front and back images text_model_raw_results_front = aadhaar_model.predict(front_path, verbose=False)[0] text_model_raw_results_back = aadhaar_model.predict(back_path, verbose=False)[0] front_ocr_results = extract_aadhaar_data(front_path, text_model_raw_results_front) back_ocr_results = extract_aadhaar_data(back_path, text_model_raw_results_back) front_ocr_data = front_ocr_results.get("data", {}) back_ocr_data = back_ocr_results.get("data", {}) # running tamper detection on front object_model_raw_results_front = object_detection_model(front_path, verbose=False)[0] object_results_front = run_object_verification(front_path, object_model_raw_results_front) # running tamper detection on back object_model_raw_results_back = object_detection_model(back_path, verbose=False)[0] object_results_back = run_object_verification(back_path, object_model_raw_results_back) # confidence scores all_confidences = [] if object_model_raw_results_front.boxes: all_confidences.extend(object_model_raw_results_front.boxes.conf.tolist()) if object_model_raw_results_back.boxes: all_confidences.extend(object_model_raw_results_back.boxes.conf.tolist()) if text_model_raw_results_front.boxes: all_confidences.extend(text_model_raw_results_front.boxes.conf.tolist()) if text_model_raw_results_back.boxes: all_confidences.extend(text_model_raw_results_back.boxes.conf.tolist()) # calculating average confidence average_confidence = np.mean(all_confidences) if all_confidences else 0.0 # running exif on both front and back exif_results_front = get_exif_data(front_path) exif_results_back = get_exif_data(back_path) # qr code analysis qr_results = decode_aadhaar_qr(back_path) general_model_results_front = general_model(front_path, verbose=False)[0] general_labels = [general_model.names[int(cls)] for cls in general_model_results_front.boxes.cls] human_detected = "person" in general_labels results = { "front": { "object_verification": object_results_front, "exif_analysis": exif_results_front, "ocr_analysis": front_ocr_data, "face_detection": {"human_detected": human_detected, "detected_objects": general_labels}, }, "back": { "object_verification": object_results_back, "exif_analysis": exif_results_back, "ocr_analysis": back_ocr_data, "qr_analysis": qr_results, "general_detection": {"human_detected":human_detected, "detected_objects": general_labels} }, "average_confidence": average_confidence, "fraud_indicators": [], "raw_results": { "text_front": text_model_raw_results_front, "text_back": text_model_raw_results_back, "object_front": object_model_raw_results_front, "object_back": object_model_raw_results_back } } combined_ocr_results = front_ocr_data.copy() if "Address" in back_ocr_data: combined_ocr_results["Address"] = back_ocr_data["Address"] results['combined_ocr'] = combined_ocr_results print("Combined OCR Results: ", combined_ocr_results) fraud_score = 0 if "error" not in object_results_front and object_results_front.get("is_tampered"): results["fraud_indicators"].append("Tampered region detected on the front of the card.") fraud_score += 3 if not human_detected: results["fraud_indicators"].append("No human detected in the photo area (possible fake document).") fraud_score += 3 # ocr and qr results comparison if isinstance(combined_ocr_results, dict) and isinstance(qr_results, dict) and "error" not in qr_results: # name comparison ocr_name = combined_ocr_results.get("Name","").strip().lower() qr_name = qr_results.get("name","").strip().lower() if ocr_name and qr_name and ocr_name not in qr_name and qr_name not in ocr_name: results['fraud_indicators'].append("Name mismatch between OCR extracted name and qr code extracted name.") fraud_score += 3 # gender comparison ocr_gender = combined_ocr_results.get("Gender","").strip().lower() # QR Gender is either M or F format qr_gender = qr_results.get("gender","").strip().lower() # we need to handle "M" vs "Male" and "F" vs "Female" if ocr_gender and qr_gender: ocr_gender_normalized = ocr_gender[0] if ocr_gender else "" qr_gender_normalized = qr_gender[0] if qr_gender else "" # comparison if ocr_gender_normalized and qr_gender_normalized and ocr_gender_normalized != qr_gender_normalized: results['fraud_indicators'].append("Mismatch between OCR extracted gender and QR code extracted gender.") fraud_score += 2 # dob comparison ocr_dob_raw = combined_ocr_results.get("Date of Birth", "") ocr_dob = ocr_dob_raw.replace("-", "/").replace("/", "").strip() qr_dob = qr_results.get("dob", "").replace("-","/").replace("/", "").strip() # comparison if ocr_dob and qr_dob and ocr_dob != qr_dob: results['fraud_indicators'].append("Mismatch between OCR extracted DOB and QR extracted DOB.") fraud_score += 3 # aadhaar num comparison ocr_num_full = combined_ocr_results.get("Aadhaar Number", "").replace(" ", "").strip() # extracting the last 4 digits of ocr_num_full if ocr_num_full and len(ocr_num_full) >= 4: ocr_last_4 = ocr_num_full[-4:] # extracting the last 4 digits of aadhar from qr qr_ref = qr_results.get("aadhar_last_4_digit","") print(f"OCR Aadhar Num: {ocr_num_full}, Last 4 digits from OCR: {ocr_last_4}") print(f"QR Aadhar Num Last 4 digits: {qr_ref}") #comparison between nums if ocr_last_4 and qr_ref and ocr_last_4 not in qr_ref and qr_ref not in ocr_last_4: results['fraud_indicators'].append("Mismatch between OCR extracted Aadhar Number and QR code extracted Aadhar Number.") fraud_score += 3 # address comparison ocr_address = combined_ocr_results.get("Address", "").strip().lower() qr_address = qr_results.get("address", "").strip().lower() # More lenient address comparison (check if main parts match) if ocr_address and qr_address: # Extract key address components (pincode, area names) ocr_parts = set(ocr_address.split()) qr_parts = set(qr_address.split()) common_parts = ocr_parts & qr_parts # If less than 30% words match, flag as mismatch if len(common_parts) < min(len(ocr_parts), len(qr_parts)) * 0.3: results["fraud_indicators"].append("Mismatch between OCR extracted address and QR code extracted address.") fraud_score += 1 if "error" not in results["front"]["ocr_analysis"]: results["aadhaar_validation"] = validate_aadhaar_number(results["front"]["ocr_analysis"]) # Check object detection for fraud indicators if "error" not in object_results_front: if object_results_front.get("fraud_indicator"): results["fraud_indicators"].append("No human detected in image (possible fake document)") fraud_score += 1 if(("error" not in exif_results_front or len(results["exif_analysis_front"]) == 0) or ("error" not in exif_results_back or len(results["exif_analysis_back"]) == 0)): results["fraud_indicators"].append("No EXIF metadata found.") fraud_score += 0 if "aadhaar_validation" in results and not results["aadhaar_validation"]["valid"]: results["fraud_indicators"].append( f"Invalid Aadhaar number: {results['aadhaar_validation']['reason']}" ) fraud_score += 2 results["fraud_score"] = fraud_score results["assessment"] = ( "HIGH FRAUD RISK" if fraud_score >= 3 else "MODERATE FRAUD RISK" if fraud_score >= 1 else "LOW FRAUD RISK" ) return results #======================================================================================================= def transform_results_for_template(results): # --- Overall Assessment --- risk_level = results.get('assessment', 'UNKNOWN').replace(" FRAUD RISK", "") risk_score = int(results.get('fraud_score', 0) * 20) # Convert a score out of 5 to a percentage color_map = { 'HIGH': 'border-red-500 text-red-900 bg-red-50', 'MODERATE': 'border-amber-500 text-amber-900 bg-amber-50', 'LOW': 'border-green-500 text-green-900 bg-green-50', 'UNKNOWN': 'border-slate-500 text-slate-900 bg-slate-50' } # --- Fraud Indicators --- indicators = [] for desc in results.get('fraud_indicators', []): severity = 'high' if "mismatch" in desc.lower() or "tampered" in desc.lower() else 'medium' badge_map = {'high': 'border-red-300 bg-red-100 text-red-800', 'medium': 'border-amber-300 bg-amber-100 text-amber-800'} indicators.append({ "type": desc.split(':')[0], "severity": severity, "description": desc, "badge_class": badge_map.get(severity, '') }) # --- Front Card OCR --- ocr_front_data = results.get('front', {}).get('ocr_analysis', {}) ocr_front_list = [ {"label": "Name", "value": ocr_front_data.get("Name", "N/A"), "icon": "M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"}, {"label": "Date of Birth", "value": ocr_front_data.get("Date of Birth", "N/A"), "icon": "M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"}, {"label": "Gender", "value": ocr_front_data.get("Gender", "N/A"), "icon": "M13 10V3L4 14h7v7l9-11h-7z"}, {"label": "Aadhaar Number", "value": ocr_front_data.get("Aadhaar Number", "N/A"), "icon": "M12 11c0 3.517-1.009 6.799-2.753 9.571m-3.44-2.04l.054-.09A13.916 13.916 0 008 11a4 4 0 118 0c0 1.017-.07 2.019-.203 3m-2.118 6.844A21.88 21.88 0 0015.171 17m3.839 1.132c.645-1.026.977-2.19.977-3.418a8 8 0 10-15.828-1.55A8 8 0 004 12c0-4.418 3.582-8 8-8s8 3.582 8 8z"}, ] # --- Back Card Data --- qr_analysis = results.get('back', {}).get('qr_analysis', {}) qr_data_list = [] print(qr_analysis) if isinstance(qr_analysis, dict) and 'error' not in qr_analysis: for key, val in qr_analysis.items(): qr_data_list.append({"label": key.capitalize(), "value": val}) # --- Metadata --- exif_analysis = results.get('front', {}).get('exif_analysis', {}) metadata_fields = [] if 'error' not in exif_analysis: for key, val in exif_analysis.items(): metadata_fields.append({"label": str(key), "value": str(val), "warning": "Software" in str(key)}) transformed_data = { 'risk_level': risk_level, 'risk_score': risk_score, 'confidence_score': int(results.get('average_confidence', 0)*100), 'risk_color_class': color_map.get(risk_level, 'border-slate-500'), 'fraud_indicators': indicators, 'ocr_status': "Success" if 'error' not in ocr_front_data else "Failed", 'ocr_message': f"{len(ocr_front_data)} fields extracted" if 'error' not in ocr_front_data else "Extraction failed", 'qr_status': "Decoded" if 'error' not in qr_analysis else "Failed", 'qr_message': "Data successfully parsed" if 'error' not in qr_analysis else qr_analysis.get('error', 'Unknown error'), 'exif_status': "Found" if exif_analysis and 'error' not in exif_analysis else "Not Found", 'exif_message': f"{len(exif_analysis)} fields found" if exif_analysis and 'error' not in exif_analysis else "No EXIF data", 'ocr_front': ocr_front_list, 'ocr_address': results.get('combined_ocr', {}).get('Address', 'N/A'), 'qr_decode_status': "Success" if 'error' not in qr_analysis else "Failed", 'qr_data_items': qr_data_list, 'qr_mismatch': any("Mismatch" in indicator for indicator in results.get('fraud_indicators', [])), 'metadata_warning': any("Software" in str(field.get('label', '')) for field in metadata_fields), 'metadata_warning_title': "Editing Software Detected", 'metadata_warning_text': "The image metadata contains tags indicating it was processed by editing software, which can be a sign of digital manipulation.", 'metadata_fields_left': metadata_fields[::2], # Split fields into two columns 'metadata_fields_right': metadata_fields[1::2] } # saving the results to the firebase db if db: try: results_for_firestore = transformed_data.copy() # removing the key that contains raw YOLO objects if 'raw_results' in results_for_firestore: del results_for_firestore['raw_results'] results_for_firestore['timestamp'] = firestore.SERVER_TIMESTAMP db.collection('analyses').add(results_for_firestore) print("Analysis results saved to Firestore.") except Exception as e: print(f"Error saving to Firestore: {e}") session['transformed_data'] = transformed_data return transformed_data #===================================================================================================================================== # Implementing Export CSV funtionality # This function handles complex data types for the CSV @app.route('/export_csv', methods=['POST']) def export_csv(): """ Flask route to export analysis results as CSV file. Retrieves the transformed_data from session and creates a CSV download. """ try: # Use ONLY global variable (no session) global current_analysis_data transformed_data = current_analysis_data if not transformed_data: print("❌ No analysis data available in global variable") return jsonify({'error': 'No analysis data available. Please run analysis first.'}), 400 print(f"✓ Found data: Risk Level = {transformed_data.get('risk_level', 'N/A')}") # Create CSV in memory output = io.StringIO() writer = csv.writer(output) # Write header writer.writerow(['Category', 'Field', 'Value']) # --- Overall Assessment Section --- writer.writerow(['OVERALL ASSESSMENT', '', '']) writer.writerow(['Assessment', 'Risk Level', transformed_data.get('risk_level', 'N/A')]) writer.writerow(['Assessment', 'Risk Score (%)', transformed_data.get('risk_score', 'N/A')]) writer.writerow(['Assessment', 'Confidence Score (%)', transformed_data.get('confidence_score', 'N/A')]) writer.writerow([]) # --- Fraud Indicators Section --- writer.writerow(['FRAUD INDICATORS', '', '']) fraud_indicators = transformed_data.get('fraud_indicators', []) if fraud_indicators: for idx, indicator in enumerate(fraud_indicators, 1): writer.writerow(['Fraud Indicator', f'Type #{idx}', indicator.get('type', 'N/A')]) writer.writerow(['Fraud Indicator', f'Severity #{idx}', indicator.get('severity', 'N/A')]) writer.writerow(['Fraud Indicator', f'Description #{idx}', indicator.get('description', 'N/A')]) else: writer.writerow(['Fraud Indicator', 'Status', 'No fraud indicators detected']) writer.writerow([]) # --- OCR Front Card Data Section --- writer.writerow(['OCR - FRONT CARD', '', '']) writer.writerow(['OCR Status', 'Status', transformed_data.get('ocr_status', 'N/A')]) writer.writerow(['OCR Status', 'Message', transformed_data.get('ocr_message', 'N/A')]) ocr_front = transformed_data.get('ocr_front', []) for item in ocr_front: writer.writerow(['OCR Data', item.get('label', 'N/A'), item.get('value', 'N/A')]) writer.writerow(['OCR Data', 'Address', transformed_data.get('ocr_address', 'N/A')]) writer.writerow([]) # --- QR Code Data Section --- writer.writerow(['QR CODE - BACK CARD', '', '']) writer.writerow(['QR Status', 'Decode Status', transformed_data.get('qr_decode_status', 'N/A')]) writer.writerow(['QR Status', 'Status', transformed_data.get('qr_status', 'N/A')]) writer.writerow(['QR Status', 'Message', transformed_data.get('qr_message', 'N/A')]) writer.writerow(['QR Status', 'Mismatch Detected', 'Yes' if transformed_data.get('qr_mismatch') else 'No']) qr_data_items = transformed_data.get('qr_data_items', []) if qr_data_items: for item in qr_data_items: writer.writerow(['QR Data', item.get('label', 'N/A'), item.get('value', 'N/A')]) writer.writerow([]) # --- EXIF Metadata Section --- writer.writerow(['EXIF METADATA', '', '']) writer.writerow(['EXIF Status', 'Status', transformed_data.get('exif_status', 'N/A')]) writer.writerow(['EXIF Status', 'Message', transformed_data.get('exif_message', 'N/A')]) writer.writerow(['EXIF Status', 'Warning Detected', 'Yes' if transformed_data.get('metadata_warning') else 'No']) if transformed_data.get('metadata_warning'): writer.writerow(['EXIF Warning', 'Title', transformed_data.get('metadata_warning_title', 'N/A')]) writer.writerow(['EXIF Warning', 'Description', transformed_data.get('metadata_warning_text', 'N/A')]) metadata_left = transformed_data.get('metadata_fields_left', []) metadata_right = transformed_data.get('metadata_fields_right', []) all_metadata = metadata_left + metadata_right for field in all_metadata: warning_flag = ' (WARNING)' if field.get('warning') else '' writer.writerow(['EXIF Data', field.get('label', 'N/A') + warning_flag, field.get('value', 'N/A')]) # Prepare the CSV for download output.seek(0) # Generate filename with timestamp timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"aadhaar_analysis_{timestamp}.csv" # Create BytesIO object for sending byte_output = io.BytesIO() byte_output.write(output.getvalue().encode('utf-8')) byte_output.seek(0) return send_file( byte_output, mimetype='text/csv', as_attachment=True, download_name=filename ) except Exception as e: print(f"Error exporting CSV: {e}") traceback.print_exc() return jsonify({'error': f'Export failed: {str(e)}'}), 500 #====================================================================================================================== @app.route('/') def home(): return render_template('upload.html') @app.route('/upload', methods=['POST']) def upload_file(): if 'front_image' not in request.files or 'back_image' not in request.files: flash('Please upload both front and back of the Aadhar card') return redirect(request.url) front_file = request.files['front_image'] back_file = request.files['back_image'] if front_file.filename == '' or back_file.filename == '': flash('Either one or both images are missing') return redirect(request.url) if (front_file and allowed_file(front_file.filename)) and (back_file and allowed_file(back_file.filename)): filename = secure_filename(front_file.filename) with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(front_file.filename)[1]) as tmp_front: front_file.save(tmp_front.name) front_path = tmp_front.name with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(back_file.filename)[1]) as tmp_back: back_file.save(tmp_back.name) back_path = tmp_back.name try: # Running the full, complex analysis analysis_results = analyze_aadhar_pair(front_path, back_path) # Transforming the results as per the template template_data = transform_results_for_template(analysis_results) # Creating annotated images raw = analysis_results['raw_results'] annotated_image_filename_front = create_annotated_image(front_path, raw['text_front'], raw['object_front']) annotated_image_filename_back = create_annotated_image(back_path, raw['text_back'], raw['object_back']) # adding annotated image paths to template data template_data['front_annotated_image'] = url_for('static', filename=annotated_image_filename_front) if annotated_image_filename_front else None template_data['back_annotated_image'] = url_for('static', filename=annotated_image_filename_back) if annotated_image_filename_back else None # render the results return render_template('results.html', **template_data) finally: try: os.unlink(front_path) os.unlink(back_path) except OSError: pass else: flash('Invalid file type. Please upload an image file.') return redirect(request.url) @app.route('/analyzing') def analyzing(): return render_template('analyzing.html') @app.route('/analyze', methods=['POST']) def api_analyze(): """API endpoint for programmatic access""" if 'file' not in request.files: return jsonify({"error": "No file provided"}), 400 file = request.files['file'] if file.filename == '' or not allowed_file(file.filename): return jsonify({"error": "Invalid file"}), 400 filename = secure_filename(file.filename) tmp_file = tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(filename)[1]) tmp_file_path = tmp_file.name tmp_file.close() try: file.save(tmp_file_path) analysis_results = analyze_aadhar_pair(tmp_file_path) return jsonify(analysis_results) finally: try: os.unlink(tmp_file_path) except OSError: pass if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=7860)