(Queue.Empty): When class based exceptions are in force, derive this

class from the standard base exception Exception.  Otherwise define
Queue.Empty as a string exception.

(Queue): 8-space to 4-space indentation conversion.  Also, basically
recast all method comments into docstrings.

Lib/Queue.py

@@ -1,12 +1,20 @@
 # A multi-producer, multi-consumer queue.
 
-Empty = 'Queue.Empty' # Exception raised by get_nowait()
+# define this exception to be compatible with Python 1.5's class
+# exceptions, but also when -X option is used.
+try:
+    class Empty(Exception):
+	pass
+except TypeError:
+    # string based exceptions
+    Empty = 'Queue.Empty'		# Exception raised by get_nowait()
 
 class Queue:
-
-	# Initialize a queue object with a given maximum size
-	# (If maxsize is <= 0, the maximum size is infinite)
     def __init__(self, maxsize):
+	"""Initialize a queue object with a given maximum size.
+
+	If maxsize is <= 0, the queue size is infinite.
+	"""
 	import thread
 	self._init(maxsize)
 	self.mutex = thread.allocate_lock()
@@ -14,29 +22,29 @@ class Queue:
 	self.esema.acquire_lock()
 	self.fsema = thread.allocate_lock()
 
-	# Get an approximation of the queue size (not reliable!)
     def qsize(self):
+	"""Returns the approximate size of the queue (not reliable!)."""
 	self.mutex.acquire_lock()
 	n = self._qsize()
 	self.mutex.release_lock()
 	return n
 
-	# Check if the queue is empty (not reliable!)
     def empty(self):
+	"""Returns 1 if the queue is empty, 0 otherwise (not reliable!)."""
 	self.mutex.acquire_lock()
 	n = self._empty()
 	self.mutex.release_lock()
 	return n
 
-	# Check if the queue is full (not reliable!)
     def full(self):
+	"""Returns 1 if the queue is full, 0 otherwise (not reliable!)."""
 	self.mutex.acquire_lock()
 	n = self._full()
 	self.mutex.release_lock()
 	return n
 
-	# Put a new item into the queue
     def put(self, item):
+	"""Put an item into the queue."""
 	self.fsema.acquire_lock()
 	self.mutex.acquire_lock()
 	was_empty = self._empty()
@@ -47,9 +55,10 @@ class Queue:
 	    self.fsema.release_lock()
 	self.mutex.release_lock()
 
-	# Get an item from the queue,
-	# blocking if necessary until one is available
     def get(self):
+	"""Gets and returns an item from the queue.
+	This method blocks if necessary until an item is available.
+	"""
 	self.esema.acquire_lock()
 	self.mutex.acquire_lock()
 	was_full = self._full()
@@ -64,10 +73,15 @@ class Queue:
     # Get an item from the queue if one is immediately available,
     # raise Empty if the queue is empty or temporarily unavailable
     def get_nowait(self):
+	"""Gets and returns an item from the queue.
+	Only gets an item if one is immediately available, Otherwise
+	this raises the Empty exception if the queue is empty or
+	temporarily unavailable.
+	"""
 	locked = self.esema.acquire_lock(0)
 	self.mutex.acquire_lock()
 	if self._empty():
-			# The queue is empyt -- we can't have esema
+	    # The queue is empty -- we can't have esema
 	    self.mutex.release_lock()
 	    raise Empty
 	if not locked: