[doc gen] fix feature.rst generation rule in Makefile and remove it from hg

2 files changed, 10 insertions, 843 deletions

diff --git a/doc/Makefile b/doc/Makefile
index 4d0a8a2..c4d1280 100644
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -131,16 +131,15 @@ doctest:
 
 
 features.rst:
-	chmod u+w ${SRC}/features.txt
-	echo "Pylint features" > ${SRC}/features.txt
-	echo "===============" >> ${SRC}/features.txt
-	echo "" >> ${SRC}/features.txt
-	echo ".. generated by pylint --full-documentation" >> ${SRC}/features.txt
-	echo "" >> ${SRC}/features.txt
-	echo ".. contents::" >> ${SRC}/features.txt
-	echo "" >> ${SRC}/features.txt
-	pylint --full-documentation >> ${SRC}/features.txt
-	${MKHTML} ${MKHTML_OPT} ${SRC}/features.txt
+	rm -f features.rst
+	echo "Pylint features" > features.rst
+	echo "===============" >> features.rst
+	echo "" >> features.rst
+	echo ".. generated by pylint --full-documentation" >> features.rst
+	echo "" >> features.rst
+	echo ".. contents::" >> features.rst
+	echo "" >> features.rst
+	pylint --full-documentation >> features.rst
 
 gen-examples:
 	chmod u+w ../examples/pylintrc
@@ -150,4 +149,4 @@ gen-man:
 	chmod u+w ../man/pylint.1
 	pylint --generate-man > ../man/pylint.1
 
-all: html gen-man gen-examples
\ No newline at end of file
+all: html gen-man gen-examples
diff --git a/doc/features.rst b/doc/features.rst
deleted file mode 100644
index 6726ba5..0000000
--- a/doc/features.rst
+++ /dev/null
@@ -1,832 +0,0 @@
-Pylint features
-===============
-
-.. generated by pylint
-
-.. contents::
-
-Options
--------
-
-General options
-~~~~~~~~~~~~~~~
-:rcfile:
-  Specify a configuration file.
-:init-hook:
-  Python code to execute, usually for sys.path manipulation such as
-  pygtk.require().
-:errors-only:
-  In error mode, checkers without error messages are disabled and for others,
-  only the ERROR messages are displayed, and no reports are done by default
-:profile:
-  Profiled execution.
-:ignore:
-  Add files or directories to the blacklist. They should be base names, not
-  paths.
-
-  Default: ``CVS``
-:persistent:
-  Pickle collected data for later comparisons.
-
-  Default: ``yes``
-:load-plugins:
-  List of plugins (as comma separated values of python modules names) to load,
-  usually to register additional checkers.
-:long-help:
-  more verbose help.
-
-Messages control options
-~~~~~~~~~~~~~~~~~~~~~~~~
-:enable:
-  Enable the message, report, category or checker with the given id(s). You can
-  either give multiple identifier separated by comma (,) or put this option
-  multiple time. See also the "--disable" option for examples.
-:disable:
-  Disable the message, report, category or checker with the given id(s). You
-  can either give multiple identifiers separated by comma (,) or put this
-  option multiple times (only on the command line, not in the configuration
-  file where it should appear only once).You can also use "--disable=all" to
-  disable everything first and then reenable specific checks. For example, if
-  you want to run only the similarities checker, you can use "--disable=all
-  --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"
-
-Commands options
-~~~~~~~~~~~~~~~~
-:help-msg:
-  Display a help message for the given message id and exit. The value may be a
-  comma separated list of message ids.
-:list-msgs:
-  Generate pylint's messages.
-:full-documentation:
-  Generate pylint's full documentation.
-:generate-rcfile:
-  Generate a sample configuration file according to the current configuration.
-  You can put other options before this one to get them in the generated
-  configuration.
-:generate-man:
-  Generate pylint's man page.
-
-Reports options
-~~~~~~~~~~~~~~~
-:output-format:
-  Set the output format. Available formats are text, parseable, colorized, msvs
-  (visual studio) and html. You can also give a reporter class, eg
-  mypackage.mymodule.MyReporterClass.
-
-  Default: ``text``
-:include-ids:
-  Include message's id in output
-:symbols:
-  Include symbolic ids of messages in output
-:files-output:
-  Put messages in a separate file for each module / package specified on the
-  command line instead of printing them on stdout. Reports (if any) will be
-  written in a file name "pylint_global.[txt|html]".
-:reports:
-  Tells whether to display a full report or only the messages
-
-  Default: ``yes``
-:evaluation:
-  Python expression which should return a note less than 10 (10 is the highest
-  note). You have access to the variables errors warning, statement which
-  respectively contain the number of errors / warnings messages and the total
-  number of statements analyzed. This is used by the global evaluation report
-  (RP0004).
-
-  Default: ``10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)``
-:comment:
-  Add a comment according to your evaluation note. This is used by the global
-  evaluation report (RP0004).
-
-logging checker
----------------
-
-Messages
-~~~~~~~~
-:E1200 (logging-unsupported-format): *Unsupported logging format character %r (%#02x) at index %d*
-  Used when an unsupported format character is used in a logging statement
-  format string.
-:E1201 (logging-format-truncated): *Logging format string ends in middle of conversion specifier*
-  Used when a logging statement format string terminates before the end of a
-  conversion specifier.
-:E1205 (logging-too-many-args): *Too many arguments for logging format string*
-  Used when a logging format string is given too few arguments.
-:E1206 (logging-too-few-args): *Not enough arguments for logging format string*
-  Used when a logging format string is given too many arguments
-:W1201 (logging-not-lazy): *Specify string format arguments as logging function parameters*
-  Used when a logging statement has a call form of "logging.<logging
-  method>(format_string % (format_args...))". Such calls should leave string
-  interpolation to the logging method itself and be written "logging.<logging
-  method>(format_string, format_args...)" so that the program may avoid
-  incurring the cost of the interpolation in those cases in which no message
-  will be logged. For more, see http://www.python.org/dev/peps/pep-0282/.
-
-
-string checker
---------------
-
-Messages
-~~~~~~~~
-:E1300 (bad-format-character): *Unsupported format character %r (%#02x) at index %d*
-  Used when a unsupported format character is used in a format string.
-:E1301 (truncated-format-string): *Format string ends in middle of conversion specifier*
-  Used when a format string terminates before the end of a conversion specifier.
-:E1302 (mixed-format-string): *Mixing named and unnamed conversion specifiers in format string*
-  Used when a format string contains both named (e.g. '%(foo)d') and unnamed
-  (e.g. '%d') conversion specifiers. This is also used when a named conversion
-  specifier contains * for the minimum field width and/or precision.
-:E1303 (format-needs-mapping): *Expected mapping for format string, not %s*
-  Used when a format string that uses named conversion specifiers is used with
-  an argument that is not a mapping.
-:E1304 (missing-format-string-key): *Missing key %r in format string dictionary*
-  Used when a format string that uses named conversion specifiers is used with a
-  dictionary that doesn't contain all the keys required by the format string.
-:E1305 (too-many-format-args): *Too many arguments for format string*
-  Used when a format string that uses unnamed conversion specifiers is given too
-  few arguments.
-:E1306 (too-few-format-args): *Not enough arguments for format string*
-  Used when a format string that uses unnamed conversion specifiers is given too
-  many arguments
-:E1310 (bad-str-strip-call): *Suspicious argument in %s.%s call*
-  The argument to a str.{l,r,}strip call contains a duplicate character,
-:W1300 (bad-format-string-key): *Format string dictionary key should be a string, not %s*
-  Used when a format string that uses named conversion specifiers is used with a
-  dictionary whose keys are not all strings.
-:W1301 (unused-format-string-key): *Unused key %r in format string dictionary*
-  Used when a format string that uses named conversion specifiers is used with a
-  dictionary that conWtains keys not required by the format string.
-
-
-format checker
---------------
-
-Options
-~~~~~~~
-:max-line-length:
-  Maximum number of characters on a single line.
-
-  Default: ``80``
-:max-module-lines:
-  Maximum number of lines in a module
-
-  Default: ``1000``
-:indent-string:
-  String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
-  tab).
-
-  Default: ``'    '``
-
-Messages
-~~~~~~~~
-:W0301 (unnecessary-semicolon): *Unnecessary semicolon*
-  Used when a statement is ended by a semi-colon (";"), which isn't necessary
-  (that's python, not C ;).
-:W0311 (bad-indentation): *Bad indentation. Found %s %s, expected %s*
-  Used when an unexpected number of indentation's tabulations or spaces has been
-  found.
-:W0312 (mixed-indentation): *Found indentation with %ss instead of %ss*
-  Used when there are some mixed tabs and spaces in a module.
-:W0331 (old-ne-operator): *Use of the <> operator*
-  Used when the deprecated "<>" operator is used instead of "!=".
-:W0332 (lowercase-l-suffix): *Use of "l" as long integer identifier*
-  Used when a lower case "l" is used to mark a long integer. You should use a
-  upper case "L" since the letter "l" looks too much like the digit "1"
-:W0333 (backtick): *Use of the `` operator*
-  Used when the deprecated "``" (backtick) operator is used instead of the str()
-  function.
-:C0301 (line-too-long): *Line too long (%s/%s)*
-  Used when a line is longer than a given number of characters.
-:C0302 (too-many-lines): *Too many lines in module (%s)*
-  Used when a module has too much lines, reducing its readability.
-:C0321 (multiple-statements): *More than one statement on a single line*
-  Used when more than on statement are found on the same line.
-:C0322 (no-space-before-operator): *Operator not preceded by a space*
-  Used when one of the following operator (!= | <= | == | >= | < | > | = | \+= |
-  -= | \*= | /= | %) is not preceded by a space.
-:C0323 (no-space-after-operator): *Operator not followed by a space*
-  Used when one of the following operator (!= | <= | == | >= | < | > | = | \+= |
-  -= | \*= | /= | %) is not followed by a space.
-:C0324 (no-space-after-comma): *Comma not followed by a space*
-  Used when a comma (",") is not followed by a space.
-
-
-imports checker
----------------
-
-Options
-~~~~~~~
-:deprecated-modules:
-  Deprecated modules which should not be used, separated by a comma
-
-  Default: ``regsub,string,TERMIOS,Bastion,rexec``
-:import-graph:
-  Create a graph of every (i.e. internal and external) dependencies in the
-  given file (report RP0402 must not be disabled)
-:ext-import-graph:
-  Create a graph of external dependencies in the given file (report RP0402 must
-  not be disabled)
-:int-import-graph:
-  Create a graph of internal dependencies in the given file (report RP0402 must
-  not be disabled)
-
-Messages
-~~~~~~~~
-:W0401 (wildcard-import): *Wildcard import %s*
-  Used when `from module import *` is detected.
-:W0402 (deprecated-module): *Uses of a deprecated module %r*
-  Used a module marked as deprecated is imported.
-:W0403 (relative-import): *Relative import %r, should be %r*
-  Used when an import relative to the package directory is detected.
-:W0404 (reimported): *Reimport %r (imported line %s)*
-  Used when a module is reimported multiple times.
-:W0406 (import-self): *Module import itself*
-  Used when a module is importing itself.
-:W0410 (misplaced-future): *__future__ import is not the first non docstring statement*
-  Python 2.5 and greater require __future__ import to be the first non docstring
-  statement in the module.
-:R0401 (cyclic-import): *Cyclic import (%s)*
-  Used when a cyclic import between two or more modules is detected.
-:F0401 (import-error): *Unable to import %s*
-  Used when pylint has been unable to import a module.
-
-Reports
-~~~~~~~
-:RP0401: External dependencies
-:RP0402: Modules dependencies graph
-
-
-variables checker
------------------
-
-Options
-~~~~~~~
-:init-import:
-  Tells whether we should check for unused import in __init__ files.
-:dummy-variables-rgx:
-  A regular expression matching the beginning of the name of dummy variables
-  (i.e. not used).
-
-  Default: ``_|dummy``
-:additional-builtins:
-  List of additional names supposed to be defined in builtins. Remember that
-  you should avoid to define new builtins when possible.
-
-Messages
-~~~~~~~~
-:E0601 (used-before-assignment): *Using variable %r before assignment*
-  Used when a local variable is accessed before it's assignment.
-:E0602 (undefined-variable): *Undefined variable %r*
-  Used when an undefined variable is accessed.
-:E0603 (undefined-all-variable): *Undefined variable name %r in __all__*
-  Used when an undefined variable name is referenced in __all__.
-:E0604 (invalid-all-object): *Invalid object %r in __all__, must contain only strings*
-  Used when an invalid (non-string) object occurs in __all__.
-:E0611 (no-name-in-module): *No name %r in module %r*
-  Used when a name cannot be found in a module.
-:W0601 (global-variable-undefined): *Global variable %r undefined at the module level*
-  Used when a variable is defined through the "global" statement but the
-  variable is not defined in the module scope.
-:W0602 (global-variable-not-assigned): *Using global for %r but no assignment is done*
-  Used when a variable is defined through the "global" statement but no
-  assignment to this variable is done.
-:W0603 (global-statement): *Using the global statement*
-  Used when you use the "global" statement to update a global variable. Pylint
-  just try to discourage this usage. That doesn't mean you can not use it !
-:W0604 (global-at-module-level): *Using the global statement at the module level*
-  Used when you use the "global" statement at the module level since it has no
-  effect
-:W0611 (unused-import): *Unused import %s*
-  Used when an imported module or variable is not used.
-:W0612 (unused-variable): *Unused variable %r*
-  Used when a variable is defined but not used.
-:W0613 (unused-argument): *Unused argument %r*
-  Used when a function or method argument is not used.
-:W0614 (unused-wildcard-import): *Unused import %s from wildcard import*
-  Used when an imported module or variable is not used from a 'from X import *'
-  style import.
-:W0621 (redefined-outer-name): *Redefining name %r from outer scope (line %s)*
-  Used when a variable's name hide a name defined in the outer scope.
-:W0622 (redefined-builtin): *Redefining built-in %r*
-  Used when a variable or function override a built-in.
-:W0623 (redefine-in-handler): *Redefining name %r from %s in exception handler*
-  Used when an exception handler assigns the exception to an existing name
-:W0631 (undefined-loop-variable): *Using possibly undefined loop variable %r*
-  Used when an loop variable (i.e. defined by a for loop or a list comprehension
-  or a generator expression) is used outside the loop.
-
-
-basic checker
--------------
-
-Options
-~~~~~~~
-:required-attributes:
-  Required attributes for module, separated by a comma
-:bad-functions:
-  List of builtins function names that should not be used, separated by a comma
-
-  Default: ``map,filter,apply,input``
-:module-rgx:
-  Regular expression which should only match correct module names
-
-  Default: ``(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$``
-:const-rgx:
-  Regular expression which should only match correct module level names
-
-  Default: ``(([A-Z_][A-Z0-9_]*)|(__.*__))$``
-:class-rgx:
-  Regular expression which should only match correct class names
-
-  Default: ``[A-Z_][a-zA-Z0-9]+$``
-:function-rgx:
-  Regular expression which should only match correct function names
-
-  Default: ``[a-z_][a-z0-9_]{2,30}$``
-:method-rgx:
-  Regular expression which should only match correct method names
-
-  Default: ``[a-z_][a-z0-9_]{2,30}$``
-:attr-rgx:
-  Regular expression which should only match correct instance attribute names
-
-  Default: ``[a-z_][a-z0-9_]{2,30}$``
-:argument-rgx:
-  Regular expression which should only match correct argument names
-
-  Default: ``[a-z_][a-z0-9_]{2,30}$``
-:variable-rgx:
-  Regular expression which should only match correct variable names
-
-  Default: ``[a-z_][a-z0-9_]{2,30}$``
-:inlinevar-rgx:
-  Regular expression which should only match correct list comprehension /
-  generator expression variable names
-
-  Default: ``[A-Za-z_][A-Za-z0-9_]*$``
-:good-names:
-  Good variable names which should always be accepted, separated by a comma
-
-  Default: ``i,j,k,ex,Run,_``
-:bad-names:
-  Bad variable names which should always be refused, separated by a comma
-
-  Default: ``foo,bar,baz,toto,tutu,tata``
-:no-docstring-rgx:
-  Regular expression which should only match functions or classes name which do
-  not require a docstring
-
-  Default: ``__.*__``
-
-Messages
-~~~~~~~~
-:E0100 (init-is-generator): *__init__ method is a generator*
-  Used when the special class method __init__ is turned into a generator by a
-  yield in its body.
-:E0101 (return-in-init): *Explicit return in __init__*
-  Used when the special class method __init__ has an explicit return value.
-:E0102 (function-redefined): *%s already defined line %s*
-  Used when a function / class / method is redefined.
-:E0103 (not-in-loop): *%r not properly in loop*
-  Used when break or continue keywords are used outside a loop.
-:E0104 (return-outside-function): *Return outside function*
-  Used when a "return" statement is found outside a function or method.
-:E0105 (yield-outside-function): *Yield outside function*
-  Used when a "yield" statement is found outside a function or method.
-:E0106 (return-arg-in-generator): *Return with argument inside generator*
-  Used when a "return" statement with an argument is found outside in a
-  generator function or method (e.g. with some "yield" statements).
-:E0107 (nonexistent-operator): *Use of the non-existent %s operator*
-  Used when you attempt to use the C-style pre-increment orpre-decrement
-  operator -- and ++, which doesn't exist in Python.
-:E0108 (duplicate-argument-name): *Duplicate argument name %s in function definition*
-  Duplicate argument names in function definitions are syntax errors.
-:W0101 (unreachable): *Unreachable code*
-  Used when there is some code behind a "return" or "raise" statement, which
-  will never be accessed.
-:W0102 (dangerous-default-value): *Dangerous default value %s as argument*
-  Used when a mutable value as list or dictionary is detected in a default value
-  for an argument.
-:W0104 (pointless-statement): *Statement seems to have no effect*
-  Used when a statement doesn't have (or at least seems to) any effect.
-:W0105 (pointless-string-statement): *String statement has no effect*
-  Used when a string is used as a statement (which of course has no effect).
-  This is a particular case of W0104 with its own message so you can easily
-  disable it if you're using those strings as documentation, instead of
-  comments.
-:W0106 (expression-not-assigned): *Expression "%s" is assigned to nothing*
-  Used when an expression that is not a function call is assigned to nothing.
-  Probably something else was intended.
-:W0107 (unnecessary-pass): *Unnecessary pass statement*
-  Used when a "pass" statement that can be avoided is encountered.
-:W0108 (unnecessary-lambda): *Lambda may not be necessary*
-  Used when the body of a lambda expression is a function call on the same
-  argument list as the lambda itself; such lambda expressions are in all but a
-  few cases replaceable with the function being called in the body of the
-  lambda.
-:W0109 (duplicate-key): *Duplicate key %r in dictionary*
-  Used when a dictionary expression binds the same key multiple times.
-:W0110 (deprecated-lambda): *map/filter on lambda could be replaced by comprehension*
-  Used when a lambda is the first argument to "map" or "filter". It could be
-  clearer as a list comprehension or generator expression.
-:W0122 (exec-statement): *Use of the exec statement*
-  Used when you use the "exec" statement, to discourage its usage. That doesn't
-  mean you can not use it !
-:W0141 (bad-builtin): *Used builtin function %r*
-  Used when a black listed builtin function is used (see the bad-function
-  option). Usual black listed functions are the ones like map, or filter , where
-  Python offers now some cleaner alternative like list comprehension.
-:W0142 (star-args): *Used * or ** magic*
-  Used when a function or method is called using `*args` or `**kwargs` to
-  dispatch arguments. This doesn't improve readability and should be used with
-  care.
-:W0150 (lost-exception): *%s statement in finally block may swallow exception*
-  Used when a break or a return statement is found inside the finally clause of
-  a try...finally block: the exceptions raised in the try clause will be
-  silently swallowed instead of being re-raised.
-:W0199 (assert-on-tuple): *Assert called on a 2-uple. Did you mean 'assert x,y'?*
-  A call of assert on a tuple will always evaluate to true if the tuple is not
-  empty, and will always evaluate to false if it is.
-:C0102 (blacklisted-name): *Black listed name "%s"*
-  Used when the name is listed in the black list (unauthorized names).
-:C0103 (invalid-name): *Invalid name "%s" for type %s (should match %s)*
-  Used when the name doesn't match the regular expression associated to its type
-  (constant, variable, class...).
-:C0109 (useless-else-on-loop): *Else clause on loop without break or return statement*
-  Loops should only have an else clause if they can exit early with a break
-  statement, otherwise the statements under else should be on the same scope as
-  the loop itself.
-:C0111 (missing-docstring): *Missing docstring*
-  Used when a module, function, class or method has no docstring. Some special
-  methods like __init__ doesn't necessary require a docstring.
-:C0112 (empty-docstring): *Empty docstring*
-  Used when a module, function, class or method has an empty docstring (it would
-  be too easy ;).
-:C0121 (missing-module-attribute): *Missing required attribute "%s"*
-  Used when an attribute required for modules is missing.
-
-Reports
-~~~~~~~
-:RP0101: Statistics by type
-
-
-miscellaneous checker
----------------------
-
-Options
-~~~~~~~
-:notes:
-  List of note tags to take in consideration, separated by a comma.
-
-  Default: ``FIXME,XXX,TODO``
-
-Messages
-~~~~~~~~
-:W0511 (fixme):
-  Used when a warning note as FIXME or XXX is detected.
-
-
-metrics checker
----------------
-
-Reports
-~~~~~~~
-:RP0701: Raw metrics
-
-
-classes checker
----------------
-
-Options
-~~~~~~~
-:ignore-iface-methods:
-  List of interface methods to ignore, separated by a comma. This is used for
-  instance to not check methods defines in Zope's Interface base class.
-
-  Default: ``isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by``
-:defining-attr-methods:
-  List of method names used to declare (i.e. assign) instance attributes.
-
-  Default: ``__init__,__new__,setUp``
-:valid-classmethod-first-arg:
-  List of valid names for the first argument in a class method.
-
-  Default: ``cls``
-:valid-metaclass-classmethod-first-arg:
-  List of valid names for the first argument in a metaclass class method.
-
-  Default: ``mcs``
-
-Messages
-~~~~~~~~
-:E0202 (method-hidden): *An attribute affected in %s line %s hide this method*
-  Used when a class defines a method which is hidden by an instance attribute
-  from an ancestor class or set by some client code.
-:E0203 (access-member-before-definition): *Access to member %r before its definition line %s*
-  Used when an instance member is accessed before it's actually assigned.
-:E0211 (no-method-argument): *Method has no argument*
-  Used when a method which should have the bound instance as first argument has
-  no argument defined.
-:E0213 (no-self-argument): *Method should have "self" as first argument*
-  Used when a method has an attribute different the "self" as first argument.
-  This is considered as an error since this is a so common convention that you
-  shouldn't break it!
-:E0221 (interface-is-not-class): *Interface resolved to %s is not a class*
-  Used when a class claims to implement an interface which is not a class.
-:E0222 (missing-interface-method): *Missing method %r from %s interface*
-  Used when a method declared in an interface is missing from a class
-  implementing this interface
-:W0201 (attribute-defined-outside-init): *Attribute %r defined outside __init__*
-  Used when an instance attribute is defined outside the __init__ method.
-:W0211 (bad-staticmethod-argument): *Static method with %r as first argument*
-  Used when a static method has "self" or a value specified in
-  valid-classmethod-first-arg option or valid-metaclass-classmethod-first-arg
-  option as first argument.
-:W0212 (protected-access): *Access to a protected member %s of a client class*
-  Used when a protected member (i.e. class member with a name beginning with an
-  underscore) is access outside the class or a descendant of the class where
-  it's defined.
-:W0221 (arguments-differ): *Arguments number differs from %s method*
-  Used when a method has a different number of arguments than in the implemented
-  interface or in an overridden method.
-:W0222 (signature-differs): *Signature differs from %s method*
-  Used when a method signature is different than in the implemented interface or
-  in an overridden method.
-:W0223 (abstract-method): *Method %r is abstract in class %r but is not overridden*
-  Used when an abstract method (i.e. raise NotImplementedError) is not
-  overridden in concrete class.
-:W0231 (super-init-not-called): *__init__ method from base class %r is not called*
-  Used when an ancestor class method has an __init__ method which is not called
-  by a derived class.
-:W0232 (no-init): *Class has no __init__ method*
-  Used when a class has no __init__ method, neither its parent classes.
-:W0233 (non-parent-init-called): *__init__ method from a non direct base class %r is called*
-  Used when an __init__ method is called on a class which is not in the direct
-  ancestors for the analysed class.
-:R0201 (no-self-use): *Method could be a function*
-  Used when a method doesn't use its bound instance, and so could be written as
-  a function.
-:C0202 (bad-classmethod-argument): *Class method %s should have %s as first argument*
-  Used when a class method has a first argument named differently than the value
-  specified in valid-classmethod-first-arg option (default to "cls"),
-  recommended to easily differentiate them from regular instance methods.
-:C0203 (bad-mcs-method-argument): *Metaclass method %s should have %s as first argument*
-  Used when a metaclass method has a first agument named differently than the
-  value specified in valid-classmethod-first-arg option (default to "cls"),
-  recommended to easily differentiate them from regular instance methods.
-:C0204 (bad-mcs-classmethod-argument): *Metaclass class method %s should have %s as first argument*
-  Used when a metaclass class method has a first argument named differently than
-  the value specified in valid-metaclass-classmethod-first-arg option (default
-  to "mcs"), recommended to easily differentiate them from regular instance
-  methods.
-:F0202 (method-check-failed): *Unable to check methods signature (%s / %s)*
-  Used when Pylint has been unable to check methods signature compatibility for
-  an unexpected reason. Please report this kind if you don't make sense of it.
-:F0220 (unresolved-interface): *failed to resolve interfaces implemented by %s (%s)*
-  Used when a Pylint as failed to find interfaces implemented by a class
-
-
-design checker
---------------
-
-Options
-~~~~~~~
-:max-args:
-  Maximum number of arguments for function / method
-
-  Default: ``5``
-:ignored-argument-names:
-  Argument names that match this expression will be ignored. Default to name
-  with leading underscore
-
-  Default: ``_.*``
-:max-locals:
-  Maximum number of locals for function / method body
-
-  Default: ``15``
-:max-returns:
-  Maximum number of return / yield for function / method body
-
-  Default: ``6``
-:max-branchs:
-  Maximum number of branch for function / method body
-
-  Default: ``12``
-:max-statements:
-  Maximum number of statements in function / method body
-
-  Default: ``50``
-:max-parents:
-  Maximum number of parents for a class (see R0901).
-
-  Default: ``7``
-:max-attributes:
-  Maximum number of attributes for a class (see R0902).
-
-  Default: ``7``
-:min-public-methods:
-  Minimum number of public methods for a class (see R0903).
-
-  Default: ``2``
-:max-public-methods:
-  Maximum number of public methods for a class (see R0904).
-
-  Default: ``20``
-
-Messages
-~~~~~~~~
-:R0901 (too-many-ancestors): *Too many ancestors (%s/%s)*
-  Used when class has too many parent classes, try to reduce this to get a more
-  simple (and so easier to use) class.
-:R0902 (too-many-instance-attributes): *Too many instance attributes (%s/%s)*
-  Used when class has too many instance attributes, try to reduce this to get a
-  more simple (and so easier to use) class.
-:R0903 (too-few-public-methods): *Too few public methods (%s/%s)*
-  Used when class has too few public methods, so be sure it's really worth it.
-:R0904 (too-many-public-methods): *Too many public methods (%s/%s)*
-  Used when class has too many public methods, try to reduce this to get a more
-  simple (and so easier to use) class.
-:R0911 (too-many-return-statements): *Too many return statements (%s/%s)*
-  Used when a function or method has too many return statement, making it hard
-  to follow.
-:R0912 (too-many-branches): *Too many branches (%s/%s)*
-  Used when a function or method has too many branches, making it hard to
-  follow.
-:R0913 (too-many-arguments): *Too many arguments (%s/%s)*
-  Used when a function or method takes too many arguments.
-:R0914 (too-many-locals): *Too many local variables (%s/%s)*
-  Used when a function or method has too many local variables.
-:R0915 (too-many-statements): *Too many statements (%s/%s)*
-  Used when a function or method has too many statements. You should then split
-  it in smaller functions / methods.
-:R0921 (abstract-class-not-used): *Abstract class not referenced*
-  Used when an abstract class is not used as ancestor anywhere.
-:R0922 (abstract-class-little-used): *Abstract class is only referenced %s times*
-  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.
-:R0924 (incomplete-protocol): *Badly implemented %s, implements %s but not %s*
-  A class implements some of the special methods for a particular protocol, but
-  not all of them
-
-
-string_constant checker
------------------------
-
-Messages
-~~~~~~~~
-:W1401 (anomalous-backslash-in-string): *Anomalous backslash in string: '%s'. String constant might be missing an r prefix.*
-  Used when a backslash is in a literal string but not as an escape.
-:W1402 (anomalous-unicode-escape-in-string): *Anomalous Unicode escape in byte string: '%s'. String constant might be missing an r or u prefix.*
-  Used when an escape like \u is encountered in a byte string where it has no
-  effect.
-
-
-similarities checker
---------------------
-
-Options
-~~~~~~~
-:min-similarity-lines:
-  Minimum lines number of a similarity.
-
-  Default: ``4``
-:ignore-comments:
-  Ignore comments when computing similarities.
-
-  Default: ``yes``
-:ignore-docstrings:
-  Ignore docstrings when computing similarities.
-
-  Default: ``yes``
-:ignore-imports:
-  Ignore imports when computing similarities.
-
-Messages
-~~~~~~~~
-:R0801 (duplicate-code): *Similar lines in %s files*
-  Indicates that a set of similar lines has been detected among multiple file.
-  This usually means that the code should be refactored to avoid this
-  duplication.
-
-Reports
-~~~~~~~
-:RP0801: Duplication
-
-
-exceptions checker
-------------------
-
-Options
-~~~~~~~
-:overgeneral-exceptions:
-  Exceptions that will emit a warning when being caught. Defaults to
-  "Exception"
-
-  Default: ``Exception``
-
-Messages
-~~~~~~~~
-:E0701 (bad-except-order): *Bad except clauses order (%s)*
-  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-bad-type): *Raising %s while only classes, instances or string are allowed*
-  Used when something which is neither a class, an instance or a string is
-  raised (i.e. a `TypeError` will be raised).
-:E0710 (raising-non-exception): *Raising a new style class which doesn't inherit from BaseException*
-  Used when a new style class which doesn't inherit from BaseException is
-  raised.
-:E0711 (notimplemented-raised): *NotImplemented raised - should raise NotImplementedError*
-  Used when NotImplemented is raised instead of NotImplementedError
-:W0701 (raising-string): *Raising a string exception*
-  Used when a string exception is raised.
-:W0702 (bare-except): *No exception type(s) specified*
-  Used when an except clause doesn't specify exceptions type to catch.
-:W0703 (broad-except): *Catching too general exception %s*
-  Used when an except catches a too general exception, possibly burying
-  unrelated errors.
-:W0704 (pointless-except): *Except doesn't do anything*
-  Used when an except clause does nothing but "pass" and there is no "else"
-  clause.
-:W0710 (nonstandard-exception): *Exception doesn't inherit from standard "Exception" class*
-  Used when a custom exception class is raised but doesn't inherit from the
-  builtin "Exception" class.
-:W0711 (binary-op-exception): *Exception to catch is the result of a binary "%s" operation*
-  Used when the exception to catch is of the form "except A or B:". If intending
-  to catch multiple, rewrite as "except (A, B):"
-
-
-newstyle checker
-----------------
-
-Messages
-~~~~~~~~
-:E1001 (slots-on-old-class): *Use of __slots__ on an old style class*
-  Used when an old style class uses the __slots__ attribute.
-:E1002 (super-on-old-class): *Use of super on an old style class*
-  Used when an old style class uses the super builtin.
-:E1003 (bad-super-call): *Bad first argument %r given to super class*
-  Used when another argument than the current class is given as first argument
-  of the super builtin.
-:W1001 (property-on-old-class): *Use of "property" on an old style class*
-  Used when Pylint detect the use of the builtin "property" on an old style
-  class while this is relying on new style classes features
-
-
-typecheck checker
------------------
-
-Options
-~~~~~~~
-:ignore-mixin-members:
-  Tells whether missing members accessed in mixin class should be ignored. A
-  mixin class is detected if its name ends with "mixin" (case insensitive).
-
-  Default: ``yes``
-:ignored-classes:
-  List of classes names for which member attributes should not be checked
-  (useful for classes with attributes dynamically set).
-
-  Default: ``SQLObject``
-:zope:
-  When zope mode is activated, add a predefined set of Zope acquired attributes
-  to generated-members.
-:generated-members:
-  List of members which are set dynamically and missed by pylint inference
-  system, and so shouldn't trigger E0201 when accessed. Python regular
-  expressions are accepted.
-
-  Default: ``REQUEST,acl_users,aq_parent``
-
-Messages
-~~~~~~~~
-:E1101 (no-member): *%s %r has no %r member*
-  Used when a variable is accessed for an unexistent member.
-:E1102 (not-callable): *%s is not callable*
-  Used when an object being called has been inferred to a non callable object
-:E1103 (maybe-no-member): *%s %r has no %r member (but some types could not be inferred)*
-  Used when a variable is accessed for an unexistent member, but astng was not
-  able to interpret all possible types of this variable.
-:E1111 (assignment-from-no-return): *Assigning to function call which doesn't return*
-  Used when an assignment is done on a function call but the inferred function
-  doesn't return anything.
-:E1120 (no-value-for-parameter): *No value passed for parameter %s in function call*
-  Used when a function call passes too few arguments.
-:E1121 (too-many-function-args): *Too many positional arguments for function call*
-  Used when a function call passes too many positional arguments.
-:E1122 (duplicate-keyword-arg): *Duplicate keyword argument %r in function call*
-  Used when a function call passes the same keyword argument multiple times.
-:E1123 (unexpected-keyword-arg): *Passing unexpected keyword argument %r in function call*
-  Used when a function call passes a keyword argument that doesn't correspond to
-  one of the function's parameter names.
-:E1124 (redundant-keyword-arg): *Parameter %r passed as both positional and keyword argument*
-  Used when a function call would result in assigning multiple values to a
-  function parameter, one value from a positional argument and one from a
-  keyword argument.
-:W1111 (assignment-from-none): *Assigning to function call which only returns None*
-  Used when an assignment is done on a function call but the inferred function
-  returns nothing but None.
-
-