Ticket #18013: except_as.diff

django/conf/__init__.py

@@ -91 +91 @@
 
         try:
             mod = importlib.import_module(self.SETTINGS_MODULE)
-        except ImportError, e:
+        except ImportError as e:
             raise ImportError("Could not import settings '%s' (Is it on sys.path?): %s" % (self.SETTINGS_MODULE, e))
 
         # Settings that should be converted into tuples if they're mistakenly entered

django/contrib/admin/tests.py

@@ -18 +18 @@
             mod = import_module(module)
             WebDriver = getattr(mod, attr)
             cls.selenium = WebDriver()
-        except Exception, e:
+        except Exception as e:
             raise SkipTest('Selenium webdriver "%s" not installed or not '
                            'operational: %s' % (cls.webdriver_class, str(e)))
         super(AdminSeleniumWebDriverTestCase, cls).setUpClass()

django/contrib/admin/util.py

@@ -153 +153 @@
                 self.add_edge(None, obj)
         try:
             return super(NestedObjects, self).collect(objs, source_attr=source_attr, **kwargs)
-        except models.ProtectedError, e:
+        except models.ProtectedError as e:
             self.protected.update(e.protected_objects)
 
     def related_objects(self, related, objs):

django/contrib/admin/views/main.py

@@ -139 +139 @@
                 use_distinct = (use_distinct or
                                 lookup_needs_distinct(self.lookup_opts, key))
             return filter_specs, bool(filter_specs), lookup_params, use_distinct
-        except FieldDoesNotExist, e:
+        except FieldDoesNotExist as e:
             raise IncorrectLookupParameters(e)
 
     def get_query_string(self, new_params=None, remove=None):
@@ -316 +316 @@
             # Allow certain types of errors to be re-raised as-is so that the
             # caller can treat them in a special way.
             raise
-        except Exception, e:
+        except Exception as e:
             # Every other error is caught with a naked except, because we don't
             # have any other way of validating lookup parameters. They might be
             # invalid if the keyword arguments are incorrect, or if the values

django/contrib/admindocs/views.py

@@ -318 +318 @@
         for library_name in libraries:
             try:
                 lib = template.get_library(library_name)
-            except template.InvalidTemplateLibrary, e:
+            except template.InvalidTemplateLibrary as e:
                 pass
 
 def get_return_data_type(func_name):

django/contrib/auth/__init__.py

@@ -12 +12 @@
     module, attr = path[:i], path[i+1:]
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('Error importing authentication backend %s: "%s"' % (path, e))
-    except ValueError, e:
+    except ValueError as e:
         raise ImproperlyConfigured('Error importing authentication backends. Is AUTHENTICATION_BACKENDS a correctly defined list or tuple?')
     try:
         cls = getattr(mod, attr)

django/contrib/comments/views/comments.py

@@ -66 +66 @@
         return CommentPostBadRequest(
             "No object matching content-type %r and object PK %r exists." % \
                 (escape(ctype), escape(object_pk)))
-    except (ValueError, ValidationError), e:
+    except (ValueError, ValidationError) as e:
         return CommentPostBadRequest(
             "Attempting go get content-type %r and object PK %r exists raised %s" % \
                 (escape(ctype), escape(object_pk), e.__class__.__name__))

django/contrib/formtools/wizard/storage/__init__.py

@@ -10 +10 @@
     module, attr = path[:i], path[i+1:]
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise MissingStorageModule(
             'Error loading storage %s: "%s"' % (module, e))
     try:

django/contrib/gis/db/backends/base.py

@@ -164 +164 @@
                 try:
                     self._srs = gdal.SpatialReference(self.wkt)
                     return self.srs
-                except Exception, msg:
+                except Exception as msg:
                     pass
 
                 try:
                     self._srs = gdal.SpatialReference(self.proj4text)
                     return self.srs
-                except Exception, msg:
+                except Exception as msg:
                     pass
 
                 raise Exception('Could not get OSR SpatialReference from WKT: %s\nError:\n%s' % (self.wkt, msg))

django/contrib/gis/db/backends/oracle/introspection.py

@@ -16 +16 @@
                 cursor.execute('SELECT "DIMINFO", "SRID" FROM "USER_SDO_GEOM_METADATA" WHERE "TABLE_NAME"=%s AND "COLUMN_NAME"=%s',
                                (table_name.upper(), geo_col.upper()))
                 row = cursor.fetchone()
-            except Exception, msg:
+            except Exception as msg:
                 raise Exception('Could not find entry in USER_SDO_GEOM_METADATA corresponding to "%s"."%s"\n'
                                 'Error message: %s.' % (table_name, geo_col, msg))
 

django/contrib/gis/db/backends/postgis/operations.py

@@ -107 +107 @@
                                        'Was the database created from a spatial database '
                                        'template?' % self.connection.settings_dict['NAME']
                                        )
-        except Exception, e:
+        except Exception as e:
             # TODO: Raise helpful exceptions as they become known.
             raise
 

django/contrib/gis/db/backends/spatialite/base.py

@@ -56 +56 @@
             cur = self.connection.cursor(factory=SQLiteCursorWrapper)
             try:
                 cur.execute("SELECT load_extension(%s)", (self.spatialite_lib,))
-            except Exception, msg:
+            except Exception as msg:
                 raise ImproperlyConfigured('Unable to load the SpatiaLite library extension '
                                            '"%s" because: %s' % (self.spatialite_lib, msg))
             return cur

django/contrib/gis/db/backends/spatialite/operations.py

@@ -122 +122 @@
             self.spatial_version = version
         except ImproperlyConfigured:
             raise
-        except Exception, msg:
+        except Exception as msg:
             raise ImproperlyConfigured('Cannot determine the SpatiaLite version for the "%s" '
                                        'database (error was "%s").  Was the SpatiaLite initialization '
                                        'SQL loaded on this database?' %

django/contrib/gis/geometry/backend/__init__.py

@@ -6 +6 @@
 
 try:
     module = import_module('.%s' % geom_backend, 'django.contrib.gis.geometry.backend')
-except ImportError, e:
+except ImportError as e:
     try:
         module = import_module(geom_backend)
-    except ImportError, e_user:
+    except ImportError as e_user:
         raise ImproperlyConfigured('Could not import user-defined GEOMETRY_BACKEND '
                                    '"%s".' % geom_backend)
 

django/contrib/gis/management/commands/ogrinspect.py

@@ -87 +87 @@
         # Getting the OGR DataSource from the string parameter.
         try:
             ds = gdal.DataSource(data_source)
-        except gdal.OGRException, msg:
+        except gdal.OGRException as msg:
             raise CommandError(msg)
 
         # Whether the user wants to generate the LayerMapping dictionary as well.

django/contrib/gis/tests/test_measure.py

@@ -64 +64 @@
 
         try:
             d5 = d1 + 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance + number should raise TypeError')
 
         try:
             d5 = d1 - 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance - number should raise TypeError')
 
         try:
             d1 += 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance += number should raise TypeError')
 
         try:
             d1 -= 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance -= number should raise TypeError')
@@ -112 +112 @@
 
         try:
             d1 *= D(m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance *= Distance should raise TypeError')
 
         try:
             d5 = d1 / D(m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance / Distance should raise TypeError')
 
         try:
             d1 /= D(m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Distance /= Distance should raise TypeError')
@@ -219 +219 @@
 
         try:
             a5 = a1 + 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area + number should raise TypeError')
 
         try:
             a5 = a1 - 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area - number should raise TypeError')
 
         try:
             a1 += 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area += number should raise TypeError')
 
         try:
             a1 -= 1
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area -= number should raise TypeError')
@@ -263 +263 @@
 
         try:
             a5 = a1 * A(sq_m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area * Area should raise TypeError')
 
         try:
             a1 *= A(sq_m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area *= Area should raise TypeError')
 
         try:
             a5 = a1 / A(sq_m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area / Area should raise TypeError')
 
         try:
             a1 /= A(sq_m=1)
-        except TypeError, e:
+        except TypeError as e:
             pass
         else:
             self.fail('Area /= Area should raise TypeError')

django/contrib/gis/utils/layermapping.py

@@ -430 +430 @@
 
             # Creating the CoordTransform object
             return CoordTransform(self.source_srs, target_srs)
-        except Exception, msg:
+        except Exception as msg:
             raise LayerMapError('Could not translate between the data source and model geometry: %s' % msg)
 
     def geometry_field(self):
@@ -514 +514 @@
                 # Getting the keyword arguments
                 try:
                     kwargs = self.feature_kwargs(feat)
-                except LayerMapError, msg:
+                except LayerMapError as msg:
                     # Something borked the validation
                     if strict: raise
                     elif not silent:
@@ -553 +553 @@
                         if verbose: stream.write('%s: %s\n' % (is_update and 'Updated' or 'Saved', m))
                     except SystemExit:
                         raise
-                    except Exception, msg:
+                    except Exception as msg:
                         if self.transaction_mode == 'autocommit':
                             # Rolling back the transaction so that other model saves
                             # will work.

django/contrib/markup/tests.py

@@ -87 +87 @@
             # Docutils v0.4 and earlier
             self.assertEqual(rendered, """<p>Paragraph 1</p>
 <p>Paragraph 2 with a <a class="reference" href="http://www.example.com/">link</a></p>""")
-        except AssertionError, e:
+        except AssertionError as e:
             # Docutils from SVN (which will become 0.5)
             self.assertEqual(rendered, """<p>Paragraph 1</p>
 <p>Paragraph 2 with a <a class="reference external" href="http://www.example.com/">link</a></p>""")

django/contrib/messages/storage/__init__.py

@@ -15 +15 @@
     module, classname = import_path[:dot], import_path[dot + 1:]
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('Error importing module %s: "%s"' %
                                    (module, e))
     try:

django/contrib/sessions/backends/file.py

@@ -90 +90 @@
             fd = os.open(session_file_name, flags)
             os.close(fd)
 
-        except OSError, e:
+        except OSError as e:
             if must_create and e.errno == errno.EEXIST:
                 raise CreateError
             raise

django/contrib/staticfiles/finders.py

@@ -260 +260 @@
     module, attr = import_path.rsplit('.', 1)
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('Error importing module %s: "%s"' %
                                    (module, e))
     try:

django/contrib/staticfiles/handlers.py

@@ -56 +56 @@
         if self._should_handle(request.path):
             try:
                 return self.serve(request)
-            except Http404, e:
+            except Http404 as e:
                 if settings.DEBUG:
                     from django.views import debug
                     return debug.technical_404_response(request, e)

django/core/cache/__init__.py

@@ -173 +173 @@
             mod_path, cls_name = backend.rsplit('.', 1)
             mod = importlib.import_module(mod_path)
             backend_cls = getattr(mod, cls_name)
-    except (AttributeError, ImportError), e:
+    except (AttributeError, ImportError) as e:
         raise InvalidCacheBackendError(
             "Could not find backend '%s': %s" % (backend, e))
     cache = backend_cls(location, params)

django/core/files/move.py

@@ -79 +79 @@
 
     try:
         os.remove(old_file_name)
-    except OSError, e:
+    except OSError as e:
         # Certain operating systems (Cygwin and Windows) 
         # fail when deleting opened files, ignore it.  (For the 
         # systems where this happens, temporary files will be auto-deleted

django/core/files/storage.py

@@ -166 +166 @@
         if not os.path.exists(directory):
             try:
                 os.makedirs(directory)
-            except OSError, e:
+            except OSError as e:
                 if e.errno != errno.EEXIST:
                     raise
         if not os.path.isdir(directory):
@@ -197 +197 @@
                     finally:
                         locks.unlock(fd)
                         os.close(fd)
-            except OSError, e:
+            except OSError as e:
                 if e.errno == errno.EEXIST:
                     # Ooops, the file exists. We need a new file name.
                     name = self.get_available_name(name)
@@ -222 +222 @@
         if os.path.exists(name):
             try:
                 os.remove(name)
-            except OSError, e:
+            except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
 
@@ -273 +273 @@
     module, classname = import_path[:dot], import_path[dot+1:]
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('Error importing storage module %s: "%s"' % (module, e))
     try:
         return getattr(mod, classname)

django/core/files/uploadedfile.py

@@ -75 +75 @@
     def close(self):
         try:
             return self.file.close()
-        except OSError, e:
+        except OSError as e:
             if e.errno != 2:
                 # Means the file was moved or deleted before the tempfile
                 # could unlink it.  Still sets self.file.close_called and

django/core/files/uploadhandler.py

@@ -204 +204 @@
     module, attr = path[:i], path[i+1:]
     try:
         mod = importlib.import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('Error importing upload handler module %s: "%s"' % (module, e))
-    except ValueError, e:
+    except ValueError as e:
         raise ImproperlyConfigured('Error importing upload handler module. Is FILE_UPLOAD_HANDLERS a correctly defined list or tuple?')
     try:
         cls = getattr(mod, attr)

django/core/handlers/base.py

@@ -43 +43 @@
                 raise exceptions.ImproperlyConfigured('%s isn\'t a middleware module' % middleware_path)
             try:
                 mod = import_module(mw_module)
-            except ImportError, e:
+            except ImportError as e:
                 raise exceptions.ImproperlyConfigured('Error importing middleware %s: "%s"' % (mw_module, e))
             try:
                 mw_class = getattr(mod, mw_classname)
@@ -109 +109 @@
                 if response is None:
                     try:
                         response = callback(request, *callback_args, **callback_kwargs)
-                    except Exception, e:
+                    except Exception as e:
                         # If the view raised an exception, run it through exception
                         # middleware, and if the exception middleware returns a
                         # response, use that. Otherwise, reraise the exception.
@@ -135 +135 @@
                         response = middleware_method(request, response)
                     response = response.render()
 
-            except http.Http404, e:
+            except http.Http404 as e:
                 logger.warning('Not Found: %s', request.path,
                             extra={
                                 'status_code': 404,

django/core/mail/__init__.py

@@ -30 +30 @@
     try:
         mod_name, klass_name = path.rsplit('.', 1)
         mod = import_module(mod_name)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured(('Error importing email backend module %s: "%s"'
                                     % (mod_name, e)))
     try:

django/core/mail/backends/filebased.py

@@ -25 +25 @@
         elif not os.path.exists(self.file_path):
             try:
                 os.makedirs(self.file_path)
-            except OSError, err:
+            except OSError as err:
                 raise ImproperlyConfigured('Could not create directory for saving email messages: %s (%s)' % (self.file_path, err))
         # Make sure that self.file_path is writable.
         if not os.access(self.file_path, os.W_OK):

django/core/management/base.py

@@ -215 +215 @@
                 from django.utils import translation
                 saved_lang = translation.get_language()
                 translation.activate('en-us')
-            except ImportError, e:
+            except ImportError as e:
                 # If settings should be available, but aren't,
                 # raise the error and quit.
                 if show_traceback:
@@ -241 +241 @@
                 self.stdout.write(output)
                 if self.output_transaction:
                     self.stdout.write('\n' + self.style.SQL_KEYWORD("COMMIT;") + '\n')
-        except CommandError, e:
+        except CommandError as e:
             if show_traceback:
                 traceback.print_exc()
             else:
@@ -297 +297 @@
             raise CommandError('Enter at least one appname.')
         try:
             app_list = [models.get_app(app_label) for app_label in app_labels]
-        except (ImproperlyConfigured, ImportError), e:
+        except (ImproperlyConfigured, ImportError) as e:
             raise CommandError("%s. Are you sure your INSTALLED_APPS setting is correct?" % e)
         output = []
         for app in app_list:

django/core/management/commands/createcachetable.py

@@ -54 +54 @@
         curs = connection.cursor()
         try:
             curs.execute("\n".join(full_statement))
-        except DatabaseError, e:
+        except DatabaseError as e:
             self.stderr.write(
                 self.style.ERROR("Cache table '%s' could not be created.\nThe error was: %s.\n" %
                     (tablename, e)))

django/core/management/commands/dumpdata.py

@@ -111 +111 @@
         try:
             return serializers.serialize(format, objects, indent=indent,
                         use_natural_keys=use_natural_keys)
-        except Exception, e:
+        except Exception as e:
             if show_traceback:
                 raise
             raise CommandError("Unable to serialize database: %s" % e)

django/core/management/commands/flush.py

@@ -55 +55 @@
                 cursor = connection.cursor()
                 for sql in sql_list:
                     cursor.execute(sql)
-            except Exception, e:
+            except Exception as e:
                 transaction.rollback_unless_managed(using=db)
                 raise CommandError("""Database %s couldn't be flushed. Possible reasons:
   * The database isn't running or isn't configured correctly.

django/core/management/commands/loaddata.py

@@ -194 +194 @@
                                             models.add(obj.object.__class__)
                                             try:
                                                 obj.save(using=using)
-                                            except (DatabaseError, IntegrityError), e:
+                                            except (DatabaseError, IntegrityError) as e:
                                                 msg = "Could not load %(app_label)s.%(object_name)s(pk=%(pk)s): %(error_msg)s" % {
                                                         'app_label': obj.object._meta.app_label,
                                                         'object_name': obj.object._meta.object_name,

django/core/management/commands/reset.py

@@ -49 +49 @@
                 cursor = connection.cursor()
                 for sql in sql_list:
                     cursor.execute(sql)
-            except Exception, e:
+            except Exception as e:
                 transaction.rollback_unless_managed()
                 raise CommandError("""Error: %s couldn't be reset. Possible reasons:
   * The database isn't running or isn't configured correctly.

django/core/management/commands/runserver.py

@@ -109 +109 @@
             handler = self.get_handler(*args, **options)
             run(self.addr, int(self.port), handler,
                 ipv6=self.use_ipv6, threading=threading)
-        except WSGIServerException, e:
+        except WSGIServerException as e:
             # Use helpful error messages instead of ugly tracebacks.
             ERRORS = {
                 13: "You don't have permission to access that port.",

django/core/management/commands/syncdb.py

@@ -38 +38 @@
         for app_name in settings.INSTALLED_APPS:
             try:
                 import_module('.management', app_name)
-            except ImportError, exc:
+            except ImportError as exc:
                 # This is slightly hackish. We want to ignore ImportErrors
                 # if the "management" module itself is missing -- but we don't
                 # want to ignore the exception if the management module exists
@@ -126 +126 @@
                         try:
                             for sql in custom_sql:
                                 cursor.execute(sql)
-                        except Exception, e:
+                        except Exception as e:
                             sys.stderr.write("Failed to install custom SQL for %s.%s model: %s\n" % \
                                                 (app_name, model._meta.object_name, e))
                             if show_traceback:
@@ -151 +151 @@
                         try:
                             for sql in index_sql:
                                 cursor.execute(sql)
-                        except Exception, e:
+                        except Exception as e:
                             sys.stderr.write("Failed to install index for %s.%s model: %s\n" % \
                                                 (app_name, model._meta.object_name, e))
                             transaction.rollback_unless_managed(using=db)

django/core/management/templates.py

@@ -82 +82 @@
             top_dir = path.join(os.getcwd(), name)
             try:
                 os.makedirs(top_dir)
-            except OSError, e:
+            except OSError as e:
                 if e.errno == errno.EEXIST:
                     message = "'%s' already exists" % top_dir
                 else:
@@ -232 +232 @@
         try:
             the_path, info = urllib.urlretrieve(url,
                                                 path.join(tempdir, filename))
-        except IOError, e:
+        except IOError as e:
             raise CommandError("couldn't download URL %s to %s: %s" %
                                (url, filename, e))
 
@@ -287 +287 @@
         try:
             archive.extract(filename, tempdir)
             return tempdir
-        except (archive.ArchiveException, IOError), e:
+        except (archive.ArchiveException, IOError) as e:
             raise CommandError("couldn't extract file %s to %s: %s" %
                                (filename, tempdir, e))
 

django/core/serializers/json.py

@@ -42 +42 @@
             yield obj
     except GeneratorExit:
         raise
-    except Exception, e:
+    except Exception as e:
         # Map to deserializer error
         raise DeserializationError(e)
 

django/core/serializers/pyyaml.py

@@ -57 +57 @@
             yield obj
     except GeneratorExit:
         raise
-    except Exception, e:
+    except Exception as e:
         # Map to deserializer error
         raise DeserializationError(e)

django/core/servers/basehttp.py

@@ -52 +52 @@
     module_name, attr = app_path.rsplit('.', 1)
     try:
         mod = import_module(module_name)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured(
             "WSGI application '%s' could not be loaded; "
             "could not import module '%s': %s" % (app_path, module_name, e))
     try:
         app = getattr(mod, attr)
-    except AttributeError, e:
+    except AttributeError as e:
         raise ImproperlyConfigured(
             "WSGI application '%s' could not be loaded; "
             "can't find '%s' in module '%s': %s"
@@ -122 +122 @@
         """Override server_bind to store the server name."""
         try:
             super(WSGIServer, self).server_bind()
-        except Exception, e:
+        except Exception as e:
             raise WSGIServerException(e)
         self.setup_environ()
 

django/core/servers/fastcgi.py

@@ -102 +102 @@
 
     try:
         import flup
-    except ImportError, e:
+    except ImportError as e:
         print >> sys.stderr, "ERROR: %s" % e
         print >> sys.stderr, "  Unable to load the flup package.  In order to run django"
         print >> sys.stderr, "  as a FastCGI application, you will need to get flup from"

django/core/signing.py

@@ -76 +76 @@
     module, attr = modpath.rsplit('.', 1)
     try:
         mod = import_module(module)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured(
             'Error importing cookie signer %s: "%s"' % (modpath, e))
     try:
         Signer = getattr(mod, attr)
-    except AttributeError, e:
+    except AttributeError as e:
         raise ImproperlyConfigured(
             'Error importing cookie signer %s: "%s"' % (modpath, e))
     return Signer('django.http.cookies' + settings.SECRET_KEY, salt=salt)

django/core/urlresolvers.py

@@ -298 +298 @@
             for pattern in self.url_patterns:
                 try:
                     sub_match = pattern.resolve(new_path)
-                except Resolver404, e:
+                except Resolver404 as e:
                     sub_tried = e.args[0].get('tried')
                     if sub_tried is not None:
                         tried.extend([[pattern] + t for t in sub_tried])
@@ -358 +358 @@
             raise ValueError("Don't mix *args and **kwargs in call to reverse()!")
         try:
             lookup_view = get_callable(lookup_view, True)
-        except (ImportError, AttributeError), e:
+        except (ImportError, AttributeError) as e:
             raise NoReverseMatch("Error importing '%s': %s." % (lookup_view, e))
         possibilities = self.reverse_dict.getlist(lookup_view)
         prefix_norm, prefix_args = normalize(_prefix)[0]
@@ -462 +462 @@
                 extra, resolver = resolver.namespace_dict[ns]
                 resolved_path.append(ns)
                 ns_pattern = ns_pattern + extra
-            except KeyError, key:
+            except KeyError as key:
                 if resolved_path:
                     raise NoReverseMatch(
                         "%s is not a registered namespace inside '%s'" %

django/core/validators.py

@@ -61 +61 @@
     def __call__(self, value):
         try:
             super(URLValidator, self).__call__(value)
-        except ValidationError, e:
+        except ValidationError as e:
             # Trivial case failed. Try for possible IDN domain
             if value:
                 value = smart_unicode(value)
@@ -144 +144 @@
     def __call__(self, value):
         try:
             super(EmailValidator, self).__call__(value)
-        except ValidationError, e:
+        except ValidationError as e:
             # Trivial case failed. Try for possible IDN domain-part
             if value and u'@' in value:
                 parts = value.split(u'@')

django/db/backends/creation.py

@@ -323 +323 @@
         try:
             cursor.execute(
                 "CREATE DATABASE %s %s" % (qn(test_database_name), suffix))
-        except Exception, e:
+        except Exception as e:
             sys.stderr.write(
                 "Got an error creating the test database: %s\n" % e)
             if not autoclobber:
@@ -340 +340 @@
                     cursor.execute(
                         "CREATE DATABASE %s %s" % (qn(test_database_name),
                                                    suffix))
-                except Exception, e:
+                except Exception as e:
                     sys.stderr.write(
                         "Got an error recreating the test database: %s\n" % e)
                     sys.exit(2)

django/db/backends/mysql/base.py

@@ -11 +11 @@
 
 try:
     import MySQLdb as Database
-except ImportError, e:
+except ImportError as e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading MySQLdb module: %s" % e)
 
@@ -112 +112 @@
     def execute(self, query, args=None):
         try:
             return self.cursor.execute(query, args)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.OperationalError, e:
+        except Database.OperationalError as e:
             # Map some error codes to IntegrityError, since they seem to be
             # misclassified and Django would prefer the more logical place.
             if e[0] in self.codes_for_integrityerror:
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def executemany(self, query, args):
         try:
             return self.cursor.executemany(query, args)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.OperationalError, e:
+        except Database.OperationalError as e:
             # Map some error codes to IntegrityError, since they seem to be
             # misclassified and Django would prefer the more logical place.
             if e[0] in self.codes_for_integrityerror:
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def __getattr__(self, attr):

django/db/backends/oracle/base.py

@@ -18 +18 @@
     if platform.system().upper().startswith('CYGWIN'):
         try:
             import ctypes
-        except ImportError, e:
+        except ImportError as e:
             from django.core.exceptions import ImproperlyConfigured
             raise ImproperlyConfigured("Error loading ctypes: %s; "
                                        "the Oracle backend requires ctypes to "
@@ -41 +41 @@
 
 try:
     import cx_Oracle as Database
-except ImportError, e:
+except ImportError as e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading cx_Oracle module: %s" % e)
 
@@ -532 +532 @@
         if self.connection is not None:
             try:
                 return self.connection.commit()
-            except Database.IntegrityError, e:
+            except Database.IntegrityError as e:
                 # In case cx_Oracle implements (now or in a future version)
                 # raising this specific exception
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-            except Database.DatabaseError, e:
+            except Database.DatabaseError as e:
                 # cx_Oracle 5.0.4 raises a cx_Oracle.DatabaseError exception
                 # with the following attributes and values:
                 #  code = 2091
@@ -673 +673 @@
         self._guess_input_sizes([params])
         try:
             return self.cursor.execute(query, self._param_generator(params))
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             # cx_Oracle <= 4.4.0 wrongly raises a DatabaseError for ORA-01400.
             if hasattr(e.args[0], 'code') and e.args[0].code == 1400 and not isinstance(e, IntegrityError):
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
@@ -702 +702 @@
         try:
             return self.cursor.executemany(query,
                                 [self._param_generator(p) for p in formatted])
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             # cx_Oracle <= 4.4.0 wrongly raises a DatabaseError for ORA-01400.
             if hasattr(e.args[0], 'code') and e.args[0].code == 1400 and not isinstance(e, IntegrityError):
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]

django/db/backends/oracle/creation.py

@@ -62 +62 @@
         if self._test_database_create():
             try:
                 self._execute_test_db_creation(cursor, parameters, verbosity)
-            except Exception, e:
+            except Exception as e:
                 sys.stderr.write("Got an error creating the test database: %s\n" % e)
                 if not autoclobber:
                     confirm = raw_input("It appears the test database, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_NAME)
@@ -72 +72 @@
                             print "Destroying old test database '%s'..." % self.connection.alias
                         self._execute_test_db_destruction(cursor, parameters, verbosity)
                         self._execute_test_db_creation(cursor, parameters, verbosity)
-                    except Exception, e:
+                    except Exception as e:
                         sys.stderr.write("Got an error recreating the test database: %s\n" % e)
                         sys.exit(2)
                 else:
@@ -84 +84 @@
                 print "Creating test user..."
             try:
                 self._create_test_user(cursor, parameters, verbosity)
-            except Exception, e:
+            except Exception as e:
                 sys.stderr.write("Got an error creating the test user: %s\n" % e)
                 if not autoclobber:
                     confirm = raw_input("It appears the test user, %s, already exists. Type 'yes' to delete it, or 'no' to cancel: " % TEST_USER)
@@ -96 +96 @@
                         if verbosity >= 1:
                             print "Creating test user..."
                         self._create_test_user(cursor, parameters, verbosity)
-                    except Exception, e:
+                    except Exception as e:
                         sys.stderr.write("Got an error recreating the test user: %s\n" % e)
                         sys.exit(2)
                 else:
@@ -197 +197 @@
                 print stmt
             try:
                 cursor.execute(stmt)
-            except Exception, err:
+            except Exception as err:
                 sys.stderr.write("Failed (%s)\n" % (err))
                 raise
 

django/db/backends/postgresql_psycopg2/base.py

@@ -20 +20 @@
 try:
     import psycopg2 as Database
     import psycopg2.extensions
-except ImportError, e:
+except ImportError as e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e)
 
@@ -50 +50 @@
     def execute(self, query, args=None):
         try:
             return self.cursor.execute(query, args)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def executemany(self, query, args):
         try:
             return self.cursor.executemany(query, args)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def __getattr__(self, attr):
@@ -233 +233 @@
         if self.connection is not None:
             try:
                 return self.connection.commit()
-            except Database.IntegrityError, e:
+            except Database.IntegrityError as e:
                 raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]

django/db/backends/sqlite3/base.py

@@ -24 +24 @@
 try:
     try:
         from pysqlite2 import dbapi2 as Database
-    except ImportError, e1:
+    except ImportError as e1:
         from sqlite3 import dbapi2 as Database
-except ImportError, exc:
+except ImportError as exc:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading either pysqlite2 or sqlite3 modules (tried in that order): %s" % exc)
 
@@ -335 +335 @@
         query = self.convert_query(query)
         try:
             return Database.Cursor.execute(self, query, params)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def executemany(self, query, param_list):
         query = self.convert_query(query)
         try:
             return Database.Cursor.executemany(self, query, param_list)
-        except Database.IntegrityError, e:
+        except Database.IntegrityError as e:
             raise utils.IntegrityError, utils.IntegrityError(*tuple(e)), sys.exc_info()[2]
-        except Database.DatabaseError, e:
+        except Database.DatabaseError as e:
             raise utils.DatabaseError, utils.DatabaseError(*tuple(e)), sys.exc_info()[2]
 
     def convert_query(self, query):

django/db/backends/sqlite3/creation.py

@@ -57 +57 @@
                 if autoclobber or confirm == 'yes':
                   try:
                       os.remove(test_database_name)
-                  except Exception, e:
+                  except Exception as e:
                       sys.stderr.write("Got an error deleting the old test database: %s\n" % e)
                       sys.exit(2)
                 else:

django/db/models/base.py

@@ -801 +801 @@
 
         try:
             self.clean_fields(exclude=exclude)
-        except ValidationError, e:
+        except ValidationError as e:
             errors = e.update_error_dict(errors)
 
         # Form.clean() is run even if other validation fails, so do the
         # same with Model.clean() for consistency.
         try:
             self.clean()
-        except ValidationError, e:
+        except ValidationError as e:
             errors = e.update_error_dict(errors)
 
         # Run unique checks, but only for fields that passed validation.
@@ -817 +817 @@
                 exclude.append(name)
         try:
             self.validate_unique(exclude=exclude)
-        except ValidationError, e:
+        except ValidationError as e:
             errors = e.update_error_dict(errors)
 
         if errors:
@@ -842 +842 @@
                 continue
             try:
                 setattr(self, f.attname, f.clean(raw_value, self))
-            except ValidationError, e:
+            except ValidationError as e:
                 errors[f.name] = e.messages
 
         if errors:

django/db/models/fields/__init__.py

@@ -152 +152 @@
         for v in self.validators:
             try:
                 v(value)
-            except exceptions.ValidationError, e:
+            except exceptions.ValidationError as e:
                 if hasattr(e, 'code') and e.code in self.error_messages:
                     message = self.error_messages[e.code]
                     if e.params:

django/db/models/query.py

@@ -205 +205 @@
             qs = self._clone()
             qs.query.set_limits(k, k + 1)
             return list(qs)[0]
-        except self.model.DoesNotExist, e:
+        except self.model.DoesNotExist as e:
             raise IndexError(e.args)
 
     def __and__(self, other):
@@ -449 +449 @@
                 obj.save(force_insert=True, using=self.db)
                 transaction.savepoint_commit(sid, using=self.db)
                 return obj, True
-            except IntegrityError, e:
+            except IntegrityError as e:
                 transaction.savepoint_rollback(sid, using=self.db)
                 exc_info = sys.exc_info()
                 try:

django/db/models/sql/query.py

@@ -1120 +1120 @@
                     parts, opts, alias, True, allow_many, allow_explicit_fk=True,
                     can_reuse=can_reuse, negate=negate,
                     process_extras=process_extras)
-        except MultiJoin, e:
+        except MultiJoin as e:
             self.split_exclude(filter_expr, LOOKUP_SEP.join(parts[:e.level]),
                     can_reuse)
             return

django/db/utils.py

@@ -22 +22 @@
     # Look for a fully qualified database backend name
     try:
         return import_module('.base', backend_name)
-    except ImportError, e_user:
+    except ImportError as e_user:
         # The database backend wasn't found. Display a helpful error message
         # listing all possible (built-in) database backends.
         backend_dir = os.path.join(os.path.dirname(__file__), 'backends')
@@ -112 +112 @@
                 try:
                     module_name, klass_name = r.rsplit('.', 1)
                     module = import_module(module_name)
-                except ImportError, e:
+                except ImportError as e:
                     raise ImproperlyConfigured('Error importing database router %s: "%s"' % (klass_name, e))
                 try:
                     router_class = getattr(module, klass_name)

django/dispatch/dispatcher.py

@@ -205 +205 @@
         for receiver in self._live_receivers(_make_id(sender)):
             try:
                 response = receiver(signal=self, sender=sender, **named)
-            except Exception, err:
+            except Exception as err:
                 responses.append((receiver, err))
             else:
                 responses.append((receiver, response))

django/dispatch/saferef.py

@@ -119 +119 @@
                 try:
                     if callable( function ):
                         function( self )
-                except Exception, e:
+                except Exception as e:
                     try:
                         traceback.print_exc()
-                    except AttributeError, err:
+                    except AttributeError as err:
                         print '''Exception during saferef %s cleanup function %s: %s'''%(
                             self, function, e
                         )

django/forms/fields.py

@@ -132 +132 @@
         for v in self.validators:
             try:
                 v(value)
-            except ValidationError, e:
+            except ValidationError as e:
                 if hasattr(e, 'code') and e.code in self.error_messages:
                     message = self.error_messages[e.code]
                     if e.params:
@@ -898 +898 @@
                 raise ValidationError(self.error_messages['required'])
             try:
                 clean_data.append(field.clean(field_value))
-            except ValidationError, e:
+            except ValidationError as e:
                 # Collect all validation errors in a single list, which we'll
                 # raise at the end of clean(), rather than raising a single
                 # exception for the first error we encounter.

django/forms/forms.py

@@ -289 +289 @@
                 if hasattr(self, 'clean_%s' % name):
                     value = getattr(self, 'clean_%s' % name)()
                     self.cleaned_data[name] = value
-            except ValidationError, e:
+            except ValidationError as e:
                 self._errors[name] = self.error_class(e.messages)
                 if name in self.cleaned_data:
                     del self.cleaned_data[name]
@@ -297 +297 @@
     def _clean_form(self):
         try:
             self.cleaned_data = self.clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self._errors[NON_FIELD_ERRORS] = self.error_class(e.messages)
 
     def _post_clean(self):

django/forms/formsets.py

@@ -291 +291 @@
         # Give self.clean() a chance to do cross-form validation.
         try:
             self.clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self._non_form_errors = self.error_class(e.messages)
 
     def clean(self):

django/forms/models.py

@@ -324 +324 @@
         # Clean the model instance's fields.
         try:
             self.instance.clean_fields(exclude=exclude)
-        except ValidationError, e:
+        except ValidationError as e:
             self._update_errors(e.message_dict)
 
         # Call the model instance's clean method.
         try:
             self.instance.clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self._update_errors({NON_FIELD_ERRORS: e.messages})
 
         # Validate uniqueness if needed.
@@ -345 +345 @@
         exclude = self._get_validation_exclusions()
         try:
             self.instance.validate_unique(exclude=exclude)
-        except ValidationError, e:
+        except ValidationError as e:
             self._update_errors(e.message_dict)
 
     def save(self, commit=True):

django/forms/util.py

@@ -66 +66 @@
         current_timezone = timezone.get_current_timezone()
         try:
             return timezone.make_aware(value, current_timezone)
-        except Exception, e:
+        except Exception as e:
             raise ValidationError(_('%(datetime)s couldn\'t be interpreted '
                                     'in time zone %(current_timezone)s; it '
                                     'may be ambiguous or it may not exist.')

django/http/__init__.py

@@ -326 +326 @@
                 raise Exception("You cannot access body after reading from request's data stream")
             try:
                 self._body = self.read()
-            except IOError, e:
+            except IOError as e:
                 raise UnreadablePostError, e, sys.exc_traceback
             self._stream = StringIO(self._body)
         return self._body
@@ -592 +592 @@
             if isinstance(value, unicode):
                 try:
                     value = value.encode('us-ascii')
-                except UnicodeError, e:
+                except UnicodeError as e:
                     e.reason += ', HTTP response headers must be in US-ASCII format'
                     raise
             else:

django/http/multipartparser.py

@@ -196 +196 @@
                                 # We only special-case base64 transfer encoding
                                 try:
                                     chunk = str(chunk).decode('base64')
-                                except Exception, e:
+                                except Exception as e:
                                     # Since this is only a chunk, any error is an unfixable error.
                                     raise MultiPartParserError("Could not decode base64 data: %r" % e)
 
@@ -209 +209 @@
                                     # If the chunk received by the handler is None, then don't continue.
                                     break
 
-                    except SkipFile, e:
+                    except SkipFile as e:
                         # Just use up the rest of this file...
                         exhaust(field_stream)
                     else:
@@ -218 +218 @@
                 else:
                     # If this is neither a FIELD or a FILE, just exhaust the stream.
                     exhaust(stream)
-        except StopUpload, e:
+        except StopUpload as e:
             if not e.connection_reset:
                 exhaust(self._input_data)
         else:

django/template/base.py

@@ -265 +265 @@
                     self.invalid_block_tag(token, command, parse_until)
                 try:
                     compiled_result = compile_func(self, token)
-                except TemplateSyntaxError, e:
+                except TemplateSyntaxError as e:
                     if not self.compile_function_error(token, e):
                         raise
                 self.extend_nodelist(nodelist, compiled_result, token)
@@ -774 +774 @@
                             # GOTCHA: This will also catch any TypeError
                             # raised in the function itself.
                             current = settings.TEMPLATE_STRING_IF_INVALID  # invalid method call
-        except Exception, e:
+        except Exception as e:
             if getattr(e, 'silent_variable_failure', False):
                 current = settings.TEMPLATE_STRING_IF_INVALID
             else:
@@ -1237 +1237 @@
     """
     try:
         mod = import_module(taglib_module)
-    except ImportError, e:
+    except ImportError as e:
         # If the ImportError is because the taglib submodule does not exist,
         # that's not an error that should be raised. If the submodule exists
         # and raised an ImportError on the attempt to load it, that we want

django/template/context.py

@@ -147 +147 @@
             module, attr = path[:i], path[i+1:]
             try:
                 mod = import_module(module)
-            except ImportError, e:
+            except ImportError as e:
                 raise ImproperlyConfigured('Error importing request processor module %s: "%s"' % (module, e))
             try:
                 func = getattr(mod, attr)

django/template/debug.py

@@ -72 +72 @@
     def render_node(self, node, context):
         try:
             return node.render(context)
-        except Exception, e:
+        except Exception as e:
             if not hasattr(e, 'django_template_source'):
                 e.django_template_source = node.source
             raise
@@ -87 +87 @@
             output = force_unicode(output)
         except UnicodeDecodeError:
             return ''
-        except Exception, e:
+        except Exception as e:
             if not hasattr(e, 'django_template_source'):
                 e.django_template_source = self.source
             raise

django/template/defaultfilters.py

@@ -892 +892 @@
     """A wrapper around pprint.pprint -- for debugging, really."""
     try:
         return pformat(value)
-    except Exception, e:
+    except Exception as e:
         return u"Error in formatting: %s" % force_unicode(e, errors="replace")

django/template/defaulttags.py

@@ -183 +183 @@
                 for node in self.nodelist_loop:
                     try:
                         nodelist.append(node.render(context))
-                    except Exception, e:
+                    except Exception as e:
                         if not hasattr(e, 'django_template_source'):
                             e.django_template_source = node.source
                         raise
@@ -340 +340 @@
             try:
                 t = Template(output, name=filepath)
                 return t.render(context)
-            except TemplateSyntaxError, e:
+            except TemplateSyntaxError as e:
                 if settings.DEBUG:
                     return "[Included template had syntax error: %s]" % e
                 else:
@@ -409 +409 @@
         url = ''
         try:
             url = reverse(view_name, args=args, kwargs=kwargs, current_app=context.current_app)
-        except NoReverseMatch, e:
+        except NoReverseMatch as e:
             if settings.SETTINGS_MODULE:
                 project_name = settings.SETTINGS_MODULE.split('.')[0]
                 try:
@@ -1015 +1015 @@
         try:
             taglib = bits[-1]
             lib = get_library(taglib)
-        except InvalidTemplateLibrary, e:
+        except InvalidTemplateLibrary as e:
             raise TemplateSyntaxError("'%s' is not a valid tag library: %s" %
                                       (taglib, e))
         else:
@@ -1038 +1038 @@
             try:
                 lib = get_library(taglib)
                 parser.add_library(lib)
-            except InvalidTemplateLibrary, e:
+            except InvalidTemplateLibrary as e:
                 raise TemplateSyntaxError("'%s' is not a valid tag library: %s" %
                                           (taglib, e))
     return LoadNode()

django/template/loader.py

@@ -93 +93 @@
         module, attr = loader.rsplit('.', 1)
         try:
             mod = import_module(module)
-        except ImportError, e:
+        except ImportError as e:
             raise ImproperlyConfigured('Error importing template source loader %s: "%s"' % (loader, e))
         try:
             TemplateLoader = getattr(mod, attr)
-        except AttributeError, e:
+        except AttributeError as e:
             raise ImproperlyConfigured('Error importing template source loader %s: "%s"' % (loader, e))
 
         if hasattr(TemplateLoader, 'load_template_source'):
@@ -185 +185 @@
     for template_name in template_name_list:
         try:
             return get_template(template_name)
-        except TemplateDoesNotExist, e:
+        except TemplateDoesNotExist as e:
             if e.args[0] not in not_found:
                 not_found.append(e.args[0])
             continue

django/template/loaders/app_directories.py

@@ -19 +19 @@
 for app in settings.INSTALLED_APPS:
     try:
         mod = import_module(app)
-    except ImportError, e:
+    except ImportError as e:
         raise ImproperlyConfigured('ImportError %s: %s' % (app, e.args[0]))
     template_dir = os.path.join(os.path.dirname(mod.__file__), 'templates')
     if os.path.isdir(template_dir):

django/test/_doctest.py

@@ -1626 +1626 @@
          ...                                    {}, 'foo', 'foo.py', 0)
          >>> try:
          ...     runner.run(test)
-         ... except UnexpectedException, failure:
+         ... except UnexpectedException as failure:
          ...     pass
 
          >>> failure.test is test
@@ -1654 +1654 @@
 
          >>> try:
          ...    runner.run(test)
-         ... except DocTestFailure, failure:
+         ... except DocTestFailure as failure:
          ...    pass
 
        DocTestFailure objects provide access to the test:
@@ -2164 +2164 @@
              >>> case = DocTestCase(test)
              >>> try:
              ...     case.debug()
-             ... except UnexpectedException, failure:
+             ... except UnexpectedException as failure:
              ...     pass
 
            The UnexpectedException contains the test, the example, and
@@ -2193 +2193 @@
 
              >>> try:
              ...    case.debug()
-             ... except DocTestFailure, failure:
+             ... except DocTestFailure as failure:
              ...    pass
 
            DocTestFailure objects provide access to the test:

django/test/client.py

@@ -379 +379 @@
 
             try:
                 response = self.handler(environ)
-            except TemplateDoesNotExist, e:
+            except TemplateDoesNotExist as e:
                 # If the view raises an exception, Django will attempt to show
                 # the 500.html template. If that template is not available,
                 # we should ignore the error in favor of re-raising the

django/test/testcases.py

@@ -85 +85 @@
 def assert_and_parse_html(self, html, user_msg, msg):
     try:
         dom = parse_html(html)
-    except HTMLParseError, e:
+    except HTMLParseError as e:
         standardMsg = u'%s\n%s' % (msg, e.msg)
         self.fail(self._formatMessage(user_msg, standardMsg))
     return dom
@@ -1036 +1036 @@
                 try:
                     self.httpd = StoppableWSGIServer(
                         (self.host, port), QuietWSGIRequestHandler)
-                except WSGIServerException, e:
+                except WSGIServerException as e:
                     if sys.version_info < (2, 6):
                         error_code = e.args[0].args[0]
                     else:
@@ -1059 +1059 @@
             self.httpd.set_app(handler)
             self.is_ready.set()
             self.httpd.serve_forever()
-        except Exception, e:
+        except Exception as e:
             self.error = e
             self.is_ready.set()
 

django/utils/daemonize.py

@@ -9 +9 @@
         try:
             if os.fork() > 0:
                 sys.exit(0)     # kill off parent
-        except OSError, e:
+        except OSError as e:
             sys.stderr.write("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
             sys.exit(1)
         os.setsid()
@@ -20 +20 @@
         try:
             if os.fork() > 0:
                 os._exit(0)
-        except OSError, e:
+        except OSError as e:
             sys.stderr.write("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
             os._exit(1)
 

django/utils/decorators.py

@@ -89 +89 @@
                         return result
                 try:
                     response = view_func(request, *args, **kwargs)
-                except Exception, e:
+                except Exception as e:
                     if hasattr(middleware, 'process_exception'):
                         result = middleware.process_exception(request, e)
                         if result is not None:

django/utils/dictconfig.py

@@ -297 +297 @@
                                 level = handler_config.get('level', None)
                                 if level:
                                     handler.setLevel(_checkLevel(level))
-                            except StandardError, e:
+                            except StandardError as e:
                                 raise ValueError('Unable to configure handler '
                                                  '%r: %s' % (name, e))
                 loggers = config.get('loggers', EMPTY_DICT)
                 for name in loggers:
                     try:
                         self.configure_logger(name, loggers[name], True)
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure logger '
                                          '%r: %s' % (name, e))
                 root = config.get('root', None)
                 if root:
                     try:
                         self.configure_root(root, True)
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure root '
                                          'logger: %s' % e)
             else:
@@ -326 +326 @@
                     try:
                         formatters[name] = self.configure_formatter(
                                                             formatters[name])
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure '
                                          'formatter %r: %s' % (name, e))
                 # Next, do filters - they don't refer to anything else, either
@@ -334 +334 @@
                 for name in filters:
                     try:
                         filters[name] = self.configure_filter(filters[name])
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure '
                                          'filter %r: %s' % (name, e))
 
@@ -347 +347 @@
                         handler = self.configure_handler(handlers[name])
                         handler.name = name
                         handlers[name] = handler
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure handler '
                                          '%r: %s' % (name, e))
                 # Next, do loggers - they refer to handlers and filters
@@ -386 +386 @@
                         existing.remove(name)
                     try:
                         self.configure_logger(name, loggers[name])
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure logger '
                                          '%r: %s' % (name, e))
 
@@ -409 +409 @@
                 if root:
                     try:
                         self.configure_root(root)
-                    except StandardError, e:
+                    except StandardError as e:
                         raise ValueError('Unable to configure root '
                                          'logger: %s' % e)
         finally:
@@ -421 +421 @@
             factory = config['()'] # for use in exception handler
             try:
                 result = self.configure_custom(config)
-            except TypeError, te:
+            except TypeError as te:
                 if "'format'" not in str(te):
                     raise
                 #Name of parameter changed from fmt to format.
@@ -451 +451 @@
         for f in filters:
             try:
                 filterer.addFilter(self.config['filters'][f])
-            except StandardError, e:
+            except StandardError as e:
                 raise ValueError('Unable to add filter %r: %s' % (f, e))
 
     def configure_handler(self, config):
@@ -460 +460 @@
         if formatter:
             try:
                 formatter = self.config['formatters'][formatter]
-            except StandardError, e:
+            except StandardError as e:
                 raise ValueError('Unable to set formatter '
                                  '%r: %s' % (formatter, e))
         level = config.pop('level', None)
@@ -477 +477 @@
                 'target' in config:
                 try:
                     config['target'] = self.config['handlers'][config['target']]
-                except StandardError, e:
+                except StandardError as e:
                     raise ValueError('Unable to set target handler '
                                      '%r: %s' % (config['target'], e))
             elif issubclass(klass, logging.handlers.SMTPHandler) and\
@@ -490 +490 @@
         kwargs = dict([(k, config[k]) for k in config if valid_ident(k)])
         try:
             result = factory(**kwargs)
-        except TypeError, te:
+        except TypeError as te:
             if "'stream'" not in str(te):
                 raise
             #The argument name changed from strm to stream
@@ -512 +512 @@
         for h in handlers:
             try:
                 logger.addHandler(self.config['handlers'][h])
-            except StandardError, e:
+            except StandardError as e:
                 raise ValueError('Unable to add handler %r: %s' % (h, e))
 
     def common_logger_config(self, logger, config, incremental=False):

django/utils/encoding.py

@@ -88 +88 @@
             # errors), so that if s is a SafeString, it ends up being a
             # SafeUnicode at the end.
             s = s.decode(encoding, errors)
-    except UnicodeDecodeError, e:
+    except UnicodeDecodeError as e:
         if not isinstance(s, Exception):
             raise DjangoUnicodeDecodeError(s, *e.args)
         else:

django/utils/simplejson/tool.py

@@ -25 +25 @@
         raise SystemExit("%s [infile [outfile]]" % (sys.argv[0],))
     try:
         obj = simplejson.load(infile)
-    except ValueError, e:
+    except ValueError as e:
         raise SystemExit(e)
     simplejson.dump(obj, outfile, sort_keys=True, indent=4)
     outfile.write('\n')

django/utils/unittest/case.py

@@ -324 +324 @@
             success = False
             try:
                 self.setUp()
-            except SkipTest, e:
+            except SkipTest as e:
                 self._addSkip(result, str(e))
             except Exception:
                 result.addError(self, sys.exc_info())
@@ -333 +333 @@
                     testMethod()
                 except self.failureException:
                     result.addFailure(self, sys.exc_info())
-                except _ExpectedFailure, e:
+                except _ExpectedFailure as e:
                     addExpectedFailure = getattr(result, 'addExpectedFailure', None)
                     if addExpectedFailure is not None:
                         addExpectedFailure(self, e.exc_info)
@@ -349 +349 @@
                         warnings.warn("Use of a TestResult without an addUnexpectedSuccess method is deprecated",
                                       DeprecationWarning)
                         result.addFailure(self, sys.exc_info())
-                except SkipTest, e:
+                except SkipTest as e:
                     self._addSkip(result, str(e))
                 except Exception:
                     result.addError(self, sys.exc_info())
@@ -770 +770 @@
         """
         try:
             difference1 = set1.difference(set2)
-        except TypeError, e:
+        except TypeError as e:
             self.fail('invalid type when attempting set difference: %s' % e)
-        except AttributeError, e:
+        except AttributeError as e:
             self.fail('first argument does not support set difference: %s' % e)
 
         try:
             difference2 = set2.difference(set1)
-        except TypeError, e:
+        except TypeError as e:
             self.fail('invalid type when attempting set difference: %s' % e)
-        except AttributeError, e:
+        except AttributeError as e:
             self.fail('second argument does not support set difference: %s' % e)
 
         if not (difference1 or difference2):
@@ -980 +980 @@
             return _AssertRaisesContext(expected_exception, self, expected_regexp)
         try:
             callable_obj(*args, **kwargs)
-        except expected_exception, exc_value:
+        except expected_exception as exc_value:
             if isinstance(expected_regexp, basestring):
                 expected_regexp = re.compile(expected_regexp)
             if not expected_regexp.search(str(exc_value)):

django/utils/unittest/loader.py

@@ -89 +89 @@
         if use_load_tests and load_tests is not None:
             try:
                 return load_tests(self, tests, None)
-            except Exception, e:
+            except Exception as e:
                 return _make_failed_load_tests(module.__name__, e,
                                                self.suiteClass)
         return tests
@@ -295 +295 @@
                 else:
                     try:
                         yield load_tests(self, tests, pattern)
-                    except Exception, e:
+                    except Exception as e:
                         yield _make_failed_load_tests(package.__name__, e,
                                                       self.suiteClass)
 

django/utils/unittest/main.py

@@ -150 +150 @@
             else:
                 self.testNames = (self.defaultTest,)
             self.createTests()
-        except getopt.error, msg:
+        except getopt.error as msg:
             self.usageExit(msg)
 
     def createTests(self):

django/utils/unittest/suite.py

@@ -138 +138 @@
         if setUpClass is not None:
             try:
                 setUpClass()
-            except Exception, e:
+            except Exception as e:
                 if isinstance(result, _DebugResult):
                     raise
                 currentClass._classSetupFailed = True
@@ -172 +172 @@
         if setUpModule is not None:
             try:
                 setUpModule()
-            except Exception, e:
+            except Exception as e:
                 if isinstance(result, _DebugResult):
                     raise
                 result._moduleSetUpFailed = True
@@ -203 +203 @@
         if tearDownModule is not None:
             try:
                 tearDownModule()
-            except Exception, e:
+            except Exception as e:
                 if isinstance(result, _DebugResult):
                     raise
                 errorName = 'tearDownModule (%s)' % previousModule
@@ -225 +225 @@
         if tearDownClass is not None:
             try:
                 tearDownClass()
-            except Exception, e:
+            except Exception as e:
                 if isinstance(result, _DebugResult):
                     raise
                 className = util.strclass(previousClass)

django/views/debug.py

@@ -77 +77 @@
         modname, classname = modpath.rsplit('.', 1)
         try:
             mod = import_module(modname)
-        except ImportError, e:
+        except ImportError as e:
             raise ImproperlyConfigured(
             'Error importing default exception reporter filter %s: "%s"' % (modpath, e))
         try:

extras/csrf_migration_helper.py

@@ -173 +173 @@
             fd = open(self.absolute_filename)
             try:
                 content = fd.read().decode(TEMPLATE_ENCODING)
-            except UnicodeDecodeError, e:
+            except UnicodeDecodeError as e:
                 message = '%s in %s' % (
                     e[4], self.absolute_filename.encode('UTF-8', 'ignore'))
                 raise UnicodeDecodeError(*(e.args[:4] + (message,)))

tests/modeltests/basic/tests.py

@@ -374 +374 @@
         try:
             Article.objects.all()[0:1] & Article.objects.all()[4:5]
             self.fail('Should raise an AssertionError')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertEqual(str(e), "Cannot combine queries once a slice has been taken.")
-        except Exception, e:
+        except Exception as e:
             self.fail('Should raise an AssertionError, not %s' % e)
 
         # Negative slices are not supported, due to database constraints.
@@ -384 +384 @@
         try:
             Article.objects.all()[-1]
             self.fail('Should raise an AssertionError')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertEqual(str(e), "Negative indexing is not supported.")
-        except Exception, e:
+        except Exception as e:
             self.fail('Should raise an AssertionError, not %s' % e)
 
         error = None
         try:
             Article.objects.all()[0:-5]
-        except Exception, e:
+        except Exception as e:
             error = e
         self.assertTrue(isinstance(error, AssertionError))
         self.assertEqual(str(error), "Negative indexing is not supported.")

tests/modeltests/get_or_create/tests.py

@@ -60 +60 @@
         # the actual traceback. Refs #16340.
         try:
             ManualPrimaryKeyTest.objects.get_or_create(id=1, data="Different")
-        except IntegrityError, e:
+        except IntegrityError as e:
             formatted_traceback = traceback.format_exc()
             self.assertIn('obj.save', formatted_traceback)
 

tests/modeltests/invalid_models/tests.py

@@ -35 +35 @@
 
         try:
             module = load_app("modeltests.invalid_models.invalid_models")
-        except Exception, e:
+        except Exception as e:
             self.fail('Unable to load invalid model module')
 
         count = get_validation_errors(self.stdout, module)

tests/modeltests/lookup/tests.py

@@ -468 +468 @@
         try:
             Article.objects.filter(pub_date_year='2005').count()
             self.fail('FieldError not raised')
-        except FieldError, ex:
+        except FieldError as ex:
             self.assertEqual(str(ex), "Cannot resolve keyword 'pub_date_year' "
                              "into field. Choices are: author, headline, id, pub_date, tag")
         try:
             Article.objects.filter(headline__starts='Article')
             self.fail('FieldError not raised')
-        except FieldError, ex:
+        except FieldError as ex:
             self.assertEqual(str(ex), "Join on field 'headline' not permitted. "
                              "Did you misspell 'starts' for the lookup type?")
 

tests/modeltests/select_for_update/tests.py

@@ -169 +169 @@
             people[0].name = 'Fred'
             people[0].save()
             transaction.commit()
-        except DatabaseError, e:
+        except DatabaseError as e:
             status.append(e)
-        except Exception, e:
+        except Exception as e:
             raise
         finally:
             # This method is run in a separate thread. It uses its own
@@ -246 +246 @@
                         )
                     )
                 )
-            except DatabaseError, e:
+            except DatabaseError as e:
                 status.append(e)
             finally:
                 # This method is run in a separate thread. It uses its own

tests/modeltests/validation/models.py

@@ -100 +100 @@
     class MultipleAutoFields(models.Model):
         auto1 = models.AutoField(primary_key=True)
         auto2 = models.AutoField(primary_key=True)
-except AssertionError, assertion_error:
+except AssertionError as assertion_error:
     pass # Fail silently
 assert str(assertion_error) == u"A model can't have more than one AutoField."
+ No newline at end of file

tests/modeltests/validation/test_error_messages.py

@@ -10 +10 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [u"'foo' value must be an integer."])
         # primary_key must be True. Refs #12467.
         self.assertRaises(AssertionError, models.AutoField, 'primary_key', False)
         try:
             models.AutoField(primary_key=False)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertEqual(str(e), "AutoFields must have primary_key=True.")
 
     def test_integer_field_raises_error_message(self):
@@ -24 +24 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [u"'foo' value must be an integer."])
 
     def test_boolean_field_raises_error_message(self):
@@ -32 +32 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages,
                         [u"'foo' value must be either True or False."])
 
@@ -41 +41 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [u"'foo' value must be a float."])
 
     def test_decimal_field_raises_error_message(self):
@@ -49 +49 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages,
                         [u"'foo' value must be a decimal number."])
 
@@ -58 +58 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages,
                         [u"'foo' value must be either None, True or False."])
 
@@ -67 +67 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'foo' value has an invalid date format. "
                 u"It must be in YYYY-MM-DD format."])
@@ -75 +75 @@
         self.assertRaises(ValidationError, f.clean, 'aaaa-10-10', None)
         try:
             f.clean('aaaa-10-10', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'aaaa-10-10' value has an invalid date format. "
                 u"It must be in YYYY-MM-DD format."])
@@ -83 +83 @@
         self.assertRaises(ValidationError, f.clean, '2011-13-10', None)
         try:
             f.clean('2011-13-10', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'2011-13-10' value has the correct format (YYYY-MM-DD) "
                 u"but it is an invalid date."])
@@ -91 +91 @@
         self.assertRaises(ValidationError, f.clean, '2011-10-32', None)
         try:
             f.clean('2011-10-32', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'2011-10-32' value has the correct format (YYYY-MM-DD) "
                 u"but it is an invalid date."])
@@ -102 +102 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'foo' value has an invalid format. It must be "
                 u"in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."])
@@ -111 +111 @@
         self.assertRaises(ValidationError, f.clean, '2011-10-32', None)
         try:
             f.clean('2011-10-32', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'2011-10-32' value has the correct format "
                 u"(YYYY-MM-DD) but it is an invalid date."])
@@ -120 +120 @@
         self.assertRaises(ValidationError, f.clean, '2011-10-32 10:10', None)
         try:
             f.clean('2011-10-32 10:10', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'2011-10-32 10:10' value has the correct format "
                 u"(YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]) "
@@ -132 +132 @@
         self.assertRaises(ValidationError, f.clean, 'foo', None)
         try:
             f.clean('foo', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'foo' value has an invalid format. It must be in "
                 u"HH:MM[:ss[.uuuuuu]] format."])
@@ -140 +140 @@
         self.assertRaises(ValidationError, f.clean, '25:50', None)
         try:
             f.clean('25:50', None)
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, [
                 u"'25:50' value has the correct format "
                 u"(HH:MM[:ss[.uuuuuu]]) but it is an invalid time."])

tests/modeltests/validation/test_unique.py

@@ -115 +115 @@
         p = FlexibleDatePost(title="Django 1.0 is released")
         try:
             p.full_clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self.fail("unique_for_date checks shouldn't trigger when the associated DateField is None.")
 
         p = FlexibleDatePost(slug="Django 1.0")
         try:
             p.full_clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self.fail("unique_for_year checks shouldn't trigger when the associated DateField is None.")
 
         p = FlexibleDatePost(subtitle="Finally")
         try:
             p.full_clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self.fail("unique_for_month checks shouldn't trigger when the associated DateField is None.")
 
     def test_unique_errors(self):

tests/regressiontests/app_loading/tests.py

@@ -61 +61 @@
         self.assertRaises(ImportError, load_app, 'broken_app')
         try:
             load_app('broken_app')
-        except ImportError, e:
+        except ImportError as e:
             # Make sure the message is indicating the actual
             # problem in the broken app.
             self.assertTrue("modelz" in e.args[0])

tests/regressiontests/backends/tests.py

@@ -544 +544 @@
                 connections['default'] = main_thread_connection
                 try:
                     models.Person.objects.get(first_name="John", last_name="Doe")
-                except DatabaseError, e:
+                except DatabaseError as e:
                     exceptions.append(e)
             t = threading.Thread(target=runner, args=[connections['default']])
             t.start()
@@ -582 +582 @@
             def runner2(other_thread_connection):
                 try:
                     other_thread_connection.close()
-                except DatabaseError, e:
+                except DatabaseError as e:
                     exceptions.add(e)
             t2 = threading.Thread(target=runner2, args=[connections['default']])
             t2.start()
@@ -599 +599 @@
             def runner2(other_thread_connection):
                 try:
                     other_thread_connection.close()
-                except DatabaseError, e:
+                except DatabaseError as e:
                     exceptions.add(e)
             # Enable thread sharing
             connections['default'].allow_thread_sharing = True

tests/regressiontests/file_uploads/tests.py

@@ -303 +303 @@
         # it raises when there is an attempt to read more than the available bytes:
         try:
             client.FakePayload('a').read(2)
-        except Exception, reference_error:
+        except Exception as reference_error:
             pass
 
         # install the custom handler that tries to access request.POST
@@ -311 +311 @@
 
         try:
             response = self.client.post('/file_uploads/upload_errors/', post_data)
-        except reference_error.__class__, err:
+        except reference_error.__class__ as err:
             self.failIf(
                 str(err) == str(reference_error),
                 "Caught a repeated exception that'll cause an infinite loop in file uploads."
             )
-        except Exception, err:
+        except Exception as err:
             # CustomUploadError is the error that should have been raised
             self.assertEqual(err.__class__, uploadhandler.CustomUploadError)
 
@@ -373 +373 @@
         os.chmod(temp_storage.location, 0500)
         try:
             self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x'))
-        except OSError, err:
+        except OSError as err:
             self.assertEqual(err.errno, errno.EACCES)
-        except Exception, err:
+        except Exception as err:
             self.fail("OSError [Errno %s] not raised." % errno.EACCES)
 
     def test_not_a_directory(self):
@@ -385 +385 @@
         fd.close()
         try:
             self.obj.testfile.save('foo.txt', SimpleUploadedFile('foo.txt', 'x'))
-        except IOError, err:
+        except IOError as err:
             # The test needs to be done on a specific string as IOError
             # is raised even without the patch (just not early enough)
             self.assertEqual(err.args[0],

tests/regressiontests/forms/tests/error_messages.py

@@ -15 +15 @@
         try:
             the_callable(*args, **kwargs)
             self.fail("Testing the 'clean' method on %s failed to raise a ValidationError.")
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(e.messages, expected)
 
 class FormsErrorMessagesTestCase(TestCase, AssertFormErrorsMixin):

tests/regressiontests/forms/tests/fields.py

@@ -660 +660 @@
         self.assertRaises(ValidationError, f.clean, 'http://qa-dev.w3.org/link-testsuite/http.php?code=405') # Method not allowed
         try:
             f.clean('http://www.broken.djangoproject.com') # bad domain
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual("[u'This URL appears to be a broken link.']", str(e))
         self.assertRaises(ValidationError, f.clean, 'http://qa-dev.w3.org/link-testsuite/http.php?code=400') # good domain, bad page
         try:
             f.clean('http://google.com/we-love-microsoft.html') # good domain, bad page
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual("[u'This URL appears to be a broken link.']", str(e))
 
     @verify_exists_urls(('http://www.google.com/',))
@@ -719 +719 @@
         # Valid but non-existent IDN
         try:
             f.clean(u'http://broken.עברית.idn.icann.org/')
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual("[u'This URL appears to be a broken link.']", str(e))
 
     @verify_exists_urls((u'http://xn--hxargifdar.idn.icann.org/%CE%91%CF%81%CF%87%CE%B9%CE%BA%CE%AE_%CF%83%CE%B5%CE%BB%CE%AF%CE%B4%CE%B1',))

tests/regressiontests/forms/tests/validators.py

@@ -12 +12 @@
         self.assertRaises(ValidationError, field.clean, 'not int nor mail')
         try:
             field.clean('not int nor mail')
-        except ValidationError, e:
+        except ValidationError as e:
             self.assertEqual(2, len(e.messages))

tests/regressiontests/middleware/tests.py

@@ -88 +88 @@
             request)
         try:
             CommonMiddleware().process_request(request)
-        except RuntimeError, e:
+        except RuntimeError as e:
             self.assertTrue('end in a slash' in str(e))
         settings.DEBUG = False
 
@@ -202 +202 @@
           request)
       try:
           CommonMiddleware().process_request(request)
-      except RuntimeError, e:
+      except RuntimeError as e:
           self.assertTrue('end in a slash' in str(e))
       settings.DEBUG = False
 

tests/regressiontests/middleware_exceptions/tests.py

@@ -118 +118 @@
     def assert_exceptions_handled(self, url, errors, extra_error=None):
         try:
             response = self.client.get(url)
-        except TestException, e:
+        except TestException as e:
             # Test client intentionally re-raises any exceptions being raised
             # during request handling. Hence actual testing that exception was
             # properly handled is done by relying on got_request_exception
             # signal being sent.
             pass
-        except Exception, e:
+        except Exception as e:
             if type(extra_error) != type(e):
                 self.fail("Unexpected exception: %s" % e)
         self.assertEqual(len(self.exceptions), len(errors))

tests/regressiontests/model_fields/tests.py

@@ -44 +44 @@
         nullboolean = NullBooleanModel(nbfield=None)
         try:
             nullboolean.full_clean()
-        except ValidationError, e:
+        except ValidationError as e:
             self.fail("NullBooleanField failed validation with value of None: %s" % e.messages)
 
     def test_field_repr(self):

tests/regressiontests/model_forms_regress/tests.py

@@ -333 +333 @@
                 class Meta:
                     model = Person
                     fields = ('name', 'no-field')
-        except FieldError, e:
+        except FieldError as e:
             # Make sure the exception contains some reference to the
             # field responsible for the problem.
             self.assertTrue('no-field' in e.args[0])

tests/regressiontests/servers/tests.py

@@ -164 +164 @@
         """
         try:
             self.urlopen('/')
-        except urllib2.HTTPError, err:
+        except urllib2.HTTPError as err:
             self.assertEquals(err.code, 404, 'Expected 404 response')
         else:
             self.fail('Expected 404 response')

tests/regressiontests/settings_tests/tests.py

@@ -65 +65 @@
         """
         try:
             super(ClassDecoratedTestCase, self).test_max_recursion_error()
-        except RuntimeError, e:
+        except RuntimeError as e:
             self.fail()
 
 ClassDecoratedTestCase = override_settings(TEST='override')(ClassDecoratedTestCase)

tests/regressiontests/templates/tests.py

@@ -42 +42 @@
 
 try:
     from .loaders import RenderToStringTest, EggLoaderTest
-except ImportError, e:
+except ImportError as e:
     if "pkg_resources" in e.message:
         pass # If setuptools isn't installed, that's fine. Just move on.
     else:
@@ -280 +280 @@
             try:
                 tmpl = loader.select_template([load_name])
                 r = tmpl.render(template.Context({}))
-            except template.TemplateDoesNotExist, e:
+            except template.TemplateDoesNotExist as e:
                 settings.TEMPLATE_DEBUG = old_td
                 self.assertEqual(e.args[0], 'missing.html')
             self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
@@ -313 +313 @@
             r = None
             try:
                 r = tmpl.render(template.Context({}))
-            except template.TemplateDoesNotExist, e:
+            except template.TemplateDoesNotExist as e:
                 settings.TEMPLATE_DEBUG = old_td
                 self.assertEqual(e.args[0], 'missing.html')
             self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
@@ -340 +340 @@
             r = None
             try:
                 r = tmpl.render(template.Context({}))
-            except template.TemplateDoesNotExist, e:
+            except template.TemplateDoesNotExist as e:
                 self.assertEqual(e.args[0], 'missing.html')
             self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
 
@@ -349 +349 @@
             tmpl = loader.get_template(load_name)
             try:
                 tmpl.render(template.Context({}))
-            except template.TemplateDoesNotExist, e:
+            except template.TemplateDoesNotExist as e:
                 self.assertEqual(e.args[0], 'missing.html')
             self.assertEqual(r, None, 'Template rendering unexpectedly succeeded, produced: ->%r<-' % r)
         finally:
@@ -393 +393 @@
         from django.template import Template, TemplateSyntaxError
         try:
             t = Template("{% if 1 %}lala{% endblock %}{% endif %}")
-        except TemplateSyntaxError, e:
+        except TemplateSyntaxError as e:
             self.assertEqual(e.args[0], "Invalid block tag: 'endblock', expected 'elif', 'else' or 'endif'")
 
     def test_templates(self):
@@ -1714 +1714 @@
         self.assertRaises(template.TemplateSyntaxError, template.Template, ttext)
         try:
             template.Template(ttext)
-        except template.TemplateSyntaxError, e:
+        except template.TemplateSyntaxError as e:
             self.assertTrue('ImportError' in e.args[0])
             self.assertTrue('Xtemplate' in e.args[0])
 
@@ -1726 +1726 @@
         self.assertRaises(template.TemplateSyntaxError, template.Template, ttext)
         try:
             template.Template(ttext)
-        except template.TemplateSyntaxError, e:
+        except template.TemplateSyntaxError as e:
             self.assertTrue('ImportError' in e.args[0])
             self.assertTrue('Xtemplate' in e.args[0])
 

tests/regressiontests/test_client_regress/models.py

@@ -39 +39 @@
 
         try:
             self.assertContains(response, 'text', status_code=999)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Couldn't retrieve content: Response code was 200 (expected 999)", str(e))
         try:
             self.assertContains(response, 'text', status_code=999, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Couldn't retrieve content: Response code was 200 (expected 999)", str(e))
 
         try:
             self.assertNotContains(response, 'text', status_code=999)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Couldn't retrieve content: Response code was 200 (expected 999)", str(e))
         try:
             self.assertNotContains(response, 'text', status_code=999, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Couldn't retrieve content: Response code was 200 (expected 999)", str(e))
 
         try:
             self.assertNotContains(response, 'once')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response should not contain 'once'", str(e))
         try:
             self.assertNotContains(response, 'once', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Response should not contain 'once'", str(e))
 
         try:
             self.assertContains(response, 'never', 1)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Found 0 instances of 'never' in response (expected 1)", str(e))
         try:
             self.assertContains(response, 'never', 1, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Found 0 instances of 'never' in response (expected 1)", str(e))
 
         try:
             self.assertContains(response, 'once', 0)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Found 1 instances of 'once' in response (expected 0)", str(e))
         try:
             self.assertContains(response, 'once', 0, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Found 1 instances of 'once' in response (expected 0)", str(e))
 
         try:
             self.assertContains(response, 'once', 2)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Found 1 instances of 'once' in response (expected 2)", str(e))
         try:
             self.assertContains(response, 'once', 2, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Found 1 instances of 'once' in response (expected 2)", str(e))
 
         try:
             self.assertContains(response, 'twice', 1)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Found 2 instances of 'twice' in response (expected 1)", str(e))
         try:
             self.assertContains(response, 'twice', 1, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Found 2 instances of 'twice' in response (expected 1)", str(e))
 
         try:
             self.assertContains(response, 'thrice')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Couldn't find 'thrice' in response", str(e))
         try:
             self.assertContains(response, 'thrice', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Couldn't find 'thrice' in response", str(e))
 
         try:
             self.assertContains(response, 'thrice', 3)
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Found 0 instances of 'thrice' in response (expected 3)", str(e))
         try:
             self.assertContains(response, 'thrice', 3, msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Found 0 instances of 'thrice' in response (expected 3)", str(e))
 
     def test_unicode_contains(self):
@@ -176 +176 @@
 
         try:
             self.assertTemplateUsed(response, 'GET Template')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("No templates used to render the response", str(e))
 
         try:
             self.assertTemplateUsed(response, 'GET Template', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: No templates used to render the response", str(e))
 
     def test_single_context(self):
@@ -190 +190 @@
 
         try:
             self.assertTemplateNotUsed(response, 'Empty GET Template')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Template 'Empty GET Template' was used unexpectedly in rendering the response", str(e))
 
         try:
             self.assertTemplateNotUsed(response, 'Empty GET Template', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Template 'Empty GET Template' was used unexpectedly in rendering the response", str(e))
 
         try:
             self.assertTemplateUsed(response, 'Empty POST Template')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Template 'Empty POST Template' was not a template used to render the response. Actual template(s) used: Empty GET Template", str(e))
 
         try:
             self.assertTemplateUsed(response, 'Empty POST Template', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Template 'Empty POST Template' was not a template used to render the response. Actual template(s) used: Empty GET Template", str(e))
 
     def test_multiple_context(self):
@@ -221 +221 @@
         self.assertContains(response, 'POST data OK')
         try:
             self.assertTemplateNotUsed(response, "form_view.html")
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Template 'form_view.html' was used unexpectedly in rendering the response", str(e))
 
         try:
             self.assertTemplateNotUsed(response, 'base.html')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Template 'base.html' was used unexpectedly in rendering the response", str(e))
 
         try:
             self.assertTemplateUsed(response, "Valid POST Template")
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Template 'Valid POST Template' was not a template used to render the response. Actual template(s) used: form_view.html, base.html", str(e))
 
 class AssertRedirectsTests(TestCase):
@@ -241 +241 @@
         response = self.client.get('/test_client/permanent_redirect_view/')
         try:
             self.assertRedirects(response, '/test_client/get_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response didn't redirect as expected: Response code was 301 (expected 302)", str(e))
 
         try:
             self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Response didn't redirect as expected: Response code was 301 (expected 302)", str(e))
 
     def test_lost_query(self):
@@ -254 +254 @@
         response = self.client.get('/test_client/redirect_view/', {'var': 'value'})
         try:
             self.assertRedirects(response, '/test_client/get_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response redirected to 'http://testserver/test_client/get_view/?var=value', expected 'http://testserver/test_client/get_view/'", str(e))
 
         try:
             self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Response redirected to 'http://testserver/test_client/get_view/?var=value', expected 'http://testserver/test_client/get_view/'", str(e))
 
     def test_incorrect_target(self):
@@ -268 +268 @@
         try:
             # Should redirect to get_view
             self.assertRedirects(response, '/test_client/some_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response didn't redirect as expected: Response code was 301 (expected 302)", str(e))
 
     def test_target_page(self):
@@ -277 +277 @@
         try:
             # The redirect target responds with a 301 code, not 200
             self.assertRedirects(response, 'http://testserver/test_client/permanent_redirect_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Couldn't retrieve redirection page '/test_client/permanent_redirect_view/': response code was 301 (expected 200)", str(e))
 
         try:
             # The redirect target responds with a 301 code, not 200
             self.assertRedirects(response, 'http://testserver/test_client/permanent_redirect_view/', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Couldn't retrieve redirection page '/test_client/permanent_redirect_view/': response code was 301 (expected 200)", str(e))
 
     def test_redirect_chain(self):
@@ -386 +386 @@
         response = self.client.get('/test_client/get_view/', follow=True)
         try:
             self.assertRedirects(response, '/test_client/get_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response didn't redirect as expected: Response code was 200 (expected 302)", str(e))
 
         try:
             self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Response didn't redirect as expected: Response code was 200 (expected 302)", str(e))
 
     def test_redirect_on_non_redirect_page(self):
@@ -400 +400 @@
         response = self.client.get('/test_client/get_view/')
         try:
             self.assertRedirects(response, '/test_client/get_view/')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("Response didn't redirect as expected: Response code was 200 (expected 302)", str(e))
 
         try:
             self.assertRedirects(response, '/test_client/get_view/', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: Response didn't redirect as expected: Response code was 200 (expected 302)", str(e))
 
 
@@ -425 +425 @@
 
         try:
             self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("The form 'wrong_form' was not used to render the response", str(e))
         try:
             self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: The form 'wrong_form' was not used to render the response", str(e))
 
     def test_unknown_field(self):
@@ -447 +447 @@
 
         try:
             self.assertFormError(response, 'form', 'some_field', 'Some error.')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("The form 'form' in context 0 does not contain the field 'some_field'", str(e))
         try:
             self.assertFormError(response, 'form', 'some_field', 'Some error.', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: The form 'form' in context 0 does not contain the field 'some_field'", str(e))
 
     def test_noerror_field(self):
@@ -469 +469 @@
 
         try:
             self.assertFormError(response, 'form', 'value', 'Some error.')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("The field 'value' on form 'form' in context 0 contains no errors", str(e))
         try:
             self.assertFormError(response, 'form', 'value', 'Some error.', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: The field 'value' on form 'form' in context 0 contains no errors", str(e))
 
     def test_unknown_error(self):
@@ -491 +491 @@
 
         try:
             self.assertFormError(response, 'form', 'email', 'Some error.')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])", str(e))
         try:
             self.assertFormError(response, 'form', 'email', 'Some error.', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])", str(e))
 
     def test_unknown_nonfield_error(self):
@@ -516 +516 @@
 
         try:
             self.assertFormError(response, 'form', None, 'Some error.')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )", str(e))
         try:
             self.assertFormError(response, 'form', None, 'Some error.', msg_prefix='abc')
-        except AssertionError, e:
+        except AssertionError as e:
             self.assertIn("abc: The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )", str(e))
 
 class LoginTests(TestCase):
@@ -677 +677 @@
         try:
             response.context['does-not-exist']
             self.fail('Should not be able to retrieve non-existent key')
-        except KeyError, e:
+        except KeyError as e:
             self.assertEqual(e.args[0], 'does-not-exist')
 
     def test_inherited_context(self):
@@ -693 +693 @@
         try:
             response.context['does-not-exist']
             self.fail('Should not be able to retrieve non-existent key')
-        except KeyError, e:
+        except KeyError as e:
             self.assertEqual(e.args[0], 'does-not-exist')
 
     def test_15368(self):

tests/regressiontests/urlpatterns_reverse/tests.py

@@ -161 +161 @@
         for name, expected, args, kwargs in test_data:
             try:
                 got = reverse(name, args=args, kwargs=kwargs)
-            except NoReverseMatch, e:
+            except NoReverseMatch as e:
                 self.assertEqual(expected, NoReverseMatch)
             else:
                 self.assertEqual(got, expected)
@@ -207 +207 @@
         try:
             resolve('/included/non-existent-url', urlconf=urls)
             self.fail('resolve did not raise a 404')
-        except Resolver404, e:
+        except Resolver404 as e:
             # make sure we at least matched the root ('/') url resolver:
             self.assertTrue('tried' in e.args[0])
             tried = e.args[0]['tried']