Using files

Gemini API mbështet ngarkimin e skedarëve të medias veçmas nga hyrja e shpejtë, duke lejuar që media juaj të ripërdoret përmes kërkesave të shumta dhe kërkesave të shumta. Për më shumë detaje, shikoni udhëzuesin Prompting with media .

Metoda: media.ngarkoni

Krijon një File .

Pika përfundimtare

  • Ngarko URI, për kërkesat e ngarkimit të mediave:
    • postoni https: / /generativelanguage.googleapis.com /upload /v1beta /files
  • URI e meta të dhënave, për kërkesat vetëm për meta të dhëna:
    • postoni https: / /generativelanguage.googleapis.com /v1beta /files

    Trupi i kërkesës

    Trupi i kërkesës përmban të dhëna me strukturën e mëposhtme:

    Fushat
    objekti file object ( File )

    Fakultative. Metadata për skedarin për t'u krijuar.

    Shembull i kërkesës

    Imazhi Audio Teksti Video PDF
    Python Nyja.js Shkoni Shell 
    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=}")
    files.py
    // 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);
    files.js
    file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "Cajun_instruments.jpg"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Can you tell me about the instruments in this photo?"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    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
    files.sh
    Python Nyja.js Shkoni Shell 
    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=}")
    files.py
    // 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);
    files.js
    file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "sample.mp3"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Describe this audio clip"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    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
    files.sh
    Python Nyja.js Shkoni Shell 
    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=}")
    files.py
    // 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);
    files.js
    // Set MIME type explicitly for text files - the service may have difficulty
// distingushing between different MIME types of text files automatically.
file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "poem.txt"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Can you add a few more lines to this poem?"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    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

    files.sh
    Python Nyja.js Shkoni Shell 
    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=}")

# Videos need to be processed before you can use them.
while myfile.state.name == "PROCESSING":
    print("processing video...")
    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=}")
    files.py
    // 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);
    files.js
    file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "earth.mp4"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

// Videos need to be processed before you can use them.
for file.State == genai.FileStateProcessing {
	log.Printf("processing %s", file.Name)
	time.Sleep(5 * time.Second)
	var err error
	if file, err = client.GetFile(ctx, file.Name); err != nil {
		log.Fatal(err)
	}
}
if file.State != genai.FileStateActive {
	log.Fatalf("uploaded file has state %s, not active", file.State)
}

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Describe this video clip"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    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
    files.sh
    Python 
    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)
    files.py

    Trupi i reagimit

    Përgjigje për media.upload .

    Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

    Fushat
    objekti file object ( File )

    Meta të dhënat për skedarin e krijuar.

    Përfaqësimi JSON 
    {
  "file": {
    object (File)
  }
}

    Metoda: files.get

    Merr meta të dhënat për File e dhënë.

    Pika përfundimtare

    merrni https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Parametrat e rrugës

    string name

    E detyrueshme. Emri i File për të marrë. Shembull: files/abc-123 Ajo merr formën files/{file} .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull i kërkesës

    Python Nyja.js Shkoni Shell 
    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)
    files.py
    // 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);
    files.js
    file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "personWorkingOnComputer.jpg"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

gotFile, err := client.GetFile(ctx, file.Name)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Got file:", gotFile.Name)

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Describe this image"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    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
    files.sh

    Trupi i reagimit

    Nëse është i suksesshëm, trupi i përgjigjes përmban një shembull të File .

    Metoda: skedarët.lista

    Liston meta të dhënat për File në pronësi të projektit kërkues.

    Pika përfundimtare

    merrni https: / /generativelanguage.googleapis.com /v1beta /files

    Parametrat e pyetjes

    integer pageSize

    Fakultative. Numri maksimal i File për t'u kthyer për faqe. Nëse nuk specifikohet, si parazgjedhje është 10. Madhësia maksimale pageSize është 100.

    vargu string pageToken

    Fakultative. Një shenjë faqeje nga një thirrje e mëparshme files.list .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull i kërkesës

    Python Nyja.js Shkoni Shell 
    from google import genai

client = genai.Client()
print("My files:")
for f in client.files.list():
    print("  ", f.name)
    files.py
    // 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();
}
    files.js
    iter := client.ListFiles(ctx)
for {
	ifile, err := iter.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ifile.Name)
}
    docs-snippets_test.go
    echo "My files: "

curl "https://generativelanguage.googleapis.com/v1beta/files?key=$GEMINI_API_KEY"
    files.sh

    Trupi i reagimit

    Përgjigje për files.list .

    Nëse është i suksesshëm, trupi i përgjigjes përmban të dhëna me strukturën e mëposhtme:

    Fushat
    files[] object ( File )

    Lista e File s.

    string nextPageToken

    Një shenjë që mund të dërgohet si një pageToken në një thirrje të mëpasshme files.list .

    Përfaqësimi JSON 
    {
  "files": [
    {
      object (File)
    }
  ],
  "nextPageToken": string
}

    Metoda: skedarët.fshi

    Fshin File .

    Pika përfundimtare

    fshi https: / /generativelanguage.googleapis.com /v1beta /{name=files /*}

    Parametrat e rrugës

    string name

    E detyrueshme. Emri i File që duhet fshirë. Shembull: files/abc-123 Ajo merr formën files/{file} .

    Trupi i kërkesës

    Trupi i kërkesës duhet të jetë bosh.

    Shembull i kërkesës

    Python Nyja.js Shkoni Shell 
    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
    files.py
    // The Gen AI SDK for TypeScript and JavaScript is in preview.
// Some features have not been implemented.
    README.md
    file, err := client.UploadFileFromPath(ctx, filepath.Join(testDataDir, "personWorkingOnComputer.jpg"), nil)
if err != nil {
	log.Fatal(err)
}
defer client.DeleteFile(ctx, file.Name)

gotFile, err := client.GetFile(ctx, file.Name)
if err != nil {
	log.Fatal(err)
}
fmt.Println("Got file:", gotFile.Name)

model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx,
	genai.FileData{URI: file.URI},
	genai.Text("Describe this image"))
if err != nil {
	log.Fatal(err)
}

printResponse(resp)
    docs-snippets_test.go
    curl --request "DELETE" https://generativelanguage.googleapis.com/v1beta/files/$name?key=$GEMINI_API_KEY
    files.sh

    Trupi i reagimit

    Nëse është i suksesshëm, trupi i përgjigjes është një objekt JSON bosh.

    Burimi REST: skedarët

    Burimi: Skedari

    Një skedar i ngarkuar në API. ID tjetër: 15

    Fushat
    string name

    E pandryshueshme. Identifikues. Emri i burimit të File . ID-ja (emri duke përjashtuar prefiksin "skedarë/") mund të përmbajë deri në 40 karaktere që janë alfanumerike të vogla ose viza (-). ID-ja nuk mund të fillojë ose të përfundojë me një vizë. Nëse emri është bosh gjatë krijimit, do të krijohet një emër unik. Shembull: files/123-456

    string displayName

    Fakultative. Emri i ekranit i lexueshëm nga njeriu për File . Emri i shfaqur duhet të jetë jo më shumë se 512 karaktere i gjatë, duke përfshirë hapësirat. Shembull: "Imazhi i mirëseardhjes"

    string mimeType

    Vetëm dalje. Lloji MIME i skedarit.

    Vargu sizeBytes string ( int64 format)

    Vetëm dalje. Madhësia e skedarit në bajt.

    createTime string ( Timestamp format)

    Vetëm dalje. Vula kohore e krijimit të File .

    Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    Vargu updateTime string ( Timestamp format)

    Vetëm dalje. Vula kohore e përditësimit të fundit të File .

    Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    expirationTime string ( Timestamp format)

    Vetëm dalje. Vula kohore kur do të fshihet File . Vendoseni vetëm nëse File është planifikuar të skadojë.

    Përdor RFC 3339, ku prodhimi i gjeneruar gjithmonë do të normalizohet me Z dhe përdor 0, 3, 6 ose 9 shifra të pjesshme. Kompensimet e tjera përveç "Z" pranohen gjithashtu. Shembuj: "2014-10-02T15:01:23Z" , "2014-10-02T15:01:23.045123456Z" ose "2014-10-02T15:01:23+05:30" .

    sha256Hash string ( bytes format)

    Vetëm dalje. SHA-256 hash i bajteve të ngarkuara.

    Një varg i koduar me bazë 64.

    string uri

    Vetëm dalje. Uri i File .

    downloadUri string

    Vetëm dalje. File i skedarit .

    numri i state enum ( State )

    Vetëm dalje. Gjendja e përpunimit të skedarit.

    source enum ( Source )

    Burimi i Dosjes.

    error object ( Status )

    Vetëm dalje. Statusi i gabimit nëse përpunimi i skedarit dështoi.

    Union type metadata
    Të dhënat meta për skedarin. metadata mund të jenë vetëm një nga sa vijon:
    Objekti videoMetadata object ( VideoMetadata )

    Vetëm dalje. Të dhënat meta për një video.

    Përfaqësimi 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 (VideoMetadata)
  }
  // Union type
}

    VideoMetadata

    Të dhënat meta për një File video.

    Fushat
    Vargu i kohëzgjatjes videoDuration string ( Duration format)

    Kohëzgjatja e videos.

    Një kohëzgjatje në sekonda me deri në nëntë shifra të pjesshme, që mbarojnë me ' s '. Shembull: "3.5s" .

    Përfaqësimi JSON 
    {
  "videoDuration": string
}

    Shtetit

    Gjendjet për ciklin jetësor të një skedari.

    Enums
    STATE_UNSPECIFIED Vlera e paracaktuar. Kjo vlerë përdoret nëse gjendja hiqet.
    PROCESSING Skedari është duke u përpunuar dhe nuk mund të përdoret ende për përfundime.
    ACTIVE Skedari është përpunuar dhe i disponueshëm për përfundime.
    FAILED Përpunimi i skedarit dështoi.

    Burimi

    Enums
    SOURCE_UNSPECIFIED Përdoret nëse burimi nuk është i specifikuar.
    UPLOADED Tregon se skedari është ngarkuar nga përdoruesi.
    GENERATED Tregon se skedari është krijuar nga Google.

    Statusi

    Lloji i Status përcakton një model gabimi logjik që është i përshtatshëm për mjedise të ndryshme programimi, duke përfshirë API-të REST dhe API-të RPC. Përdoret nga gRPC . Çdo mesazh Status përmban tre pjesë të të dhënave: kodin e gabimit, mesazhin e gabimit dhe detajet e gabimit.

    Mund të mësoni më shumë rreth këtij modeli gabimi dhe si të punoni me të në Udhëzuesin e Dizajnit API .

    Fushat
    code integer

    Kodi i statusit, i cili duhet të jetë një vlerë e numrit të google.rpc.Code .

    string message

    Një mesazh gabimi përballë zhvilluesit, i cili duhet të jetë në anglisht. Çdo mesazh gabimi që përballet me përdoruesin duhet të lokalizohet dhe të dërgohet në fushën google.rpc.Status.details ose të lokalizohet nga klienti.

    details[] object

    Një listë e mesazheve që përmbajnë detajet e gabimit. Ekziston një grup i zakonshëm i llojeve të mesazheve për përdorim nga API.

    Një objekt që përmban fusha të një lloji arbitrar. Një fushë shtesë "@type" përmban një URI që identifikon llojin. Shembull: { "id": 1234, "@type": "types.example.com/standard/id" } .

    Përfaqësimi JSON 
    {
  "code": integer,
  "message": string,
  "details": [
    {
      "@type": string,
      field1: ...,
      ...
    }
  ]
}