Exemple #1
0
    def get(self, request):
        now = datetime.now()

        current_time = now.strftime("%H:%M:%S")
        print("Current Time =", current_time)

        new_cache = str(uuid.uuid4())
        print('New UUID: ' + new_cache)

        try:
            cache = request.session['cache_id']
            print('cache exists')
        except KeyError:
            print('new cache')
            request.session['cache_id'] = new_cache
            cache = request.session['cache_id']

        cache_path = spotify_cache_folder + cache
        print('cache_path: ' + cache_path)

        if os.path.exists(cache_path):
            print('cache file exists')
        else:
            print('cache file does not exist')

        scope = 'user-read-email, user-top-read'

        auth_manager = SpotifyOAuth(scope=scope,
                                    cache_path=cache_path,
                                    show_dialog=True)

        code = self.request.query_params.get('code')
        print(code)
        if code:
            print('code: ' + code)
            auth_manager.get_access_token(code=code)
            print('redirecting..')
            redirect_url = prod_url + '/success.html'
            return HttpResponseRedirect(redirect_to=redirect_url)

        if not auth_manager.get_cached_token():
            url = {'url': auth_manager.get_authorize_url()}
            serializer = UrlSerializer(url)

            return Response(serializer.data, status=status.HTTP_200_OK)
        else:
            url = {'url': auth_manager.get_authorize_url()}
            serializer = UrlSerializer(url)

            return Response(serializer.data, status=status.HTTP_200_OK)

        return Response("ERROR", status=status.HTTP_400_BAD_REQUEST)
Exemple #2
0
def spot_login(request):
    if 'cache_id' not in request.session:
        #create random cache
        request.session['cache_id'] = get_random_alphanumeric_string(14)

    auth_manager = SpotifyOAuth(client_id=client_id,
                                client_secret=client_secret,
                                redirect_uri='http://localhost:8000/login/',
                                scope=scope,
                                cache_path=get_cache_path(
                                    request.session['cache_id']),
                                show_dialog=True)
    if 'code' in request.GET:
        print('Getting code')
        token = auth_manager.get_access_token(request.GET.get('code'))
        # print(token)
        return redirect('/')
    print(f'token: {auth_manager.get_cached_token()}')
    if not auth_manager.get_cached_token():
        print('Checking for Cache')
        url = auth_manager.get_authorize_url()
        return redirect(url)
    spotify_object = spotipy.Spotify(auth_manager=auth_manager)
    print('redirecting to login')
    # return HttpResponse(f'<h2><a href="{url}">Sign in</a></h2>')
    # spot = spotipy.Spotify(client_credentials_manager=SpotifyClientCredentials(client_id= client_id, client_secret=client_secret))
    return redirect('Login')
Exemple #3
0
    def __init__(self, args, key_path):
        """ Spotify API Constructor
        :param client_id: client id provided by Spotify
        :param client_secret: client secret provided by Spotify
        :param redirect_uri: redirect uri provided by Spotify
        :param sp: spotipy API handler.
        """
        self.save_location = args.save_location
        self.song_format = args.format
        self.overwrite = args.overwrite
        self.verbose = args.verbose
        self.username = args.username
        self.scope = "playlist-read-private"

        with open(key_path) as json_file:
            data = json.load(json_file)
            self.client_id = data['SPOTIPY_CLIENT_ID']
            self.client_secret = data['SPOTIPY_CLIENT_SECRET']
            self.redirect_uri = data['SPOTIPY_REDIRECT_URI']
            sp_oauth = SpotifyOAuth(scope=self.scope,
                                    username=self.username,
                                    client_id=self.client_id,
                                    client_secret=self.client_secret,
                                    redirect_uri=self.redirect_uri)
            self.auth_url = sp_oauth.get_authorize_url()
            self.last_auth_url = " "
            self.sp = spotipy.Spotify(auth_manager=sp_oauth)
Exemple #4
0
def index(request):
    if not request.session.get('uuid'):
        request.session['uuid'] = str(uuid.uuid4())

    auth_manager = SpotifyOAuth(
        scope='user-read-currently-playing',
        cache_path=session_cache_path(request.session),
        show_dialog=True)
    if request.method == 'GET':
        if request.GET.get("code"):
            # Step 3. Being redirected from Spotify auth page
            request.session['token_info'] = auth_manager.get_access_token(
                request.GET.get("code"))
            return redirect(index)

    if not auth_manager.get_cached_token():
        auth_url = auth_manager.get_authorize_url()
        return HttpResponse(f'<h2><a href="{auth_url}">Sign in</a></h2>')

    if auth_manager.is_token_expired(request.session.get('token_info')):
        request.session['token_info'] = auth_manager.refresh_access_token(
            request.session.get('token_info'))

    spotify = Spotify(auth_manager=auth_manager)
    request.session['username'] = spotify.me()['id']
    request.session['token'] = auth_manager.get_cached_token()
    return redirect(visview, request.session.get('username'))
Exemple #5
0
    def spotifyLogin():

        cache_handler = spotipy.cache_handler.CacheFileHandler(
            cache_path='data/.cache')
        auth_manager = SpotifyOAuth(client_id=os.environ["CLIENT_ID"],
                                    client_secret=os.environ["CLIENT_SECRET"],
                                    redirect_uri=request.host_url + "login",
                                    scope="user-modify-playback-state "
                                    "user-read-playback-state "
                                    "user-read-recently-played",
                                    cache_handler=cache_handler)
        if request.args.get("code"):
            # Step 3. Being redirected from Spotify auth page
            auth_manager.get_access_token(request.args.get("code"))
            loggingWrite("Logged In", "System")
            print("Need to login Redirecting")
            return redirect('/')
        if not auth_manager.validate_token(cache_handler.get_cached_token()):
            # Step 2. Display sign in link when no token
            auth_url = auth_manager.get_authorize_url()
            print("Need to login Redirecting")
            print("Redirect URL is: " + request.host_url + "login")
            loggingWrite("REDIRECT URL is: " + request.host_url + "login",
                         "System")
            loggingWrite("Need to login Redirecting", "System")
            return redirect(auth_url)
        loggingWrite("Already Login Passing on", "System")
        return redirect('/')
Exemple #6
0
async def read_login_url(
        spotipy_oauth: SpotifyOAuth = Depends(get_spotipy_oauth)):
    """
    Get login url for SpotifyApi
    """
    url = spotipy_oauth.get_authorize_url()
    return LoginUrl(login_url=url)
Exemple #7
0
class SpotifyAuthenticator:
    def __init__(self):
        self.scopes = 'user-read-private user-read-email playlist-read-private playlist-read-collaborative ' \
                      'user-top-read user-library-read'
        self.sp_oauth = None
        self.sp = None
        self._init_oauth(
            "0.0.0.0"
        )  # init with stand in redirect_uri so update_token_info can be called

    def _init_oauth(self, redirect_uri):
        self.sp_oauth = SpotifyOAuth(
            scope=self.scopes,
            client_id=os.getenv("SPOTIFY_CLIENT_ID"),
            client_secret=os.getenv("SPOTIFY_CLIENT_SECRET"),
            redirect_uri=redirect_uri)
        return self.sp_oauth.get_authorize_url()

    def initialize_auth(self, request):
        redirect_uri = request.build_absolute_uri('/') + 'login'
        return HttpResponseRedirect(self._init_oauth(redirect_uri))

    def get_initial_token_info(self, initial_token):
        return self.sp_oauth.get_access_token(initial_token)

    def update_token_info(self, token_info):
        if self.sp_oauth.is_token_expired(token_info):
            return self.sp_oauth.refresh_access_token(
                token_info["refresh_token"])
        return token_info

    def connect_user(self, token_info):
        self.sp = Spotify(token_info['access_token'])
        return self.sp.current_user()
Exemple #8
0
    def test_get_authorize_url_shows_dialog_when_requested(self):
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR")

        url = oauth.get_authorize_url(show_dialog=True)

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertTrue(parsed_qs['show_dialog'])
Exemple #9
0
def login_user(request):
    spotify_oauth = SpotifyOAuth(
        settings.SPOTIPY_CLIENT_ID,
        settings.SPOTIPY_CLIENT_SECRET,
        settings.SPOTIPY_REDIRECT_URI,
        scope='user-read-email playlist-modify-public user-follow-modify')
    authorize_url = spotify_oauth.get_authorize_url()
    return HttpResponseRedirect(authorize_url)
Exemple #10
0
    def test_get_authorize_url_does_not_show_dialog_by_default(self):
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR")

        url = oauth.get_authorize_url()

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertNotIn('show_dialog', parsed_qs)
Exemple #11
0
    def test_get_authorize_url_shows_dialog_when_requested(self):
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR")

        url = oauth.get_authorize_url(show_dialog=True)

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertTrue(parsed_qs['show_dialog'])
Exemple #12
0
    def test_get_authorize_url_does_not_show_dialog_by_default(self):
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR")

        url = oauth.get_authorize_url()

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertNotIn('show_dialog', parsed_qs)
Exemple #13
0
    def test_get_authorize_url_passes_state_from_func_call(self):
        state = "STATE"
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR", "NOT STATE")

        url = oauth.get_authorize_url(state=state)

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertEqual(parsed_qs['state'][0], state)
Exemple #14
0
    def test_get_authorize_url_passes_state_from_func_call(self):
        state = "STATE"
        oauth = SpotifyOAuth("CLID", "CLISEC", "REDIR", "NOT STATE")

        url = oauth.get_authorize_url(state=state)

        parsed_url = urllibparse.urlparse(url)
        parsed_qs = urllibparse.parse_qs(parsed_url.query)
        self.assertEqual(parsed_qs['state'][0], state)
Exemple #15
0
def login():
    global state
    global oauth
    state = generate_random_string(RANDOM_STRING_LENGTH)
    oauth = SpotifyOAuth(
        state=state,
        scope=scope,
        cache_path='./token_cache'
    )
    return redirect(oauth.get_authorize_url())
Exemple #16
0
def verify():
    auth = SpotifyOAuth(client_id=cid,
                        client_secret=secret,
                        redirect_uri=uri,
                        cache_path=cache,
                        scope=scope)

    auth_url = auth.get_authorize_url()

    return redirect(auth_url)
Exemple #17
0
def login():
    # Obtém as credenciais da aplicação cliente (cadastrada no dashboard do Spotify Developers)
    cred = SpotifyClientCredentials()

    # Obtém o objeto de autenticação OAuth2
    url = SpotifyOAuth(cred.client_id,
                       cred.client_secret,
                       environ['SPOTIPY_REDIRECT_URI'],
                       scope=scope)

    # Obtém a URL de autorização do Spotify e redireciona o usuário para esta
    return redirect(url.get_authorize_url())
Exemple #18
0
def login():
    """
    Routes user to unique authorization URL. Redirects back to app via redirect_uri
    """
    auth_manager = SpotifyOAuth(
        client_id=app.config["SPOTIPY_CLIENT_ID"],
        client_secret=app.config["SPOTIPY_CLIENT_SECRET"],
        redirect_uri=app.config["SPOTIPY_REDIRECT_URI"],
        scope=app.config["SCOPE"])
    url = auth_manager.get_authorize_url()

    # Code is the result of the redirect
    return redirect(url, code=302)
class SpotifyActions:
    def __init__(self, client_id, client_secret, scope, redirect_uri):
        self.sp_oauth = SpotifyOAuth(client_id=client_id,
                                     client_secret=client_secret,
                                     redirect_uri=redirect_uri,
                                     scope=scope)

    @staticmethod
    def create_playlist(party):
        sp = party.spotify
        return sp.user_playlist_create(user=party.user, name=party.party_name)

    @staticmethod
    def add_song_to_playlist(party, song_id):
        sp = party.spotify
        sp.user_playlist_add_tracks(user=party.user,
                                    playlist_id=party.playlist_id,
                                    tracks=[song_id])

    def get_authorize_url(self):
        return self.sp_oauth.get_authorize_url()

    def get_access_token(self, code):
        return self.sp_oauth.get_access_token(code)["access_token"]

    @staticmethod
    def find_song(party, song_name, artist_name=None):
        sp = party.spotify
        search_results = sp.search(song_name)
        if artist_name:
            song_dict = list(
                filter(
                    lambda x: x['album']['artists'][0]['name'] == artist_name,
                    search_results['tracks']['items']))[0]
            return song_dict['id']
        return search_results['tracks']["items"][0]["id"]

    @staticmethod
    def parse_link_to_uri(link):
        start = link.rindex('/') + 1
        stop = link.index('?')
        track = link[start:stop]
        spotify_uri = "spotify:track:{}".format(track)
        return spotify_uri
Exemple #20
0
def auth(request):
    if not request.session.get('uuid'):
        request.session['uuid'] = str(uuid.uuid4())

    auth_manager = SpotifyOAuth(
        scope='user-read-currently-playing user-top-read',
        cache_path=session_cache_path(request.session),
        show_dialog=True)

    if request.GET.get('code'):
        auth_manager.get_access_token(request.GET.get('code'))
        return redirect('index')

    if not auth_manager.get_cached_token():
        auth_url = auth_manager.get_authorize_url()
        return Response({"auth_url": auth_url})

    spotify = Spotify(auth_manager=auth_manager)
    return Response({"name": spotify.me()["display_name"]})
def auth_page():
    # hacky way to store token in database
    # 1. use a MemoryCacheHandler to temporarily store token in ram
    # 2. use the api to retrieve the username
    # 3. transfer the token data from MemoryCacheHandler to DatabaseCacheHandler
    #    with username attached to the token
    tokenData = MemoryCacheHandler()
    oauth = SpotifyOAuth(
        scope=constant.SCOPE,
        cache_handler=tokenData,
        client_id=config.client_id,
        client_secret=config.client_secret,
        redirect_uri=config.redirect_uri + "/login"
    )
    # ask the user for authorization here
    if ("code" not in request.args):
        return redirect(oauth.get_authorize_url())
    else:
        # TODO: backend logic probably doesn't belong here
        # we got the code here, use it to create a token
        print("Response Code: " + request.args["code"])
        try:
            # called for no reason other than to trigger a save_token_to_cache()
            # call inside the cache handler
            oauth.get_access_token(request.args["code"], as_dict=False)
        except SpotifyOauthError:
            return render_template("auth_fail.html", url=config.redirect_uri)

        # hacky database caching
        client = spotipy.Spotify(auth_manager=oauth)
        user = client.me()['id']
        # create and store user in the Users table
        database.add_user(client.me()['id'])
        # transfer data from MemoryCacheHandler to DatabaseCacheHandler
        db = DatabaseCacheHandler(user)
        db.save_token_to_cache(tokenData.get_cached_token())

        # create new playlist for user
        update_playlist(client)

        return render_template("auth_success.html")
    return render_template("auth_success.html")
Exemple #22
0
def authorize_application(token_path, scopes):

    cached_data_path = os.path.join(os.path.split(__file__)[0], 'cached_data')
    if not os.path.isdir(cached_data_path):
        os.mkdir(cached_data_path)

    oauth = SpotifyOAuth(CLIENT_ID,
                         APP_SECRET,
                         REDIRECT_URI,
                         cache_path=token_path,
                         scope=scopes)
    authorization_url = oauth.get_authorize_url()

    webbrowser.open(authorization_url)

    authorization_response = input("Enter the full callback URL: ")
    code = oauth.parse_response_code(authorization_response)
    token = oauth.get_access_token(code)
    print("Authorization was successful!")
    return token
Exemple #23
0
def get_token(username, client_id, client_secret, redirect_uri, scope):
    sp_oauth = SpotifyOAuth(username=username,
                            client_id=client_id,
                            client_secret=client_secret,
                            redirect_uri=redirect_uri,
                            scope=scope,
                            cache_path=getenv("HOME") + "/.cache/soapify-" +
                            username)

    token_info = sp_oauth.get_cached_token()
    token = None
    if not token_info:
        auth_url = sp_oauth.get_authorize_url()
        webbrowser.open(auth_url)
        pool = ThreadPool(processes=1)
        code = pool.apply_async(CallbackServer).get().get_token()
        token_info = sp_oauth.get_access_token(code)
    if token_info:
        token = token_info['access_token']
    return token
Exemple #24
0
def login():
    if request.method == 'POST':
        try:
            sp_oauth = SpotifyOAuth(client_id=client_id,
                                    client_secret=client_secret,
                                    redirect_uri=REDIRECT_URI,
                                    scope=scope,
                                    cache_path=session_cache_path(),
                                    show_dialog=True)

            # So if we have a token(which means we are logged in)
            # and the login button is clicked then we need to sign out

            if not sp_oauth.get_cached_token():
                # Authorization Code Flow Step 1
                auth_url = sp_oauth.get_authorize_url()
                return redirect(auth_url)
            return redirect("/sign_out")
        except TypeError:
            pass
    return redirect("spotify_login")
Exemple #25
0
    def get(self, request):
        new_cache = str(uuid.uuid4())

        cache = request.session.get('cache_id', new_cache)

        cache_path = spotify_cache_folder + cache
        print('cache_path:' + cache_path)

        scope = 'user-read-email, user-top-read'

        auth_manager = SpotifyOAuth(scope=scope,
                                    cache_path=cache_path,
                                    show_dialog=True)

        code = self.request.query_params.get('code')
        if code:
            print('code: ' + code)
            auth_manager.get_access_token(code=code)
            print('redirecting..')
            return HttpResponseRedirect(
                redirect_to='http://localhost:8080/index3.html')

        if not auth_manager.get_cached_token():
            auth_url = auth_manager.get_authorize_url()

            data = f'<h2><a href="{auth_url}">Sign in</a></h2>'
            return Response(data)

        spotify = spotipy.Spotify(auth_manager=auth_manager)
        user_result = spotify.current_user()

        display_name = user_result['display_name']
        client_url = 'https://chopshop-client.herokuapp.com/'

        data = '<html><body><h1>Hello ' + display_name + '. You are connected to Spotify :) </h1>'
        data += f'<h2><a href="{client_url}">Now click here!</a></h2>'
        data += '</body></html>'

        return Response(data)
Exemple #26
0
def authenticate(n_clicks, username):
    if n_clicks:
        # add spotify username to .env file if it's not already there
        if not os.getenv('SPOTIFY_USERNAME'):
            f = open('.env', 'a')
            f.write('\nSPOTIFY_USERNAME={}'.format(username))
            f.close()

        load_dotenv()

        # Get clientID and clientSecret from .env file
        client_id = os.getenv("CLIENT_ID")
        client_secret = os.getenv("CLIENT_SECRET")
        user_id = os.getenv("SPOTIFY_USERNAME")

        scope = 'user-read-private user-read-playback-state user-modify-playback-state user-top-read user-library-read playlist-modify-public playlist-modify-private'

        auth = SpotifyOAuth(client_id,
                            client_secret,
                            'http://localhost:8050/callback',
                            cache_path=f".cache-{user_id}",
                            scope=scope)
        return None, auth.get_authorize_url()
Exemple #27
0
def spotify_login(request):
    assert isinstance(request, HttpRequest)

    scope = "user-read-private user-read-birthdate user-read-recently-played user-read-playback-state user-follow-read playlist-read-collaborative user-top-read"
    client_credentials_manager = SpotifyOAuth(
        client_id='e31546dc73154ddaab16538209d8526e',
        client_secret='f12c6904e491409bbc5834aaa86d14c0',
        scope=scope,
        redirect_uri='http://localhost:8000/spotify_login/')
    spotipy.Spotify(client_credentials_manager=client_credentials_manager)
    authorize_url = client_credentials_manager.get_authorize_url()

    if request.method == 'GET':
        if "code" in request.GET:
            code = request.GET.get("code")
            token = client_credentials_manager.get_access_token(code)
            token = token["access_token"]

            response = HttpResponseRedirect("/")
            response.set_cookie("SpotifyToken", token)

            return response
        else:
            return HttpResponseRedirect(authorize_url)
Exemple #28
0
def spotify_connect(session_id, code=''):
    '''
    Connect to the Spotify API using the token associated with the given session
    ID, generating one if it does not already exist.
    '''
    token = None
    cache_path = CACHE + session_id

    sp_oauth = SpotifyOAuth(CLIENT_ID,
                            CLIENT_SECRET,
                            REDIRECT_URI,
                            scope=SCOPE,
                            cache_path=cache_path)
    token_info = sp_oauth.get_cached_token()
    if token_info:
        token = token_info['access_token']
    elif code:
        token_info = sp_oauth.get_access_token(code)
        token = token_info['access_token']

    if token:
        return Spotify(token, requests_timeout=30, retries=1)
    else:
        return sp_oauth.get_authorize_url()
Exemple #29
0
# Playlist counts
LIMIT_SHORT = 10
LIMIT_MEDIUM = 25
LIMIT_LONG = 50

# Spotify API variables
CLIENT_ID = os.getenv('SPOTIPY_CLIENT_ID', None)
CLIENT_SECRET = os.getenv('SPOTIPY_CLIENT_SECRET', None)
REDIRECT_URI = os.getenv('SPOTIPY_REDIRECT_URI', None)
SCOPE = 'user-library-read user-read-recently-played user-top-read ' \
        'playlist-modify-private playlist-read-private ' \
        'playlist-read-collaborative user-read-private user-read-birthdate ' \
        'user-read-email'

sp_oauth = SpotifyOAuth(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI, scope=SCOPE)
auth_url = sp_oauth.get_authorize_url()

# Flask setup
PORT = os.getenv('SPOTIPY_PORT', 8888)
SESSION_TYPE = 'filesystem'

app = Flask(__name__)
app.config.from_object(__name__)
Session(app)


@app.route("/")
def index():
    return 'My Spotipy App!'

        token = token_info['access_token']
        sp = spotipy.Spotify(auth=token)


scope = 'playlist-modify-public'
id = os.environ['ClientID']
secret = os.environ['ClientSecret']
# id = config.ClientID
# secret = config.ClientSecret
oauth = SpotifyOAuth(client_id=id,
                     client_secret=secret,
                     redirect_uri='http://localhost/',
                     scope=scope)
token_info = oauth.get_cached_token()
if not token_info:
    auth_url = oauth.get_authorize_url()
    st.write(auth_url)
    response = st.text_input(
        'Click the above link, then paste the redirect url here and hit enter: '
    )
    st.write(
        '*The BadAuth error below should go away after entering the redirect url'
    )
    # response = input('Paste the above link into your browser, then paste the redirect url here: ')
    if response == "":
        time.sleep(5)
    code = oauth.parse_response_code(response)
    token_info = oauth.get_access_token(code)
    token = token_info['access_token']
    sp = spotipy.Spotify(auth=token)
Exemple #31
0
import pandas as pd

# spotify authentication and initialization of client object
client_id = '##########'
client_secret = '#############'
redirect_uri = '############'
username = '******'
scopes = 'playlist-modify-private'

sp_oauth = SpotifyOAuth(client_id=client_id,
                        client_secret=client_secret,
                        redirect_uri=redirect_uri,
                        scope=scopes)
token_info = sp_oauth.get_cached_token()
if not token_info:
    auth_url = sp_oauth.get_authorize_url(show_dialog=True)
    print(auth_url)
    response = input(
        'Paste the above link into your browser, then paste the redirect url here: '
    )

    code = sp_oauth.parse_response_code(response)
    token_info = sp_oauth.get_access_token(code)

    token = token_info['access_token']

sp = spotipy.Spotify(auth=token)


# refresh function
def refresh():
Exemple #32
0
class SpotifyAuthManager():
    """
        A class used to handle Spotify Oauth.
        Refreshable user authentication.

        Owned by Playlist & ArtistManager.

        Args:

        Instance Attributes

        Class Attributes:

    """

    username = os.environ['SPOTIFY_USERNAME']
    client_id = os.environ['SPOTIFY_CLIENT_ID']
    client_secret = os.environ['SPOTIFY_CLIENT_SECRET']
    scope = os.environ['SPOTIFY_SCOPE']
    redirect_uri = os.environ['SPOTIFY_REDIRECT_URI']

    def __init__(self, session=None):

        self.token_info = None
        self.response_code = None
        self.client_mgr = None

        self.session = session
        # use same session
        # self.session = session

    def create_client_mgr(self):
        """
        Create SpotifyOauth object.

        Args:
            client_id
            client_secret
            redirect_uri
            scope
            cache_path

        """

        cache_path = WindowsPath("__pycache__") / fr'.cache-{self.username}'
        self.client_mgr = SpotifyOAuth(self.client_id,
                                       self.client_secret,
                                       self.redirect_uri,
                                       scope=self.scope,
                                       cache_path=cache_path)
        return self

    def get_auth_token(self):
        """
        Get oauth token from cache or prompt for new token.
        """

        try:
            self.token_info = self.client_mgr.get_cached_token()
            logger.info(
                f"Token expires at {time.strftime('%c', time.localtime(self.token_info['expires_at']))}"
            )
            return self
        # TODO: add specific exceptions
        except Exception:
            logger.info("No token in cache. Getting new token.", exc_info=True)
            auth_url = self.client_mgr.get_authorize_url()
            user_auth = self.session.get(auth_url).url
            response_code = input(f'Use Browser to authenticate: {user_auth}')
            code = self.client_mgr.parse_response_code(response_code)
            self.token_info = self.client_mgr.get_access_token(code)

            with open(self.client_mgr.cache_path, 'w') as f:
                f.write(json.dumps(self.token_info))

    def refresh_auth_token(self):
        """
            Refresh authentication token.

            Same spotify obect used throughout. How to call from owning classes.
        """

        self.client_mgr.refresh_access_token(self.token_info['refresh_token'])
        logger.info(
            f"Token refreshed, expires at: {time.strftime('%c', time.localtime(self.token_info['expires_at']))}"
        )

    def create_spotify(self):
        """
        Create Spotify object for Authorization Code flow.

        Args: token, session, client_mgr
        """

        try:
            auth_info = {
                'auth': self.token_info['access_token'],
                'requests_session': self.session,
                'client_credentials_manager': self.client_mgr
            }
            return catch(spotipy.Spotify, auth_info)
        except TypeError:
            # Why TypeError?
            logger.error("Token error.", exc_info=True)
Exemple #33
0
def main():
    st.title('Nodata.tv Spotify Playlist Maker')
    st.header('By Xristos Katsaros')
    st.subheader(
        'This app utilizes web scraping to find releases covered by Nodata.tv and places them in a Spotify playlist'
    )

    st.header('Connect to Spotify')

    #defining spotify oauth parameters
    scope = 'playlist-modify-public'
    client_id = os.environ['client_id']
    client_secret = os.environ['client_secret']

    #initializing spotify oauth
    oauth = SpotifyOAuth(client_id=client_id,
                         client_secret=client_secret,
                         redirect_uri='http://localhost:8080/',
                         scope=scope)
    auth_url = oauth.get_authorize_url()
    st.write(auth_url)
    response = st.text_input(
        'Click the link above, then copy the URL from the new tab, paste it here, and press enter: '
    )

    #defining variables
    genres = pickle.load(open('genres.pkl', 'rb'))
    years = list(range(1990, 2022))

    st.header('Select playlist preferences')
    st.text('Number of pages to scrape on the Nodata blog')
    pages = st.selectbox('Pages', list(range(1, 1800)))
    user_genre1 = st.selectbox('Genre 1', sorted(list(genres)))
    user_genre2 = st.selectbox('Genre 2', sorted(list(genres)))
    user_genres = [user_genre1, user_genre2]
    username = st.text_input('Spotify username')
    playlist_name = st.text_input('Name of new or existing playlist')
    year = str(st.selectbox('Year', sorted(years, reverse=True)))

    if st.button('Make playlist'):
        #connect to spotify
        code = oauth.parse_response_code(response)
        token_info = oauth.get_access_token(code)
        token = token_info['access_token']
        sp = spotipy.Spotify(auth=token)

        #get the names of of all the user's playlists
        playlists = [
            x['name'].lower() for x in sp.current_user_playlists()['items']
        ]

        #determine playlist ID
        if playlist_name not in playlists:
            sp.user_playlist_create(user=username,
                                    name=playlist_name)  #create a new playlist
            playlist_id = sp.current_user_playlists()['items'][0][
                'id']  #grab new playlist ID
        elif playlist_name in playlists:
            playlist_id = sp.current_user_playlists()['items'][playlists.index(
                playlist_name)]['id']  #find ID of existing playlist

        #the 2 main functions for scraping & searching spotify
        scrape_results = scraper.scrape(int(pages), user_genres,
                                        year)  #scrapes nodata.tv
        spotify_results = search_spotify(
            scrape_results, sp)  #inserts scraped results into search function

        confirm_and_add(spotify_results, username, playlist_id, sp)