Using files

API Gemini поддерживает загрузку медиафайлов отдельно от ввода подсказок, что позволяет повторно использовать ваши медиа в нескольких запросах и нескольких подсказках. Для получения более подробной информации ознакомьтесь с руководством Prompting with media .

Метод: media.upload

Создает File .

Конечная точка

  • URI загрузки для запросов на загрузку медиафайлов:
  • пост https: / /generativelanguage.googleapis.com /upload /v1beta /files
  • URI метаданных для запросов только метаданных:
  • пост https: / /generativelanguage.googleapis.com /v1beta /files

    Текст запроса

    Тело запроса содержит данные со следующей структурой:

    Поля
    file object ( File )

    Необязательно. Метаданные для создаваемого файла.

    Пример запроса

    from google import genai
    
    client = genai.Client()
    myfile = client.files.upload(file=media / "Cajun_instruments.jpg")
    print(f"{myfile=}")
    
    result = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=[
            myfile,
            "\n\n",
            "Can you tell me about the instruments in this photo?",
        ],
    )
    print(f"{result.text=}")
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    const myfile = await ai.files.upload({
      file: path.join(media, "Cajun_instruments.jpg"),
      config: { mimeType: "image/jpeg" },
    });
    console.log("Uploaded file:", myfile);
    
    const result = await ai.models.generateContent({
      model: "gemini-2.0-flash",
      contents: createUserContent([
        createPartFromUri(myfile.uri, myfile.mimeType),
        "\n\n",
        "Can you tell me about the instruments in this photo?",
      ]),
    });
    console.log("result.text=", result.text);
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    myfile, err := client.Files.UploadFromPath(
    	ctx, 
    	filepath.Join(getMedia(), "Cajun_instruments.jpg"), 
    	&genai.UploadFileConfig{
    		MIMEType : "image/jpeg",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Printf("myfile=%+v\n", myfile)
    
    parts := []*genai.Part{
    	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
    	genai.NewPartFromText("\n\n"),
    	genai.NewPartFromText("Can you tell me about the instruments in this photo?"),
    }
    
    contents := []*genai.Content{
    	genai.NewContentFromParts(parts, "user"),
    }
    
    response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
    if err != nil {
    	log.Fatal(err)
    }
    text := response.Text()
    fmt.Printf("result.text=%s\n", text)
    MIME_TYPE=$(file -b --mime-type "${IMG_PATH_2}")
    NUM_BYTES=$(wc -c < "${IMG_PATH_2}")
    DISPLAY_NAME=TEXT
    
    tmp_header_file=upload-header.tmp
    
    # Initial resumable request defining metadata.
    # The upload url is in the response headers dump them to a file.
    curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
      -D upload-header.tmp \
      -H "X-Goog-Upload-Protocol: resumable" \
      -H "X-Goog-Upload-Command: start" \
      -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
      -H "Content-Type: application/json" \
      -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null
    
    upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
    rm "${tmp_header_file}"
    
    # Upload the actual bytes.
    curl "${upload_url}" \
      -H "Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Offset: 0" \
      -H "X-Goog-Upload-Command: upload, finalize" \
      --data-binary "@${IMG_PATH_2}" 2> /dev/null > file_info.json
    
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri
    
    # Now generate content using that file
    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
        -H 'Content-Type: application/json' \
        -X POST \
        -d '{
          "contents": [{
            "parts":[
              {"text": "Can you tell me about the instruments in this photo?"},
              {"file_data":
                {"mime_type": "image/jpeg", 
                "file_uri": '$file_uri'}
            }]
            }]
           }' 2> /dev/null > response.json
    
    cat response.json
    echo
    
    jq ".candidates[].content.parts[].text" response.json
    from google import genai
    
    client = genai.Client()
    myfile = client.files.upload(file=media / "sample.mp3")
    print(f"{myfile=}")
    
    result = client.models.generate_content(
        model="gemini-2.0-flash", contents=[myfile, "Describe this audio clip"]
    )
    print(f"{result.text=}")
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    const myfile = await ai.files.upload({
      file: path.join(media, "sample.mp3"),
      config: { mimeType: "audio/mpeg" },
    });
    console.log("Uploaded file:", myfile);
    
    const result = await ai.models.generateContent({
      model: "gemini-2.0-flash",
      contents: createUserContent([
        createPartFromUri(myfile.uri, myfile.mimeType),
        "Describe this audio clip",
      ]),
    });
    console.log("result.text=", result.text);
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    myfile, err := client.Files.UploadFromPath(
    	ctx, 
    	filepath.Join(getMedia(), "sample.mp3"), 
    	&genai.UploadFileConfig{
    		MIMEType : "audio/mpeg",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Printf("myfile=%+v\n", myfile)
    
    parts := []*genai.Part{
    	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
    	genai.NewPartFromText("Describe this audio clip"),
    }
    
    contents := []*genai.Content{
    	genai.NewContentFromParts(parts, "user"),
    }
    
    response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
    if err != nil {
    	log.Fatal(err)
    }
    text := response.Text()
    fmt.Printf("result.text=%s\n", text)
    MIME_TYPE=$(file -b --mime-type "${AUDIO_PATH}")
    NUM_BYTES=$(wc -c < "${AUDIO_PATH}")
    DISPLAY_NAME=AUDIO
    
    tmp_header_file=upload-header.tmp
    
    # Initial resumable request defining metadata.
    # The upload url is in the response headers dump them to a file.
    curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
      -D upload-header.tmp \
      -H "X-Goog-Upload-Protocol: resumable" \
      -H "X-Goog-Upload-Command: start" \
      -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
      -H "Content-Type: application/json" \
      -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null
    
    upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
    rm "${tmp_header_file}"
    
    # Upload the actual bytes.
    curl "${upload_url}" \
      -H "Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Offset: 0" \
      -H "X-Goog-Upload-Command: upload, finalize" \
      --data-binary "@${AUDIO_PATH}" 2> /dev/null > file_info.json
    
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri
    
    # Now generate content using that file
    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
        -H 'Content-Type: application/json' \
        -X POST \
        -d '{
          "contents": [{
            "parts":[
              {"text": "Describe this audio clip"},
              {"file_data":{"mime_type": "audio/mp3", "file_uri": '$file_uri'}}]
            }]
           }' 2> /dev/null > response.json
    
    cat response.json
    echo
    
    jq ".candidates[].content.parts[].text" response.json
    from google import genai
    
    client = genai.Client()
    myfile = client.files.upload(file=media / "poem.txt")
    print(f"{myfile=}")
    
    result = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=[myfile, "\n\n", "Can you add a few more lines to this poem?"],
    )
    print(f"{result.text=}")
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    const myfile = await ai.files.upload({
      file: path.join(media, "poem.txt"),
    });
    console.log("Uploaded file:", myfile);
    
    const result = await ai.models.generateContent({
      model: "gemini-2.0-flash",
      contents: createUserContent([
        createPartFromUri(myfile.uri, myfile.mimeType),
        "\n\n",
        "Can you add a few more lines to this poem?",
      ]),
    });
    console.log("result.text=", result.text);
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    
    myfile, err := client.Files.UploadFromPath(
    	ctx, 
    	filepath.Join(getMedia(), "poem.txt"), 
    	&genai.UploadFileConfig{
    		MIMEType : "text/plain",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Printf("myfile=%+v\n", myfile)
    
    parts := []*genai.Part{
    	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
    	genai.NewPartFromText("\n\n"),
    	genai.NewPartFromText("Can you add a few more lines to this poem?"),
    }
    
    contents := []*genai.Content{
    	genai.NewContentFromParts(parts, "user"),
    }
    
    response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
    if err != nil {
    	log.Fatal(err)
    }
    text := response.Text()
    fmt.Printf("result.text=%s\n", text)
    MIME_TYPE=$(file -b --mime-type "${TEXT_PATH}")
    NUM_BYTES=$(wc -c < "${TEXT_PATH}")
    DISPLAY_NAME=TEXT
    
    tmp_header_file=upload-header.tmp
    
    # Initial resumable request defining metadata.
    # The upload url is in the response headers dump them to a file.
    curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
      -D upload-header.tmp \
      -H "X-Goog-Upload-Protocol: resumable" \
      -H "X-Goog-Upload-Command: start" \
      -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
      -H "Content-Type: application/json" \
      -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null
    
    upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
    rm "${tmp_header_file}"
    
    # Upload the actual bytes.
    curl "${upload_url}" \
      -H "Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Offset: 0" \
      -H "X-Goog-Upload-Command: upload, finalize" \
      --data-binary "@${TEXT_PATH}" 2> /dev/null > file_info.json
    
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri
    
    # Now generate content using that file
    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
        -H 'Content-Type: application/json' \
        -X POST \
        -d '{
          "contents": [{
            "parts":[
              {"text": "Can you add a few more lines to this poem?"},
              {"file_data":{"mime_type": "text/plain", "file_uri": '$file_uri'}}]
            }]
           }' 2> /dev/null > response.json
    
    cat response.json
    echo
    
    jq ".candidates[].content.parts[].text" response.json
    
    name=$(jq ".file.name" file_info.json)
    # Get the file of interest to check state
    curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
    # Print some information about the file you got
    name=$(jq ".file.name" file_info.json)
    echo name=$name
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri
    
    curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY
    
    from google import genai
    import time
    
    client = genai.Client()
    # Video clip (CC BY 3.0) from https://peach.blender.org/download/
    myfile = client.files.upload(file=media / "Big_Buck_Bunny.mp4")
    print(f"{myfile=}")
    
    # Poll until the video file is completely processed (state becomes ACTIVE).
    while not myfile.state or myfile.state.name != "ACTIVE":
        print("Processing video...")
        print("File state:", myfile.state)
        time.sleep(5)
        myfile = client.files.get(name=myfile.name)
    
    result = client.models.generate_content(
        model="gemini-2.0-flash", contents=[myfile, "Describe this video clip"]
    )
    print(f"{result.text=}")
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    let myfile = await ai.files.upload({
      file: path.join(media, "Big_Buck_Bunny.mp4"),
      config: { mimeType: "video/mp4" },
    });
    console.log("Uploaded video file:", myfile);
    
    // Poll until the video file is completely processed (state becomes ACTIVE).
    while (!myfile.state || myfile.state.toString() !== "ACTIVE") {
      console.log("Processing video...");
      console.log("File state: ", myfile.state);
      await sleep(5000);
      myfile = await ai.files.get({ name: myfile.name });
    }
    
    const result = await ai.models.generateContent({
      model: "gemini-2.0-flash",
      contents: createUserContent([
        createPartFromUri(myfile.uri, myfile.mimeType),
        "Describe this video clip",
      ]),
    });
    console.log("result.text=", result.text);
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    myfile, err := client.Files.UploadFromPath(
    	ctx, 
    	filepath.Join(getMedia(), "Big_Buck_Bunny.mp4"), 
    	&genai.UploadFileConfig{
    		MIMEType : "video/mp4",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Printf("myfile=%+v\n", myfile)
    
    // Poll until the video file is completely processed (state becomes ACTIVE).
    for myfile.State == genai.FileStateUnspecified || myfile.State != genai.FileStateActive {
    	fmt.Println("Processing video...")
    	fmt.Println("File state:", myfile.State)
    	time.Sleep(5 * time.Second)
    
    	myfile, err = client.Files.Get(ctx, myfile.Name, nil)
    	if err != nil {
    		log.Fatal(err)
    	}
    }
    
    parts := []*genai.Part{
    	genai.NewPartFromURI(myfile.URI, myfile.MIMEType),
    	genai.NewPartFromText("Describe this video clip"),
    }
    
    contents := []*genai.Content{
    	genai.NewContentFromParts(parts, "user"),
    }
    
    response, err := client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
    if err != nil {
    	log.Fatal(err)
    }
    text := response.Text()
    fmt.Printf("result.text=%s\n", text)
    MIME_TYPE=$(file -b --mime-type "${VIDEO_PATH}")
    NUM_BYTES=$(wc -c < "${VIDEO_PATH}")
    DISPLAY_NAME=VIDEO_PATH
    
    # Initial resumable request defining metadata.
    # The upload url is in the response headers dump them to a file.
    curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
      -D upload-header.tmp \
      -H "X-Goog-Upload-Protocol: resumable" \
      -H "X-Goog-Upload-Command: start" \
      -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
      -H "Content-Type: application/json" \
      -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null
    
    upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
    rm "${tmp_header_file}"
    
    # Upload the actual bytes.
    curl "${upload_url}" \
      -H "Content-Length: ${NUM_BYTES}" \
      -H "X-Goog-Upload-Offset: 0" \
      -H "X-Goog-Upload-Command: upload, finalize" \
      --data-binary "@${VIDEO_PATH}" 2> /dev/null > file_info.json
    
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri
    
    state=$(jq ".file.state" file_info.json)
    echo state=$state
    
    # Ensure the state of the video is 'ACTIVE'
    while [[ "($state)" = *"PROCESSING"* ]];
    do
      echo "Processing video..."
      sleep 5
      # Get the file of interest to check state
      curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
      state=$(jq ".file.state" file_info.json)
    done
    
    # Now generate content using that file
    curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GEMINI_API_KEY" \
        -H 'Content-Type: application/json' \
        -X POST \
        -d '{
          "contents": [{
            "parts":[
              {"text": "Describe this video clip"},
              {"file_data":{"mime_type": "video/mp4", "file_uri": '$file_uri'}}]
            }]
           }' 2> /dev/null > response.json
    
    cat response.json
    echo
    
    jq ".candidates[].content.parts[].text" response.json
    from google import genai
    
    client = genai.Client()
    sample_pdf = client.files.upload(file=media / "test.pdf")
    response = client.models.generate_content(
        model="gemini-2.0-flash",
        contents=["Give me a summary of this pdf file.", sample_pdf],
    )
    print(response.text)

    Тело ответа

    Ответ для media.upload .

    В случае успеха тело ответа содержит данные со следующей структурой:

    Поля
    file object ( File )

    Метаданные для созданного файла.

    JSON-представление
    {
      "file": {
        object (File)
      }
    }

    Метод: files.get

    Получает метаданные для указанного File .

    Конечная точка

    получить https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Параметры пути

    name string

    Обязательно. Имя File , который нужно получить. Пример: files/abc-123 Он имеет вид files/{file} .

    Текст запроса

    Тело запроса должно быть пустым.

    Пример запроса

    from google import genai
    
    client = genai.Client()
    myfile = client.files.upload(file=media / "poem.txt")
    file_name = myfile.name
    print(file_name)  # "files/*"
    
    myfile = client.files.get(name=file_name)
    print(myfile)
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    const myfile = await ai.files.upload({
      file: path.join(media, "poem.txt"),
    });
    const fileName = myfile.name;
    console.log(fileName);
    
    const fetchedFile = await ai.files.get({ name: fileName });
    console.log(fetchedFile);
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    myfile, err := client.Files.UploadFromPath(
    	ctx,
    	filepath.Join(getMedia(), "poem.txt"), 
    	&genai.UploadFileConfig{
    		MIMEType: "text/plain",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    fileName := myfile.Name
    fmt.Println(fileName)
    file, err := client.Files.Get(ctx, fileName, nil)
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Println(file)
    name=$(jq ".file.name" file_info.json)
    # Get the file of interest to check state
    curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
    # Print some information about the file you got
    name=$(jq ".file.name" file_info.json)
    echo name=$name
    file_uri=$(jq ".file.uri" file_info.json)
    echo file_uri=$file_uri

    Тело ответа

    В случае успеха тело ответа содержит экземпляр File .

    Метод: files.list

    Перечисляет метаданные для File , принадлежащих запрашивающему проекту.

    Конечная точка

    получить https: / /generativelanguage.googleapis.com /v1beta /files

    Параметры запроса

    pageSize integer

    Необязательно. Максимальное количество File для возврата на страницу. Если не указано, по умолчанию 10. Максимальный pageSize равен 100.

    string pageToken

    Необязательно. Токен страницы из предыдущего вызова files.list .

    Текст запроса

    Тело запроса должно быть пустым.

    Пример запроса

    from google import genai
    
    client = genai.Client()
    print("My files:")
    for f in client.files.list():
        print("  ", f.name)
    // Make sure to include the following import:
    // import {GoogleGenAI} from '@google/genai';
    const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
    console.log("My files:");
    // Using the pager style to list files
    const pager = await ai.files.list({ config: { pageSize: 10 } });
    let page = pager.page;
    const names = [];
    while (true) {
      for (const f of page) {
        console.log("  ", f.name);
        names.push(f.name);
      }
      if (!pager.hasNextPage()) break;
      page = await pager.nextPage();
    }
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    fmt.Println("My files:")
    page, err := client.Files.List(ctx, nil)
    if err != nil {
    	log.Fatal(err)
    }
    for _, f := range page.Items {
    	fmt.Println("  ", f.Name)
    }
    echo "My files: "
    
    curl "https://generativelanguage.googleapis.com/v1beta/files?key=$GEMINI_API_KEY"

    Тело ответа

    Ответ для files.list .

    В случае успеха тело ответа содержит данные со следующей структурой:

    Поля
    files[] object ( File )

    Список File s.

    string nextPageToken

    Токен, который можно отправить как pageToken в последующий вызов files.list .

    JSON-представление
    {
      "files": [
        {
          object (File)
        }
      ],
      "nextPageToken": string
    }

    Метод: files.delete

    Удаляет File .

    Конечная точка

    удалить https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Параметры пути

    name string

    Обязательно. Имя File для удаления. Пример: files/abc-123 Он имеет вид files/{file} .

    Текст запроса

    Тело запроса должно быть пустым.

    Пример запроса

    from google import genai
    
    client = genai.Client()
    myfile = client.files.upload(file=media / "poem.txt")
    
    client.files.delete(name=myfile.name)
    
    try:
        result = client.models.generate_content(
            model="gemini-2.0-flash", contents=[myfile, "Describe this file."]
        )
        print(result)
    except genai.errors.ClientError:
        pass
    // The Gen AI SDK for TypeScript and JavaScript is in preview.
    // Some features have not been implemented.
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
    	APIKey:  os.Getenv("GEMINI_API_KEY"),
    	Backend: genai.BackendGeminiAPI,
    })
    if err != nil {
    	log.Fatal(err)
    }
    myfile, err := client.Files.UploadFromPath(
    	ctx, 
    	filepath.Join(getMedia(), "poem.txt"), 
    	&genai.UploadFileConfig{
    		MIMEType: "text/plain",
    	},
    )
    if err != nil {
    	log.Fatal(err)
    }
    // Delete the file.
    _, err = client.Files.Delete(ctx, myfile.Name, nil)
    if err != nil {
    	log.Fatal(err)
    }
    // Attempt to use the deleted file.
    parts := []*genai.Part{
    	genai.NewPartFromURI(myfile.URI, myfile.MIMEType,),
    	genai.NewPartFromText("Describe this file."),
    }
    
    contents := []*genai.Content{
    	genai.NewContentFromParts(parts, "user"),
    }
    
    _, err = client.Models.GenerateContent(ctx, "gemini-2.0-flash", contents, nil)
    // Expect an error when using a deleted file.
    if err != nil {
    	return nil
    }
    return fmt.Errorf("expected an error when using deleted file")
    curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY

    Тело ответа

    В случае успеха тело ответа представляет собой пустой объект JSON.

    Ресурс REST: файлы

    Ресурс: Файл

    Файл загружен в API. Следующий ID: 15

    Поля
    name string

    Неизменяемый. Идентификатор. Имя ресурса File . Идентификатор (имя без префикса "files/") может содержать до 40 символов, которые являются строчными буквами, цифрами или дефисами (-). Идентификатор не может начинаться или заканчиваться дефисом. Если имя пустое при создании, будет сгенерировано уникальное имя. Пример: files/123-456

    displayName string

    Необязательно. Удобочитаемое отображаемое имя для File . Отображаемое имя должно быть не длиннее 512 символов, включая пробелы. Пример: "Welcome Image"

    string mimeType

    Только вывод. MIME-тип файла.

    string ( int64 format) sizeBytes (формат int64)

    Только вывод. Размер файла в байтах.

    createTime string ( Timestamp format)

    Только вывод. Метка времени создания File .

    Использует RFC 3339, где сгенерированный вывод всегда будет Z-нормализованным и использует 0, 3, 6 или 9 дробных цифр. Смещения, отличные от "Z", также принимаются. Примеры: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" или "2014-10-02T15:01:23+05:30" .

    строка updateTime string ( Timestamp format)

    Только вывод. Метка времени последнего обновления File .

    Использует RFC 3339, где сгенерированный вывод всегда будет Z-нормализованным и использует 0, 3, 6 или 9 дробных цифр. Смещения, отличные от "Z", также принимаются. Примеры: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" или "2014-10-02T15:01:23+05:30" .

    строка expirationTime string ( Timestamp format)

    Только вывод. Временная метка, когда File будет удален. Устанавливается только в том случае, если File должен истечь.

    Использует RFC 3339, где сгенерированный вывод всегда будет Z-нормализованным и использует 0, 3, 6 или 9 дробных цифр. Смещения, отличные от "Z", также принимаются. Примеры: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" или "2014-10-02T15:01:23+05:30" .

    sha256Hash string ( bytes format)

    Только вывод. SHA-256 хэш загруженных байтов.

    Строка в кодировке base64.

    string uri

    Только вывод. URI File .

    string downloadUri

    Только вывод. URI загрузки File .

    state enum ( State )

    Только вывод. Состояние обработки файла.

    source enum ( Source )

    Источник файла.

    object ( Status ) error (статус)

    Только вывод. Статус ошибки, если обработка файла не удалась.

    metadata Union type
    Метаданные для файла. metadata могут быть только одними из следующих:
    object ( VideoFileMetadata ) videoMetadata ( VideoFileMetadata )

    Только вывод. Метаданные для видео.

    JSON-представление
    {
      "name": string,
      "displayName": string,
      "mimeType": string,
      "sizeBytes": string,
      "createTime": string,
      "updateTime": string,
      "expirationTime": string,
      "sha256Hash": string,
      "uri": string,
      "downloadUri": string,
      "state": enum (State),
      "source": enum (Source),
      "error": {
        object (Status)
      },
    
      // metadata
      "videoMetadata": {
        object (VideoFileMetadata)
      }
      // Union type
    }

    ВидеофайлМетаданные

    Метаданные для File .

    Поля
    videoDuration string ( Duration format)

    Продолжительность видео.

    Длительность в секундах с дробной частью до девяти цифр, заканчивающаяся на ' s '. Пример: "3.5s" .

    JSON-представление
    {
      "videoDuration": string
    }

    Состояние

    Состояния жизненного цикла файла.

    Перечисления
    STATE_UNSPECIFIED Значение по умолчанию. Это значение используется, если состояние пропущено.
    PROCESSING Файл обрабатывается и пока не может быть использован для вывода.
    ACTIVE Файл обработан и доступен для вывода.
    FAILED Файл не удалось обработать.

    Источник

    Перечисления
    SOURCE_UNSPECIFIED Используется, если источник не указан.
    UPLOADED Указывает, что файл загружен пользователем.
    GENERATED Указывает, что файл создан Google.

    Статус

    Тип Status определяет логическую модель ошибок, подходящую для различных сред программирования, включая REST API и RPC API. Он используется gRPC . Каждое сообщение Status содержит три фрагмента данных: код ошибки, сообщение об ошибке и сведения об ошибке.

    Дополнительную информацию об этой модели ошибок и о том, как с ней работать, можно найти в Руководстве по проектированию API .

    Поля
    code integer

    Код состояния, который должен быть значением перечисления google.rpc.Code .

    string message

    Сообщение об ошибке, с которым сталкивается разработчик, которое должно быть на английском языке. Любое сообщение об ошибке, с которым сталкивается пользователь, должно быть локализовано и отправлено в поле google.rpc.Status.details или локализовано клиентом.

    details[] object

    Список сообщений, содержащих сведения об ошибках. Существует общий набор типов сообщений для использования API.

    Объект, содержащий поля произвольного типа. Дополнительное поле "@type" содержит URI, идентифицирующий тип. Пример: { "id": 1234, "@type": "types.example.com/standard/id" } .

    JSON-представление
    {
      "code": integer,
      "message": string,
      "details": [
        {
          "@type": string,
          field1: ...,
          ...
        }
      ]
    }