Charger et ajuster un fichier

Documentation de référence sur le chargement et la manipulation des fichiers avant envoi, à 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.

Avant de commencer

Dans la plupart des cas, vous chargerez un fichier source pour l'utiliser dans le client Mindee.

Initialisez votre client comme décrit dans la section : Configuration du client.

Cependant, vous n'avez pas réellement besoin que le client soit initialisé pour utiliser ces fonctionnalités, seulement que la bibliothèque cliente soit installée.

Aperçu

Dans l'ensemble, les étapes pour envoyer un fichier sont :

Chargez un fichier source.
Facultatif: ajustez le fichier source avant l'envoi.
Utilisez l'instance du client Mindee pour envoyer le fichier.

Charger un fichier source

Vous pouvez charger un fichier source à partir d'un chemin, d'octets bruts, d'un flux d'octets ou d'un objet spécifique au langage. Choisissez le type approprié en fonction des besoins de votre application.

Si vous n'êtes pas certain de l'option à utiliser, nous recommandons de charger depuis un chemin.

Pour charger un fichier, vous devrez importer la classe d'entrée correspondante depuis le mindee module.

Pour charger une chaîne de chemin, utilisez PathInput .

from mindee import PathInput

input_path = "/path/to/the/file.ext"
input_source = PathInput(input_path)

Pour charger une Path instance, utilisez PathInput.

from pathlib import Path
from mindee import PathInput

input_path = Path("/path/to/the/file.ext")
input_source = PathInput(input_path)

Pour charger des octets bruts, utilisez BytesInput . Le nom de fichier est requis.

from pathlib import Path
from mindee import BytesInput

input_path = Path("/path/to/the/file.ext")
with input_path.open("rb") as fh:
    input_bytes = fh.read()

input_source = BytesInput(
    input_bytes,
    filename="file.ext",
)

Pour charger une chaîne base64, utilisez Base64Input . Le nom de fichier paramètre est requis. La chaîne sera décodée en octets en interne.

from mindee import Base64Input

input_base64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."
input_source = Base64Input(
    input_base64,
    filename="file.ext",
)

Pour charger un handle de fichier, utilisez FileInput. Il doit être ouvert en mode binaire, en tant que BinaryIO .

from pathlib import Path
from mindee import FileInput

input_path = Path("/path/to/the/file.ext")
with input_path.open("rb") as fh:
    input_source = FileInput(fh)
    # IMPORTANT :
    # Continuez toutes les opérations à l'intérieur de l'instruction 'with'.
    response = mindee_client.enqueue_and_get_result(
        InferenceResponse,
        input_source,
        params,
    )

Pour charger un fichier, vous devrez importer la classe d'entrée correspondante et l'instancier.

Assurez-vous d'importer les classes nécessaires :

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

Pour charger une chaîne de chemin, utilisez PathInput.

const filePath = "/path/to/the/file.ext";
const inputSource = new mindee.PathInput({ inputPath: filePath });

Pour charger une Buffer instance, utilisez BufferInput . Le nom de fichier est requis.

const buffer = Buffer.from(
  await fs.promises.readFile("/path/to/the/file.ext")
);

const inputSource = new mindee.BufferInput({
  buffer: buffer,
  filename: "file.ext",
});

Pour charger des octets bruts, utilisez BytesInput . Le nom de fichier est requis.

const inputBytes = new Uint8Array(
  await fs.promises.readFile("/path/to/the/file.ext")
);

const inputSource = new mindee.BytesInput({
  inputBytes: inputBytes,
  filename: "file.ext",
});

Pour charger une Stream, utilisez StreamInput. Le nom de fichier est requis.

const stream = fs.createReadStream("/path/to/the/file.ext");

const inputSource = new mindee.StreamInput({
  inputStream: stream,
  filename: "file.ext",
});

Pour charger une chaîne base64, utilisez Base64Input . Le nom de fichier est requis.

const b64String = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";

const inputSource = new mindee.Base64Input({
  inputString: b64String,
  filename: "file.ext",
});

Pour charger un fichier, vous devrez importer la classe d'entrée correspondante depuis le Mindee\Input namespace.

Pour charger une chaîne de chemin, utilisez PathInput.

use Mindee\Input\PathInput;

$filePath = "/path/to/the/file.ext";
$inputSource = new PathInput($filePath);

Pour charger une ressource de fichier, utilisez FileInput.

use Mindee\Input\FileInput;

$handle = fopen("/path/to/the/file.ext", "rb");
$inputSource = new FileInput($handle);

Pour charger des octets bruts, utilisez BytesInput. Le nom de fichier est requis.

use Mindee\Input\BytesInput;

$filePath = "/path/to/the/file.ext";
$handle = fopen($filePath, "rb");
$contents = fread($handle, filesize($filePath));

$inputSource = new BytesInput($contents, "file.ext");

Pour charger une chaîne base64, utilisez Base64Input . La chaîne sera décodée en octets en interne. Le nom de fichier est requis.

use Mindee\Input\Base64Input;

$inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."

$inputSource = Base64Input($inputBase64, "file.ext");

Pour charger une chaîne de chemin, utilisez la PathInputSource classe.

input_path = '/path/to/the/file.ext'
input_source = Mindee::Input::Source::PathInputSource.new(input_path)

Pour charger des octets bruts, utilisez la BytesInputSource classe.

input_bytes = File.binread('/path/to/the/file.ext')
input_source = Mindee::Input::Source::BytesInputSource.new(input_bytes, file_name)

Pour charger une chaîne base64, utilisez Base64InputSource. Le nom de fichier est requis. La chaîne sera décodée en octets en interne.

input_base64 = 'iVBORw0KGgoAAAANSUhEUgAAABgAAA ...'
input_source = Mindee::Input::Source::Base64InputSource.new(
    input_base64, 'file.ext'
)

Pour charger un handle de fichier, utilisez FileInputSource. Le nom de fichier est requis. Il doit être ouvert en mode binaire.

file = File.open('/path/to/the/file.ext', 'rb')
input_source = Mindee::Input::Source::FileInputSource.new(file, 'file.ext')

Pour charger un fichier, initialisez-le en utilisant LocalInputSource classe.

Cette classe possède différents constructeurs permettant d'ouvrir divers types d'entrées.

Pour charger une chaîne de chemin :

var filePath = "/path/to/the/file.ext";

var inputSource = new LocalInputSource(filePath);

Pour charger une Path instance :

var filePath = new Path("/path/to/the/file.ext");

var inputSource = new LocalInputSource(filePath);

Pour charger une File instance :

var file = new File("/path/to/the/file.ext");

var inputSource = new LocalInputSource(file);

Pour charger un tableau d'octets, le nom de fichier est requis :

var fileBytes = Files.readAllBytes("/path/to/the/file.ext");
var filename = "file.ext";

var inputSource = new LocalInputSource(fileBytes, filename);

Pour charger une InputStream instance, le nom de fichier est requis :

var fileStream = new FileInputStream(
    new File("/path/to/the/file.ext")
);
var filename = "file.ext";

var inputSource = new LocalInputSource(fileStream, filename);

Pour charger une chaîne base64, le nom de fichier est requis :

var inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";
var filename = "file.ext";

var inputSource = new LocalInputSource(inputBase64, filename);

Pour charger un fichier, initialisez-le en utilisant LocalInputSource classe.

Cette classe possède différents constructeurs permettant d'ouvrir divers types d'entrées.

Pour charger une chaîne de chemin :

string filePath = "/path/to/the/file.ext";

var inputSource = new LocalInputSource(filePath)

Pour charger une FileInfo instance :

FileInfo fileinfo = new FileInfo("/path/to/the/file.ext");

var inputSource = new LocalInputSource(fileinfo)

Pour charger un tableau d'octets, le nom de fichier est requis :

byte[] fileBytes = File.ReadAllBytes("/path/to/the/file.ext");
string filename = "file.ext";

var inputSource = new LocalInputSource(fileBytes, filename)

Pour charger une Stream instance, le nom de fichier est requis :

Stream fileStream = FileStream SourceStream = File.Open(
    "/path/to/the/file.ext", FileMode.Open);
string filename = "file.ext";

var inputSource = new LocalInputSource(fileStream, filename)

Métadonnées du fichier source

Une fois un fichier source chargé, diverses métadonnées peuvent être consultées.

Ces métadonnées sont globalement très similaires à celles renvoyées par l'API après une inférence réussie. Si vous avez besoin de ces métadonnées avant d'obtenir le résultat complet du serveur, c'est la méthode recommandée.

Cela peut être utile pour appliquer des règles métier basées sur le fichier d'entrée, par exemple :

Envoyer les PDF à un modèle, les images à un autre
N'envoyez pas de PDF comportant trop de pages
Enregistrez le nom de fichier dans une base de données
...

Voici quelques exemples de code, en utilisant une source d’entrée instance.

filename: str = input_source.filename
is_pdf: bool = input_source.is_pdf
number_of_pages: int = input_source.page_count

// assurez-vous d'initialiser d'abord la source
await inputSource.init();

const filename = inputSource.filename;
const isPdf = inputSource.isPdf();
const numberOfPages = await inputSource.getPageCount();

Ajuster le fichier source

Vous pouvez éventuellement apporter des modifications et des ajustements au fichier source avant l'envoi.

Tous les ajustements de fichier sont appliqués en mémoire à l'instance du fichier source.

S'il est chargé depuis le disque, le fichier original n'est pas modifié.

Corriger les en-têtes PDF

Dans certains cas, les PDF ont des en-têtes corrompus ou invalides. Ces fichiers renverront une erreur HTTP 4xx, car le serveur ne pourra pas les traiter.

Vous pouvez essayer de corriger les en-têtes à l'aide des fonctions fournies.

Remarque : cette fonctionnalité n'est pas encore disponible pour tous les langages.

Voici quelques exemples de code, en utilisant une source d’entrée instance.

input_source.fix_pdf()

Compresser les fichiers

Il n'est pas nécessaire d'envoyer des fichiers excessivement volumineux à l'API Mindee.

Malheureusement, de nombreux smartphones modernes peuvent prendre des images de très haute résolution.

Nous fournissons un moyen de compresser les images avant de les envoyer à l'API.

Voici quelques exemples de code, en utilisant une source d’entrée instance.