def _extract_lambda_source(f):
"""Extracts a single lambda expression from the string source. Returns a
string indicating an unknown body if it gets confused in any way.
This is not a good function and I am sorry for it. Forgive me my
sins, oh lord
"""
out = BytesIO() if PY2 else StringIO()
deparse_code(sys.version_info[0] + sys.version_info[1] * 0.1,
f.__code__,
out=out,
is_pypy=PYPY,
compile_mode='eval')
source = out.getvalue()
if source.startswith('return '):
source = source[len('return '):]
else:
source = '<unknown>'
args = getargspec(f)
arg_bits = []
for a in args.args:
if isinstance(a, str):
arg_bits.append(a)
else: # pragma: no cover
assert isinstance(a, list)
arg_bits.append('(%s)' % (', '.join(a)))
if args.varargs is not None:
arg_bits.append('*' + args.varargs)
if args.keywords is not None:
arg_bits.append('**' + args.keywords)
return 'lambda %s: %s' % (', '.join(arg_bits), source)
def _extract_lambda_source(f):
"""Extracts a single lambda expression from the string source. Returns a
string indicating an unknown body if it gets confused in any way.
This is not a good function and I am sorry for it. Forgive me my
sins, oh lord
"""
out = BytesIO() if PY2 else StringIO()
deparse_code(
sys.version_info[0] + sys.version_info[1] * 0.1,
f.__code__,
out=out, is_pypy=PYPY, compile_mode='eval'
)
source = out.getvalue()
if source.startswith('return '):
source = source[len('return '):]
else:
source = '<unknown>'
args = getargspec(f)
arg_bits = []
for a in args.args:
if isinstance(a, str):
arg_bits.append(a)
else: # pragma: no cover
assert isinstance(a, list)
arg_bits.append('(%s)' % (', '.join(a)))
if args.varargs is not None:
arg_bits.append('*' + args.varargs)
if args.keywords is not None:
arg_bits.append('**' + args.keywords)
return 'lambda %s: %s' % (
', '.join(arg_bits), source
)
def validate_uncompyle(text, mode='exec'):
"""
Validate decompilation of the given source code.
:param text: Source to validate decompilation of.
"""
original_code = compile(text, '<string>', mode)
original_dis = _dis_to_text(original_code)
original_text = text
deparsed = deparse_code(PYTHON_VERSION,
original_code,
compile_mode=mode,
out=six.StringIO(),
is_pypy=IS_PYPY)
uncompyled_text = deparsed.text
uncompyled_code = compile(uncompyled_text, '<string>', 'exec')
if not are_code_objects_equal(uncompyled_code, original_code):
uncompyled_dis = _dis_to_text(uncompyled_text)
def output(text, dis):
width = 60
return '\n\n'.join([
' SOURCE CODE '.center(width, '#'),
text.strip(), ' BYTECODE '.center(width, '#'), dis
])
original = output(original_text, original_dis)
uncompyled = output(uncompyled_text, uncompyled_dis)
print_diff(original, uncompyled)
assert 'original' == 'uncompyled'
def validate_uncompyle(text, mode='exec'):
"""
Validate decompilation of the given source code.
:param text: Source to validate decompilation of.
"""
original_code = compile(text, '<string>', mode)
original_dis = _dis_to_text(original_code)
original_text = text
deparsed = deparse_code(PYTHON_VERSION, original_code,
compile_mode=mode, out=six.StringIO())
uncompyled_text = deparsed.text
uncompyled_code = compile(uncompyled_text, '<string>', 'exec')
if not are_code_objects_equal(uncompyled_code, original_code):
uncompyled_dis = _dis_to_text(uncompyled_text)
def output(text, dis):
width = 60
return '\n\n'.join([
' SOURCE CODE '.center(width, '#'),
text.strip(),
' BYTECODE '.center(width, '#'),
dis
])
original = output(original_text, original_dis)
uncompyled = output(uncompyled_text, uncompyled_dis)
print_diff(original, uncompyled)
assert 'original' == 'uncompyled'
def run_test(text):
expr = text + '\n'
code = compile(expr, '<string>', 'single')
deparsed = deparse_code(PYTHON_VERSION, code, compile_mode='single')
recompiled = compile(deparsed.text, '<string>', 'single')
if recompiled != code:
assert 'dis(' + deparsed.text.strip('\n') + ')' == 'dis(' + expr.strip('\n') + ')'
def run_test(text):
hypothesis.assume(len(text))
hypothesis.assume("f'{" in text)
expr = text + '\n'
code = compile(expr, '<string>', 'single')
deparsed = deparse_code(PYTHON_VERSION, code, compile_mode='single')
recompiled = compile(deparsed.text, '<string>', 'single')
if recompiled != code:
assert 'dis(' + deparsed.text.strip('\n') + ')' == 'dis(' + expr.strip('\n') + ')'
def get_source_from_byte_code(code):
try:
import uncompyle6
except ImportError:
return
version = sys.version_info.major + (sys.version_info.minor / 10.0)
try:
return uncompyle6.deparse_code(version, code).text
except Exception:
return
def get_source_from_byte_code(code):
try:
import uncompyle6
except ImportError:
return
version = sys.version_info[0] + (sys.version_info[1] / 10.0)
try:
return uncompyle6.deparse_code(version, code).text
except Exception:
return
def get_source_from_byte_code(code):
try:
import uncompyle6
except Exception:
return
version = sys.version_info[0] + (sys.version_info[1] / 10.0)
try:
with open(os.devnull, 'w') as dn:
return uncompyle6.deparse_code(version, code, dn).text
except Exception:
return
def get_source_from_byte_code(code):
try:
import uncompyle6
except Exception:
return
version = sys.version_info[0] + (sys.version_info[1] / 10.0)
try:
with open(os.devnull, 'w') as dn:
return uncompyle6.deparse_code(version, code, dn).text
except Exception:
return
def prepare_conditions(conditions, conditions_type, function_name):
# Make conditions iterable if they are not
conditions = (conditions, ) if callable(conditions) else conditions
# Compose messages
composed = OrderedDict()
for condition in conditions:
# Get source from bytecode if it is an anonym function
if condition.__name__ == _LAMBDA_NAME:
condition_repr = StringIO()
deparse_code(PYTHON_VERSION,
condition.__code__,
out=condition_repr).text
# Remove 'return '
condition_repr = condition_repr.getvalue()[7:]
# Use the validator name
else:
condition_repr = condition.__name__
# Create assertion error message
composed[condition] = 'in {}: {}: {}'.format(function_name,
conditions_type,
condition_repr)
return composed
def test_single_mode():
single_expressions = (
'i = 1',
'i and (j or k)',
'i += 1',
'i = j % 4',
'i = {}',
'i = []',
'for i in range(10):\n i\n',
'for i in range(10):\n for j in range(10):\n i + j\n',
'try:\n i\nexcept Exception:\n j\nelse:\n k\n'
)
for expr in single_expressions:
code = compile(expr + '\n', '<string>', 'single')
assert deparse_code(PYTHON_VERSION, code, compile_mode='single').text == expr + '\n'
def print_code(code):
print(uncompyle6.deparse_code(2.7, code).text)
def print_code(code):
print(uncompyle6.deparse_code(2.7, code).text)
