API de datos de Youtube para manejar videos | Conjunto-3

Requisito previo: API de datos de Youtube para manejar videos | Conjunto-1 , Conjunto-2
Antes de continuar, primero vea cómo obtener una lista de Categorías de video válidas, para determinar en qué categoría colocar un video. Para el ejemplo, hemos utilizado el valor «IN» para el parámetro regionCode. Puede utilizar cualquier otro valor. Solo los ID de categoría que tienen un parámetro asignable como valor «Verdadero» se pueden usar en la inserción o actualización del video.
Analicemos cómo insertar un video en la cuenta de youtube de un usuario autorizado. 
Encuentre categorías de video válidas: 

# importing library
from apiclient.discovery import build
 
# Arguments that need to passed
# to the build function
DEVELOPER_KEY = "API_key"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"
 
# creating Youtube Resource Object
youtube_object = build(YOUTUBE_API_SERVICE_NAME,
                            YOUTUBE_API_VERSION,
                   developerKey = DEVELOPER_KEY)
     
def youtube_video_categories():
     
    # calling the videoCategory.list method
    # to retrieve youtube video categories result
    video_category = youtube_object.videoCategories(
       ).list(part ='snippet', regionCode ='IN').execute()
     
    # extracting the results
    # from video_category response
    results = video_category.get("items", [])
 
    # empty list to store video category metadata
    videos_categories = []
     
    # extracting required info
    # from each result object
    for result in results:
         
        # video_categories result object
        videos_categories.append("% s, (% s % s)"
                   %(result["id"],
                   result["snippet"]["title"],
                   result["snippet"]["assignable"]))
 
    print ("Video_Category_Id Catgeory_Name     Assignable :\n",
                          "\n".join(videos_categories), "\n")
     
if __name__ == "__main__":
    youtube_video_categories()

Producción: 

Dado que insertar un video en la cuenta de un usuario autorizado requiere la autorización del usuario, crearemos el tipo de credencial OAuth para este ejemplo. Siga los pasos a continuación para generar una identificación de cliente y una clave secreta. 

1. Vaya a Google Developers Console y haga clic en Iniciar sesión en la esquina superior derecha de la página. Inicie sesión con las credenciales de la cuenta de Google válida. Si no tiene una cuenta de Google, primero configure una cuenta y luego use los detalles para iniciar sesión en la página de inicio de Google Developers. 
    
2. Ahora navegue hasta el panel del desarrollador y cree un nuevo proyecto.
3. Haga clic en la opción Habilitar API.
4. En el campo de búsqueda, busque API de datos de Youtube y seleccione la opción API de datos de Youtube que aparece en la lista desplegable.

1. Será redirigido a una pantalla que dice información sobre la API de datos de Youtube, junto con dos opciones: HABILITAR y PROBAR API.
2. Haga clic en la opción HABILITAR para comenzar con la API.
3. En la barra lateral debajo de API y servicios, seleccione Credenciales.
4. En la parte superior de la página, seleccione la pestaña de la pantalla de consentimiento de OAuth. Seleccione una dirección de correo electrónico, ingrese un nombre de producto si aún no lo ha establecido y haga clic en el botón Guardar.
5. En la pestaña Credenciales, seleccione la lista desplegable Crear credenciales y elija ID de cliente de OAuth. OAuth generalmente se usa cuando se requiere autorización, como en el caso de recuperar videos que le gustan a un usuario.
6. Seleccione el tipo de aplicación Otro, ingrese el nombre «YouTube Data API Myvideos» y haga clic en el botón Crear.
7. Haga clic en Aceptar.
8. Haga clic en el botón Descargar a la derecha de la identificación del cliente para descargar el archivo JSON.
9. Guarde y cambie el nombre del archivo como client_secret.json y muévalo al directorio de trabajo.

Instale bibliotecas adicionales usando el comando pip:  

pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2

Hemos descargado un video de muestra: Aprenda ABC para mostrar cómo funciona la carga. El id, snippet.title y snippet.categoryId son las propiedades obligatorias, todas las demás son opcionales.
Insertar un video: este ejemplo muestra cómo cargar un video en la cuenta del usuario autorizado. La carga de videos se rige por las siguientes restricciones: 

1. El archivo puede tener un tamaño máximo de 128 MB
2. Los tipos MIME de medios aceptables son solo video/*, application/octet-stream 

# importing necessary libraries
import os
import urllib.request, urllib.parse, urllib.error
import http.client
import urllib.request
import urllib.error
import http.client
import httplib2
import random
import time
import google.oauth2.credentials
import google_auth_oauthlib.flow
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from google_auth_oauthlib.flow import InstalledAppFlow
from apiclient.http import MediaFileUpload
 
# The CLIENT_SECRETS_FILE variable
# specifies the name of a file that
# contains client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"
 
# This scope allows for full read /
# write access to the authenticated
# user's account and requires requests
# to use an SSL connection.
SCOPES = ['https://www.googleapis.com/auth/youtube.force-ssl']
API_SERVICE_NAME = 'youtube'
API_VERSION = 'v3'
 
def get_authenticated_service():
flow = InstalledAppFlow.from_client_secrets_file(
                     CLIENT_SECRETS_FILE, SCOPES)
                     
credentials = flow.run_console()
return build(API_SERVICE_NAME, API_VERSION,
                credentials = credentials)
 
# Here we are telling HTTP Transport
# Library not to retry the video upload.
httplib2.RETRIES = 1
 
# MAX_RETRIES specifies the maximum number
# of retries that can done before giving up.
MAX_RETRIES = 10
 
# Always retry when these exceptions are raised.
RETRIABLE_EXCEPTIONS = (httplib2.HttpLib2Error, IOError,
                        http.client.NotConnected,
                        http.client.IncompleteRead,
                        http.client.ImproperConnectionState,
                        http.client.CannotSendRequest,
                        http.client.CannotSendHeader,
                        http.client.ResponseNotReady,
                        http.client.BadStatusLine)
 
# Always retry when an apiclient.errors.HttpError
# with one of these status codes is raised.
RETRIABLE_STATUS_CODES = [500, 502, 503, 504]
 
# This method implements an exponential
# backoff strategy to resume a failed upload.
def resumable_upload(request, resource, method):
response = None
error = None
retry = 0
 
while response is None:
    try:
         
    print("Uploading the file...")
    status, response = request.next_chunk()
     
    if response is not None:
         
        if method == 'insert' and 'id' in response:
            print(response)
        elif method != 'insert' or 'id' not in response:
            print(response)
        else:
            exit("The file upload failed with an\
            unexpected response: % s" % response)
             
    except HttpError as e:
    if e.resp.status in RETRIABLE_STATUS_CODES:
        error = "A retriable HTTP error % d occurred:\n % s"
                                % (e.resp.status, e.content)
    else:
        raise
    except RETRIABLE_EXCEPTIONS as e:
        error = "A retriable error occurred: % s" % e
 
    if error is not None:
        print(error)
    retry += 1
     
    if retry > MAX_RETRIES:
        exit("No longer attempting to retry.")
 
    max_sleep = 2 ** retry
    sleep_seconds = random.random() * max_sleep
     
    print(("Sleeping % f seconds and then retrying..."
                                    % sleep_seconds))
    time.sleep(sleep_seconds)
     
def print_response(response):
    print(response)
 
# Build a resource based on a list of
# properties given as key-value pairs.
# Leave properties with empty values
# out of the inserted resource.
def build_resource(properties):
     
    resource = {}
    for p in properties:
         
        # Given a key like "snippet.title", split into
        # "snippet" and "title", where
        # "snippet" will be an object and "title"
        # will be a property in that object.
        prop_array = p.split('.')
        ref = resource
        for pa in range(0, len(prop_array)):
        is_array = False
        key = prop_array[pa]
     
        # For properties that have array values,
        # convert a name like "snippet.tags[]" to
        # snippet.tags, and set a flag to handle
        # the value as an array.
        if key[-2:] == '[]':
            key = key[0:len(key)-2:]
            is_array = True
     
        if pa == (len(prop_array) - 1):
             
            # Leave properties without values
            # out of inserted resource.
            if properties[p]:
                if is_array:
                    ref[key] = properties[p].split(', ')
                else:
                    ref[key] = properties[p]
                     
        elif key not in ref:
            # For example, the property is "snippet.title",
            # but the resource does not yet have a "snippet"
            # object. Create the snippet object here.
            # Setting "ref = ref[key]" means that in the
            # next time through the "for pa in range ..." loop,
            # we will be setting a property in the
            # resource's "snippet" object.
            ref[key] = {}
            ref = ref[key]
        else:
            # For example, the property is "snippet.description",
            # and the resource already has a "snippet" object.
            ref = ref[key]
    return resource
 
# Remove keyword arguments that are not set
def remove_empty_kwargs(**kwargs):
    good_kwargs = {}
     
    if kwargs is not None:
        for key, value in list(kwargs.items()):
            if value:
                good_kwargs[key] = value
    return good_kwargs
 
def videos_insert(client, properties, media_file, **kwargs):
    resource = build_resource(properties)
    kwargs = remove_empty_kwargs(**kwargs)
    request = client.videos().insert(body = resource,
               media_body = MediaFileUpload(media_file,
         chunksize =-1, resumable = True), **kwargs)
     
     
    return resumable_upload(request, 'video', 'insert')
 
 
if __name__ == '__main__':
     
    # When running locally, disable OAuthlib's
    # HTTPs verification. When running in production
    # * do not * leave this option enabled.
    os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
    client = get_authenticated_service()
    media_file = 'videoplayback.3gp'
     
    if not os.path.exists(media_file):
        exit('Please specify the complete valid file location.')
     
    videos_insert(client,
        {'snippet.categoryId': '27',
        'snippet.defaultLanguage': '',
        'snippet.description': 'Sample Learn ABC Video',
        'snippet.tags[]': '',
        'snippet.title': 'Sample Test video upload',
        'status.embeddable': '',
        'status.license': '',
        'status.privacyStatus': 'private',
        'status.publicStatsViewable': ''},
        media_file,
        part ='snippet, status')

Salida:
Al ejecutar el código te pedirá el código de autorización. Para obtener el código, debe seguir el enlace mencionado en la pantalla del símbolo del sistema sobre la línea: Ingrese el código de autorización. 

Ahora siga el enlace y copie y pegue el código de autorización que obtendrá al otorgar el permiso. 

Ahora, como puede ver en la cuenta usada, muestra que el video está cargado. 

Referencias: 

• https://developers.google.com/youtube/v3/docs/videos/insert
• https://developers.google.com/youtube/v3/docs/videoCategories/list