Fixed the remaining E302 violations int eh django package

            getattr(combined, 'add_' + name)(getattr(other, '_' + name, None))

        return combined

def media_property(cls):

    def _media(self):

        # Get the media property of the superclass, if it exists

            return base

    return property(_media)

class MediaDefiningClass(type):

    """

    Metaclass for classes that can have media definitions.

            args.append(self.choices)

        return self.parent_widget.render(*args)

class Widget(six.with_metaclass(MediaDefiningClass)):

    is_hidden = False             # Determines whether this corresponds to an <input type="hidden">.

    needs_multipart_form = False  # Determines does this widget need multipart form

        """

        return id_

class Input(Widget):

    """

    Base class for all <input> widgets (except type='checkbox' and

            value = None

        return super(PasswordInput, self).render(name, value, attrs)

class HiddenInput(Input):

    input_type = 'hidden'

    is_hidden = True

class MultipleHiddenInput(HiddenInput):

    """

    A widget that handles <input type="hidden"> for fields that have a list

            return data.getlist(name)

        return data.get(name, None)

class FileInput(Input):

    input_type = 'file'

    needs_multipart_form = True

FILE_INPUT_CONTRADICTION = object()

class ClearableFileInput(FileInput):

    initial_text = ugettext_lazy('Currently')

    input_text = ugettext_lazy('Change')

            return False

        return upload

class Textarea(Widget):

    def __init__(self, attrs=None):

        # The 'rows' and 'cols' attributes are required for HTML correctness.

                output.append(self.render_option(selected_choices, option_value, option_label))

        return '\n'.join(output)

class NullBooleanSelect(Select):

    """

    A Select Widget intended to be used with NullBooleanField.

            return [value.date(), value.time().replace(microsecond=0)]

        return [None, None]

class SplitHiddenDateTimeWidget(SplitDateTimeWidget):

    """

    A Widget that splits datetime input into two <input type="hidden"> inputs.

        """Cleanup filename from Internet Explorer full paths."""

        return filename and filename[filename.rfind("\\")+1:].strip()

class LazyStream(six.Iterator):

    """

    The LazyStream wrapper allows one to get and "unget" bytes from a stream.

                " if there is none, report this to the Django developers."

            )

class ChunkIter(six.Iterator):

    """

    An iterable that will yield chunks of data. Given a file-like object as the

    def __iter__(self):

        return self

class InterBoundaryIter(six.Iterator):

    """

    A Producer that will iterate over boundaries.

        except InputStreamExhausted:

            raise StopIteration()

class BoundaryIter(six.Iterator):

    """

    A Producer that is sensitive to boundaries.

                end -= 1

            return end, next

def exhaust(stream_or_iterable):

    """

    Completely exhausts an iterator or stream.

    for __ in iterator:

        pass

def parse_boundary_stream(stream, max_header_size):

    """

    Parses one and exactly one stream that encapsulates a boundary.

    return (TYPE, outdict, stream)

class Parser(object):

    def __init__(self, stream, boundary):

        self._stream = stream

            # Iterate over each part

            yield parse_boundary_stream(sub_stream, 1024)

def parse_header(line):

    """ Parse the header into a key-value.

        Input (line): bytes, output: unicode for key/name, bytes for value which

            pdict[name] = value

    return key, pdict

def _parse_header_params(s):

    plist = []

    while s[:1] == b';':

        return self.msg % tuple(force_text(p, errors='replace')

                                 for p in self.params)

class InvalidTemplateLibrary(Exception):

    pass

class Origin(object):

    def __init__(self, name):

        self.name = name

    def __str__(self):

        return self.name

class StringOrigin(Origin):

    def __init__(self, source):

        super(StringOrigin, self).__init__(UNKNOWN_SOURCE)

    def reload(self):

        return self.source

class Template(object):

    def __init__(self, template_string, origin=None,

                 name='<Unknown Template>'):

        finally:

            context.render_context.pop()

def compile_string(template_string, origin):

    "Compiles template_string into NodeList ready for rendering"

    if settings.TEMPLATE_DEBUG:

    parser = parser_class(lexer.tokenize())

    return parser.parse()

class Token(object):

    def __init__(self, token_type, contents):

        # token_type must be TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK or

            split.append(bit)

        return split

class Lexer(object):

    def __init__(self, template_string, origin):

        self.template_string = template_string

        self.lineno += token_string.count('\n')

        return token

class Parser(object):

    def __init__(self, tokens):

        self.tokens = tokens

        else:

            raise TemplateSyntaxError("Invalid filter: '%s'" % filter_name)

class TokenParser(object):

    """

    Subclass this and implement the top() method to parse a template line.

filter_re = re.compile(filter_raw_string, re.UNICODE | re.VERBOSE)

class FilterExpression(object):

    """

    Parses a variable token and its optional filters (all as a single string),

    def __str__(self):

        return self.token

def resolve_variable(path, context):

    """

    Returns the resolved variable, which may contain attribute syntax, within

    """

    return Variable(path).resolve(context)

class Variable(object):

    """

    A template variable, resolvable against a given context. The variable may

        return current

class Node(object):

    # Set this to True for nodes that must be first in the template (although

    # they can be preceded by text nodes.

                nodes.extend(nodelist.get_nodes_by_type(nodetype))

        return nodes

class NodeList(list):

    # Set to True the first time a non-TextNode is inserted by

    # extend_nodelist().

    def render_node(self, node, context):

        return node.render(context)

class TextNode(Node):

    def __init__(self, s):

        self.s = s

    def render(self, context):

        return self.s

def render_value_in_context(value, context):

    """

    Converts any value to a string to become part of a rendered template. This

    else:

        return value

class VariableNode(Node):

    def __init__(self, filter_expression):

        self.filter_expression = filter_expression

# Regex for token keyword arguments

kwarg_re = re.compile(r"(?:(\w+)=)?(.+)")

def token_kwargs(bits, parser, support_legacy=False):

    """

    A utility method for parsing token keyword arguments.

            del bits[:1]

    return kwargs

def parse_bits(parser, bits, params, varargs, varkw, defaults,

               takes_context, name):

    """

            (name, ", ".join("'%s'" % p for p in unhandled_params)))

    return args, kwargs

def generic_tag_compiler(parser, token, params, varargs, varkw, defaults,

                         name, takes_context, node_class):

    """

                              defaults, takes_context, name)

    return node_class(takes_context, args, kwargs)

class TagHelperNode(Node):

    """

    Base class for tag helper nodes such as SimpleNode, InclusionNode and

                                for k, v in self.kwargs.items())

        return resolved_args, resolved_kwargs

class Library(object):

    def __init__(self):

        self.filters = {}

            return func

        return dec

def is_library_missing(name):

    """Check if library that failed to load cannot be found under any

    templatetags directory or does exist but fails to import.

    except ImportError:

        return is_library_missing(path)

def import_library(taglib_module):

    """

    Load a template tag library module.

templatetags_modules = []

def get_templatetags_modules():

    """

    Return the list of all available template tag modules.

        templatetags_modules = _templatetags_modules

    return templatetags_modules

def get_library(library_name):

    """

    Load the template library module with the given name.

            return d[key]

        return otherwise

# This is a function rather than module-level procedural code because we only

# want it to execute if somebody uses RequestContext.

def get_standard_processors():

        _standard_context_processors = tuple(processors)

    return _standard_context_processors

class RequestContext(Context):

    """

    This subclass of template.Context automatically populates itself using

    """

    return value.replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")

@register.filter(is_safe=True)

@stringfilter

def capfirst(value):

    """Capitalizes the first character of the value."""

    return value and value[0].upper() + value[1:]

@register.filter("escapejs")

@stringfilter

def escapejs_filter(value):

    """Hex encodes characters for use in JavaScript strings."""

    return escapejs(value)

@register.filter("fix_ampersands", is_safe=True)

@stringfilter

def fix_ampersands_filter(value):

nan = (1e200 * 1e200) // (1e200 * 1e200)

special_floats = [str(pos_inf), str(neg_inf), str(nan)]

@register.filter(is_safe=True)

def floatformat(text, arg=-1):

    """

    except InvalidOperation:

        return input_val

@register.filter(is_safe=True)

@stringfilter

def iriencode(value):

    """Escapes an IRI value for use in a URL."""

    return force_text(iri_to_uri(value))

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def linenumbers(value, autoescape=None):

            lines[i] = ("%0" + width + "d. %s") % (i + 1, escape(line))

    return mark_safe('\n'.join(lines))

@register.filter(is_safe=True)

@stringfilter

def lower(value):

    """Converts a string into all lowercase."""

    return value.lower()

@register.filter(is_safe=False)

@stringfilter

def make_list(value):

    """

    return list(value)

@register.filter(is_safe=True)

@stringfilter

def slugify(value):

    from django.utils.text import slugify

    return slugify(value)

@register.filter(is_safe=True)

def stringformat(value, arg):

    """

    except (ValueError, TypeError):

        return ""

@register.filter(is_safe=True)

@stringfilter

def title(value):

    t = re.sub("([a-z])'([A-Z])", lambda m: m.group(0).lower(), value.title())

    return re.sub("\d([A-Z])", lambda m: m.group(0).lower(), t)

@register.filter(is_safe=True)

@stringfilter

def truncatechars(value, arg):

        return value  # Fail silently.

    return Truncator(value).chars(length)

@register.filter(is_safe=True)

@stringfilter

def truncatewords(value, arg):

        return value  # Fail silently.

    return Truncator(value).words(length, truncate=' ...')

@register.filter(is_safe=True)

@stringfilter

def truncatewords_html(value, arg):

        return value  # Fail silently.

    return Truncator(value).words(length, html=True, truncate=' ...')

@register.filter(is_safe=False)

@stringfilter

def upper(value):

    """Converts a string into all uppercase."""

    return value.upper()

@register.filter(is_safe=False)

@stringfilter

def urlencode(value, safe=None):

        kwargs['safe'] = safe

    return urlquote(value, **kwargs)

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def urlize(value, autoescape=None):

    """Converts URLs in plain text into clickable links."""

    return mark_safe(urlize_impl(value, nofollow=True, autoescape=autoescape))

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def urlizetrunc(value, limit, autoescape=None):

    return mark_safe(urlize_impl(value, trim_url_limit=int(limit), nofollow=True,

                            autoescape=autoescape))

@register.filter(is_safe=False)

@stringfilter

def wordcount(value):

    """Returns the number of words."""

    return len(value.split())

@register.filter(is_safe=True)

@stringfilter

def wordwrap(value, arg):

    """

    return wrap(value, int(arg))

@register.filter(is_safe=True)

@stringfilter

def ljust(value, arg):

    """

    return value.ljust(int(arg))

@register.filter(is_safe=True)

@stringfilter

def rjust(value, arg):

    """

    return value.rjust(int(arg))

@register.filter(is_safe=True)

@stringfilter

def center(value, arg):

    """Centers the value in a field of a given width."""

    return value.center(int(arg))

@register.filter

@stringfilter

def cut(value, arg):

        return mark_safe(value)

    return value

###################

# HTML STRINGS    #

###################

    """

    return mark_for_escaping(value)

@register.filter(is_safe=True)

@stringfilter

def force_escape(value):

    """

    return escape(value)

@register.filter("linebreaks", is_safe=True, needs_autoescape=True)

@stringfilter

def linebreaks_filter(value, autoescape=None):

    autoescape = autoescape and not isinstance(value, SafeData)

    return mark_safe(linebreaks(value, autoescape))

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def linebreaksbr(value, autoescape=None):

        value = escape(value)

    return mark_safe(value.replace('\n', '<br />'))

@register.filter(is_safe=True)

@stringfilter

def safe(value):

    """

    return mark_safe(value)

@register.filter(is_safe=True)

def safeseq(value):

    """

    """

    return [mark_safe(force_text(obj)) for obj in value]

@register.filter(is_safe=True)

@stringfilter

def removetags(value, tags):

    from django.utils.html import remove_tags

    return remove_tags(value, tags)

@register.filter(is_safe=True)

@stringfilter

def striptags(value):

    """Strips all [X]HTML tags."""

    return strip_tags(value)

###################

# LISTS           #

###################

    except (TypeError, VariableDoesNotExist):

        return ''

@register.filter(is_safe=False)

def dictsortreversed(value, arg):

    """

    except (TypeError, VariableDoesNotExist):

        return ''

@register.filter(is_safe=False)

def first(value):

    """Returns the first item in a list."""

    except IndexError:

        return ''

@register.filter(is_safe=True, needs_autoescape=True)

def join(value, arg, autoescape=None):

    """

        return value