pylint man page on Cygwin

Man page or keyword search:  
man Server   22533 pages
apropos Keyword Search (all sections)
Output format
Cygwin logo
[printable version]

pylint(1)							     pylint(1)

NAME
       pylint - python code static checker

SYNOPSIS
       pylint [ OPTIONS ] [ <arguments> ]

DESCRIPTION
       pylint  is  a  Python  source code analyzer which looks for programming
       errors, helps enforcing a coding standard  and  sniffs  for  some  code
       smells (as defined in Martin Fowler's Refactoring book)

       Pylint  can be seen as another PyChecker since nearly all tests you can
       do with PyChecker can also be done with Pylint. However, Pylint	offers
       some  more features, like checking length of lines of code, checking if
       variable names are well-formed according to your	 coding	 standard,  or
       checking if declared interfaces are truly implemented, and much more.

       Additionally, it is possible to write plugins to add your own checks.

OPTIONS
       --version
	      show program's version number and exit

       --help, -h
	      show this help message and exit

       --long-help
	      more verbose help.

MASTER
       --rcfile=<file>
	      Specify a configuration file.

       --init-hook=<code>
	      Python  code  to execute, usually for sys.path manipulation such
	      as pygtk.require().

       --errors-only, -E
	      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

       --ignore=<file>[,<file>...]
	      Add files or directories to the blacklist. They should  be  base
	      names, not paths.

       --persistent=<y_or_n>
	      Pickle collected data for later comparisons. [current: yes]

       --load-plugins=<modules>
	      List  of	plugins	 (as  comma separated values of python modules
	      names) to load, usually to register additional  checkers.	 [cur‐
	      rent: none]

COMMANDS
       --help-msg=<msg-id>
	      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.

MESSAGES CONTROL
       --enable=<msg ids>, -e <msg ids>
	      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=<msg ids>, -d <msg ids>
	      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
       --output-format=<format>, -f <format>
	      Set   the	  output   format.   Available	 formats   are	 text,
	      parseable,  colorized,  msvs  (visual studio) and html [current:
	      text]

       --include-ids=<y_or_n>, -i <y_or_n>
	      Include message's id in output [current: no]

       --files-output=<y_or_n>
	      Put messages in a separate file for each module / package speci‐
	      fied  on	the  command  line instead of printing them on stdout.
	      Reports  (if   any)   will   be	written	  in   a   file	  name
	      "pylint_global.[txt|html]". [current: no]

       --reports=<y_or_n>, -r <y_or_n>
	      Tells  whether  to  display  a  full report or only the messages
	      [current: yes]

       --evaluation=<python_expression>
	      Python expression which should return a note less than 10 (10 is
	      the highest note). You have access to the variables errors warn‐
	      ing, 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).	 [cur‐
	      rent:  10.0  -  ((float(5 * error + warning + refactor + conven‐
	      tion) / statement) * 10)]

       --comment=<y_or_n>
	      Add a comment according to your evaluation note. This is used by
	      the global evaluation report (RP0004). [current: no]

FORMAT
       --max-line-length=<int>
	      Maximum number of characters on a single line. [current: 80]

       --max-module-lines=<int>
	      Maximum number of lines in a module [current: 1000]

       --indent-string=<string>
	      String  used as indentation unit. This is usually "    " (4 spa‐
	      ces) or "" (1 tab). [current: '	 ']

IMPORTS
       --deprecated-modules=<modules>
	      Deprecated modules which should not  be  used,  separated	 by  a
	      comma [current: regsub,string,TERMIOS,Bastion,rexec]

       --import-graph=<file.dot>
	      Create  a	 graph of every (i.e. internal and external) dependen‐
	      cies in the given file (report  RP0402  must  not	 be  disabled)
	      [current: none]

       --ext-import-graph=<file.dot>
	      Create  a	 graph	of  external  dependencies  in	the given file
	      (report RP0402 must not be disabled) [current: none]

       --int-import-graph=<file.dot>
	      Create a graph  of  internal  dependencies  in  the  given  file
	      (report RP0402 must not be disabled) [current: none]

DESIGN
       --max-args=<int>
	      Maximum number of arguments for function / method [current: 5]

       --ignored-argument-names=<regexp>
	      Argument	names  that  match  this  expression  will be ignored.
	      Default to name with leading underscore [current: _.*]

       --max-locals=<int>
	      Maximum number of locals for function /  method  body  [current:
	      15]

       --max-returns=<int>
	      Maximum  number  of  return  /  yield for function / method body
	      [current: 6]

       --max-branchs=<int>
	      Maximum number of branch for function /  method  body  [current:
	      12]

       --max-statements=<int>
	      Maximum number of statements in function / method body [current:
	      50]

       --max-parents=<num>
	      Maximum number of parents for a class (see R0901). [current: 7]

       --max-attributes=<num>
	      Maximum number of attributes for a class (see R0902).  [current:
	      7]

       --min-public-methods=<num>
	      Minimum  number of public methods for a class (see R0903). [cur‐
	      rent: 2]

       --max-public-methods=<num>
	      Maximum number of public methods for a class (see R0904).	 [cur‐
	      rent: 20]

MISCELLANEOUS
       --notes=<comma separated values>
	      List  of	note  tags  to	take  in consideration, separated by a
	      comma. [current: FIXME,XXX,TODO]

VARIABLES
       --init-import=<y_or_n>
	      Tells whether we should check  for  unused  import  in  __init__
	      files. [current: no]

       --dummy-variables-rgx=<regexp>
	      A	   regular    expression    matching	the    beginning    of
	      the name of dummy variables (i.e. not used). [current: _|dummy]

       --additional-builtins=<comma separated list>
	      List of additional names supposed to  be	defined	 in  builtins.
	      Remember	that you should avoid to define new builtins when pos‐
	      sible. [current: none]

TYPECHECK
       --ignore-mixin-members=<y_or_n>
	      Tells whether missing members accessed in mixin class should  be
	      ignored. A mixin class is detected if its name ends with "mixin"
	      (case insensitive). [current: yes]

       --ignored-classes=<members names>
	      List of classes names for which member attributes should not  be
	      checked  (useful	for  classes with attributes dynamically set).
	      [current: SQLObject]

       --zope=<y_or_n>
	      When zope mode is	 activated,  add  a  predefined	 set  of  Zope
	      acquired attributes to generated-members. [current: no]

       --generated-members=<members names>
	      List  of	members which are set dynamically and missed by pylint
	      inference system, and so shouldn't trigger E0201 when  accessed.
	      [current: REQUEST,acl_users,aq_parent]

BASIC
       --required-attributes=<attributes>
	      Required	attributes  for module, separated by a comma [current:
	      none]

       --bad-functions=<builtin function names>
	      List of builtins function names that should not be  used,	 sepa‐
	      rated by a comma [current: map,filter,apply,input]

       --module-rgx=<regexp>
	      Regular  expression which should only match correct module names
	      [current: (([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$]

       --const-rgx=<regexp>
	      Regular expression which should only match correct module	 level
	      names [current: (([A-Z_][A-Z0-9_]*)|(__.*__))$]

       --class-rgx=<regexp>
	      Regular  expression  which should only match correct class names
	      [current: [A-Z_][a-zA-Z0-9]+$]

       --function-rgx=<regexp>
	      Regular expression which	should	only  match  correct  function
	      names [current: [a-z_][a-z0-9_]{2,30}$]

       --method-rgx=<regexp>
	      Regular  expression which should only match correct method names
	      [current: [a-z_][a-z0-9_]{2,30}$]

       --attr-rgx=<regexp>
	      Regular expression which	should	only  match  correct  instance
	      attribute names [current: [a-z_][a-z0-9_]{2,30}$]

       --argument-rgx=<regexp>
	      Regular  expression  which  should  only	match correct argument
	      names [current: [a-z_][a-z0-9_]{2,30}$]

       --variable-rgx=<regexp>
	      Regular expression which	should	only  match  correct  variable
	      names [current: [a-z_][a-z0-9_]{2,30}$]

       --inlinevar-rgx=<regexp>
	      Regular  expression which should only match correct list compre‐
	      hension	    /	    generator	    expression	      variable
	      names [current: [A-Za-z_][A-Za-z0-9_]*$]

       --good-names=<names>
	      Good  variable  names which should always be accepted, separated
	      by a comma [current: i,j,k,ex,Run,_]

       --bad-names=<names>
	      Bad variable names which should always be refused, separated  by
	      a comma [current: foo,bar,baz,toto,tutu,tata]

       --no-docstring-rgx=<regexp>
	      Regular  expression which should only match functions or classes
	      name which do not require a docstring [current: __.*__]

SIMILARITIES
       --min-similarity-lines=<int>
	      Minimum lines number of a similarity. [current: 4]

       --ignore-comments=<y or n>
	      Ignore comments when computing similarities. [current: yes]

       --ignore-docstrings=<y or n>
	      Ignore docstrings when computing similarities. [current: yes]

CLASSES
       --ignore-iface-methods=<method names>
	      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.	   [current:	  isImplement‐
	      edBy,deferred,extends,names,namesAndDescriptions,queryDescrip‐
	      tionFor,getBases,getDescriptionFor,getDoc,getName,getTagged‐
	      Value,getTaggedValueTags,isEqualOrExtendedBy,setTagged‐
	      Value,isImplementedByInstancesOf,adaptWith,is_implemented_by]

       --defining-attr-methods=<method names>
	      List of method names used	 to  declare  (i.e.  assign)  instance
	      attributes. [current: __init__,__new__,setUp]

ENVIRONMENT VARIABLES
       The following environment variables are used :
	   * PYLINTHOME
	   path	 to the directory where data of persistent run will be stored.
       If not found, it defaults to ~/.pylint.d/ or .pylint.d (in the  current
       working directory).
	   * PYLINTRC
	   path to the configuration file. If not found, it will use the first
       existent file in ~/.pylintrc, /etc/pylintrc.

OUTPUT
       Using the default text output, the message format is :

	       MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE

       There are 5 kind of message types :
	   * (C) convention, for programming standard violation
	   * (R) refactor, for bad code smell
	   * (W) warning, for python specific problems
	   * (E) error, for probable bugs in the code
	   * (F) fatal, if an error occurred which prevented pylint from doing
       further processing.

OUTPUT STATUS CODE
       Pylint should leave with following status code:
	   * 0 if everything went fine
	   * 1 if a fatal message was issued
	   * 2 if an error message was issued
	   * 4 if a warning message was issued
	   * 8 if a refactor message was issued
	   * 16 if a convention message was issued
	   * 32 on usage error

       status  1  to 16 will be bit-ORed so you can know which different cate‐
       gories has been issued by analysing pylint output status code

SEE ALSO
       epylint(1) pylint-gui(1) pyreverse(1) symilar(1)

       /usr/share/doc/pylint/

COPYRIGHT
       Logilab S.A.

BUGS
       Please report bugs on  the  project's  mailing  list:  mailto://python-
       projects@lists.logilab.org

AUTHOR
       Logilab <python-projects@lists.logilab.org>

pylint				  2010-11-15			     pylint(1)
[top]

List of man pages available for Cygwin

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net