Welcome back. With the Redis task queue setup, let's use AngularJS to poll the back-end to see if the task is complete and then update the DOM once the data is made available.
You will use Angular to implement the user interface features and Python for the backend. These days it is not uncommon to have an API that is responsible not only for persisting data to the database, but also dealing with business requirements like permissions, data flow, data visibility, and so on.
"Quick to develop", "Great mvc" and "Powerful" are the key factors why developers consider AngularJS; whereas "Lightweight", "Python" and "Minimal" are the primary reasons why Flask is favored.
I would start out by organizing the Flask app in the standard structure as follows:
app
|-- app.py
|-- static
|-- css
|-- img
|-- js
|-- templates
And as btford mentioned, if you are doing an Angular app, you'll want to focus on using Angular client-side templates and stay away from server-side templates. Using render_template('index.html') will cause Flask to interpret your angular templates as jinja templates, so they won't render correctly. Instead, you'll want to do the following:
@app.route("/")
def index():
return send_file('templates/index.html')
Note that using send_file() means that the files will be cached, so you might want to use make_response() instead, at least for development:
return make_response(open('templates/index.html').read())
Afterwards, build out the AngularJS part of your app, modifying the app structure so that it looks like this:
app
|-- app.py
|-- static
|-- css
|-- img
|-- js
|-- app.js, controllers.js, etc.
|-- lib
|-- angular
|-- angular.js, etc.
|-- partials
|-- templates
|-- index.html
Make sure your index.html includes AngularJS, as well as any other files:
<script src="static/lib/angular/angular.js"></script>
At this point, you haven't yet constructed your RESTful API, so you can have your js controllers return predefined sample data (only a temporary setup). When you're ready, implement the RESTful API and hook it up to your angular app with angular-resource.js.
EDIT: I put together an app template that, though a little more complex that what I've described above, illustrates how one could build an app with AngularJS + Flask, complete with communication between AngularJS and a simple Flask API. Here it is if you want to check it out: https://github.com/rxl/angular-flask
You can start on either end.
You are right that you probably don't need a full server-side framework with AngularJS. It's typically better to serve static HTML/CSS/JavaScript files, and provide a RESTful API for the back end for the client to consume. One thing that you should probably avoid is mixing server-side templates with AngularJS client-side templates.
If you want to use Flask to serve your files (might be overkill, but you can use it nonetheless) you would copy the contents of "app" from "angular-phonecat" into the "static" folder of "minitwit."
AngularJS is more targeted at AJAX-like applications, whereas flask gives you the ability to do both the older-style web apps as well as create RESTful APIs. There are advantages and disadvantages to each approach, so it really depends what you want to do. If you give me some insights, I might be able to make further recommendations.
This official Jetbrains PyCharm video by John Lindquist (angular.js and jetbrains guru) is a nice starting point as it shows the interplay of webservice, database and angular.js within flask.
He builds a pinterest clone with flask, sqlalchemy, flask-restless and angular.js in less than 25 minutes.
Enjoy: http://www.youtube.com/watch?v=2geC50roans
edit: The new Angular2 style guide suggests a similar, if not the same structure in much more detail.
The answer below target large scale projects. I have spend quite some time thinking and experimenting with several approaches so I can combine some server side framework (Flask with App Engine in my case) for back-end functionality along with a client side framework like Angular. Both answers are very good, but I would like to suggest a slightly different approach which (in my mind at least) scales in a more human way.
When you are implementing a TODO example, things are quite straight forward. When you start adding functionality though and small nice details for user experience improvement, its not difficult to get lost in chaos of styles, javascript etc..
My application started to grow quite big, so I had to take a step back and rethink. Initially an approach like suggested above would work, by having all the styles together and all JavaScript together, but its not modular and not easily maintainable.
What if we organized the client code per feature and not per file type:
app
|-- server
|-- controllers
|-- app.py
|-- models
|-- model.py
|-- templates
|-- index.html
|-- static
|-- img
|-- client
|-- app.js
|-- main_style.css
|-- foo_feature
|-- controller.js
|-- directive.js
|-- service.js
|-- style.css
|-- html_file.tpl.html
|-- bar_feature
|-- controller.js
|-- directive.js
|-- service.js
|-- style.css
|-- html_file.tpl.html
|-- lib
|-- jquery.js
|-- angular.js
|-- ...
and so on.
If we build it like this, we can wrap every directory of ours in an angular module. And we have split our files in a nice way that we don't have to go through irrelevant code when we are working with a specific feature.
A task runner like Grunt properly configured, will be able to find and concatenate and compile your files without much hassle.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With