Modern APIs with FastAPI and Python Transcripts
Chapter: Error handling and performance
Lecture: Error responses

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Well, our weather API works. We can come over here and click this. Get a nice result here, nice response.
0:07 However, what happens if there's the smallest of mistake? Like we misspell Portland to Portlnad.
0:15 That doesn't seem right. So we probably shouldn't be getting a server crash 500 server
0:20 error message when really what happened was there's just no city named Portlnad.
0:25 So let's go fix that. So what's happening is we're getting some response back, and it's just raising a standard exception.
0:32 So let's go and add a little bit more information here. We'll go over here and add a validation. We'll have a class,
0:42 which is a validation error, that derives from exception. And let's give it actually a couple of things.
0:49 Let's go over here and say that it's going to take an error message, string, and it's gonna take a status code, which is an integer. Let PyCharm
1:01 add that to the class for us. This way, when we get one of these errors, we'll have a meaningful way to respond and let's go over here like this,
1:09 Say "super dot init" and pass the error message along as well, perfect. So now we have one of these validation errors.
1:16 We can raise these and catch these and so on. So, for example, instead of this, we can say if response dot, say that this
1:24 is a response, like so. You can say that the status code is not equal to 200. Well, something went wrong over there.
1:33 So let's raise a validation error, like that, and we'll set the error message to be like this and the status code to the status
1:44 code. Let's pick an error message. Actually, let's just let the service communicate that response dot text, like that.
1:51 Let's see if this gives us some kind of better result for our Portlnad. We come over here and we try again.
1:57 Well, it crashed again because we're not converting that to a response. We'll do that now. So over here,
2:03 let's instead of just calling this, and we can just do a return, I suppose, like that. But instead of doing this,
2:10 let's say try to do it, and then we'll have an except validation error, like so. As
2:18 ve. And then what we want to do is return some kind of response. So return fastapi dot response. Set the content to be ve dot error message, and
2:27 the status code to be ve dot error. And I believe that's just gonna be, whoops status code. Set that to just the standard,
2:36 you know, plain text response. We could put that into a dictionary, right? This could be a little bit nicer. Maybe we'll do that in the end.
2:43 But let's just see what's happening now. Try again. 404 not found. And it says 404 there but that's not the super important thing.
2:50 Let's look at what the network says When we make this call. There you go, 404 is the actual response whoever called our API got,
2:59 which is perfect. So, we got our 400. Excellent, excellent, Excellent. There's a whole bunch of other validation that we need
3:05 to add that turns out to be a lot of work. We wanna make sure that we're always passing the lower case state,
3:11 maybe, in case that matters or not have spaces or potentially commas. We use two letter abbreviations instead of just random text,
3:20 and so on. Now that turns out to be super error prone. So Let's go and just do this real quick. We're gonna throw this in and import a type here.
3:28 So we're gonna have this thing called "validate units", which is going to take a city, state, country and unit, and it's going to return
3:35 modified city, state, country and units. Yes, second one maybe needs to be optional here. So what we want to do is go and strip out the city,
3:45 make it lower case. If there's no country, make it the US, otherwise lower case it, strip it, make sure it has length two,
3:52 if not create an error message that says it has to be length two, and that's bad data you passed because it's not length two.
3:59 So we're gonna raise a validation error just like before, but now it's gonna catch that. If there's a state,
4:04 do the same thing here, the units, make sure it's lowercase. There has to be some valid units. It has to be one of these three.
4:11 If it's not, say it has to be one. All that is a lot of work. I'll copy this to save a little typing. We'll go up to the top here,
4:20 and I'll just say that equals validate all of those things. Okay, let's see if we could get this to work. So we got our Portlnad.
4:27 That's a server error on the other side. This is valid. But what if we come over and say, country equals USA?
4:35 Nope. It must be two letters, US. And look, your 400, bad data. That's fine. So we got this back good again. And what if we say "units equals metricy"?
4:46 No, no, Can't be metricy, it has to be standard, imperial or metric, right? So now we've got our validation happening again and notice
4:53 the status code, not just the error message is being passed along. Cool, Right? So now, instead of saying, "Oh, the server crashed",
4:59 if we click up here and we got Portlnad, instead what we're getting back is error messages in terms of http status codes and meaningful messages.

Talk Python's Mastodon Michael Kennedy's Mastodon