Building data-driven web apps with Pyramid and SQLAlchemy Transcripts
Chapter: Routing and URLs
Lecture: Routing overview
Login or
purchase this course
to watch this video and the rest of the course contents.
0:00
Having properly structured URLs is super important
0:03
for web applications.
0:05
It matters for SEO, Search Engine Optimization
0:09
but it also matters for usability and discoverability
0:11
of your users.
0:13
I'm sure many of your users will be either
0:15
typing into the URL bar
0:17
or looking at it and trying to make sense
0:20
of the structure there
0:21
so you want to have good control and put some thought
0:25
into your URL structure.
0:27
And we're going to dig into the mechanism in Pyramid
0:31
how we do that, how we create the best possible set of URLs
0:36
and map those to our view methods.
0:39
So let's start by just talking about what is routing.
0:43
We've mentioned it a few times
0:44
and it's basically mapping URLs into action methods
0:48
or controller methods.
0:49
So let's go through this.
0:51
So a request comes in.
0:53
This request is an HTTP GET, that's a verb, a HTTP verb
0:57
for /project/sqlalchemy.
1:00
And imagine, over on the right we have our server
1:03
and this sort of weird conceptualization
1:05
of the various view methods, or controller methods
1:08
index and details to do with packages
1:11
and index and about to do with home.
1:15
We've registered some routes in this application.
1:19
We've got / and that goes to HomeController.index.
1:23
And so the system's going to ask
1:24
Is /project/sqlalchemy a match for that?
1:28
No. And in this case it has to be an exact match.
1:31
There's no ambiguity or variability here.
1:35
So, no it's not that.
1:37
We also have /about that goes to home.about.
1:41
Now, also not a match, so we'll keep goin'
1:45
The next one we have is /project.
1:47
And then that last part can change, right.
1:50
This is data driven, so that's part of the data, alright.
1:53
sqlalchemy, requests, mongoengine
1:55
whatever goes in there, Pyramid, alright.
1:59
that's what goes after /project.
2:02
In our route, we've defined a little variable here
2:04
and this one we said
2:06
"If something like that comes into the system
2:10
"map that over to details."
2:11
And in addition to that, capture whatever value
2:15
goes into that {package} location
2:17
and pass it into the method as, not a parameter
2:21
but as a piece of data.
2:22
We'll see how to get that in just a sec.
2:24
So this one's match and as soon as it finds the first match
2:26
it's just like, we're done, calling this one.
2:28
So it's going to prepare the request
2:30
it does a bunch of stuff.
2:32
In addition to the common things
2:35
it's going to go to the matchdict
2:36
which is a dictionary that's always on request.
2:39
Sometimes it's empty, sometimes it's not.
2:40
These variables that come from the URL
2:43
the routing itself like {package}
2:45
those values get stored in that part of your request.
2:49
So here our request is going to have, more than just this
2:53
but the matchdict will have at least package as a key
2:58
and then that value for this URL is going to be sqlalchemy.
3:01
And it's going to call details passing that request
3:03
and we can pull out that matchdict and work with it.
3:07
So that's the gist with routing.
3:09
We'll see that we can do all sorts of interesting
3:12
and powerful things like we could say
3:14
I want to map this to details
3:16
but only if those are only letters, no numbers.
3:20
Or maybe if it's only a number
3:21
we want to do something different.
3:23
So later on in this section, in this chapter
3:25
we're going to and do some really powerful things with routing.
3:28
But let's stop here and add this functionality
3:31
to our application.
