RESTful and HTTP APIs in Pyramid Transcripts
Chapter: Web application building blocks
Lecture: Pyramid building blocks
Login or
purchase this course
to watch this video and the rest of the course contents.
0:02
Before we can write our first service, we should have a high level of view of all the moving parts of the building blocks of Pyramid.
0:11
I find in web apps in general they are even harder to work with, than say just standard other libraries
0:17
because a lot of parts have to fit together often via conventions, configuration files, main app initialization files,
0:24
views, templates, static files and so on. So we're going to try to cover those things and show you how they all fit together
0:31
and then we'll start writing some code around it. So what are these building blocks?
0:36
First of all, we're going to need to take a url and map it to some code, some behaviors in our app, so the first thing we can talk about are routes,
0:43
so routes take a url pattern and map them to views, some web frameworks use regular expressions for these,
0:51
and I don't think that's a great way to do it, right, these regular expressions can be really tricky,
0:57
they're powerful but they're also quite complicated and error prone to see why something may or may not map to a particular url.
1:03
Thankfully, in Pyramid, there's a really powerful and simple way to do this, and if we need what regular expressions provide,
1:10
we can add on something like constraints via a regular expression. Views, so views are the functions or the code that runs
1:18
once a request has been routed, and figure out which view it's suppose to go to, all the request data is passed to us, that could be the post body
1:26
that could be the url, a query string and many many more things. Now notice also have a.k.a controllers, Pyramid speaks
1:32
in this template view design pattern language, but it very much matches the pattern of what's more generally known as model of view controller,
1:42
so if you're coming from an mvc design way of thinking I'll also put those words here, so views are the functions
1:48
that run in Pyramid syntax or nomenclature, and these would be called controllers. And we also have templates so once the view is run,
1:57
it's gotten some sort of data, presumably, and it wants to show that to a person or transform that
2:03
into say an xml rss feed to send off to a machine, or even turn into json. Templates are a way to take HTML structure
2:12
and pass a bit of data to it and it will transform it into HTML, we don't use this a ton in services, we use this all the time in web applications.
2:22
So if you have a web page for documentation that's sort of the front part of your service,
2:27
you're going to care about this, if you're just sending json, the thing that we'll be working with is not so much templates but renderers.
2:33
And these renderers take our data and transform it just some sort of plain text thing like json or xml or something like that.
2:41
We also have models, this is the data taken, created by the view and passed either to the template or to the renderer
2:47
to be turned into text for the users, and we have static files and a special way to deal with static files
2:53
again services probably care less about this, but you could theoretically redirect to a static file
2:59
with all of its cashing and support and things like that, and we also have configuration, any real service has database connection strings,
3:06
service API strings, things like what's your Stripe credit card API key if you're going to be a credit card service
3:15
it's going to do some sort of charge for your web application or your web app, so we'll see there's a lot of support for configuration files
3:22
as well as various use cases for these configuration files, like different settings for dev, test and production.