RESTful and HTTP APIs in Pyramid Transcripts
Chapter: Customer Renderers
Lecture: Generating image-based responses with renderers (v2)
Login or
purchase this course
to watch this video and the rest of the course contents.
0:01
So we've seen that our car renderer, our car image renderer works really well.
0:06
You can see the image is here, but if you actually look at the network request it goes and it bounces just over to some other web server.
0:13
And you know, that may or may not be okay with you, but it's probably not really okay if you've got data as a binary blob in a database
0:20
because then what's the url for that, right? So, let's go and write a second version that actually pulls that data in
0:28
and streams it straight from our server, so as far as the clients can tell, it's our data coming through;
0:34
regardless of whether it comes out of our database, out of our file system or maybe even off of the internet, from somewhere else.
0:40
So let's make image, call this direct renderer, and redirect calls direct. Now you will know what the redirect part was about there.
0:50
Okay, so this is all going to work pretty much the same except for now that we're sending a response directly
0:55
we're going to need to have this type, so let's go and delete it out of the other. And because system is not used if you want,
1:03
you can put underscore and PyCharm will stop complaining and because we started using some pieces, also the static bit is not necessary, okay.
1:10
So, we get our request, we send a response type, we're going to try to adapt it, we're going to try to get the image
1:15
but instead of doing this, we're going to do something entirely different.
1:19
So now that we have the url, let's go over here and let's actually download it, let's go and say I'm going to download this off of the internet
1:27
if this was a binary blob, you would just have the data say out of sqlalchemy or something like that
1:32
but it's really off the internet, in this case we're going to go and say the response,
1:35
we'll use request, like who wouldn't want to use request in this class right. So let's make sure that we've got this registered in our system,
1:44
anytime you have a dependency like an external package like request you want to make sure that you put it here
1:49
so we install it in production or somewhere else, on new dev machine it automatically has that, so we could click the button, we could open this up,
1:56
and notice it's got our virtual environment active so pip install requests, just you can imagine how to click the button,
2:03
this also happened, just fine, so now give it a second, and that goes away.
2:07
So now we have requests, the one we're actually looking for not this pip thing, or we can do a get image url, and then we probably should check
2:16
so if so response.raise for status if something is wrong raising exception,
2:22
and then we want to return like a bytes array, some kind of stream that we can use, so we'll say return, and we are going to return bytes io from io,
2:32
and what are we going to do we're just going to give it the response content, like that. Now this one should go, have I changed this car one here—
2:42
let's turn this off for just a minute so we can test it. Let's click here and let's go get an individual car that's not going to work
2:51
but if we put first, there, so you can see that we got the car, right let me copy this, google wants to keep changing that around, okay,
3:00
so if we go there, you can see the car shows up, but notice it redirected, right,
3:04
there's a three or two redirect to this location, we want to stream it directly,
3:08
so let's go and switch here, by the way, the reason I commented this out is it's not so easy to set the accept type to png in the browser, right,
3:18
so we're just having one request, like you can do it, but it's not as easy. So let's go over here and say I want to get a different image renderer,
3:26
this is going to be direct, import that, so we can pick, right, which one do you want turn on the redirecting one, turn on the direct one.
3:34
So we'll run this again, notice we're using direct one, so if I go back over here and I enter this address, it should just stay here and show us image,
3:41
it shouldn't redirect like it just did, right, there's the redirect to opel, it stays, why does it stay, because as far as we're concerned
3:50
we make a request to the server, the server says you're getting png back and here's a bunch of bites, perfect, right?
3:57
Go and view the network, reload the page, you can see get right here set domain and when I restart it I got a different car, yeah perfect.
4:10
So it's just going straight here, right, it should stay the same now. Right if we switch this back, one more time so you can see the difference here,
4:18
hit this again, notice we did this request, we got it through to redirect and then we went over there, right.
4:25
So now we're here it's just staying there, but any time we go to this url you can see we're getting this redirect.
4:31
Like I said, this may or may not be okay, if you want to stream it straight out the database or suck it through off the internet
4:37
and stream it back through, then we can switch to this direct renderer and it stays right there.
4:44
Now we've got a wide variety of options for our renderers, we've got a csv renderer, we've got these two image renderers
4:51
let's go ahead and add one more before we kind of call this thing done, let's go ahead and add a json renderer,
4:57
and you might say Michael, why would we add a json renderer, we already have one right here, a built in one;
5:02
well, we're going to want to use some ability of grouping these together as a common set of objects, and let the api negotiator determine
5:11
which renderer is best, so having a renderer that exactly adapts to the same functionality as ours, and we can just of course delegate to this one,
5:19
it will be nice, so we want to add one more of these in our real app and then we'll be ready to talk about content negotiation.