> For the complete documentation index, see [llms.txt](https://docs.mindee.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md).

# Charger et ajuster un fichier

## Prérequis

Dans la plupart des cas, vous chargerez un fichier source à utiliser dans le client Mindee ; jetez un œil à la [Configuration du client](/v2/fr/integrations/client-libraries-sdk/configure-the-client.md) section pour plus d’informations.

Cependant, vous n’avez pas réellement besoin d’initialiser le client pour utiliser ces fonctionnalités, seulement d’avoir la bibliothèque cliente installée.

## Aperçu

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

1. Charger un fichier source.
2. *Facultatif*: ajustez le fichier source avant l’envoi.
3. Utilisez l’instance cliente Mindee pour envoyer le fichier.

## Charger un fichier source

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

Si vous ne savez pas lequel utiliser, nous vous recommandons de le charger depuis un chemin.

{% tabs %}
{% tab title="Python" %}
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` .

```python
from mindee import PathInput

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

Pour charger une `Path` instance, utilisez `PathInput`.

```python
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.

```python
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` le paramètre est requis.\
La chaîne sera décodée en octets en interne.

```python
from mindee import Base64Input

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

Pour charger un descripteur de fichier, utilisez `FileInput`.\
Il **doit** être ouvert en mode binaire, comme un `BinaryIO` .

```python
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,
    )
```

{% endtab %}

{% tab title="Node.js" %}
Pour charger un fichier, vous devrez importer la classe d'entrée correspondante et l'instancier.

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

```typescript
import * as mindee from "mindee";
// Si vous êtes en CommonJS :
// const mindee = require("mindee");
```

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

```typescript
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.

```typescript
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.

```typescript
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.

```typescript
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.

```typescript
const b64String = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ...";

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

{% endtab %}

{% tab title="PHP" %}
Pour charger un fichier, vous devrez importer la classe d'entrée correspondante depuis le `Mindee\Input` espace de noms.

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

```php
use Mindee\Input\PathInput;

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

Pour charger une ressource de fichier, utilisez `FileInput`.

```php
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.

```php
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.

```php
use Mindee\Input\Base64Input;

$inputBase64 = "iVBORw0KGgoAAAANSUhEUgAAABgAAA ..."

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

{% endtab %}

{% tab title="Ruby" %}
Pour charger une chaîne de chemin, utilisez le `PathInputSource` classe.

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

Pour charger des octets bruts, utilisez le `BytesInputSource` classe.

```ruby
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.

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

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

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

{% endtab %}

{% tab title="Java" %}
Pour charger un fichier, initialisez-le en utilisant le `LocalInputSource` classe.

Cette classe possède différents constructeurs pour permettre l'ouverture de divers types d'entrées.

Pour charger une chaîne de chemin :

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

var inputSource = new LocalInputSource(filePath);
```

Pour charger une `Path` instance :

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

var inputSource = new LocalInputSource(filePath);
```

Pour charger une `Fichier` instance :

```java
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 :

```java
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 :

```java
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 :

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

var inputSource = new LocalInputSource(inputBase64, filename);
```

{% endtab %}

{% tab title=".NET" %}
Pour charger un fichier, initialisez-le en utilisant le `LocalInputSource` classe.

Cette classe possède différents constructeurs pour permettre l'ouverture de divers types d'entrées.

Pour charger une chaîne de chemin :

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

var inputSource = new LocalInputSource(filePath)
```

Pour charger une `FileInfo` instance :

```csharp
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 :

```csharp
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 :

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

var inputSource = new LocalInputSource(fileStream, filename)
```

{% endtab %}
{% endtabs %}

## Métadonnées du fichier source

Une fois qu'un fichier source est 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 de recevoir 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 avec trop de pages
* Enregistrer le nom de fichier dans une base de données
* ...

{% tabs %}
{% tab title="Python" %}

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

{% endtab %}

{% tab title="Node.js" %}

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

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

{% endtab %}

{% tab title="PHP" %}

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

{% endtab %}

{% tab title="Ruby" %}

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

{% endtab %}

{% tab title="Java" %}

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

{% endtab %}

{% tab title=".NET" %}

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

{% endtab %}
{% endtabs %}

## Ajuster le fichier source

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

{% hint style="info" %}
Tous les ajustements de fichier sont appliqués en mémoire à l'instance du fichier source.

Si le fichier est chargé depuis le disque, le fichier original n'est pas modifié.
{% endhint %}

### Corriger les en-têtes PDF

Dans certains cas, les PDF auront des en-têtes corrompus ou invalides.\
Ces fichiers renverront une erreur HTTP 4xx, car le serveur sera incapable de 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 toutes les langues.

{% tabs %}
{% tab title="Python" %}

```python
input_source.fix_pdf()
```

{% endtab %}

{% tab title="PHP" %}

```php
$inputSource->fixPDF();
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
input_source.fix_pdf!
```

{% endtab %}
{% endtabs %}

### 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 à très haute résolution.

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

{% tabs %}
{% tab title="Python" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```python
input_source.compress(quality=85)
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le rapport d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```python
input_source.compress(
    quality=85, max_width=1920, max_height=1920
)
```

{% endtab %}

{% tab title="Node.js" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```typescript
await inputSource.compress(85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le rapport d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```typescript
await inputSource.compress(85, 1920, 1920);
```

{% endtab %}

{% tab title="PHP" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```php
$inputSource->compress(quality: 85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le rapport d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```php
$inputSource->compress(
    quality: 85, maxWidth: 1920, maxHeight: 1920
);
```

{% endtab %}

{% tab title="Ruby" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```ruby
input_source.compress!(quality:85)
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales. Le rapport d'aspect sera toujours conservé.\
Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```ruby
input_source.compress!(
    quality:85, max_width:1920, max_height:1920
)
```

{% endtab %}

{% tab title="Java" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```java
inputSource.compress(85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le rapport d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```java
inputSource.compress(85, 1920, 1920);
```

{% endtab %}

{% tab title=".NET" %}
L'utilisation de base est très simple et peut s'appliquer aussi bien aux images qu'aux PDF :

```csharp
inputSource.Compress(quality: 85);
```

Pour les images, vous pouvez également définir une hauteur et/ou une largeur maximales.\
Le rapport d'aspect sera toujours conservé.

Par exemple, pour compresser et redimensionner à au plus 1920x1920 pixels :

```csharp
inputSource.Compress(
    quality: 85, maxWidth: 1920, maxHeight: 1920);
```

{% endtab %}
{% endtabs %}

### Manipuler les pages PDF

Dans certains cas, les PDF comporteront des pages superflues.

Par exemple, une page de couverture ou des conditions générales qui ne sont pas utiles à l'extraction de données souhaitée.

Ces pages supplémentaires sont comptabilisées dans votre facturation et ralentissent le traitement.

Il est donc dans votre intérêt de les supprimer avant l'envoi.

**Paramètres :**

* "Indices de pages" est requis et constitue une liste d'indices de pages basés sur 0.\
  Utilisez des valeurs négatives pour spécifier des indices en partant de la fin, c'est-à-dire `-1` pour la dernière page.
* "Opération" précise s'il faut conserver uniquement les pages spécifiées ou supprimer les pages spécifiées.\
  L'une de "Conserver uniquement" ou "Supprimer".
* "Nombre minimal de pages" est facultatif et indique le nombre minimal de pages qu'un document doit avoir pour que l'opération ait lieu. La valeur de `0` signifie n'importe quel nombre de pages.

L'appellation exacte des paramètres dépendra du langage.

{% tabs %}
{% tab title="Python" %}

```python
from mindee import PageOptions

# Définissez les options comme suit :
# Pour tous les documents, ne conserver que la première page
page_options = PageOptions(
    operation="KEEP_ONLY",
    page_indexes=[0],
)

# Appliquer en mémoire
input_source.apply_page_options(page_options)
```

Voici d'autres exemples :

```python
# Uniquement pour les documents ayant 3 pages ou plus :
# Ne conserver que ces pages : première, avant-dernière, dernière
PageOptions(
    operation="KEEP_ONLY",
    on_min_pages=3,
    page_indexes=[0, -2, -1],
)

# Pour tous les documents :
# Supprimer la première page
PageOptions(
    operation="REMOVE",
    page_indexes=[0],
)

# Uniquement pour les documents ayant 10 pages ou plus :
# Supprimer les 5 premières pages
PageOptions(
    operation="REMOVE",
    on_min_pages=10,
    page_indexes=list(range(5)),
)
```

{% endtab %}

{% tab title="Node.js" %}

```typescript
// Définissez les options comme suit :
// Pour tous les documents, ne conserver que la première page
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.KeepOnly,
  pageIndexes: [0],
};

// Appliquer en mémoire
await inputSource.applyPageOptions(pageOptions);
```

Voici d'autres exemples :

```typescript
// Uniquement pour les documents ayant 3 pages ou plus :
// Ne conserver que ces pages : première, avant-dernière, dernière
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.KeepOnly,
  onMinPages: 3,
  pageIndexes: [0, -2, -1],
};

// Pour tous les documents :
// Supprimer la première page
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.Remove,
  pageIndexes: [0],
};

// Uniquement pour les documents ayant 10 pages ou plus :
// Supprimer les 5 premières pages
const pageOptions: mindee.PageOptions = {
  operation: mindee.PageOptionsOperation.Remove,
  onMinPages: 10,
  pageIndexes: [0, 1, 2, 3, 4],
};
```

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\Input\PageOptions;
use const Mindee\Input\KEEP_ONLY;

// Définissez les options comme suit :
// Pour tous les documents, ne conserver que la première page
$pageOptions = new PageOptions(
    pageIndexes: [0],
    operation: KEEP_ONLY
);

// Appliquer en mémoire
$inputSource->applyPageOptions($pageOptions);
```

Voici d'autres exemples :

```php
use Mindee\Input\PageOptions;
use const Mindee\Input\KEEP_ONLY;
use const Mindee\Input\REMOVE;

// Uniquement pour les documents ayant 3 pages ou plus :
// Ne conserver que ces pages : première, avant-dernière, dernière
$pageOptions = new PageOptions(
    pageIndexes: [0, -2, -1],
    operation: KEEP_ONLY,
    onMinPage: 3
);

// Pour tous les documents :
// Supprimer la première page
$pageOptions = new PageOptions(
    pageIndexes: [0],
    operation: REMOVE
);

// Uniquement pour les documents ayant 10 pages ou plus :
// Supprimer les 5 premières pages
$pageOptions = new PageOptions(
    pageIndexes: [0, 1, 2, 3, 4],
    operation: REMOVE,
    onMinPage: 10
);
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
# Définissez les options comme suit :
# Pour tous les documents, ne conserver que la première page
page_options = Mindee::PageOptions.new(
    operation: :KEEP_ONLY,
    page_indexes: [0],
)

# Appliquer en mémoire
input_source.apply_page_options(page_options)
```

Remarque : le nom est `apply_page_options` au lieu de `apply_page_options!` même si l'opération est effectuée en place, afin d'harmoniser avec les autres bibliothèques clientes.

Voici d'autres exemples :

```ruby
# Uniquement pour les documents ayant 3 pages ou plus :
# Ne conserver que ces pages : première, avant-dernière, dernière
Mindee::PageOptions.new(
    operation: :KEEP_ONLY,
    on_min_pages: 3,
    page_indexes: [0, -2, -1],
)

# Pour tous les documents :
# Supprimer la première page
Mindee::PageOptions.new(
    operation: :REMOVE,
    page_indexes: [0],
)

# Uniquement pour les documents ayant 10 pages ou plus :
# Supprimer les 5 premières pages
Mindee::PageOptions.new(
    operation: :REMOVE,
    on_min_pages: 10,
    page_indexes: array[0..4]
)
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.input.PageOptions;
import com.mindee.input.PageOptionsOperation;

// Définissez les options comme suit :
// Pour tous les documents, ne conserver que la première page
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0 })
    .operation(PageOptionsOperation.KEEP_ONLY)
    .build();

// Appliquer en mémoire
inputSource.applyPageOptions(pageOptions);
```

Voici d'autres exemples :

```java
import com.mindee.input.PageOptions;
import com.mindee.input.PageOptionsOperation;

// Uniquement pour les documents ayant 3 pages ou plus :
// Ne conserver que ces pages : première, avant-dernière, dernière
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0, -2, -1 })
    .operation(PageOptionsOperation.KEEP_ONLY)
    .onMinPages(3)
    .build();

// Pour tous les documents :
// Supprimer la première page
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0 })
    .operation(PageOptionsOperation.REMOVE)
    .build();

// Uniquement pour les documents ayant 10 pages ou plus :
// Supprimer les 5 premières pages
var pageOptions = new PageOptions.Builder()
    .pageIndexes(new Integer[]{ 0, 1, 2, 3, 4 })
    .operation(PageOptionsOperation.REMOVE)
    .onMinPages(10)
    .build();
```

{% endtab %}

{% tab title=".NET" %}

```csharp
// Définissez les options comme suit :
// Pour tous les documents, ne conserver que la première page
var pageOptions = new PageOptions(
    operation: PageOptionsOperation.KeepOnly
    , pageIndexes: [ 0 ]);

// Appliquer en mémoire
inputSource.ApplyPageOptions(pageOptions);
```

Voici d'autres exemples :

```csharp
// Uniquement pour les documents ayant 3 pages ou plus :
// Ne conserver que ces pages : première, avant-dernière, dernière
new PageOptions(
    operation: PageOptionsOperation.KeepOnly
    , onMinPages: 3
    , pageIndexes: new short[] { 0, -2, -1 }
);

// Pour tous les documents :
// Supprimer la première page
new PageOptions(
    operation: PageOptionsOperation.Remove
    , pageIndexes: new short[] { 0 }
);

// Uniquement pour les documents ayant 10 pages ou plus :
// Supprimer les 5 premières pages
new PageOptions(
    operation: PageOptionsOperation.Remove
    , onMinPages: 10
    , pageIndexes: new short[] { 0, 1, 2, 3, 4 }
);
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.mindee.com/v2/fr/integrations/client-libraries-sdk/load-and-adjust-a-file.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.