Implements leapi dynamic classes enhancement with decorators classes

Lodel/plugins.py

@@ -5,9 +5,109 @@ import os, os.path
 import warnings
 
 from Lodel.settings import Settings
+from Lodel import logger
 from Lodel.hooks import LodelHook
 from Lodel.user import authentication_method, identification_method
 
+## @brief Handle registration and fetch of plugins functions that will be bound to LeCrud subclass
+#
+# @note This class exists because of strange behavior with decorator's class inheritance (static attributes was modified by child class)
+class LeapiPluginsMethods(object):
+
+    ## @brief Stores instance methods we want to bind to LeCrud subclass instances
+    __methods = {}
+    ## @brief Stores classmethods we want to bind to LeCrud subclass
+    __classmethods = {}
+    
+    ## @brief Register a new method for LeApi enhancement
+    # @param class_method bool : if True register a classmethod
+    # @param leapi_classname str : the classname
+    # @param method callable : the method to bind
+    # @param bind_name str|None : binding name, if None use the decorated function name
+    @classmethod
+    def register(cls, class_method, leapi_classname, method, bind_name = None):
+        if bind_name is None:
+            bind_name = method.__name__ # use method name if no bind_name specified
+
+        methods = cls.__classmethods if class_method else cls.__methods
+
+        if leapi_classname not in methods:
+            methods[leapi_classname] = dict()
+        elif bind_name in methods[leapi_classname]:
+            orig_fun = methods[leapi_classname][bind_name]
+            msg = 'Method overwriting : %s.%s will be registered as %s for %s in place of %s.%s' % (
+                inspect.getmodule(orig_fun).__name__,
+                orig_fun.__name__,
+                bind_name,
+                leapi_classname,
+                inspect.getmodule(method).__name__,
+                method.__name__
+            )
+            logger.warning(msg)
+        methods[leapi_classname][bind_name] = method
+        # I was thinking that dict are refrerences...
+        if class_method:
+            cls.__classmethods = methods
+        else:
+            cls.__methods = methods
+    
+    ## @brief Fetch all methods that has to be bound to a class
+    # @param class_method bool : if true returns classmethods
+    # @param call_cls LeCrud subclass : the targeted class
+    # @return a dict with wanted bind name as key and callable as value
+    @classmethod
+    def get_methods(cls, class_method, call_cls):
+        methods = cls.__classmethods if class_method else cls.__methods
+        result = dict()
+        for leapi_classname in methods:
+            leapi_cls = call_cls.name2class(leapi_classname)
+            # Strange tests are made on call_cls.__name__ because the name2class method
+            # is not working when called from LeObject at init time...
+            if leapi_cls is False and leapi_classname != call_cls.__name__:
+                logger.warning("Unable to find leapi class %s" % (leapi_classname))
+            elif leapi_classname == call_cls.__name__ or issubclass(call_cls, leapi_cls):
+                result.update(methods[leapi_classname])
+        return result
+
+
+## @brief Decorator class for leapi object enhancement
+#
+# This decorator allows plugins to bind methods to leapi
+# classes.
+#
+# The decorator take 2 arguments :
+# - leapi_cls_name str : the leapi class name
+# - method_name str (optional) : the method name once bind (if None the decorated function name will be used)
+#
+# @note there is another optionnal argument class_method (a bool), but you should not use it and use the leapi_classmethod decorator instead
+class leapi_method(object):
+    ## @brief Constructor for plugins leapi enhancement methods
+    # @param leapi_cls_name str : the classname we want to bind a method to
+    # @param method_name str|None : binding name, if None use the decorated function name
+    def __init__(self, leapi_cls_name, method_name = None, class_method = False):
+        self.__leapi_cls_name = leapi_cls_name
+        self.__method_name = method_name
+        self.__method = None
+        self.__class_method = bool(class_method)
+    
+    ## @brief Called at decoration time
+    # @param method callable : the decorated function
+    def __call__(self, method):
+        self.__method = method
+        if self.__method_name is None:
+            self.__method_name = method.__name__
+        self.__register()
+    
+    ## @biref Register a method to the method we want to bind
+    def __register(self):
+        LeapiPluginsMethods.register(self.__class_method, self.__leapi_cls_name, self.__method, self.__method_name)
+
+
+## @brief Same behavior thant leapi_method but registers classmethods
+class leapi_classmethod(leapi_method):
+    def __init__(self, leapi_cls_name, method_name = None):
+        super().__init__(leapi_cls_name, method_name, True)
+    
 
 ## @brief Returns a list of human readable registered hooks
 # @param names list | None : optionnal filter on name
@@ -40,6 +140,7 @@ def list_hooks(names = None, plugins = None):
                 res += "\t- %s.%s ( priority %d )\n" % (module, hook.__name__, priority)
     return res
 
+
 ## @brief Return a human readable list of plugins
 # @param activated bool | None : Optionnal filter on activated or not plugin
 # @return a str
@@ -82,6 +183,3 @@ def _all_plugins():
             # plugin is a simple python sourcefile
             res.append('%s' % plugin_name)
     return res
-            
-            
-    

leapi/lecrud.py

@@ -8,8 +8,10 @@ import copy
 import warnings
 import importlib
 import re
+import types
 
 from Lodel import logger
+from Lodel.plugins import LeapiPluginsMethods
 from Lodel.settings import Settings
 from EditorialModel.fieldtypes.generic import DatasConstructor
 from Lodel.hooks import LodelHook
@@ -44,9 +46,15 @@ class LeApiQueryError(LeApiErrors): pass
 
 ## @brief When an error concerns a datas
 class LeApiDataCheckError(LeApiErrors): pass
-    
+
+## @brief Metaclass for _LeCrud
+#
+# Implements __getattribute__ for static class attr access ( for the 
+# _datasource lazy instanciation from settings).
 class _MetaLeCrud(type):
-     def __getattribute__(self, name):
+    
+    ## @brief Handles the lazy instancation of datasource (from settings)
+    def __getattribute__(self, name):
         if name == '_datasource':
             if super().__getattribute__('_datasource') is None:
                 module = importlib.import_module("DataSource.{pkg_name}.leapidatasource".format(
@@ -57,17 +65,29 @@ class _MetaLeCrud(type):
                 super().__setattr__('_datasource', ds_cls(**Settings.datasource_options))
         return super().__getattribute__(name)
 
-
-        if 'leapidatasource' in globals():
-            if name == '_datasource' and isinstance(self._datasource, DummyDatasource):
-                #if name == '_datasource' and self._datasource == None:
-                leapids = globals()['leapidatasource']
-                if not isinstance(leapids, DummyDatasource):
-                    self._datasource = leapids({})
-        return super().__getattribute__(name)
+## @brief Metaclass for dynamically generated leapi objects
+#
+# Implements the __init__ method in order to bin registered plugins method
+# ( see @ref Lodel.plugins.leapi_method )
+class MetaDynLeapi(_MetaLeCrud):
+    def __init__(self, *args):
+        self.__bind_plugins_method()
+        super().__init__(*args)
+    
+    ## @brief Handles methods binding
+    def __bind_plugins_method(self):
+        to_bind = LeapiPluginsMethods.get_methods(class_method = True, call_cls = self)
+        for name, method in to_bind.items():
+            if hasattr(self, name):
+                logger.debug("Classmethod '%s' bind overwrite existing attribute (probably parent class bound method)" % name)
+            logger.info("Binding classmethod %s to class %s as %s" % (method.__name__, self, name))
+            bounded = types.MethodType(method, self)
+            setattr(self, name, bounded)
+        
 
 ## @brief Main class to handler lodel editorial components (relations and objects)
 class _LeCrud(object, metaclass = _MetaLeCrud):
+
     ## @brief The datasource
     _datasource = None
 
@@ -87,6 +107,7 @@ class _LeCrud(object, metaclass = _MetaLeCrud):
     # @param uid int : lodel_id if LeObject, id_relation if its a LeRelation
     # @param **kwargs : datas !
     # @throw NotImplementedError if trying to instanciate a class that cannot be instanciated
+    # @todo see if instance methods bindings HAS TO be in the constructor
     def __init__(self, uid, **kwargs):
         if len(kwargs) > 0:
             if not self.implements_leobject() and not self.implements_lerelation():
@@ -106,6 +127,15 @@ class _LeCrud(object, metaclass = _MetaLeCrud):
             warnings.warn("When instanciating the uid was given in the uid argument but was also provided in kwargs. Droping the kwargs uid")
             del(kwargs[uid_name])
         
+        # Binding instance methods from plugins
+        to_bind = LeapiPluginsMethods.get_methods(class_method = False, call_cls = self.__class__)
+        for name, method in to_bind.items():
+            if hasattr(self, name):
+                logger.debug("Method '%s' bind overwrite existing attribute" % name)
+            logger.info("Binding method %s to an instance of %s as %s" %(method.__name__, self.__class__, name))
+            bounded = types.MethodType(method, self)
+            setattr(self, name, bounded)
+
         # Populating the object with given datas
         errors = dict()
         for name, value in kwargs.items():

leapi/lefactory.py

@@ -87,7 +87,7 @@ class LeFactory(object):
                 attr_l[attr.name] = LeFactory.fieldtype_construct_from_field(attr)
 
             rel_code = """
-class {classname}(LeRel2Type):
+class {classname}(LeRel2Type, metaclass = leapi.lecrud.MetaDynLeapi):
     _rel_attr_fieldtypes = {attr_dict}
     _superior_cls = {supcls}
     _subordinate_cls = {subcls}
@@ -218,12 +218,12 @@ from leapi.letype import _LeType
         result += """
 ## @brief _LeCrud concret class
 # @see leapi.lecrud._LeCrud
-class LeCrud(leapi.lecrud._LeCrud):
+class LeCrud(leapi.lecrud._LeCrud, metaclass = leapi.lecrud.MetaDynLeapi):
     _uid_fieldtype = None
 
 ## @brief _LeObject concret class
 # @see leapi.leobject._LeObject
-class LeObject(LeCrud, leapi.leobject._LeObject):
+class LeObject(LeCrud, leapi.leobject._LeObject, metaclass = leapi.lecrud.MetaDynLeapi):
     _me_uid = {me_uid_l}
     _me_uid_field_names = ({class_id}, {type_id})
     _uid_fieldtype = {leo_uid_fieldtype}
@@ -231,7 +231,7 @@ class LeObject(LeCrud, leapi.leobject._LeObject):
 
 ## @brief _LeRelation concret class
 # @see leapi.lerelation._LeRelation
-class LeRelation(LeCrud, leapi.lerelation._LeRelation):
+class LeRelation(LeCrud, leapi.lerelation._LeRelation, metaclass = leapi.lecrud.MetaDynLeapi):
     _uid_fieldtype = {lerel_uid_fieldtype}
     _rel_fieldtypes = {lerel_fieldtypes}
     ## WARNING !!!! OBSOLETE ! DON'T USE IT
@@ -239,16 +239,16 @@ class LeRelation(LeCrud, leapi.lerelation._LeRelation):
     ## WARNING !!!! OBSOLETE ! DON'T USE IT
     _subordinate_field_name = {lesub_name}
 
-class LeHierarch(LeRelation, leapi.lerelation._LeHierarch):
+class LeHierarch(LeRelation, leapi.lerelation._LeHierarch, metaclass = leapi.lecrud.MetaDynLeapi):
     pass
 
-class LeRel2Type(LeRelation, leapi.lerelation._LeRel2Type):
+class LeRel2Type(LeRelation, leapi.lerelation._LeRel2Type, metaclass = leapi.lecrud.MetaDynLeapi):
     pass
 
-class LeClass(LeObject, _LeClass):
+class LeClass(LeObject, _LeClass, metaclass = leapi.lecrud.MetaDynLeapi):
     pass
 
-class LeType(LeClass, _LeType):
+class LeType(LeClass, _LeType, metaclass = leapi.lecrud.MetaDynLeapi):
     pass
 """.format(
             me_uid_l = repr(leobj_me_uid),
@@ -272,7 +272,7 @@ class LeType(LeClass, _LeType):
             result += """
 ## @brief EmClass {name} LeClass child class
 # @see leapi.leclass.LeClass
-class {name}(LeClass, LeObject):
+class {name}(LeClass, LeObject, metaclass = leapi.lecrud.MetaDynLeapi):
     _class_id = {uid}
     ml_string = MlString({name_translations})
 
@@ -288,7 +288,7 @@ class {name}(LeClass, LeObject):
             result += """
 ## @brief EmType {name} LeType child class
 # @see leobject::letype::LeType
-class {name}(LeType, {leclass}):
+class {name}(LeType, {leclass}, metaclass = leapi.lecrud.MetaDynLeapi):
     _type_id = {uid}
     ml_string = MlString({name_translations})
 

plugins/dummy_leapi.py

@@ -0,0 +1,11 @@
+#-*- coding: utf-8 -*-
+
+from Lodel.plugins import leapi_method, leapi_classmethod
+
+@leapi_method('LeObject', 'test_method')
+def a_name(self, arg1):
+    print("Hello from %s. arg1 = %s" % (self, arg1))
+
+@leapi_classmethod('LeObject', 'test_classmethod')
+def another_name(cls):
+    print("I'm a super class method from class %s" % cls)

runtest

@@ -7,6 +7,6 @@ test_package_name='test'
 
 for d in $(find . -type d -name "$test_package_name")
 do
-	echo -e "\tTesting\t$(dirname $d)\n"
+	echo -e "\n\tTesting\t$(dirname $d)"
 	python -W ignore -m unittest discover -qf -s "$d" || break
 done