Allow overriding defaults via the creator.dbapi and creator.threadsafety attributes. In some cases, finalizers could throw exceptions or create infinite recursion via getattr when init failed; solved by adequate pre-initialization in the init method.

Author: Cito

DBUtils/PersistentDB.py

@@ -139,9 +139,12 @@ def __init__(self, creator,
 			threadsafety = creator.threadsafety
 		except AttributeError:
 			try:
-				threadsafety = callable(creator.connect) and 0 or 1
+				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

DBUtils/PooledDB.py

@@ -190,9 +190,12 @@ def __init__(self, creator,
 			threadsafety = creator.threadsafety
 		except AttributeError:
 			try:
-				threadsafety = callable(creator.connect) and 0 or 2
+				if not callable(creator.connect):
+					raise AttributeError
 			except AttributeError:
 				threadsafety = 2
+			else:
+				threadsafety = 0
 		if not threadsafety:
 			raise NotSupportedError("Database module is not thread-safe.")
 		self._creator = creator
@@ -368,6 +371,9 @@ def __init__(self, pool, con):
 		con: the underlying SteadyDB connection
 
 		"""
+		# basic initialization to make finalizer work
+		self._con = None
+		# proper initialization of the connection
 		if not con.threadsafety():
 			raise NotSupportedError("Database module is not thread-safe.")
 		self._pool = pool
@@ -431,6 +437,9 @@ def __init__(self, pool, shared_con):
 		con: the underlying SharedDBConnection
 
 		"""
+		# basic initialization to make finalizer work
+		self._con = None
+		# proper initialization of the connection
 		con = shared_con.con
 		if not con.threadsafety() > 1:
 			raise NotSupportedError("Database connection is not thread-safe.")

DBUtils/SteadyDB.py

@@ -93,6 +93,13 @@
 import sys
 
 
+class SteadyDBError(Exception):
+	"""General SteadyDB error."""
+
+class InvalidCursor(SteadyDBError):
+	"""Database cursor is invalid."""
+
+
 def connect(creator, maxusage=None, setsession=None, failures=None,
 		closeable=True, *args, **kwargs):
 	"""A tough version of the connection constructor of a DB-API 2 module.
@@ -123,22 +130,35 @@ class SteadyDBConnection:
 
 	version = __version__
 
-	_closed = True
-
 	def __init__(self, creator, maxusage=None, setsession=None, failures=None,
 			closeable=True, *args, **kwargs):
 		""""Create a "tough" DB-API 2 connection."""
+		# basic initialization to make finalizer work
+		self._con = None
+		self._closed = True
+		# proper initialization of the connection
 		try:
 			self._creator = creator.connect
 			self._dbapi = creator
 		except AttributeError:
+			# try finding the DB-API 2 module via the connection creator
 			self._creator = creator
 			try:
-				self._dbapi = sys.modules[creator.__module__]
-				if self._dbapi.connect != creator:
-					raise AttributeError
-			except (AttributeError, KeyError):
-				self._dbapi = None
+				self._dbapi = creator.dbapi
+			except AttributeError:
+				try:
+					self._dbapi = sys.modules[creator.__module__]
+					if self._dbapi.connect != creator:
+						raise AttributeError
+				except (AttributeError, KeyError):
+					self._dbapi = None
+		try:
+			self._threadsafety = creator.threadsafety
+		except AttributeError:
+			try:
+				self._threadsafety = self._dbapi.threadsafety
+			except AttributeError:
+				self._threadsafety = None
 		if not callable(self._creator):
 			raise TypeError("%r is not a connection provider." % (creator,))
 		if maxusage is not None and not isinstance(maxusage, (int, long)):
@@ -161,15 +181,74 @@ def _create(self):
 				if self._dbapi.connect != self._creator:
 					raise AttributeError
 			except AttributeError:
+				# try finding the DB-API 2 module via the connection itself
 				try:
-					self._dbapi = sys.modules[con.__module__]
-					if not callable(self._dbapi.connect):
-						raise AttributeError
-				except (AttributeError, KeyError):
-					raise TypeError("Cannot determine DB-API 2 module.")
+					mod = con.__module__
+				except AttributeError:
+					mod = None
+				while mod:
+					try:
+						self._dbapi = sys.modules[mod]
+						if not callable(self._dbapi.connect):
+							raise AttributeError
+					except (AttributeError, KeyError):
+						pass
+					else:
+						break
+					i = mod.rfind('.')
+					if i < 0:
+						mod = None
+					else:
+						mod = mod[:i]
+				else:
+					try:
+						mod = con.OperationalError.__module__
+					except AttributeError:
+						mod = None
+					while mod:
+						try:
+							self._dbapi = sys.modules[mod]
+							if not callable(self._dbapi.connect):
+								raise AttributeError
+						except (AttributeError, KeyError):
+							pass
+						else:
+							break
+						i = mod.rfind('.')
+						if i < 0:
+							mod = None
+						else:
+							mod = mod[:i]
+					else:
+						self._dbapi = None
+			if self._threadsafety is None:
+				try:
+					self._threadsafety = self._dbapi.threadsafety
+				except AttributeError:
+					try:
+						self._threadsafety = con.threadsafety
+					except AttributeError:
+						pass
 			if self._failures is None:
-				self._failures = (self._dbapi.OperationalError,
-					self._dbapi.InternalError)
+				try:
+					self._failures = (self._dbapi.OperationalError,
+						self._dbapi.InternalError)
+				except AttributeError:
+					try:
+						self._failures = (self._creator.OperationalError,
+							self._creator.InternalError)
+					except AttributeError:
+						try:
+							self._failures = (con.OperationalError,
+								con.InternalError)
+						except AttributeError:
+							raise AttributeError(
+								"Could not determine failure exceptions"
+								" (please set failures or creator.dbapi).")
+			if isinstance(self._failures, tuple):
+				self._failure = self._failures[0]
+			else:
+				self._failure = self._failures
 			self._setsession(con)
 		except Exception, error:
 			# the database module could not be determined
@@ -213,14 +292,19 @@ def _close(self):
 
 	def dbapi(self):
 		"""Return the underlying DB-API 2 module of the connection."""
+		if self._dbapi is None:
+			raise AttributeError("Could not determine DB-API 2 module"
+				" (please set creator.dbapi).")
 		return self._dbapi
 
 	def threadsafety(self):
 		"""Return the thread safety level of the connection."""
-		try:
-			return self._dbapi.threadsafety
-		except AttributeError:
+		if self._threadsafety is None:
+			if self._dbapi is None:
+				raise AttributeError("Could not determine threadsafety"
+					" (please set creator.dbapi or creator.threadsafety).")
 			return 0
+		return self._threadsafety
 
 	def close(self):
 		"""Close the tough connection.
@@ -290,10 +374,12 @@ def __del__(self):
 class SteadyDBCursor:
 	"""A "tough" version of DB-API 2 cursors."""
 
-	_closed = True
-
 	def __init__(self, con, *args, **kwargs):
 		""""Create a "tough" DB-API 2 cursor."""
+		# basic initialization to make finalizer work
+		self._cursor = None
+		self._closed = True
+		# proper initialization of the cursor
 		self._con = con
 		self._args, self._kwargs = args, kwargs
 		self._clearsizes()
@@ -424,12 +510,18 @@ def tough_method(*args, **kwargs):
 
 	def __getattr__(self, name):
 		"""Inherit methods and attributes of underlying cursor."""
-		if name.startswith('execute') or name.startswith('call'):
-			# make execution methods "tough"
-			return self._get_tough_method(name)
+		if self._cursor:
+			if name.startswith('execute') or name.startswith('call'):
+				# make execution methods "tough"
+				return self._get_tough_method(name)
+			else:
+				return getattr(self._cursor, name)
 		else:
-			return getattr(self._cursor, name)
+			raise InvalidCursor
 
 	def __del__(self):
 		"""Delete the steady cursor."""
-		self.close() # make sure the cursor is closed
+		try:
+			self.close() # make sure the cursor is closed
+		except Exception:
+			pass

DBUtils/SteadyPg.py

@@ -74,6 +74,13 @@
 from pg import DB as PgConnection
 
 
+class SteadyPgError(Exception):
+	"""General SteadyPg error."""
+
+class InvalidConnection(SteadyPgError):
+	"""Database connection is invalid."""
+
+
 class SteadyPgConnection:
 	"""Class representing steady connections to a PostgreSQL database.
 
@@ -89,8 +96,6 @@ class SteadyPgConnection:
 
 	version = __version__
 
-	_closed = True
-
 	def __init__(self, maxusage=None, setsession=None, closeable=True,
 			*args, **kwargs):
 		"""Create a "tough" PostgreSQL connection.
@@ -106,6 +111,10 @@ def __init__(self, maxusage=None, setsession=None, closeable=True,
 			the PostgreSQL connections with PyGreSQL using pg.DB()
 
 		"""
+		# basic initialization to make finalizer work
+		self._con = None
+		self._closed = True
+		# proper initialization of the connection
 		if maxusage is not None and not isinstance(maxusage, (int, long)):
 			raise TypeError("'maxusage' must be an integer value.")
 		self._maxusage = maxusage
@@ -214,11 +223,14 @@ def __getattr__(self, name):
 		Some methods are made "tougher" than in the standard version.
 
 		"""
-		attr = getattr(self._con, name)
-		if name in ('query', 'get', 'insert', 'update', 'delete') \
-			or name.startswith('get_'):
-			attr = self._get_tough_method(attr)
-		return attr
+		if self._con:
+			attr = getattr(self._con, name)
+			if (name in ('query', 'get', 'insert', 'update', 'delete')
+					or name.startswith('get_')):
+				attr = self._get_tough_method(attr)
+			return attr
+		else:
+			raise InvalidConnection
 
 	def __del__(self):
 		"""Delete the steady connection."""

DBUtils/Testing/TestSteadyDB.py

@@ -39,13 +39,13 @@ class Connection:
 	def __init__(self, database=None, user=None):
 		self.database = database
 		self.user = user
+		self.valid = False
+		if database == 'error':
+			raise OperationalError
 		self.open_cursors = 0
 		self.num_uses = 0
 		self.num_queries = 0
 		self.session = []
-		if database == 'error':
-			self.valid = False
-			raise OperationalError
 		self.valid = True
 
 	def close(self):
@@ -73,10 +73,10 @@ class Cursor:
 
 	def __init__(self, con, name=None):
 		self.con = con
-		self.result = None
+		self.valid = False
 		if name == 'error':
-			self.valid = False
 			raise OperationalError
+		self.result = None
 		con.open_cursors += 1
 		self.valid = True
 

DBUtils/Testing/TestSteadyPg.py

@@ -87,7 +87,7 @@ def __getattr__(self, name):
 		if self.db:
 			return getattr(self.db, name)
 		else:
-			raise InternalError
+			raise AttributeError
 
 	def close(self):
 		if self.db: