<p>How can I fetch more than 1000 record from data store and put all in one single list to pass to django?</p>

You can't.
Part of the FAQ states that there is no way you can access beyond row 1000 of a query, increasing the "OFFSET" will just result in a shorter result set,
ie: OFFSET 999 --> 1 result comes back.
From Wikipedia:
App Engine limits the maximum rows
  returned from an entity get to 1000
  rows per Datastore call. Most web
  database applications use paging and
  caching, and hence do not require this
  much data at once, so this is a
  non-issue in most scenarios.[citation
  needed] If an application needs more
  than 1,000 records per operation, it
  can use its own client-side software
  or an Ajax page to perform an
  operation on an unlimited number of
  rows.
From
http://code.google.com/appengine/docs/whatisgoogleappengine.html
Another example of a service limit is
  the number of results returned by a
  query. A query can return at most
  1,000 results. Queries that would
  return more results only return the
  maximum. In this case, a request that
  performs such a query isn't likely to
  return a request before the timeout,
  but the limit is in place to conserve
  resources on the datastore.
From
http://code.google.com/appengine/docs/datastore/gqlreference.html
Note: A LIMIT clause has a maximum of
  1000. If a limit larger than the maximum is specified, the maximum is
  used. This same maximum applies to the
  fetch() method of the GqlQuery class.
Note: Like the offset parameter for
  the fetch() method, an OFFSET in a GQL
  query string does not reduce the
  number of entities fetched from the
  datastore. It only affects which
  results are returned by the fetch()
  method. A query with an offset has
  performance characteristics that
  correspond linearly with the offset
  size.
From
http://code.google.com/appengine/docs/datastore/queryclass.html
The limit and offset arguments control
  how many results are fetched from the
  datastore, and how many are returned
  by the fetch() method:
The datastore fetches offset + limit results to the application. The first offset results are
not
skipped by the datastore itself.
The fetch() method skips the first offset results, then returns the rest (limit results).
The query has performance characteristics that correspond
  linearly with the offset amount plus the limit.
What this means is
If you have a singular query, there is no way to request anything outside the range 0-1000.
Increasing offset will just raise the 0, so
```
```
LIMIT 1000  OFFSET 0
```
```
Will return 1000 rows,
and
```
```
LIMIT 1000 OFFSET 1000
```
```
Will return
0 rows
, thus, making it impossible to, with a single query syntax, fetch 2000 results either manually or using the API.
The only plausible exception
Is to create a numeric index on the table, ie:
```
```
SELECT * FROM Foo  WHERE ID > 0 AND ID < 1000 

 SELECT * FROM Foo WHERE ID >= 1000 AND ID < 2000
```
```
If your data or query can't have this 'ID' hardcoded identifier, then you are
out of luck