Eve: Building RESTful APIs with MongoDB and Flask Transcripts
Chapter: Introducing Flask
Lecture: Hello world, Flask-style
0:00 Let's build our first Flask application.
0:03 First of all, we want to activate our virtual environment,
0:06 so let's just source our activation script
0:14 and here we go, as you can see
0:16 the virtual environment is now active
0:18 and we are sitting in our working folder.
0:21 We can now launch our text editor
0:27 we already have a hello.py script in here.
0:31 The first thing I want you to note
0:33 is that we are dealing with just 6 lines of code,
0:36 actually 4, if we don't factor in the import line here and the blank line,
0:41 so we are speaking about 4 lines of code
0:43 for a fully functional Flask app.
0:46 I guess this is where the famous, simple and elegant Flask definition comes from.
0:54 Let's review our code line by line.
0:56 On the first line, we are importing a Flask class from the Flask package.
1:00 This class will be our wsgi application.
1:03 On the second line, we are creating an instance of our class
1:06 and as you can see, we are passing an argument.
1:09 This is the name of the application module or package
1:13 and it is needed so Flask knows
1:15 where to look for templates, static files and so on.
1:18 On line 4, we are using the route decorator to tell Flask
1:25 what URL should trigger our function.
1:28 So any time the home page is hit by the browser
1:31 the hello function will be triggered
1:35 and the function itself is super simple,
1:38 it is simply returning a hello world message.
1:41 So now our script is ready and we want to see it running, right?
1:45 So how do we do that?
1:47 We could go back to our terminal window
1:49 and launch the built in Flask server,
1:52 but we can do better than that
1:54 because within code we have an integrated terminal window and we can use it
1:57 let's just go to the view menu and click on integrated terminal,
2:02 and here we go, we have a new window with the terminal.
2:05 And as you can see, we are already in our working folder
2:08 and in fact, if we check the contents, we see our hello.py script right there.
2:15 Now, before we can continue,
2:17 we need to activate the virtual environment, so let's do that.
2:26 Now we're ready, and by the way,
2:29 by the the time you see this screencast,
2:31 you probably want to activate the virtual environment yet again
2:34 because as you might remember,
2:36 we already activated it before launching the editor.
2:38 There is a ticket open on the github repository for Visual Studio Code
2:43 and a fix to go online with the next update in February 2018.
2:50 So now that the virtual environment is ready
2:53 we can try and launch our script.
2:55 To launch the built in server, all we need to do is issue this command
3:01 Flask run, and if we do that, it will fail,
3:05 and the reason is that we didn't tell Flask which is the launch script,
3:09 we can do that by simply exporting the Flask app variable
3:16 and we set it to our scrap
3:20 Okay, let's try again, Flask run,
3:24 there we go, as you can see, now Flask is serving the app hello
3:28 on local host port 5000.
3:33 Let's go and try it out.
3:41 Hello world, this is nice, we have a working website up and running
3:47 with just six lines of Python code
3:50 and the built in Flask server is serving it to us.
3:53 How can we improve it?
3:55 Well, first we might want Json as a response
3:58 since we are going to build RESTful APIs anyway,
4:01 so how do we do that?
4:03 Let's go back to our app, it turns out
4:07 that Flask comes with a very powerful jsonify function
4:13 so we can leverage it, and in our function
4:18 we simply go and call jsonify and then we need to pass
4:23 a Python dictionary, so maybe something like this,
4:33 it should be good enough, let's save,
4:37 go back to our browser and refresh.
4:40 And nothing happens. Why is that?
4:42 Well, the reason is that we didn't relaunch our server
4:45 so let's stop the server and launch it again,
4:51 so it can pick the new script, and here we go, as you can see,
4:57 now we're getting Json back as a response to our request.
5:00 Now, powerful, but it is quite annoying
5:03 that we have to stop the server and relaunch
5:05 every single time we make a change in our scripts.
5:09 Well, luckily for us,
5:11 Flask comes with a built in debug mode, and we can activate it
5:14 by simply setting an environment variable, so let's do that.
5:18 Again, let's stop the server and export Flask debug
5:26 let's switch this variable on.
5:31 And now, let's run the server again.
5:37 As you can see, we get a slightly different message now
5:40 the Flask app is running but it is forced to debug mode,
5:45 so now, any change we do here, it will be picked up by the server.
5:51 Let's try for example and add a new route—
5:59 how about we make a log in page,
6:13 okay, let's save, and we can see that the server here
6:18 has detected a change in hello.py and it is reloading,
6:23 in fact, the server restarted
6:25 and let's see if we go back and just go to the login page
6:32 there it is, we didn't need to stop the server,
6:36 so for example, let's say that we change the contents of the string
6:42 in welcome, you are logged in,
6:51 save, again, the server restarts, we go back, refresh,
6:55 here we go, back to our script,
6:58 we only scratched the Flask surface here,
7:00 of course, there is a lot more to Flask to be seen
7:04 but I believe in a few minutes, we achieved quite a lot
7:07 we now have our Flask site up and running,
7:10 we know how to handle growth with Flask
7:13 and we also learned how to import some very nice functionality from Flask.
7:19 Of course, we learned about the built in server and the debug mode.
7:23 All these features will come in handy in the next segments,
7:27 when we move on to Eve.