Move hash_from_dict and make it better support OrderedDict

theano/gof/tests/test_utils.py

 import theano
-from theano.gof.utils import give_variables_names, unique, remove
+from theano.compat import OrderedDict
+from theano.gof.utils import (
+    give_variables_names, hash_from_dict, remove, unique)
 
 
 def test_give_variables_names():
@@ -44,3 +46,20 @@ def test_remove():
     # The list are needed as with python 3, remove and filter return generators
     # and we can't compare generators.
     assert list(remove(even, range(5))) == list(filter(odd, range(5)))
+
+
+def test_hash_from_dict():
+    dicts = [{}, {0: 0}, {0: 1}, {1: 0}, {1: 1},
+             {0: (0,)}, {0: [1]},
+             {0: (0, 1)}, {0: [1, 0]},
+         ]
+    for elem in dicts[:]:
+        dicts.append(OrderedDict(elem))
+    hashs = []
+    for idx, d in enumerate(dicts):
+        h = hash_from_dict(d)
+        assert h not in hashs
+        hashs.append(h)
+
+    # List are not hashable. So they are transformed into tuple.
+    assert hash_from_dict({0: (0,)}) == hash_from_dict({0: [0]})

theano/gof/utils.py

@@ -7,7 +7,7 @@ import numpy
 from six import iteritems
 
 from theano import config
-from theano.compat import PY3
+from theano.compat import OrderedDict, PY3
 
 
 def simple_extract_stack(f=None, limit=None):
@@ -465,3 +465,34 @@ else:
 def hash_from_file(file_path):
     """Return the MD5 hash of a file."""
     return hash_from_code(open(file_path, 'rb').read())
+
+
+def hash_from_dict(d):
+    """Work around the fact that dict are not hashable in python
+
+    This request that all object have a sorted order that depend only
+    on the value of the object. This is true for integer/float/string
+
+    We do not verify that the objects in the dict have this property.
+
+    Also, we transform values that are list into tuple as list are not
+    hashable.
+
+    :note: special case for OrderedDict, it use the order of the dict,
+        so the key don't need to be sortable.
+
+    """
+    if isinstance(d, OrderedDict):
+        items = list(d.iteritems())
+    else:
+        items = list(d.items())
+        items.sort()
+    first_part = [k for k, v in items]
+    second_part = []
+    for k, v in items:
+        if isinstance(v, (tuple, list)):
+            second_part += [tuple(v)]
+        else:
+            second_part += [v]
+    tuple_items = tuple(first_part + second_part + [d.__class__])
+    return hash(tuple_items)

theano/misc/pycuda_example.py

@@ -27,11 +27,11 @@ import theano
 from six.moves import xrange
 from theano.compat import izip
 from theano.gof import Op, Apply, local_optimizer, EquilibriumDB
+from theano.gof.utils import hash_from_dict
 from theano.sandbox.cuda import GpuElemwise, CudaNdarrayType, GpuOp
 from theano.sandbox.cuda.basic_ops import (as_cuda_ndarray_variable,
                                            gpu_contiguous)
 from theano.sandbox.cuda.opt import gpu_seqopt
-from theano.tensor.utils import hash_from_dict
 
 from . import pycuda_init
 if not pycuda_init.pycuda_available:

theano/tensor/elemwise.py

@@ -13,9 +13,9 @@ from theano.gof import Apply, Op, OpenMPOp
 from theano import scalar
 from theano.scalar import get_scalar_type
 from theano.printing import pprint
-from theano.tensor.utils import hash_from_dict
 from theano.gradient import DisconnectedType
 from theano.gof.null_type import NullType
+from theano.gof.utils import hash_from_dict
 from theano.tensor import elemwise_cgen as cgen
 
 config = theano.config

theano/tensor/tests/test_utils.py

@@ -3,8 +3,7 @@ import unittest
 import numpy
 
 import theano
-from theano.tensor.utils import (hash_from_ndarray, hash_from_dict,
-                                 shape_of_variables)
+from theano.tensor.utils import (hash_from_ndarray, shape_of_variables)
 
 
 def test_hash_from_ndarray():
@@ -37,21 +36,6 @@ def test_hash_from_ndarray():
     assert hash_from_ndarray(rng[::-1]) == hash_from_ndarray(rng[::-1].copy())
 
 
-def test_hash_from_dict():
-    dicts = [{}, {0: 0}, {0: 1}, {1: 0}, {1: 1},
-             {0: (0,)}, {0: [1]},
-             {0: (0, 1)}, {0: [1, 0]},
-         ]
-    hashs = []
-    for idx, d in enumerate(dicts):
-        h = hash_from_dict(d)
-        assert h not in hashs
-        hashs.append(h)
-
-    # List are not hashable. So they are transformed into tuple.
-    assert hash_from_dict({0: (0,)}) == hash_from_dict({0: [0]})
-
-
 class Tshape_of_variables(unittest.TestCase):
     def test_simple(self):
         x = theano.tensor.matrix('x')

theano/tensor/utils.py

@@ -30,31 +30,6 @@ def hash_from_ndarray(data):
                           hash_from_code(str(data.dtype)))
 
 
-def hash_from_dict(d):
-    """Work around the fact that dict are not hashable in python
-
-    This request that all object have a sorted order that depend only
-    on the value of the object. This is true for integer/float/string
-
-    We do not verify that the objects in the dict have this property.
-
-    Also, we transform values that are list into tuple as list are not
-    hashable.
-
-    """
-    items = list(d.items())
-    items.sort()
-    first_part = [k for k, v in items]
-    second_part = []
-    for k, v in items:
-        if isinstance(v, (tuple, list)):
-            second_part += [tuple(v)]
-        else:
-            second_part += [v]
-    tuple_items = tuple(first_part + second_part)
-    return hash(tuple_items)
-
-
 def shape_of_variables(fgraph, input_shapes):
     """
     Compute the numeric shape of all intermediate variables given input shapes