mirror of
https://github.com/facebook/sapling.git
synced 2024-10-09 00:14:35 +03:00
f1c575a099
Summary:
This check is useful and detects real errors (ex. fbconduit). Unfortunately
`arc lint` will run it with both py2 and py3 so a lot of py2 builtins will
still be warned.
I didn't find a clean way to disable py3 check. So this diff tries to fix them.
For `xrange`, the change was done by a script:
```
import sys
import redbaron
headertypes = {'comment', 'endl', 'from_import', 'import', 'string',
'assignment', 'atomtrailers'}
xrangefix = '''try:
xrange(0)
except NameError:
xrange = range
'''
def isxrange(x):
try:
return x[0].value == 'xrange'
except Exception:
return False
def main(argv):
for i, path in enumerate(argv):
print('(%d/%d) scanning %s' % (i + 1, len(argv), path))
content = open(path).read()
try:
red = redbaron.RedBaron(content)
except Exception:
print(' warning: failed to parse')
continue
hasxrange = red.find('atomtrailersnode', value=isxrange)
hasxrangefix = 'xrange = range' in content
if hasxrangefix or not hasxrange:
print(' no need to change')
continue
# find a place to insert the compatibility statement
changed = False
for node in red:
if node.type in headertypes:
continue
# node.insert_before is an easier API, but it has bugs changing
# other "finally" and "except" positions. So do the insert
# manually.
# # node.insert_before(xrangefix)
line = node.absolute_bounding_box.top_left.line - 1
lines = content.splitlines(1)
content = ''.join(lines[:line]) + xrangefix + ''.join(lines[line:])
changed = True
break
if changed:
# "content" is faster than "red.dumps()"
open(path, 'w').write(content)
print(' updated')
if __name__ == "__main__":
sys.exit(main(sys.argv[1:]))
```
For other py2 builtins that do not have a py3 equivalent, some `# noqa`
were added as a workaround for now.
Reviewed By: DurhamG
Differential Revision: D6934535
fbshipit-source-id: 546b62830af144bc8b46788d2e0fd00496838939
120 lines
4.0 KiB
Python
120 lines
4.0 KiB
Python
from __future__ import absolute_import, print_function
|
|
|
|
import _lsprof
|
|
import sys
|
|
|
|
Profiler = _lsprof.Profiler
|
|
|
|
# PyPy doesn't expose profiler_entry from the module.
|
|
profiler_entry = getattr(_lsprof, 'profiler_entry', None)
|
|
|
|
__all__ = ['profile', 'Stats']
|
|
|
|
def profile(f, *args, **kwds):
|
|
"""XXX docstring"""
|
|
p = Profiler()
|
|
p.enable(subcalls=True, builtins=True)
|
|
try:
|
|
f(*args, **kwds)
|
|
finally:
|
|
p.disable()
|
|
return Stats(p.getstats())
|
|
|
|
class Stats(object):
|
|
"""XXX docstring"""
|
|
|
|
def __init__(self, data):
|
|
self.data = data
|
|
|
|
def sort(self, crit="inlinetime"):
|
|
"""XXX docstring"""
|
|
# profiler_entries isn't defined when running under PyPy.
|
|
if profiler_entry:
|
|
if crit not in profiler_entry.__dict__:
|
|
raise ValueError("Can't sort by %s" % crit)
|
|
elif self.data and not getattr(self.data[0], crit, None):
|
|
raise ValueError("Can't sort by %s" % crit)
|
|
|
|
self.data.sort(key=lambda x: getattr(x, crit), reverse=True)
|
|
for e in self.data:
|
|
if e.calls:
|
|
e.calls.sort(key=lambda x: getattr(x, crit), reverse=True)
|
|
|
|
def pprint(self, top=None, file=None, limit=None, climit=None):
|
|
"""XXX docstring"""
|
|
if file is None:
|
|
file = sys.stdout
|
|
d = self.data
|
|
if top is not None:
|
|
d = d[:top]
|
|
cols = "% 12s %12s %11.4f %11.4f %s\n"
|
|
hcols = "% 12s %12s %12s %12s %s\n"
|
|
file.write(hcols % ("CallCount", "Recursive", "Total(s)",
|
|
"Inline(s)", "module:lineno(function)"))
|
|
count = 0
|
|
for e in d:
|
|
file.write(cols % (e.callcount, e.reccallcount, e.totaltime,
|
|
e.inlinetime, label(e.code)))
|
|
count += 1
|
|
if limit is not None and count == limit:
|
|
return
|
|
ccount = 0
|
|
if climit and e.calls:
|
|
for se in e.calls:
|
|
file.write(cols % (se.callcount, se.reccallcount,
|
|
se.totaltime, se.inlinetime,
|
|
" %s" % label(se.code)))
|
|
count += 1
|
|
ccount += 1
|
|
if limit is not None and count == limit:
|
|
return
|
|
if climit is not None and ccount == climit:
|
|
break
|
|
|
|
def freeze(self):
|
|
"""Replace all references to code objects with string
|
|
descriptions; this makes it possible to pickle the instance."""
|
|
|
|
# this code is probably rather ickier than it needs to be!
|
|
for i in range(len(self.data)):
|
|
e = self.data[i]
|
|
if not isinstance(e.code, str):
|
|
self.data[i] = type(e)((label(e.code),) + e[1:])
|
|
if e.calls:
|
|
for j in range(len(e.calls)):
|
|
se = e.calls[j]
|
|
if not isinstance(se.code, str):
|
|
e.calls[j] = type(se)((label(se.code),) + se[1:])
|
|
|
|
_fn2mod = {}
|
|
|
|
def label(code):
|
|
if isinstance(code, str):
|
|
return code
|
|
try:
|
|
mname = _fn2mod[code.co_filename]
|
|
except KeyError:
|
|
for k, v in list(sys.modules.iteritems()):
|
|
if v is None:
|
|
continue
|
|
if not isinstance(getattr(v, '__file__', None), str):
|
|
continue
|
|
if v.__file__.startswith(code.co_filename):
|
|
mname = _fn2mod[code.co_filename] = k
|
|
break
|
|
else:
|
|
mname = _fn2mod[code.co_filename] = '<%s>' % code.co_filename
|
|
|
|
return '%s:%d(%s)' % (mname, code.co_firstlineno, code.co_name)
|
|
|
|
if __name__ == '__main__':
|
|
import os
|
|
sys.argv = sys.argv[1:]
|
|
if not sys.argv:
|
|
print("usage: lsprof.py <script> <arguments...>", file=sys.stderr)
|
|
sys.exit(2)
|
|
sys.path.insert(0, os.path.abspath(os.path.dirname(sys.argv[0])))
|
|
stats = profile(execfile, sys.argv[0], globals(), locals()) # noqa
|
|
stats.sort()
|
|
stats.pprint()
|