Is there an obvious way to do this in python?

[H J van Rooyen]

"Bruno Desthuilliers" <bdesth.quelquechose at free.quelquepart.fr> wrote:


|H J van Rooyen a écrit :
|> Hi,
|>
|> I want to write a small system that is transaction based.
|>
|> I want to split the GUI front end data entry away from the file handling and
|> record keeping.
|>
|> Now it seems almost trivially easy using the sockets module to communicate
|> between machines on the same LAN, so that I want to do the record keeping on
one
|> machine.
|>
|> I want to keep the "server" machine as simple as possible - just doing record
|> keeping on a stimulus response basis - I would prefer it to do one thing at a
|> time to completion because this style of operation, though limited in
|> performance, keeps a lot of hassles out of life - a transaction has either
|> completed, or it has not - recovery scenarios are relatively easy...
|
|IOW, you want a SQL DBMS. May I recommand PostgreSQL ?
|

Looks like the way to go - after the argy bargy here in another thread seems
mySQL has no supporters left...

|> Up to this point, I don't have a problem - my toy system can create a dummy
|> transaction, and I can echo it from the "server" machine, with more than one
|> "user" machine running - so I think it is feasible to have several tens of
"data
|> entry terminal" systems running, served by one not very strong machine.
|>
|> Now what I would really like to do is to differentiate between the 'User"
|> machines, so that some can do a full range of transactions, and others a
limited
|> range.
|
|Any decent SQL DBMS is able to handle this. It's kind of builtin...

Yes - if you do the whole job on the server - the architecture I have mind is
more like a banking terminal scenario - please see my reply to Simon

|
|> And I would like to make this flexible, so that it becomes easy to introduce
new
|> transactions, without having to run around updating the code in all the user
|> machines, with the concomitant version number hassles.
|
|Then you want a web front end.

This seems to me to assume that the server does all the work

|
|> And I would like to do the whole thing in python
|
|You'll at least need bits of SQL (but SQLAlchemy may hide away most of
|it) and HTML (but there are some python packages that knows how to build
|HTML from declarative Python code).
|

that is good news - which packages?

|> - so my question is this - is
|> it possible to do the equivalent of dynamic linking? - i.e. if I keep a list
of
|> what a user is allowed to do
|
|In SQL : GRANT/REVOKE

again - centric thinking - I really would like to change the bits on the client,
as I explained to Simon

|
|> - can I somehow send him just the bits he needs to
|> do the job, without having to change the static code on his machine?
|
|HTTP/HTML.
|

everybody says this - I am being dragged, kicking and screaming...

|> - it seems
|> to me that the eval() thingy could possibly do this for me,
|
|Err... I thought you wanted a reasonnably secure system, but I may have
|misunderstood.
|

this is the guts of what I want - if eval is NFG then how do I implement such a
kind of "dynamic linking" of modules on the client?

|> by sending it data
|> that makes it do import statements followed by calls to whatever... - will
this
|> work, or is there a better way?
|>
|> Or has all this been done already?
|
|Yes, it's called a web frontend for a SQL DBMS. There's no shortage of
|Python frameworks to do this kind of things.
|

I kind of wanted to avoid the web based stuff - the application data is so small
and trivial, in a sense.

|> - and no I don't want a web server
|
|If you don't want Apache, there are Python-based application servers.
|CherryPy comes to mind.
|
|> and php
|
|Why PHP ?
|

seems popular

|> and browsers and Java
|
|Why Java ?
|

it addresses what I want - to dynamically and securely download bits of code and
execute them on the remote machine...

|> and html or xml... - I want to write something that works
|> simply and reliably
|
|We do write SQL-based web apps all day long, and I can tell you they are
|certainly more simple and reliable than whatever eval()-based home-made
|solution we could imagine !-)

Aah! but I would like you to stretch that imagination - to tell me how to do
some of what Java was designed to do, but better and easier, because this is
python we are talking about...

I saw something in another thread here - they were talking about weave - can I
use that if eval is nfg?

If my original post was unclear I am sorry - the point I want answered, if
possible, is how to make the client code effectively updateable on the fly -
because the answer to this will influence the whole design of the rest of the
system...

- Hendrik