Remarque:L'API YouTube Content ID est destinée aux partenaires de contenu YouTube. Elle n'est pas accessible à tous les développeurs ni à tous les utilisateurs YouTube. Si l'API YouTube Content ID n'apparaît pas dans la console Google APIs, consultez le Centre d'aide YouTube pour en savoir plus sur le Programme Partenaire YouTube.
Cet exemple de code montre comment importer une reference à l'aide de l'API YouTube Content ID. Pour importer un élément reference, vous devez d'abord créer un élément asset, puis configurer la propriété et la règle de correspondance de l'élément. Cet exemple décrit chacune de ces étapes.
Cet exemple est présenté comme la série d'étapes impliquées, ainsi que les sections pertinentes du code. Le script complet se trouve au bas de cette page. Le code est écrit en Python. Des bibliothèques clientes pour d'autres langages de programmation courants sont également disponibles.
L'exemple de script ne gère pas les erreurs.
Conditions requises
- Python 2.5 ou version ultérieure
- google-api-python-client
Dans cette étape, nous allons intégrer l'autorisation OAuth 2.0 dans le script. Ainsi, l'utilisateur qui exécute le script pourra l'autoriser à exécuter les requêtes API attribuées au compte de l'utilisateur.
Créer un fichier client_secrets.json
L'API YouTube Content ID nécessite un fichier client_secrets.json, qui contient des informations de la console API, pour effectuer l'authentification. Vous devez également enregistrer votre application. Pour en savoir plus sur le fonctionnement de l'authentification, consultez le guide sur l'authentification.
{
"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"
}
}
Ajouter un code d'authentification à votre script
Pour activer l'authentification et l'autorisation des utilisateurs, vous devez ajouter les instructions import suivantes:
from oauth2client.file import Storage from oauth2client.client import flow_from_clientsecrets from oauth2client.tools import run
Nous allons ensuite créer un objet FLOW à l'aide des codes secrets du client configurés à l'étape 2a. Si l'utilisateur autorise notre application à envoyer des requêtes API en son nom, les identifiants obtenus sont stockés dans un objet Storage pour une utilisation ultérieure. Si les identifiants expirent, l'utilisateur devra autoriser à nouveau notre application.
Ajoutez le code suivant à la fin de la fonction main:
# Set up a Flow object to be used if we need to authenticate.
FLOW = flow_from_clientsecrets('client_secrets.json',
scope='https://www.googleapis.com/auth/youtubepartner',
message='error message')
# The Storage object stores the credentials. If it doesn't exist, or if
# the credentials are invalid or expired, run through the native client flow.
storage = Storage('yt_partner_api.dat')
credentials = storage.get()
if (credentials is None or credentials.invalid or
credentials.token_expiry <= datetime.now()):
credentials = run(FLOW, storage)
Créer un objet httplib2 et associer des identifiants
Une fois que l'utilisateur a autorisé notre script, nous créons un objet httplib2.Http qui gère les requêtes API, et nous associons les identifiants d'autorisation à cet objet.
Ajoutez la déclaration d'importation suivante :
import httplib2
Ajoutez le code suivant à la fin de la fonction main:
# Create httplib2.Http object to handle HTTP requests and # attach auth credentials. http = httplib2.Http() http = credentials.authorize(http)
Obtenir des services
Une fois l'autorisation réussie, le code obtient les services nécessaires aux opérations qu'il va effectuer. Elle crée d'abord un objet service qui donne accès à tous les services de l'API YouTube Content ID. Le code utilise ensuite l'objet service pour obtenir les quatre services spécifiques aux ressources qu'il appelle.
from apiclient.discovery import build
# ...
service = build("youtubePartner", "v1", http=http, static_discovery=False)
# ...
asset_service = service.assets()
# ...
ownership_service = service.ownership()
# ...
match_policy_service = service.assetMatchPolicy()
# ...
reference_service = service.references()
Créer un élément
La première étape de l'importation d'un reference consiste à créer le asset. Nous commençons par créer un objet metadata simple qui ne définit que le titre de l'élément. Le code ajoute ensuite cet objet au asset_body, qui identifie également le type de l'asset. L'objet asset_body, à son tour, est utilisé comme entrée dans la méthode asset_service.insert(). Cette méthode crée l'asset et renvoie son identifiant unique.
def _create_asset(service, title, metadata_type):
metadata = {'title': title}
asset_body = {'metadata': metadata, 'type': metadata_type}
# Retrieve asset service.
asset_service = service.assets()
# Create and execute insert request.
request = asset_service.insert(body=asset_body)
response = request.execute()
logger.info('Asset has been created.\n%s', response)
asset_id = response['id']
return asset_id
Mettre à jour la propriété
Une fois l'élément asset créé, le script configure le paramètre ownership de l'élément. Cet exemple indique que le propriétaire de contenu détient 100% de l'élément, mais que cette propriété est limitée à la Pologne (PL) et à la Grande-Bretagne (GB).
def _create_asset_ownership(service, asset_id, owner_name):
ownership = {
'owner': owner_name,
'ratio' : 100,
'type': 'include',
'territories': ['PL', 'GB']}
ownership_body = {'general': [ownership]}
ownership_service = service.ownership()
request = ownership_service.update(assetId=asset_id, body=ownership_body)
response = request.execute()
logger.info('Asset ownership has been created.\n%s', response)
Modifier les règles de correspondance de l'élément
Avant de créer la référence, le code doit également configurer la règle de correspondance de l'élément en modifiant la ressource assetMatchPolicy associée à l'élément. La règle de correspondance de l'élément détermine l'action que YouTube prendra lorsqu'une vidéo sur YouTube correspond à une référence associée à cet élément. Cet exemple crée une règle simple qui suit dans le monde entier toutes les correspondances de plus de 10 secondes.
def _create_match_policy(service, asset_id):
match_policy_service = service.assetMatchPolicy()
everywhere_policy_condition = {
'requiredTerritories': {
'type': 'exclude', 'territories': []},
'requiredReferenceDuration': [{'low': 10}],
'contentMatchType': 'video'}
track_everywhere_rule = {
'action': 'track',
'condition': everywhere_policy_condition}
request = match_policy_service.update(
assetId=asset_id,
body={
'name': 'Track Everywhere 10s.',
'description': 'Track Everywhere matches longer than 10s.',
'rules': [track_everywhere_rule]})
response = request.execute()
logger.info('Asset match policy has been created.\n%s', response)
Importer la référence
Une fois les éléments asset, ownership et assetMatchPolicy en place, le script importe un reference. Elle utilise la méthode MediaFileUpload pour pouvoir tirer parti de l'importation avec reprise. Notez que le paramètre reference_file spécifie le nom d'un fichier local à importer et que cette valeur est transmise au script à l'aide de l'option de ligne de commande reference_file.
def _create_reference(service, asset_id, reference_file):
reference_service = service.reference()
media = MediaFileUpload(reference_file, resumable=True)
request = reference_service.insert(
body={'assetId': asset_id, 'contentType': 'video'},
media_body=media)
status, response = request.next_chunk()
while response is None:
status, response = request.next_chunk()
if status:
logger.info("Uploaded %d%%.", int(status.progress() * 100))
logger.info('Reference has been created.\n%s', response)
Full code sample
The complete working sample asset_reference_upload_example.py is listed below:
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2012 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 asset, asset ownership, match policy
and reference.
Usage:
$ python asset_reference_upload_example.py --reference_file=REFERENCE_FILE \
--asset_title=ASSET_TITLE --owner=OWNER
You can also get help on all the command-line flags the program understands
by running:
$ python asset_reference_upload_example.py --help
"""
__author__ = '[email protected] (Mateusz Zięba)'
import httplib2
import logging
import sys
import optparse
import os
from apiclient.discovery import build
from apiclient.errors import HttpError
from apiclient.http import MediaFileUpload
from oauth2client.file import Storage
from oauth2client.client import AccessTokenRefreshError
from oauth2client.client import flow_from_clientsecrets
from oauth2client.tools import run
# 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
CLIENT_SECRETS = 'client_secrets.json'
# 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 found at:
%s
with information from the API Console
<https://console.cloud.google.com/>.
""" % os.path.join(os.path.dirname(__file__), CLIENT_SECRETS)
# Set up a Flow object to be used if we need to authenticate.
FLOW = flow_from_clientsecrets(CLIENT_SECRETS,
scope='https://www.googleapis.com/auth/youtubepartner',
message=MISSING_CLIENT_SECRETS_MESSAGE)
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(logging.StreamHandler())
def _create_asset(service, title, metadata_type):
metadata = {'title': title}
asset_body = {'metadata': metadata, 'type': metadata_type}
# Retrieve asset service.
asset_service = service.assets()
# Create and execute insert request.
request = asset_service.insert(body=asset_body)
response = request.execute()
logger.info('Asset has been created.\n%s', response)
asset_id = response['id']
return asset_id
def _create_asset_ownership(service, asset_id, owner_name):
ownership = {
'owner': owner_name,
'ratio' : 100,
'type': 'include',
'territories': ['PL', 'GB']}
ownership_body = {'general': [ownership]}
ownership_service = service.ownership()
request = ownership_service.update(assetId=asset_id, body=ownership_body)
response = request.execute()
logger.info('Asset ownership has been created.\n%s', response)
def _create_match_policy(service, asset_id):
match_policy_service = service.assetMatchPolicy()
everywhere_policy_condition = {
'requiredTerritories': {
'type': 'exclude', 'territories': []},
'requiredReferenceDuration': [{'low': 10}],
'contentMatchType': 'video'}
track_everywhere_rule = {
'action': 'track',
'condition': everywhere_policy_condition}
request = match_policy_service.update(
assetId=asset_id,
body={
'name': 'Track Everywhere 10s.',
'description': 'Track Everywhere matches longer than 10s.',
'rules': [track_everywhere_rule]})
response = request.execute()
logger.info('Asset match policy has been created.\n%s', response)
def _create_reference(service, asset_id, reference_file):
reference_service = service.references()
media = MediaFileUpload(reference_file, resumable=True)
request = reference_service.insert(
body={'assetId': asset_id, 'contentType': 'video'},
media_body=media)
status, response = request.next_chunk()
while response is None:
status, response = request.next_chunk()
if status:
logger.info("Uploaded %d%%.", int(status.progress() * 100))
logger.info('Reference has been created.\n%s', response)
def _parse_options():
parser = optparse.OptionParser(
description='Creates asset, asset ownership, match policy and reference.')
parser.add_option('--version',
default='v1',
type=str, help='API version.')
parser.add_option('--reference_file', type=str,
help='File containing reference to be uploaded. Required')
parser.add_option('--asset_title',
type=str, help='Asset title. Required')
parser.add_option('--owner',
type=str, help='Content owner name. Required')
(options, args) = parser.parse_args()
if not options.reference_file:
parser.error("--reference_file is required")
if not options.asset_title:
parser.error("--asset_title is required")
if not options.owner:
parser.error("--owner is required")
return options
def main(argv):
options = _parse_options()
# If the Credentials don't exist or are invalid run through the native client
# flow. The Storage object ensures that if successful the good
# Credentials are written back to a file.
storage = Storage('yt_partner_api.dat')
credentials = storage.get()
if credentials is None or credentials.invalid:
credentials = run(FLOW, storage)
# Create an httplib2.Http object to handle our HTTP requests and authorize it
# with our good Credentials.
http = httplib2.Http()
http = credentials.authorize(http)
service = build("youtubePartner", options.version, http=http, static_discovery=False)
try:
asset_id = _create_asset(service, options.asset_title, 'web')
_create_asset_ownership(service, asset_id, options.owner)
_create_match_policy(service, asset_id)
_create_reference(service, asset_id, options.reference_file)
except AccessTokenRefreshError:
logger.info("The credentials have been revoked or expired, please re-run"
" the application to re-authorize")
if __name__ == '__main__':
main(sys.argv)