Video transcripts for responder mini course.

Author: mikeckennedy

transcirpts/01-course-intro/1-welcome-to-course_transcript_final.txt

@@ -0,0 +1,120 @@
+00:00 Hello and welcome
+00:01 to this short mini course on
+00:03 the Responder web framework.
+00:05 Maybe you've heard of Responder
+00:07 it's written by this guy, he's done a few
+00:09 open source projects in Python
+00:10 his name's Kenneth Reitz.
+00:12 So, likely you've heard of Kenneth
+00:13 because of his Requests library
+00:16 and Kenneth is pretty well known
+00:17 for creating clean and well liked APIs.
+00:22 So, when he said hey, I know there's a bunch
+00:24 of web frameworks out there, but I'm going to
+00:26 create another one to put my stamp on
+00:28 what that API might look like
+00:30 well that got my attention.
+00:31 And probably it got your attention as well.
+00:34 So, if you want to see what this web framework
+00:37 that Kenneth Reitz came up with looks like
+00:39 and take it for a tour
+00:41 well you've come to the right place.
+00:43 Let's talk quickly about what we're going to cover.
+00:46 First, I'm going to talk about some of the key features.
+00:48 After all, with this mini course
+00:49 we're not going to be able to dive deep
+00:51 into some of the really intriguing things
+00:53 that this framework takes on, for example
+00:55 it has async run as background work
+00:58 that you can run in process.
+01:00 It has web socket support
+01:02 it has really good async methods
+01:05 that you can work with.
+01:06 And we're not going to dig deep into that
+01:08 but we will talk a little bit about it.
+01:10 We're going to go and build an async capable API
+01:14 and notice I didn't say async API
+01:15 because we're not actually going into async here
+01:18 that's well beyond the scope of this
+01:20 I have a very long course on that
+01:22 and you're welcome to take it and it's super, super powerful
+01:24 and it's one of the things that drew me
+01:25 to this framework, however we're not
+01:27 going to go into those details.
+01:29 If you know async in a way, all the view methods
+01:32 and API endpoints we create here with Responder
+01:35 you can put async def on the method
+01:37 and you can do await within it
+01:39 it's really, really great for scalability
+01:41 but again, we're not going into it.
+01:43 We're going to create two kinds of views
+01:45 or processing with this web framework.
+01:47 One is going to return templated Jinja2 based views.
+01:51 I'm going to go to the database to go to a data source
+01:53 and then I'm going to convert that into
+01:57 a dictionary, I'm going to pass that dictionary
+01:58 to a Jinja2 template, Jinja2 template's going to be
+02:01 rendered into rich HTML, that's great.
+02:04 The other kind are more HTTP API endpoints.
+02:08 Here we're going to do a get request
+02:10 or a post request over to an endpoint
+02:12 and return some kind of JSON.
+02:14 These JSON endpoints, they're fun
+02:16 and they're cool, but you know
+02:17 they just exchange little bits of data.
+02:19 Wouldn't it be fun if we had
+02:20 a really awesome app built around it?
+02:23 Why, yes it would.
+02:24 So, we're going to take an app that I built
+02:26 using Vue JS to explore this API
+02:29 and it's really fun, it's really interactive.
+02:31 Again, same reasons as async
+02:33 we're not going to go into Vue
+02:35 I'm going to show you how the app works
+02:36 I'll give you like the one minute flyer
+02:37 of Vue JS, but I will give you this
+02:40 rich application that works with this API
+02:42 that we will build during the class.
+02:45 Now, I said it a few times but I just
+02:46 wanted to remind you, this is a fast course
+02:48 we're just going to go really quickly
+02:50 into some of the key elements of Responder
+02:52 we're going to build some JSON APIs
+02:54 we're going to build some cool apps to consume it.
+02:57 Think we're going to have a lot of fun.
+02:58 So, with that in mind, let's just keep moving.
+03:00 Now, what do we expect you to know
+03:01 in order to take this class
+03:03 and get the most out of it?
+03:04 Well, Python obviously.
+03:06 We're not going to cover any of the foundations
+03:08 you don't know what a foreign loop is
+03:10 or things like that, there's other places
+03:12 you probably should start and then come back here.
+03:14 This assumes that you know like the majority
+03:16 of the core Python language.
+03:18 We're not doing meta classes and deep things
+03:20 but the basic Python syntax, you should
+03:22 definitely have that down.
+03:23 And it is a web framework, we're not going
+03:25 really deep into the foundations
+03:27 of what REST APIs are or why you care about them.
+03:30 Or what HTTP verbs are, we're going to assume
+03:33 you kind of are familiar with that
+03:34 and we want to build something in Python with Responder.
+03:37 These are the expectations for the course.
+03:39 And finally, let me introduce myself, who am I?
+03:41 Who's this guy talking to you?
+03:42 My name's Michael Kennedy
+03:43 that's a picture of me, you can find me
+03:45 on Twitter @MKennedy.
+03:47 You might know me from the Talk Python to Me podcast
+03:49 you may also know me from the Python Bytes podcast
+03:52 but most relevant for this conversation
+03:55 I'm the founder and one of the main authors
+03:57 at Talk Python Training.
+03:59 Welcome, welcome to the course.
+04:00 It's going to be a lot of fun
+04:02 and it's not going to take a lot of time
+04:03 so I think that's a beautiful mix
+04:05 and I hope you enjoy it.

transcirpts/01-course-intro/2-python-versions_transcript_final.txt

@@ -0,0 +1,67 @@
+00:00 Now we're almost ready to start writing some code
+00:02 and talking about this framework.
+00:03 But before we do, let's just make sure everyone's on a
+00:05 level playing field.
+00:06 There's a couple things I want to share with you.
+00:08 A couple things I want to give you.
+00:09 And, also want to make sure you have what you need
+00:12 to take this course.
+00:13 So the first thing I'm want to start with is
+00:15 what version of Python do you need.
+00:17 Well of course we're on modern Python.
+00:20 That in my mind I guess, is probably like
+00:22 Python 3.5 and above.
+00:24 But you're actually going to need Python 3.6 'cause
+00:26 I believe we use some f-strings.
+00:28 f-strings are a new way to format strings in Python
+00:30 which are great.
+00:31 Also it has async and await which came in 3.5
+00:34 but I believe some of the features that were added
+00:37 also required a little bit later.
+00:39 So let's just say, 3.6 or later, maybe even 3.7.
+00:42 Newer is better. You have to have Python installed
+00:45 and it has to be Python 3.5 at an absolute minimum.
+00:49 Ah, could be higher still. You may even wonder all
+00:52 "That's great Michael I, really want to have Python installed
+00:55 but do I on this particular machine".
+00:57 I don't know. Well you can always ask.
+00:59 You can go to your terminal in macOS or Linux
+01:02 and type python3 -V and it will tell you, one of two things.
+01:06 Either the version number or Python 3 not found.
+01:09 If Python 3 not found, that means it's either not installed
+01:12 or just not in your path.
+01:13 But, you can see I got Python 3.7.2
+01:15 that's almost the latest.
+01:17 Just the day I started pressing record here, 3.7.3 came out.
+01:22 Pretty much the same. On Windows, ah, python3 -V
+01:26 sometimes works and you can get 3.7.2.
+01:30 Depending on how you've installed Python.
+01:32 You might have to type just python, without the 3, -V
+01:35 and see what you get.
+01:37 And especially on Windows '�ause until recently
+01:39 could not target the version by the executable name.
+01:43 You have to make sure your path is just right
+01:45 so you can type "where python" on Windows I think
+01:49 and "which python" on Mac and Linux.
+01:51 If that's wrong, you can switch it.
+01:52 It's either which or where
+01:53 to show you where it's come from and if there is more
+01:55 it'll show you which, which is in the path and where
+01:57 you know which one comes first in the path and so on.
+02:00 So if you have a new enough version of Python
+02:03 super, let's rock and roll.
+02:04 If you don't, refer you over to
+02:06 realpython.com/installing-python
+02:10 These guys have a really nice set of steps on giving this OS
+02:14 here's how you get Python there
+02:15 here's the trade off's and so on.
+02:17 And, they're keeping it nice and up to date, so ah
+02:21 instead of showing you how install and maybe
+02:23 you know, six months there's some other way like
+02:25 Windows 10 now just offered Python 3.7 in the store
+02:29 which is a better way that getting it off
+02:31 python.org for example.
+02:32 So you can check out what they've got here.
+02:34 This is pretty helpful and of course, you know
+02:37 get modern Python all set up if you don't have it
+02:38 and let's roll.

transcirpts/01-course-intro/3-editor_transcript_final.txt

@@ -0,0 +1,31 @@
+00:00 Now, we could use whatever editor we want
+00:02 but I am a big fan of PyCharm.
+00:04 I think PyCharm strikes a really nice balance
+00:07 of not being too heavyweight
+00:09 it's somewhat heavyweight, but it's really not that bad
+00:11 with absolutely supporting proper web applications.
+00:16 So, not only does it understand CSS and JavaScript and HTML
+00:20 it knows Python really well
+00:21 and it understands the relationships
+00:22 between your CSS files, your static files
+00:25 your Python files that you're working with.
+00:28 It has nice refactoring.
+00:29 All sorts of stuff.
+00:31 So, we're going to be using PyCharm.
+00:32 You can get the Community Edition
+00:33 which will do most of what you need here.
+00:36 It'll basically do everything except for give you
+00:39 any form of support for the Jinja2 stuff
+00:41 or the CSS editing, all right?
+00:44 You could still create those files and edit them
+00:46 I'm pretty sure
+00:47 but with the free community edition
+00:48 it won't do auto-complete within them.
+00:50 They don't have native support for Responder
+00:52 built in anyway, so that's not a huge shortcoming
+00:55 but it is something to be aware of.
+00:57 So we're going to use PyCharm Professional.
+00:58 You can follow along with that.
+01:00 Or use something else if you prefer
+01:01 but here's how you can get the same editor
+01:03 that we're using.

transcirpts/01-course-intro/4-get-the-code_transcript_final.txt

@@ -0,0 +1,14 @@
+00:00 Now of course, everything you see me type and much more
+00:02 will be available to you
+00:04 in a free and open GitHub repository, and this one, so go to
+00:08 github.com/talkpython/responder-webframework-minicourse.
+00:13 Here, you'll see all the demo code that you'll see created
+00:17 even a little bit more
+00:18 because I had to tweak a couple of things.
+00:19 We added the Vue JS, there's stuff in there
+00:21 that we're going to talk about at the end
+00:24 and everything that you need to get going
+00:26 you can get it right here.
+00:27 So be sure to go to this repository, star, and fork it
+00:31 and that way you'll be sure
+00:32 to have all the materials to follow along.

transcirpts/01-course-intro/5-some-excerpts-from-100days_transcript_final.txt

@@ -0,0 +1,46 @@
+00:00 Now some of the content
+00:01 in fact the main demo where we build out this Responder API
+00:05 comes from this other course that we're working on
+00:08 and we have been working on for a long time
+00:10 called 100 days of Web in Python.
+00:13 Haven't heard of it?
+00:14 That's because this is the first time
+00:16 were publicly talking about it at all
+00:18 so workin' on this with Bob Belderbos
+00:20 and Julian Sequeira who helped
+00:22 with the 100 days of Python course
+00:24 100 days of Code in Python course
+00:25 that we already did, and this is another
+00:27 massive course covering all sorts of things
+00:29 in the web framework world.
+00:30 Vue JS, React, Flask, Django, Responder
+00:34 APIStar, you name it.
+00:36 If you want to dig into a bunch of different web frameworks
+00:39 and kind of get a survey of the entire landscape
+00:40 this is the course where we're doing that.
+00:43 It's going to be like 25 hours of content
+00:45 and it's going to be amazing.
+00:46 So in the next chapter when we build out this API
+00:49 some of that presentation is coming from
+00:51 a little excerpt from his 100 Days of Web course.
+00:55 Now, I didn't know anything about it
+00:57 or have any experience with this 100 Days of Web course
+01:00 but you'll see it in the demo links
+01:02 like in the fold or path.
+01:04 Things like that if you see that and
+01:06 you're like, wait, what is this 100 Days of Web about?
+01:08 Well, here's what it's about.
+01:09 So we took this little bit of Responder
+01:11 from the 100 Days of Web course
+01:12 and we turned it into its own proper course
+01:15 this little mini course that you can take right here.
+01:18 That's what it's about, check this out.
+01:19 It's not out yet at the time of the recording
+01:22 but maybe the time of watching.
+01:24 Anyway, if you subscribe to get notified
+01:26 somehow at training.talkpython.fm
+01:29 like you have an account and you haven't opted out
+01:31 for example, you'll definitely hear about this
+01:33 when it comes out.
+01:34 Heads up, this a little excerpt from a really big course
+01:37 that's been blown up to be its own proper course.

transcirpts/01-course-intro/6-follow-along_transcript_final.txt

@@ -0,0 +1,69 @@
+00:00 Think back to when you were younger, much younger.
+00:02 And you were playing with Legos or something like this.
+00:05 These look like so much fun, right?
+00:07 And see, there's a little dragon head there in the middle
+00:09 and there's a bunch of blocks
+00:10 and maybe somethin' from a spaceship, who knows?
+00:13 Well, this looks like fun.
+00:15 But it's a lot more fun to actually follow along
+00:18 and build something.
+00:20 So this course is built for you to follow along in two ways.
+00:23 So I want to highlight those right at the beginning.
+00:25 In case you want to follow along, you can.
+00:27 You don't have to, all right?
+00:29 If you just want to watch and let it wash over you
+00:32 that's great, you can totally do that.
+00:33 But if you want to follow along
+00:34 there's two things you can do.
+00:36 First, when we work our way
+00:38 through all the demos and stuff
+00:39 you could pause the videos and just go and recreate that.
+00:43 You might need to grab the data that we're using
+00:45 off of the GitHub repository.
+00:47 But after that, you should be able to follow along
+00:48 and create it yourself.
+00:49 So one, step one, round one, version one
+00:52 of this would be to follow along.
+00:55 The second is this thing I'm calling "Your Turn."
+00:58 So if you GitHub repo, actually to this folder here
+01:01 linked at the bottom, you'll see
+01:03 we put together a separate independent project
+01:06 that was not presented in this video
+01:08 for you to also follow along.
+01:11 So here we are in this responder webframe
+01:15 marked "Minicourse", Github repository.
+01:17 And here's your turn I was talking about.
+01:19 So if we go in here you can see, there's a couple of steps.
+01:22 It's not like, do X, type Y, and so on.
+01:25 It's more like, here's some ideas of how you can explore
+01:28 to build something with Responder.
+01:31 We're going to use this Mockaroo service
+01:33 go over here you can see if I log in.
+01:36 Mockaroo will let us generate things like
+01:38 ID, first name, email.
+01:39 And I can even preview it and it'll show me
+01:42 some pretty cool data there, actually.
+01:43 But you can go further and click here and say
+01:45 "I would like a animal scientific name,"
+01:48 or, "Bitcoin address."
+01:50 You see, there's all sorts of stuff here.
+01:53 So the idea is, you go to this Mockaroo service.
+01:56 You look through that data source
+01:58 of sets of data sources you can generate, and go
+02:00 "Oh, I have an idea for a veterinary clinic,"
+02:02 "or a Bitcoin company," or whatever, right?
+02:06 Look through and find something interesting
+02:07 and generate a bunch of data.
+02:09 You can save it as JSON, here's a way to load it back up
+02:11 as JSON into Python dictionaries that you can use.
+02:14 And then here's a simple example of
+02:16 building out some sort of API endpoint.
+02:19 And you'll have seen this, you'll see how this goes.
+02:23 So here, just a reminder on how that works.
+02:25 And you always look back at the demo code.
+02:27 And I encourage you, after you've seen the short course
+02:29 after you've followed along, to go explore Mockaroo.
+02:32 Build an interesting fake data set and then
+02:34 build an interesting fake service to work with that.
+02:38 All right, well hopefully this adds a fun twist
+02:40 at the end of the course for you.

transcirpts/02-main/01-intro-responder_transcript_final.txt

@@ -0,0 +1,19 @@
+00:00 Hello and welcome to Day 50.
+00:02 We're going to spend this one day chapter on Responder
+00:07 a new async web framework created by Kenneth Reitz.
+00:11 Maybe you've heard of Responder, but very likely not.
+00:13 It's quite, quite new.
+00:15 It's a great async-capable web framework.
+00:19 Why are we only spending one day on this
+00:21 and not diving deep into it?
+00:23 Well, it's really quite new and I'm not sure
+00:26 if it's going to survive
+00:27 or if it's going to gain all the traction
+00:28 so right now we're just throwin' it out there
+00:30 as another topic that you can cover.
+00:33 Something that you can use. I really like the API even just building small apps with it
+00:37 it's made me smile.
+00:38 It seems like there's some
+00:39 really great stuff happenin' here.
+00:41 So we're going to build a quick, simple API and website
+00:46 within Responder and I think that'll make you smile as well.