[Checkins] SVN: BTrees/branches/pure_python/ Prefer '__contains__', w/ 'has_key' as alias.
Tres Seaver
cvs-admin at zope.org
Mon Nov 12 20:31:03 UTC 2012
Log message for revision 128260:
Prefer '__contains__', w/ 'has_key' as alias.
Remove moar 'else-after-return'.
Changed:
_U BTrees/branches/pure_python/
U BTrees/branches/pure_python/BTrees/_base.py
U BTrees/branches/pure_python/BTrees/tests/test__base.py
-=-
Modified: BTrees/branches/pure_python/BTrees/_base.py
===================================================================
--- BTrees/branches/pure_python/BTrees/_base.py 2012-11-12 18:37:29 UTC (rev 128259)
+++ BTrees/branches/pure_python/BTrees/_base.py 2012-11-12 20:31:03 UTC (rev 128260)
@@ -75,14 +75,13 @@
return self._keys[0]
key = self._to_key(key)
index = self._search(key)
- if index >- 0:
+ if index >= 0:
return key
+ index = -index - 1
+ if index < len(self._keys):
+ return self._keys[index]
else:
- index = -index - 1
- if index < len(self._keys):
- return self._keys[index]
- else:
- raise ValueError("no key satisfies the conditions")
+ raise ValueError("no key satisfies the conditions")
def maxKey(self, key=_marker):
if key is _marker:
@@ -140,13 +139,13 @@
def __iter__(self):
return iter(self._keys)
- def has_key(self, key):
- return (self._search(self._to_key(key)) >= 0) and 1
+ def __contains__(self, key):
+ return (self._search(self._to_key(key)) >= 0)
- __contains__ = has_key
+ has_key = __contains__
def _p_resolveConflict(self, *states):
- set = not hasattr(self, '_values')
+ is_set = getattr(self, '_values', None) is not None
buckets = []
for state in states:
@@ -171,7 +170,7 @@
result = self.__class__()
- if set:
+ if is_set:
def merge_output(it):
result._keys.append(it.key)
it.advance()
@@ -186,7 +185,7 @@
cmp13 = cmp(i1.key, i3.key)
if cmp12==0:
if cmp13==0:
- if set:
+ if is_set:
result.add(i1.key)
elif i2.value == i1.value:
result[i1.key] = i3.value
@@ -199,7 +198,7 @@
i3.advance()
elif (cmp13 > 0): # insert in new
merge_output(i3)
- elif set or i1.value == i2.value: # deleted new
+ elif is_set or i1.value == i2.value: # deleted new
if i3.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -212,7 +211,7 @@
elif cmp13 == 0:
if cmp12 > 0: # insert committed
merge_output(i2)
- elif set or i1.value == i3.value: # delete committed
+ elif is_set or i1.value == i3.value: # delete committed
if i2.position == 1:
# Deleted the first item. This will modify the
# parent node, so we don't know if merging will be
@@ -249,7 +248,7 @@
cmp12 = cmp(i1.key, i2.key)
if cmp12 > 0: # insert committed
merge_output(i2)
- elif cmp12 == 0 and (set or i1.value == i2.value): # deleted in new
+ elif cmp12 == 0 and (is_set or i1.value == i2.value): # del in new
i1.advance()
i2.advance()
else: # dueling deletes or delete and change
@@ -259,7 +258,7 @@
cmp13 = cmp(i1.key, i3.key)
if cmp13 > 0: # insert new
merge_output(i3)
- elif cmp13 == 0 and (set or i1.value == i3.value):
+ elif cmp13 == 0 and (is_set or i1.value == i3.value):
# deleted in committed
i1.advance()
i3.advance()
Modified: BTrees/branches/pure_python/BTrees/tests/test__base.py
===================================================================
--- BTrees/branches/pure_python/BTrees/tests/test__base.py 2012-11-12 18:37:29 UTC (rev 128259)
+++ BTrees/branches/pure_python/BTrees/tests/test__base.py 2012-11-12 20:31:03 UTC (rev 128260)
@@ -28,6 +28,7 @@
bucket = self._makeOne()
self.assertEqual(bucket._keys, [])
self.assertEqual(bucket._next, None)
+ self.assertEqual(len(bucket), 0)
self.assertEqual(bucket.size, 0)
def test__deleteNextBucket_none(self):
@@ -62,7 +63,299 @@
bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
self.assertEqual(bucket._search('charlie'), 2)
+ def test_minKey_empty(self):
+ bucket = self._makeOne()
+ self.assertRaises(IndexError, bucket.minKey)
+ def test_minKey_no_bound(self):
+ bucket = self._makeOne()
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.minKey(), 'alpha')
+
+ def test_minKey_w_bound_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.minKey('bravo'), 'bravo')
+
+ def test_minKey_w_bound_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.minKey('candy'), 'charlie')
+
+ def test_minKey_w_bound_fail(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertRaises(ValueError, bucket.minKey, 'foxtrot')
+
+ def test_maxKey_empty(self):
+ bucket = self._makeOne()
+ self.assertRaises(IndexError, bucket.maxKey)
+
+ def test_maxKey_no_bound(self):
+ bucket = self._makeOne()
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.maxKey(), 'echo')
+
+ def test_maxKey_w_bound_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.maxKey('bravo'), 'bravo')
+
+ def test_maxKey_w_bound_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.maxKey('candy'), 'bravo')
+
+ def test_maxKey_w_bound_fail(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertRaises(ValueError, bucket.maxKey, 'abacus')
+
+ def test__range_defaults_empty(self):
+ bucket = self._makeOne()
+ self.assertEqual(bucket._range(), (0, 0))
+
+ def test__range_defaults_filled(self):
+ bucket = self._makeOne()
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(), (0, 5))
+
+ def test__range_defaults_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(excludemin=True), (1, 5))
+
+ def test__range_defaults_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(excludemax=True), (0, 4))
+
+ def test__range_w_min_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(min='bravo'), (1, 5))
+
+ def test__range_w_min_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(min='candy'), (2, 5))
+
+ def test__range_w_min_hit_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(min='bravo', excludemin=True), (2, 5))
+
+ def test__range_w_min_miss_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemin' doesn't fire on miss
+ self.assertEqual(bucket._range(min='candy', excludemin=True), (2, 5))
+
+ def test__range_w_max_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(max='delta'), (0, 4))
+
+ def test__range_w_max_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(max='dandy'), (0, 3))
+
+ def test__range_w_max_hit_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket._range(max='delta', excludemax=True), (0, 3))
+
+ def test__range_w_max_miss_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemax' doesn't fire on miss
+ self.assertEqual(bucket._range(max='dandy', excludemax=True), (0, 3))
+
+ def test_keys_defaults_empty(self):
+ bucket = self._makeOne()
+ self.assertEqual(bucket.keys(), [])
+
+ def test_keys_defaults_filled(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(), KEYS[0: 5])
+
+ def test_keys_defaults_exclude_min(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(excludemin=True), KEYS[1: 5])
+
+ def test_keys_defaults_exclude_max(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(excludemax=True), KEYS[0: 4])
+
+ def test_keys_w_min_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(min='bravo'), KEYS[1: 5])
+
+ def test_keys_w_min_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(min='candy'), KEYS[2: 5])
+
+ def test_keys_w_min_hit_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(min='bravo', excludemin=True), KEYS[2: 5])
+
+ def test_keys_w_min_miss_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemin' doesn't fire on miss
+ self.assertEqual(bucket.keys(min='candy', excludemin=True), KEYS[2: 5])
+
+ def test_keys_w_max_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(max='delta'), KEYS[0: 4])
+
+ def test_keys_w_max_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(max='dandy'), KEYS[0: 3])
+
+ def test_keys_w_max_hit_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(bucket.keys(max='delta', excludemax=True), KEYS[0: 3])
+
+ def test_keys_w_max_miss_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemax' doesn't fire on miss
+ self.assertEqual(bucket.keys(max='dandy', excludemax=True), KEYS[0: 3])
+
+ def test_iterkeys_defaults_empty(self):
+ bucket = self._makeOne()
+ self.assertEqual(list(bucket.iterkeys()), [])
+
+ def test_iterkeys_defaults_filled(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys()), KEYS[0: 5])
+
+ def test_iterkeys_defaults_exclude_min(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(excludemin=True)), KEYS[1: 5])
+
+ def test_iterkeys_defaults_exclude_max(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(excludemax=True)), KEYS[0: 4])
+
+ def test_iterkeys_w_min_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(min='bravo')), KEYS[1: 5])
+
+ def test_iterkeys_w_min_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(min='candy')), KEYS[2: 5])
+
+ def test_iterkeys_w_min_hit_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(min='bravo', excludemin=True)),
+ KEYS[2: 5])
+
+ def test_iterkeys_w_min_miss_w_exclude_min(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemin' doesn't fire on miss
+ self.assertEqual(list(bucket.iterkeys(min='candy', excludemin=True)),
+ KEYS[2: 5])
+
+ def test_iterkeys_w_max_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(max='delta')), KEYS[0: 4])
+
+ def test_iterkeys_w_max_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.iterkeys(max='dandy')), KEYS[0: 3])
+
+ def test_iterkeys_w_max_hit_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual(list(bucket.keys(max='delta', excludemax=True)),
+ KEYS[0: 3])
+
+ def test_iterkeys_w_max_miss_w_exclude_max(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ # 'excludemax' doesn't fire on miss
+ self.assertEqual(list(bucket.iterkeys(max='dandy', excludemax=True)),
+ KEYS[0: 3])
+
+ def test___iter___empty(self):
+ bucket = self._makeOne()
+ self.assertEqual([x for x in bucket], [])
+
+ def test___iter___filled(self):
+ bucket = self._makeOne()
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertEqual([x for x in bucket], KEYS[0: 5])
+
+ def test___contains___empty(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ self.assertFalse('nonesuch' in bucket)
+
+ def test___contains___filled_miss(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ self.assertFalse('nonesuch' in bucket)
+
+ def test___contains___filled_hit(self):
+ bucket = self._makeOne()
+ bucket._to_key = lambda x: x
+ KEYS = bucket._keys = ['alpha', 'bravo', 'charlie', 'delta', 'echo']
+ for key in KEYS:
+ self.assertTrue(key in bucket)
+
+
def test_suite():
return unittest.TestSuite((
unittest.makeSuite(Test_BucketBase),
More information about the checkins
mailing list