Uwaga: interfejs YouTube Content ID API jest przeznaczony dla dostawców treści w YouTube i nie jest dostępny dla wszystkich deweloperów ani użytkowników YouTube. Jeśli nie widzisz interfejsu YouTube Content ID API na liście usług wymienionych w Konsoli interfejsów API Google, odwiedź Centrum pomocy YouTube, aby dowiedzieć się więcej o programie partnerskim YouTube.
Ten przykładowy kod pokazuje, jak przesłać film do YouTube i zastosować do niego zasady zarabiania. Aby zarabiać na filmie, musisz zgłosić do niego roszczenie asset
w systemie zarządzania prawami YouTube. Przesyła film, tworzy nowy zasób, zgłasza roszczenie do filmu za pomocą zasobu i stosuje do niego zasady zarabiania.
Ten przykład przedstawia serię czynności, które należy wykonać, wraz z odpowiednimi sekcjami kodu. Cały skrypt znajdziesz na końcu tej strony. Kod jest napisany w Pythonie. Dostępne są również biblioteki klienckie dla innych popularnych języków programowania.
Wymagania
- Python 2.5 lub nowszy
- google-api-python-client
Krok 1. Popularne funkcje porządkowe
Pierwsze sekcje kodu przykładowego wykonują podstawowe funkcje, które są wspólne dla wielu skryptów: analizują wiersz poleceń, uwierzytelniają użytkownika i uzyskują potrzebne usługi API.
Analizowanie wiersza poleceń
Metoda parse_options
używa elementu OptionParser
z biblioteki klienta Pythona do utworzenia obiektu options
, który zawiera jako właściwość każdy argument wiersza poleceń. Kolejne metody w razie potrzeby pobierają wartości z obiektu options
.
Argumenty wiersza poleceń przykładowego skryptu znajdziesz poniżej. Pierwsze dwa (file
i channelId
) są wymagane. Pozostałe są opcjonalne.
-
file
: nazwa i lokalizacja pliku wideo do przesłania.Example: --file="/home/path/to/file.mov"
-
channelId
: kanał YouTube, na który chcesz przesłać film. Kanał musi być zarządzany przez konto Menedżera treści YouTube użytkownika uwierzytelnionego. Identyfikator kanału możesz pobrać w ustawieniach konta YouTube dla uwierzytelnionego użytkownika lub za pomocą metodychannels.list
.Example: --channelId="UC_x5XG1OV2P6uZZ5FSM9Ttw"
-
title
: tytuł przesyłanego filmu. Wartością domyślną jestTest title
.Example: --title="Summer vacation in California"
-
description
: opis przesyłanego filmu. Wartością domyślną jestTest description
.Example: --description="Had a great time surfing in Santa Cruz"
-
category
: identyfikator kategorii kategorii filmów w YouTube powiązanej z filmem. Wartość domyślna to22
, która odnosi się do kategoriiPeople & Blogs
.Example: --category=22
-
keywords
: rozdzielona przecinkami lista słów kluczowych powiązanych z filmem. Wartość domyślna to pusty ciąg znaków.Example: --keywords="surfing, beach volleyball"
-
privacyStatus
: stan prywatności filmu. Domyślnie przesłany film jest widoczny publicznie (public
). Podczas przesyłania filmów testowych możesz podać wartość argumentu--privacyStatus
, aby mieć pewność, że filmy są prywatne lub niepubliczne. Prawidłowe wartości topublic
,private
iunlisted
.Example: --privacyStatus="private"
-
policyId
: zasady zarabiania, które mają zastosowanie do przesłanego filmu. Zasady muszą być powiązane z kontem uwierzytelnionego użytkownika w Menedżerze treści YouTube. Domyślną wartością jest standardowa zasada „Zarabiaj” w YouTube.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
Autoryzuj żądanie
Na tym etapie w skrypcie włączamy autoryzację OAuth 2.0. Dzięki temu użytkownik, który uruchamia skrypt, może autoryzować skrypt do wykonywania żądań interfejsu API przypisanych do konta użytkownika.
Tworzenie pliku client_secrets.json
Typ autoryzacji przedstawiony w przykładzie wymaga do przeprowadzenia autoryzacji pliku client_secrets.json
, który zawiera informacje z Konsoli interfejsów API Google. Musisz też zarejestrować swoją aplikację. Pełne wyjaśnienie działania autoryzacji znajdziesz w przewodniku po autoryzacji. Pamiętaj, że ten przykład wymaga skonfigurowania w Konsoli interfejsów API projektu usług YouTube Data API w wersji 3 oraz YouTube Content ID API.
{ "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" } }
Kod autoryzacji w skrypcie
Skrypt zawiera te instrukcje import
, które umożliwiają uwierzytelnianie i autoryzację użytkowników:
from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import run
Następnie metoda get_authenticated_services
tworzy obiekt FLOW
przy użyciu danych z pliku client_secrets.json
skonfigurowanego w poprzednim kroku. Jeśli użytkownik autoryzuje naszą aplikację do przesyłania żądań interfejsu API w imieniu użytkownika, uzyskane dane uwierzytelniające są przechowywane w obiekcie Storage
do późniejszego wykorzystania. Jeśli dane logowania wygasną, użytkownik musi ponownie autoryzować naszą aplikację.
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)
Uzyskiwanie usług
Po pomyślnej autoryzacji uzyskamy niezbędne usługi do wykonania operacji, które chcemy wykonać. W przykładzie użyto interfejsu YouTube Data API do przesłania filmu oraz interfejsu YouTube Content ID API, aby utworzyć zasób i zgłosić do niego roszczenie. Aby umożliwić autoryzowany dostęp do funkcji obu interfejsów API, tworzymy osobne usługi.
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)
Krok 2. Zidentyfikuj właściciela treści
Aby tworzyć zasoby i zgłaszać roszczenia, uwierzytelniony użytkownik musi mieć konto Menedżera treści YouTube. Konto Menedżera treści zawiera obiekty zarządzania prawami co najmniej jednego właściciela treści. Właściciel treści to właściciel praw autorskich, który ma prawo decydować, czy film ma zarabiać, monitorować go czy zablokować.
Metoda get_content_owner
pobiera identyfikator właściciela treści z konta Menedżera treści uwierzytelnionego użytkownika. Większość kont ma jednego właściciela treści (uwierzytelnionego użytkownika), ale jeśli konto ma wielu właścicieli treści, metoda zwraca pierwszego.
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"]
Krok 3. Prześlij film
Aby przesłać film, tworzymy częściowy zasób JSON reprezentujący film i przekazujemy go do metody videos.insert
. Metadane filmu ustawiamy za pomocą wartości z obiektu options
utworzonego podczas analizowania wiersza poleceń. W przypadku pliku multimedialnego używamy parametru MediaFileUpload
, aby umożliwić przesyłanie z możliwością wznowienia. Więcej informacji znajdziesz w artykule Przesyłanie filmu.
Metoda upload
zwraca identyfikator nowego filmu, a skrypt musi przekazać tę wartość do innych metod w późniejszych krokach.
def upload(youtube, content_owner_id, options): if options.keywords: tags = options.keywords.split(",") else: tags = None insert_request = youtube.videos().insert( onBehalfOfContentOwner=content_owner_id, onBehalfOfContentOwnerChannel=options.channelId, 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)
Krok 4. Utwórz zasób
Aby zarabiać na filmie w YouTube, musisz najpierw powiązać go z zasobem. Metoda create_asset
tworzy nowy zasób dla nowo przesłanego filmu.
Podobnie jak w przypadku filmu, tworzymy częściowy zasób JSON, który określa typ zasobu do utworzenia (film internetowy) oraz zawiera tytuł i opis nowego zasobu. Przekazujemy zasób JSON do metody assets.insert
, która tworzy zasób i zwraca jego unikalny identyfikator. Również w tym przypadku skrypt musi przekazać tę wartość do innych metod w kolejnych krokach.
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( onBehalfOfContentOwner=content_owner_id, body=body ).execute() return assets_insert_response["id"]
Krok 5. Zaktualizuj własność
Zanim będziesz mieć możliwość zarabiania na filmie, YouTube musi wiedzieć, kto jest właścicielem powiązanego zasobu. Po utworzeniu zasobu konfigurujemy jego ownership
. W przykładzie określamy, że właściciel treści ma prawa własności na całym świecie do zasobu.
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( onBehalfOfContentOwner=content_owner_id, assetId=asset_id, body=body ).execute()
Krok 6. Zgłoś roszczenie do filmu
Kolejnym krokiem jest powiązanie przesłanego filmu z odpowiednim zasobem przez zgłoszenie do niego roszczenia. Roszczenie stanowi połączenie między filmem a systemem zarządzania prawami w YouTube, który ustala, na czym polega prawo własności do filmu, i umożliwia właścicielowi określenie zasad zarabiania.
Metoda claim_video
zgłasza prawa do treści audiowizualnych. Jeśli umieścisz parametr policyId
w wierszu poleceń, metoda zastosuje określoną zasadę do filmu. Jeśli go nie podasz, zastosujemy standardową zasadę „Zarabiaj”.
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( onBehalfOfContentOwner=content_owner_id, body=body ).execute()
Krok 7. Ustaw opcje reklam
Zgłosiliśmy roszczenie do filmu i zastosowaliśmy do niego zasadę zarabiania. Na koniec określ typ reklam, które mają się wyświetlać w filmie. Gdy obowiązuje zasada „zarabiaj”, YouTube sprawdza opcje reklamowe i wyświetla te reklamy, które generują najwyższe przychody.
Przykład informuje YouTube, że w tym filmie mają wyświetlać się reklamy In-Stream TrueView.
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, onBehalfOfContentOwner=content_owner_id, body=body ).execute()
Uzupełnij przykładowy kod
Poniżej znajdziesz pełny przykład roboczy (upload_monetize_video_example.py
):
#!/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( onBehalfOfContentOwner=content_owner_id, onBehalfOfContentOwnerChannel=options.channelId, 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( onBehalfOfContentOwner=content_owner_id, 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( onBehalfOfContentOwner=content_owner_id, 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( onBehalfOfContentOwner=content_owner_id, 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, onBehalfOfContentOwner=content_owner_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, # onBehalfOfContentOwner=*CONTENT_OWNER_ID*) # 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!")