Run black -l 79 against all source files

This is a straight reformat run using black as is, with no edits
applied at all.

The black run will format code consistently, however in
some cases that are prevalent in SQLAlchemy code it produces
too-long lines.   The too-long lines will be resolved in the
following commit that will resolve all remaining flake8 issues
including shadowed builtins, long lines, import order, unused
imports, duplicate imports, and docstring issues.

Change-Id: I7eda77fed3d8e73df84b3651fd6cfcfe858d4dc9

1 files changed, 93 insertions, 65 deletions

diff --git a/test/orm/test_evaluator.py b/test/orm/test_evaluator.py
index fca050ccf..651c81a85 100644
--- a/test/orm/test_evaluator.py
+++ b/test/orm/test_evaluator.py
@@ -24,9 +24,13 @@ def eval_eq(clause, testcases=None):
     evaluator = compiler.process(clause)
 
     def testeval(obj=None, expected_result=None):
-        assert evaluator(obj) == expected_result, \
-            "%s != %r for %s with %r" % (
-                evaluator(obj), expected_result, clause, obj)
+        assert evaluator(obj) == expected_result, "%s != %r for %s with %r" % (
+            evaluator(obj),
+            expected_result,
+            clause,
+            obj,
+        )
+
     if testcases:
         for an_obj, result in testcases:
             testeval(an_obj, result)
@@ -36,10 +40,13 @@ def eval_eq(clause, testcases=None):
 class EvaluateTest(fixtures.MappedTest):
     @classmethod
     def define_tables(cls, metadata):
-        Table('users', metadata,
-              Column('id', Integer, primary_key=True),
-              Column('name', String(64)),
-              Column('othername', String(64)))
+        Table(
+            "users",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("name", String(64)),
+            Column("othername", String(64)),
+        )
 
     @classmethod
     def setup_classes(cls):
@@ -55,35 +62,43 @@ class EvaluateTest(fixtures.MappedTest):
     def test_compare_to_value(self):
         User = self.classes.User
 
-        eval_eq(User.name == 'foo', testcases=[
-            (User(name='foo'), True),
-            (User(name='bar'), False),
-            (User(name=None), None),
-        ])
+        eval_eq(
+            User.name == "foo",
+            testcases=[
+                (User(name="foo"), True),
+                (User(name="bar"), False),
+                (User(name=None), None),
+            ],
+        )
 
-        eval_eq(User.id < 5, testcases=[
-            (User(id=3), True),
-            (User(id=5), False),
-            (User(id=None), None),
-        ])
+        eval_eq(
+            User.id < 5,
+            testcases=[
+                (User(id=3), True),
+                (User(id=5), False),
+                (User(id=None), None),
+            ],
+        )
 
     def test_compare_to_callable_bind(self):
         User = self.classes.User
 
         eval_eq(
-            User.name == bindparam('x', callable_=lambda: 'foo'),
+            User.name == bindparam("x", callable_=lambda: "foo"),
             testcases=[
-                (User(name='foo'), True),
-                (User(name='bar'), False),
+                (User(name="foo"), True),
+                (User(name="bar"), False),
                 (User(name=None), None),
-            ]
+            ],
         )
 
     def test_compare_to_none(self):
         User = self.classes.User
 
-        eval_eq(User.name == None,  # noqa
-                testcases=[(User(name='foo'), False), (User(name=None), True)])
+        eval_eq(
+            User.name == None,  # noqa
+            testcases=[(User(name="foo"), False), (User(name=None), True)],
+        )
 
     def test_warn_on_unannotated_matched_column(self):
         User = self.classes.User
@@ -92,8 +107,9 @@ class EvaluateTest(fixtures.MappedTest):
 
         with expect_warnings(
             r"Evaluating non-mapped column expression 'othername' "
-                "onto ORM instances; this is a deprecated use case."):
-            meth = compiler.process(User.name == Column('othername', String))
+            "onto ORM instances; this is a deprecated use case."
+        ):
+            meth = compiler.process(User.name == Column("othername", String))
 
         u1 = User(id=5)
         meth(u1)
@@ -106,7 +122,8 @@ class EvaluateTest(fixtures.MappedTest):
         assert_raises_message(
             evaluator.UnevaluatableError,
             "Cannot evaluate column: foo",
-            compiler.process, User.id == Column('foo', Integer)
+            compiler.process,
+            User.id == Column("foo", Integer),
         )
 
         # if we let the above method through as we did
@@ -121,58 +138,70 @@ class EvaluateTest(fixtures.MappedTest):
         eval_eq(
             User.name == False,  # noqa
             testcases=[
-                (User(name='foo'), False),
+                (User(name="foo"), False),
                 (User(name=True), False),
                 (User(name=False), True),
-            ]
+            ],
         )
 
         eval_eq(
             User.name == True,  # noqa
             testcases=[
-                (User(name='foo'), False),
+                (User(name="foo"), False),
                 (User(name=True), True),
                 (User(name=False), False),
-            ]
+            ],
         )
 
     def test_boolean_ops(self):
         User = self.classes.User
 
-        eval_eq(and_(User.name == 'foo', User.id == 1), testcases=[
-            (User(id=1, name='foo'), True),
-            (User(id=2, name='foo'), False),
-            (User(id=1, name='bar'), False),
-            (User(id=2, name='bar'), False),
-            (User(id=1, name=None), None),
-        ])
-
-        eval_eq(or_(User.name == 'foo', User.id == 1), testcases=[
-            (User(id=1, name='foo'), True),
-            (User(id=2, name='foo'), True),
-            (User(id=1, name='bar'), True),
-            (User(id=2, name='bar'), False),
-            (User(id=1, name=None), True),
-            (User(id=2, name=None), None),
-        ])
-
-        eval_eq(not_(User.id == 1), testcases=[
-            (User(id=1), False),
-            (User(id=2), True),
-            (User(id=None), None),
-        ])
+        eval_eq(
+            and_(User.name == "foo", User.id == 1),
+            testcases=[
+                (User(id=1, name="foo"), True),
+                (User(id=2, name="foo"), False),
+                (User(id=1, name="bar"), False),
+                (User(id=2, name="bar"), False),
+                (User(id=1, name=None), None),
+            ],
+        )
+
+        eval_eq(
+            or_(User.name == "foo", User.id == 1),
+            testcases=[
+                (User(id=1, name="foo"), True),
+                (User(id=2, name="foo"), True),
+                (User(id=1, name="bar"), True),
+                (User(id=2, name="bar"), False),
+                (User(id=1, name=None), True),
+                (User(id=2, name=None), None),
+            ],
+        )
+
+        eval_eq(
+            not_(User.id == 1),
+            testcases=[
+                (User(id=1), False),
+                (User(id=2), True),
+                (User(id=None), None),
+            ],
+        )
 
     def test_null_propagation(self):
         User = self.classes.User
 
-        eval_eq((User.name == 'foo') == (User.id == 1), testcases=[
-            (User(id=1, name='foo'), True),
-            (User(id=2, name='foo'), False),
-            (User(id=1, name='bar'), False),
-            (User(id=2, name='bar'), True),
-            (User(id=None, name='foo'), None),
-            (User(id=None, name=None), None),
-        ])
+        eval_eq(
+            (User.name == "foo") == (User.id == 1),
+            testcases=[
+                (User(id=1, name="foo"), True),
+                (User(id=2, name="foo"), False),
+                (User(id=1, name="bar"), False),
+                (User(id=2, name="bar"), True),
+                (User(id=None, name="foo"), None),
+                (User(id=None, name=None), None),
+            ],
+        )
 
 
 class M2OEvaluateTest(fixtures.DeclarativeMappedTest):
@@ -187,12 +216,13 @@ class M2OEvaluateTest(fixtures.DeclarativeMappedTest):
         class Child(Base):
             __tablename__ = "child"
             _id_parent = Column(
-                "id_parent", Integer, ForeignKey(Parent.id), primary_key=True)
+                "id_parent", Integer, ForeignKey(Parent.id), primary_key=True
+            )
             name = Column(String(50), primary_key=True)
             parent = relationship(Parent)
 
     def test_delete(self):
-        Parent, Child = self.classes('Parent', 'Child')
+        Parent, Child = self.classes("Parent", "Child")
 
         session = Session()
 
@@ -206,6 +236,4 @@ class M2OEvaluateTest(fixtures.DeclarativeMappedTest):
 
         session.query(Child).filter(Child.parent == p).delete("evaluate")
 
-        is_(
-            inspect(c).deleted, True
-        )
+        is_(inspect(c).deleted, True)