Remove non-superfluous eval_env argument from ModelDesc.from_formula

Author: njsmith

doc/_examples/add_predictors.py

@@ -1,7 +1,5 @@
 def add_predictors(base_formula, extra_predictors):
-    # Interpret formula in caller's environment:
-    env = EvalEnvironment.capture(1)
-    desc = ModelDesc.from_formula(base_formula, env)
+    desc = ModelDesc.from_formula(base_formula)
     # Using LookupFactor here ensures that everything will work correctly even
     # if one of the column names in extra_columns is named like "weight.in.kg"
     # or "sys.exit()" or "LittleBobbyTables()".

doc/formulas.rst

@@ -67,7 +67,7 @@ formula::
 
 Compare to what you get from parsing the above formula::
 
-  ModelDesc.from_formula("y ~ a + a:b + np.log(x)", env)
+  ModelDesc.from_formula("y ~ a + a:b + np.log(x)")
 
 :class:`ModelDesc` represents an overall formula; it just takes two
 lists of :class:`Term` objects, representing the left-hand side and
@@ -326,26 +326,22 @@ you can always ask Patsy how it expands.
 
 Here's some code to try out at the Python prompt to get started::
 
-  from patsy import EvalEnvironment, ModelDesc
-  # This captures the current Python environment. If a factor refers
-  # to a variable that doesn't exist in the data (like np.log) then it
-  # will be looked for here.
-  env = EvalEnvironment.capture()
-  ModelDesc.from_formula("y ~ x", env)
-  ModelDesc.from_formula("y ~ x + x + x", env)
-  ModelDesc.from_formula("y ~ -1 + x", env)
-  ModelDesc.from_formula("~ -1", env)
-  ModelDesc.from_formula("y ~ a:b", env)
-  ModelDesc.from_formula("y ~ a*b", env)
-  ModelDesc.from_formula("y ~ (a + b + c + d) ** 2", env)
-  ModelDesc.from_formula("y ~ (a + b)/(c + d)", env)
+  from patsy import ModelDesc
+  ModelDesc.from_formula("y ~ x")
+  ModelDesc.from_formula("y ~ x + x + x")
+  ModelDesc.from_formula("y ~ -1 + x")
+  ModelDesc.from_formula("~ -1")
+  ModelDesc.from_formula("y ~ a:b")
+  ModelDesc.from_formula("y ~ a*b")
+  ModelDesc.from_formula("y ~ (a + b + c + d) ** 2")
+  ModelDesc.from_formula("y ~ (a + b)/(c + d)")
   ModelDesc.from_formula("np.log(x1 + x2) "
-                         "+ (x + {6: x3, 8 + 1: x4}[3 * i])", env)
+                         "+ (x + {6: x3, 8 + 1: x4}[3 * i])")
 
 Sometimes it might be easier to read if you put the processed formula
 back into formula notation using :meth:`ModelDesc.describe`::
 
-  desc = ModelDesc.from_formula("y ~ (a + b + c + d) ** 2", env)
+  desc = ModelDesc.from_formula("y ~ (a + b + c + d) ** 2")
   desc.describe()
 
 .. _formulas-building:

patsy/build.py

@@ -782,17 +782,13 @@ def subset(self, which_terms):
         term_name_to_term = dict(zip(design_info.term_names,
                                      design_info.terms))
         if isinstance(which_terms, str):
-            # We don't use this EvalEnvironment -- all we want to do is to
-            # find matching terms, and we can't do that use == on Term
-            # objects, because that calls == on factor objects, which in turn
-            # compares EvalEnvironments. So all we do with the parsed formula
-            # is pull out the term *names*, which the EvalEnvironment doesn't
-            # effect. This is just a placeholder then to allow the ModelDesc
-            # to be created:
-            env = EvalEnvironment({})
-            desc = ModelDesc.from_formula(which_terms, env)
+            desc = ModelDesc.from_formula(which_terms)
             if desc.lhs_termlist:
                 raise PatsyError("right-hand-side-only formula required")
+            # Use the term names instead of the term objects themselves,
+            # because even if my original DesignInfo is using LookupFactors
+            # or something then it's still unambiguous what naming them in
+            # this formula means.
             which_terms = [term.name() for term in desc.rhs_termlist]
         terms = []
         evaluators = set()

patsy/desc.py

@@ -145,22 +145,19 @@ def term_code(term):
         return result
 
     @classmethod
-    def from_formula(cls, tree_or_string, factor_eval_env):
+    def from_formula(cls, tree_or_string):
         """Construct a :class:`ModelDesc` from a formula string.
 
         :arg tree_or_string: A formula string. (Or an unevaluated formula
           parse tree, but the API for generating those isn't public yet. Shh,
           it can be our secret.)
-        :arg factor_eval_env: A :class:`EvalEnvironment`, to be used for
-          constructing :class:`EvalFactor` objects while parsing this
-          formula.
         :returns: A new :class:`ModelDesc`.
         """
         if isinstance(tree_or_string, ParseNode):
             tree = tree_or_string
         else:
             tree = parse_formula(tree_or_string)
-        value = Evaluator(factor_eval_env).eval(tree, require_evalexpr=False)
+        value = Evaluator().eval(tree, require_evalexpr=False)
         assert isinstance(value, cls)
         return value
 
@@ -181,8 +178,7 @@ def test_ModelDesc():
 
 def test_ModelDesc_from_formula():
     for input in ("y ~ x", parse_formula("y ~ x")):
-        eval_env = EvalEnvironment.capture(0)
-        md = ModelDesc.from_formula(input, eval_env)
+        md = ModelDesc.from_formula(input)
         assert md.lhs_termlist == [Term([EvalFactor("y")]),]
         assert md.rhs_termlist == [INTERCEPT, Term([EvalFactor("x")])]
 
@@ -352,9 +348,8 @@ def _eval_python_expr(evaluator, tree):
     return IntermediateExpr(False, None, False, [Term([factor])])
 
 class Evaluator(object):
-    def __init__(self, factor_eval_env):
+    def __init__(self):
         self._evaluators = {}
-        self._factor_eval_env = factor_eval_env
         self.add_op("~", 2, _eval_any_tilde)
         self.add_op("~", 1, _eval_any_tilde)
 
@@ -592,8 +587,7 @@ def _do_eval_formula_tests(tests): # pragma: no cover
     for code, result in six.iteritems(tests):
         if len(result) == 2:
             result = (False, []) + result
-        eval_env = EvalEnvironment.capture(0)
-        model_desc = ModelDesc.from_formula(code, eval_env)
+        model_desc = ModelDesc.from_formula(code)
         print(repr(code))
         print(result)
         print(model_desc)
@@ -608,13 +602,12 @@ def test_eval_formula():
 
 def test_eval_formula_error_reporting():
     from patsy.parse_formula import _parsing_error_test
-    parse_fn = lambda formula: ModelDesc.from_formula(formula,
-                                                      EvalEnvironment.capture(0))
+    parse_fn = lambda formula: ModelDesc.from_formula(formula)
     _parsing_error_test(parse_fn, _eval_error_tests)
 
 def test_formula_factor_origin():
     from patsy.origin import Origin
-    desc = ModelDesc.from_formula("a + b", EvalEnvironment.capture(0))
+    desc = ModelDesc.from_formula("a + b")
     assert (desc.rhs_termlist[1].factors[0].origin
             == Origin("a + b", 0, 1))
     assert (desc.rhs_termlist[2].factors[0].origin

patsy/highlevel.py

@@ -47,10 +47,10 @@ def _try_incr_builders(formula_like, data_iter_maker, eval_env,
                                 % (formula_like,))
         # fallthrough
     if isinstance(formula_like, str):
-        assert isinstance(eval_env, EvalEnvironment)
-        formula_like = ModelDesc.from_formula(formula_like, eval_env)
+        formula_like = ModelDesc.from_formula(formula_like)
         # fallthrough
     if isinstance(formula_like, ModelDesc):
+        assert isinstance(eval_env, EvalEnvironment)
         return design_matrix_builders([formula_like.lhs_termlist,
                                        formula_like.rhs_termlist],
                                       data_iter_maker,