Résultat Split

Documentation de référence sur le traitement d’un résultat Split à l’aide des SDK Mindee.

Vous devrez disposer d'un objet de réponse comme décrit dans la Traitement des réponses section.

Accéder aux plages de Split

Un SplitRange décrit un sous-document logique identifié dans le fichier source.

SplitRange Attributs

Chaque SplitRange instance aura ces propriétés.

Type de document

La catégorie de document attribuée au sous-document. Elle est toujours renseignée.

Elle est renvoyée sous forme de chaîne et est identique à la valeur saisie sur la plateforme Mindee — casse, espaces et ponctuation inclus.

Plage de pages

Un tableau de deux éléments de à base 0 indices de page, où le premier entier indique la page de début et le deuxième entier indique la page de fin. Elle est toujours renseignée.

Une valeur de plage de pages de (0,2) signifierait de la première page à la troisième page.

Réponse d'extraction

Réponse d'extraction optionnelle associée au SplitRange. Celle-ci n'est renseignée que si le chaînage d'extraction est activé pour le modèle.

Les résultats de l’extraction en chaîne seront dans un ExtractionResponse objet. Cet objet est identique à la réponse d’un modèle Extraction.

Reportez-vous à la Résultat de l’extraction section pour plus de détails sur le traitement de l’extraction.

Itérer sur les plages de Split

Vous voudrez généralement itérer sur toutes les plages de Split, car le nombre de plages dépend du document.

Exemple de code

Python

from mindee import SplitResponse

def handle_response(response: SplitResponse) -> None:
    splits = response.inference.result.splits

    for split in splits:
        # plage [start_page, end_page] à base 0
        page_range = split.page_range

        print(f"Type détecté : {split.document_type}")
        print(f"Sur les pages : {page_range[0]} - {page_range[1]}")

        # Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
        extraction_response = split.extraction_response

        if extraction_response is not None:
            # Accédez aux champs extraits à partir du résultat d'inférence du split
            fields = extraction_response.inference.result.fields
            print(f"Champs d'extraction : {fields}")

Node.js

handleResponse(response) {
  const splits = response.inference.result.splits;

  for (const split of splits) {
    // plage [startPage, endPage] à base 0
    const pageRange = split.pageRange;

    // Type de document identifié pour ce split
    const documentType = split.documentType;

    console.log(`Type détecté : ${documentType}`);
    console.log(`Sur les pages : ${pageRange[0]} - ${pageRange[1]}`);
    
    // Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
    const extractionResponse = split.extractionResponse;

    if (extractionResponse) {
      // Accédez aux champs extraits à partir du résultat d'inférence du split
      const fields = extractionResponse.inference.result.fields;
      console.log("Champs d'extraction :", fields.toString());
    }
  }
}

PHP

use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        // plage [startPage, endPage] à base 0
        $pageRange = $split->pageRange;

        // Type de document identifié pour ce split
        $documentType = $split->documentType;

        echo "Type détecté : $documentType\n";
        echo "Sur les pages : {$pageRange[0]} - {$pageRange[1]}\n";

        // Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
        $extractionResponse = $split->extractionResponse;

        if ($extractionResponse !== null) {
            // Accédez aux champs extraits à partir du résultat d'inférence du split
            $fields = $extractionResponse->inference->result->fields;
            echo "Champs d'extraction : " . $fields->toString() . "\n";
        }
    }
}

Ruby

def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    # plage [start_page, end_page] à base 0
    page_range = split.page_range

    # Type de document identifié pour ce split
    document_type = split.document_type

    puts "Type détecté : #{document_type}"
    puts "Sur les pages : #{page_range[0]} - #{page_range[1]}"

    # Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
    extraction_response = split.extraction_response

    if extraction_response
      # Accédez aux champs extraits à partir du résultat d'inférence du split
      fields = extraction_response.inference.result.fields
      puts "Champs d'extraction : #{fields}"
    end
  end

Java

import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(SplitResponse response) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    // plage [startPage, endPage] à base 0
    var pageRange = split.getPageRange();

    // Type de document identifié pour ce split
    String documentType = split.getDocumentType();

    System.out.println("Type détecté : " + documentType);
    System.out.println(
      "Sur les pages : " + pageRange.get(0) + " - " + pageRange.get(1)
    );

    // Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
    var extractionResponse = split.getExtractionResponse();

    if (extractionResponse != null) {
      // Accédez aux champs extraits à partir du résultat d'inférence du split
      var fields = extractionResponse.getInference().getResult().getFields();
      System.out.println("Champs d'extraction : " + fields.toString());
    }
  }
}

.NET

using System;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        // plage [startPage, endPage] à base 0
        var pageRange = split.PageRange;

        // Type de document identifié pour ce split
        string documentType = split.DocumentType;

        Console.WriteLine($"Type détecté : {documentType}");
        Console.WriteLine($"Sur les pages : {pageRange[0]} - {pageRange[1]}");

        // Réponse d'extraction optionnelle, présente si le chaînage d'extraction a été demandé
        var extractionResponse = split.ExtractionResponse;

        if (extractionResponse != null)
        {
            // Accédez aux champs extraits à partir du résultat d'inférence du split
            var fields = extractionResponse.Inference.Result.Fields;
            Console.WriteLine($"Champs d'extraction : {fields}");
        }
    }
}

Extraire les plages de Split à partir du fichier d'entrée

Les SDK proposent la prise en charge de l'extraction de chaque plage de Split sous forme de fichiers PDF distincts.

Python

from mindee import SplitResponse

def handle_response(response: SplitResponse, input_source) -> None:
    splits = response.inference.result.splits

    for split in splits:
      extracted_split = split.extract_from_input_source(input_source)

Node.js

async handleResponse(response, inputSource) {
  const splits = response.inference.result.splits;

  for (const split of splits) {
    const extractedSplit = await split.extractFromInputSource(inputSource);
  }
}

PHP

use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response, $inputSource)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        $extractedSplit = $split->extractFromInputSource($inputSource)
    }
}

Ruby

def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    extracted_split = split.extract_from_input_source(input_source)
  end

Java

import com.mindee.input.LocalInputSource;
import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(
  SplitResponse response,
  LocalInputSource inputSource
) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    var extractedSplit = split.extractFromInputSource(inputSource);
  }
}

.NET

using System;
using Mindee.Input;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response, LocalInputSource inputSource)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        var extractedSplit = split.ExtractFromInputSource(inputSource);
    }
}

Seules les méthodes documentées ici sont prêtes pour la production.

C'est parce que nous continuons à améliorer les SDK, patientez encore un peu !