From d3690171223cf6760d93872b350b5af5f4207c5e Mon Sep 17 00:00:00 2001 From: rocky Date: Sun, 16 Jun 2019 21:57:56 -0400 Subject: [PATCH] remove deprecated deparse_code --- pytest/test_fstring.py | 132 +++++++++++++++---------------- pytest/validate.py | 8 +- uncompyle6/__init__.py | 8 +- uncompyle6/semantics/pysource.py | 16 ---- 4 files changed, 71 insertions(+), 93 deletions(-) diff --git a/pytest/test_fstring.py b/pytest/test_fstring.py index 364c529b..5e486476 100644 --- a/pytest/test_fstring.py +++ b/pytest/test_fstring.py @@ -1,9 +1,12 @@ # std # test -from uncompyle6 import PYTHON_VERSION, deparse_code +import sys +from uncompyle6 import PYTHON_VERSION, code_deparse import pytest -pytestmark = pytest.mark.skipif(PYTHON_VERSION <= 2.6, - reason='hypothesis needs 2.7 or later') + +pytestmark = pytest.mark.skipif( + PYTHON_VERSION <= 2.6, reason="hypothesis needs 2.7 or later" +) if PYTHON_VERSION > 2.6: import hypothesis @@ -11,29 +14,31 @@ if PYTHON_VERSION > 2.6: # uncompyle6 - @st.composite def expressions(draw): # todo : would be nice to generate expressions using hypothesis however # this is pretty involved so for now just use a corpus of expressions # from which to select. - return draw(st.sampled_from(( - 'abc', - 'len(items)', - 'x + 1', - 'lineno', - 'container', - 'self.attribute', - 'self.method()', - # These expressions are failing, I think these are control - # flow problems rather than problems with FORMAT_VALUE, - # however I need to confirm this... - #'sorted(items, key=lambda x: x.name)', - #'func(*args, **kwargs)', - #'text or default', - #'43 if life_the_universe and everything else None' - ))) - + return draw( + st.sampled_from( + ( + "abc", + "len(items)", + "x + 1", + "lineno", + "container", + "self.attribute", + "self.method()", + # These expressions are failing, I think these are control + # flow problems rather than problems with FORMAT_VALUE, + # however I need to confirm this... + #'sorted(items, key=lambda x: x.name)', + #'func(*args, **kwargs)', + #'text or default', + #'43 if life_the_universe and everything else None' + ) + ) + ) @st.composite def format_specifiers(draw): @@ -54,36 +59,37 @@ if PYTHON_VERSION > 2.6: :return: An example format_specifier. """ - alphabet_strategy = st.characters(min_codepoint=ord('a'), max_codepoint=ord('z')) + alphabet_strategy = st.characters( + min_codepoint=ord("a"), max_codepoint=ord("z") + ) fill = draw(st.one_of(alphabet_strategy, st.none())) - align = draw(st.sampled_from(list('<>=^'))) - fill_align = (fill + align or '') if fill else '' + align = draw(st.sampled_from(list("<>=^"))) + fill_align = (fill + align or "") if fill else "" - type_ = draw(st.sampled_from('bcdeEfFgGnosxX%')) - can_have_sign = type_ in 'deEfFgGnoxX%' - can_have_comma = type_ in 'deEfFgG%' - can_have_precision = type_ in 'fFgG' - can_have_pound = type_ in 'boxX%' - can_have_zero = type_ in 'oxX' + type_ = draw(st.sampled_from("bcdeEfFgGnosxX%")) + can_have_sign = type_ in "deEfFgGnoxX%" + can_have_comma = type_ in "deEfFgG%" + can_have_precision = type_ in "fFgG" + can_have_pound = type_ in "boxX%" + can_have_zero = type_ in "oxX" - sign = draw(st.sampled_from(list('+- ') + [''])) if can_have_sign else '' - pound = draw(st.sampled_from(('#', '',))) if can_have_pound else '' - zero = draw(st.sampled_from(('0', '',))) if can_have_zero else '' + sign = draw(st.sampled_from(list("+- ") + [""])) if can_have_sign else "" + pound = draw(st.sampled_from(("#", ""))) if can_have_pound else "" + zero = draw(st.sampled_from(("0", ""))) if can_have_zero else "" int_strategy = st.integers(min_value=1, max_value=1000) width = draw(st.one_of(int_strategy, st.none())) - width = str(width) if width is not None else '' + width = str(width) if width is not None else "" - comma = draw(st.sampled_from((',', '',))) if can_have_comma else '' + comma = draw(st.sampled_from((",", ""))) if can_have_comma else "" if can_have_precision: precision = draw(st.one_of(int_strategy, st.none())) - precision = '.' + str(precision) if precision else '' + precision = "." + str(precision) if precision else "" else: - precision = '' - - return ''.join((fill_align, sign, pound, zero, width, comma, precision, type_,)) + precision = "" + return "".join((fill_align, sign, pound, zero, width, comma, precision, type_)) @st.composite def fstrings(draw): @@ -96,9 +102,7 @@ if PYTHON_VERSION > 2.6: :return: A valid f-string. """ character_strategy = st.characters( - blacklist_characters='\r\n\'\\s{}', - min_codepoint=1, - max_codepoint=1000, + blacklist_characters="\r\n'\\s{}", min_codepoint=1, max_codepoint=1000 ) is_raw = draw(st.booleans()) integer_strategy = st.integers(min_value=0, max_value=3) @@ -106,53 +110,49 @@ if PYTHON_VERSION > 2.6: content = [] for _ in range(expression_count): expression = draw(expressions()) - conversion = draw(st.sampled_from(('', '!s', '!r', '!a',))) + conversion = draw(st.sampled_from(("", "!s", "!r", "!a"))) has_specifier = draw(st.booleans()) - specifier = ':' + draw(format_specifiers()) if has_specifier else '' - content.append('{{{}{}}}'.format(expression, conversion, specifier)) + specifier = ":" + draw(format_specifiers()) if has_specifier else "" + content.append("{{{}{}}}".format(expression, conversion, specifier)) content.append(draw(st.text(character_strategy))) - content = ''.join(content) - return "f{}'{}'".format('r' if is_raw else '', content) + content = "".join(content) + return "f{}'{}'".format("r" if is_raw else "", content) - - @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6') + @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason="need Python 3.6") @hypothesis.given(format_specifiers()) def test_format_specifiers(format_specifier): """Verify that format_specifiers generates valid specifiers""" try: exec('"{:' + format_specifier + '}".format(0)') except ValueError as e: - if 'Unknown format code' not in str(e): + if "Unknown format code" not in str(e): raise - def run_test(text): hypothesis.assume(len(text)) hypothesis.assume("f'{" in text) - expr = text + '\n' - code = compile(expr, '', 'single') - deparsed = deparse_code(PYTHON_VERSION, code, compile_mode='single') - recompiled = compile(deparsed.text, '', 'single') + expr = text + "\n" + code = compile(expr, "", "single") + deparsed = code_deparse(code, sys.stdout, PYTHON_VERSION, compile_mode="single") + recompiled = compile(deparsed.text, "", "single") if recompiled != code: print(recompiled) - print('================') + print("================") print(code) - print('----------------') - assert 'dis(' + deparsed.text.strip('\n') + ')' == 'dis(' + expr.strip('\n') + ')' + print("----------------") + assert ( + "dis(" + deparsed.text.strip("\n") + ")" + == "dis(" + expr.strip("\n") + ")" + ) - - @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6') + @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason="need Python 3.6") @hypothesis.given(fstrings()) def test_uncompyle_fstring(fstring): """Verify uncompyling fstring bytecode""" run_test(fstring) - - @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason='need Python 3.6+') - @pytest.mark.parametrize('fstring', [ - "f'{abc}{abc!s}'", - "f'{abc}0'", - ]) + @pytest.mark.skipif(PYTHON_VERSION != 3.6, reason="need Python 3.6+") + @pytest.mark.parametrize("fstring", ["f'{abc}{abc!s}'", "f'{abc}0'"]) def test_uncompyle_direct(fstring): """useful for debugging""" run_test(fstring) diff --git a/pytest/validate.py b/pytest/validate.py index ead43859..84e6e4b2 100644 --- a/pytest/validate.py +++ b/pytest/validate.py @@ -7,7 +7,7 @@ import subprocess import tempfile import functools # uncompyle6 / xdis -from uncompyle6 import PYTHON_VERSION, PYTHON3, IS_PYPY, deparse_code +from uncompyle6 import PYTHON_VERSION, PYTHON3, IS_PYPY, code_deparse # TODO : I think we can get xdis to support the dis api (python 3 version) by doing something like this there from xdis.bytecode import Bytecode from xdis.main import get_opcode @@ -125,10 +125,10 @@ def validate_uncompyle(text, mode='exec'): original_dis = _dis_to_text(original_code) original_text = text - deparsed = deparse_code(PYTHON_VERSION, original_code, - compile_mode=mode, + deparsed = code_deparse(original_code, out=six.StringIO(), - is_pypy=IS_PYPY) + version=PYTHON_VERSION, + compile_mode=mode) uncompyled_text = deparsed.text uncompyled_code = compile(uncompyled_text, '', 'exec') diff --git a/uncompyle6/__init__.py b/uncompyle6/__init__.py index 9a3808d9..32062352 100644 --- a/uncompyle6/__init__.py +++ b/uncompyle6/__init__.py @@ -51,14 +51,8 @@ import uncompyle6.semantics.fragments # Export some functions from uncompyle6.main import decompile_file -# For compatibility -uncompyle_file = decompile_file - # Convenience functions so you can say: # from uncompyle6 import (code_deparse, deparse_code2str) -code_deparse = uncompyle6.semantics.pysource.code_deparse deparse_code2str = uncompyle6.semantics.pysource.deparse_code2str - -# This is deprecated: -deparse_code = uncompyle6.semantics.pysource.deparse_code +code_deparse = uncompyle6.semantics.pysource.code_deparse diff --git a/uncompyle6/semantics/pysource.py b/uncompyle6/semantics/pysource.py index 1cb6980d..2c7b3cef 100644 --- a/uncompyle6/semantics/pysource.py +++ b/uncompyle6/semantics/pysource.py @@ -2269,22 +2269,6 @@ DEFAULT_DEBUG_OPTS = { 'grammar': False } -# This interface is deprecated. Use simpler code_deparse. -def deparse_code(version, co, out=sys.stdout, showasm=None, showast=False, - showgrammar=False, code_objects={}, compile_mode='exec', - is_pypy=IS_PYPY, walker=SourceWalker): - debug_opts = { - 'asm': showasm, - 'ast': showast, - 'grammar': showgrammar - } - return code_deparse(co, out, - version=version, - debug_opts=debug_opts, - code_objects=code_objects, - compile_mode=compile_mode, - is_pypy=is_pypy, walker=walker) - def code_deparse(co, out=sys.stdout, version=None, debug_opts=DEFAULT_DEBUG_OPTS, code_objects={}, compile_mode='exec', is_pypy=IS_PYPY, walker=SourceWalker): """