Refs #33476 -- Reformatted code with Black.

2 files changed, 87 insertions, 69 deletions

diff --git a/tests/queryset_pickle/models.py b/tests/queryset_pickle/models.py
index f780dc2a18..033cd2bbf9 100644
--- a/tests/queryset_pickle/models.py
+++ b/tests/queryset_pickle/models.py
@@ -17,7 +17,7 @@ class Numbers:
 class PreviousDjangoVersionQuerySet(models.QuerySet):
     def __getstate__(self):
         state = super().__getstate__()
-        state[DJANGO_VERSION_PICKLE_KEY] = '1.0'
+        state[DJANGO_VERSION_PICKLE_KEY] = "1.0"
         return state
 
 
@@ -29,7 +29,7 @@ class MissingDjangoVersionQuerySet(models.QuerySet):
 
 
 class Group(models.Model):
-    name = models.CharField(_('name'), max_length=100)
+    name = models.CharField(_("name"), max_length=100)
     objects = models.Manager()
     previous_django_version_objects = PreviousDjangoVersionQuerySet.as_manager()
     missing_django_version_objects = MissingDjangoVersionQuerySet.as_manager()
@@ -68,7 +68,7 @@ class M2MModel(models.Model):
 class AbstractEvent(Event):
     class Meta:
         abstract = True
-        ordering = ['title']
+        ordering = ["title"]
 
 
 class MyEvent(AbstractEvent):
@@ -76,4 +76,4 @@ class MyEvent(AbstractEvent):
 
 
 class Edition(models.Model):
-    event = models.ForeignKey('MyEvent', on_delete=models.CASCADE)
+    event = models.ForeignKey("MyEvent", on_delete=models.CASCADE)
diff --git a/tests/queryset_pickle/tests.py b/tests/queryset_pickle/tests.py
index 1d47f13c7d..337c5193ce 100644
--- a/tests/queryset_pickle/tests.py
+++ b/tests/queryset_pickle/tests.py
@@ -6,20 +6,28 @@ from django.db import models
 from django.test import TestCase
 
 from .models import (
-    BinaryFieldModel, Container, Event, Group, Happening, M2MModel, MyEvent,
+    BinaryFieldModel,
+    Container,
+    Event,
+    Group,
+    Happening,
+    M2MModel,
+    MyEvent,
 )
 
 
 class PickleabilityTestCase(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.happening = Happening.objects.create()  # make sure the defaults are working (#20158)
+        cls.happening = (
+            Happening.objects.create()
+        )  # make sure the defaults are working (#20158)
 
     def assert_pickles(self, qs):
         self.assertEqual(list(pickle.loads(pickle.dumps(qs))), list(qs))
 
     def test_binaryfield(self):
-        BinaryFieldModel.objects.create(data=b'binary data')
+        BinaryFieldModel.objects.create(data=b"binary data")
         self.assert_pickles(BinaryFieldModel.objects.all())
 
     def test_related_field(self):
@@ -87,7 +95,7 @@ class PickleabilityTestCase(TestCase):
         self.assertEqual(original, reloaded)
         # Also, deferred dynamic model works
         Container.SomeModel.objects.create(somefield=1)
-        original = Container.SomeModel.objects.defer('somefield')[0]
+        original = Container.SomeModel.objects.defer("somefield")[0]
         dumped = pickle.dumps(original)
         reloaded = pickle.loads(dumped)
         self.assertEqual(original, reloaded)
@@ -98,9 +106,9 @@ class PickleabilityTestCase(TestCase):
         Test intentionally the automatically created through model.
         """
         m1 = M2MModel.objects.create()
-        g1 = Group.objects.create(name='foof')
+        g1 = Group.objects.create(name="foof")
         m1.groups.add(g1)
-        m2m_through = M2MModel._meta.get_field('groups').remote_field.through
+        m2m_through = M2MModel._meta.get_field("groups").remote_field.through
         original = m2m_through.objects.get()
         dumped = pickle.dumps(original)
         reloaded = pickle.loads(dumped)
@@ -109,7 +117,12 @@ class PickleabilityTestCase(TestCase):
     def test_model_pickle_dynamic(self):
         class Meta:
             proxy = True
-        dynclass = type("DynamicEventSubclass", (Event,), {'Meta': Meta, '__module__': Event.__module__})
+
+        dynclass = type(
+            "DynamicEventSubclass",
+            (Event,),
+            {"Meta": Meta, "__module__": Event.__module__},
+        )
         original = dynclass(pk=1)
         dumped = pickle.dumps(original)
         reloaded = pickle.loads(dumped)
@@ -117,16 +130,18 @@ class PickleabilityTestCase(TestCase):
         self.assertIs(reloaded.__class__, dynclass)
 
     def test_specialized_queryset(self):
-        self.assert_pickles(Happening.objects.values('name'))
-        self.assert_pickles(Happening.objects.values('name').dates('when', 'year'))
+        self.assert_pickles(Happening.objects.values("name"))
+        self.assert_pickles(Happening.objects.values("name").dates("when", "year"))
         # With related field (#14515)
         self.assert_pickles(
-            Event.objects.select_related('group').order_by('title').values_list('title', 'group__name')
+            Event.objects.select_related("group")
+            .order_by("title")
+            .values_list("title", "group__name")
         )
 
     def test_pickle_prefetch_related_idempotence(self):
-        g = Group.objects.create(name='foo')
-        groups = Group.objects.prefetch_related('event_set')
+        g = Group.objects.create(name="foo")
+        groups = Group.objects.prefetch_related("event_set")
 
         # First pickling
         groups = pickle.loads(pickle.dumps(groups))
@@ -139,26 +154,26 @@ class PickleabilityTestCase(TestCase):
     def test_pickle_prefetch_queryset_usable_outside_of_prefetch(self):
         # Prefetch shouldn't affect the fetch-on-pickle behavior of the
         # queryset passed to it.
-        Group.objects.create(name='foo')
-        events = Event.objects.order_by('id')
-        Group.objects.prefetch_related(models.Prefetch('event_set', queryset=events))
+        Group.objects.create(name="foo")
+        events = Event.objects.order_by("id")
+        Group.objects.prefetch_related(models.Prefetch("event_set", queryset=events))
         with self.assertNumQueries(1):
             events2 = pickle.loads(pickle.dumps(events))
         with self.assertNumQueries(0):
             list(events2)
 
     def test_pickle_prefetch_queryset_still_usable(self):
-        g = Group.objects.create(name='foo')
+        g = Group.objects.create(name="foo")
         groups = Group.objects.prefetch_related(
-            models.Prefetch('event_set', queryset=Event.objects.order_by('id'))
+            models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
         )
         groups2 = pickle.loads(pickle.dumps(groups))
         self.assertSequenceEqual(groups2.filter(id__gte=0), [g])
 
     def test_pickle_prefetch_queryset_not_evaluated(self):
-        Group.objects.create(name='foo')
+        Group.objects.create(name="foo")
         groups = Group.objects.prefetch_related(
-            models.Prefetch('event_set', queryset=Event.objects.order_by('id'))
+            models.Prefetch("event_set", queryset=Event.objects.order_by("id"))
         )
         list(groups)  # evaluate QuerySet
         with self.assertNumQueries(0):
@@ -169,43 +184,45 @@ class PickleabilityTestCase(TestCase):
         #24831 -- Cached properties on ManyToOneRel created in QuerySet.delete()
         caused subsequent QuerySet pickling to fail.
         """
-        g = Group.objects.create(name='foo')
+        g = Group.objects.create(name="foo")
         m2m = M2MModel.objects.create()
         m2m.groups.add(g)
         Group.objects.all().delete()
 
-        m2ms = M2MModel.objects.prefetch_related('groups')
+        m2ms = M2MModel.objects.prefetch_related("groups")
         m2ms = pickle.loads(pickle.dumps(m2ms))
         self.assertSequenceEqual(m2ms, [m2m])
 
     def test_pickle_boolean_expression_in_Q__queryset(self):
-        group = Group.objects.create(name='group')
-        Event.objects.create(title='event', group=group)
+        group = Group.objects.create(name="group")
+        Event.objects.create(title="event", group=group)
         groups = Group.objects.filter(
-            models.Q(models.Exists(
-                Event.objects.filter(group_id=models.OuterRef('id')),
-            )),
+            models.Q(
+                models.Exists(
+                    Event.objects.filter(group_id=models.OuterRef("id")),
+                )
+            ),
         )
         groups2 = pickle.loads(pickle.dumps(groups))
         self.assertSequenceEqual(groups2, [group])
 
     def test_pickle_exists_queryset_still_usable(self):
-        group = Group.objects.create(name='group')
-        Event.objects.create(title='event', group=group)
+        group = Group.objects.create(name="group")
+        Event.objects.create(title="event", group=group)
         groups = Group.objects.annotate(
             has_event=models.Exists(
-                Event.objects.filter(group_id=models.OuterRef('id')),
+                Event.objects.filter(group_id=models.OuterRef("id")),
             ),
         )
         groups2 = pickle.loads(pickle.dumps(groups))
         self.assertSequenceEqual(groups2.filter(has_event=True), [group])
 
     def test_pickle_exists_queryset_not_evaluated(self):
-        group = Group.objects.create(name='group')
-        Event.objects.create(title='event', group=group)
+        group = Group.objects.create(name="group")
+        Event.objects.create(title="event", group=group)
         groups = Group.objects.annotate(
             has_event=models.Exists(
-                Event.objects.filter(group_id=models.OuterRef('id')),
+                Event.objects.filter(group_id=models.OuterRef("id")),
             ),
         )
         list(groups)  # evaluate QuerySet.
@@ -213,11 +230,11 @@ class PickleabilityTestCase(TestCase):
             self.assert_pickles(groups)
 
     def test_pickle_exists_kwargs_queryset_not_evaluated(self):
-        group = Group.objects.create(name='group')
-        Event.objects.create(title='event', group=group)
+        group = Group.objects.create(name="group")
+        Event.objects.create(title="event", group=group)
         groups = Group.objects.annotate(
             has_event=models.Exists(
-                queryset=Event.objects.filter(group_id=models.OuterRef('id')),
+                queryset=Event.objects.filter(group_id=models.OuterRef("id")),
             ),
         )
         list(groups)  # evaluate QuerySet.
@@ -225,11 +242,11 @@ class PickleabilityTestCase(TestCase):
             self.assert_pickles(groups)
 
     def test_pickle_subquery_queryset_not_evaluated(self):
-        group = Group.objects.create(name='group')
-        Event.objects.create(title='event', group=group)
+        group = Group.objects.create(name="group")
+        Event.objects.create(title="event", group=group)
         groups = Group.objects.annotate(
             event_title=models.Subquery(
-                Event.objects.filter(group_id=models.OuterRef('id')).values('title'),
+                Event.objects.filter(group_id=models.OuterRef("id")).values("title"),
             ),
         )
         list(groups)  # evaluate QuerySet.
@@ -237,34 +254,36 @@ class PickleabilityTestCase(TestCase):
             self.assert_pickles(groups)
 
     def test_pickle_filteredrelation(self):
-        group = Group.objects.create(name='group')
-        event_1 = Event.objects.create(title='Big event', group=group)
-        event_2 = Event.objects.create(title='Small event', group=group)
-        Happening.objects.bulk_create([
-            Happening(event=event_1, number1=5),
-            Happening(event=event_2, number1=3),
-        ])
+        group = Group.objects.create(name="group")
+        event_1 = Event.objects.create(title="Big event", group=group)
+        event_2 = Event.objects.create(title="Small event", group=group)
+        Happening.objects.bulk_create(
+            [
+                Happening(event=event_1, number1=5),
+                Happening(event=event_2, number1=3),
+            ]
+        )
         groups = Group.objects.annotate(
             big_events=models.FilteredRelation(
-                'event',
-                condition=models.Q(event__title__startswith='Big'),
+                "event",
+                condition=models.Q(event__title__startswith="Big"),
             ),
-        ).annotate(sum_number=models.Sum('big_events__happening__number1'))
+        ).annotate(sum_number=models.Sum("big_events__happening__number1"))
         groups_query = pickle.loads(pickle.dumps(groups.query))
         groups = Group.objects.all()
         groups.query = groups_query
         self.assertEqual(groups.get().sum_number, 5)
 
     def test_pickle_filteredrelation_m2m(self):
-        group = Group.objects.create(name='group')
+        group = Group.objects.create(name="group")
         m2mmodel = M2MModel.objects.create(added=datetime.date(2020, 1, 1))
         m2mmodel.groups.add(group)
         groups = Group.objects.annotate(
             first_m2mmodels=models.FilteredRelation(
-                'm2mmodel',
+                "m2mmodel",
                 condition=models.Q(m2mmodel__added__year=2020),
             ),
-        ).annotate(count_groups=models.Count('first_m2mmodels__groups'))
+        ).annotate(count_groups=models.Count("first_m2mmodels__groups"))
         groups_query = pickle.loads(pickle.dumps(groups.query))
         groups = Group.objects.all()
         groups.query = groups_query
@@ -272,30 +291,30 @@ class PickleabilityTestCase(TestCase):
 
     def test_annotation_with_callable_default(self):
         # Happening.when has a callable default of datetime.datetime.now.
-        qs = Happening.objects.annotate(latest_time=models.Max('when'))
+        qs = Happening.objects.annotate(latest_time=models.Max("when"))
         self.assert_pickles(qs)
 
     def test_annotation_values(self):
-        qs = Happening.objects.values('name').annotate(latest_time=models.Max('when'))
+        qs = Happening.objects.values("name").annotate(latest_time=models.Max("when"))
         reloaded = Happening.objects.all()
         reloaded.query = pickle.loads(pickle.dumps(qs.query))
         self.assertEqual(
             reloaded.get(),
-            {'name': 'test', 'latest_time': self.happening.when},
+            {"name": "test", "latest_time": self.happening.when},
         )
 
     def test_annotation_values_list(self):
         # values_list() is reloaded to values() when using a pickled query.
         tests = [
-            Happening.objects.values_list('name'),
-            Happening.objects.values_list('name', flat=True),
-            Happening.objects.values_list('name', named=True),
+            Happening.objects.values_list("name"),
+            Happening.objects.values_list("name", flat=True),
+            Happening.objects.values_list("name", named=True),
         ]
         for qs in tests:
             with self.subTest(qs._iterable_class.__name__):
                 reloaded = Happening.objects.all()
                 reloaded.query = pickle.loads(pickle.dumps(qs.query))
-                self.assertEqual(reloaded.get(), {'name': 'test'})
+                self.assertEqual(reloaded.get(), {"name": "test"})
 
     def test_filter_deferred(self):
         qs = Happening.objects.all()
@@ -327,19 +346,18 @@ class PickleabilityTestCase(TestCase):
             pickle.loads(pickle.dumps(qs))
 
     def test_order_by_model_with_abstract_inheritance_and_meta_ordering(self):
-        group = Group.objects.create(name='test')
-        event = MyEvent.objects.create(title='test event', group=group)
+        group = Group.objects.create(name="test")
+        event = MyEvent.objects.create(title="test event", group=group)
         event.edition_set.create()
-        self.assert_pickles(event.edition_set.order_by('event'))
+        self.assert_pickles(event.edition_set.order_by("event"))
 
 
 class InLookupTests(TestCase):
-
     @classmethod
     def setUpTestData(cls):
         for i in range(1, 3):
-            group = Group.objects.create(name='Group {}'.format(i))
-        cls.e1 = Event.objects.create(title='Event 1', group=group)
+            group = Group.objects.create(name="Group {}".format(i))
+        cls.e1 = Event.objects.create(title="Event 1", group=group)
 
     def test_in_lookup_queryset_evaluation(self):
         """
@@ -359,7 +377,7 @@ class InLookupTests(TestCase):
         self.assertSequenceEqual(reloaded_events, [self.e1])
 
     def test_in_lookup_query_evaluation(self):
-        events = Event.objects.filter(group__in=Group.objects.values('id').query)
+        events = Event.objects.filter(group__in=Group.objects.values("id").query)
 
         with self.assertNumQueries(0):
             dumped = pickle.dumps(events.query)