Checking code for deprecation warnings

Question

Consider the following sample code: ``` data = [] try: print data[0] except IndexError as error: print error.message ``` There is nothing syntactically wrong (using Python2.7) with the code except that if you run python with warnings turned on, you would see a `DeprecationWarning`: ``` $ python -W always test.py test.py:5: DeprecationWarning: BaseException.message has been deprecated as of Python 2.6 print error.message list index out of range ``` FYI, this is because `.message` was deprecated since python2.6 and removed in python3. Now, I'd like to find all places in the project where `.message` is called on any exception instance by using static code analysis tools. As an end goal, I'm planning to have this check running as a part of a daily build&test&code quality check task and raise an error if the syntax is still used. Is it possible? Is it something that `pylint`, `pyflakes` or other code analysis tools are capable of? I found that `pep8` tool has several similar checks impleme…

Accepted Answer

Since you want to do this statically, you can use the `ast` module to parse the code and then scan it for any occurrence of the deprecated code with a subclass of the `NodeVisitor` class. Like so:

```
import ast, sys

class UsingMessageAttr(ast.NodeVisitor):

error_object_names = []

def visit_Attribute(self, node):
        if (node.attr == 'message' and 
            hasattr(node.value, 'id') and 
            node.value.id in self.error_object_names):

print("Danger Will Robinson!!")
            sys.exit(1)

self.generic_visit(node)

def visit_ExceptHandler(self, node):
        if node.name is not None:
            self.error_object_names.append(node.name)
            self.generic_visit(node)
            self.error_object_names.pop()
        else:
            self.generic_visit(node)

with open('sourcefile.py', 'r') as f:
    UsingMessageAttr().visit(ast.parse(f.read()))
```

This works by using python parse the source file into an AST and then uses the visitor pattern to walk through the entire file and find any instances of the deprecated attribute. For more information on how this works, see the python documentation on the ast module.

Note that this won't work if you use something clever to refer to the exception object. It simply takes the variable name that the exception object was bound to and checks if a `message` attribute is ever accessed from a variable of the same name inside the body of the exception handler.

Checking code for deprecation warnings

Solution

Problem