Begin editorial_model package implementation + tests

lodel/editorial_model/component.py

@@ -0,0 +1,105 @@
+#-*- coding: utf-8 -*-
+
+import itertools
+
+from lodel.utils.mlstring import MlString
+
+from lodel.editorial_model.exceptions import *
+
+## @brief Abstract class to represent editorial model components
+# @see EmClass EmField
+class EmComponent(object):
+    
+    ## @brief Instanciate an EmComponent
+    # @param uid str : uniq identifier
+    # @param display_name MlString|str|dict : component display_name
+    # @param help_text MlString|str|dict : help_text
+    def __init__(self, uid, display_name = None, help_text = None, group = None):
+        if self.__class__ == EmComponent:
+            raise NotImplementedError('EmComponent is an abstract class')
+        self.uid = uid
+        self.display_name = None if display_name is None else MlString(display_name)
+        self.help_text = None if help_text is None else MlString(help_text)
+        self.group = group
+    
+    def __str__(self):
+        if self.display_name is None:
+            return str(self.uid)
+        return str(self.display_name)
+
+## @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
+class EmClass(EmComponent):
+    
+    ## @brief Instanciate a new EmClass
+    # @param uid str : uniq identifier
+    # @param display_name MlString|str|dict : component display_name
+    # @param abstract bool : set the class as asbtract if True
+    # @param parents list: parent EmClass list or uid list
+    # @param help_text MlString|str|dict : help_text
+    def __init__(self, uid, display_name = None, help_text = None, abstract = False, parents = None, group = None):
+        super().__init__(uid, display_name, help_text, group)
+        self.abstract = bool(abstract)
+        if parents is not None:
+            if not isinstance(parents, list):
+                parents = [parents]
+            for parent in parents:
+                if not isinstance(parent, EmClass):
+                    raise ValueError("<class EmClass> expected in parents list, but %s found" % type(parent))
+        self.parents = parents
+        ## @brief Stores EmFields instances indexed by field uid
+        self.__fields = dict() 
+    
+    ## @brief Property that represent a dict of all fields (the EmField defined in this class and all its parents)
+    @property
+    def __all_fields(self):
+        res = dict()
+        for pfields in [ p.__all_fields for p in self.parents]:
+            res.update(pfields)
+        res.update(self.__fields)
+        return res
+
+    ## @brief EmField getter
+    # @param uid None | str : If None returns an iterator on EmField instances else return an EmField instance
+    # @param no_parents bool : If True returns only fields defined is this class and not the one defined in parents classes
+    # @return An iterator on EmFields instances (if uid is None) else return an EmField instance
+    def fields(self, uid = None, no_parents = False):
+        fields = self.__fields if no_parents else self.__all_fields
+        try:
+            return iter(fields.values()) if uid is None else fields[uid]
+        except KeyError:
+            raise EditorialModelError("No such EmField '%s'" % uid)
+
+    ## @brief Add a field to the EmClass
+    # @param emfield EmField : an EmField instance
+    # @warning do not add an EmField allready in another class !
+    # @throw EditorialModelException if an EmField with same uid allready in this EmClass (overwritting allowed from parents)
+    def add_field(self, emfield):
+        if emfield.uid in self.__fields:
+            raise EditorialModelException("Duplicated uid '%s' for EmField in this class ( %s )" % (emfield.uid, self))
+        self.__fields[emfield.uid] = emfield
+    
+    ## @brief Create a new EmField and add it to the EmClass
+    # @param uid str : the EmField uniq id
+    # @param **field_kwargs :  EmField constructor parameters ( see @ref EmField.__init__() ) 
+    def new_field(self, uid, **field_kwargs):
+        return self.add_field(EmField(uid, **kwargs))
+
+
+## @brief Handles editorial model classes fields
+class EmField(EmComponent):
+    
+    ## @brief Instanciate a new EmField
+    # @param uid str : uniq identifier
+    # @param display_name MlString|str|dict : field display_name
+    # @param data_handler class|str : A DataHandler class or display_name
+    # @param help_text MlString|str|dict : help text
+    # @param group EmGroup :
+    # @param **handler_kwargs : data handler arguments
+    def __init__(self, uid, data_handler, display_name = None, help_text = None, group = None, **handler_kwargs):
+        super().__init__(uid, display_name, help_text, group)
+        self.data_handler = data_handler
+        self.data_handler_options = data_handler_options
+
+    

lodel/editorial_model/exceptions.py

@@ -0,0 +1,5 @@
+#-*- coding: utf-8 -*-
+
+class EditorialModelError(Exception):
+    pass
+

lodel/editorial_model/model.py

@@ -0,0 +1,71 @@
+#-*- coding:utf-8 -*-
+from lodel.utils.mlstring import MlString
+
+from lodel.editorial_model.exceptions import *
+from lodel.editorial_model.component import EmClass, EmField
+
+## @brief Describe an editorial model
+class EditorialModel(object):
+    
+    ## @brief Create a new editorial model
+    # @param name MlString|str|dict : the editorial model name
+    # @param description MlString|str|dict : the editorial model description
+    def __init__(self, name, description = None):
+        self.name = MlString(name)
+        self.description = MlString(description)
+        ## @brief Stores all groups indexed by id
+        self.__groups = dict()
+        ## @brief Stores all classes indexed by id
+        self.__classes = dict()
+    
+    ## @brief EmClass accessor
+    # @param uid None | str : give this argument to get a specific EmClass
+    # @return if uid given return an EmClass else return an EmClass iterator
+    def classes(self, uid = None):
+        try:
+            return __elt_getter(self.__classes)
+        except KeyError:
+            raise EditorialModelException("EmClass not found : '%s'" % uid)
+
+    ## @brief EmGroup getter
+    # @param uid None | str : give this argument to get a specific EmGroup
+    # @return if uid given return an EmGroup else return an EmGroup iterator
+    def groups(self, uid = None):
+        try:
+            return __elt_getter(self.__groups)
+        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
+    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:
+            raise EditorialModelException('Duplicated uid "%s"' % emclass.uid)
+        self.__classes[emclass.uid] = emclass
+
+    ## @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 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)
+    
+    ## @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)
+    
+    ## @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]
+

lodel/editorial_model/translator/__init__.py

@@ -0,0 +1,4 @@
+## @package lodel.editorial_model.translator Editorial model translators
+#
+# This package contains modules that provides a save and a load function able to load and save
+# lodel.editorial_model.model.EditorialModel

lodel/editorial_model/translator/pickle.py

@@ -0,0 +1 @@
+#-*- coding: utf-8 -*-

lodel/editorial_model/translator/picklefile.py

@@ -0,0 +1,19 @@
+#-*- coding: utf-8 -*-
+
+import pickle
+
+## @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:
+        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:
+        edmod = pickle.load(ffd)
+    return edmod

tests/test_model.py

@@ -0,0 +1,20 @@
+#-*- coding: utf-8 -*-
+
+import unittest
+
+from lodel.editorial_model.component import EmComponent, EmClass, EmField
+from lodel.utils.mlstring import MlString
+
+class EmComponentTestCase(unittest.TestCase):
+    
+    def test_abstract_init(self):
+        with self.assertRaises(NotImplementedError):
+            EmComponent('test')
+
+class EmClassTestCase(unittest.TestCase):
+
+    def test_init(self):
+        cls = EmClass('testClass', 'test class', 'A test class')
+        self.assertEqual(cls.uid, 'testClass')
+        self.assertEqual(cls.display_name, MlString('test class'))
+        self.assertEqual(cls.help_text, MlString('A test class'))