diff --git a/linkcheck/containers.py b/linkcheck/containers.py index 2e8706b7..e17d0290 100644 --- a/linkcheck/containers.py +++ b/linkcheck/containers.py @@ -18,86 +18,6 @@ Special container classes. """ -from collections import namedtuple -from past.builtins import basestring - -class AttrDict (dict): - """Dictionary allowing attribute access to its elements if they - are valid attribute names and not already existing methods.""" - - def __getattr__ (self, name): - """Return attribute name from dict.""" - return self[name] - - -class CaselessDict (dict): - """A dictionary ignoring the case of keys (which must be strings).""" - - def __getitem__ (self, key): - """Return lowercase key item.""" - assert isinstance(key, basestring) - return dict.__getitem__(self, key.lower()) - - def __delitem__ (self, key): - """Remove lowercase key item.""" - assert isinstance(key, basestring) - return dict.__delitem__(self, key.lower()) - - def __setitem__ (self, key, value): - """Set lowercase key item.""" - assert isinstance(key, basestring) - dict.__setitem__(self, key.lower(), value) - - def __contains__ (self, key): - """Check lowercase key item.""" - assert isinstance(key, basestring) - return dict.__contains__(self, key.lower()) - - def get (self, key, def_val=None): - """Return lowercase key value.""" - assert isinstance(key, basestring) - return dict.get(self, key.lower(), def_val) - - def setdefault (self, key, *args): - """Set lowercase key value and return.""" - assert isinstance(key, basestring) - return dict.setdefault(self, key.lower(), *args) - - def update (self, other): - """Update this dict with lowercase key from other dict""" - for k, v in other.items(): - dict.__setitem__(self, k.lower(), v) - - def fromkeys (cls, iterable, value=None): - """Construct new caseless dict from given data.""" - d = cls() - for k in iterable: - dict.__setitem__(d, k.lower(), value) - return d - fromkeys = classmethod(fromkeys) - - def pop (self, key, *args): - """Remove lowercase key from dict and return value.""" - assert isinstance(key, basestring) - return dict.pop(self, key.lower(), *args) - - -class CaselessSortedDict (CaselessDict): - """Caseless dictionary with sorted keys.""" - - def keys (self): - """Return sorted key list.""" - return sorted(super(CaselessSortedDict, self).keys()) - - def items (self): - """Return sorted item list.""" - return [(x, self[x]) for x in self.keys()] - - def iteritems (self): - """Return sorted item iterator.""" - return ((x, self[x]) for x in self.keys()) - - class LFUCache (dict): """Limited cache which purges least frequently used items.""" @@ -182,18 +102,3 @@ class LFUCache (dict): """Remove and return a value.""" value = super(LFUCache, self).pop() return value[1] - - -def enum (*names): - """Return an enum datatype instance from given list of keyword names. - The enum values are zero-based integers. - - >>> Status = enum('open', 'pending', 'closed') - >>> Status.open - 0 - >>> Status.pending - 1 - >>> Status.closed - 2 - """ - return namedtuple('Enum', ' '.join(names))(*range(len(names))) diff --git a/tests/test_containers.py b/tests/test_containers.py index a90c8f10..0d119b48 100644 --- a/tests/test_containers.py +++ b/tests/test_containers.py @@ -24,130 +24,6 @@ import linkcheck.containers from builtins import range -class TestAttrDict (unittest.TestCase): - - def setUp (self): - self.d = linkcheck.containers.AttrDict() - - def test_access (self): - self.d["test"] = 1 - self.assertEqual(self.d.test, self.d["test"]) - self.assertEqual(self.d.test, 1) - - def test_method (self): - self.d["get"] = 1 - self.assertTrue(isinstance(self.d.get, type({}.get))) - - -class TestCaselessDict (unittest.TestCase): - """Test caseless dictionary routines.""" - - def setUp (self): - """Set up self.d as empty caseless dict.""" - self.d = linkcheck.containers.CaselessDict() - - def test_insert (self): - self.assertTrue(not self.d) - self.d["a"] = 1 - self.assertTrue("a" in self.d) - self.assertTrue("A" in self.d) - self.d["aBcD"] = 2 - self.assertTrue("abcd" in self.d) - self.assertTrue("Abcd" in self.d) - self.assertTrue("ABCD" in self.d) - - def test_delete (self): - self.assertTrue(not self.d) - self.d["a"] = 1 - del self.d["A"] - self.assertTrue("a" not in self.d) - self.assertTrue("A" not in self.d) - - def test_update (self): - self.assertTrue(not self.d) - self.d["a"] = 1 - self.d["A"] = 2 - self.assertEqual(self.d["a"], 2) - - def test_clear (self): - self.assertTrue(not self.d) - self.d["a"] = 5 - self.d["b"] = 6 - self.d.clear() - self.assertTrue(not self.d) - - def test_containment (self): - self.assertTrue(not self.d) - self.assertTrue("A" not in self.d) - self.assertTrue("a" not in self.d) - self.d["a"] = 5 - self.assertTrue("A" in self.d) - self.assertTrue("a" in self.d) - - def test_setdefault (self): - self.assertTrue(not self.d) - self.d["a"] = 5 - self.assertEqual(self.d.setdefault("A", 6), 5) - self.assertEqual(self.d.setdefault("b", 7), 7) - - def test_get (self): - self.assertTrue(not self.d) - self.d["a"] = 42 - self.assertEqual(self.d.get("A"), 42) - self.assertTrue(self.d.get("B") is None) - - def test_update2 (self): - self.assertTrue(not self.d) - self.d["a"] = 42 - self.d.update({"A": 43}) - self.assertEqual(self.d["a"], 43) - - def test_fromkeys (self): - self.assertTrue(not self.d) - keys = ["a", "A", "b", "C"] - d1 = self.d.fromkeys(keys, 42) - for key in keys: - self.assertEqual(d1[key], 42) - - def test_pop (self): - self.assertTrue(not self.d) - self.d["a"] = 42 - self.assertEqual(self.d.pop("A"), 42) - self.assertTrue(not self.d) - self.assertRaises(KeyError, self.d.pop, "A") - - def test_popitem (self): - self.assertTrue(not self.d) - self.d["a"] = 42 - self.assertEqual(self.d.popitem(), ("a", 42)) - self.assertTrue(not self.d) - self.assertRaises(KeyError, self.d.popitem) - - -class TestCaselessSortedDict (unittest.TestCase): - """Test caseless sorted dictionary routines.""" - - def setUp (self): - """Set up self.d as empty caseless sorted dict.""" - self.d = linkcheck.containers.CaselessSortedDict() - - def test_sorted (self): - self.assertTrue(not self.d) - self.d["b"] = 6 - self.d["a"] = 7 - self.d["C"] = 8 - prev = None - for key in self.d.keys(): - if prev is not None: - self.assertTrue(key > prev) - prev = key - prev = None - for key, value in self.d.items(): - self.assertEqual(value, self.d[key]) - if prev is not None: - self.assertTrue(key > prev) - prev = key - class TestLFUCache (unittest.TestCase): """Test LFU cache implementation.""" @@ -185,13 +61,3 @@ class TestLFUCache (unittest.TestCase): self.d[i] = i self.d[1001] = 1001 self.assertTrue(950 <= len(self.d) <= self.size) - - -class TestEnum (unittest.TestCase): - - def test_enum (self): - e = linkcheck.containers.enum("a", "b", "c") - self.assertEqual(e.a, 0) - self.assertEqual(e.b, 1) - self.assertEqual(e.c, 2) - self.assertEqual(e, (0, 1, 2))