Pylint

A Python source code analyzer which looks for programming errors, helps enforcing a coding standard and sniffs for some code smells.

Version

1.9.4

Runtime

Python Versions

Supported Languages

Python

Official Documentation

https://www.pylint.org/

YAML Configuration

pylint:

  • input:

    Patterns to include in execution and reports.

  • ignore:

    Patterns to exclude from execution and reports.

  • auto-fix:

    N/A

  • config-file:

    Alias of --rcfile option.

  • machine:

    • cpu:

      Amount of CPU. The default machine has 0.75 CPU with 2880 MiB RAM.

      Inspecode automatically specifies --jobs option to Pylint according to this value. For example, --jobs=1 is specified by default (for 0.75 CPU), --jobs=2 is specified for 1.1 CPU.

  • options:

    Below is the list of options that are supported:

    Master:
      --rcfile=<file>     Specify a configuration file.
      -E, --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
      --py3k              In Python 3 porting mode, all checkers will be
                          disabled and only messages emitted by the porting
                          checker will be displayed
      --ignore=<file>[,<file>...]
                          Add files or directories to the blacklist. They should
                          be base names, not paths. [current: CVS]
      --ignore-patterns=<pattern>[,<pattern>...]
                          Add files or directories matching the regex patterns
                          to the blacklist. The regex matches against base
                          names, not paths. [current: none]
      --suggestion-mode=<yn>
                          When enabled, pylint would attempt to guess common
                          misconfiguration and emit user-friendly hints instead
                          of false-positive error messages [current: yes]
    Messages control:
      --confidence=<levels>
                          Only show warnings with the listed confidence levels.
                          Leave empty to show all. Valid levels: HIGH,
                          INFERENCE, INFERENCE_FAILURE, UNDEFINED [current:
                          none]
      -e <msg ids>, --enable=<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 (only on the command line, not in the
                          configuration file where it should appear only once).
                          See also the "--disable" option for examples.
      -d <msg ids>, --disable=<msg ids>
                          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"
    Reports:
      -r <y_or_n>, --reports=<y_or_n>
                          Tells whether to display a full report or only the
                          messages [current: no]
      -s <y_or_n>, --score=<y_or_n>
                          Activate the evaluation score. [current: yes]
    Basic:
      --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]
      --name-group=<name1:name2>
                          Colon-delimited sets of names that determine each
                          other's naming style when the name regexes allow
                          several styles. [current: none]
      --include-naming-hint=<y_or_n>
                          Include a hint for the correct naming format with
                          invalid-name [current: no]
      --property-classes=<decorator names>
                          List of decorators that produce properties, such as
                          abc.abstractproperty. Add to this list to register
                          other decorators that produce valid properties.
                          [current: abc.abstractproperty]
      --function-naming-style=<style>
                          Naming style matching correct function names [current:
                          snake_case]
      --function-rgx=<regexp>
                          Regular expression matching correct function names.
                          Overrides function-naming-style
      --const-naming-style=<style>
                          Naming style matching correct constant names [current:
                          UPPER_CASE]
      --const-rgx=<regexp>
                          Regular expression matching correct constant names.
                          Overrides const-naming-style
      --attr-naming-style=<style>
                          Naming style matching correct attribute names
                          [current: snake_case]
      --attr-rgx=<regexp>
                          Regular expression matching correct attribute names.
                          Overrides attr-naming-style
      --argument-naming-style=<style>
                          Naming style matching correct argument names [current:
                          snake_case]
      --argument-rgx=<regexp>
                          Regular expression matching correct argument names.
                          Overrides argument-naming-style
      --module-naming-style=<style>
                          Naming style matching correct module names [current:
                          snake_case]
      --module-rgx=<regexp>
                          Regular expression matching correct module names.
                          Overrides module-naming-style
      --method-naming-style=<style>
                          Naming style matching correct method names [current:
                          snake_case]
      --method-rgx=<regexp>
                          Regular expression matching correct method names.
                          Overrides method-naming-style
      --variable-naming-style=<style>
                          Naming style matching correct variable names [current:
                          snake_case]
      --variable-rgx=<regexp>
                          Regular expression matching correct variable names.
                          Overrides variable-naming-style
      --class-attribute-naming-style=<style>
                          Naming style matching correct class attribute names
                          [current: any]
      --class-attribute-rgx=<regexp>
                          Regular expression matching correct class attribute
                          names. Overrides class-attribute-naming-style
      --inlinevar-naming-style=<style>
                          Naming style matching correct inline iteration names
                          [current: any]
      --inlinevar-rgx=<regexp>
                          Regular expression matching correct inline iteration
                          names. Overrides inlinevar-naming-style
      --class-naming-style=<style>
                          Naming style matching correct class names [current:
                          PascalCase]
      --class-rgx=<regexp>
                          Regular expression matching correct class names.
                          Overrides class-naming-style
      --no-docstring-rgx=<regexp>
                          Regular expression which should only match function or
                          class names that do not require a docstring. [current:
                          ^_]
      --docstring-min-length=<int>
                          Minimum line length for functions/classes that require
                          docstrings, shorter ones are exempt. [current: -1]
    Spelling:
      --spelling-ignore-words=<comma separated words>
                          List of comma separated words that should not be
                          checked. [current: none]
      --spelling-private-dict-file=<path to file>
                          A path to a file that contains private dictionary; one
                          word per line. [current: none]
      --spelling-store-unknown-words=<y_or_n>
                          Tells whether to store unknown words to indicated
                          private dictionary in --spelling-private-dict-file
                          option instead of raising a message. [current: no]
      --max-spelling-suggestions=N
                          Limits count of emitted suggestions for spelling
                          mistakes [current: 4]
    Format:
      --max-line-length=<int>
                          Maximum number of characters on a single line.
                          [current: 100]
      --ignore-long-lines=<regexp>
                          Regexp for a line that is allowed to be longer than
                          the limit. [current: ^\s*(# )?<?https?://\S+>?$]
      --single-line-if-stmt=<y_or_n>
                          Allow the body of an if to be on the same line as the
                          test if there is no else. [current: no]
      --single-line-class-stmt=<y_or_n>
                          Allow the body of a class to be on the same line as
                          the declaration if body contains single statement.
                          [current: no]
      --no-space-check=trailing-comma,dict-separator,empty-line
                          List of optional constructs for which whitespace
                          checking is disabled. `dict-separator` is used to
                          allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
                          `trailing-comma` allows a space between comma and
                          closing bracket: (a, ). `empty-line` allows space-only
                          lines. [current: trailing-comma,dict-separator]
      --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 spaces) or "\t" (1 tab). [current: '    ']
      --indent-after-paren=<int>
                          Number of spaces of indent required inside a hanging
                          or continued line. [current: 4]
      --expected-line-ending-format=<empty or LF or CRLF>
                          Expected format of line ending, e.g. empty (any line
                          ending), LF or CRLF. [current: none]
    Miscellaneous:
      --notes=<comma separated values>
                          List of note tags to take in consideration, separated
                          by a comma. [current: FIXME,XXX,TODO]
    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]
      --ignore-imports=<y or n>
                          Ignore imports when computing similarities. [current:
                          no]
    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 name of dummy
                          variables (i.e. expectedly not used). [current: _+$|(_
                          [a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_]
      --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 possible. [current: none]
      --callbacks=<callbacks>
                          List of strings which can identify a callback function
                          by name. A callback name must start or end with one of
                          those strings. [current: cb_,_cb]
      --redefining-builtins-modules=<comma separated list>
                          List of qualified module names which can have objects
                          that can redefine builtins. [current:
                          six.moves,past.builtins,future.builtins,io,builtins]
      --ignored-argument-names=<regexp>
                          Argument names that match this expression will be
                          ignored. Default to name with leading underscore
                          [current: _.*|^ignored_|^unused_]
      --allow-global-unused-variables=<y_or_n>
                          Tells whether unused global variables should be
                          treated as a violation. [current: yes]
    Typecheck:
      --ignore-on-opaque-inference=<y_or_n>
                          This flag controls whether pylint should warn about
                          no-member and similar checks whenever an opaque object
                          is returned when inferring. The inference can return
                          multiple potential results while evaluating a Python
                          object, but some branches might not be evaluated,
                          which results in partial inference. In that case, it
                          might be useful to still emit no-member and other
                          checks for the rest of the inferred objects. [current:
                          yes]
      --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-modules=<module names>
                          List of module names for which member attributes
                          should not be checked (useful for modules/projects
                          where namespaces are manipulated during runtime and
                          thus existing member attributes cannot be deduced by
                          static analysis. It supports qualified module names,
                          as well as Unix pattern matching. [current: none]
      --ignored-classes=<members names>
                          List of class names for which member attributes should
                          not be checked (useful for classes with dynamically
                          set attributes). This supports the use of qualified
                          names. [current:
                          optparse.Values,thread._local,_thread._local]
      --generated-members=<members names>
                          List of members which are set dynamically and missed
                          by pylint inference system, and so shouldn't trigger
                          E1101 when accessed. Python regular expressions are
                          accepted. [current: none]
      --contextmanager-decorators=<decorator names>
                          List of decorators that produce context managers, such
                          as contextlib.contextmanager. Add to this list to
                          register other decorators that produce valid context
                          managers. [current: contextlib.contextmanager]
      --missing-member-hint-distance=<member hint edit distance>
                          The minimum edit distance a name should have in order
                          to be considered a similar match for a missing member
                          name. [current: 1]
      --missing-member-max-choices=<member hint max choices>
                          The total number of similar names that should be taken
                          in consideration when showing a hint for a missing
                          member. [current: 1]
      --missing-member-hint=<missing member hint>
                          Show a hint with possible names when a member name was
                          not found. The aspect of finding the hint is based on
                          edit distance. [current: yes]
    Exceptions:
      --overgeneral-exceptions=<comma-separated class names>
                          Exceptions that will emit a warning when being caught.
                          Defaults to "Exception" [current: Exception]
    Design:
      --max-args=<int>    Maximum number of arguments for function / method
                          [current: 5]
      --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-branches=<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). [current: 2]
      --max-public-methods=<num>
                          Maximum number of public methods for a class (see
                          R0904). [current: 20]
      --max-bool-expr=<num>
                          Maximum number of boolean expressions in a if
                          statement [current: 5]
    Refactoring:
      --max-nested-blocks=<int>
                          Maximum number of nested blocks for function / method
                          body [current: 5]
      --never-returning-functions=NEVER_RETURNING_FUNCTIONS
                          Complete name of functions that never returns. When
                          checking for inconsistent-return-statements if a never
                          returning function is called then it will be
                          considered as an explicit return statement and no
                          message will be printed. [current:
                          optparse.Values,sys.exit]
    Classes:
      --defining-attr-methods=<method names>
                          List of method names used to declare (i.e. assign)
                          instance attributes. [current: __init__,__new__,setUp]
      --valid-classmethod-first-arg=<argument names>
                          List of valid names for the first argument in a class
                          method. [current: cls]
      --valid-metaclass-classmethod-first-arg=<argument names>
                          List of valid names for the first argument in a
                          metaclass class method. [current: mcs]
      --exclude-protected=<protected access exclusions>
                          List of member names, which should be excluded from
                          the protected access warning. [current:
                          _asdict,_fields,_replace,_source,_make]
    Imports:
      --deprecated-modules=<modules>
                          Deprecated modules which should not be used, separated
                          by a comma [current: regsub,TERMIOS,Bastion,rexec]
      --known-standard-library=<modules>
                          Force import order to recognize a module as part of
                          the standard compatibility libraries. [current: none]
      --known-third-party=<modules>
                          Force import order to recognize a module as part of a
                          third party library. [current: enchant]
      --analyse-fallback-blocks=<y_or_n>
                          Analyse import fallback blocks. This can be used to
                          support both Python 2 and 3 compatible code, which
                          means that the block might have code that exists only
                          in one or another interpreter, leading to false
                          positives when analysed. [current: no]
      --allow-wildcard-with-all=<y_or_n>
                          Allow wildcard imports from modules that define
                          __all__. [current: no]
    Logging:
      --logging-modules=<comma separated list>
                          Logging modules to check that the string format
                          arguments are in logging function parameter format
                          [current: logging]
    
  • thresholds:

    • num-issues:

      In addition to general severity levels, the following tool specific severity levels can be specified:

      • F, Fatal (equivalent to general severity level critical)
      • E, Error (equivalent to general severity level error)
      • W, Warning (equivalent to general severity level warning)
      • C, Convention (equivalent to general severity level info)
      • R, Refactor (equivalent to general severity level info)
  • experimental:

    • incremental:

      true/false

      Note: The incremental analysis is disabled if any kinds of configuration files are changed. The files recognized as configuration files are as follows:

      • Configuration files:
        • Files specified in config-file field
        • Files specified to --rcfile option
        • If none of the above configuration files are found:
          • **/pylintrc, **/.pylintrc
      • Dictionary files:
        • Files specified to --spelling-private-dict-file option

      Note: The incremental analysis is disabled if external dependencies are required. See Resolving Dependencies about how the dependencies are resolved.

YAML Examples

  • With default options:

    inspecode:
      pylint: default
    
  • With custom machine:

    inspecode:
      pylint:
        machine:
          cpu: 1.5 # 1.5 CPU, 5760 MiB RAM
    
  • With custom options:

    inspecode:
      pylint:
        options:
          --confidence: HIGH
          --disable: W
    
  • With a configuration file:

    inspecode:
      pylint:
        config-file: ./my-pylintrc
    

    The above configuration is equivalent to:

    inspecode:
      pylint:
        options:
          --rcfile: ./my-pylintrc
    

Resolving Dependencies

The dependencies are resolved in the same manner as pytest. See the pytest page for the details.

results matching ""

    No results matching ""