4 Translate from PEP8 Python style to Mininet (i.e. Arista-like)
7 usage: unpep8 < old.py > new.py
9 - Reinstates CapWords for methods and instance variables
10 - Gets rid of triple single quotes
11 - Eliminates triple quotes on single lines
12 - Inserts extra spaces to improve readability
13 - Fixes Doxygen (or doxypy) ugliness
15 Does the following translations:
17 ClassName.method_name(foo = bar) -> ClassName.methodName( foo=bar )
19 Triple-single-quotes -> triple-double-quotes
21 @param foo description -> foo: description
22 @return description -> returns: description
23 @author me -> author: me
28 - Hack to restore strings is ugly
29 - Multiline strings get mangled
30 - Comments are mangled (which is arguably the "right thing" to do, except
31 that, for example, the left hand sides of the above would get translated!)
32 - Doesn't eliminate unnecessary backslashes
33 - Has no opinion on tab size
34 - complicated indented docstrings get flattened
35 - We don't (yet) have a filter to generate Doxygen/Doxypy
36 - Currently leaves indents on blank comment lines
37 - May lead to namespace collisions (e.g. some_thing and someThing)
39 Bob Lantz, rlantz@cs.stanford.edu
43 from __future__ import print_function
46 def fixUnderscoreTriplet( match ):
47 "Translate a matched triplet of the form a_b to aB."
48 triplet = match.group()
49 return triplet[ :-2 ] + triplet[ -1 ].capitalize()
51 def reinstateCapWords( text ):
52 underscoreTriplet = re.compile( r'[A-Za-z0-9]_[A-Za-z0-9]' )
53 return underscoreTriplet.sub( fixUnderscoreTriplet, text )
55 def replaceTripleApostrophes( text ):
56 "Replace triple apostrophes with triple quotes."
57 return text.replace( "'''", '"""')
59 def simplifyTripleQuotes( text ):
60 "Fix single-line doc strings."
61 r = re.compile( r'"""([^\"\n]+)"""' )
62 return r.sub( r'"\1"', text )
64 def insertExtraSpaces( text ):
65 "Insert extra spaces inside of parentheses and brackets/curly braces."
66 lparen = re.compile( r'\((?![\s\)])' )
67 text = lparen.sub( r'( ', text )
68 rparen = re.compile( r'([^\s\(])(?=\))' )
69 text = rparen.sub( r'\1 ', text)
71 lbrack = re.compile( r'\[(?![\s\]])' )
72 text = lbrack.sub( r'[ ', text )
73 rbrack = re.compile( r'([^\s\[])(?=\])' )
74 text = rbrack.sub( r'\1 ', text)
76 lcurly = re.compile( r'\{(?![\s\}])' )
77 text = lcurly.sub( r'{ ', text )
78 rcurly = re.compile( r'([^\s\{])(?=\})' )
79 text = rcurly.sub( r'\1 ', text)
82 def fixDoxygen( text ):
83 """Translate @param foo to foo:, @return bar to returns: bar, and
84 @author me to author: me"""
85 param = re.compile( r'@param (\w+)' )
86 text = param.sub( r'\1:', text )
87 returns = re.compile( r'@return' )
88 text = returns.sub( r'returns:', text )
89 author = re.compile( r'@author' )
90 text = author.sub( r'author:', text)
92 text = text.replace( '@todo', 'TODO' )
95 def removeCommentFirstBlankLine( text ):
96 "Remove annoying blank lines after first line in comments."
97 line = re.compile( r'("""[^\n]*\n)\s*\n', re.MULTILINE )
98 return line.sub( r'\1', text )
100 def fixArgs( match, kwarg = re.compile( r'(\w+) = ' ) ):
101 "Replace foo = bar with foo=bar."
102 return kwarg.sub( r'\1=', match.group() )
104 def fixKeywords( text ):
105 "Change keyword argumentsfrom foo = bar to foo=bar."
106 args = re.compile( r'\(([^\)]+)\)', re.MULTILINE )
107 return args.sub( fixArgs, text )
109 # Unfortunately, Python doesn't natively support balanced or recursive
110 # regular expressions. We could use PyParsing, but that opens another can
111 # of worms. For now, we just have a cheap hack to restore strings,
112 # so we don't end up accidentally mangling things like messages, search strings,
113 # and regular expressions.
115 def lineIter( text ):
116 "Simple iterator over lines in text."
117 for line in text.splitlines(): yield line
119 def stringIter( strList ):
120 "Yield strings in strList."
121 for s in strList: yield s
123 def restoreRegex( regex, old, new ):
124 "Find regexes in old and restore them into new."
125 oldStrs = regex.findall( old )
126 # Sanity check - count should be the same!
127 newStrs = regex.findall( new )
128 assert len( oldStrs ) == len( newStrs )
129 # Replace newStrs with oldStrs
130 siter = stringIter( oldStrs )
131 reps = lambda dummy: siter.next()
132 return regex.sub( reps, new )
134 # This is a cheap hack, and it may not work 100%, since
135 # it doesn't handle multiline strings.
136 # However, it should be mostly harmless...
138 def restoreStrings( oldText, newText ):
139 "Restore strings from oldText into newText, returning result."
140 oldLines, newLines = lineIter( oldText ), lineIter( newText )
141 quoteStrings = re.compile( r'("[^"]*")' )
142 tickStrings = re.compile( r"('[^']*')" )
144 # It would be nice if we could blast the whole file, but for
145 # now it seems to work line-by-line
146 for newLine in newLines:
147 oldLine = oldLines.next()
148 newLine = restoreRegex( quoteStrings, oldLine, newLine )
149 newLine = restoreRegex( tickStrings, oldLine, newLine )
150 result += newLine + '\n'
153 # This might be slightly controversial, since it uses
154 # three spaces to line up multiline comments. However,
155 # I much prefer it. Limitations: if you have deeper
156 # indents in comments, they will be eliminated. ;-(
158 def fixComment( match,
159 indentExp=re.compile( r'\n([ ]*)(?=[^/s])', re.MULTILINE ),
160 trailingQuotes=re.compile( r'\s+"""' ) ):
161 "Re-indent comment, and join trailing quotes."
162 originalIndent = match.group( 1 )
163 comment = match.group( 2 )
164 indent = '\n' + originalIndent
165 # Exception: leave unindented things unindented!
166 if len( originalIndent ) is not 0: indent += ' '
167 comment = indentExp.sub( indent, comment )
168 return originalIndent + trailingQuotes.sub( '"""', comment )
170 def fixCommentIndents( text ):
171 "Fix multiline comment indentation."
172 comments = re.compile( r'^([ ]*)("""[^"]*""")$', re.MULTILINE )
173 return comments.sub( fixComment, text )
175 def removeBogusLinefeeds( text ):
176 "Remove extra linefeeds at the end of single-line comments."
177 bogusLfs = re.compile( r'"([^"\n]*)\n"', re.MULTILINE )
178 return bogusLfs.sub( '"\1"', text)
180 def convertFromPep8( program ):
182 # Program text transforms
183 program = reinstateCapWords( program )
184 program = fixKeywords( program )
185 program = insertExtraSpaces( program )
187 program = restoreStrings( oldProgram, program )
188 # Docstring transforms
189 program = replaceTripleApostrophes( program )
190 program = simplifyTripleQuotes( program )
191 program = fixDoxygen( program )
192 program = fixCommentIndents( program )
193 program = removeBogusLinefeeds( program )
194 # Destructive transforms (these can delete lines)
195 program = removeCommentFirstBlankLine( program )
198 if __name__ == '__main__':
199 print( convertFromPep8( sys.stdin.read() ) )