Async callback in python

[Linan]

Hi,

In javascript, code could be written like this:

....

var _p=XMLHttpReque st();
_p.open('GET',u rl,true);
_p.send(null);
_p.onreadystate Change=function (){
if(_p.readyStat e==4)
cb(_p.responseT ext);
}
....

This basic AJAX code allows function to be called when it's invoked,
without blocking the main process. There is same library asyncore in
python. However, I can't validate it's asynchronous through code:
class T(asyncore.disp atcher):
def __init__(self,h ost,url):
asyncore.dispat cher.__init__(s elf)
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
self.connect((h ost,80))
self.url='GET %s HTTP/1.0\r\n\r\n' % url

def handle_connect( self):
pass

def handle_close(se lf):
self.close()

def handle_read(sel f):
print 'READING.....'
print self.recv(256)

def handle_write(se lf):
sent=self.send( self.url)
self.url=self.u rl[sent:]

t=T('aVerySlowS ite','/')
asyncore.loop()
for i in range(0,10):
print '%d in main process' % i
time.sleep(1)

Suppose it's asynchronous, couple of '%d in main process' lines should
be mixed in the output of T.handle_read() , right? But I found that
actually main process was blocked at asyncore.loop() , until the the
socket was closed. My questions:
1, Did I do anything wrong?
2, Is it real asynchronous?
3, If not, where to get the real one(s)?

Any comment is welcome :)

[tleeuwenburg]

Did you flush the buffer?

It might be that the print statements are being called in the order you
expect but that they are all written to the screen only at the end.
I've had that happen before.

Cheers,
-T

Linan wrote:

Hi,

In javascript, code could be written like this:

...

var _p=XMLHttpReque st();
_p.open('GET',u rl,true);
_p.send(null);
_p.onreadystate Change=function (){
if(_p.readyStat e==4)
cb(_p.responseT ext);
}
...

This basic AJAX code allows function to be called when it's invoked,
without blocking the main process. There is same library asyncore in
python. However, I can't validate it's asynchronous through code:
class T(asyncore.disp atcher):
def __init__(self,h ost,url):
asyncore.dispat cher.__init__(s elf)
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
self.connect((h ost,80))
self.url='GET %s HTTP/1.0\r\n\r\n' % url

def handle_connect( self):
pass

def handle_close(se lf):
self.close()

def handle_read(sel f):
print 'READING.....'
print self.recv(256)

def handle_write(se lf):
sent=self.send( self.url)
self.url=self.u rl[sent:]

t=T('aVerySlowS ite','/')
asyncore.loop()
for i in range(0,10):
print '%d in main process' % i
time.sleep(1)

Suppose it's asynchronous, couple of '%d in main process' lines should
be mixed in the output of T.handle_read() , right? But I found that
actually main process was blocked at asyncore.loop() , until the the
socket was closed. My questions:
1, Did I do anything wrong?
2, Is it real asynchronous?
3, If not, where to get the real one(s)?

Any comment is welcome :)

[Calvin Spealman]

On 4 Dec 2006 20:18:22 -0800, Linan <ta*******@gmai l.comwrote:

Hi,

In javascript, code could be written like this:

...

var _p=XMLHttpReque st();
_p.open('GET',u rl,true);
_p.send(null);
_p.onreadystate Change=function (){
if(_p.readyStat e==4)
cb(_p.responseT ext);
}
...

This basic AJAX code allows function to be called when it's invoked,
without blocking the main process. There is same library asyncore in
python. However, I can't validate it's asynchronous through code:
class T(asyncore.disp atcher):
def __init__(self,h ost,url):
asyncore.dispat cher.__init__(s elf)
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
self.connect((h ost,80))
self.url='GET %s HTTP/1.0\r\n\r\n' % url

def handle_connect( self):
pass

def handle_close(se lf):
self.close()

def handle_read(sel f):
print 'READING.....'
print self.recv(256)

def handle_write(se lf):
sent=self.send( self.url)
self.url=self.u rl[sent:]

t=T('aVerySlowS ite','/')
asyncore.loop()
for i in range(0,10):
print '%d in main process' % i
time.sleep(1)

Suppose it's asynchronous, couple of '%d in main process' lines should
be mixed in the output of T.handle_read() , right? But I found that
actually main process was blocked at asyncore.loop() , until the the
socket was closed. My questions:
1, Did I do anything wrong?
2, Is it real asynchronous?
3, If not, where to get the real one(s)?

Any comment is welcome :)

--
http://mail.python.org/mailman/listinfo/python-list

You seem to be confusing the terms "asyncronou s" and "threaded".
Although multi-threading is a way to implement asyncronous software,
it is not the only or the best way to get those results. Usually the
term "asyncronou s" is attached to non-threaded methods, because
"multi-threading" is usually just used for those threaded methods.

Thus, solutions like asyncore are ways to allow asyncronous code
without threading, and usually this involves a loop, as with asyncore,
and until all the asyncronous operations running in the loop are
complete, the loop does not end.

If you wanted to have these prints interlaced in the http download,
you might schedule them as a seperate asyncronous operation.

I hope that helped.

PS - Another, more complete asyncronous framework is the Twisted
project (http://www.twistedmatrix.com/)

--
Read my blog! I depend on your acceptance of my opinion! I am interesting!
http://ironfroggy-code.blogspot.com/

[Felipe Almeida Lessa]

On 4 Dec 2006 20:18:22 -0800, Linan <ta*******@gmai l.comwrote:

3, If not, where to get the real one(s)?

After reading Calvin's mail, you may want to see
http://twistedmatrix.com/ . It's an assynchronous library built around
the concept of deferreds (think of callbacks). You may like it =).

Cya,

--
Felipe.

[Gabriel Genellina]

At Tuesday 5/12/2006 01:18, Linan wrote:

>t=T('aVerySlow Site','/')
asyncore.loop( )
for i in range(0,10):
print '%d in main process' % i
time.sleep(1)

Suppose it's asynchronous, couple of '%d in main process' lines should
be mixed in the output of T.handle_read() , right?

No. As you noticed, asyncore.loop (without arguments) won't return
until all channels are closed.

>But I found that
actually main process was blocked at asyncore.loop() , until the the
socket was closed.

Exactly.

>My questions:
1, Did I do anything wrong?
2, Is it real asynchronous?
3, If not, where to get the real one(s)?

Perhaps you didn't understand the nature of asyncore processing. The
idea is not to have many threads, each one blocking on its own
(synchronous) socket processing. Instead, using a single thread which
never blocks, and dispatches events to many instances, each one
processing its own data.
If you want to do other things mixed with network events, put those
things inside the loop, that is, instead of asyncore.loop() do something like:

while asyncore.socket _map:
asyncore.loop(1 , count=1)
// do other things
--
Gabriel Genellina
Softlab SRL

_______________ _______________ _______________ _____
Correo Yahoo!
Espacio para todos tus mensajes, antivirus y antispam ¡gratis!
¡Abrí tu cuenta ya! - http://correo.yahoo.com.ar

[Chris Mellon]

On 12/4/06, Calvin Spealman <ir********@gma il.comwrote:

On 4 Dec 2006 20:18:22 -0800, Linan <ta*******@gmai l.comwrote:

Hi,

In javascript, code could be written like this:

...

var _p=XMLHttpReque st();
_p.open('GET',u rl,true);
_p.send(null);
_p.onreadystate Change=function (){
if(_p.readyStat e==4)
cb(_p.responseT ext);
}
...

This basic AJAX code allows function to be called when it's invoked,
without blocking the main process. There is same library asyncore in
python. However, I can't validate it's asynchronous through code:
class T(asyncore.disp atcher):
def __init__(self,h ost,url):
asyncore.dispat cher.__init__(s elf)
self.create_soc ket(socket.AF_I NET, socket.SOCK_STR EAM)
self.connect((h ost,80))
self.url='GET %s HTTP/1.0\r\n\r\n' % url

def handle_connect( self):
pass

def handle_close(se lf):
self.close()

def handle_read(sel f):
print 'READING.....'
print self.recv(256)

def handle_write(se lf):
sent=self.send( self.url)
self.url=self.u rl[sent:]

t=T('aVerySlowS ite','/')
asyncore.loop()
for i in range(0,10):
print '%d in main process' % i
time.sleep(1)

Suppose it's asynchronous, couple of '%d in main process' lines should
be mixed in the output of T.handle_read() , right? But I found that
actually main process was blocked at asyncore.loop() , until the the
socket was closed. My questions:
1, Did I do anything wrong?
2, Is it real asynchronous?
3, If not, where to get the real one(s)?

Any comment is welcome :)

--
http://mail.python.org/mailman/listinfo/python-list

You seem to be confusing the terms "asyncronou s" and "threaded".
Although multi-threading is a way to implement asyncronous software,
it is not the only or the best way to get those results. Usually the
term "asyncronou s" is attached to non-threaded methods, because
"multi-threading" is usually just used for those threaded methods.

Thus, solutions like asyncore are ways to allow asyncronous code
without threading, and usually this involves a loop, as with asyncore,
and until all the asyncronous operations running in the loop are
complete, the loop does not end.

If you wanted to have these prints interlaced in the http download,
you might schedule them as a seperate asyncronous operation.

I hope that helped.

PS - Another, more complete asyncronous framework is the Twisted
project (http://www.twistedmatrix.com/)

In addition to the above, you misinterpret the way the posted
JavaScript works. JavaScript uses a "run to completion" model and, in
browsers, is purely event-based. There is no "main process" to block,
and if you simulate one via a loop, the code you posted won't work.

Except in IE, because it violates the ecmascript standard and will
'call back' from the implementation to the javascript environment
without regard for the current state of that environment.