La API de YouTube Data permite que las aplicaciones cliente recuperen y actualicen contenido de YouTube en forma de feeds de la API de Google Data. Tu aplicación cliente puede usar los feeds de la API de datos de YouTube para recuperar, buscar y actualizar videos, comentarios, respuestas, playlists, perfiles de usuario y contactos de usuario, así como consultar videos que coincidan con criterios específicos.
Además de proporcionar información sobre las funciones de la API de YouTube Data, este documento incluye ejemplos para interactuar con la API con la biblioteca cliente de Python. Para usar la biblioteca cliente de Python, necesitarás Python 2.0 o versiones posteriores, y los módulos Element Tree, httplib y urllib. Consulta Módulos de dependencia para obtener más detalles.
Si necesitas ayuda para configurar la biblioteca cliente de Python, consulta la Guía de introducción. Si quieres obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Python para interactuar con YouTube, consulta la página de protocolos de la Guía para desarrolladores.
Acerca de este documento
Público
Este documento está dirigido a programadores que deseen escribir aplicaciones cliente que puedan interactuar con YouTube mediante la biblioteca cliente de Python. Proporciona una serie de ejemplos de interacciones básicas con la API de datos.
Para obtener información de referencia de la API de YouTube Data, consulta la guía de referencia.
En este documento, se da por sentado que comprendes las ideas generales detrás del protocolo de las APIs de Google Data y que sabes programar en Python.
Para obtener información de referencia sobre las clases y los métodos de Python, consulta pyDocs (para la clase de servicio y las clases de datos) que se incluyen con el código fuente.
Estructura del documento
Este documento incluye las siguientes secciones:
-
En la sección Autenticación, se describen los dos métodos de autenticación diferentes disponibles para asociar operaciones de la API con una cuenta de usuario específica. En esta sección, también se describen las diferencias entre la autenticación de la API de datos de YouTube y otras APIs de datos de Google. A lo largo de este documento, las explicaciones de funciones específicas de la API indicarán claramente si la función requiere autenticación del usuario. En general, todas las solicitudes que modifican datos de videos o feeds deben autenticarse. Las solicitudes de solo lectura a videos públicos no requieren autenticación.
-
En la sección Información sobre los feeds y las entradas de video, se proporciona una respuesta de API de muestra y se explica cómo extraer información sobre un solo video de una lista de videos o un conjunto de resultados de la búsqueda. En esta sección, también se explica cómo acceder a los metadatos de una entrada de video específica. Por último, en esta sección, se explica el mecanismo para actualizar una entrada de video individual.
-
En la sección Cómo recuperar y buscar videos, se explica cómo recuperar listas específicas de videos, como un feed estándar de los videos más populares de YouTube. Otras listas de videos incluyen videos subidos por un usuario específico y listas de videos relacionados con un video en particular. En esta sección, también se explica cómo usar la API para permitir que los usuarios busquen en la biblioteca de videos de YouTube por categorías o términos de búsqueda específicos.
-
En la sección Cómo subir videos, se explican brevemente dos maneras en las que puedes permitir que los usuarios suban videos a YouTube desde tu aplicación. Además, en esta sección, también se explica cómo subir videos como respuestas a otros videos.
-
En la sección Cómo actualizar y borrar videos, se describe cómo usar la API para actualizar la información de un video de YouTube. También se describe cómo se puede quitar un video con la API.
-
En la sección Cómo usar las funciones de comunidad, se describen las funciones de la API que permiten a los usuarios interactuar con los videos de YouTube. Estas funciones explican las solicitudes para publicar una calificación, un comentario o una queja en un video existente. También puedes usar la API para recuperar listas de comentarios de videos.
-
En la sección Cómo guardar y recopilar videos, se explica cómo usar la API para acceder a videos favoritos, crear y actualizar playlists de video y suscripciones a canales de YouTube. También se muestra cómo agregar y quitar videos para modificar las playlists y los favoritos.
-
En la sección Cómo habilitar la interacción del usuario, se explica cómo usar la API para recuperar y actualizar los perfiles de usuario. En esta sección, también se explica cómo recuperar, agregar, actualizar y borrar los contactos de los usuarios.
Cómo comenzar
Requisitos
Tu aplicación cliente puede usar los feeds de la API de datos de YouTube para buscar, recuperar y actualizar videos, comentarios, respuestas, playlists, suscripciones, perfiles de usuario y mucho más.Además de proporcionar información sobre las funciones de la API de YouTube Data, este documento incluye ejemplos para interactuar con la API con la biblioteca cliente de Python. Para usar la biblioteca cliente de Python, necesitarás Python 2.2 o versiones posteriores, y los módulos Element Tree, httplib y urllib. Consulta Módulos de dependencia para obtener más detalles.
Consulta la Guía de introducción para obtener más información sobre la configuración de tu entorno. Si quieres obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Python para interactuar con YouTube, consulta la página de protocolos de la Guía para desarrolladores.
Los fragmentos de código de muestra que se muestran a continuación se pueden copiar o pegar en tu código y modificar para satisfacer tus necesidades.
Antes de que puedas realizar cualquier operación con la API de datos de YouTube, debes inicializar un objeto gdata.youtube.service.YouTubeService, como se muestra a continuación. Las sentencias import que se indican a continuación realizarán automáticamente más importaciones desde los módulos gdata.media y gdata.geo. Ten en cuenta que todas las acciones, excepto la recuperación de contenido público, requerirán autenticación.
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 mayoría de los ejemplos de métodos de esta guía operan en una instancia de gdata.youtube.service.YouTubeService. Puede ser beneficioso probar las solicitudes no autenticadas desde el intérprete de Python interactivo.
Nota: La biblioteca cliente de Python se debe agregar correctamente en tu ruta. Asegúrate de instalarlo ejecutando la secuencia de comandos setup.py proporcionada. Consulta la Guía de introducción para obtener más información.
Autenticación
La biblioteca cliente de Python se puede usar para trabajar con feeds públicos o privados. Los feeds públicos son de solo lectura y no requieren autenticación. Los feeds privados requieren que te autentiques en los servidores de YouTube.
La autenticación se puede realizar a través de la autenticación de ClientLogin (para apps de escritorio) o de la autenticación de AuthSub (para aplicaciones web).
Cómo configurar tu clave de desarrollador y tu ID de cliente
Una clave de desarrollador identifica al desarrollador de YouTube que envía una solicitud a la API. Un ID de cliente identifica tu aplicación para fines de registro y depuración.
Cuando realizas una solicitud a la API con la biblioteca cliente de Python, se usa el encabezado de solicitud X-GData-Key para especificar tu clave de desarrollador y el encabezado X-GData-Client para especificar tu ID de cliente. La clave de desarrollador y el ID de cliente se pueden configurar en el objeto YouTubeService, independientemente del esquema de autenticación que se use:
yt_service.developer_key = 'ABCxyz123...' yt_service.client_id = 'My-Client_id'
Deberás registrarte para obtener una clave de desarrollador de YouTube.
Autenticación de AuthSub para aplicaciones web
Las aplicaciones web que necesitan autenticar a sus usuarios en cuentas de YouTube o Google usan la autenticación de proxy de AuthSub. El operador no necesita acceso al nombre de usuario ni a la contraseña del usuario de YouTube; solo se requieren tokens de AuthSub especiales.
Cuando el usuario visita tu aplicación por primera vez, aún no se autentica con los servicios de Google. En este caso, debes proporcionarle un vínculo que dirija al usuario a Google para que autorice la solicitud de acceso de tus aplicaciones a su cuenta de YouTube. La biblioteca cliente de Python proporciona una función para generar esta URL. El siguiente código configura un vínculo a la página 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
Observa los parámetros que se envían al método GenerateAuthSubURL de los objetos de servicio:
- next: Es la URL de la página a la que YouTube debe redireccionar al usuario después de que autorice a tu aplicación para que acceda a su cuenta.
- scope: Indica que la aplicación solo accederá a los feeds de la API de YouTube.
- secure: Indica que el token que se muestra no será seguro.
- session: Indica que este token se puede intercambiar por un token de uso múltiple (sesión).
La URL que se muestra se verá de la siguiente manera:
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
Luego, el usuario puede seguir el vínculo para acceder a su cuenta de YouTube. Una vez que el usuario autorice a tu aplicación para que acceda a su cuenta, se lo redireccionará a la URL de next. La URL tendrá un valor de token de un solo uso agregado como parámetro de consulta. La URL debería ser similar a la siguiente:
http://www.example.com/video_upload.pyc?token=Abc123...
En la siguiente sección, se mostrará cómo actualizar este token. En el siguiente fragmento, se muestra una de las formas de recuperar este token de la URL:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Actualiza a un token de sesión
Por motivos de seguridad, este token es de un solo uso, por lo que ahora debes intercambiarlo por un token de sesión. Este proceso se describe en la documentación de AuthSub. En el siguiente fragmento de código, se muestra cómo actualizar el token.
yt_service = gdata.youtube.service.YouTubeService() yt_service.SetAuthSubToken(authsub_token) yt_service.UpgradeToSessionToken()
Este valor de token representa un token de AuthSub de un solo uso. Dado que se especificó session = True anteriormente, este token se puede intercambiar por un token de sesión de AuthSub con el método UpgradeToSessionToken, que llama al servicio AuthSubSessionToken.
Tu objeto YouTubeService ahora está completamente autenticado y se puede usar para realizar todas las solicitudes adicionales con la API de YouTube. Los tokens de sesión de AuthSub no vencerán, a menos que envíes una solicitud específica para revocarlos o el usuario decida revocar el acceso visitando la página Sitios autorizados en su cuenta de YouTube.
Autenticación de ClientLogin para aplicaciones instaladas
La autenticación de ClientLogin se usa en aplicaciones instaladas que pueden almacenar o consultar el nombre de usuario y la contraseña del usuario. Para usar esta forma de autenticación, invoca el método ProgrammaticLogin de YouTubeService heredado de la clase gdata.service.GDataService y especifica el ID y la contraseña del usuario en cuyo nombre tu cliente envía la solicitud de autenticación.
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()
Una vez que se hayan establecido las credenciales, se puede usar el objeto YouTubeService para controlar todas las solicitudes adicionales. Para poder realizar cargas y cualquier tipo de solicitud de "escritura" (agregar comentarios, etc.) a la API de YouTube, asegúrate de pasar tu clave de desarrollador y el ID de cliente al objeto yt_service cuando realices la autenticación:
# 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()
El objeto YouTubeService establece automáticamente los encabezados X-GData-Key y X-GData-Client correctos cuando se configuran los atributos developer_key y client_id.
Nota: Consulta la documentación de autenticación de las APIs de datos de Google para obtener información más detallada sobre los mecanismos de AuthSub y ClientLogin.
Información sobre los feeds y las entradas de video
La API de datos de YouTube proporciona varios feeds de video que representan listas de videos, como feeds estándar, cargas, suscripciones y favoritos. La URL de cada feed se documenta en la guía de referencia.
Cómo mostrar un feed de videos
Muchos feeds de la API de YouTube consisten en entradas de video. Estos feeds se pueden modelar de forma más sencilla como objetos gdata.youtube.YouTubeVideoFeed, cada uno de los cuales contiene una cantidad de objetos gdata.youtube.YouTubeVideoEntry. Cada entrada de video corresponde exactamente a un video de YouTube y contiene información sobre él.
La estructura básica para recuperar una lista de videos es crear una URL a un feed de video y, luego, procesar las entradas de a una por vez, de manera similar al siguiente código:
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
En la sección Cómo recuperar y buscar videos, se detallan muchas URLs de feeds comunes y cómo recuperar varios feeds de video.
Cómo recuperar una entrada de video específica
Puedes recuperar solo la información de una entrada de video específica si conoces su ID. La URL de entrada se basa en el ID de video:
http://gdata.youtube.com/feeds/api/videos/videoID
El siguiente código recupera un gdata.youtube.YouTubeVideoEntry que corresponde a un video de YouTube:
entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')
Contenido de la entrada de video
Hay muchos metadatos que se pueden recuperar de un objeto gdata.youtube.YouTubeVideoEntry, como miniaturas, URLs de reproductores y duración de videos. En el siguiente código, se muestra cómo obtener parte de esta información. La biblioteca cliente de Python abstrae la mayor parte de esta funcionalidad asignando elementos XML a clases. La mayor parte de la información importante sobre una entrada YouTubeVideoEntry está disponible en los elementos secundarios del atributo media (que contiene un objeto gdata.media.Group) dentro de la entrada (que representa el elemento media:group de XML). A continuación, se muestra un ejemplo de cómo recuperar metadatos de video:
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
Nota: Para obtener más información sobre cómo generar la información necesaria para incorporar un video con un reproductor en tu página, consulta la guía del protocolo.
Cómo recuperar y buscar videos
Cómo recuperar feeds estándares
La API de YouTube Data proporciona un feed estándar de los videos más populares de YouTube. Anteriormente, la API admitía otros feeds estándares, que dejaron de estar disponibles. Si deseas obtener más información, consulta la Guía para desarrolladores.
La URL del feed de los videos más populares de YouTube tiene el siguiente formato:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Nota: También puedes recuperar feeds estándares específicos de la configuración regional si especificas un localeID en el formato http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Por ejemplo, los videos más populares en Japón serían: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Para obtener una lista completa de los supuestos localeIDs, consulta la guía de referencia.
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))
Cómo recuperar videos subidos por un usuario específico
Cada usuario de YouTube tiene un feed de video asociado que corresponde a los videos que subió en http://gdata.youtube.com/feeds/api/users/username/uploads.
En el siguiente código, se muestra cómo recuperar y mostrar un feed de cargas de usuarios:
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))
Nota: También puedes usar la cadena "default" en lugar de username para recuperar videos del usuario autenticado actualmente.
Cómo recuperar videos relacionados
Para recuperar videos relacionados, pasa el ID de video del objeto gdata.youtube.YouTubeVideoEntry al método GetYouTubeRelatedVideoFeed del objeto gdata.youtube.service.YouTubeService. Esto recupera un objeto YouTubeVideoFeed que contiene entradas relacionadas.
related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')
Cómo buscar videos
La API de YouTube Data te permite solicitar un conjunto de entradas que coincidan con criterios especificados, como solicitar entradas de video publicadas por un autor en particular, por formato de video o que contengan una palabra clave específica. Para ello, crea un objeto gdata.service.YouTubeVideoQuery con tus criterios de búsqueda particulares y pásalo al método YouTubeQuery de gdata.youtube.service.YouTubeService.
En el siguiente ejemplo, se muestra cómo realizar una búsqueda con resultados ordenados por cantidad de vistas, incluidos los videos restringidos (que la API denomina "Racy"):
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 clase gdata.service.Query y las subclases, como YouTubeVideoQuery, son responsables de la construcción de las URLs de los feeds. El VideoQuery que se muestra arriba construye una URL equivalente a la siguiente:
http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount
Estas son algunas de las propiedades YouTubeVideoQuery más comunes para establecer parámetros de búsqueda:
author- Establece el autor de la entrada. El autor es sinónimo de nombre de usuario de YouTube.
format- Especifica un formato de video. Acepta parámetros numéricos para especificar uno de los dos tipos de URLs de transmisión RTSP para la reproducción de video en dispositivos móviles o una URL HTTP al reproductor Flash incorporado.
racy- Indica si se debe incluir contenido restringido en los resultados. Solo acepta dos parámetros: "include" o "exclude".
max_results- Establece la cantidad máxima de entradas que se mostrarán a la vez.
start_index- Establece el índice basado en 1 del primer resultado que se recuperará (para la paginación).
orderby- Establece el orden en el que se enumeran las entradas, como por
relevance,viewCount,publishedorating. time- Establece un período para limitar los resultados del feed estándar a
today,this_week,this_monthoall_time. vq- Establece un término de búsqueda. Busca la cadena especificada en todos los metadatos de los videos, como los títulos, las etiquetas y las descripciones.
Nota: Para obtener más información sobre los parámetros de consulta, consulta la Guía de referencia de la API de datos de YouTube y la Guía de referencia de las APIs de datos de Google.
Cómo buscar con categorías y palabras clave
Puedes restringir los resultados de la búsqueda para que solo muestren videos que coincidan con un conjunto determinado de categorías y palabras clave. En la guía de referencia, se describe cómo especificar las categorías predefinidas de YouTube (como Música, Personas y blogs, etc.) y las palabras clave (etiquetas) definidas por el usuario.
En el siguiente código, se muestra cómo realizar búsquedas con palabras clave (etiquetas) cambiando los términos de búsqueda a minúsculas. Nota: Dado que algunas palabras (como “comedia”) pueden ser una categoría de YouTube y una palabra clave, las búsquedas de categorías y palabras clave usan la convención de que una palabra en mayúsculas ("Comedia") indica una categoría de YouTube, mientras que una palabra en minúsculas ("comedia") indica una palabra clave.
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)
Búsqueda por etiquetas de desarrollador
Las etiquetas de desarrollador son palabras clave adicionales y ocultas que un desarrollador puede usar para etiquetar el contenido que suben los usuarios finales a través de su aplicación. Las etiquetas de desarrollador coinciden con la clave de desarrollador establecida en los encabezados durante la carga. Estas palabras clave no serán visibles para el público y se pueden usar para recuperar videos. Para buscar videos por una etiqueta de desarrollador específica, envía una solicitud de búsqueda general de la API de YouTube Data con tu clave de desarrollador. Asegúrate de especificar el esquema de categorías y la etiqueta del desarrollador con los que deben coincidir los videos. Puedes recuperar un feed de videos que coincidan con tu etiqueta de desarrollador ("your_tag_here" en nuestro ejemplo) desde la siguiente URL:
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))
Sube videos
Asegúrate de revisar los diagramas de la guía de protocolos para obtener una descripción general del proceso de carga. Puedes subir videos de dos maneras:
- Subiendo el video directamente desde tus servidores con el método de carga directa
- o bien, primero envía los metadatos y, luego, pídele al usuario que suba el video directamente a YouTube con el método de carga basado en el navegador.
Carga directa
Para subir un video, primero debes crear un objeto gdata.youtube.YouTubeVideoEntry nuevo y pasarle un objeto gdata.media.Group que contenga los metadatos necesarios. En el siguiente ejemplo, se muestra cómo subir el video Quicktime “mytestmovie.mov” a YouTube con las siguientes propiedades:
| Propiedad | Valor |
|---|---|
| Título | Mi película de prueba |
| Categoría | Automóviles |
| Palabras clave | autos, gracioso |
| Descripción | Mi descripción |
| Nombre del archivo | mytestmovie.mov |
| Tipo de MIME de archivo | video/quicktime |
| ¿El video es privado? | falso |
| Ubicación del video | 37,-122 (lat,long) |
| Etiquetas para desarrolladores | mydevelopertag, anotherdevelopertag |
El siguiente código crea un YouTubeVideoEntry en blanco para subir. El método InsertVideoEntry en YouTubeService requiere los siguientes parámetros:
video_entry: Es el objetogdata.youtube.VideoEntryque contiene metadatos.filename_or_handle: Es un objeto similar a un archivo o el nombre de archivo desde el que se leerá el video.youtube_username: Es una cadena opcional que especifica el nombre de usuario a la cuenta a la que se subirá este video. Por supuesto, tu cuenta necesitará los permisos adecuados. De forma predeterminada, se usa la cuenta del usuario autenticado actualmente.content_type: Es una cadena opcional que especifica el tipo de MIME del video que se subirá.
yt_service hace referencia a un objeto YouTubeService completamente autenticado.
# 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 quisiéramos etiquetar nuestro video con etiquetas de desarrollador opcionales (consulta Cómo realizar búsquedas por etiquetas de desarrollador para obtener más información), podríamos haber usado el método AddDeveloperTags antes de realizar la llamada a InsertVideoEntry:
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Nota: Para subir videos como privados, se debe pasar un atributo privado a 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)
Carga basada en el navegador
La carga basada en el navegador se realiza de manera casi idéntica a la carga directa, excepto que no subes el archivo binario en la misma solicitud que usas para enviar los metadatos del video. En su lugar, simplemente creas un YouTubeVideoEntry que solo contenga metadatos. Luego, esta entrada de video se publica en un vínculo especial en el servidor de la API de YouTube. La respuesta XML contiene un token y un url que se pueden usar para subir el archivo binario con un formulario HTML estándar.
# 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]
El código anterior imprime un vínculo y un token que se usan para crear un formulario HTML que se mostrará en el navegador del usuario. A continuación, se muestra un formulario de ejemplo simple con youtube_token que representa el contenido del elemento de token que se muestra, como se muestra en YouTubeVideoEntry anteriormente. Para que el usuario se redireccione a tu sitio web después de enviar el formulario, asegúrate de agregar un parámetro next a post_url (como se muestra a continuación), que funcionará de la misma manera que el parámetro next de un vínculo de AuthSub. La única diferencia es que, en lugar de un token de un solo uso, se devuelven una variable status y una id como parámetros de 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)
Una respuesta para una carga correcta se vería de la siguiente manera:
http://example.com/post_video_upload.pyc?status=200&id=ABC123
El parámetro status muestra el estado de la transacción HTTP de la transacción de carga. El parámetro id muestra el ID de video de YouTube que se asignó al video subido.
Verifica el estado de carga
Después de subir un video, este se podrá ver de inmediato en el feed de cargas de un usuario autenticado. Sin embargo, no se mostrará públicamente en el sitio hasta que se haya procesado. Los videos que se rechazaron o no se pudieron subir correctamente también solo aparecerán en el feed de cargas del usuario autenticado. El siguiente código verifica el estado de un YouTubeVideoEntry para ver si aún no está publicado o si se rechazó.
upload_status = yt_service.CheckUploadStatus(new_entry) if upload_status is not None: video_upload_state = upload_status[[]0] detailed_message = upload_status[[]1]
Actualiza y borra videos
Cómo actualizar la información de los videos
Para actualizar los metadatos de video, simplemente actualiza el objeto YouTubeVideoEntry y, luego, usa el método UpdateVideoEntry de los objetos YouTubeService. Este método toma como parámetro un YouTubeVideoEntry que contiene metadatos actualizados.
# 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)
Eliminación de un video
Borrar un video es muy sencillo y solo implica una llamada a DeleteVideoEntry del objeto YouTubeService.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Cómo usar las funciones de la comunidad
Cómo agregar una calificación
Para calificar un video, usa el método AddRating del objeto YouTubeService. Ten en cuenta que no puedes calificar tus propios videos y que las calificaciones deben estar entre 1 y 5 (inclusive):
video_id_to_rate = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate) response = yt_service.AddRating(3, video_entry)
Comentarios
Cómo recuperar los comentarios de un video
Si tienes un objeto YouTubeVideoEntry o un ID de video simple, puedes recuperar e imprimir un feed que contenga los comentarios del video con el método GetYouTubeVideoCommentFeed del objeto YouTubeService. El feed resultante es un gdata.youtube.YouTubeCommentFeed, que consta de objetos gdata.youtube.YouTubeCommentEntry. El feed se puede analizar como cualquier otro:
video_id = 'ABC123...' comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id) for comment_entry in comment_feed.entry: print comment_entry.ToString()
Agregando un comentario
Para agregar un comentario nuevo, simplemente usa el método AddComment del objeto YouTubeService. El método requiere un objeto YouTubeVideoEntry completo sobre el que se hará el comentario, así como una cadena que represente el comentario:
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)
Respuestas en video
Una respuesta en video de YouTube era un video que se asociaba, como respuesta, con un segundo video. La función de respuestas de video dejó de estar disponible, como se explica en este anuncio. Si bien las respuestas en video existentes siguen disponibles, YouTube ya no admite la capacidad de recuperar una lista de respuestas en video de un video, subir respuestas en video nuevas ni borrarlas, aunque puedes borrar el video que se usó en una respuesta en video. Por lo tanto, estas funciones tampoco son compatibles con la API.
Las solicitudes a la API para operaciones de respuesta de video ahora muestran lo siguiente:
- Una solicitud para recuperar las respuestas de un video muestra una lista vacía.
- Una solicitud para agregar una respuesta de video muestra un código de respuesta HTTP 403.
- Una solicitud para borrar una respuesta de video muestra un código de respuesta HTTP 403.
Cómo marcar un video
Para agregar un reclamo sobre un video, se usa el método AddComplaint en el objeto YouTubeService. El término del reclamo debe ser una categoría válida. Para obtener más información, consulta la sección Cómo agregar un reclamo en la guía del protocolo.
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)
Cómo guardar y recopilar videos
Videos favoritos
Cómo recuperar los videos favoritos de un usuario
Los usuarios de YouTube pueden marcar los videos que miran como favoritos. La ubicación general del feed favorito de un usuario es la siguiente URL.
http://gdata.youtube.com/feeds/api/users/username/favorites
Para recuperar los videos favoritos de un usuario, usa el método GetUserFavoritesFeed del objeto YouTubeService. El método toma una cadena opcional como parámetro que representa el nombre de usuario de YouTube del usuario cuyo feed favorito se recuperará.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
El feed que se muestra es un feed de video normal que contiene objetos YouTubeVideoEntry.
Nota: Como alternativa, puedes pasar la cadena default para recuperar los favoritos del usuario autenticado actualmente. Este es el comportamiento predeterminado del método GetUserFavoritesFeed si no se proporciona un nombre de usuario.
Cómo agregar un favorito
Para agregar un video favorito, usa el método AddVideoEntryToFavorites del objeto YouTubeService. Los parámetros son el YouTubeVideoEntry que se agregará y, de manera opcional, el nombre de usuario a cuyos favoritos se agregará (el valor predeterminado es el usuario autenticado actualmente).
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'
Cómo borrar un favorito
Para borrar un favorito, simplemente usa el método DeleteVideoEntryFromFavorites del objeto YouTubeService.
video_id = 'Ncakifd_16k' response = yt_service.DeleteVideoEntryFromFavorites(video_id) if response is True: print 'Video deleted from favorites'
Playlists
Cada usuario de YouTube tiene un feed de playlists que contiene todas las playlists que creó. Cada playlist tiene un feed para todos los videos que contiene.
Cómo recuperar playlists de usuarios
Para recuperar una lista de todas las playlists de un usuario de forma manual, usa la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/playlists
Con la biblioteca cliente de Python, puedes usar el método GetYouTubePlaylistFeed del objeto 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')
Nota: En lugar de pasar un nombre de usuario específico (como "gdpython" en el ejemplo anterior), también puedes pasar la cadena 'default' para hacer referencia al usuario autenticado actualmente.
Un gdata.youtube.YouTubePlaylistFeed representa un feed de objetos gdata.youtube.YouTubePlaylistEntry. Se refiere a las playlists individuales que puede tener un usuario. Las entradas de video de una playlist en particular se representan como objetos gdata.youtube.YouTubePlaylistVideoEntry. Estos objetos son muy similares a los objetos gdata.youtube.YouTubeVideoEntry normales, con algunas excepciones. Se pueden aplicar títulos y descripciones personalizados a los videos, y un campo de posición indica dónde aparece el video en la playlist.
Recuperación de información de una lista de reproducción
Dado un YouTubePlaylistEntry (que representa una playlist específica), puedes obtener un YouTubePlaylistVideoFeed que contenga objetos YouTubePlaylistVideoEntry. Como se explicó anteriormente, estos objetos representan videos individuales en una playlist (con títulos y descripciones personalizados opcionales). Para obtener este feed, pasa el URI de tu playlist al método GetYouTubePlaylistVideoFeed del objeto 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
Cómo agregar una playlist
Para agregar una playlist nueva, simplemente usa el método AddPlaylist del objeto YouTubeService. Este método toma los siguientes parámetros: playlist_title, playlist_description (ambas cadenas) y un valor booleano opcional que se puede establecer en True si se marca la playlist como privada.
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'
Cómo actualizar una playlist
Para actualizar una playlist, usa el método UpdatePlaylist del objeto YouTubeService. El método toma los siguientes parámetros: el ID de la playlist que se actualizará, un título nuevo, una descripción nueva, un valor booleano opcional para marcar la playlist como privada y una cadena opcional que indica el nombre de usuario propietario de la playlist. La cadena se establecerá de forma predeterminada en el usuario autenticado actualmente.
# 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)
Agregar video a playlist
Para agregar un video a una playlist, usa el método AddPlaylistVideoEntryToPlaylist del objeto YouTubeService. El siguiente código agrega un video a una playlist, con un título y una descripción personalizados.
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'
Nota: Ten en cuenta que no es necesario que incluyas un título y una descripción personalizados. Si no los especificas, se usarán el título y la descripción reales del video.
Cómo editar la información de un video en una playlist
Usa el método UpdatePlaylistVideoEntryMetaData del objeto YouTubeService para cambiar los metadatos de un YouTubePlaylistVideoEntry. En el siguiente ejemplo, decidimos darle a nuestro video un nuevo título personalizado y moverlo a la primera posición (posición 1) de nuestra 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)
Nota: Si deseas revertir la descripción y el título de un video de una playlist a los metadatos originales, simplemente pasa NULL para el título y la descripción.
Eliminar el video de la playlist
Para quitar un video de una playlist, usa el método DeletePlaylistVideoEntry del objeto YouTubeService. El método requiere el URI de la playlist que contiene la entrada que se borrará, así como el ID de la entrada:
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'
Eliminar una lista de reproducción
Para borrar una playlist, simplemente usa el método DeletePlaylist del objeto YouTubeService y pasa el URI de la playlist que se borrará:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' response = yt_service.DeletePlaylist(playlist_uri) if response is True: print 'Playlist successfully deleted'
Suscripciones
Para recuperar una lista de los canales, las búsquedas y los favoritos a los que se suscribió un usuario determinado, usa el siguiente URI:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Nota: Como alternativa, puedes pasar la cadena default para recuperar los favoritos del usuario autenticado actualmente.
Cómo recuperar las suscripciones de los usuarios
En el siguiente código, se muestra cómo recuperar e imprimir la lista de suscripciones de un usuario determinado. Las suscripciones se representan como un gdata.youtube.YouTubeSubscriptionFeed que consta de objetos gdata.youtube.YouTubeSubscriptionEntry. Para recuperar suscripciones, usa el método GetYouTubeSubscriptionFeed del objeto YouTubeService y pasa el URI de un feed de suscripción o el nombre de usuario cuyo feed de suscripción se recuperará. El parámetro de nombre de usuario se establece de forma predeterminada en el usuario autenticado actualmente.
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()
Cómo agregar una suscripción
Para crear una suscripción nueva, inserta un YouTubeSubsciptionEntry nuevo en el feed de suscripciones del usuario autenticado. Podemos crear tres tipos de suscripciones: una suscripción al canal de un usuario (con AddSubscriptionToChannel), una suscripción a los favoritos de un usuario (con AddSubscriptionToFavorites) o una suscripción a una palabra clave específica (con AddSubscriptionToQuery). El siguiente código suscribe al usuario autenticado al canal "GoogleDevelopers".
new_subscription = yt_service.AddSubscriptionToChannel(
username_to_subscribe_to='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
También puedes suscribirte a los favoritos del usuario "GoogleDevelopers":
new_subscription = yt_service.AddSubscriptionToFavorites(
username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Por último, también puedes suscribirte a términos de búsqueda específicos. Aquí, nos suscribimos a una búsqueda de videos etiquetados como “python”.
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Cómo borrar una suscripción
Para borrar la suscripción de un usuario, usa el método DeleteSubscription del objeto 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'
Habilita la interacción del usuario
Perfiles de usuario
Cómo recuperar el perfil de un usuario
Para recuperar el perfil de YouTube de un usuario de forma manual, usa el siguiente URI:
http://gdata.youtube.com/feeds/api/users/username
Puedes recuperar un gdata.youtube.YouTubeUserEntry con el método GetYouTubeUserEntry del objeto 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
Contactos
La lista de contactos de un usuario determinado se puede recuperar desde la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/contacts
Cómo recuperar los contactos del usuario
El método GetYouTubeContactFeed del objeto YouTubeService se puede usar para recuperar un gdata.youtube.YouTubeContactFeed, que consta de objetos 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
Agrega un contacto
Para agregar un contacto nuevo al feed de contactos de un usuario, usa el método AddContact del objeto YouTubeService.
new_contact = yt_service.AddContact(contact_username='GoogleDevelopers') if isinstance(new_contact, gdata.youtube.YouTubeContactEntry) print 'New contact added'
Cómo aceptar o rechazar un contacto
Para actualizar un contacto, usa el método UpdateContact del objeto YouTubeService. Este método se puede usar para aceptar o rechazar solicitudes de contacto y también para categorizar los contactos como "Amigo" o "Familia". En el siguiente ejemplo, aceptamos un contacto y, luego, configuramos su categoría como "Familia":
# 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'
Borra un contacto
Para borrar un contacto, usa el método DeleteContact del objeto YouTubeService y pasa el nombre de usuario del contacto que quieres borrar.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'