Getting Started with Google APIs (Python)

Welcome to Google I/O 2013. I am Prashant Labhane from the Google APIs team. And today we’ll be learning about getting started with Google APIs in App Engine using Python. In Google APIs’ team, we try really hard to make tools so that your application development is easier and you can use the APIs very easily. In today’s session, we’ll be covering about running a Quickstart application locally. We’ll deep-dive into the Quickstart application. We’ll do application development using an API.

We’ll deploy the application to App Engine. And at the end, I’ll provide some reference. But before getting started, the first question I ask before writing any application is to see what is provided in the APIs. You can do that without writing a single line of code with a tool called APIs Explorer. You can go to that tool at developers.googl And as you can see, Google provides a lot of APIs, some of them very product-specific like Blogger and Books. But we also provide a lot of infrastructure APIs like Cloud Storage and Compute Engine. For today’s session, I’m going to be using one of my favorite APIs, Google+. But I would encourage you to try out this exercise with any API of your liking. So as you can see, Google+ provides resources like activities, comments, and people information in the API.

So there’s a method called a Search in which you can query anything, and you will get results for the activities that are relevant to that query. So as you can see here, it gives a bunch of items– the title, the URL, which is basically a list of activity resources. What you can also do with the Google+ API is to get information about a particular users list of activities. And you can do that using plus.activities.list. But before we get into that, we need to authorize the application to get access to the user’s data. We do that using OAuth 2. So I’m going to turn on OAuth 2 and allow access for Google+ API. And this presents me a user content screen. During the course of this session, you’ll find the screen come up again.

What this is trying to do is trying to authorize the application Google APIs Explorer to access user Prashant Labhane’s data for the Google+ API. I’m going to give it access. And then I can use my user ID here. For brevity, you can use Me as the code word for user ID. And it will pick up the user from your browser. And I want to see whatever I have shared publicly. Now, as you do that, you will see, again, the same list of activities. But this one is particular to the activities that are shared by the user. Looking at this API, I have a good sense of what application I want to build. So I will be building an application which displays the URLs of all the activities for a particular user. So we can now get started with the first section, which is running your Quickstart application. For the purpose of this exercise, I’m using a brand new Google account called Google I/O 13 Python . So all the flows you’ll be seeing in today’s session will be first-time session. If you already have registered with App Engine or APIs Console, your flow might look a little bit different.

So let’s get started. The first thing you need to do is to register a Google Cloud Project. And you can get an instance of Google Cloud Project at Since this is the first time it’s going to ask me for a verification– and I’m going to go ahead and complete the verification flow. So as you can see in the previous screen, I had to get a verification code. You can get that via a phone call or a text message. I just got my verification code, which I’m going to verify. And that brings me into the Google Cloud Console. I’m going to agree to the terms of service. And I’m going to create a new Cloud Project. I’m going to call it Google APIs Quickstart. By default, the Cloud Project comes with a project ID. But you can also choose something that you like.

I’ll try to see if I can get something of my liking. So I’ll try Google APIs Quickstart, which already exists, so I’m going to say, Google I/O 13 Quickstart. And that would be the name of the project that we’ll be using. So it’s going to create a new Cloud Project at this point. While we are doing that, let’s also download the App Engine SDK, which we’ll be using later in this session. You can download the App Engine SDK from developers.googl You can also find the link in the presentation for this video.

I’m using a MacBook. And it already has Python installed. I am going to use Hands, the App Engine SDK. In the meantime, the Cloud Project has been created. The name of the project is Google APIs Quickstart. And the project ID is Goog I/O 13 Quickstart. The Google Cloud Project is the home for a lot of other Google technologies like Google Cloud Storage, Cloud SQL, Bit Query, which I would encourage you to try after this session. Now my Google App Engine SDK is downloaded.

I am going to extract the file. And I am going to move it to my Applications folder. When you install the Google App Engine Launcher, you also want to make sure– let me change my system preferences. OK. When you use Google App Engine Launcher, you also want to make sure that you create the right symlinks so that you’ll be able to use the SDK tool from command line. So this is what it does the first time it starts up. If you happen to miss the step, you can always go back to Google App Engine Launcher to make symlinks, and it’ll create the links for you. OK. Now we can get started with the next step. Google provides a set of client libraries to make it easy for you to use APIs, though most of the APIs are resource-oriented and you can always write your libraries around the protocol. And we encourage people to use the client libraries, because they are easier to use and they also encompass a lot of functions that you will see. You can access the client libraries at developers.googl

As you can see, Google provides libraries in very many languages. For today’s session, we’ll be using Python. Google Client libraries make it very easy to take care of a lot of your application tasks like authentication batching, logging, et cetera, so that you can focus more on writing the code for the API, as you will see in the next sections. What we also provide, in addition to the client library, is a way to get you started quickly on your project with the Quickstart widget. So in this case, as we discussed, I’m going to be using the Google+ API. I’m going to be deploying it on Google App Engine. And I’m going to configure my Cloud Project with this project. So as you see, it’s already pre-populated with Google APIs Quickstart, which is the Cloud Project we just created. Please make sure you read the terms of service.

This one is the terms of service for the Google+ API. And it’s going to finish the widget. What you get at the end of Quickstart is your starter application as well as the client credentials that go with it. So I’m going to download both of these. And as you can see, in my Downloads folder I have the Client Secrets file as well as the App Engine Project. So let’s take a look at the App Engine Project.

The App Engine Project comes with a default Client Secrets. And if you take a closer look, the Client Secrets file is empty. It doesn’t have the client ID or the Client Secret. What you could do is, from the developer’s console, paste in the client ID and the Client Secret. But the method I prefer to use is to just drop the file into the folder. And now, to make it easy for this session, I’m going to rename this folder to be called My App Engine Project so that we can refer to it more easily. OK. Now that I have the new Client Secrets into the folder, let’s go to the next step, which is to run this Quickstart application locally. As you can see, we have downloaded the App Engine SDK and we have created symlinks. And the App Engine SDK comes with a lot of handy tools to run application.

One of them is called the Absorber that lets you run an App Engine application locally on your machine. So I’m going to go to the Downloads folder, and it has my App Engine Project. I am going to run dev app server against my App Engine Project. And it’s going to start up a server that you can access on local host 8080. So this is your application running locally. The first screen that you see here is asking for the user authentication to the application.

Since this is a locally-running application, it does not require any log-in. So it’s a test log-in screen. The next screen that you see is the OAuth screen that we previously saw. But in this case, the service account for the project is asking to authorize that application to get the data for Prashant Labhane for Google+ APIs. I’m going to say, Accept. And it’s going to take a while. And with that, we have a locally-running application. As you can see, the application doesn’t do much but render HTML.

It gives you handy links on how to use the Google+ API in Python. With that, we have our application running locally. Let’s move to the next section, where we’ll do a deep-dive of the Quickstart application code, what it does. And we’ll do a bit of application development later. So let’s get into the deep-dive of the code. As you can see, the project is here. You can use an ID of any choice to import this project.

In my case, I’m going to just use my text editor. So the main file that controls your application in the Quickstart project is main.pi. And let’s do a code walk-through of what that application does. The first thing you would notice that it imports the Client Secrets file that we put in the same folder. It’s creating a service for your API. And this is the service that you can use to invoke resources and methods upon. It creates an OAuth-decorated blazed on the Client Secret file. And it has a main handler and Get method, which is decorated with OAuth Required.

The decoration OAuth Required makes sure that the OAuth flow is called before the Get method is called. Since this is a simple application, we will be using OAuth Required. However, when you’re developing your complex application, you want to make sure that the content screen shows up at the right time, in which case I would encourage you to try OAuth Aware, which lets the application take control of when the OAuth credential gets checked and called. And as you can see, the application is writing out a simple HTML.

What you will also notice is the application is a WSGI application, which comes with Main Handler. But it also comes with the OAuth 2 callback handlers, which take care of OAuth flow on behalf of you in the application. You can also register other handlers as and when needed for this WSGI application. Now that we have a good sense of what the Quickstart code is doing, we can now get started with coding our application. So I already walked you through the OAuth flow. And we did a code walk-through. Let’s get to the next section, which is application development. What you can see is the locally-running application gives you a handy link to the Python Google+ API.

So let’s take a look. As you can see, the same resources that we saw at the start of this session for APIs Explorer are now exposed as Python methods that can be called upon. So let’s take a look at Activities. And you can see the same methods like Search and List can be called upon in this API. So let’s go ahead and write some code. So what I’m going to do is I mirrored the same activities that we did earlier with the APIs Explorer in Python code. So I’m going to get Activities results. I’m going to do it using the service. And as you can see, the service is created here for the Google+ API. If you’re using a different API, then you can invoke the methods relevant to that API. So I’m going to call service.activities. And as you can see, the Activities has a search method.

So I’m going to call Search using the query, Google. And now I’m going to execute this command. Another thing to notice is for executing any API call, you need to make sure you get an authenticated HTTP object to carry that API call over. So in this case, it’s already decorated. I’m going to use the HTTP object from the Decorator. So it’s going to be decorator.http, which is the authenticated HTTP connection. And the next thing I’m going to do is I’m going to write out Activities Result in the HTML. And remove all this code. OK. And now I’ll make sure I save the file, because that’s important. One of the good things about developing with dev app server is it automatically takes care of any code changes you make. So you don’t have to go and kill your application and restart it. But you can keep you dev app server running, keep developing. And you will be able to see the changes without having to restart dev app server. So in this case, as you can see, I modified my code and it’s giving me a list of Python objects relevant to the query, Google.

What I’m also going to do next is to get a list of activities for my user account. As you can recall, in APIs Explorer we had to turn on OAuth 2. But this application is already decorated with OAuth 2 Required, which means you can call the List method for the Activities in my account, and the Decorator OAuth 2 Required will take care of running OAuth 2 on your behalf. So I’m going to use List. User ID equals Me, and Collection is public. And I’m going to execute it the same way I executed the Search, using the Decorator’s authenticated HTTP object. If you ever find yourself not knowing what the parameters are, you can always go to the documentation for the API and check out what the query parameters are. Now, again, as I said earlier, when you change your code, just make sure you save your file, and you’ll be able to see the changes quickly. So this is the list of activities that is shared by my user account.

What you can also do in App Engine Python is to use templates to render the HTML in a nice way. As I said earlier, we’ll be creating links for the various sets of activities. The Quickstart application comes with a built-in template that you can use to render these. In Python 2.5, it does Django templates. But if you are using Python 2.7, that would be So let’s write a small template file to render the results. So let’s create an HTML file. And I’m going to write a Django template.

And I know that I’m going to be getting items in this object, as you have seen in the APIs Explorer. And also, you can inspect this code, which tells you that it’s a list of items and each of the items has a URL and a title, which is relevant to the activities. So this is what my template is going to do. So I’m going to get the link from Items URL. And I’m going to be getting the item’s title. And I’m going to put some line breaks. And that is a very simple template that I’m going to be calling activities.html. And now that I have the template, I can go to my code. And I’m going to invoke the template and render my Activities result object using this template. So I’m first going to declare the template path. And as you can see, the activities.html file is in the same folder, so I’m going to be using the directory name. And joining with activities.html. And next up, I’m going to be rendering the template path, which is the template that it just wrote with the Activities result.

If you are wondering where the template model came from, you can see, as I told earlier, the Quickstart application comes with the default template. And with that, I’m going to save my file. And as you can see, it now renders a link to the activities that are shared by my user account. And if you click on them, you will go to the specific activity post that is relevant. Now, with that, I am pretty happy with my application. And I want to deploy it to App Engine. So we can get started with the next section, which is deploy to App Engine. Before we do that, let’s understand a little bit about client credentials. The client credential file, which I downloaded earlier, client_secrets.json, was to run the application locally. To deploy the application on App Engine, we need to get the credentials for a web application on App Engine. You can do that by visiting And go to API access.

And just create a new client ID. In this case, it’s a web application. The site name is your Cloud Project ID name. And that is also the name of your App Engine application. And it will be hosted on So your site name would be Goog I/O 13 Quickstart. I’m going to go to my Cloud Project and check it again. It’s Goog I/O 13 Quickstart. So the application name is correct. And it’s going to be hosted on And like that, you create a new client credential. What you also want to do is once you’ve created this client credential, you want to make sure that the application still continues to run locally. To do that, you can edit your settings and add Local Host to the redirect URIs, which make sure that the application continues to run locally. However, when you are finally deploying your application, I would recommend moving this out so that it’s safer. What I’m going to do, now that I have created a client credential, I’m going to download the Client Secrets JSON.

And as you can see here, I have a new Client Secrets file. So I’m going to remove the old one and move the new Client Secrets into the project. The second thing that you want to do is to configure your application on how the code is deployed to App Engine. In Python, that’s controlled by a file called ab.yamal, which comes in your Quickstart project. You want to enter your application ID, which is Goog I/O 13 Quickstart in our case. What you also want to do is I prefer to be secure and always use HTTPS for my applications. And you can do that using the parameter Secure Always. If your Quickstart application code doesn’t come with Secure Always, I would recommend you adding this. And I’m going to save this file.

And now we are ready to deploy this application to App Engine. As I said earlier, I’m going to stop my local application. The App Engine SDK comes with a variety of handy tools. One such tool is AppConfig, which lets you upload your application to App Engine. So I’m going to update, and I’m going to give it the location of my App Engine project. And the first time it runs, it’s going to ask you about the account with which you have your Cloud Projects and things like that. So I’m just going to enter my password. And with that, this is the first run. It’s going to take some time to deploy the application that I just wrote locally into App Engine. And it seems like it’s completed. So I’m going to go to my browser and go to

And it’s going to ask me to log in. So this is the part where the user is authenticating to the App Engine application. This is the second screen, which is the OAuth screen. Now, as you can see, this is showing up again. This is because this time the application is different. In the previous case, you were running your application locally, and that’s the application you authorized.

Now that you have deployed it to App Engine, you want to authorize the App Engine application and the authorization to access the data for Prashant Labhane. I’m going to go and accept that. And with that, you have the same application that you just developed locally and deployed onto App Engine. Now, with that, we come to the end of this session. But I wanted to give you some handy references and things that are happening in Google APIs.

If you are more interested, I would definitely recommend you to check out Google Cloud Endpoints, which enables third parties to host APIs on Google. Now, this is a very powerful concept. And we are trying to bring the client libraries and authentication and all the good stuff that you just saw in this session to third-party APIs as well, so that as an application developer, you can use Google APIs as well as you can use third-party APIs to create really powerful applications on App Engine. If you are interested in the Java version of this talk, I would recommend you watching on getting started with Google APIs in Java on App Engine. And I would also recommend you to going to some of the reference, more specifically and to check out all the different technologies that are offered in Google Cloud.

With that, we come to the end of this session. Thanks for watching, and have a good time coding. .

Add Comment