def _Run2to3Fixers(source, options):
"""Use lib2to3 to reformat the source.
Args:
source: (unicode) The source to reformat.
options: dictionary of options to pass to lib2to3_refactor.RefactoringTool
Returns:
Reformatted source code.
"""
fixer_names = [MODULE_NAME_PREFIX + fixer for fixer in options['fixers']]
options['print_function'] = True
try:
try:
tool = lib2to3_refactor.RefactoringTool(fixer_names=fixer_names,
explicit=fixer_names,
options=options)
return '{}'.format(tool.refactor_string(source, name=''))
except pgen2_parse.ParseError:
options['print_function'] = False
tool = lib2to3_refactor.RefactoringTool(fixer_names=fixer_names,
explicit=fixer_names,
options=options)
return '{}'.format(tool.refactor_string(source, name=''))
except (pgen2_tokenize.TokenError, pgen2_parse.ParseError, SyntaxError,
UnicodeDecodeError, UnicodeEncodeError) as err:
logging.error(err)
raise
def test_print_function_option(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always", DeprecationWarning)
refactor.RefactoringTool(_DEFAULT_FIXERS, {"print_function": True})
self.assertEqual(len(w), 1)
msg, = w
self.assertTrue(msg.category is DeprecationWarning)
def refactor(self):
try:
factory = refactor.RefactoringTool(refactor.get_fixers_from_package(lib2to3_fixer_packages[0]))
return factory.refactor_string(self.code, "test code")
except Exception as e:
print(getattr(e, "message", repr(e)))
return "print invalid"
def __init__(self):
super().__init__()
fixes = set(refactor.get_fixers_from_package("lib2to3.fixes"))
self.refactorer_2to3 = refactor.RefactoringTool(fixes)
self.lattice = TypeLatticeGenerator(
os.path.join("processing", "typilus", "src", "data_preparation", "metadata", "typingRules.json")
)
def convert_2to3(file_content, file_name):
"""Quick helper function to convert python2 to python3 so that we can keep the ast buildin."""
# all default fixers
avail_fixes = set(refactor.get_fixers_from_package("lib2to3.fixes"))
# create default RefactoringTool, apply to passed file_content string and return fixed string
rt = refactor.RefactoringTool(avail_fixes)
tmp = rt.refactor_string(file_content, file_name)
return str(tmp)
def ConvertPy2to3(py_script_text):
"""
Converts contents of input string py_script_text to python 3 using lib2to3
and returns the result as a string.
"""
# As far as I can tell, lib2to3 isn't documented that well but once
# you find the right recipe it's very easy to use for this case.
# ref:
# https://stackoverflow.com/questions/30340151/using-2to3-on-in-memory-scripts
fixes = refactor.get_fixers_from_package('lib2to3.fixes')
converter = refactor.RefactoringTool(fixes)
ast = converter.refactor_string(py_script_text, '<script>')
return str(ast)
def get_refactorer(fixer_pkg="lib2to3", fixers=None, options=None):
"""
A convenience function for creating a RefactoringTool for tests.
fixers is a list of fixers for the RefactoringTool to use. By default
"lib2to3.fixes.*" is used. options is an optional dictionary of options to
be passed to the RefactoringTool.
"""
if fixers is not None:
fixers = [fixer_pkg + ".fixes.fix_" + fix for fix in fixers]
else:
fixers = refactor.get_fixers_from_package(fixer_pkg + ".fixes")
options = options or {}
return refactor.RefactoringTool(fixers, options, explicit=True)
def build(log=simple_logger, force=False):
dreampielib_dir = dirname(abspath(__file__))
src_dir = dirname(dreampielib_dir)
build_dir = join(dreampielib_dir, 'data')
if py3_available:
avail_fixes = refactor.get_fixers_from_package('lib2to3.fixes')
rt = refactor.RefactoringTool(avail_fixes)
for ver in lib_vers:
lib_fn = join(build_dir, lib_fns[ver])
# Make dirs if they don't exist yet
if not os.path.exists(lib_fn):
os.mkdir(lib_fn)
for dir in dirs:
dir_fn = join(lib_fn, dir)
if not os.path.exists(dir_fn):
os.mkdir(dir_fn)
# Write files if not up to date
for fn in files:
src_fn = join(src_dir, fn)
dst_fn = join(lib_fn, fn)
if not force and not newer(src_fn, dst_fn):
continue
if ver == 3:
log.info("Converting %s to Python 3..." % fn)
else:
log.info("Copying %s..." % fn)
f = open(join(src_dir, fn), 'rb')
src = f.read()
f.close()
if ver == 3:
dst = str(rt.refactor_string(src + '\n', fn))[:-1]
else:
dst = src
dst = """\
# This file was automatically generated from a file in the source DreamPie dir.
# DO NOT EDIT IT, as your changes will be gone when the file is created again.
""" + dst
f = open(dst_fn, 'wb')
f.write(dst)
f.close()
from Bio._py3k import _universal_read_mode
import unittest
import doctest
import os
import sys
import warnings
from Bio import BiopythonExperimentalWarning
warnings.simplefilter('ignore', BiopythonExperimentalWarning)
if sys.version_info[0] >= 3:
from lib2to3 import refactor
fixers = refactor.get_fixers_from_package("lib2to3.fixes")
fixers.remove("lib2to3.fixes.fix_print") # Already using print function
rt = refactor.RefactoringTool(fixers)
assert rt.refactor_docstring(">>> print(2+2)\n4\n", "example1") == \
">>> print(2+2)\n4\n"
assert rt.refactor_docstring('>>> print("Two plus two is", 2+2)\n'
'Two plus two is 4\n', "example2") == \
'>>> print("Two plus two is", 2+2)\nTwo plus two is 4\n'
# Cache this to restore the cwd at the end of the tests
original_path = os.path.abspath(".")
if os.path.basename(sys.argv[0]) == "test_Tutorial.py":
# sys.argv[0] will be (relative) path to test_Turorial.py - use this to allow, e.g.
# [base]$ python Tests/test_Tutorial.py
# [Tests/]$ python test_Tutorial.py
tutorial_base = os.path.abspath(
os.path.join(os.path.dirname(sys.argv[0]), "../Doc/"))
def rt(self, options=None, fixers=_DEFAULT_FIXERS, explicit=None):
return refactor.RefactoringTool(fixers, options, explicit)
def fix_python2(code):
tool = refactor.RefactoringTool(fixers, {}, explicit=True)
return str(tool.refactor_string(code + '\n', 'test'))
from lib2to3 import refactor
code = 'print "old-fashioned print"'
fixes = set(refactor.get_fixers_from_package("lib2to3.fixes"))
conversion_tool = refactor.RefactoringTool(fixes)
converted_code = str(conversion_tool.refactor_string(code + '\n', 'some_name'))
print(converted_code) # print("old-fashioned print")
import unittest
import doctest
import os
import sys
if sys.version_info[0] >= 3:
from lib2to3 import refactor
rt = refactor.RefactoringTool(
refactor.get_fixers_from_package("lib2to3.fixes"))
assert rt.refactor_docstring(">>> print 2+2\n4\n", "example") == \
">>> print(2+2)\n4\n"
tutorial = os.path.join(os.path.dirname(sys.argv[0]), "../Doc/Tutorial.tex")
tutorial_base = os.path.abspath(
os.path.join(os.path.dirname(sys.argv[0]), "../Doc/"))
original_path = os.path.abspath(".")
def _extract(handle):
line = handle.readline()
if line != "\\begin{verbatim}\n":
raise ValueError(
"Any '%doctest' or '%cont-doctest' line should be followed by '\\begin{verbatim}'"
)
lines = []
while True:
line = handle.readline()
if not line:
if lines:
print "".join(lines[:30])
raise ValueError("Didn't find end of test starting: %r",
import ast, _ast
import typing
from stackrunner._meta import errors
# Never thought I'd import this... What a world we live in
from lib2to3 import refactor
fixers = refactor.get_fixers_from_package(
'lib2to3.fixes') # Why is this package like this?
refactoring_tool = refactor.RefactoringTool(fixers)
class RemovePrints(ast.NodeTransformer):
def visit_Expr(self, node):
if isinstance(node, _ast.Expr) \
and isinstance(node.value, _ast.Call) \
and isinstance(node.value.func, _ast.Name) \
and node.value.func.id == 'print':
return ast.Pass() # replace prints with noop
return node
print_remover = RemovePrints()
def remove_prints(tree: ast.AST) -> ast.AST:
return print_remover.visit(tree)
def refactor2to3(code: str) -> str:
def create_refactoring_tool(self, fixer_names):
"""Create the refactoring tool from a list of fixer names."""
return refactor.RefactoringTool(fixer_names)
import sys
from lib2to3 import refactor
infile = sys.argv[1]
fixers = ['fixer_generic']
tool = refactor.RefactoringTool(fixers, {}, explicit=True)
class_code = open(infile).read()
print tool.refactor_string(class_code, 'test')
