idvpackage 3.0.9__py3-none-any.whl → 3.0.11__py3-none-any.whl

idvpackage/ocr.py

@@ -191,6 +191,7 @@ class IdentityVerification:
 
         return enhanced_contrast
 
+
     def check_document_quality(self, data):
         video_quality = {"error": ""}
         temp_video_file = tempfile.NamedTemporaryFile(delete=False)
@@ -205,62 +206,73 @@ class IdentityVerification:
             video_capture = cv2.VideoCapture(temp_video_file.name)
 
             if video_capture.isOpened():
-                frame_count = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
-
-                for _ in range(frame_count):
-                    ret, frame = video_capture.read()
-                    #                         if ret:
-                    # frame_count_vid+=1
-                    # if frame_count_vid % 10 == 0:
-                    _, buffer = cv2.imencode(".jpg", frame)
-                    image_data = buffer.tobytes()
-
-                    image = vision_v1.Image(content=image_data)
-
-                    response = self.client.face_detection(image=image)
-                    if len(response.face_annotations) >= 1:
-                        break
-
-            video_capture.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                video_capture.set(cv2.CAP_PROP_POS_FRAMES, 0)
 
             selfie_result = self.extract_selfie_from_video(video_capture)
             if isinstance(selfie_result, dict):
                 video_quality["error"] = selfie_result["error"]
+
             else:
                 (
                     selfie_blurry_result,
                     selfie_bright_result,
                 ) = self.get_blurred_and_glared_for_doc(selfie_result)
                 if (
-                    selfie_blurry_result == "consider"
-                    or selfie_bright_result == "consider"
+                        selfie_blurry_result == "consider"
+                        or selfie_bright_result == "consider"
                 ):
                     video_quality["error"] = "face_not_clear_in_video"
                 else:
                     video_quality["selfie"] = selfie_result
                     video_quality["shape"] = selfie_result.shape
 
-            video_capture.release()  # Release the video capture
-
-        # except Exception as e:
-        #     video_quality["error"] = "bad_video"
-
+            return video_quality
+    
+        except Exception as e:
+            logging.exception("check_document_quality failed")
+            video_quality["error"] = "face_not_clear_in_video"
+            return video_quality
+        
         finally:
-            # Ensure the temporary file is deleted
-            if os.path.exists(temp_video_file_path):
-                os.remove(temp_video_file_path)
-                # print(f"Temporary file {temp_video_file_path} has been deleted.")
+              
+            if video_capture is not None:
+                try:
+                    video_capture.release()
+                except Exception:
+                    pass
+                del video_capture
 
-        return video_quality
+            # Remove temp file
+            if temp_video_file_path and os.path.exists(temp_video_file_path):
+                try:
+                    os.remove(temp_video_file_path)
+                except Exception:
+                    logging.warning("Failed to delete temp file %s", temp_video_file_path)
+
+            # Force cleanup of OpenCV / numpy memory
+            import gc
+            gc.collect()
+        
 
     def extract_selfie_from_video(self, video_capture):
         """Extract the best quality selfie from video with speed optimizations for frontal faces."""
-        video_dict = {"error": ""}
+        video_dict = {'error': ''}
+        
 
         try:
+            # Get rotation metadata from video
+            try:
+                rotation = int(video_capture.get(cv2.CAP_PROP_ORIENTATION_META))
+            except Exception as e:
+                logging.info(f"Defaulting to Rotation=0, Exception Thrown while getting rotation metadata from video.{e}")
+                rotation=0
+            logging.info(f"Video rotation metadata: {rotation}°")
+
+
+            
             total_frames = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
             if total_frames <= 0:
-                video_dict["error"] = "invalid_video_frame_count"
+                video_dict['error'] = 'invalid_video_frame_count'
                 return video_dict
 
             # Check only 6 frames - 2 at start, 2 in the middle, 2 at the end
@@ -270,17 +282,17 @@ class IdentityVerification:
                 int(total_frames * 0.45),
                 int(total_frames * 0.55),
                 int(total_frames * 0.85),
-                int(total_frames * 0.95),
+                int(total_frames * 0.95)
             ]
 
             best_face = None
             best_score = -1
-            best_frame = None
             best_frame_position = None
-            frame_results = []
+            best_frame = None
 
-            print(f"Analyzing video with {total_frames} frames")
-            print(f"Checking {len(frame_positions)} strategic frames")
+            logging.info(f"Analyzing video with {total_frames} frames")
+            logging.info(f"Checking {len(frame_positions)} strategic frames")
+            logging.info(f"Frame positions to analyze: {frame_positions}")
 
             for target_frame in frame_positions:
                 if target_frame >= total_frames:
@@ -288,11 +300,20 @@ class IdentityVerification:
                 if target_frame < 0:
                     target_frame = 0
 
+                logging.info(f"Processing frame {target_frame}")
                 video_capture.set(cv2.CAP_PROP_POS_FRAMES, target_frame)
                 ret, frame = video_capture.read()
                 if not ret or frame is None or frame.size == 0:
                     continue
 
+                # Apply rotation correction based on video metadata
+                if rotation == 90:
+                    frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+                elif rotation == 180:
+                    frame = cv2.rotate(frame, cv2.ROTATE_180)
+                elif rotation == 270:
+                    frame = cv2.rotate(frame, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
                 try:
                     scale = 0.7
                     small_frame = cv2.resize(frame, (0, 0), fx=scale, fy=scale)
@@ -300,8 +321,17 @@ class IdentityVerification:
                     encode_params = [cv2.IMWRITE_JPEG_QUALITY, 90]
                     _, buffer = cv2.imencode(".jpg", small_frame, encode_params)
 
-                    image = vision_v1.Image(content=buffer.tobytes())
+                    # image = vision_v1.Image(content=buffer.tobytes())
+                    # response = self.client.face_detection(image=image, max_results=2)
+                    # faces = response.face_annotations
+
+                    image_bytes = buffer.tobytes()
+                    del buffer
+
+                    image = vision_v1.Image(content=image_bytes)
                     response = self.client.face_detection(image=image, max_results=2)
+                    del image_bytes
+
                     faces = response.face_annotations
 
                     if not faces:
@@ -311,10 +341,8 @@ class IdentityVerification:
                     frame_best_score = -1
 
                     for face in faces:
-                        vertices = [
-                            (int(vertex.x / scale), int(vertex.y / scale))
-                            for vertex in face.bounding_poly.vertices
-                        ]
+                        vertices = [(int(vertex.x / scale), int(vertex.y / scale))
+                                  for vertex in face.bounding_poly.vertices]
 
                         left = min(v[0] for v in vertices)
                         upper = min(v[1] for v in vertices)
@@ -322,18 +350,13 @@ class IdentityVerification:
                         lower = max(v[1] for v in vertices)
 
                         # Validate face coordinates
-                        if not (
-                            0 <= left < right <= frame.shape[1]
-                            and 0 <= upper < lower <= frame.shape[0]
-                        ):
+                        if not (0 <= left < right <= frame.shape[1] and 0 <= upper < lower <= frame.shape[0]):
                             continue
 
                         # Calculate face metrics
                         face_width = right - left
                         face_height = lower - upper
-                        face_area = (face_width * face_height) / (
-                            frame.shape[0] * frame.shape[1]
-                        )
+                        face_area = (face_width * face_height) / (frame.shape[0] * frame.shape[1])
 
                         # Reject small faces
                         if face_area < 0.05:
@@ -345,23 +368,19 @@ class IdentityVerification:
                         frame_center_x = frame.shape[1] / 2
                         frame_center_y = frame.shape[0] / 2
 
-                        center_dist_x = abs(face_center_x - frame_center_x) / (
-                            frame.shape[1] / 2
-                        )
-                        center_dist_y = abs(face_center_y - frame_center_y) / (
-                            frame.shape[0] / 2
-                        )
+                        center_dist_x = abs(face_center_x - frame_center_x) / (frame.shape[1] / 2)
+                        center_dist_y = abs(face_center_y - frame_center_y) / (frame.shape[0] / 2)
                         center_score = 1.0 - (center_dist_x + center_dist_y) / 2
 
                         # For frontal faces, left and right eye/ear should be roughly symmetric
                         if len(face.landmarks) > 0:
                             # Head rotation detection
                             roll, pan, tilt = 0, 0, 0
-                            if hasattr(face, "roll_angle"):
+                            if hasattr(face, 'roll_angle'):
                                 roll = abs(face.roll_angle)
-                            if hasattr(face, "pan_angle"):
+                            if hasattr(face, 'pan_angle'):
                                 pan = abs(face.pan_angle)
-                            if hasattr(face, "tilt_angle"):
+                            if hasattr(face, 'tilt_angle'):
                                 tilt = abs(face.tilt_angle)
 
                             head_angle_penalty = (roll + pan + tilt) / 180.0
@@ -369,9 +388,7 @@ class IdentityVerification:
                             # Symmetry detection from face bounding box
                             left_half = face_center_x - left
                             right_half = right - face_center_x
-                            width_ratio = min(left_half, right_half) / max(
-                                left_half, right_half
-                            )
+                            width_ratio = min(left_half, right_half) / max(left_half, right_half)
 
                             # Frontal-face score: higher for more frontal faces
                             # Perfect frontal face would be 1.0
@@ -380,17 +397,15 @@ class IdentityVerification:
                             # No landmarks, estimate from bounding box
                             left_half = face_center_x - left
                             right_half = right - face_center_x
-                            frontal_score = min(left_half, right_half) / max(
-                                left_half, right_half
-                            )
+                            frontal_score = min(left_half, right_half) / max(left_half, right_half)
 
                         # Combined score weights different factors
                         # More weight for frontal-ness and face confidence
                         score = (
-                            face.detection_confidence * 0.3
-                            + face_area * 0.2
-                            + center_score * 0.2
-                            + frontal_score * 0.3
+                            face.detection_confidence * 0.3 +
+                            face_area * 0.2 +
+                            center_score * 0.2 +
+                            frontal_score * 0.3
                         )
 
                         # Heavy bonus for very frontal faces (nearly symmetric)
@@ -410,70 +425,70 @@ class IdentityVerification:
                             left_with_margin = max(0, left - margin_x)
                             upper_with_margin = max(0, upper - margin_y_top)
                             right_with_margin = min(frame.shape[1], right + margin_x)
-                            lower_with_margin = min(
-                                frame.shape[0], lower + margin_y_bottom
-                            )
+                            lower_with_margin = min(frame.shape[0], lower + margin_y_bottom)
 
                             # Store the best face info
                             frame_best_score = score
                             frame_best_face = {
-                                "face": face,
-                                "left": left_with_margin,
-                                "upper": upper_with_margin,
-                                "right": right_with_margin,
-                                "lower": lower_with_margin,
-                                "frontal_score": frontal_score,
-                                "center_score": center_score,
-                                "confidence": face.detection_confidence,
-                                "frame": target_frame,
+                                'face': face,
+                                'left': left_with_margin,
+                                'upper': upper_with_margin,
+                                'right': right_with_margin,
+                                'lower': lower_with_margin,
+                                'frontal_score': frontal_score,
+                                'center_score': center_score,
+                                'confidence': face.detection_confidence,
+                                'frame': target_frame
                             }
 
                     if frame_best_face is not None:
-                        frame_results.append(
-                            {
-                                "frame": target_frame,
-                                "face": frame_best_face,
-                                "score": frame_best_score,
-                                "frame_data": frame.copy(),
-                            }
-                        )
+
+                        
+                        # frame_results.append({
+                        #     'frame': target_frame,
+                        #     'face': frame_best_face,
+                        #     'score': frame_best_score,
+                        #     'frame_data': frame.copy()
+                        # })
+                        logging.info(f"Frame {target_frame}: Best face score {frame_best_score:.2f} "
+                                     f"(Frontal: {frame_best_face['frontal_score']:.2f}, "
+                                     f"Center: {frame_best_face['center_score']:.2f}, "
+                                     f"Confidence: {frame_best_face['confidence']:.2f})")
 
                         if frame_best_score > best_score:
+                            logging.info(f"New best face found at frame {target_frame} with score {frame_best_score:.2f}")
                             best_score = frame_best_score
                             best_face = frame_best_face
                             best_frame = frame.copy()
                             best_frame_position = target_frame
 
                 except Exception as e:
+                    logging.info(f"Error processing frame {target_frame}: {e}")
                     continue
 
-            # Process results
-            if len(frame_results) > 0:
-                # Sort faces by score
-                frame_results.sort(key=lambda x: x["score"], reverse=True)
+            # # Process results
+            # if len(frame_results) > 0:
+            #     # Sort faces by score
+            #     frame_results.sort(key=lambda x: x['score'], reverse=True)
 
-                for i, result in enumerate(frame_results[: min(3, len(frame_results))]):
-                    face_info = result["face"]
-                    print(
-                        f"Rank {i + 1}: Frame {face_info['frame']}, "
-                        f"Score: {result['score']:.2f}, "
-                        f"Frontal: {face_info['frontal_score']:.2f}, "
-                        f"Center: {face_info['center_score']:.2f}"
-                    )
+                # for i, result in enumerate(frame_results[:min(3, len(frame_results))]):
+                #     face_info = result['face']
+                #     print(f"Rank {i+1}: Frame {face_info['frame']}, "
+                #           f"Score: {result['score']:.2f}, "
+                #           f"Frontal: {face_info['frontal_score']:.2f}, "
+                #           f"Center: {face_info['center_score']:.2f}")
 
                 # Use the best frame
-                best_result = frame_results[0]
-                best_face = best_result["face"]
-                best_frame = best_result["frame_data"]
+                # best_frame = frame_best_face['frame']
 
-                print(f"Selected frame {best_face['frame']} as best selfie")
+                # print(f"Selected frame {best_face['frame']} as best selfie")
 
             if best_face and best_frame is not None:
                 try:
-                    left = best_face["left"]
-                    upper = best_face["upper"]
-                    right = best_face["right"]
-                    lower = best_face["lower"]
+                    left = best_face['left']
+                    upper = best_face['upper']
+                    right = best_face['right']
+                    lower = best_face['lower']
 
                     # Convert to RGB and crop
                     rgb_frame = cv2.cvtColor(best_frame, cv2.COLOR_BGR2RGB)
@@ -481,23 +496,26 @@ class IdentityVerification:
 
                     # Validate cropped face
                     if cropped_face is None or cropped_face.size == 0:
-                        video_dict["error"] = "invalid_cropped_face"
+                        video_dict['error'] = 'invalid_cropped_face'
                         return video_dict
 
                     print(f"Face shape: {cropped_face.shape}")
                     return cropped_face
 
                 except Exception as e:
-                    video_dict["error"] = "error_processing_detected_face"
+                    video_dict['error'] = 'error_processing_detected_face'
                     return video_dict
             else:
-                video_dict["error"] = "no_suitable_face_detected_in_video"
+                video_dict['error'] = 'no_suitable_face_detected_in_video'
                 return video_dict
 
         except Exception as e:
-            video_dict["error"] = "video_processing_error"
+            logging.info(f"Exception in extract_selfie_from_video: {e}")
+            video_dict['error'] = 'video_processing_error'
             return video_dict
 
+        
+
     def is_colored(self, base64_image):
         img = self.image_conversion(base64_image)
         img = np.array(img)
@@ -1013,12 +1031,7 @@ class IdentityVerification:
     ):
         st = time.time()
         document_data = {}
-        # side=auto only in testing mode.
-        # if document_type != 'passport' and country == 'IRQ':
-        #     document_data = self.agent_extraction(image, country, side)
-        #     logging.info(
-        #         f"--------------Time taken for Front ID Extraction in IDV package: {time.time() - st} seconds\n")
-        #     return document_data
+      
         logging.info(f"Starting extraction for document_type: {document_type}, country: {country}, side: {side}, nationality: {nationality}, \n step data: {step_data}")
 
         if country == "IRQ":
@@ -1459,94 +1472,6 @@ class IdentityVerification:
 
             return front_data
 
-        if country == "SAU":
-            from idvpackage.ocr_utils import (
-                detect_photo_on_screen,
-                detect_screenshot,
-                document_on_printed_paper,
-            )
-            from idvpackage.sau_id_extraction import extract_id_details
-
-            front_data = {"error": "", "doc_type": "national_identity_card"}
-
-            try:
-                processed_front_id = self.image_conversion(front_id)
-                front_id_text = self.get_ocr_results(processed_front_id)
-                front_id_text = front_id_text[0].description
-                front_id_text_list = front_id_text.split("\n")
-
-                img = self.image_conversion(front_id)
-                image = np.array(img)
-                pil_image = Image.fromarray(image)
-
-                doc_on_pp_result = document_on_printed_paper(image)
-
-                with io.BytesIO() as output:
-                    pil_image.save(output, format="PNG")
-                    image_data = output.getvalue()
-                logo_result = "clear"
-                screenshot_result = detect_screenshot(self.client, front_id)
-                photo_on_screen_result = detect_photo_on_screen(self.client, front_id)
-
-                front_blurred, front_glare = self.get_blurred_and_glared_for_doc(image)
-
-                front_face_locations, front_face_encodings = (
-                    self.load_and_process_image_fr(front_id)
-                )
-
-                front_face_locations_str = json.dumps(
-                    [tuple(face_loc) for face_loc in front_face_locations]
-                )
-                front_face_encodings_str = json.dumps(
-                    [face_enc.tolist() for face_enc in front_face_encodings]
-                )
-
-                front_data_fields = extract_id_details(front_id_text_list)
-                valid_nationality_result = self.check_nationality_in_iso_list(
-                    front_data_fields.get("nationality")
-                )
-
-                front_data = {
-                    "valid_nationality": valid_nationality_result,
-                    "front_extracted_data": front_id_text,
-                    "front_coloured": True,
-                    "front_doc_on_pp": doc_on_pp_result,
-                    "front_logo_result": logo_result,
-                    "front_screenshot_result": screenshot_result,
-                    "front_photo_on_screen_result": photo_on_screen_result,
-                    "front_blurred": front_blurred,
-                    "front_glare": front_glare,
-                    "front_face_locations": front_face_locations_str,
-                    "front_face_encodings": front_face_encodings_str,
-                }
-
-                front_data.update(front_data_fields)
-
-                non_optional_keys = [
-                    "front_face_locations",
-                    "front_face_encodings",
-                    "id_number",
-                    "name",
-                    "dob",
-                    "expiry_date",
-                    "gender",
-                    "nationality",
-                ]
-                empty_string_keys = [
-                    key
-                    for key, value in front_data.items()
-                    if key in non_optional_keys and value == ""
-                ]
-
-                if empty_string_keys:
-                    front_data["error"] = "covered_photo"
-
-            except Exception as e:
-                front_data["error"] = "bad_image"
-                front_data["error_details"] = e
-
-            return front_data
-
         if country == "IRQ":
             logging.info("-------------Working on IRQ \n")
             from idvpackage.ocr_utils import (
@@ -2244,16 +2169,6 @@ class IdentityVerification:
                 print(f"-------------->> Something went wrong error trace:: {e}")
                 front_data["error_details"] = e
 
-            # try:
-            #     list_1 = front_data['name_ar'].split(" ")
-            #     filtered_names = [name for name in list_1 if len(name) > 1]
-            #     front_data['first_name_ar'] = filtered_names[0]
-            #     front_data['last_name_ar'] = filtered_names[3]
-            #     front_data['middle_name_ar'] = filtered_names[1]+' '+filtered_names[2]
-            # except Exception as e:
-            #     front_data['first_name_ar'] = ''
-            #     front_data['last_name_ar'] = ''
-            #     front_data['middle_name_ar'] = ''
 
             try:
                 list_1 = front_data["name_ar"].split(" ")
@@ -2996,7 +2911,6 @@ class IdentityVerification:
             return back_data
 
         if country == "QAT":
-            # from idvpackage.qatar_id_extraction import qatar_back_id_extraction
             from idvpackage.qatar_id_extraction import get_response_from_openai_qat
 
             back_data = {"error": "", "doc_type": "national_identity_card"}
@@ -3011,28 +2925,6 @@ class IdentityVerification:
                 )
                 compressed_image_data = compressed_image.getvalue()
 
-                # id_infos = self.get_ocr_results(compressed_image_data, country="QAT")
-
-                # text = id_infos[0].description
-                # print(f'Original text: {text}')
-
-                # translated_id_text = self.translator.translate(text, from_lang='ar', to_lang='en').text
-                # pattern4 = r"(Director General of the General Department|Directorate of Passports|Passport number|Serial)"
-                # k = re.search(pattern4, text, re.IGNORECASE)
-                # print('this is translated_id_text',translated_id_text)
-                # if not k:
-                #     back_data["error"] = "not_back_id"
-
-                #     return back_data
-
-                # original_text = text
-
-                # print('this is original text:',original_text)
-
-                ## TODO: template matching for Qatar ID's
-                # image_data = base64.b64decode(back_id)
-
-                # back_extraction_result = qatar_back_id_extraction(original_text)
                 back_extraction_result = get_response_from_openai_qat(compressed_image_data, "back", country, self.openai_key)
                 back_data.update(back_extraction_result)
 
@@ -3052,30 +2944,19 @@ class IdentityVerification:
 
                 back_data.update(back_data_update)
 
-            # non_optional_keys = ["card_number"]
-            # empty_string_keys = [key for key, value in back_data.items() if key in non_optional_keys and value == '']
-
-            # if empty_string_keys:
-            #     back_data['error'] = 'covered_photo'
-
+           
             except Exception as e:
                 back_data["error"] = "bad_image"
                 back_data["error_details"] = e
 
-                # back_data['error_details'] = e
-            # else:
-            #     back_data['error'] = 'bad_image'
-
             return back_data
 
         if country == "LBN":
             from idvpackage.ocr_utils import (
-                detect_logo,
                 detect_photo_on_screen,
                 detect_screenshot,
                 document_on_printed_paper,
             )
-            # from idvpackage.lebanon_id_extraction import lebanon_back_id_extraction
             from idvpackage.lebanon_id_extraction import lebanon_id_extraction_from_text
             from idvpackage.blur_detection import is_image_blur
 
@@ -3118,16 +2999,7 @@ class IdentityVerification:
                     back_data["error"] = "blur_photo"
                     return back_data
 
-                ## TODO: template matching for Lebanon ID's
-                # image_data = base64.b64decode(back_id)
-                # template_result = detect_logo(self.client, image_data, country, compare_type='template', side='back')
-                # if template_result == 'consider':
-                #     back_data["error"] = "not_back_id"
-                #     return back_data
-
-                ## TODO: tampering result for Lebanon ID's
-                # tampered_result_back = calculate_error_difference(np.array(Image.open(io.BytesIO(base64.decodebytes(bytes(back_id, "utf-8"))))))
-
+             
                 st = time.time()
                 back_extraction_result = lebanon_id_extraction_from_text(back_id_text_desc, compressed_image_data, "back", self.openai_key)
 
@@ -3208,80 +3080,29 @@ class IdentityVerification:
 
         if country == "SDN":
             from idvpackage.ocr_utils import (
-                detect_logo,
                 detect_photo_on_screen,
                 detect_screenshot,
                 document_on_printed_paper,
             )
-            from idvpackage.sudan_id_extraction import sdn_back_id_extraction
             from idvpackage.blur_detection import is_image_blur
 
             back_data = {"error": "", "doc_type": "national_identity_card"}
 
-            logging.info(f"Starting Sudan ID back side processing with step_data:{step_data}")
+            logging.info(f"Starting Sudan ID back side processing with step_data:{step_data.keys() if step_data else 'None'}")
             try:
                 st = time.time()
                 processed_back_id = self.image_conversion(back_id)
                 logging.info(
                     f"----------------Time taken for image conversion back: {time.time() - st} seconds\n"
                 )
-
                 st = time.time()
                 compressed_image = BytesIO()
                 processed_back_id.save(
                     compressed_image, format="JPEG", quality=90, optimize=True
                 )
                 compressed_image_data = compressed_image.getvalue()
-                # id_infos = self.get_ocr_results(compressed_image_data, country="SDN")
-                # text = id_infos[0].description
-                # logging.info(
-                #     f"----------------Time taken for vision back: {time.time() - st} seconds\n"
-                # )
-
-                # try:
-                #     translated_id_text = self.translator.translate(
-                #         text, src="ar", dest="en"
-                #     ).text
-                # except:
-                #     logging.info(
-                #         f"\n--------------Fallback for translation keyword matching"
-                #     )
-                #     from deep_translator import GoogleTranslator
-
-                #     translated_id_text = GoogleTranslator("ar", "en").translate(text)
-                # logging.info(
-                #     f"----------------Time taken for ar-en translation back: {time.time() - st} seconds\n"
-                # )
-
-                # pattern4 = r"(IDSDN|Name)"
-                # k = re.search(pattern4, translated_id_text, re.IGNORECASE)
-
-                # if not k:
-                #     back_data["error"] = "not_back_id"
-                #     return back_data
-
-               
-                
-
                 image = np.array(processed_back_id)
-                # blur_test = is_image_blur(image)
-                # if blur_test == True:
-                #     print(f"Back ID Document is blurry, marking as covered photo")
-                #     back_data['error'] = 'covered_photo'
-                #     return back_data
-
-                ## TODO: template matching for Lebanon ID's
-                # image_data = base64.b64decode(back_id)
-                # template_result = detect_logo(self.client, image_data, country, compare_type='template', side='back')
-                # if template_result == 'consider':
-                #     back_data["error"] = "not_back_id"
-                #     return back_data
-
-                ## TODO: tampering result for Lebanon ID's
-                # tampered_result_back = calculate_error_difference(np.array(Image.open(io.BytesIO(base64.decodebytes(bytes(back_id, "utf-8"))))))
-
                 st = time.time()
-                # back_extraction_result = sdn_back_id_extraction(text)
                 from idvpackage.sudan_passport_extraction import get_response_from_openai_sdn
                 back_extraction_result = get_response_from_openai_sdn(compressed_image_data, "back", self.openai_key)
 
@@ -3309,14 +3130,6 @@ class IdentityVerification:
                 back_data.update(back_extraction_result)
                 back_data['issuing_country'] = 'SDN'
 
-
-                # back_data['']
-
-                # issue and expiry date should be same as mrz
-                # issue and expiry date should have 5 years of difference
-                # issue and expiry date from mrz should have 5 years of difference
-                # date of birth from front should match date of birth from back
-                # date of birth from front should match date of birth from mrz
                 from idvpackage.ocr_utils import normalize_date_generic
 
                 dob_front_str = step_data.get("dob", "") if step_data else ""
@@ -3423,27 +3236,6 @@ class IdentityVerification:
                     back_data['error'] = "front_back_mismatch"
                     return back_data
 
-                # name_mrz = []
-                # try:
-                #     for word in back_data.get("mrz3", "").split("<"):
-                #         if word and word.isalpha():
-                #             name_mrz.append(word)
-
-                #     back_data['name_mrz'] = " ".join(name_mrz)
-                #     name = back_data.get("full_name_generic", "")
-                #     try:
-                #         name = name.split(" ")
-                #     except:
-                #         name = []
-                #     from idvpackage.ocr_utils import get_name_match_mrz
-                #     back_data['name_match_mrz'] = get_name_match_mrz(name, name_mrz)
-
-                #     logging.info(f"name_match_mrz: {back_data['name_match_mrz']}")
-                # except Exception as e:
-                #     back_data['name_match_mrz'] = False
-                #     back_data['name_mrz'] = ''
-                #     logging.info(f"Error in comparing name between extracted name and MRZ for SDN ID {e}")
-                #     pass
                 from idvpackage.ocr_utils import get_name_match_mrz
                 back_data['nationality'] = 'SDN'
                 back_data['is_name_match_mrz'], back_data['name_mrz'] = get_name_match_mrz(back_data, "nationality_identity_card")
@@ -3759,11 +3551,7 @@ class IdentityVerification:
                 detect_screenshot,
                 document_on_printed_paper,
             )
-            # from idvpackage.lebanon_passport_extraction import (
-            #     lebanon_passport_extraction,
-            #     verify_lbn_pss_chain,
-            # )
-
+         
             from idvpackage.lebanon_id_extraction import get_response_from_openai_lbn
             from idvpackage.common import load_and_process_image_deepface
             from idvpackage.blur_detection import is_image_blur
@@ -3853,31 +3641,7 @@ class IdentityVerification:
                 logging.info(f"validation_results: {json.dumps(validation_results, ensure_ascii=False, indent=2)}")
                 passport_data.update(validation_results)
 
-                #extract name from mrz1
-                # mrz1 = passport_details.get('mrz1', '')
-                # logging.info(f"MRZ1 extracted: {mrz1}")
-                # if mrz1:
-                #     try:
-                #         mrz1 = mrz1[5:]
-                #         logging.info(f"Processed MRZ1: {mrz1}")
-                #         name_mrz = []
-                #         for word in mrz1.split("<"):
-                #             if word and  word.isalpha():
-                #                 name_mrz.append(word)
-
-                #         passport_data['name_mrz'] = " ".join(name_mrz)
-                #         logging.info(f"Name from MRZ1 parts: {name_mrz}")
-
-                #         name = passport_data.get("last_name", "") + " " + passport_data.get("first_name", "")
-                #         name = name.split(" ")
-                #         from idvpackage.ocr_utils import get_name_match_mrz
-                #         passport_data['is_name_match_mrz'] = get_name_match_mrz(name, name_mrz)
-                #         logging.info(f"is_name_match_mrz: {passport_data['is_name_match_mrz']}")
-
-                #     except Exception as e:
-                #         logging.info(f"Error in processing Name from MRZ1: {e}")
-                #         passport_data['is_name_match_mrz'] = False
-                #         pass
+                
                 from idvpackage.ocr_utils import get_name_match_mrz
                 passport_data['is_name_match_mrz'], passport_data['name_mrz'] = get_name_match_mrz(passport_data, "passport")
 
@@ -3885,8 +3649,7 @@ class IdentityVerification:
                 image = np.array(processed_passport)
 
                 st = time.time()
-                ## TODO: doc_on_pp and detect_photo_on_screen for LBN
-                # doc_on_pp_result = document_on_printed_paper(image)
+                
                 doc_on_pp_result = "clear"
                 screenshot_result = detect_screenshot(self.client, passport)
                 # photo_on_screen_result = detect_photo_on_screen(self.client, passport)
@@ -3959,24 +3722,6 @@ class IdentityVerification:
                     logging.info(f"Empty keys found: {empty_string_keys}")
                    
 
-                # if passport_data["mrz1"] == "":
-                #     passport_data["error"] = "cropped_mrz"
-                #     passport_data["error_details"] = "MRZ1 is null"
-
-                # mrz2_pattern = r"^[A-Za-z]{2}\d{7}.*"
-
-                # # Check if the extracted text matches the pattern
-                # if not (re.match(mrz2_pattern, passport_data["mrz2"])):
-                #     passport_data["error"] = "invalid mrz"
-                #     passport_data["error_details"] = "MRZ not present in picture"
-
-                # if len(passport_data["mrz2"]) < 43:
-                #     passport_data["error"] = "cropped_mrz"
-                #     passport_data["error_details"] = "MRZ not present in picture"
-
-                # if not (re.match(mrz2_pattern, passport_data["id_number"])):
-                #     passport_data["error"] = "id_number_not_found"
-                #     passport_data["error_details"] = "ID Number not identified."
 
             except Exception as e:
                 passport_data["error"] = "bad_image"
@@ -4009,29 +3754,13 @@ class IdentityVerification:
 
                 st = time.time()
                 compressed_image = BytesIO()
-                # TODO
 
-                # processed_passport=self.preprocess_image(processed_passport, sharpness=2.0, contrast=1.5, radius=3, percent=180, threshold=5)
-                # Enhance image sharpness and contrast.
+                
                 processed_passport.save(
                     compressed_image, format="JPEG", quality=95, optimize=True
                 )
                 compressed_image_data = compressed_image.getvalue()
-                # id_infos = self.get_ocr_results(compressed_image_data, country="SDN")
-                # passport_text = id_infos[0].description
-                # logging.info(
-                #     f"----------------Time taken for vision passport: {time.time() - st} seconds\n"
-                # )
-
-                # pattern4 = r"(Republic of Sudan|Republic of the Sudan|PCSDN|SDN)"
-                # k = re.search(pattern4, passport_text, re.IGNORECASE)
-
-                # if k:
-                #     print(f"Keyword feature matches: {k.group()}\n")
-
-                # if not k:
-                #     passport_data["error"] = "not_passport"
-                #     return passport_data
+               
 
                 image = np.array(processed_passport)
                 if country == "SDN":
@@ -4087,31 +3816,7 @@ class IdentityVerification:
                 
                 passport_data.update(passport_details)
 
-                # mrz1 = passport_data.get('mrz1', '')
-                
-                # logging.info(f"MRZ1 extracted: {mrz1}")
-                # if mrz1:
-                #     try:
-                #         mrz1 = mrz1[5:]
-                #         logging.info(f"Processed MRZ1: {mrz1}")
-                #         name_mrz = []
-                #         for word in mrz1.split("<"):
-                #             if word and  word.isalpha():
-                #                 name_mrz.append(word)
-
-                #         passport_data['name_mrz'] = " ".join(name_mrz)
-                #         logging.info(f"Name from MRZ1 parts: {name_mrz}")
-
-                #         name = passport_data.get("full_name_generic", "")
-                #         name = name.split(" ")
-                #         from idvpackage.ocr_utils import get_name_match_mrz
-                #         passport_data['name_match_mrz'] = get_name_match_mrz(name, name_mrz)
-                #         logging.info(f"name_match_mrz: {passport_data['name_match_mrz']}")
-
-                #     except Exception as e:
-                #         logging.info(f"Error in processing Name from MRZ1: {e}")
-                #         passport_data['name_match_mrz'] = False
-                #         pass
+               
                 
 
                 from idvpackage.ocr_utils import validation_checks_passport
@@ -4123,63 +3828,7 @@ class IdentityVerification:
                 from idvpackage.ocr_utils import get_name_match_mrz
                 passport_data['is_name_match_mrz'], passport_data['name_mrz'] = get_name_match_mrz(passport_data, "passport")
 
-                # check difference between issue_date and expiry_date should be 10 years
-                # check difference between issue_date and expiry_date_mrz should be 10 years
-                # check passport_number and passport_number_mrz are same
-                # check dob and dob_mrz are same
-                # check gender and gender_mrz are same
-
-                # checking difference between issue_date and expiry_date for 10 years validity
-                # issue_date_str = passport_data.get("issue_date",'') 
-                # expiry_date_str = passport_data.get("expiry_date",'')
-                # expiry_date_mrz_str = passport_data.get("expiry_date_mrz",'')
-                # dob_str = passport_data.get("dob",'')
-                # dob_mrz_str = passport_data.get("dob_mrz",'')
-                # passport_number = passport_data.get("passport_number",'')
-                # passport_number_mrz = passport_data.get("passport_number_mrz",'')
-
-                # logging.info(f"issue_date_str: {issue_date_str}, expiry_date_str: {expiry_date_str}, expiry_date_mrz_str: {expiry_date_mrz_str}")
-                # if issue_date_str and expiry_date_str:
-                #     try:
-                #         issue_date_obj = datetime.strptime(issue_date_str, "%d/%m/%Y")
-                #         expiry_date_obj = datetime.strptime(expiry_date_str, "%d/%m/%Y")
-                #         logging.info(f"issue_date_obj: {issue_date_obj}, expiry_date_obj: {expiry_date_obj}, difference is : {(expiry_date_obj - issue_date_obj).days}")
-
-                #         difference_in_days_obj = (expiry_date_obj - issue_date_obj).days
-                #         passport_data["valid_id_duration"] = difference_in_days_obj in [ 3650, 3651, 3652, 3653]
-                #     except:
-                #         logging.info("Error in parsing issue_date or expiry_date from SDN Passport")
-                #         passport_data["valid_id_duration"] = False
-                #         pass
                 
-                # if issue_date_str and expiry_date_mrz_str:
-                #     try:
-
-                #         expiry_date_mrz_obj = datetime.strptime(expiry_date_mrz_str, "%d/%m/%Y")
-
-                #         logging.info(f"issue_date_obj: {issue_date_obj}, expiry_date_mrz_obj: {expiry_date_mrz_obj}, difference is : {(expiry_date_mrz_obj - issue_date_obj).days}")
-                #         difference_in_days_obj = (expiry_date_mrz_obj - issue_date_obj).days
-                #         passport_data["valid_id_mrz_duration"] = difference_in_days_obj in [ 3650, 3651, 3652, 3653]
-                #     except:
-                #         logging.info("Error in parsing issue_date or expiry_date from SDN Passport")
-                #         passport_data["valid_id_mrz_duration"] = False
-                #         pass
-
-                # if passport_number and passport_number_mrz:
-                #     passport_data["is_passport_number_mrz_match"] = passport_number == passport_number_mrz
-                # else:
-                #     passport_data["is_passport_number_mrz_match"] = False
-
-                # if dob_str and dob_mrz_str:
-                #     passport_data["is_dob_mrz_match"] = dob_str == dob_mrz_str
-                # else:
-                #     passport_data["is_dob_mrz_match"] = False
-
-                # if passport_data['gender'] and passport_data['gender_mrz']:
-                #     passport_data["is_gender_mrz_match"] = passport_data['gender'] == passport_data['gender_mrz']
-                # else:
-                #     passport_data["is_gender_mrz_match"] = False
-
                 if passport_data.get("issue_date"):
                     passport_data["issuance_date"] = passport_details["issue_date"]
 
@@ -4189,11 +3838,9 @@ class IdentityVerification:
                 image = np.array(processed_passport)
 
                 st = time.time()
-                ## TODO: doc_on_pp and detect_photo_on_screen for LBN
-                # doc_on_pp_result = document_on_printed_paper(image)
+               
                 doc_on_pp_result = "clear"
                 screenshot_result = detect_screenshot(self.client, passport)
-                # photo_on_screen_result = detect_photo_on_screen(self.client, passport)
                 photo_on_screen_result = "clear"
                 blurred, glare = self.get_blurred_and_glared_for_doc(image)
                 valid_nationality_result = self.check_nationality_in_iso_list(