Prepare for using OrderedDict

setup.py

@@ -11,9 +11,17 @@ longdesc += codecs.open('LICENSE.rst', encoding='utf-8').read()
 
 
 tests_require = []
+install_requires = [
+    'setuptools',
+    'python-dateutil',
+    'pytz'
+]
+
 if sys.version_info[:2] == (2, 6):
     # Python unittest2 only needed for Python 2.6
-    tests_require = ['unittest2']
+    tests_require.append('unittest2')
+    # OrderedDict was added in 2.7
+    install_requires.append('ordereddict')
 
 
 setuptools.setup(
@@ -42,11 +50,7 @@ setuptools.setup(
     package_dir={'': 'src'},
     include_package_data=True,
     zip_safe=False,
-    install_requires=[
-        'setuptools',
-        'python-dateutil',
-        'pytz',
-    ],
+    install_requires=install_requires,
     extras_require={
         'test': tests_require
     }

src/icalendar/caselessdict.py

@@ -2,6 +2,11 @@
 from icalendar.parser_tools import to_unicode
 from icalendar.parser_tools import data_encode
 
+try:
+    from collections import OrderedDict
+except ImportError:
+    from ordereddict import OrderedDict
+
 
 def canonsort_keys(keys, canonical_order=None):
     """Sorts leading keys according to canonical_order.  Keys not specified in
@@ -28,47 +33,47 @@ class CaselessDict(dict):
     def __init__(self, *args, **kwargs):
         """Set keys to upper for initial dict.
         """
-        dict.__init__(self, *args, **kwargs)
+        super(CaselessDict, self).__init__(*args, **kwargs)
         for key, value in self.items():
             key_upper = to_unicode(key).upper()
             if key != key_upper:
-                dict.__delitem__(self, key)
+                super(CaselessDict, self).__delitem__(key)
                 self[key_upper] = value
 
     def __getitem__(self, key):
         key = to_unicode(key)
-        return dict.__getitem__(self, key.upper())
+        return super(CaselessDict, self).__getitem__(key.upper())
 
     def __setitem__(self, key, value):
         key = to_unicode(key)
-        dict.__setitem__(self, key.upper(), value)
+        super(CaselessDict, self).__setitem__(key.upper(), value)
 
     def __delitem__(self, key):
         key = to_unicode(key)
-        dict.__delitem__(self, key.upper())
+        super(CaselessDict, self).__delitem__(key.upper())
 
     def __contains__(self, key):
         key = to_unicode(key)
-        return dict.__contains__(self, key.upper())
+        return super(CaselessDict, self).__contains__(key.upper())
 
     def get(self, key, default=None):
         key = to_unicode(key)
-        return dict.get(self, key.upper(), default)
+        return super(CaselessDict, self).get(key.upper(), default)
 
     def setdefault(self, key, value=None):
         key = to_unicode(key)
-        return dict.setdefault(self, key.upper(), value)
+        return super(CaselessDict, self).setdefault(key.upper(), value)
 
     def pop(self, key, default=None):
         key = to_unicode(key)
-        return dict.pop(self, key.upper(), default)
+        return super(CaselessDict, self).pop(key.upper(), default)
 
     def popitem(self):
-        return dict.popitem(self)
+        return super(CaselessDict, self).popitem()
 
     def has_key(self, key):
         key = to_unicode(key)
-        return dict.__contains__(self, key.upper())
+        return super(CaselessDict, self).__contains__(key.upper())
 
     def update(self, indict):
         # Multiple keys where key1.upper() == key2.upper() will be lost.
@@ -76,7 +81,7 @@ class CaselessDict(dict):
             self[key] = value
 
     def copy(self):
-        return CaselessDict(dict.copy(self))
+        return type(self)(super(CaselessDict, self).copy())
 
     def __repr__(self):
         return 'CaselessDict(%s)' % data_encode(self)