[Checkins] SVN: Products.ZCatalog/trunk/src/Products/PluginIndexes/ pep8 / whitespace cleanup
Hano Schlichting
cvs-admin at zope.org
Sun Mar 25 13:29:54 UTC 2012
Log message for revision 124719:
pep8 / whitespace cleanup
Changed:
U Products.ZCatalog/trunk/src/Products/PluginIndexes/FieldIndex/tests/testFieldIndex.py
U Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/KeywordIndex.py
U Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/tests/testKeywordIndex.py
-=-
Modified: Products.ZCatalog/trunk/src/Products/PluginIndexes/FieldIndex/tests/testFieldIndex.py
===================================================================
--- Products.ZCatalog/trunk/src/Products/PluginIndexes/FieldIndex/tests/testFieldIndex.py 2012-03-25 12:49:53 UTC (rev 124718)
+++ Products.ZCatalog/trunk/src/Products/PluginIndexes/FieldIndex/tests/testFieldIndex.py 2012-03-25 13:29:50 UTC (rev 124719)
@@ -20,13 +20,13 @@
class Dummy:
- def __init__( self, foo ):
+ def __init__(self, foo):
self._foo = foo
- def foo( self ):
+ def foo(self):
return self._foo
- def __str__( self ):
+ def __str__(self):
return '<Dummy: %s>' % self._foo
__repr__ = __str__
@@ -36,23 +36,23 @@
"""Test FieldIndex objects.
"""
- def setUp( self ):
- self._index = FieldIndex( 'foo' )
+ def setUp(self):
+ self._index = FieldIndex('foo')
self._marker = []
- self._values = [ ( 0, Dummy( 'a' ) )
- , ( 1, Dummy( 'ab' ) )
- , ( 2, Dummy( 'abc' ) )
- , ( 3, Dummy( 'abca' ) )
- , ( 4, Dummy( 'abcd' ) )
- , ( 5, Dummy( 'abce' ) )
- , ( 6, Dummy( 'abce' ) )
- , ( 7, Dummy( 0 ) ) # Collector #1959
- , ( 8, Dummy(None) )]
+ self._values = [(0, Dummy('a')),
+ (1, Dummy('ab')),
+ (2, Dummy('abc')),
+ (3, Dummy('abca')),
+ (4, Dummy('abcd')),
+ (5, Dummy('abce')),
+ (6, Dummy('abce')),
+ (7, Dummy(0)), # Collector #1959
+ (8, Dummy(None))]
self._forward = {}
self._backward = {}
for k, v in self._values:
self._backward[k] = v
- keys = self._forward.get( v, [] )
+ keys = self._forward.get(v, [])
self._forward[v] = keys
self._noop_req = {'bar': 123}
@@ -66,11 +66,11 @@
self._max_req_n = {'foo':
{'query': 'abc', 'range': 'max', 'not': ['a', 'b', None, 0]}}
self._range_req = {'foo':
- {'query': ( 'abc', 'abcd' ), 'range': 'min:max'}}
+ {'query': ('abc', 'abcd'), 'range': 'min:max'}}
self._range_ren = {'foo':
- {'query': ( 'abc', 'abcd' ), 'range': 'min:max', 'not': 'abcd'}}
+ {'query': ('abc', 'abcd'), 'range': 'min:max', 'not': 'abcd'}}
self._range_non = {'foo':
- {'query': ( 'a', 'aa' ), 'range': 'min:max', 'not': 'a'}}
+ {'query': ('a', 'aa'), 'range': 'min:max', 'not': 'a'}}
self._zero_req = {'foo': 0 }
self._none_req = {'foo': None }
self._not_1 = {'foo': {'query': 'a', 'not': 'a'}}
@@ -80,17 +80,17 @@
self._not_5 = {'foo': {'not': ['a', 'b']}}
self._not_6 = {'foo': 'a', 'bar': {'query': 123, 'not': 1}}
- def _populateIndex( self ):
+ def _populateIndex(self):
for k, v in self._values:
- self._index.index_object( k, v )
+ self._index.index_object(k, v)
- def _checkApply( self, req, expectedValues ):
- result, used = self._index._apply_index( req )
+ def _checkApply(self, req, expectedValues):
+ result, used = self._index._apply_index(req)
if hasattr(result, 'keys'):
result = result.keys()
- assert used == ( 'foo', )
- assert len( result ) == len( expectedValues ), \
- '%s | %s' % ( map( None, result ), expectedValues )
+ assert used == ('foo', )
+ assert len(result) == len(expectedValues), \
+ '%s | %s' % (map(None, result), expectedValues)
for k, v in expectedValues:
assert k in result
@@ -104,21 +104,21 @@
verifyClass(ISortIndex, FieldIndex)
verifyClass(IUniqueValueIndex, FieldIndex)
- def testEmpty( self ):
+ def testEmpty(self):
"Test an empty FieldIndex."
- assert len( self._index ) == 0
- assert len( self._index.referencedObjects() ) == 0
+ assert len(self._index) == 0
+ assert len(self._index.referencedObjects()) == 0
self.assertEqual(self._index.numObjects(), 0)
- assert self._index.getEntryForObject( 1234 ) is None
- assert ( self._index.getEntryForObject( 1234, self._marker )
- is self._marker )
- self._index.unindex_object( 1234 ) # nothrow
+ assert self._index.getEntryForObject(1234) is None
+ assert (self._index.getEntryForObject(1234, self._marker)
+ is self._marker)
+ self._index.unindex_object(1234) # nothrow
- assert self._index.hasUniqueValuesFor( 'foo' )
- assert not self._index.hasUniqueValuesFor( 'bar' )
- assert len( self._index.uniqueValues( 'foo' ) ) == 0
+ assert self._index.hasUniqueValuesFor('foo')
+ assert not self._index.hasUniqueValuesFor('bar')
+ assert len(self._index.uniqueValues('foo')) == 0
assert self._index._apply_index(self._noop_req) is None
self._checkApply(self._request, [])
@@ -130,26 +130,26 @@
self._checkApply(self._range_ren, [])
self._checkApply(self._range_non, [])
- def testPopulated( self ):
+ def testPopulated(self):
""" Test a populated FieldIndex """
self._populateIndex()
values = self._values
- assert len( self._index ) == len( values )-1 #'abce' is duplicate
- assert len( self._index.referencedObjects() ) == len( values )
- self.assertEqual(self._index.indexSize(), len( values )-1)
+ assert len(self._index) == len(values) - 1 # 'abce' is duplicate
+ assert len(self._index.referencedObjects() ) == len(values)
+ self.assertEqual(self._index.indexSize(), len(values) - 1)
- assert self._index.getEntryForObject( 1234 ) is None
- assert ( self._index.getEntryForObject( 1234, self._marker )
- is self._marker )
- self._index.unindex_object( 1234 ) # nothrow
+ assert self._index.getEntryForObject(1234) is None
+ assert (self._index.getEntryForObject(1234, self._marker)
+ is self._marker)
+ self._index.unindex_object(1234) # nothrow
for k, v in values:
- assert self._index.getEntryForObject( k ) == v.foo()
+ assert self._index.getEntryForObject(k) == v.foo()
- assert len( self._index.uniqueValues( 'foo' ) ) == len( values )-1
+ assert len(self._index.uniqueValues('foo')) == len(values) - 1
- assert self._index._apply_index( self._noop_req ) is None
+ assert self._index._apply_index(self._noop_req) is None
self._checkApply(self._request, values[-4:-2])
self._checkApply(self._min_req, values[2:-2])
@@ -167,12 +167,12 @@
self._checkApply(self._not_5, values[1:])
self._checkApply(self._not_6, values[0:1])
- def testZero( self ):
+ def testZero(self):
""" Make sure 0 gets indexed """
self._populateIndex()
values = self._values
- self._checkApply( self._zero_req, values[ -2:-1 ] )
- assert 0 in self._index.uniqueValues( 'foo' )
+ self._checkApply(self._zero_req, values[-2:-1])
+ assert 0 in self._index.uniqueValues('foo')
def testNone(self):
""" make sure None gets indexed """
@@ -181,20 +181,20 @@
self._checkApply(self._none_req, values[-1:])
assert None in self._index.uniqueValues('foo')
- def testReindex( self ):
+ def testReindex(self):
self._populateIndex()
- result, used = self._index._apply_index( {'foo':'abc'} )
- assert list(result)==[2]
- assert self._index.keyForDocument(2)=='abc'
+ result, used = self._index._apply_index({'foo': 'abc'})
+ assert list(result) == [2]
+ assert self._index.keyForDocument(2) == 'abc'
d = Dummy('world')
- self._index.index_object(2,d)
- result, used = self._index._apply_index( {'foo':'world'} )
- assert list(result)==[2]
- assert self._index.keyForDocument(2)=='world'
+ self._index.index_object(2, d)
+ result, used = self._index._apply_index({'foo': 'world'})
+ assert list(result) == [2]
+ assert self._index.keyForDocument(2) == 'world'
del d._foo
- self._index.index_object(2,d)
- result, used = self._index._apply_index( {'foo':'world'} )
- assert list(result)==[]
+ self._index.index_object(2, d)
+ result, used = self._index._apply_index({'foo': 'world'})
+ assert list(result) == []
try:
should_not_be = self._index.keyForDocument(2)
except KeyError:
@@ -206,35 +206,28 @@
def testRange(self):
"""Test a range search"""
- index = FieldIndex( 'foo' )
+ index = FieldIndex('foo')
for i in range(100):
- index.index_object(i, Dummy(i%10))
+ index.index_object(i, Dummy(i % 10))
- record = { 'foo' : { 'query' : [-99, 3]
- , 'range' : 'min:max'
- }
- }
- r=index._apply_index( record )
+ record = {'foo': {'query': [-99, 3], 'range': 'min:max'}}
+ r = index._apply_index(record)
- assert tuple(r[1])==('foo',), r[1]
- r=list(r[0].keys())
+ assert tuple(r[1]) == ('foo', ), r[1]
+ r = list(r[0].keys())
- expect=[
+ expect = [
0, 1, 2, 3, 10, 11, 12, 13, 20, 21, 22, 23, 30, 31, 32, 33,
40, 41, 42, 43, 50, 51, 52, 53, 60, 61, 62, 63, 70, 71, 72, 73,
80, 81, 82, 83, 90, 91, 92, 93
]
+ assert r == expect, r
- assert r==expect, r
-
- #
- # Make sure that range tests with incompatible paramters
- # don't return empty sets.
- #
- record[ 'foo' ][ 'operator' ] = 'and'
- r2, ignore = index._apply_index( record )
- r2 = list( r2.keys() )
-
+ # Make sure that range tests with incompatible paramters
+ # don't return empty sets.
+ record['foo']['operator'] = 'and'
+ r2, ignore = index._apply_index(record)
+ r2 = list(r2.keys())
assert r2 == r
Modified: Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/KeywordIndex.py
===================================================================
--- Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/KeywordIndex.py 2012-03-25 12:49:53 UTC (rev 124718)
+++ Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/KeywordIndex.py 2012-03-25 13:29:50 UTC (rev 124719)
@@ -33,14 +33,14 @@
This should have an _apply_index that returns a relevance score
"""
- meta_type="KeywordIndex"
+ meta_type = "KeywordIndex"
- manage_options= (
+ manage_options = (
{'label': 'Settings', 'action': 'manage_main'},
{'label': 'Browse', 'action': 'manage_browse'},
)
- query_options = ("query","operator", "range")
+ query_options = ("query", "operator", "range")
def _index_object(self, documentId, obj, threshold=None, attr=''):
""" index an object 'obj' with integer id 'i'
@@ -136,6 +136,7 @@
manage_addKeywordIndexForm = DTMLFile('dtml/addKeywordIndex', globals())
+
def manage_addKeywordIndex(self, id, extra=None,
REQUEST=None, RESPONSE=None, URL3=None):
"""Add a keyword index"""
Modified: Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/tests/testKeywordIndex.py
===================================================================
--- Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/tests/testKeywordIndex.py 2012-03-25 12:49:53 UTC (rev 124718)
+++ Products.ZCatalog/trunk/src/Products/PluginIndexes/KeywordIndex/tests/testKeywordIndex.py 2012-03-25 13:29:50 UTC (rev 124719)
@@ -10,8 +10,6 @@
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
-"""KeywordIndex unit tests.
-"""
import unittest
@@ -20,17 +18,18 @@
class Dummy:
- def __init__( self, foo ):
+ def __init__(self, foo):
self._foo = foo
- def foo( self ):
+ def foo(self):
return self._foo
- def __str__( self ):
+ def __str__(self):
return '<Dummy: %s>' % self._foo
__repr__ = __str__
+
def sortedUnique(seq):
unique = {}
for i in seq:
@@ -40,49 +39,42 @@
return unique
-class TestKeywordIndex( unittest.TestCase ):
- """
- Test KeywordIndex objects.
- """
+class TestKeywordIndex(unittest.TestCase):
+
_old_log_write = None
- def setUp( self ):
- """
- """
- self._index = KeywordIndex( 'foo' )
+ def setUp(self):
+ self._index = KeywordIndex('foo')
self._marker = []
- self._values = [ ( 0, Dummy( ['a'] ) )
- , ( 1, Dummy( ['a','b'] ) )
- , ( 2, Dummy( ['a','b','c'] ) )
- , ( 3, Dummy( ['a','b','c','a'] ) )
- , ( 4, Dummy( ['a', 'b', 'c', 'd'] ) )
- , ( 5, Dummy( ['a', 'b', 'c', 'e'] ) )
- , ( 6, Dummy( ['a', 'b', 'c', 'e', 'f'] ))
- , ( 7, Dummy( [0] ) )
+ self._values = [(0, Dummy(['a'])),
+ (1, Dummy(['a', 'b'])),
+ (2, Dummy(['a', 'b', 'c'])),
+ (3, Dummy(['a', 'b', 'c', 'a'])),
+ (4, Dummy(['a', 'b', 'c', 'd'])),
+ (5, Dummy(['a', 'b', 'c', 'e'])),
+ (6, Dummy(['a', 'b', 'c', 'e', 'f'])),
+ (7, Dummy([0])),
]
- self._noop_req = { 'bar': 123 }
- self._all_req = { 'foo': ['a'] }
- self._some_req = { 'foo': ['e'] }
- self._overlap_req = { 'foo': ['c', 'e'] }
+ self._noop_req = {'bar': 123}
+ self._all_req = {'foo': ['a']}
+ self._some_req = {'foo': ['e']}
+ self._overlap_req = {'foo': ['c', 'e']}
self._string_req = {'foo': 'a'}
- self._zero_req = { 'foo': [0] }
+ self._zero_req = {'foo': [0]}
- def tearDown( self ):
- """
- """
-
- def _populateIndex( self ):
+ def _populateIndex(self):
for k, v in self._values:
- self._index.index_object( k, v )
+ self._index.index_object(k, v)
- def _checkApply( self, req, expectedValues ):
- result, used = self._index._apply_index( req )
- assert used == ( 'foo', )
- assert len(result) == len( expectedValues ), \
- '%s | %s' % ( map( None, result ),
- map(lambda x: x[0], expectedValues ))
+ def _checkApply(self, req, expectedValues):
+ result, used = self._index._apply_index(req)
+ assert used == ('foo', )
+ assert len(result) == len(expectedValues), \
+ '%s | %s' % (map(None, result),
+ map(lambda x: x[0], expectedValues))
- if hasattr(result, 'keys'): result=result.keys()
+ if hasattr(result, 'keys'):
+ result = result.keys()
for k, v in expectedValues:
assert k in result
@@ -97,77 +89,70 @@
verifyClass(IUniqueValueIndex, KeywordIndex)
def testAddObjectWOKeywords(self):
+ self._populateIndex()
+ self._index.index_object(999, None)
- try:
- self._populateIndex()
- self._index.index_object(999, None)
- finally:
- pass
-
- def testEmpty( self ):
- assert len( self._index ) == 0
- assert len( self._index.referencedObjects() ) == 0
+ def testEmpty(self):
+ assert len(self._index) == 0
+ assert len(self._index.referencedObjects()) == 0
self.assertEqual(self._index.numObjects(), 0)
- assert self._index.getEntryForObject( 1234 ) is None
- assert ( self._index.getEntryForObject( 1234, self._marker )
- is self._marker ), self._index.getEntryForObject(1234)
- self._index.unindex_object( 1234 ) # nothrow
+ assert self._index.getEntryForObject(1234) is None
+ assert (self._index.getEntryForObject(1234, self._marker)
+ is self._marker), self._index.getEntryForObject(1234)
+ self._index.unindex_object(1234) # nothrow
- assert self._index.hasUniqueValuesFor( 'foo' )
- assert not self._index.hasUniqueValuesFor( 'bar' )
- assert len( self._index.uniqueValues( 'foo' ) ) == 0
+ assert self._index.hasUniqueValuesFor('foo')
+ assert not self._index.hasUniqueValuesFor('bar')
+ assert len(self._index.uniqueValues('foo')) == 0
- assert self._index._apply_index( self._noop_req ) is None
- self._checkApply( self._all_req, [] )
- self._checkApply( self._some_req, [] )
- self._checkApply( self._overlap_req, [] )
- self._checkApply( self._string_req, [] )
+ assert self._index._apply_index(self._noop_req) is None
+ self._checkApply(self._all_req, [])
+ self._checkApply(self._some_req, [])
+ self._checkApply(self._overlap_req, [])
+ self._checkApply(self._string_req, [])
- def testPopulated( self ):
+ def testPopulated(self):
self._populateIndex()
values = self._values
- #assert len( self._index ) == len( values )
- assert len( self._index.referencedObjects() ) == len( values )
+ assert len(self._index.referencedObjects()) == len(values)
+ assert self._index.getEntryForObject(1234) is None
+ assert (self._index.getEntryForObject(1234, self._marker)
+ is self._marker)
+ self._index.unindex_object(1234) # nothrow
+ self.assertEqual(self._index.indexSize(), len(values) - 1)
- assert self._index.getEntryForObject( 1234 ) is None
- assert ( self._index.getEntryForObject( 1234, self._marker )
- is self._marker )
- self._index.unindex_object( 1234 ) # nothrow
- self.assertEqual(self._index.indexSize(), len( values )-1)
-
for k, v in values:
- entry = self._index.getEntryForObject( k )
+ entry = self._index.getEntryForObject(k)
entry.sort()
kw = sortedUnique(v.foo())
self.assertEqual(entry, kw)
- assert len( self._index.uniqueValues( 'foo' ) ) == len( values )-1
- assert self._index._apply_index( self._noop_req ) is None
+ assert len(self._index.uniqueValues('foo')) == len(values) - 1
+ assert self._index._apply_index(self._noop_req) is None
- self._checkApply( self._all_req, values[:-1])
- self._checkApply( self._some_req, values[ 5:7 ] )
- self._checkApply( self._overlap_req, values[2:7] )
- self._checkApply( self._string_req, values[:-1] )
+ self._checkApply(self._all_req, values[:-1])
+ self._checkApply(self._some_req, values[5:7])
+ self._checkApply(self._overlap_req, values[2:7])
+ self._checkApply(self._string_req, values[:-1])
- def testZero( self ):
+ def testZero(self):
self._populateIndex()
values = self._values
- self._checkApply( self._zero_req, values[ -1: ] )
- assert 0 in self._index.uniqueValues( 'foo' )
+ self._checkApply(self._zero_req, values[-1:])
+ assert 0 in self._index.uniqueValues('foo')
def testReindexChange(self):
self._populateIndex()
expected = Dummy(['x', 'y'])
self._index.index_object(6, expected)
result, used = self._index._apply_index({'foo': ['x', 'y']})
- result=result.keys()
+ result = result.keys()
assert len(result) == 1
assert result[0] == 6
result, used = self._index._apply_index(
- {'foo': ['a', 'b', 'c', 'e', 'f']}
- )
+ {'foo': ['a', 'b', 'c', 'e', 'f']})
result = result.keys()
assert 6 not in result
@@ -191,27 +176,19 @@
# Test an 'and' search, ensuring that 'range' doesn't mess it up.
self._populateIndex()
- record = { 'foo' : { 'query' : [ 'e', 'f' ]
- , 'operator' : 'and'
- }
- }
- self._checkApply( record, self._values[6:7] )
+ record = {'foo': {'query': ['e', 'f'], 'operator': 'and'}}
+ self._checkApply(record, self._values[6:7])
- #
- # Make sure that 'and' tests with incompatible paramters
- # don't return empty sets.
- #
- record[ 'foo' ][ 'range' ] = 'min:max'
- self._checkApply( record, self._values[6:7] )
+ # Make sure that 'and' tests with incompatible parameters
+ # don't return empty sets.
+ record['foo']['range'] = 'min:max'
+ self._checkApply(record, self._values[6:7])
def testDuplicateKeywords(self):
- try:
- self._index.index_object(0, Dummy(['a', 'a', 'b', 'b']))
- self._index.unindex_object(0)
- finally:
- pass
+ self._index.index_object(0, Dummy(['a', 'a', 'b', 'b']))
+ self._index.unindex_object(0)
- def testCollectorIssue889(self) :
+ def testCollectorIssue889(self):
# Test that collector issue 889 is solved
values = self._values
nonexistent = 'foo-bar-baz'
@@ -220,22 +197,14 @@
result = self._index._index.get(nonexistent, self._marker)
assert result is self._marker
# patched _apply_index now works as expected
- record = {'foo' : { 'query' : [nonexistent]
- , 'operator' : 'and'}
- }
+ record = {'foo': {'query': [nonexistent], 'operator': 'and'}}
self._checkApply(record, [])
- record = {'foo' : { 'query' : [nonexistent, 'a']
- , 'operator' : 'and'}
- }
+ record = {'foo': {'query': [nonexistent, 'a'], 'operator': 'and'}}
# and does not break anything
self._checkApply(record, [])
- record = {'foo' : { 'query' : ['d']
- , 'operator' : 'and'}
- }
+ record = {'foo': {'query': ['d'], 'operator': 'and'}}
self._checkApply(record, values[4:5])
- record = {'foo' : { 'query' : ['a', 'e']
- , 'operator' : 'and'}
- }
+ record = {'foo': {'query': ['a', 'e'], 'operator': 'and'}}
self._checkApply(record, values[5:7])
def test_noindexing_when_noattribute(self):
@@ -274,5 +243,5 @@
def test_suite():
suite = unittest.TestSuite()
- suite.addTest( unittest.makeSuite( TestKeywordIndex ) )
+ suite.addTest(unittest.makeSuite(TestKeywordIndex))
return suite
More information about the checkins
mailing list