Hi Dmitry, hi Ian,
thanks for the help.
I got it to work. Here is what I am doing.
Django gets a request for "/data.json". A view function is called.
This is my function:
def data(request):
return HttpResponse(subsampling(), mimetype='application/javascript')
subsampling() is an iterator, i.e. it yields data every once in while.
Look at:
http://docs.djangoproject.com/en/dev/ref/request-response/#passing-iterators
I am yielding simplejson.dumps(my_dict) + '\n' which is then received
by the client. The original request for data.json came from an ajax
function (using jQuery). At the beginning using 'beforeSend' I start a
function that takes the XmlHttpRequest.responseText and sees how much
data has arrived and appends that data to the already existing data. I
do this every 10ms and stop once the xmr.readyState indicates that the
connection was closed.
I am quite satisfied with this result. It does not use much memory and
is much faster (and feels much faster) than before.
I tested it under Chromium, Firefox and Konqueror. I will add some
additional functionality and make it a nice graphics module in the
late summer. Probably GPL'ed. It would be for people like me, who have
lots of data and want to make them available interactively.
Regards,
Christoph
On Mon, Jun 14, 2010 at 12:13 PM, Ian McDowall wrote:
> As the other posters say, this is not possible with standard HTTP and
> certainly not with Django.
>
> By default, HTTP is one request / one response and Django (and other
> web frameworks) are built on that. Take a look at the HTTP spec and
> try looking at the packet contents for HTTP requests - it is quite
> educational.
>
> Paying attention to the innards of HTTP, it is possible to have a
> response that is delivered in more than one packet and so the client
> can receive part of the response followed by more of the response
> later and so on. I think that this is normally used as a technique
> for long-polling and I am doubtful that the browser client will handle
> it as you want and even more doubtful that a Django (or similar)
> framework will handle it as you want. If you want to experiment with
> HTTP and server internals then it could be quite interesting but as a
> way to actually get the job done it is likely to be a red herring.
>
> Other techniques beyond straight HTTP include web sockets and server
> events - both part of HTML5. These would let your client receive
> updates from the server as and when ready. Unfortunately, these are
> not well supported by current browsers (AFAIK Chrome supports we
> sockets and Opera has a version of server sent events) and you will
> need a custom server. I am using similar techniques to implement real
> time event handling but I have had to build my own server and accept
> that I cannot use certain browsers.
>
> To go back to your original question and assuming that you want a
> simple way of getting the job done then I think that you either have
> to accept the delay and do the calculation in one go or handle
> multiple requests. Performing the calculation in one go may take some
> time but AJAX is asynchronous so the user can see what ever progress
> info you want to show (i.e. an hourglass). If the work really will
> take too long then multiple requests looks necessary but remember that
> you will need to cache the calculation between requests or do it in a
> separate thread and make it available. Remember that each Django
> request is normally run in isolation and nothing is persisted when it
> is finished unless you write it to a database. if you can make the
> calculation such that nothing needs to persist (or each request
> includes the result from the previous one) then that may be OK.
>
> Is there any option to pre-calculate so the results are easily
> availabl?
> Regards, Ian McDowall
>
> On Jun 11, 4:15 pm, Christoph wrote:
>> Hi,
>>
>> normally in views.py I have a function that takes a request and
>> returns a render_to_response or the like. I, however, would like it to
>> take a request and have Django reply with multiple responses. Is there
>> a way to do this, or is this not possible with HTTP anyway?
>>
>> What I am trying to achieve: Have a a view that gets called and in it
>> I have a JS/AJAX script that asks for some data. However, calculating
>> the data takes a while and it comes one after the other. So I thought
>> that I could send the data as soon as it becomes available.
>>
>> In my example I have a graph (using flot) and it would also look
>> natural to have the data points show up one by one.
>>
>> A different approach: Have JS ask for more data (using GET) until the
>> view responses sets a flag (NO_MORE_DATA = True). I don't like this,
>> since for me this looks like it defies the A in AJAX and the view
>> would lose all parameters (I.e. which points it already sent and which
>> not). However, I don't know much JS, nor AJAX nor do I understand the
>> HTTP protocol good enough.
>>
>> Maybe this has
