You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
110 lines
3.4 KiB
110 lines
3.4 KiB
"""
|
|
For the ``future`` package.
|
|
|
|
Adds this import line:
|
|
|
|
from __future__ import division
|
|
|
|
at the top and changes any old-style divisions to be calls to
|
|
past.utils.old_div so the code runs as before on Py2.6/2.7 and has the same
|
|
behaviour on Py3.
|
|
|
|
If "from __future__ import division" is already in effect, this fixer does
|
|
nothing.
|
|
"""
|
|
|
|
import re
|
|
import lib2to3.pytree as pytree
|
|
from lib2to3.fixer_util import Leaf, Node, Comma
|
|
from lib2to3 import fixer_base
|
|
from lib2to3.fixer_util import syms, does_tree_import
|
|
from libfuturize.fixer_util import (token, future_import, touch_import_top,
|
|
wrap_in_fn_call)
|
|
|
|
|
|
def match_division(node):
|
|
u"""
|
|
__future__.division redefines the meaning of a single slash for division,
|
|
so we match that and only that.
|
|
"""
|
|
slash = token.SLASH
|
|
return node.type == slash and not node.next_sibling.type == slash and \
|
|
not node.prev_sibling.type == slash
|
|
|
|
const_re = re.compile('^[0-9]*[.][0-9]*$')
|
|
|
|
def is_floaty(node, div_idx):
|
|
return _is_floaty(node.children[0:div_idx]) or _is_floaty(node.children[div_idx+1:])
|
|
|
|
|
|
def _is_floaty(expr):
|
|
if isinstance(expr, list):
|
|
expr = expr[0]
|
|
|
|
if isinstance(expr, Leaf):
|
|
# If it's a leaf, let's see if it's a numeric constant containing a '.'
|
|
return const_re.match(expr.value)
|
|
elif isinstance(expr, Node):
|
|
# If the expression is a node, let's see if it's a direct cast to float
|
|
if isinstance(expr.children[0], Leaf):
|
|
return expr.children[0].value == u'float'
|
|
return False
|
|
|
|
def find_division(node):
|
|
for i, child in enumerate(node.children):
|
|
if match_division(child):
|
|
return i
|
|
return False
|
|
|
|
def clone_div_operands(node, div_idx):
|
|
children = []
|
|
for i, child in enumerate(node.children):
|
|
if i == div_idx:
|
|
children.append(Comma())
|
|
else:
|
|
children.append(child.clone())
|
|
|
|
# Strip any leading space for the first number:
|
|
children[0].prefix = u''
|
|
|
|
return children
|
|
|
|
class FixDivisionSafe(fixer_base.BaseFix):
|
|
# BM_compatible = True
|
|
run_order = 4 # this seems to be ignored?
|
|
|
|
_accept_type = token.SLASH
|
|
|
|
PATTERN = """
|
|
term<(not('/') any)+ '/' ((not('/') any))>
|
|
"""
|
|
|
|
def start_tree(self, tree, name):
|
|
"""
|
|
Skip this fixer if "__future__.division" is already imported.
|
|
"""
|
|
super(FixDivisionSafe, self).start_tree(tree, name)
|
|
self.skip = "division" in tree.future_features
|
|
|
|
def match(self, node):
|
|
u"""
|
|
Since the tree needs to be fixed once and only once if and only if it
|
|
matches, we can start discarding matches after the first.
|
|
"""
|
|
if node.type == self.syms.term:
|
|
div_idx = find_division(node)
|
|
if div_idx is not False:
|
|
# 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 not is_floaty(node, div_idx):
|
|
return clone_div_operands(node, div_idx)
|
|
return False
|
|
|
|
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)
|