Démarrage rapide de l’extraction

La manière la plus rapide de démarrer avec les bibliothèques clientes.

Instructions d'installation

Nécessite Python ≥ 3.9. Python ≥ 3.11 est recommandé.

Installez simplement le package PyPI avec pip:

pip install -U mindee~=5.1

Nécessite PHP ≥ 8.1. PHP ≥ 8.3 est recommandé.

Installez simplement le package Packagist avec composer:

php composer.phar require "mindee/mindee:>=3.0"

Vous ne voyez pas de prise en charge pour votre langage ou framework préféré ? Faites une demande de fonctionnalité !

Envoyer un fichier et interroger les résultats

Prenez note de l'ID de votre modèle pour l'utiliser dans l'API.

Lorsque vous débutez, nous vous recommandons d'utiliser la méthode d'interrogation, qui sera la plus rapide (à moins que vous n'ayez déjà accès à un serveur Web public).

Voici des exemples de code de base, ils sont autonomes et peuvent être exécutés tels quels :

Nécessite Python ≥ 3.10. Python ≥ 3.12 est recommandé. Nécessite le bibliothèque cliente Python Mindee version 5.1.1 ou supérieure.

from mindee import PathInput
from mindee.v2 import (
    Client,
    ExtractionParameters,
    ExtractionResponse,
)

input_path = "/path/to/the/file.ext"
api_key = "MY_API_KEY"
model_id = "MY_MODEL_ID"

# Initialiser un nouveau client
mindee_client = Client(api_key)

# Définir les paramètres Extraction
model_params = ExtractionParameters(
    # ID du modèle, requis.
    model_id=model_id,

    # Options : définissez `True` ou `False` pour remplacer les valeurs par défaut

    # Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag=None,
    # Extraire le contenu textuel complet du document sous forme de chaînes.
    raw_text=None,
    # Calculer les polygones des cadres englobants pour tous les champs.
    polygon=None,
    # Améliorer la précision et l'exactitude de toutes les extractions.
    # Calculer les scores de confiance pour tous les champs.
    confidence=None,
)

# Charger un fichier depuis le disque
input_source = PathInput(input_path)

# Envoyer pour traitement
response = mindee_client.enqueue_and_get_result(
    ExtractionResponse,
    input_source,
    model_params,
)

# Afficher un bref résumé des données analysées
print(response.inference)

# Accéder aux champs du résultat
fields: dict = response.inference.result.fields

Consultez également Résultat d'extraction documentation.

Nécessite Node.js ≥ 20.1. Node.js ≥ 22 est recommandé. Nécessite le bibliothèque cliente Node.js Mindee version 5.5.0 ou supérieure.

import * as mindee from "mindee";
// Si vous utilisez CommonJS :
// const mindee = require("mindee");

const apiKey = "MY_API_KEY";
const filePath = "/path/to/the/file.ext";
const modelId = "MY_MODEL_ID";

// Initialiser un nouveau client
const mindeeClient = new mindee.Client(
  { apiKey: apiKey }
);

// Définir les paramètres d'Extraction
const modelParams = {
  modelId: modelId,

  // Options : définissez sur `true` ou `false` pour remplacer les valeurs par défaut

  // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
  rag: undefined,
  // Extraire le contenu textuel complet du document sous forme de chaînes.
  rawText: undefined,
  // Calculer les polygones des boîtes englobantes pour tous les champs.
  polygon: undefined,
  // Améliorez la précision et l'exactitude de toutes les extractions.
  // Calculer les scores de confiance pour tous les champs.
  confidence: undefined,
};

// Charger un fichier depuis le disque
const inputSource = new mindee.PathInput({ inputPath: filePath });

// Envoyer pour traitement
const response = await mindeeClient.enqueueAndGetResult(
  mindee.product.Extraction,
  inputSource,
  modelParams,
);

// afficher un résumé sous forme de chaîne
console.log(response.inference.toString());

// Accéder aux champs du résultat
const fields = response.inference.result.fields;

Consultez également la Résultats de traitement documentation.

Nécessite PHP ≥ 8.1. PHP ≥ 8.3 est recommandé. Nécessite le Bibliothèque cliente PHP Mindee version 3.0.0 ou supérieure.

<?php

use Mindee\Input\PathInput;
use Mindee\V2\Client;
use Mindee\V2\Product\Extraction\Params\ExtractionParameters;
use Mindee\V2\Product\Extraction\ExtractionResponse;

$apiKey = "MY_API_KEY";
$modelId = "MY_MODEL_ID";
$filePath = "/path/to/the/file.ext";

// Initialiser un nouveau client
$mindeeClient = new Client($apiKey);

// Définir les paramètres d'Extraction
$modelParams = new ExtractionParameters(
    // ID du modèle, requis.
    $modelId,

    // Options : définissez `true` ou `false` pour remplacer les valeurs par défaut

    // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag: null,
    // Extrayez le contenu textuel complet du document sous forme de chaînes.
    rawText: null,
    // Calculez les polygones de boîte englobante pour tous les champs.
    polygon: null,
    // Améliorez la précision et l'exactitude de toutes les extractions.
    // Calculez les scores de confiance pour tous les champs.
    confidence: null
);

// Charger un fichier depuis le disque
$inputSource = new PathInput($filePath);

// Envoyer pour traitement à l’aide du polling
$response = $mindeeClient->enqueueAndGetResult(
    ExtractionResponse::class,
    $inputSource,
    $modelParams
);

// Afficher un résumé de la réponse
echo strval($response->inference);

// Accédez aux champs extraits
$fields = $response->inference->result->fields;

Consultez également les Résultats de traitement documentation.

Nécessite Ruby ≥ 3.2. Nécessite bibliothèque cliente Ruby de Mindee version 5.2.1 ou supérieure.

require 'mindee'
require 'mindee/v2/product'

input_path = '/path/to/the/file.ext'
api_key = 'MY_API_KEY'
model_id = 'MY_MODEL_ID'

# Initialisez un nouveau client
mindee_client = Mindee::V2::Client.new(api_key: api_key)

# Définissez les paramètres du modèle Extraction
model_params = {
    # ID du modèle, obligatoire.
    model_id: model_id,

    # Options : définissez sur `true` ou `false` pour remplacer les valeurs par défaut

    # Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    rag: nil,
    # Extrayez le contenu textuel complet du document sous forme de chaînes de caractères.
    raw_text: nil,
    # Calculez les polygones des boîtes englobantes pour tous les champs.
    polygon: nil,
    # Renforcez la précision et l'exactitude de toutes les extractions.
    # Calculez les scores de confiance pour tous les champs.
    confidence: nil
}

# Chargez un fichier depuis le disque
input_source = Mindee::Input::Source::PathInputSource.new(input_path)

# Envoyez pour traitement
response = mindee_client.enqueue_and_get_result(
    Mindee::V2::Product::Extraction::Extraction,
    input_source,
    model_params
)

# Affichez un bref résumé des données analysées
puts response.inference

# Accédez aux champs du résultat
fields = response.inference.result.fields

# fields.get_simple_field('my_simple_field')
# fields.get_list_field('my_list_field')
# fields.get_object_field('my_object_field')

Consultez également les Résultats de traitement documentation.

Nécessite Java ≥ 11. Java ≥ 21 est recommandé. Nécessite le SDK Java Mindee version 5.2.0 ou supérieure.

import com.mindee.input.LocalInputSource;
import com.mindee.v2.MindeeClient;
import com.mindee.v2.product.extraction.params.ExtractionParameters;
import com.mindee.v2.product.extraction.ExtractionResponse;
import java.io.IOException;

public class SimpleMindeeClientV2 {

  public static void main(String[] args)
      throws IOException, InterruptedException
  {
    String apiKey = "MY_API_KEY";
    String modelId = "MY_MODEL_ID";
    String filePath = "/path/to/the/file.ext";

    // Initialisez un nouveau client
    var mindeeClient = new MindeeClient(apiKey);

    // Définissez les paramètres d’Extraction
    var modelParams = ExtractionParameters
        // ID du modèle, requis.
        .builder(modelId)

        // Options : définissez à `true` ou `false` pour remplacer les valeurs par défaut

        // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
        .rag(null)
        // Extrayez le contenu textuel complet du document sous forme de chaînes.
        .rawText(null)
        // Calculez les polygones de boîte englobante pour tous les champs.
        .polygon(null)
        // Améliorez la précision et l’exactitude de toutes les extractions.
        // Calculez les scores de confiance pour tous les champs.
        .confidence(null)

        .build();

    // Chargez un fichier depuis le disque
    var inputSource = new LocalInputSource(filePath);

    // Envoyez pour traitement en mode polling
    ExtractionResponse response = mindeeClient.enqueueAndGetResult(
        ExtractionResponse.class,
        inputSource,
        modelParams
    );

    // Affichez un résumé de la réponse
    System.out.println(response.getInference().toString());

    // Accédez aux champs du résultat
    var fields = response.getInference().getResult().getFields();
  }
}

Consultez également la Résultats du traitement documentation.

.NET ≥ 8.0 est recommandé. Nécessite le Bibliothèque cliente .NET Mindee version 4.3.0 ou supérieure.

using Mindee;
using Mindee.Input;
using Mindee.V2;
using Mindee.V2.Product.Extraction;
using Mindee.V2.Product.Extraction.Params;

string filePath = "/path/to/the/file.ext";
string apiKey = "MY_API_KEY";
string modelId = "MY_MODEL_ID";

// Créez un nouveau client
Client mindeeClient = new Client(apiKey);

// Définir les paramètres d'Extraction
var modelParams = new ExtractionParameters(
    modelId: modelId

    // Options : définissez `true` ou `false` pour remplacer les valeurs par défaut

    // Améliorez la précision de l'extraction grâce à la génération augmentée par récupération.
    , rag: null
    // Extrayez le contenu textuel complet du document sous forme de chaînes.
    , rawText: null
    // Calculez les polygones de boîte englobante pour tous les champs.
    , polygon: null
    // Améliorez la précision et l'exactitude de toutes les extractions.
    // Calculez les scores de confiance pour tous les champs.
    , confidence: null
);

// Charger un fichier depuis le disque
var inputSource = new LocalInputSource(filePath);

// Téléversez le fichier
var response = await mindeeClient.EnqueueAndGetResultAsync<ExtractionResponse>(
    inputSource, modelParams);

// Afficher un résumé de la réponse
System.Console.WriteLine(response.Inference.ToString());

// Accéder aux champs extraits
var fields = response.Inference.Result.Fields;

Consultez également les Résultats de traitement documentation.

Détails sur l'envoi

Pour plus de détails sur les options disponibles et l'utilisation avancée, consultez les sections suivantes :

Traiter les résultats d'extraction

Une fois que vous avez envoyé le fichier et récupéré la réponse, vous pouvez commencer à accéder aux résultats.

Les champs du modèle d'extraction se trouveront dans le attribut fields objet dans la valeur renvoyée (la response variable renvoyée à l'étape ci-dessus).

Chaque clé dans le attribut fields objet correspond au champ nom dans votre Schéma de données.

Vous devrez adapter votre traitement en fonction du type de champ, par exemple lors de l'itération sur des listes ou de l'accès à des sous-champs.

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Vous pouvez (et devriez !) préciser le type de valeur ; les types possibles sont str , bool , float . Notez que tous les types peuvent être None.

from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
  fields = response.inference.result.fields

  # textes, dates, classifications ...
  string_field_value: str | None = fields.get_simple_field("string_field").value

  # un float JSON sera un float
  float_field_value: float | None = fields.get_simple_field("float_field").value

  # même si l’API renvoie toujours un entier, le type sera float
  int_field_value: float | None = fields.get_simple_field("int_field").value

  # booléens
  bool_field_value: bool | None = fields.get_simple_field("bool_field").value

Accéder à une liste de valeurs simples, où my_list_field est le nom du champ dans le modèle.

from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    simple_list_field = fields.get_list_field("my_simple_list_field")

    # Parcourir la liste des champs Simple
    for list_item in simple_list_field.items:
        item_value = list_item.value

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    object_field = fields.get_object_field("my_object_field")

    sub_fields: dict = object_field.fields

    # récupérer un seul sous-champ
    subfield_1 = sub_fields["subfield_1"]

    # parcourir les sous-champs
    for field_name, sub_field in sub_fields.items():
        sub_field.value

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

from mindee.v2 import ExtractionResponse

def handle_response(response: ExtractionResponse):
    fields = response.inference.result.fields

    object_list_field = fields.get_list_field("my_object_list_field")

    # Parcourez la liste des champs d'objet
    for object_item in object_list_field.items:
        # récupérez un seul sous-champ
        sub_field_value = object_item.fields["sub_field"].value
        
        # parcourez les sous-champs
        for field_name, sub_field in object_item.fields.items():
            sub_field.value

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que SimpleField instances lors de la récupération de leur valeur.

handleResponse(response) {
  const fields = response.inference.result.fields;
  
  // textes, dates, classifications ...
  const stringFieldValue = fields.getSimpleField("string_field").stringValue;
  
  // aucune distinction entre les nombres à virgule flottante et les entiers
  const floatFieldValue = fields.getSimpleField("float_field").numberValue;
  const intFieldValue = fields.getSimpleField("int_field").numberValue;
  
  // booléens
  const boolFieldValue = fields.getSimpleField("bool_field").booleanValue;
}

Accéder à une liste de valeurs, où my_simple_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses éléments.

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

  const simpleListField = fields.getListField("my_simple_list_field");

  const simpleItems = simpleListField.simpleItems;

  // Parcourez la liste des champs Simple
  for (const itemField of simpleItems) {
    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const fieldValue = itemField.stringValue;
  }
}

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

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

  const objectField = fields.getObjectField("my_object_field");

  const simpleSubFields = objectField.simpleFields;

  // récupérer un seul sous-champ
  const subfield1 = subFields.get("subfield_1");

  // boucle sur les sous-champs simples
  subFields.forEach((simpleSubFields, fieldName) => {
    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const fieldValue = subField.stringValue;
  });

  // Les champs d’objet peuvent aussi avoir des listes :
  const listSubFields = objectField.listFields;
}

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses éléments.

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

  const fieldObjectList = fields.getListField("my_object_list_field");

  const objectItems = fieldSimpleList.objectItems;

  // Parcourir la liste des champs Object
  for (const itemField of objectItems) {
    const simpleSubFields = itemField.simpleFields;

    // récupérer un seul sous-champ
    const subField1 = subFields.get("subfield_1");

    // Choisissez l'accès approprié :
    // stringValue, numberValue, booleanValue
    const subFieldValue = subField1.stringValue;

    // boucle sur les sous-champs simples
    simpleSubFields.forEach((subField, fieldName) => {
      // Choisissez l'accès approprié :
      // stringValue, numberValue, booleanValue
      const fieldValue = subField.stringValue;
    });

    // Les champs d’objet peuvent aussi avoir des listes :
    const listSubFields = itemField.listFields;
  }
}

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que SimpleField instances lors de la récupération de leur valeur.

use Mindee\V2\Product\Extraction\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;

    // textes, dates, classifications ...
    $stringFieldValue = $fields->getSimpleField('string_field')->value;

    // un float JSON sera un float
    $floatFieldValue = $fields->getSimpleField('float_field')->value;

    // même si l'API renvoie toujours un entier, le type sera float
    $intFieldValue = $fields->getSimpleField('int_field')->value;

    // booléens
    $boolFieldValue = $fields->getSimpleField('bool_field')->value;
}

Accéder à une liste de valeurs, où my_simple_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses éléments.

use Mindee\V2\Product\Extraction\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;

    $simpleListField = $fields->getListField('my_simple_list_field');

    // accéder à une valeur à une position donnée
    $fieldFirstValue = $simpleListField->items[0]->value;

    // Parcourir la liste des champs Simple
    foreach ($simpleListField->items as $listItem) {
        $itemValue = $listItem->value;
    }
}

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

use Mindee\V2\Product\Extraction\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;

    $objectField = $fields->getObjectField('my_object_field');
    $subFields = $objectField->fields;

    // récupérer un seul sous-champ
    $subfield1 = $subFields->getSimpleField('subfield_1');

    // parcourir les sous-champs
    foreach ($subFields as $fieldName => $subField) {
        $fieldValue = $subField->value;
    }
}

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses éléments.

use Mindee\\V2\\Product\\Extraction\\ExtractionResponse;

public function handleResponse(ExtractionResponse $response)
{
    $fields = $response->inference->result->fields;
    $fieldObjectList = $fields->getObjectField('my_object_list_field');

    // accéder à un objet à une position donnée
    $objectItem0 = $fieldObjectList->items[0];
    $subField0Value = $objectItem0->fields->get('sub_field')->value;

    // Parcourez la liste des champs Object
    foreach ($myObjectListField->items as $objectItem) {
        $subFieldValue = $objectItem->fields->get('sub_field')->value;
    }
}

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que SimpleField instances lors de la récupération de leur valeur.

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

  # textes, dates, classifications ...
  string_field_value = fields.get_simple_field('string_field').string_value

  # un float JSON sera un float
  float_field_value = fields.get_simple_field('float_field').float_value

  # même si l'API renvoie toujours un entier, le type sera float
  int_field_value = fields.get_simple_field('int_field').float_value

  # booléens
  bool_field_value = fields.get_simple_field('bool_field').boolean_value
end

Accéder à une liste de valeurs, où my_simple_list_field est le nom du champ dans le modèle.

Accédez à la liste en tant que ListField instance, et les éléments en tant que SimpleField instances.

def handle_response(response)
  fields = response.inference.result.fields
  
  my_list_field = fields.get_list_field('my_simple_list_field')

  # accéder à une valeur à une position donnée
  simple_list_field = my_list_field.simple_items[0].value

  # Parcourir la liste des champs Simple
  simple_list_field.simple_items.each do |list_item|
    item_value = list_item.value
  end
end

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

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

  object_field = fields.get_object_field('my_object_field')
  sub_fields = object_field.fields
  
  # récupérer un seul sous-champ
  sub_field_value = sub_fields.get_simple_field('sub_field').value
  
  # parcourir les sous-champs
  sub_fields.each_value do |sub_field|
    field_value = sub_field.value
  end
end

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

Accédez à la liste en tant que ListField instance, et les éléments en tant que ObjectField instances.

def handle_response(response)
  fields = response.inference.result.fields
  
  object_list_field = fields.get_list_field('my_object_list_field')

  # accéder à un objet à une position donnée
  object_item_0 = object_list_field.items[0]
  sub_field_0_value = object_item_0.fields.get('sub_field').value

  # Parcourir la liste des champs de l'objet
  object_list_field.fields.each do |object_item|
    sub_field_value = object_item.fields.get('sub_field').value
  end
end

Vous pouvez techniquement accéder à tous les types de champs par leur indice : fields['field_name']

Ceci est fortement déconseillé et non pris en charge.

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que SimpleField instances lors de la récupération de leur valeur.

Nous devons également préciser le type de valeur ; les types possibles sont String , Booléen , Double . Notez que tous les types peuvent être null.

import com.mindee.v2.product.extraction.ExtractionResponse;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  // textes, dates, classifications ...
  String stringFieldValue = fields.getSimpleField("string_field")
        .getStringValue();

  // un flottant JSON sera un Double
  Double floatFieldValue = fields.getSimpleField("float_field")
      .getDoubleValue();

  // même si l'API renvoie toujours un entier, le type sera Double
  Double intFieldValue = fields.getSimpleField("int_field")
      .getDoubleValue();

  // booléens
  Boolean boolFieldValue = fields.getSimpleField("bool_field")
      .getBooleanValue();
}

Accéder à une liste de valeurs simples, où my_simple_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses SimpleItems.

Pour chaque élément de la liste, nous devons également préciser le champ et le type de valeur corrects, comme décrit ci-dessus.

import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ListField simpleListField = fields.getListField("my_simple_list_field");

  List<SimpleField> simpleItems = simpleListField.getSimpleItems();

  // Parcourir la liste des champs Simple
  for (SimpleField itemField : simpleItems) {
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String fieldValue = itemField.getStringValue();
  }
}

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.ObjectField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ObjectField objectField = fields.getObjectField("my_object_field");

  HashMap<String, SimpleField> subFields = objectField.getSimpleFields();

  // récupérer un seul sous-champ
  SimpleField subfield1 = subFields.get("subfield_1");

  // parcourir les sous-champs
  for (Map.Entry<String, SimpleField> entry : subFields.entrySet()) {
    String fieldName = entry.getKey();
    SimpleField subField = entry.getValue();
    
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String fieldValue = subField.getStringValue();
  }
}

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

import com.mindee.v2.product.extraction.ExtractionResponse;
import com.mindee.parsing.v2.field.ListField;
import com.mindee.parsing.v2.field.ObjectField;
import com.mindee.parsing.v2.field.SimpleField;

public void handleResponse(ExtractionResponseresponse) {
  var fields = response.getInference().getResult().getFields();

  ListField fieldObjectList = fields.getListField("my_object_list_field");

  List<ObjectField> objectItems = listField.getObjectItems();

  // Parcourez la liste des champs Object
  for (ObjectField itemField : objectItems) {

    // Les sous-champs Object seront toujours des champs Simple
    HashMap<String, SimpleField> subFields = itemField.getSimpleFields();

    // récupérer un seul sous-champ
    SimpleField subfield1 = subFields.get("subfield_1");
    
    // Choisissez la méthode d'accès au type de valeur appropriée :
    // String, Double, Boolean
    String subFieldValue = subfield1.getStringValue();

    // parcourir les sous-champs
    for (Map.Entry<String, SimpleField> entry : subFields.entrySet()) {
      String fieldName = entry.getKey();
      SimpleField subField = entry.getValue();
    }
  }
}

Selon vos besoins, cela peut être simplifié à l'aide de diverses méthodes personnalisées.

Accéder à des valeurs simples, en utilisant le nom du champ dans le Schéma de données.

Accédez aux champs en tant que SimpleField instances lors de la récupération de leur valeur.

Nous devons également préciser le type de valeur ; les types possibles sont string , Booléen , Double . Notez que tous les types peuvent être null.

using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    // textes, dates, classifications ...
    string stringFieldValue = fields["string_field"].SimpleField.Value;

    // un float JSON sera un Double
    Double floatFieldValue = fields["float_field"].SimpleField.Value;

    // même si l'API renvoie toujours un entier, le type sera Double
    Double intFieldValue = fields["int_field"].SimpleField.Value;

    // booléens
    Boolean boolFieldValue = fields["bool_field"].SimpleField.Value;
}

Accéder à une liste de valeurs simples, où my_list_field est le nom du champ dans le modèle.

Nous devons préciser que le champ est un ListField afin d'accéder à ses SimpleItems.

using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ListField simpleListField = fields["my_simple_list_field"].ListField;

    List<SimpleField> simpleItems = simpleListField.SimpleItems;

    // Parcourez la liste des champs Simple
    foreach (SimpleField itemField in simpleItems)
    {
        // Choisissez le type de valeur approprié :
        // string, Double, Boolean
        string fieldValue = itemField.Value;
    }
}

Accéder à un champ objet et à ses sous-champs, où my_object_field est le nom du champ dans le modèle. Dans ce cas hypothétique, l'objet a un sous-champ nommé subfield_1 .

using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ObjectField objectField = fields["my_object_field"].ObjectField;

    Dictionary<string, SimpleField> subFields = objectField.SimpleFields;

    // récupérer un seul sous-champ
    SimpleField subField1 = subFields["subfield_1"];

    // parcourir les sous-champs
    // Remarque : en C#14, 'field' est un mot-clé réservé, d'où l'utilisation de 'entry'.
    foreach (KeyValuePair<string, SimpleField> entry in subFields)
    {
        string fieldName = entry.Key;
        SimpleField subField = entry.Value;
        
        // traiter le SimpleField ...
    }
}

Accéder à une liste d'objets, où my_object_list_field est le nom du champ dans le modèle.

using Mindee.V2.Parsing.Inference.Field;

public void HandleResponse(ExtractionResponse response)
{
    InferenceFields fields = response.Inference.Result.Fields;

    ListField fieldObjectList = fields["my_simple_list_field"].ListField;

    List<ObjectField> objectItems = fieldObjectList.ObjectItems;

    // Parcourir la liste des champs Object
    foreach (ObjectField itemField in objectItems)
    {
        Dictionary<string, SimpleField> subFields = objectField.SimpleFields;
    
        // récupérer un seul sous-champ
        SimpleField subField1 = subFields["subfield_1"];
        
        // Choisissez le type de valeur approprié :
        // string, Double, Boolean
        string subFieldValue = subField1.Value;
    
        // parcourir les sous-champs
        // Remarque : en C#14, 'field' est un mot-clé réservé, d'où l'utilisation de 'entry'.
        foreach (KeyValuePair<string, SimpleField> entry in subFields)
        {
            string fieldName = entry.Key;
            SimpleField subField = entry.Value;
        }
    }
}

Détails sur le traitement de la réponse

Pour plus de détails sur l'utilisation des champs de résultat dans votre application : Résultat d’extraction

Pour plus de détails sur les métadonnées de réponse : Traitement des réponses

PrécédentIntégration SDK SuivantConfiguration de l’extraction

Mis à jour il y a 2 mois

Ce contenu vous a-t-il été utile ?