Typical AngularJS workflow and project structure (with Python Flask)
I am pretty new to this whole MV* client-side framework frenzy. It doesn’t have to be AngularJS, but I picked it because it feels more natural to me than either Knockout, Ember or Backbone. Anyway what is the workflow like? Do people start with developing a client-side application in AngularJS and then hooking up the back-end to it?
Or the other way around by first building the back-end in Django, Flask, Rails and then attaching an AngularJS app to it? Is there a “right” way of doing it, or is it just a personal preference in the end?
I am also not sure whether to structure my project according to the Flask or AngularJS? community practices.
For example, Flask’s minitwit app is structured like so:
|– css, js, images, etc…
|– html files and base layout
AngularJS tutorial app is structured like this:
`– node.js server and test server files
I could picture a Flask app by itself, and it’s fairly easy to see AngularJS app like ToDo List by itself but when it comes to using both of these technologies I don’t understand how they work together. It almost seems like I don’t need a server-side web-framework when you already have AngularJS, a simple Python web server will suffice. In the AngularJS to-do app for example they use MongoLab to talk to the database using Restful API. There was no need having a web framework on the back-end.
Maybe I am just awfully confused, and AngularJS is nothing more than a fancy jQuery library so I should use just like I would use jQuery in my Flask projects (assuming I change the AngularJS template syntax to something that doesn’t conflict with Jinja2). I hope my questions make some sense. I mainly work on the back-end and this client-side framework is an unknown territory for me.
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:
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:
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.
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.
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.
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.
Another option is to completely separate the two.
project |-- server |-- client
Files related to flask goes under the server folder and files related to angularjs goes under the client folder. This way, it will be easier to change the backend or front-end. For example, you might want to switch from Flask to Django or AngularJS to ReactJS in the future.
I think it is important to determine at what end you want to do most of your data processing – front end or back end.
If it’s front end, then go with the angular workflow, which means your flask app will function as more of an api where an extension like flask-restful will come end.
But if like me, you are doing most work on the backend, then go with the flask structure and only plug angular ( or in my case vue.js) to build the front end (when neccessary)