> 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/modeles-split/sdk-integration/split-result.md).

# Résultat du modèle Split

Vous devrez disposer d'un objet de réponse comme décrit dans la [Traitement des réponses](/v2/fr/integrations/client-libraries-sdk/process-the-response.md) section.

## Accéder aux plages Split

Un `SplitRange` décrit un sous-document logique identifié dans le fichier source.

### `SplitRange` Attributs

Chaque `SplitRange` instance aura ces propriétés.

#### Type de document

La catégorie de document attribuée au sous-document. Elle est toujours renseignée.

Elle est renvoyée sous forme de chaîne et est identique à la valeur saisie sur la plateforme Mindee — casse, espaces et ponctuation compris.

#### Plage de pages

Un tableau à deux éléments de **à base 0** indices de page, où le premier entier indique la page de début et le second entier indique la page de fin. Elle est toujours renseignée.

Une valeur de plage de pages de `(0,2)` signifierait de la **première** page à la **troisième** page.

#### Réponse d'extraction

Réponse d'extraction facultative associée au Split. Elle n'est renseignée que si l'enchaînement d'extraction est activé pour le modèle.

### Parcourir les plages Split

Vous voudrez généralement parcourir toutes les plages Split, car le nombre de plages dépend du document.

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

```python
from mindee import SplitResponse

def handle_response(response: SplitResponse) -> None:
    splits = response.inference.result.splits

    for split in splits:
        # plage [start_page, end_page] à base 0
        page_range = split.page_range

        print(f"Type détecté : {split.document_type}")
        print(f"Sur les pages : {page_range[0]} - {page_range[1]}")

        # Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        extraction_response = split.extraction_response

        if extraction_response is not None:
            # Accédez aux champs extraits à partir du résultat d'inférence du Split
            fields = extraction_response.inference.result.fields
            print(f"Champs d'extraction : {fields}")
```

{% endtab %}

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

```javascript
handleResponse(response) {
  const splits = response.inference.result.splits;

  for (const split of splits) {
    // plage [startPage, endPage] à base 0
    const pageRange = split.pageRange;

    // Type de document identifié pour ce Split
    const documentType = split.documentType;

    console.log(`Type détecté : ${documentType}`);
    console.log(`Sur les pages : ${pageRange[0]} - ${pageRange[1]}`);
    
    // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    const extractionResponse = split.extractionResponse;

    if (extractionResponse) {
      // Accédez aux champs extraits à partir du résultat d'inférence du Split
      const fields = extractionResponse.inference.result.fields;
      console.log("Champs d'extraction :", fields.toString());
    }
  }
}
```

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        // plage [startPage, endPage] à base 0
        $pageRange = $split->pageRange;

        // Type de document identifié pour ce Split
        $documentType = $split->documentType;

        echo "Type détecté : $documentType\n";
        echo "Sur les pages : {$pageRange[0]} - {$pageRange[1]}\n";

        // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        $extractionResponse = $split->extractionResponse;

        if ($extractionResponse !== null) {
            // Accédez aux champs extraits à partir du résultat d'inférence du Split
            $fields = $extractionResponse->inference->result->fields;
            echo "Champs d'extraction : " . $fields->toString() . "\n";
        }
    }
}
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    # plage [start_page, end_page] à base 0
    page_range = split.page_range

    # Type de document identifié pour ce Split
    document_type = split.document_type

    puts "Type détecté : #{document_type}"
    puts "Sur les pages : #{page_range[0]} - #{page_range[1]}"

    # Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    extraction_response = split.extraction_response

    if extraction_response
      # Accédez aux champs extraits à partir du résultat d'inférence du Split
      fields = extraction_response.inference.result.fields
      puts "Champs d'extraction : #{fields}"
    end
  end
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(SplitResponse response) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    // plage [startPage, endPage] à base 0
    var pageRange = split.getPageRange();

    // Type de document identifié pour ce Split
    String documentType = split.getDocumentType();

    System.out.println("Type détecté : " + documentType);
    System.out.println(
      "Sur les pages : " + pageRange.get(0) + " - " + pageRange.get(1)
    );

    // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
    var extractionResponse = split.getExtractionResponse();

    if (extractionResponse != null) {
      // Accédez aux champs extraits à partir du résultat d'inférence du Split
      var fields = extractionResponse.getInference().getResult().getFields();
      System.out.println("Champs d'extraction : " + fields.toString());
    }
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        // plage [startPage, endPage] à base 0
        var pageRange = split.PageRange;

        // Type de document identifié pour ce Split
        string documentType = split.DocumentType;

        Console.WriteLine($"Type détecté : {documentType}");
        Console.WriteLine($"Sur les pages : {pageRange[0]} - {pageRange[1]}");

        // Réponse d'extraction facultative, présente si l'enchaînement d'extraction a été demandé
        var extractionResponse = split.ExtractionResponse;

        if (extractionResponse != null)
        {
            // Accédez aux champs extraits à partir du résultat d'inférence du Split
            var fields = extractionResponse.Inference.Result.Fields;
            Console.WriteLine($"Champs d'extraction : {fields}");
        }
    }
}
```

{% endtab %}
{% endtabs %}

Les résultats de l'extraction en chaîne seront un `ExtractionResponse` objet. Cet objet est identique à la réponse d’un modèle d'extraction.

Reportez-vous à la [Résultat d'extraction](/v2/fr/modeles-extraction/sdk-integration/extraction-result.md) section pour plus de détails sur le traitement de l'extraction.

## Extraire les plages Split depuis le fichier d'entrée

Les SDK offrent la prise en charge de l'extraction de chaque plage Split sous forme de fichiers PDF distincts.

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

```python
from mindee import SplitResponse

def handle_response(response: SplitResponse, input_source) -> None:
    splits = response.inference.result.splits

    for split in splits:
      extracted_split = split.extract_from_input_source(input_source)

```

{% endtab %}

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

<pre class="language-javascript"><code class="lang-javascript"><strong>async handleResponse(response, inputSource) {
</strong>  const splits = response.inference.result.splits;

  for (const split of splits) {
    const extractedSplit = await split.extractFromInputSource(inputSource);
  }
}
</code></pre>

{% endtab %}

{% tab title="PHP" %}

```php
use Mindee\V2\Product\Split\SplitResponse;

public function handleResponse(SplitResponse $response, $inputSource)
{
    $splits = $response->inference->result->splits;

    foreach ($splits as $split) {
        $extractedSplit = $split->extractFromInputSource($inputSource)
    }
}
```

{% endtab %}

{% tab title="Ruby" %}

```ruby
def handle_response(response)
  splits = response.inference.result.splits

  splits.each do |split|
    extracted_split = split.extract_from_input_source(input_source)
  end
```

{% endtab %}

{% tab title="Java" %}

```java
import com.mindee.input.LocalInputSource;
import com.mindee.v2.product.split.SplitResponse;
import com.mindee.v2.product.split.SplitRange;

public void handleResponse(
  SplitResponse response,
  LocalInputSource inputSource
) {
  var splits = response.getInference().getResult().getSplits();

  for (SplitRange split : splits) {
    var extractedSplit = split.extractFromInputSource(inputSource);
  }
}
```

{% endtab %}

{% tab title=".NET" %}

```csharp
using System;
using Mindee.Input;
using Mindee.V2.Product.Split;

public void HandleResponse(SplitResponse response, LocalInputSource inputSource)
{
    var splits = response.Inference.Result.Splits;

    foreach (SplitRange split in splits)
    {
        var extractedSplit = split.ExtractFromInputSource(inputSource);
    }
}
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
**Seules les méthodes documentées ici sont prêtes pour la production**.

C'est parce que nous améliorons encore les SDK, veuillez patienter !
{% endhint %}


---

# 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, and the optional `goal` query parameter:

```
GET https://docs.mindee.com/v2/fr/modeles-split/sdk-integration/split-result.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.