L'API YouTube Data permet aux applications clientes de récupérer et de mettre à jour le contenu YouTube sous la forme de flux d'API Google Data. Votre application cliente peut utiliser les flux de l'API YouTube Data pour extraire, rechercher et mettre à jour des vidéos, des commentaires, des réponses, des playlists, des profils utilisateur et des contacts utilisateur, ainsi que pour interroger des vidéos correspondant à des critères particuliers.
En plus de fournir des informations sur les fonctionnalités de l'API YouTube Data, ce document fournit des exemples d'interaction avec l'API à l'aide de la bibliothèque cliente Python. Pour utiliser la bibliothèque cliente Python, vous devez disposer de Python 2.0 ou version ultérieure, ainsi que des modules Element Tree, httplib et urllib. Pour en savoir plus, consultez la section Modules de dépendance.
Si vous avez besoin d'aide pour configurer la bibliothèque cliente Python, consultez le guide de démarrage. Pour en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque cliente Python pour interagir avec YouTube, consultez la page du protocole du guide du développeur.
À propos de ce document
Audience
Ce document est destiné aux programmeurs qui souhaitent écrire des applications clientes pouvant interagir avec YouTube à l'aide de la bibliothèque cliente Python. Il fournit une série d'exemples d'interactions d'API de données de base.
Pour en savoir plus sur la documentation de référence de l'API YouTube Data, consultez le guide de référence.
Ce document suppose que vous comprenez les idées générales derrière le protocole des API Google Data et que vous savez programmer en Python.
Pour obtenir des informations de référence sur les classes et les méthodes Python, consultez les pyDocs (pour la classe de service et les classes de données) inclus avec le code source.
Structure du document
Ce document inclut les sections suivantes :
-
La section Authentification décrit les deux méthodes d'authentification disponibles pour associer des opérations d'API à un compte utilisateur spécifique. Cette section décrit également les différences entre l'authentification pour l'API YouTube Data et les autres API Google Data. Tout au long de ce document, les explications des fonctions d'API spécifiques indiquent clairement si la fonction nécessite une authentification utilisateur. En général, toutes les requêtes qui modifient des données de vidéo ou de flux doivent être authentifiées. Les requêtes en lecture seule sur les vidéos publiques ne nécessitent pas d'authentification.
-
La section Comprendre les flux et les entrées vidéo fournit un exemple de réponse d'API et explique comment extraire des informations sur une vidéo spécifique à partir d'une liste de vidéos ou d'un ensemble de résultats de recherche. Cette section explique également comment accéder aux métadonnées d'une entrée vidéo spécifique. Enfin, cette section explique le mécanisme de mise à jour d'une entrée vidéo individuelle.
-
La section Récupérer et rechercher des vidéos explique comment récupérer des listes de vidéos spécifiques, comme un flux standard des vidéos les plus populaires sur YouTube. D'autres listes de vidéos incluent les vidéos importées par un utilisateur spécifique et les listes de vidéos associées à une vidéo spécifique. Cette section explique également comment utiliser l'API pour permettre aux utilisateurs de rechercher des vidéos dans la bibliothèque vidéo YouTube à l'aide de termes de recherche ou de catégories spécifiques.
-
La section Mettre en ligne des vidéos explique brièvement deux façons d'autoriser les utilisateurs à mettre en ligne des vidéos sur YouTube depuis votre application. Cette section explique également comment mettre en ligne des vidéos en réponse à d'autres vidéos.
-
La section Modifier et supprimer des vidéos explique comment utiliser l'API pour modifier les informations d'une vidéo YouTube. Elle explique également comment supprimer une vidéo à l'aide de l'API.
-
La section Utiliser les fonctionnalités de la communauté décrit les fonctions d'API qui permettent à vos utilisateurs d'interagir avec les vidéos YouTube. Ces fonctions expliquent les demandes de publication d'une note, d'un commentaire ou d'une réclamation sur une vidéo existante. Vous pouvez également utiliser l'API pour récupérer des listes de commentaires sur des vidéos.
-
La section Enregistrer et collecter des vidéos explique comment utiliser l'API pour accéder, créer et mettre à jour des vidéos, des playlists et des abonnements à des chaînes YouTube préférés. Il explique également comment modifier les playlists et les favoris en ajoutant et en supprimant des vidéos.
-
La section Activer l'interaction utilisateur explique comment utiliser l'API pour récupérer et mettre à jour des profils utilisateur. Cette section explique également comment récupérer, ajouter, mettre à jour et supprimer les contacts des utilisateurs.
Premiers pas
Conditions requises
Votre application cliente peut utiliser les flux de l'API YouTube Data pour rechercher, récupérer et mettre à jour des vidéos, des commentaires, des réponses, des playlists, des abonnements, des profils utilisateur, etc.En plus de fournir des informations sur les fonctionnalités de l'API YouTube Data, ce document fournit des exemples d'interaction avec l'API à l'aide de la bibliothèque cliente Python. Pour utiliser la bibliothèque cliente Python, vous devez disposer de Python 2.2 ou version ultérieure, ainsi que des modules Element Tree, httplib et urllib. Pour en savoir plus, consultez la section Modules de dépendance.
Pour en savoir plus sur la configuration de votre environnement, consultez le guide de démarrage. Pour en savoir plus sur le protocole sous-jacent utilisé par la bibliothèque cliente Python pour interagir avec YouTube, consultez la page du protocole du guide du développeur.
Vous pouvez copier/coller les extraits de code ci-dessous dans votre code et les modifier en fonction de vos besoins.
Avant de pouvoir effectuer des opérations avec l'API YouTube Data, vous devez initialiser un objet gdata.youtube.service.YouTubeService, comme indiqué ci-dessous. Les instructions import listées ci-dessous effectuent automatiquement d'autres importations à partir des modules gdata.media et gdata.geo. Veuillez noter que toutes les actions autres que la récupération de contenu public nécessitent une authentification.
import gdata.youtube import gdata.youtube.service yt_service = gdata.youtube.service.YouTubeService() # Turn on HTTPS/SSL access. # Note: SSL is not available at this time for uploads. yt_service.ssl = True
La plupart des exemples de méthodes de ce guide s'exécutent sur une instance de gdata.youtube.service.YouTubeService. Il peut être utile de tester les requêtes non authentifiées à partir de l'interpréteur Python interactif.
Remarque: La bibliothèque cliente Python doit être correctement ajoutée à votre chemin d'accès. Assurez-vous de l'installer en exécutant le script setup.py fourni. Pour en savoir plus, consultez le guide de démarrage.
Authentification
La bibliothèque cliente Python peut être utilisée pour travailler avec des flux publics ou privés. Les flux publics sont en lecture seule et ne nécessitent aucune authentification. Les flux privés nécessitent que vous vous authentifiiez sur les serveurs YouTube.
L'authentification peut être effectuée via l'authentification ClientLogin (pour les applications de bureau) ou via l'authentification AuthSub (pour les applications Web).
Définir votre clé de développeur et votre ID client
Une clé de développeur identifie le développeur YouTube qui envoie une requête API. Un ID client identifie votre application à des fins de journalisation et de débogage.
Lorsque vous envoyez une requête API à l'aide de la bibliothèque cliente Python, l'en-tête de requête X-GData-Key permet de spécifier votre clé de développeur, et l'en-tête X-GData-Client permet de spécifier votre ID client. La clé du développeur et l'ID client peuvent être définis sur l'objet YouTubeService, indépendamment du schéma d'authentification utilisé:
yt_service.developer_key = 'ABCxyz123...' yt_service.client_id = 'My-Client_id'
Vous devez vous inscrire pour obtenir une clé de développeur YouTube.
Authentification AuthSub pour les applications Web
L'authentification par proxy AuthSub est utilisée par les applications Web qui doivent authentifier leurs utilisateurs auprès de comptes YouTube/Google. L'opérateur n'a pas besoin d'accéder au nom d'utilisateur et au mot de passe de l'utilisateur YouTube. Seuls des jetons AuthSub spéciaux sont requis.
Lorsque l'utilisateur accède à votre application pour la première fois, il n'est pas encore authentifié auprès des services Google. Dans ce cas, vous devez lui fournir un lien redirigeant l'utilisateur vers Google pour qu'il autorise la demande d'accès de vos applications à son compte YouTube. La bibliothèque cliente Python fournit une fonction permettant de générer cette URL. Le code ci-dessous configure un lien vers la page AuthSubRequest.
def GetAuthSubUrl(): next = 'http://www.example.com/video_upload.pyc' scope = 'http://gdata.youtube.com' secure = False session = True yt_service = gdata.youtube.service.YouTubeService() return yt_service.GenerateAuthSubURL(next, scope, secure, session) authSubUrl = GetAuthSubUrl() print '<a href="%s">Login to your Google account</a>' % authSubUrl
Notez les paramètres envoyés à la méthode GenerateAuthSubURL des objets de service:
- next : URL de la page vers laquelle YouTube doit rediriger l'utilisateur après qu'il a autorisé votre application à accéder à son compte.
- scope : indique que l'application n'accèdera qu'aux flux de l'API YouTube.
- secure (sécurisé) : indique que le jeton renvoyé ne sera pas sécurisé.
- session : indique que ce jeton peut être échangé contre un jeton à usage multiple (session).
L'URL renvoyée se présente comme suit:
https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fgdata.youtube.com&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fvideo_upload.pyc
L'utilisateur peut ensuite suivre le lien pour se connecter à son compte YouTube. Une fois que l'utilisateur a autorisé votre application à accéder à son compte, il est redirigé vers l'URL next. Une valeur de jeton à usage unique sera ajoutée à l'URL en tant que paramètre de requête. L'URL ressemble à ce qui suit :
http://www.example.com/video_upload.pyc?token=Abc123...
La section suivante explique comment mettre à niveau ce jeton. L'extrait de code ci-dessous montre l'une des façons de récupérer ce jeton à partir de l'URL:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Passer à un jeton de session
Pour des raisons de sécurité, ce jeton est à usage unique. Vous devez donc l'échanger contre un jeton de session. Ce processus est décrit dans la documentation AuthSub. L'extrait de code suivant montre comment mettre à niveau le jeton.
yt_service = gdata.youtube.service.YouTubeService() yt_service.SetAuthSubToken(authsub_token) yt_service.UpgradeToSessionToken()
Cette valeur de jeton représente un jeton AuthSub à usage unique. Étant donné que session = True a été spécifié ci-dessus, ce jeton peut être échangé contre un jeton de session AuthSub à l'aide de la méthode UpgradeToSessionToken, qui appelle le service AuthSubSessionToken.
Votre objet YouTubeService est désormais entièrement authentifié et peut être utilisé pour effectuer toutes les autres requêtes avec l'API YouTube. Les jetons de session AuthSub n'expirent que si vous demandez spécifiquement à les révoquer ou si l'utilisateur décide de révoquer l'accès en accédant à la page Sites autorisés de son compte YouTube.
Authentification ClientLogin pour les applications installées
L'authentification ClientLogin est utilisée dans les applications installées qui peuvent stocker le nom d'utilisateur et le mot de passe de l'utilisateur ou l'interroger à ce sujet. Pour utiliser cette forme d'authentification, appelez la méthode ProgrammaticLogin de YouTubeService héritée de la classe gdata.service.GDataService, en spécifiant l'ID et le mot de passe de l'utilisateur au nom duquel votre client envoie la requête d'authentification.
yt_service = gdata.youtube.service.YouTubeService() yt_service.email = 'jo@gmail.com' yt_service.password = 'mypassword' yt_service.source = 'my-example-application' yt_service.ProgrammaticLogin()
Une fois les identifiants définis, l'objet YouTubeService peut être utilisé pour gérer toutes les requêtes ultérieures. Pour pouvoir effectuer des importations et tout type de requêtes d'écriture (ajout de commentaires, etc.) dans l'API YouTube, assurez-vous également de transmettre votre clé de développeur et votre ID client à l'objet yt_service lorsque vous effectuez l'authentification:
# A complete client login request yt_service.email = 'jo@gmail.com' yt_service.password = 'mypassword' yt_service.source = 'my-example-application' yt_service.developer_key = 'ABC123...' yt_service.client_id = 'my-example-application' yt_service.ProgrammaticLogin()
L'objet YouTubeService définit automatiquement les en-têtes X-GData-Key et X-GData-Client appropriés lorsque les attributs developer_key et client_id sont définis.
Remarque:Pour en savoir plus sur les mécanismes AuthSub et ClientLogin, consultez la documentation sur l'authentification des API Google Data.
Comprendre les flux et les entrées vidéo
L'API YouTube Data fournit plusieurs flux vidéo qui représentent des listes de vidéos, comme les flux standards, les mises en ligne, les abonnements et les favoris. L'URL de chaque flux est indiquée dans le guide de référence.
Affichage d'un flux de vidéos
De nombreux flux de l'API YouTube sont constitués d'entrées vidéo. La modélisation la plus simple de ces flux consiste à les représenter sous la forme d'objets gdata.youtube.YouTubeVideoFeed, chacun contenant un certain nombre d'objets gdata.youtube.YouTubeVideoEntry. Chaque entrée vidéo correspond à une vidéo YouTube unique et contient des informations à son sujet.
La structure de base de la récupération d'une liste de vidéos consiste à créer une URL vers un flux vidéo, puis à traiter les entrées une par une, comme dans le code suivant:
def GetAndPrintVideoFeed(uri):
yt_service = gdata.youtube.service.YouTubeService()
feed = yt_service.GetYouTubeVideoFeed(uri)
for entry in feed.entry:
PrintEntryDetails(entry) # full documentation for this function
La section Récupérer et rechercher des vidéos détaille de nombreuses URL de flux courantes et explique comment récupérer différents flux vidéo.
Récupérer une entrée vidéo spécifique
Vous ne pouvez récupérer que les informations d'une vidéo spécifique si vous connaissez son ID. L'URL d'entrée est basée sur l'ID vidéo:
http://gdata.youtube.com/feeds/api/videos/videoID
Le code suivant récupère un gdata.youtube.YouTubeVideoEntry correspondant à une vidéo sur YouTube:
entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')
Contenu de la vidéo
De nombreuses métadonnées peuvent être récupérées à partir d'un objet gdata.youtube.YouTubeVideoEntry, telles que les miniatures, les URL des lecteurs et la durée des vidéos. Le code suivant montre comment accéder à certaines de ces informations. La bibliothèque cliente Python effectue une abstraction de la plupart de ces fonctionnalités en mappant des éléments XML dans des classes. La plupart des informations importantes sur une entrée YouTubeVideoEntry sont disponibles auprès des enfants de l'attribut media (contenant un objet gdata.media.Group) dans l'entrée (représentant l'élément XML media:group). Vous trouverez ci-dessous un exemple de récupération de métadonnées vidéo:
def PrintEntryDetails(entry):
print 'Video title: %s' % entry.media.title.text
print 'Video published on: %s ' % entry.published.text
print 'Video description: %s' % entry.media.description.text
print 'Video category: %s' % entry.media.category[[]0].text
print 'Video tags: %s' % entry.media.keywords.text
print 'Video watch page: %s' % entry.media.player.url
print 'Video flash player URL: %s' % entry.GetSwfUrl()
print 'Video duration: %s' % entry.media.duration.seconds
# non entry.media attributes
print 'Video geo location: %s' % entry.geo.location()
print 'Video view count: %s' % entry.statistics.view_count
print 'Video rating: %s' % entry.rating.average
# show alternate formats
for alternate_format in entry.media.content:
if 'isDefault' not in alternate_format.extension_attributes:
print 'Alternate format: %s | url: %s ' % (alternate_format.type,
alternate_format.url)
# show thumbnails
for thumbnail in entry.media.thumbnail:
print 'Thumbnail url: %s' % thumbnail.url
Remarque:Pour savoir comment générer les informations requises pour intégrer une vidéo avec un lecteur sur votre page, consultez le guide du protocole.
Récupérer et rechercher des vidéos
Récupérer des flux standards
L'API YouTube Data fournit un flux standard des vidéos les plus populaires sur YouTube. L'API était auparavant compatible avec d'autres flux standards, qui ont depuis été abandonnés. Pour en savoir plus, consultez le guide du développeur.
L'URL du flux des vidéos les plus populaires sur YouTube se présente comme suit:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Remarque : Vous pouvez également récupérer des flux standards spécifiques aux paramètres régionaux en spécifiant un localeID au format http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Par exemple, les vidéos les plus populaires au Japon sont les suivantes: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Pour obtenir la liste complète des localeID supposés, consultez le guide de référence .
def PrintVideoFeed(feed):
for entry in feed.entry:
PrintEntryDetails(entry)
def GetAndPrintFeedByUrl:
yt_service = gdata.youtube.service.YouTubeService()
# You can retrieve a YouTubeVideoFeed by passing in the URI
uri = 'http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular'
PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))
Récupérer les vidéos mises en ligne par un utilisateur spécifique
Chaque utilisateur YouTube dispose d'un flux vidéo associé aux vidéos qu'il a mises en ligne, à l'adresse http://gdata.youtube.com/feeds/api/users/username/uploads.
Le code suivant montre comment récupérer et afficher le flux d'importations d'un utilisateur:
def GetAndPrintUserUploads(username): yt_service = gdata.youtube.service.YouTubeService() uri = 'http://gdata.youtube.com/feeds/api/users/%s/uploads' % username PrintVideoFeed(yt_service.GetYouTubeVideoFeed(uri))
Remarque:Vous pouvez également utiliser la chaîne "default" à la place de username pour récupérer les vidéos de l'utilisateur actuellement authentifié.
Récupérer des vidéos similaires
Pour récupérer des vidéos associées, transmettez l'ID de la vidéo de l'objet gdata.youtube.YouTubeVideoEntry à la méthode GetYouTubeRelatedVideoFeed de l'objet gdata.youtube.service.YouTubeService. Cela permet de récupérer un objet YouTubeVideoFeed contenant des entrées associées.
related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')
Rechercher des vidéos
L'API YouTube Data vous permet de demander un ensemble d'entrées correspondant à des critères spécifiés, par exemple en demandant des entrées vidéo publiées par un auteur particulier, par format vidéo ou contenant un mot clé particulier. Pour ce faire, créez un objet gdata.service.YouTubeVideoQuery avec vos critères de recherche spécifiques, puis transmettez-le à la méthode YouTubeQuery de gdata.youtube.service.YouTubeService.
L'exemple ci-dessous montre comment effectuer une requête de recherche, avec des résultats triés par nombre de vues, y compris les vidéos soumises à restriction (appelées "Racy" par l'API):
def SearchAndPrint(search_terms): yt_service = gdata.youtube.service.YouTubeService() query = gdata.youtube.service.YouTubeVideoQuery() query.vq = search_terms query.orderby = 'viewCount' query.racy = 'include' feed = yt_service.YouTubeQuery(query) PrintVideoFeed(feed)
La classe gdata.service.Query et les sous-classes telles que YouTubeVideoQuery sont chargées de créer des URL de flux. VideoQuery, illustré ci-dessus, crée une URL équivalente à la suivante:
http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount
Voici quelques-unes des propriétés YouTubeVideoQuery les plus courantes pour définir des paramètres de recherche:
author- Définit l'auteur de l'entrée. L'auteur est synonyme de nom d'utilisateur YouTube.
format- Spécifie un format vidéo. Accepte des paramètres numériques pour spécifier l'un des deux types d'URL de streaming RTSP pour la lecture vidéo sur mobile ou une URL HTTP vers le lecteur Flash intégré.
racy- Indique si le contenu soumis à des restrictions doit être inclus dans les résultats. N'accepte que deux paramètres: "include" ou "exclude".
max_results- Définit le nombre maximal d'entrées à renvoyer en une seule fois.
start_index- Définit l'index en base 1 du premier résultat à récupérer (pour la pagination).
orderby- Définit l'ordre dans lequel les entrées doivent être listées, par exemple par
relevance,viewCount,publishedourating. time- Définit une période pour limiter les résultats du flux standard aux valeurs suivantes:
today,this_week,this_monthouall_time. vq- Définit un terme de requête de recherche. Recherche la chaîne spécifiée dans toutes les métadonnées des vidéos, comme les titres, les tags et les descriptions.
Remarque:Pour en savoir plus sur les paramètres de requête, consultez le guide de référence de l'API YouTube Data et le guide de référence des API Google Data.
Rechercher à l'aide de catégories et de mots clés
Vous pouvez limiter les résultats de recherche pour n'afficher que les vidéos correspondant à un ensemble donné de catégories et de mots clés. Le guide de référence explique comment spécifier à la fois des catégories YouTube prédéfinies (par exemple, "Musique", "Personnes et blogs", etc.) et des mots clés (tags) définis par l'utilisateur.
Le code suivant montre comment effectuer une recherche à l'aide de mots clés (balises) en remplaçant les termes de recherche par des minuscules. Remarque: Étant donné que certains mots (comme "comédie") peuvent être à la fois une catégorie YouTube et un mot clé, les requêtes de catégorie et de mot clé utilisent la convention selon laquelle un mot majuscule ("Comédie") désigne une catégorie YouTube, tandis qu'un mot minuscule ("comédie") désigne un mot clé.
def SearchAndPrintVideosByKeywords(list_of_search_terms):
yt_service = gdata.youtube.service.YouTubeService()
query = gdata.youtube.service.YouTubeVideoQuery()
query.orderby = 'viewCount'
query.racy = 'include'
for search_term in list_of_search_terms:
new_term = search_term.lower()
query.categories.append('/%s' % new_term)
feed = yt_service.YouTubeQuery(query)
PrintVideoFeed(feed)
Rechercher par tags de développeur
Les tags du développeur sont des mots clés supplémentaires et masqués qu'un développeur peut utiliser pour taguer le contenu mis en ligne par les utilisateurs finaux via son application. Les tags de développeur sont mis en correspondance avec la clé de développeur définie dans les en-têtes lors de la mise en ligne. Ces mots clés ne seront pas visibles par le public et peuvent être utilisés pour récupérer des vidéos. Pour rechercher des vidéos à l'aide d'un tag de développeur spécifique, envoyez une requête de recherche générale à l'aide de votre clé de développeur. Veillez à spécifier le schéma de catégories et la balise de développeur auxquels les vidéos doivent correspondre. Vous pouvez récupérer un flux de vidéos correspondant à votre balise de développeur ('votre_balise_ici' dans notre exemple) à partir de l'URL ci-dessous:
developer_tag_uri = 'http://gdata.youtube.com/feeds/videos/-/%7Bhttp%3A%2F%2Fgdata.youtube.com%2Fschemas%2F2007%2Fdevelopertags.cat%7Dyour_tag_here' yt_service = gdata.youtube.service.YouTubeService() PrintVideoFeed(yt_service.GetYouTubeVideoFeed(developer_tag_uri))
Mettre en ligne des vidéos
Veuillez consulter les schémas du guide du protocole pour obtenir une vue d'ensemble du processus d'importation. Vous pouvez importer des vidéos de deux manières:
- en important la vidéo directement depuis vos serveurs via la méthode d'importation directe ;
- ou en envoyant d'abord les métadonnées, puis en demandant à l'utilisateur de mettre en ligne la vidéo directement sur YouTube via la méthode d'importation dans le navigateur.
Importation directe
Pour importer une vidéo, vous devez d'abord créer un objet gdata.youtube.YouTubeVideoEntry, en lui transmettant un objet gdata.media.Group contenant les métadonnées requises. L'exemple suivant montre comment importer la vidéo QuickTime "mytestmovie.mov" sur YouTube avec les propriétés suivantes:
| Propriété | Value (Valeur) |
|---|---|
| Title | Mon film de test |
| Catégorie | Automobiles |
| Mots clés | voitures, drôle |
| Description | Ma description |
| Nom de fichier | mytestmovie.mov |
| Type MIME du fichier | video/quicktime |
| La vidéo est-elle privée ? | faux |
| Lieu de tournage de la vidéo | 37,-122 (lat,long) |
| Tags de développeur | mydevelopertag, anotherdevelopertag |
Le code ci-dessous crée un YouTubeVideoEntry vierge à importer. La méthode InsertVideoEntry sur YouTubeService nécessite les paramètres suivants:
video_entry: objetgdata.youtube.VideoEntrycontenant des métadonnéesfilename_or_handle: objet de type fichier ou nom de fichier à partir duquel la vidéo sera lueyoutube_username: chaîne facultative spécifiant le nom d'utilisateur du compte sur lequel cette vidéo doit être mise en ligne. Bien entendu, votre compte doit disposer des autorisations appropriées. Par défaut, il s'agit du compte de l'utilisateur actuellement authentifié.content_type: chaîne facultative spécifiant le type MIME de la vidéo à importer.
yt_service fait référence à un objet YouTubeService entièrement authentifié.
# prepare a media group object to hold our video's meta-data
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None
)
# prepare a geo.where object to hold the geographical location
# of where the video was recorded
where = gdata.geo.Where()
where.set_location((37.0,-122.0))
# create the gdata.youtube.YouTubeVideoEntry to be uploaded
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group,
geo=where)
# set the path for the video file binary
video_file_location = '/path/to/my/file.mov'
new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)
Si nous souhaitions ajouter des tags de développeur facultatifs à notre vidéo (pour en savoir plus, consultez Rechercher par tags de développeur), nous aurions pu utiliser la méthode AddDeveloperTags avant d'effectuer l'appel à InsertVideoEntry:
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Remarque: Pour mettre en ligne des vidéos en mode privé, vous devez transmettre un attribut privé à gdata.media.Group:
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None,
private=gdata.media.Private()
)
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)
# assuming that video_file_location points to a valid path
new_entry = yt_service.InsertVideoEntry(video_entry, video_file_location)
Importation basée sur un navigateur
L'importation dans le navigateur est presque identique à l'importation directe, sauf que vous n'importez pas votre fichier binaire dans la même requête que celle que vous utilisez pour envoyer les métadonnées de la vidéo. Vous créez simplement un YouTubeVideoEntry qui ne contient que des métadonnées. Cette entrée vidéo est ensuite publiée sur un lien spécial sur le serveur de l'API YouTube. La réponse XML contient un token et un url qui peuvent ensuite être utilisés pour importer le fichier binaire à l'aide d'un formulaire HTML standard.
# create media group as usual
my_media_group = gdata.media.Group(
title=gdata.media.Title(text='My Test Movie'),
description=gdata.media.Description(description_type='plain',
text='My description'),
keywords=gdata.media.Keywords(text='cars, funny'),
category=[[]gdata.media.Category(
text='Autos',
scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
label='Autos')],
player=None
)
# create video entry as usual
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)
# upload meta data only
response = yt_service.GetFormUploadToken(video_entry)
# parse response tuple and use the variables to build a form (see next code snippet)
post_url = response[[]0]
youtube_token = response[[]1]
Le code ci-dessus affiche un lien et un jeton qui permettent de créer un formulaire HTML à afficher dans le navigateur de l'utilisateur. Un exemple de formulaire simple est présenté ci-dessous, avec youtube_token représentant le contenu de l'élément de jeton renvoyé, comme indiqué dans la récupération de YouTubeVideoEntry ci-dessus. Pour que l'utilisateur soit redirigé vers votre site Web après l'envoi du formulaire, veillez à ajouter un paramètre next à post_url (comme indiqué ci-dessous). Il fonctionnera de la même manière que le paramètre next d'un lien AuthSub. La seule différence est qu'ici, au lieu d'un jeton à usage unique, une variable status et une variable id sont renvoyées en tant que paramètres d'URL.
next = 'http://example.com/post_video_upload.pyc'
form = """<form action="%s?nexturl=%s" method="post" enctype="multipart/form-data">
<input name="file" type="file"/>
<input name="token" type="hidden" value="%s"/>
<input value="Upload Video File" type="submit" />
</form>""" % (post_url, next, youtube_token)
Une réponse pour une importation réussie se présente alors comme suit:
http://example.com/post_video_upload.pyc?status=200&id=ABC123
Le paramètre status renvoie l'état de la transaction HTTP de l'importation. Le paramètre id renvoie l'ID vidéo YouTube attribué à la vidéo mise en ligne.
Vérifier l'état de l'importation
Une fois une vidéo importée, elle est immédiatement visible dans le flux d'importations d'un utilisateur authentifié. Toutefois, il ne sera pas public sur le site tant qu'il n'aura pas été traité. Les vidéos refusées ou dont la mise en ligne a échoué ne s'affichent également que dans le flux de mises en ligne de l'utilisateur authentifié. Le code suivant vérifie l'état d'un YouTubeVideoEntry pour voir s'il n'est pas encore actif ou s'il a été refusé.
upload_status = yt_service.CheckUploadStatus(new_entry) if upload_status is not None: video_upload_state = upload_status[[]0] detailed_message = upload_status[[]1]
Modifier et supprimer des vidéos
Modifier les informations d'une vidéo
Pour mettre à jour les métadonnées vidéo, il vous suffit de modifier l'objet YouTubeVideoEntry, puis d'utiliser la méthode UpdateVideoEntry des objets YouTubeService. Cette méthode utilise un YouTubeVideoEntry contenant des métadonnées mises à jour comme paramètre.
# assuming we have a video entry that was just posted in our 'new_entry' variable new_entry.media.title.text = 'My Updated Video Title' new_entry.media.description.text = 'Just updated' updated_entry = yt_service.UpdateVideoEntry(new_entry)
Suppression d'une vidéo
La suppression d'une vidéo est très simple. Il suffit d'appeler DeleteVideoEntry de l'objet YouTubeService.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Utiliser les fonctionnalités communautaires
Ajouter une note
Pour évaluer une vidéo, utilisez la méthode AddRating de l'objet YouTubeService. Veuillez noter que vous ne pouvez pas évaluer vos propres vidéos et que les notes doivent être comprises entre 1 et 5 (inclus):
video_id_to_rate = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate) response = yt_service.AddRating(3, video_entry)
Commentaires
Récupérer les commentaires d'une vidéo
À partir d'un objet YouTubeVideoEntry ou d'un ID vidéo simple, vous pouvez récupérer et imprimer un flux contenant les commentaires de la vidéo à l'aide de la méthode GetYouTubeVideoCommentFeed de l'objet YouTubeService. Le flux obtenu est un gdata.youtube.YouTubeCommentFeed, composé d'objets gdata.youtube.YouTubeCommentEntry. Le flux peut être analysé comme n'importe quel autre flux:
video_id = 'ABC123...' comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id) for comment_entry in comment_feed.entry: print comment_entry.ToString()
Ajout d'un commentaire…
Pour ajouter un commentaire, utilisez simplement la méthode AddComment de l'objet YouTubeService. La méthode nécessite un objet YouTubeVideoEntry complet à commenter, ainsi qu'une chaîne représentant le commentaire:
my_comment = 'what a boring test video' video_id = '9g6buYJTt_g' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id) yt_service.AddComment(comment_text=my_comment, video_entry=video_entry)
Commentaires vidéo
Une vidéo de réponse YouTube était une vidéo associée, en tant que réponse, à une deuxième vidéo. La fonctionnalité de réponses vidéo a été abandonnée, comme expliqué dans cette annonce. Les réponses vidéo existantes sont toujours disponibles, mais YouTube ne permet plus de récupérer une liste de réponses vidéo pour une vidéo, de mettre en ligne de nouvelles réponses vidéo ni de les supprimer. Vous pouvez toutefois supprimer la vidéo utilisée dans une réponse vidéo. Par conséquent, ces fonctions ne sont plus disponibles dans l'API.
Les requêtes API pour les opérations de réponse vidéo renvoient désormais les éléments suivants:
- Une requête visant à récupérer les réponses vidéo pour une vidéo renvoie une liste vide.
- Une requête d'ajout d'une réponse vidéo renvoie un code de réponse HTTP 403.
- Une requête de suppression d'une réponse vidéo renvoie un code de réponse HTTP 403.
Signalement d'une vidéo
Pour ajouter une réclamation concernant une vidéo, utilisez la méthode AddComplaint sur l'objet YouTubeService. Le terme de la réclamation doit être une catégorie valide. Pour en savoir plus, consultez la section Ajouter une réclamation du guide du protocole.
video_id_to_flag = 'Ncakifd_16k'
complaint_term = 'VIOLENCE'
complaint_text = ('Please ignore this complaint. '
'I\'m testing a YouTube API and needed to issue '
'a complaint to test the add complaint function. ')
response = yt_service.AddComplaint(complaint_text, complaint_term, video_id_to_flag)
Enregistrer et collecter des vidéos
Vidéos favorites
Récupérer les vidéos préférées d'un utilisateur
Les utilisateurs YouTube peuvent choisir de marquer les vidéos qu'ils regardent comme des favoris. L'emplacement général du flux favori d'un utilisateur est l'URL suivante.
http://gdata.youtube.com/feeds/api/users/username/favorites
Pour récupérer les vidéos préférées d'un utilisateur, utilisez la méthode GetUserFavoritesFeed de l'objet YouTubeService. La méthode reçoit une chaîne facultative en tant que paramètre représentant le nom d'utilisateur YouTube de l'utilisateur dont le flux favori doit être récupéré.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
Le flux renvoyé est un flux vidéo standard, contenant des objets YouTubeVideoEntry.
Remarque:Vous pouvez également transmettre la chaîne default pour récupérer les favoris de l'utilisateur actuellement authentifié. Il s'agit du comportement par défaut de la méthode GetUserFavoritesFeed si aucun nom d'utilisateur n'est fourni.
Ajouter un favori
Pour ajouter une vidéo à vos favoris, utilisez la méthode AddVideoEntryToFavorites de l'objet YouTubeService. Les paramètres sont le YouTubeVideoEntry à ajouter et éventuellement le nom d'utilisateur auquel il doit être ajouté (par défaut, l'utilisateur actuellement authentifié).
video_id = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id) response = yt_service.AddVideoEntryToFavorites(video_entry) # The response, if successfully posted is a YouTubeVideoEntry if isinstance(response, gdata.youtube.YouTubeVideoEntry): print 'Video successfully added to favorites'
Supprimer un favori
Pour supprimer un favori, utilisez simplement la méthode DeleteVideoEntryFromFavorites de l'objet YouTubeService.
video_id = 'Ncakifd_16k' response = yt_service.DeleteVideoEntryFromFavorites(video_id) if response is True: print 'Video deleted from favorites'
Playlists
Chaque utilisateur YouTube dispose d'un flux de playlists contenant toutes les playlists qu'il a créées. Chaque playlist dispose ensuite d'un flux pour toutes les vidéos qu'elle contient.
Récupérer les playlists des utilisateurs
Pour récupérer manuellement la liste de toutes les playlists d'un utilisateur, utilisez l'URL suivante:
http://gdata.youtube.com/feeds/api/users/username/playlists
Avec la bibliothèque cliente Python, vous pouvez utiliser la méthode GetYouTubePlaylistFeed de l'objet YouTubeService:
playlist_feed = yt_service.GetYouTubePlaylistFeed(username='gdpython') # instead of passing in a username, you can also pass the URI to the playlist feed: playlist_feed = yt_service.GetYouTubePlaylistFeed(uri='http://gdata.youtube.com/feeds/api/users/default/playlists')
Remarque:Au lieu de transmettre un nom d'utilisateur spécifique (par exemple, "gdpython" dans l'exemple ci-dessus), vous pouvez également transmettre la chaîne 'default' pour faire référence à l'utilisateur actuellement authentifié.
Un gdata.youtube.YouTubePlaylistFeed représente un flux d'objets gdata.youtube.YouTubePlaylistEntry. Il s'agit des playlists individuelles qu'un utilisateur peut avoir. Les entrées vidéo d'une playlist spécifique sont représentées par des objets gdata.youtube.YouTubePlaylistVideoEntry. Ces objets sont très similaires aux objets gdata.youtube.YouTubeVideoEntry standards, à quelques exceptions près. Vous pouvez leur appliquer des titres et des descriptions personnalisés, et un champ de position indique leur position dans la playlist.
Récupérer des informations sur la playlist
Étant donné un YouTubePlaylistEntry (représentant une playlist spécifique), vous pouvez obtenir une YouTubePlaylistVideoFeed contenant des objets YouTubePlaylistVideoEntry. Comme expliqué ci-dessus, ces objets représentent des vidéos individuelles dans une playlist (avec des titres et des descriptions personnalisés facultatifs). Pour obtenir ce flux, transmettez l'URI de votre playlist à la méthode GetYouTubePlaylistVideoFeed de l'objet YouTubeService:
# a typical playlist URI playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' playlist_video_feed = yt_service.GetYouTubePlaylistVideoFeed(uri=playlist_uri) # iterate through the feed as you would with any other for playlist_video_entry in playlist_video_feed.entry: print playlist_video_entry.title.text
Ajouter une playlist
Pour ajouter une playlist, utilisez simplement la méthode AddPlaylist de l'objet YouTubeService. Cette méthode prend les paramètres suivants: playlist_title, playlist_description (deux chaînes) et une valeur booléenne facultative qui peut être définie sur True si la playlist doit être marquée comme privée.
new_public_playlistentry = yt_service.AddPlaylist('my new playlist', 'a new playlist')
if isinstance(new_public_playlistentry, gdata.youtube.YouTubePlaylistEntry):
print 'New playlist added'
# adding a private playlist
new_private_playlistentry = yt_service.AddPlaylist('new private playlist', 'a new private playlist', True)
if isinstance(new_private_playlistentry, gdata.youtube.YouTubePlaylistEntry):
print 'New private playlist added'
Mettre à jour une playlist
Pour mettre à jour une playlist, utilisez la méthode UpdatePlaylist de l'objet YouTubeService. La méthode prend les paramètres suivants: l'ID de la playlist à mettre à jour, un nouveau titre, une nouvelle description, une valeur booléenne facultative pour marquer la playlist comme privée et une chaîne facultative indiquant le nom d'utilisateur propriétaire de la playlist. La chaîne sera définie par défaut sur l'utilisateur actuellement authentifié.
# here we are updating a public playlist with a new title while also making it private
# we assume that playlist_to_be_updated here represents a YouTubePlaylistEntry object
playlist_entry_id = playlist_to_be_updated.id.text.split('/')[[]-1]
# we want to keep the original description for the playlist so we store it first
original_description = playlist_to_be_updated.description.text
updated_playlist = yt_service.UpdatePlaylist(playlist_entry_id,
'a new updated title',
original_playlist_description,
playlist_private=True)
Ajout d'une vidéo à une playlist
Vous pouvez ajouter une vidéo à une playlist à l'aide de la méthode AddPlaylistVideoEntryToPlaylist de l'objet YouTubeService. Le code ci-dessous ajoute une vidéo à une playlist, avec un titre et une description personnalisés.
custom_video_title = 'my test video on my test playlist'
custom_video_description = 'this is a test video on my test playlist'
video_id = 'Ncakifd_16k'
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_video_entry = yt_service.AddPlaylistVideoEntryToPlaylist(
playlist_uri, video_id, custom_video_title, custom_video_description)
if isinstance(playlist_video_entry, gdata.youtube.YouTubePlaylistVideoEntry):
print 'Video added'
Remarque:Sachez qu'un titre et une description personnalisés ne sont pas obligatoires. Si vous ne les spécifiez pas, le titre et la description réels de la vidéo seront utilisés.
Modifier les informations d'une vidéo dans une playlist
Utilisez la méthode UpdatePlaylistVideoEntryMetaData de l'objet YouTubeService pour modifier les métadonnées d'un YouTubePlaylistVideoEntry. Dans l'exemple ci-dessous, nous décidons de donner un nouveau titre personnalisé à notre vidéo et de la placer à la première position (1) de notre playlist.
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'
new_video_title = 'a useful video'
new_video_description = 'updated video description'
updated_playlist_video_entry = yt_service.UpdatePlaylistVideoEntryMetaData(
playlist_uri, playlist_entry_id, new_video_title, new_video_description, 1)
Remarque:Si vous souhaitez rétablir les métadonnées d'origine du titre et de la description d'une vidéo dans une playlist, il vous suffit de transmettre NULL pour le titre et la description.
Supprimer la vidéo de la playlist
Pour supprimer une vidéo d'une playlist, utilisez la méthode DeletePlaylistVideoEntry de l'objet YouTubeService. La méthode nécessite l'URI de la playlist contenant l'entrée à supprimer, ainsi que l'ID de l'entrée:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'
response = yt_service.DeletePlaylistVideoEntry(playlist_uri,
playlist_entry_id)
if response is True:
print 'Entry successfully deleted'
Suppression d'une playlist
Pour supprimer une playlist, utilisez simplement la méthode DeletePlaylist de l'objet YouTubeService, en transmettant l'URI de la playlist à supprimer:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' response = yt_service.DeletePlaylist(playlist_uri) if response is True: print 'Playlist successfully deleted'
Abonnements
Pour récupérer la liste des chaînes, des recherches et des favoris auxquels un utilisateur donné est abonné, utilisez l'URI suivant:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Remarque:Vous pouvez également transmettre la chaîne default pour récupérer les favoris de l'utilisateur actuellement authentifié.
Récupérer les abonnements des utilisateurs
Le code suivant montre comment récupérer et imprimer la liste des abonnements d'un utilisateur donné. Les abonnements sont représentés par un gdata.youtube.YouTubeSubscriptionFeed composé d'objets gdata.youtube.YouTubeSubscriptionEntry. Pour récupérer des abonnements, utilisez la méthode GetYouTubeSubscriptionFeed de l'objet YouTubeService, en transmettant l'URI d'un flux d'abonnements ou le nom d'utilisateur dont le flux d'abonnements doit être récupéré. Le paramètre "nom d'utilisateur" est défini par défaut sur l'utilisateur actuellement authentifié.
subscription_feed = yt_service.GetYouTubeSubscriptionFeed(username='gdpython')
if isinstance(subscription_feed, gdata.youtube.YouTubeSubscriptionFeed)):
# given a YouTubeSubscriptionEntry we can determine it's type (channel, favorite, or query)
for entry in subscription_feed.entry:
print entry.GetSubscriptionType()
Ajouter un abonnement
Vous pouvez créer un abonnement en insérant un nouvel élément YouTubeSubsciptionEntry dans le flux d'abonnements de l'utilisateur authentifié. Vous pouvez créer trois types d'abonnements: un abonnement à la chaîne d'un utilisateur (à l'aide de AddSubscriptionToChannel), un abonnement aux favoris d'un utilisateur (à l'aide de AddSubscriptionToFavorites) ou un abonnement à un mot clé spécifique (à l'aide de AddSubscriptionToQuery). Le code suivant abonne l'utilisateur authentifié à la chaîne "GoogleDevelopers".
new_subscription = yt_service.AddSubscriptionToChannel(
username_to_subscribe_to='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Vous pouvez également vous abonner aux favoris de l'utilisateur "GoogleDevelopers" :
new_subscription = yt_service.AddSubscriptionToFavorites(
username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Enfin, vous pouvez également vous abonner à des termes de recherche spécifiques. Nous nous abonnons ici à une requête pour les vidéos taguées "python".
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Supprimer un abonnement
Pour supprimer l'abonnement d'un utilisateur, utilisez la méthode DeleteSubscription de l'objet YouTubeService.
sample_subscription_uri = ('http://gdata.youtube.com/feeds/api/users/'
'gdpython/subscriptions/c0c77ca6102a7479')
response = yt_service.DeleteSubscription(sample_subscription_uri)
if response is True:
print 'Subscription successfully deleted'
Activer l'interaction utilisateur
Profils utilisateur
Récupérer le profil d'un utilisateur
Pour extraire manuellement le profil YouTube d'un utilisateur, utilisez l'URI suivant:
http://gdata.youtube.com/feeds/api/users/username
Vous pouvez récupérer un gdata.youtube.YouTubeUserEntry à l'aide de la méthode GetYouTubeUserEntry de l'objet YouTubeService.
user_entry = yt_service.GetYouTubeUserEntry(username='gdpython')
# we can then write a helper function to print out the user details
def PrintUserEntry(entry):
# print required fields where we know there will be information
print 'URI: %s\n' % entry.id.text
print 'Age: %s\n' % entry.age.text
print 'Gender: %s\n' % entry.gender.text
print 'Location: %s\n' % entry.location.text
# check if there is information in the other fields and if so print it
if user.first_name:
print 'First Name: %s\n' % user.first_name.text
if user.last_name:
print 'Last Name: %s\n' % user.last_name.text
if user.relationship:
print 'Relationship: %s\n' % user.relationship.text
if user.description:
print 'About me: %s\n' % user.description.text
for link in user.link:
if link.rel == 'related':
print 'Website: %s\n' % link.href
if user.company:
print 'Company: %s\n' % user.company.text
if user.occupation:
print 'Occupation: %s\n' % user.occupation.text
if user.school:
print 'School: %s\n' % user.school.text
if user.hobbies:
print 'Hobbies: %s\n' % user.hobbies.text
if user.movies:
print 'Movies: %s\n' % user.movies.text
if user.music:
print 'Music: %s\n' % user.music.text
if user.books:
print 'Books: %s\n' % user.books.text
if user.hometown:
print 'Hometown: %s\n' % user.hometown.text
Contacts
La liste des contacts d'un utilisateur donné peut être récupérée à l'aide de l'URL suivante:
http://gdata.youtube.com/feeds/api/users/username/contacts
Récupérer les contacts des utilisateurs
La méthode GetYouTubeContactFeed de l'objet YouTubeService permet de récupérer un gdata.youtube.YouTubeContactFeed, composé d'objets gdata.youtube.YouTubeContactEntry.
contact_feed = yt_service.GetYouTubeContactFeed(username='GoogleDevelopers')
for entry in contact_feed.entry:
print entry.title.text
# find the apprpriate category element to find out the contact type
for category in entry.category:
if category.scheme == 'http://gdata.youtube.com/schemas/2007/contact.cat':
print category.term
Ajouter un contact
Pour ajouter un contact au flux de contacts d'un utilisateur, utilisez la méthode AddContact de l'objet YouTubeService.
new_contact = yt_service.AddContact(contact_username='GoogleDevelopers') if isinstance(new_contact, gdata.youtube.YouTubeContactEntry) print 'New contact added'
Accepter/Refuser un contact
Pour mettre à jour un contact, utilisez la méthode UpdateContact de l'objet YouTubeService. Cette méthode permet d'accepter ou de refuser des demandes d'ajout à la liste de contacts, et de classer les contacts dans les catégories "Ami" ou "Famille". Dans l'exemple ci-dessous, nous acceptons un contact, puis définissons sa catégorie sur "Famille":
# in this case user 'gdpython' has requested to be our contact
#so the original contact status is 'pending'
updated_contact = yt_service.UpdateContact('gdpython', 'accepted', 'Family')
if isinstance(updated_contact, gdata.youtube.YouTubeContactEntry)
print 'New contact added'
Supprimer un contact
Pour supprimer un contact, utilisez la méthode DeleteContact de l'objet YouTubeService, en transmettant le nom d'utilisateur du contact que vous souhaitez supprimer.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'