Consuming HTTP Services in Python Transcripts
Chapter: Consuming RESTful HTTP services
Lecture: Blog explorer: Creating a post
Login or
purchase this course
to watch this video and the rest of the course contents.
0:02
So we can see the post, that is not really new for us
0:05
although I do feel like this is a pretty sleek little trick with the dictionary unpacking,
0:08
it's time to add the post, so over here we are going to do a few things,
0:13
I've already created the publish date text
0:15
because that is just not worth you watching me type that,
0:19
but we still need to get some additional information, from the user.
0:22
So, we are going to need to get the title, so we could say just input, okay,
0:26
once we have all of this information we will be able to create
0:31
a dictionary on the Python side here, called post data,
0:36
exactly like the thing we are working with, so we could say like title=title,
0:40
content=content, we know this is what it's going to expect,
0:45
view_count=view_count, and published=published_text okay,
0:52
so you might think that we can just send this over directly as it is but it turns out
0:57
we got to do one more little step here, we are going to need the url to submit it too
1:01
so it will be base url plus, remember our API is if we do a post
1:06
to the general blog collection that will create one and actually even return it
1:10
as the response body, so that is cool and let's go ahead and add some headers,
1:15
and earlier we said we'd accept application json
1:17
but now we are telling it I am sending you application json right,
1:21
we are going to turn that into json and send that as the body so on the server side,
1:26
it knows it's not like form encoded data or something to that effect,
1:30
and now we can send it so we can say the response=request. not get, but post,
1:35
right, there is also a put and there is also a delete.
1:38
So we'll say post and it takes the url the data, the json and so on,
1:42
so we'll say url, we'll say json=post data, and headers=headers,
1:51
okay, that is pretty cool, let's go ahead and try sending this to the server,
1:54
I think this actually might work, so we'll say if response,
1:57
now, you got to be a little careful, what does success mean for a post,
2:01
if you look at the http protocol, it says there is a specific success status code 201
2:09
which means created and that is the ideal status code for here
2:13
so we are going to assume that this service is working right,
2:16
if you get a 200 back that might also mean it worked,
2:19
they just aren't being super careful with their status codes,
2:23
so let's say if it's not over here we'll say print error creating post,
2:29
and any text that we get back, right, it could be hey like this was not found
2:35
or it could be access denied you must log in or something to that effect.
2:40
Now, if we do see it let's go ahead and do a print, created this,
2:45
and I am going to do a print whatever we got back, so we should have a post,
2:49
I am going to actually capture that post, and say response.json,
2:53
now, if we just sent the data to the server,
2:56
why would it send it back, that's weird, right,
2:59
well, remember, there is 5 pieces of data in every blog post in our data model,
3:03
there is the title, content, view count, published and id,
3:06
the id is server generated and maybe they also do other normalization
3:10
like set this to be at least zero, not negative, maybe they do cleanup on this,
3:15
all sorts of things could have been modified
3:18
and we want what the server believes it created, not what we asked it to create.
3:21
So this post is going to represent that.
3:24
Alright, you want to see if it works- let's give it a shot.
3:28
Alright, so let's see what's you first, we have three,
3:31
there is always these three that are static when you get started,
3:34
I didn't want you to start with an empty set of data,
3:37
then I am going to add so this is our first attempt to create a post,
3:43
the title is this is the body, I don't want to write the whole blog post,
3:48
and the view count is going to be 10.
3:51
Here we go, boom, that worked beautifully, now it's important to notice here
3:55
that we set the json, another possibility up here, is we could set the data,
4:00
if we set the data we have to set a string representation of the json,
4:05
if we set the json itself and not the data,
4:08
it's going to basically stringify that json, so be careful here.
4:12
Alright, now let's see how this works, let's list and see if our post is actually there,
4:17
oh awesome, this is our first attempt to create a post,
4:20
let's just add one more because we can.
4:24
This one has got a lot of views folks,
4:27
boom, we got it back and then notice right here,
4:30
the id that we got back from the server it ends in 48 a
4:33
so when I list this is our success story it ends in 48 a,
4:38
that is a direct call to the server, we are not holding onto that data.
4:41
So that is how we create data using our API, remember, we knew that over here,
4:46
because it said the way you create a new post is you do a post against /api/blog
4:53
where it doesn't actually say it here, but I am telling you
4:57
the body is the actual post content minus the id.
5:00
Now we have a much more interesting little blog explorer,
5:04
we can both list the existing post and create new ones for ourselves,
5:07
up next, we are going to want to update the post,
5:10
what if we made a type error or something and maybe even delete the post
5:13
like no this is old, this is outdated, I'm done with it, goodbye.
5:17
Much less common, but still, we want to have all the crud operations in our little explorer.