Fin del proyecto + bonus

Curso con un gran nivel que bueno

De los mejores cursos que he visto. ¡Excelente!

Me encanta el Head Banging mega sutil al final. Siento que hice todo el curso para ver eso. Ya puedo morir en paz.

Genial…!! No sabía sobre la función del audio 😃

Excelente clase, queda muy claro el tema de webscrapping, sigo con la sugerencia de que coloquen este curso antes que el de ingenieria de datos!

Obtener el link de la preview.

preview_url=r.json()['items'][0]['preview_url']

Este curso es impoluto, what do you think?

El curso ha sido muy completo, hoy sigue vigente casi en su totalidad.

Que curso tan bueno de verdad

Después de clases como esta es cuando siento que hace falta el botón de ‘me gusta’ en ellas jajaja.
Qué buen profesor.

Que curso tan increíble, así uno se emociona para continuar aprendiendo temas densos y de mucha práctica como estos.

Eso si que no me lo esperaba jajaja , muy bueno

Excelente curso. El programa permite obtener la discografía y las canciones de una discografía escogida

import requests
import base64
import pandas as pd

URL_SPOTYFY = 'https://api.spotify.com/v1'
EP_ARTIST = '/artists/{artist_id}'
URL_SPOTYFY_SRCH = 'https://api.spotify.com/v1/search'
TOKEN = 'https://accounts.spotify.com/api/token'


def encoding():
    ''' Function that encodes the client id and client secret into base64'''
    
    client_id = "CLIENTID:CLIENTSECRET"
    msg_bytes = client_id.encode("UTF-8")
    msg_base64 = base64.b64encode(msg_bytes)
    msg_decode = msg_base64.decode("UTF-8")

    return msg_decode

def get_token():
    ''' Function that updates the token '''

    params = {'grant_type': 'client_credentials'}
    headers = {'Authorization': 'Basic ' + encoding()}
    r_spoty = requests.post(TOKEN, headers=headers, data=params)
    if r_spoty.status_code != 200:
        print('Error en la requests', r_spoty.json())
    return r_spoty.json()["access_token"]
    
def get_artist_id(artist):
    ''' Function that finds the ID for a search artist '''
    token = get_token()
    header = {'Authorization': 'Bearer {}'.format(token)}
    srch_params = {'q' : artist, 'type' : 'artist'}
    get_url = requests.get(URL_SPOTYFY_SRCH, headers=header, params=srch_params)
    df = pd.DataFrame(get_url.json()['artists']['items'])

    artist_id = df.sort_values(by = "popularity", ascending= False).iloc[0]['id']

    return artist_id


def obtener_discografia(artist_id, return_name = False, page_limit = 50, country = None):
    ''' Function that obtains the albums of the desire artist '''
    token = get_token()
    url = f'https://api.spotify.com/v1/artists/{artist_id}/albums'
    header = {'Authorization': 'Bearer {}'.format(token)}
    params = {'limit': page_limit,
              'offset': 0,
              'country': country}
    lista = []
    r = requests.get(url, headers = header, params = params)

    if r.status_code != 200:
        print('Error en la requets')
        return None
    if return_name:

        lista += [(item['id'], item['name'],"Año:{}".format(item['release_date']) ) for item in r.json()['items']]
    else:
        lista += [(item['name'],"Año:{}".format(item['release_date'])) for item in r.json()['items']]


    '''
    
    while r.json()['next']:
        r = requests.get(r.json()['next'], headers = header)
        if return_name:
            lista += [(item['id'], item['name']) for item in r.json()['items']]
        else:
            lista += [item['id'] for item in r.json()['items']]
    
    '''
    return lista

def get_tracks(discografia_id, return_name = False, page_limit = 50, market = None):
    ''' Function that gets all the tracks inside a specific album '''

    album_id = str(input('Ingresa el ID del album que quieras conocer las canciones: '))
    token = get_token()
    url = f'https://api.spotify.com/v1/albums/{album_id}/tracks'
    header = {'Authorization': 'Bearer {}'.format(token)}
    params = {
        'limit': page_limit,
        'offset': 0
    }

    tracks = []
    r = requests.get(url, headers = header, params = params)
    if r.status_code != 200:
        print('Error en la requests')
        return None
    if return_name:
        tracks += [(i['id'], i['name']) for i in r.json()['items']]
    else:
        tracks += [(i['name']) for i in r.json()['items']]
    
    return tracks

def run():

    print('Este programa obtendrá información acerca del artista que desees.')
    artist_name = str(input('Por favor ingresa el nombre del artista: '))
    artist_id = get_artist_id(artist_name)
    discografia = obtener_discografia(artist_id, return_name = True)
    discografia_id = obtener_discografia(artist_id, return_name = True)
    print('Esta es la discografía:')
    counter = 1
    for i in discografia:
        print(counter, i)
        counter += 1

    while True:
        choice = str(input("Deseas conocer las canciones de algún album? y/n: "))
        if choice == "y":
            tracks = get_tracks(discografia_id)
            print('Estas son las canciones del album escogido:')
            counter = 1
            for i in tracks:
                print(counter, i)
                counter += 1
            break

        elif choice == "n":
            print('Cerrando el programa')
            break
        else:
            print('Escribe una opción válida')
        

if __name__ == '__main__':
    run()

No reproduce mi audio 😦

Excelente esta este curso

¡Muy buen curso!

¡Que gran curso! Asombroso esa introducción a scrapear por medio de APIs

Les comparto el script para corra desde la computadora. Para que funcione solamente hay que crear un archivo txt para guardar las llaves de nuestras cuentas.

Necesito un botón de me gusta en este video

Solo encontre previews de tracks con iron maiden XD

Brutal! este curso!

excelente curso

[-]


import requests
[-]


id_im = '6mdiAmATAx73kdxrNrnlao'
[-]


url_base = 'https://api.spotify.com/v1'
[-]


ep_artist = '/artists/{artist_id}'
[-]


url_base+ep_artist.format(artist_id=id_im)
[-]


r = requests.get(url_base+ep_artist.format(artist_id=id_im))
[-]


r.status_code
[-]


r.json()
[-]


token_url = 'https://accounts.spotify.com/api/token'
[-]


params = {'grant_type': 'client_credentials'}
[-]


headers = {'Authorization': 'Basic NDRiN2IzNmVjMTQ1NDY3ZjlhOWVlYWY3ZTQxN2NmOGI6N2I0YWE3YTBlZjQ4NDQwNDhhYjFkMjI0MzBhMWViMWY='}
[-]


r = requests.post(token_url, data=params, headers=headers)
[-]


r.status_code
[-]


r.json()
[-]


token = r.json()['access_token']
token
[-]


header = {"Authorization": "Bearer {}".format(token)}
[-]


r = requests.get(url_base+ep_artist.format(artist_id=id_im), headers=header)
[-]


r.status_code
[-]


r.json()
[-]


url_busqueda = 'https://api.spotify.com/v1/search'
[-]


search_params = {'q': "Iron+Maiden", 'type':'artist', 'market':'AR'}
[-]


busqueda = requests.get(url_busqueda, headers=header, params=search_params)
[-]


busqueda.status_code
[-]


busqueda.json()
[-]


import pandas as pd
[-]


df = pd.DataFrame(busqueda.json()['artists']['items'])
df.head()
[-]


df.sort_values(by='popularity', ascending=False).iloc[0]['id']
[-]


import base64
def get_token(client_id, client_secret):
    encoded = base64.b64encode(bytes(client_id+':'+client_secret, 'utf-8'))
    params = {'grant_type':'client_credentials'}
    header={'Authorization': 'Basic ' + str(encoded, 'utf-8')}
    r = requests.post('https://accounts.spotify.com/api/token', headers=header, data=params)
    if r.status_code != 200:

[-]


client_id = '44b7b36ec145467f9a9eeaf7e417cf8b'
client_secret = '7b4aa7a0ef4844048ab1d22430a1eb1f'
[-]


token = get_token(client_id, client_secret)
[-]


header = {"Authorization": "Bearer {}".format(token)}
[-]


id_im
[-]


artist_im = requests.get(url_base+ep_artist.format(artist_id=id_im), headers=header)
artist_im.status_code
[-]


artist_im.json()
[-]


params = {'country': 'AR'}
[-]


albums_im = requests.get(url_base+ep_artist.format(artist_id=id_im)+'/albums', headers=header, params=params)
albums_im.status_code
[-]


albums_im.json()['items']
[-]


[(album['id'], album['name']) for album in albums_im.json()['items']]
[-]


bnw_id = '1hDF0QPIHVTnSJtxyQVguB'
[-]


album_ep = '/albums/{album_id}'
[-]


album_params = {'market':'AR'}
[-]


bnw = requests.get(url_base+album_ep.format(album_id=bnw_id)+'/tracks', headers=header, params=album_params)
bnw
[-]


bnw.json()
[-]


bnw.json()['items']
[-]


[(track['id'], track['name']) for track in bnw.json()['items']]
[-]


def obtener_discografia(artist_id, token, return_name=False, page_limit=50, country=None):
    url = f'https://api.spotify.com/v1/artists/{artist_id}/albums'
    header = {'Authorization': f'Bearer {token}'}
    params = {'limit': page_limit, 
              'offset': 0,
              'country': country}
    lista = []
    r = requests.get(url, params=params, headers=header)

[-]


def obtener_tracks(album_id, token, return_name=False, page_limit=50, market=None):
    url=f'https://api.spotify.com/v1/albums/{album_id}/tracks'
    header = {'Authorization': f'Bearer {token}'}
    params = {'limit': page_limit, 
              'offset': 0,
              'market': market}
    lista = []
    r = requests.get(url, params=params, headers=header)

Utilizando estas funciones podemos obtener todos las canciones que tiene un artista publicadas en Spotify

[-]


for album in obtener_discografia(id_im, token, return_name=True, country='AR'):
    print(album[1])
    for track in obtener_tracks(album[0], token, return_name=True, market='AR'):
        print('\t', track[1])
[-]


preview_url = 'https://p.scdn.co/mp3-preview/647a53055a6f5d012ed238d87c3191df1ed5aff9?cid=44b7b36ec145467f9a9eeaf7e417cf8b'
[-]


preview = requests.get(preview_url)
preview.status_code
[-]


preview.content
[-]


import IPython.display as ipd
[-]


ipd.Audio(preview.content)
[-]

Alguien, ¿Alguna vez a utilizado la Api de Google Gmail?, Quisiera descargar todos los archivos adjuntos de mi bandeja de entrada.
Excelente curso !!!

Espectacular!!! se pueden hacer muchas cosas con ese tipo de funcionalidades y permisos de la API

Que curso tan completo !! , muchas gracias …

Bacanisimooooo

Encantado con este curso! Me costó superar esta etapa pero cuando finalmente la comprendí quedé muy satisfecho

Excelente, que BONUS O.o

Eso del audio no me imaginaba que existía. =D

Esa función de audio probablemente valió todo el curso!!!

jajaja

Está bien perrona

Qué interesante curso. Qué gran forma de hacer interesante el introducirse al manejo de API’s

Madre mía con este curso, Genial!

Ay! Genial el bonus!!! … Lo mejor fue el bailecito del profesor 😅😅😅

Me gustó mucho el proyecto. Ese bonus estuvo genial.

que buen final de clase con canción de Maiden incluida ImI

Tremendo curso este, excelente.

Excelente!

Agrupe el codigo en funciones y exporte 3 csv , para la info del artista , discografia y todos los tracks del artista.

import requests
import base64
import pandas as pd
import math

def main(client_id,client_secret , str_artist):
    token = get_token(client_id,client_secret)
    header = {'Authorization': f'Bearer {token}'};
    artist_id = get_artist(str_artist,header)
    list_discography = get_discography(artist_id,header);
    get_tracks(list_discography, header)


def get_tracks(list_discography , header):
    list_tracks = []
    for discography in list_discography:
        discography_id = discography['id']
        url_tracks = f'https://api.spotify.com/v1/albums/{discography_id}/tracks'
        params = {'market': 'PE', 'offset': 0, 'limit': 50};
        tracks = requests.get(url_tracks, headers=header, params=params)
        tracks = tracks.json()['items']
        for track in tracks:
            track['discography_id']= discography_id
            list_tracks.append(track)
    tracks_data = pd.DataFrame(list_tracks)
    tracks_data.to_csv('tracks.csv')

    return list_tracks


def get_artist(str_artist,header):
    url_busqueda = "https://api.spotify.com/v1/search";
    search_params = {'q': f'{str_artist}', 'type': 'artist', 'market': 'US'};
    busqueda = requests.get(url_busqueda, headers=header, params=search_params);
    if busqueda.status_code != 200:
        print('Error en la request ', busqueda.json())
        return None
    resultado = busqueda.json()
    artists = resultado['artists']['items'] # artistas
    artists_data = pd.DataFrame(artists)
    # artista
    artist = artists_data.sort_values(by="popularity", ascending=False).iloc[0]
    artist.to_csv('artist.csv')
    artist_id = artist['id']

    return artist_id

def get_discography(artist_id ,header,offset = 0,limit = 30):
    list_discography= [];
    url_discography = f'https://api.spotify.com/v1/artists/{artist_id}/albums';
    albums = requests.get(url_discography, headers=header)
    total = albums.json()['total']
    pages = math.ceil(total/limit)
    for i in range (0,pages):
        params = {'country': 'PE', 'offset': offset, 'limit': limit};
        albums = requests.get(url_discography, headers=header, params=params)
        if albums.status_code != 200:
            print('Error en la request ', albums.json())
            return None
        albums = albums.json()['items']
        for album in albums:
            list_discography.append(album)
        offset = offset + limit
    discography = pd.DataFrame(list_discography)
    discography.to_csv('discography.csv')
    return list_discography;


def get_token(client_id,client_secret):
    client_str = f'{client_id}:{client_secret}'
    # codificando en bytes
    client_encode = base64.b64encode(client_str.encode("utf-8"))
    # codificando en string
    client_encode = str(client_encode, "utf-8")
    token_url = 'https://accounts.spotify.com/api/token'
    params = {'grant_type': 'client_credentials'}
    headers = {'Authorization': f'Basic {client_encode}'}
    p = requests.post(token_url, data=params, headers=headers)
    if p.status_code != 200:
        print('Error en la request ', p.json())
        return None
    token = p.json()['access_token']
    return token

if __name__ == "__main__":
    client_id = ' tu_clientid'
    client_secret = ' tuclient_secret'
    str_artist = 'oasis'
    main(client_id , client_secret , str_artist);

buena clase