Python-tidy test/engine and test/aaa_profiling, 80% auto + 20% manual intervention

1 files changed, 228 insertions, 196 deletions

diff --git a/test/aaa_profiling/test_zoomark.py b/test/aaa_profiling/test_zoomark.py
index 20dd2597e..dc990e983 100644
--- a/test/aaa_profiling/test_zoomark.py
+++ b/test/aaa_profiling/test_zoomark.py
@@ -1,143 +1,137 @@
 """Benchmark for SQLAlchemy.
 
-An adaptation of Robert Brewers' ZooMark speed tests.
-"""
+An adaptation of Robert Brewers' ZooMark speed tests. """
+
 
 import datetime
 import sys
 import time
 from sqlalchemy import *
 from sqlalchemy.test import *
-
 ITERATIONS = 1
-
 dbapi_session = engines.ReplayableSession()
 metadata = None
 
-    
-class ZooMarkTest(TestBase):
-    """Runs the ZooMark and squawks if method counts vary from the norm.
 
-    Each test has an associated `call_range`, the total number of accepted
-    function calls made during the test.  The count can vary between Python
-    2.4 and 2.5.
+class ZooMarkTest(TestBase):
 
+    """Runs the ZooMark and squawks if method counts vary from the norm.
+    
+    Each test has an associated `call_range`, the total number of
+    accepted function calls made during the test.  The count can vary
+    between Python 2.4 and 2.5.
+    
     Unlike a unit test, this is a ordered collection of steps.  Running
     components individually will fail.
-
+    
     """
 
     __only_on__ = 'postgresql+psycopg2'
-    __skip_if__ = ((lambda: sys.version_info < (2, 4)), )
+    __skip_if__ = lambda : sys.version_info < (2, 4),
 
     def test_baseline_0_setup(self):
         global metadata
-
         creator = testing.db.pool._creator
-        
-        recorder = lambda: dbapi_session.recorder(creator())
-        engine = engines.testing_engine(options={'creator':recorder})
+        recorder = lambda : dbapi_session.recorder(creator())
+        engine = engines.testing_engine(options={'creator': recorder})
         metadata = MetaData(engine)
         engine.connect()
-        
+
     def test_baseline_1_create_tables(self):
-        Zoo = Table('Zoo', metadata,
-                    Column('ID', Integer, Sequence('zoo_id_seq'),
-                           primary_key=True, index=True),
-                    Column('Name', Unicode(255)),
-                    Column('Founded', Date),
-                    Column('Opens', Time),
-                    Column('LastEscape', DateTime),
-                    Column('Admission', Float),
-                    )
-
-        Animal = Table('Animal', metadata,
-                       Column('ID', Integer, Sequence('animal_id_seq'),
-                              primary_key=True),
-                       Column('ZooID', Integer, ForeignKey('Zoo.ID'),
-                              index=True),
-                       Column('Name', Unicode(100)),
-                       Column('Species', Unicode(100)),
-                       Column('Legs', Integer, default=4),
-                       Column('LastEscape', DateTime),
-                       Column('Lifespan', Float(4)),
-                       Column('MotherID', Integer, ForeignKey('Animal.ID')),
-                       Column('PreferredFoodID', Integer),
-                       Column('AlternateFoodID', Integer),
-                       )
+        Zoo = Table(
+            'Zoo',
+            metadata,
+            Column('ID', Integer, Sequence('zoo_id_seq'),
+                   primary_key=True, index=True),
+            Column('Name', Unicode(255)),
+            Column('Founded', Date),
+            Column('Opens', Time),
+            Column('LastEscape', DateTime),
+            Column('Admission', Float),
+            )
+        Animal = Table(
+            'Animal',
+            metadata,
+            Column('ID', Integer, Sequence('animal_id_seq'),
+                   primary_key=True),
+            Column('ZooID', Integer, ForeignKey('Zoo.ID'), index=True),
+            Column('Name', Unicode(100)),
+            Column('Species', Unicode(100)),
+            Column('Legs', Integer, default=4),
+            Column('LastEscape', DateTime),
+            Column('Lifespan', Float(4)),
+            Column('MotherID', Integer, ForeignKey('Animal.ID')),
+            Column('PreferredFoodID', Integer),
+            Column('AlternateFoodID', Integer),
+            )
         metadata.create_all()
 
     def test_baseline_1a_populate(self):
         Zoo = metadata.tables['Zoo']
         Animal = metadata.tables['Animal']
-
         wap = Zoo.insert().execute(Name=u'Wild Animal Park',
-                           Founded=datetime.date(2000, 1, 1),
-                           # 59 can give rounding errors with divmod, which
-                           # AdapterFromADO needs to correct.
-                           Opens=datetime.time(8, 15, 59),
-                           LastEscape=datetime.datetime(2004, 7, 29, 5, 6, 7),
-                           Admission=4.95,
-                           ).inserted_primary_key[0]
-
-        sdz = Zoo.insert().execute(Name =u'San Diego Zoo',
-                           Founded = datetime.date(1935, 9, 13),
-                           Opens = datetime.time(9, 0, 0),
-                           Admission = 0,
-                           ).inserted_primary_key[0]
-
-        Zoo.insert(inline=True).execute(
-                  Name = u'Montr\xe9al Biod\xf4me',
-                  Founded = datetime.date(1992, 6, 19),
-                  Opens = datetime.time(9, 0, 0),
-                  Admission = 11.75,
-                  )
-
-        seaworld = Zoo.insert().execute(
-                Name =u'Sea_World', Admission = 60).inserted_primary_key[0]
+                                   Founded=datetime.date(2000, 1, 1),
+                                   Opens=datetime.time(8, 15, 59),
+                                   LastEscape=
+                                  datetime.datetime(2004, 7, 29, 5, 6, 7),
+                                  Admission=4.95).inserted_primary_key[0]
+        sdz = Zoo.insert().execute(Name=u'San Diego Zoo',
+                                   Founded=datetime.date(1935, 9, 13),
+                                   Opens=datetime.time(9, 0, 0),
+                                   Admission=0).inserted_primary_key[0]
+        Zoo.insert(inline=True).execute(Name=u'Montr\xe9al Biod\xf4me',
+                Founded=datetime.date(1992, 6, 19),
+                Opens=datetime.time(9, 0, 0), Admission=11.75)
+        seaworld = Zoo.insert().execute(Name=u'Sea_World',
+                Admission=60).inserted_primary_key[0]
 
         # Let's add a crazy futuristic Zoo to test large date values.
-        lp = Zoo.insert().execute(Name =u'Luna Park',
-                                  Founded = datetime.date(2072, 7, 17),
-                                  Opens = datetime.time(0, 0, 0),
-                                  Admission = 134.95,
-                                  ).inserted_primary_key[0]
+
+        lp = Zoo.insert().execute(Name=u'Luna Park',
+                                  Founded=datetime.date(2072, 7, 17),
+                                  Opens=datetime.time(0, 0, 0),
+                                  Admission=134.95).inserted_primary_key[0]
 
         # Animals
-        leopardid = Animal.insert().execute(Species=u'Leopard', Lifespan=73.5,
-                                            ).inserted_primary_key[0]
-        Animal.update(Animal.c.ID==leopardid).execute(ZooID=wap,
-                LastEscape=datetime.datetime(2004, 12, 21, 8, 15, 0, 999907))
 
-        lion = Animal.insert().execute(Species=u'Lion', ZooID=wap).inserted_primary_key[0]
+        leopardid = Animal.insert().execute(Species=u'Leopard',
+                Lifespan=73.5).inserted_primary_key[0]
+        Animal.update(Animal.c.ID == leopardid).execute(ZooID=wap,
+                LastEscape=datetime.datetime( 2004, 12, 21, 8, 15, 0, 999907,)
+                )
+        lion = Animal.insert().execute(Species=u'Lion',
+                ZooID=wap).inserted_primary_key[0]
         Animal.insert().execute(Species=u'Slug', Legs=1, Lifespan=.75)
-
-        tiger = Animal.insert().execute(Species=u'Tiger', ZooID=sdz
-                                        ).inserted_primary_key[0]
+        tiger = Animal.insert().execute(Species=u'Tiger',
+                ZooID=sdz).inserted_primary_key[0]
 
         # Override Legs.default with itself just to make sure it works.
-        Animal.insert(inline=True).execute(Species=u'Bear', Legs=4)
-        Animal.insert(inline=True).execute(Species=u'Ostrich', Legs=2, Lifespan=103.2)
-        Animal.insert(inline=True).execute(Species=u'Centipede', Legs=100)
-
-        emp = Animal.insert().execute(Species=u'Emperor Penguin', Legs=2,
-                                      ZooID=seaworld).inserted_primary_key[0]
-        adelie = Animal.insert().execute(Species=u'Adelie Penguin', Legs=2,
-                                         ZooID=seaworld).inserted_primary_key[0]
 
-        Animal.insert(inline=True).execute(Species=u'Millipede', Legs=1000000, ZooID=sdz)
+        Animal.insert(inline=True).execute(Species=u'Bear', Legs=4)
+        Animal.insert(inline=True).execute(Species=u'Ostrich', Legs=2,
+                Lifespan=103.2)
+        Animal.insert(inline=True).execute(Species=u'Centipede',
+                Legs=100)
+        emp = Animal.insert().execute(Species=u'Emperor Penguin',
+                Legs=2, ZooID=seaworld).inserted_primary_key[0]
+        adelie = Animal.insert().execute(Species=u'Adelie Penguin',
+                Legs=2, ZooID=seaworld).inserted_primary_key[0]
+        Animal.insert(inline=True).execute(Species=u'Millipede',
+                Legs=1000000, ZooID=sdz)
 
         # Add a mother and child to test relationships
-        bai_yun = Animal.insert().execute(Species=u'Ape', Name=u'Bai Yun',
-                                          Legs=2).inserted_primary_key[0]
-        Animal.insert(inline=True).execute(Species=u'Ape', Name=u'Hua Mei', Legs=2,
-                                MotherID=bai_yun)
+
+        bai_yun = Animal.insert().execute(Species=u'Ape',
+                Name=u'Bai Yun', Legs=2).inserted_primary_key[0]
+        Animal.insert(inline=True).execute(Species=u'Ape',
+                Name=u'Hua Mei', Legs=2, MotherID=bai_yun)
 
     def test_baseline_2_insert(self):
         Animal = metadata.tables['Animal']
         i = Animal.insert(inline=True)
         for x in xrange(ITERATIONS):
-            tick = i.execute(Species=u'Tick', Name=u'Tick %d' % x, Legs=8)
+            tick = i.execute(Species=u'Tick', Name=u'Tick %d' % x,
+                             Legs=8)
 
     def test_baseline_3_properties(self):
         Zoo = metadata.tables['Zoo']
@@ -145,20 +139,32 @@ class ZooMarkTest(TestBase):
 
         def fullobject(select):
             """Iterate over the full result row."""
+
             return list(select.execute().first())
 
         for x in xrange(ITERATIONS):
+
             # Zoos
-            WAP = fullobject(Zoo.select(Zoo.c.Name==u'Wild Animal Park'))
-            SDZ = fullobject(Zoo.select(Zoo.c.Founded==datetime.date(1935, 9, 13)))
-            Biodome = fullobject(Zoo.select(Zoo.c.Name==u'Montr\xe9al Biod\xf4me'))
-            seaworld = fullobject(Zoo.select(Zoo.c.Admission == float(60)))
+
+            WAP = fullobject(Zoo.select(Zoo.c.Name
+                             == u'Wild Animal Park'))
+            SDZ = fullobject(Zoo.select(Zoo.c.Founded
+                             == datetime.date(1935, 9, 13)))
+            Biodome = fullobject(Zoo.select(Zoo.c.Name
+                                 == u'Montr\xe9al Biod\xf4me'))
+            seaworld = fullobject(Zoo.select(Zoo.c.Admission
+                                  == float(60)))
 
             # Animals
-            leopard = fullobject(Animal.select(Animal.c.Species ==u'Leopard'))
-            ostrich = fullobject(Animal.select(Animal.c.Species==u'Ostrich'))
-            millipede = fullobject(Animal.select(Animal.c.Legs==1000000))
-            ticks = fullobject(Animal.select(Animal.c.Species==u'Tick'))
+
+            leopard = fullobject(Animal.select(Animal.c.Species
+                                 == u'Leopard'))
+            ostrich = fullobject(Animal.select(Animal.c.Species
+                                 == u'Ostrich'))
+            millipede = fullobject(Animal.select(Animal.c.Legs
+                                   == 1000000))
+            ticks = fullobject(Animal.select(Animal.c.Species == u'Tick'
+                               ))
 
     def test_baseline_4_expressions(self):
         Zoo = metadata.tables['Zoo']
@@ -166,117 +172,147 @@ class ZooMarkTest(TestBase):
 
         def fulltable(select):
             """Iterate over the full result table."""
+
             return [list(row) for row in select.execute().fetchall()]
 
         for x in xrange(ITERATIONS):
             assert len(fulltable(Zoo.select())) == 5
             assert len(fulltable(Animal.select())) == ITERATIONS + 12
-            assert len(fulltable(Animal.select(Animal.c.Legs==4))) == 4
-            assert len(fulltable(Animal.select(Animal.c.Legs == 2))) == 5
-            assert len(fulltable(Animal.select(and_(Animal.c.Legs >= 2, Animal.c.Legs < 20)
-                                     ))) == ITERATIONS + 9
-            assert len(fulltable(Animal.select(Animal.c.Legs > 10))) == 2
-            assert len(fulltable(Animal.select(Animal.c.Lifespan > 70))) == 2
-            assert len(fulltable(Animal.select(Animal.c.Species.startswith(u'L')))) == 2
-            assert len(fulltable(Animal.select(Animal.c.Species.endswith(u'pede')))) == 2
-
-            assert len(fulltable(Animal.select(Animal.c.LastEscape != None))) == 1
-            assert len(fulltable(Animal.select(None == Animal.c.LastEscape
-                                     ))) == ITERATIONS + 11
+            assert len(fulltable(Animal.select(Animal.c.Legs == 4))) \
+                == 4
+            assert len(fulltable(Animal.select(Animal.c.Legs == 2))) \
+                == 5
+            assert len(fulltable(Animal.select(and_(Animal.c.Legs >= 2,
+                       Animal.c.Legs < 20)))) == ITERATIONS + 9
+            assert len(fulltable(Animal.select(Animal.c.Legs > 10))) \
+                == 2
+            assert len(fulltable(Animal.select(Animal.c.Lifespan
+                       > 70))) == 2
+            assert len(fulltable(Animal.select(Animal.c.Species.
+                        startswith(u'L')))) == 2
+            assert len(fulltable(Animal.select(Animal.c.Species.
+                        endswith(u'pede')))) == 2
+            assert len(fulltable(Animal.select(Animal.c.LastEscape
+                       != None))) == 1
+            assert len(fulltable(Animal.select(None
+                       == Animal.c.LastEscape))) == ITERATIONS + 11
 
             # In operator (containedby)
-            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%pede%')))) == 2
-            assert len(fulltable(Animal.select(Animal.c.Species.in_([u'Lion', u'Tiger', u'Bear'])))) == 3
+
+            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%pede%'
+                       )))) == 2
+            assert len(fulltable(Animal.select(Animal.c.Species.in_([u'Lion'
+                       , u'Tiger', u'Bear'])))) == 3
 
             # Try In with cell references
-            class thing(object): pass
+            class thing(object):
+                pass
+
+
             pet, pet2 = thing(), thing()
-            pet.Name, pet2.Name =u'Slug', u'Ostrich'
-            assert len(fulltable(Animal.select(Animal.c.Species.in_([pet.Name, pet2.Name])))) == 2
+            pet.Name, pet2.Name = u'Slug', u'Ostrich'
+            assert len(fulltable(Animal.select(Animal.c.Species.in_([pet.Name,
+                       pet2.Name])))) == 2
 
             # logic and other functions
-            assert len(fulltable(Animal.select(Animal.c.Species.like(u'Slug')))) == 1
-            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%pede%')))) == 2
-            name =u'Lion'
-            assert len(fulltable(Animal.select(func.length(Animal.c.Species) == len(name)
-                                     ))) == ITERATIONS + 3
 
-            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%i%')
-                                     ))) == ITERATIONS + 7
+            assert len(fulltable(Animal.select(Animal.c.Species.like(u'Slug'
+                       )))) == 1
+            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%pede%'
+                       )))) == 2
+            name = u'Lion'
+            assert len(fulltable(Animal.select(func.length(Animal.c.Species)
+                       == len(name)))) == ITERATIONS + 3
+            assert len(fulltable(Animal.select(Animal.c.Species.like(u'%i%'
+                       )))) == ITERATIONS + 7
 
             # Test now(), today(), year(), month(), day()
+
             assert len(fulltable(Zoo.select(and_(Zoo.c.Founded != None,
-                                  Zoo.c.Founded < func.current_timestamp(_type=Date))))) == 3
-            assert len(fulltable(Animal.select(Animal.c.LastEscape == func.current_timestamp(_type=Date)))) == 0
-            assert len(fulltable(Animal.select(func.date_part('year', Animal.c.LastEscape) == 2004))) == 1
-            assert len(fulltable(Animal.select(func.date_part('month', Animal.c.LastEscape) == 12))) == 1
-            assert len(fulltable(Animal.select(func.date_part('day', Animal.c.LastEscape) == 21))) == 1
+                       Zoo.c.Founded
+                       < func.current_timestamp(_type=Date))))) == 3
+            assert len(fulltable(Animal.select(Animal.c.LastEscape
+                       == func.current_timestamp(_type=Date)))) == 0
+            assert len(fulltable(Animal.select(func.date_part('year',
+                       Animal.c.LastEscape) == 2004))) == 1
+            assert len(fulltable(Animal.select(func.date_part('month',
+                       Animal.c.LastEscape) == 12))) == 1
+            assert len(fulltable(Animal.select(func.date_part('day',
+                       Animal.c.LastEscape) == 21))) == 1
 
     def test_baseline_5_aggregates(self):
         Animal = metadata.tables['Animal']
         Zoo = metadata.tables['Zoo']
-
         for x in xrange(ITERATIONS):
+
             # views
+
             view = select([Animal.c.Legs]).execute().fetchall()
             legs = [x[0] for x in view]
             legs.sort()
-
-            expected = {'Leopard': 73.5,
-                        'Slug': .75,
-                        'Tiger': None,
-                        'Lion': None,
-                        'Bear': None,
-                        'Ostrich': 103.2,
-                        'Centipede': None,
-                        'Emperor Penguin': None,
-                        'Adelie Penguin': None,
-                        'Millipede': None,
-                        'Ape': None,
-                        'Tick': None,
-                        }
-            for species, lifespan in select([Animal.c.Species, Animal.c.Lifespan]
-                                            ).execute().fetchall():
+            expected = {
+                'Leopard': 73.5,
+                'Slug': .75,
+                'Tiger': None,
+                'Lion': None,
+                'Bear': None,
+                'Ostrich': 103.2,
+                'Centipede': None,
+                'Emperor Penguin': None,
+                'Adelie Penguin': None,
+                'Millipede': None,
+                'Ape': None,
+                'Tick': None,
+                }
+            for species, lifespan in select([Animal.c.Species,
+                    Animal.c.Lifespan]).execute().fetchall():
                 assert lifespan == expected[species]
-
             expected = [u'Montr\xe9al Biod\xf4me', 'Wild Animal Park']
-            e = select([Zoo.c.Name],
-                       and_(Zoo.c.Founded != None,
-                            Zoo.c.Founded <= func.current_timestamp(),
-                            Zoo.c.Founded >= datetime.date(1990, 1, 1)))
+            e = select([Zoo.c.Name], and_(Zoo.c.Founded != None,
+                       Zoo.c.Founded <= func.current_timestamp(),
+                       Zoo.c.Founded >= datetime.date(1990, 1, 1)))
             values = [val[0] for val in e.execute().fetchall()]
             assert set(values) == set(expected)
 
             # distinct
-            legs = [x[0] for x in
-                    select([Animal.c.Legs], distinct=True).execute().fetchall()]
+
+            legs = [x[0] for x in select([Animal.c.Legs],
+                    distinct=True).execute().fetchall()]
             legs.sort()
 
     def test_baseline_6_editing(self):
         Zoo = metadata.tables['Zoo']
-
         for x in xrange(ITERATIONS):
+
             # Edit
-            SDZ = Zoo.select(Zoo.c.Name==u'San Diego Zoo').execute().first()
-            Zoo.update(Zoo.c.ID==SDZ['ID']).execute(
-                     Name=u'The San Diego Zoo',
-                     Founded = datetime.date(1900, 1, 1),
-                     Opens = datetime.time(7, 30, 0),
-                     Admission = "35.00")
+
+            SDZ = Zoo.select(Zoo.c.Name == u'San Diego Zoo'
+                             ).execute().first()
+            Zoo.update(Zoo.c.ID == SDZ['ID'
+                       ]).execute(Name=u'The San Diego Zoo',
+                                  Founded=datetime.date(1900, 1, 1),
+                                  Opens=datetime.time(7, 30, 0),
+                                  Admission='35.00')
 
             # Test edits
-            SDZ = Zoo.select(Zoo.c.Name==u'The San Diego Zoo').execute().first()
-            assert SDZ['Founded'] == datetime.date(1900, 1, 1), SDZ['Founded']
+
+            SDZ = Zoo.select(Zoo.c.Name == u'The San Diego Zoo'
+                             ).execute().first()
+            assert SDZ['Founded'] == datetime.date(1900, 1, 1), \
+                SDZ['Founded']
 
             # Change it back
-            Zoo.update(Zoo.c.ID==SDZ['ID']).execute(
-                     Name =u'San Diego Zoo',
-                     Founded = datetime.date(1935, 9, 13),
-                     Opens = datetime.time(9, 0, 0),
-                     Admission = "0")
+
+            Zoo.update(Zoo.c.ID == SDZ['ID'
+                       ]).execute(Name=u'San Diego Zoo',
+                                  Founded=datetime.date(1935, 9, 13),
+                                  Opens=datetime.time(9, 0, 0),
+                                  Admission='0')
 
             # Test re-edits
-            SDZ = Zoo.select(Zoo.c.Name==u'San Diego Zoo').execute().first()
+
+            SDZ = Zoo.select(Zoo.c.Name == u'San Diego Zoo'
+                             ).execute().first()
             assert SDZ['Founded'] == datetime.date(1935, 9, 13)
 
     def test_baseline_7_multiview(self):
@@ -285,44 +321,43 @@ class ZooMarkTest(TestBase):
 
         def fulltable(select):
             """Iterate over the full result table."""
+
             return [list(row) for row in select.execute().fetchall()]
 
         for x in xrange(ITERATIONS):
             za = fulltable(select([Zoo.c.ID] + list(Animal.c),
-                                  Zoo.c.Name ==u'San Diego Zoo',
-                                  from_obj = [join(Zoo, Animal)]))
-
-            SDZ = Zoo.select(Zoo.c.Name==u'San Diego Zoo')
-
+                           Zoo.c.Name == u'San Diego Zoo',
+                           from_obj=[join(Zoo, Animal)]))
+            SDZ = Zoo.select(Zoo.c.Name == u'San Diego Zoo')
             e = fulltable(select([Zoo.c.ID, Animal.c.ID],
-                                 and_(Zoo.c.Name==u'San Diego Zoo',
-                                      Animal.c.Species==u'Leopard'),
-                                 from_obj = [join(Zoo, Animal)]))
+                          and_(Zoo.c.Name == u'San Diego Zoo',
+                          Animal.c.Species == u'Leopard'),
+                          from_obj=[join(Zoo, Animal)]))
 
             # Now try the same query with INNER, LEFT, and RIGHT JOINs.
+
             e = fulltable(select([Zoo.c.Name, Animal.c.Species],
-                                 from_obj=[join(Zoo, Animal)]))
+                          from_obj=[join(Zoo, Animal)]))
             e = fulltable(select([Zoo.c.Name, Animal.c.Species],
-                                 from_obj=[outerjoin(Zoo, Animal)]))
+                          from_obj=[outerjoin(Zoo, Animal)]))
             e = fulltable(select([Zoo.c.Name, Animal.c.Species],
-                                 from_obj=[outerjoin(Animal, Zoo)]))
+                          from_obj=[outerjoin(Animal, Zoo)]))
 
     def test_baseline_8_drop(self):
         metadata.drop_all()
 
-    # Now, run all of these tests again with the DB-API driver factored out:
-    # the ReplayableSession playback stands in for the database.
-
+    # Now, run all of these tests again with the DB-API driver factored
+    # out: the ReplayableSession playback stands in for the database.
+    #
     # How awkward is this in a unittest framework?  Very.
 
     def test_profile_0(self):
         global metadata
-
-        player = lambda: dbapi_session.player()
+        player = lambda : dbapi_session.player()
         engine = create_engine('postgresql:///', creator=player)
         metadata = MetaData(engine)
         engine.connect()
-        
+
     @profiling.function_call_count(3012, {'2.4': 1827})
     def test_profile_1_create_tables(self):
         self.test_baseline_1_create_tables()
@@ -339,17 +374,15 @@ class ZooMarkTest(TestBase):
     def test_profile_3_properties(self):
         self.test_baseline_3_properties()
 
-    @profiling.function_call_count(13341, {'2.4': 7963,
-                                            '2.6+cextension':12447,
-                                            '2.7+cextension':12447},
-                                            variance=0.10)
+    @profiling.function_call_count(13341, {'2.4': 7963, '2.6+cextension'
+                                   : 12447, '2.7+cextension': 12447},
+                                   variance=0.10)
     def test_profile_4_expressions(self):
         self.test_baseline_4_expressions()
 
-    @profiling.function_call_count(1311, {'2.4': 904, 
-                                            '2.6+cextension':1226,
-                                            '2.7+cextension':1226,
-                                            }, variance=0.10)
+    @profiling.function_call_count(1311, {'2.4': 904, '2.6+cextension'
+                                   : 1226, '2.7+cextension': 1226},
+                                   variance=0.10)
     def test_profile_5_aggregates(self):
         self.test_baseline_5_aggregates()
 
@@ -357,11 +390,10 @@ class ZooMarkTest(TestBase):
     def test_profile_6_editing(self):
         self.test_baseline_6_editing()
 
-    @profiling.function_call_count(2641, {'2.4': 1673, '2.6+cextension':2502})
+    @profiling.function_call_count(2641, {'2.4': 1673, '2.6+cextension'
+                                   : 2502})
     def test_profile_7_multiview(self):
         self.test_baseline_7_multiview()
 
     def test_profile_8_drop(self):
         self.test_baseline_8_drop()
-
-