REF: refactor Factor class

Author: wesm

RELEASE.rst

@@ -131,6 +131,7 @@ pandas 0.8.0
   - Deprecation of offset, time_rule timeRule parameters throughout codebase
   - Series.append and DataFrame.append no longer check for duplicate indexes
     by default, add verify_integrity parameter (#1394)
+  - Refactor Factor class, old constructor moved to Factor.from_array
 
 **Bug fixes**
 

pandas/core/factor.py

@@ -1,14 +1,18 @@
+# pylint: disable=E1101,W0232
+
 import numpy as np
 import pandas.core.common as com
-import pandas.lib as lib
 
 
-class Factor(np.ndarray):
+class Factor(object):
     """
     Represents a categorical variable in classic R / S-plus fashion
 
     Parameters
     ----------
+    labels : ndarray of integers
+    levels : Index-like (unique)
+
     data : array-like
 
     Returns
@@ -17,43 +21,45 @@ class Factor(np.ndarray):
       * labels : ndarray
       * levels : ndarray
     """
-    def __new__(cls, data):
+    def __init__(self, labels, levels):
         from pandas.core.index import _ensure_index
+
+        levels = _ensure_index(levels)
+        if not levels.is_unique:
+            raise ValueError('Factor levels must be unique')
+
+        self.labels = labels
+        self.levels = levels
+
+    @classmethod
+    def from_array(cls, data):
         from pandas.core.algorithms import factorize
 
         try:
             labels, levels, _ = factorize(data, sort=True)
         except TypeError:
             labels, levels, _ = factorize(data, sort=False)
 
-        labels = labels.view(Factor)
-        labels.levels = _ensure_index(levels)
-        return labels
+        return Factor(labels, levels)
 
     levels = None
 
-    def __array_finalize__(self, obj):
-        self.levels = getattr(obj, 'levels', None)
-
-    @property
-    def labels(self):
-        return self.view(np.ndarray)
-
-    def asarray(self):
-        return np.asarray(self.levels).take(self.labels)
+    def __array__(self):
+        return self.levels.values.take(self.labels)
 
     def __len__(self):
         return len(self.labels)
 
     def __repr__(self):
         temp = 'Factor:\n%s\nLevels (%d): %s'
-        values = self.asarray()
+        values = np.asarray(self)
         return temp % (repr(values), len(self.levels), self.levels)
 
     def __getitem__(self, key):
         if isinstance(key, (int, np.integer)):
             i = self.labels[key]
             return self.levels[i]
         else:
-            return np.ndarray.__getitem__(self, key)
+            return Factor(self.labels[key], self.levels)
+
 

pandas/core/index.py

@@ -1460,7 +1460,7 @@ def from_arrays(cls, arrays, sortorder=None, names=None):
         levels = []
         labels = []
         for arr in arrays:
-            factor = Factor(arr)
+            factor = Factor.from_array(arr)
             levels.append(factor.levels)
             labels.append(factor.labels)
 

pandas/core/panel.py

@@ -77,8 +77,8 @@ def panel_index(time, panels, names=['time', 'panel']):
                 (1962, 'C')], dtype=object)
     """
     time, panels = _ensure_like_indices(time, panels)
-    time_factor = Factor(time)
-    panel_factor = Factor(panels)
+    time_factor = Factor.from_array(time)
+    panel_factor = Factor.from_array(panels)
 
     labels = [time_factor.labels, panel_factor.labels]
     levels = [time_factor.levels, panel_factor.levels]

pandas/core/reshape.py

@@ -586,7 +586,7 @@ def convert_dummies(data, cat_variables, prefix_sep='_'):
 
 def make_column_dummies(data, column, prefix=False, prefix_sep='_'):
     from pandas import Factor
-    factor = Factor(data[column].values)
+    factor = Factor.from_array(data[column].values)
     dummy_mat = np.eye(len(factor.levels)).take(factor.labels, axis=0)
 
     if prefix:
@@ -628,7 +628,7 @@ def make_axis_dummies(frame, axis='minor', transform=None):
     labels = frame.index.labels[num]
     if transform is not None:
         mapped_items = items.map(transform)
-        factor = Factor(mapped_items.take(labels))
+        factor = Factor.from_array(mapped_items.take(labels))
         labels = factor.labels
         items = factor.levels
 

pandas/io/pytables.py

@@ -843,8 +843,8 @@ def _read_panel_table(self, group, where=None):
         index = _maybe_convert(sel.values['index'], table._v_attrs.index_kind)
         values = sel.values['values']
 
-        major = Factor(index)
-        minor = Factor(columns)
+        major = Factor.from_array(index)
+        minor = Factor.from_array(columns)
 
         J, K = len(major.levels), len(minor.levels)
         key = major.labels * K + minor.labels

pandas/tests/test_index.py

@@ -1534,7 +1534,8 @@ def test_has_duplicates(self):
 class TestFactor(unittest.TestCase):
 
     def setUp(self):
-        self.factor = Factor(['a', 'b', 'b', 'a', 'a', 'c', 'c', 'c'])
+        self.factor = Factor.from_array(['a', 'b', 'b', 'a',
+                                         'a', 'c', 'c', 'c'])
 
     def test_getitem(self):
         self.assertEqual(self.factor[0], 'a')
@@ -1543,14 +1544,14 @@ def test_getitem(self):
         subf = self.factor[[0, 1, 2]]
         tm.assert_almost_equal(subf.labels, [0, 1, 1])
 
-        subf = self.factor[self.factor.asarray() == 'c']
+        subf = self.factor[np.asarray(self.factor) == 'c']
         tm.assert_almost_equal(subf.labels, [2, 2, 2])
 
     def test_constructor_unsortable(self):
         arr = np.array([1, 2, 3, datetime.now()], dtype='O')
 
         # it works!
-        factor = Factor(arr)
+        factor = Factor.from_array(arr)
 
     def test_factor_agg(self):
         import pandas.core.frame as frame

pandas/tools/merge.py

@@ -1117,7 +1117,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
             names = [None] * len(zipped)
 
         if levels is None:
-            levels = [Factor(zp).levels for zp in zipped]
+            levels = [Factor.from_array(zp).levels for zp in zipped]
         else:
             levels = [_ensure_index(x) for x in levels]
     else:
@@ -1150,7 +1150,7 @@ def _make_concat_multiindex(indexes, keys, levels=None, names=None):
             levels.extend(concat_index.levels)
             label_list.extend(concat_index.labels)
         else:
-            factor = Factor(concat_index)
+            factor = Factor.from_array(concat_index)
             levels.append(factor.levels)
             label_list.append(factor.labels)
 

pandas/tools/tile.py

@@ -3,6 +3,7 @@
 """
 
 from pandas.core.api import DataFrame, Series
+from pandas.core.factor import Factor
 import pandas.core.algorithms as algos
 import pandas.core.common as com
 import pandas.core.nanops as nanops