idvpackage 3.0.9__tar.gz → 3.0.10__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idvpackage
-Version: 3.0.9
+Version: 3.0.10
 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.9 → idvpackage-3.0.10}/idvpackage/common.py

@@ -780,196 +780,176 @@ def load_and_process_image_deepface_topup(image_input):
 
 
 def load_and_process_image_deepface(image_input, country=None):
-    DeepFace = get_deepface()  # Only load when needed
-    face_recognition = get_face_recognition()  # Only load when needed
+    DeepFace = get_deepface()
+    face_recognition = get_face_recognition()
+
+    CONFIDENCE_THRESHOLD = 0.90 if country == "SDN" else 0.97
+
     def process_angle(img, angle):
+        img_to_process = None
+        img_rgb = None
+        img_pil = None
+        rotated = None
+
         try:
-            # Create a view instead of copy when possible
+            # Rotate only if needed
             if angle != 0:
-                # Minimize memory usage during rotation
-                with np.errstate(all='ignore'):
-                    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-                    img_pil = Image.fromarray(img_rgb)
-                    # Use existing buffer when possible
-                    rotated = np.ascontiguousarray(img_pil.rotate(angle, expand=True))
-                    img_to_process = cv2.cvtColor(rotated, cv2.COLOR_RGB2BGR)
-                    # Clear references to intermediate arrays
-                    del img_rgb, img_pil, rotated
+                img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+                img_pil = Image.fromarray(img_rgb)
+                rotated = np.ascontiguousarray(
+                    img_pil.rotate(angle, expand=True)
+                )
+                img_to_process = cv2.cvtColor(rotated, cv2.COLOR_RGB2BGR)
             else:
                 img_to_process = img
 
-            # Extract faces with memory optimization
             face_objs = DeepFace.extract_faces(
                 img_to_process,
-                detector_backend='fastmtcnn',
+                detector_backend="fastmtcnn",
                 enforce_detection=False,
-                align=True
+                align=True,
             )
 
-            if face_objs and len(face_objs) > 0:
-                confidence = face_objs[0].get('confidence', 0)
+            if not face_objs:
+                return None, None, 0.0
 
-                # Check face frame size only if confidence is less than 1
-                if confidence < 1:
-                    facial_area = face_objs[0]['facial_area']
-                    # Sudanese Edge Case. They have smaller pictures.
-                    if country == 'SDN' and (facial_area['w'] < 40 or facial_area['h'] < 50):
-                        print(f"Rejecting face at {angle} degrees due to small size of Sudanese Document: {facial_area['w']}x{facial_area['h']} (minimum 40x50)")
-                        return None, None, 0
-                    elif country != 'SDN' and (facial_area['w'] < 80 or facial_area['h'] < 90):
-                        print(f"Rejecting face at {angle} degrees due to small size: {facial_area['w']}x{facial_area['h']} (minimum 100x100)")
-                        return None, None, 0
-
-                # Immediately reject if confidence is below threshold
-                if confidence < 0.95 and country != 'SDN':
-                    print(f"Rejecting face at {angle} degrees due to low confidence: {confidence:.3f}")
-                    return None, None, 0
-                elif confidence >= 0.90 and country == 'SDN':
-                    return face_objs, img_to_process, confidence
+            #get largest face
+            biggest_face = max(
+                face_objs,
+                key=lambda f: f["facial_area"]["w"] * f["facial_area"]["h"],
+            )
 
-                return face_objs, img_to_process, confidence
+            facial_area = biggest_face["facial_area"]
+            confidence = biggest_face.get("confidence", 0.0)
+
+            logging.info(f"Angle {angle}: Detected face with confidence {confidence}")
+
+            if country == "SDN":
+                if confidence < CONFIDENCE_THRESHOLD:
+                    logging.info(f"Low confidence for SDN at angle: {confidence} at angle {angle}")
+                    return None, None, 0.0
+            else:
+                if confidence < 0.95:
+                    logging.info(f"Low confidence: for country : {country} -> {confidence} at angle {angle}")
+                    return None, None, 0.0
+
+            # Size validation (only when confidence < 1)
+            w, h = facial_area["w"], facial_area["h"]
+            if country == "SDN":
+                if w < 40 or h < 50:
+                    logging.info(f"Face too small for SDN: w={w}, h={h}")
+                    return None, None, 0.0
+            else:
+                if w < 80 or h < 90:
+                    logging.info(f"Face too small: w={w}, h={h}")
+                    return None, None, 0.0
+
+            # All checks passed
+            return biggest_face, img_to_process, confidence
 
-            # Clear memory if no face found
-            del img_to_process
-            return None, None, 0
         except Exception as e:
-            print(f"Error processing angle {angle}: {e}")
-            return None, None, 0
+            print(f"[DeepFace] Error at angle {angle}: {e}")
+            return None, None, 0.0
+
         finally:
-            # Ensure memory is cleared
-            if 'img_to_process' in locals():
-                del img_to_process
+            # Aggressive memory cleanup
+            if img_rgb is not None:
+                del img_rgb
+            if img_pil is not None:
+                del img_pil
+            if rotated is not None:
+                del rotated
+
+    # -------------------- INPUT HANDLING --------------------
 
     try:
-        # Process input image efficiently
         if isinstance(image_input, np.ndarray):
-            # Use view when possible
             image = np.ascontiguousarray(image_input)
             if image.dtype != np.uint8:
                 image = image.astype(np.uint8, copy=False)
+
         elif isinstance(image_input, str):
-            # Decode base64 directly to numpy array
             image_data = base64.b64decode(image_input)
-            image = cv2.imdecode(np.frombuffer(image_data, np.uint8), cv2.IMREAD_COLOR)
-            del image_data  # Clear decoded data
+            image = cv2.imdecode(
+                np.frombuffer(image_data, np.uint8),
+                cv2.IMREAD_COLOR,
+            )
+            del image_data
+
         else:
-            print(f"Unexpected input type: {type(image_input)}")
+            print("Unsupported image input type")
             return [], []
 
         if image is None or image.size == 0:
-            print("Empty image")
+            print("Empty image input")
             return [], []
 
-        if country == 'SDN':
-            CONFIDENCE_THRESHOLD = 0.90
-        else:
-            CONFIDENCE_THRESHOLD = 0.97
 
-        # Try original orientation first to avoid unnecessary processing
-        face_objs, processed_image, confidence = process_angle(image, 0)
-        if face_objs is not None and confidence >= CONFIDENCE_THRESHOLD:
-            try:
-                biggest_face = max(face_objs, key=lambda face: face['facial_area']['w'] * face['facial_area']['h'])
-                facial_area = biggest_face['facial_area']
+        # -------------------- ANGLE LOOP (NO THREADS) --------------------
 
-                # Double check size requirements for biggest face
-                if confidence < 1:
-                    # print(f"Confidence less than 1: {confidence}")
-                    if country == 'SDN' and (facial_area['w'] < 40 or facial_area['h'] < 50):
-                        print(f"Face validation failed: Face frame too small {facial_area['w']}x{facial_area['h']} (minimum 40x50)")
-                        return [], []
-                    elif country != 'SDN' and (facial_area['w'] < 80 or facial_area['h'] < 90):
-                        print(f"Face validation failed: Face frame too small {facial_area['w']}x{facial_area['h']} (minimum 100x100)")
-                        return [], []
+        best_face_objs = None
+        best_image = None
+        best_confidence = 0.0
 
-                x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
+        for angle in (0, 90, 180, 270):
+            face_objs, processed_image, confidence = process_angle(image, angle)
 
-                # Minimize memory usage during color conversion
-                image_rgb = cv2.cvtColor(processed_image, cv2.COLOR_BGR2RGB)
-                face_locations = [(y, x + w, y + h, x)]
-                face_encodings = face_recognition.face_encodings(image_rgb, face_locations)
+            if confidence > best_confidence:
+                best_face_objs = face_objs
+                best_image = processed_image
+                best_confidence = confidence
+                best_angle = angle
 
-                if face_encodings:
-                    # print(f"Found face in original orientation with confidence {confidence}")
-                    return face_locations, face_encodings
-            finally:
-                # Clear memory
-                del processed_image, image_rgb
-                if 'face_objs' in locals():
-                    del face_objs
-        if country=='QAT':
-            return 0,0
-
-        # Try other angles in parallel
-        angles = [90, 180, 270]
-        best_confidence = confidence if face_objs is not None else 0
-        best_face_objs = face_objs
-        best_image = processed_image
+            if face_objs is None:
+                continue
+            
+            else:
+                break  # Exit loop on first valid detection
 
-        with ThreadPoolExecutor(max_workers=3) as executor:
-            futures = {
-                executor.submit(process_angle, image, angle): angle
-                for angle in angles
-            }
+            # Keep best fallback (just in case)
+            
 
-            try:
-                for future in as_completed(futures):
-                    face_objs, processed_image, confidence = future.result()
-                    if face_objs is not None:
-                        if confidence >= CONFIDENCE_THRESHOLD:
-                            # Cancel remaining tasks
-                            for f in futures:
-                                if not f.done():
-                                    f.cancel()
-                            best_face_objs = face_objs
-                            best_image = processed_image
-                            best_confidence = confidence
-                            break
-            finally:
-                for future in futures:
-                    future.cancel()
+        if country == "QAT":
+            return 0, 0
 
         if best_face_objs is None or best_confidence < CONFIDENCE_THRESHOLD:
-            print(f"No faces detected with confidence >= {CONFIDENCE_THRESHOLD}")
+            print(f"No valid face found (threshold={CONFIDENCE_THRESHOLD})")
             return [], []
 
-        try:
-            biggest_face = max(best_face_objs, key=lambda face: face['facial_area']['w'] * face['facial_area']['h'])
-            facial_area = biggest_face['facial_area']
-
-            # Final size check for rotated face
-            if country != 'SDN' and confidence < 1:
-                if facial_area['w'] < 80 or facial_area['h'] < 90:
-                    print(f"Face validation failed: Face frame too small {facial_area['w']}x{facial_area['h']} (minimum 100x100)")
-                    return [], []
-            elif country == 'SDN' and confidence < CONFIDENCE_THRESHOLD:
-                print(f"Face validation failed: Face frame too small {facial_area['w']}x{facial_area['h']} (minimum 40x50)")
-                return [], []
-
-            x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
-
-            # Minimize memory during final processing
-            image_rgb = cv2.cvtColor(best_image, cv2.COLOR_BGR2RGB)
-            face_locations = [(y, x + w, y + h, x)]
-            face_encodings = face_recognition.face_encodings(image_rgb, face_locations)
+        # -------------------- FINAL ENCODING --------------------
 
-            if face_encodings:
-                return face_locations, face_encodings
+        
+        logging.info(f"Using best angle: {best_angle} detected with confidence {best_confidence} for encodings")
+        fa = best_face_objs["facial_area"]
+        x, y, w, h = fa["x"], fa["y"], fa["w"], fa["h"]
+
+        image_rgb = cv2.cvtColor(best_image, cv2.COLOR_BGR2RGB)
+        face_locations = [(y, x + w, y + h, x)]
+        face_encodings = face_recognition.face_encodings(
+            image_rgb, face_locations
+        )
 
-            print("Failed to extract face encodings")
+        if not face_encodings:
             return [], []
-        finally:
-            # Clear final processing memory
-            del image_rgb, best_image, best_face_objs
+
+        return face_locations, face_encodings
 
     except Exception as e:
-        print(f"Error in face detection: {e}")
+        print(f"[FacePipeline] Fatal error: {e}")
         return [], []
+
     finally:
-        # Ensure main image is cleared
-        if 'image' in locals():
+        # Final memory cleanup
+        if "image_rgb" in locals():
+            del image_rgb
+        if "best_image" in locals():
+            del best_image
+        if "best_face_objs" in locals():
+            del best_face_objs
+        if "image" in locals():
             del image
 
+
 def calculate_similarity(face_encoding1, face_encoding2):
     face_recognition = get_face_recognition()
     similarity_score = 1 - face_recognition.face_distance([face_encoding1], face_encoding2)[0]

idvpackage-3.0.10/idvpackage/jor_passport_extraction.py

@@ -0,0 +1,256 @@
+
+import base64
+import time
+from io import BytesIO
+from typing import Optional
+import cv2
+
+from openai import OpenAI
+from pydantic import BaseModel, Field
+import logging
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    force=True,
+)
+
+
+PROMPT_PASSPORT = """
+Extract ALL fields from this Jordan Passport **front side** image with high accuracy.
+
+Return a JSON object with the following fields (use the exact field names):
+
+- dob: Date of birth exactly as shown on the card, but always return in DD/MM/YYYY format (e.g., '15/06/1990'). If the card shows a different format, convert it to DD/MM/YYYY.
+- date_of_expiry: Date of expiry exactly as shown on the card, but always return in DD/MM/YYYY format (e.g., '15/06/1990'). If the card shows a different format, convert it to DD/MM/YYYY.
+- mrz1: First line of the MRZ (extract exactly as written).
+- mrz2: Second line of the MRZ (extract exactly as written).
+- name: Full name as printed on the card (extract exactly as written).
+- first_name: First name as printed on the card (extract exactly as written).
+- gender: Gender as either M or F (printed as Sex; output MALE if M, FEMALE if F).
+- place_of_issue: Issuing place as printed on the card (extract exactly as written).
+- full_name: Full name as printed on the card (extract exactly as written).
+- last_name: Last name from the full name (extract exactly as written; if not present, return null).
+- mother_name: Mother's full name as printed on the card (look for the label "Mother Full Name" and extract the name exactly as written in English, even if Arabic is present).
+- nationality: Nationality as printed on the card and return ISO 3166-1 alpha-3 code (e.g., JOR).
+- passport_national_number: National number as printed on the card (extract exactly as written) return empty string if not present.
+- passport_number: Passport number as printed on the card (exactly 8 characters)
+- issuing_date: Date of issue exactly as shown on the card, always in DD/MM/YYYY format.
+- place_of_birth: Place of birth as printed on the card, tagged under Address (extract exactly as written).
+- header_verified: Return True if any of these texts are present in the image: "Hashemite Kingdom of Jordan", "Hashemite Kingdom", or "Jordan"; otherwise False.
+- dob_mrz: Date of birth as extracted from MRZ (in DD/MM/YYYY format)
+- id_number_mrz: ID number as extracted from MRZ
+- expiry_date_mrz: Expiry date as extracted from MRZ (in DD/MM/YYYY format)
+- gender_mrz: Gender as extracted from MRZ (M or F) if M return MALE else if F return FEMALE
+
+Instructions:
+Instructions:
+- Do NOT guess or hallucinate any values. If unclear,return empty string.
+- Only use information visible on the card.
+- Return the result as a single JSON object matching the schema above.
+"""
+
+
+class JordanPassportFront(BaseModel):
+    dob: str = Field(
+        ...,
+        description="The date of birth (preserve (dd/mm/yyyy) format)",
+    )
+    expiry_date: str = Field(
+        ...,
+        description="The date of expiry  (preserve (dd/mm/yyyy) format) tagged as Date if Expiry",
+    )
+
+    mrz1: str = Field(..., description="First line of the MRZ")
+
+    mrz2: str = Field(..., description="Second line of the MRZ")
+
+    name: str = Field(
+        ...,
+        description="Full name as printed on the card (extract exactly as written on the card)",
+    )
+
+    first_name: str = Field(
+        ...,
+        description="First name as printed on the card (extract exactly as written on the card)",
+    )
+
+    gender: str = Field(
+        ...,
+        description="Gender as either M or F , (printed as Sex,  Male if M or Female if F)",
+    )
+
+    place_of_issue: str = Field(
+        ...,
+        description="Issuing place as printed on the card (extract exactly as written on the card)",
+    )
+
+    full_name: str = Field(
+        ...,
+        description="Full name as printed on the card (extract exactly as written on the card)",
+    )
+
+    last_name: Optional[str] = Field(
+        None,
+        description="Last name from the full name",
+    )
+
+    mother_name: str = Field(
+        ...,
+        description=" Mother's full name as printed on the card (look for the label Mother Full Name and extract the name exactly as written in English, Even Arabic is present)",
+    )
+
+    nationality: str = Field(
+        ...,
+        description="Nationality as printed on the card and return ISO 3166-1 alpha-3, e.g., JOR",
+    )
+
+    passport_number: str = Field(
+        ...,
+        min_length=8,
+        max_length=8,
+        description="ID number as printed on the card, extract exactly as written on the card ",
+    )
+
+    passport_national_number: str = Field(
+        ...,
+        description="National number as printed on the card, extract exactly as written on the card  return empty string if not present",
+    )
+
+    issuing_date: str = Field(
+        ...,
+        description="The date of issue  (preserve (dd/mm/yyyy) format)",
+    )
+
+    place_of_birth: str = Field(
+        ...,
+        description="Place of birth as printed on the card tagged under Address tag, extract exactly as written on the card",
+    )
+
+    header_verified: bool = Field(
+        ...,
+        description=" Return True if one of the texts present in the image Hashemite Kingdom of Jordan or Hashemite Kingdom or Jordan ",
+    )
+    
+    dob_mrz: str = Field(
+        ..., description="Date of birth as extracted from MRZ (in DD/MM/YYYY format)"
+    )
+    passport_number_mrz: str = Field(
+        ..., description="Passport number as extracted from MRZ"
+    )
+    expiry_date_mrz: str = Field(
+        ..., description="Expiry date as extracted from MRZ (in DD/MM/YYYY format)"
+    )
+    gender_mrz: str = Field(
+        ..., description="Gender as extracted from MRZ (M or F) if M return MALE else if F return FEMALE"
+    )
+
+
+def process_image(side):
+    if side == "first" or side == "page1":
+        prompt = PROMPT_PASSPORT
+        model = JordanPassportFront
+
+    else:
+        raise ValueError(
+            "Invalid document side specified. please upload front side of passport'."
+        )
+
+    return model, prompt
+
+
+def get_openai_response(prompt: str, model_type, image: BytesIO, genai_key):
+    b64_image = base64.b64encode(image.getvalue()).decode("utf-8")
+    for attempt in range(3):
+        try:
+            client = OpenAI(api_key=genai_key)
+            response = client.responses.parse(
+                model="gpt-4.1-mini",
+                input=[
+                    {
+                        "role": "system",
+                        "content": "You are an expert at extracting information from identity documents.",
+                    },
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "input_text", "text": prompt},
+                            {
+                                "type": "input_image",
+                                "image_url": f"data:image/jpeg;base64,{b64_image}",
+                                "detail": "low",
+                            },
+                        ],
+                    },
+                ],
+                text_format=model_type,
+            )
+            return response.output_parsed
+        except Exception as e:
+            logging.info(f"[ERROR] Attempt {attempt + 1} failed: {str(e)}")
+            time.sleep(2)
+    return None
+
+
+def _image_to_jpeg_bytesio(image) -> BytesIO:
+    """
+    Accepts: numpy.ndarray (OpenCV BGR), PIL.Image.Image, bytes/bytearray, or io.BytesIO
+    Returns: io.BytesIO containing JPEG bytes (ready for get_openai_response)
+    """
+    import numpy as np
+
+    if isinstance(image, BytesIO):
+        image.seek(0)
+        return image
+
+    if isinstance(image, (bytes, bytearray)):
+        return BytesIO(image)
+
+    try:
+        from PIL.Image import Image as _PILImage
+
+        if isinstance(image, _PILImage):
+            buf = BytesIO()
+            image.convert("RGB").save(buf, format="JPEG", quality=95)
+            buf.seek(0)
+            return buf
+    except Exception:
+        pass
+
+    if isinstance(image, np.ndarray):
+        success, enc = cv2.imencode(".jpg", image)
+        if not success:
+            raise ValueError("cv2.imencode failed")
+        return BytesIO(enc.tobytes())
+
+    raise TypeError(
+        "Unsupported image type. Provide numpy.ndarray, PIL.Image.Image, bytes, or io.BytesIO."
+    )
+
+
+def get_response_from_openai_jor(image, side, country, openai_key):
+    logging.info("Processing image for Jordan passport extraction OPENAI......")
+    logging.info(f" and type: {type(image)}")
+    try:
+        image = _image_to_jpeg_bytesio(image)
+    except Exception as e:
+        logging.error(f"Error encoding image: {e}")
+        return {"error": "Image encoding failed"}
+    try:
+        model, prompt = process_image(side)
+        logging.info(f"Using model: {model.__name__} and prompt {prompt[:100]}")
+    except ValueError as ve:
+        logging.error(f"Error: {ve}")
+        return {"error": str(ve)}
+
+    try:
+        response = get_openai_response(prompt, model, image, openai_key)
+    except Exception as e:
+        logging.error(f"Error during OpenAI request: {e}")
+        return {"error": "OpenAI request failed"}
+
+    response_data = vars(response)
+    logging.info(f"Openai response: {response}")
+    return response_data