check_untyped_defs pandas.core.computation.ops xref pandas-dev#28446

Author: simonjayhawkins

pandas/core/computation/engines.py

@@ -117,9 +117,8 @@ def _evaluate(self):
         try:
             env = self.expr.env
             scope = env.full_scope
-            truediv = scope["truediv"]
             _check_ne_builtin_clash(self.expr)
-            return ne.evaluate(s, local_dict=scope, truediv=truediv)
+            return ne.evaluate(s, local_dict=scope)
         except KeyError as e:
             # python 3 compat kludge
             try:

pandas/core/computation/eval.py

@@ -171,7 +171,6 @@ def eval(
     expr,
     parser="pandas",
     engine: Optional[str] = None,
-    truediv=True,
     local_dict=None,
     global_dict=None,
     resolvers=(),
@@ -219,8 +218,6 @@ def eval(
 
         More backends may be available in the future.
 
-    truediv : bool, optional
-        Whether to use true division, like in Python >= 3
     local_dict : dict or None, optional
         A dictionary of local variables, taken from locals() by default.
     global_dict : dict or None, optional
@@ -320,7 +317,7 @@ def eval(
             target=target,
         )
 
-        parsed_expr = Expr(expr, engine=engine, parser=parser, env=env, truediv=truediv)
+        parsed_expr = Expr(expr, engine=engine, parser=parser, env=env)
 
         # construct the engine and evaluate the parsed expression
         eng = _engines[engine]

pandas/core/computation/expr.py

@@ -565,8 +565,7 @@ def visit_BinOp(self, node, **kwargs):
         return self._maybe_evaluate_binop(op, op_class, left, right)
 
     def visit_Div(self, node, **kwargs):
-        truediv = self.env.scope["truediv"]
-        return lambda lhs, rhs: Div(lhs, rhs, truediv)
+        return lambda lhs, rhs: Div(lhs, rhs)
 
     def visit_UnaryOp(self, node, **kwargs):
         op = self.visit(node.op)
@@ -812,18 +811,14 @@ class Expr:
     engine : str, optional, default 'numexpr'
     parser : str, optional, default 'pandas'
     env : Scope, optional, default None
-    truediv : bool, optional, default True
     level : int, optional, default 2
     """
 
-    def __init__(
-        self, expr, engine="numexpr", parser="pandas", env=None, truediv=True, level=0
-    ):
+    def __init__(self, expr, engine="numexpr", parser="pandas", env=None, level=0):
         self.expr = expr
         self.env = env or Scope(level=level + 1)
         self.engine = engine
         self.parser = parser
-        self.env.scope["truediv"] = truediv
         self._visitor = _parsers[parser](self.env, self.engine, self.parser)
         self.terms = self.parse()
 

pandas/core/computation/ops.py

@@ -5,6 +5,7 @@
 from distutils.version import LooseVersion
 from functools import partial
 import operator as op
+from typing import Callable, Iterable, Union
 
 import numpy as np
 
@@ -196,10 +197,10 @@ class Op:
     Hold an operator of arbitrary arity.
     """
 
-    def __init__(self, op, operands, *args, **kwargs):
+    def __init__(self, op: str, operands: Iterable[Union[Term, "Op"]], encoding=None):
         self.op = _bool_op_map.get(op, op)
         self.operands = operands
-        self.encoding = kwargs.get("encoding", None)
+        self.encoding = encoding
 
     def __iter__(self):
         return iter(self.operands)
@@ -333,11 +334,11 @@ class BinOp(Op):
     Parameters
     ----------
     op : str
-    left : Term or Op
-    right : Term or Op
+    lhs : Term or Op
+    rhs : Term or Op
     """
 
-    def __init__(self, op, lhs, rhs, **kwargs):
+    def __init__(self, op: str, lhs: Union[Term, Op], rhs: Union[Term, Op]):
         super().__init__(op, (lhs, rhs))
         self.lhs = lhs
         self.rhs = rhs
@@ -369,10 +370,6 @@ def __call__(self, env):
         object
             The result of an evaluated expression.
         """
-        # handle truediv
-        if self.op == "/" and env.scope["truediv"]:
-            self.func = op.truediv
-
         # recurse over the left/right nodes
         left = self.lhs(env)
         right = self.rhs(env)
@@ -431,6 +428,7 @@ def convert_values(self):
         """
 
         def stringify(value):
+            encoder: Callable
             if self.encoding is not None:
                 encoder = partial(pprint_thing_encoded, encoding=self.encoding)
             else:
@@ -483,13 +481,10 @@ class Div(BinOp):
     ----------
     lhs, rhs : Term or Op
         The Terms or Ops in the ``/`` expression.
-    truediv : bool
-        Whether or not to use true division. With Python 3 this happens
-        regardless of the value of ``truediv``.
     """
 
-    def __init__(self, lhs, rhs, truediv, *args, **kwargs):
-        super().__init__("/", lhs, rhs, *args, **kwargs)
+    def __init__(self, lhs: Union[Term, Op], rhs: Union[Term, Op]):
+        super().__init__("/", lhs, rhs)
 
         if not isnumeric(lhs.return_type) or not isnumeric(rhs.return_type):
             raise TypeError(

pandas/tests/computation/test_eval.py

@@ -2,6 +2,7 @@
 from functools import reduce
 from itertools import product
 import operator
+import re
 import warnings
 
 import numpy as np
@@ -1196,32 +1197,27 @@ def test_single_variable(self):
         df2 = self.eval("df", local_dict={"df": df})
         assert_frame_equal(df, df2)
 
-    def test_truediv(self):
+    def test_div(self):
         s = np.array([1])
         ex = "s / 1"
         d = {"s": s}  # noqa
 
-        res = self.eval(ex, truediv=False)
+        res = self.eval(ex)
         tm.assert_numpy_array_equal(res, np.array([1.0]))
 
-        res = self.eval(ex, truediv=True)
-        tm.assert_numpy_array_equal(res, np.array([1.0]))
-
-        res = self.eval("1 / 2", truediv=True)
-        expec = 0.5
-        assert res == expec
-
-        res = self.eval("1 / 2", truediv=False)
+        res = self.eval("1 / 2")
         expec = 0.5
         assert res == expec
 
-        res = self.eval("s / 2", truediv=False)
+        res = self.eval("s / 2")
         expec = 0.5
         assert res == expec
 
-        res = self.eval("s / 2", truediv=True)
-        expec = 0.5
-        assert res == expec
+    def test_truediv_kwarg_raises(self):
+        # gh-28446
+        msg = re.escape("eval() got an unexpected keyword argument 'truediv'")
+        with pytest.raises(TypeError, match=msg):
+            self.eval("1 / 2", truediv=False)
 
     def test_failing_subscript_with_name_error(self):
         df = DataFrame(np.random.randn(5, 3))  # noqa

setup.cfg

@@ -200,9 +200,6 @@ check_untyped_defs=False
 [mypy-pandas.core.computation.expressions]
 check_untyped_defs=False
 
-[mypy-pandas.core.computation.ops]
-check_untyped_defs=False
-
 [mypy-pandas.core.computation.pytables]
 check_untyped_defs=False