La API de datos de YouTube permite que las aplicaciones cliente recuperen y actualicen contenido de YouTube en forma de feeds de API de datos de Google. Tu aplicación cliente puede utilizar los feeds de la API de datos de YouTube para obtener, buscar y actualizar videos, comentarios, respuestas, listas de reproducción, perfiles de usuario y contactos de usuario, así como consultar videos que coincidan con criterios particulares.
Además de proporcionar información general sobre las capacidades de la API de datos de YouTube, en este documento se proporcionan ejemplos para interactuar con la API mediante la biblioteca cliente de Python. Para usar la biblioteca cliente de Python, necesitarás Python 2.0+ y los módulos Árbol de elementos, 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 te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Python para interactuar con YouTube, consulta la página del protocolo de la Guía para desarrolladores.
Acerca de este documento
Público
Este documento está dirigido a programadores que deseen escribir aplicaciones cliente que pueden interactuar con YouTube mediante la biblioteca cliente de Python. Proporciona una serie de ejemplos de interacciones básicas de la API de datos.
Para obtener información de referencia de la API de datos de YouTube, consulta la guía de referencia.
En este documento, se asume que comprendes las ideas generales sobre el protocolo de las API de datos de Google y que sabes programar en Python.
Para obtener información de referencia sobre las clases y los métodos de Python, consulta los 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 las operaciones de 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 de otras API 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 video o feed deben autenticarse. Las solicitudes de solo lectura a videos públicos no requieren autenticación.
-
La sección Información sobre los feeds y las entradas de video proporciona una respuesta de la API de muestra y explica cómo extraer información sobre un solo video de una lista de videos o de un conjunto de resultados de búsqueda. Esta sección también explica cómo acceder a los metadatos sobre una entrada de video específica. Finalmente, esta sección explica el mecanismo para actualizar una entrada de video individual.
-
La sección Recuperación y búsqueda de videos 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. Esta sección también explica cómo utilizar la API para permitir a los usuarios buscar a través de la biblioteca de videos de YouTube por categorías o términos de búsqueda específicos.
-
La sección Carga de videos explica brevemente dos formas de permitir que los usuarios carguen 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.
-
La sección Actualización y eliminación de videos describe cómo utilizar 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.
-
La sección Uso de las funciones de la comunidad describe 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 un reclamo para un video existente. También puedes usar la API para recuperar listas de comentarios de videos.
-
La sección Guardar y recopilar videos explica cómo utilizar la API para acceder a los videos favoritos, las listas de reproducción, las suscripciones a los canales de YouTube y crear y actualizar videos favoritos. También se muestra cómo modificar y agregar listas de videos favoritos a las listas de reproducción y los videos favoritos.
-
La sección Habilita la interacción del usuario explica cómo utilizar 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 del usuario.
Cómo comenzar
Requisitos
Tu aplicación cliente puede utilizar los feeds de API de datos de YouTube para buscar, recuperar y actualizar videos, comentarios, respuestas, listas de reproducción, suscripciones, perfiles de usuario y más.Además de proporcionar información general sobre las capacidades de la API de datos de YouTube, en este documento se proporcionan ejemplos para interactuar con la API mediante la biblioteca cliente de Python. Para usar la biblioteca cliente de Python, necesitarás Python 2.2+ y los módulos Árbol de elementos, 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 te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca cliente de Python para interactuar con YouTube, consulta la página del protocolo de guía para desarrolladores.
Los fragmentos de código de muestra que aparecen a continuación se pueden copiar y pegar en el código y modificar para satisfacer tus necesidades.
Antes de que puedas realizar operaciones con la API de datos de YouTube, debes inicializar un objeto gdata.youtube.service.YouTubeService, como se muestra a continuación. Las declaraciones import que se enumeran a continuación realizarán automáticamente más importaciones desde los módulos gdata.media y gdata.geo. Ten en cuenta que se requerirán autenticación para todas las acciones aparte de recuperar el contenido público.
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 resultar beneficioso probar las solicitudes no autenticadas del intérprete interactivo de Python.
Nota: La biblioteca cliente de Python debe agregarse correctamente a la ruta. Asegúrate de instalarla mediante la ejecución de 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 utilizar 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 mediante la autenticación ClientLogin (para aplicaciones de escritorio) o mediante la autenticación AuthSub (para aplicaciones web).
Configura tu clave de desarrollador y tu ID de cliente
Una clave de programador identifica al programador de YouTube que envía una solicitud de API. Un ID de cliente identifica tu aplicación con 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/Google usan la autenticación del proxy de AuthSub. El operador no necesita acceso al nombre de usuario y la contraseña para el usuario de YouTube; solo se requieren tokens especiales de AuthSub.
Cuando el usuario visita tu aplicación por primera vez, aún no se ha autenticado 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 las 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 enviados al método GenerateAuthSubURL de los objetos de servicio:
- siguiente: La URL de la página a la que YouTube debe redireccionar al usuario después de que se autoriza a la aplicación para acceder 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á un token seguro.
- session: Indica que este token se puede intercambiar por un token multiuso (sesión).
La URL que se muestra se verá más o menos 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 su aplicación para acceder a su cuenta, se lo redireccionará de vuelta a la URL de next. Se le agregará un valor de token de uso único a la URL como un parámetro de consulta. La URL tiene un aspecto similar al siguiente:
http://www.example.com/video_upload.pyc?token=Abc123...
En la siguiente sección, se demostrará cómo actualizar este token. El siguiente fragmento demuestra una de las maneras de recuperar este token de la dirección URL:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Actualiza a un token de sesión
Por seguridad, este token es de uso único, por lo que ahora debe 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 uso único. Dado que session = True se especificó anteriormente, este token se puede intercambiar por un token de sesión de AuthSub mediante el método UpgradeToSessionToken, que llama al servicio AuthSubSessionToken.
Tu objeto YouTubeService ya está completamente autenticado y se puede usar para realizar todas las demás solicitudes con la API de YouTube. Los tokens de sesión de AuthSub no vencerán a menos que emitas una solicitud específicamente para revocarlos o que el usuario decida revocar el acceso visitando la página Sitios autorizados en su cuenta de YouTube.
Autenticación ClientLogin para aplicaciones instaladas
La autenticación ClientLogin se utiliza en aplicaciones instaladas que pueden almacenar o consultar al usuario su nombre de usuario y contraseña. 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 configuraron las credenciales, se puede usar el objeto YouTubeService para controlar todas las demás solicitudes. Para poder realizar cargas y cualquier tipo de solicitud de escritura (agregar comentarios, etc.) en la API de YouTube, asegúrate de pasar tu clave de programador y tu 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 API de datos de Google para obtener información más detallada sobre los mecanismos de AuthSub y ClientLogin.
Información sobre las entradas y los feeds 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.
Muestra un feed de videos
Muchos feeds de la API de YouTube constan de entradas de video. Estos feeds se pueden modelar simplemente como objetos gdata.youtube.YouTubeVideoFeed, cada uno con una cantidad de objetos gdata.youtube.YouTubeVideoEntry. Cada entrada de video corresponde exactamente a un video de YouTube e incluye información acerca del video.
La estructura básica para recuperar una lista de videos es construir una URL para un feed de video y luego procesar las entradas de a una, 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
La sección Recuperación y búsqueda de videos detalla muchas URL de feed comunes y cómo recuperar varios feeds de video.
Cómo recuperar una entrada de video específica
Solo puedes recuperar la información de una entrada de video específica si conoces su ID de video. La URL de entrada se basa en la identificación de video:
http://gdata.youtube.com/feeds/api/videos/videoID
El siguiente código recupera un gdata.youtube.YouTubeVideoEntry que corresponde a un video en 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, URL del reproductor y duración del video. 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 mediante la asignación de 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 XML media:group). 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 insertar un video con un reproductor en tu página, consulta la guía del protocolo.
Recuperar y buscar videos
Cómo recuperar feeds estándar
La API de datos de YouTube proporciona un feed estándar de los videos más populares de YouTube. Anteriormente, la API admitía otros feeds estándar, que ya no están disponibles. Para obtener más información, consulta la guía para programadores.
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ándar específicos según la configuración regional si especificas una configuración regional 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 parámetros de configuración regional, 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))
Recuperar videos subidos por un usuario específico
Cada usuario de YouTube tiene un feed de video asociado, que corresponde a los videos que ha subido, en http://gdata.youtube.com/feeds/api/users/username/uploads.
El siguiente código demuestra cómo recuperar y mostrar un feed subido por el usuario:
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 string "default" en lugar de username a fin de recuperar videos para el usuario autenticado actual.
Recuperación de 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 datos de YouTube te permite solicitar un conjunto de entradas que coincidan con los criterios especificados, como solicitar entradas de video publicadas por un autor en particular, por formato de video o por contener una palabra clave determinada. Para ello, crea un objeto gdata.service.YouTubeVideoQuery con los criterios de búsqueda específicos y pásalo al método YouTubeQuery de gdata.youtube.service.YouTubeService.
El siguiente ejemplo muestra cómo realizar una consulta de búsqueda, con resultados ordenados por cantidad de vistas, incluidos los videos restringidos (denominado "Racy" por la 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 clase gdata.service.Query y las subclases como YouTubeVideoQuery son responsables de construir las URL del feed. La 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 más comunes de YouTubeVideoQuery para configurar parámetros de búsqueda:
author- Establece el autor de la entrada. El autor es sinónimo del nombre de usuario de YouTube.
format- Especifica un formato de video. Acepta parámetros numéricos para especificar uno de dos tipos de URL de transmisión RTSP para la reproducción de videos para 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 ejemplo,
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 string especificada en todos los metadatos de video, como títulos, etiquetas y descripciones.
Nota: Para obtener más información sobre los parámetros de búsqueda, consulta la Guía de referencia de la API de datos de YouTube y la Guía de referencia de las API de datos de Google.
Buscar con categorías y palabras clave
Puede restringir los resultados de búsqueda para mostrar sólo los videos que coincidan con un grupo determinado de categorías y palabras clave. La guía de referencia describe cómo especificar las categorías predefinidas de YouTube (como Música, Personas y Blogs, etc.) y las palabras clave definidas (etiquetas).
El siguiente código muestra cómo realizar búsquedas con las palabras clave (etiquetas). Para ello, cambie los términos de búsqueda a minúsculas. Nota: debido a que algunas palabras (como "comedia") pueden ser tanto una categoría de YouTube como una palabra clave, las consultas de palabras clave y de categoría utilizan la convención de que una palabra en mayúsculas ("Comedia") denota una categoría de YouTube, mientras que una palabra en minúscula ("comedia") denota 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)
Buscar por etiquetas de programador
Las etiquetas del desarrollador son palabras clave ocultas adicionales que un desarrollador puede usar para etiquetar el contenido que suban los usuarios finales. Las etiquetas del desarrollador coinciden con la clave del desarrollador establecida en los encabezados durante la carga. Estas palabras clave no serán visibles para el público y podrán utilizarse para recuperar videos. Para buscar videos por una etiqueta específica del programador, envía una solicitud de búsqueda general de API de datos de YouTube usando tu clave de programador. Asegúrate de especificar el esquema de categorías y la etiqueta del desarrollador con la que deben coincidir los videos. Puede recuperar un feed de videos que coincidan con su etiqueta de programador (en el ejemplo, "su_etiqueta_aquí") de 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úrese de revisar los diagramas de la guía del protocolo para obtener una descripción general de alto nivel del proceso de carga. Puedes subir videos de dos maneras:
- ya sea subiendo el video directamente desde sus servidores a través del método de subida directa
- o enviando los metadatos y haciendo que el usuario suba el video directamente a YouTube a través del método de subida basado en el navegador
Carga directa
Para subir un video, primero debes construir un nuevo objeto gdata.youtube.YouTubeVideoEntry y pasarle un objeto gdata.media.Group que contenga metadatos requeridos. El siguiente ejemplo 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ático |
| Palabras clave | autos, divertido |
| Descripción | Mi descripción |
| Nombre del archivo | mipelículademovimiento.mov |
| Tipo de MIME del archivo | video/quicktime |
| ¿Video privado? | falso |
| Ubicación del video | 37,-122 (lat.,long.) |
| Etiquetas de desarrollador | mietiquetadeldesarrollador, otraetiquetadelprogramador |
El siguiente código crea un YouTubeVideoEntry en blanco para subir. El método InsertVideoEntry en el YouTubeService requiere los siguientes parámetros:
video_entry: Es el objetogdata.youtube.VideoEntryque contiene metadatos.filename_or_handle: Un objeto similar a un archivo o el nombre de archivo desde el que se leerá el video.youtube_username: una string opcional que especifica el nombre de usuario en la cuenta en la que se subirá el video. Por supuesto, tu cuenta necesitará los permisos correspondientes. La configuración predeterminada es la cuenta del usuario autenticado actualmente.content_type: Es una string 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 Búsqueda por etiquetas de desarrollador para obtener más detalles), podríamos haber usado el método AddDeveloperTags antes de permitir 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 casi de la misma manera que 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 crea un YouTubeVideoEntry que contiene solo metadatos. Esta entrada de video se publica en un vínculo especial en el servidor API de YouTube. La respuesta XML contiene un token y un url que se pueden usar para subir el archivo binario mediante 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 utiliza para crear un formulario HTML para 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 del token mostrado, como se recupera de YouTubeVideoEntry más arriba. Para que se redireccione al usuario 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 AuthSub. La única diferencia es que aquí, en lugar de un token de un solo uso, una variable status y una id se muestran 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 exitosa 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 asignado al video que se subió.
Verifica el estado de la carga
Después de subir un video, este será visible de inmediato en el feed de cargas de un usuario autenticado. Sin embargo, no será público en el sitio hasta que se haya procesado. Los videos que se hayan rechazado o que no se hayan subido correctamente también 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]
Actualización y eliminación de videos
Actualización de la información del video
Para actualizar metadatos de video, simplemente actualiza el objeto YouTubeVideoEntry y luego usa el método YouTubeService UpdateVideoEntry. 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
Agregar una calificación
Para calificar un video, usa el método AddRating del objeto YouTubeService. Ten en cuenta que no puedes clasificar tus 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 comentarios para un video
Si tienes un objeto YouTubeVideoEntry o una identificación de video simple, puedes recuperar e imprimir un feed que contenga los comentarios para el video utilizando 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()
Cómo agregar un comentario
Para agregar un comentario nuevo, usa el método AddComment del objeto YouTubeService. El método requiere un objeto YouTubeVideoEntry completo que deba comentarse, así como una string 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 fue un video asociado como respuesta a un segundo video. Se retiró la función de respuestas en video como se explica en este anuncio. Mientras las respuestas en video existentes aún estén disponibles, YouTube ya no admite la posibilidad de recuperar una lista de respuestas en video para un video, subir nuevas respuestas en video o borrar respuestas en video, aunque puedes borrar el video que se usó en una respuesta en video. En consecuencia, estas funciones tampoco se admiten en la API.
Las solicitudes a la API para las operaciones de respuesta de video ahora muestran lo siguiente:
- Una solicitud para recuperar respuestas de video para 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 en video muestra un código de respuesta HTTP 403.
Cómo marcar un video
Para agregar un reclamo sobre un video, puedes usar el método AddComplaint en el objeto YouTubeService. El término de reclamo debe ser una categoría válida. Consulte la sección Agregar un reclamo en la guía de protocolo para obtener más información.
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
Recuperar los videos favoritos de un usuario
Los usuarios de YouTube pueden elegir 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 va a recuperar.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
El feed que se muestra es un feed de video normal que contiene objetos YouTubeVideoEntry.
Nota: También puedes pasar la string default a fin de recuperar favoritos para el usuario autenticado actual. Este es el comportamiento predeterminado del método GetUserFavoritesFeed si no se proporciona un nombre de usuario.
Agregando un favorito...
Para agregar un video favorito, usa el método YouTubeService del objeto AddVideoEntryToFavorites. Los parámetros son el YouTubeVideoEntry que se agregará y, de forma opcional, el nombre de usuario al que se agregará el favorito (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'
Eliminar 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'
Listas de reproducción
Cada usuario de YouTube tiene un feed de listas de reproducción con todas las listas de reproducción que ha creado el usuario. Cada lista de reproducción tendrá un feed para todos sus videos.
Recuperación de listas de reproducción de usuarios
Para obtener una lista de todas las listas de reproducción de un usuario de forma manual, utiliza 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 string 'default' para hacer referencia al usuario autenticado actualmente.
Un objeto gdata.youtube.YouTubePlaylistFeed representa un feed de objetos gdata.youtube.YouTubePlaylistEntry. Se refieren a las listas de reproducción individuales que puede tener un usuario. Las entradas de video de una lista de reproducción 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 lista de reproducción.
Recuperación de información de una lista de reproducción
Dada una YouTubePlaylistEntry (que representa una lista de reproducción específica), puedes obtener una YouTubePlaylistVideoFeed que contenga objetos YouTubePlaylistVideoEntry. Como se explicó anteriormente, estos objetos representan videos individuales de una lista de reproducción (con títulos y descripción personalizados opcionales). Para obtener este feed, pasa el URI de tu lista de reproducción 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 lista de reproducción
Para agregar una lista de reproducción nueva, usa el método AddPlaylist del objeto YouTubeService. Este método toma los siguientes parámetros: playlist_title, playlist_description (ambas strings) y un valor booleano opcional que se puede establecer como True si la lista de reproducción se marca 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'
Actualización de una lista de reproducción
Para actualizar una lista de reproducción, usa el método UpdatePlaylist del objeto YouTubeService. El método incluye los siguientes parámetros: el ID de la lista de reproducción que se actualizará, un nuevo título, una nueva descripción, un valor booleano opcional para marcar la lista de reproducción como privada y una string opcional que indica el nombre de usuario propietario de la lista de reproducción. La string predeterminada será el usuario autenticado actual.
# 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 lista de reproducción
Puedes agregar un video a una lista de reproducción con el método AddPlaylistVideoEntryToPlaylist del objeto YouTubeService. El siguiente código agrega un video a una lista de reproducción, 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 el título y la descripción personalizados no son obligatorios y que, si no se especifican, se usará el título y la descripción reales del video.
Editar la información del video en la lista de reproducción
Usa el método UpdatePlaylistVideoEntryMetaData del objeto YouTubeService para cambiar los metadatos de una YouTubePlaylistVideoEntry. En el siguiente ejemplo, decidimos asignar un nuevo título personalizado a nuestro video y moverlo a la primera posición (posición 1) de nuestra lista de reproducción.
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 quieres revertir la descripción y el título de un video en una lista de reproducción a los metadatos originales, solo tienes que pasar NULL para el título y la descripción.
Eliminar el video de la lista de reproducción
Para quitar un video de una lista de reproducción, usa el método DeletePlaylistVideoEntry del objeto YouTubeService. El método requiere el URI de la lista de reproducción 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'
Eliminación de una lista de reproducción
Para borrar una lista de reproducción, solo debes usar el método DeletePlaylist del objeto YouTubeService y pasar el URI de la lista de reproducción 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, búsquedas y favoritos a los que se suscribió un usuario, usa el siguiente URI:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Nota: También puedes pasar la string default a fin de recuperar favoritos para el usuario autenticado actual.
Recupera suscripciones de usuarios
El siguiente código demuestra cómo recuperar e imprimir la lista de suscripciones para 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 debe recuperar. El parámetro de nombre de usuario se establece de forma predeterminada en el usuario autenticado actual.
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()
Agregar una suscripción
Para crear una suscripción nueva, inserta un nuevo YouTubeSubsciptionEntry en el feed de suscripciones del usuario autenticado. Podemos crear tres tipos de suscripciones: una suscripción al canal de un usuario (mediante AddSubscriptionToChannel), una suscripción a los favoritos de un usuario (mediante AddSubscriptionToFavorites o una suscripción a una palabra clave específica (mediante 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í estamos suscribiéndonos a una consulta de videos etiquetados como "python".
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Borra una suscripción
Para borrar una suscripción de 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'
Cómo habilitar la interacción del usuario
Perfiles de usuario
Recuperar el perfil de un usuario
Para obtener el perfil de YouTube de un usuario manualmente, debes usar el siguiente URI:
http://gdata.youtube.com/feeds/api/users/username
Puedes recuperar un objeto 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 a partir de la siguiente URL:
http://gdata.youtube.com/feeds/api/users/username/contacts
Cómo recuperar los contactos del usuario
Se puede usar el método GetYouTubeContactFeed del objeto YouTubeService 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 a un feed de contacto de los usuarios, 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'
Aceptar o rechazar un contacto
Para actualizar un contacto, usa el método UpdateContact del objeto YouTubeService. Este método puede utilizarse para aceptar o rechazar solicitudes de contactos y también para categorizarlos como "Amigos" o "Familia". En el siguiente ejemplo, aceptamos un contacto y, luego, establecemos su categoría en "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 deseas borrar.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'