# --enable=similarities". If you want to run only the classes checker, but have
 # no Warning level messages displayed, use"--disable=all --enable=classes
 # --disable=W"
-disable=print-statement,
-        parameter-unpacking,
-        unpacking-in-except,
-        old-raise-syntax,
-        backtick,
-        long-suffix,
-        old-ne-operator,
-        old-octal-literal,
-        import-star-module-level,
-        non-ascii-bytes-literal,
+disable=import-star-module-level,
         raw-checker-failed,
         bad-inline-option,
         locally-disabled,
         locally-enabled,
-        file-ignored,
         suppressed-message,
         useless-suppression,
-        deprecated-pragma,
         apply-builtin,
         basestring-builtin,
         buffer-builtin,
         next-method-called,
         metaclass-assignment,
         indexing-exception,
-        raising-string,
         reload-builtin,
         oct-method,
         hex-method,
         invalid-str-codec,
         sys-max-int,
         bad-python3-import,
-        deprecated-string-function,
-        deprecated-str-translate-call,
-        deprecated-itertools-function,
-        deprecated-types-field,
         next-method-defined,
         dict-items-not-iterating,
         dict-keys-not-iterating,
         no-self-use,
         too-few-public-methods,
         no-member,
-        fixme,
         too-many-arguments,
         too-many-locals
 
 
 # -*- coding: utf-8 -*-
-# pylint: disable=W0212
+# pylint: disable=protected-access
 from __future__ import absolute_import
 
 import collections
         else:
             return inspect.getargspec(func).args[1:]  # pylint: disable=deprecated-method
 
-    # pylint: disable=W1505
     @staticmethod
     def _takes_json(func):
         def inner(*args, **kwargs):
 
         self._module = module_inst
         self.fscid = fscid
 
-    # pylint: disable=unused-variable
     @ViewCache()
     def get(self):
-        # TODO handle nonzero returns, e.g. when rank isn't active
         return CephService.send_command('mds', 'session ls', srv_spec='{0}:0'.format(self.fscid))
 
         for l in lines:
             buf.appendleft(l)
 
-    # pylint: disable=R0914
     @cherrypy.expose
     @cherrypy.tools.json_out()
     def health(self):
 
         return result
 
     def list(self, pool_name=None):
-        # pylint: disable=unbalanced-tuple-unpacking
         return self._rbd_list(pool_name)
 
     def get(self, pool_name, image_name):
 
             'health_color': 'info',
             'health': 'Unknown'
         }
-        for _, pool_data in daemon['status'].items():  # TODO: simplify
+        for _, pool_data in daemon['status'].items():
             if (health['health'] != 'error' and
                     [k for k, v in pool_data.get('callouts', {}).items()
                      if v['level'] == 'error']):
 
 # -*- coding: utf-8 -*-
-# pylint: disable=W0212,too-many-arguments
+# pylint: disable=too-many-arguments
 from __future__ import absolute_import
 
 import json
         task_name = res['name']
         task_metadata = res['metadata']
 
+        # pylint: disable=protected-access
         class Waiter(threading.Thread):
             def __init__(self, task_name, task_metadata, tc):
                 super(Waiter, self).__init__()
 
 from ..tools import is_valid_ipv6_address, dict_contains_path
 
 
-# pylint: disable=W0613
 @ApiController('foo')
 class FooResource(RESTController):
     elems = []
         return {'code': code, 'name': name, 'opt1': opt1, 'opt2': opt2}
 
 
-# pylint: disable=C0102
+# pylint: disable=blacklisted-name
 class Root(object):
     foo = FooResource()
     fooargs = FooArgs()
 
 # -*- coding: utf-8 -*-
-# pylint: disable=W0212
 from __future__ import absolute_import
 
 import collections
         logger.debug("notification queue finished")
 
 
-# pylint: disable=too-many-arguments
+# pylint: disable=too-many-arguments, protected-access
 class TaskManager(object):
     FINISHED_TASK_SIZE = 10
     FINISHED_TASK_TTL = 60.0
         } for t in fn_t]
 
 
+# pylint: disable=protected-access
 class TaskExecutor(object):
     def __init__(self):
         self.task = None
         self.task._complete(ret_value, exception)
 
 
+# pylint: disable=protected-access
 class ThreadedExecutor(TaskExecutor):
     def __init__(self):
         super(ThreadedExecutor, self).__init__()