But there is no support of using lookups outside filtering yet.

MANIFEST.in

@@ -6,6 +6,7 @@ include MANIFEST.in
include django/contrib/gis/gdal/LICENSE
include django/contrib/gis/geos/LICENSE
include django/dispatch/license.txt
include django/dispatch/license.python.txt
recursive-include docs *
recursive-include scripts *
recursive-include extras *

django/apps/base.py

@@ -99,7 +99,7 @@ def create(cls, entry):
                raise ImproperlyConfigured(
                    "'%s' must supply a name attribute." % entry)

            # Ensure app_names points to a valid module.
            # Ensure app_name points to a valid module.
            app_module = import_module(app_name)

            # Entry is a path to an app config class.

django/apps/registry.py

@@ -1,11 +1,11 @@
from collections import Counter, defaultdict, OrderedDict
import os
import sys
import threading
import warnings

from django.core.exceptions import ImproperlyConfigured
from django.utils import lru_cache
from django.utils.module_loading import import_lock
from django.utils._os import upath

from .base import AppConfig
@@ -44,6 +44,9 @@ def __init__(self, installed_apps=()):
        # Whether the registry is populated.
        self.ready = False

        # Lock for thread-safe population.
        self._lock = threading.Lock()

        # Pending lookups for lazy relations.
        self._pending_lookups = {}

@@ -61,10 +64,10 @@ def populate(self, installed_apps=None):
        """
        if self.ready:
            return
        # Since populate() may be a side effect of imports, and since it will
        # itself import modules, an ABBA deadlock between threads would be
        # possible if we didn't take the import lock. See #18251.
        with import_lock():

        # populate() might be called by two threads in parallel on servers
        # that create threads before initializing the WSGI callable.
        with self._lock:
            if self.ready:
                return

django/contrib/auth/management/__init__.py

@@ -60,7 +60,7 @@ def _check_permission_clashing(custom, builtin, ctype):
        pool.add(codename)


def create_permissions(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
def create_permissions(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs):
    if not app_config.models_module:
        return

@@ -69,7 +69,7 @@ def create_permissions(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_
    except LookupError:
        return

    if not router.allow_migrate(db, Permission):
    if not router.allow_migrate(using, Permission):
        return

    from django.contrib.contenttypes.models import ContentType
@@ -82,15 +82,15 @@ def create_permissions(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_
    for klass in app_config.get_models():
        # Force looking up the content types in the current database
        # before creating foreign keys to them.
        ctype = ContentType.objects.db_manager(db).get_for_model(klass)
        ctype = ContentType.objects.db_manager(using).get_for_model(klass)
        ctypes.add(ctype)
        for perm in _get_all_permissions(klass._meta, ctype):
            searched_perms.append((ctype, perm))

    # Find all the Permissions that have a content_type for a model we're
    # looking for.  We don't need to check for codenames since we already have
    # a list of the ones we're going to create.
    all_perms = set(Permission.objects.using(db).filter(
    all_perms = set(Permission.objects.using(using).filter(
        content_type__in=ctypes,
    ).values_list(
        "content_type", "codename"
@@ -113,13 +113,13 @@ def create_permissions(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_
                    verbose_name_max_length,
                )
            )
    Permission.objects.using(db).bulk_create(perms)
    Permission.objects.using(using).bulk_create(perms)
    if verbosity >= 2:
        for perm in perms:
            print("Adding permission '%s'" % perm)


def create_superuser(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
def create_superuser(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs):
    try:
        apps.get_model('auth', 'Permission')
    except LookupError:
@@ -139,7 +139,7 @@ def create_superuser(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_AL
                confirm = input('Please enter either "yes" or "no": ')
                continue
            if confirm == 'yes':
                call_command("createsuperuser", interactive=True, database=db)
                call_command("createsuperuser", interactive=True, database=using)
            break

django/contrib/auth/tests/test_templates.py

@@ -17,6 +17,7 @@
    PASSWORD_HASHERS=('django.contrib.auth.hashers.SHA1PasswordHasher',),
)
class AuthTemplateTests(TestCase):
    urls = 'django.contrib.auth.tests.urls'

    def test_titles(self):
        rf = RequestFactory()

django/contrib/auth/tests/urls.py

@@ -1,4 +1,5 @@
from django.conf.urls import patterns, url
from django.conf.urls import patterns, url, include
from django.contrib import admin
from django.contrib.auth import context_processors
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.urls import urlpatterns
@@ -98,4 +99,7 @@ def custom_request_auth_login(request):
    (r'^auth_processor_messages/$', auth_processor_messages),
    (r'^custom_request_auth_login/$', custom_request_auth_login),
    url(r'^userpage/(.+)/$', userpage, name="userpage"),

    # This line is only required to render the password reset with is_admin=True
    (r'^admin/', include(admin.site.urls)),
)

django/contrib/contenttypes/generic.py

@@ -12,7 +12,7 @@
from django.db.models import signals
from django.db.models.fields.related import ForeignObject, ForeignObjectRel
from django.db.models.related import PathInfo
from django.db.models.sql.where import Constraint
from django.db.models.sql.datastructures import Col
from django.forms import ModelForm, ALL_FIELDS
from django.forms.models import (BaseModelFormSet, modelformset_factory,
    modelform_defines_fields)
@@ -236,7 +236,8 @@ def get_extra_restriction(self, where_class, alias, remote_alias):
        field = self.rel.to._meta.get_field_by_name(self.content_type_field_name)[0]
        contenttype_pk = self.get_content_type().pk
        cond = where_class()
        cond.add((Constraint(remote_alias, field.column, field), 'exact', contenttype_pk), 'AND')
        lookup = field.get_lookup('exact')(Col(remote_alias, field, field), contenttype_pk)
        cond.add(lookup, 'AND')
        return cond

    def bulk_related_objects(self, objs, using=DEFAULT_DB_ALIAS):

django/contrib/contenttypes/management.py

@@ -6,7 +6,7 @@
from django.utils.six.moves import input


def update_contenttypes(app_config, verbosity=2, interactive=True, db=DEFAULT_DB_ALIAS, **kwargs):
def update_contenttypes(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, **kwargs):
    """
    Creates content types for models in the given app, removing any model
    entries that no longer have a matching model class.
@@ -19,7 +19,7 @@ def update_contenttypes(app_config, verbosity=2, interactive=True, db=DEFAULT_DB
    except LookupError:
        return

    if not router.allow_migrate(db, ContentType):
    if not router.allow_migrate(using, ContentType):
        return

    ContentType.objects.clear_cache()
@@ -36,7 +36,7 @@ def update_contenttypes(app_config, verbosity=2, interactive=True, db=DEFAULT_DB
    # Get all the content types
    content_types = dict(
        (ct.model, ct)
        for ct in ContentType.objects.using(db).filter(app_label=app_label)
        for ct in ContentType.objects.using(using).filter(app_label=app_label)
    )
    to_remove = [
        ct
@@ -53,7 +53,7 @@ def update_contenttypes(app_config, verbosity=2, interactive=True, db=DEFAULT_DB
        for (model_name, model) in six.iteritems(app_models)
        if model_name not in content_types
    ]
    ContentType.objects.using(db).bulk_create(cts)
    ContentType.objects.using(using).bulk_create(cts)
    if verbosity >= 2:
        for ct in cts:
            print("Adding content type '%s | %s'" % (ct.app_label, ct.model))

django/contrib/gis/db/backends/mysql/operations.py

@@ -49,9 +49,7 @@ def get_geom_placeholder(self, value, srid):
        return placeholder

    def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
        alias, col, db_type = lvalue

        geo_col = '%s.%s' % (qn(alias), qn(col))
        geo_col, db_type = lvalue

        lookup_info = self.geometry_functions.get(lookup_type, False)
        if lookup_info:

django/contrib/gis/db/backends/oracle/operations.py

@@ -231,10 +231,7 @@ def transform_value(val, srid):

    def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
        "Returns the SQL WHERE clause for use in Oracle spatial SQL construction."
        alias, col, db_type = lvalue

        # Getting the quoted table name as `geo_col`.
        geo_col = '%s.%s' % (qn(alias), qn(col))
        geo_col, db_type = lvalue

        # See if a Oracle Geometry function matches the lookup type next
        lookup_info = self.geometry_functions.get(lookup_type, False)

django/contrib/gis/db/backends/postgis/operations.py

@@ -478,10 +478,7 @@ def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
        (alias, col, db_type), the lookup type string, lookup value, and
        the geometry field.
        """
        alias, col, db_type = lvalue

        # Getting the quoted geometry column.
        geo_col = '%s.%s' % (qn(alias), qn(col))
        geo_col, db_type = lvalue

        if lookup_type in self.geometry_operators:
            if field.geography and not lookup_type in self.geography_operators:

django/contrib/gis/db/backends/spatialite/operations.py

@@ -324,10 +324,7 @@ def spatial_lookup_sql(self, lvalue, lookup_type, value, field, qn):
        [a tuple of (alias, column, db_type)], lookup type, lookup
        value, the model field, and the quoting function.
        """
        alias, col, db_type = lvalue

        # Getting the quoted field as `geo_col`.
        geo_col = '%s.%s' % (qn(alias), qn(col))
        geo_col, db_type = lvalue

        if lookup_type in self.geometry_functions:
            # See if a SpatiaLite geometry function matches the lookup type.

django/contrib/gis/db/models/constants.py

@@ -0,0 +1,15 @@
from django.db.models.sql.constants import QUERY_TERMS

GIS_LOOKUPS = {
    'bbcontains', 'bboverlaps', 'contained', 'contains',
    'contains_properly', 'coveredby', 'covers', 'crosses', 'disjoint',
    'distance_gt', 'distance_gte', 'distance_lt', 'distance_lte',
    'dwithin', 'equals', 'exact',
    'intersects', 'overlaps', 'relate', 'same_as', 'touches', 'within',
    'left', 'right', 'overlaps_left', 'overlaps_right',
    'overlaps_above', 'overlaps_below',
    'strictly_above', 'strictly_below'
}
ALL_TERMS = GIS_LOOKUPS | QUERY_TERMS

__all__ = ['ALL_TERMS', 'GIS_LOOKUPS']

django/contrib/gis/db/models/fields.py

@@ -2,6 +2,8 @@
from django.db.models.sql.expressions import SQLEvaluator
from django.utils.translation import ugettext_lazy as _
from django.contrib.gis import forms
from django.contrib.gis.db.models.constants import GIS_LOOKUPS
from django.contrib.gis.db.models.lookups import GISLookup
from django.contrib.gis.db.models.proxy import GeometryProxy
from django.contrib.gis.geometry.backend import Geometry, GeometryException
from django.utils import six
@@ -284,6 +286,10 @@ def get_placeholder(self, value, connection):
        """
        return connection.ops.get_geom_placeholder(self, value)

for lookup_name in GIS_LOOKUPS:
    lookup = type(lookup_name, (GISLookup,), {'lookup_name': lookup_name})
    GeometryField.register_lookup(lookup)


# The OpenGIS Geometry Type Fields
class PointField(GeometryField):

django/contrib/gis/db/models/lookups.py

@@ -0,0 +1,28 @@
from django.db.models.lookups import Lookup
from django.db.models.sql.expressions import SQLEvaluator


class GISLookup(Lookup):
    def as_sql(self, qn, connection):
        from django.contrib.gis.db.models.sql import GeoWhereNode
        # We use the same approach as was used by GeoWhereNode. It would
        # be a good idea to upgrade GIS to use similar code that is used
        # for other lookups.
        if isinstance(self.rhs, SQLEvaluator):
            # Make sure the F Expression destination field exists, and
            # set an `srid` attribute with the same as that of the
            # destination.
            geo_fld = GeoWhereNode._check_geo_field(self.rhs.opts, self.rhs.expression.name)
            if not geo_fld:
                raise ValueError('No geographic field found in expression.')
            self.rhs.srid = geo_fld.srid
        db_type = self.lhs.output_type.db_type(connection=connection)
        params = self.lhs.output_type.get_db_prep_lookup(
            self.lookup_name, self.rhs, connection=connection)
        lhs_sql, lhs_params = self.process_lhs(qn, connection)
        # lhs_params not currently supported.
        assert not lhs_params
        data = (lhs_sql, db_type)
        spatial_sql, spatial_params = connection.ops.spatial_lookup_sql(
            data, self.lookup_name, self.rhs, self.lhs.output_type, qn)
        return spatial_sql, spatial_params + params

django/contrib/gis/db/models/sql/compiler.py

@@ -133,7 +133,7 @@ def get_default_columns(self, with_aliases=False, col_aliases=None,
            if table in only_load and field.column not in only_load[table]:
                continue
            if as_pairs:
                result.append((alias, field.column))
                result.append((alias, field))
                aliases.add(alias)
                continue
            # This part of the function is customized for GeoQuery. We

django/contrib/gis/db/models/sql/query.py

@@ -1,6 +1,7 @@
from django.db import connections
from django.db.models.query import sql

from django.contrib.gis.db.models.constants import ALL_TERMS
from django.contrib.gis.db.models.fields import GeometryField
from django.contrib.gis.db.models.sql import aggregates as gis_aggregates
from django.contrib.gis.db.models.sql.conversion import AreaField, DistanceField, GeomField
@@ -9,19 +10,6 @@
from django.contrib.gis.measure import Area, Distance


ALL_TERMS = set([
    'bbcontains', 'bboverlaps', 'contained', 'contains',
    'contains_properly', 'coveredby', 'covers', 'crosses', 'disjoint',
    'distance_gt', 'distance_gte', 'distance_lt', 'distance_lte',
    'dwithin', 'equals', 'exact',
    'intersects', 'overlaps', 'relate', 'same_as', 'touches', 'within',
    'left', 'right', 'overlaps_left', 'overlaps_right',
    'overlaps_above', 'overlaps_below',
    'strictly_above', 'strictly_below'
])
ALL_TERMS.update(sql.constants.QUERY_TERMS)


class GeoQuery(sql.Query):
    """
    A single spatial SQL query.

django/contrib/staticfiles/finders.py

@@ -57,7 +57,7 @@ def __init__(self, app_names=None, *args, **kwargs):
                prefix, root = root
            else:
                prefix = ''
            if os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root):
            if settings.STATIC_ROOT and os.path.abspath(settings.STATIC_ROOT) == os.path.abspath(root):
                raise ImproperlyConfigured(
                    "The STATICFILES_DIRS setting should "
                    "not contain the STATIC_ROOT setting")

django/contrib/staticfiles/storage.py

@@ -32,13 +32,21 @@ def __init__(self, location=None, base_url=None, *args, **kwargs):
            location = settings.STATIC_ROOT
        if base_url is None:
            base_url = settings.STATIC_URL
        check_settings(base_url)
        super(StaticFilesStorage, self).__init__(location, base_url,
                                                 *args, **kwargs)
        # FileSystemStorage fallbacks to MEDIA_ROOT when location
        # is empty, so we restore the empty value.
        if not location:
            self.base_location = None
            self.location = None

    def path(self, name):
        if not self.location:
            raise ImproperlyConfigured("You're using the staticfiles app "
                                       "without having set the STATIC_ROOT "
                                       "setting to a filesystem path.")
        check_settings(base_url)
        super(StaticFilesStorage, self).__init__(location, base_url,
                                                 *args, **kwargs)
        return super(StaticFilesStorage, self).path(name)


class CachedFilesMixin(object):

django/core/mail/backends/smtp.py

@@ -57,6 +57,7 @@ def open(self):
                self.connection.ehlo()
            if self.username and self.password:
                self.connection.login(self.username, self.password)
            return True
        except smtplib.SMTPException:
            if not self.fail_silently:
                raise