Video Yükleme ve Videoyla İlgili Hak Talebinde Bulunma

Not: YouTube Content ID API, YouTube içerik iş ortaklarının kullanımı için tasarlanmıştır ve tüm geliştiriciler ya da tüm YouTube kullanıcıları tarafından kullanılamaz. YouTube Content ID API'yi Google API Konsolu'nda listelenen hizmetlerden biri olarak görmüyorsanız YouTube İş Ortağı Programı hakkında daha fazla bilgi edinmek için YouTube Yardım Merkezi'ni ziyaret edin.

Bu kod örneğinde, YouTube videosunun nasıl yükleneceği ve videoya para kazanma politikasının nasıl uygulanacağı gösterilmektedir. Bir videodan para kazanmak için YouTube hak yönetimi sisteminde asset ile videoyla ilgili hak talebinde bulunmanız gerekir. Örnek; videoyu yükler, yeni bir öğe oluşturur, öğeyi kullanan videoyla ilgili hak talebinde bulunur ve videoya para kazanma politikası uygular.

Bu örnek, kodun ilgili bölümleriyle birlikte sürece dahil edilen bir dizi adım olarak sunulmaktadır. Komut dosyasının tamamını bu sayfanın sonunda bulabilirsiniz. Bu kod Python'da yazılmıştır. Diğer popüler programlama dilleri için istemci kitaplıkları da mevcuttur.

Koşullar

1. Adım: Yaygın kullanılan temizlik işlevleri

Kod örneğinin ilk bölümleri, birçok komut dosyasında sık kullanılan temel temizlik işlevlerini yerine getirir: komut satırını ayrıştırma, kullanıcının kimliğini doğrulama ve gerekli API hizmetlerini edinme.

Komut satırını ayrıştırma

parse_options yöntemi, her komut satırı bağımsız değişkenini özellik olarak içeren bir options nesnesi oluşturmak için Python istemci kitaplığındaki OptionParser öğesini kullanır. Sonraki yöntemler, gerektiğinde options nesnesinden değerler alır.

Örnek komut dosyasının komut satırı bağımsız değişkenleri aşağıda listelenmiştir. İlk ikisi (file ve channelId) zorunludur, geri kalanlar isteğe bağlıdır.

  • file: Yüklenecek video dosyasının adı ve konumu.

    Example: --file="/home/path/to/file.mov"

  • channelId: Videoyu yüklemek istediğiniz YouTube kanalı. Kanal, kimliği doğrulanmış kullanıcının YouTube İçerik Yöneticisi hesabı tarafından yönetilmelidir. Kanal kimliğini, kimliği doğrulanmış kullanıcıya ilişkin YouTube hesap ayarlarından veya channels.list yöntemini kullanarak alabilirsiniz.

    Example: --channelId="UC_x5XG1OV2P6uZZ5FSM9Ttw"

  • title: Yüklemekte olduğunuz videonun başlığı. Varsayılan değer: Test title.

    Example: --title="Summer vacation in California"

  • description: Yüklemekte olduğunuz videonun açıklaması. Varsayılan değer: Test description.

    Example: --description="Had a great time surfing in Santa Cruz"

  • category: Videoyla ilişkilendirilmiş YouTube video kategorisinin kategori kimliği. Varsayılan değer, People & Blogs kategorisini ifade eden 22 değeridir.

    Example: --category=22

  • keywords: Videoyla ilişkili anahtar kelimelerin virgülle ayrılmış listesi. Varsayılan değer boş bir dizedir.

    Example: --keywords="surfing, beach volleyball"

  • privacyStatus: Videonun gizlilik durumu. Varsayılan davranış, yüklenen bir videonun herkese görünür olmasıdır (public). Test videoları yüklerken bu videoların gizli veya liste dışı olduğundan emin olmak için --privacyStatus bağımsız değişken değeri belirtebilirsiniz. Geçerli değerler public, private ve unlisted'dir.

    Example: --privacyStatus="private"

  • policyId: Yüklenen videoya uygulanacak para kazanma politikasıdır. Politika, kimliği doğrulanmış kullanıcının YouTube İçerik Yöneticisi hesabıyla ilişkilendirilmelidir. Varsayılan olarak standart YouTube "para kazanma" politikası kullanılır.

    Example: --policyId="S309961703555739"
def parse_options():
  parser = OptionParser()
  parser.add_option("--file", dest="file", help="Video file to upload")
  parser.add_option("--title", dest="title", help="Video title",
    default="Test Title")
  parser.add_option("--description", dest="description",
    help="Video description",
    default="Test Description")
  parser.add_option("--category", dest="category",
    help="Numeric video category. " +
      "See https://developers.google.com/youtube/v3/docs/videoCategories/list",
    default="22")
  parser.add_option("--keywords", dest="keywords",
    help="Video keywords, comma separated", default="")
  parser.add_option("--privacyStatus", dest="privacyStatus",
    help="Video privacy status: public, private or unlisted",
    default="public")
  parser.add_option("--policyId", dest="policyId",
    help="Optional id of a saved claim policy")
  parser.add_option("--channelId", dest="channelId",
    help="Id of the channel to upload to. Must be managed by your CMS account")
  (options, args) = parser.parse_args()

  return options

İsteği yetkilendirin

Bu adımda, OAuth 2.0 yetkilendirmesini komut dosyasına dahil ediyoruz. Bu işlem, komut dosyasını çalıştıran kullanıcının, komut dosyasını kullanıcının hesabıyla ilişkilendirilen API isteklerini gerçekleştirmek üzere yetkilendirmesini sağlar.

client_secrets.json dosyası oluşturma

Örnekte gösterilen yetkilendirme türünün yetkilendirme gerçekleştirebilmesi için Google API Konsolu'ndan alınan bilgileri içeren bir client_secrets.json dosyasının olması gerekir. Ayrıca uygulamanızı kaydetmeniz de gerekir. Yetkilendirmenin işleyiş şekli hakkında daha kapsamlı bir açıklama için yetkilendirme kılavuzunu inceleyin. Bu örneğin, projeniz için API Konsolu'nda hem YouTube Data API V3 hem de YouTube Content ID API hizmetinin yapılandırılmasını gerektirdiğini unutmayın.

 {
  "web": {
    "client_id": "INSERT CLIENT ID HERE",
    "client_secret": "INSERT CLIENT SECRET HERE",
    "redirect_uris": [],
    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
    "token_uri": "https://accounts.google.com/o/oauth2/token"
  }
}

Komut dosyasındaki yetkilendirme kodu

Komut dosyası, kullanıcı kimlik doğrulamasını ve yetkilendirmesini etkinleştirmek için şu import ifadelerini içerir:

from oauth2client.file import Storage
from oauth2client.client import flow_from_clientsecrets
from oauth2client.tools import run

Daha sonra, get_authenticated_services yöntemi önceki adımda yapılandırılan client_secrets.json dosyasındaki verileri kullanarak bir FLOW nesnesi oluşturur. Kullanıcı, kullanıcı adına API istekleri göndermek üzere uygulamamıza yetki verirse sonuçta elde edilen kimlik bilgileri daha sonra kullanılmak üzere bir Storage nesnesinde depolanır. Kimlik bilgilerinin geçerliliği sona ererse kullanıcının uygulamamızı yeniden yetkilendirmesi gerekir.

YOUTUBE_SCOPES = (
  # An OAuth 2 access scope that allows for full read/write access.
  "https://www.googleapis.com/auth/youtube",
  # A scope that grants access to YouTube Partner API functionality.
  "https://www.googleapis.com/auth/youtubepartner")

flow = flow_from_clientsecrets(
  CLIENT_SECRETS_FILE,
  scope=" ".join(YOUTUBE_SCOPES),
  message=MISSING_CLIENT_SECRETS_MESSAGE
)

storage = Storage(CACHED_CREDENTIALS_FILE)
credentials = storage.get()

if credentials is None or credentials.invalid:
  credentials = run(flow, storage)

Hizmet alma

Yetkilendirme işlemi başarılı olduktan sonra, gerçekleştirmek istediğimiz işlemler için gerekli hizmetleri alırız. Örnek, videoyu yüklemek için YouTube Data API'yi, öğeyi oluşturmak ve videoyla ilgili hak talebinde bulunmak için YouTube Content ID API'yi kullanır. İki API'nin işlevlerine yetkili erişim sağlamak için ayrı hizmetler oluşturuyoruz.

from googleapiclient.discovery import build
import httplib2

YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"
YOUTUBE_CONTENT_ID_API_SERVICE_NAME = "youtubePartner"
YOUTUBE_CONTENT_ID_API_VERSION = "v1"

youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
  http=credentials.authorize(httplib2.Http()))

youtube_partner = build(YOUTUBE_CONTENT_ID_API_SERVICE_NAME,
  YOUTUBE_CONTENT_ID_API_VERSION, http=credentials.authorize(httplib2.Http()),
  static_discovery=False)

return (youtube, youtube_partner)

2. Adım: İçerik sahibini tanımlama

Öğe oluşturmak ve hak talebinde bulunmak için kimliği doğrulanan kullanıcının YouTube İçerik Yöneticisi hesabı olmalıdır. İçerik Yöneticisi hesabı, bir veya daha fazla içerik sahibi için hak yönetimi nesnelerini barındırır. Videodan para kazanma, videoyu takip etme veya engelleme konusunda karar verme hakkına sahip olan içerik sahibi, telif hakkı sahibidir.

get_content_owner yöntemi, kimliği doğrulanmış kullanıcının İçerik Yöneticisi hesabındaki içerik sahibinin kimliğini alır. Çoğu hesabın tek bir içerik sahibi (kimliği doğrulanmış kullanıcı) vardır, ancak hesabın birden fazla içerik sahibi varsa yöntem ilkini döndürür.

def get_content_owner_id(youtube_partner):
  try:
    content_owners_list_response = youtube_partner.contentOwners().list(
      fetchMine=True
    ).execute()
  except HttpError, e:
    if INVALID_CREDENTIALS in e.content:
      logging.error("The request is not authorized by a Google Account that "
        "is linked to a YouTube content owner. Please delete '%s' and "
        "re-authenticate with a YouTube content owner account." %
        CACHED_CREDENTIALS_FILE)
      exit(1)
    else:
      raise

  # This returns the CMS user id of the first entry returned
  # by youtubePartner.contentOwners.list()
  # See https://developers.google.com/youtube/partner/reference/rest/v1/contentOwners/list
  # Normally this is what you want, but if you authorize with a Google Account
  # that has access to multiple YouTube content owner accounts, you need to
  # iterate through the results.
  return content_owners_list_response["items"][0]["id"]

3. Adım: Videoyu yükleyin

Video yüklemek için videoyu temsil eden kısmi bir JSON kaynağı oluşturur ve videos.insert yöntemine iletiriz. Video meta verilerini, komut satırını ayrıştırırken oluşturulan options nesnesindeki değerleri kullanarak ayarlarız. Devam ettirilebilir yüklemeyi kullanabilmek için medya dosyasının kendisi için MediaFileUpload kullanırız. Daha fazla bilgi için Video yükleme bölümünü inceleyin.

upload yöntemi yeni videonun video kimliğini döndürür ve komut dosyasının sonraki adımlarda bu değeri diğer yöntemlere aktarması gerekir.

def upload(youtube, content_owner_id, options):
  if options.keywords:
    tags = options.keywords.split(",")
  else:
    tags = None

  insert_request = youtube.videos().insert(
    
    
    part="snippet,status",
    body=dict(
      snippet=dict(
        title=options.title,
        description=options.description,
        tags=tags,
        categoryId=options.category
      ),
      status=dict(
        privacyStatus=options.privacyStatus
      )
    ),
    # chunksize=-1 means that the entire file will be uploaded in a single
    # HTTP request. (If the upload fails, it will still be retried where it
    # left off.) This is usually a best practice, but if you're using Python
    # older than 2.6 or if you're running on App Engine, you should set the
    # chunksize to something like 1024 * 1024 (1 megabyte).
    media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True)
  )

  response = None
  error = None
  retry = 0
  duration_seconds=0
  while response is None:
    try:
      logging.debug("Uploading file...")

      start_seconds = time.time()
      status, response = insert_request.next_chunk()
      delta_seconds = time.time() - start_seconds
      duration_seconds += delta_seconds

      if "id" in response:
        return (response["id"], duration_seconds)
      else:
        logging.error("The upload failed with an unexpected response: %s" %
          response)
        exit(1)
    except HttpError, e:
      if e.resp.status in RETRIABLE_STATUS_CODES:
        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
                                                             e.content)
      else:
        raise
    except RETRIABLE_EXCEPTIONS, e:
      error = "A retriable error occurred: %s" % e

    if error is not None:
      logging.error(error)
      retry += 1
      if retry > MAX_RETRIES:
        logging.error("No longer attempting to retry.")
        exit(1)

      max_sleep = 2 ** retry
      sleep_seconds = random.random() * max_sleep
      logging.debug("Sleeping %f seconds and then retrying..." % sleep_seconds)
      time.sleep(sleep_seconds)

4. Adım: Öğe oluşturma

Bir YouTube videosundan para kazanmak için önce videoyu bir öğeyle ilişkilendirmeniz gerekir. create_asset yöntemi, yeni yüklenen video için yeni bir öğe oluşturur.

Videoda yaptığımız gibi, oluşturulacak öğenin türünü (web videosu) tanımlayan ve yeni öğe için başlık ile açıklama sağlayan kısmi bir JSON kaynağı oluştururuz. JSON kaynağını, öğeyi oluşturan ve benzersiz kimliğini döndüren assets.insert yöntemine iletiriz. Yine komut dosyasının sonraki adımlarda bu değeri diğer yöntemlere aktarması gerekir.

def create_asset(youtube_partner, content_owner_id, title, description):
  # This creates a new asset corresponding to a video on the web.
  # The asset is linked to the corresponding YouTube video via a
  # claim that will be created later.
  body = dict(
    type="web",
    metadata=dict(
      title=title,
      description=description
    )
  )

  assets_insert_response = youtube_partner.assets().insert(
    
    body=body
  ).execute()

  return assets_insert_response["id"]

5. Adım: Sahipliği güncelleyin

Bir videodan para kazanabilmeniz için YouTube'un ilişkilendirilmiş öğenin kime ait olduğunu bilmesi gerekir. Öğe oluşturulduktan sonra öğenin ownership özelliğini yapılandırıyoruz. Örnekte, içerik sahibinin öğenin dünya genelinde sahipliğinin olduğu belirtilmektedir.

  def set_asset_ownership(youtube_partner, content_owner_id, asset_id):
  # This specifies that content_owner_id owns 100% of the asset worldwide.
  # Adjust as needed.
  body = dict(
    general=[dict(
      owner=content_owner_id,
      ratio=100,
      type="exclude",
      territories=[]
    )]
  )

  youtube_partner.ownership().update(
    
    assetId=asset_id,
    body=body
  ).execute()

6. adım: Video için hak talebinde bulunun

Sonraki adım, yüklenen videoyla ilgili hak talebinde bulunarak videoyu ilgili öğesiyle ilişkilendirmektir. Hak talebi, video ile YouTube hak yönetimi sistemi arasındaki bağlantıyı sağlar. Bu sistem, videonun sahipliğini oluşturur ve içerik sahibinin para kazanma politikası belirlemesini sağlar.

claim_video yöntemi, görsel-işitsel haklarla ilgili hak talebinde bulunur. Komut satırına policyId parametresini eklerseniz söz konusu yöntem, belirtilen politikayı videoya uygular. Parametreyi eklemezseniz yöntem, standart "para kazanma" politikasını uygular.

def claim_video(youtube_partner, content_owner_id, asset_id, video_id,
  policy_id):
  # policy_id can be set to the id of an existing policy, which can be obtained
  # via youtubePartner.policies.list()
  # See https://developers.google.com/youtube/partner/reference/rest/v1/policies/list
  # If you later update that existing policy, the claim will also be updated.
  if policy_id:
    policy = dict(
      id=policy_id
    )
  # If policy_id is not provided, a new inline policy is created.
  else:
    policy = dict(
      rules=[dict(
        action="monetize"
      )]
    )

  body = dict(
    assetId=asset_id,
    videoId=video_id,
    policy=policy,
    contentType="audiovisual"
  )

  youtube_partner.claims().insert(
    
    body=body
  ).execute()

7. Adım: Reklamcılık seçeneklerini ayarlama

Videoyla ilgili hak talebinde bulunduk ve videoya para kazanma politikası uyguladık. Son adım, videoda ne tür reklamların gösterileceğini belirlemektir. "Para kazanma" politikası geçerli olduğunda, YouTube reklam seçeneklerini kontrol eder ve en yüksek gelir sağlayan reklam türünü gösterir.

Örnek, YouTube'a bu videoyla birlikte yayın içi TrueView reklamlar göstermesini bildirir.

def set_advertising_options(youtube_partner, content_owner_id, video_id):
  # This enables the TrueView ad format for the given video.
  # Adjust as needed.
  body = dict(
    adFormats=["trueview_instream"]
  )

  youtube_partner.videoAdvertisingOptions().update(
    videoId=video_id,
    
    body=body
  ).execute()

Tam kod örneği

Tam bir çalışma örneği upload_monetize_video_example.py aşağıda listelenmiştir:

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2013 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Simple command-line sample for Youtube Partner API.

Command-line application that creates an asset, uploads and claims a video for that asset.

Usage:
  $ python upload_monetize_video_example.py --file=VIDEO_FILE --channelID=CHANNEL_ID \
      [--title=VIDEO_TITLE] [--description=VIDEO_DESCRIPTION] [--category=CATEGORY_ID] \
      [--keywords=KEYWORDS] [--privacyStatus=PRIVACY_STATUS] [--policyId=POLICY_ID] 

You can also get help on all the command-line flags the program understands
by running:

  $ python upload_monetize_video_example.py --help
"""

__author__ = 'jeffy+pub@google.com (Jeffrey Posnick)'

import httplib
import httplib2
import logging
import os
import random
import sys
import time

from apiclient.discovery import build
from apiclient.errors import HttpError
from apiclient.http import MediaFileUpload
from oauth2client.file import Storage
from oauth2client.client import flow_from_clientsecrets
from oauth2client.tools import run
from optparse import OptionParser


# Explicitly tell the underlying HTTP transport library not to retry, since
# we are handling retry logic ourselves.
httplib2.RETRIES = 1

# Maximum number of times to retry before giving up.
MAX_RETRIES = 10

# Always retry when these exceptions are raised.
RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError, httplib.NotConnected,
  httplib.IncompleteRead, httplib.ImproperConnectionState,
  httplib.CannotSendRequest, httplib.CannotSendHeader,
  httplib.ResponseNotReady, httplib.BadStatusLine,)

# Always retry when an apiclient.errors.HttpError with one of these status
# codes is raised.
RETRIABLE_STATUS_CODES = (500, 502, 503, 504,)

# The message associated with the HTTP 401 error that's returned when a request
# is authorized by a user whose account is not associated with a YouTube
# content owner.
INVALID_CREDENTIALS = "Invalid Credentials"

# The CLIENT_SECRETS_FILE variable specifies the name of a file that contains
# the OAuth 2.0 information for this application, including its client_id and
# client_secret. You can acquire an OAuth 2.0 client ID and client secret from
# the Google API Console at
# https://console.cloud.google.com/.
# See the "Registering your application" instructions for an explanation
# of how to find these values:
# https://developers.google.com/youtube/partner/guides/registering_an_application
# For more information about using OAuth2 to access Google APIs, please visit:
#   https://developers.google.com/accounts/docs/OAuth2
# For more information about the client_secrets.json file format, please visit:
#   https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
CLIENT_SECRETS_FILE = "client_secrets.json"

# The local file used to store the cached OAuth 2 credentials after going
# through a one-time browser-based login.
CACHED_CREDENTIALS_FILE = "%s-oauth2.json" % sys.argv[0]

YOUTUBE_SCOPES = (
  # An OAuth 2 access scope that allows for full read/write access.
  "https://www.googleapis.com/auth/youtube",
  # A scope that grants access to YouTube Partner API functionality.
  "https://www.googleapis.com/auth/youtubepartner",)
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"
YOUTUBE_CONTENT_ID_API_SERVICE_NAME = "youtubePartner"
YOUTUBE_CONTENT_ID_API_VERSION = "v1"

# Helpful message to display if the CLIENT_SECRETS_FILE is missing.
MISSING_CLIENT_SECRETS_MESSAGE = """
WARNING: Please configure OAuth 2.0

To make this sample run you need to populate the client_secrets.json file at:

   %s

with information from the API Console
https://console.cloud.google.com/

For more information about the client_secrets.json file format, please visit:
https://developers.google.com/api-client-library/python/guide/aaa_client_secrets
""" % os.path.abspath(os.path.join(os.path.dirname(__file__),
                                   CLIENT_SECRETS_FILE))

def parse_options():
  parser = OptionParser()
  parser.add_option("--file", dest="file", help="Video file to upload")
  parser.add_option("--title", dest="title", help="Video title",
    default="Test Title")
  parser.add_option("--description", dest="description",
    help="Video description",
    default="Test Description")
  parser.add_option("--category", dest="category",
    help="Numeric video category. " +
      "See https://developers.google.com/youtube/v3/docs/videoCategories/list",
    default="22")
  parser.add_option("--keywords", dest="keywords",
    help="Video keywords, comma separated", default="")
  parser.add_option("--privacyStatus", dest="privacyStatus",
    help="Video privacy status: public, private or unlisted",
    default="public")
  parser.add_option("--policyId", dest="policyId",
    help="Optional id of a saved claim policy")
  parser.add_option("--channelId", dest="channelId",
    help="Id of the channel to upload to. Must be managed by your CMS account")
  (options, args) = parser.parse_args()

  return options

def get_authenticated_services():
  flow = flow_from_clientsecrets(
    CLIENT_SECRETS_FILE,
    scope=" ".join(YOUTUBE_SCOPES),
    message=MISSING_CLIENT_SECRETS_MESSAGE
  )

  storage = Storage(CACHED_CREDENTIALS_FILE)
  credentials = storage.get()

  if credentials is None or credentials.invalid:
    credentials = run(flow, storage)

  youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
    http=credentials.authorize(httplib2.Http()))

  youtube_partner = build(YOUTUBE_CONTENT_ID_API_SERVICE_NAME,
    YOUTUBE_CONTENT_ID_API_VERSION, http=credentials.authorize(httplib2.Http()),
    static_discovery=False)

  return (youtube, youtube_partner)

def get_content_owner_id(youtube_partner):
  try:
    content_owners_list_response = youtube_partner.contentOwners().list(
      fetchMine=True
    ).execute()
  except HttpError, e:
    if INVALID_CREDENTIALS in e.content:
      logging.error("Your request is not authorized by a Google Account that "
        "is associated with a YouTube content owner. Please delete '%s' and "
        "re-authenticate with an account that is associated "
        "with a content owner." % CACHED_CREDENTIALS_FILE)
      exit(1)
    else:
      raise

  # This returns the CMS user id of the first entry returned
  # by youtubePartner.contentOwners.list()
  # See https://developers.google.com/youtube/partner/reference/rest/v1/contentOwners/list
  # Normally this is what you want, but if you authorize with a Google Account
  # that has access to multiple YouTube content owner accounts, you need to
  # iterate through the results.
  return content_owners_list_response["items"][0]["id"]

def upload(youtube, content_owner_id, options):
  if options.keywords:
    tags = options.keywords.split(",")
  else:
    tags = None

  insert_request = youtube.videos().insert(
    
    
    part="snippet,status",
    body=dict(
      snippet=dict(
        title=options.title,
        description=options.description,
        tags=tags,
        categoryId=options.category
      ),
      status=dict(
        privacyStatus=options.privacyStatus
      )
    ),
    # chunksize=-1 means that the entire file will be uploaded in a single
    # HTTP request. (If the upload fails, it will still be retried where it
    # left off.) This is usually a best practice, but if you're using Python
    # older than 2.6 or if you're running on App Engine, you should set the
    # chunksize to something like 1024 * 1024 (1 megabyte).
    media_body=MediaFileUpload(options.file, chunksize=-1, resumable=True)
  )

  response = None
  error = None
  retry = 0
  duration_seconds=0
  while response is None:
    try:
      logging.debug("Uploading file...")

      start_seconds = time.time()
      status, response = insert_request.next_chunk()
      delta_seconds = time.time() - start_seconds
      duration_seconds += delta_seconds

      if "id" in response:
        return (response["id"], duration_seconds)
      else:
        logging.error("The upload failed with an unexpected response: %s" %
          response)
        exit(1)
    except HttpError, e:
      if e.resp.status in RETRIABLE_STATUS_CODES:
        error = "A retriable HTTP error %d occurred:\n%s" % (e.resp.status,
                                                             e.content)
      else:
        raise
    except RETRIABLE_EXCEPTIONS, e:
      error = "A retriable error occurred: %s" % e

    if error is not None:
      logging.error(error)
      retry += 1
      if retry > MAX_RETRIES:
        logging.error("No longer attempting to retry.")
        exit(1)

      max_sleep = 2 ** retry
      sleep_seconds = random.random() * max_sleep
      logging.debug("Sleeping %f seconds and then retrying..." % sleep_seconds)
      time.sleep(sleep_seconds)

def create_asset(youtube_partner, content_owner_id, title, description):
  # This creates a new asset corresponding to a video on the web.
  # The asset is linked to the corresponding YouTube video via a
  # claim that will be created later.
  body = dict(
    type="web",
    metadata=dict(
      title=title,
      description=description
    )
  )

  assets_insert_response = youtube_partner.assets().insert(
    
    body=body
  ).execute()

  return assets_insert_response["id"]

def set_asset_ownership(youtube_partner, content_owner_id, asset_id):
  # This specifies that content_owner_id owns 100% of the asset worldwide.
  # Adjust as needed.
  body = dict(
    general=[dict(
      owner=content_owner_id,
      ratio=100,
      type="exclude",
      territories=[]
    )]
  )

  youtube_partner.ownership().update(
    
    assetId=asset_id,
    body=body
  ).execute()

def claim_video(youtube_partner, content_owner_id, asset_id, video_id,
  policy_id):
  # policy_id can be set to the id of an existing policy, which can be obtained
  # via youtubePartner.policies.list()
  # See https://developers.google.com/youtube/partner/reference/rest/v1/policies/list
  # If you later update that existing policy, the claim will also be updated.
  if policy_id:
    policy = dict(
      id=policy_id
    )
  # If policy_id is not provided, a new inline policy is created.
  else:
    policy = dict(
      rules=[dict(
        action="monetize"
      )]
    )

  body = dict(
    assetId=asset_id,
    videoId=video_id,
    policy=policy,
    contentType="audiovisual"
  )

  claims_insert_response = youtube_partner.claims().insert(
    
    body=body
  ).execute()

  return claims_insert_response["id"]

def set_advertising_options(youtube_partner, content_owner_id, video_id):
  # This enables the true view ad format for the given video.
  # Adjust as needed.
  body = dict(
    adFormats=["trueview_instream"]
  )

  youtube_partner.videoAdvertisingOptions().update(
    videoId=video_id,
    
    body=body
  ).execute()


if __name__ == '__main__':
  logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
  )

  options = parse_options()

  if options.file is None or not os.path.exists(options.file):
    logging.error("Please specify a valid file using the --file= parameter.")
    exit(1)

  # The channel ID looks something like "UC..." and needs to correspond to a
  # channel managed by the YouTube content owner authorizing the request.
  # youtube.channels.list(part="snippet", managedByMe=true,
  #                       
  # can be used to retrieve a list of managed channels and their channel IDs.
  # See https://developers.google.com/youtube/v3/docs/channels/list
  if options.channelId is None:
    logging.error("Please specify a channel ID via the --channelId= parameter.")
    exit(1)

  (youtube, youtube_partner) = get_authenticated_services()

  content_owner_id = get_content_owner_id(youtube_partner)
  logging.info("Authorized by content owner ID '%s'." % content_owner_id)

  (video_id, duration_seconds) = upload(youtube, content_owner_id, options)
  logging.info("Successfully uploaded video ID '%s'." % video_id)

  file_size_bytes = os.path.getsize(options.file)
  logging.debug("Uploaded %d bytes in %0.2f seconds (%0.2f megabytes/second)." %
    (file_size_bytes, duration_seconds,
      (file_size_bytes / (1024 * 1024)) / duration_seconds))

  asset_id = create_asset(youtube_partner, content_owner_id,
    options.title, options.description)
  logging.info("Created new asset ID '%s'." % asset_id)

  set_asset_ownership(youtube_partner, content_owner_id, asset_id)
  logging.info("Successfully set asset ownership.")

  claim_id = claim_video(youtube_partner, content_owner_id, asset_id,
    video_id, options.policyId)
  logging.info("Successfully claimed video.")

  set_advertising_options(youtube_partner, content_owner_id, video_id)
  logging.info("Successfully set advertising options.")

  logging.info("All done!")