Appengine 1.4

djangoappengine/boot.py

@@ -2,6 +2,13 @@
 import os
 import sys
 
+global devappserver_ver
+try:
+    import force_devappserver
+    devappserver_ver = force_devappserver.devappserver_ver
+except:
+    devappserver_ver = 1
+
 def find_project_dir():
     """
         Go through the path, and look for manage.py
@@ -70,6 +77,10 @@ def setup_env():
 
         # Then call fix_sys_path from the SDK
         from dev_appserver import fix_sys_path
+        if devappserver_ver == 2:
+            # emulate dev_appserver._run_file in devappserver2
+            from dev_appserver import _SYS_PATH_ADDITIONS
+            sys.path = _SYS_PATH_ADDITIONS['_python_runtime.py'] + sys.path
         fix_sys_path()
 
     setup_project()
@@ -146,41 +157,50 @@ def setup_project():
     # enable https connections (seem to be broken on Windows because
     # the _ssl module is disallowed).
     if not have_appserver:
-        from google.appengine.tools import dev_appserver
-        try:
-            # Backup os.environ. It gets overwritten by the
-            # dev_appserver, but it's needed by the subprocess module.
-            env = dev_appserver.DEFAULT_ENV
-            dev_appserver.DEFAULT_ENV = os.environ.copy()
-            dev_appserver.DEFAULT_ENV.update(env)
-            # Backup the buffer() builtin. The subprocess in Python 2.5
-            # on Linux and OS X uses needs it, but the dev_appserver
-            # removes it.
-            dev_appserver.buffer = buffer
-        except AttributeError:
-            logging.warn("Could not patch the default environment. "
-                         "The subprocess module will not work correctly.")
-
-        try:
-            # Allow importing compiler/parser, _ssl (for https),
-            # _io for Python 2.7 io support on OS X
-            dev_appserver.HardenedModulesHook._WHITE_LIST_C_MODULES.extend(
-                ('parser', '_ssl', '_io'))
-        except AttributeError:
-            logging.warn("Could not patch modules whitelist. the compiler "
-                         "and parser modules will not work and SSL support "
-                         "is disabled.")
-    elif not on_production_server:
-        try:
-            # Restore the real subprocess module.
-            from google.appengine.api.mail_stub import subprocess
-            sys.modules['subprocess'] = subprocess
-            # Re-inject the buffer() builtin into the subprocess module.
+        if devappserver_ver == 1:
             from google.appengine.tools import dev_appserver
-            subprocess.buffer = dev_appserver.buffer
-        except Exception, e:
-            logging.warn("Could not add the subprocess module to the "
-                         "sandbox: %s" % e)
+            try:
+                # Backup os.environ. It gets overwritten by the
+                # dev_appserver, but it's needed by the subprocess module.
+                env = dev_appserver.DEFAULT_ENV
+                dev_appserver.DEFAULT_ENV = os.environ.copy()
+                dev_appserver.DEFAULT_ENV.update(env)
+                # Backup the buffer() builtin. The subprocess in Python 2.5
+                # on Linux and OS X uses needs it, but the dev_appserver
+                # removes it.
+                dev_appserver.buffer = buffer
+            except AttributeError:
+                logging.warn("Could not patch the default environment. "
+                             "The subprocess module will not work correctly.")
+
+            try:
+                # Allow importing compiler/parser, _ssl (for https),
+                # _io for Python 2.7 io support on OS X
+                dev_appserver.HardenedModulesHook._WHITE_LIST_C_MODULES.extend(
+                    ('parser', '_ssl', '_io'))
+            except AttributeError:
+                logging.warn("Could not patch modules whitelist. the compiler "
+                             "and parser modules will not work and SSL support "
+                             "is disabled.")
+            # In SDK 1.6.4, the datastore doesn't save automatically on exit.
+            # Register a handler to make sure we save.  This is important on 
+            # manage.py commands other than 'runserver'.  Note that with runserver,
+            # the datastore is flushed twice.  This should be acceptable.
+            import atexit
+            if hasattr(dev_appserver, 'TearDownStubs'):
+                atexit.register(dev_appserver.TearDownStubs)
+    elif not on_production_server:
+        if devappserver_ver == 1:
+            try:
+                # Restore the real subprocess module.
+                from google.appengine.tools import dev_appserver
+                from google.appengine.api.mail_stub import subprocess
+                sys.modules['subprocess'] = subprocess
+                # Re-inject the buffer() builtin into the subprocess module.
+                subprocess.buffer = dev_appserver.buffer
+            except Exception, e:
+                logging.warn("Could not add the subprocess module to the "
+                             "sandbox: %s" % e)
 
     os.environ.update(env_ext)
 
@@ -202,3 +222,4 @@ def setup_project():
             while path in sys.path:
                 sys.path.remove(path)
         sys.path = extra_paths + sys.path
+

djangoappengine/db/base.py

@@ -155,7 +155,8 @@ def _value_for_db(self, value, field, field_kind, db_type, lookup):
         if db_type == 'key':
 #            value = self._value_for_db_key(value, field_kind)
             try:
-                value = key_from_path(field.model._meta.db_table, value)
+                if not isinstance(value, Key):
+                    value = key_from_path(field.model._meta.db_table, value)
             except (BadArgumentError, BadValueError,):
                 raise DatabaseError("Only strings and positive integers "
                                     "may be used as keys on GAE.")
@@ -169,9 +170,9 @@ def _value_for_db(self, value, field, field_kind, db_type, lookup):
 
         # Store all date / time values as datetimes, by using some
         # default time or date.
-        elif db_type == 'date':
+        elif db_type == 'date' and isinstance(value, datetime.date):
             value = datetime.datetime.combine(value, self.DEFAULT_TIME)
-        elif db_type == 'time':
+        elif db_type == 'time' and isinstance(value, datetime.time):
             value = datetime.datetime.combine(self.DEFAULT_DATE, value)
 
         # Store BlobField, DictField and EmbeddedModelField values as Blobs.
@@ -207,9 +208,9 @@ def _value_from_db(self, value, field, field_kind, db_type):
                 value = unicode(value)
 
         # Dates and times are stored as datetimes, drop the added part.
-        elif db_type == 'date':
+        elif db_type == 'date' and isinstance(value, datetime.datetime):
             value = value.date()
-        elif db_type == 'time':
+        elif db_type == 'time' and isinstance(value, datetime.datetime):
             value = value.time()
 
         # Convert GAE Blobs to plain strings for Django.

djangoappengine/db/compiler.py

@@ -23,7 +23,7 @@
 
 from .db_settings import get_model_indexes
 from .expressions import ExpressionEvaluator
-from .utils import commit_locked
+from .utils import AncestorKey, commit_locked
 
 
 # Valid query types (a dictionary is used for speedy lookups).
@@ -87,6 +87,7 @@ def __init__(self, compiler, fields):
         self.included_pks = None
         self.excluded_pks = ()
         self.has_negated_exact_filter = False
+        self.ancestor_key = None
         self.ordering = []
         self.db_table = self.query.get_meta().db_table
         self.pks_only = (len(fields) == 1 and fields[0].primary_key)
@@ -197,6 +198,14 @@ def add_filter(self, field, lookup_type, negated, value):
         # Optimization: batch-get by key; this is only suitable for
         # primary keys, not for anything that uses the key type.
         if field.primary_key and lookup_type in ('exact', 'in'):
+            if lookup_type == 'exact' and isinstance(value, AncestorKey):
+                if negated:
+                    raise DatabaseError("You can't negate an ancestor operator.")
+                if self.ancestor_key is not None:
+                    raise DatabaseError("You can't use more than one ancestor operator.")
+                self.ancestor_key = value.key
+                return
+
             if self.included_pks is not None:
                 raise DatabaseError("You can't apply multiple AND "
                                     "filters on the primary key. "
@@ -318,6 +327,8 @@ def _make_entity(self, entity):
     def _build_query(self):
         for query in self.gae_query:
             query.Order(*self.ordering)
+            if self.ancestor_key:
+                query.Ancestor(self.ancestor_key)
         if len(self.gae_query) > 1:
             return MultiQuery(self.gae_query, self.ordering)
         return self.gae_query[0]
@@ -403,6 +414,7 @@ def insert(self, data_list, return_id=False):
                     if value is not None:
                         kwds['id'] = value.id()
                         kwds['name'] = value.name()
+                        kwds['parent'] = value.parent()
 
                 # GAE does not store empty lists (and even does not allow
                 # passing empty lists to Entity.update) so skip them.

djangoappengine/db/creation.py

@@ -32,6 +32,13 @@ def db_type(self, field):
         field is to be indexed, and the "text" db_type (db.Text) if
         it's registered as unindexed.
         """
+        from djangoappengine.fields import DbKeyField
+
+        # DBKeyField reads/stores db.Key objects directly
+        # so its treated as a special case
+        if isinstance(field, DbKeyField):
+            return field.db_type(connection=self.connection)
+
         if self.connection.settings_dict.get('STORE_RELATIONS_AS_DB_KEYS'):
             if field.primary_key or field.rel is not None:
                 return 'key'

djangoappengine/db/models/manager.py

@@ -0,0 +1,14 @@
+from django.db.models import Manager as _baseManager
+from djangoappengine.db.utils import as_ancestor
+from djangoappengine.db.models.query import QuerySet
+
+class Manager(_baseManager):
+
+    def get_query_set(self):
+        """Returns a new QuerySet object.  Subclasses can override this method
+        to easily customize the behavior of the Manager.
+        """
+        return QuerySet(self.model, using=self._db)
+
+    def ancestor(self, ancestor):
+        return self.get_query_set().ancestor(ancestor)

djangoappengine/db/models/query.py

@@ -0,0 +1,17 @@
+from django.db.models.query import QuerySet as _baseQuerySet
+from djangoappengine.db.utils import as_ancestor
+
+class QuerySet(_baseQuerySet):
+    def ancestor(self, ancestor):
+        """
+        Returns a new QuerySet instance with the args ANDed to the existing
+        set.
+        """      
+        return self._filter_or_exclude(False, pk=as_ancestor(ancestor))
+
+class EmptyQuerySet(QuerySet):
+    def ancestor(self, *args, **kwargs):
+        """
+        Always returns EmptyQuerySet.
+        """
+        return self

djangoappengine/db/stubs.py

@@ -3,7 +3,7 @@
 import time
 from urllib2 import HTTPError, URLError
 
-from ..boot import PROJECT_DIR
+from ..boot import PROJECT_DIR, devappserver_ver
 from ..utils import appid, have_appserver
 
 
@@ -62,9 +62,13 @@ def activate_test_stubs(self, connection):
         self.testbed.init_memcache_stub()
         self.testbed.init_taskqueue_stub(auto_task_running=True, root_path=PROJECT_DIR)
         self.testbed.init_urlfetch_stub()
-        self.testbed.init_user_stub()
+        self.testbed.init_user_stub(True, **{ 'logout_url'   : '/_ah/login?continue=%s&action=Logout',
+                                              'login_url' : '/_ah/login?continue=%s' })
         self.testbed.init_xmpp_stub()
         self.testbed.init_channel_stub()
+        self.testbed.init_files_stub(True)
+        self.testbed.init_blobstore_stub(True)
+        self.testbed.init_images_stub(True)
 
     def deactivate_test_stubs(self):
         if self.active_stubs == 'test':
@@ -82,9 +86,17 @@ def setup_local_stubs(self, connection):
         log_level = logging.getLogger().getEffectiveLevel()
         logging.getLogger().setLevel(logging.WARNING)
         from google.appengine.tools import dev_appserver
-        dev_appserver.SetupStubs('dev~' + appid, **args)
+        dev_appserver.SetupStubs('dev~' + appid, 
+                                 _use_atexit_for_datastore_stub=True,
+                                 **args)
         logging.getLogger().setLevel(log_level)
         self.active_stubs = 'local'
+        if devappserver_ver == 2:
+            # Mimic google.appengine.tools.devappserver2
+            os.environ['TZ'] = 'UTC'
+            if hasattr(time, 'tzset'):
+                # time.tzet() should be called on Unix, but doesn't exist on Windows.
+                time.tzset()
 
     def setup_remote_stubs(self, connection):
         if self.active_stubs == 'remote':

djangoappengine/db/utils.py

@@ -1,14 +1,17 @@
-from django.db import DEFAULT_DB_ALIAS
-
+from google.appengine.api.datastore import Key
 from google.appengine.datastore.datastore_query import Cursor
+from django.db import models, DEFAULT_DB_ALIAS
 
 try:
     from functools import wraps
 except ImportError:
     from django.utils.functional import wraps  # Python 2.3, 2.4 fallback.
 
+
 class CursorQueryMixin(object):
+
     def clone(self, *args, **kwargs):
+        kwargs['_gae_cursor'] = getattr(self, '_gae_cursor', None)
         kwargs['_gae_start_cursor'] = getattr(self, '_gae_start_cursor', None)
         kwargs['_gae_end_cursor'] = getattr(self, '_gae_end_cursor', None)
         kwargs['_gae_config'] = getattr(self, '_gae_config', None)
@@ -90,3 +93,36 @@ def _commit_locked(*args, **kw):
     if callable(func_or_using):
         return inner_commit_locked(func_or_using, DEFAULT_DB_ALIAS)
     return lambda func: inner_commit_locked(func, func_or_using)
+
+class AncestorKey(object):
+    def __init__(self, key):
+        self.key = key
+
+def as_ancestor(key_or_model):
+    if key_or_model is None:
+        raise ValueError("key_or_model must not be None")
+
+    if isinstance(key_or_model, models.Model):
+        key_or_model = Key.from_path(key_or_model._meta.db_table, key_or_model.pk)
+
+    return AncestorKey(key_or_model)
+
+def make_key(*args, **kwargs):
+    parent = kwargs.pop('parent', None)
+
+    if kwargs:
+        raise AssertionError('Excess keyword arguments; received %s' % kwargs)
+
+    if not args or len(args) % 2:
+        raise AssertionError('A non-zero even number of positional arguments is required; received %s' % args)
+
+    if isinstance(parent, models.Model):
+        parent = Key.from_path(parent._meta.db_table, parent.pk)
+
+    converted_args = []
+    for i in xrange(0, len(args), 2):
+        model, id_or_name = args[i:i+2]
+        converted_args.extend((model._meta.db_table, id_or_name))
+
+    newkwargs = { 'parent' : parent }
+    return Key.from_path(*converted_args, **newkwargs)