Implements deterministic __hash__ methods for objects

lodel/editorial_model/components.py

 import itertools
 import warnings
 import copy
+import hashlib
 
 from lodel.utils.mlstring import MlString
 
             return str(self.uid)
         return str(self.display_name)
 
+    def __hash__(self):
+        m = hashlib.md5()
+        for data in (
+                        self.uid,
+                        str(hash(self.display_name)),
+                        str(hash(self.help_text)),
+                        str(hash(self.group)),
+        ):
+            m.update(bytes(data, 'utf-8'))
+        return int.from_bytes(m.digest(), byteorder='big')
+
+
 ## @brief Handles editorial model objects classes
 #
 # @note The inheritance system allow child classes to overwrite parents EmField. But it's maybe not a good idea
             raise EditorialModelException("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
         self.__fields[emfield.uid] = emfield
         emfield._emclass = self
+        return emfield
     
     ## @brief Create a new EmField and add it to the EmClass
     # @param uid str : the EmField uniq id
     def new_field(self, uid, **field_kwargs):
         return self.add_field(EmField(uid, **field_kwargs))
 
+    def __hash__(self):
+        m = hashlib.md5()
+        payload = str(super().__hash__()) + "1" if self.abstract else "0"
+        for p in sorted(self.parents):
+            payload += str(hash(p))
+        m.update(bytes(payload, 'utf-8'))
+        return int.from_bytes(m.digest(), byteorder='big')
+
 
 ## @brief Handles editorial model classes fields
 class EmField(EmComponent):
         ## @brief Stores the emclass that contains this field (set by EmClass.add_field() method)
         self._emclass = None
 
+    ## @warning Not complete !
+    # @todo Complete the hash when data handlers becomes available
+    def __hash__(self):
+        return int.from_bytes(hashlib.md5(
+                        bytes(
+                                "%s%s" % (  super().__hash__(),
+                                            hash(self.data_handler)), 
+                                'utf-8')
+        ).digest(), byteorder='big')
+
 
 ## @brief Handles functionnal group of EmComponents
 class EmGroup(object):
     def __circular_dependencie(self, new_dep):
         return self.uid in new_dep.dependencies(True)
 
+    ## @brief Fancy string representation of an EmGroup
+    # @return a string
     def __str__(self):
-        return "<class EmGroup '%s'>" % self.uid
+        if self.display_name is None:
+            return self.uid
+        else:
+            return self.display_name.get()
+
+    def __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]))
+        for req_by_uid in self.required_by:
+            payload += req_by_uid
+        return int.from_bytes(
+                                bytes(payload, 'utf-8'),
+                                byteorder = 'big'
+        )
     
-    ## @todo better implementation
+    ## @brief Complete string representation of an EmGroup
+    # @return a string
     def __repr__(self):
-        return self.__str__()
+        return "<class EmGroup '%s' depends : [%s]>" % (self.uid, ', '.join([duid for duid in self.dependencies(False)]) )

lodel/editorial_model/model.py

 #-*- coding:utf-8 -*-
+
+import hashlib
+
 from lodel.utils.mlstring import MlString
 
 from lodel.editorial_model.exceptions import *
-from lodel.editorial_model.components import EmClass, EmField
+from lodel.editorial_model.components import EmClass, EmField, EmGroup
 
 ## @brief Describe an editorial model
 class EditorialModel(object):
     # @return if uid given return an EmClass else return an EmClass iterator
     def classes(self, uid = None):
         try:
-            return __elt_getter(self.__classes)
+            return self.__elt_getter(self.__classes, uid)
         except KeyError:
             raise EditorialModelException("EmClass not found : '%s'" % uid)
 
     # @return if uid given return an EmGroup else return an EmGroup iterator
     def groups(self, uid = None):
         try:
-            return __elt_getter(self.__groups)
+            return self.__elt_getter(self.__groups, uid)
         except KeyError:
             raise EditorialModelException("EmGroup not found : '%s'" % uid)
 
     ## @brief Add a class to the editorial model
     # @param emclass EmClass : the EmClass instance to add
+    # @return emclass
     def add_class(self, emclass):
         if not isinstance(emclass, EmClass):
             raise ValueError("<class EmClass> expected but got %s " % type(emclass))
-        if emclass.uid in self.classes:
+        if emclass.uid in self.classes():
             raise EditorialModelException('Duplicated uid "%s"' % emclass.uid)
         self.__classes[emclass.uid] = emclass
+        return emclass
+
+    ## @brief Add a group to the editorial model
+    # @param emgroup EmGroup : the EmGroup instance to add
+    # @return emgroup
+    def add_group(self, emgroup):
+        if not isinstance(emgroup, EmGroup):
+            raise ValueError("<class EmGroup> expected but got %s" % type(emgroup))
+        if emgroup.uid in self.groups():
+            raise EditorialModelException('Duplicated uid "%s"' % emgroup.uid)
+        self.__groups[emgroup.uid] = emgroup
+        return emgroup
 
     ## @brief Add a new EmClass to the editorial model
     # @param uid str : EmClass uid
     # @param **kwargs : EmClass constructor options ( see @ref lodel.editorial_model.component.EmClass.__init__() )
     def new_class(self, uid, **kwargs):
         return self.add_class(EmClass(uid, **kwargs))
+    
+    ## @brief Add a new EmGroup to the editorial model
+    # @param uid str : EmGroup uid
+    # @param *kwargs : EmGroup constructor keywords arguments (see @ref lodel.editorial_model.component.EmGroup.__init__() )
+    def new_group(self, uid, **kwargs):
+        return self.add_group(EmGroup(uid, **kwargs))
 
     # @brief Save a model
     # @param translator module : The translator module to use
     # @param **translator_args
-    def save(self, translator, **translator_args):
-        return translator.save(self, **kwargs)
+    def save(self, translator, **translator_kwargs):
+        return translator.save(self, **translator_kwargs)
     
     ## @brief Load a model
     # @param translator module : The translator module to use
     # @param **translator_args
     @classmethod
-    def load(cls, translator, **translator_args):
-        return translator.load(**kwargs)
+    def load(cls, translator, **translator_kwargs):
+        return translator.load(**translator_kwargs)
     
     ## @brief Private getter for __groups or __classes
     # @see classes() groups()
     def __elt_getter(self, elts, uid):
-        return iter(elts.values) if uid is None else elts[uid]
+        return iter(elts.values()) if uid is None else elts[uid]
+
+    def __hash__(self):
+        payload = "%s%s" % (self.name,hash(self.description))
+        for guid in sorted(self.__groups):
+            payload += str(hash(self.__groups[guid]))
+        for cuid in sorted(self.__classes):
+            payload += str(hash(self.__classes[cuid]))
+        return int.from_bytes(
+                                hashlib.md5(bytes(payload, 'utf-8')).digest(),
+                                byteorder='big'
+        )
 

lodel/editorial_model/translator/picklefile.py

 #-*- coding: utf-8 -*-
 
 import pickle
+from pickle import Pickler
 
 ## @brief Save a model in a file
 # @param model EditorialModel : the model to save
 # @param filename str|None : if None return the model as pickle bytes
 # @return None if filename is a string, else returns bytes representation of model
-def save(self, model, filename = None):
-    with open(filename, 'w+') as ffd:
+def save(model, filename = None):
+    with open(filename, 'w+b') as ffd:
         pickle.dump(model, ffd)
     return filename
 
 ## @brief Load a model from a file
 # @param filename str : the filename to use to load the model
-def load(self, filename):
-    with open(filename, 'r') as ffd:
+def load(filename):
+    with open(filename, 'rb') as ffd:
         edmod = pickle.load(ffd)
     return edmod

lodel/utils/mlstring.py

 #-*- coding: utf-8 -*-
 
+import hashlib
 import copy
 import json
 
             raise ValueError('<class str>, <class dict> or <class MlString> expected, but %s found' % type(arg))
     
     ## @brief Return a translation given a lang
-    # @param lang str
-    def get(self, lang):
+    # @param lang str | None : If None return default lang translation
+    def get(self, lang = None):
+        lang = self.__default_lang if lang is None else lang
         if not self.lang_is_valid(lang):
             raise ValueError("Invalid lang : '%s'" % lang)
         elif lang in self.values:
         return MlString(json.loads(json_str))
 
     def __hash__(self):
-        res = ''
+        m = hashlib.md5()
         for lang in sorted(list(self.values.keys())):
-            res = hash((res, lang, self.values[lang]))
-        return res
+            m.update(bytes(lang+";"+self.values[lang], 'utf-8'))
+        return int.from_bytes(m.digest(), byteorder='big')
 
     def __eq__(self, a):
         return hash(self) == hash(a)