Follow PEP8 rules for whitespace

Author: Cito

DBUtils/Docs/UsersGuide.de.html

@@ -322,7 +322,7 @@ <h2>PersistentDB</h2>
 <p>Wenn Sie beispielsweise <span class="docutils literal">pgdb</span> als DB-API-2-Datenbankadapter verwenden, und
 möchten, dass jede Verbindung Ihrer lokalen Datenbank <span class="docutils literal">meinedb</span> 1000 mal
 wiederverwendet werden soll, sieht die Initialisierung so aus:</p>
-<pre class="literal-block">import pgdb # importiere das verwendete DB-API-2-Modul
+<pre class="literal-block">import pgdb  # importiere das verwendete DB-API-2-Modul
 from DBUtils.PersistentDB import PersistentDB
 persist = PersistentDB(pgdb, 1000, database='meinedb')</pre>
 <p>Nachdem Sie den Generator mit diesen Parametern eingerichtet haben, können
@@ -406,7 +406,7 @@ <h2>PooledDB</h2>
 <p>Wenn Sie beispielsweise <span class="docutils literal">pgdb</span> als DB-API-2-Datenbankadapter benutzen,
 und einen Pool von mindestens fünf Datenbankverbindungen zu Ihrer Datenbank
 <span class="docutils literal">meinedb</span> verwenden möchten, dann sieht die Initialisierung so aus:</p>
-<pre class="literal-block">import pgdb # importiere das verwendete DB-API-2-Modul
+<pre class="literal-block">import pgdb  # importiere das verwendete DB-API-2-Modul
 from DBUtils.PooledDB import PooledDB
 pool = PooledDB(pgdb, 5, database='meinedb')</pre>
 <p>Nachdem Sie den Pool für Datenbankverbindungen so eingerichtet haben, können
@@ -436,8 +436,8 @@ <h2>PooledDB</h2>
 cur = db.cursor()
 cur.execute(...)
 res = cur.fetchone()
-cur.close() # oder del cur
-db.close() # oder del db</pre>
+cur.close()  # oder del cur
+db.close()  # oder del db</pre>
 <p>Bitte beachten Sie, dass Transaktionen explizit durch Aufruf der Methode
 <span class="docutils literal">begin()</span> eingeleiten werden müssen. Hierdurch wird sichergestellt,
 dass die Verbindung nicht mehr mit anderen Threads geteilt wird, dass das

DBUtils/Docs/UsersGuide.de.txt

@@ -303,7 +303,7 @@ Wenn Sie beispielsweise ``pgdb`` als DB-API-2-Datenbankadapter verwenden, und
 möchten, dass jede Verbindung Ihrer lokalen Datenbank ``meinedb`` 1000 mal
 wiederverwendet werden soll, sieht die Initialisierung so aus::
 
-  import pgdb # importiere das verwendete DB-API-2-Modul
+  import pgdb  # importiere das verwendete DB-API-2-Modul
   from DBUtils.PersistentDB import PersistentDB
   persist = PersistentDB(pgdb, 1000, database='meinedb')
 
@@ -405,7 +405,7 @@ Wenn Sie beispielsweise ``pgdb`` als DB-API-2-Datenbankadapter benutzen,
 und einen Pool von mindestens fünf Datenbankverbindungen zu Ihrer Datenbank
 ``meinedb`` verwenden möchten, dann sieht die Initialisierung so aus::
 
-  import pgdb # importiere das verwendete DB-API-2-Modul
+  import pgdb  # importiere das verwendete DB-API-2-Modul
   from DBUtils.PooledDB import PooledDB
   pool = PooledDB(pgdb, 5, database='meinedb')
 
@@ -447,8 +447,8 @@ sie gebraucht werden, etwa so::
   cur = db.cursor()
   cur.execute(...)
   res = cur.fetchone()
-  cur.close() # oder del cur
-  db.close() # oder del db
+  cur.close()  # oder del cur
+  db.close()  # oder del db
 
 Bitte beachten Sie, dass Transaktionen explizit durch Aufruf der Methode
 ``begin()`` eingeleiten werden müssen. Hierdurch wird sichergestellt,

DBUtils/Docs/UsersGuide.html

@@ -204,7 +204,7 @@ <h2>PersistentDB</h2>
 for this specific thread. When the thread closes the database connection,
 it will still be kept open so that the next time when a connection is
 requested by the same thread, this already opened connection can be used.
-The connecton will be closed automatically when the thread dies.</p>
+The connection will be closed automatically when the thread dies.</p>
 <p>In short: <span class="docutils literal">PersistentDB</span> tries to recycle database connections to
 increase the overall database access performance of your threaded application,
 but it makes sure that connections are never shared between threads.</p>
@@ -300,7 +300,7 @@ <h2>PersistentDB</h2>
 </ul>
 <p>For instance, if you are using <span class="docutils literal">pgdb</span> as your DB-API 2 database module and
 want every connection to your local database <span class="docutils literal">mydb</span> to be reused 1000 times:</p>
-<pre class="literal-block">import pgdb # import used DB-API 2 module
+<pre class="literal-block">import pgdb  # import used DB-API 2 module
 from DBUtils.PersistentDB import PersistentDB
 persist = PersistentDB(pgdb, 1000, database='mydb')</pre>
 <p>Once you have set up the generator with these parameters, you can request
@@ -372,7 +372,7 @@ <h2>PooledDB</h2>
 </ul>
 <p>For instance, if you are using <span class="docutils literal">pgdb</span> as your DB-API 2 database module and
 want a pool of at least five connections to your local database <span class="docutils literal">mydb</span>:</p>
-<pre class="literal-block">import pgdb # import used DB-API 2 module
+<pre class="literal-block">import pgdb  # import used DB-API 2 module
 from DBUtils.PooledDB import PooledDB
 pool = PooledDB(pgdb, 5, database='mydb')</pre>
 <p>Once you have set up the connection pool you can request database connections
@@ -398,8 +398,8 @@ <h2>PooledDB</h2>
 cur = db.cursor()
 cur.execute(...)
 res = cur.fetchone()
-cur.close() # or del cur
-db.close() # or del db</pre>
+cur.close()  # or del cur
+db.close()  # or del db</pre>
 <p>Note that you need to explicitly start transactions by calling the
 <span class="docutils literal">begin()</span> method. This ensures that the connection will not be shared
 with other threads, that the transparent reopening will be suspended

DBUtils/Docs/UsersGuide.txt

@@ -164,7 +164,7 @@ connection to the database will be opened that will be used from now on
 for this specific thread. When the thread closes the database connection,
 it will still be kept open so that the next time when a connection is
 requested by the same thread, this already opened connection can be used.
-The connecton will be closed automatically when the thread dies.
+The connection will be closed automatically when the thread dies.
 
 In short: ``PersistentDB`` tries to recycle database connections to
 increase the overall database access performance of your threaded application,
@@ -280,7 +280,7 @@ of ``PersistentDB``, passing the following parameters:
 For instance, if you are using ``pgdb`` as your DB-API 2 database module and
 want every connection to your local database ``mydb`` to be reused 1000 times::
 
-  import pgdb # import used DB-API 2 module
+  import pgdb  # import used DB-API 2 module
   from DBUtils.PersistentDB import PersistentDB
   persist = PersistentDB(pgdb, 1000, database='mydb')
 
@@ -370,7 +370,7 @@ following parameters:
 For instance, if you are using ``pgdb`` as your DB-API 2 database module and
 want a pool of at least five connections to your local database ``mydb``::
 
-  import pgdb # import used DB-API 2 module
+  import pgdb  # import used DB-API 2 module
   from DBUtils.PooledDB import PooledDB
   pool = PooledDB(pgdb, 5, database='mydb')
 
@@ -408,8 +408,8 @@ object stays alive as long as you are using it, like that::
   cur = db.cursor()
   cur.execute(...)
   res = cur.fetchone()
-  cur.close() # or del cur
-  db.close() # or del db
+  cur.close()  # or del cur
+  db.close()  # or del db
 
 Note that you need to explicitly start transactions by calling the
 ``begin()`` method. This ensures that the connection will not be shared

DBUtils/Examples/DBUtilsExample.py

@@ -44,15 +44,15 @@ class DBUtilsExample(ExamplePage):
     else:
         dbmod_name = 'Pooled'
     dbapi_name = config.pop('dbapi', 'pg')
-    if dbapi_name == 'pg': # use the PyGreSQL classic DB API
+    if dbapi_name == 'pg':  # use the PyGreSQL classic DB API
         dbmod_name += 'Pg'
         if config.has_key('database'):
             config['dbname'] = config['database']
             del config['database']
         if config.has_key('password'):
             config['passwd'] = config['password']
             del config['password']
-    else: # use a DB-API 2 compliant module
+    else:  # use a DB-API 2 compliant module
         dbmod_name += 'DB'
     dbapi = dbmod = dbclass = dbstatus = None
     try:

DBUtils/PersistentDB.py

@@ -16,7 +16,7 @@
 
 Measures are taken to make the database connections thread-affine.
 This means the same thread always uses the same cached connection,
-and no other thread will use it. So even if the underlying DB-API module
+and no other thread will use it.  So even if the underlying DB-API module
 is not thread-safe at the connection level this will be no problem here.
 
 For best performance, the application server should keep threads persistent.
@@ -56,14 +56,14 @@
 
     The creator function or the connect function of the DB-API 2 compliant
     database module specified as the creator will receive any additional
-    parameters such as the host, database, user, password etc. You may
+    parameters such as the host, database, user, password etc.  You may
     choose some or all of these parameters in your own creator function,
     allowing for sophisticated failover and load-balancing mechanisms.
 
 For instance, if you are using pgdb as your DB-API 2 database module and want
 every connection to your local database 'mydb' to be reused 1000 times:
 
-    import pgdb # import used DB-API 2 module
+    import pgdb  # import used DB-API 2 module
     from DBUtils.PersistentDB import PersistentDB
     persist = PersistentDB(pgdb, 1000, database='mydb')
 
@@ -73,17 +73,17 @@
     db = persist.connection()
 
 You can use these connections just as if they were ordinary
-DB-API 2 connections. Actually what you get is the hardened
+DB-API 2 connections.  Actually what you get is the hardened
 SteadyDB version of the underlying DB-API 2 connection.
 
 Closing a persistent connection with db.close() will be silently
 ignored since it would be reopened at the next usage anyway and
-contrary to the intent of having persistent connections. Instead,
+contrary to the intent of having persistent connections.  Instead,
 the connection will be automatically closed when the thread dies.
 You can change this behavior be setting the closeable parameter.
 
 Note that you need to explicitly start transactions by calling the
-begin() method. This ensures that the transparent reopening will be
+begin() method.  This ensures that the transparent reopening will be
 suspended until the end of the transaction, and that the connection
 will be rolled back before being reused by the same thread.
 
@@ -199,7 +199,7 @@ def connection(self, shareable=False):
         """Get a steady, persistent DB-API 2 connection.
 
         The shareable parameter exists only for compatibility with the
-        PooledDB connection method. In reality, persistent connections
+        PooledDB connection method.  In reality, persistent connections
         are of course never shared with other threads.
 
         """

DBUtils/PersistentPg.py

@@ -16,7 +16,7 @@
 
 Measures are taken to make the database connections thread-affine.
 This means the same thread always uses the same cached connection,
-and no other thread will use it. So the fact that the classic PyGreSQL
+and no other thread will use it.  So the fact that the classic PyGreSQL
 pg module is not thread-safe at the connection level is no problem here.
 
 For best performance, the application server should keep threads persistent.
@@ -63,19 +63,19 @@
     db = persist.connection()
 
 You can use these connections just as if they were ordinary
-classic PyGreSQL API connections. Actually what you get is the
+classic PyGreSQL API connections.  Actually what you get is the
 hardened SteadyPg version of a classic PyGreSQL connection.
 
 Closing a persistent connection with db.close() will be silently
 ignored since it would be reopened at the next usage anyway and
-contrary to the intent of having persistent connections. Instead,
+contrary to the intent of having persistent connections.  Instead,
 the connection will be automatically closed when the thread dies.
 You can change this behavior be setting the closeable parameter.
 
 Note that you need to explicitly start transactions by calling the
-begin() method. This ensures that the transparent reopening will be
+begin() method.  This ensures that the transparent reopening will be
 suspended until the end of the transaction, and that the connection
-will be rolled back before being reused in the same thread. To end
+will be rolled back before being reused in the same thread.  To end
 transactions, use one of the end(), commit() or rollback() methods.
 
 By setting the threadlocal parameter to threading.local, getting