[Zope-Checkins] SVN: Zope/trunk/src/Products/ZCatalog/Lazy.py Lazy PEP8

Hanno Schlichting hannosch at hannosch.eu
Sat Jul 31 17:28:37 EDT 2010


Log message for revision 115289:
  Lazy PEP8
  

Changed:
  U   Zope/trunk/src/Products/ZCatalog/Lazy.py

-=-
Modified: Zope/trunk/src/Products/ZCatalog/Lazy.py
===================================================================
--- Zope/trunk/src/Products/ZCatalog/Lazy.py	2010-07-31 21:11:26 UTC (rev 115288)
+++ Zope/trunk/src/Products/ZCatalog/Lazy.py	2010-07-31 21:28:36 UTC (rev 115289)
@@ -16,22 +16,24 @@
     # Allow (reluctantly) access to unprotected attributes
     __allow_access_to_unprotected_subobjects__=1
 
-    def __repr__(self): return `list(self)`
+    def __repr__(self):
+        return repr(list(self))
 
     def __len__(self):
         # This is a worst-case len, subclasses should try to do better
-        try: return self._len
-        except AttributeError: pass
+        try:
+            return self._len
+        except AttributeError:
+            pass
 
-        l=len(self._data)
+        l = len(self._data)
         while 1:
             try:
                 self[l]
-                l=l+1
+                l = l + 1
             except:
-                self._len=l
+                self._len = l
                 return l
-                
 
     def __add__(self, other):
         if not isinstance(other, Lazy):
@@ -39,17 +41,20 @@
                 "Can not concatenate objects. Both must be lazy sequences.")
         return LazyCat([self, other])
 
-    def __getslice__(self,i1,i2):
-        r=[]
-        for i in xrange(i1,i2):
-            try: r.append(self[i])
-            except IndexError: return r
+    def __getslice__(self, i1, i2):
+        r = []
+        for i in xrange(i1, i2):
+            try:
+                r.append(self[i])
+            except IndexError:
+                return r
         return r
 
-    slice=__getslice__
+    slice = __getslice__
 
+
 class LazyCat(Lazy):
-    # Lazy concatenation of one or more sequences.  Should be handy
+    # Lazy concatenation of one or more sequences. Should be handy
     # for accessing small parts of big searches.
 
     def __init__(self, sequences, length=None):
@@ -66,54 +71,62 @@
                 else:
                     flattened_seq.append(s)
             sequences = flattened_seq
-        self._seq=sequences
-        self._data=[]
-        self._sindex=0
-        self._eindex=-1
-        if length is not None: self._len=length
+        self._seq = sequences
+        self._data = []
+        self._sindex = 0
+        self._eindex = -1
+        if length is not None:
+            self._len = length
 
-    def __getitem__(self,index):
+    def __getitem__(self, index):
+        data = self._data
+        try:
+            seq = self._seq
+        except AttributeError:
+            return data[index]
 
-        data=self._data
-        try: seq=self._seq
-        except AttributeError: return data[index]
+        i = index
+        if i < 0:
+            i = len(self) + i
+        if i < 0:
+            raise IndexError(index)
 
-        i=index
-        if i < 0: i=len(self)+i
-        if i < 0: raise IndexError, index
+        ind = len(data)
+        if i < ind:
+            return data[i]
+        ind = ind - 1
 
-        ind=len(data)
-        if i < ind: return data[i]
-        ind=ind-1
-
-        sindex=self._sindex
-        try: s=seq[sindex]
-        except: raise IndexError, index
-        eindex=self._eindex
+        sindex = self._sindex
+        try:
+            s = seq[sindex]
+        except:
+            raise IndexError(index)
+        eindex = self._eindex
         while i > ind:
             try:
-                eindex=eindex+1
-                v=s[eindex]
+                eindex = eindex + 1
+                v = s[eindex]
                 data.append(v)
-                ind=ind+1
+                ind = ind + 1
             except IndexError:
-                self._sindex=sindex=sindex+1
-                try: s=self._seq[sindex]
-                except:
+                self._sindex = sindex = sindex + 1
+                try:
+                    s = self._seq[sindex]
+                except Exception:
                     del self._seq
                     del self._sindex
                     del self._eindex
-                    raise IndexError, index
-                self._eindex=eindex=-1
-        self._eindex=eindex
+                    raise IndexError(index)
+                self._eindex = eindex = -1
+        self._eindex = eindex
         return data[i]
-        
+
     def __len__(self):
-        # Make len of LazyCat only as expensive as the lens 
+        # Make len of LazyCat only as expensive as the lens
         # of its underlying sequences
         try:
             return self._len
-        except:
+        except Exception:
             try:
                 l = 0
                 for s in self._seq:
@@ -123,142 +136,161 @@
             self._len = l
             return l
 
+
 class LazyMap(Lazy):
     # Act like a sequence, but get data from a filtering process.
     # Don't access data until necessary
 
     def __init__(self, func, seq, length=None):
-        self._seq=seq
-        self._data=[]
-        self._func=func
-        if length is not None: self._len=length
-        else: self._len = len(seq)
+        self._seq = seq
+        self._data = []
+        self._func = func
+        if length is not None:
+            self._len = length
+        else:
+            self._len = len(seq)
 
-    def __getitem__(self,index):
+    def __getitem__(self, index):
+        data = self._data
+        try:
+            s = self._seq
+        except AttributeError:
+            return data[index]
 
-        data=self._data
-        try: s=self._seq
-        except AttributeError: return data[index]
+        i = index
+        if i < 0:
+            i = len(self) + i
+        if i < 0:
+            raise IndexError(index)
 
-        i=index
-        if i < 0: i=len(self)+i
-        if i < 0: raise IndexError, index
+        ind = len(data)
+        if i < ind:
+            return data[i]
+        ind = ind - 1
 
-        ind=len(data)
-        if i < ind: return data[i]
-        ind=ind-1
-
-        func=self._func
+        func = self._func
         while i > ind:
             try:
-                ind=ind+1
+                ind = ind + 1
                 data.append(func(s[ind]))
             except IndexError:
                 del self._func
                 del self._seq
-                raise IndexError, index
+                raise IndexError(index)
         return data[i]
 
+
 class LazyFilter(Lazy):
     # Act like a sequence, but get data from a filtering process.
-    # Don't access data until necessary. Only data for which test(data) 
+    # Don't access data until necessary. Only data for which test(data)
     # returns true will be considered part of the set.
 
     def __init__(self, test, seq):
-        self._seq=seq
-        self._data=[]
-        self._eindex=-1
-        self._test=test
+        self._seq = seq
+        self._data = []
+        self._eindex = -1
+        self._test = test
 
-    def __getitem__(self,index):
+    def __getitem__(self, index):
+        data = self._data
+        try:
+            s = self._seq
+        except AttributeError:
+            return data[index]
 
-        data=self._data
-        try: s=self._seq
-        except AttributeError: return data[index]
+        i = index
+        if i < 0:
+            i = len(self) + i
+        if i < 0:
+            raise IndexError(index)
 
-        i=index
-        if i < 0: i=len(self)+i
-        if i < 0: raise IndexError, index
+        ind = len(data)
+        if i < ind:
+            return data[i]
+        ind = ind - 1
 
-        ind=len(data)
-        if i < ind: return data[i]
-        ind=ind-1
-
-        test=self._test
-        e=self._eindex
+        test = self._test
+        e = self._eindex
         while i > ind:
             try:
-                e=e+1
-                v=s[e]
+                e = e + 1
+                v = s[e]
                 if test(v):
                     data.append(v)
-                    ind=ind+1
+                    ind = ind + 1
             except IndexError:
                 del self._test
                 del self._seq
                 del self._eindex
-                raise IndexError, index
-        self._eindex=e
+                raise IndexError(index)
+        self._eindex = e
         return data[i]
 
+
 class LazyMop(Lazy):
     # Act like a sequence, but get data from a filtering process.
-    # Don't access data until necessary.  If the filter raises an exception
+    # Don't access data until necessary. If the filter raises an exception
     # for a given item, then that item isn't included in the sequence.
-    
+
     def __init__(self, test, seq):
-        self._seq=seq
-        self._data=[]
-        self._eindex=-1
-        self._test=test
+        self._seq = seq
+        self._data = []
+        self._eindex = -1
+        self._test = test
 
-    def __getitem__(self,index):
+    def __getitem__(self, index):
+        data = self._data
+        try:
+            s = self._seq
+        except AttributeError:
+            return data[index]
 
-        data=self._data
-        try: s=self._seq
-        except AttributeError: return data[index]
+        i = index
+        if i < 0:
+            i = len(self) + i
+        if i < 0:
+            raise IndexError(index)
 
-        i=index
-        if i < 0: i=len(self)+i
-        if i < 0: raise IndexError, index
+        ind = len(data)
+        if i < ind:
+            return data[i]
+        ind = ind - 1
 
-        ind=len(data)
-        if i < ind: return data[i]
-        ind=ind-1
-
-        test=self._test
-        e=self._eindex
+        test = self._test
+        e = self._eindex
         while i > ind:
             try:
-                e=e+1
-                v=s[e]
+                e = e + 1
+                v = s[e]
                 try:
-                    v=test(v)
+                    v = test(v)
                     data.append(v)
-                    ind=ind+1
-                except: pass
+                    ind = ind + 1
+                except Exception:
+                    pass
             except IndexError:
                 del self._test
                 del self._seq
                 del self._eindex
-                raise IndexError, index
-        self._eindex=e
+                raise IndexError(index)
+        self._eindex = e
         return data[i]
 
+
 class LazyValues(Lazy):
     """Given a sequence of two tuples typically (key, value) act as
     though we are just a list of the values lazily"""
-    
+
     def __init__(self, seq):
         self._seq = seq
-    
+
     def __len__(self):
         return len(self._seq)
-    
+
     def __getitem__(self, index):
         return self._seq[index][1]
-    
+
     def __getslice__(self, start, end):
         return self.__class__(self._seq[start:end])
-        
+
     slice = __getslice__



More information about the Zope-Checkins mailing list