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 <christophsieden...@gmail.com> 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 been done before? Is there a way of having server-side
> generated AJAX-actions? Is there a way of having Django send something
> within a views-function (as opposed to returning it at the end)?
>
> Some possible code:
>
> def my_view(request):
> data =
> MyModel.objects.filter('something').order_by('somethingelse')
> for item in list(data): # Note, I don't do this but this is just
> to show how what I want
> send_json(do_something(item)) # send_json() is the crucial
> (non-existing) function that I am looking for
> return None # or maybe return Done or something like it
>
> Best regards,
> Christoph
--
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-us...@googlegroups.com.
To unsubscribe from this group, send email to
django-users+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en.
