Merge branch 'master' into splines

njsmith · njsmith · commit 9df387345d10 · 2013-08-07T20:57:21.000+01:00
diff --git a/patsy/builtins.py b/patsy/builtins.py
@@ -67,7 +67,7 @@ def Q(name):
 
       my_fit_function("y ~ Q('weight.in.kg')", ...)
       my_fit_function('y ~ Q("weight.in.kg")', ...)
-      my_fit_function("y ~ Q(\"weight.in.kg\")", ...)
+      my_fit_function("y ~ Q(\\"weight.in.kg\\")", ...)
 
     Note also that ``Q`` is an ordinary Python function, which means that you
     can use it in more complex expressions. For example, this is a legal
diff --git a/patsy/desc.py b/patsy/desc.py
@@ -13,7 +13,7 @@
 from patsy.util import repr_pretty_delegate, repr_pretty_impl
 
 # These are made available in the patsy.* namespace
-__all__ = ["Term", "ModelDesc", "INTERCEPT", "LookupFactor"]
+__all__ = ["Term", "ModelDesc", "INTERCEPT"]
 
 # One might think it would make more sense for 'factors' to be a set, rather
 # than a tuple-with-guaranteed-unique-entries-that-compares-like-a-set. The
@@ -63,64 +63,6 @@ def name(self):
 
 INTERCEPT = Term([])
 
-class LookupFactor(object):
-    """A simple factor class that simply looks up a named entry in the given
-    data.
-
-    Useful for programatically constructing formulas, and as a simple example
-    of the factor protocol.  For details see
-    :ref:`expert-model-specification`.
-
-    Example::
-
-      dmatrix(ModelDesc([], [Term([LookupFactor("x")])]), {"x": [1, 2, 3]})
-    """
-    def __init__(self, varname, origin=None):
-        self._varname = varname
-        self.origin = origin
-
-    def name(self):
-        return self._varname
-
-    def __repr__(self):
-        return "%s(%r)" % (self.__class__.__name__, self._varname)
-       
-    def __eq__(self, other):
-        return (isinstance(other, LookupFactor)
-                and self._varname == other._varname)
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        return hash((LookupFactor, self._varname))
-
-    def memorize_passes_needed(self, state):
-        return 0
-
-    def memorize_chunk(self, state, which_pass, env): # pragma: no cover
-        assert False
-
-    def memorize_finish(self, state, which_pass): # pragma: no cover
-        assert False
-
-    def eval(self, memorize_state, data):
-        return data[self._varname]
-
-def test_LookupFactor():
-    l_a = LookupFactor("a")
-    assert l_a.name() == "a"
-    assert l_a == LookupFactor("a")
-    assert l_a != LookupFactor("b")
-    assert hash(l_a) == hash(LookupFactor("a"))
-    assert hash(l_a) != hash(LookupFactor("b"))
-    assert l_a.eval({}, {"a": 1}) == 1
-    assert l_a.eval({}, {"a": 2}) == 2
-    assert repr(l_a) == "LookupFactor('a')"
-    assert l_a.origin is None
-    l_with_origin = LookupFactor("b", origin="asdf")
-    assert l_with_origin.origin == "asdf"
-
 class _MockFactor(object):
     def __init__(self, name):
         self._name = name
diff --git a/patsy/test_build.py b/patsy/test_build.py
@@ -13,10 +13,10 @@
 from patsy.util import (atleast_2d_column_default,
                         have_pandas, have_pandas_categorical)
 from patsy.compat import itertools_product
-from patsy.desc import Term, INTERCEPT, LookupFactor
+from patsy.desc import Term, INTERCEPT
 from patsy.build import *
 from patsy.categorical import C
-from patsy.user_util import balanced
+from patsy.user_util import balanced, LookupFactor
 from patsy.design_info import DesignMatrix
 
 if have_pandas:
diff --git a/patsy/test_highlevel.py b/patsy/test_highlevel.py
@@ -11,10 +11,10 @@
 from patsy import PatsyError
 from patsy.design_info import DesignMatrix
 from patsy.eval import EvalEnvironment
-from patsy.desc import ModelDesc, Term, LookupFactor, INTERCEPT
+from patsy.desc import ModelDesc, Term, INTERCEPT
 from patsy.categorical import C
 from patsy.contrasts import Helmert
-from patsy.user_util import balanced
+from patsy.user_util import balanced, LookupFactor
 from patsy.build import (design_matrix_builders,
                          build_design_matrices,
                          DesignMatrixBuilder)
diff --git a/patsy/user_util.py b/patsy/user_util.py
@@ -6,11 +6,12 @@
 # patsy.util, which is misc. utilities useful for implementing patsy).
 
 # These are made available in the patsy.* namespace
-__all__ = ["balanced", "demo_data"]
+__all__ = ["balanced", "demo_data", "LookupFactor"]
 
 import numpy as np
 from patsy import PatsyError
 from patsy.compat import itertools_product
+from patsy.categorical import C
 
 def balanced(**kwargs):
     """balanced(factor_name=num_levels, [factor_name=num_levels, ..., repeat=1])
@@ -136,3 +137,89 @@ def test_demo_data():
     from nose.tools import assert_raises
     assert_raises(PatsyError, demo_data, "a", "b", "__123")
     assert_raises(TypeError, demo_data, "a", "b", asdfasdf=123)
+
+class LookupFactor(object):
+    """A simple factor class that simply looks up a named entry in the given
+    data.
+
+    Useful for programatically constructing formulas, and as a simple example
+    of the factor protocol.  For details see
+    :ref:`expert-model-specification`.
+
+    Example::
+
+      dmatrix(ModelDesc([], [Term([LookupFactor("x")])]), {"x": [1, 2, 3]})
+    """
+    def __init__(self, varname,
+                 force_categorical=False, contrast=None, levels=None,
+                 origin=None):
+        self._varname = varname
+        self._force_categorical = force_categorical
+        self._contrast = contrast
+        self._levels = levels
+        self.origin = origin
+        if not self._force_categorical:
+            if contrast is not None:
+                raise ValueError("contrast= requires force_categorical=True")
+            if levels is not None:
+                raise ValueError("levels= requires force_categorical=True")
+
+    def name(self):
+        return self._varname
+
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__.__name__, self._varname)
+       
+    def __eq__(self, other):
+        return (isinstance(other, LookupFactor)
+                and self._varname == other._varname
+                and self._force_categorical == other._force_categorical
+                and self._contrast == other._contrast
+                and self._levels == other._levels)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((LookupFactor, self._varname,
+                     self._force_categorical, self._contrast, self._levels))
+
+    def memorize_passes_needed(self, state):
+        return 0
+
+    def memorize_chunk(self, state, which_pass, env): # pragma: no cover
+        assert False
+
+    def memorize_finish(self, state, which_pass): # pragma: no cover
+        assert False
+
+    def eval(self, memorize_state, data):
+        value = data[self._varname]
+        if self._force_categorical:
+            value = C(value, contrast=self._contrast, levels=self._levels)
+        return value
+
+def test_LookupFactor():
+    l_a = LookupFactor("a")
+    assert l_a.name() == "a"
+    assert l_a == LookupFactor("a")
+    assert l_a != LookupFactor("b")
+    assert hash(l_a) == hash(LookupFactor("a"))
+    assert hash(l_a) != hash(LookupFactor("b"))
+    assert l_a.eval({}, {"a": 1}) == 1
+    assert l_a.eval({}, {"a": 2}) == 2
+    assert repr(l_a) == "LookupFactor('a')"
+    assert l_a.origin is None
+    l_with_origin = LookupFactor("b", origin="asdf")
+    assert l_with_origin.origin == "asdf"
+
+    l_c = LookupFactor("c", force_categorical=True,
+                       contrast="CONTRAST", levels=(1, 2))
+    box = l_c.eval({}, {"c": [1, 1, 2]})
+    assert box.data == [1, 1, 2]
+    assert box.contrast == "CONTRAST"
+    assert box.levels == (1, 2)
+
+    from nose.tools import assert_raises
+    assert_raises(ValueError, LookupFactor, "nc", contrast="CONTRAST")
+    assert_raises(ValueError, LookupFactor, "nc", levels=(1, 2))
