Implement Nested as it was deprecated in 3.1.

Alter the dependencies to reference the new implementation.

It may be wise to just import the Python 3 version sans the warning in order to
warrant exception __context__ preservation--currently Nested() uses __cause__ as
a final out-of-context raise wrecks the context chain.

Author: James William Pye

postgresql/bin/pg_python.py

@@ -12,7 +12,8 @@
 import optparse
 import contextlib
 from .. import clientparameters
-from ..resolved import pythoncommand as pycmd
+from ..python import command as pycmd
+from ..python.contextlib import Nested, NoCM
 from .. import __version__
 
 from ..driver import default as pg_driver
@@ -110,7 +111,7 @@ def command(argv = sys.argv):
 			if trace_file is not None:
 				connection.tracer = trace_file.write
 			context = [connection]
-			with contextlib.nested(*context):
+			with Nested(*context):
 				rv = pythonexec(
 					context = pycmd.postmortem(os.environ.get('PYTHON_POSTMORTEM'))
 				)

postgresql/resolved/pythoncommand.py postgresql/python/command.pypostgresql/resolved/pythoncommand.py renamed to postgresql/python/command.py

@@ -0,0 +1,82 @@
+##
+# copyright 2009, James William Pye
+# http://python.projects.postgresql.org
+##
+import sys
+
+class NoCM(object):
+	"""
+	CM that does nothing. Useful for parameterized CMs.
+	"""
+	__slots__ = ()
+
+	def __new__(typ):
+		return typ
+
+	@staticmethod
+	def __enter__():
+		pass
+
+	@classmethod
+	def __context__(typ):
+		return typ
+
+	@staticmethod
+	def __exit__(typ, val, tb):
+		pass
+
+class Nested(object):
+	"""
+	cause they deprecated it in 3.1
+
+	Implemented with a class instead of a contextlib.contextmanager. A generator
+	CM is probably a better choice as it would likely make it easier to properly
+	preserve __context__.
+
+	WARNING: Uses __cause__ to reference exception contexts when possible.
+	"""
+	__slots__ = ('cm', 'exits')
+
+	def __init__(self, *cm):
+		self.cm = tuple([
+			x.__context__() if hasattr(x, '__context__') else x for x in cm
+		])
+
+	def __enter__(self):
+		if hasattr(self, 'exits'):
+			raise RuntimeError("context manager already ran")
+		self.exits = []
+		r = []
+		try:
+			for x in self.cm:
+				r.append(x.__enter__())
+				self.exits.append(x.__exit__)
+		except:
+			if self.__exit__(*sys.exc_info()):
+				raise RuntimeError("cannot suppress exceptions raised during entry")
+			raise
+		return tuple(r)
+
+	def __exit__(self, typ, val, tb):
+		# if there are no exits, there's nothing to be done.
+		oval = val
+		for x in reversed(self.exits):
+			try:
+				if x(typ, val, tb):
+					typ = val = tb = None
+			except:
+				newtyp, newval, newtb = sys.exc_info()
+				if getattr(newval,'__cause__') is None:
+					newval.__cause__ = getattr(newval, '__context__', val)
+				if newval.__cause__ is newval.__context__:
+					newval.__context__ = None
+				typ = newtyp
+				val = newval
+				tb = newtb
+		self.exits = ()
+		if val is not None and val is not oval:
+			raise val
+		return val is None
+
+	def __context__(self):
+		return self

postgresql/python/contextlib.py

@@ -4,7 +4,7 @@
 import unittest
 from ..unittest import TestCaseWithCluster
 import time
-from contextlib import nested
+from ..python.contextlib import NoCM
 
 ##
 # Various Adjustments for pg.driver.dbapi20
@@ -110,7 +110,7 @@ def tearDown(self):
 			con.close()
 
 	def connection(self):
-		return nested()
+		return NoCM
 
 	def _connect(self):
 		host, port = self.cluster.address()
@@ -807,21 +807,21 @@ def test_Date(self):
 		d1 = self.driver.Date(2002,12,25)
 		d2 = self.driver.DateFromTicks(time.mktime((2002,12,25,0,0,0,0,0,0)))
 		# Can we assume this? API doesn't specify, but it seems implied
-		# self.assertEqual(str(d1),str(d2))
+		self.assertEqual(str(d1),str(d2))
 
 	def test_Time(self):
 		t1 = self.driver.Time(13,45,30)
 		t2 = self.driver.TimeFromTicks(time.mktime((2001,1,1,13,45,30,0,0,0)))
 		# Can we assume this? API doesn't specify, but it seems implied
-		# self.assertEqual(str(t1),str(t2))
+		self.assertEqual(str(t1),str(t2))
 
 	def test_Timestamp(self):
 		t1 = self.driver.Timestamp(2002,12,25,13,45,30)
 		t2 = self.driver.TimestampFromTicks(
 			time.mktime((2002,12,25,13,45,30,0,0,0))
 		)
 		# Can we assume this? API doesn't specify, but it seems implied
-		# self.assertEqual(str(t1),str(t2))
+		#self.assertEqual(str(t1),str(t2))
 
 	def test_Binary(self):
 		b = self.driver.Binary(b'Something')

postgresql/test/test_dbapi20.py

@@ -7,7 +7,9 @@
 import errno
 from itertools import chain
 from operator import methodcaller
+from contextlib import contextmanager
 
+from ..python.contextlib import *
 from ..python import functools
 from ..python import itertools
 from ..python.socket import find_available_port
@@ -148,6 +150,150 @@ def testFindAvailable(self):
 			else:
 				self.fail("got a connection to an available port: " + str(portnum))
 
+class contextlib(unittest.TestCase):
+	def testNoCM(self):
+		with NoCM as foo:
+			pass
+		self.failUnlessEqual(foo, None)
+		self.failUnlessEqual(NoCM(), NoCM)
+		# has no state, may be used repeatedly
+		with NoCM as foo:
+			pass
+		self.failUnlessEqual(foo, None)
+
+	def testNested(self):
+		class SomeExc(Exception):
+			pass
+		@contextmanager
+		def just_one():
+			yield 1
+		@contextmanager
+		def just_two():
+			try:
+				yield 2
+			except:
+				print("wtf")
+		@contextmanager
+		def raise_exc():
+			raise SomeExc("foo")
+			yield 1
+		@contextmanager
+		def finally_exc():
+			try:
+				yield 1
+			finally:
+				raise SomeExc("foo")
+		@contextmanager
+		def suppress():
+			try:
+				yield None
+			except SomeExc:
+				pass
+		@contextmanager
+		def expect_and_raise(exc, rexc):
+			try:
+				yield None
+			except exc:
+				raise rexc("bleh")
+
+		with Nested() as foo:
+			pass
+		self.failUnlessEqual(foo, ())
+		try:
+			with Nested() as foo:
+				self.failUnlessEqual(foo, ())
+				raise SomeExc("bar")
+		except SomeExc:
+			pass
+		else:
+			self.fail("empty Nested did not raise exception")
+
+		with Nested(just_one()) as foo:
+			pass
+		self.failUnlessEqual(foo, (1,))
+
+		with Nested(just_one(), just_one()) as foo:
+			pass
+		self.failUnlessEqual(foo, (1,1))
+
+		# NoCM won't raise a RuntimeError on re-use.
+		N=Nested(NoCM)
+		with N:
+			pass
+		try:
+			with N:
+				pass
+		except RuntimeError:
+			pass
+		else:
+			self.fail("exhausted Nested() failed to raise RuntimeError")
+
+		# unsuppressed exceptions on entry
+		try:
+			with Nested(raise_exc()):
+				pass
+		except SomeExc:
+			pass
+		else:
+			self.fail("nested didn't raise SomeExc")
+		try:
+			with Nested(just_one(), raise_exc()):
+				pass
+		except SomeExc:
+			pass
+		else:
+			self.fail("nested didn't raise SomeExc")
+
+		# suppressed SomeExc during entry--disallowed.
+		try:
+			with Nested(suppress(), raise_exc()):
+				pass
+		except RuntimeError:
+			pass
+		else:
+			self.fail("nested didn't raise RuntimeError on suppressed partial entry")
+
+		# suppress should stop it, and that's okay because we're already
+		# inside the block.
+		with Nested(suppress(), finally_exc()):
+			raise SomeExc("foo")
+
+		# This test case validates that the context is being
+		# properly set.
+		class ThisExc(Exception):
+			pass
+		try:
+			with Nested(expect_and_raise(ThisExc, SomeExc)):
+				raise ThisExc("FOO")
+		except SomeExc as e:
+			self.failUnlessEqual(type(e.__context__), ThisExc)
+		else:
+			self.fail("failed to raise exception")
+
+		class ThatExc(Exception):
+			pass
+		try:
+			with Nested(expect_and_raise(ThisExc, SomeExc), expect_and_raise(ThatExc, ThisExc)):
+				raise ThatExc("BAFOON")
+		except SomeExc as e:
+			# ThatExc -> ThisExc -> SomeExc
+			self.failUnlessEqual(type(e.__cause__), ThisExc)
+			self.failUnlessEqual(type(e.__cause__.__cause__), ThatExc)
+
+		try:
+			with Nested(just_one()) as foo:
+				self.failUnlessEqual(foo, (1,))
+				raise SomeExc("inside the block")
+		except SomeExc as e:
+			pass
+		else:
+			self.fail("Nested didn't pass up exception raised in block")
+
+		# Slightly more complex suppression.
+		with Nested(just_two(), suppress(), expect_and_raise(ThisExc, SomeExc), expect_and_raise(ThatExc, ThisExc)) as foo:
+			raise ThatExc("MOOF")
+		self.failUnlessEqual(foo[0], 2)
+
 if __name__ == '__main__':
 	from types import ModuleType
 	this = ModuleType("this")