1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
#!/usr/bin/env python
# -*- coding: utf-8; mode: python; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- vim:fenc=utf-8:ft=python:et:sw=4:ts=4:sts=4
"""Emacs and Flymake compatible Pylint.
This script is for integration with emacs and is compatible with flymake mode.
epylint walks out of python packages before invoking pylint. This avoids
reporting import errors that occur when a module within a package uses the
absolute import path to get another module within this package.
For example:
- Suppose a package is structured as
a/__init__.py
a/b/x.py
a/c/y.py
- Then if y.py imports x as "from a.b import x" the following produces pylint errors
cd a/c; pylint y.py
- The following obviously doesn't
pylint a/c/y.py
- As this script will be invoked by emacs within the directory of the file
we are checking we need to go out of it to avoid these false positives.
You may also use py_run to run pylint with desired options and get back (or not) its output.
"""
import sys, os, re
from subprocess import Popen, PIPE
def lint(filename):
"""Pylint the given file.
When run from emacs we will be in the directory of a file, and passed its filename.
If this file is part of a package and is trying to import other modules from within
its own package or another package rooted in a directory below it, pylint will classify
it as a failed import.
To get around this, we traverse down the directory tree to find the root of the package this
module is in. We then invoke pylint from this directory.
Finally, we must correct the filenames in the output generated by pylint so Emacs doesn't
become confused (it will expect just the original filename, while pylint may extend it with
extra directories if we've traversed down the tree)
"""
# traverse downwards until we are out of a python package
fullPath = os.path.abspath(filename)
parentPath, childPath = os.path.dirname(fullPath), os.path.basename(fullPath)
while parentPath != "/" and os.path.exists(os.path.join(parentPath, '__init__.py')):
childPath = os.path.join(os.path.basename(parentPath), childPath)
parentPath = os.path.dirname(parentPath)
# Start pylint
# Ensure we use the python and pylint associated with the running epylint
lintPath = os.path.join(os.path.dirname(__file__), 'lint.py')
cmd = [sys.executable, lintPath, '-f', 'parseable', '-r', 'n',
'--disable=C,R,I', childPath]
process = Popen(cmd, stdout=PIPE, stderr=PIPE, cwd=parentPath)
# The parseable line format is '%(path)s:%(line)s: [%(sigle)s%(obj)s] %(msg)s'
# NOTE: This would be cleaner if we added an Emacs reporter to pylint.reporters.text ..
regex = re.compile(r"\[(?P<type>[WE])(?P<remainder>.*?)\]")
def _replacement(mObj):
"Alter to include 'Error' or 'Warning'"
if mObj.group("type") == "W":
replacement = "Warning"
else:
replacement = "Error"
# replace as "Warning (W0511, funcName): Warning Text"
return "%s (%s%s):" % (replacement, mObj.group("type"), mObj.group("remainder"))
for line in process.stdout:
# remove pylintrc warning
if line.startswith("No config file found"):
continue
line = regex.sub(_replacement, line, 1)
# modify the file name thats output to reverse the path traversal we made
parts = line.split(":")
if parts and parts[0] == childPath:
line = ":".join([filename] + parts[1:])
print line,
process.wait()
return process.returncode
def Run():
sys.exit(lint(sys.argv[1]))
def py_run(command_options='', return_std=False, stdout=None, stderr=None,
script='epylint'):
"""Run pylint from python (needs Python >= 2.4).
``command_options`` is a string containing ``pylint`` command line options;
``return_std`` (boolean) indicates return of created standart output
and error (see below);
``stdout`` and ``stderr`` are 'file-like' objects in which standart output
could be written.
Calling agent is responsible for stdout/err management (creation, close).
Default standart output and error are those from sys,
or standalone ones (``subprocess.PIPE``) are used
if they are not set and ``return_std``.
If ``return_std`` is set to ``True``, this function returns a 2-uple
containing standart output and error related to created process,
as follows: ``(stdout, stderr)``.
A trivial usage could be as follows:
>>> py_run( '--version')
No config file found, using default configuration
pylint 0.18.1,
...
To silently run Pylint on a module, and get its standart output and error:
>>> (pylint_stdout, pylint_stderr) = py_run( 'module_name.py', True)
"""
# Create command line to call pylint
if os.name == 'nt':
script += '.bat'
command_line = script + ' ' + command_options
# Providing standart output and/or error if not set
if stdout is None:
if return_std:
stdout = PIPE
else:
stdout = sys.stdout
if stderr is None:
if return_std:
stderr = PIPE
else:
stderr = sys.stderr
# Call pylint in a subprocess
p = Popen(command_line, shell=True, stdout=stdout, stderr=stderr)
p.wait()
# Return standart output and error
if return_std:
return (p.stdout, p.stderr)
if __name__ == '__main__':
lint(sys.argv[1])
|
