Merge lp:~divmod-dev/divmod.org/1095248-remove-pyflakes into lp:divmod.org

[Florent]

Move Pyflakes out of the divmod.org's repository

[Glyph Lefkowitz (glyph)]

Discussion on the mailing list appears to have reached consensus, outstanding branches have been dealt with, and the pyflakes branch has already been created. Please land this with all due haste, to reduce any confusion about where the code now lives. Thank you!

review: Approve

=== modified file 'Divmod.pth'
--- Divmod.pth	2008-10-01 18:28:58 +0000
+++ Divmod.pth	2013-01-02 10:12:49 +0000
@@ -1,10 +1,9 @@
-# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,pyflakes,xquotient,reverend,sine,vertex,hyperbola,imaginary,examplegame -*-
+# -*- test-case-name: axiom,combinator,epsilon,xmantissa,nevow,formless,xquotient,reverend,sine,vertex,hyperbola,imaginary,examplegame -*-
 Axiom
 Combinator
 Epsilon
 Mantissa
 Nevow
-Pyflakes
 Quotient
 Reverend
 Sine

=== removed directory 'Pyflakes'
=== removed file 'Pyflakes/LICENSE'
--- Pyflakes/LICENSE	2011-09-03 16:03:07 +0000
+++ Pyflakes/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright 2005-2011 Divmod, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

=== removed file 'Pyflakes/MANIFEST.in'
--- Pyflakes/MANIFEST.in	2011-09-03 16:06:14 +0000
+++ Pyflakes/MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-include NEWS.txt
-include LICENSE

=== removed file 'Pyflakes/NEWS.txt'
--- Pyflakes/NEWS.txt	2011-09-03 16:03:28 +0000
+++ Pyflakes/NEWS.txt	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-0.5.0 (2011-09-02):
-  - Convert pyflakes to use newer _ast infrastructure rather than compiler.
-  - Support for new syntax in 2.7 (including set literals, set comprehensions,
-    and dictionary comprehensions).
-  - Make sure class names don't get bound until after class definition.
-
-0.4.0 (2009-11-25):
-  - Fix reporting for certain SyntaxErrors which lack line number
-    information.
-  - Check for syntax errors more rigorously.
-  - Support checking names used with the class decorator syntax in versions
-    of Python which have it.
-  - Detect local variables which are bound but never used.
-  - Handle permission errors when trying to read source files.
-  - Handle problems with the encoding of source files.
-  - Support importing dotted names so as not to incorrectly report them as
-    redefined unused names.
-  - Support all forms of the with statement.
-  - Consider static `__all__` definitions and avoid reporting unused names
-    if the names are listed there.
-  - Fix incorrect checking of class names with respect to the names of their
-    bases in the class statement.
-  - Support the `__path__` global in `__init__.py`.
-
-0.3.0 (2009-01-30):
-  - Display more informative SyntaxError messages.
-  - Don't hang flymake with unmatched triple quotes (only report a single
-    line of source for a multiline syntax error).
-  - Recognize __builtins__ as a defined name.
-  - Improve pyflakes support for python versions 2.3-2.5
-  - Support for if-else expressions and with statements.
-  - Warn instead of error on non-existant file paths.
-  - Check for __future__ imports after other statements.
-  - Add reporting for some types of import shadowing.
-  - Improve reporting of unbound locals

=== removed directory 'Pyflakes/bin'
=== removed file 'Pyflakes/bin/pyflakes'
--- Pyflakes/bin/pyflakes	2012-07-08 13:48:46 +0000
+++ Pyflakes/bin/pyflakes	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-#!/usr/bin/python
-from pyflakes.scripts.pyflakes import main
-main()

=== removed directory 'Pyflakes/pyflakes'
=== removed file 'Pyflakes/pyflakes/__init__.py'
--- Pyflakes/pyflakes/__init__.py	2011-09-03 16:06:14 +0000
+++ Pyflakes/pyflakes/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,2 +0,0 @@
-
-__version__ = '0.5.0'

=== removed file 'Pyflakes/pyflakes/checker.py'
--- Pyflakes/pyflakes/checker.py	2012-01-10 19:09:22 +0000
+++ Pyflakes/pyflakes/checker.py	1970-01-01 00:00:00 +0000
@@ -1,634 +0,0 @@
-# -*- test-case-name: pyflakes -*-
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-import __builtin__
-import os.path
-import _ast
-
-from pyflakes import messages
-
-
-# utility function to iterate over an AST node's children, adapted
-# from Python 2.6's standard ast module
-try:
-    import ast
-    iter_child_nodes = ast.iter_child_nodes
-except (ImportError, AttributeError):
-    def iter_child_nodes(node, astcls=_ast.AST):
-        """
-        Yield all direct child nodes of *node*, that is, all fields that are nodes
-        and all items of fields that are lists of nodes.
-        """
-        for name in node._fields:
-            field = getattr(node, name, None)
-            if isinstance(field, astcls):
-                yield field
-            elif isinstance(field, list):
-                for item in field:
-                    yield item
-
-
-class Binding(object):
-    """
-    Represents the binding of a value to a name.
-
-    The checker uses this to keep track of which names have been bound and
-    which names have not. See L{Assignment} for a special type of binding that
-    is checked with stricter rules.
-
-    @ivar used: pair of (L{Scope}, line-number) indicating the scope and
-                line number that this binding was last used
-    """
-
-    def __init__(self, name, source):
-        self.name = name
-        self.source = source
-        self.used = False
-
-
-    def __str__(self):
-        return self.name
-
-
-    def __repr__(self):
-        return '<%s object %r from line %r at 0x%x>' % (self.__class__.__name__,
-                                                        self.name,
-                                                        self.source.lineno,
-                                                        id(self))
-
-
-
-class UnBinding(Binding):
-    '''Created by the 'del' operator.'''
-
-
-
-class Importation(Binding):
-    """
-    A binding created by an import statement.
-
-    @ivar fullName: The complete name given to the import statement,
-        possibly including multiple dotted components.
-    @type fullName: C{str}
-    """
-    def __init__(self, name, source):
-        self.fullName = name
-        name = name.split('.')[0]
-        super(Importation, self).__init__(name, source)
-
-
-
-class Argument(Binding):
-    """
-    Represents binding a name as an argument.
-    """
-
-
-class Definition(Binding):
-    """
-    A binding that defines a function or class.
-    """
-
-
-class Assignment(Binding):
-    """
-    Represents binding a name with an explicit assignment.
-
-    The checker will raise warnings for any Assignment that isn't used. Also,
-    the checker does not consider assignments in tuple/list unpacking to be
-    Assignments, rather it treats them as simple Bindings.
-    """
-
-
-
-class FunctionDefinition(Definition):
-    pass
-
-
-
-class ClassDefinition(Definition):
-    pass
-
-
-
-class ExportBinding(Binding):
-    """
-    A binding created by an C{__all__} assignment.  If the names in the list
-    can be determined statically, they will be treated as names for export and
-    additional checking applied to them.
-
-    The only C{__all__} assignment that can be recognized is one which takes
-    the value of a literal list containing literal strings.  For example::
-
-        __all__ = ["foo", "bar"]
-
-    Names which are imported and not otherwise used but appear in the value of
-    C{__all__} will not have an unused import warning reported for them.
-    """
-    def names(self):
-        """
-        Return a list of the names referenced by this binding.
-        """
-        names = []
-        if isinstance(self.source, _ast.List):
-            for node in self.source.elts:
-                if isinstance(node, _ast.Str):
-                    names.append(node.s)
-        return names
-
-
-
-class Scope(dict):
-    importStarred = False       # set to True when import * is found
-
-
-    def __repr__(self):
-        return '<%s at 0x%x %s>' % (self.__class__.__name__, id(self), dict.__repr__(self))
-
-
-    def __init__(self):
-        super(Scope, self).__init__()
-
-
-
-class ClassScope(Scope):
-    pass
-
-
-
-class FunctionScope(Scope):
-    """
-    I represent a name scope for a function.
-
-    @ivar globals: Names declared 'global' in this function.
-    """
-    def __init__(self):
-        super(FunctionScope, self).__init__()
-        self.globals = {}
-
-
-
-class ModuleScope(Scope):
-    pass
-
-
-# Globally defined names which are not attributes of the __builtin__ module, or
-# are only present on some platforms.
-_MAGIC_GLOBALS = ['__file__', '__builtins__', 'WindowsError']
-
-
-
-class Checker(object):
-    """
-    I check the cleanliness and sanity of Python code.
-
-    @ivar _deferredFunctions: Tracking list used by L{deferFunction}.  Elements
-        of the list are two-tuples.  The first element is the callable passed
-        to L{deferFunction}.  The second element is a copy of the scope stack
-        at the time L{deferFunction} was called.
-
-    @ivar _deferredAssignments: Similar to C{_deferredFunctions}, but for
-        callables which are deferred assignment checks.
-    """
-
-    nodeDepth = 0
-    traceTree = False
-
-    def __init__(self, tree, filename='(none)'):
-        self._deferredFunctions = []
-        self._deferredAssignments = []
-        self.dead_scopes = []
-        self.messages = []
-        self.filename = filename
-        self.scopeStack = [ModuleScope()]
-        self.futuresAllowed = True
-        self.handleChildren(tree)
-        self._runDeferred(self._deferredFunctions)
-        # Set _deferredFunctions to None so that deferFunction will fail
-        # noisily if called after we've run through the deferred functions.
-        self._deferredFunctions = None
-        self._runDeferred(self._deferredAssignments)
-        # Set _deferredAssignments to None so that deferAssignment will fail
-        # noisly if called after we've run through the deferred assignments.
-        self._deferredAssignments = None
-        del self.scopeStack[1:]
-        self.popScope()
-        self.check_dead_scopes()
-
-
-    def deferFunction(self, callable):
-        '''
-        Schedule a function handler to be called just before completion.
-
-        This is used for handling function bodies, which must be deferred
-        because code later in the file might modify the global scope. When
-        `callable` is called, the scope at the time this is called will be
-        restored, however it will contain any new bindings added to it.
-        '''
-        self._deferredFunctions.append((callable, self.scopeStack[:]))
-
-
-    def deferAssignment(self, callable):
-        """
-        Schedule an assignment handler to be called just after deferred
-        function handlers.
-        """
-        self._deferredAssignments.append((callable, self.scopeStack[:]))
-
-
-    def _runDeferred(self, deferred):
-        """
-        Run the callables in C{deferred} using their associated scope stack.
-        """
-        for handler, scope in deferred:
-            self.scopeStack = scope
-            handler()
-
-
-    def scope(self):
-        return self.scopeStack[-1]
-    scope = property(scope)
-
-    def popScope(self):
-        self.dead_scopes.append(self.scopeStack.pop())
-
-
-    def check_dead_scopes(self):
-        """
-        Look at scopes which have been fully examined and report names in them
-        which were imported but unused.
-        """
-        for scope in self.dead_scopes:
-            export = isinstance(scope.get('__all__'), ExportBinding)
-            if export:
-                all = scope['__all__'].names()
-                if os.path.split(self.filename)[1] != '__init__.py':
-                    # Look for possible mistakes in the export list
-                    undefined = set(all) - set(scope)
-                    for name in undefined:
-                        self.report(
-                            messages.UndefinedExport,
-                            scope['__all__'].source.lineno,
-                            name)
-            else:
-                all = []
-
-            # Look for imported names that aren't used.
-            for importation in scope.itervalues():
-                if isinstance(importation, Importation):
-                    if not importation.used and importation.name not in all:
-                        self.report(
-                            messages.UnusedImport,
-                            importation.source.lineno,
-                            importation.name)
-
-
-    def pushFunctionScope(self):
-        self.scopeStack.append(FunctionScope())
-
-    def pushClassScope(self):
-        self.scopeStack.append(ClassScope())
-
-    def report(self, messageClass, *args, **kwargs):
-        self.messages.append(messageClass(self.filename, *args, **kwargs))
-
-    def handleChildren(self, tree):
-        for node in iter_child_nodes(tree):
-            self.handleNode(node, tree)
-
-    def isDocstring(self, node):
-        """
-        Determine if the given node is a docstring, as long as it is at the
-        correct place in the node tree.
-        """
-        return isinstance(node, _ast.Str) or \
-               (isinstance(node, _ast.Expr) and
-                isinstance(node.value, _ast.Str))
-
-    def handleNode(self, node, parent):
-        node.parent = parent
-        if self.traceTree:
-            print '  ' * self.nodeDepth + node.__class__.__name__
-        self.nodeDepth += 1
-        if self.futuresAllowed and not \
-               (isinstance(node, _ast.ImportFrom) or self.isDocstring(node)):
-            self.futuresAllowed = False
-        nodeType = node.__class__.__name__.upper()
-        try:
-            handler = getattr(self, nodeType)
-            handler(node)
-        finally:
-            self.nodeDepth -= 1
-        if self.traceTree:
-            print '  ' * self.nodeDepth + 'end ' + node.__class__.__name__
-
-    def ignore(self, node):
-        pass
-
-    # "stmt" type nodes
-    RETURN = DELETE = PRINT = WHILE = IF = WITH = RAISE = TRYEXCEPT = \
-        TRYFINALLY = ASSERT = EXEC = EXPR = handleChildren
-
-    CONTINUE = BREAK = PASS = ignore
-
-    # "expr" type nodes
-    BOOLOP = BINOP = UNARYOP = IFEXP = DICT = SET = YIELD = COMPARE = \
-    CALL = REPR = ATTRIBUTE = SUBSCRIPT = LIST = TUPLE = handleChildren
-
-    NUM = STR = ELLIPSIS = ignore
-
-    # "slice" type nodes
-    SLICE = EXTSLICE = INDEX = handleChildren
-
-    # expression contexts are node instances too, though being constants
-    LOAD = STORE = DEL = AUGLOAD = AUGSTORE = PARAM = ignore
-
-    # same for operators
-    AND = OR = ADD = SUB = MULT = DIV = MOD = POW = LSHIFT = RSHIFT = \
-    BITOR = BITXOR = BITAND = FLOORDIV = INVERT = NOT = UADD = USUB = \
-    EQ = NOTEQ = LT = LTE = GT = GTE = IS = ISNOT = IN = NOTIN = ignore
-
-    # additional node types
-    COMPREHENSION = EXCEPTHANDLER = KEYWORD = handleChildren
-
-    def addBinding(self, lineno, value, reportRedef=True):
-        '''Called when a binding is altered.
-
-        - `lineno` is the line of the statement responsible for the change
-        - `value` is the optional new value, a Binding instance, associated
-          with the binding; if None, the binding is deleted if it exists.
-        - if `reportRedef` is True (default), rebinding while unused will be
-          reported.
-        '''
-        if not isinstance(self.scope, ClassScope):
-            for scope in self.scopeStack[::-1]:
-                existing = scope.get(value.name)
-                if (isinstance(existing, Importation)
-                        and not existing.used
-                        and (not isinstance(value, Importation) or value.fullName == existing.fullName)
-                        and reportRedef):
-
-                    self.report(messages.RedefinedWhileUnused,
-                                lineno, value.name, scope[value.name].source.lineno)
-
-        existing = self.scope.get(value.name)
-        if isinstance(value, UnBinding):
-            try:
-                del self.scope[value.name]
-            except KeyError:
-                self.report(messages.UndefinedName, lineno, value.name)
-        elif isinstance(existing, Definition) and not existing.used:
-            self.report(messages.RedefinedWhileUnused,
-                        lineno, value.name, existing.source.lineno)
-        else:
-            self.scope[value.name] = value
-
-    def GLOBAL(self, node):
-        """
-        Keep track of globals declarations.
-        """
-        if isinstance(self.scope, FunctionScope):
-            self.scope.globals.update(dict.fromkeys(node.names))
-
-    def LISTCOMP(self, node):
-        # handle generators before element
-        for gen in node.generators:
-            self.handleNode(gen, node)
-        self.handleNode(node.elt, node)
-
-    GENERATOREXP = SETCOMP = LISTCOMP
-
-    # dictionary comprehensions; introduced in Python 2.7
-    def DICTCOMP(self, node):
-        for gen in node.generators:
-            self.handleNode(gen, node)
-        self.handleNode(node.key, node)
-        self.handleNode(node.value, node)
-
-    def FOR(self, node):
-        """
-        Process bindings for loop variables.
-        """
-        vars = []
-        def collectLoopVars(n):
-            if isinstance(n, _ast.Name):
-                vars.append(n.id)
-            elif isinstance(n, _ast.expr_context):
-                return
-            else:
-                for c in iter_child_nodes(n):
-                    collectLoopVars(c)
-
-        collectLoopVars(node.target)
-        for varn in vars:
-            if (isinstance(self.scope.get(varn), Importation)
-                    # unused ones will get an unused import warning
-                    and self.scope[varn].used):
-                self.report(messages.ImportShadowedByLoopVar,
-                            node.lineno, varn, self.scope[varn].source.lineno)
-
-        self.handleChildren(node)
-
-    def NAME(self, node):
-        """
-        Handle occurrence of Name (which can be a load/store/delete access.)
-        """
-        # Locate the name in locals / function / globals scopes.
-        if isinstance(node.ctx, (_ast.Load, _ast.AugLoad)):
-            # try local scope
-            importStarred = self.scope.importStarred
-            try:
-                self.scope[node.id].used = (self.scope, node.lineno)
-            except KeyError:
-                pass
-            else:
-                return
-
-            # try enclosing function scopes
-
-            for scope in self.scopeStack[-2:0:-1]:
-                importStarred = importStarred or scope.importStarred
-                if not isinstance(scope, FunctionScope):
-                    continue
-                try:
-                    scope[node.id].used = (self.scope, node.lineno)
-                except KeyError:
-                    pass
-                else:
-                    return
-
-            # try global scope
-
-            importStarred = importStarred or self.scopeStack[0].importStarred
-            try:
-                self.scopeStack[0][node.id].used = (self.scope, node.lineno)
-            except KeyError:
-                if ((not hasattr(__builtin__, node.id))
-                        and node.id not in _MAGIC_GLOBALS
-                        and not importStarred):
-                    if (os.path.basename(self.filename) == '__init__.py' and
-                        node.id == '__path__'):
-                        # the special name __path__ is valid only in packages
-                        pass
-                    else:
-                        self.report(messages.UndefinedName, node.lineno, node.id)
-        elif isinstance(node.ctx, (_ast.Store, _ast.AugStore)):
-            # if the name hasn't already been defined in the current scope
-            if isinstance(self.scope, FunctionScope) and node.id not in self.scope:
-                # for each function or module scope above us
-                for scope in self.scopeStack[:-1]:
-                    if not isinstance(scope, (FunctionScope, ModuleScope)):
-                        continue
-                    # if the name was defined in that scope, and the name has
-                    # been accessed already in the current scope, and hasn't
-                    # been declared global
-                    if (node.id in scope
-                            and scope[node.id].used
-                            and scope[node.id].used[0] is self.scope
-                            and node.id not in self.scope.globals):
-                        # then it's probably a mistake
-                        self.report(messages.UndefinedLocal,
-                                    scope[node.id].used[1],
-                                    node.id,
-                                    scope[node.id].source.lineno)
-                        break
-
-            if isinstance(node.parent,
-                          (_ast.For, _ast.comprehension, _ast.Tuple, _ast.List)):
-                binding = Binding(node.id, node)
-            elif (node.id == '__all__' and
-                  isinstance(self.scope, ModuleScope)):
-                binding = ExportBinding(node.id, node.parent.value)
-            else:
-                binding = Assignment(node.id, node)
-            if node.id in self.scope:
-                binding.used = self.scope[node.id].used
-            self.addBinding(node.lineno, binding)
-        elif isinstance(node.ctx, _ast.Del):
-            if isinstance(self.scope, FunctionScope) and \
-                   node.id in self.scope.globals:
-                del self.scope.globals[node.id]
-            else:
-                self.addBinding(node.lineno, UnBinding(node.id, node))
-        else:
-            # must be a Param context -- this only happens for names in function
-            # arguments, but these aren't dispatched through here
-            raise RuntimeError(
-                "Got impossible expression context: %r" % (node.ctx,))
-
-
-    def FUNCTIONDEF(self, node):
-        # the decorators attribute is called decorator_list as of Python 2.6
-        if hasattr(node, 'decorators'):
-            for deco in node.decorators:
-                self.handleNode(deco, node)
-        else:
-            for deco in node.decorator_list:
-                self.handleNode(deco, node)
-        self.addBinding(node.lineno, FunctionDefinition(node.name, node))
-        self.LAMBDA(node)
-
-    def LAMBDA(self, node):
-        for default in node.args.defaults:
-            self.handleNode(default, node)
-
-        def runFunction():
-            args = []
-
-            def addArgs(arglist):
-                for arg in arglist:
-                    if isinstance(arg, _ast.Tuple):
-                        addArgs(arg.elts)
-                    else:
-                        if arg.id in args:
-                            self.report(messages.DuplicateArgument,
-                                        node.lineno, arg.id)
-                        args.append(arg.id)
-
-            self.pushFunctionScope()
-            addArgs(node.args.args)
-            # vararg/kwarg identifiers are not Name nodes
-            if node.args.vararg:
-                args.append(node.args.vararg)
-            if node.args.kwarg:
-                args.append(node.args.kwarg)
-            for name in args:
-                self.addBinding(node.lineno, Argument(name, node), reportRedef=False)
-            if isinstance(node.body, list):
-                # case for FunctionDefs
-                for stmt in node.body:
-                    self.handleNode(stmt, node)
-            else:
-                # case for Lambdas
-                self.handleNode(node.body, node)
-            def checkUnusedAssignments():
-                """
-                Check to see if any assignments have not been used.
-                """
-                for name, binding in self.scope.iteritems():
-                    if (not binding.used and not name in self.scope.globals
-                        and isinstance(binding, Assignment)):
-                        self.report(messages.UnusedVariable,
-                                    binding.source.lineno, name)
-            self.deferAssignment(checkUnusedAssignments)
-            self.popScope()
-
-        self.deferFunction(runFunction)
-
-
-    def CLASSDEF(self, node):
-        """
-        Check names used in a class definition, including its decorators, base
-        classes, and the body of its definition.  Additionally, add its name to
-        the current scope.
-        """
-        # decorator_list is present as of Python 2.6
-        for deco in getattr(node, 'decorator_list', []):
-            self.handleNode(deco, node)
-        for baseNode in node.bases:
-            self.handleNode(baseNode, node)
-        self.pushClassScope()
-        for stmt in node.body:
-            self.handleNode(stmt, node)
-        self.popScope()
-        self.addBinding(node.lineno, ClassDefinition(node.name, node))
-
-    def ASSIGN(self, node):
-        self.handleNode(node.value, node)
-        for target in node.targets:
-            self.handleNode(target, node)
-
-    def AUGASSIGN(self, node):
-        # AugAssign is awkward: must set the context explicitly and visit twice,
-        # once with AugLoad context, once with AugStore context
-        node.target.ctx = _ast.AugLoad()
-        self.handleNode(node.target, node)
-        self.handleNode(node.value, node)
-        node.target.ctx = _ast.AugStore()
-        self.handleNode(node.target, node)
-
-    def IMPORT(self, node):
-        for alias in node.names:
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            self.addBinding(node.lineno, importation)
-
-    def IMPORTFROM(self, node):
-        if node.module == '__future__':
-            if not self.futuresAllowed:
-                self.report(messages.LateFutureImport, node.lineno,
-                            [n.name for n in node.names])
-        else:
-            self.futuresAllowed = False
-
-        for alias in node.names:
-            if alias.name == '*':
-                self.scope.importStarred = True
-                self.report(messages.ImportStarUsed, node.lineno, node.module)
-                continue
-            name = alias.asname or alias.name
-            importation = Importation(name, node)
-            if node.module == '__future__':
-                importation.used = (self.scope, node.lineno)
-            self.addBinding(node.lineno, importation)

=== removed file 'Pyflakes/pyflakes/messages.py'
--- Pyflakes/pyflakes/messages.py	2011-10-31 15:19:35 +0000
+++ Pyflakes/pyflakes/messages.py	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# (c) 2005 Divmod, Inc.  See LICENSE file for details
-
-class Message(object):
-    message = ''
-    message_args = ()
-    def __init__(self, filename, lineno):
-        self.filename = filename
-        self.lineno = lineno
-    def __str__(self):
-        return '%s:%s: %s' % (self.filename, self.lineno, self.message % self.message_args)
-
-
-class UnusedImport(Message):
-    message = '%r imported but unused'
-    def __init__(self, filename, lineno, name):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name,)
-
-
-class RedefinedWhileUnused(Message):
-    message = 'redefinition of unused %r from line %r'
-    def __init__(self, filename, lineno, name, orig_lineno):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name, orig_lineno)
-
-
-class ImportShadowedByLoopVar(Message):
-    message = 'import %r from line %r shadowed by loop variable'
-    def __init__(self, filename, lineno, name, orig_lineno):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name, orig_lineno)
-
-
-class ImportStarUsed(Message):
-    message = "'from %s import *' used; unable to detect undefined names"
-    def __init__(self, filename, lineno, modname):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (modname,)
-
-
-class UndefinedName(Message):
-    message = 'undefined name %r'
-    def __init__(self, filename, lineno, name):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name,)
-
-
-
-class UndefinedExport(Message):
-    message = 'undefined name %r in __all__'
-    def __init__(self, filename, lineno, name):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name,)
-
-
-
-class UndefinedLocal(Message):
-    message = "local variable %r (defined in enclosing scope on line %r) referenced before assignment"
-    def __init__(self, filename, lineno, name, orig_lineno):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name, orig_lineno)
-
-
-class DuplicateArgument(Message):
-    message = 'duplicate argument %r in function definition'
-    def __init__(self, filename, lineno, name):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name,)
-
-
-class Redefined(Message):
-    message = 'redefinition of %r from line %r'
-    def __init__(self, filename, lineno, name, orig_lineno):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (name, orig_lineno)
-
-
-class LateFutureImport(Message):
-    message = 'future import(s) %r after other statements'
-    def __init__(self, filename, lineno, names):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (names,)
-
-
-class UnusedVariable(Message):
-    """
-    Indicates that a variable has been explicity assigned to but not actually
-    used.
-    """
-
-    message = 'local variable %r is assigned to but never used'
-    def __init__(self, filename, lineno, names):
-        Message.__init__(self, filename, lineno)
-        self.message_args = (names,)

=== removed file 'Pyflakes/pyflakes/reporter.py'
--- Pyflakes/pyflakes/reporter.py	2012-10-23 13:07:35 +0000
+++ Pyflakes/pyflakes/reporter.py	1970-01-01 00:00:00 +0000
@@ -1,79 +0,0 @@
-# (c) 2005-2012 Divmod, Inc.
-# See LICENSE file for details
-
-import sys
-
-
-class Reporter(object):
-    """
-    Formats the results of pyflakes checks to users.
-    """
-
-    def __init__(self, warningStream, errorStream):
-        """
-        Construct a L{Reporter}.
-
-        @param warningStream: A file-like object where warnings will be
-            written to.  The stream's C{write} method must accept unicode.
-            C{sys.stdout} is a good value.
-        @param errorStream: A file-like object where error output will be
-            written to.  The stream's C{write} method must accept unicode.
-            C{sys.stderr} is a good value.
-        """
-        self._stdout = warningStream
-        self._stderr = errorStream
-
-
-    def unexpectedError(self, filename, msg):
-        """
-        An unexpected error occurred trying to process C{filename}.
-
-        @param filename: The path to a file that we could not process.
-        @ptype filename: C{unicode}
-        @param msg: A message explaining the problem.
-        @ptype msg: C{unicode}
-        """
-        self._stderr.write(u"%s: %s\n" % (filename, msg))
-
-
-    def syntaxError(self, filename, msg, lineno, offset, text):
-        """
-        There was a syntax errror in C{filename}.
-
-        @param filename: The path to the file with the syntax error.
-        @ptype filename: C{unicode}
-        @param msg: An explanation of the syntax error.
-        @ptype msg: C{unicode}
-        @param lineno: The line number where the syntax error occurred.
-        @ptype lineno: C{int}
-        @param offset: The column on which the syntax error occurred.
-        @ptype offset: C{int}
-        @param text: The source code containing the syntax error.
-        @ptype text: C{unicode}
-        """
-        line = text.splitlines()[-1]
-        if offset is not None:
-            offset = offset - (len(text) - len(line))
-        self._stderr.write(u'%s:%d: %s\n' % (filename, lineno, msg))
-        self._stderr.write(line)
-        self._stderr.write(u'\n')
-        if offset is not None:
-            self._stderr.write(u" " * (offset + 1) + u"^\n")
-
-
-    def flake(self, message):
-        """
-        pyflakes found something wrong with the code.
-
-        @param: A L{pyflakes.messages.Message}.
-        """
-        self._stdout.write(unicode(message))
-        self._stdout.write(u'\n')
-
-
-
-def _makeDefaultReporter():
-    """
-    Make a reporter that can be used when no reporter is specified.
-    """
-    return Reporter(sys.stdout, sys.stderr)

=== removed directory 'Pyflakes/pyflakes/scripts'
=== removed file 'Pyflakes/pyflakes/scripts/__init__.py'
=== removed file 'Pyflakes/pyflakes/scripts/pyflakes.py'
--- Pyflakes/pyflakes/scripts/pyflakes.py	2012-10-23 11:48:54 +0000
+++ Pyflakes/pyflakes/scripts/pyflakes.py	1970-01-01 00:00:00 +0000
@@ -1,122 +0,0 @@
-"""
-Implementation of the command-line I{pyflakes} tool.
-"""
-
-from __future__ import absolute_import
-
-import sys
-import os
-import _ast
-
-from pyflakes import checker
-from pyflakes import reporter as modReporter
-
-
-def check(codeString, filename, reporter=None):
-    """
-    Check the Python source given by C{codeString} for flakes.
-
-    @param codeString: The Python source to check.
-    @type codeString: C{str}
-
-    @param filename: The name of the file the source came from, used to report
-        errors.
-    @type filename: C{str}
-
-    @param reporter: A L{Reporter} instance, where errors and warnings will be
-        reported.
-
-    @return: The number of warnings emitted.
-    @rtype: C{int}
-    """
-    if reporter is None:
-        reporter = modReporter._makeDefaultReporter()
-    # First, compile into an AST and handle syntax errors.
-    try:
-        tree = compile(codeString, filename, "exec", _ast.PyCF_ONLY_AST)
-    except SyntaxError, value:
-        msg = value.args[0]
-
-        (lineno, offset, text) = value.lineno, value.offset, value.text
-
-        # If there's an encoding problem with the file, the text is None.
-        if text is None:
-            # Avoid using msg, since for the only known case, it contains a
-            # bogus message that claims the encoding the file declared was
-            # unknown.
-            reporter.unexpectedError(filename, u'problem decoding source')
-        else:
-            reporter.syntaxError(filename, msg, lineno, offset, text)
-        return 1
-    else:
-        # Okay, it's syntactically valid.  Now check it.
-        w = checker.Checker(tree, filename)
-        w.messages.sort(lambda a, b: cmp(a.lineno, b.lineno))
-        for warning in w.messages:
-            reporter.flake(warning)
-        return len(w.messages)
-
-
-def checkPath(filename, reporter=None):
-    """
-    Check the given path, printing out any warnings detected.
-
-    @param reporter: A L{Reporter} instance, where errors and warnings will be
-        reported.
-
-    @return: the number of warnings printed
-    """
-    if reporter is None:
-        reporter = modReporter._makeDefaultReporter()
-    try:
-        return check(file(filename, 'U').read() + '\n', filename, reporter)
-    except IOError, msg:
-        reporter.unexpectedError(filename, msg.args[1])
-        return 1
-
-
-
-def iterSourceCode(paths):
-    """
-    Iterate over all Python source files in C{paths}.
-
-    @param paths: A list of paths.  Directories will be recursed into and
-        any .py files found will be yielded.  Any non-directories will be
-        yielded as-is.
-    """
-    for path in paths:
-        if os.path.isdir(path):
-            for dirpath, dirnames, filenames in os.walk(path):
-                for filename in filenames:
-                    if filename.endswith('.py'):
-                        yield os.path.join(dirpath, filename)
-        else:
-            yield path
-
-
-
-def checkRecursive(paths, reporter):
-    """
-    Recursively check all source files in C{paths}.
-
-    @param paths: A list of paths to Python source files and directories
-        containing Python source files.
-    @param reporter: A L{Reporter} where all of the warnings and errors
-        will be reported to.
-    @return: The number of warnings found.
-    """
-    warnings = 0
-    for sourcePath in iterSourceCode(paths):
-        warnings += checkPath(sourcePath, reporter)
-    return warnings
-
-
-
-def main():
-    args = sys.argv[1:]
-    reporter = modReporter._makeDefaultReporter()
-    if args:
-        warnings = checkRecursive(args, reporter)
-    else:
-        warnings = check(sys.stdin.read(), '<stdin>', reporter)
-    raise SystemExit(warnings > 0)

=== removed directory 'Pyflakes/pyflakes/test'
=== removed file 'Pyflakes/pyflakes/test/__init__.py'
=== removed file 'Pyflakes/pyflakes/test/harness.py'
--- Pyflakes/pyflakes/test/harness.py	2010-04-13 14:53:04 +0000
+++ Pyflakes/pyflakes/test/harness.py	1970-01-01 00:00:00 +0000
@@ -1,27 +0,0 @@
-
-import textwrap
-import _ast
-
-from twisted.trial import unittest
-
-from pyflakes import checker
-
-
-class Test(unittest.TestCase):
-
-    def flakes(self, input, *expectedOutputs, **kw):
-        ast = compile(textwrap.dedent(input), "<test>", "exec",
-                      _ast.PyCF_ONLY_AST)
-        w = checker.Checker(ast, **kw)
-        outputs = [type(o) for o in w.messages]
-        expectedOutputs = list(expectedOutputs)
-        outputs.sort()
-        expectedOutputs.sort()
-        self.assert_(outputs == expectedOutputs, '''\
-for input:
-%s
-expected outputs:
-%s
-but got:
-%s''' % (input, repr(expectedOutputs), '\n'.join([str(o) for o in w.messages])))
-        return w

=== removed file 'Pyflakes/pyflakes/test/test_imports.py'
--- Pyflakes/pyflakes/test/test_imports.py	2011-10-31 15:19:35 +0000
+++ Pyflakes/pyflakes/test/test_imports.py	1970-01-01 00:00:00 +0000
@@ -1,670 +0,0 @@
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-class Test(harness.Test):
-
-    def test_unusedImport(self):
-        self.flakes('import fu, bar', m.UnusedImport, m.UnusedImport)
-        self.flakes('from baz import fu, bar', m.UnusedImport, m.UnusedImport)
-
-    def test_aliasedImport(self):
-        self.flakes('import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-        self.flakes('from moo import fu as FU, bar as FU', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_usedImport(self):
-        self.flakes('import fu; print fu')
-        self.flakes('from baz import fu; print fu')
-
-    def test_redefinedWhileUnused(self):
-        self.flakes('import fu; fu = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; del fu', m.RedefinedWhileUnused)
-        self.flakes('import fu; fu, bar = 3', m.RedefinedWhileUnused)
-        self.flakes('import fu; [fu, bar] = 3', m.RedefinedWhileUnused)
-
-    def test_redefinedByFunction(self):
-        self.flakes('''
-        import fu
-        def fu():
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_redefinedInNestedFunction(self):
-        """
-        Test that shadowing a global name with a nested function definition
-        generates a warning.
-        """
-        self.flakes('''
-        import fu
-        def bar():
-            def baz():
-                def fu():
-                    pass
-        ''', m.RedefinedWhileUnused, m.UnusedImport)
-
-    def test_redefinedByClass(self):
-        self.flakes('''
-        import fu
-        class fu:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_redefinedBySubclass(self):
-        """
-        If an imported name is redefined by a class statement which also uses
-        that name in the bases list, no warning is emitted.
-        """
-        self.flakes('''
-        from fu import bar
-        class bar(bar):
-            pass
-        ''')
-
-
-    def test_redefinedInClass(self):
-        """
-        Test that shadowing a global with a class attribute does not produce a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        class bar:
-            fu = 1
-        print fu
-        ''')
-
-    def test_usedInFunction(self):
-        self.flakes('''
-        import fu
-        def fun():
-            print fu
-        ''')
-
-    def test_shadowedByParameter(self):
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        ''', m.UnusedImport)
-
-        self.flakes('''
-        import fu
-        def fun(fu):
-            print fu
-        print fu
-        ''')
-
-    def test_newAssignment(self):
-        self.flakes('fu = None')
-
-    def test_usedInGetattr(self):
-        self.flakes('import fu; fu.bar.baz')
-        self.flakes('import fu; "bar".fu.baz', m.UnusedImport)
-
-    def test_usedInSlice(self):
-        self.flakes('import fu; print fu.bar[1:]')
-
-    def test_usedInIfBody(self):
-        self.flakes('''
-        import fu
-        if True: print fu
-        ''')
-
-    def test_usedInIfConditional(self):
-        self.flakes('''
-        import fu
-        if fu: pass
-        ''')
-
-    def test_usedInElifConditional(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        elif fu: pass
-        ''')
-
-    def test_usedInElse(self):
-        self.flakes('''
-        import fu
-        if False: pass
-        else: print fu
-        ''')
-
-    def test_usedInCall(self):
-        self.flakes('import fu; fu.bar()')
-
-    def test_usedInClass(self):
-        self.flakes('''
-        import fu
-        class bar:
-            bar = fu
-        ''')
-
-    def test_usedInClassBase(self):
-        self.flakes('''
-        import fu
-        class bar(object, fu.baz):
-            pass
-        ''')
-
-    def test_notUsedInNestedScope(self):
-        self.flakes('''
-        import fu
-        def bleh():
-            pass
-        print fu
-        ''')
-
-    def test_usedInFor(self):
-        self.flakes('''
-        import fu
-        for bar in range(9):
-            print fu
-        ''')
-
-    def test_usedInForElse(self):
-        self.flakes('''
-        import fu
-        for bar in range(10):
-            pass
-        else:
-            print fu
-        ''')
-
-    def test_redefinedByFor(self):
-        self.flakes('''
-        import fu
-        for fu in range(2):
-            pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_shadowedByFor(self):
-        """
-        Test that shadowing a global name with a for loop variable generates a
-        warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for fu in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_shadowedByForDeep(self):
-        """
-        Test that shadowing a global name with a for loop variable nested in a
-        tuple unpack generates a warning.
-        """
-        self.flakes('''
-        import fu
-        fu.bar()
-        for (x, y, z, (a, b, c, (fu,))) in ():
-            pass
-        ''', m.ImportShadowedByLoopVar)
-
-    def test_usedInReturn(self):
-        self.flakes('''
-        import fu
-        def fun():
-            return fu
-        ''')
-
-    def test_usedInOperators(self):
-        self.flakes('import fu; 3 + fu.bar')
-        self.flakes('import fu; 3 % fu.bar')
-        self.flakes('import fu; 3 - fu.bar')
-        self.flakes('import fu; 3 * fu.bar')
-        self.flakes('import fu; 3 ** fu.bar')
-        self.flakes('import fu; 3 / fu.bar')
-        self.flakes('import fu; 3 // fu.bar')
-        self.flakes('import fu; -fu.bar')
-        self.flakes('import fu; ~fu.bar')
-        self.flakes('import fu; 1 == fu.bar')
-        self.flakes('import fu; 1 | fu.bar')
-        self.flakes('import fu; 1 & fu.bar')
-        self.flakes('import fu; 1 ^ fu.bar')
-        self.flakes('import fu; 1 >> fu.bar')
-        self.flakes('import fu; 1 << fu.bar')
-
-    def test_usedInAssert(self):
-        self.flakes('import fu; assert fu.bar')
-
-    def test_usedInSubscript(self):
-        self.flakes('import fu; fu.bar[1]')
-
-    def test_usedInLogic(self):
-        self.flakes('import fu; fu and False')
-        self.flakes('import fu; fu or False')
-        self.flakes('import fu; not fu.bar')
-
-    def test_usedInList(self):
-        self.flakes('import fu; [fu]')
-
-    def test_usedInTuple(self):
-        self.flakes('import fu; (fu,)')
-
-    def test_usedInTry(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_usedInExcept(self):
-        self.flakes('''
-        import fu
-        try: fu
-        except: pass
-        ''')
-
-    def test_redefinedByExcept(self):
-        self.flakes('''
-        import fu
-        try: pass
-        except Exception, fu: pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_usedInRaise(self):
-        self.flakes('''
-        import fu
-        raise fu.bar
-        ''')
-
-    def test_usedInYield(self):
-        self.flakes('''
-        import fu
-        def gen():
-            yield fu
-        ''')
-
-    def test_usedInDict(self):
-        self.flakes('import fu; {fu:None}')
-        self.flakes('import fu; {1:fu}')
-
-    def test_usedInParameterDefault(self):
-        self.flakes('''
-        import fu
-        def f(bar=fu):
-            pass
-        ''')
-
-    def test_usedInAttributeAssign(self):
-        self.flakes('import fu; fu.bar = 1')
-
-    def test_usedInKeywordArg(self):
-        self.flakes('import fu; fu.bar(stuff=fu)')
-
-    def test_usedInAssignment(self):
-        self.flakes('import fu; bar=fu')
-        self.flakes('import fu; n=0; n+=fu')
-
-    def test_usedInListComp(self):
-        self.flakes('import fu; [fu for _ in range(1)]')
-        self.flakes('import fu; [1 for _ in range(1) if fu]')
-
-    def test_redefinedByListComp(self):
-        self.flakes('import fu; [1 for fu in range(1)]', m.RedefinedWhileUnused)
-
-
-    def test_usedInTryFinally(self):
-        self.flakes('''
-        import fu
-        try: pass
-        finally: fu
-        ''')
-
-        self.flakes('''
-        import fu
-        try: fu
-        finally: pass
-        ''')
-
-    def test_usedInWhile(self):
-        self.flakes('''
-        import fu
-        while 0:
-            fu
-        ''')
-
-        self.flakes('''
-        import fu
-        while fu: pass
-        ''')
-
-    def test_usedInGlobal(self):
-        self.flakes('''
-        import fu
-        def f(): global fu
-        ''', m.UnusedImport)
-
-    def test_usedInBackquote(self):
-        self.flakes('import fu; `fu`')
-
-    def test_usedInExec(self):
-        self.flakes('import fu; exec "print 1" in fu.bar')
-
-    def test_usedInLambda(self):
-        self.flakes('import fu; lambda: fu')
-
-    def test_shadowedByLambda(self):
-        self.flakes('import fu; lambda fu: fu', m.UnusedImport)
-
-    def test_usedInSliceObj(self):
-        self.flakes('import fu; "meow"[::fu]')
-
-    def test_unusedInNestedScope(self):
-        self.flakes('''
-        def bar():
-            import fu
-        fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_methodsDontUseClassScope(self):
-        self.flakes('''
-        class bar:
-            import fu
-            def fun(self):
-                fu
-        ''', m.UnusedImport, m.UndefinedName)
-
-    def test_nestedFunctionsNestScope(self):
-        self.flakes('''
-        def a():
-            def b():
-                fu
-            import fu
-        ''')
-
-    def test_nestedClassAndFunctionScope(self):
-        self.flakes('''
-        def a():
-            import fu
-            class b:
-                def c(self):
-                    print fu
-        ''')
-
-    def test_importStar(self):
-        self.flakes('from fu import *', m.ImportStarUsed)
-
-
-    def test_packageImport(self):
-        """
-        If a dotted name is imported and used, no warning is reported.
-        """
-        self.flakes('''
-        import fu.bar
-        fu.bar
-        ''')
-
-
-    def test_unusedPackageImport(self):
-        """
-        If a dotted name is imported and not used, an unused import warning is
-        reported.
-        """
-        self.flakes('import fu.bar', m.UnusedImport)
-
-
-    def test_duplicateSubmoduleImport(self):
-        """
-        If a submodule of a package is imported twice, an unused import warning
-        and a redefined while unused warning are reported.
-        """
-        self.flakes('''
-        import fu.bar, fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-        self.flakes('''
-        import fu.bar
-        import fu.bar
-        fu.bar
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_differentSubmoduleImport(self):
-        """
-        If two different submodules of a package are imported, no duplicate
-        import warning is reported for the package.
-        """
-        self.flakes('''
-        import fu.bar, fu.baz
-        fu.bar, fu.baz
-        ''')
-        self.flakes('''
-        import fu.bar
-        import fu.baz
-        fu.bar, fu.baz
-        ''')
-
-    def test_assignRHSFirst(self):
-        self.flakes('import fu; fu = fu')
-        self.flakes('import fu; fu, bar = fu')
-        self.flakes('import fu; [fu, bar] = fu')
-        self.flakes('import fu; fu += fu')
-
-    def test_tryingMultipleImports(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            import bar as fu
-        ''')
-    test_tryingMultipleImports.todo = ''
-
-    def test_nonGlobalDoesNotRedefine(self):
-        self.flakes('''
-        import fu
-        def a():
-            fu = 3
-            return fu
-        fu
-        ''')
-
-    def test_functionsRunLater(self):
-        self.flakes('''
-        def a():
-            fu
-        import fu
-        ''')
-
-    def test_functionNamesAreBoundNow(self):
-        self.flakes('''
-        import fu
-        def fu():
-            fu
-        fu
-        ''', m.RedefinedWhileUnused)
-
-    def test_importingForImportError(self):
-        self.flakes('''
-        try:
-            import fu
-        except ImportError:
-            pass
-        ''')
-    test_importingForImportError.todo = ''
-
-    def test_importedInClass(self):
-        '''Imports in class scope can be used through self'''
-        self.flakes('''
-        class c:
-            import i
-            def __init__(self):
-                self.i
-        ''')
-    test_importedInClass.todo = 'requires evaluating attribute access'
-
-    def test_futureImport(self):
-        '''__future__ is special'''
-        self.flakes('from __future__ import division')
-        self.flakes('''
-        "docstring is allowed before future import"
-        from __future__ import division
-        ''')
-
-    def test_futureImportFirst(self):
-        """
-        __future__ imports must come before anything else.
-        """
-        self.flakes('''
-        x = 5
-        from __future__ import division
-        ''', m.LateFutureImport)
-        self.flakes('''
-        from foo import bar
-        from __future__ import division
-        bar
-        ''', m.LateFutureImport)
-
-
-
-class TestSpecialAll(harness.Test):
-    """
-    Tests for suppression of unused import warnings by C{__all__}.
-    """
-    def test_ignoredInFunction(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        function scope.
-        """
-        self.flakes('''
-        def foo():
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport, m.UnusedVariable)
-
-
-    def test_ignoredInClass(self):
-        """
-        An C{__all__} definition does not suppress unused import warnings in a
-        class scope.
-        """
-        self.flakes('''
-        class foo:
-            import bar
-            __all__ = ["bar"]
-        ''', m.UnusedImport)
-
-
-    def test_warningSuppressed(self):
-        """
-        If a name is imported and unused but is named in C{__all__}, no warning
-        is reported.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["foo"]
-        ''')
-
-
-    def test_unrecognizable(self):
-        """
-        If C{__all__} is defined in a way that can't be recognized statically,
-        it is ignored.
-        """
-        self.flakes('''
-        import foo
-        __all__ = ["f" + "oo"]
-        ''', m.UnusedImport)
-        self.flakes('''
-        import foo
-        __all__ = [] + ["foo"]
-        ''', m.UnusedImport)
-
-
-    def test_unboundExported(self):
-        """
-        If C{__all__} includes a name which is not bound, a warning is emitted.
-        """
-        self.flakes('''
-        __all__ = ["foo"]
-        ''', m.UndefinedExport)
-
-        # Skip this in __init__.py though, since the rules there are a little
-        # different.
-        for filename in ["foo/__init__.py", "__init__.py"]:
-            self.flakes('''
-            __all__ = ["foo"]
-            ''', filename=filename)
-
-
-    def test_usedInGenExp(self):
-        """
-        Using a global in a generator expression results in no warnings.
-        """
-        self.flakes('import fu; (fu for _ in range(1))')
-        self.flakes('import fu; (1 for _ in range(1) if fu)')
-
-
-    def test_redefinedByGenExp(self):
-        """
-        Re-using a global name as the loop variable for a generator
-        expression results in a redefinition warning.
-        """
-        self.flakes('import fu; (1 for fu in range(1))', m.RedefinedWhileUnused)
-
-
-    def test_usedAsDecorator(self):
-        """
-        Using a global name in a decorator statement results in no warnings,
-        but using an undefined name in a decorator statement results in an
-        undefined name warning.
-        """
-        self.flakes('''
-        from interior import decorate
-        @decorate
-        def f():
-            return "hello"
-        ''')
-
-        self.flakes('''
-        from interior import decorate
-        @decorate('value')
-        def f():
-            return "hello"
-        ''')
-
-        self.flakes('''
-        @decorate
-        def f():
-            return "hello"
-        ''', m.UndefinedName)
-
-
-class Python26Tests(harness.Test):
-    """
-    Tests for checking of syntax which is valid in PYthon 2.6 and newer.
-    """
-    if version_info < (2, 6):
-        skip = "Python 2.6 required for class decorator tests."
-
-
-    def test_usedAsClassDecorator(self):
-        """
-        Using an imported name as a class decorator results in no warnings,
-        but using an undefined name as a class decorator results in an
-        undefined name warning.
-        """
-        self.flakes('''
-        from interior import decorate
-        @decorate
-        class foo:
-            pass
-        ''')
-
-        self.flakes('''
-        from interior import decorate
-        @decorate("foo")
-        class bar:
-            pass
-        ''')
-
-        self.flakes('''
-        @decorate
-        class foo:
-            pass
-        ''', m.UndefinedName)

=== removed file 'Pyflakes/pyflakes/test/test_other.py'
--- Pyflakes/pyflakes/test/test_other.py	2011-11-17 16:21:58 +0000
+++ Pyflakes/pyflakes/test/test_other.py	1970-01-01 00:00:00 +0000
@@ -1,654 +0,0 @@
-# (c) 2005-2010 Divmod, Inc.
-# See LICENSE file for details
-
-"""
-Tests for various Pyflakes behavior.
-"""
-
-from sys import version_info
-
-from pyflakes import messages as m
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
-
-    def test_duplicateArgs(self):
-        self.flakes('def fu(bar, bar): pass', m.DuplicateArgument)
-
-    def test_localReferencedBeforeAssignment(self):
-        self.flakes('''
-        a = 1
-        def f():
-            a; a=1
-        f()
-        ''', m.UndefinedName)
-    test_localReferencedBeforeAssignment.todo = 'this requires finding all assignments in the function body first'
-
-    def test_redefinedFunction(self):
-        """
-        Test that shadowing a function definition with another one raises a
-        warning.
-        """
-        self.flakes('''
-        def a(): pass
-        def a(): pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_redefinedClassFunction(self):
-        """
-        Test that shadowing a function definition in a class suite with another
-        one raises a warning.
-        """
-        self.flakes('''
-        class A:
-            def a(): pass
-            def a(): pass
-        ''', m.RedefinedWhileUnused)
-
-    def test_functionDecorator(self):
-        """
-        Test that shadowing a function definition with a decorated version of
-        that function does not raise a warning.
-        """
-        self.flakes('''
-        from somewhere import somedecorator
-
-        def a(): pass
-        a = somedecorator(a)
-        ''')
-
-    def test_classFunctionDecorator(self):
-        """
-        Test that shadowing a function definition in a class suite with a
-        decorated version of that function does not raise a warning.
-        """
-        self.flakes('''
-        class A:
-            def a(): pass
-            a = classmethod(a)
-        ''')
-
-    def test_unaryPlus(self):
-        '''Don't die on unary +'''
-        self.flakes('+1')
-
-
-    def test_undefinedBaseClass(self):
-        """
-        If a name in the base list of a class definition is undefined, a
-        warning is emitted.
-        """
-        self.flakes('''
-        class foo(foo):
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_classNameUndefinedInClassBody(self):
-        """
-        If a class name is used in the body of that class's definition and
-        the name is not already defined, a warning is emitted.
-        """
-        self.flakes('''
-        class foo:
-            foo
-        ''', m.UndefinedName)
-
-
-    def test_classNameDefinedPreviously(self):
-        """
-        If a class name is used in the body of that class's definition and
-        the name was previously defined in some other way, no warning is
-        emitted.
-        """
-        self.flakes('''
-        foo = None
-        class foo:
-            foo
-        ''')
-
-
-    def test_classRedefinition(self):
-        """
-        If a class is defined twice in the same module, a warning is emitted.
-        """
-        self.flakes(
-        '''
-        class Foo:
-            pass
-        class Foo:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_functionRedefinedAsClass(self):
-        """
-        If a function is redefined as a class, a warning is emitted.
-        """
-        self.flakes(
-        '''
-        def Foo():
-            pass
-        class Foo:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_classRedefinedAsFunction(self):
-        """
-        If a class is redefined as a function, a warning is emitted.
-        """
-        self.flakes(
-        '''
-        class Foo:
-            pass
-        def Foo():
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_doubleAssignment(self):
-        """
-        If a variable is re-assigned to without being used, no warning is
-        emitted.
-        """
-        self.flakes(
-        '''
-        x = 10
-        x = 20
-        ''', m.RedefinedWhileUnused)
-    test_doubleAssignment.todo = (
-        "Too hard to make this warn but other cases stay silent")
-
-
-    def test_doubleAssignmentConditionally(self):
-        """
-        If a variable is re-assigned within a conditional, no warning is
-        emitted.
-        """
-        self.flakes(
-        '''
-        x = 10
-        if True:
-            x = 20
-        ''')
-
-
-    def test_doubleAssignmentWithUse(self):
-        """
-        If a variable is re-assigned to after being used, no warning is
-        emitted.
-        """
-        self.flakes(
-        '''
-        x = 10
-        y = x * 2
-        x = 20
-        ''')
-
-
-    def test_comparison(self):
-        """
-        If a defined name is used on either side of any of the six comparison
-        operators, no warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x < y
-        x <= y
-        x == y
-        x != y
-        x >= y
-        x > y
-        ''')
-
-
-    def test_identity(self):
-        """
-        If a defined name is used on either side of an identity test, no
-        warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x is y
-        x is not y
-        ''')
-
-
-    def test_containment(self):
-        """
-        If a defined name is used on either side of a containment test, no
-        warning is emitted.
-        """
-        self.flakes('''
-        x = 10
-        y = 20
-        x in y
-        x not in y
-        ''')
-
-
-    def test_loopControl(self):
-        """
-        break and continue statements are supported.
-        """
-        self.flakes('''
-        for x in [1, 2]:
-            break
-        ''')
-        self.flakes('''
-        for x in [1, 2]:
-            continue
-        ''')
-
-
-    def test_ellipsis(self):
-        """
-        Ellipsis in a slice is supported.
-        """
-        self.flakes('''
-        [1, 2][...]
-        ''')
-
-
-    def test_extendedSlice(self):
-        """
-        Extended slices are supported.
-        """
-        self.flakes('''
-        x = 3
-        [1, 2][x,:]
-        ''')
-
-
-
-class TestUnusedAssignment(harness.Test):
-    """
-    Tests for warning about unused assignments.
-    """
-
-    def test_unusedVariable(self):
-        """
-        Warn when a variable in a function is assigned a value that's never
-        used.
-        """
-        self.flakes('''
-        def a():
-            b = 1
-        ''', m.UnusedVariable)
-
-
-    def test_assignToGlobal(self):
-        """
-        Assigning to a global and then not using that global is perfectly
-        acceptable. Do not mistake it for an unused local variable.
-        """
-        self.flakes('''
-        b = 0
-        def a():
-            global b
-            b = 1
-        ''')
-
-
-    def test_assignToMember(self):
-        """
-        Assigning to a member of another object and then not using that member
-        variable is perfectly acceptable. Do not mistake it for an unused
-        local variable.
-        """
-        # XXX: Adding this test didn't generate a failure. Maybe not
-        # necessary?
-        self.flakes('''
-        class b:
-            pass
-        def a():
-            b.foo = 1
-        ''')
-
-
-    def test_assignInForLoop(self):
-        """
-        Don't warn when a variable in a for loop is assigned to but not used.
-        """
-        self.flakes('''
-        def f():
-            for i in range(10):
-                pass
-        ''')
-
-
-    def test_assignInListComprehension(self):
-        """
-        Don't warn when a variable in a list comprehension is assigned to but
-        not used.
-        """
-        self.flakes('''
-        def f():
-            [None for i in range(10)]
-        ''')
-
-
-    def test_generatorExpression(self):
-        """
-        Don't warn when a variable in a generator expression is assigned to but not used.
-        """
-        self.flakes('''
-        def f():
-            (None for i in range(10))
-        ''')
-
-
-    def test_assignmentInsideLoop(self):
-        """
-        Don't warn when a variable assignment occurs lexically after its use.
-        """
-        self.flakes('''
-        def f():
-            x = None
-            for i in range(10):
-                if i > 2:
-                    return x
-                x = i * 2
-        ''')
-
-
-    def test_tupleUnpacking(self):
-        """
-        Don't warn when a variable included in tuple unpacking is unused. It's
-        very common for variables in a tuple unpacking assignment to be unused
-        in good Python code, so warning will only create false positives.
-        """
-        self.flakes('''
-        def f():
-            (x, y) = 1, 2
-        ''')
-
-
-    def test_listUnpacking(self):
-        """
-        Don't warn when a variable included in list unpacking is unused.
-        """
-        self.flakes('''
-        def f():
-            [x, y] = [1, 2]
-        ''')
-
-
-    def test_closedOver(self):
-        """
-        Don't warn when the assignment is used in an inner function.
-        """
-        self.flakes('''
-        def barMaker():
-            foo = 5
-            def bar():
-                return foo
-            return bar
-        ''')
-
-
-    def test_doubleClosedOver(self):
-        """
-        Don't warn when the assignment is used in an inner function, even if
-        that inner function itself is in an inner function.
-        """
-        self.flakes('''
-        def barMaker():
-            foo = 5
-            def bar():
-                def baz():
-                    return foo
-            return bar
-        ''')
-
-
-
-class Python25Test(harness.Test):
-    """
-    Tests for checking of syntax only available in Python 2.5 and newer.
-    """
-    if version_info < (2, 5):
-        skip = "Python 2.5 required for if-else and with tests"
-
-    def test_ifexp(self):
-        """
-        Test C{foo if bar else baz} statements.
-        """
-        self.flakes("a = 'moo' if True else 'oink'")
-        self.flakes("a = foo if True else 'oink'", m.UndefinedName)
-        self.flakes("a = 'moo' if True else bar", m.UndefinedName)
-
-
-    def test_withStatementNoNames(self):
-        """
-        No warnings are emitted for using inside or after a nameless C{with}
-        statement a name defined beforehand.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        bar = None
-        with open("foo"):
-            bar
-        bar
-        ''')
-
-    def test_withStatementSingleName(self):
-        """
-        No warnings are emitted for using a name defined by a C{with} statement
-        within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            bar
-        bar
-        ''')
-
-
-    def test_withStatementAttributeName(self):
-        """
-        No warnings are emitted for using an attribute as the target of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo.bar:
-            pass
-        ''')
-
-
-    def test_withStatementSubscript(self):
-        """
-        No warnings are emitted for using a subscript as the target of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo[0]:
-            pass
-        ''')
-
-
-    def test_withStatementSubscriptUndefined(self):
-        """
-        An undefined name warning is emitted if the subscript used as the
-        target of a C{with} statement is not defined.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import foo
-        with open('foo') as foo[bar]:
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementTupleNames(self):
-        """
-        No warnings are emitted for using any of the tuple of names defined by
-        a C{with} statement within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as (bar, baz):
-            bar, baz
-        bar, baz
-        ''')
-
-
-    def test_withStatementListNames(self):
-        """
-        No warnings are emitted for using any of the list of names defined by a
-        C{with} statement within the suite or afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as [bar, baz]:
-            bar, baz
-        bar, baz
-        ''')
-
-
-    def test_withStatementComplicatedTarget(self):
-        """
-        If the target of a C{with} statement uses any or all of the valid forms
-        for that part of the grammar (See
-        U{http://docs.python.org/reference/compound_stmts.html#the-with-statement}),
-        the names involved are checked both for definedness and any bindings
-        created are respected in the suite of the statement and afterwards.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        c = d = e = g = h = i = None
-        with open('foo') as [(a, b), c[d], e.f, g[h:i]]:
-            a, b, c, d, e, g, h, i
-        a, b, c, d, e, g, h, i
-        ''')
-
-
-    def test_withStatementSingleNameUndefined(self):
-        """
-        An undefined name warning is emitted if the name first defined by a
-        C{with} statement is used before the C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        bar
-        with open('foo') as bar:
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementTupleNamesUndefined(self):
-        """
-        An undefined name warning is emitted if a name first defined by a the
-        tuple-unpacking form of the C{with} statement is used before the
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        baz
-        with open('foo') as (bar, baz):
-            pass
-        ''', m.UndefinedName)
-
-
-    def test_withStatementSingleNameRedefined(self):
-        """
-        A redefined name warning is emitted if a name bound by an import is
-        rebound by the name defined by a C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import bar
-        with open('foo') as bar:
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_withStatementTupleNamesRedefined(self):
-        """
-        A redefined name warning is emitted if a name bound by an import is
-        rebound by one of the names defined by the tuple-unpacking form of a
-        C{with} statement.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        import bar
-        with open('foo') as (bar, baz):
-            pass
-        ''', m.RedefinedWhileUnused)
-
-
-    def test_withStatementUndefinedInside(self):
-        """
-        An undefined name warning is emitted if a name is used inside the
-        body of a C{with} statement without first being bound.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            baz
-        ''', m.UndefinedName)
-
-
-    def test_withStatementNameDefinedInBody(self):
-        """
-        A name defined in the body of a C{with} statement can be used after
-        the body ends without warning.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with open('foo') as bar:
-            baz = 10
-        baz
-        ''')
-
-
-    def test_withStatementUndefinedInExpression(self):
-        """
-        An undefined name warning is emitted if a name in the I{test}
-        expression of a C{with} statement is undefined.
-        """
-        self.flakes('''
-        from __future__ import with_statement
-        with bar as baz:
-            pass
-        ''', m.UndefinedName)
-
-        self.flakes('''
-        from __future__ import with_statement
-        with bar as bar:
-            pass
-        ''', m.UndefinedName)
-
-
-
-class Python27Test(harness.Test):
-    """
-    Tests for checking of syntax only available in Python 2.7 and newer.
-    """
-    if version_info < (2, 7):
-        skip = "Python 2.7 required for dict/set comprehension tests"
-
-    def test_dictComprehension(self):
-        """
-        Dict comprehensions are properly handled.
-        """
-        self.flakes('''
-        a = {1: x for x in range(10)}
-        ''')
-
-    def test_setComprehensionAndLiteral(self):
-        """
-        Set comprehensions are properly handled.
-        """
-        self.flakes('''
-        a = {1, 2, 3}
-        b = {x for x in range(10)}
-        ''')

=== removed file 'Pyflakes/pyflakes/test/test_script.py'
--- Pyflakes/pyflakes/test/test_script.py	2012-10-23 11:52:32 +0000
+++ Pyflakes/pyflakes/test/test_script.py	1970-01-01 00:00:00 +0000
@@ -1,563 +0,0 @@
-"""
-Tests for L{pyflakes.scripts.pyflakes}.
-"""
-
-import os
-import sys
-from StringIO import StringIO
-
-from twisted.internet import protocol
-from twisted.internet.utils import (
-    _callProtocolWithDeferred,
-    getProcessOutputAndValue,
-    )
-from twisted.python.filepath import FilePath
-from twisted.trial.unittest import TestCase
-
-from pyflakes.messages import UnusedImport
-from pyflakes.reporter import Reporter
-from pyflakes.scripts.pyflakes import (
-    checkPath,
-    checkRecursive,
-    iterSourceCode,
-    )
-
-
-def withStderrTo(stderr, f, *args, **kwargs):
-    """
-    Call C{f} with C{sys.stderr} redirected to C{stderr}.
-    """
-    (outer, sys.stderr) = (sys.stderr, stderr)
-    try:
-        return f(*args, **kwargs)
-    finally:
-        sys.stderr = outer
-
-
-
-class LoggingReporter(object):
-    """
-    Implementation of Reporter that just appends any errors to a list.
-    """
-
-    def __init__(self, log):
-        """
-        Construct a C{LoggingReporter}.
-
-        @param log: A list to append log messages to.
-        """
-        self.log = log
-
-
-    def flake(self, message):
-        self.log.append(('flake', str(message)))
-
-
-    def unexpectedError(self, filename, message):
-        self.log.append(('unexpectedError', filename, message))
-
-
-    def syntaxError(self, filename, msg, lineno, offset, line):
-        self.log.append(('syntaxError', filename, msg, lineno, offset, line))
-
-
-
-class TestIterSourceCode(TestCase):
-    """
-    Tests for L{iterSourceCode}.
-    """
-
-    def test_emptyDirectory(self):
-        """
-        There are no Python files in an empty directory.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        self.assertEqual(list(iterSourceCode([tempdir.path])), [])
-
-
-    def test_singleFile(self):
-        """
-        If the directory contains one Python file, C{iterSourceCode} will find
-        it.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        tempdir.child('foo.py').touch()
-        self.assertEqual(
-            list(iterSourceCode([tempdir.path])),
-            [tempdir.child('foo.py').path])
-
-
-    def test_onlyPythonSource(self):
-        """
-        Files that are not Python source files are not included.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        tempdir.child('foo.pyc').touch()
-        self.assertEqual(list(iterSourceCode([tempdir.path])), [])
-
-
-    def test_recurses(self):
-        """
-        If the Python files are hidden deep down in child directories, we will
-        find them.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        tempdir.child('foo').createDirectory()
-        tempdir.child('foo').child('a.py').touch()
-        tempdir.child('bar').createDirectory()
-        tempdir.child('bar').child('b.py').touch()
-        tempdir.child('c.py').touch()
-        self.assertEqual(
-            sorted(iterSourceCode([tempdir.path])),
-            sorted([tempdir.child('foo').child('a.py').path,
-                    tempdir.child('bar').child('b.py').path,
-                    tempdir.child('c.py').path]))
-
-
-    def test_multipleDirectories(self):
-        """
-        L{iterSourceCode} can be given multiple directories.  It will recurse
-        into each of them.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        foo = tempdir.child('foo')
-        foo.createDirectory()
-        foo.child('a.py').touch()
-        bar = tempdir.child('bar')
-        bar.createDirectory()
-        bar.child('b.py').touch()
-        self.assertEqual(
-            sorted(iterSourceCode([foo.path, bar.path])),
-            sorted([foo.child('a.py').path,
-                    bar.child('b.py').path]))
-
-
-    def test_explicitFiles(self):
-        """
-        If one of the paths given to L{iterSourceCode} is not a directory but
-        a file, it will include that in its output.
-        """
-        tempfile = FilePath(self.mktemp())
-        tempfile.touch()
-        self.assertEqual(list(iterSourceCode([tempfile.path])),
-                         [tempfile.path])
-
-
-
-class TestReporter(TestCase):
-    """
-    Tests for L{Reporter}.
-    """
-
-    def test_syntaxError(self):
-        """
-        C{syntaxError} reports that there was a syntax error in the source
-        file.  It reports to the error stream and includes the filename, line
-        number, error message, actual line of source and a caret pointing to
-        where the error is.
-        """
-        err = StringIO()
-        reporter = Reporter(None, err)
-        reporter.syntaxError('foo.py', 'a problem', 3, 4, 'bad line of source')
-        self.assertEquals(
-            ("foo.py:3: a problem\n"
-             "bad line of source\n"
-             "     ^\n"),
-            err.getvalue())
-
-
-    def test_syntaxErrorNoOffset(self):
-        """
-        C{syntaxError} doesn't include a caret pointing to the error if
-        C{offset} is passed as C{None}.
-        """
-        err = StringIO()
-        reporter = Reporter(None, err)
-        reporter.syntaxError('foo.py', 'a problem', 3, None,
-                             'bad line of source')
-        self.assertEquals(
-            ("foo.py:3: a problem\n"
-             "bad line of source\n"),
-            err.getvalue())
-
-
-    def test_multiLineSyntaxError(self):
-        """
-        If there's a multi-line syntax error, then we only report the last
-        line.  The offset is adjusted so that it is relative to the start of
-        the last line.
-        """
-        err = StringIO()
-        lines = [
-            'bad line of source',
-            'more bad lines of source',
-            ]
-        reporter = Reporter(None, err)
-        reporter.syntaxError('foo.py', 'a problem', 3, len(lines[0]) + 5,
-                             '\n'.join(lines))
-        self.assertEquals(
-            ("foo.py:3: a problem\n" +
-             lines[-1] + "\n" +
-             "     ^\n"),
-            err.getvalue())
-
-
-    def test_unexpectedError(self):
-        """
-        C{unexpectedError} reports an error processing a source file.
-        """
-        err = StringIO()
-        reporter = Reporter(None, err)
-        reporter.unexpectedError(u'source.py', u'error message')
-        self.assertEquals(u'source.py: error message\n', err.getvalue())
-
-
-    def test_flake(self):
-        """
-        C{flake} reports a code warning from Pyflakes.  It is exactly the
-        str() of a L{pyflakes.messages.Message}.
-        """
-        out = StringIO()
-        reporter = Reporter(out, None)
-        message = UnusedImport('foo.py', 42, 'bar')
-        reporter.flake(message)
-        self.assertEquals(out.getvalue(), "%s\n" % (message,))
-
-
-
-class CheckTests(TestCase):
-    """
-    Tests for L{check} and L{checkPath} which check a file for flakes.
-    """
-
-    def makeTempFile(self, content):
-        """
-        Make a temporary file containing C{content} and return a path to it.
-        """
-        path = FilePath(self.mktemp())
-        path.setContent(content)
-        return path.path
-
-
-    def assertHasErrors(self, path, errorList):
-        """
-        Assert that C{path} causes errors.
-
-        @param path: A path to a file to check.
-        @param errorList: A list of errors expected to be printed to stderr.
-        """
-        err = StringIO()
-        count = withStderrTo(err, checkPath, path)
-        self.assertEquals(
-            (count, err.getvalue()), (len(errorList), ''.join(errorList)))
-
-
-    def getErrors(self, path):
-        """
-        Get any warnings or errors reported by pyflakes for the file at C{path}.
-
-        @param path: The path to a Python file on disk that pyflakes will check.
-        @return: C{(count, log)}, where C{count} is the number of warnings or
-            errors generated, and log is a list of those warnings, presented
-            as structured data.  See L{LoggingReporter} for more details.
-        """
-        log = []
-        reporter = LoggingReporter(log)
-        count = checkPath(path, reporter)
-        return count, log
-
-
-    def test_missingTrailingNewline(self):
-        """
-        Source which doesn't end with a newline shouldn't cause any
-        exception to be raised nor an error indicator to be returned by
-        L{check}.
-        """
-        fName = self.makeTempFile("def foo():\n\tpass\n\t")
-        self.assertHasErrors(fName, [])
-
-
-    def test_checkPathNonExisting(self):
-        """
-        L{checkPath} handles non-existing files.
-        """
-        count, errors = self.getErrors('extremo')
-        self.assertEquals(count, 1)
-        self.assertEquals(
-            errors,
-            [('unexpectedError', 'extremo', 'No such file or directory')])
-
-
-    def test_multilineSyntaxError(self):
-        """
-        Source which includes a syntax error which results in the raised
-        L{SyntaxError.text} containing multiple lines of source are reported
-        with only the last line of that source.
-        """
-        source = """\
-def foo():
-    '''
-
-def bar():
-    pass
-
-def baz():
-    '''quux'''
-"""
-
-        # Sanity check - SyntaxError.text should be multiple lines, if it
-        # isn't, something this test was unprepared for has happened.
-        def evaluate(source):
-            exec source
-        exc = self.assertRaises(SyntaxError, evaluate, source)
-        self.assertTrue(exc.text.count('\n') > 1)
-
-        sourcePath = self.makeTempFile(source)
-        self.assertHasErrors(
-            sourcePath, ["""\
-%s:8: invalid syntax
-    '''quux'''
-           ^
-"""
-                % (sourcePath,)])
-
-
-    def test_eofSyntaxError(self):
-        """
-        The error reported for source files which end prematurely causing a
-        syntax error reflects the cause for the syntax error.
-        """
-        sourcePath = self.makeTempFile("def foo(")
-        self.assertHasErrors(
-            sourcePath,
-            ["""\
-%s:1: unexpected EOF while parsing
-def foo(
-         ^
-""" % (sourcePath,)])
-
-
-    def test_nonDefaultFollowsDefaultSyntaxError(self):
-        """
-        Source which has a non-default argument following a default argument
-        should include the line number of the syntax error.  However these
-        exceptions do not include an offset.
-        """
-        source = """\
-def foo(bar=baz, bax):
-    pass
-"""
-        sourcePath = self.makeTempFile(source)
-        self.assertHasErrors(
-            sourcePath,
-            ["""\
-%s:1: non-default argument follows default argument
-def foo(bar=baz, bax):
-""" % (sourcePath,)])
-
-
-    def test_nonKeywordAfterKeywordSyntaxError(self):
-        """
-        Source which has a non-keyword argument after a keyword argument should
-        include the line number of the syntax error.  However these exceptions
-        do not include an offset.
-        """
-        source = """\
-foo(bar=baz, bax)
-"""
-        sourcePath = self.makeTempFile(source)
-        self.assertHasErrors(
-            sourcePath,
-            ["""\
-%s:1: non-keyword arg after keyword arg
-foo(bar=baz, bax)
-""" % (sourcePath,)])
-
-
-    def test_permissionDenied(self):
-        """
-        If the source file is not readable, this is reported on standard
-        error.
-        """
-        sourcePath = FilePath(self.mktemp())
-        sourcePath.setContent('')
-        sourcePath.chmod(0)
-        count, errors = self.getErrors(sourcePath.path)
-        self.assertEquals(count, 1)
-        self.assertEquals(
-            errors,
-            [('unexpectedError', sourcePath.path, "Permission denied")])
-
-
-    def test_pyflakesWarning(self):
-        """
-        If the source file has a pyflakes warning, this is reported as a
-        'flake'.
-        """
-        sourcePath = self.makeTempFile("import foo")
-        count, errors = self.getErrors(sourcePath)
-        self.assertEquals(count, 1)
-        self.assertEquals(
-            errors, [('flake', str(UnusedImport(sourcePath, 1, 'foo')))])
-
-
-    def test_misencodedFile(self):
-        """
-        If a source file contains bytes which cannot be decoded, this is
-        reported on stderr.
-        """
-        source = u"""\
-# coding: ascii
-x = "\N{SNOWMAN}"
-""".encode('utf-8')
-        sourcePath = self.makeTempFile(source)
-        self.assertHasErrors(
-            sourcePath, ["%s: problem decoding source\n" % (sourcePath,)])
-
-
-    def test_checkRecursive(self):
-        """
-        L{checkRecursive} descends into each directory, finding Python files
-        and reporting problems.
-        """
-        tempdir = FilePath(self.mktemp())
-        tempdir.createDirectory()
-        tempdir.child('foo').createDirectory()
-        file1 = tempdir.child('foo').child('bar.py')
-        file1.setContent("import baz\n")
-        file2 = tempdir.child('baz.py')
-        file2.setContent("import contraband")
-        log = []
-        reporter = LoggingReporter(log)
-        warnings = checkRecursive([tempdir.path], reporter)
-        self.assertEqual(warnings, 2)
-        self.assertEqual(
-            sorted(log),
-            sorted([('flake', str(UnusedImport(file1.path, 1, 'baz'))),
-                    ('flake',
-                     str(UnusedImport(file2.path, 1, 'contraband')))]))
-
-
-
-class _EverythingGetterWithStdin(protocol.ProcessProtocol):
-    """
-    C{ProcessProtocol} that writes to stdin and gathers exit code, stdout and
-    stderr.
-    """
-
-    # Although Twisted provides a helper that spawns a subprocess, gathers its
-    # exit code, standard output and standard error
-    # (i.e. getProcessOutputAndValue), it does *not* provide one that data to
-    # be written to stdin first.
-
-    def __init__(self, deferred, stdin):
-        self.deferred = deferred
-        self.outBuf = StringIO()
-        self.errBuf = StringIO()
-        self.outReceived = self.outBuf.write
-        self.errReceived = self.errBuf.write
-        self.stdin = stdin
-
-
-    def connectionMade(self):
-        self.transport.write(self.stdin)
-        self.transport.closeStdin()
-
-
-    def processEnded(self, reason):
-        out = self.outBuf.getvalue()
-        err = self.errBuf.getvalue()
-        e = reason.value
-        code = e.exitCode
-        if e.signal:
-            code = -e.signal
-        self.deferred.callback((out, err, code))
-
-
-
-class IntegrationTests(TestCase):
-    """
-    Tests of the pyflakes script that actually spawn the script.
-    """
-
-    def getPyflakesBinary(self):
-        """
-        Return the path to the pyflakes binary.
-        """
-        import pyflakes
-        package_dir = FilePath(pyflakes.__file__).parent()
-        return package_dir.sibling('bin').child('pyflakes').path
-
-
-    def runPyflakes(self, paths, stdin=None):
-        """
-        Launch a subprocess running C{pyflakes}.
-
-        @param args: Command-line arguments to pass to pyflakes.
-        @param kwargs: Options passed on to C{subprocess.Popen}.
-        @return: C{(returncode, stdout, stderr)} of the completed pyflakes
-            process.
-        """
-        env = dict(os.environ)
-        env['PYTHONPATH'] = os.pathsep.join(sys.path)
-        command = [self.getPyflakesBinary()]
-        command.extend(paths)
-        if stdin:
-            d = _callProtocolWithDeferred(
-                lambda d: _EverythingGetterWithStdin(d, stdin),
-                sys.executable, command, env=env, path=None)
-        else:
-            d = getProcessOutputAndValue(sys.executable, command, env=env)
-        return d
-
-
-    def test_goodFile(self):
-        """
-        When a Python source file is all good, the return code is zero and no
-        messages are printed to either stdout or stderr.
-        """
-        tempfile = FilePath(self.mktemp())
-        tempfile.touch()
-        d = self.runPyflakes([tempfile.path])
-        return d.addCallback(self.assertEqual, ('', '', 0))
-
-
-    def test_fileWithFlakes(self):
-        """
-        When a Python source file has warnings, the return code is non-zero
-        and the warnings are printed to stdout.
-        """
-        tempfile = FilePath(self.mktemp())
-        tempfile.setContent("import contraband\n")
-        d = self.runPyflakes([tempfile.path])
-        return d.addCallback(
-            self.assertEqual,
-            ("%s\n" % UnusedImport(tempfile.path, 1, 'contraband'), '', 1))
-
-
-    def test_errors(self):
-        """
-        When pyflakes finds errors with the files it's given, (if they don't
-        exist, say), then the return code is non-zero and the errors are
-        printed to stderr.
-        """
-        tempfile = FilePath(self.mktemp())
-        d = self.runPyflakes([tempfile.path])
-        return d.addCallback(
-            self.assertEqual,
-            ('', '%s: No such file or directory\n' % (tempfile.path,), 1))
-
-
-    def test_readFromStdin(self):
-        """
-        If no arguments are passed to C{pyflakes} then it reads from stdin.
-        """
-        d = self.runPyflakes([], stdin='import contraband')
-        return d.addCallback(
-            self.assertEqual,
-            ("%s\n" % UnusedImport('<stdin>', 1, 'contraband'), '', 1))

=== removed file 'Pyflakes/pyflakes/test/test_undefined_names.py'
--- Pyflakes/pyflakes/test/test_undefined_names.py	2011-12-04 20:27:45 +0000
+++ Pyflakes/pyflakes/test/test_undefined_names.py	1970-01-01 00:00:00 +0000
@@ -1,273 +0,0 @@
-
-from _ast import PyCF_ONLY_AST
-
-from twisted.trial.unittest import TestCase
-
-from pyflakes import messages as m, checker
-from pyflakes.test import harness
-
-
-class Test(harness.Test):
-    def test_undefined(self):
-        self.flakes('bar', m.UndefinedName)
-
-    def test_definedInListComp(self):
-        self.flakes('[a for a in range(10) if a]')
-
-
-    def test_functionsNeedGlobalScope(self):
-        self.flakes('''
-        class a:
-            def b():
-                fu
-        fu = 1
-        ''')
-
-    def test_builtins(self):
-        self.flakes('range(10)')
-
-
-    def test_builtinWindowsError(self):
-        """
-        C{WindowsError} is sometimes a builtin name, so no warning is emitted
-        for using it.
-        """
-        self.flakes('WindowsError')
-
-
-    def test_magicGlobalsFile(self):
-        """
-        Use of the C{__file__} magic global should not emit an undefined name
-        warning.
-        """
-        self.flakes('__file__')
-
-
-    def test_magicGlobalsBuiltins(self):
-        """
-        Use of the C{__builtins__} magic global should not emit an undefined
-        name warning.
-        """
-        self.flakes('__builtins__')
-
-
-    def test_magicGlobalsName(self):
-        """
-        Use of the C{__name__} magic global should not emit an undefined name
-        warning.
-        """
-        self.flakes('__name__')
-
-
-    def test_magicGlobalsPath(self):
-        """
-        Use of the C{__path__} magic global should not emit an undefined name
-        warning, if you refer to it from a file called __init__.py.
-        """
-        self.flakes('__path__', m.UndefinedName)
-        self.flakes('__path__', filename='package/__init__.py')
-
-
-    def test_globalImportStar(self):
-        '''Can't find undefined names with import *'''
-        self.flakes('from fu import *; bar', m.ImportStarUsed)
-
-    def test_localImportStar(self):
-        '''A local import * still allows undefined names to be found in upper scopes'''
-        self.flakes('''
-        def a():
-            from fu import *
-        bar
-        ''', m.ImportStarUsed, m.UndefinedName)
-
-    def test_unpackedParameter(self):
-        '''Unpacked function parameters create bindings'''
-        self.flakes('''
-        def a((bar, baz)):
-            bar; baz
-        ''')
-
-    def test_definedByGlobal(self):
-        '''"global" can make an otherwise undefined name in another function defined'''
-        self.flakes('''
-        def a(): global fu; fu = 1
-        def b(): fu
-        ''')
-    test_definedByGlobal.todo = ''
-
-    def test_globalInGlobalScope(self):
-        """
-        A global statement in the global scope is ignored.
-        """
-        self.flakes('''
-        global x
-        def foo():
-            print x
-        ''', m.UndefinedName)
-
-    def test_del(self):
-        '''del deletes bindings'''
-        self.flakes('a = 1; del a; a', m.UndefinedName)
-
-    def test_delGlobal(self):
-        '''del a global binding from a function'''
-        self.flakes('''
-        a = 1
-        def f():
-            global a
-            del a
-        a
-        ''')
-
-    def test_delUndefined(self):
-        '''del an undefined name'''
-        self.flakes('del a', m.UndefinedName)
-
-    def test_globalFromNestedScope(self):
-        '''global names are available from nested scopes'''
-        self.flakes('''
-        a = 1
-        def b():
-            def c():
-                a
-        ''')
-
-    def test_laterRedefinedGlobalFromNestedScope(self):
-        """
-        Test that referencing a local name that shadows a global, before it is
-        defined, generates a warning.
-        """
-        self.flakes('''
-        a = 1
-        def fun():
-            a
-            a = 2
-            return a
-        ''', m.UndefinedLocal)
-
-    def test_laterRedefinedGlobalFromNestedScope2(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        global declared in an enclosing scope, before it is defined, generates
-        a warning.
-        """
-        self.flakes('''
-            a = 1
-            def fun():
-                global a
-                def fun2():
-                    a
-                    a = 2
-                    return a
-        ''', m.UndefinedLocal)
-
-
-    def test_intermediateClassScopeIgnored(self):
-        """
-        If a name defined in an enclosing scope is shadowed by a local variable
-        and the name is used locally before it is bound, an unbound local
-        warning is emitted, even if there is a class scope between the enclosing
-        scope and the local scope.
-        """
-        self.flakes('''
-        def f():
-            x = 1
-            class g:
-                def h(self):
-                    a = x
-                    x = None
-                    print x, a
-            print x
-        ''', m.UndefinedLocal)
-
-
-    def test_doubleNestingReportsClosestName(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        variable declared in two different outer scopes before it is defined
-        in the innermost scope generates an UnboundLocal warning which
-        refers to the nearest shadowed name.
-        """
-        exc = self.flakes('''
-            def a():
-                x = 1
-                def b():
-                    x = 2 # line 5
-                    def c():
-                        x
-                        x = 3
-                        return x
-                    return x
-                return x
-        ''', m.UndefinedLocal).messages[0]
-        self.assertEqual(exc.message_args, ('x', 5))
-
-
-    def test_laterRedefinedGlobalFromNestedScope3(self):
-        """
-        Test that referencing a local name in a nested scope that shadows a
-        global, before it is defined, generates a warning.
-        """
-        self.flakes('''
-            def fun():
-                a = 1
-                def fun2():
-                    a
-                    a = 1
-                    return a
-                return a
-        ''', m.UndefinedLocal)
-
-    def test_nestedClass(self):
-        '''nested classes can access enclosing scope'''
-        self.flakes('''
-        def f(foo):
-            class C:
-                bar = foo
-                def f(self):
-                    return foo
-            return C()
-
-        f(123).f()
-        ''')
-
-    def test_badNestedClass(self):
-        '''free variables in nested classes must bind at class creation'''
-        self.flakes('''
-        def f():
-            class C:
-                bar = foo
-            foo = 456
-            return foo
-        f()
-        ''', m.UndefinedName)
-
-    def test_definedAsStarArgs(self):
-        '''star and double-star arg names are defined'''
-        self.flakes('''
-        def f(a, *b, **c):
-            print a, b, c
-        ''')
-
-    def test_definedInGenExp(self):
-        """
-        Using the loop variable of a generator expression results in no
-        warnings.
-        """
-        self.flakes('(a for a in xrange(10) if a)')
-
-
-
-class NameTests(TestCase):
-    """
-    Tests for some extra cases of name handling.
-    """
-    def test_impossibleContext(self):
-        """
-        A Name node with an unrecognized context results in a RuntimeError being
-        raised.
-        """
-        tree = compile("x = 10", "<test>", "exec", PyCF_ONLY_AST)
-        # Make it into something unrecognizable.
-        tree.body[0].targets[0].ctx = object()
-        self.assertRaises(RuntimeError, checker.Checker, tree)

=== removed file 'Pyflakes/setup.py'
--- Pyflakes/setup.py	2011-09-03 16:31:04 +0000
+++ Pyflakes/setup.py	1970-01-01 00:00:00 +0000
@@ -1,29 +0,0 @@
-#!/usr/bin/python
-# Copyright 2005-2011 Divmod, Inc.  See LICENSE file for details
-
-from distutils.core import setup
-
-setup(
-    name="pyflakes",
-    license="MIT",
-    version="0.5.0",
-    description="passive checker of Python programs",
-    author="Phil Frost",
-    author_email="[e-mail]",
-    maintainer="Divmod developers",
-    maintainer_email="[e-mail]",
-    url="https://launchpad.net/pyflakes",
-    packages=["pyflakes", "pyflakes.scripts", "pyflakes.test"],
-    scripts=["bin/pyflakes"],
-    long_description="""Pyflakes is program to analyze Python programs and detect various errors. It
-works by parsing the source file, not importing it, so it is safe to use on
-modules with side effects. It's also much faster.""",
-    classifiers=[
-        "Development Status :: 6 - Mature",
-        "Environment :: Console",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python",
-        "Topic :: Software Development",
-        "Topic :: Utilities",
-        ])