From b993c64c48a864882b67f58e87608544f202c978 Mon Sep 17 00:00:00 2001
From: Luke Campagnola <luke.campagnola@gmail.com>
Date: Fri, 18 Oct 2013 09:46:48 -0400
Subject: [PATCH] Workaround for OrderedDict bug: import from 'ordereddict'
 backport module if available

---
 pyqtgraph/pgcollections.py | 137 +++++++++++++++++++------------------
 1 file changed, 71 insertions(+), 66 deletions(-)

diff --git a/pyqtgraph/pgcollections.py b/pyqtgraph/pgcollections.py
index b0198526..4de1b7d0 100644
--- a/pyqtgraph/pgcollections.py
+++ b/pyqtgraph/pgcollections.py
@@ -15,74 +15,79 @@ import threading, sys, copy, collections
 
 try:
     from collections import OrderedDict
-except:
-    # Deprecated; this class is now present in Python 2.7 as collections.OrderedDict
-    # Only keeping this around for python2.6 support.
-    class OrderedDict(dict):
-        """extends dict so that elements are iterated in the order that they were added.
-        Since this class can not be instantiated with regular dict notation, it instead uses
-        a list of tuples: 
-        od = OrderedDict([(key1, value1), (key2, value2), ...])
-        items set using __setattr__ are added to the end of the key list.
-        """
-        
-        def __init__(self, data=None):
-            self.order = []
-            if data is not None:
-                for i in data:
-                    self[i[0]] = i[1]
-        
-        def __setitem__(self, k, v):
-            if not self.has_key(k):
-                self.order.append(k)
-            dict.__setitem__(self, k, v)
-        
-        def __delitem__(self, k):
-            self.order.remove(k)
-            dict.__delitem__(self, k)
-
-        def keys(self):
-            return self.order[:]
-        
-        def items(self):
-            it = []
-            for k in self.keys():
-                it.append((k, self[k]))
-            return it
-        
-        def values(self):
-            return [self[k] for k in self.order]
-        
-        def remove(self, key):
-            del self[key]
-            #self.order.remove(key)
-        
-        def __iter__(self):
-            for k in self.order:
-                yield k
-                
-        def update(self, data):
-            """Works like dict.update, but accepts list-of-tuples as well as dict."""
-            if isinstance(data, dict):
-                for k, v in data.iteritems():
-                    self[k] = v
-            else:
-                for k,v in data:
-                    self[k] = v
-
-        def copy(self):
-            return OrderedDict(self.items())
+except ImportError:
+    # fallback: try to use the ordereddict backport when using python 2.6
+    try:
+        from ordereddict import OrderedDict
+    except ImportError:
+        # backport not installed: use local OrderedDict
+        # Deprecated; this class is now present in Python 2.7 as collections.OrderedDict
+        # Only keeping this around for python2.6 support.
+        class OrderedDict(dict):
+            """extends dict so that elements are iterated in the order that they were added.
+            Since this class can not be instantiated with regular dict notation, it instead uses
+            a list of tuples: 
+            od = OrderedDict([(key1, value1), (key2, value2), ...])
+            items set using __setattr__ are added to the end of the key list.
+            """
             
-        def itervalues(self):
-            for k in self.order:
-                yield self[k]
+            def __init__(self, data=None):
+                self.order = []
+                if data is not None:
+                    for i in data:
+                        self[i[0]] = i[1]
+            
+            def __setitem__(self, k, v):
+                if not self.has_key(k):
+                    self.order.append(k)
+                dict.__setitem__(self, k, v)
+            
+            def __delitem__(self, k):
+                self.order.remove(k)
+                dict.__delitem__(self, k)
+
+            def keys(self):
+                return self.order[:]
+            
+            def items(self):
+                it = []
+                for k in self.keys():
+                    it.append((k, self[k]))
+                return it
+            
+            def values(self):
+                return [self[k] for k in self.order]
+            
+            def remove(self, key):
+                del self[key]
+                #self.order.remove(key)
+            
+            def __iter__(self):
+                for k in self.order:
+                    yield k
+                    
+            def update(self, data):
+                """Works like dict.update, but accepts list-of-tuples as well as dict."""
+                if isinstance(data, dict):
+                    for k, v in data.iteritems():
+                        self[k] = v
+                else:
+                    for k,v in data:
+                        self[k] = v
+
+            def copy(self):
+                return OrderedDict(self.items())
                 
-        def iteritems(self):
-            for k in self.order:
-                yield (k, self[k])
-                
-        def __deepcopy__(self, memo):
-            return OrderedDict([(k, copy.deepcopy(v, memo)) for k, v in self.iteritems()])
+            def itervalues(self):
+                for k in self.order:
+                    yield self[k]
+                    
+            def iteritems(self):
+                for k in self.order:
+                    yield (k, self[k])
+                    
+            def __deepcopy__(self, memo):
+                return OrderedDict([(k, copy.deepcopy(v, memo)) for k, v in self.iteritems()])