[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