Load and Adjust a File

Reference documentation on loading and manipulating files prior to sending, using Mindee client libraries.

This is reference documentation.

Code samples shown are only examples, and will not work as-is. You'll need to copy-paste and modify according to your requirements.

Looking full code samples?

You can also use the "Ask" button at the top of any page in the documentation.

Before Starting

In most cases you'll be loading a source file for use in the Mindee Client.

Initialize your client as described in the section: Client Configuration.

However, you don't actually need the client initialized to use these features, only the client library installed.

Overview

Overall, the steps to sending a file are:

Load a source file.
Optional: adjust the source file before sending.
Use the Mindee client instance to send the file.

Load a Source File

You can load a source file from a path, from raw bytes, from a bytes stream, or from a language-specific object. Choose the appropriate type based on your application requirements.

If you're unsure of which to use, we recommend loading from a path.

To load a file, you'll need to import the corresponding input class from the mindee module.

To load a path string, use PathInput .

from mindee import PathInput

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

To load a Path instance, use PathInput.

from pathlib import Path
from mindee import PathInput

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

To load raw bytes, use BytesInput . The filename parameter is required.

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",
)

To load a base-64 string, use Base64Input . The filename parameter is required. The string will be decoded into bytes internally.

from mindee import Base64Input

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

To load a file handle, use FileInput. It must be opened in binary mode, as a 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:
    # Continue all operations inside the 'with' statement.
    response = mindee_client.enqueue_and_get_result(
        InferenceResponse,
        input_source,
        params,
    )

To load a file, you'll need to import the corresponding input class and instantiate it.

Make sure to import the needed classes:

import * as mindee from "mindee";
// If you're on CommonJS:
// const mindee = require("mindee");

To load a path string, use PathInput.

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

To load a Buffer instance, use BufferInput . The filename parameter is required.

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

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

To load raw bytes, use BytesInput . The filename parameter is required.

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

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

To load a Stream, use StreamInput. The filename parameter is required.

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

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

To load a base-64 string, use Base64Input . The filename parameter is required.

const b64String = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";

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

To load a file, you'll need to import the corresponding input class from the Mindee\Input namespace.

To load a path string, use PathInput.

use Mindee\Input\PathInput;

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

To load a file resource, use FileInput.

use Mindee\Input\FileInput;

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

To load raw bytes, use BytesInput. The filename is required.

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");

To load a base-64 string, use Base64Input . The string will be decoded into bytes internally. The filename is required.

use Mindee\Input\Base64Input;

$inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."

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

To load a path string, use the PathInputSource class.

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

To load raw bytes, use the BytesInputSource class.

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

To load a base-64 string, use Base64InputSource. The filename is required. The string will be decoded into bytes internally.

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

To load a file handle, use FileInputSource. The filename is required. It must be opened in binary mode.

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

To load a file, initialize it using the LocalInputSource class.

This class has different constructors to allow for opening various types of inputs.

To load a path string:

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

var inputSource = new LocalInputSource(filePath);

To load a Path instance:

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

var inputSource = new LocalInputSource(filePath);

To load a File instance:

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

var inputSource = new LocalInputSource(file);

To load a byte array, the filename is required:

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

var inputSource = new LocalInputSource(fileBytes, filename);

To load an InputStream instance, the filename is required:

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

var inputSource = new LocalInputSource(fileStream, filename);

To load a base-64 string, the filename is required:

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

var inputSource = new LocalInputSource(inputBase64, filename);

To load a file, initialize it using the LocalInputSource class.

This class has different constructors to allow for opening various types of inputs.

To load a path string:

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

var inputSource = new LocalInputSource(filePath)

To load a FileInfo instance:

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

var inputSource = new LocalInputSource(fileinfo)

To load a byte array, the filename is required:

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

var inputSource = new LocalInputSource(fileBytes, filename)

To load a Stream instance, the filename is required:

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

var inputSource = new LocalInputSource(fileStream, filename)

Source File Metadata

Once a source file is loaded, various metadata can be accessed.

These metadata are overall very similar to the ones returned by the API after a successful inference. If you have need of these metadata before getting the full result back from the server, this is the recommended way.

This can be useful for applying business rules based on the input file, for example:

Send PDFs to one model, images to another
Don't send PDFs with too many pages
Save the filename to a database
...

Here are some code samples, using an input source instance.

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

// make sure to initialze the source first
await inputSource.init();

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

$filename = $inputSource->fileName;
$isPdf = $inputSource->isPdf();
$numberOfPages = $inputSource->getPageCount();

filename = input_source.filename
is_pdf = input_source.pdf?
number_of_pages = input_source.page_count

String filename = inputSource.getFilename();
boolean isPdf = inputSource.isPdf();
int numberOfPages = inputSource.getPageCount();

string filename = inputSource.Filename;
bool isPdf = inputSource.IsPdf();
int numberOfPages = inputSource.GetPageCount();

Adjust the Source File

Optionally make changes and adjustments to the source file before sending.

All file adjustments are applied in-memory to the source file instance.

If loaded from disk, the original file is not modified.

Fix PDF Headers

In some cases, PDFs will have corrupt or invalid headers. These files will return a 4xx HTTP error as the server will be unable to process them.

You can try to fix the headers using the provided functions.

Note: this feature is not yet available for all languages.

Here are some code samples, using an input source instance.

input_source.fix_pdf()

$inputSource->fixPDF();

input_source.fix_pdf!

Compress Files

There is no need to send excessively large files to the Mindee API.

Unfortunately, many modern smartphones can take very high resolution images.

We provide a way to compress images before sending to the API.

Here are some code samples, using an input source instance.