Refs #33476 -- Reformatted code with Black.

tests/gis_tests/distapp/tests.py

@@ -1,32 +1,52 @@
 from django.contrib.gis.db.models.functions import (
-    Area, Distance, Length, Perimeter, Transform, Union,
+    Area,
+    Distance,
+    Length,
+    Perimeter,
+    Transform,
+    Union,
 )
 from django.contrib.gis.geos import GEOSGeometry, LineString, Point
 from django.contrib.gis.measure import D  # alias for Distance
 from django.db import NotSupportedError, connection
 from django.db.models import (
-    Case, Count, Exists, F, IntegerField, OuterRef, Q, Value, When,
+    Case,
+    Count,
+    Exists,
+    F,
+    IntegerField,
+    OuterRef,
+    Q,
+    Value,
+    When,
 )
 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
 
 from ..utils import FuncTestMixin
 from .models import (
-    AustraliaCity, CensusZipcode, Interstate, SouthTexasCity, SouthTexasCityFt,
-    SouthTexasInterstate, SouthTexasZipcode,
+    AustraliaCity,
+    CensusZipcode,
+    Interstate,
+    SouthTexasCity,
+    SouthTexasCityFt,
+    SouthTexasInterstate,
+    SouthTexasZipcode,
 )
 
 
 class DistanceTest(TestCase):
-    fixtures = ['initial']
+    fixtures = ["initial"]
 
     def setUp(self):
         # A point we are testing distances with -- using a WGS84
         # coordinate that'll be implicitly transformed to that to
         # the coordinate system of the field, EPSG:32140 (Texas South Central
         # w/units in meters)
-        self.stx_pnt = GEOSGeometry('POINT (-95.370401017314293 29.704867409475465)', 4326)
+        self.stx_pnt = GEOSGeometry(
+            "POINT (-95.370401017314293 29.704867409475465)", 4326
+        )
         # Another one for Australia
-        self.au_pnt = GEOSGeometry('POINT (150.791 -34.4919)', 4326)
+        self.au_pnt = GEOSGeometry("POINT (150.791 -34.4919)", 4326)
 
     def get_names(self, qs):
         cities = [c.name for c in qs]
@@ -57,8 +77,8 @@ class DistanceTest(TestCase):
         au_dists = [(0.5, 32000), D(km=32), D(mi=19.884)]
 
         # Expected cities for Australia and Texas.
-        tx_cities = ['Downtown Houston', 'Southside Place']
-        au_cities = ['Mittagong', 'Shellharbour', 'Thirroul', 'Wollongong']
+        tx_cities = ["Downtown Houston", "Southside Place"]
+        au_cities = ["Mittagong", "Shellharbour", "Thirroul", "Wollongong"]
 
         # Performing distance queries on two projected coordinate systems one
         # with units in meters and the other in units of U.S. survey feet.
@@ -74,7 +94,9 @@ class DistanceTest(TestCase):
                     self.assertEqual(tx_cities, self.get_names(qs))
 
         # With a complex geometry expression
-        self.assertFalse(SouthTexasCity.objects.exclude(point__dwithin=(Union('point', 'point'), 0)))
+        self.assertFalse(
+            SouthTexasCity.objects.exclude(point__dwithin=(Union("point", "point"), 0))
+        )
 
         # Now performing the `dwithin` queries on a geodetic coordinate system.
         for dist in au_dists:
@@ -89,15 +111,20 @@ class DistanceTest(TestCase):
                         dist = dist[0]
 
                 # Creating the query set.
-                qs = AustraliaCity.objects.order_by('name')
+                qs = AustraliaCity.objects.order_by("name")
                 if type_error:
                     # A ValueError should be raised on PostGIS when trying to
                     # pass Distance objects into a DWithin query using a
                     # geodetic field.
                     with self.assertRaises(ValueError):
-                        AustraliaCity.objects.filter(point__dwithin=(self.au_pnt, dist)).count()
+                        AustraliaCity.objects.filter(
+                            point__dwithin=(self.au_pnt, dist)
+                        ).count()
                 else:
-                    self.assertEqual(au_cities, self.get_names(qs.filter(point__dwithin=(self.au_pnt, dist))))
+                    self.assertEqual(
+                        au_cities,
+                        self.get_names(qs.filter(point__dwithin=(self.au_pnt, dist))),
+                    )
 
     @skipUnlessDBFeature("supports_distances_lookups")
     def test_distance_lookups(self):
@@ -108,20 +135,26 @@ class DistanceTest(TestCase):
         # (thus, Houston and Southside place will be excluded as tested in
         # the `test02_dwithin` above).
         for model in [SouthTexasCity, SouthTexasCityFt]:
-            stx_pnt = self.stx_pnt.transform(model._meta.get_field('point').srid, clone=True)
+            stx_pnt = self.stx_pnt.transform(
+                model._meta.get_field("point").srid, clone=True
+            )
             qs = model.objects.filter(point__distance_gte=(stx_pnt, D(km=7))).filter(
                 point__distance_lte=(stx_pnt, D(km=20)),
             )
             cities = self.get_names(qs)
-            self.assertEqual(cities, ['Bellaire', 'Pearland', 'West University Place'])
+            self.assertEqual(cities, ["Bellaire", "Pearland", "West University Place"])
 
         # Doing a distance query using Polygons instead of a Point.
-        z = SouthTexasZipcode.objects.get(name='77005')
-        qs = SouthTexasZipcode.objects.exclude(name='77005').filter(poly__distance_lte=(z.poly, D(m=275)))
-        self.assertEqual(['77025', '77401'], self.get_names(qs))
+        z = SouthTexasZipcode.objects.get(name="77005")
+        qs = SouthTexasZipcode.objects.exclude(name="77005").filter(
+            poly__distance_lte=(z.poly, D(m=275))
+        )
+        self.assertEqual(["77025", "77401"], self.get_names(qs))
         # If we add a little more distance 77002 should be included.
-        qs = SouthTexasZipcode.objects.exclude(name='77005').filter(poly__distance_lte=(z.poly, D(m=300)))
-        self.assertEqual(['77002', '77025', '77401'], self.get_names(qs))
+        qs = SouthTexasZipcode.objects.exclude(name="77005").filter(
+            poly__distance_lte=(z.poly, D(m=300))
+        )
+        self.assertEqual(["77002", "77025", "77401"], self.get_names(qs))
 
     @skipUnlessDBFeature("supports_distances_lookups", "supports_distance_geodetic")
     def test_geodetic_distance_lookups(self):
@@ -130,12 +163,18 @@ class DistanceTest(TestCase):
         """
         # Line is from Canberra to Sydney.  Query is for all other cities within
         # a 100km of that line (which should exclude only Hobart & Adelaide).
-        line = GEOSGeometry('LINESTRING(144.9630 -37.8143,151.2607 -33.8870)', 4326)
+        line = GEOSGeometry("LINESTRING(144.9630 -37.8143,151.2607 -33.8870)", 4326)
         dist_qs = AustraliaCity.objects.filter(point__distance_lte=(line, D(km=100)))
         expected_cities = [
-            'Batemans Bay', 'Canberra', 'Hillsdale',
-            'Melbourne', 'Mittagong', 'Shellharbour',
-            'Sydney', 'Thirroul', 'Wollongong',
+            "Batemans Bay",
+            "Canberra",
+            "Hillsdale",
+            "Melbourne",
+            "Mittagong",
+            "Shellharbour",
+            "Sydney",
+            "Thirroul",
+            "Wollongong",
         ]
         if connection.ops.spatialite:
             # SpatiaLite is less accurate and returns 102.8km for Batemans Bay.
@@ -144,141 +183,185 @@ class DistanceTest(TestCase):
 
         msg = "2, 3, or 4-element tuple required for 'distance_lte' lookup."
         with self.assertRaisesMessage(ValueError, msg):  # Too many params.
-            len(AustraliaCity.objects.filter(point__distance_lte=('POINT(5 23)', D(km=100), 'spheroid', '4', None)))
+            len(
+                AustraliaCity.objects.filter(
+                    point__distance_lte=(
+                        "POINT(5 23)",
+                        D(km=100),
+                        "spheroid",
+                        "4",
+                        None,
+                    )
+                )
+            )
 
         with self.assertRaisesMessage(ValueError, msg):  # Too few params.
-            len(AustraliaCity.objects.filter(point__distance_lte=('POINT(5 23)',)))
+            len(AustraliaCity.objects.filter(point__distance_lte=("POINT(5 23)",)))
 
         msg = "For 4-element tuples the last argument must be the 'spheroid' directive."
         with self.assertRaisesMessage(ValueError, msg):
-            len(AustraliaCity.objects.filter(point__distance_lte=('POINT(5 23)', D(km=100), 'spheroid', '4')))
+            len(
+                AustraliaCity.objects.filter(
+                    point__distance_lte=("POINT(5 23)", D(km=100), "spheroid", "4")
+                )
+            )
 
         # Getting all cities w/in 550 miles of Hobart.
-        hobart = AustraliaCity.objects.get(name='Hobart')
-        qs = AustraliaCity.objects.exclude(name='Hobart').filter(point__distance_lte=(hobart.point, D(mi=550)))
+        hobart = AustraliaCity.objects.get(name="Hobart")
+        qs = AustraliaCity.objects.exclude(name="Hobart").filter(
+            point__distance_lte=(hobart.point, D(mi=550))
+        )
         cities = self.get_names(qs)
-        self.assertEqual(cities, ['Batemans Bay', 'Canberra', 'Melbourne'])
+        self.assertEqual(cities, ["Batemans Bay", "Canberra", "Melbourne"])
 
         # Cities that are either really close or really far from Wollongong --
         # and using different units of distance.
-        wollongong = AustraliaCity.objects.get(name='Wollongong')
+        wollongong = AustraliaCity.objects.get(name="Wollongong")
         d1, d2 = D(yd=19500), D(nm=400)  # Yards (~17km) & Nautical miles.
 
         # Normal geodetic distance lookup (uses `distance_sphere` on PostGIS.
         gq1 = Q(point__distance_lte=(wollongong.point, d1))
         gq2 = Q(point__distance_gte=(wollongong.point, d2))
-        qs1 = AustraliaCity.objects.exclude(name='Wollongong').filter(gq1 | gq2)
+        qs1 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq1 | gq2)
 
         # Geodetic distance lookup but telling GeoDjango to use `distance_spheroid`
         # instead (we should get the same results b/c accuracy variance won't matter
         # in this test case).
         querysets = [qs1]
         if connection.features.has_DistanceSpheroid_function:
-            gq3 = Q(point__distance_lte=(wollongong.point, d1, 'spheroid'))
-            gq4 = Q(point__distance_gte=(wollongong.point, d2, 'spheroid'))
-            qs2 = AustraliaCity.objects.exclude(name='Wollongong').filter(gq3 | gq4)
+            gq3 = Q(point__distance_lte=(wollongong.point, d1, "spheroid"))
+            gq4 = Q(point__distance_gte=(wollongong.point, d2, "spheroid"))
+            qs2 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq3 | gq4)
             querysets.append(qs2)
 
         for qs in querysets:
             cities = self.get_names(qs)
-            self.assertEqual(cities, ['Adelaide', 'Hobart', 'Shellharbour', 'Thirroul'])
+            self.assertEqual(cities, ["Adelaide", "Hobart", "Shellharbour", "Thirroul"])
 
     @skipUnlessDBFeature("supports_distances_lookups")
     def test_distance_lookups_with_expression_rhs(self):
-        stx_pnt = self.stx_pnt.transform(SouthTexasCity._meta.get_field('point').srid, clone=True)
+        stx_pnt = self.stx_pnt.transform(
+            SouthTexasCity._meta.get_field("point").srid, clone=True
+        )
         qs = SouthTexasCity.objects.filter(
-            point__distance_lte=(stx_pnt, F('radius')),
-        ).order_by('name')
+            point__distance_lte=(stx_pnt, F("radius")),
+        ).order_by("name")
         self.assertEqual(
             self.get_names(qs),
-            ['Bellaire', 'Downtown Houston', 'Southside Place', 'West University Place']
+            [
+                "Bellaire",
+                "Downtown Houston",
+                "Southside Place",
+                "West University Place",
+            ],
         )
 
         # With a combined expression
         qs = SouthTexasCity.objects.filter(
-            point__distance_lte=(stx_pnt, F('radius') * 2),
-        ).order_by('name')
+            point__distance_lte=(stx_pnt, F("radius") * 2),
+        ).order_by("name")
         self.assertEqual(len(qs), 5)
-        self.assertIn('Pearland', self.get_names(qs))
+        self.assertIn("Pearland", self.get_names(qs))
 
         # With spheroid param
         if connection.features.supports_distance_geodetic:
-            hobart = AustraliaCity.objects.get(name='Hobart')
+            hobart = AustraliaCity.objects.get(name="Hobart")
             AustraliaCity.objects.update(ref_point=hobart.point)
-            for ref_point in [hobart.point, F('ref_point')]:
+            for ref_point in [hobart.point, F("ref_point")]:
                 qs = AustraliaCity.objects.filter(
-                    point__distance_lte=(ref_point, F('radius') * 70, 'spheroid'),
-                ).order_by('name')
-                self.assertEqual(self.get_names(qs), ['Canberra', 'Hobart', 'Melbourne'])
+                    point__distance_lte=(ref_point, F("radius") * 70, "spheroid"),
+                ).order_by("name")
+                self.assertEqual(
+                    self.get_names(qs), ["Canberra", "Hobart", "Melbourne"]
+                )
 
         # With a complex geometry expression
-        self.assertFalse(SouthTexasCity.objects.filter(point__distance_gt=(Union('point', 'point'), 0)))
+        self.assertFalse(
+            SouthTexasCity.objects.filter(
+                point__distance_gt=(Union("point", "point"), 0)
+            )
+        )
         self.assertEqual(
-            SouthTexasCity.objects.filter(point__distance_lte=(Union('point', 'point'), 0)).count(),
+            SouthTexasCity.objects.filter(
+                point__distance_lte=(Union("point", "point"), 0)
+            ).count(),
             SouthTexasCity.objects.count(),
         )
 
-    @skipUnlessDBFeature('supports_distances_lookups')
+    @skipUnlessDBFeature("supports_distances_lookups")
     def test_distance_annotation_group_by(self):
         stx_pnt = self.stx_pnt.transform(
-            SouthTexasCity._meta.get_field('point').srid,
+            SouthTexasCity._meta.get_field("point").srid,
             clone=True,
         )
-        qs = SouthTexasCity.objects.annotate(
-            relative_distance=Case(
-                When(point__distance_lte=(stx_pnt, D(km=20)), then=Value(20)),
-                default=Value(100),
-                output_field=IntegerField(),
-            ),
-        ).values('relative_distance').annotate(count=Count('pk'))
-        self.assertCountEqual(qs, [
-            {'relative_distance': 20, 'count': 5},
-            {'relative_distance': 100, 'count': 4},
-        ])
+        qs = (
+            SouthTexasCity.objects.annotate(
+                relative_distance=Case(
+                    When(point__distance_lte=(stx_pnt, D(km=20)), then=Value(20)),
+                    default=Value(100),
+                    output_field=IntegerField(),
+                ),
+            )
+            .values("relative_distance")
+            .annotate(count=Count("pk"))
+        )
+        self.assertCountEqual(
+            qs,
+            [
+                {"relative_distance": 20, "count": 5},
+                {"relative_distance": 100, "count": 4},
+            ],
+        )
 
     def test_mysql_geodetic_distance_error(self):
         if not connection.ops.mysql:
-            self.skipTest('This is a MySQL-specific test.')
-        msg = 'Only numeric values of degree units are allowed on geodetic distance queries.'
+            self.skipTest("This is a MySQL-specific test.")
+        msg = "Only numeric values of degree units are allowed on geodetic distance queries."
         with self.assertRaisesMessage(ValueError, msg):
-            AustraliaCity.objects.filter(point__distance_lte=(Point(0, 0), D(m=100))).exists()
+            AustraliaCity.objects.filter(
+                point__distance_lte=(Point(0, 0), D(m=100))
+            ).exists()
 
-    @skipUnlessDBFeature('supports_dwithin_lookup')
+    @skipUnlessDBFeature("supports_dwithin_lookup")
     def test_dwithin_subquery(self):
         """dwithin lookup in a subquery using OuterRef as a parameter."""
         qs = CensusZipcode.objects.annotate(
-            annotated_value=Exists(SouthTexasCity.objects.filter(
-                point__dwithin=(OuterRef('poly'), D(m=10)),
-            ))
+            annotated_value=Exists(
+                SouthTexasCity.objects.filter(
+                    point__dwithin=(OuterRef("poly"), D(m=10)),
+                )
+            )
         ).filter(annotated_value=True)
-        self.assertEqual(self.get_names(qs), ['77002', '77025', '77401'])
+        self.assertEqual(self.get_names(qs), ["77002", "77025", "77401"])
 
-    @skipUnlessDBFeature('supports_dwithin_lookup', 'supports_dwithin_distance_expr')
+    @skipUnlessDBFeature("supports_dwithin_lookup", "supports_dwithin_distance_expr")
     def test_dwithin_with_expression_rhs(self):
         # LineString of Wollongong and Adelaide coords.
         ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326)
         qs = AustraliaCity.objects.filter(
-            point__dwithin=(ls, F('allowed_distance')),
-        ).order_by('name')
+            point__dwithin=(ls, F("allowed_distance")),
+        ).order_by("name")
         self.assertEqual(
             self.get_names(qs),
-            ['Adelaide', 'Mittagong', 'Shellharbour', 'Thirroul', 'Wollongong'],
+            ["Adelaide", "Mittagong", "Shellharbour", "Thirroul", "Wollongong"],
         )
 
-    @skipIfDBFeature('supports_dwithin_distance_expr')
+    @skipIfDBFeature("supports_dwithin_distance_expr")
     def test_dwithin_with_expression_rhs_not_supported(self):
         ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326)
         msg = (
-            'This backend does not support expressions for specifying '
-            'distance in the dwithin lookup.'
+            "This backend does not support expressions for specifying "
+            "distance in the dwithin lookup."
         )
         with self.assertRaisesMessage(NotSupportedError, msg):
-            list(AustraliaCity.objects.filter(
-                point__dwithin=(ls, F('allowed_distance')),
-            ))
+            list(
+                AustraliaCity.objects.filter(
+                    point__dwithin=(ls, F("allowed_distance")),
+                )
+            )
 
 
-'''
+"""
 =============================
 Distance functions on PostGIS
 =============================
@@ -310,20 +393,27 @@ ST_Distance(geom1, geom2, use_ellipsoid=False)  |    N/A             |      OK (
 
 Perimeter(geom1)                                |    OK              |      :-( (degrees)
 
-'''  # NOQA
+"""  # NOQA
 
 
 class DistanceFunctionsTests(FuncTestMixin, TestCase):
-    fixtures = ['initial']
+    fixtures = ["initial"]
 
     @skipUnlessDBFeature("has_Area_function")
     def test_area(self):
         # Reference queries:
         # SELECT ST_Area(poly) FROM distapp_southtexaszipcode;
-        area_sq_m = [5437908.90234375, 10183031.4389648, 11254471.0073242, 9881708.91772461]
+        area_sq_m = [
+            5437908.90234375,
+            10183031.4389648,
+            11254471.0073242,
+            9881708.91772461,
+        ]
         # Tolerance has to be lower for Oracle
         tol = 2
-        for i, z in enumerate(SouthTexasZipcode.objects.annotate(area=Area('poly')).order_by('name')):
+        for i, z in enumerate(
+            SouthTexasZipcode.objects.annotate(area=Area("poly")).order_by("name")
+        ):
             self.assertAlmostEqual(area_sq_m[i], z.area.sq_m, tol)
 
     @skipUnlessDBFeature("has_Distance_function")
@@ -332,14 +422,14 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         Test a simple distance query, with projected coordinates and without
         transformation.
         """
-        lagrange = GEOSGeometry('POINT(805066.295722839 4231496.29461335)', 32140)
-        houston = SouthTexasCity.objects.annotate(dist=Distance('point', lagrange)).order_by('id').first()
-        tol = 2 if connection.ops.oracle else 5
-        self.assertAlmostEqual(
-            houston.dist.m,
-            147075.069813,
-            tol
+        lagrange = GEOSGeometry("POINT(805066.295722839 4231496.29461335)", 32140)
+        houston = (
+            SouthTexasCity.objects.annotate(dist=Distance("point", lagrange))
+            .order_by("id")
+            .first()
         )
+        tol = 2 if connection.ops.oracle else 5
+        self.assertAlmostEqual(houston.dist.m, 147075.069813, tol)
 
     @skipUnlessDBFeature("has_Distance_function", "has_Transform_function")
     def test_distance_projected(self):
@@ -347,24 +437,44 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         Test the `Distance` function on projected coordinate systems.
         """
         # The point for La Grange, TX
-        lagrange = GEOSGeometry('POINT(-96.876369 29.905320)', 4326)
+        lagrange = GEOSGeometry("POINT(-96.876369 29.905320)", 4326)
         # Reference distances in feet and in meters. Got these values from
         # using the provided raw SQL statements.
         #  SELECT ST_Distance(point, ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 32140))
         #  FROM distapp_southtexascity;
-        m_distances = [147075.069813, 139630.198056, 140888.552826,
-                       138809.684197, 158309.246259, 212183.594374,
-                       70870.188967, 165337.758878, 139196.085105]
+        m_distances = [
+            147075.069813,
+            139630.198056,
+            140888.552826,
+            138809.684197,
+            158309.246259,
+            212183.594374,
+            70870.188967,
+            165337.758878,
+            139196.085105,
+        ]
         #  SELECT ST_Distance(point, ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 2278))
         #  FROM distapp_southtexascityft;
-        ft_distances = [482528.79154625, 458103.408123001, 462231.860397575,
-                        455411.438904354, 519386.252102563, 696139.009211594,
-                        232513.278304279, 542445.630586414, 456679.155883207]
+        ft_distances = [
+            482528.79154625,
+            458103.408123001,
+            462231.860397575,
+            455411.438904354,
+            519386.252102563,
+            696139.009211594,
+            232513.278304279,
+            542445.630586414,
+            456679.155883207,
+        ]
 
         # Testing using different variations of parameters and using models
         # with different projected coordinate systems.
-        dist1 = SouthTexasCity.objects.annotate(distance=Distance('point', lagrange)).order_by('id')
-        dist2 = SouthTexasCityFt.objects.annotate(distance=Distance('point', lagrange)).order_by('id')
+        dist1 = SouthTexasCity.objects.annotate(
+            distance=Distance("point", lagrange)
+        ).order_by("id")
+        dist2 = SouthTexasCityFt.objects.annotate(
+            distance=Distance("point", lagrange)
+        ).order_by("id")
         dist_qs = [dist1, dist2]
 
         # Ensuring expected distances are returned for each distance queryset.
@@ -386,10 +496,22 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         # Reference query:
         #  SELECT ST_distance_sphere(point, ST_GeomFromText('LINESTRING(150.9020 -34.4245,150.8700 -34.5789)', 4326))
         #  FROM distapp_australiacity ORDER BY name;
-        distances = [1120954.92533513, 140575.720018241, 640396.662906304,
-                     60580.9693849269, 972807.955955075, 568451.8357838,
-                     40435.4335201384, 0, 68272.3896586844, 12375.0643697706, 0]
-        qs = AustraliaCity.objects.annotate(distance=Distance('point', ls)).order_by('name')
+        distances = [
+            1120954.92533513,
+            140575.720018241,
+            640396.662906304,
+            60580.9693849269,
+            972807.955955075,
+            568451.8357838,
+            40435.4335201384,
+            0,
+            68272.3896586844,
+            12375.0643697706,
+            0,
+        ]
+        qs = AustraliaCity.objects.annotate(distance=Distance("point", ls)).order_by(
+            "name"
+        )
         for city, distance in zip(qs, distances):
             with self.subTest(city=city, distance=distance):
                 # Testing equivalence to within a meter (kilometer on SpatiaLite).
@@ -406,30 +528,46 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         #  SELECT ST_distance_sphere(point, ST_GeomFromText('POINT(151.231341 -33.952685)', 4326))
         #  FROM distapp_australiacity WHERE (NOT (id = 11));  st_distance_sphere
         spheroid_distances = [
-            60504.0628957201, 77023.9489850262, 49154.8867574404,
-            90847.4358768573, 217402.811919332, 709599.234564757,
-            640011.483550888, 7772.00667991925, 1047861.78619339,
+            60504.0628957201,
+            77023.9489850262,
+            49154.8867574404,
+            90847.4358768573,
+            217402.811919332,
+            709599.234564757,
+            640011.483550888,
+            7772.00667991925,
+            1047861.78619339,
             1165126.55236034,
         ]
         sphere_distances = [
-            60580.9693849267, 77144.0435286473, 49199.4415344719,
-            90804.7533823494, 217713.384600405, 709134.127242793,
-            639828.157159169, 7786.82949717788, 1049204.06569028,
+            60580.9693849267,
+            77144.0435286473,
+            49199.4415344719,
+            90804.7533823494,
+            217713.384600405,
+            709134.127242793,
+            639828.157159169,
+            7786.82949717788,
+            1049204.06569028,
             1162623.7238134,
         ]
         # Testing with spheroid distances first.
-        hillsdale = AustraliaCity.objects.get(name='Hillsdale')
-        qs = AustraliaCity.objects.exclude(id=hillsdale.id).annotate(
-            distance=Distance('point', hillsdale.point, spheroid=True)
-        ).order_by('id')
+        hillsdale = AustraliaCity.objects.get(name="Hillsdale")
+        qs = (
+            AustraliaCity.objects.exclude(id=hillsdale.id)
+            .annotate(distance=Distance("point", hillsdale.point, spheroid=True))
+            .order_by("id")
+        )
         for i, c in enumerate(qs):
             with self.subTest(c=c):
                 self.assertAlmostEqual(spheroid_distances[i], c.distance.m, tol)
         if connection.ops.postgis or connection.ops.spatialite:
             # PostGIS uses sphere-only distances by default, testing these as well.
-            qs = AustraliaCity.objects.exclude(id=hillsdale.id).annotate(
-                distance=Distance('point', hillsdale.point)
-            ).order_by('id')
+            qs = (
+                AustraliaCity.objects.exclude(id=hillsdale.id)
+                .annotate(distance=Distance("point", hillsdale.point))
+                .order_by("id")
+            )
             for i, c in enumerate(qs):
                 with self.subTest(c=c):
                     self.assertAlmostEqual(sphere_distances[i], c.distance.m, tol)
@@ -437,9 +575,13 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
     @skipIfDBFeature("supports_distance_geodetic")
     @skipUnlessDBFeature("has_Distance_function")
     def test_distance_function_raw_result(self):
-        distance = Interstate.objects.annotate(
-            d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)),
-        ).first().d
+        distance = (
+            Interstate.objects.annotate(
+                d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)),
+            )
+            .first()
+            .d
+        )
         self.assertEqual(distance, 1)
 
     @skipUnlessDBFeature("has_Distance_function")
@@ -449,29 +591,37 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         ).filter(d=D(m=1))
         self.assertTrue(qs.exists())
 
-    @skipUnlessDBFeature('supports_tolerance_parameter')
+    @skipUnlessDBFeature("supports_tolerance_parameter")
     def test_distance_function_tolerance_escaping(self):
-        qs = Interstate.objects.annotate(
-            d=Distance(
-                Point(500, 500, srid=3857),
-                Point(0, 0, srid=3857),
-                tolerance='0.05) = 1 OR 1=1 OR (1+1',
-            ),
-        ).filter(d=D(m=1)).values('pk')
-        msg = 'The tolerance parameter has the wrong type'
+        qs = (
+            Interstate.objects.annotate(
+                d=Distance(
+                    Point(500, 500, srid=3857),
+                    Point(0, 0, srid=3857),
+                    tolerance="0.05) = 1 OR 1=1 OR (1+1",
+                ),
+            )
+            .filter(d=D(m=1))
+            .values("pk")
+        )
+        msg = "The tolerance parameter has the wrong type"
         with self.assertRaisesMessage(TypeError, msg):
             qs.exists()
 
-    @skipUnlessDBFeature('supports_tolerance_parameter')
+    @skipUnlessDBFeature("supports_tolerance_parameter")
     def test_distance_function_tolerance(self):
         # Tolerance is greater than distance.
-        qs = Interstate.objects.annotate(
-            d=Distance(
-                Point(0, 0, srid=3857),
-                Point(1, 1, srid=3857),
-                tolerance=1.5,
-            ),
-        ).filter(d=0).values('pk')
+        qs = (
+            Interstate.objects.annotate(
+                d=Distance(
+                    Point(0, 0, srid=3857),
+                    Point(1, 1, srid=3857),
+                    tolerance=1.5,
+                ),
+            )
+            .filter(d=0)
+            .values("pk")
+        )
         self.assertIs(qs.exists(), True)
 
     @skipIfDBFeature("supports_distance_geodetic")
@@ -480,11 +630,11 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         qs = Interstate.objects.annotate(
             d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)),
         ).filter(d=D(m=1))
-        msg = 'Distance measure is supplied, but units are unknown for result.'
+        msg = "Distance measure is supplied, but units are unknown for result."
         with self.assertRaisesMessage(ValueError, msg):
             list(qs)
 
-    @skipUnlessDBFeature("has_Distance_function", 'has_Transform_function')
+    @skipUnlessDBFeature("has_Distance_function", "has_Transform_function")
     def test_distance_transform(self):
         """
         Test the `Distance` function used with `Transform` on a geographic field.
@@ -493,7 +643,7 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         # of 77005 to 100m) -- which aren't allowed in geographic distance
         # queries normally, however our field has been transformed to
         # a non-geographic system.
-        z = SouthTexasZipcode.objects.get(name='77005')
+        z = SouthTexasZipcode.objects.get(name="77005")
 
         # Reference query:
         # SELECT ST_Distance(ST_Transform("distapp_censuszipcode"."poly", 32140),
@@ -508,22 +658,29 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         # however.
         buf1 = z.poly.centroid.buffer(100)
         buf2 = buf1.transform(4269, clone=True)
-        ref_zips = ['77002', '77025', '77401']
+        ref_zips = ["77002", "77025", "77401"]
 
         for buf in [buf1, buf2]:
-            qs = CensusZipcode.objects.exclude(name='77005').annotate(
-                distance=Distance(Transform('poly', 32140), buf)
-            ).order_by('name')
+            qs = (
+                CensusZipcode.objects.exclude(name="77005")
+                .annotate(distance=Distance(Transform("poly", 32140), buf))
+                .order_by("name")
+            )
             self.assertEqual(ref_zips, sorted(c.name for c in qs))
             for i, z in enumerate(qs):
                 self.assertAlmostEqual(z.distance.m, dists_m[i], 5)
 
     @skipUnlessDBFeature("has_Distance_function")
     def test_distance_order_by(self):
-        qs = SouthTexasCity.objects.annotate(distance=Distance('point', Point(3, 3, srid=32140))).order_by(
-            'distance'
-        ).values_list('name', flat=True).filter(name__in=('San Antonio', 'Pearland'))
-        self.assertSequenceEqual(qs, ['San Antonio', 'Pearland'])
+        qs = (
+            SouthTexasCity.objects.annotate(
+                distance=Distance("point", Point(3, 3, srid=32140))
+            )
+            .order_by("distance")
+            .values_list("name", flat=True)
+            .filter(name__in=("San Antonio", "Pearland"))
+        )
+        self.assertSequenceEqual(qs, ["San Antonio", "Pearland"])
 
     @skipUnlessDBFeature("has_Length_function")
     def test_length(self):
@@ -537,20 +694,24 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         len_m2 = 4617.668
 
         if connection.features.supports_length_geodetic:
-            qs = Interstate.objects.annotate(length=Length('path'))
+            qs = Interstate.objects.annotate(length=Length("path"))
             tol = 2 if connection.ops.oracle else 3
             self.assertAlmostEqual(len_m1, qs[0].length.m, tol)
             # TODO: test with spheroid argument (True and False)
         else:
             # Does not support geodetic coordinate systems.
             with self.assertRaises(NotSupportedError):
-                list(Interstate.objects.annotate(length=Length('path')))
+                list(Interstate.objects.annotate(length=Length("path")))
 
         # Now doing length on a projected coordinate system.
-        i10 = SouthTexasInterstate.objects.annotate(length=Length('path')).get(name='I-10')
+        i10 = SouthTexasInterstate.objects.annotate(length=Length("path")).get(
+            name="I-10"
+        )
         self.assertAlmostEqual(len_m2, i10.length.m, 2)
         self.assertTrue(
-            SouthTexasInterstate.objects.annotate(length=Length('path')).filter(length__gt=4000).exists()
+            SouthTexasInterstate.objects.annotate(length=Length("path"))
+            .filter(length__gt=4000)
+            .exists()
         )
         # Length with an explicit geometry value.
         qs = Interstate.objects.annotate(length=Length(i10.path))
@@ -563,14 +724,21 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
         """
         # Reference query:
         # SELECT ST_Perimeter(distapp_southtexaszipcode.poly) FROM distapp_southtexaszipcode;
-        perim_m = [18404.3550889361, 15627.2108551001, 20632.5588368978, 17094.5996143697]
+        perim_m = [
+            18404.3550889361,
+            15627.2108551001,
+            20632.5588368978,
+            17094.5996143697,
+        ]
         tol = 2 if connection.ops.oracle else 7
-        qs = SouthTexasZipcode.objects.annotate(perimeter=Perimeter('poly')).order_by('name')
+        qs = SouthTexasZipcode.objects.annotate(perimeter=Perimeter("poly")).order_by(
+            "name"
+        )
         for i, z in enumerate(qs):
             self.assertAlmostEqual(perim_m[i], z.perimeter.m, tol)
 
         # Running on points; should return 0.
-        qs = SouthTexasCity.objects.annotate(perim=Perimeter('point'))
+        qs = SouthTexasCity.objects.annotate(perim=Perimeter("point"))
         for city in qs:
             self.assertEqual(0, city.perim.m)
 
@@ -578,28 +746,32 @@ class DistanceFunctionsTests(FuncTestMixin, TestCase):
     def test_perimeter_geodetic(self):
         # Currently only Oracle supports calculating the perimeter on geodetic
         # geometries (without being transformed).
-        qs1 = CensusZipcode.objects.annotate(perim=Perimeter('poly'))
+        qs1 = CensusZipcode.objects.annotate(perim=Perimeter("poly"))
         if connection.features.supports_perimeter_geodetic:
             self.assertAlmostEqual(qs1[0].perim.m, 18406.3818954314, 3)
         else:
             with self.assertRaises(NotSupportedError):
                 list(qs1)
         # But should work fine when transformed to projected coordinates
-        qs2 = CensusZipcode.objects.annotate(perim=Perimeter(Transform('poly', 32140))).filter(name='77002')
+        qs2 = CensusZipcode.objects.annotate(
+            perim=Perimeter(Transform("poly", 32140))
+        ).filter(name="77002")
         self.assertAlmostEqual(qs2[0].perim.m, 18404.355, 3)
 
-    @skipUnlessDBFeature("supports_null_geometries", "has_Area_function", "has_Distance_function")
+    @skipUnlessDBFeature(
+        "supports_null_geometries", "has_Area_function", "has_Distance_function"
+    )
     def test_measurement_null_fields(self):
         """
         Test the measurement functions on fields with NULL values.
         """
         # Creating SouthTexasZipcode w/NULL value.
-        SouthTexasZipcode.objects.create(name='78212')
+        SouthTexasZipcode.objects.create(name="78212")
         # Performing distance/area queries against the NULL PolygonField,
         # and ensuring the result of the operations is None.
-        htown = SouthTexasCity.objects.get(name='Downtown Houston')
+        htown = SouthTexasCity.objects.get(name="Downtown Houston")
         z = SouthTexasZipcode.objects.annotate(
-            distance=Distance('poly', htown.point), area=Area('poly')
-        ).get(name='78212')
+            distance=Distance("poly", htown.point), area=Area("poly")
+        ).get(name="78212")
         self.assertIsNone(z.distance)
         self.assertIsNone(z.area)