exercism-analysis 0.1.1

data/vendor/python/pylint/checkers/design_analysis.py

@@ -0,0 +1,367 @@
+# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+"""check for signs of poor design"""
+
+from astroid import Function, If, InferenceError
+
+from pylint.interfaces import IAstroidChecker
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import check_messages
+
+import re
+
+# regexp for ignored argument name
+IGNORED_ARGUMENT_NAMES = re.compile('_.*')
+
+
+def class_is_abstract(klass):
+    """return true if the given class node should be considered as an abstract
+    class
+    """
+    for attr in klass.values():
+        if isinstance(attr, Function):
+            if attr.is_abstract(pass_is_abstract=False):
+                return True
+    return False
+
+
+MSGS = {
+    'R0901': ('Too many ancestors (%s/%s)',
+              'too-many-ancestors',
+              'Used when class has too many parent classes, try to reduce \
+              this to get a simpler (and so easier to use) class.'),
+    'R0902': ('Too many instance attributes (%s/%s)',
+              'too-many-instance-attributes',
+              'Used when class has too many instance attributes, try to reduce \
+              this to get a simpler (and so easier to use) class.'),
+    'R0903': ('Too few public methods (%s/%s)',
+              'too-few-public-methods',
+              'Used when class has too few public methods, so be sure it\'s \
+              really worth it.'),
+    'R0904': ('Too many public methods (%s/%s)',
+              'too-many-public-methods',
+              'Used when class has too many public methods, try to reduce \
+              this to get a simpler (and so easier to use) class.'),
+
+    'R0911': ('Too many return statements (%s/%s)',
+              'too-many-return-statements',
+              'Used when a function or method has too many return statement, \
+              making it hard to follow.'),
+    'R0912': ('Too many branches (%s/%s)',
+              'too-many-branches',
+              'Used when a function or method has too many branches, \
+              making it hard to follow.'),
+    'R0913': ('Too many arguments (%s/%s)',
+              'too-many-arguments',
+              'Used when a function or method takes too many arguments.'),
+    'R0914': ('Too many local variables (%s/%s)',
+              'too-many-locals',
+              'Used when a function or method has too many local variables.'),
+    'R0915': ('Too many statements (%s/%s)',
+              'too-many-statements',
+              'Used when a function or method has too many statements. You \
+              should then split it in smaller functions / methods.'),
+
+    'R0921': ('Abstract class not referenced',
+              'abstract-class-not-used',
+              'Used when an abstract class is not used as ancestor anywhere.'),
+    'R0922': ('Abstract class is only referenced %s times',
+              'abstract-class-little-used',
+              'Used when an abstract class is used less than X times as \
+              ancestor.'),
+    'R0923': ('Interface not implemented',
+              'interface-not-implemented',
+              'Used when an interface class is not implemented anywhere.'),
+    }
+
+
+class MisdesignChecker(BaseChecker):
+    """checks for sign of poor/misdesign:
+    * number of methods, attributes, local variables...
+    * size, complexity of functions, methods
+    """
+
+    __implements__ = (IAstroidChecker,)
+
+    # configuration section name
+    name = 'design'
+    # messages
+    msgs = MSGS
+    priority = -2
+    # configuration options
+    options = (('max-args',
+                {'default' : 5, 'type' : 'int', 'metavar' : '<int>',
+                 'help': 'Maximum number of arguments for function / method'}
+                ),
+               ('ignored-argument-names',
+                {'default' : IGNORED_ARGUMENT_NAMES,
+                 'type' :'regexp', 'metavar' : '<regexp>',
+                 'help' : 'Argument names that match this expression will be '
+                          'ignored. Default to name with leading underscore'}
+                ),
+               ('max-locals',
+                {'default' : 15, 'type' : 'int', 'metavar' : '<int>',
+                 'help': 'Maximum number of locals for function / method body'}
+                ),
+               ('max-returns',
+                {'default' : 6, 'type' : 'int', 'metavar' : '<int>',
+                 'help': 'Maximum number of return / yield for function / '
+                         'method body'}
+                ),
+               ('max-branches',
+                {'default' : 12, 'type' : 'int', 'metavar' : '<int>',
+                 'help': 'Maximum number of branch for function / method body'}
+                ),
+               ('max-statements',
+                {'default' : 50, 'type' : 'int', 'metavar' : '<int>',
+                 'help': 'Maximum number of statements in function / method '
+                         'body'}
+                ),
+               ('max-parents',
+                {'default' : 7,
+                 'type' : 'int',
+                 'metavar' : '<num>',
+                 'help' : 'Maximum number of parents for a class (see R0901).'}
+                ),
+               ('max-attributes',
+                {'default' : 7,
+                 'type' : 'int',
+                 'metavar' : '<num>',
+                 'help' : 'Maximum number of attributes for a class \
+(see R0902).'}
+                ),
+               ('min-public-methods',
+                {'default' : 2,
+                 'type' : 'int',
+                 'metavar' : '<num>',
+                 'help' : 'Minimum number of public methods for a class \
+(see R0903).'}
+                ),
+               ('max-public-methods',
+                {'default' : 20,
+                 'type' : 'int',
+                 'metavar' : '<num>',
+                 'help' : 'Maximum number of public methods for a class \
+(see R0904).'}
+                ),
+               )
+
+    def __init__(self, linter=None):
+        BaseChecker.__init__(self, linter)
+        self.stats = None
+        self._returns = None
+        self._branches = None
+        self._used_abstracts = None
+        self._used_ifaces = None
+        self._abstracts = None
+        self._ifaces = None
+        self._stmts = 0
+
+    def open(self):
+        """initialize visit variables"""
+        self.stats = self.linter.add_stats()
+        self._returns = []
+        self._branches = []
+        self._used_abstracts = {}
+        self._used_ifaces = {}
+        self._abstracts = []
+        self._ifaces = []
+
+    # Check 'R0921', 'R0922', 'R0923'
+    def close(self):
+        """check that abstract/interface classes are used"""
+        for abstract in self._abstracts:
+            if not abstract in self._used_abstracts:
+                self.add_message('abstract-class-not-used', node=abstract)
+            elif self._used_abstracts[abstract] < 2:
+                self.add_message('abstract-class-little-used', node=abstract,
+                                 args=self._used_abstracts[abstract])
+        for iface in self._ifaces:
+            if not iface in self._used_ifaces:
+                self.add_message('interface-not-implemented', node=iface)
+
+    @check_messages('too-many-ancestors', 'too-many-instance-attributes',
+                    'too-few-public-methods', 'too-many-public-methods',
+                    'abstract-class-not-used', 'abstract-class-little-used',
+                    'interface-not-implemented')
+    def visit_class(self, node):
+        """check size of inheritance hierarchy and number of instance attributes
+        """
+        self._inc_branch()
+        # Is the total inheritance hierarchy is 7 or less?
+        nb_parents = len(list(node.ancestors()))
+        if nb_parents > self.config.max_parents:
+            self.add_message('too-many-ancestors', node=node,
+                             args=(nb_parents, self.config.max_parents))
+        # Does the class contain less than 20 attributes for
+        # non-GUI classes (40 for GUI)?
+        # FIXME detect gui classes
+        if len(node.instance_attrs) > self.config.max_attributes:
+            self.add_message('too-many-instance-attributes', node=node,
+                             args=(len(node.instance_attrs),
+                                   self.config.max_attributes))
+        # update abstract / interface classes structures
+        if class_is_abstract(node):
+            self._abstracts.append(node)
+        elif node.type == 'interface' and node.name != 'Interface':
+            self._ifaces.append(node)
+            for parent in node.ancestors(False):
+                if parent.name == 'Interface':
+                    continue
+                self._used_ifaces[parent] = 1
+        try:
+            for iface in node.interfaces():
+                self._used_ifaces[iface] = 1
+        except InferenceError:
+            # XXX log ?
+            pass
+        for parent in node.ancestors():
+            try:
+                self._used_abstracts[parent] += 1
+            except KeyError:
+                self._used_abstracts[parent] = 1
+
+    @check_messages('too-many-ancestors', 'too-many-instance-attributes',
+                    'too-few-public-methods', 'too-many-public-methods',
+                    'abstract-class-not-used', 'abstract-class-little-used',
+                    'interface-not-implemented')
+    def leave_class(self, node):
+        """check number of public methods"""
+        nb_public_methods = 0
+        special_methods = set()
+        for method in node.methods():
+            if not method.name.startswith('_'):
+                nb_public_methods += 1
+            if method.name.startswith("__"):
+                special_methods.add(method.name)
+        # Does the class contain less than 20 public methods ?
+        if nb_public_methods > self.config.max_public_methods:
+            self.add_message('too-many-public-methods', node=node,
+                             args=(nb_public_methods,
+                                   self.config.max_public_methods))
+        # stop here for exception, metaclass and interface classes
+        if node.type != 'class':
+            return
+        # Does the class contain more than 5 public methods ?
+        if nb_public_methods < self.config.min_public_methods:
+            self.add_message('R0903', node=node,
+                             args=(nb_public_methods,
+                                   self.config.min_public_methods))
+
+    @check_messages('too-many-return-statements', 'too-many-branches',
+                    'too-many-arguments', 'too-many-locals', 'too-many-statements')
+    def visit_function(self, node):
+        """check function name, docstring, arguments, redefinition,
+        variable names, max locals
+        """
+        self._inc_branch()
+        # init branch and returns counters
+        self._returns.append(0)
+        self._branches.append(0)
+        # check number of arguments
+        args = node.args.args
+        if args is not None:
+            ignored_args_num = len(
+                [arg for arg in args
+                 if self.config.ignored_argument_names.match(arg.name)])
+            argnum = len(args) - ignored_args_num
+            if  argnum > self.config.max_args:
+                self.add_message('too-many-arguments', node=node,
+                                 args=(len(args), self.config.max_args))
+        else:
+            ignored_args_num = 0
+        # check number of local variables
+        locnum = len(node.locals) - ignored_args_num
+        if locnum > self.config.max_locals:
+            self.add_message('too-many-locals', node=node,
+                             args=(locnum, self.config.max_locals))
+        # init statements counter
+        self._stmts = 1
+
+    @check_messages('too-many-return-statements', 'too-many-branches', 'too-many-arguments', 'too-many-locals', 'too-many-statements')
+    def leave_function(self, node):
+        """most of the work is done here on close:
+        checks for max returns, branch, return in __init__
+        """
+        returns = self._returns.pop()
+        if returns > self.config.max_returns:
+            self.add_message('too-many-return-statements', node=node,
+                             args=(returns, self.config.max_returns))
+        branches = self._branches.pop()
+        if branches > self.config.max_branches:
+            self.add_message('too-many-branches', node=node,
+                             args=(branches, self.config.max_branches))
+        # check number of statements
+        if self._stmts > self.config.max_statements:
+            self.add_message('too-many-statements', node=node,
+                             args=(self._stmts, self.config.max_statements))
+
+    def visit_return(self, _):
+        """count number of returns"""
+        if not self._returns:
+            return # return outside function, reported by the base checker
+        self._returns[-1] += 1
+
+    def visit_default(self, node):
+        """default visit method -> increments the statements counter if
+        necessary
+        """
+        if node.is_statement:
+            self._stmts += 1
+
+    def visit_tryexcept(self, node):
+        """increments the branches counter"""
+        branches = len(node.handlers)
+        if node.orelse:
+            branches += 1
+        self._inc_branch(branches)
+        self._stmts += branches
+
+    def visit_tryfinally(self, _):
+        """increments the branches counter"""
+        self._inc_branch(2)
+        self._stmts += 2
+
+    def visit_if(self, node):
+        """increments the branches counter"""
+        branches = 1
+        # don't double count If nodes coming from some 'elif'
+        if node.orelse and (len(node.orelse) > 1 or
+                            not isinstance(node.orelse[0], If)):
+            branches += 1
+        self._inc_branch(branches)
+        self._stmts += branches
+
+    def visit_while(self, node):
+        """increments the branches counter"""
+        branches = 1
+        if node.orelse:
+            branches += 1
+        self._inc_branch(branches)
+
+    visit_for = visit_while
+
+    def _inc_branch(self, branchesnum=1):
+        """increments the branches counter"""
+        branches = self._branches
+        for i in xrange(len(branches)):
+            branches[i] += branchesnum
+
+    # FIXME: make a nice report...
+
+def register(linter):
+    """required method to auto register this checker """
+    linter.register_checker(MisdesignChecker(linter))

data/vendor/python/pylint/checkers/exceptions.py

@@ -0,0 +1,306 @@
+# Copyright (c) 2003-2013 LOGILAB S.A. (Paris, FRANCE).
+# http://www.logilab.fr/ -- mailto:contact@logilab.fr
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+"""exceptions handling (raising, catching, exceptions classes) checker
+"""
+import sys
+
+from logilab.common.compat import builtins
+BUILTINS_NAME = builtins.__name__
+import astroid
+from astroid import YES, Instance, unpack_infer
+
+from pylint.checkers import BaseChecker
+from pylint.checkers.utils import is_empty, is_raising, check_messages
+from pylint.interfaces import IAstroidChecker
+
+def infer_bases(klass):
+    """ Fully infer the bases of the klass node.
+
+    This doesn't use .ancestors(), because we need
+    the non-inferable nodes (YES nodes),
+    which can't be retrieved from .ancestors()
+    """
+    for base in klass.bases:
+        try:
+            inferit = base.infer().next()
+        except astroid.InferenceError:
+            continue
+        if inferit is YES:
+            yield inferit
+        else:
+            for base in infer_bases(inferit):
+                yield base
+
+PY3K = sys.version_info >= (3, 0)
+OVERGENERAL_EXCEPTIONS = ('Exception',)
+
+MSGS = {
+    'E0701': ('Bad except clauses order (%s)',
+              'bad-except-order',
+              'Used when except clauses are not in the correct order (from the '
+              'more specific to the more generic). If you don\'t fix the order, '
+              'some exceptions may not be catched by the most specific handler.'),
+    'E0702': ('Raising %s while only classes, instances or string are allowed',
+              'raising-bad-type',
+              'Used when something which is neither a class, an instance or a \
+              string is raised (i.e. a `TypeError` will be raised).'),
+    'E0703': ('Exception context set to something which is not an '
+              'exception, nor None',
+              'bad-exception-context',
+              'Used when using the syntax "raise ... from ...", '
+              'where the exception context is not an exception, '
+              'nor None.',
+              {'minversion': (3, 0)}),
+    'E0710': ('Raising a new style class which doesn\'t inherit from BaseException',
+              'raising-non-exception',
+              'Used when a new style class which doesn\'t inherit from \
+               BaseException is raised.'),
+    'E0711': ('NotImplemented raised - should raise NotImplementedError',
+              'notimplemented-raised',
+              'Used when NotImplemented is raised instead of \
+              NotImplementedError'),
+    'E0712': ('Catching an exception which doesn\'t inherit from BaseException: %s',
+              'catching-non-exception',
+              'Used when a class which doesn\'t inherit from \
+               BaseException is used as an exception in an except clause.'),
+
+    'W0701': ('Raising a string exception',
+              'raising-string',
+              'Used when a string exception is raised.'),
+    'W0702': ('No exception type(s) specified',
+              'bare-except',
+              'Used when an except clause doesn\'t specify exceptions type to \
+              catch.'),
+    'W0703': ('Catching too general exception %s',
+              'broad-except',
+              'Used when an except catches a too general exception, \
+              possibly burying unrelated errors.'),
+    'W0704': ('Except doesn\'t do anything',
+              'pointless-except',
+              'Used when an except clause does nothing but "pass" and there is\
+              no "else" clause.'),
+    'W0710': ('Exception doesn\'t inherit from standard "Exception" class',
+              'nonstandard-exception',
+              'Used when a custom exception class is raised but doesn\'t \
+              inherit from the builtin "Exception" class.',
+              {'maxversion': (3, 0)}),
+    'W0711': ('Exception to catch is the result of a binary "%s" operation',
+              'binary-op-exception',
+              'Used when the exception to catch is of the form \
+              "except A or B:".  If intending to catch multiple, \
+              rewrite as "except (A, B):"'),
+    'W0712': ('Implicit unpacking of exceptions is not supported in Python 3',
+              'unpacking-in-except',
+              'Python3 will not allow implicit unpacking of exceptions in except '
+              'clauses. '
+              'See http://www.python.org/dev/peps/pep-3110/',
+              {'maxversion': (3, 0)}),
+    'W0713': ('Indexing exceptions will not work on Python 3',
+              'indexing-exception',
+              'Indexing exceptions will not work on Python 3. Use '
+              '`exception.args[index]` instead.',
+              {'maxversion': (3, 0)}),
+    }
+
+
+if sys.version_info < (3, 0):
+    EXCEPTIONS_MODULE = "exceptions"
+else:
+    EXCEPTIONS_MODULE = "builtins"
+
+class ExceptionsChecker(BaseChecker):
+    """checks for
+    * excepts without exception filter
+    * type of raise argument : string, Exceptions, other values
+    """
+
+    __implements__ = IAstroidChecker
+
+    name = 'exceptions'
+    msgs = MSGS
+    priority = -4
+    options = (('overgeneral-exceptions',
+                {'default' : OVERGENERAL_EXCEPTIONS,
+                 'type' :'csv', 'metavar' : '<comma-separated class names>',
+                 'help' : 'Exceptions that will emit a warning '
+                          'when being caught. Defaults to "%s"' % (
+                              ', '.join(OVERGENERAL_EXCEPTIONS),)}
+                ),
+               )
+
+    @check_messages('raising-string', 'nonstandard-exception', 'raising-bad-type',
+                    'raising-non-exception', 'notimplemented-raised', 'bad-exception-context')
+    def visit_raise(self, node):
+        """visit raise possibly inferring value"""
+        # ignore empty raise
+        if node.exc is None:
+            return
+        if PY3K and node.cause:
+            try:
+                cause = node.cause.infer().next()
+            except astroid.InferenceError:
+                pass
+            else:
+                if cause is YES:
+                    return
+                if isinstance(cause, astroid.Const):
+                    if cause.value is not None:
+                        self.add_message('bad-exception-context',
+                                         node=node)
+                elif (not isinstance(cause, astroid.Class) and
+                      not inherit_from_std_ex(cause)):
+                    self.add_message('bad-exception-context',
+                                      node=node)
+        expr = node.exc
+        if self._check_raise_value(node, expr):
+            return
+        else:
+            try:
+                value = unpack_infer(expr).next()
+            except astroid.InferenceError:
+                return
+            self._check_raise_value(node, value)
+
+    def _check_raise_value(self, node, expr):
+        """check for bad values, string exception and class inheritance
+        """
+        value_found = True
+        if isinstance(expr, astroid.Const):
+            value = expr.value
+            if isinstance(value, str):
+                self.add_message('raising-string', node=node)
+            else:
+                self.add_message('raising-bad-type', node=node,
+                                 args=value.__class__.__name__)
+        elif (isinstance(expr, astroid.Name) and \
+                 expr.name in ('None', 'True', 'False')) or \
+                 isinstance(expr, (astroid.List, astroid.Dict, astroid.Tuple,
+                                   astroid.Module, astroid.Function)):
+            self.add_message('raising-bad-type', node=node, args=expr.name)
+        elif ((isinstance(expr, astroid.Name) and expr.name == 'NotImplemented')
+              or (isinstance(expr, astroid.CallFunc) and
+                  isinstance(expr.func, astroid.Name) and
+                  expr.func.name == 'NotImplemented')):
+            self.add_message('notimplemented-raised', node=node)
+        elif isinstance(expr, astroid.BinOp) and expr.op == '%':
+            self.add_message('raising-string', node=node)
+        elif isinstance(expr, (Instance, astroid.Class)):
+            if isinstance(expr, Instance):
+                expr = expr._proxied
+            if (isinstance(expr, astroid.Class) and
+                    not inherit_from_std_ex(expr) and
+                    expr.root().name != BUILTINS_NAME):
+                if expr.newstyle:
+                    self.add_message('raising-non-exception', node=node)
+                else:
+                    self.add_message('nonstandard-exception', node=node)
+            else:
+                value_found = False
+        else:
+            value_found = False
+        return value_found
+
+    @check_messages('unpacking-in-except')
+    def visit_excepthandler(self, node):
+        """Visit an except handler block and check for exception unpacking."""
+        if isinstance(node.name, (astroid.Tuple, astroid.List)):
+            self.add_message('unpacking-in-except', node=node)
+
+    @check_messages('indexing-exception')
+    def visit_subscript(self, node):
+        """ Look for indexing exceptions. """
+        try:
+            for infered in node.value.infer():
+                if not isinstance(infered, astroid.Instance):
+                    continue
+                if inherit_from_std_ex(infered):
+                    self.add_message('indexing-exception', node=node)
+        except astroid.InferenceError:
+            return
+
+    @check_messages('bare-except', 'broad-except', 'pointless-except',
+                    'binary-op-exception', 'bad-except-order',
+                    'catching-non-exception')
+    def visit_tryexcept(self, node):
+        """check for empty except"""
+        exceptions_classes = []
+        nb_handlers = len(node.handlers)
+        for index, handler  in enumerate(node.handlers):
+            # single except doing nothing but "pass" without else clause
+            if nb_handlers == 1 and is_empty(handler.body) and not node.orelse:
+                self.add_message('pointless-except', node=handler.type or handler.body[0])
+            if handler.type is None:
+                if nb_handlers == 1 and not is_raising(handler.body):
+                    self.add_message('bare-except', node=handler)
+                # check if a "except:" is followed by some other
+                # except
+                elif index < (nb_handlers - 1):
+                    msg = 'empty except clause should always appear last'
+                    self.add_message('bad-except-order', node=node, args=msg)
+
+            elif isinstance(handler.type, astroid.BoolOp):
+                self.add_message('binary-op-exception', node=handler, args=handler.type.op)
+            else:
+                try:
+                    excs = list(unpack_infer(handler.type))
+                except astroid.InferenceError:
+                    continue
+                for exc in excs:
+                    # XXX skip other non class nodes
+                    if exc is YES or not isinstance(exc, astroid.Class):
+                        continue
+                    exc_ancestors = [anc for anc in exc.ancestors()
+                                     if isinstance(anc, astroid.Class)]
+                    for previous_exc in exceptions_classes:
+                        if previous_exc in exc_ancestors:
+                            msg = '%s is an ancestor class of %s' % (
+                                previous_exc.name, exc.name)
+                            self.add_message('bad-except-order', node=handler.type, args=msg)
+                    if (exc.name in self.config.overgeneral_exceptions
+                        and exc.root().name == EXCEPTIONS_MODULE
+                        and nb_handlers == 1 and not is_raising(handler.body)):
+                        self.add_message('broad-except', args=exc.name, node=handler.type)
+
+                    if (not inherit_from_std_ex(exc) and
+                        exc.root().name != BUILTINS_NAME):
+                        # try to see if the exception is based on a C based
+                        # exception, by infering all the base classes and
+                        # looking for inference errors
+                        bases = infer_bases(exc)
+                        fully_infered = all(inferit is not YES
+                                            for inferit in bases)
+                        if fully_infered:
+                            self.add_message('catching-non-exception',
+                                             node=handler.type,
+                                             args=(exc.name, ))
+
+                exceptions_classes += excs
+
+
+def inherit_from_std_ex(node):
+    """return true if the given class node is subclass of
+    exceptions.Exception
+    """
+    if node.name in ('Exception', 'BaseException') \
+            and node.root().name == EXCEPTIONS_MODULE:
+        return True
+    for parent in node.ancestors(recurs=False):
+        if inherit_from_std_ex(parent):
+            return True
+    return False
+
+def register(linter):
+    """required method to auto register this checker"""
+    linter.register_checker(ExceptionsChecker(linter))