Importer des données de fichier

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

L'API Google Drive vous permet d'importer des données de fichier lorsque vous créez ou mettez à jour un File. Pour savoir comment créer un objet File ne contenant que des métadonnées, consultez la page Créer des fichiers.

Vous pouvez importer trois types de vidéos:

  • Importation simple (uploadType=media) : utilisez ce type d'importation pour transférer un petit fichier multimédia (5 Mo ou moins) sans fournir de métadonnées. Pour effectuer une importation simple, consultez la section Effectuer une importation simple.

  • Importation en plusieurs parties (uploadType=multipart) : utilisez ce type d'importation pour transférer un petit fichier (5 Mo ou moins) avec des métadonnées décrivant le fichier, en une seule requête. Pour effectuer une importation en plusieurs parties, reportez-vous à la section Effectuer une importation en plusieurs parties.

  • Importation avec reprise (uploadType=resumable) : utilisez ce type d'importation pour les fichiers volumineux (supérieurs à 5 Mo) et en cas d'interruption élevée du réseau, par exemple lorsque vous créez un fichier à partir d'une application mobile. Les importations avec reprise sont également un bon choix pour la plupart des applications, car elles fonctionnent également avec des petits fichiers pour un coût minimal d'une requête HTTP supplémentaire par importation. Pour effectuer une importation avec reprise, consultez la section Effectuer une importation avec reprise.

Les bibliothèques clientes des API Google mettent en œuvre au moins l'un de ces types d'importations. Reportez-vous à la documentation de la bibliothèque cliente pour en savoir plus sur l'utilisation de chacun de ces types.

Utilisez PATCH par rapport à PUT

Pour rappel, le verbe HTTP PATCH autorise la mise à jour partielle des ressources de fichiers, tandis que le verbe HTTP PUT permet le remplacement complet des ressources. Notez que PUT peut introduire des modifications destructives lors de l'ajout d'un champ à une ressource existante.

Lorsque vous importez une ressource de fichier, suivez les consignes ci-dessous:

  • Utilisez le verbe HTTP documenté dans la documentation de référence de l'API pour la requête initiale d'une importation avec reprise ou pour la seule requête d'importation simple ou en plusieurs parties.
  • Utilisez PUT pour toutes les requêtes ultérieures d'importation avec reprise une fois que la requête a démarré. Ces requêtes importent du contenu, quelle que soit la méthode appelée.

Effectuer une importation simple

Pour effectuer une importation simple, utilisez la méthode files.create avec uploadType=media.

Pour effectuer une importation simple, procédez comme suit:

HTTP

  1. Créez une requête POST sur l'URI /upload de la méthode avec le paramètre de requête uploadType=media:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=media

  2. Ajoutez les données du fichier au corps de la requête.

  3. Ajoutez ces en-têtes HTTP:

    • Content-Type. Définissez le type de média MIME de l'objet importé.
    • Content-Length. Définissez le nombre d'octets que vous importez. Si vous utilisez l'encodage de transfert fragmenté, cet en-tête n'est pas obligatoire.

  4. Envoyez la requête. Si la requête aboutit, le serveur affiche le code d'état HTTP 200 OK avec les métadonnées du fichier. {HTTP}

Lorsque vous effectuez une importation simple, des métadonnées de base sont créées et certains attributs sont déduits du fichier, tels que le type MIME ou modifiedTime. Vous pouvez utiliser une importation simple lorsque vous avez des fichiers de petite taille et que les métadonnées de fichiers ne sont pas importantes.

Importer en plusieurs parties

Une requête d'importation en plusieurs parties vous permet d'importer des métadonnées et des données dans la même requête. Utilisez cette option si les données que vous envoyez sont suffisamment petites pour être réimportées, dans leur intégralité, en cas d'échec de la connexion.

Pour effectuer une importation en plusieurs parties, utilisez la méthode files.create avec uploadType=multipart.

Pour effectuer une importation en plusieurs parties, procédez comme suit:

Java

drive/snippets/drive_v3/src/main/java/UploadBasic.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate use of Drive insert file API */
public class UploadBasic {

  /**
   * Upload new file.
   *
   * @return Inserted file metadata if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadBasic() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();
    // Upload file photo.jpg on drive.
    File fileMetadata = new File();
    fileMetadata.setName("photo.jpg");
    // File's content.
    java.io.File filePath = new java.io.File("files/photo.jpg");
    // Specify media type and file-path for file.
    FileContent mediaContent = new FileContent("image/jpeg", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to upload file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_basic.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_basic():
    """Insert new file.
    Returns : Id's of the file uploaded

    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()

    try:
        # create drive api client
        service = build('drive', 'v3', credentials=creds)

        file_metadata = {'name': 'download.jpeg'}
        media = MediaFileUpload('download.jpeg',
                                mimetype='image/jpeg')
        # pylint: disable=maybe-no-member
        file = service.files().create(body=file_metadata, media_body=media,
                                      fields='id').execute()
        print(F'File ID: {file.get("id")}')

    except HttpError as error:
        print(F'An error occurred: {error}')
        file = None

    return file.get('id')


if __name__ == '__main__':
    upload_basic()

Node.js

drive/snippets/drive_v3/file_snippets/upload_basic.js
/**
 * Insert new file.
 * @return{obj} file Id
 * */
async function uploadBasic() {
  const fs = require('fs');
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const requestBody = {
    name: 'photo.jpg',
    fields: 'id',
  };
  const media = {
    mimeType: 'image/jpeg',
    body: fs.createReadStream('files/photo.jpg'),
  };
  try {
    const file = await service.files.create({
      requestBody,
      media: media,
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadBasic.php
use Google\Client;
use Google\Service\Drive;
# TODO - PHP client currently chokes on fetching start page token
function uploadBasic()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
        'name' => 'photo.jpg'));
        $content = file_get_contents('../files/photo.jpg');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'image/jpeg',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    } 

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadBasic.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate use of Drive insert file API
    public class UploadBasic
    {
        /// <summary>
        /// Upload new file.
        /// </summary>
        /// <param name="filePath">Image path to upload.</param>
        /// <returns>Inserted file metadata if successful, null otherwise.</returns>
        public static string DriveUploadBasic(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file photo.jpg on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "photo.jpg"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new file on drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "image/jpeg");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

HTTP

  1. Créez une requête POST sur l'URI /upload de la méthode avec le paramètre de requête uploadType=multipart:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart

  2. Créez le corps de la requête. Mettez en forme le corps en fonction du type de contenu associé en plusieurs parties [RFC 2387], qui contient deux parties:

    • Métadonnées. Les métadonnées doivent apparaître en premier et l'en-tête Content-Type doit être défini sur application/json; charset=UTF-8. Ajoutez les métadonnées du fichier au format JSON.
    • Médias. Le contenu multimédia doit apparaître en deuxième position et comporter un en-tête Content-Type de n'importe quel type MIME. Ajoutez les données du fichier à la partie multimédia.

    Identifiez chaque partie à l'aide d'une chaîne de délimitation, précédée de deux traits d'union. En outre, ajoutez deux traits d'union après la dernière chaîne de limite.

  3. Ajoutez ces en-têtes HTTP de premier niveau:

    • Content-Type. Définissez la valeur sur multipart/related et incluez la chaîne de limite que vous utilisez pour identifier les différentes parties de la requête. Exemple: Content-Type: multipart/related; boundary=foo_bar_baz
    • Content-Length. Défini sur le nombre total d'octets dans le corps de la requête.

  4. Envoyez la requête.

Pour créer ou mettre à jour la partie de métadonnées uniquement, sans les données associées, envoyez une requête POST ou PATCH au point de terminaison de la ressource standard : https://www.googleapis.com/drive/v3/files Si la requête aboutit, le serveur renvoie le code d'état HTTP 200 OK avec les métadonnées du fichier.

Lors de la création de fichiers, ils doivent spécifier une extension de fichier dans le champ name du fichier. Par exemple, lorsque vous créez un fichier JPEG de photo, vous pouvez spécifier "name": "photo.jpg" dans les métadonnées. Les appels suivants à files.get renvoient la propriété fileExtension en lecture seule contenant l'extension spécifiée à l'origine dans le champ name.

Effectuer une importation avec reprise

Une importation avec reprise vous permet de reprendre une opération d'importation après un échec de communication qui interrompt le flux de données. Comme vous n'avez pas besoin de redémarrer les importations de fichiers volumineux depuis le début, les importations avec reprise peuvent également réduire votre utilisation de la bande passante en cas de panne du réseau.

Les importations avec reprise sont utiles lorsque la taille de vos fichiers peut varier considérablement ou lorsque les requêtes (comme les tâches d'arrière-plan de l'OS mobile et certaines requêtes App Engine) sont soumises à une limite de temps fixe. Vous pouvez également utiliser les importations avec reprise pour les cas où vous souhaitez afficher une barre de progression de l'importation.

Une importation avec reprise comprend plusieurs étapes générales:

  1. Envoyez la requête initiale et récupérez l'URI de la session avec reprise.
  2. Importez les données et surveillez l'état d'importation.
  3. (Facultatif) Si l'importation est interrompue, reprenez l'importation.

Envoyer la requête initiale

Pour lancer une importation avec reprise, utilisez la méthode files.create avec uploadType=resumable.

HTTP

  1. Créez une requête POST sur l'URI /upload de la méthode avec le paramètre de requête uploadType=resumable:

    POST https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable

    Si la requête d'initiation réussit, la réponse inclut un code d'état HTTP 200 OK. Il inclut également un en-tête Location qui spécifie l'URI de la session avec reprise:

    HTTP/1.1 200 OK
Location: https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable&upload_id=xa298sd_sdlkj2
Content-Length: 0

    Enregistrez l'URI de la session avec reprise afin de pouvoir importer les données du fichier et interroger l'état de l'importation. Un URI de session avec reprise expire au bout d'une semaine.

  2. Si vous disposez de métadonnées pour le fichier, ajoutez-les au corps de la requête au format JSON. Sinon, laissez le corps de la requête vide.

  3. Ajoutez ces en-têtes HTTP:

    • X-Upload-Content-Type Facultatif. Défini sur le type MIME des données du fichier à transférer dans les requêtes ultérieures. Si le type MIME des données n'est pas spécifié dans les métadonnées ni via cet en-tête, l'objet est diffusé en tant que application/octet-stream..
    • X-Upload-Content-Length Facultatif. Définissez le nombre d'octets de données de fichier, qui seront transférés dans les requêtes ultérieures.
    • Content-Type. Obligatoire si vous disposez de métadonnées pour le fichier. Défini sur application/json; charset=UTF-8.
    • Content-Length. Obligatoire, sauf si vous utilisez l'encodage de transfert fragmenté. Défini sur le nombre d'octets dans le corps de cette requête initiale.

  4. Envoyez la requête. Si la requête de lancement de session aboutit, la réponse inclut un code d'état 200 OK HTTP. En outre, la réponse inclut un en-tête Location qui spécifie l'URI de la session avec reprise. Utilisez l'URI de la session avec reprise pour importer les données du fichier et interroger l'état de l'importation. Un URI de session avec reprise expire au bout d'une semaine.

  5. Copiez et enregistrez l'URL de la session avec reprise.

  6. Passez à la section Importer le contenu.

Importer le contenu

Il existe deux façons d'importer un fichier avec une session avec reprise:

  • Importer le contenu dans une seule requête : utilisez cette approche lorsque le fichier peut être importé dans une requête unique, qu'il n'y a pas de limite de temps fixe pour une seule requête ou que vous n'avez pas besoin d'afficher un indicateur de progression de l'importation. Cette approche est préférable, car elle nécessite moins de requêtes et entraîne de meilleures performances.

  • Importer le contenu en plusieurs fragments : utilisez cette approche si vous devez réduire la quantité de données transférées dans une seule requête. Vous devrez peut-être réduire les données transférées en cas de limite de temps fixe pour des requêtes individuelles, comme cela peut être le cas pour certaines classes de requêtes App Engine. Cette approche est également utile si vous devez fournir un indicateur personnalisé pour indiquer la progression de l'importation.

HTTP : requête simple

  1. Créez une requête PUT vers l'URI de la session avec reprise.
  2. Ajoutez les données du fichier au corps de la requête.
  3. Ajoutez un en-tête HTTP Content-length, défini sur le nombre d'octets du fichier.
  4. Envoyez la requête. Si la requête d'importation est interrompue ou si vous recevez une réponse 5xx, suivez la procédure décrite dans la section Reprendre une importation interrompue.

HTTP : requêtes multiples

  1. Créez une requête PUT vers l'URI de la session avec reprise.

  2. Ajoutez les données du fragment au corps de la requête. Créez des fragments par multiples de 256 Ko (256 x 1 024 octets), à l'exception du fragment final qui termine l'importation. La taille des fragments doit être aussi grande que possible pour que l'importation soit efficace.

  3. Ajoutez ces en-têtes HTTP:

    • Content-Length. Défini sur le nombre d'octets du fragment actuel.
    • Content-Range. Défini pour afficher les octets du fichier que vous importez. Par exemple, Content-Range: bytes 0-524287/2000000 montre que vous importez les 524 288 premiers octets (256 x 1 024 x 2) dans un fichier de 2 000 000 octets.

  4. Envoyez la requête, puis traitez la réponse. Si la requête d'importation est interrompue ou si vous recevez une réponse 5xx, suivez la procédure décrite dans la section Reprendre une importation interrompue.

  5. Répétez les étapes 1 à 4 pour chaque fragment restant dans le fichier. Utilisez l'en-tête Range dans la réponse pour déterminer où démarrer le prochain fragment. Ne partez pas du principe que le serveur a reçu tous les octets envoyés dans la requête précédente.

Une fois l'importation du fichier terminée, vous recevez une réponse 200 OK ou 201 Created, ainsi que toutes les métadonnées associées à la ressource.

Reprendre une importation interrompue

Si une requête d'importation se termine avant une réponse ou si vous recevez une réponse 503 Service Unavailable, vous devez reprendre l'importation interrompue.

HTTP

  1. Pour demander l'état de l'importation, créez une requête PUT vide à destination de l'URI de la session avec reprise.

  2. Ajoutez un en-tête Content-Range pour indiquer que la position actuelle dans le fichier est inconnue. Par exemple, définissez Content-Range sur */2000000 si la longueur totale de votre fichier correspond à 2 000 000 octets. Si vous ne connaissez pas la taille totale du fichier, définissez Content-Range sur */*.

  3. Envoyez la requête.

  4. Traitez la réponse:

    • Une réponse 200 OK ou 201 Created indique que l'importation a été effectuée et qu'aucune autre action n'est requise.
    • Une réponse 308 Resume Incomplete indique que vous devez continuer à importer le fichier.
    • Une réponse 404 Not Found indique que la session d'importation a expiré et que l'importation doit reprendre depuis le début.

  5. Si vous avez reçu une réponse 308 Resume Incomplete, traitez l'en-tête Range de la réponse pour déterminer les octets reçus par le serveur. Si la réponse ne comporte pas d'en-tête Range, aucun octet n'a été reçu. Par exemple, un en-tête Range de bytes=0-42 indique que les 43 premiers octets du fichier ont été reçus et que le prochain fragment à importer commence par l'octet 44.

  6. Maintenant que vous savez où reprendre l'importation, continuez à importer le fichier à partir du premier octet. Incluez un en-tête Content-Range pour indiquer la partie du fichier que vous envoyez. Par exemple, Content-Range: bytes 43-1999999 indique que vous envoyez des octets 44 à 2 000 000.

Gérer les erreurs d'importation de fichiers multimédias

Lorsque vous importez des médias, suivez ces bonnes pratiques pour gérer les erreurs:

  • Pour les erreurs 5xx, réactivez ou relancez les importations qui échouent en raison d'interruptions de connexion. Pour en savoir plus sur la gestion des erreurs 5xx, consultez Résoudre une erreur 5xx.
  • Pour les erreurs 403 rate limit, relancez l'importation. Pour en savoir plus sur la gestion des erreurs 403 rate limit, consultez Résoudre une erreur 403 error: Rate limit exceeded.
  • Pour les erreurs 4xx (y compris 403) lors d'une importation avec reprise, redémarrez l'importation. Ces erreurs indiquent que la session d'importation a expiré et doivent être redémarrées en demandant un nouvel URI de session. Les sessions d'importation expirent également après une semaine d'inactivité.

Importer dans les types Google Docs

Lorsque vous créez un fichier dans Drive, vous pouvez le convertir en un type de fichier Google Workspace, tel qu'un document Google Docs ou une feuille de calcul Google Sheets. Par exemple, si vous souhaitez convertir un document de votre logiciel de traitement de texte préféré en document Google Docs afin de profiter de ses fonctionnalités,

Pour convertir un fichier en un type de fichier Google Workspace spécifique, spécifiez l'mimeType de Google Workspace lors de la création du fichier.

Pour convertir un fichier CSV en feuille Google Workspace:

Java

drive/snippets/drive_v3/src/main/java/UploadWithConversion.java
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.FileContent;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.drive.Drive;
import com.google.api.services.drive.DriveScopes;
import com.google.api.services.drive.model.File;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;
import java.util.Arrays;

/* Class to demonstrate Drive's upload with conversion use-case. */
public class UploadWithConversion {

  /**
   * Upload file with conversion.
   *
   * @return Inserted file id if successful, {@code null} otherwise.
   * @throws IOException if service account credentials file not found.
   */
  public static String uploadWithConversion() throws IOException {
    // Load pre-authorized user credentials from the environment.
    // TODO(developer) - See https://developers.google.com/identity for
    // guides on implementing OAuth2 for your application.
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Arrays.asList(DriveScopes.DRIVE_FILE));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Build a new authorized API client service.
    Drive service = new Drive.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Drive samples")
        .build();

    // File's metadata.
    File fileMetadata = new File();
    fileMetadata.setName("My Report");
    fileMetadata.setMimeType("application/vnd.google-apps.spreadsheet");

    java.io.File filePath = new java.io.File("files/report.csv");
    FileContent mediaContent = new FileContent("text/csv", filePath);
    try {
      File file = service.files().create(fileMetadata, mediaContent)
          .setFields("id")
          .execute();
      System.out.println("File ID: " + file.getId());
      return file.getId();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      System.err.println("Unable to move file: " + e.getDetails());
      throw e;
    }
  }
}

Python

drive/snippets/drive-v3/file_snippet/upload_with_conversion.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from googleapiclient.http import MediaFileUpload


def upload_with_conversion():
    """Upload file with conversion
    Returns: ID of the file uploaded

    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()

    try:
        # create drive api client
        service = build('drive', 'v3', credentials=creds)

        file_metadata = {
            'name': 'My Report',
            'mimeType': 'application/vnd.google-apps.spreadsheet'
        }
        media = MediaFileUpload('report.csv', mimetype='text/csv',
                                resumable=True)
        # pylint: disable=maybe-no-member
        file = service.files().create(body=file_metadata, media_body=media,
                                      fields='id').execute()
        print(F'File with ID: "{file.get("id")}" has been uploaded.')

    except HttpError as error:
        print(F'An error occurred: {error}')
        file = None

    return file.get('id')


if __name__ == '__main__':
    upload_with_conversion()

Node.js

drive/snippets/drive_v3/file_snippets/upload_with_conversion.js
/**
 * Upload file with conversion
 * @return{obj} file Id
 * */
async function uploadWithConversion() {
  const fs = require('fs');
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');
  // Get credentials and build service
  // TODO (developer) - Use appropriate auth mechanism for your app
  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/drive',
  });
  const service = google.drive({version: 'v3', auth});
  const fileMetadata = {
    name: 'My Report',
    mimeType: 'application/vnd.google-apps.spreadsheet',
  };
  const media = {
    mimeType: 'text/csv',
    body: fs.createReadStream('files/report.csv'),
  };

  try {
    const file = await service.files.create({
      resource: fileMetadata,
      media: media,
      fields: 'id',
    });
    console.log('File Id:', file.data.id);
    return file.data.id;
  } catch (err) {
    // TODO(developer) - Handle error
    throw err;
  }
}

PHP

drive/snippets/drive_v3/src/DriveUploadWithConversion.php
use Google\Client;
use Google\Service\Drive;
function uploadWithConversion()
{
    try {
        $client = new Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Drive::DRIVE);
        $driveService = new Drive($client);
        $fileMetadata = new Drive\DriveFile(array(
            'name' => 'My Report',
            'mimeType' => 'application/vnd.google-apps.spreadsheet'));
        $content = file_get_contents('../files/report.csv');
        $file = $driveService->files->create($fileMetadata, array(
            'data' => $content,
            'mimeType' => 'text/csv',
            'uploadType' => 'multipart',
            'fields' => 'id'));
        printf("File ID: %s\n", $file->id);
        return $file->id;
    } catch(Exception $e) {
        echo "Error Message: ".$e;
    }

}

.NET

drive/snippets/drive_v3/DriveV3Snippets/UploadWithConversion.cs
using Google.Apis.Auth.OAuth2;
using Google.Apis.Drive.v3;
using Google.Apis.Services;

namespace DriveV3Snippets
{
    // Class to demonstrate Drive's upload with conversion use-case.
    public class UploadWithConversion
    {
        /// <summary>
        /// Upload file with conversion.
        /// </summary>
        /// <param name="filePath">Id of the spreadsheet file.</param>
        /// <returns>Inserted file id if successful, null otherwise.</returns>
        public static string DriveUploadWithConversion(string filePath)
        {
            try
            {
                /* Load pre-authorized user credentials from the environment.
                 TODO(developer) - See https://developers.google.com/identity for
                 guides on implementing OAuth2 for your application. */
                GoogleCredential credential = GoogleCredential.GetApplicationDefault()
                    .CreateScoped(DriveService.Scope.Drive);

                // Create Drive API service.
                var service = new DriveService(new BaseClientService.Initializer
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "Drive API Snippets"
                });

                // Upload file My Report on drive.
                var fileMetadata = new Google.Apis.Drive.v3.Data.File()
                {
                    Name = "My Report",
                    MimeType = "application/vnd.google-apps.spreadsheet"
                };
                FilesResource.CreateMediaUpload request;
                // Create a new drive.
                using (var stream = new FileStream(filePath,
                           FileMode.Open))
                {
                    // Create a new file, with metadata and stream.
                    request = service.Files.Create(
                        fileMetadata, stream, "text/csv");
                    request.Fields = "id";
                    request.Upload();
                }

                var file = request.ResponseBody;
                // Prints the uploaded file id.
                Console.WriteLine("File ID: " + file.Id);
                return file.Id;
            }
            catch (Exception e)
            {
                // TODO(developer) - handle error appropriately
                if (e is AggregateException)
                {
                    Console.WriteLine("Credential Not found");
                }
                else if (e is FileNotFoundException)
                {
                    Console.WriteLine("File not found");
                }
                else
                {
                    throw;
                }
            }
            return null;
        }
    }
}

Pour savoir si une conversion est disponible, consultez le tableau importFormats de la ressource À propos avant de créer le fichier. Les conversions compatibles sont disponibles de manière dynamique dans ce tableau. Voici quelques formats d'importation courants:

DeVers
Microsoft Word, OpenDocument Text, HTML, RTF, texte brutGoogle Docs
Microsoft Excel, feuille de calcul OpenDocument, CSV, TSV, texte brutGoogle Sheets
Microsoft PowerPoint, OpenDocument PresentationGoogle Slides
JPEG, PNG, GIF, BMP, PDFGoogle Docs (intègre l'image dans un document Docs)
Texte brut (type MIME spécial), JSONGoogle Apps Script

Lorsque vous importez et convertissez du contenu multimédia pendant une requête update dans un document, une feuille de calcul ou une diapositive, l'intégralité du contenu du document est remplacée.

Lorsque vous convertissez une image en document, Drive utilise la reconnaissance optique des caractères (OCR) pour la convertir en texte. Vous pouvez améliorer la qualité de l'algorithme OCR en spécifiant le code de langue BCP 47 applicable dans le paramètre ocrLanguage. Le texte extrait apparaît dans le document à côté de l'image intégrée.

Utiliser un ID prégénéré pour importer des fichiers

L'API Drive vous permet de récupérer la liste des ID de fichier prégénérés utilisés pour importer et créer des ressources. Les requêtes d'importation et de création de fichier peuvent utiliser ces ID prégénérés. Définissez le champ id dans les métadonnées du fichier.

Pour créer des ID prégénérés, appelez file.generateIds avec le nombre d'ID à créer.

Vous pouvez relancer des importations en toute sécurité avec des ID prégénérés en cas d'erreur ou de délai avant expiration indéterminé du serveur. Si le fichier a bien été créé, les tentatives suivantes renvoient une erreur HTTP 409 et ne créent pas de fichiers en double.

Définir du texte indexable pour les types de fichiers inconnus

L'interface utilisateur de Drive permet aux utilisateurs de rechercher du contenu dans un document. Vous pouvez également utiliser files.list et le champ fullText pour rechercher du contenu dans votre application. Pour en savoir plus, consultez la page Rechercher des fichiers et des dossiers.

Drive indexe automatiquement les documents lors des recherches lorsqu'il reconnaît le type de fichier, y compris les documents texte, les PDF, les images avec du texte et d'autres types courants. Si votre application enregistre d'autres types de fichiers (tels que des dessins, des vidéos et des raccourcis), vous pouvez améliorer la visibilité en fournissant du texte indexable dans le champ contentHints.indexableText du fichier.

Pour en savoir plus sur le texte indexable, consultez Gérer les métadonnées de fichiers.