A API Data do YouTube permite que os aplicativos clientes recuperem e atualizem o conteúdo do YouTube no formato de feeds da API Data do Google. O aplicativo cliente pode usar os feeds da API Data do YouTube para buscar, pesquisar e atualizar vídeos, comentários, respostas, playlists, perfis e contatos de usuários, além de consultar vídeos que correspondem a critérios específicos.
Além de fornecer alguns antecedentes sobre os recursos da API Data do YouTube, este documento apresenta exemplos de como interagir com a API usando a biblioteca de cliente Python. Para usar a biblioteca de cliente Python, você vai precisar do Python 2.0 ou mais recente e dos módulos Element Tree, httplib e urllib. Consulte Módulos de dependência para mais detalhes.
Se precisar de ajuda para configurar a biblioteca de cliente Python, consulte o Guia para iniciantes. Se você quiser saber mais sobre o protocolo usado pela biblioteca de cliente Python para interagir com o YouTube, consulte a página de protocolo do guia para desenvolvedores.
Sobre este documento
Público-alvo
Este documento é destinado a programadores que querem criar aplicativos clientes que possam interagir com o YouTube usando a biblioteca de cliente Python. Ele oferece uma série de exemplos de interações básicas com a API de dados.
Para informações de referência da API Data do YouTube, consulte o guia de referência.
Este documento pressupõe que você entenda as ideias gerais por trás do protocolo das APIs de dados do Google e saiba programar em Python.
Para informações de referência sobre as classes e os métodos do Python, consulte os pyDocs (para a classe de serviço e as classes de dados) incluídos no código-fonte.
Estrutura do documento
Este documento contém as seguintes seções:
-
A seção Autenticação descreve os dois métodos de autenticação disponíveis para associar operações de API a uma conta de usuário específica. Essa seção também descreve as diferenças entre a autenticação para a API de dados do YouTube e para outras APIs de dados do Google. Ao longo deste documento, as explicações de funções específicas da API indicam claramente se a função exige a autenticação do usuário. Em geral, todas as solicitações que modificam dados de vídeo ou feed precisam ser autenticadas. As solicitações de acesso somente leitura a vídeos públicos não exigem autenticação.
-
A seção Como entender os feeds e as entradas de vídeo mostra um exemplo de resposta da API e explica como extrair informações sobre um único vídeo de uma lista de vídeos ou de um conjunto de resultados de pesquisa. Esta seção também explica como acessar metadados sobre uma entrada de vídeo específica. Por fim, esta seção explica o mecanismo para atualizar uma entrada de vídeo individual.
-
A seção Como buscar e pesquisar vídeos explica como buscar listas específicas de vídeos, como um feed padrão dos vídeos mais populares do YouTube. Outras listas de vídeos incluem conteúdo enviado por um usuário específico e listas de vídeos relacionados a um conteúdo específico. Esta seção também explica como usar a API para permitir que os usuários pesquisem na biblioteca de vídeos do YouTube por termos ou categorias de pesquisa específicos.
-
A seção Enviar vídeos explica brevemente duas maneiras de permitir que os usuários enviem vídeos para o YouTube pelo seu aplicativo. Além disso, esta seção também explica como fazer upload de vídeos como respostas a outros vídeos.
-
A seção Atualização e exclusão de vídeos descreve como usar a API para atualizar informações sobre um vídeo do YouTube. Ela também descreve como um vídeo pode ser removido usando a API.
-
A seção Como usar os recursos da comunidade descreve as funções da API que permitem que os usuários interajam com os vídeos do YouTube. Essas funções explicam solicitações para postar uma avaliação, um comentário ou uma denúncia em um vídeo. Também é possível usar a API para recuperar listas de comentários de vídeo.
-
A seção Salvar e coletar vídeos explica como usar a API para acessar, criar e atualizar vídeos favoritos, playlists de vídeo e inscrições em canais do YouTube. Também mostra como modificar playlists de vídeos e favoritos adicionando e removendo vídeos.
-
A seção Ativar a interação do usuário explica como usar a API para recuperar e atualizar perfis de usuários. Essa seção também explica como recuperar, adicionar, atualizar e excluir contatos dos usuários.
Primeiros passos
Requisitos
O aplicativo cliente pode usar os feeds da API Data do YouTube para pesquisar, recuperar e atualizar vídeos, comentários, respostas, playlists, inscrições, perfis de usuários e muito mais.Além de fornecer alguns antecedentes sobre os recursos da API Data do YouTube, este documento apresenta exemplos de interação com a API usando a biblioteca de cliente Python. Para usar a biblioteca de cliente Python, você vai precisar do Python 2.2 ou mais recente e dos módulos Element Tree, httplib e urllib. Consulte Módulos de dependência para mais detalhes.
Consulte o Guia de início para mais informações sobre como configurar seu ambiente. Se você quiser saber mais sobre o protocolo usado pela biblioteca de cliente Python para interagir com o YouTube, consulte a página de protocolo do guia para desenvolvedores.
Os snippets de código de exemplo abaixo podem ser copiados/colados no seu código e modificados para atender às suas necessidades.
Antes de realizar qualquer operação com a API Data do YouTube, é necessário inicializar um objeto
gdata.youtube.service.YouTubeService, conforme mostrado abaixo. As instruções import listadas abaixo vão realizar automaticamente outras importações dos módulos gdata.media e gdata.geo. Todas as ações, exceto a recuperação de conteúdo público, vão exigir autenticação.
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
A maioria dos exemplos de método neste guia opera em uma instância de
gdata.youtube.service.YouTubeService. Pode ser útil testar as solicitações não autenticadas do interpretador Python interativo.
Observação: a biblioteca de cliente do Python precisa ser adicionada corretamente no caminho. Instale-o executando o script setup.py fornecido. Consulte o guia de início para mais informações.
Autenticação
A biblioteca de cliente Python pode ser usada para trabalhar com feeds públicos ou privados. Os feeds públicos são somente leitura e não exigem autenticação. Os feeds particulares exigem que você faça a autenticação nos servidores do YouTube.
A autenticação pode ser feita por ClientLogin (para apps para computador) ou AuthSub (para aplicativos da Web).
Como definir a chave de desenvolvedor e o ID do cliente
Uma chave de desenvolvedor identifica o desenvolvedor do YouTube que está enviando uma solicitação à API. Um ID de cliente identifica o seu aplicativo para fins de login e depuração.
Ao fazer uma solicitação de API usando a biblioteca de cliente do Python, o cabeçalho de solicitação X-GData-Key é usado para especificar a chave de desenvolvedor, e o cabeçalho X-GData-Client é usado para especificar o ID do cliente. A chave do desenvolvedor e o ID do cliente podem ser definidos no objeto YouTubeService, independente do esquema de autenticação que está sendo usado:
yt_service.developer_key = 'ABCxyz123...' yt_service.client_id = 'My-Client_id'
É necessário fazer a inscrição para receber uma chave de desenvolvedor do YouTube.
Autenticação AuthSub para aplicativos da Web
A autenticação de proxy AuthSub é usada por aplicativos da Web que precisam autenticar os usuários nas contas do YouTube/Google. O operador não precisa ter acesso ao nome de usuário e à senha do usuário do YouTube. Apenas tokens especiais do AuthSub são necessários.
Quando o usuário acessa seu aplicativo pela primeira vez, ele ainda não foi autenticado com os serviços do Google. Nesse caso, você precisa fornecer um link que direcione o usuário ao Google para autorizar a solicitação de acesso dos seus apps à conta do YouTube. A biblioteca de cliente do Python fornece uma função para gerar esse URL. O código abaixo configura um link para a 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
Observe os parâmetros enviados para o método GenerateAuthSubURL dos objetos de serviço:
- next: o URL da página para onde o YouTube vai redirecionar o usuário depois que ele autorizar seu app a acessar a conta.
- escopo: indica que o aplicativo só vai acessar feeds da API YouTube.
- secure: indica que o token retornado não será um token seguro.
- sessão: indica que esse token pode ser trocado por um token de uso múltiplo (sessão).
O URL retornado será parecido com este:
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
O usuário pode clicar no link para fazer login na conta do YouTube. Depois que o usuário autorizar o aplicativo a acessar a conta, ele será redirecionado de volta para o URL next. O URL terá um valor de token de uso único anexado como um parâmetro de consulta. O URL será semelhante a este:
http://www.example.com/video_upload.pyc?token=Abc123...
A próxima seção vai mostrar como fazer upgrade desse token. O snippet abaixo demonstra uma das maneiras de recuperar esse token do URL:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters[[]'token' ]
Fazer upgrade para um token de sessão
Por motivos de segurança, esse token é de uso único. Portanto, você precisa trocar esse token de uso único por um token de sessão. Esse processo é descrito na documentação do AuthSub. O snippet de código abaixo mostra como fazer upgrade do token.
yt_service = gdata.youtube.service.YouTubeService() yt_service.SetAuthSubToken(authsub_token) yt_service.UpgradeToSessionToken()
Esse valor de token representa um token AuthSub de um único uso. Como session = True foi especificado acima, esse token pode ser trocado por um token de sessão do AuthSub usando o método UpgradeToSessionToken, que chama o serviço AuthSubSessionToken.
Agora, seu objeto YouTubeService está totalmente autenticado e pode ser usado para realizar todas as solicitações com a API do YouTube. Os tokens de sessão do AuthSub não expiram, a menos que você emita uma solicitação específica para revogar ou que o usuário decida revogar o acesso acessando a página Sites autorizados na conta do YouTube.
Autenticação do ClientLogin para aplicativos instalados
A autenticação do ClientLogin é usada em aplicativos instalados que podem armazenar ou consultar o nome de usuário e a senha do usuário. Para usar esse tipo de autenticação, invoque o método ProgrammaticLogin de YouTubeService herdado da
classe gdata.service.GDataService, especificando o ID e a senha do usuário em nome de quem o cliente está enviando a solicitação para autenticação.
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()
Depois que as credenciais forem definidas, o objeto YouTubeService poderá ser usado para processar todas as solicitações. Para fazer uploads e qualquer tipo de solicitação de gravação (adicionar comentários etc.) na API do YouTube, transmita também a chave de desenvolvedor e o ID do cliente para o objeto yt_service ao realizar a autenticação:
# 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()
O objeto YouTubeService define automaticamente os cabeçalhos X-GData-Key e X-GData-Client corretos quando os atributos developer_key e client_id são definidos.
Observação:consulte a documentação de autenticação das APIs Data do Google para mais detalhes sobre os mecanismos AuthSub e ClientLogin.
Noções básicas dos feeds e entradas de vídeo
A API YouTube Data oferece vários feeds de vídeo que representam listas de vídeos, como feeds padrão, envios, inscrições e favoritos. O URL de cada feed está documentado no guia de referência.
Como mostrar um feed de vídeos
Muitos feeds na API do YouTube consistem em entradas de vídeo. Esses feeds podem ser modelados de forma mais simples como objetos gdata.youtube.YouTubeVideoFeed, cada um contendo vários objetos gdata.youtube.YouTubeVideoEntry. Cada entrada de vídeo corresponde a exatamente um vídeo no YouTube e contém informações sobre ele.
A estrutura básica para recuperar uma lista de vídeos é criar um URL para um feed de vídeo e processar as entradas uma por vez, semelhante ao código abaixo:
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
A seção Como recuperar e pesquisar vídeos detalha muitos URLs de feeds comuns e como recuperar vários feeds de vídeo.
Como recuperar uma entrada de vídeo específica
Você pode extrair apenas as informações de uma entrada de vídeo específica se souber o ID do vídeo. O URL de entrada é baseado no ID do vídeo:
http://gdata.youtube.com/feeds/api/videos/videoID
O código abaixo recupera um gdata.youtube.YouTubeVideoEntry correspondente a um vídeo no YouTube:
entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')
Conteúdo da entrada de vídeo
Há muitos metadados que podem ser recuperados de um objeto gdata.youtube.YouTubeVideoEntry, como miniaturas, URLs de players e duração do vídeo. O código a seguir demonstra como acessar algumas dessas informações. A biblioteca de cliente do Python abstrai a maior parte dessa funcionalidade mapeando elementos XML em classes. A maioria das informações importantes sobre uma entrada YouTubeVideoEntry está disponível nos filhos do atributo media (que contém um objeto gdata.media.Group) na entrada (que representa o elemento media:group XML). Confira abaixo um exemplo de como recuperar metadados de vídeo:
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
Observação:para mais informações sobre como gerar as informações necessárias para incorporar um vídeo com um player na sua página, consulte o guia de protocolo.
Como recuperar e pesquisar por vídeos
Como recuperar feeds padrão
A API Data do YouTube oferece um feed padrão dos vídeos mais populares do YouTube. A API já ofereceu suporte a outros feeds padrão, que foram descontinuados. Consulte o Guia para desenvolvedores para mais informações.
O URL do feed dos vídeos mais populares do YouTube tem o seguinte formato:
http://gdata.youtube.com/feeds/api/standardfeeds/most_popular
Observação: também é possível recuperar feeds padrão específicos da localidade especificando um ID de localidade no formato http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Por exemplo, os vídeos mais populares no Japão seriam: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Para uma lista completa de possíveis localeIDs, consulte o guia de referência .
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))
Como recuperar vídeos enviados por um usuário específico
Cada usuário do YouTube tem um feed de vídeo associado aos
vídeos enviados por ele em http://gdata.youtube.com/feeds/api/users/username/uploads.
O código abaixo demonstra como buscar e mostrar um feed de envios do usuário:
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))
Observação:também é possível usar a string "default" no lugar de username para recuperar vídeos do usuário autenticado.
Como recuperar vídeos relacionados
Para recuperar vídeos relacionados, transmita o ID do vídeo do objeto gdata.youtube.YouTubeVideoEntry para o método GetYouTubeRelatedVideoFeed do objeto gdata.youtube.service.YouTubeService. Isso recupera um objeto YouTubeVideoFeed que contém entradas relacionadas.
related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')
Pesquisar vídeos
A API Data do YouTube permite solicitar um conjunto de entradas que correspondem
a critérios especificados, como solicitar entradas de vídeo publicadas por um
autor específico, por formato de vídeo ou que contenham uma palavra-chave específica. Para fazer isso, crie um objeto gdata.service.YouTubeVideoQuery com seus critérios de pesquisa específicos e transmita-o para o
método YouTubeQuery do gdata.youtube.service.YouTubeService.
O exemplo abaixo mostra como realizar uma consulta de pesquisa, com resultados ordenados por contagem de visualizações, incluindo vídeos restritos (chamados de "Racy" pela 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)
A classe gdata.service.Query e subclasses como YouTubeVideoQuery são responsáveis por criar URLs de feed. O VideoQuery mostrado acima cria um URL equivalente ao seguinte:
http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount
Confira algumas das propriedades mais comuns da YouTubeVideoQuery para definir parâmetros de pesquisa:
author- Define o autor da entrada. Autor é sinônimo de nome de usuário do YouTube.
format- Especifica um formato de vídeo. Aceita parâmetros numéricos para especificar um dos dois tipos de URLs de streaming RTSP para reprodução de vídeo em dispositivos móveis ou um URL HTTP para o player Flash incorporável.
racy- Indica se o conteúdo restrito precisa ser incluído nos resultados. Aceita apenas dois parâmetros: "include" ou "exclude".
max_results- Define o número máximo de entradas a serem retornadas de uma só vez.
start_index- Define o índice com base em 1 do primeiro resultado a ser recuperado (para paginação).
orderby- Define a ordem em que as entradas são listadas, como por
relevance,viewCount,publishedourating. time- Define um período para limitar os resultados do feed padrão a:
today,this_week,this_monthouall_time. vq- Define um termo de consulta de pesquisa. Procura a string especificada em todos os metadados do vídeo, como títulos, tags e descrições.
Observação:para mais informações sobre parâmetros de consulta, consulte o Guia de referência da API Data do YouTube e o Guia de referência das APIs Data do Google.
Pesquisar com categorias e palavras-chave
Você pode restringir os resultados da pesquisa para mostrar apenas vídeos que correspondem a um determinado conjunto de categorias e palavras-chave. O guia de referência descreve como especificar as categorias predefinidas do YouTube (como Música, Pessoas e Blogs etc.) e as palavras-chave definidas pelo usuário (tags).
O código abaixo demonstra como pesquisar usando palavras-chave (tags) mudando os termos de pesquisa para letras minúsculas. Observação: como algumas palavras (como "comédia") podem ser uma categoria do YouTube e uma palavra-chave, as consultas de categoria e de palavra-chave usam a convenção de que uma palavra em maiúsculas ("Comédia") indica uma categoria do YouTube, enquanto uma palavra em letras minúsculas ("comédia") indica uma palavra-chave.
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)
Pesquisar por tags de desenvolvedor
As tags do desenvolvedor são outras palavras-chave ocultas que um desenvolvedor pode usar para marcar o conteúdo enviado pelos usuários finais pelo app. As tags de desenvolvedor são associadas à chave de desenvolvedor definida nos cabeçalhos durante o upload. Essas palavras-chave não vão ficar visíveis para o público e podem ser usadas para recuperar vídeos. Para pesquisar vídeos por uma tag de desenvolvedor específica, envie uma solicitação de pesquisa geral da API Data do YouTube usando sua chave de desenvolvedor. Especifique o esquema de categoria e a tag do desenvolvedor que os vídeos precisam corresponder. É possível recuperar um feed de vídeos que correspondem à sua tag de desenvolvedor ("your_tag_here" no nosso exemplo) no URL abaixo:
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))
Como enviar vídeos
Consulte os diagramas no guia do protocolo para ter uma visão geral do processo de upload. É possível fazer upload de vídeos de duas maneiras:
- fazendo upload do vídeo diretamente dos seus servidores usando o método de upload direto
- ou enviando primeiro os metadados e depois permitindo que o usuário envie o vídeo diretamente para o YouTube usando o método de envio baseado em navegador
Upload direto
Para fazer upload de um vídeo, primeiro é necessário criar um novo objeto gdata.youtube.YouTubeVideoEntry e transmitir a ele um objeto gdata.media.Group com os metadados necessários. O exemplo a seguir mostra o upload do vídeo Quicktime "mytestmovie.mov" para o YouTube com as seguintes propriedades:
| Propriedade | Value |
|---|---|
| Title | My Test Movie |
| Categorias | Carros |
| Keywords | carros, engraçado |
| Descrição | Minha descrição |
| Nome do arquivo | mytestmovie.mov |
| Tipo MIME do arquivo | video/quicktime |
| Vídeo privado? | falso |
| Local do vídeo | 37,-122 (lat,long) |
| Tags para desenvolvedores | mydevelopertag, anotherdevelopertag |
O código abaixo cria um YouTubeVideoEntry em branco para ser enviado. O método InsertVideoEntry no YouTubeService requer os seguintes parâmetros:
video_entry: o objetogdata.youtube.VideoEntryque contém metadados.filename_or_handle: um objeto semelhante a um arquivo ou o nome de arquivo de onde o vídeo será lido.youtube_username: uma string opcional que especifica o nome de usuário da conta para a qual o vídeo será enviado. Sua conta precisa das permissões adequadas. O padrão é a conta do usuário autenticado.content_type: uma string opcional que especifica o tipo MIME do vídeo a ser enviado.
yt_service se refira a um objeto YouTubeService totalmente 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)
Se quiséssemos marcar nosso vídeo com tags opcionais para desenvolvedores (consulte Pesquisar por tags para desenvolvedores para mais detalhes), poderíamos usar o método AddDeveloperTags antes de realizar a chamada para InsertVideoEntry:
developer_tags = [[]'some_tag_01', 'another_tag'] video_entry.AddDeveloperTags(developer_tags)
Observação: para enviar vídeos como privados, um atributo privado precisa ser transmitido para o 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)
Envio com base no navegador
O upload baseado em navegador é quase idêntico ao upload direto, exceto que você não envia o arquivo binário na mesma solicitação que usa para enviar os metadados do vídeo. Em vez disso, basta criar um YouTubeVideoEntry que contenha apenas metadados. Essa entrada de vídeo é publicada em um link especial no servidor da API do YouTube. A resposta em XML contém um token e um url, que podem ser usados para fazer upload do arquivo binário usando um formulário HTML padrão.
# 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]
O código acima imprime um link e um token que é usado para criar um formulário HTML a ser exibido no navegador do usuário. Um exemplo simples de formulário é mostrado abaixo com youtube_token representando o conteúdo do elemento de token retornado, como mostrado sendo extraído de YouTubeVideoEntry acima. Para que o usuário seja redirecionado ao seu site após enviar o formulário, anexe um parâmetro next ao post_url (conforme mostrado abaixo), que funcionará da mesma forma que o parâmetro next de um link AuthSub. A única diferença é que, em vez de um token de uso único, uma variável status e id são retornadas 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)
Uma resposta para um upload bem-sucedido seria semelhante a esta:
http://example.com/post_video_upload.pyc?status=200&id=ABC123
O parâmetro status retorna o status da transação HTTP da transação de upload. O parâmetro id retorna o ID do vídeo do YouTube atribuído ao vídeo enviado.
Como verificar o status do upload
Depois de fazer o upload de um vídeo, ele vai aparecer imediatamente no feed de envios de um usuário autenticado. No entanto, ele não será público no site até ser processado. Os vídeos rejeitados ou que não foram enviados também vão aparecer apenas no feed de envios do usuário autenticado. O código a seguir verifica o status de um YouTubeVideoEntry para saber se ele ainda não está ativo ou se foi rejeitado.
upload_status = yt_service.CheckUploadStatus(new_entry) if upload_status is not None: video_upload_state = upload_status[[]0] detailed_message = upload_status[[]1]
Como atualizar e excluir vídeos
Como atualizar as informações do vídeo
Para atualizar os metadados do vídeo, basta atualizar o objeto YouTubeVideoEntry e usar o método UpdateVideoEntry dos objetos YouTubeService. Esse método usa como parâmetro um YouTubeVideoEntry que contém metadados atualizados.
# 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)
Como excluir um vídeo
A exclusão de um vídeo é muito simples e envolve apenas uma chamada para o DeleteVideoEntry do objeto YouTubeService.
response = yt_service.DeleteVideoEntry(entry_to_be_deleted) if response: print 'Video successfully deleted!'
Como usar recursos de comunidade
Como adicionar uma avaliação
Para avaliar um vídeo, use o método AddRating do objeto YouTubeService. Não é possível classificar seus próprios vídeos, e as classificações precisam estar entre 1 e 5:
video_id_to_rate = 'Ncakifd_16k' video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate) response = yt_service.AddRating(3, video_entry)
Comentários
Como recuperar comentários para um vídeo
Com um objeto YouTubeVideoEntry ou um ID de vídeo simples, é possível recuperar e imprimir um feed contendo os comentários do vídeo usando o método GetYouTubeVideoCommentFeed do objeto YouTubeService. O feed resultante é um gdata.youtube.YouTubeCommentFeed, que consiste em objetos gdata.youtube.YouTubeCommentEntry. O feed pode ser analisado como qualquer outro:
video_id = 'ABC123...' comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id) for comment_entry in comment_feed.entry: print comment_entry.ToString()
Adicionando um comentário
Para adicionar um novo comentário, use o método AddComment do objeto YouTubeService. O método requer um objeto YouTubeVideoEntry completo que será comentado, além de uma string que represente o comentário:
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)
Respostas ao vídeo
Uma resposta em vídeo do YouTube é um vídeo associado, como uma resposta, a um segundo vídeo. O recurso de respostas em vídeo foi desativado, conforme explicado neste comunicado. As respostas em vídeo ainda estão disponíveis, mas o YouTube não oferece mais a opção de recuperar uma lista de respostas em vídeo para um vídeo, enviar novas respostas em vídeo ou excluir respostas em vídeo. No entanto, é possível excluir o vídeo que foi usado em uma resposta em vídeo. Consequentemente, essas funções também não são mais compatíveis com a API.
As solicitações de API para operações de resposta de vídeo agora retornam o seguinte:
- Uma solicitação para recuperar respostas em vídeo para um vídeo retorna uma lista vazia.
- Uma solicitação para adicionar uma resposta em vídeo retorna um código de resposta HTTP 403.
- Uma solicitação para excluir uma resposta em vídeo retorna um código de resposta HTTP 403.
Como sinalizar um vídeo
A adição de uma denúncia sobre um vídeo é feita com o método AddComplaint no objeto YouTubeService. O termo da reclamação precisa ser uma categoria válida. Consulte a seção Adicionar uma denúncia no guia do protocolo para mais informações.
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)
Como salvar e colecionar vídeos
Vídeos favoritos
Como recuperar os vídeos favoritos de um usuário
Os usuários do YouTube podem marcar os vídeos que assistem como favoritos. O local geral do feed favorito de um usuário é o seguinte URL.
http://gdata.youtube.com/feeds/api/users/username/favorites
Para recuperar os vídeos favoritos de um usuário, use o método GetUserFavoritesFeed do objeto YouTubeService. O método usa uma string opcional como parâmetro que representa o nome de usuário do YouTube do usuário cujo feed favorito será recuperado.
favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')
O feed retornado é um feed de vídeo normal, que contém objetos YouTubeVideoEntry.
Observação:também é possível transmitir a string default para recuperar os favoritos do usuário autenticado. Esse é o comportamento padrão do método GetUserFavoritesFeed se nenhum nome de usuário for fornecido.
Adicionar um favorito
Para adicionar um vídeo aos favoritos, use o método AddVideoEntryToFavorites do objeto YouTubeService. Os parâmetros são o YouTubeVideoEntry que será adicionado e, opcionalmente, o nome de usuário dos favoritos em que ele será adicionado (o padrão é o usuário autenticado no momento).
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'
Como excluir um favorito
Para excluir um favorito, basta usar o método DeleteVideoEntryFromFavorites do objeto YouTubeService.
video_id = 'Ncakifd_16k' response = yt_service.DeleteVideoEntryFromFavorites(video_id) if response is True: print 'Video deleted from favorites'
Playlists
Cada usuário do YouTube tem um feed de playlists que contém todas as playlists criadas por ele. Cada playlist tem um feed com todos os vídeos dela.
Como recuperar playlists do usuário
Para buscar uma lista de todas as playlists de um usuário manualmente, use o seguinte URL:
http://gdata.youtube.com/feeds/api/users/username/playlists
Com a biblioteca de cliente do Python, é possível usar o método GetYouTubePlaylistFeed do 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')
Observação:em vez de transmitir um nome de usuário específico (como "gdpython" no exemplo acima), também é possível transmitir a string 'default' para se referir ao usuário autenticado.
Um gdata.youtube.YouTubePlaylistFeed representa um feed de objetos gdata.youtube.YouTubePlaylistEntry. Eles se referem às playlists individuais que um usuário pode ter. As entradas de vídeo em uma playlist específica são representadas como objetos gdata.youtube.YouTubePlaylistVideoEntry. Esses objetos são muito semelhantes aos objetos gdata.youtube.YouTubeVideoEntry normais, com algumas exceções. É possível adicionar títulos e descrições personalizados aos vídeos, e um campo de posição indica onde o vídeo aparece na playlist.
Recuperar informações da reprodução
Com um YouTubePlaylistEntry (que representa uma playlist específica), é possível receber um YouTubePlaylistVideoFeed que contém objetos YouTubePlaylistVideoEntry. Como explicado acima, esses objetos representam vídeos individuais em uma playlist (com títulos e descrições personalizados opcionais). Para acessar esse feed, transmita o URI da playlist para o método GetYouTubePlaylistVideoFeed do 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
Como adicionar uma lista de reprodução
Para adicionar uma nova playlist, basta usar o método AddPlaylist do objeto YouTubeService. Esse método usa os seguintes parâmetros: playlist_title, playlist_description (ambas strings) e um valor booleano opcional que pode ser definido como True se a playlist for marcada 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'
Como atualizar uma lista de reprodução
Para atualizar uma playlist, use o método UpdatePlaylist do objeto YouTubeService. O método recebe os seguintes parâmetros: o ID da playlist a ser atualizada, um novo título, uma nova descrição, um booleano opcional para marcar a playlist como privada e uma string opcional indicando o nome de usuário proprietário da playlist. A string será definida como o usuário autenticado no momento.
# 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)
Adicionar vídeo à playlist
Para adicionar um vídeo a uma playlist, use o método AddPlaylistVideoEntryToPlaylist do objeto YouTubeService. O código abaixo adiciona um vídeo a uma playlist com um título e uma descrição 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'
Observação:não é necessário incluir um título e uma descrição personalizados. Se eles não forem especificados, o título e a descrição reais do vídeo serão usados.
Editar informações do vídeo na playlist
Use o método UpdatePlaylistVideoEntryMetaData do objeto YouTubeService para mudar os metadados de um YouTubePlaylistVideoEntry. No exemplo abaixo, decidimos dar um novo título personalizado ao vídeo e movê-lo para a primeira posição (posição 1) na 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)
Observação:se você quiser reverter a descrição e o título de um vídeo em uma playlist para os metadados originais, basta informar NULL para o título e a descrição.
Remover vídeo da playlist
Para remover um vídeo de uma playlist, use o método DeletePlaylistVideoEntry do objeto YouTubeService. O método exige o URI da playlist que contém a entrada a ser excluída, bem como o ID da 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'
Como excluir uma lista de reprodução
Para excluir uma playlist, basta usar o método DeletePlaylist do objeto YouTubeService, transmitindo o URI da playlist a ser excluída:
playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505' response = yt_service.DeletePlaylist(playlist_uri) if response is True: print 'Playlist successfully deleted'
Inscrições
Para buscar uma lista dos canais, pesquisas e favoritos de um determinado usuário, use o seguinte URI:
http://gdata.youtube.com/feeds/api/users/username/subscriptions
Observação:também é possível transmitir a string default para recuperar os favoritos do usuário autenticado.
Como recuperar assinaturas do usuário
O código abaixo demonstra como recuperar e mostrar a lista de assinaturas de um determinado usuário. As assinaturas são representadas como um gdata.youtube.YouTubeSubscriptionFeed composto por objetos gdata.youtube.YouTubeSubscriptionEntry. Para recuperar assinaturas, use o método GetYouTubeSubscriptionFeed do objeto YouTubeService, transmitindo o URI de um feed de assinaturas ou o nome de usuário cujo feed de assinaturas será recuperado. O parâmetro de nome de usuário é definido como o usuário autenticado.
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()
Como adicionar uma inscrição
Para criar uma nova assinatura, insira um novo YouTubeSubsciptionEntry no feed de assinaturas do usuário autenticado. Podemos criar três tipos de assinaturas: uma assinatura do canal de um usuário (usando AddSubscriptionToChannel), uma assinatura dos favoritos de um usuário (usando AddSubscriptionToFavorites) ou uma assinatura de uma palavra-chave específica (usando AddSubscriptionToQuery). O código a seguir inscreve o usuário autenticado no canal "GoogleDevelopers".
new_subscription = yt_service.AddSubscriptionToChannel(
username_to_subscribe_to='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Você também pode se inscrever nos favoritos do usuário "GoogleDevelopers":
new_subscription = yt_service.AddSubscriptionToFavorites(
username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
print 'New subscription added'
Por fim, você também pode se inscrever em termos de pesquisa específicos. Aqui estamos nos inscrevendo em uma consulta para vídeos com a tag "python".
new_subscription = yt_service.AddSubscriptionToQuery(query='python') if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry): print 'New subscription added'
Como excluir uma inscrição
Para excluir uma assinatura do usuário, use o método DeleteSubscription do 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'
Como ativar a interação do usuário
Perfis de usuário
Como recuperar o perfil de um usuário
Para buscar o perfil do YouTube de um usuário manualmente, use o seguinte URI:
http://gdata.youtube.com/feeds/api/users/username
É possível recuperar um gdata.youtube.YouTubeUserEntry com o método GetYouTubeUserEntry do 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
Contatos
A lista de contatos de um determinado usuário pode ser recuperada no seguinte URL:
http://gdata.youtube.com/feeds/api/users/username/contacts
Como recuperar os contatos do usuário
O método GetYouTubeContactFeed do objeto YouTubeService pode ser usado para extrair um gdata.youtube.YouTubeContactFeed, que consiste em 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
Como adicionar um contato
Para adicionar um novo contato ao feed de contatos de um usuário, use o método AddContact do objeto YouTubeService.
new_contact = yt_service.AddContact(contact_username='GoogleDevelopers') if isinstance(new_contact, gdata.youtube.YouTubeContactEntry) print 'New contact added'
Aceitar/rejeitar um contato
Para atualizar um contato, use o método UpdateContact do objeto YouTubeService. Esse método pode ser usado para aceitar/rejeitar solicitações de contato e também para categorizar contatos como "Amigo" ou "Família". No exemplo abaixo, aceitamos um contato e definimos a categoria como "Família":
# 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'
Como excluir um contato
Para excluir um contato, use o método DeleteContact do objeto YouTubeService, transmitindo o nome de usuário do contato que você quer excluir.
response = yt_service.DeleteContact(contact_username='gdpython') if response is True: print 'Contact deleted'