Building data-driven web apps with Flask and SQLAlchemy Transcripts
Chapter: Routing and URLs
Lecture: Refactoring view methods with Flask blueprints
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
So here we are in our Flask app.
0:02
And it's pretty standard, right?
0:04
This is like how they tell you how to do it in Flask.
0:06
Import flask, you create your app
0:09
and then you create your view methods.
0:10
You put your app.route on them.
0:12
Well, okay, that's how you get started maybe sometimes.
0:16
But this is a terrible way
0:17
to organize real applications.
0:20
It definitely encourages just cramming
0:22
your entire web app into like a single file.
0:26
Bad idea. And it's bad because Flask has a really
0:29
super cool way of organizing your views
0:32
that you don't have to do much at all about.
0:34
You just change basically a one word right there
0:37
and you're good to go.
0:38
So what we're going to do in this little short segment
0:41
is we're going to reorganize our code
0:43
not because it's really that long
0:45
you can see it's actually short
0:46
but so that it's ready to grow
0:48
as we build up this real application.
0:51
So let's do a couple of things.
0:53
The first thing I want to do
0:54
is actually deal with this fake data.
0:56
We're going to have a real database
0:57
with lots of interesting stuff going on.
0:59
So I want to create a special part
1:01
of my application just for that.
1:04
I'm going to call that services.
1:07
Not web services, but services that are provided
1:09
through our application like stuff that deals with packages
1:12
stuff that deals with users, and so on
1:14
so we can isolate that over here.
1:16
So I'm going to create something called
1:19
package_service. Like so.
1:23
And then let's just take this code and put it over here.
1:27
All right. Not super interesting.
1:29
Remember, we don't have our data yet.
1:31
We don't have our database.
1:32
That's coming later.
1:34
But, we can get started this way.
1:36
So we're going to come here and say import
1:38
pypi.org.services.package_service
1:42
and let's say as just package_service.
1:44
I noticed there were some errors down here
1:46
so we can come and say .get_latest_packages.
1:48
Just like that, I think that's the only place it's used.
1:51
Okay, let's just make sure real quick
1:53
that we didn't break it. We did not, okay super.
1:59
That's what I expected.
2:00
So, that organizes it a little bit
2:02
gets some of the data access out of here.
2:04
But this, this is the ultimate problem right there.
2:08
However, it's tricky to reorganize it as is.
2:11
So this needs to be created
2:13
and then it needs to be used
2:15
to start the app in this main app.py.
2:18
And yet, it has to be available at the time
2:20
that these are parsed so that we can apply the route.
2:24
So, that can make it really tricky.
2:25
There are patterns that allow you
2:26
to share this across the file, different files
2:29
but because Flask has this built in thing
2:31
called Blueprints which are ways to predefine
2:35
these routes and then later apply them
2:37
after the app is created, we're going to use that.
2:40
It's really nice.
2:41
So, let's go down here and create a folder called views.
2:45
And in the views folder, we're going to create
2:47
let's start with two things
2:49
we'll have a file called home_views
2:53
keep adding that to get up.
2:54
And we'll create another one
2:57
called package_views.
2:59
We don't really directly work with these often
3:02
so the name isn't super important.
3:04
Okay, so what we need to do is we want to take
3:07
this is going to be the home stuff
3:09
and we're going to put it over here.
3:12
Well, immediately you can see the problem.
3:14
Some of it's just an import problem, that's easy.
3:17
Let's go up here and grab that
3:22
'cause of my renaming.
3:23
Okay that was easy, but the one that's left here
3:26
hmm not so much.
3:27
So, we're going to use this thing called
3:28
a Flask Blueprint.
3:30
And the way it works is we're going to come over here
3:31
and we're going to say Blueprint
3:34
you can also call it app if you want
3:35
but let's not confuse things here.
3:37
So we say Flask, which we have to import at the top
3:40
we say Blueprint and in here
3:42
we're going to give it three pieces of information.
3:45
A friendly name, so in this case
3:46
I'm going to call it home, 'cause it has to do
3:48
with the home_views.
3:50
And then for the import name
3:52
I'm going to give it the __name__
3:53
which is the name of this file, home_views.
3:57
And then we want to set the template folder to templates.
4:02
And then all we have to do is go down here
4:04
instead of doing @app.route
4:06
we say @blueprint.route.
4:10
So, we just replace app with blueprint
4:14
like so. Now, this sort of works
4:17
this will sort of add some features here.
4:21
And we go and run it
4:22
let's see what's going to happen.
4:23
We don't need this anymore.
4:25
So, let's see if we run it
4:26
is it going to be amazing?
4:28
The chances are it's not going to be amazing.
4:31
That didn't work.
4:32
But remember, potentially these
4:35
these are created before the app is there.
4:38
And how does the app instance know about it?
4:40
Well, we can do, there's a couple of things we can do.
4:43
But, let's define, let's do a little bit of work here.
4:46
Let's define a main
4:50
and move that up.
4:51
Now, before we do this let's call another function
4:53
called register_blueprints
4:55
or whatever we want to call it.
5:00
Like so and then all we got to do is say
5:04
so import home_views
5:07
and then we can go over to the app
5:09
this is the one that now exists here
5:11
and we can say register_blueprint, like so
5:15
and pass it in home_views.
5:17
And that's it, that basically goes back
5:19
and tells the app about the few routes
5:21
and methods and what not are defined over here.
5:25
It should work, let's give it a try.
5:27
And it did not like that. Oh
5:32
we can't aim for home_views, we have to
5:35
aim for, register home_views not blueprint.
5:38
Let's try that again. All right, there we go.
5:41
So, looks like it's running
5:44
but does it work? Moment of truth.
5:47
Of course it works. Of course it works.
5:49
Isn't that nice?
5:50
So that lets us break our code apart.
5:52
Our view code into these more specialized pieces.
5:57
So, it might not be convincing to you yet
5:59
how amazing this is, so let's go and add
6:02
another one here for the package.
6:06
So, for packages we're going to have a couple of things
6:08
and I'm just going to copy a few bits here to start out.
6:12
So, we're going to have a blueprint
6:13
and it's going to be packages, that all looks good.
6:16
And this is going to be packages
6:20
what we want to have is maybe a details.
6:23
And we're not going to do anything super interesting yet
6:27
let's just return package details for some package.
6:34
And here do we get to define our first
6:37
interesting route, I guess I would say.
6:39
This is going to be, let's remind us
6:41
what that's going to look like.
6:42
pypi.org, the real thing
6:45
click on this one, it's going to be
6:48
/project/<package_name>, okay.
6:52
So that's what we want there
6:54
so here we say package, let's do package_name.
6:58
Like so. Now, notice start away that PyCharm is saying
7:03
whoa, whoa, whoa there's something wrong
7:05
with this part of your route. What is wrong?
7:08
A function index does not have a parameter to take it.
7:11
That's so cool. So, we just go in here and say
7:13
it takes a string, now it's happy
7:15
and we can actually put that there as well.
7:19
Okay. Let's omit that out for a moment.
7:23
So, we should be able to run this.
7:25
Let's change the name, let's call this
7:28
package_details.
7:30
And the blueprint, we're also going to have to
7:32
register this blueprint for it to work.
7:34
So, last thing, I need to go down here
7:38
to import package_views
7:43
like so and then we can import it
7:44
make sure everything's nice and cleaned up.
7:46
Did it rerun? Probably it did rerun.
7:49
Make sure, there we go.
7:51
So, we've got our two things here
7:53
but if we go to /project/abc
7:56
boom, package details for abc.
7:59
Okay, so we've defined our first interesting route
8:02
but maybe even more importantly for the moment is
8:05
we found a way to take our single super
8:09
mega monolith file that was defining our application
8:13
imagine there's fifty of these methods
8:15
and breaking them apart by category.
8:18
So, here we have home, these are the things
8:19
to do with like home and about.
8:21
And we'll have package and we'll have some
8:22
other package things going on here as well.
8:25
Of course we'll use that again in just a minute.
8:28
And then in our templates folder
8:29
I told you I was organize these
8:31
with this in mind so here we have home
8:33
we're also going to have a new folder called packages
8:37
in which case we're going to put our details.html.
8:41
So, let's just rob this one and call it
8:44
details.html, of course, it doesn't
8:48
have all the details yet, but it's going to.
8:50
So, this organization here is directly tied
8:54
to this organization that we did with blueprints there
8:57
so, I think this is a great way to organize your code
9:01
nothing about Flask encourages you
9:02
or suggests that you should do these
9:04
types of things, it's just a recommendation from me
9:07
you don't have to but I think it's going to be
9:09
really, really great as your app grows.
