Guida per gli sviluppatori: Python

L'API YouTube Data consente alle applicazioni client di recuperare e aggiornare i contenuti di YouTube sotto forma di feed dell'API di dati Google. L'applicazione client può utilizzare i feed dell'API YouTube Data per recuperare, cercare e aggiornare video, commenti, risposte, playlist, profili utente e contatti utente, nonché eseguire query sui video che soddisfano determinati criteri.

Oltre a fornire alcune informazioni sulle funzionalità dell'API di dati di YouTube, questo documento fornisce esempi per interagire con l'API utilizzando la libreria client Python. Per utilizzare la libreria client Python, devi disporre di Python 2.0 o versioni successive e dei moduli Element Tree, httplib e urllib. Per ulteriori dettagli, consulta la sezione Moduli di dipendenza.

Se hai bisogno di aiuto per configurare la libreria client Python, consulta la Guida introduttiva. Se vuoi saperne di più sul protocollo di base utilizzato dalla libreria client Python per interagire con YouTube, consulta la pagina del protocollo della Guida per gli sviluppatori.

Informazioni su questo documento

Pubblico

Questo documento è rivolto ai programmatori che vogliono scrivere applicazioni client in grado di interagire con YouTube utilizzando la libreria client Python. Fornisce una serie di esempi di interazioni di base con le API di dati.

Per informazioni di riferimento sull'API YouTube Data, consulta la guida di riferimento.

Questo documento presuppone che tu comprenda le idee generali alla base del protocollo delle API di dati di Google e che tu sappia programmare in Python.

Per informazioni di riferimento sui metodi e sulle classi Python, consulta i file pyDocs (per la classe di servizio e per le classi di dati) inclusi nel codice sorgente.

Struttura del documento

Il presente documento si articola nelle seguenti sezioni:

  • La sezione Autenticazione descrive i due diversi metodi di autenticazione disponibili per associare le operazioni API a un account utente specifico. Questa sezione illustra anche le differenze tra l'autenticazione per l'API YouTube Data e per altre API di dati di Google. In questo documento, le spiegazioni di funzioni API specifiche indicheranno chiaramente se la funzione richiede l'autenticazione dell'utente. In generale, tutte le richieste che modificano i dati dei video o dei feed devono essere autenticate. Le richieste di accesso di sola lettura ai video pubblici non richiedono l'autenticazione.

  • La sezione Informazioni su feed e voci video fornisce una risposta API di esempio e spiega come estrarre informazioni su un singolo video da un elenco di video o da un insieme di risultati di ricerca. Questa sezione spiega anche come accedere ai metadati di una voce video specifica. Infine, questa sezione spiega il meccanismo per aggiornare una singola voce video.

  • La sezione Recupero e ricerca di video spiega come recuperare elenchi specifici di video, ad esempio un feed standard dei video più popolari di YouTube. Altri elenchi di video includono i video caricati da un utente specifico e gli elenchi di video correlati a un determinato video. Questa sezione spiega anche come utilizzare l'API per consentire agli utenti di cercare nella raccolta video di YouTube in base a termini di ricerca o categorie specifici.

  • La sezione Caricamento di video spiega brevemente due modi per consentire agli utenti di caricare video su YouTube dalla tua applicazione. Inoltre, in questa sezione viene spiegato anche come caricare i video come risposta ad altri video.

  • La sezione Aggiornamento ed eliminazione dei video descrive come utilizzare l'API per aggiornare le informazioni su un video di YouTube. Inoltre, descrive come rimuovere un video utilizzando l'API.

  • La sezione Utilizzare le funzionalità della scheda Community descrive le funzioni dell'API che consentono agli utenti di interagire con i video di YouTube. Queste funzioni spiegano le richieste di pubblicazione di una valutazione, un commento o un reclamo su un video esistente. Puoi anche utilizzare l'API per recuperare gli elenchi dei commenti dei video.

  • La sezione Salvare e raccogliere video spiega come utilizzare l'API per accedere, creare e aggiornare video preferiti, playlist e iscrizioni ai canali YouTube. Inoltre, spiega come modificare le playlist e i video preferiti aggiungendo e rimuovendo video.

  • La sezione Abilitazione dell'interazione utente spiega come utilizzare l'API per recuperare e aggiornare i profili utente. Questa sezione spiega anche come recuperare, aggiungere, aggiornare ed eliminare i contatti degli utenti.

Per iniziare

Requisiti

L'applicazione client può utilizzare i feed dell'API YouTube Data per cercare, recuperare e aggiornare video, commenti, risposte, playlist, iscrizioni, profili utente e altro ancora.

Oltre a fornire alcune informazioni sulle funzionalità dell'API di dati di YouTube, questo documento fornisce esempi per interagire con l'API utilizzando la libreria client Python. Per utilizzare la libreria client Python, devi disporre di Python 2.2 o versioni successive e dei moduli Element Tree, httplib e urllib. Per ulteriori dettagli, consulta la sezione Moduli di dipendenza.

Per ulteriori informazioni sulla configurazione dell'ambiente, consulta la Guida introduttiva. Se vuoi saperne di più sul protocollo di base utilizzato dalla libreria client Python per interagire con YouTube, consulta la pagina del protocollo della Guida per gli sviluppatori.

Gli snippet di codice di esempio riportati di seguito possono essere copiati/incollati nel codice e modificati in base alle tue esigenze.

Prima di poter eseguire qualsiasi operazione con l'API YouTube Data, devi inizializzare un oggetto gdata.youtube.service.YouTubeService, come mostrato di seguito. Le istruzioni import elencate di seguito eseguiranno automaticamente ulteriori importazioni dai moduli gdata.media e gdata.geo. Tieni presente che tutte le azioni, ad eccezione del recupero dei contenuti pubblici, richiedono l'autenticazione.

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 maggior parte degli esempi di metodo in questa guida opera su un'istanza di gdata.youtube.service.YouTubeService. Potrebbe essere utile testare le richieste non autenticate dall'interprete Python interattivo.

Nota: la libreria client Python deve essere aggiunta correttamente al percorso. Assicurati di installarlo eseguendo lo script setup.py fornito. Per ulteriori informazioni, consulta la Guida introduttiva.

Autenticazione

La libreria client Python può essere utilizzata per lavorare con feed pubblici o privati. I feed pubblici sono di sola lettura e non richiedono alcuna autenticazione. I feed privati richiedono l'autenticazione sui server di YouTube.

L'autenticazione può essere eseguita tramite l'autenticazione ClientLogin (per le app desktop) o tramite l'autenticazione AuthSub (per le applicazioni web).

Impostazione della chiave dello sviluppatore e dell'ID client

Una chiave dello sviluppatore identifica lo sviluppatore di YouTube che invia una richiesta API. Un ID client identifica la tua applicazione a scopo di logging e debug.

Quando effettui una richiesta API utilizzando la libreria client Python, l'intestazione della richiesta X-GData-Key viene utilizzata per specificare la chiave sviluppatore e l'intestazione X-GData-Client viene utilizzata per specificare l'ID client. La chiave dello sviluppatore e l'ID client possono essere impostati nell'oggetto YouTubeService, indipendentemente dallo schema di autenticazione utilizzato:

yt_service.developer_key = 'ABCxyz123...'
yt_service.client_id = 'My-Client_id'

Dovrai registrarti per ottenere una chiave per gli sviluppatori di YouTube.

Autenticazione AuthSub per le applicazioni web

L'autenticazione proxy AuthSub viene utilizzata dalle applicazioni web che devono autenticare i propri utenti negli account YouTube/Google. L'operatore non ha bisogno di accedere al nome utente e alla password dell'utente di YouTube, ma sono necessari solo token AuthSub speciali.

Quando l'utente visita per la prima volta la tua applicazione, non è ancora stato autenticato con i servizi Google. In questo caso, devi fornire all'utente un link che lo indirizzi a Google per autorizzare la richiesta di accesso delle tue applicazioni al suo account YouTube. La libreria client Python fornisce una funzione per generare questo URL. Il codice riportato di seguito configura un link alla pagina 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

Tieni presente i parametri inviati al metodo GenerateAuthSubURL degli oggetti di servizio:

  • next: l'URL della pagina a cui YouTube deve reindirizzare l'utente dopo che ha autorizzato la tua applicazione ad accedere al suo account.
  • scope: indica che l'applicazione accederà solo ai feed dell'API YouTube.
  • secure: indica che il token restituito non sarà un token sicuro.
  • session: indica che questo token può essere scambiato con un token multiuso (di sessione).

L'URL restituito sarà simile al seguente:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fgdata.youtube.com&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2Fvideo_upload.pyc

L'utente può quindi seguire il link per accedere al proprio account YouTube. Dopo che l'utente avrà autorizzato la tua applicazione ad accedere al suo account, verrà reindirizzato all'URL next. All'URL verrà aggiunto un valore token monouso come parametro di query. L'URL sarà simile a questo: 

http://www.example.com/video_upload.pyc?token=Abc123...

La sezione successiva mostra come eseguire l'upgrade di questo token. Lo snippet riportato di seguito mostra uno dei modi per recuperare questo token dall'URL:

import cgi
parameters = cgi.FieldStorage()
authsub_token = parameters[[]'token' ]

Eseguire l'upgrade a un token sessione

Per motivi di sicurezza, questo token è monouso, quindi ora devi scambiarlo con un token di sessione. Questa procedura è descritta nella documentazione di AuthSub. Il seguente snippet di codice mostra come eseguire l'upgrade del token.

yt_service = gdata.youtube.service.YouTubeService()
yt_service.SetAuthSubToken(authsub_token)
yt_service.UpgradeToSessionToken()

Questo valore del token rappresenta un token AuthSub monouso. Poiché session = True è stato specificato sopra, questo token può essere scambiato con un token di sessione AuthSub utilizzando il metodo UpgradeToSessionToken, che chiama il servizio AuthSubSessionToken.

L'oggetto YouTubeService è ora completamente autenticato e può essere utilizzato per eseguire tutte le richieste successive con l'API YouTube. I token di sessione AuthSub non scadono, a meno che tu non emetta una richiesta specifica per revocarli o che l'utente decida di revocare l'accesso visitando la pagina Siti autorizzati nel proprio account YouTube.

Autenticazione ClientLogin per le applicazioni installate

L'autenticazione ClientLogin viene utilizzata nelle applicazioni installate che possono memorizzare o richiedere all'utente il nome utente e la password. Per utilizzare questa forma di autenticazione, invoca il metodo ProgrammaticLogin di YouTubeService ereditato dalla classe gdata.service.GDataService, specificando l'ID e la password dell'utente per conto del quale il tuo client invia la richiesta di autenticazione.

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 volta impostate le credenziali, l'oggetto YouTubeService può essere utilizzato per gestire tutte le richieste successive. Per poter eseguire caricamenti e qualsiasi tipo di richiesta di "scrittura" (aggiunta di commenti e così via) all'API YouTube, assicurati di passare anche la chiave dello sviluppatore e l'ID cliente all'oggetto yt_service quando esegui l'autenticazione:

# A complete client login request
yt_service.email = 'jo@gmail.com'
yt_service.password = 'mypassword'
yt_service.source = 'my-example-application'
yt_service.developer_key = 'ABC123...'
yt_service.client_id = 'my-example-application'
yt_service.ProgrammaticLogin()

L'oggetto YouTubeService imposta automaticamente le intestazioni X-GData-Key e X-GData-Client corrette quando sono impostati gli attributi developer_key e client_id.

Nota:consulta la documentazione sull'autenticazione delle API di dati di Google per informazioni più dettagliate sui meccanismi AuthSub e ClientLogin.

Informazioni su feed e voci video

L'API YouTube Data fornisce diversi feed video che rappresentano elenchi di video, ad esempio feed standard, caricamenti, iscrizioni e preferiti. L'URL di ogni feed è documentato nella guida di riferimento.

Visualizzazione di un feed di video

Molti feed nell'API YouTube sono costituiti da voci video. Questi feed possono essere modellati più semplicemente come oggetti gdata.youtube.YouTubeVideoFeed, ciascuno contenente una serie di oggetti gdata.youtube.YouTubeVideoEntry. Ogni voce video corrisponde a un solo video su YouTube e contiene informazioni sul video.

La struttura di base per recuperare un elenco di video consiste nel creare un URL per un feed video e poi elaborare le voci una alla volta, in modo simile al seguente codice:

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 sezione Recupero e ricerca di video descrive in dettaglio molti URL di feed comuni e come recuperare vari feed video.

Recupero di una voce video specifica

Puoi recuperare solo le informazioni relative a una voce video specifica se conosci il relativo ID video. L'URL di inserimento si basa sull'ID video:

http://gdata.youtube.com/feeds/api/videos/videoID

Il seguente codice recupera un gdata.youtube.YouTubeVideoEntry corrispondente a un video su YouTube:

entry = yt_service.GetYouTubeVideoEntry(video_id='the0KZLEacs')

Contenuti della partecipazione video

Esistono molti metadati che possono essere recuperati da un oggetto gdata.youtube.YouTubeVideoEntry, ad esempio miniature, URL dei player e durata del video. Il codice seguente mostra come recuperare alcune di queste informazioni. La libreria client Python esegue l'astrazione della maggior parte di queste funzionalità mappando gli elementi XML in classi. La maggior parte delle informazioni importanti su una voce YouTubeVideoEntry è disponibile dagli elementi secondari dell'attributo media (contenente un oggetto gdata.media.Group) all'interno della voce (che rappresenta l'elemento XML media:group). Di seguito è riportato un esempio di come recuperare i metadati dei 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:per ulteriori informazioni su come generare le informazioni necessarie per incorporare un video con un player nella tua pagina, consulta la guida al protocollo.

Recupero e ricerca di video

Recupero dei feed standard

L'API di dati di YouTube fornisce un feed standard dei video più popolari di YouTube. In precedenza l'API supportava altri feed standard, che sono stati ritirati. Per scoprire di più, consulta la Guida per gli sviluppatori.

L'URL del feed dei video più popolari di YouTube ha il seguente formato:

http://gdata.youtube.com/feeds/api/standardfeeds/most_popular

Nota:puoi anche recuperare i feed standard specifici per le impostazioni internazionali specificando un localeID nel formato: http://gdata.youtube.com/feeds/api/standardfeeds/localeID/feedID. Ad esempio, i video più popolari in Giappone sono: http://gdata.youtube.com/feeds/api/standardfeeds/JP/most_popular. Per un elenco completo dei presunti localeID, consulta la guida di riferimento .

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))

Recuperare i video caricati da un utente specifico

A ogni utente di YouTube è associato un feed video corrispondente ai video che ha caricato, al giorno http://gdata.youtube.com/feeds/api/users/username/uploads. Il seguente codice mostra come recuperare e visualizzare un feed dei caricamenti dell'utente:

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:puoi anche utilizzare la stringa "default" al posto di username per recuperare i video per l'utente attualmente autenticato.

Per recuperare i video correlati, passa l'ID video dell'oggetto gdata.youtube.YouTubeVideoEntry al metodo GetYouTubeRelatedVideoFeed dell'oggetto gdata.youtube.service.YouTubeService. Viene recuperato un oggetto YouTubeVideoFeed contenente le voci correlate.

related_feed = yt_service.GetYouTubeRelatedVideoFeed(video_id='abc123')

Ricerca i video

L'API YouTube Data ti consente di richiedere un insieme di voci che corrispondono a criteri specificati, ad esempio richiedere voci video pubblicate da un determinato autore, per formato video o contenenti una determinata parola chiave. Per farlo, crea un oggetto gdata.service.YouTubeVideoQuery con i tuoi criteri di ricerca specifici e trasmettelo al metodo YouTubeQuery di gdata.youtube.service.YouTubeService.

L'esempio seguente mostra come eseguire una query di ricerca, con i risultati ordinati in base al numero di visualizzazioni, inclusi i video con limitazioni (definiti "Racy" dall'API):

def SearchAndPrint(search_terms):
  yt_service = gdata.youtube.service.YouTubeService()
  query = gdata.youtube.service.YouTubeVideoQuery()
  query.vq = search_terms
  query.orderby = 'viewCount'
  query.racy = 'include'
  feed = yt_service.YouTubeQuery(query)
  PrintVideoFeed(feed)

La classe gdata.service.Query e le sottoclassi come YouTubeVideoQuery sono responsabili della costruzione degli URL dei feed. VideoQuery mostrato sopra genera un URL equivalente al seguente:

http://gdata.youtube.com/feeds/api/videos?vq=<searchTerms>&racy=include&orderby=viewCount

Di seguito sono riportate alcune delle proprietà YouTubeVideoQuery più comuni per l'impostazione dei parametri di ricerca:

author
Imposta l'autore della voce. Autore è sinonimo di nome utente di YouTube.
format
Specifica un formato video. Accetta parametri numerici per specificare uno dei due tipi di URL di streaming RTSP per la riproduzione di video su dispositivi mobili o un URL HTTP al player Flash embeddable.
racy
Indica se i contenuti con limitazioni devono essere inclusi nei risultati. Accetta solo due parametri: "include" o "exclude".
max_results
Imposta il numero massimo di voci da restituire contemporaneamente.
start_index
Imposta l'indice basato su 1 del primo risultato da recuperare (per la paginazione).
orderby
Imposta l'ordine in cui elencare le voci, ad esempio per relevance, viewCount, published o rating.
time
Imposta un periodo di tempo per limitare i risultati del feed standard a: today, this_week, this_month o all_time.
vq
Imposta un termine di query di ricerca. Cerca la stringa specificata in tutti i metadati del video, ad esempio titoli, tag e descrizioni.

Nota:per ulteriori informazioni sui parametri di query, consulta la Guida di riferimento dell'API YouTube Data e la Guida di riferimento delle API di dati di Google.

Ricerca con categorie e parole chiave

Puoi limitare i risultati di ricerca in modo da mostrare solo i video che corrispondono a un determinato insieme di categorie e parole chiave. La guida di riferimento descrive come specificare sia le categorie predefinite di YouTube (ad es. Musica, Persone e blog e così via) sia le parole chiave definite dall'utente (tag).

Il codice seguente mostra come eseguire ricerche utilizzando parole chiave (tag) impostando i termini di ricerca in minuscolo. Nota: poiché alcune parole (ad esempio "commedia") possono essere sia una categoria di YouTube sia una parola chiave, le query per categorie e parole chiave utilizzano la convenzione che una parola scritta in maiuscolo ("Commedia") indica una categoria di YouTube, mentre una parola scritta in minuscolo ("commedia") indica una parola chiave.

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)

Ricerca per tag sviluppatore

I tag sviluppatore sono parole chiave aggiuntive e nascoste che uno sviluppatore può utilizzare per taggare i contenuti caricati tramite la sua applicazione dagli utenti finali. I tag sviluppatore vengono associati alla chiave sviluppatore impostata nelle intestazioni durante il caricamento. Queste parole chiave non saranno visibili al pubblico e potrebbero essere utilizzate per recuperare i video. Per cercare video in base a un tag sviluppatore specifico, invia una richiesta di ricerca generale dell'API YouTube Data utilizzando la tua chiave sviluppatore. Assicurati di specificare lo schema di categoria e il tag sviluppatore a cui devono corrispondere i video. Puoi recuperare un feed di video corrispondenti al tuo tag sviluppatore ("your_tag_here" nel nostro esempio) dall'URL riportato di seguito:

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))

Caricamento dei video

Assicurati di esaminare i diagrammi nella guida al protocollo per una panoramica generale della procedura di caricamento. Puoi caricare i video in due modi:

  • caricando il video direttamente dai tuoi server tramite il metodo di caricamento diretto
  • oppure inviando prima i metadati e poi chiedendo all'utente di caricare il video direttamente su YouTube tramite il metodo di caricamento basato su browser

Caricamento diretto

Per caricare un video, devi prima creare un nuovo oggetto gdata.youtube.YouTubeVideoEntry, passandogli un oggetto gdata.media.Group contenente i metadati richiesti. L'esempio seguente mostra il caricamento del video Quicktime "mytestmovie.mov" su YouTube con le seguenti proprietà:

ProprietàValore
TitoloIl mio film di prova
CategoriaAuto
Keywordsauto, divertenti
DescrizioneLa mia descrizione
Nome filemytestmovie.mov
Tipo MIME del filevideo/quicktime
Il video è privato?falso
Località del video37,-122 (lat,long)
Tag sviluppatoremydevelopertag, anotherdevelopertag

Il codice seguente crea un YouTubeVideoEntry vuoto da caricare. Il metodo InsertVideoEntry in YouTubeService richiede i seguenti parametri:

  • video_entry: l'oggetto gdata.youtube.VideoEntry contenente i metadati
  • filename_or_handle: un oggetto simile a un file o il nome del file da cui verrà letto il video
  • youtube_username: una stringa facoltativa che specifica il nome utente dell'account in cui caricare il video. Il tuo account dovrà disporre delle autorizzazioni appropriate. Per impostazione predefinita, viene utilizzato l'account dell'utente attualmente autenticato.
  • content_type: una stringa facoltativa che specifica il tipo MIME del video da caricare.
Tieni presente che questi esempi presuppongono che la variabile yt_service si riferisca a un oggetto YouTubeService completamente autenticato.

# 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 volessimo taggare il video con tag sviluppatore facoltativi (per maggiori dettagli, consulta la sezione Ricerca per tag sviluppatore), avremmo potuto utilizzare il metodo AddDeveloperTags prima di eseguire la chiamata a InsertVideoEntry:

developer_tags = [[]'some_tag_01', 'another_tag']
video_entry.AddDeveloperTags(developer_tags)

Nota: per caricare i video come privati, è necessario passare un attributo privato 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)

Caricamento basato su browser

Il caricamento tramite browser viene eseguito in modo quasi identico al caricamento diretto, tranne per il fatto che non carichi il file binario nella stessa richiesta utilizzata per inviare i metadati del video. ma crea semplicemente un YouTubeVideoEntry contenente solo metadati. Questa voce del video viene poi pubblicata su un link speciale sul server dell'API di YouTube. La risposta XML contiene un token e un url che possono essere utilizzati per caricare il file binario utilizzando un modulo HTML standard.

# create media group as usual
my_media_group = gdata.media.Group(
  title=gdata.media.Title(text='My Test Movie'),
  description=gdata.media.Description(description_type='plain',
                                      text='My description'),
  keywords=gdata.media.Keywords(text='cars, funny'),
  category=[[]gdata.media.Category(
      text='Autos',
      scheme='http://gdata.youtube.com/schemas/2007/categories.cat',
      label='Autos')],
  player=None
)

# create video entry as usual
video_entry = gdata.youtube.YouTubeVideoEntry(media=my_media_group)

# upload meta data only
response = yt_service.GetFormUploadToken(video_entry)

# parse response tuple and use the variables to build a form (see next code snippet)
post_url = response[[]0]
youtube_token = response[[]1]

Il codice riportato sopra stampa un link e un token utilizzati per creare un modulo HTML da visualizzare nel browser dell'utente. Di seguito è riportato un semplice esempio di modulo in cui youtube_token rappresenta il contenuto dell'elemento token restituito, come mostrato nel recupero da YouTubeVideoEntry sopra. Affinché l'utente venga reindirizzato al tuo sito web dopo aver inviato il modulo, assicurati di aggiungere un parametro next a post_url (come mostrato di seguito), che funzionerà nello stesso modo del parametro next di un link AuthSub. L'unica differenza è che qui, anziché un token monouso, vengono restituite come parametri URL una variabile status e una id.

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 risposta per un caricamento riuscito sarà simile alla seguente:

http://example.com/post_video_upload.pyc?status=200&id=ABC123

Il parametro status restituisce lo stato della transazione HTTP della transazione di caricamento. Il parametro id restituisce l'ID video di YouTube assegnato al video caricato.

Controllo dello stato del caricamento

Una volta caricato, il video sarà immediatamente visibile nel feed dei caricamenti di un utente autenticato. Tuttavia, non sarà visibile pubblicamente sul sito finché non sarà stato elaborato. Anche i video rifiutati o il cui caricamento non è andato a buon fine saranno presenti solo nel feed dei caricamenti dell'utente autenticato. Il seguente codice controlla lo stato di un YouTubeVideoEntry per verificare se non è ancora pubblicato o se è stato rifiutato.

upload_status = yt_service.CheckUploadStatus(new_entry)

if upload_status is not None:
  video_upload_state = upload_status[[]0]
  detailed_message = upload_status[[]1]

Aggiornamento ed eliminazione di video

Aggiornamento delle informazioni sui video

Per aggiornare i metadati del video, aggiorna semplicemente l'oggetto YouTubeVideoEntry e utilizza il metodo UpdateVideoEntry degli oggetti YouTubeService. Questo metodo prende come parametro un YouTubeVideoEntry contenente metadati aggiornati.

# 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)

Eliminazione di un video

L'eliminazione di un video è molto semplice e richiede solo una chiamata a DeleteVideoEntry dell'oggetto YouTubeService.

response = yt_service.DeleteVideoEntry(entry_to_be_deleted)

if response:
  print 'Video successfully deleted!'

Utilizzare le funzionalità della community

Aggiunta di una valutazione

Per valutare un video, utilizza il metodo AddRating dell'oggetto YouTubeService. Tieni presente che non puoi valutare i tuoi video e che le valutazioni devono essere comprese tra 1 e 5 (inclusi):

video_id_to_rate = 'Ncakifd_16k'
video_entry = yt_service.GetYouTubeVideoEntry(video_id=video_id_to_rate)
response = yt_service.AddRating(3, video_entry)

Commenti

Recuperare i commenti di un video

Dato un oggetto YouTubeVideoEntry o un semplice ID video, puoi recuperare e stampare un feed contenente i commenti del video utilizzando il metodo GetYouTubeVideoCommentFeed dell'oggetto YouTubeService. Il feed risultante è un gdata.youtube.YouTubeCommentFeed composto da oggetti gdata.youtube.YouTubeCommentEntry. Il feed può essere analizzato come qualsiasi altro feed:

video_id = 'ABC123...'
comment_feed = yt_service.GetYouTubeVideoCommentFeed(video_id=video_id)

for comment_entry in comment_feed.entry:
  print comment_entry.ToString()

Aggiunta di un commento

Per aggiungere un nuovo commento, utilizza semplicemente il metodo AddComment dell'oggetto YouTubeService. Il metodo richiede un oggetto YouTubeVideoEntry completo su cui aggiungere un commento, nonché una stringa che rappresenti il commento:

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)

Video di risposta

Una risposta video di YouTube era un video associato, come risposta, a un secondo video. La funzionalità di risposta ai video è stata ritirata, come spiegato in questo annuncio. Anche se le risposte video esistenti rimangono disponibili, YouTube non supporta più la possibilità di recuperare un elenco di risposte video per un video, di caricare nuove risposte video o di eliminarle, anche se puoi eliminare il video utilizzato in una risposta video. Di conseguenza, queste funzioni non sono più supportate nell'API.

Le richieste API per le operazioni di risposta video ora restituiscono quanto segue:

  • Una richiesta di recupero delle risposte video per un video restituisce un elenco vuoto.
  • Una richiesta di aggiunta di una risposta video restituisce un codice di risposta HTTP 403.
  • Una richiesta di eliminazione di una risposta video restituisce un codice di risposta HTTP 403.

Segnalazione di un video

Per aggiungere un reclamo relativo a un video, utilizza il metodo AddComplaint dell'oggetto YouTubeService. Il termine del reclamo deve essere una categoria valida. Per ulteriori informazioni, consulta la sezione Aggiunta di un reclamo nella guida del protocollo.

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)

Salvare e raccogliere video

Video preferiti

Recuperare i video preferiti di un utente

Gli utenti di YouTube possono scegliere di contrassegnare i video che guardano come preferiti. La posizione generale del feed preferito di un utente è il seguente URL.

http://gdata.youtube.com/feeds/api/users/username/favorites

Per recuperare i video preferiti di un utente, utilizza il metodo GetUserFavoritesFeed dell'oggetto YouTubeService. Il metodo accetta come parametro una stringa facoltativa che rappresenta il nome utente di YouTube dell'utente di cui deve essere recuperato il feed preferito.

favorite_feed = yt_service.GetUserFavoritesFeed(username='gdpython')

Il feed restituito è un normale feed video contenente oggetti YouTubeVideoEntry.

Nota:in alternativa, puoi passare la stringa default per recuperare i preferiti dell'utente attualmente autenticato. Questo è il comportamento predefinito del metodo GetUserFavoritesFeed se non viene fornito alcun nome utente.

Aggiunta di un preferito

Per aggiungere un video preferito, utilizza il metodo AddVideoEntryToFavorites dell'oggetto YouTubeService. I parametri sono il YouTubeVideoEntry da aggiungere e, facoltativamente, il nome utente a cui aggiungerlo (il valore predefinito è l'utente attualmente autenticato).

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'

Eliminare un preferito

Per eliminare un preferito, utilizza semplicemente il metodo DeleteVideoEntryFromFavorites dell'oggetto YouTubeService.

video_id = 'Ncakifd_16k'
response = yt_service.DeleteVideoEntryFromFavorites(video_id)
if response is True:
  print 'Video deleted from favorites'

Playlist

Ogni utente di YouTube ha un feed di playlist che contiene tutte le playlist create dall'utente. Ogni playlist ha un feed per tutti i video al suo interno.

Recupero delle playlist degli utenti

Per recuperare manualmente un elenco di tutte le playlist di un utente, utilizza il seguente URL:

http://gdata.youtube.com/feeds/api/users/username/playlists

Con la libreria client Python, puoi utilizzare il metodo GetYouTubePlaylistFeed dell'oggetto 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:anziché passare un nome utente specifico (ad esempio "gdpython" nell'esempio precedente), puoi anche passare la stringa 'default' per fare riferimento all'utente attualmente autenticato.

Un gdata.youtube.YouTubePlaylistFeed rappresenta un feed di oggetti gdata.youtube.YouTubePlaylistEntry. Si riferiscono alle singole playlist che un utente potrebbe avere. Le voci video di una determinata playlist sono rappresentate come oggetti gdata.youtube.YouTubePlaylistVideoEntry. Questi oggetti sono molto simili agli oggetti gdata.youtube.YouTubeVideoEntry standard, con alcune eccezioni. Ai video possono essere applicati titoli e descrizioni personalizzati e un campo di posizione indica dove il video viene visualizzato nella playlist.

Recupero delle informazioni sulla playlist

Dato un YouTubePlaylistEntry (che rappresenta una playlist specifica), puoi ottenere un YouTubePlaylistVideoFeed contenente oggetti YouTubePlaylistVideoEntry. Come spiegato sopra, questi oggetti rappresentano i singoli video di una playlist (con titoli e descrizioni personalizzati facoltativi). Puoi ottenere questo feed passando l'URI della playlist al metodo GetYouTubePlaylistVideoFeed dell'oggetto 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

Aggiunta di una playlist

Per aggiungere una nuova playlist, utilizza semplicemente il metodo AddPlaylist dell'oggetto YouTubeService. Questo metodo accetta i seguenti parametri: playlist_title, playlist_description (entrambi stringhe) e un valore booleano facoltativo che può essere impostato su True se la playlist deve essere contrassegnata come privata.

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'

Aggiornare una playlist

Per aggiornare una playlist, utilizza il metodo UpdatePlaylist dell'oggetto YouTubeService. Il metodo accetta i seguenti parametri: l'ID della playlist da aggiornare, un nuovo titolo, una nuova descrizione, un valore booleano facoltativo per contrassegnare la playlist come privata e una stringa facoltativa che indica il nome utente del proprietario della playlist. Per impostazione predefinita, la stringa corrisponde all'utente attualmente autenticato.

# 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)

Aggiunta di video a playlist

Puoi aggiungere un video a una playlist utilizzando il metodo AddPlaylistVideoEntryToPlaylist dell'oggetto YouTubeService. Il codice riportato di seguito aggiunge un video a una playlist con un titolo e una descrizione personalizzati.

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:tieni presente che non è obbligatorio specificare un titolo e una descrizione personalizzati. Se non li specifichi, verranno utilizzati il titolo e la descrizione effettivi del video.

Modificare le informazioni dei video nella playlist

Utilizza il metodo UpdatePlaylistVideoEntryMetaData dell'oggetto YouTubeService per modificare i metadati di un YouTubePlaylistVideoEntry. Nell'esempio seguente abbiamo deciso di assegnare al video un nuovo titolo personalizzato e di spostarlo nella prima posizione (posizione 1) della playlist.

playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
playlist_entry_id = 'B0F29389E537F888'

new_video_title = 'a useful video'
new_video_description = 'updated video description'

updated_playlist_video_entry = yt_service.UpdatePlaylistVideoEntryMetaData(
    playlist_uri, playlist_entry_id, new_video_title, new_video_description, 1)

Nota: se vuoi ripristinare i metadati originali per il titolo e la descrizione di un video in una playlist, passa NULL sia per il titolo che per la descrizione.

Rimuovi video dalla playlist

Per rimuovere un video da una playlist, utilizza il metodo DeletePlaylistVideoEntry dell'oggetto YouTubeService. Il metodo richiede l'URI della playlist contenente la voce da eliminare, nonché l'ID della voce:

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'

Eliminazione di una playlist

Per eliminare una playlist, utilizza semplicemente il metodo DeletePlaylist dell'oggetto YouTubeService, passando l'URI della playlist da eliminare:

playlist_uri = 'http://gdata.youtube.com/feeds/api/playlists/BCB3BB96DF51B505'
response = yt_service.DeletePlaylist(playlist_uri)

if response is True:
  print 'Playlist successfully deleted'

Iscrizioni

Per recuperare un elenco dei canali, delle ricerche e dei preferiti a cui è iscritto un determinato utente, utilizza il seguente URI:

http://gdata.youtube.com/feeds/api/users/username/subscriptions

Nota:in alternativa, puoi passare la stringa default per recuperare i preferiti dell'utente attualmente autenticato.

Recupero degli abbonamenti degli utenti

Il seguente codice mostra come recuperare e stampare l'elenco degli abbonamenti di un determinato utente. Gli abbonamenti sono rappresentati come gdata.youtube.YouTubeSubscriptionFeed composto da oggetti gdata.youtube.YouTubeSubscriptionEntry. Per recuperare gli abbonamenti, utilizza il metodo GetYouTubeSubscriptionFeed dell'oggetto YouTubeService, passando l'URI di un feed di abbonamento o il nome utente di cui deve essere recuperato il feed di abbonamento. Il parametro nome utente è impostato per impostazione predefinita sull'utente attualmente autenticato.

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()

Aggiunta di un abbonamento

Puoi creare un nuovo abbonamento inserendo un nuovo YouTubeSubsciptionEntry nel feed Iscrizioni dell'utente autenticato. Possiamo creare tre tipi di iscrizioni: un'iscrizione al canale di un utente (utilizzando AddSubscriptionToChannel), un'iscrizione ai preferiti di un utente (utilizzando AddSubscriptionToFavorites) o un'iscrizione a una parola chiave specifica (utilizzando AddSubscriptionToQuery). Il codice seguente iscrive l'utente autenticato al canale "GoogleDevelopers".

new_subscription = yt_service.AddSubscriptionToChannel(
      username_to_subscribe_to='GoogleDevelopers')

if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

Puoi anche iscriverti ai preferiti dell'utente "GoogleDevelopers":

new_subscription = yt_service.AddSubscriptionToFavorites(
    username='GoogleDevelopers')
if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

Infine, puoi anche iscriverti a termini di ricerca specifici. In questo caso ci stiamo iscrivendo a una query per i video taggati come "python".

new_subscription = yt_service.AddSubscriptionToQuery(query='python')

if isinstance(new_subscription, gdata.youtube.YouTubeSubscriptionEntry):
  print 'New subscription added'

Eliminare un abbonamento

Per eliminare l'abbonamento di un utente, utilizza il metodo DeleteSubscription dell'oggetto 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'

Attivazione dell'interazione utente

Profili utente

Recupero del profilo di un utente

Per recuperare manualmente il profilo YouTube di un utente, utilizza il seguente URI:

http://gdata.youtube.com/feeds/api/users/username

Puoi recuperare un gdata.youtube.YouTubeUserEntry con il metodo GetYouTubeUserEntry dell'oggetto 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

Contatti

L'elenco dei contatti di un determinato utente può essere recuperato dal seguente URL:

http://gdata.youtube.com/feeds/api/users/username/contacts

Recupero dei contatti utente

Il metodo GetYouTubeContactFeed dell'oggetto YouTubeService può essere utilizzato per recuperare un gdata.youtube.YouTubeContactFeed, costituito da oggetti 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

Aggiunta di un contatto

Per aggiungere un nuovo contatto al feed dei contatti di un utente, utilizza il metodo AddContact dell'oggetto YouTubeService.

new_contact = yt_service.AddContact(contact_username='GoogleDevelopers')

if isinstance(new_contact, gdata.youtube.YouTubeContactEntry)
  print 'New contact added'

Accettare/rifiutare un contatto

Per aggiornare un contatto, utilizza il metodo UpdateContact dell'oggetto YouTubeService. Questo metodo può essere utilizzato per accettare/rifiutare le richieste di contatto e anche per classificare i contatti come "Amico" o "Famiglia". Nell'esempio seguente accettiamo un contatto e ne impostiamo la categoria su "Famiglia":

# 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'

Eliminare un contatto

Per eliminare un contatto, utilizza il metodo DeleteContact dell'oggetto YouTubeService, passando il nome utente del contatto da eliminare.

response = yt_service.DeleteContact(contact_username='gdpython')

if response is True:
  print 'Contact deleted'

Torna all'inizio