Converted tabs to spaces as done in Webware 1.1.

Author: Cito

.pylintrc

@@ -287,8 +287,7 @@ max-module-lines=1000
 
 # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
 # tab).
-#indent-string='    '
-indent-string='\t'
+indent-string='    '
 
 
 # checks for:

DBUtils/PersistentDB.py

@@ -19,49 +19,49 @@
 For this, you have to set MinServerThreads = MaxServerThreads in Webware.
 
 For the Python DB-API 2 specification, see:
-	http://www.python.org/peps/pep-0249.html
+    http://www.python.org/peps/pep-0249.html
 For information on Webware for Python, see:
-	http://www.webwareforpython.org
+    http://www.webwareforpython.org
 
 
 Usage:
 
 First you need to set up a generator for your kind of database connections
 by creating an instance of PersistentDB, passing the following parameters:
 
-	creator: either an arbitrary function returning new DB-API 2
-		connection objects or a DB-API 2 compliant database module
-	maxusage: the maximum number of reuses of a single connection
-		(the default of 0 or None means unlimited reuse)
-		Whenever the limit is reached, the connection will be reset.
-	setsession: an optional list of SQL commands that may serve to
-		prepare the session, e.g. ["set datestyle to german", ...].
-	failures: an optional exception class or a tuple of exception classes
-		for which the connection failover mechanism shall be applied,
-		if the default (OperationalError, InternalError) is not adequate
-	closeable: if this is set to true, then closing connections will
-		be allowed, but by default this will be silently ignored
-	threadlocal: an optional class for representing thread-local data
-		that will be used instead of our Python implementation
-		(threading.local is faster, but cannot be used in all cases)
-
-	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
-	choose some or all of these parameters in your own creator function,
-	allowing for sophisticated failover and load-balancing mechanisms.
+    creator: either an arbitrary function returning new DB-API 2
+        connection objects or a DB-API 2 compliant database module
+    maxusage: the maximum number of reuses of a single connection
+        (the default of 0 or None means unlimited reuse)
+        Whenever the limit is reached, the connection will be reset.
+    setsession: an optional list of SQL commands that may serve to
+        prepare the session, e.g. ["set datestyle to german", ...].
+    failures: an optional exception class or a tuple of exception classes
+        for which the connection failover mechanism shall be applied,
+        if the default (OperationalError, InternalError) is not adequate
+    closeable: if this is set to true, then closing connections will
+        be allowed, but by default this will be silently ignored
+    threadlocal: an optional class for representing thread-local data
+        that will be used instead of our Python implementation
+        (threading.local is faster, but cannot be used in all cases)
+
+    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
+    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
-	from DBUtils.PersistentDB import PersistentDB
-	persist = PersistentDB(pgdb, 1000, database='mydb')
+    import pgdb # import used DB-API 2 module
+    from DBUtils.PersistentDB import PersistentDB
+    persist = PersistentDB(pgdb, 1000, database='mydb')
 
 Once you have set up the generator with these parameters, you can
 request database connections of that kind:
 
-	db = persist.connection()
+    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
@@ -112,90 +112,90 @@
 
 
 class PersistentDBError(Exception):
-	"""General PersistentDB error."""
+    """General PersistentDB error."""
 
 class NotSupportedError(PersistentDBError):
-	"""DB-API module not supported by PersistentDB."""
+    """DB-API module not supported by PersistentDB."""
 
 
 class PersistentDB:
-	"""Generator for persistent DB-API 2 connections.
-
-	After you have created the connection pool, you can use
-	connection() to get thread-affine, steady DB-API 2 connections.
-
-	"""
-
-	version = __version__
-
-	def __init__(self, creator,
-			maxusage=None, setsession=None, failures=None,
-			closeable=False, threadlocal=None, *args, **kwargs):
-		"""Set up the persistent DB-API 2 connection generator.
-
-		creator: either an arbitrary function returning new DB-API 2
-			connection objects or a DB-API 2 compliant database module
-		maxusage: maximum number of reuses of a single connection
-			(number of database operations, 0 or None means unlimited)
-			Whenever the limit is reached, the connection will be reset.
-		setsession: optional list of SQL commands that may serve to prepare
-			the session, e.g. ["set datestyle to ...", "set time zone ..."]
-		failures: an optional exception class or a tuple of exception classes
-			for which the connection failover mechanism shall be applied,
-			if the default (OperationalError, InternalError) is not adequate
-		closeable: if this is set to true, then closing connections will
-			be allowed, but by default this will be silently ignored
-		threadlocal: an optional class for representing thread-local data
-			that will be used instead of our Python implementation
-			(threading.local is faster, but cannot be used in all cases)
-		args, kwargs: the parameters that shall be passed to the creator
-			function or the connection constructor of the DB-API 2 module
-
-		"""
-		try:
-			threadsafety = creator.threadsafety
-		except AttributeError:
-			try:
-				if not callable(creator.connect):
-					raise AttributeError
-			except AttributeError:
-				threadsafety = 1
-			else:
-				threadsafety = 0
-		if not threadsafety:
-			raise NotSupportedError("Database module is not thread-safe.")
-		self._creator = creator
-		self._maxusage = maxusage
-		self._setsession = setsession
-		self._failures = failures
-		self._closeable = closeable
-		self._args, self._kwargs = args, kwargs
-		self.thread = (threadlocal or ThreadingLocal.local)()
-
-	def steady_connection(self):
-		"""Get a steady, non-persistent DB-API 2 connection."""
-		return connect(self._creator,
-			self._maxusage, self._setsession,
-			self._failures, self._closeable,
-			*self._args, **self._kwargs)
-
-	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
-		are of course never shared with other threads.
-
-		"""
-		try:
-			con = self.thread.connection
-		except AttributeError:
-			con = self.steady_connection()
-			if not con.threadsafety():
-				raise NotSupportedError("Database module is not thread-safe.")
-			self.thread.connection = con
-		return con
-
-	def dedicated_connection(self):
-		"""Alias for connection(shareable=False)."""
-		return self.connection()
+    """Generator for persistent DB-API 2 connections.
+
+    After you have created the connection pool, you can use
+    connection() to get thread-affine, steady DB-API 2 connections.
+
+    """
+
+    version = __version__
+
+    def __init__(self, creator,
+            maxusage=None, setsession=None, failures=None,
+            closeable=False, threadlocal=None, *args, **kwargs):
+        """Set up the persistent DB-API 2 connection generator.
+
+        creator: either an arbitrary function returning new DB-API 2
+            connection objects or a DB-API 2 compliant database module
+        maxusage: maximum number of reuses of a single connection
+            (number of database operations, 0 or None means unlimited)
+            Whenever the limit is reached, the connection will be reset.
+        setsession: optional list of SQL commands that may serve to prepare
+            the session, e.g. ["set datestyle to ...", "set time zone ..."]
+        failures: an optional exception class or a tuple of exception classes
+            for which the connection failover mechanism shall be applied,
+            if the default (OperationalError, InternalError) is not adequate
+        closeable: if this is set to true, then closing connections will
+            be allowed, but by default this will be silently ignored
+        threadlocal: an optional class for representing thread-local data
+            that will be used instead of our Python implementation
+            (threading.local is faster, but cannot be used in all cases)
+        args, kwargs: the parameters that shall be passed to the creator
+            function or the connection constructor of the DB-API 2 module
+
+        """
+        try:
+            threadsafety = creator.threadsafety
+        except AttributeError:
+            try:
+                if not callable(creator.connect):
+                    raise AttributeError
+            except AttributeError:
+                threadsafety = 1
+            else:
+                threadsafety = 0
+        if not threadsafety:
+            raise NotSupportedError("Database module is not thread-safe.")
+        self._creator = creator
+        self._maxusage = maxusage
+        self._setsession = setsession
+        self._failures = failures
+        self._closeable = closeable
+        self._args, self._kwargs = args, kwargs
+        self.thread = (threadlocal or ThreadingLocal.local)()
+
+    def steady_connection(self):
+        """Get a steady, non-persistent DB-API 2 connection."""
+        return connect(self._creator,
+            self._maxusage, self._setsession,
+            self._failures, self._closeable,
+            *self._args, **self._kwargs)
+
+    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
+        are of course never shared with other threads.
+
+        """
+        try:
+            con = self.thread.connection
+        except AttributeError:
+            con = self.steady_connection()
+            if not con.threadsafety():
+                raise NotSupportedError("Database module is not thread-safe.")
+            self.thread.connection = con
+        return con
+
+    def dedicated_connection(self):
+        """Alias for connection(shareable=False)."""
+        return self.connection()