Let's go ahead and configure our development environment. The first thing we need to do is create a new virtual environment, so we can work and install the packages that we need without interfering with the global Python installation.

Our application will be called musicterminal, so we can create a virtual environment with the same name.

To create a new virtual environment, run the following command:

$ python3 -m venv musicterminal

And to activate the virtual environment, you can run the following command:

$ . musicterminal/bin/activate

Perfect! Now that we have our virtual environment set up, we can create the project's directory structure. It should have the following structure:

musicterminal
├── client
├...

The first thing we need to do is create a Spotify app; after that, we are going to get access keys so we can authenticate and consume the REST API.

Head over to https://beta.developer.spotify.com/dashboard/ and further down on the page you can find the Login button, and if you don't have an account, you can create a new one:

If you don't have a Spotify account, you will have to create one first. You should be able to create applications if you sign up for the free account, but I would recommend signing up for the premium account because it is a great service with a great music catalog.

When you log in to the Spotify developer website, you will see a page similar to the following:

To make the application more flexible and easy to configure, we are going to create a configuration file. This way, we don't need to hardcode the URL and access keys; also, if we need to change these settings, changes in the source code will not be required.
We are going to create a config file in the YAML format to store information that will be used by our application to authenticate, make requests to the Spotify RESP API endpoints, and so on.

Let's go ahead and create a file called config.yaml in the musicterminal directory with the following contents:

client_id: '<your client ID>'
client_secret: '<your client secret>...

Now that we have the code to load the configuration file for us, we are going to start coding the authentication part of our framework. Spotify currently supports three kinds of authentication: authorization code, client credentials, and implicitly grant. We are going to implement authorization code and client credentials in this chapter, and we will start by implementing the client credentials flow, which is the easiest to start with.

The client credentials flow has some disadvantages over the authorization code flow because the flow does not include authorization and cannot access the user's private data as well as control playback. We will implement and use this flow for now, but we will change to authorization code when we start implementing the terminal player.

First, we are going to create a file called authorization.py in...

So far, we have only prepared the terrain and now things start to get a bit more interesting. In this section, we are going to create the basic functions to send requests to Spotify's Web API; more specifically, we want to be able to search for an artist, get an artist's list of albums, get a list of tracks in that album, and finally we want to send a request to actually play a given track in Spotify's client that is currently active. It can be the browser, a mobile phone, Spotify's client, or even video game consoles. So, let's dive right into it!

To start off, we are going to create a file called request_type.py in the musicterminal/pytify/core directory with the following contents:

from enum import Enum, auto


class RequestType(Enum):
    GET = auto()
    PUT = auto()

We have gone through enumerations before, so we won&apos...

Now that we have everything we need to authenticate and consume the Spotify Rest API, we are going to create a small terminal client where we can search for an artist, browse his/her albums, and select a track to play in the Spotify client. Note that to use the client, we will have to issue an access token from a premium account and the authentication flow we need to use here is the AUTHENTICATION_CODE.
We will also need to require from the user of our application the user-modify-playback-state scope, which will allow us to control playback. With that said, let's get right into it!

First, we need to create a new directory to keep all the client's related files in it, so go ahead and create a directory named musicterminal/client.

Our client will only have three views. In the first view, we are going to get the user input and search for an...

We have covered a lot of ground in this chapter; we started by creating an application on Spotify and learning our way around its developer's website. Then, we learned how to implement the two types of authentication flow that Spotify supports: the client credentials flow and the authorization flow.

In this chapter, we also implemented a whole module wrapper with some of the functionality available from Spotify's REST API.

Then, we implemented a simple terminal client where users can search for artists, browse the artist's albums and tracks, and finally play a song in the user's active device, which can be a computer, mobile phone, or even a video game console.

In the next chapter, we are going to create a desktop application that shows the number of votes given through Twitter hashtags.