idvpackage 3.0.10__tar.gz → 3.0.11__tar.gz

{idvpackage-3.0.10/idvpackage.egg-info → idvpackage-3.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idvpackage
-Version: 3.0.10
+Version: 3.0.11
 Summary: This repository contains a Python program designed to execute Optical Character Recognition (OCR) and Facial Recognition on images.
 Home-page: https://github.com/NymCard-Payments/project_idv_package
 Classifier: Programming Language :: Python :: 3

{idvpackage-3.0.10 → idvpackage-3.0.11}/idvpackage/common.py

@@ -909,8 +909,6 @@ def load_and_process_image_deepface(image_input, country=None):
             # Keep best fallback (just in case)
             
 
-        if country == "QAT":
-            return 0, 0
 
         if best_face_objs is None or best_confidence < CONFIDENCE_THRESHOLD:
             print(f"No valid face found (threshold={CONFIDENCE_THRESHOLD})")

{idvpackage-3.0.10 → idvpackage-3.0.11}/idvpackage/ocr.py

@@ -206,27 +206,12 @@ 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,
@@ -241,22 +226,38 @@ class IdentityVerification:
                     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': ''}
+        
 
         try:
             # Get rotation metadata from video
@@ -286,12 +287,12 @@ class IdentityVerification:
 
             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:
@@ -299,6 +300,7 @@ 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:
@@ -319,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:
@@ -431,40 +442,46 @@ class IdentityVerification:
                             }
 
                     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:
@@ -493,9 +510,11 @@ class IdentityVerification:
                 return video_dict
 
         except Exception as e:
+            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)

{idvpackage-3.0.10 → idvpackage-3.0.11/idvpackage.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idvpackage
-Version: 3.0.10
+Version: 3.0.11
 Summary: This repository contains a Python program designed to execute Optical Character Recognition (OCR) and Facial Recognition on images.
 Home-page: https://github.com/NymCard-Payments/project_idv_package
 Classifier: Programming Language :: Python :: 3

{idvpackage-3.0.10 → idvpackage-3.0.11}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = idvpackage
-version = 3.0.10
+version = 3.0.11
 description = This repository contains a Python program designed to execute Optical Character Recognition (OCR) and Facial Recognition on images.
 long_description = file: README.md
 long_description_content_type = text/markdown

{idvpackage-3.0.10 → idvpackage-3.0.11}/setup.py

@@ -9,7 +9,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="idvpackage",
-    version="3.0.10",
+    version="3.0.11",
     description=(
         "This repository contains a Python program designed to execute Optical Character Recognition (OCR)"
         " and Facial Recognition on images."