def user_token(app_env, user_refresh): """ Provides a user token based on the environment. """ cred = tk.Credentials(*app_env) try: return cred.refresh_user_token(user_refresh) except tk.HTTPError as error: skip_or_fail(tk.HTTPError, 'Error in retrieving user token!', error)
def __init__(self): self.client_id = '04b4767cc75549d7a19f70985c837dcb' self.client_secret = 'cfbd881c349a409ab4794b2547889ce1' self.redirect_uri = 'http://localhost/teste/spotifyTeste.php' self.cred = tk.Credentials(self.client_id, self.client_secret, self.redirect_uri) self.app_token = tk.request_client_token(self.client_id, self.client_secret) self.spotify = tk.Spotify(self.app_token) self.inicialize = False
def app_token(app_env): """ Provides an application token based on the environment. """ cred = tk.Credentials(*app_env) try: return cred.request_client_token() except tk.HTTPError as error: skip_or_fail(tk.HTTPError, 'Error in retrieving application token!', error)
def queue_song(db: Session, song_url: str, spotify_username: str): if spotify_username: conf = tk.config_from_environment() cred = tk.Credentials(*conf) spotify = tk.Spotify() spotify_data = crud.spotify.get(db_session=db, id=spotify_username) token = cred.refresh_user_token(spotify_data.refresh_token) with spotify.token_as(token): uri = "spotify:track:" + song_url.split("/").pop(-1) spotify.playback_queue_add(uri) else: print("ERROR: NO USERNAME - " + str(spotify_username))
def get_spotify_auth() -> UserAuth: """get a User auth object Returns: auth """ conf = (current_app.config['SPOTIFY_CLIENT_ID'], current_app.config['SPOTIFY_CLIENT_SECRET'], current_app.config['SPOTIFY_REDIRECT_URI']) cred = tk.Credentials(*conf) # scopes allow client to read user's name, id, avatar & user's top artists/tracks scope = tk.Scope(tk.scope.user_top_read, tk.scope.user_read_private) auth = tk.UserAuth(cred, scope) return auth
def get_left_playtime(db: Session, spotify_username: str) -> int: if spotify_username: conf = tk.config_from_environment() cred = tk.Credentials(*conf) spotify = tk.Spotify() spotify_data = crud.spotify.get(db_session=db, id=spotify_username) token = cred.refresh_user_token(spotify_data.refresh_token) with spotify.token_as(token): current = spotify.playback_currently_playing() if current: return current.item.duration_ms - current.progress_ms else: return 0 else: return 0
def get_user(self): """ Get a tekore.Spotify object representing a user using the refresh token. :return: None if the refresh token is invalid. """ refresh_token = self.get_refresh_token() if refresh_token: creds = tk.Credentials(client_id=self.client_id) try: new_token = creds.refresh_pkce_token(refresh_token) self.set_refresh_token(new_token.refresh_token) return tk.Spotify(new_token) except tk.BadRequest: self.remove_refresh_token() return None
def __init__(self): """Read the "SPOTIFY" section from the given config path and configure the Credentials object. Parameters ---------- config_path: str Path to the configuration file. """ client_id = config.SPOTIFY_CLIENT_ID client_secret = config.SPOTIFY_CLIENT_SECRET redirect_uri = config.SPOTIFY_REDIRECT_URI logging.info(redirect_uri) self.Credentials = tk.Credentials(client_id, client_secret, redirect_uri, asynchronous=True)
def get_spotify_client(): token_dict = current_token_dict() if token_dict: # If token has expired, refresh it if int(time.time()) > token_dict['expires_at']: app.server.logger.debug('Spotify tokens expired, refreshing...') new_token = tk.Credentials( client_id=client_id, client_secret=client_secret, redirect_uri=redirect_uri).refresh_user_token( token_dict['refresh_token']) # Save to DB save_spotify_token(new_token) # Query the new tokens into a dict token_dict = current_token_dict() client = tk.Spotify(token_dict['access_token']) else: client = tk.Spotify() return client
def check_spotify_login() -> Optional[tuple]: """checks if the person's logged in the token's not expired refreshes token if present Returns: (user, token) """ user = session.get('user', None) token = session.get('token', None) if token: token = pickle.loads(session.get('token', None)) if user is None or token is None: print('either user or token is None') session.pop('user', None) session.pop('token', None) return None, None if token.is_expiring: # get new access token print('token is expiring') conf = (current_app.config['SPOTIFY_CLIENT_ID'], current_app.config['SPOTIFY_CLIENT_SECRET'], current_app.config['SPOTIFY_REDIRECT_URI']) print(user) cred = tk.Credentials(*conf) user_entry = User.query.filter_by(spotify_id=user).first() print(f"user entry: {user_entry}") if user_entry: print(f'user found: {user}') # get user's refresh token from db refresh_token = user_entry.spotify_token print(f'refresh_token: {refresh_token}') if refresh_token: # get new token via refresh token token = cred.refresh_user_token(refresh_token) session['token'] = pickle.dumps(token) return user, token
import tekore as tk from flask import Flask, request, redirect, session, render_template, jsonify, make_response from pprint import pprint from lyricscraper import search_lyrics from config import * conf = (CLIENT_ID, CLIENT_SECRET, REDIRECT_URI) cred = tk.Credentials(*conf) spotify = tk.Spotify() users = {} auths = {} app = Flask(__name__) app.config['SECRET_KEY'] = 'chicken' playbackdata = {} def get_user_data(): user = spotify.current_user() if not len(user.images): pfp = 'https://cdn.pixabay.com/photo/2015/10/05/22/37/blank-profile-picture-973460_960_720.png' else: pfp = user.images[0].url data = { 'pfp': pfp, 'name': user.display_name,
from flask import Flask, request from flask_sqlalchemy import SQLAlchemy import tekore as tk from dotenv import load_dotenv import os app = Flask(__name__) app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False # initialize Spotify cursor load_dotenv() CLIENT_ID = os.getenv('CLIENT_ID') CLIENT_SECRET = os.getenv('CLIENT_SECRET') cred = tk.Credentials(CLIENT_ID, CLIENT_SECRET) access_token = cred.request_client_token() spotify = tk.Spotify(access_token) @app.route('/') def root(): return "You don't want to look at this page" @app.route('/request') def request(): tracks, = spotify.search('5 best songs', types=('track', ), limit=5) result = '' for track in tracks.items: result = result + track.name + '\n' #' by ' + track.artists.name + return result
EXCLUDED_PLAYLISTS = [ 'Discover Weekly', 'New Releases', ] CLIENT_ID = "[REMOVED]" CLIENT_SECRET = "[REMOVED]" REDIRECT_URI = "http://localhost:8888/callback/" REFRESH_TOKEN = "[REMOVED]" # Temporary redirection to stderr for script usability old_stdout = sys.stdout sys.stdout = sys.stderr creds = tk.Credentials( client_id=CLIENT_ID, client_secret=CLIENT_SECRET, redirect_uri=REDIRECT_URI, ) cached_token = tk.refresh_user_token( creds.client_id, creds.client_secret, REFRESH_TOKEN ) # If the token is invalid, prompt the user. user_token = cached_token or tk.prompt_for_user_token( creds.client_id, creds.client_secret, creds.redirect_uri, scope=[
import tekore as tk import os from flask import Flask, Response, session, jsonify from functools import wraps spotify_conf = tk.config_from_environment() spotfy_cred = tk.Credentials(*spotify_conf) spotify = tk.Spotify() user_to_token = {} app = Flask(__name__) # Decorate to ensure user is logged in to spotify def spotify_user_logged_in(f): @wraps(f) def wrap(*args, **kwargs): user = session.get('spotify_user', None) if user is None: # There is no logged in user --> Send to login page return jsonify({ 'redirect': spotfy_cred.user_authorisation_url( scope=tk.scope.playlist_read_private) }) else: user_token: tk.Token = user_to_token.get(user, None) if user_token.is_expiring: user_token = user_token.refresh_token(user_token) user_to_token[user] = user_token return f(*args, **kwargs)