data-science-document-ai 1.42.5__py3-none-any.whl → 1.56.1__py3-none-any.whl

src/postprocessing/postprocess_partner_invoice.py

@@ -1,7 +1,7 @@
 """This module contains the postprocessing functions for the partner invoice."""
-from concurrent.futures import ThreadPoolExecutor
+from collections import defaultdict
 
-from fuzzywuzzy import fuzz
+from rapidfuzz import fuzz, process
 
 from src.io import logger
 from src.utils import get_tms_mappings
@@ -105,9 +105,18 @@ def post_process_bundeskasse(aggregated_data):
             )
 
         # Check if the deferredDutyPayer is forto
-        deferredDutyPayer = line_item.get("deferredDutyPayer", {})
-        lower = deferredDutyPayer.get("documentValue", "").lower()
-        if any(key in lower for key in ["de789147263644738", "forto"]):
+        KEYWORDS = {"de789147263644738", "forto", "009812"}
+
+        def is_forto_recipient(line_item: dict) -> bool:
+            values_to_check = [
+                line_item.get("deferredDutyPayer", {}).get("documentValue", ""),
+                line_item.get("vatId", {}).get("documentValue", ""),
+            ]
+
+            combined = " ".join(values_to_check).lower()
+            return any(keyword in combined for keyword in KEYWORDS)
+
+        if is_forto_recipient(line_item):
             is_recipient_forto = True
 
     update_recipient_and_vendor(aggregated_data, is_recipient_forto)
@@ -136,13 +145,32 @@ def update_recipient_and_vendor(aggregated_data, is_recipient_forto):
     ] = "Dasbachstraße 15, 54292 Trier, Germany"
 
 
-def process_partner_invoice(params, aggregated_data, document_type_code):
+def select_unique_bank_account(bank_account):
+    # Select the unique bank account if multiple are present
+    if isinstance(bank_account, list) and bank_account:
+        best = defaultdict(lambda: None)
+
+        for item in bank_account:
+            dv = item["documentValue"]
+            if best[dv] is None or item["page"] < best[dv]["page"]:
+                best[dv] = item
+
+        unique = list(best.values())
+        return unique
+
+
+async def process_partner_invoice(params, aggregated_data, document_type_code):
     """Process the partner invoice data."""
     # Post process bundeskasse invoices
     if document_type_code == "bundeskasse":
         post_process_bundeskasse(aggregated_data)
         return
 
+    if "bankAccount" in aggregated_data:
+        aggregated_data["bankAccount"] = select_unique_bank_account(
+            aggregated_data["bankAccount"]
+        )
+
     line_items = aggregated_data.get("lineItem", [])
     # Add debug logging
     logger.info(f"Processing partnerInvoice with {len(line_items)} line items")
@@ -160,27 +188,78 @@ def process_partner_invoice(params, aggregated_data, document_type_code):
         reverse_charge_info["formattedValue"] = reverse_charge_value
         reverse_charge = aggregated_data.pop("reverseChargeSentence", None)
 
-    # Process each line item
-    for line_item in line_items:
-        if line_item.get("lineItemDescription", None) is not None:
-            line_item["itemCode"] = associate_forto_item_code(
-                line_item["lineItemDescription"]["formattedValue"],
-                params,
-            )
+    # Partner Name
+    partner_name = aggregated_data.get("vendorName", {}).get("documentValue", None)
+
+    # Process everything in one go
+    processed_items = await process_line_items_batch(
+        params, line_items, reverse_charge, partner_name
+    )
 
-            # Add page number for the consistency
-            line_item["itemCode"]["page"] = line_item["lineItemDescription"]["page"]
+    # Update your main data structure
+    aggregated_data["lineItem"] = processed_items
 
-        if reverse_charge:
-            # Distribute reverseChargeSentence to all line items
-            line_item["reverseChargeSentence"] = reverse_charge
-            line_item["reverseChargeSentence"]["page"] = reverse_charge["page"]
 
+async def process_line_items_batch(
+    params: dict, line_items: list[dict], reverse_charge=None, partner_name=None
+):
+    """
+    Processes all line items efficiently using a "Split-Apply-Combine" strategy.
+    """
+    # To store items that need external API lookup
+    pending_line_items = {}
+
+    # Check Fuzzy Matching
+    logger.info(f"Mapping line item codes with Fuzzy matching....")
+    for i, item in enumerate(line_items):
+        description_obj = item.get("lineItemDescription")
+
+        if not description_obj or not description_obj.get("formattedValue"):
+            continue
+        # Get the formatted description text
+        desc = description_obj["formattedValue"]
+
+        # Find Fuzzy Match
+        matched_code = find_matching_lineitem(
+            desc,
+            params["lookup_data"]["item_code"],
+            params["fuzzy_threshold_item_code"],
+        )
+
+        if matched_code:
+            # Set the code to the line item
+            item["itemCode"] = {
+                "documentValue": desc,
+                "formattedValue": matched_code,
+                "page": description_obj.get("page"),
+            }
+        else:
+            # Store for batch API call
+            pending_line_items[i] = desc
+
+    # Batch API Call for Embedding lookups
+    if pending_line_items:
+        code_map = await fetch_line_item_codes(pending_line_items, partner_name, params)
+
+        for index, desc in pending_line_items.items():
+            line_items[index]["itemCode"] = {
+                "documentValue": desc,
+                "formattedValue": code_map.get(desc),
+                "page": line_items[index]["lineItemDescription"].get("page"),
+            }
+
+    # Add reverse charge here if exists
+    if reverse_charge:
+        [
+            item.update({"reverseChargeSentence": reverse_charge})
+            for item in line_items
+            if (
+                (item.get("itemCode") and item["itemCode"]["formattedValue"] != "CDU")
+                or not item.get("itemCode")
+            )
+        ]
 
-def compute_score(args):
-    """Compute the fuzzy matching score between a new line item and a key."""
-    new_lineitem, key = args
-    return key, fuzz.ratio(new_lineitem, key)
+    return line_items
 
 
 def get_fuzzy_match_score(target: str, sentences: list, threshold: int):
@@ -195,16 +274,18 @@ def get_fuzzy_match_score(target: str, sentences: list, threshold: int):
         tuple: (best_match, score) if above threshold, else (None, 0)
     """
     # Use multiprocessing to find the best match
-    with ThreadPoolExecutor() as executor:
-        results = executor.map(compute_score, [(target, s) for s in sentences])
+    result = process.extractOne(
+        target, sentences, scorer=fuzz.WRatio, score_cutoff=threshold
+    )
+
+    if result is None:
+        return None, False
 
-    # Find the best match and score
-    best_match, best_score = max(results, key=lambda x: x[1], default=(None, 0))
+    match, score, index = result
 
-    # return best_match, best_score
-    # If the best match score is above a threshold (e.g., 80), return it
-    if best_score >= threshold:
-        return best_match, True
+    # return best_match if the best match score is above a threshold (e.g., 80)
+    if match:
+        return match, True
 
     return None, False
 
@@ -219,11 +300,14 @@ def if_reverse_charge_sentence(sentence: str, params):
         return False
 
     # Check if the sentence is similar to any of the reverse charge sentences
-    _, is_reverse_charge = get_fuzzy_match_score(
-        sentence, reverse_charge_sentences, threshold
+    match, _ = get_fuzzy_match_score(
+        sentence, list(reverse_charge_sentences.keys()), threshold
     )
 
-    return is_reverse_charge
+    if match:
+        return reverse_charge_sentences[match]
+
+    return False
 
 
 def find_matching_lineitem(new_lineitem: str, kvp_dict: dict, threshold=90):
@@ -236,46 +320,97 @@ def find_matching_lineitem(new_lineitem: str, kvp_dict: dict, threshold=90):
     Returns:
         str: The best matching 'Forto SLI' value from the dictionary.
     """
-    new_lineitem = new_lineitem.upper()
-
     # Check if the new line item is already in the dictionary
     if new_lineitem in kvp_dict:
         return kvp_dict[new_lineitem]
 
     # Get the best fuzzy match score for the extracted line item
-    best_match, _ = get_fuzzy_match_score(
-        new_lineitem, list(kvp_dict.keys()), threshold
+    match, _ = get_fuzzy_match_score(
+        new_lineitem,
+        list(kvp_dict.keys()),
+        threshold,
     )
 
-    return kvp_dict.get(best_match, None)
-
+    if match:
+        # find the code from the kvp_dict
+        return kvp_dict[match]
 
-def associate_forto_item_code(input_string, params):
-    """
-    Finds a match for the input string using fuzzy matching first, then embedding fallback.
+    return None
 
-    1. Tries to find a fuzzy match for input_string against the keys in
-       mapping_data using RapidFuzz, requiring a score >= fuzzy_threshold.
-    2. If found, returns the corresponding value from mapping_data.
-    3. If not found above threshold, calls the embedding_fallback function.
 
+async def associate_forto_item_code(line_item_data, params, partner_name=None):
+    """
+    Associates Forto item codes to a list of line item descriptions.
     Args:
-        input_string: The string to find a match for.
-        params: Parameters containing the lookup data and fuzzy threshold.
+        line_item_data (dict): A dictionary where keys are original descriptions and values are cleaned descriptions.
+        params (dict): Parameters containing lookup data and thresholds.
+        partner_name (str, optional): The name of the partner for context in matching. Defaults to None.
 
     Returns:
-        The matched value (from fuzzy match or embedding), or None if no match found.
+        list: A list of dictionaries with 'description' and 'itemCode' keys.
     """
-    # Get the Forto item code using fuzzy matching
-    forto_item_code = find_matching_lineitem(
-        new_lineitem=input_string,
-        kvp_dict=params["lookup_data"]["item_code"],  # TODO: Parse the KVP dictionary
-        threshold=params["fuzzy_threshold_item_code"],
+
+    result = []
+    pending_line_items = {}
+    for desc, f_desc in line_item_data.items():
+        # Get the Forto item code using fuzzy matching
+        code = find_matching_lineitem(
+            new_lineitem=f_desc,
+            kvp_dict=params["lookup_data"]["item_code"],
+            threshold=params["fuzzy_threshold_item_code"],
+        )
+        if code:
+            result.append({"description": desc, "itemCode": code})
+        else:
+            pending_line_items[desc] = f_desc
+
+    # Batch API Call for Embedding lookups
+    if pending_line_items:
+        code_map = await fetch_line_item_codes(pending_line_items, partner_name, params)
+
+        for desc, f_desc in pending_line_items.items():
+            result.append(
+                {
+                    "description": desc,
+                    "itemCode": code_map.get(f_desc),
+                }
+            )
+
+    return result
+
+
+async def fetch_line_item_codes(
+    pending_line_items: dict,
+    partner_name: str | None,
+    params: dict,
+):
+    """Returns: {original_description: mapped_code_or_None}"""
+    t_mode = (
+        find_matching_lineitem(
+            partner_name.upper(),
+            params["lookup_data"]["intermodal_partners"],
+            threshold=87,
+        )
+        if partner_name
+        else None
     )
 
-    if forto_item_code is None:
-        # 2. Fallback to embedding function if no good fuzzy match
-        forto_item_code = get_tms_mappings(input_string, "line_items")
+    unique_descs = list(set(pending_line_items.values()))
+    logger.info(f"Mapping {len(unique_descs)} line items from Embedding API...")
 
-    result = {"documentValue": input_string, "formattedValue": forto_item_code}
+    # Build API input map
+    api_input_map = {
+        desc: f"{t_mode} - {desc}" if t_mode else desc for desc in unique_descs
+    }
+
+    api_results = await get_tms_mappings(
+        input_list=list(api_input_map.values()),
+        embedding_type="line_items",
+    )
+
+    # Normalize response back to original descriptions
+    result = {
+        original_desc: api_results.get(api_desc)
+        for original_desc, api_desc in api_input_map.items()
+    }
     return result

src/prompts/library/arrivalNotice/other/placeholders.json

@@ -0,0 +1,70 @@
+{
+  "type": "OBJECT",
+  "properties": {
+      "bookingNumber": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The booking number associated with the Arrival Notice document. They are often referred to as 'Booking Number', 'Booking No.', 'Booking Ref.', 'Booking Reference', 'Booking ID', 'carrier's reference' or 'Order Ref'."
+      },
+      "destinationTerminal": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The terminal at the destination port where the container will be delivered."
+      },
+      "eta": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "Estimated Time of Arrival (ETA) is the expected date when the shipment will arrive at its destination."
+      },
+      "mblNumber": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "Bill of Lading number (B/L NO.), a document issued by the carrier."
+      },
+      "portOfDischarge": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The port where the goods are discharged from the vessel. This is the destination port for the shipment."
+      },
+      "vesselName": {
+        "type": "STRING",
+        "nullable": true,
+        "description": "The name of the vessel carrying the shipment."
+      },
+      "containers": {
+          "type": "ARRAY",
+          "items": {
+              "type": "OBJECT",
+              "properties": {
+                  "containerNumber": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The unique identifier for each container. It always starts with 4 capital letters and followed by 7 digits. Example: TEMU7972458."
+                  },
+                  "containerType": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The size of the container associated with the containerNumber, such as 20ft, 40ft, 40HC, 20DC etc."
+                  },
+                  "grossWeight": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The gross weight of the container. Usually mentioned as G.W or GW or Gross Weight, etc.."
+                  },
+                  "measurements": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The volume of the container. Usually, it is measured in 'Cubic Meter (cbm)' or dimensions. But volume in 'cbm' is preferred."
+                  },
+                  "sealNumber": {
+                    "type": "STRING",
+                    "nullable": true,
+                    "description": "The seal number associated with the container Number. But it is not same as the container number."
+                  }
+              },
+              "required": ["containerNumber", "containerType", "grossWeight"]
+          }
+      }
+},
+  "required": ["bookingNumber", "destinationTerminal", "eta", "portOfDischarge", "vesselName", "containers"]
+}

src/prompts/library/arrivalNotice/other/prompt.txt

@@ -0,0 +1,40 @@
+<PERSONA> You are an efficient document entity data extraction specialist working for a Freight Forwarding company. <PERSONA>
+
+<TASK> Your task is to extract data from Arrival Notice documents as per the given response schema structure. <TASK>
+
+<CONTEXT>
+The Freight Forwarding company receives Arrival Notice from shipping lines.
+These documents contain various details related to arrival of a shipment to the port of destination such as container numbers, estimated time of arrival, vessel details and containers information.
+They may be written in different languages such as English, German, Italian and can appear in a variety of formats and layouts.
+Your role is to accurately extract specific entities from these Arrival Notices to support efficient processing and accurate record-keeping.
+<CONTEXT>
+
+<INSTRUCTIONS>
+- Populate fields as defined in the response schema.
+- Multiple Containers entries may exist, capture all instances under "containers".
+- Use the data field description to understand the context of the data.
+
+- bookingNumbers:
+    - Booking numbers are unique identifiers for shipments. They are often referred to as "Booking Number", "Booking No.", "Booking Ref.", "Booking Reference", "Booking ID", "SACO-Pos.", "Order Ref", "Unsere Referenz", or "Unsere Position"
+    - If there is a unique_id that starts with "S" followed by 6 or 8 digits, it is a shipmentID, not a bookingNumber.
+
+- destinationTerminal:
+    - Destination Terminal can also be referred to as "Destination Termina;", "Pickup Location", "Delivery Location", "Delivery Terminal", "Empfangsort", "Entladeort", or "Abladestelle".
+
+- mblNumbers:
+    - Commonly known as "Bill of Lading Number", "BILL OF LADING NO.", "BL Number", "BL No.", "B/L No.", "BL-Nr.", "B/L", "HBL No.", or "M-AWB Nummer".
+    - Bill of Lading Number is known as mblNumber. Not a shipmentID even if it starts with "S".
+    - mblNumber from Hapag-Lloyd always starts with HLC.... (e.g., "HLCUTS12303AWNT3) and named as SEA WAYBILL or "SWB-NR.
+
+- eta:
+    - Estimated Time of Arrival (ETA) is the expected date and time when the shipment will arrive at the destination port.
+    - It can be referred to as "ETA", "Estimated Arrival", "Voraussichtliche Ankunft", "Ankunftszeit", "Arrivo", "Due to arrive at Terminal"
+
+- vesselName:
+    - Vessel Name is the name of the ship carrying the cargo. It can be referred to as "Vessel", "Ship Name", "Schiff", "Schiffsname", "Nave", or "Vessel/Flight No.".
+
+- containers: Details of each container on the arrival notice. Make sure to extract each container information separately.
+    - containerNumber: Container Number consists of 4 capital letters followed by 7 digits (e.g., TEMU7972458, CAIU 7222892).
+    - sealNumber: Seal numbers are unique identifiers for shipping seals. They are usually mentioned as seal numbers in the document but they are definitely not container numbers.
+
+<INSTRUCTIONS>

src/prompts/library/bundeskasse/other/placeholders.json

@@ -1,15 +1,15 @@
 {
   "type": "OBJECT",
   "properties": {
-      "currencyCode": {
+      "grandTotal": {
         "type": "STRING",
         "nullable": true,
-        "description": "The currency in which the invoice is issued."
+        "description": "The overall total amount of the invoice. It can be found with the key words Gesamtabgabenbetrag, Gesamtbetrag, or Zu erstattender Abgabenbetrag"
       },
-      "grandTotal": {
+      "currencyCode": {
         "type": "STRING",
         "nullable": true,
-        "description": "The overall total amount of the invoice."
+        "description": "The currency in which the invoice is issued. Extract the currency associated with the grand total (grandTotal) amount. It is majorly mentioned as EUR, Euro or €."
       },
       "issueDate": {
         "type": "STRING",
@@ -54,7 +54,7 @@
                   "deferredDutyPayer": {
                     "type": "STRING",
                     "nullable": true,
-                    "description": "It can be identified under \"Aufschubenhmer\" for each line item"
+                    "description": "It can be identified under 'Aufschubenhmer' for each line item"
                   },
                   "name": {
                     "type": "STRING",

src/prompts/library/bundeskasse/other/prompt.txt

@@ -1,6 +1,6 @@
 <PERSONA> You are an efficient document entity data extraction specialist working for a Freight Forwarding company. <PERSONA>
 
-<TASK>Your task is to extract data and page numbers starting from 0 from customs invoice documents as per the given response schema structure.<TASK>
+<TASK> Your task is to extract data from customs invoice documents as per the given response schema structure. <TASK>
 
 <CONTEXT>
 The Freight Forwarding company receives Customs invoices from Customs Brokers called Bundeskasse.
@@ -13,6 +13,7 @@ Your role is to accurately extract specific entities from these Customs invoices
 - Populate fields as defined in the response schema.
 - Multiple line item entries may exist, capture all instances under "lineItem".
 - Use the data field description to understand the context of the data.
+- The amount and the currency is always in EUR both for grandTotal and line items.
 
 - containerNumber:
     - Container Number consists of 4 capital letters followed by 7 digits (e.g., TEMU7972458, CAIU7222892).
@@ -31,15 +32,16 @@ Your role is to accurately extract specific entities from these Customs invoices
     - Credit Note Invoice Number is a unique identifier for the credit note, it starts with "ATS" only (e.g., ATS.....).
     - NIZZA is not a credit note invoice number.
 
-- grandTotal in the credit notes can be found under "Zu erstattender Abgabenbetrag".
+- grandTotal:
+    - It can be found with the key words Gesamtabgabenbetrag, Gesamtbetragin. In credit notes, it can be found under "Zu erstattender Abgabenbetrag".
+    - grandTotal value is always or mostly mentioned in EUR currency as it is issued by German Customs.
 
 - serviceDate can also be referred to as "Zollanmeldung" or "Eingangdatum" in the invoice.
 - issueDate can also be referred to as "Einfuhrabgabenbescheid" in the invoice. issueDate and serviceDate can be same in some cases.
 - vendor details can be "Hauptzollamt" details in the top portion of the invoice.
 
-- lineItem:
-    - Each line item should be extracted only once
-    - totalAmount in the Credit Note is the Differenzbetrag in the line items.
+- lineItem: Each line item should be extracted only once. Give priority to the first occurrence of the line item details in the document.
+    - totalAmount in the Credit Note is the Differenzbetrag in the line items. The totalAmount value is always or mostly mentioned in EUR currency.
     - deferredDutyPayer can be identified under "Aufschubenhmer" for each line item. It is a combination of number code and entity.
 
 You can usually find all the information in the top 2 pages of the invoice.

src/prompts/library/commercialInvoice/other/placeholders.json

@@ -0,0 +1,125 @@
+{
+  "type": "OBJECT",
+  "properties": {
+    "consignee": {
+      "type": "string",
+      "nullable": true,
+      "description": "The receiver or buyer of the goods."
+    },
+    "currency": {
+      "type": "string",
+      "nullable": true,
+      "description": "The currency of the totalAmount."
+    },
+    "grossWeight": {
+      "type": "string",
+      "nullable": true,
+      "description": "The total gross weight of all the goods. Usually mentioned as G.W or GW or Gross Weight, etc.."
+    },
+    "incoterm": {
+      "type": "string",
+      "nullable": true,
+      "description": "An Incoterm is a 3 letter standardized trade term defining the responsibilities of buyers and sellers in international shipping and logistics. For example, FOB, CFR, DAP, CIF, etc..."
+    },
+    "invoiceDate": {
+      "type": "string",
+      "nullable": true,
+      "description": "A date that the invoice was created or issued."
+    },
+    "invoiceNumber": {
+      "type": "string",
+      "nullable": true,
+      "description": "The invoice number of the commercial invoice document."
+    },
+    "measurement": {
+      "type": "string",
+      "nullable": true,
+      "description": "The volume of the goods. Usually, it is measured in \"Cubic Meter (cbm)\" or dimensions. But volume in \"cbm\" is preferred."
+    },
+    "netWeight": {
+      "type": "string",
+      "nullable": true,
+      "description": "The total net weight of all the goods. Usually, mentioned as N.W or NW or Net Weight, etc.."
+    },
+    "shipper": {
+      "type": "string",
+      "nullable": true,
+      "description": "The seller or shipper of the goods."
+    },
+    "totalAmount": {
+      "type": "string",
+      "nullable": true,
+      "description": "The total amount of all the goods mentioned in the invoice."
+    },
+    "skus": {
+      "type": "ARRAY",
+      "items": {
+        "type": "OBJECT",
+        "properties": {
+          "amount": {
+            "type": "string",
+            "nullable": true,
+            "description": "Amount of the goods."
+          },
+          "containerNumber": {
+            "type": "string",
+            "nullable": true,
+            "description": "Container Number consists of 4 capital letters followed by 7 digits. Example: TEMU7972458. Usually mentioned as Container Number, CONTAINER NO. Containers, or Container / Truck No"
+          },
+          "currency": {
+            "type": "string",
+            "nullable": true,
+            "description": "The currency of the Amount. Usually mentioned in USD, EURO, CNY, $, or any other currency units and symbols."
+          },
+          "goodsDescription": {
+            "type": "string",
+            "nullable": true,
+            "description": "Description of the goods."
+          },
+          "grossWeight": {
+            "type": "string",
+            "nullable": true,
+            "description": "The gross weight of an individual product/goods. Usually, mentioned as G.W or GW or Gross Weight, etc.."
+          },
+          "hsCode": {
+            "type": "string",
+            "nullable": true,
+            "description": "The harmonized system code of a goods."
+          },
+          "materialNumber": {
+            "type": "string",
+            "nullable": true,
+            "description": "Material number of the product or goods."
+          },
+          "netWeight": {
+            "type": "string",
+            "nullable": true,
+            "description": "The net weight of an individual product/goods. Usually, mentioned as N.W or NW or Net Weight, etc.."
+          },
+          "packagingQuantity": {
+                "type": "string",
+                "nullable": true,
+                "description": "The quantity of the goods. Usually, the quantity is in pallets, PLT, cartons, CTNS, pieces, PCS, packages, boxes, etc. Please prioritize the packaging types based on their size, as follows: Pallets (PLT) >> Cartons (CTNS) >> Pieces (PCS). Extract the Larger packaging types that will have a lower count."
+            },
+          "packageType": {
+            "type": "string",
+            "nullable": true,
+            "description": "The packaging type is the unit of packagingQuantity. Example; pallets, PLT, cartons, CTNS, pieces, PCS, packages, etc. Sometimes, the packaging type is available in the column name of the packagingQuantity."
+          },
+          "poNumber": {
+            "type": "string",
+            "nullable": true,
+            "description": "Purchase order of the goods."
+          },
+          "skuNumber": {
+            "type": "string",
+            "nullable": true,
+            "description": "SKU number of the goods."
+          }
+        },
+        "required": []
+      }
+    }
+  },
+  "required": []
+}

src/prompts/library/commercialInvoice/other/prompt.txt

@@ -2,7 +2,7 @@ Task: You are a document entity extraction specialist. Given a document, your ta
 
 Extract all the data points from the given document.
 Each data point is part of a master field called skus. There may be multiple skus entries in a document.
-Your task is to extract the text value of the entities and page numbers starting from 0 starting from 0 where the value was found in the document.
+Your task is to extract the text value of the entities and page numbers starting from 0 where the value was found in the document.
 
 
 Instructions: