Modification in backreference handling.

Now a backreference is represented by a tuple(LeObject child class, fieldname)

Makefile

 dyncode_filename='lodel/leapi/dyncode.py'
 
-all: doc refresh_dyn
+all: test doc refresh_dyn
 
 doc: cleandoc
 	doxygen
 em_test:
 	python3 em_test.py
 
-refresh_dyn: clean_dyn em_test
-	python3 scripts/refreshdyn.py examples/em_test.pickle $(dyncode_filename)
-	
+dyncode: clean_dyn em_test
+	python3 scripts/refreshdyn.py examples/em_test.pickle $(dyncode_filename) && echo -e "\n\nCode generated in $(dyncode_filename)"
+
+tests:
+	./runtest -v
 
-.PHONY: clean clean_dyn cleandoc cleanpyc
+.PHONY: clean clean_dyn cleandoc cleanpyc tests
 
 clean: clean_dyn cleandoc cleanpyc
 

lodel/leapi/datahandlers/base_classes.py

 
     ## @brief Instanciation
     # @param allowed_classes list | None : list of allowed em classes if None no restriction
-    # @param back_reference tuple | None : tuple containing (EmClass name, EmField name)
+    # @param back_reference tuple | None : tuple containing (LeObject child class, fieldname)
     # @param internal bool : if False, the field is not internal
     # @param **kwargs : other arguments
     def __init__(self, allowed_classes = None, back_reference = None, internal=False, **kwargs):
         if back_reference is not None:
             if len(back_reference) != 2:
                 raise ValueError("A tuple (classname, fieldname) expected but got '%s'" % back_reference)
+            #if not issubclass(back_reference[0], LeObject) or not isinstance(back_reference[1], str):
+            #    raise TypeError("Back reference was expected to be a tuple(<class LeObject>, str) but got : (%s, %s)" % (back_reference[0], back_reference[1]))
         self.__back_reference = back_reference
         super().__init__(internal=internal, **kwargs)
     
     @property
     def back_reference(self):
-        return self.__back_reference
+        return copy.copy(self.__back_reference)
 
     ## @brief Set the back reference for this field.
     def _set_back_reference(self, back_reference):

lodel/leapi/lefactory.py

     
     # Generation of LeObject child classes code
     cls_code, modules, bootstrap_instr = generate_classes(model)
-    # Completing bootstrap with back_reference bootstraping
-    for leoname in [ LeObject.name2objname(emcls.uid) for emcls in get_classes(model) ]:
-        bootstrap_instr += """
-{leobject}._backref_init()
-""".format(leobject = leoname)
-    bootstrap_instr += """
-del(LeObject._set__fields)
-del(LeObject._backref_init)
-"""
 
     # Header
     imports = """from lodel.leapi.leobject import LeObject
     #dh_module_name = DataHandler.module_name(emfield.data_handler_name)+'.DataHandler'
     get_handler_class_instr = 'DataField.from_name(%s)' % repr(emfield.data_handler_name)
     options = []
+    for name, val in emfield.data_handler_options.items():
+        if name == 'back_reference' and isinstance(val, tuple):
+            options.append('{optname}: ({leo_name}, {fieldname})'.format(
+                optname = repr(name),
+                leo_name = LeObject.name2objname(val[0]),
+                fieldname = repr(val[1]),))
+        else:
+            options.append(repr(name)+': '+forge_optval(val))
 
-    return ('%s(**{' % get_handler_class_instr)+(', '.join([repr(name)+': '+forge_optval(val) for name, val in emfield.data_handler_options.items()])) + '})'
+    return '{handler_instr}(**{{ {options} }})'.format(
+                                                        handler_instr = get_handler_class_instr,
+                                                        options = ', '.join(options))
             
-
+## @brief Return a python repr of option values
 def forge_optval(optval):
     if isinstance(optval, dict):
         return '{' + (', '.join( [ '%s: %s' % (repr(name), forge_optval(val)) for name, val in optval.items()])) + '}'
         res += em_cls_code
         # Dyncode bootstrap instructions
         bootstrap += """{classname}._set__fields({fields})
-#del({classname}._set__fields)
 """.format(
     classname = LeObject.name2objname(em_class.uid),
     fields = '{' + (', '.join(['\n\t%s: %s' % (repr(emfield.uid),data_handler_constructor(emfield)) for emfield in em_class.fields()])) + '}',

lodel/leapi/leobject.py

         except AttributeError:
             raise NameError("No LeObject named '%s'" % leobject_name)
     
-    ## @brief Method designed to "bootstrap" fields by settings their back references
-    # 
-    # @note called once at dyncode load
-    # @note doesn't do any consistency checks, it assume that checks has been done EM side
-    # @warning after dyncode load this method is deleted
-    @classmethod
-    def _backref_init(cls):
-        for fname,field in cls._fields.items():
-            #if field.is_reference():
-            #    print(fname, field.back_reference)
-            if field.is_reference() and field.back_reference is not None:
-                cls_name, field_name = field.back_reference
-                bref_leobject = cls.name2class(cls.name2objname(cls_name))
-                if field_name not in bref_leobject._fields:
-                    raise NameError("LeObject %s doesn't have a field named '%s'" % (cls_name, field_name))
-                field._set_back_reference(bref_leobject._fields[field_name])
-
     @classmethod
     def is_abstract(cls):
         return cls._abstract