def transform(self, node, results):
# Add the __future__ import first. (Otherwise any shebang or encoding
# comment line attached as a prefix to the print statement will be
# copied twice and appear twice.)
future_import(u'print_function', node)
n_stmt = super(FixPrintWithImport, self).transform(node, results)
return n_stmt
def transform(self, node, results):
future_import(u"division", node)
touch_import_top(u'past.utils', u'old_div', node)
expr1, expr2 = results[0].clone(), results[1].clone()
# Strip any leading space for the first number:
expr1.prefix = u''
return wrap_in_fn_call("old_div", expr1, expr2, prefix=node.prefix)
def transform(self, node, results):
# Add the __future__ import first. (Otherwise any shebang or encoding
# comment line attached as a prefix to the print statement will be
# copied twice and appear twice.)
future_import(u'print_function', node)
n_stmt = super(FixPrintWithImport, self).transform(node, results)
return n_stmt
def transform(self, node, results):
future_import(u"division", node)
touch_import_top(u'past.utils', u'old_div', node)
expr1, expr2 = results[0].clone(), results[1].clone()
# Strip any leading space for the first number:
expr1.prefix = u''
return wrap_in_fn_call("old_div", expr1, expr2, prefix=node.prefix)
def transform(self, node, results):
if self.skip:
return
future_import(u"division", node)
expr1, expr2 = results[0].clone(), results[1].clone()
# Strip any leading space for the first number:
expr1.prefix = u''
# if expr1 or expr2 are obviously floats, we don't need to wrap in
# old_div, as the behavior of division between any number and a float
# should be the same in 2 or 3
if _is_floaty(expr1) or _is_floaty(expr2):
return
touch_import_top(u'past.utils', u'old_div', node)
return wrap_in_fn_call("old_div", (expr1, expr2), prefix=node.prefix)
def transform(self, node, results):
"""
Copied from FixImport.transform(), but with this line added in
any modules that had implicit relative imports changed:
from __future__ import absolute_import"
"""
if self.skip:
return
imp = results['imp']
if node.type == syms.import_from:
# Some imps are top-level (eg: 'import ham')
# some are first level (eg: 'import ham.eggs')
# some are third level (eg: 'import ham.eggs as spam')
# Hence, the loop
while not hasattr(imp, 'value'):
imp = imp.children[0]
if self.probably_a_local_import(imp.value):
imp.value = u"." + imp.value
imp.changed()
future_import(u"absolute_import", node)
else:
have_local = False
have_absolute = False
for mod_name in traverse_imports(imp):
if self.probably_a_local_import(mod_name):
have_local = True
else:
have_absolute = True
if have_absolute:
if have_local:
# We won't handle both sibling and absolute imports in the
# same statement at the moment.
self.warning(node, "absolute and local imports together")
return
new = FromImport(u".", [imp])
new.prefix = node.prefix
future_import(u"absolute_import", node)
return new
def transform(self, node, results):
# Reverse order:
future_import(u"absolute_import", node)
future_import(u"division", node)
future_import(u"print_function", node)
def transform(self, node, results):
future_import(u"print_function", node)
def transform(self, node, results):
n_stmt = super(FixPrintWithImport, self).transform(node, results)
future_import(u'print_function', node)
return n_stmt
def transform(self, node, results):
future_import(u"unicode_literals", node)
def transform(self, node, results):
if self.skip:
return
future_import(u"division", node)
touch_import_top(u'past.utils', u'old_div', node)
return wrap_in_fn_call("old_div", results, prefix=node.prefix)
def transform(self, node, results):
if self.skip:
return
future_import(u"division", node)
touch_import_top(u'past.utils', u'old_div', node)
return results
def transform(self, node, results):
future_import(u"division", node)
def transform(self, node, results):
future_import(u"absolute_import", node)
future_import(u"division", node)
future_import(u"print_function", node)
future_import(u"unicode_literals", node)
def transform(self, node, results):
future_import(u"division", node)
def transform(self, node, results):
n_stmt = super(FixPrintWithImport, self).transform(node, results)
future_import(u'print_function', node)
return n_stmt
def transform(self, node, results):
if self.skip:
return
future_import(u"division", node)
touch_import_top(u'past.utils', u'old_div', node)
return results
def transform(self, node, results):
if self.skip:
return
future_import(u"division", node)
touch_import_top(u"past.utils", u"old_div", node)
return wrap_in_fn_call("old_div", results, prefix=node.prefix)
def transform(self, node, results):
future_import(u"unicode_literals", node)
def transform(self, node, results):
# Reverse order:
future_import(u"print_function", node)
future_import(u"division", node)
future_import(u"absolute_import", node)
def transform(self, node, results):
future_import(u"unicode_literals", node)
future_import(u"print_function", node)
future_import(u"division", node)
future_import(u"absolute_import", node)
def transform(self, node, results):
future_import(u"print_function", node)
