Krdytkyu

This is refactored and much more expanded version of the script reviewed here. The whole authorization process is added.

import os

import secrets

import string

import time

import webbrowser



import furl

import requests

import simplejson as json



import config





URL_CODE_BASE_VK = 'https://oauth.vk.com/authorize'

URL_CODE_BASE_SP = 'https://accounts.spotify.com/authorize'

URL_TOKEN_VK = 'https://oauth.vk.com/access_token'

URL_TOKEN_SP = 'https://accounts.spotify.com/api/token'

URL_TRACK = 'https://api.spotify.com/v1/me/player/currently-playing'

URL_STATUS = 'https://api.vk.com/method/status.set'

EXP_IN_TOKEN_SP = 3400

EXP_IN_TOKEN_VK = 86400

FILE_TOKEN_VK = 'vk_token.json'

FILE_TOKEN_SP = 'sp_token.json'

INP_MSG = '''Enter the full URL, that you have been redirected on after giving

the permissions: '''





def get_auth_code_vk():

    url_code_params = {

        'client_id': config.CLIENT_ID_VK,

        'response_type': 'code',

        'redirect_uri': 'https://oauth.vk.com/blank.html',

        'v': 5.92,

        'scope': 'status',

        'state': gen_state(),

        'display': 'page'

    }



    code = url_open(URL_CODE_BASE_VK, url_code_params)

    return parse_code(code)





def get_auth_code_sp():

    url_code_params = {

        'client_id': config.CLIENT_ID_SP,

        'response_type': 'code',

        'redirect_uri': 'https://www.spotify.com/',

        'scope': 'user-read-currently-playing',

        'state': gen_state()

    }



    code = url_open(URL_CODE_BASE_SP, url_code_params)

    return parse_code(code)





def gen_state():

    symbols = string.ascii_lowercase + string.digits

    return ''.join(secrets.choice(symbols) for _ in range(12))





def url_open(url_base, url_params):

    url_code_full = furl.furl(url_base).add(url_params).url

    webbrowser.open_new_tab(url_code_full)



    input_url = input(INP_MSG)

    return input_url





def parse_code(url):

    return (url.split("code=")[1]).split("&state=")[0]





def get_token_vk():

    data = {

        'grant_type': 'authorization_code',

        'code': get_auth_code_vk(),

        'redirect_uri': 'https://oauth.vk.com/blank.html',

        'client_id': 6782333,

        'client_secret': config.CLIENT_SECRET_VK

    }



    response = requests.post(url=URL_TOKEN_VK, data=data).json()

    write_file(FILE_TOKEN_VK, response)





def get_token_sp():

    data = {

        'grant_type': 'authorization_code',

        'code': get_auth_code_sp(),

        'redirect_uri': 'https://www.spotify.com/',

        'client_id': config.CLIENT_ID_SP,

        'client_secret': config.CLIENT_SECRET_SP

    }



    response = requests.post(url=URL_TOKEN_SP, data=data).json()

    write_file(FILE_TOKEN_SP, response)





def write_file(tkn_file, response):

    token = {}

    token['token'] = response["access_token"]

    token['time'] = time.time()



    with open(tkn_file, 'w') as file:

        file.write(json.dumps(token))





def load_file(tkn_file):

    with open(tkn_file) as file:

        data = json.load(file)

    return data





def set_status():

    params = {

        'user_id': 8573490,

        'v': 5.92,

        'access_token': load_file(FILE_TOKEN_VK)['token'],

        'text': current_track()

    }



    response = requests.get(url=URL_STATUS, params=params)

    error = http_error(response)

    if error:

        return error

    return response





def track_data():

    tkn_file = load_file(FILE_TOKEN_SP)['token']

    headers = {

        'Accept': 'application/json',

        'Authorization': f'Bearer {tkn_file}'

    }



    return requests.get(url=URL_TRACK, headers=headers)





def current_track():

    response = track_data()

    error = http_error(response)

    if error:

        return error



    data = response.json()

    artist = data['item']['artists'][0]['name']

    track = data['item']['name']



    return f'{artist} - {track}'





def http_error(response):

    try:

        response.raise_for_status()

        return None

    except requests.exceptions.HTTPError as error:

        return error





def check_playback():

    if track_data().status_code == 204:

        print("Not playing")

    else:

        set_status()

        print(current_track())





def token_missing(file):

    return not os.path.isfile(file)





def token_expired(file, exp_in):

    return time.time() - load_file(file)['time'] > exp_in





def token_not_valid(file, exp_in):

    return token_missing(file) or token_expired(file, exp_in)





def run_script():

    if token_not_valid(FILE_TOKEN_VK, EXP_IN_TOKEN_VK):

        get_token_vk()



    if token_not_valid(FILE_TOKEN_SP, EXP_IN_TOKEN_SP):

        get_token_sp()



    check_playback()





if __name__ == "__main__":

    run_script()