diff options
author | Sylvain Thénault <sylvain.thenault@logilab.fr> | 2013-04-25 09:35:13 +0200 |
---|---|---|
committer | Sylvain Thénault <sylvain.thenault@logilab.fr> | 2013-04-25 09:35:13 +0200 |
commit | 8d3422e502e8148ec6819da62fdf63357f024984 (patch) | |
tree | 19b4e02dbd396ce9c662cbb529dead52cb034722 | |
parent | 31e6b776a0817ffc84e9a5c763d061dc7b4ca474 (diff) | |
download | pylint-git-8d3422e502e8148ec6819da62fdf63357f024984.tar.gz |
[doc gen] fix feature.rst generation rule in Makefile and remove it from hg
-rw-r--r-- | doc/Makefile | 21 | ||||
-rw-r--r-- | doc/features.rst | 832 |
2 files changed, 10 insertions, 843 deletions
diff --git a/doc/Makefile b/doc/Makefile index 4d0a8a2fc..c4d128067 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 6726ba573..000000000 --- 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. - - |