Description: <short summary of the patch>
 TODO: Put a short summary on the line above and replace this paragraph
 with a longer explanation of this change. Complete the meta-information
 with other relevant fields (see below for details). To make it easier, the
 information below has been extracted from the changelog. Adjust it or drop
 it.
 .
 python-protorpc-standalone (0.9.1-1) unstable; urgency=medium
 .
   * Initial release. (Closes: #759385)
Author: Thomas Goirand <zigo@debian.org>
Bug-Debian: https://bugs.debian.org/759385

---
The information above should follow the Patch Tagging Guidelines, please
checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
are templates for supplementary fields that you might want to add:

Origin: <vendor|upstream|other>, <url of original patch>
Bug: <url in upstream bugtracker>
Bug-Debian: https://bugs.debian.org/<bugnumber>
Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
Forwarded: <no|not-needed|url proving that it has been forwarded>
Reviewed-By: <name and email of someone who approved the patch>
Last-Update: <YYYY-MM-DD>

--- python-protorpc-standalone-0.9.1.orig/protorpc/_google/net/proto/ProtocolBuffer.py
+++ python-protorpc-standalone-0.9.1/protorpc/_google/net/proto/ProtocolBuffer.py
@@ -84,7 +84,7 @@ class ProtocolMessage:
     self.MergePartialFromString(s)
     dbg = []
     if not self.IsInitialized(dbg):
-      raise ProtocolBufferDecodeError, '\n\t'.join(dbg)
+      raise ProtocolBufferDecodeError('\n\t'.join(dbg))
 
   def MergePartialFromString(self, s):
     try:
@@ -200,7 +200,7 @@ class ProtocolMessage:
   def Output(self, e):
     dbg = []
     if not self.IsInitialized(dbg):
-      raise ProtocolBufferEncodeError, '\n\t'.join(dbg)
+      raise ProtocolBufferEncodeError('\n\t'.join(dbg))
     self.OutputUnchecked(e)
     return
 
@@ -219,7 +219,7 @@ class ProtocolMessage:
     self.TryMerge(d)
     dbg = []
     if not self.IsInitialized(dbg):
-      raise ProtocolBufferDecodeError, '\n\t'.join(dbg)
+      raise ProtocolBufferDecodeError('\n\t'.join(dbg))
     return
 
   def TryMerge(self, d):
@@ -338,18 +338,18 @@ class Encoder:
     return self.buf
 
   def put8(self, v):
-    if v < 0 or v >= (1<<8): raise ProtocolBufferEncodeError, "u8 too big"
+    if v < 0 or v >= (1<<8): raise ProtocolBufferEncodeError("u8 too big")
     self.buf.append(v & 255)
     return
 
   def put16(self, v):
-    if v < 0 or v >= (1<<16): raise ProtocolBufferEncodeError, "u16 too big"
+    if v < 0 or v >= (1<<16): raise ProtocolBufferEncodeError("u16 too big")
     self.buf.append((v >> 0) & 255)
     self.buf.append((v >> 8) & 255)
     return
 
   def put32(self, v):
-    if v < 0 or v >= (1L<<32): raise ProtocolBufferEncodeError, "u32 too big"
+    if v < 0 or v >= (1L<<32): raise ProtocolBufferEncodeError("u32 too big")
     self.buf.append((v >> 0) & 255)
     self.buf.append((v >> 8) & 255)
     self.buf.append((v >> 16) & 255)
@@ -357,7 +357,7 @@ class Encoder:
     return
 
   def put64(self, v):
-    if v < 0 or v >= (1L<<64): raise ProtocolBufferEncodeError, "u64 too big"
+    if v < 0 or v >= (1L<<64): raise ProtocolBufferEncodeError("u64 too big")
     self.buf.append((v >> 0) & 255)
     self.buf.append((v >> 8) & 255)
     self.buf.append((v >> 16) & 255)
@@ -382,7 +382,7 @@ class Encoder:
       buf_append(v)
       return
     if v >= 0x80000000 or v < -0x80000000:
-      raise ProtocolBufferEncodeError, "int32 too big"
+      raise ProtocolBufferEncodeError("int32 too big")
     if v < 0:
       v += 0x10000000000000000
     while True:
@@ -398,7 +398,7 @@ class Encoder:
   def putVarInt64(self, v):
     buf_append = self.buf.append
     if v >= 0x8000000000000000 or v < -0x8000000000000000:
-      raise ProtocolBufferEncodeError, "int64 too big"
+      raise ProtocolBufferEncodeError("int64 too big")
     if v < 0:
       v += 0x10000000000000000
     while True:
@@ -414,7 +414,7 @@ class Encoder:
   def putVarUint64(self, v):
     buf_append = self.buf.append
     if v < 0 or v >= 0x10000000000000000:
-      raise ProtocolBufferEncodeError, "uint64 too big"
+      raise ProtocolBufferEncodeError("uint64 too big")
     while True:
       bits = v & 127
       v >>= 7
@@ -496,7 +496,7 @@ class Decoder:
     return self.idx
 
   def skip(self, n):
-    if self.idx + n > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + n > self.limit: raise ProtocolBufferDecodeError("truncated")
     self.idx += n
     return
 
@@ -517,30 +517,30 @@ class Decoder:
         else:
           self.skipData(t)
       if (t - Encoder.ENDGROUP) != (tag - Encoder.STARTGROUP):
-        raise ProtocolBufferDecodeError, "corrupted"
+        raise ProtocolBufferDecodeError("corrupted")
     elif t == Encoder.ENDGROUP:
-      raise ProtocolBufferDecodeError, "corrupted"
+      raise ProtocolBufferDecodeError("corrupted")
     elif t == Encoder.FLOAT:
       self.skip(4)
     else:
-      raise ProtocolBufferDecodeError, "corrupted"
+      raise ProtocolBufferDecodeError("corrupted")
 
 
   def get8(self):
-    if self.idx >= self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx >= self.limit: raise ProtocolBufferDecodeError("truncated")
     c = self.buf[self.idx]
     self.idx += 1
     return c
 
   def get16(self):
-    if self.idx + 2 > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + 2 > self.limit: raise ProtocolBufferDecodeError("truncated")
     c = self.buf[self.idx]
     d = self.buf[self.idx + 1]
     self.idx += 2
     return (d << 8) | c
 
   def get32(self):
-    if self.idx + 4 > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + 4 > self.limit: raise ProtocolBufferDecodeError("truncated")
     c = self.buf[self.idx]
     d = self.buf[self.idx + 1]
     e = self.buf[self.idx + 2]
@@ -549,7 +549,7 @@ class Decoder:
     return (f << 24) | (e << 16) | (d << 8) | c
 
   def get64(self):
-    if self.idx + 8 > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + 8 > self.limit: raise ProtocolBufferDecodeError("truncated")
     c = self.buf[self.idx]
     d = self.buf[self.idx + 1]
     e = self.buf[self.idx + 2]
@@ -578,15 +578,15 @@ class Decoder:
       shift += 7
       if not (b & 128):
         if result >= 0x10000000000000000L:
-          raise ProtocolBufferDecodeError, "corrupted"
+          raise ProtocolBufferDecodeError("corrupted")
         break
-      if shift >= 64: raise ProtocolBufferDecodeError, "corrupted"
+      if shift >= 64: raise ProtocolBufferDecodeError("corrupted")
       b = self.get8()
 
     if result >= 0x8000000000000000L:
       result -= 0x10000000000000000L
     if result >= 0x80000000L or result < -0x80000000L:
-      raise ProtocolBufferDecodeError, "corrupted"
+      raise ProtocolBufferDecodeError("corrupted")
     return result
 
   def getVarInt64(self):
@@ -599,36 +599,36 @@ class Decoder:
     result = long(0)
     shift = 0
     while 1:
-      if shift >= 64: raise ProtocolBufferDecodeError, "corrupted"
+      if shift >= 64: raise ProtocolBufferDecodeError("corrupted")
       b = self.get8()
       result |= (long(b & 127) << shift)
       shift += 7
       if not (b & 128):
-        if result >= (1L << 64): raise ProtocolBufferDecodeError, "corrupted"
+        if result >= (1L << 64): raise ProtocolBufferDecodeError("corrupted")
         return result
     return result
 
   def getFloat(self):
-    if self.idx + 4 > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + 4 > self.limit: raise ProtocolBufferDecodeError("truncated")
     a = self.buf[self.idx:self.idx+4]
     self.idx += 4
     return struct.unpack("<f", a)[0]
 
   def getDouble(self):
-    if self.idx + 8 > self.limit: raise ProtocolBufferDecodeError, "truncated"
+    if self.idx + 8 > self.limit: raise ProtocolBufferDecodeError("truncated")
     a = self.buf[self.idx:self.idx+8]
     self.idx += 8
     return struct.unpack("<d", a)[0]
 
   def getBoolean(self):
     b = self.get8()
-    if b != 0 and b != 1: raise ProtocolBufferDecodeError, "corrupted"
+    if b != 0 and b != 1: raise ProtocolBufferDecodeError("corrupted")
     return b
 
   def getPrefixedString(self):
     length = self.getVarInt32()
     if self.idx + length > self.limit:
-      raise ProtocolBufferDecodeError, "truncated"
+      raise ProtocolBufferDecodeError("truncated")
     r = self.buf[self.idx : self.idx + length]
     self.idx += length
     return r.tostring()
--- python-protorpc-standalone-0.9.1.orig/protorpc/descriptor.py
+++ python-protorpc-standalone-0.9.1/protorpc/descriptor.py
@@ -602,7 +602,7 @@ def import_descriptor_loader(definition_
     # Attempt to use messages.find_definition to find item.
     return describe(messages.find_definition(definition_name,
                                              importer=__import__))
-  except messages.DefinitionNotFoundError, err:
+  except messages.DefinitionNotFoundError as err:
     # There are things that find_definition will not find, but if the parent
     # is loaded, its children can be searched for a match.
     split_name = definition_name.rsplit('.', 1)
--- python-protorpc-standalone-0.9.1.orig/protorpc/descriptor_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/descriptor_test.py
@@ -344,7 +344,7 @@ class DescribeFileTest(test_util.TestCas
               'messages': messages,
               'remote': remote,
               }
-    exec source in result
+    exec(source, result)
 
     module = new.module(module_name)
     for name, value in result.iteritems():
--- python-protorpc-standalone-0.9.1.orig/protorpc/end2end_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/end2end_test.py
@@ -109,7 +109,7 @@ class EndToEndTest(webapp_test_util.EndT
   def testApplicationError(self):
     try:
       self.stub.raise_application_error()
-    except remote.ApplicationError, err:
+    except remote.ApplicationError as err:
       self.assertEquals('This is an application error', err.message)
       self.assertEquals('ERROR_NAME', err.error_name)
     else:
@@ -118,7 +118,7 @@ class EndToEndTest(webapp_test_util.EndT
   def testRpcError(self):
     try:
       self.stub.raise_rpc_error()
-    except remote.ServerError, err:
+    except remote.ServerError as err:
       self.assertEquals('Internal Server Error', err.message)
     else:
       self.fail('Expected server error')
@@ -126,7 +126,7 @@ class EndToEndTest(webapp_test_util.EndT
   def testUnexpectedError(self):
     try:
       self.stub.raise_unexpected_error()
-    except remote.ServerError, err:
+    except remote.ServerError as err:
       self.assertEquals('Internal Server Error', err.message)
     else:
       self.fail('Expected server error')
@@ -134,7 +134,7 @@ class EndToEndTest(webapp_test_util.EndT
   def testBadResponse(self):
     try:
       self.stub.return_bad_message()
-    except remote.ServerError, err:
+    except remote.ServerError as err:
       self.assertEquals('Internal Server Error', err.message)
     else:
       self.fail('Expected server error')
--- python-protorpc-standalone-0.9.1.orig/protorpc/messages.py
+++ python-protorpc-standalone-0.9.1/protorpc/messages.py
@@ -769,7 +769,7 @@ class Message(object):
             else:
               message_value = field.value_to_message(value)
               message_value.check_initialized()
-        except ValidationError, err:
+        except ValidationError as err:
           if not hasattr(err, 'message_name'):
             err.message_name = type(self).__name__
           raise
@@ -1132,7 +1132,7 @@ class Field(object):
     if default is not None:
       try:
         self.validate_default(default)
-      except ValidationError, err:
+      except ValidationError as err:
         try:
           name = self.name
         except AttributeError:
@@ -1390,7 +1390,7 @@ class StringField(Field):
     if isinstance(value, str):
       try:
         unicode(value)
-      except UnicodeDecodeError, err:
+      except UnicodeDecodeError as err:
         try:
           name = self.name
         except AttributeError:
--- python-protorpc-standalone-0.9.1.orig/protorpc/messages_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/messages_test.py
@@ -119,7 +119,6 @@ class EnumTest(test_util.TestCase):
     self.assertEquals(Color.RED, Color('RED'))
     self.assertEquals(Color.RED, Color(u'RED'))
     self.assertEquals(Color.RED, Color(20))
-    self.assertEquals(Color.RED, Color(20L))
     self.assertEquals(Color.RED, Color(Color.RED))
     self.assertRaises(TypeError, Color, 'Not exists')
     self.assertRaises(TypeError, Color, 'Red')
--- python-protorpc-standalone-0.9.1.orig/protorpc/protobuf.py
+++ python-protorpc-standalone-0.9.1/protorpc/protobuf.py
@@ -351,7 +351,7 @@ def decode_message(message_type, encoded
           values.append(value)
       else:
         setattr(message, field.name, value)
-  except ProtocolBuffer.ProtocolBufferDecodeError, err:
+  except ProtocolBuffer.ProtocolBufferDecodeError as err:
     raise messages.DecodeError('Decoding error: %s' % str(err))
 
   message.check_initialized()
--- python-protorpc-standalone-0.9.1.orig/protorpc/protobuf_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/protobuf_test.py
@@ -55,7 +55,7 @@ class EncodeMessageTest(test_util.TestCa
     try:
       function(*params, **kwargs)
       self.fail('Expected to raise exception %s but did not.' % exception)
-    except exception, err:
+    except exception as err:
       self.assertEquals(message, str(err))
 
   @property
--- python-protorpc-standalone-0.9.1.orig/protorpc/protojson.py
+++ python-protorpc-standalone-0.9.1/protorpc/protojson.py
@@ -72,7 +72,7 @@ def _load_json_module():
         raise ImportError(message)
       else:
         return module
-    except ImportError, err:
+    except ImportError as err:
       if not first_import_error:
         first_import_error = err
 
@@ -304,13 +304,13 @@ class ProtoJson(object):
     elif isinstance(field, messages.BytesField):
       try:
         return base64.b64decode(value)
-      except TypeError, err:
+      except TypeError as err:
         raise messages.DecodeError('Base64 decoding error: %s' % err)
 
     elif isinstance(field, message_types.DateTimeField):
       try:
         return util.decode_datetime(value)
-      except ValueError, err:
+      except ValueError as err:
         raise messages.DecodeError(err)
 
     elif isinstance(field, messages.MessageField):
--- python-protorpc-standalone-0.9.1.orig/protorpc/protourlencode.py
+++ python-protorpc-standalone-0.9.1/protorpc/protourlencode.py
@@ -425,7 +425,7 @@ class URLEncodedRequestBuilder(object):
     elif isinstance(field, message_types.DateTimeField):
       try:
         converted_value = util.decode_datetime(value)
-      except ValueError, e:
+      except ValueError as e:
         raise messages.DecodeError(e)
     elif isinstance(field, messages.MessageField):
       # Just make sure it's instantiated.  Assignment to field or
--- python-protorpc-standalone-0.9.1.orig/protorpc/remote_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/remote_test.py
@@ -735,7 +735,7 @@ class CheckRpcStatusTest(test_util.TestC
     try:
       remote.check_rpc_status(status)
       self.fail('Should have raised application error.')
-    except remote.ApplicationError, err:
+    except remote.ApplicationError as err:
       self.assertEquals('an application error', str(err))
       self.assertEquals('blam', err.error_name)
 
--- python-protorpc-standalone-0.9.1.orig/protorpc/test_util.py
+++ python-protorpc-standalone-0.9.1/protorpc/test_util.py
@@ -69,7 +69,7 @@ class TestCase(unittest.TestCase):
     try:
       function(*params, **kwargs)
       self.fail('Expected exception %s was not raised' % exception.__name__)
-    except exception, err:
+    except exception as err:
       match = bool(re.match(regexp, str(err)))
       self.assertTrue(match, 'Expected match "%s", found "%s"' % (regexp,
                                                                   err))
--- python-protorpc-standalone-0.9.1.orig/protorpc/transport_test.py
+++ python-protorpc-standalone-0.9.1/protorpc/transport_test.py
@@ -268,7 +268,7 @@ class HttpTransportTest(webapp_test_util
     bad_transport = transport.HttpTransport('http://localhost:-1/blar')
     try:
       bad_transport.send_rpc(my_method.remote, self.request)
-    except remote.NetworkError, err:
+    except remote.NetworkError as err:
       self.assertTrue(str(err).startswith('Socket error: gaierror ('))
       self.assertEquals(socket.gaierror, type(err.cause))
       self.assertEquals(8, abs(err.cause.args[0]))  # Sign is sys depednent.
--- python-protorpc-standalone-0.9.1.orig/protorpc/webapp/service_handlers.py
+++ python-protorpc-standalone-0.9.1/protorpc/webapp/service_handlers.py
@@ -224,7 +224,7 @@ class RPCMapper(object):
     """
     try:
       return self.__protocol.decode_message(request_type, handler.request.body)
-    except (messages.ValidationError, messages.DecodeError), err:
+    except (messages.ValidationError, messages.DecodeError) as err:
       raise RequestError('Unable to parse request content: %s' % err)
 
   def build_response(self, handler, response, pad_string=False):
@@ -245,7 +245,7 @@ class RPCMapper(object):
     """
     try:
       encoded_message = self.__protocol.encode_message(response)
-    except messages.ValidationError, err:
+    except messages.ValidationError as err:
       raise ResponseError('Unable to encode message: %s' % err)
     else:
       handler.response.headers['Content-Type'] = self.default_content_type
@@ -582,7 +582,7 @@ class ServiceHandler(webapp.RequestHandl
         try:
           method = getattr(self.service, remote_method)
           method_info = method.remote
-        except AttributeError, err:
+        except AttributeError as err:
           self.__send_error(
           400, remote.RpcState.METHOD_NOT_FOUND_ERROR,
             'Unrecognized RPC method: %s' % remote_method,
@@ -590,7 +590,7 @@ class ServiceHandler(webapp.RequestHandl
           return
 
         request = mapper.build_request(self, method_info.request_type)
-      except (RequestError, messages.DecodeError), err:
+      except (RequestError, messages.DecodeError) as err:
         self.__send_error(400,
                           remote.RpcState.REQUEST_ERROR,
                           'Error parsing ProtoRPC request (%s)' % err,
@@ -599,7 +599,7 @@ class ServiceHandler(webapp.RequestHandl
 
       try:
         response = method(request)
-      except remote.ApplicationError, err:
+      except remote.ApplicationError as err:
         self.__send_error(400,
                           remote.RpcState.APPLICATION_ERROR,
                           err.message,
@@ -608,7 +608,7 @@ class ServiceHandler(webapp.RequestHandl
         return
 
       mapper.build_response(self, response)
-    except Exception, err:
+    except Exception as err:
       logging.error('An unexpected error occured when handling RPC: %s',
                     err, exc_info=1)
 
@@ -693,7 +693,7 @@ class URLEncodedRPCMapper(RPCMapper):
       values = handler.request.get_all(argument)
       try:
         builder.add_parameter(argument, values)
-      except messages.DecodeError, err:
+      except messages.DecodeError as err:
         raise RequestError(str(err))
     return request
 
--- python-protorpc-standalone-0.9.1.orig/protorpc/webapp_test_util.py
+++ python-protorpc-standalone-0.9.1/protorpc/webapp_test_util.py
@@ -394,5 +394,5 @@ class EndToEndTestBase(WebServerTestBase
     try:
       self.DoRawRequest(method, content, content_type, headers)
       self.fail('Expected HTTP error')
-    except urllib2.HTTPError, err:
+    except urllib2.HTTPError as err:
       return err.code, err.read(), err.headers
--- python-protorpc-standalone-0.9.1.orig/protorpc/wsgi/service.py
+++ python-protorpc-standalone-0.9.1/protorpc/wsgi/service.py
@@ -146,7 +146,7 @@ def service_mapping(service_factory, ser
     try:
       request = protocol.decode_message(
         remote_info.request_type, environ['wsgi.input'].read(content_length))
-    except (messages.ValidationError, messages.DecodeError), err:
+    except (messages.ValidationError, messages.DecodeError) as err:
       return send_rpc_error(httplib.BAD_REQUEST,
                             remote.RpcState.REQUEST_ERROR,
                             'Error parsing ProtoRPC request '
@@ -180,12 +180,12 @@ def service_mapping(service_factory, ser
     try:
       response = method(instance, request)
       encoded_response = protocol.encode_message(response)
-    except remote.ApplicationError, err:
+    except remote.ApplicationError as err:
       return send_rpc_error(httplib.BAD_REQUEST,
                             remote.RpcState.APPLICATION_ERROR,
                             err.message,
                             err.error_name)
-    except Exception, err:
+    except Exception as err:
       logging.exception('Encountered unexpected error from ProtoRPC '
                         'method implementation: %s (%s)' %
                         (err.__class__.__name__, err))