Disabled deterministic __hash__ method and renamed it d_hash() + tests

lodel/editorial_model/components.py

@@ -30,13 +30,13 @@ class EmComponent(object):
             return str(self.uid)
         return str(self.display_name)
 
-    def __hash__(self):
+    def d_hash(self):
         m = hashlib.md5()
         for data in (
                         self.uid,
-                        str(hash(self.display_name)),
-                        str(hash(self.help_text)),
-                        str(hash(self.group)),
+                        'NODISPNAME' if self.display_name is None else str(self.display_name.d_hash()),
+                        'NOHELP' if self.help_text is None else str(self.help_text.d_hash()),
+                        'NOGROUP' if self.group is None else str(self.group.d_hash()),
         ):
             m.update(bytes(data, 'utf-8'))
         return int.from_bytes(m.digest(), byteorder='big')
@@ -105,11 +105,11 @@ class EmClass(EmComponent):
     def new_field(self, uid, **field_kwargs):
         return self.add_field(EmField(uid, **field_kwargs))
 
-    def __hash__(self):
+    def d_hash(self):
         m = hashlib.md5()
-        payload = str(super().__hash__()) + "1" if self.abstract else "0"
+        payload = str(super().d_hash()) + ("1" if self.abstract else "0")
         for p in sorted(self.parents):
-            payload += str(hash(p))
+            payload += str(p.d_hash())
         m.update(bytes(payload, 'utf-8'))
         return int.from_bytes(m.digest(), byteorder='big')
 
@@ -133,11 +133,11 @@ class EmField(EmComponent):
 
     ## @warning Not complete !
     # @todo Complete the hash when data handlers becomes available
-    def __hash__(self):
+    def d_hash(self):
         return int.from_bytes(hashlib.md5(
                         bytes(
-                                "%s%s" % (  super().__hash__(),
-                                            hash(self.data_handler)), 
+                                "%s%s" % (  super().d_hash(),
+                                            self.data_handler), 
                                 'utf-8')
         ).digest(), byteorder='big')
 
@@ -224,13 +224,13 @@ class EmGroup(object):
         else:
             return self.display_name.get()
 
-    def __hash__(self):
+    def d_hash(self):
         
         payload = "%s%s%s" % (self.uid, hash(self.display_name), hash(self.help_text))
         for recurs in (False, True):
             deps = self.dependencies(recurs)
             for dep_uid in sorted(deps.keys()):
-                payload += str(hash(deps[dep_uid]))
+                payload += str(deps[dep_uid].d_hash())
         for req_by_uid in self.required_by:
             payload += req_by_uid
         return int.from_bytes(

lodel/editorial_model/model.py

@@ -90,13 +90,14 @@ class EditorialModel(object):
     # @see classes() groups()
     def __elt_getter(self, elts, uid):
         return iter(elts.values()) if uid is None else elts[uid]
-
-    def __hash__(self):
+    
+    ## @brief Lodel hash
+    def d_hash(self):
         payload = "%s%s" % (self.name,hash(self.description))
         for guid in sorted(self.__groups):
-            payload += str(hash(self.__groups[guid]))
+            payload += str(self.__groups[guid].d_hash())
         for cuid in sorted(self.__classes):
-            payload += str(hash(self.__classes[cuid]))
+            payload += str(self.__classes[cuid].d_hash())
         return int.from_bytes(
                                 hashlib.md5(bytes(payload, 'utf-8')).digest(),
                                 byteorder='big'

lodel/utils/mlstring.py

@@ -80,6 +80,12 @@ class MlString(object):
         return MlString(json.loads(json_str))
 
     def __hash__(self):
+        res = ''
+        for lang in sorted(list(self.values.keys())):
+            res = hash((res, lang, self.values[lang]))
+        return res
+
+    def d_hash(self):
         m = hashlib.md5()
         for lang in sorted(list(self.values.keys())):
             m.update(bytes(lang+";"+self.values[lang], 'utf-8'))

tests/editorial_model/test_translator_picklefile.py

@@ -0,0 +1,43 @@
+#-*- coding: utf-8 -*-
+
+import unittest
+import tempfile
+import os
+
+from lodel.editorial_model.translator import picklefile
+from lodel.editorial_model.model import EditorialModel
+from lodel.editorial_model.components import *
+from lodel.editorial_model.exceptions import *
+
+class PickleFileTestCase(unittest.TestCase):
+    
+    def test_save(self):
+        model = EditorialModel("test model", description = "Test EM")
+        cls1 = model.new_class('testclass1', display_name = 'Classe de test 1', help_text = 'super aide')
+        c1f1 = cls1.new_field('testfield1', data_handler = None)
+        c1f2 = cls1.new_field('testfield2', data_handler = None)
+        cls2 = model.new_class('testclass2')
+        c2f1 = cls2.new_field('testfield1', data_handler = None)
+        c2f2 = cls2.new_field('testfield2', data_handler = None)
+
+        grp1 = model.new_group('testgroup1')
+        grp1.add_components((cls1, c1f1))
+        grp2 = model.new_group('testgroup2')
+        grp2.add_components((cls2, c1f2, c2f1, c2f2))
+
+        grp2.add_dependencie(grp1)
+        
+        tmpfd, temp_file = tempfile.mkstemp()
+        os.close(tmpfd)
+        os.unlink(temp_file)
+
+        model.save(picklefile, filename=temp_file)
+        new_model = model.load(picklefile, filename=temp_file)
+
+        self.assertNotEqual(id(new_model), id(model))
+        self.assertEqual(new_model.d_hash(), model.d_hash())
+
+        os.unlink(temp_file)
+
+
+

tests/test_utils_mlstrings.py

@@ -81,7 +81,7 @@ class MlStringTestCase(unittest.TestCase):
         self.assertNotEqual(hash(mls1), hash(mls2))
 
 
-    def test_hash(self):
+    def test_d_hash(self):
         """ Test if the hash method is deterministic """
         mls1 = MlString('Hello world !')
-        self.assertEqual(hash(mls1),1631096711380631894)
+        self.assertEqual(mls1.d_hash(),305033383450738439650269714534939972534)