mirror of
https://fuchsia.googlesource.com/third_party/github.com/pylint-dev/pylint
synced 2024-09-20 23:51:39 +00:00
770 lines
29 KiB
Plaintext
770 lines
29 KiB
Plaintext
PyLint features
|
|
===============
|
|
|
|
.. generated by pylint --full-documentation
|
|
|
|
.. 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 <file or directory> to the black list. It should be a base name, not a
|
|
path. You may set this option multiple times.
|
|
|
|
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.
|
|
|
|
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.
|
|
|
|
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.
|
|
:disable:
|
|
Disable 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 (only on the command line, not in the configuration file where
|
|
it should appear only once).
|
|
|
|
Reports options
|
|
~~~~~~~~~~~~~~~
|
|
:output-format:
|
|
Set the output format. Available formats are text, parseable, colorized, msvs
|
|
(visual studio) and html
|
|
|
|
Default: ``text``
|
|
:include-ids:
|
|
Include message's id 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).
|
|
|
|
metrics checker
|
|
---------------
|
|
|
|
Reports
|
|
~~~~~~~
|
|
:RP0701: Raw metrics
|
|
|
|
|
|
logging checker
|
|
---------------
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:W1201: *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/.
|
|
|
|
:E1200: *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 string ends in middle of conversion specifier*
|
|
Used when a logging statement format string terminates before the end of a
|
|
conversion specifier.
|
|
|
|
:E1205: *Too many arguments for logging format string*
|
|
Used when a logging format string is given too few arguments.
|
|
|
|
:E1206: *Not enough arguments for logging format string*
|
|
Used when a logging format string is given too many arguments.
|
|
|
|
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``
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:R0801: *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
|
|
~~~~~~~
|
|
:R0801: Duplication
|
|
|
|
|
|
string_format checker
|
|
---------------------
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E1300: *Unsupported format character %r (%#02x) at index %d*
|
|
Used when a unsupported format character is used in a format string.
|
|
:E1301: *Format string ends in middle of conversion specifier*
|
|
Used when a format string terminates before the end of a conversion specifier.
|
|
:E1302: *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: *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 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 arguments for format string*
|
|
Used when a format string that uses unnamed conversion specifiers is given too
|
|
few arguments.
|
|
:E1306: *Not enough arguments for format string*
|
|
Used when a format string that uses unnamed conversion specifiers is given too
|
|
many arguments
|
|
:W1300: *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 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*
|
|
Used when a statement is ended by a semi-colon (";"), which isn't necessary
|
|
(that's python, not C ;).
|
|
:W0311: *Bad indentation. Found %s %s, expected %s*
|
|
Used when an unexpected number of indentation's tabulations or spaces has been
|
|
found.
|
|
:W0312: *Found indentation with %ss instead of %ss*
|
|
Used when there are some mixed tabs and spaces in a module.
|
|
:W0331: *Use of the <> operator*
|
|
Used when the deprecated "<>" operator is used instead of "!=".
|
|
:W0332: *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: *Use of the `` operator*
|
|
Used when the deprecated "``" (backtick) operator is used instead of the str()
|
|
function.
|
|
:C0301: *Line too long (%s/%s)*
|
|
Used when a line is longer than a given number of characters.
|
|
:C0302: *Too many lines in module (%s)*
|
|
Used when a module has too much lines, reducing its readability.
|
|
:C0321: *More than one statement on a single line*
|
|
Used when more than on statement are found on the same line.
|
|
:C0322: *Operator not preceded by a space*
|
|
Used when one of the following operator (!= | <= | == | >= | < | > | = | \+= |
|
|
-= | \*= | /= | %) is not preceded by a space.
|
|
:C0323: *Operator not followed by a space*
|
|
Used when one of the following operator (!= | <= | == | >= | < | > | = | \+= |
|
|
-= | \*= | /= | %) is not followed by a space.
|
|
:C0324: *Comma not followed by a space*
|
|
Used when a comma (",") is not followed by a space.
|
|
|
|
|
|
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.
|
|
|
|
Default: ``REQUEST,acl_users,aq_parent``
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E1101: *%s %r has no %r member*
|
|
Used when a variable is accessed for an unexistent member.
|
|
:E1102: *%s is not callable*
|
|
Used when an object being called has been inferred to a non callable object
|
|
:E1103: *%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: *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 passed for parameter %s in function call*
|
|
Used when a function call passes too few arguments.
|
|
:E1121: *Too many positional arguments for function call*
|
|
Used when a function call passes too many positional arguments.
|
|
:E1122: *Duplicate keyword argument %r in function call*
|
|
Used when a function call passes the same keyword argument multiple times.
|
|
:E1123: *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: *Multiple values passed for parameter %r in function call*
|
|
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: *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.
|
|
|
|
|
|
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: *Using variable %r before assignment*
|
|
Used when a local variable is accessed before it's assignment.
|
|
:E0602: *Undefined variable %r*
|
|
Used when an undefined variable is accessed.
|
|
:E0611: *No name %r in module %r*
|
|
Used when a name cannot be found in a module.
|
|
:W0601: *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: *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: *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: *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 %s*
|
|
Used when an imported module or variable is not used.
|
|
:W0612: *Unused variable %r*
|
|
Used when a variable is defined but not used.
|
|
:W0613: *Unused argument %r*
|
|
Used when a function or method argument is not used.
|
|
:W0614: *Unused import %s from wildcard import*
|
|
Used when an imported module or variable is not used from a 'from X import *'
|
|
style import.
|
|
:W0621: *Redefining name %r from outer scope (line %s)*
|
|
Used when a variable's name hide a name defined in the outer scope.
|
|
:W0622: *Redefining built-in %r*
|
|
Used when a variable or function override a built-in.
|
|
:W0631: *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.
|
|
|
|
|
|
miscellaneous checker
|
|
---------------------
|
|
|
|
Options
|
|
~~~~~~~
|
|
:notes:
|
|
List of note tags to take in consideration, separated by a comma.
|
|
|
|
Default: ``FIXME,XXX,TODO``
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E0501: *Non ascii characters found but no encoding specified (PEP 263)*
|
|
Used when some non ascii characters are detected but now encoding is
|
|
specified, as explicited in the PEP 263.
|
|
:E0502: *Wrong encoding specified (%s)*
|
|
Used when a known encoding is specified but the file doesn't seem to be
|
|
actually in this encoding.
|
|
:W0511:
|
|
Used when a warning note as FIXME or XXX is detected.
|
|
|
|
|
|
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 %s*
|
|
Used when `from module import *` is detected.
|
|
:W0402: *Uses of a deprecated module %r*
|
|
Used a module marked as deprecated is imported.
|
|
:W0403: *Relative import %r, should be %r*
|
|
Used when an import relative to the package directory is detected.
|
|
:W0404: *Reimport %r (imported line %s)*
|
|
Used when a module is reimported multiple times.
|
|
:W0406: *Module import itself*
|
|
Used when a module is importing itself.
|
|
:W0410: *__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 (%s)*
|
|
Used when a cyclic import between two or more modules is detected.
|
|
:F0401: *Unable to import %r*
|
|
Used when pylint has been unable to import a module.
|
|
|
|
Reports
|
|
~~~~~~~
|
|
:RP0401: External dependencies
|
|
:RP0402: Modules dependencies graph
|
|
|
|
|
|
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``
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E0202: *An attribute inherited from %s hide this method*
|
|
Used when a class defines a method which is hidden by an instance attribute
|
|
from an ancestor class.
|
|
:E0203: *Access to member %r before its definition line %s*
|
|
Used when an instance member is accessed before it's actually assigned.
|
|
:E0211: *Method has no argument*
|
|
Used when a method which should have the bound instance as first argument has
|
|
no argument defined.
|
|
:E0213: *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 resolved to %s is not a class*
|
|
Used when a class claims to implement an interface which is not a class.
|
|
:E0222: *Missing method %r from %s interface*
|
|
Used when a method declared in an interface is missing from a class
|
|
implementing this interface
|
|
:W0201: *Attribute %r defined outside __init__*
|
|
Used when an instance attribute is defined outside the __init__ method.
|
|
:W0211: *Static method with %r as first argument*
|
|
Used when a static method has "self" or "cls" as first argument.
|
|
:W0212: *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 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 from %s method*
|
|
Used when a method signature is different than in the implemented interface or
|
|
in an overridden method.
|
|
:W0223: *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: *__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: *Class has no __init__ method*
|
|
Used when a class has no __init__ method, neither its parent classes.
|
|
:W0233: *__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: *Method could be a function*
|
|
Used when a method doesn't use its bound instance, and so could be written as
|
|
a function.
|
|
:C0202: *Class method should have "cls" as first argument*
|
|
Used when a class method has an attribute different than "cls" as first
|
|
argument, to easily differentiate them from regular instance methods.
|
|
:C0203: *Metaclass method should have "mcs" as first argument*
|
|
Used when a metaclass method has an attribute different the "mcs" as first
|
|
argument.
|
|
:F0202: *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: *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 (%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 (%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 (%s/%s)*
|
|
Used when class has too few public methods, so be sure it's really worth it.
|
|
:R0904: *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 (%s/%s)*
|
|
Used when a function or method has too many return statement, making it hard
|
|
to follow.
|
|
:R0912: *Too many branches (%s/%s)*
|
|
Used when a function or method has too many branches, making it hard to
|
|
follow.
|
|
:R0913: *Too many arguments (%s/%s)*
|
|
Used when a function or method takes too many arguments.
|
|
:R0914: *Too many local variables (%s/%s)*
|
|
Used when a function or method has too many local variables.
|
|
:R0915: *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 referenced*
|
|
Used when an abstract class is not used as ancestor anywhere.
|
|
:R0922: *Abstract class is only referenced %s times*
|
|
Used when an abstract class is used less than X times as ancestor.
|
|
:R0923: *Interface not implemented*
|
|
Used when an interface class is not implemented anywhere.
|
|
|
|
|
|
basic checker
|
|
-------------
|
|
|
|
Options
|
|
~~~~~~~
|
|
: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: ``__.*__``
|
|
: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``
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E0100: *__init__ method is a generator*
|
|
Used when the special class method __init__ is turned into a generator by a
|
|
yield in its body.
|
|
:E0101: *Explicit return in __init__*
|
|
Used when the special class method __init__ has an explicit return value.
|
|
:E0102: *%s already defined line %s*
|
|
Used when a function / class / method is redefined.
|
|
:E0103: *%r not properly in loop*
|
|
Used when break or continue keywords are used outside a loop.
|
|
:E0104: *Return outside function*
|
|
Used when a "return" statement is found outside a function or method.
|
|
:E0105: *Yield outside function*
|
|
Used when a "yield" statement is found outside a function or method.
|
|
:E0106: *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: *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.
|
|
:W0101: *Unreachable code*
|
|
Used when there is some code behind a "return" or "raise" statement, which
|
|
will never be accessed.
|
|
:W0102: *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: *Statement seems to have no effect*
|
|
Used when a statement doesn't have (or at least seems to) any effect.
|
|
:W0105: *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 "%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 statement*
|
|
Used when a "pass" statement that can be avoided is encountered.)
|
|
:W0108: *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 %r in dictionary*
|
|
Used when a dictionary expression binds the same key multiple times.
|
|
:W0122: *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: *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: *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: *%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 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: *Black listed name "%s"*
|
|
Used when the name is listed in the black list (unauthorized names).
|
|
:C0103: *Invalid name "%s" (should match %s)*
|
|
Used when the name doesn't match the regular expression associated to its type
|
|
(constant, variable, class...).
|
|
:C0111: *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*
|
|
Used when a module, function, class or method has an empty docstring (it would
|
|
be too easy ;).
|
|
:C0121: *Missing required attribute "%s"*
|
|
Used when an attribute required for modules is missing.
|
|
|
|
Reports
|
|
~~~~~~~
|
|
:RP0101: Statistics by type
|
|
|
|
|
|
exceptions checker
|
|
------------------
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E0701: *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 %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 a new style class which doesn't inherit from BaseException*
|
|
Used when a new style class which doesn't inherit from BaseException is raised
|
|
since it's not possible with python >= 2.5.
|
|
:E0711: *NotImplemented raised - should raise NotImplementedError*
|
|
Used when NotImplemented is raised instead of NotImplementedError
|
|
:W0701: *Raising a string exception*
|
|
Used when a string exception is raised.
|
|
:W0702: *No exception type(s) specified*
|
|
Used when an except clause doesn't specify exceptions type to catch.
|
|
:W0703: *Catch "Exception"*
|
|
Used when an except catches Exception instances.
|
|
:W0704: *Except doesn't do anything*
|
|
Used when an except clause does nothing but "pass" and there is no "else"
|
|
clause.
|
|
:W0710: *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.
|
|
|
|
|
|
newstyle checker
|
|
----------------
|
|
|
|
Messages
|
|
~~~~~~~~
|
|
:E1001: *Use __slots__ on an old style class*
|
|
Used when an old style class use the __slots__ attribute.
|
|
:E1002: *Use super on an old style class*
|
|
Used when an old style class use the super builtin.
|
|
:E1003: *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: *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
|
|
|
|
|