Fixed #26176 -- Fixed E123 flake8 warnings.26176

1 files changed, 138 insertions, 186 deletions

diff --git a/tests/many_to_one/tests.py b/tests/many_to_one/tests.py
index b3028e00ca..e8210955ce 100644
--- a/tests/many_to_one/tests.py
+++ b/tests/many_to_one/tests.py
@@ -22,8 +22,7 @@ class ManyToOneTests(TestCase):
         self.r2 = Reporter(first_name='Paul', last_name='Jones', email='paul@example.com')
         self.r2.save()
         # Create an Article.
-        self.a = Article(id=None, headline="This is a test",
-                         pub_date=datetime.date(2005, 7, 27), reporter=self.r)
+        self.a = Article(headline="This is a test", pub_date=datetime.date(2005, 7, 27), reporter=self.r)
         self.a.save()
 
     def test_get(self):
@@ -38,21 +37,18 @@ class ManyToOneTests(TestCase):
     def test_create(self):
         # You can also instantiate an Article by passing the Reporter's ID
         # instead of a Reporter object.
-        a3 = Article(id=None, headline="Third article",
-                     pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
+        a3 = Article(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
         a3.save()
         self.assertEqual(a3.reporter.id, self.r.id)
 
         # Similarly, the reporter ID can be a string.
-        a4 = Article(id=None, headline="Fourth article",
-                     pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        a4 = Article(headline="Fourth article", pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
         a4.save()
         self.assertEqual(repr(a4.reporter), "<Reporter: John Smith>")
 
     def test_add(self):
         # Create an Article via the Reporter object.
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
         self.assertEqual(repr(new_article), "<Article: John's second story>")
         self.assertEqual(new_article.reporter.id, self.r.id)
 
@@ -64,12 +60,10 @@ class ManyToOneTests(TestCase):
 
         self.r.article_set.add(new_article2, bulk=False)
         self.assertEqual(new_article2.reporter.id, self.r.id)
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>", "<Article: This is a test>"]
+        )
 
         # Add the same article to a different article set - check that it moves.
         self.r2.article_set.add(new_article2)
@@ -81,17 +75,14 @@ class ManyToOneTests(TestCase):
             with six.assertRaisesRegex(self, TypeError,
                                        "'Article' instance expected, got <Reporter.*"):
                 self.r.article_set.add(self.r2)
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
 
     def test_set(self):
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story",
-                                                  pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
 
         # Assign the article to the reporter.
         new_article2.reporter = self.r
@@ -108,20 +99,18 @@ class ManyToOneTests(TestCase):
         # Set the article back again.
         self.r2.article_set.set([new_article, new_article2])
         self.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"])
-        self.assertQuerysetEqual(self.r2.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-            ])
+        self.assertQuerysetEqual(
+            self.r2.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>"]
+        )
 
         # Funny case - because the ForeignKey cannot be null,
         # existing members of the set must remain.
         self.r.article_set.set([new_article])
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"])
 
     def test_reverse_assignment_deprecation(self):
@@ -134,10 +123,8 @@ class ManyToOneTests(TestCase):
             self.r2.article_set = []
 
     def test_assign(self):
-        new_article = self.r.article_set.create(headline="John's second story",
-                                                pub_date=datetime.date(2005, 7, 29))
-        new_article2 = self.r2.article_set.create(headline="Paul's story",
-                                                  pub_date=datetime.date(2006, 1, 17))
+        new_article = self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        new_article2 = self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
 
         # Assign the article to the reporter directly using the descriptor.
         new_article2.reporter = self.r
@@ -154,73 +141,59 @@ class ManyToOneTests(TestCase):
         # Set the article back again using set() method.
         self.r2.article_set.set([new_article, new_article2])
         self.assertQuerysetEqual(self.r.article_set.all(), ["<Article: This is a test>"])
-        self.assertQuerysetEqual(self.r2.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: Paul's story>",
-            ])
+        self.assertQuerysetEqual(
+            self.r2.article_set.all(),
+            ["<Article: John's second story>", "<Article: Paul's story>"]
+        )
 
         # Because the ForeignKey cannot be null, existing members of the set
         # must remain.
         self.r.article_set.set([new_article])
-        self.assertQuerysetEqual(self.r.article_set.all(),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            self.r.article_set.all(),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         self.assertQuerysetEqual(self.r2.article_set.all(), ["<Article: Paul's story>"])
         # Reporter cannot be null - there should not be a clear or remove method
         self.assertFalse(hasattr(self.r2.article_set, 'remove'))
         self.assertFalse(hasattr(self.r2.article_set, 'clear'))
 
     def test_selects(self):
-        self.r.article_set.create(headline="John's second story",
-                                  pub_date=datetime.date(2005, 7, 29))
-        self.r2.article_set.create(headline="Paul's story",
-                                   pub_date=datetime.date(2006, 1, 17))
+        self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
         # Reporter objects have access to their related Article objects.
         self.assertQuerysetEqual(self.r.article_set.all(), [
             "<Article: John's second story>",
             "<Article: This is a test>",
         ])
-        self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='This'),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(self.r.article_set.filter(headline__startswith='This'), ["<Article: This is a test>"])
         self.assertEqual(self.r.article_set.count(), 2)
         self.assertEqual(self.r2.article_set.count(), 1)
         # Get articles by id
-        self.assertQuerysetEqual(Article.objects.filter(id__exact=self.a.id),
-                                 ["<Article: This is a test>"])
-        self.assertQuerysetEqual(Article.objects.filter(pk=self.a.id),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(id__exact=self.a.id), ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(pk=self.a.id), ["<Article: This is a test>"])
         # Query on an article property
-        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='This'),
-                                 ["<Article: This is a test>"])
+        self.assertQuerysetEqual(Article.objects.filter(headline__startswith='This'), ["<Article: This is a test>"])
         # The API automatically follows relationships as far as you need.
         # Use double underscores to separate relationships.
         # This works as many levels deep as you want. There's no limit.
         # Find all Articles for any Reporter whose first name is "John".
-        self.assertQuerysetEqual(Article.objects.filter(reporter__first_name__exact='John'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(reporter__first_name__exact='John'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Check that implied __exact also works
-        self.assertQuerysetEqual(Article.objects.filter(reporter__first_name='John'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+        self.assertQuerysetEqual(
+            Article.objects.filter(reporter__first_name='John'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Query twice over the related field.
         self.assertQuerysetEqual(
-            Article.objects.filter(reporter__first_name__exact='John',
-                                   reporter__last_name__exact='Smith'),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith'),
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # The underlying query only makes one join when a related table is referenced twice.
-        queryset = Article.objects.filter(reporter__first_name__exact='John',
-                                       reporter__last_name__exact='Smith')
+        queryset = Article.objects.filter(reporter__first_name__exact='John', reporter__last_name__exact='Smith')
         self.assertNumQueries(1, list, queryset)
         self.assertEqual(queryset.query.get_compiler(queryset.db).as_sql()[0].count('INNER JOIN'), 1)
 
@@ -228,19 +201,15 @@ class ManyToOneTests(TestCase):
         self.assertQuerysetEqual(
             Article.objects.filter(reporter__first_name__exact='John').extra(
                 where=["many_to_one_reporter.last_name='Smith'"]),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # ... and should work fine with the unicode that comes out of forms.Form.cleaned_data
         self.assertQuerysetEqual(
             (Article.objects
                 .filter(reporter__first_name__exact='John')
                 .extra(where=["many_to_one_reporter.last_name='%s'" % 'Smith'])),
-            [
-                "<Article: John's second story>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second story>", "<Article: This is a test>"]
+        )
         # Find all Articles for a Reporter.
         # Use direct ID check, pk check, and object comparison
         self.assertQuerysetEqual(
@@ -294,49 +263,39 @@ class ManyToOneTests(TestCase):
             ])
 
     def test_reverse_selects(self):
-        a3 = Article.objects.create(id=None, headline="Third article",
-                                    pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
-        Article.objects.create(id=None, headline="Fourth article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        a3 = Article.objects.create(
+            headline="Third article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=self.r.id,
+        )
+        Article.objects.create(
+            headline="Fourth article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=self.r.id,
+        )
+        john_smith = ["<Reporter: John Smith>"]
         # Reporters can be queried
-        self.assertQuerysetEqual(Reporter.objects.filter(id__exact=self.r.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(pk=self.r.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(first_name__startswith='John'),
-                                 ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(id__exact=self.r.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(pk=self.r.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(first_name__startswith='John'), john_smith)
         # Reporters can query in opposite direction of ForeignKey definition
-        self.assertQuerysetEqual(Reporter.objects.filter(article__id__exact=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article__pk=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a.id),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a),
-                                 ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__in=[self.a, a3]).distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__id__exact=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__pk=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a.id), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article=self.a), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3.id]).distinct(), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a.id, a3]).distinct(), john_smith)
+        self.assertQuerysetEqual(Reporter.objects.filter(article__in=[self.a, a3]).distinct(), john_smith)
         self.assertQuerysetEqual(
             Reporter.objects.filter(article__headline__startswith='T'),
             ["<Reporter: John Smith>", "<Reporter: John Smith>"],
             ordered=False
         )
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__headline__startswith='T').distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__headline__startswith='T').distinct(), john_smith)
 
         # Counting in the opposite direction works in conjunction with distinct()
-        self.assertEqual(
-            Reporter.objects.filter(article__headline__startswith='T').count(), 2)
-        self.assertEqual(
-            Reporter.objects.filter(article__headline__startswith='T').distinct().count(), 1)
+        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').count(), 2)
+        self.assertEqual(Reporter.objects.filter(article__headline__startswith='T').distinct().count(), 1)
 
         # Queries can go round in circles.
         self.assertQuerysetEqual(
@@ -350,23 +309,21 @@ class ManyToOneTests(TestCase):
         )
         self.assertQuerysetEqual(
             Reporter.objects.filter(article__reporter__first_name__startswith='John').distinct(),
-            ["<Reporter: John Smith>"])
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__reporter__exact=self.r).distinct(),
-            ["<Reporter: John Smith>"])
+            john_smith
+        )
+        self.assertQuerysetEqual(Reporter.objects.filter(article__reporter__exact=self.r).distinct(), john_smith)
 
         # Check that implied __exact also works.
-        self.assertQuerysetEqual(
-            Reporter.objects.filter(article__reporter=self.r).distinct(),
-            ["<Reporter: John Smith>"])
+        self.assertQuerysetEqual(Reporter.objects.filter(article__reporter=self.r).distinct(), john_smith)
 
         # It's possible to use values() calls across many-to-one relations.
         # (Note, too, that we clear the ordering here so as not to drag the
         # 'headline' field into the columns being used to determine uniqueness)
         d = {'reporter__first_name': 'John', 'reporter__last_name': 'Smith'}
-        self.assertEqual([d],
-            list(Article.objects.filter(reporter=self.r).distinct().order_by()
-                 .values('reporter__first_name', 'reporter__last_name')))
+        qs = Article.objects.filter(
+            reporter=self.r,
+        ).distinct().order_by().values('reporter__first_name', 'reporter__last_name')
+        self.assertEqual([d], list(qs))
 
     def test_select_related(self):
         # Check that Article.objects.select_related().dates() works properly when
@@ -376,55 +333,54 @@ class ManyToOneTests(TestCase):
         r2 = Reporter.objects.create(first_name='John', last_name='Kass', email='jkass@tribune.com')
         Article.objects.create(headline='First', pub_date=datetime.date(1980, 4, 23), reporter=r1)
         Article.objects.create(headline='Second', pub_date=datetime.date(1980, 4, 23), reporter=r2)
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'day')),
-            [
-                datetime.date(1980, 4, 23),
-                datetime.date(2005, 7, 27),
-            ])
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'month')),
-            [
-                datetime.date(1980, 4, 1),
-                datetime.date(2005, 7, 1),
-            ])
-        self.assertEqual(list(Article.objects.select_related().dates('pub_date', 'year')),
-            [
-                datetime.date(1980, 1, 1),
-                datetime.date(2005, 1, 1),
-            ])
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'day')),
+            [datetime.date(1980, 4, 23), datetime.date(2005, 7, 27)]
+        )
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'month')),
+            [datetime.date(1980, 4, 1), datetime.date(2005, 7, 1)]
+        )
+        self.assertEqual(
+            list(Article.objects.select_related().dates('pub_date', 'year')),
+            [datetime.date(1980, 1, 1), datetime.date(2005, 1, 1)]
+        )
 
     def test_delete(self):
-        self.r.article_set.create(headline="John's second story",
-                                  pub_date=datetime.date(2005, 7, 29))
-        self.r2.article_set.create(headline="Paul's story",
-                                   pub_date=datetime.date(2006, 1, 17))
-        Article.objects.create(id=None, headline="Third article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
-        Article.objects.create(id=None, headline="Fourth article",
-                               pub_date=datetime.date(2005, 7, 27), reporter_id=str(self.r.id))
+        self.r.article_set.create(headline="John's second story", pub_date=datetime.date(2005, 7, 29))
+        self.r2.article_set.create(headline="Paul's story", pub_date=datetime.date(2006, 1, 17))
+        Article.objects.create(headline="Third article", pub_date=datetime.date(2005, 7, 27), reporter_id=self.r.id)
+        Article.objects.create(
+            headline="Fourth article",
+            pub_date=datetime.date(2005, 7, 27),
+            reporter_id=str(self.r.id),
+        )
         # If you delete a reporter, his articles will be deleted.
-        self.assertQuerysetEqual(Article.objects.all(),
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 "<Article: Fourth article>",
                 "<Article: John's second story>",
                 "<Article: Paul's story>",
                 "<Article: Third article>",
                 "<Article: This is a test>",
-            ])
-        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'),
-            [
-                "<Reporter: John Smith>",
-                "<Reporter: Paul Jones>",
-            ])
+            ]
+        )
+        self.assertQuerysetEqual(
+            Reporter.objects.order_by('first_name'),
+            ["<Reporter: John Smith>", "<Reporter: Paul Jones>"]
+        )
         self.r2.delete()
-        self.assertQuerysetEqual(Article.objects.all(),
+        self.assertQuerysetEqual(
+            Article.objects.all(),
             [
                 "<Article: Fourth article>",
                 "<Article: John's second story>",
                 "<Article: Third article>",
                 "<Article: This is a test>",
-            ])
-        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'),
-                                 ["<Reporter: John Smith>"])
+            ]
+        )
+        self.assertQuerysetEqual(Reporter.objects.order_by('first_name'), ["<Reporter: John Smith>"])
         # You can delete using a JOIN in the query.
         Reporter.objects.filter(article__headline__startswith='This').delete()
         self.assertQuerysetEqual(Reporter.objects.all(), [])
@@ -433,33 +389,35 @@ class ManyToOneTests(TestCase):
     def test_explicit_fk(self):
         # Create a new Article with get_or_create using an explicit value
         # for a ForeignKey.
-        a2, created = Article.objects.get_or_create(id=None,
-                                                    headline="John's second test",
-                                                    pub_date=datetime.date(2011, 5, 7),
-                                                    reporter_id=self.r.id)
+        a2, created = Article.objects.get_or_create(
+            headline="John's second test",
+            pub_date=datetime.date(2011, 5, 7),
+            reporter_id=self.r.id,
+        )
         self.assertTrue(created)
         self.assertEqual(a2.reporter.id, self.r.id)
 
         # You can specify filters containing the explicit FK value.
         self.assertQuerysetEqual(
             Article.objects.filter(reporter_id__exact=self.r.id),
-            [
-                "<Article: John's second test>",
-                "<Article: This is a test>",
-            ])
+            ["<Article: John's second test>", "<Article: This is a test>"]
+        )
 
         # Create an Article by Paul for the same date.
-        a3 = Article.objects.create(id=None, headline="Paul's commentary",
-                                    pub_date=datetime.date(2011, 5, 7),
-                                    reporter_id=self.r2.id)
+        a3 = Article.objects.create(
+            headline="Paul's commentary",
+            pub_date=datetime.date(2011, 5, 7),
+            reporter_id=self.r2.id,
+        )
         self.assertEqual(a3.reporter.id, self.r2.id)
 
         # Get should respect explicit foreign keys as well.
         with self.assertRaises(MultipleObjectsReturned):
             Article.objects.get(reporter_id=self.r.id)
-        self.assertEqual(repr(a3),
-                         repr(Article.objects.get(reporter_id=self.r2.id,
-                                             pub_date=datetime.date(2011, 5, 7))))
+        self.assertEqual(
+            repr(a3),
+            repr(Article.objects.get(reporter_id=self.r2.id, pub_date=datetime.date(2011, 5, 7)))
+        )
 
     def test_deepcopy_and_circular_references(self):
         # Regression for #12876 -- Model methods that include queries that
@@ -478,12 +436,9 @@ class ManyToOneTests(TestCase):
         self.assertIs(r1.article_set.__class__, r2.article_set.__class__)
 
     def test_create_relation_with_ugettext_lazy(self):
-        reporter = Reporter.objects.create(first_name='John',
-                                           last_name='Smith',
-                                           email='john.smith@example.com')
+        reporter = Reporter.objects.create(first_name='John', last_name='Smith', email='john.smith@example.com')
         lazy = ugettext_lazy('test')
-        reporter.article_set.create(headline=lazy,
-                                    pub_date=datetime.date(2011, 6, 10))
+        reporter.article_set.create(headline=lazy, pub_date=datetime.date(2011, 6, 10))
         notlazy = six.text_type(lazy)
         article = reporter.article_set.get()
         self.assertEqual(article.headline, notlazy)
@@ -632,10 +587,7 @@ class ManyToOneTests(TestCase):
         private_student = Student.objects.create(school=private_school)
 
         # Only one school is available via all() due to the custom default manager.
-        self.assertQuerysetEqual(
-            School.objects.all(),
-            ["<School: School object>"]
-        )
+        self.assertQuerysetEqual(School.objects.all(), ["<School: School object>"])
 
         self.assertEqual(public_student.school, public_school)