Envoyer un fichier ou une URL

Documentation de référence sur l’envoi de fichiers ou d’URL à traiter à l’aide des bibliothèques clientes Mindee.

Il s'agit d'une documentation de référence.

Les exemples de code affichés sont uniquement des exemples et ne fonctionneront pas tels quels. Vous devrez les copier-coller et les modifier selon vos besoins.

Vous cherchez des exemples de code complets ?

Vous pouvez également utiliser le bouton « Demander » en haut de n'importe quelle page de la documentation.

Prérequis

Vous devrez configurer correctement votre client Mindee comme décrit dans la Configuration du client section.

Vous pouvez envoyer soit un fichier local soit une URL aux serveurs Mindee pour traitement.

Il n'y a aucune différence entre l'envoi d'un fichier ou d'une URL ; les deux sont considérés comme des sources d'entrée valides.

Utilisation d'un fichier local

Vous devrez disposer d'une source d'entrée locale comme décrit dans la Charger et ajuster un fichier section.

Un fichier local peut être manipulé et ajusté avant l'envoi, comme décrit dans la Charger et ajuster un fichier section.

Utilisation d'une URL

Vous devrez disposer d'une source d'entrée URL comme décrit dans la Charger une URL section.

Le contenu d'une URL ne peut pas être manipulé localement. Vous devrez le télécharger sur la machine locale si vous souhaitez modifier le fichier d'une quelconque manière avant l'envoi.

Envoi avec interrogation

Envoyez un document en utilisant l'interrogation, c'est la manière la plus simple pour commencer.

La bibliothèque cliente enverra la requête en POST pour vous, puis interrogera automatiquement l'API.

Configuration de l'interrogation

N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent ExtractionParameters.

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le model_id .

model_params = ExtractionParameters(model_id="MY_MODEL_ID")

Vous pouvez également définir les différents paramètres d'interrogation. Cependant, nous ne recommandons pas de définir cette option sauf si vous rencontrez des problèmes de délai d'attente.

from mindee import PollingOptions

# À utiliser uniquement en cas de problèmes de délai d'attente.
polling_options=PollingOptions(
    # Délai initial avant la première tentative d'interrogation.
    initial_delay_sec=3,
    # Délai entre chaque tentative d'interrogation.
    delay_sec=1.5,
    # Nombre total de tentatives d'interrogation.
    max_retries=80,
)

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le modelId .

const modelParams = {modelId: "MY_MODEL_ID"};

// Facultatif, à définir uniquement en cas de problèmes de délai d'attente.
const pollingOptions = {
  // Délai initial avant la première tentative d'interrogation.
  initialDelaySec: 3.0,
  // Délai entre chaque tentative d'interrogation.
  delaySec: 1.5,
  // Nombre total de tentatives d'interrogation.
  maxRetries: 80,
}

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le modelId .

$modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID");

use Mindee\ClientOptions\PollingOptions;

// À définir uniquement en cas de problèmes de délai d'attente.
$pollingOptions = new PollingOptions(
    // Délai initial avant la première tentative d'interrogation.
    initialDelaySec: 3.0,
    // Délai entre chaque tentative d'interrogation.
    delaySec: 1.5,
    // Nombre total de tentatives d'interrogation.
    maxRetries: 80,
);

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le model_id .

model_params = { model_id: "MY_MODEL_ID" }

# À définir uniquement en cas de problèmes de délai d'attente.
polling_options = {
  # Délai initial avant la première tentative d'interrogation.
  initial_delay_sec: 3,
  # Délai entre chaque tentative d'interrogation.
  delay_sec: 1.5,
  # Nombre total de tentatives d'interrogation.
  max_retries: 80,
}

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le modelId .

var modelParams = ExtractionParameters
        .builder("MY_MODEL_ID")
        .build();

import com.mindee.v2.clientoptions.PollingOptions;

var pollingOptions = PollingOptions
    .builder()
    // Délai initial avant la première tentative d'interrogation.
    .initialDelaySec(3.0)
    // Délai entre chaque tentative d'interrogation.
    .intervalSec(1.5)
    // Nombre total de tentatives d'interrogation.
    .maxRetries(80)
    // complétez le générateur d'interrogation
    .build();

Lors de l'utilisation de l'interrogation, vous n'avez vraiment besoin de définir que le modelId.

var modelParams = new ExtractionParameters(modelId: "MY_MODEL_ID");

using Mindee.V2.ClientOptions;

var pollingOptions = new PollingOptions(
    // Délai initial avant la première tentative d'interrogation.
    initialDelaySec: 3.5,
    // Délai entre chaque tentative d'interrogation.
    intervalSec: 1.5,
    // Nombre total de tentatives d'interrogation.
    maxRetries: 80
);

Appel de la méthode d'interrogation

Vous aurez besoin d’une source valide source d’entrée, parmi les suivantes :

une source locale créée dans Charger et ajuster un fichier
une source distante créée dans Charger une URL

Le mindee_client, créé dans Configuration du client.

Utilisez la enqueue_and_get_result méthode.

response = mindee_client.enqueue_and_get_result(
    InferenceResponse,
    input_source,
    model_params,
)

# Pour tester facilement quelles données ont été extraites,
# affichez simplement une représentation RST de l'inférence
print(response.inference)

Le mindeeClient, créé dans Configuration du client.

Utilisez la enqueueAndGetResult méthode. N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent Extraction.

const response = mindeeClient.enqueueAndGetResult(
  // Utilisez la classe produit appropriée
  mindee.product.Extraction,
  inputSource,
  modelParams,
  // facultatif, à définir uniquement en cas de problèmes de délai d'attente.
  // pollingOptions,
);

// Gérez la Promise de réponse
response.then((resp) => {
  // Pour tester facilement quelles données ont été extraites,
  // affichez simplement une représentation RST de l'inférence
  console.log(resp.inference.toString());
});

Le $mindeeClient , créé dans Configuration du client.

Utilisez la enqueueAndGetResult méthode. N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent ExtractionResponse.

$response = $mindeeClient->enqueueAndGetResult(
    // Utilisez la classe produit appropriée
    ExtractionResponse::class,
    $inputSource,
    $modelParams,
    // facultatif, à définir uniquement en cas de problèmes de délai d'attente.
    // $pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
echo strval($response->inference);

Le mindee_client, créé dans Configuration du client.

Utilisez la enqueue_and_get_result méthode. N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent Extraction.

response = mindee_client.enqueue_and_get_result(
  # Utilisez la classe produit appropriée
  Mindee::V2::Product::Extraction::Extraction,
  input_source,
  model_params,
  # facultatif, à définir uniquement en cas de problèmes de délai d'attente.
  # polling_options,
)

# Pour tester facilement quelles données ont été extraites,
# affichez simplement une représentation RST de l'inférence
puts response.inference

Le mindeeClient, créé dans Configuration du client.

Utilisez la enqueueAndGetResult méthode. N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent ExtractionResponse.

var response = mindeeClient.enqueueAndGetResult(
    // Utilisez la classe produit appropriée
    ExtractionResponse.class,
    inputSource,
    modelParams
    // facultatif, à définir uniquement en cas de problèmes de délai d'attente.
    // pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
System.out.println(response.getInference().toString());

Le mindeeClient, créé dans Configuration du client.

Utilisez la EnqueueAndGetResultAsync méthode. N'oubliez pas d'utiliser la classe produit/modèle appropriée ; les exemples utilisent ExtractionResponse.

var response = await mindeeClient.EnqueueAndGetResultAsync<ExtractionResponse>(
    inputSource
    , modelParams
    // facultatif, à définir uniquement en cas de problèmes de délai d'attente.
    //, pollingOptions
);

// Pour tester facilement quelles données ont été extraites,
// affichez simplement une représentation RST de l'inférence
System.Console.WriteLine(response.Inference.ToString());

Envoi avec webhook

Envoyez un document en utilisant webhooks, c'est recommandé pour une utilisation en production, en particulier pour les volumes élevés.

Vous aurez besoin d’une source valide source d’entrée, parmi les suivantes :

une source locale créée dans Charger et ajuster un fichier
une source distante créée dans Charger une URL

Configuration du webhook

La bibliothèque cliente enverra la requête en POST à votre serveur web, comme configuré par votre point de terminaison de webhook.

Pour plus d'informations sur les webhooks, consultez la Utilisation des webhooks page.

Lors de l'utilisation d'un webhook, vous devrez définir l'ID de modèle et les ID de webhook à utiliser.

N'oubliez pas d'utiliser la classe Produit/Modèle appropriée ; les exemples utilisent ExtractionParameters.

model_params = ExtractionParameters(
    # ID du modèle, obligatoire.
    model_id="MY_MODEL_ID",
    
    # Ajoutez ici autant d'ID de webhook que nécessaire.
    webhook_ids=["ENDPOINT_1_UUID"],
    
    # ... toute autre option ...
)

const modelParams = {
  // ID du modèle, obligatoire.
  modelId: "MY_MODEL_ID",

  // Ajoutez ici autant d'ID de webhook que nécessaire.
  webhookIds: ["ENDPOINT_1_UUID"],

  // ... toute autre option ...
};

$modelParams = new ExtractionParameters(
    // ID du modèle, obligatoire.
    modelId: "MY_MODEL_ID",
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    // Remarque : PHP 8.1 n'autorise le passage que d'un seul ID.
    webhooksIds: array("ENDPOINT_1_UUID"),

    // ... toute autre option ...
);

model_params = {
  # ID du modèle, obligatoire.
  model_id: 'MY_MODEL_ID',

  # Ajoutez ici autant d'ID de webhook que nécessaire.
  webhook_ids: ["ENDPOINT_1_UUID"],

  # ... toute autre option ...
}

var modelParams = ExtractionParameters
    // ID du modèle, obligatoire.
    .builder("MY_MODEL_ID")
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    .webhookIds(new String[]{"ENDPOINT_1_UUID"})
    
    // ... toute autre option ...
    
    .build();

var modelParams = new ExtractionParameters(
    // ID du modèle, obligatoire.
    modelId: "MY_MODEL_ID"
    
    // Ajoutez ici autant d'ID de webhook que nécessaire.
    , webhookIds: new List<string>{ "ENDPOINT_1_UUID" }
    
    // ... toute autre option ...
);

Appel de la méthode webhook

Vous pouvez spécifier autant d'ID de point de terminaison de webhook que nécessaire ; chacun recevra la charge utile.

En utilisant la mindee_client, créé dans Configuration du client.

Utilisez la enqueue_inference méthode :

response = mindee_client.enqueue(
    input_source, model_params
)

# Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
print(response.job.id)

# Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
print(response.job.alias)

Remarque : Vous pouvez utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' InferenceParameters instance. Puis, appelez enqueue_and_get_result . Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

En utilisant la mindeeClient, créé dans Configuration du client.

Utilisez la enqueue méthode :

const response = await mindeeClient.enqueue(
  mindee.product.Extraction,
  inputSource,
  modelParams
);

// Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
console.log(response.job.id);

// Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
console.log(response.job.alias);

Remarque : Vous pouvez utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' modelParams objet. Puis, appelez enqueueAndGetResult et await la promesse. Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

En utilisant la $mindeeClient, créé dans Configuration du client.

Utilisez la enqueueInference méthode :

$response = $mindeeClient->enqueue(
    $inputSource,
    $modelParams
);

// Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
echo strval($response->job->id);

// Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
echo strval($response->job->alias);

Remarque : Vous pouvez également utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' ExtractionParameters instance. Puis, appelez enqueueAndGetResult. Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

En utilisant la mindee_client, créé dans Configuration du client.

Utilisez la enqueue méthode :

response = mindee_client.enqueue(
    Mindee::V2::Product::Extraction::Extraction,
    input_source,
    model_params,
)

# Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
puts response.job.id

# Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
puts response.job.alias

Remarque : Vous pouvez utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' inference_params hachage. Puis, appelez enqueue_and_get_result . Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

En utilisant la mindeeClient, créé dans Configuration du client.

Utilisez la enqueueInference méthode :

JobResponse response = mindeeClient.enqueue(
    inputSource, modelParams
);

// Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
System.out.println(response.getJob().getId());

// Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
System.out.println(response.getJob().getAlias());

Remarque : Vous pouvez utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' InferenceParameters instance. Puis, appelez enqueueAndGetInference et gérez la promesse. Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

En utilisant la mindeeClient, créé dans Configuration du client.

Utilisez EnqueueInferenceAsync méthode :

var response = mindeeClient.EnqueueAsync(
    inputSource, modelParams
);

// Vous devriez enregistrer l'ID de tâche pour vos archives/débogage
System.Console.WriteLine(response.Job.Id);

// Si vous définissez un `alias`, vous pouvez vérifier qu'il a été pris en compte
System.Console.WriteLine(response.Job.Alias);

Remarque : Vous pouvez également utiliser les deux méthodes !

Commencez par vous assurer d'avoir ajouté un ID de webhook à l' InferenceParameters instance. Puis, appelez EnqueueAndGetResultAsync. Vous obtiendrez la réponse via interrogation et des webhooks seront également envoyés.

Obtenir l'état de traitement

L'accès aux informations de traitement se fait à l'aide de l' Job objet et des appels de méthode associés.

Si vous utilisez des webhooks, nous vous recommandons vivement d'enregistrer l'ID de la tâche afin de pouvoir récupérer ces informations à des fins de débogage.

Vous pouvez accéder à :

à l'URL du résultat
à l'état global du traitement
aux erreurs détaillées, le cas échéant
au statut de chaque webhook envoyé
aux heures de création et de fin
etc.

# depuis la méthode `enqueue` (généralement pour webhook)
job_id = response.job.id

# depuis la méthode `enqueue_and_get_result` (généralement pour interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

# quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
print(job_response.job.status)
print(job_response.job.created_at)
print(job_response.job.completed_at)

# vérifiez les webhooks
for webhook in job_response.job.webhooks:
    print(f"{webhook.id} status: {webhook.status}")

// depuis la méthode `enqueue` (généralement pour webhook)
const jobId = response.job.id;

// depuis la méthode `enqueueAndGetResult` (généralement pour interrogation)
//const jobId = response.inference.job.id;

const jobResponse = await mindeeClient.getJob(jobId);

// quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
console.log(jobResponse.job.status);
console.log(jobResponse.job.createdAt);
console.log(jobResponse.job.completedAt);

// vérifiez les webhooks
jobResponse.job.webhooks.forEach((webhook) => {
  console.log(`${webhook.id} status: ${webhook.status}`);
});

// depuis la méthode `enqueueInference` (généralement pour webhook)
$jobId = $response->job->id;

// depuis la méthode `enqueueAndGetInference` (généralement pour interrogation)
// $jobId = $response->inference->job->id;

$jobResponse = $mindeeClient->getJob($jobId);

// quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
echo $jobResponse->job->status;
echo $jobResponse->job->createdAt->format('Y-m-d H:i:s');
echo $jobResponse->job->completedAt?->format('Y-m-d H:i:s');

// vérifiez les webhooks
foreach ($jobResponse->job->webhooks as $webhook) {
    echo "{$webhook->id} status: {$webhook->status}";
}

# depuis la méthode `enqueue` (généralement pour webhook)
job_id = response.job.id

# depuis la méthode `enqueue_and_get_result` (généralement pour interrogation)
# job_id = response.inference.job.id

job_response = mindee_client.get_job(job_id)

# quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
puts job_response.job.status
puts job_response.job.created_at
puts job_response.job.completed_at

# vérifiez les webhooks
job_response.job.webhooks.each do |webhook|
  puts "#{webhook.id} status: #{webhook.status}"
end

// depuis la méthode `enqueueInference` (généralement pour webhook)
String jobId = response.getJob().getId();

// depuis la méthode `enqueueAndGetInference` (généralement pour interrogation)
// String jobId = response.getInference().getJob().getId();

var jobResponse = mindeeClient.getJob(jobId);

// quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
var job = jobResponse.getJob();
System.out.println(job.getStatus());
System.out.println(job.getCreatedAt());
System.out.println(job.getCompletedAt());

// vérifiez les webhooks
job.getWebhooks().forEach(webhook ->
    System.out.println(webhook.getId() + " status: " + webhook.getStatus())
);

// depuis la méthode `EnqueueInferenceAsync` (généralement pour webhook)
var jobId = response.Job.Id;

// depuis la méthode `EnqueueAndGetResultAsync` (généralement pour interrogation)
// var jobId = response.Inference.Job.Id;

var jobResponse = await mindeeClient.GetJobAsync(jobId);

// quelques métadonnées, vérifiez votre IDE pour tous les attributs disponibles
Console.WriteLine(jobResponse.Job.Status);
Console.WriteLine(jobResponse.Job.CreatedAt);
Console.WriteLine(jobResponse.Job.CompletedAt);

// vérifiez les webhooks
foreach (var webhook in jobResponse.Job.Webhooks)
{
    Console.WriteLine($"{webhook.Id} status: {webhook.Status}");
}

Envoi de plusieurs fichiers

L'API Mindee ne prend pas en charge l'envoi de plusieurs fichiers en une seule fois ; si vous traitez un grand nombre de fichiers, vous pouvez adopter plusieurs stratégies.

Il existe deux cas d'utilisation typiques : la gestion de fichiers sur disque ou la gestion des téléversements d'utilisateurs finaux.

Fichiers sur disque

Lorsque vous devez traiter un grand nombre de fichiers dans un répertoire ou plusieurs répertoires.

En général, vous vous contentez d'itérer sur tous les fichiers des répertoires et d'appeler l'API pour chacun d'eux.

Ici, la principale préoccupation est le temps nécessaire pour traiter tous les fichiers.

Si vous utilisez l'interrogation, vous pouvez soit utiliser des threads, soit des processus asynchrones pour envoyer plusieurs fichiers en même temps. Votre langage de programmation et votre framework détermineront ce qui fonctionne le mieux.

Si vous utilisez des webhooks, votre débit sera nettement plus élevé qu'avec l'interrogation, sans avoir besoin d'utiliser le multithreading ou la programmation asynchrone. En effet, vous n'attendez pas que le serveur renvoie les résultats avant de passer au fichier suivant.

Dans les deux cas, faites attention aux limites de téléversement de fichiers sur le serveur Mindee. Le serveur répondra avec un code HTTP 429 en cas de téléversements de fichiers excessifs.

Téléversements d'utilisateurs finaux

Lorsque vous fournissez un service dans lequel un utilisateur final peut téléverser des documents directement sur votre plateforme.

Comme tous les SDK Mindee offrent plusieurs façons de gérer les fichiers en mémoire, vous n'avez rien à écrire sur le disque. Vous pouvez le faire si vous le souhaitez, bien sûr !

En général, vous utiliserez soit des octets bruts, soit un objet flux, selon votre langage et votre framework. Envoyez-le directement au SDK Mindee et traitez-le comme d'habitude (interrogation ou webhook). Plus d'informations dans la section : Charger et ajuster un fichier

Avec ce type de configuration, l'interrogation est peut-être moins pénalisante en termes de performances si vous disposez de plusieurs processus serveur en cours d'exécution et de peu d'utilisateurs.

Lorsque vous avez de nombreux utilisateurs qui téléversent de nombreux fichiers, en somme lorsque c'est une fonctionnalité centrale de votre produit ou de votre flux de travail, les webhooks vous offriront davantage de flexibilité. Par exemple, vous pourriez faire en sorte que votre processus de téléversement envoie le fichier directement à Mindee, puis utiliser un autre processus ou microservice pour traiter les résultats.

Obtenir de l'aide pour l'intégration

L'assistant IA peut vous fournir du code personnalisé et des conseils.

Les utilisateurs Enterprise bénéficient d'une assistance d'intégration personnalisée, n'hésitez pas à contacter notre équipe d'assistance.

PrécédentCharger une URL SuivantTraitement des réponses

Mis à jour il y a 25 jours

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