Python database application framework and tools
I have been building business database applications such as finance, inventory and other business requirement applications. I am planning to shift to Python. What would be the tools to start with best. I would need to do master, transaction forms, processing (back end), reports and that sort of thing. The database would be postgress or mysql. As I am new to Python I understand that I need besides Python the ORM and also a framework. My application is not a web site related but it could also be need to be done over the web if needed.
How to choose the initial setup of tool combinations?
Answer
If I were you, I would probably first look whether a web-based solution based on Django does the trick. If you need a little bit better look and feel, add jQuery to the mix. If it provides way too little functionality, go for PyQt. If you have a lot of very small applications, go for a mix of technologies. Below, you find my (somewhat lengthy) reasoning for this recommendation.
Webapp vs. desktop application
One year ago, we had a business db and needed a front-end. We had to decide what technology to use for the front-end. We considered:
The advantages for PyQt from our perspective:
- Previous C++ experience with Qt from which we knew that Qt is suited for the task.
- All necessary tools included.
- Easy to develop rich clients.
We however decided against PyQt and for a web-based solution instead. Reasons were:
- The requirements for the front-end were modest and easy to do within a browser (mostly reporting, some forms for entering data or running functions).
- Deployment of the application (and new versions, bug fixes, etc.) is much easier as everything only happens on the server in a controlled environment.
- Access control / authentification / rights is "for free" as it is part of the server (in our case Apache using Active Directory Authentification) and the browser, which is important for us.
- The application needed server connection anyways and didn't have to store anything on the client's side.
In a nutshell: feature-rich front-ends with a lot of functionality in a controlled deployment environment are probably easier to implement with Qt. For our light-weight front-ends, a server-based solution seemed better to us.
Which web framework?
Now that we had decided on a technology, we had to choose a framework. We researched a bit, and looked at two alternatives in detail:
- Django
- A stack of software consisting of CherryPy as dispatcher (to match http requests to functionality and all the related stuff), Mako as a templating library to generate web-pages, SQLAlchemy as an ORM, and jQuery for client-side functionality.
We evaluated the two alternatives, and at the end settled for the second one. The decision was driven by our really "light-light-weight" front-end requirements (a lot of very small applications). A stack of software - which we can mix and match as needed - seemed better to us. We can re-use SQLAlchemy in situations, where we don't need a web-front-end, we can just use CherryPy without a templating library and a ORM, and so on. In many other cases, I would however choose Django over this stack.
To sum up:
- one big, complex application -> PyQt
- a set of relativily similar, straigtforward reports, forms, etc. with one look-and-feel -> Django
- a relatively diverse set of things that differ widely in requirements and used technology or re-use of some technology in other circumstances -> mix of technologies as needed