Repository navigation
Expand file tree
/
Copy pathunpep8
More file actions
executable file
·198 lines (166 loc) · 6.78 KB
/
Copy pathunpep8
File metadata and controls
executable file
·198 lines (166 loc) · 6.78 KB
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
#!/usr/bin/python
"""
Translate from PEP8 Python style to Mininet (i.e. Arista-like)
Python style
usage: unpep8 < old.py > new.py
- Reinstates CapWords for methods and instance variables
- Gets rid of triple single quotes
- Eliminates triple quotes on single lines
- Inserts extra spaces to improve readability
- Fixes Doxygen (or doxypy) ugliness
Does the following translations:
ClassName.method_name(foo = bar) -> ClassName.methodName( foo=bar )
Triple-single-quotes -> triple-double-quotes
@param foo description -> foo: description
@return description -> returns: description
@author me -> author: me
@todo(me) -> TODO(me)
Bugs/Limitations:
- Hack to restore strings is ugly
- Multiline strings get mangled
- Comments are mangled (which is arguably the "right thing" to do, except
that, for example, the left hand sides of the above would get translated!)
- Doesn't eliminate unnecessary backslashes
- Has no opinion on tab size
- complicated indented docstrings get flattened
- We don't (yet) have a filter to generate Doxygen/Doxypy
- Currently leaves indents on blank comment lines
- May lead to namespace collisions (e.g. some_thing and someThing)
8000
Bob Lantz, rlantz@cs.stanford.edu
1/24/2010
"""
import re, sys
def fixUnderscoreTriplet( match ):
"Translate a matched triplet of the form a_b to aB."
triplet = match.group()
return triplet[ :-2 ] + triplet[ -1 ].capitalize()
def reinstateCapWords( text ):
underscoreTriplet = re.compile( r'[A-Za-z0-9]_[A-Za-z0-9]' )
return underscoreTriplet.sub( fixUnderscoreTriplet, text )
def replaceTripleApostrophes( text ):
"Replace triple apostrophes with triple quotes."
return text.replace( "'''", '"""')
def simplifyTripleQuotes( text ):
"Fix single-line doc strings."
r = re.compile( r'"""([^\"\n]+)"""' )
return r.sub( r'"\1"', text )
def insertExtraSpaces( text ):
"Insert extra spaces inside of parentheses and brackets/curly braces."
lparen = re.compile( r'\((?![\s\)])' )
text = lparen.sub( r'( ', text )
rparen = re.compile( r'([^\s\(])(?=\))' )
text = rparen.sub( r'\1 ', text)
# brackets
lbrack = re.compile( r'\[(?![\s\]])' )
text = lbrack.sub( r'[ ', text )
rbrack = re.compile( r'([^\s\[])(?=\])' )
text = rbrack.sub( r'\1 ', text)
# curly braces
lcurly = re.compile( r'\{(?![\s\}])' )
text = lcurly.sub( r'{ ', text )
rcurly = re.compile( r'([^\s\{])(?=\})' )
text = rcurly.sub( r'\1 ', text)
return text
def fixDoxygen( text ):
"""Translate @param foo to foo:, @return bar to returns: bar, and
@author me to author: me"""
param = re.compile( r'@param (\w+)' )
text = param.sub( r'\1:', text )
returns = re.compile( r'@return' )
text = returns.sub( r'returns:', text )
author = re.compile( r'@author' )
text = author.sub( r'author:', text)
# @todo -> TODO
text = text.replace( '@todo', 'TODO' )
return text
def removeCommentFirstBlankLine( text ):
"Remove annoying blank lines after first line in comments."
line = re.compile( r'("""[^\n]*\n)\s*\n', re.MULTILINE )
return line.sub( r'\1', text )
def fixArgs( match, kwarg = re.compile( r'(\w+) = ' ) ):
"Replace foo = bar with foo=bar."
return kwarg.sub( r'\1=', match.group() )
def fixKeywords( text ):
"Change keyword argumentsfrom foo = bar to foo=bar."
args = re.compile( r'\(([^\)]+)\)', re.MULTILINE )
return args.sub( fixArgs, text )
# Unfortunately, Python doesn't natively support balanced or recursive
# regular expressions. We could use PyParsing, but that opens another can
# of worms. For now, we just have a cheap hack to restore strings,
# so we don't end up accidentally mangling things like messages, search strings,
# and regular expressions.
def lineIter( text ):
"Simple iterator over lines in text."
for line in text.splitlines(): yield line
def stringIter( strList ):
"Yield strings in strList."
for s in strList: yield s
def restoreRegex( regex, old, new ):
"Find regexes in old and restore them into new."
oldStrs = regex.findall( old )
# Sanity check - count should be the same!
newStrs = regex.findall( new )
assert len( oldStrs ) == len( newStrs )
# Replace newStrs with oldStrs
siter = stringIter( oldStrs )
reps = lambda dummy: siter.next()
return regex.sub( reps, new )
# This is a cheap hack, and it may not work 100%, since
# it doesn't handle multiline strings.
# However, it should be mostly harmless...
def restoreStrings( oldText, newText ):
"Restore strings from oldText into newText, returning result."
oldLines, newLines = lineIter( oldText ), lineIter( newText )
quoteStrings = re.compile( r'("[^"]*")' )
tickStrings = re.compile( r"('[^']*')" )
result = ''
# It would be nice if we could blast the whole file, but for
# now it seems to work line-by-line
for newLine in newLines:
oldLine = oldLines.next()
newLine = restoreRegex( quoteStrings, oldLine, newLine )
newLine = restoreRegex( tickStrings, oldLine, newLine )
result += newLine + '\n'
return result
# This might be slightly controversial, since it uses
# three spaces to line up multiline comments. However,
# I much prefer it. Limitations: if you have deeper
# indents in comments, they will be eliminated. ;-(
def fixComment( match,
indentExp=re.compile( r'\n([ ]*)(?=[^/s])', re.MULTILINE ),
trailingQuotes=re.compile( r'\s+"""' ) ):
"Re-indent comment, and join trailing quotes."
originalIndent = match.group( 1 )
comment = match.group( 2 )
indent = '\n' + originalIndent
# Exception: leave unindented things unindented!
if len( originalIndent ) is not 0: indent += ' '
comment = indentExp.sub( indent, comment )
return originalIndent + trailingQuotes.sub( '"""', comment )
def fixCommentIndents( text ):
"Fix multiline comment indentation."
comments = re.compile( r'^([ ]*)("""[^"]*""")$', re.MULTILINE )
return comments.sub( fixComment, text )
def removeBogusLinefeeds( text ):
"Remove extra linefeeds at the end of single-line comments."
bogusLfs = re.compile( r'"([^"\n]*)\n"', re.MULTILINE )
return bogusLfs.sub( '"\1"', text)
def convertFromPep8( program ):
oldProgram = program
# Program text transforms
program = reinstateCapWords( program )
program = fixKeywords( program )
program = insertExtraSpaces( program )
# Undo string damage
program = restoreStrings( oldProgram, program )
# Docstring transforms
program = replaceTripleApostrophes( program )
program = simplifyTripleQuotes( program )
program = fixDoxygen( program )
program = fixCommentIndents( program )
program = removeBogusLinefeeds( program )
# Destructive transforms (these can delete lines)
program = removeCommentFirstBlankLine( program )
return program
if __name__ == '__main__':
print convertFromPep8( sys.stdin.read() )