Why raise_for_status() did not catch the error?

Question

Trying to check for none 200 Response in the current_track() function. What could be a problem? It throwing JSONDecodeError error. But if I understood raise_for_ status correctly it should have prevented the function from trying to load a JSON from a faulty web-page? If I run the script without this check and with uncommenting lines check_playback() it successfully catches JSONDecodeError.

The script is fetching data from Spotify and putting it to the status on vk.com.

import config
import webbrowser
import requests
import furl
import secrets
import string
import time
import os
import simplejson as json


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'


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('Enter the whole URL, that you have been redirected on: ')

    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):
    dict = {}
    dict['token'] = response["access_token"]
    dict['time'] = time.time()

    with open(tkn_file, 'w') as file:
        file.write(json.dumps(dict))


def load_file(tkn_file):
    with open(tkn_file) as file:
        data = json.load(file)
    return data


def set_status():
    params = {
              'v': 5.92,
              'access_token': load_file(FILE_TOKEN_VK)['token'],
              'text': current_track()
    }

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


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()
    print(response)

    try:
        response.raise_for_status()
    except requests.exceptions.HTTPError as e:
        return "Error: " + str(e)

    # data = track_data().json()
    data = response.json()
    artist = data['item']['artists'][0]['name']
    track = data['item']['name']

    return(f'{artist} - {track}')


def check_playback():
    set_status()
    print(current_track())
    # try:
    #     set_status()
    #     print(current_track())
    # except json.decoder.JSONDecodeError:
    #     print('Not playing')


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()

Error screen

Answer 1

raise_for_status() will only raise an exception if the server reported an error to you (and even then, only if it actually followed the HTTP spec and returned a HTTP error code).

There is no way for the library to know that the response is incorrect. Even if it was correctly formatted JSON, it can't know what schema you expect it to follow (what fields should be present, and what types those fields should have). Even if it knew the schema and had verified it, there is no way for it to know that the data is actually correct and not made up on the spot.