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): 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): # 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)