I am in the planning stages of rewriting an Access db I wrote several years ago in a full fledged program. I have very slight experience coding, but not enough to call myself a programmer by far. I'll definitely be learning as I go, so I'd like to keep everything as simple as possible. I've decided on Python and SQLite for my program, but I need help on my next decision.
Here is my situation
1) It'll be run locally on each machine, all Windows computers
2) I would really like a nice looking GUI with colors, nice screens, menus, lists, etc,
3) I'm thinking about using a browser interface because (a) from what I've read, browser apps
can look really great, and (b) I understand there are lots of free tools to assist in setting up the GUI/GUI code with drag and drop tools, so that helps my "keep it simple" goal.
4) I want the program to be totally portable so it runs completely from one single folder on a user's PC, with no installation(s) needed for it to run
(If I did it as a browser app, isn't there the possibility that a user's browser settings could affect or break the app. How likely is this?)
For my situation, should/could I make it a browser app? What would be the pros and cons for my situation?
Writing a desktop application as a locally-hosted web application isn't typically a good idea. Although it's possible to create great user interfaces with HTML, CSS, and Javascript, it's far easier to create interfaces with conventional GUI frameworks.
Using web technologies to create your desktop GUI would introduce a great deal of unnecessary complexity to your application.
Creating user interfaces with HTML and CSS is difficult and time-consuming. HTML is a document markup language and CSS is a document formatting language; neither is well-suited to creating GUIs.
Using web technologies makes your application depend on the user's web browser. Far too many people are still using old, crippled browsers such as IE 6 and 7 that don't follow modern standards. You'll spend hours if not days trying to track down interface bugs that only happen on certain browsers.
You'll need to serve your application with a web server, introducing another layer of complexity. Your application will have to communicate with your interface through restricted web technologies without any of the benefits of a true web application.
I recommend using a desktop GUI framework, instead. In particular, I think wxPython would be the best GUI framework for you to use; it's stable, widely used, well documented, and highly portable. In addition, you can use a GUI-based interface builder such as Boa Constructor or possibly wxGlade to design your application's user interface. In summary, creating an application with almost any desktop GUI framework would be easier than using web technologies.
I've done a desktop app running on windows and I think that it is a great way to develop app.
I would recommend to have a look at bottle. It is a lightweight web framework. It is less capabale than Django for example but it does well. It can be packed with py2exe if you want to deploy on machines without Python.
There is a lot of javascript libs on the web to help you. I like jquery and jquery-ui, raphaeljs ... but there are some others.
My app is running into a small browser based on the mshtml component of Pyjama-Desktop. This way, the user doesn't know that it is a web app. But you could let the app running into the favorite browser, webbrowser python module might be interesting for you.
If your app needs to access your filesystem, a browser-based app may be tricky. For security reasons, a browser doesn't have full access to your filesystem. However, you can mimick file open with ajaxupload and file save with an iframe.
If it only deals with a sqllite database, i think that it is a very good choice.
I hope it helps
Pyjamas-Desktop
You did not mention if you are on windows or linux or any other OS.
If you are writing a browser app the first thing you are going to need is a web server, if each user is running the app on his local machine => means each user has to have a webserver running locally.
Also there are a lot of Rapid Development GUI toolkits such as wxPython and Glade which make design of GUI apps simple and easier.
I would suggest that if you are building a network app -> Take the browser route.
If you are building standalone app then go with a native application.
Here is an almost exhaustive list of all the frameworks. you can choose whatever suits your needs.
http://wiki.python.org/moin/GuiProgramming
I personally favor PyGtk, however it has a little learning curve associated with it if you havent done any GUI programming before.
I think it should work. What are you afraid of? Proxy settings, firewall?
I think running web server locally isn't hard for power user but it could be a problem for average user (even integrated with your app).
Probably You should run your app as service because forcing user to start server before entering web page, could be frustrating.
I would prefer other solutions. I would probably use Java (Swing) or C++ with QT. But I like Your approach, especially that it allows easy prototyping. If You prefer web style development you could try http://www.appcelerator.com/products/titanium-desktop-application-development/ it creates desktop apps using html+java script +webkit. But I didn't tried it my self (but I would like to).
Also Adobe Air could be probably good option for You.
I would suggest a browser application. This eliminates the need for installation on client computers (and as such, as OS agnostic), and is accessible from anywhere in the world if the DNS is set up correctly for the server.
Using a web interface allows you to make use of some of the more powerful User Interface tools, such as:
The ability to use CSS for spectacular design
The availability of JavaScript Utilities (jQuery, ExtJS, etc.)
Easily modified compared to Desktop applications
Higher accessibility
Consistent UI (e.g. Users already know how "back" works, etc)
Centralized updates (Just update the server, not each client)
Your choice of application type will be related both to the technology constraints and the type of user experience you plan to deliver.
Rich Client Application:
Usually developed as a stand-alone application.
Can support disconnected or occasionally connected scenarios.
Uses the processing and storage resources of the local machine.
Web Application:
Can support multiple platforms and browsers.
Supports only connected scenarios.
Uses the processing and storage resources of the server.
I personally favor PyQt in your case for a portable application.
The homepage for PyQt is http://www.riverbankcomputing.com/software/pyqt/
PyQt supports the Windows, Linux, UNIX and MacOS/X platforms.
PyQt4 is a set of Python bindings for Qt 4 that are dual-licensed under the GPL (version 2 and 3, with additional license exceptions) and a commercial license. There is also PySide by Nokia - new alternative bindings (as of November 2009) with LGPL license that struggle to be API compatible (at least until Qt 4.6) with PyQt4.
Tools and docs
PyQt Reference Documentation.
PyQt4 book: http://www.qtrac.eu/pyqtbook.html
The pyuic4 utility is a command line interface to the uic module. Conver xml ui from Qt to python.
Qt Designer is a powerful cross-platform GUI layout and forms builder. It allows you to rapidly design and build widgets and dialogs using on-screen forms using the same widgets that will be used in your application.
PyQt4 exposes much of the functionality of Qt 4 (From Nokia) to Python, including:
A comprehensive set of widgets
Flexible layout managers
Standard GUI features for applications (menus, toolbars, dock windows)
Easy communication between application components (signals and slots)
A unified painting system with transparency, anti-aliasing, OpenGL integration and SVG support
Internationalization (i18n) support and integration with the Qt Linguist translation tool
Etc.
You question is a little broad. I'll try to cover as much as I can.
First, what I understood and my assumptions.
In your situation, the sqlite database is just a data store. Only one process (unless your application is multiprocess) will be accessing it so you won't need to worry about locking issues. The application doesn't need to communicate with other instances etc. over the network. It's a single desktop app. The platform is Windows.
Here are some thoughts that come to mind.
If you develop an application in Python (either web based or desktop), you will have to package it as a single executable and distribute it to your users. They might have to install the Python runtime as well as any extra modules that you might be using.
Guis are in my experience easier to develop using a standalone widget system than in a browser with Javascript. There are things like Pyjamas that make this better but it's still hard.
While it's not impossible to have local web applications running on each computer, your real benefits come if you centralise it. One place to update software. No need to "distribute" etc. This of course entails that you use a more powerful database system and you can actually manage multiple users. It will also require that you worry about browser specific quirks.
I'd go with a simple desktop app that uses a prepackaged toolkit (perhaps Tkinter which ships with Python). It's not the best of approaches but it will avoid problems for you. I'd also consider using a language that's more "first class" on windows like C# so that the runtimes and other things are already there. You requirement for a fancy GUI is secondary and I'd recommend that you get the functionality working fine before you focus on the bells and whistles.
Good luck.
Related
Ok I was doing some data science in python over the weekend and I got to looking at python for mobile development. I was curious as to if it's possible to use both Python (back-end) and use Kotlin (front-end) together?
I know python is a non GUI unless you use kivy or flask. However I was thinking if it's possible can you cross python and Kotlin together.
There is a lot apps that use python as the backend, and another language for the front end. I have done some research and found that Kivy (unstable from my research) can be used for mobile development. However for Android Kotlin is the preferred choice by Google.
Which throws me off because Google uses python for the backend. So when you look at the Google Apps on the Play Store, are they using python and java in mobile apps?
The app I am planning which will be released to Google Play on my developer page will be a Data Driven app. So things would go much smoother if I could combine the two.
Has anyone tried using python and Kotlin? However, would I be stuck with Python and Kivy?
The language used to program frontend vs backend don't matter, the only thing that matters is how the two communicate (assuming when you say backend you mean like a server and not like a game engine). Traditionally, applications will communicate with a backend using a REST API. So long as both sides abide by the same rules for talking to each other, it doesn't matter what language they were programmed in, known as a communication protocol.
The situation that you presented of a Kotlin frontend with a Python backend is definitely being used in production environments, and you shouldn't be afraid to do so either.
See also this related question, though I personally wouldn't recommend using Python to write an Android application because I believe natively supported first-class languages are going to produce more performant, reliable apps than non-native second/third-class languages (I haven't done more than find that SO question, so take my opinion with a grain of salt)
I'm looking to develop a web app that controls Concept2 rowing gym equipment connected to the users computer via USB. I'm trying to decide what approach I should take in developing something like this.
Control of these devices has been achieved in the past both in python:
(https://github.com/uvd/PyRow)
and using node/jQuery:
(https://github.com/tijmenvangulik/ErgometerJS).
An SDK and documentation is provided by the developers of Concept2 gym equipment. DLL and CSafe commands are used to interface with the machines monitors.
(https://www.concept2.com/service/software/software-development-kit)
I'm looking for recommendations on how I should this tackle this project. At the moment python seems like the best approach however I have no idea how I can run these python files through a website interacting with the java script front end.
Any advice or pointers is appreciated.
David
You task looks like a simple SCADA solution with web interface.
You choice depends on whether you have experienced developers, who are able to use modern frameworks like Vue.js, Angular, React and others or not.
Really, in your particular case - monitoring equipment over web, you don't necessary need to invest a lot in your front-end - depends on your target audience. Is it a single service engineer? If yes, probably your front-end should be minimalistic, you can use Python with Twisted for static web server and build your frontend on bootstrap plus jquery. This is a fast win solution and you can implement it even if you've never worked with web.
More complex approach, requiring more engineering, is Python + Flask.
If you feel ready for modern frameworks, like Vue, React, Angular, then, possibly, you'd better look at NodeJs as a backend. They are better integrated with NodeJs and its package manager npm. You will need it to build the project on your server side; also some people treat it as a solid solution, when using the same language (javascript) for both backend and frontend. As for me, it doesn't really matter a lot.
I have some data in an SQLite database and serve it through JSON objects to an HTML app via AJAX calls and chart it using D3.js. I would like to replicate the same functionality locally (MS Windows is fine) in a self-contained application. It would be a super simple app, just a few form controls, a chart and a table, querying a local file-based database. As for it being self-contained - I'd like to ship an .exe file and an .sqlite file to someone with no need to install python, numpy, matplotlib, sqlite or anything on the target computer.
I'd like to it to be quite future-proof, so I'd rather stay away from experimental/alpha libraries and build it using more proven technologies that have had longer term support. It seems that PyInstaller is the way to go in terms of self-containing, but developers seem to be quite divided when it comes to GUI options.
The question is then: What's the industry standard to build future self-contained GUI apps in Python? One which would include SQLite access and charting. Thanks!
Python itself includes the sqlite module since version 2.5:
https://docs.python.org/2/library/sqlite3.html
So regardless of which Python GUI Toolkit you go with, you already have that functionality built in to Python. There are several options to choose from when it comes to Python GUI toolkits. If you want a toolkit that can handle theming / skinning, then you may want to look at PyQt or even Kivy. The only GUI toolkit that uses the actual widgets of each major OS that I know of is wxPython. All the others draw their own widgets, albeit some of them do it so well that you'd be hard-pressed to tell the difference (i.e. PyQt).
All three of these projects are stable and are currently being developed, although wxPython's development is much slower than the others mentioned here. wxPython and PyQt both have widgets that allow you to load web pages.
However if all you want to do is serve web pages locally, then you might be better served using a Python web framework such as Django or Flask. You could run these locally pretty easily and view your content via the user's browser. The exe could launch them locally and call Python's webbrowser module to launch the default browser to a local URL.
I am new with Django. I need to quickly develop a sophisticated GUI for a Django project. My underlying database is resource description framework (RDF). Is there any Eclipse IDE available for quick Django GUI development? Or is there any other GUI development tool (provides widgets) available for Django based project?
JetBrains has a Product for Python developers with Django support.
Its not for free but you can try it for 30 days.
https://www.jetbrains.com/pycharm/
Django is a web framework. It doesn't have a GUI. Though there are many IDEs that support Django template syntax, none of them will provide any kind of GUI functionality.
As far as IDEs go, Jetbrains is good, Eclipse has pretty decent python support, though I'm a big fan of sublime texts smart simplicity.
As for GUI stuff, perhaps rethink a little here. Django is a web framework that deals best with transactional interaction. It fires you a web page, you fire it a response. The system isn't really a good fit to GUI stuff. Thats not to say it can't play a part. Instead consider splitting it into a client/server product. Both TastyPie and Django Rest Framework are good options for building a RESTful API that can be interrogated by a remote client. You can then build the client using either one of the visual studio suites, or delphi, or if your looking to stay within the python mothership, perhaps PyQT/PySide (Which include a visual form designer) would be more up your alley. I guess you could build djangos ORM into an app (Although personally I'd use SQLAlchemy for that as its more decoupled than djangos ORM), but I'd warn that direct network access to databases isn't generally held to be wise for obvious security reasons, and you need to have a have a hard think about the threading implications if your gui toolkit is multithreaded, because Djangos ORM isn't built with the assumption it'll need to deal with multiple threads over single objects. My 0.02c is use Django to build an API and PyQT (or whateer your comfortable with) for the front end.
GUI is a term more for desktops, frontend is for web, for more see https://en.wikipedia.org/wiki/Graphical_user_interface.
Try any HTML5 WISWYG editor to make frontend (probably responsive) design.
More no this look in https://softwareengineering.stackexchange.com/questions/148489/how-to-develop-front-end-ui-for-my-django-website
I'm trying to build a desktop application using Python. To make it able to be used on as many platforms as possible, I think web UI may be a good choice. This boils down to the problem of making a local HTTP server first. I did some survey and found that people are mainly talking about BaseHTTPServer and SimpleHTTPServer. For prototyping, subclassing them may suffice.
Besides pure prototyping, I also want to leave some room for extension to real service. That is, once mature, I'd like to move the codes to a real dedicated HTTP server, so that end users only need a browser to use it.
I say "extensible" in the following sense:
The code modification is as minimum as possible in the migration process.
I will focus on algorithm in the prototyping stage. I also want to leave some room for future front end designer.
It looks WSGI + Django is a widely mentioned combination. After some search, what I found is using WSGI in apache or nginx. Is it possible to use self-contained modules? i.e. wsgiref + Django, so that I can start everything just from one entry script. I don't want to bother potential first adopters by asking them install apache and configure it. It will be very good if you have sample codes or pointers for further reading.
I'm new to Python and web programming in Python. Thanks for your help. I just try to make sure I'm on the right track. My underlying algorithms is implemented in Python 2.7. So the UI solution had better also be in Python 2.7.
I think what you may want is Bottle. It is a web framework that only needs the standard library to be installed. It also has compatibility with many other production servers, as well as shipping with it's own development server. And if that isn't good enough, it is all in a single file, and has support with many different templating languages, as well as it's own built in templating language.
Check it out here: http://bottlepy.org/docs/dev/
As mentioned bottle is a good choice, I personally like Flask, which if I recall correctly is what bottle is based off of. Anyways there are three things that really make Flask a joy to use.
Blueprints - essentially an application architecture
Flask-Sijax - allows for comet technology
Celery - an asynchronous task queue/job queue based on distributed message passing
there are a lot of other plugins, including one for an admin interface that I haven't tried out yet but it looks promising, and it works with Python 2.7