L'API YouTube Data permet aux applications clientes de récupérer et de mettre à jour du contenu YouTube sous la forme de flux d'API Google Data. Votre application cliente peut utiliser les flux de l'API YouTube Data pour récupérer, rechercher et mettre à jour des vidéos, des commentaires, des réponses, des playlists, des profils utilisateur et des contacts, ainsi que pour rechercher des vidéos répondant à certains critères.
En plus de fournir des informations générales 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+ et des modules d'arborescence d'éléments, httplib et urllib. Pour en savoir plus, reportez-vous à 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 guide du développeur.
À propos de ce document
Audience
Ce document est destiné aux programmeurs qui souhaitent créer des applications clientes capables d'interagir avec YouTube à l'aide de la bibliothèque cliente Python. Il fournit une série d'exemples d'interactions de l'API Data de base.
Pour en savoir plus sur l'API YouTube Data, consultez le guide de référence.
Dans ce document, nous partons du principe que vous comprenez les principes généraux du protocole Google Data APIs et que vous savez programmer dans Python.
Pour plus d'informations sur les classes et les méthodes Python, consultez la documentation sur pyDocs (pour la classe de service et pour les classes de données) incluses dans le code source.
Structure du document
Ce document inclut les sections suivantes :
-
La section Authentification décrit les deux méthodes d'authentification différentes 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. Dans ce document, les explications de fonctions d'API spécifiques indiquent clairement si la fonction nécessite une authentification de l'utilisateur. En général, toutes les requêtes qui modifient les données vidéo ou de flux doivent être authentifiées. Les requêtes en lecture seule envoyées aux 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 à l'API et explique comment extraire des informations sur une vidéo à 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 de 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 (par exemple, un flux standard de vidéos les plus populaires sur YouTube). Les autres listes de vidéos incluent les vidéos mises en ligne par un utilisateur spécifique et les listes de vidéos en rapport avec une vidéo donnée. Cette section explique également comment utiliser l'API pour permettre aux utilisateurs de rechercher des termes ou des catégories de recherche spécifiques dans la bibliothèque de vidéos YouTube.
-
La section Mise en ligne de vidéos explique brièvement comment vous pouvez 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 pour répondre à d'autres vidéos.
-
La section Modifier et supprimer des vidéos explique comment utiliser l'API pour mettre à jour des informations sur une vidéo YouTube. Il 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 de l'API qui permettent à vos utilisateurs d'interagir avec des vidéos YouTube. Ces fonctions décrivent les demandes de publication de notes, de commentaires ou de réclamations pour une vidéo existante. Vous pouvez également utiliser l'API pour récupérer des listes de commentaires vidéo.
-
La section Enregistrement et collecte de vidéos explique comment utiliser l'API pour accéder à vos vidéos préférées, vos playlists de vidéos et vos abonnements à des chaînes YouTube, les créer et les modifier. Il montre également comment modifier les playlists et les favoris vidéo en ajoutant et en supprimant des vidéos.
-
La section Activation de 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 des contacts utilisateur.
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 générales 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+ et des modules d'arborescence d'éléments, httplib et urllib. Pour en savoir plus, reportez-vous à 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 le Guide du protocole du développeur.
Vous pouvez copier les extraits d'exemple ci-dessous et les coller dans votre code, puis les modifier selon 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. Notez que toutes les actions en dehors de 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 fonctionnent sur une instance de gdata.youtube.service.YouTubeService. Il peut être utile de tester les requêtes non authentifiées 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
Vous pouvez utiliser la bibliothèque cliente Python pour travailler avec des flux publics ou privés. Les flux publics sont en lecture seule et ne nécessitent aucune authentification. Pour les flux privés, vous devez vous authentifier auprès des serveurs YouTube.
L'authentification peut être effectuée via l'authentification ClientLogin (pour les applications de bureau) ou 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 effectuez 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 est utilisé pour spécifier votre ID client. La clé de 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 visite votre application pour la première fois, il n'a pas encore été authentifié auprès des services Google. Dans ce cas, vous devez lui fournir un lien dirigeant l'utilisateur vers Google pour autoriser l'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 avoir autorisé votre application à accéder à son compte.
- scope : indique que l'application accédera uniquement aux flux d'API YouTube.
- secure : indique que le jeton renvoyé ne sera pas un jeton sécurisé.
- session : indique que ce jeton peut être échangé contre un jeton (session) à usages multiples.
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 cliquer sur 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 est ajoutée à l'URL en tant que paramètre de requête. L'URL ressemble à ceci :
http://www.example.com/video_upload.pyc?token=Abc123...
La section suivante explique comment mettre à niveau ce jeton. L'extrait ci-dessous illustre l'une des manières 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 maintenant 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 représente un jeton AuthSub à usage unique. Comme 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 maintenant entièrement authentifié et peut être utilisé pour effectuer d'autres requêtes avec l'API YouTube. Les jetons de session AuthSub n'expirent pas, sauf si vous émettez une demande de révocation spécifique, ou si l'utilisateur décide de révoquer l'accès sur 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 ou interroger votre utilisateur pour connaître son nom d'utilisateur et son mot de passe. 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 traiter toutes les requêtes suivantes. Pour effectuer des importations et des requêtes d'écriture (ajouter des commentaires, etc.) à l'API YouTube, assurez-vous de transmettre également votre clé de développeur et votre ID client à l'objet yt_service lors de 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 corrects lorsque les attributs developer_key et client_id sont définis.
Remarque:Veuillez consulter la documentation sur l'authentification des API Google Data pour en savoir plus sur les mécanismes AuthSub et ClientLogin.
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 vidéos mises en ligne, les abonnements et les favoris. L'URL de chaque flux est documentée dans le Guide de référence.
Afficher un flux de vidéos
Dans l'API YouTube, de nombreux flux sont constitués d'entrées vidéo. Ces flux peuvent simplement être modélisés sous la forme d'objets gdata.youtube.YouTubeVideoFeed, chacun contenant un certain nombre d'objets gdata.youtube.YouTubeVideoEntry. Chaque entrée correspond à une seule vidéo sur YouTube et contient des informations la concernant.
Pour récupérer une liste de vidéos, vous devez structurer une URL pointant 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 vidéo spécifique
Vous pouvez récupérer uniquement 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 extraites d'un objet gdata.youtube.YouTubeVideoEntry, telles que des vignettes, des URL de lecteur et la durée de la vidéo. Le code suivant montre comment accéder à certaines de ces informations. La bibliothèque cliente Python extrait la plupart de ces fonctionnalités en mappant des éléments XML en classes. La plupart des informations importantes concernant 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 des métadonnées de 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 à un lecteur dans 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 YouTube les plus populaires. L'API était auparavant compatible avec d'autres flux standards, qui sont désormais obsolètes. Pour en savoir plus, consultez le Guide du développeur.
L'URL du flux des vidéos les plus populaires sur YouTube est au format suivant:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Remarque : Vous pouvez également récupérer des flux standards régionaux en spécifiant un identifiant régional 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 identifiants régionaux supposés, veuillez consulter 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 des vidéos mises en ligne par un utilisateur spécifique
Chaque utilisateur YouTube est associé à un flux vidéo correspondant 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 un flux envoyé par 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 "par défaut" à 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 les vidéos similaires, transmettez l'ID vidéo de l'objet gdata.youtube.YouTubeVideoEntry à la méthode GetYouTubeRelatedVideoFeed de l'objet gdata.youtube.service.YouTubeService. Cela récupère 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 aux critères spécifiés, par exemple pour demander des entrées vidéo publiées par un auteur donné, par format vidéo ou contenant un mot clé particulier. Pour ce faire, vous devez créer un objet gdata.service.YouTubeVideoQuery avec vos critères de recherche spécifiques et le transmettre à la méthode YouTubeQuery de gdata.youtube.service.YouTubeService.
L'exemple ci-dessous montre comment effectuer une requête de recherche. Les résultats sont triés en fonction du nombre de vues, y compris des vidéos dont l'accès est limité (appelé "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 et les sous-classes gdata.service.Query, comme YouTubeVideoQuery, sont responsables de la construction des URL de flux. L'élément VideoQuery ci-dessus construit une URL équivalente à celle-ci:
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 les paramètres numériques permettant de spécifier l'un des deux types d'URL de streaming RTSP pour la lecture de vidéos mobiles ou une URL HTTP vers le lecteur Flash intégrable.
racy- Indique si le contenu soumis à des restrictions doit être inclus dans les résultats. Accepte uniquement deux paramètres : "include" ou "exclude".
max_results- Définit le nombre maximal d'entrées à renvoyer simultanément.
start_index- Définit l'index de base 1 du premier résultat à récupérer (pour la pagination).
orderby- Définit l'ordre dans lequel répertorier les entrées, par exemple
relevance,viewCount,publishedourating. time- Définit la période d'affichage des résultats de flux standards sur
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 de la vidéo, telles que 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 de données Google.
Recherche à l'aide des catégories et des mots clés
Vous pouvez limiter les résultats de recherche pour n'afficher que les vidéos qui correspondent à un ensemble donné de catégories et de mots clés. Le guide de référence vous explique comment spécifier des catégories YouTube prédéfinies (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 (tags) en remplaçant les termes de recherche par minuscules. Remarque: Certains mots (comme "comédie") peuvent être à la fois une catégorie YouTube et un mot clé. Par conséquent, les requêtes de catégorie et de mot-clé utilisent la convention selon laquelle un mot commençant par une majuscule ("Comédie") dénote 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 de développeur sont des mots clés supplémentaires cachés qu'un développeur peut utiliser pour ajouter des tags à du contenu importé via son application par les utilisateurs finaux. Les tags de développeur sont mis en correspondance avec la clé de développeur définie dans les en-têtes lors de l'importation. Ces mots clés ne seront pas visibles par le public et pourront être utilisés pour récupérer des vidéos. Pour rechercher des vidéos en fonction d'un tag de développeur spécifique, envoyez une requête générale d'API YouTube Data à l'aide de votre clé de développeur. Veillez à spécifier le schéma de catégorie et le tag de développeur auxquels les vidéos doivent correspondre. Vous pouvez récupérer un flux de vidéos correspondant à votre tag de développeur ("votre_tag_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
Consultez les schémas du guide du protocole pour avoir une vue d'ensemble du processus de mise en ligne. Vous pouvez mettre en ligne des vidéos de deux manières:
- soit en mettant en ligne la vidéo directement depuis vos serveurs via la méthode d'importation directe.
- ou envoyer d'abord les métadonnées, puis demander à l'utilisateur de mettre en ligne la vidéo directement sur YouTube via la méthode de mise en ligne basée sur un navigateur
Importation directe
Pour mettre en ligne une vidéo, vous devez d'abord construire un nouvel objet gdata.youtube.YouTubeVideoEntry, en lui transmettant un objet gdata.media.Group contenant les métadonnées requises. L'exemple suivant montre comment mettre en ligne la vidéo Quicktime "mytestmovie.mov" sur YouTube avec les propriétés suivantes:
| Propriété | Valeur |
|---|---|
| Title | Mon film test |
| Catégorie | Automatiques |
| Mots clés | voitures, drôle |
| Description | Ma description |
| Nom de fichier | mytestmovie.mov |
| Type de fichier MIME | video/quicktime |
| Vidéo privée ? | false |
| Lieu de tournage de la vidéo | 37,-122 (lat,long) |
| Tags de développeur | mydevelopertag, autredéveloppeurtag |
Le code ci-dessous crée un YouTubeVideoEntry vide à 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 est lueyoutube_username: chaîne facultative spécifiant le nom d'utilisateur sur lequel cette vidéo doit être mise en ligne. Bien entendu, votre compte doit disposer des autorisations appropriées. Le compte de l'utilisateur actuellement authentifié est utilisé par défaut.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 vous souhaitez ajouter des tags facultatifs à notre vidéo à l'aide de tags (pour en savoir plus, consultez la section Rechercher par tags de développeur), nous aurions pu utiliser la méthode AddDeveloperTags avant d'appeler InsertVideoEntry :
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Remarque: Pour importer des vidéos en tant que vidéos privées, un attribut privé doit être transmis à 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 via navigateur
La mise en ligne par navigateur est presque identique à l'importation directe, sauf que vous n'importez pas le fichier binaire de la même requête que celle que vous utilisez pour envoyer les métadonnées de la vidéo. Il vous suffit de créer un YouTubeVideoEntry contenant uniquement des métadonnées. Cette vidéo est ensuite publiée sur un lien spécial du serveur d'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 imprime un lien et un jeton permettant de créer un formulaire HTML à afficher dans le navigateur de l'utilisateur. Vous trouverez ci-dessous un exemple de formulaire simple avec youtube_token représentant le contenu de l'élément de jeton renvoyé, tel qu'il est récupéré à partir de YouTubeVideoEntry ci-dessus. Pour que l'utilisateur soit redirigé vers votre site Web après avoir envoyé le formulaire, veillez à ajouter un paramètre next à post_url (comme illustré ci-dessous), qui fonctionnera de la même manière que le paramètre next d'un lien AuthSub. La seule différence est qu'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 indiquant que l'importation a réussi se présente 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 la transaction d'importation. Le paramètre id renvoie l'ID vidéo YouTube attribué à la vidéo mise en ligne.
Vérifier l'état de la mise en ligne
Une fois mise en ligne, la vidéo apparaît immédiatement dans le flux de mise en ligne d'un utilisateur authentifié. Cependant, elle ne sera pas publique sur le site tant qu'elle n'aura pas été traitée. De plus, les vidéos qui ont été refusées ou qui n'ont pas pu être mises en ligne n'apparaissent que dans le flux de vidéos mises en ligne par l'utilisateur authentifié. Le code suivant vérifie l'état d'un YouTubeVideoEntry pour voir s'il n'est pas encore en ligne ou s'il a été rejeté.
upload_status = yt_service.CheckUploadStatus(new_entry) if upload_status is not None: video_upload_state = upload_status[[]0] detailed_message = upload_status[[]1]
Mettre à jour et supprimer des vidéos
Mise à jour des informations sur la vidéo...
Pour mettre à jour les métadonnées vidéo, il vous suffit de mettre à jour l'objet YouTubeVideoEntry, puis d'utiliser la méthode UpdateVideoEntry des objets YouTubeService. Cette méthode utilise comme paramètre un YouTubeVideoEntry contenant des métadonnées mises à jour.
# 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 et nécessite simplement d'appeler la fonction DeleteVideoEntry de l'objet YouTubeService.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Utiliser les fonctionnalités destinées à la communauté
Ajouter une note
Pour évaluer une vidéo, utilisez la méthode AddRating de l'objet YouTubeService. Vous ne pouvez pas évaluer vos propres vidéos, et la note doit être comprise 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 des commentaires sur une vidéo
Avec un objet YouTubeVideoEntry ou 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 objet 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 nouveau commentaire, utilisez la méthode AddComment de l'objet YouTubeService. La méthode nécessite un objet YouTubeVideoEntry complet qui doit être commenté, ainsi qu'une chaîne qui représente 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
Un commentaire vidéo YouTube est une vidéo qui a été associée en tant que réponse à une deuxième vidéo. La fonctionnalité de commentaires vidéo a été supprimée, comme expliqué dans cette annonce. Même si les commentaires vidéo existants sont toujours disponibles, YouTube ne permet plus de récupérer la liste des commentaires vidéo d'une vidéo, de mettre en ligne de nouveaux commentaires vidéo ni de supprimer des commentaires vidéo. Vous pouvez toutefois supprimer la vidéo utilisée dans un commentaire vidéo. Par conséquent, ces fonctions ne sont plus prises en charge dans l'API.
Les requêtes API pour les opérations de réponse vidéo renvoient désormais les éléments suivants:
- Une demande de récupération des commentaires vidéo sur une vidéo renvoie une liste vide.
- Une requête d'ajout d'un commentaire vidéo renvoie un code de réponse HTTP 403.
- Une requête de suppression d'un commentaire vidéo renvoie un code de réponse HTTP 403.
Signalement d'une vidéo
Pour déposer 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 Ajout d'une réclamation dans le 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 de YouTube peuvent choisir de marquer leurs vidéos préférées. 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 utilise une chaîne facultative comme 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.
Ajout d'un favori
Pour ajouter une vidéo préférée, utilisez la méthode AddVideoEntryToFavorites de l'objet YouTubeService. Les paramètres sont les YouTubeVideoEntry qui doivent être ajoutés, et éventuellement le nom d'utilisateur auquel les favoris doivent être ajoutés (l'utilisateur actuellement authentifié est la valeur par défaut).
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'
Suppression d'un favori
Pour supprimer un favori, il vous suffit d'utiliser 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 dispose d'un flux contenant toutes les playlists qu'il a créées. Chaque playlist est associée à un flux contenant toutes les vidéos qu'elle contient.
Récupérer des playlists d'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
La bibliothèque cliente Python vous permet d'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. Elles font référence aux playlists individuelles d'un utilisateur. Les entrées vidéo d'une playlist particulière sont représentées en tant qu'objets gdata.youtube.YouTubePlaylistVideoEntry. Ces objets sont très semblables aux objets gdata.youtube.YouTubeVideoEntry standards, à quelques exceptions près. Vous pouvez appliquer des titres et des descriptions personnalisés aux vidéos, et un champ "Position" indique leur emplacement dans la playlist.
Récupérer des informations sur la playlist
Une fonction YouTubePlaylistEntry (correspondant à une playlist spécifique) vous permet d'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 une description 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 utilise les paramètres suivants: playlist_title, playlist_description (les deux chaînes) et une valeur booléenne facultative pouvant ê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'
Modifier une playlist
Pour modifier une playlist, utilisez la méthode UpdatePlaylist de l'objet YouTubeService. La méthode utilise les paramètres suivants: l'ID de la playlist à modifier, 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 renvoie par défaut à 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)
Ajouter la vidéo à la 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'aucun titre ni aucune description personnalisés ne sont requis. Le cas échéant, le titre et la description de la vidéo sont utilisés.
Modifier les informations de la vidéo sur la playlist
Utilisez la méthode UpdatePlaylistVideoEntryMetaData de l'objet YouTubeService pour modifier les métadonnées d'une YouTubePlaylistVideoEntry. Dans l'exemple ci-dessous, nous décidons d'attribuer un nouveau titre personnalisé à notre vidéo et de la placer en première position (position 1) dans 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 de la description et du titre d'une playlist, il vous suffit d'utiliser 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. Cette 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'
Supprimer une playlist
Pour supprimer une playlist, il vous suffit d'utiliser 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 des abonnements utilisateur
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 les abonnements, utilisez la méthode GetYouTubeSubscriptionFeed de l'objet YouTubeService, en transmettant l'URI d'un flux d'abonnement ou le nom d'utilisateur dont le flux d'abonnements doit être récupéré. Par défaut, le paramètre de nom d'utilisateur correspond à 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 une nouvelle YouTubeSubsciptionEntry dans le flux des abonnements de l'utilisateur authentifié. Nous pouvons 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 (avec AddSubscriptionToQuery). Le code suivant permet d'abonner 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. Ici, nous nous sommes abonnés à une requête pour des vidéos avec le tag "python".
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Supprimer un abonnement
Pour supprimer un abonnement 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'
Interaction des utilisateurs
Profils d'utilisateurs
Récupérer le profil d'un utilisateur
Pour récupérer manuellement le profil YouTube d'un utilisateur, vous devez utiliser l'URI suivant:
http://gdata.youtube.com/feeds/api/users/username
Vous pouvez récupérer un gdata.youtube.YouTubeUserEntry avec 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 à partir de l'URL suivante:
http://gdata.youtube.com/feeds/api/users/username/contacts
Récupérer des contacts utilisateur
La méthode GetYouTubeContactFeed de l'objet YouTubeService peut être utilisée pour 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 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 peut être utilisée pour accepter/refuser les demandes de contact et pour classer les contacts dans la catégorie "Amis" 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'