wulczer
diff --git a/‎test/test_txpostgres.py
Lines changed: 18 additions & 0 deletions b/‎test/test_txpostgres.py
Lines changed: 18 additions & 0 deletions
diff --git a/‎txpostgres/txpostgres.py
Lines changed: 7 additions & 3 deletions b/‎txpostgres/txpostgres.py
Lines changed: 7 additions & 3 deletions
@@ -92,12 +92,16 @@ class FakeReactor(object):
     def reset(self):
         self.readersAdded = self.writersAdded = 0
         self.readersRemoved = self.writersRemoved = 0
+
     def addReader(self, _):
         self.readersAdded += 1
+
     def addWriter(self, _):
         self.writersAdded += 1
+
     def removeReader(self, _):
         self.readersRemoved += 1
+
     def removeWriter(self, _):
         self.writersRemoved += 1
 
@@ -288,36 +292,48 @@ def test_errors(self):
         also make connect() return a failure.
         """
         conn = txpostgres.Connection()
+
         class BadPollable(object):
+
             def __init__(*args, **kwars):
                 pass
+
             def poll(self):
                 raise RuntimeError("booga")
+
             def close(self):
                 pass
+
         conn.connectionFactory = BadPollable
 
         d = conn.connect()
         d = self.assertFailure(d, RuntimeError)
         d.addCallback(lambda _: conn.close())
 
         class BadThing(object):
+
             def __init__(*args, **kwargs):
                 raise RuntimeError("wooga")
+
             def close(self):
                 pass
+
         conn.connectionFactory = BadThing
 
         d.addCallback(lambda _: conn.connect())
         d = self.assertFailure(d, RuntimeError)
 
         class BrokenPollable(object):
+
             def __init__(*args, **kwars):
                 pass
+
             def poll(self):
                 return "tee hee hee"
+
             def close(self):
                 pass
+
         conn.connectionFactory = BrokenPollable
 
         d.addCallback(lambda _: conn.connect())
@@ -719,6 +735,7 @@ def brokenInteraction(c):
             return c.execute("boom")
         d.addCallback(lambda _: pool.runInteraction(brokenInteraction))
         d.addCallback(lambda _: self.fail("No exception"))
+
         def checkErrorAndHotswap(f):
             f.trap(txpostgres.RollbackFailed)
             e = f.value
@@ -735,6 +752,7 @@ def checkErrorAndHotswap(f):
             d = c.connect(user=DB_USER, password=DB_PASS,
                           host=DB_HOST, database=DB_NAME)
             return d.addCallback(lambda c: pool.add(c))
+
         d.addErrback(checkErrorAndHotswap)
 
         d.addCallback(lambda _: defer.gatherResults([
 
@@ -8,10 +8,9 @@
 """
 
 import psycopg2
-from psycopg2 import extensions
 from zope.interface import implements
 
-from twisted.internet import interfaces, reactor, defer
+from twisted.internet import interfaces, defer
 from twisted.python import failure, log
 
 
@@ -30,6 +29,7 @@ class UnexpectedPollResult(Exception):
     Polling returned an unexpected result.
     """
 
+
 class _CancelInProgress(Exception):
     """
     A query cancellation is in progress.
@@ -404,17 +404,21 @@ def _runInteraction(self, interaction, *args, **kwargs):
         def commitAndPassthrough(ret, cursor):
             e = cursor.execute("commit")
             return e.addCallback(lambda _: ret)
+
         def rollbackAndPassthrough(f, cursor):
             # maybeDeferred in case cursor.execute raises a synchronous
             # exception
             e = defer.maybeDeferred(cursor.execute, "rollback")
+
             def justPanic(rf):
                 log.err(rf)
                 return defer.fail(RollbackFailed(self, f))
+
             # if rollback failed panic
             e.addErrback(justPanic)
             # reraise the original failure afterwards
             return e.addCallback(lambda _: f)
+
         d.addCallback(commitAndPassthrough, c)
         d.addErrback(rollbackAndPassthrough, c)
         d.addCallback(lambda ret: (c.close(), ret)[1])
@@ -533,7 +537,7 @@ def add(self, connection):
         """
         self.connections.add(connection)
         self._semaphore.limit += 1
-        self._semaphore.release() # uuuugh...
+        self._semaphore.release()  # uuuugh...
 
     def _putBackAndPassthrough(self, result, connection):
         self.connections.add(connection)