added __slots__ to all our structures

this makes attribute access a tad faster and uses less memory (because it does not create a __dict__ for a each instance)

Author: gdementen

larray/core/array.py

@@ -311,6 +311,8 @@ def concat(arrays, axis=0, dtype=None):
 
 
 class LArrayIterator(object):
+    __slots__ = ('nextfunc', 'axes')
+
     def __init__(self, array):
         data_iter = iter(array.data)
         self.nextfunc = data_iter.next if PY2 else data_iter.__next__
@@ -333,6 +335,7 @@ def __next__(self):
 
 # TODO: rename to LArrayIndexIndexer or something like that
 class LArrayPositionalIndexer(object):
+    __slots__ = ('array',)
     """
     numpy indexing *except* we index the cross product
     """
@@ -363,6 +366,8 @@ def __len__(self):
 
 
 class LArrayPointsIndexer(object):
+    __slots__ = ('array',)
+
     def __init__(self, array):
         self.array = array
 
@@ -384,6 +389,7 @@ def __setitem__(self, key, value):
 
 # TODO: rename to LArrayIndexPointsIndexer or something like that
 class LArrayPositionalPointsIndexer(object):
+    __slots__ = ('array',)
     """
     the closest to numpy indexing we get, but not 100% the same.
     """
@@ -658,6 +664,7 @@ class LArray(ABCLArray):
           M  10   9   8
           F  10  11  12
     """
+    __slots__ = ('data', 'axes', '_meta')
 
     def __init__(self, data, axes=None, title=None, meta=None, dtype=None):
         data = np.asarray(data, dtype=dtype)
@@ -887,14 +894,15 @@ def __getattr__(self, key):
     # needed to make *un*pickling work (because otherwise, __getattr__ is called before .axes exists, which leads to
     # an infinite recursion)
     def __getstate__(self):
-        return self.__dict__
+        return self.data, self.axes, self._meta
 
     def __setstate__(self, d):
-        self.__dict__ = d
+        self.data, self.axes, self._meta = d
 
     def __dir__(self):
         axis_names = set(axis.name for axis in self.axes if axis.name is not None)
-        return list(set(dir(self.__class__)) | set(self.__dict__.keys()) | axis_names)
+        attributes = self.__slots__
+        return list(set(dir(self.__class__)) | set(attributes) | axis_names)
 
     def _ipython_key_completions_(self):
         return list(chain(*[list(labels) for labels in self.axes.labels]))

larray/core/axis.py

@@ -75,6 +75,8 @@ class Axis(ABCAxis):
     >>> anonymous
     Axis([0, 1, 2, 3, 4], None)
     """
+    __slots__ = ('name', '__mapping', '__sorted_keys', '__sorted_values', '_labels', '_length', '_iswildcard')
+
     # ticks instead of labels?
     def __init__(self, labels, name=None):
         if isinstance(labels, Group) and name is None:
@@ -766,6 +768,24 @@ def __contains__(self, key):
     def __hash__(self):
         return id(self)
 
+    # needed for Python 2 only (on Python2 all classes defining __slots__ need to define __getstate__/__setstate__ too)
+    def __getstate__(self):
+        return self.name, self._length if self._iswildcard else self._labels
+
+    # needed for Python 2 only
+    def __setstate__(self, state):
+        name, labels = state
+        self.name = name
+        self._labels = None
+        self._length = None
+        self._iswildcard = False
+
+        self.__mapping = None
+        self.__sorted_keys = None
+        self.__sorted_values = None
+        # set _labels, _length and _iswildcard via the property
+        self.labels = labels
+
     def _is_key_type_compatible(self, key):
         key_kind = np.dtype(type(key)).kind
         label_kind = self.labels.dtype.kind
@@ -1371,6 +1391,7 @@ def _make_axis(obj):
 # not using namedtuple because we have to know the fields in advance (it is a one-off class) and we need more
 # functionality than just a named tuple
 class AxisCollection(object):
+    __slots__ = ('_list', '_map')
     """
     Represents a collection of axes.
 
@@ -1464,10 +1485,11 @@ def __getattr__(self, key):
     # needed to make *un*pickling work (because otherwise, __getattr__ is called before _map exists, which leads to
     # an infinite recursion)
     def __getstate__(self):
-        return self.__dict__
+        return self._list
 
-    def __setstate__(self, d):
-        self.__dict__ = d
+    def __setstate__(self, state):
+        self._list = state
+        self._map = {axis.name: axis for axis in state if axis.name is not None}
 
     def __getitem__(self, key):
         if isinstance(key, Axis):

larray/core/group.py

@@ -706,6 +706,8 @@ class IGroupMaker(object):
     -----
     This class is used by the method `Axis.i`
     """
+    __slots__ = ('axis',)
+
     def __init__(self, axis):
         assert isinstance(axis, ABCAxis)
         self.axis = axis
@@ -724,6 +726,8 @@ def __len__(self):
 class Group(object):
     """Abstract Group.
     """
+    __slots__ = ('key', 'name', 'axis')
+
     format_string = None
 
     def __init__(self, key, name=None, axis=None):
@@ -1484,7 +1488,8 @@ def __array__(self, dtype=None):
     def __dir__(self):
         # called by dir() and tab-completion at the interactive prompt, must return a list of any valid getattr key.
         # dir() takes care of sorting but not uniqueness, so we must ensure that.
-        return list(set(dir(self.eval())) | set(self.__dict__.keys()) | set(dir(self.__class__)))
+        attributes = self.__slots__
+        return list(set(dir(self.eval())) | set(attributes) | set(dir(self.__class__)))
 
     def __getattr__(self, key):
         if key == '__array_struct__':
@@ -1495,10 +1500,10 @@ def __getattr__(self, key):
     # needed to make *un*pickling work (because otherwise, __getattr__ is called before .key exists, which leads to
     # an infinite recursion)
     def __getstate__(self):
-        return self.__dict__
+        return self.key, self.name, self.axis
 
     def __setstate__(self, d):
-        self.__dict__ = d
+        self.key, self.name, self.axis = d
 
     def __hash__(self):
         # to_tick & to_key are partially opposite operations but this standardize on a single notation so that they can
@@ -1556,6 +1561,7 @@ class LGroup(Group):
     >>> teens
     X.age[10:19] >> 'teens'
     """
+    __slots__ = ()
     format_string = "{axis}[{key}]"
 
     def __init__(self, key, name=None, axis=None):
@@ -1615,6 +1621,7 @@ class LSet(LGroup):
     >>> abc & letters['b:d']
     letters['b', 'c'].set()
     """
+    __slots__ = ()
     format_string = "{axis}[{key}].set()"
 
     def __init__(self, key, name=None, axis=None):
@@ -1677,6 +1684,7 @@ class IGroup(Group):
     axis : int, str, Axis, optional
         Axis for group.
     """
+    __slots__ = ()
     format_string = "{axis}.i[{key}]"
 
     def translate(self, bound=None, stop=False):