Merge lp:~openerp-dev/openobject-server/trunk-base-model-thu into lp:openobject-server

[Antony Lesuisse (OpenERP)]

It seems this should fix https://bugs.launchpad.net/openobject-server/+bug/996816.

This patch does two important things (in addition to some cleaning):
- make "copied" (_inherit + new _name) models inherit from the consolidated parent model, instead of inherit of the parent as-is at installation time (i.e. when not all modules have possibly changed the copied parent).
- introduce a 'base.model' model that is, by default, always a copied parent of any model. (I.e. the default value of _inherit is 'base.model' instead of None.)

'base.model' might be renamed to simply 'base'.

Other changes:
- properly return the super()._auto_init() result (which is a list of stored fields that must be initialized after the table creation).
(The trunk addons are already fixed, so the code calling _auto_init()
can now rightfuly assume that the return type is indeed a list.)
- Removed some exports (or their uses) in openerp.addons and openerp.modules.
- Introduce a deprecation warning (and its controlling flag and comment in openerp.conf.deprecation) for manual instanciation of models. (When such manual instanciations are completely removed, models will be able to be instanciated with a simple model() call, instead of using object.__new__().__init__().)
- The previous point is possible because now __new__() is useless: everything it was doing is handled by the MetaModel meta class.
- Removed load_openerp_module(). Instead, using simply import or __import__ is enough.
- The previous point means that zip files are no longer supported (the code for those was probably broken anyway).
- The ImportHook was needed in the past to lookup OpenERP modules in the different addons paths. Now it is also used to recursively import module dependencies (as-if the imported module had some import statements for its dependencies), and perform some bookkeeping about modules and models (rank modules and models, store the content of the __openerp__.py descriptor file, ...).
- The _name of a model is set by its meta class, instead of sometimes being left to None.
- The support for the _sql model attribute is gone (it was not used, and its purpose is already served with _auto_init()/init() overriding).

Note:
Custom (a.k.a. manual) models seem to be broken in this branch but in trunk too; I hope/guess I haven't made the situation worse.

[lp:~openerp-dev/openobject-server/trunk-base-model-thu]

4866. By Vo Minh Thu on 2013-04-17

[FIX] _auto_init(): when _auto_init() is overridden it does not return the super() result, which might brake functional fields initialization.

4867. By Vo Minh Thu on 2013-04-17

[REF] loading: init_module_models() moved to loading.py, slightly cleaner.

4868. By Vo Minh Thu on 2013-04-17

[REF] orm: renamed todo_end into something more sensible (matching the variable used in loading.py).

4869. By Vo Minh Thu on 2013-04-17

[REM] orm: removed unused _sql feature.

4870. By Vo Minh Thu on 2013-04-17

[REF] module: get_module_resource() is no longer in addons.

4871. By Vo Minh Thu on 2013-04-17

[REF] orm: removed create_instance (used by ir_module.py).

4872. By Vo Minh Thu on 2013-04-17

[FIX] registry: re-consolidate all previously built models whenever a new module is loaded in the registry.

This is needed so we can recompute the full class hierarchy of
models copying parents that are changed by the currently being
loaded module.

4873. By Vo Minh Thu on 2013-05-08

[MERGE] merged trunk.

4874. By Vo Minh Thu on 2013-05-08

[IMP] registry: avoid consolidating and instanciating the exact same model again and again.

4875. By Vo Minh Thu on 2013-05-08

[DOC] changelog: base.model and new _inherit/_name behavior.

4876. By Vo Minh Thu on 2013-07-08

[MERGE] merged trunk.

4877. By Vo Minh Thu on 2013-07-08

[ADD] base.model: added tests.

4878. By Vo Minh Thu on 2013-07-08

[ADD] base.model: added tests.

4879. By Vo Minh Thu on 2013-07-10

[IMP] base.model: disabled tests when run from within openerp.

It is still possible to run them via oe though.

[Raphael Collet (OpenERP) (rco-openerp)]

Some tests are broken (see runbot).

I think you should split this branch in two:
 - the refactoring of the consolidation of models,
 - the other stuff, that is mostly orthogonal.

Please add documentation to your functions to explain what they do (stuff like "rank_modules() must have been called." does not help).

Your code is recursive-imperative: it traverses nodes and update them (openerp_rank, _parents, _rank, etc.) The problem is that it introduces *race conditions* whenever your server serves multiple databases! The ranking of modules is possibly independent from which modules are installed on a database, but the ranking of classes is not! The attributes _number, _parents, _children, _rank that you assign to addons classes depend on which modules are installed.

I suggest you to use memoized functions (which may be database-specific) instead of assigning the objects you are ranking. For instance, the sorting of modules by rank may be written as follows:

@memoize
def get_module_rank(name):
    """ return the rank of the module with the given name """
    module = get_module(name)
    depends = module.openerp_descriptor['depends']
    return max(map(get_module_rank, depends)) + 1 if depends else 0

# sorting module names by rank and name
modules = list(sorted(modules, key=lambda name: (get_module_rank(name), name)))

Raphael

review: Needs Fixing

[Vo Minh Thu (thu)]

Thanks for the review. I will check what you said properly, but quickly my first thoughts:

It seems you're right it is a bad idea to store registry-specific data in sys.modules :)

I'm not sure I could memoize them. I think I re-run them as each module is installed.

The other "orthogonal" stuff: I'm not they are that much orthogonal. I'm pretty sure some of them were possible because of the main change of this merge prop, and some other were actually necessary. I don't want to play with three branches (the orthogonal stuff that are not necessary for this branch, those that depends on this branch, and this branch) and re-base all the resulting commits.

review: Approve

[Vo Minh Thu (thu)]

About the runbot. Tests are not broken per se. They just can't be run all together at the same time, as some (more than one) of them assume a clean base model. That's boring, I don't know what I will do to the runbot to run them separately (and load the modules they belong to separately to). It seems I need a 'base' database, an 'all' one, and then a new one for the new tests.

[Vo Minh Thu (thu)]

review: Needs Fixing

Unmerged revisions

4879. By Vo Minh Thu on 2013-07-10

[IMP] base.model: disabled tests when run from within openerp.

It is still possible to run them via oe though.

4878. By Vo Minh Thu on 2013-07-08

[ADD] base.model: added tests.

4877. By Vo Minh Thu on 2013-07-08

[ADD] base.model: added tests.

4876. By Vo Minh Thu on 2013-07-08

[MERGE] merged trunk.

4875. By Vo Minh Thu on 2013-05-08

[DOC] changelog: base.model and new _inherit/_name behavior.

4874. By Vo Minh Thu on 2013-05-08

[IMP] registry: avoid consolidating and instanciating the exact same model again and again.

4873. By Vo Minh Thu on 2013-05-08

[MERGE] merged trunk.

4872. By Vo Minh Thu on 2013-04-17

[FIX] registry: re-consolidate all previously built models whenever a new module is loaded in the registry.

This is needed so we can recompute the full class hierarchy of
models copying parents that are changed by the currently being
loaded module.

4871. By Vo Minh Thu on 2013-04-17

[REF] orm: removed create_instance (used by ir_module.py).

4870. By Vo Minh Thu on 2013-04-17

[REF] module: get_module_resource() is no longer in addons.

=== modified file 'doc/changelog.rst'
--- doc/changelog.rst	2013-06-21 07:44:28 +0000
+++ doc/changelog.rst	2013-07-10 14:52:28 +0000
@@ -6,6 +6,11 @@
 `trunk`
 -------
 
+- Introduced a ``base.model``. It is to OpenERP models what ``object`` is
+  to Python classes. To make this possible, it means that now copied models
+  (ie. models using ``_inherit`` and providing a new ``_name``) will copy
+  the fully consolidated parent, instead of the parent as-is as the time
+  of module installation.
 - Almost removed ``LocalService()``. For reports,
   ``openerp.osv.orm.Model.print_report()`` can be used. For workflows, see
   :ref:`orm-workflows`.

=== modified file 'openerp/addons/__init__.py'
--- openerp/addons/__init__.py	2012-01-09 12:41:20 +0000
+++ openerp/addons/__init__.py	2013-07-10 14:52:28 +0000
@@ -23,18 +23,10 @@
 """ Addons module.
 
 This module serves to contain all OpenERP addons, across all configured addons
-paths. For the code to manage those addons, see openerp.modules.
-
-Addons are made available under `openerp.addons` after
-openerp.tools.config.parse_config() is called (so that the addons paths are
-known).
-
-This module also conveniently reexports some symbols from openerp.modules.
-Importing them from here is deprecated.
-
+paths. For the code to manage those addons, see `openerp.modules`.
+
+Addons can be imported from `openerp.addons` after
+`openerp.modules.module.initialize_sys_path()` has been called.
 """
 
-# get_module_path is used only by base_module_quality
-from openerp.modules import get_module_resource, get_module_path
-
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== modified file 'openerp/addons/base/__init__.py'
--- openerp/addons/base/__init__.py	2012-08-22 06:28:23 +0000
+++ openerp/addons/base/__init__.py	2013-07-10 14:52:28 +0000
@@ -19,6 +19,7 @@
 #
 ##############################################################################
 
+import models
 import ir
 import module
 import res

=== modified file 'openerp/addons/base/ir/ir_actions.py'
--- openerp/addons/base/ir/ir_actions.py	2013-06-13 17:39:00 +0000
+++ openerp/addons/base/ir/ir_actions.py	2013-07-10 14:52:28 +0000
@@ -354,10 +354,11 @@
         'multi': False,
     }
     def _auto_init(self, cr, context=None):
-        super(act_window_view, self)._auto_init(cr, context)
+        res = super(act_window_view, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'act_window_view_unique_mode_per_action\'')
         if not cr.fetchone():
             cr.execute('CREATE UNIQUE INDEX act_window_view_unique_mode_per_action ON ir_act_window_view (act_window_id, view_mode)')
+        return res
 act_window_view()
 
 class act_wizard(osv.osv):

=== modified file 'openerp/addons/base/ir/ir_attachment.py'
--- openerp/addons/base/ir/ir_attachment.py	2013-06-12 15:28:26 +0000
+++ openerp/addons/base/ir/ir_attachment.py	2013-07-10 14:52:28 +0000
@@ -175,11 +175,12 @@
     }
 
     def _auto_init(self, cr, context=None):
-        super(ir_attachment, self)._auto_init(cr, context)
+        res = super(ir_attachment, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = %s', ('ir_attachment_res_idx',))
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_attachment_res_idx ON ir_attachment (res_model, res_id)')
             cr.commit()
+        return res
 
     def check(self, cr, uid, ids, mode, context=None, values=None):
         """Restricts the access to an ir.attachment, according to referred model

=== modified file 'openerp/addons/base/ir/ir_filters.py'
--- openerp/addons/base/ir/ir_filters.py	2013-02-20 10:34:59 +0000
+++ openerp/addons/base/ir/ir_filters.py	2013-07-10 14:52:28 +0000
@@ -118,12 +118,13 @@
     ]
 
     def _auto_init(self, cr, context=None):
-        super(ir_filters, self)._auto_init(cr, context)
+        res = super(ir_filters, self)._auto_init(cr, context)
         # Use unique index to implement unique constraint on the lowercase name (not possible using a constraint)
         cr.execute("SELECT indexname FROM pg_indexes WHERE indexname = 'ir_filters_name_model_uid_unique_index'")
         if not cr.fetchone():
             cr.execute("""CREATE UNIQUE INDEX "ir_filters_name_model_uid_unique_index" ON ir_filters
                             (lower(name), model_id, COALESCE(user_id,-1))""")
+        return res
 
     _columns = {
         'name': fields.char('Filter Name', size=64, translate=True, required=True),

=== modified file 'openerp/addons/base/ir/ir_model.py'
--- openerp/addons/base/ir/ir_model.py	2013-06-19 09:13:32 +0000
+++ openerp/addons/base/ir/ir_model.py	2013-07-10 14:52:28 +0000
@@ -203,9 +203,13 @@
     def instanciate(self, cr, user, model, context=None):
         class x_custom_model(osv.osv):
             _custom = True
-        x_custom_model._name = model
-        x_custom_model._module = False
-        a = x_custom_model.create_instance(self.pool, cr)
+            _name = model
+            _module = False
+        classes = list(openerp.modules.module.get_model_classes('base.model'))
+        classes = [x_custom_model] + classes
+        cls = openerp.osv.orm.consolidate(model, classes)
+        a = object.__new__(cls)
+        a.__init__(self.pool, cr)
         if not a._columns:
             x_name = 'id'
         elif 'x_name' in a._columns.keys():
@@ -842,10 +846,11 @@
         self.loads = self.pool.model_data_reference_ids
 
     def _auto_init(self, cr, context=None):
-        super(ir_model_data, self)._auto_init(cr, context)
+        res = super(ir_model_data, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_model_data_module_name_index\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_model_data_module_name_index ON ir_model_data (module, name)')
+        return res
 
     @tools.ormcache()
     def _get_id(self, cr, uid, module, xml_id):

=== modified file 'openerp/addons/base/ir/ir_translation.py'
--- openerp/addons/base/ir/ir_translation.py	2013-04-18 11:46:27 +0000
+++ openerp/addons/base/ir/ir_translation.py	2013-07-10 14:52:28 +0000
@@ -223,7 +223,7 @@
         'Language code of translation item must be among known languages' ), ]
 
     def _auto_init(self, cr, context=None):
-        super(ir_translation, self)._auto_init(cr, context)
+        res = super(ir_translation, self)._auto_init(cr, context)
 
         # FIXME: there is a size limit on btree indexed values so we can't index src column with normal btree.
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = %s', ('ir_translation_ltns',))
@@ -247,6 +247,8 @@
             cr.execute('CREATE INDEX ir_translation_ltn ON ir_translation (name, lang, type)')
             cr.commit()
 
+        return res
+
     def _check_selection_field_value(self, cr, uid, field, value, context=None):
         if field == 'lang':
             return

=== modified file 'openerp/addons/base/ir/ir_ui_view.py'
--- openerp/addons/base/ir/ir_ui_view.py	2013-06-05 12:11:43 +0000
+++ openerp/addons/base/ir/ir_ui_view.py	2013-07-10 14:52:28 +0000
@@ -41,10 +41,11 @@
     }
 
     def _auto_init(self, cr, context=None):
-        super(view_custom, self)._auto_init(cr, context)
+        res = super(view_custom, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_ui_view_custom_user_id_ref_id\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_ui_view_custom_user_id_ref_id ON ir_ui_view_custom (user_id, ref_id)')
+        return res
 
 class view(osv.osv):
     _name = 'ir.ui.view'
@@ -165,10 +166,11 @@
     ]
 
     def _auto_init(self, cr, context=None):
-        super(view, self)._auto_init(cr, context)
+        res = super(view, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_ui_view_model_type_inherit_id\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_ui_view_model_type_inherit_id ON ir_ui_view (model, inherit_id)')
+        return res
 
     def get_inheriting_views_arch(self, cr, uid, view_id, model, context=None):
         """Retrieves the architecture of views that inherit from the given view, from the sets of
@@ -293,10 +295,11 @@
     }
 
     def _auto_init(self, cr, context=None):
-        super(view_sc, self)._auto_init(cr, context)
+        res = super(view_sc, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_ui_view_sc_user_id_resource\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_ui_view_sc_user_id_resource ON ir_ui_view_sc (user_id, resource)')
+        return res
 
     def get_sc(self, cr, uid, user_id, model='ir.ui.menu', context=None):
         ids = self.search(cr, uid, [('user_id','=',user_id),('resource','=',model)], context=context)

=== modified file 'openerp/addons/base/ir/ir_values.py'
--- openerp/addons/base/ir/ir_values.py	2013-06-13 17:39:00 +0000
+++ openerp/addons/base/ir/ir_values.py	2013-07-10 14:52:28 +0000
@@ -183,10 +183,11 @@
     }
 
     def _auto_init(self, cr, context=None):
-        super(ir_values, self)._auto_init(cr, context)
+        res = super(ir_values, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'ir_values_key_model_key2_res_id_user_id_idx\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX ir_values_key_model_key2_res_id_user_id_idx ON ir_values (key, model, key2, res_id, user_id)')
+        return res
 
     def set_default(self, cr, uid, model, field_name, value, for_all_users=True, company_id=False, condition=False):
         """Defines a default value for the given model and field_name. Any previous

=== modified file 'openerp/addons/base/ir/workflow/workflow.py'
--- openerp/addons/base/ir/workflow/workflow.py	2013-06-13 17:39:00 +0000
+++ openerp/addons/base/ir/workflow/workflow.py	2013-07-10 14:52:28 +0000
@@ -137,13 +137,14 @@
         'state': fields.char('Status', size=32),
     }
     def _auto_init(self, cr, context=None):
-        super(wkf_instance, self)._auto_init(cr, context)
+        res = super(wkf_instance, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'wkf_instance_res_type_res_id_state_index\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX wkf_instance_res_type_res_id_state_index ON wkf_instance (res_type, res_id, state)')
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'wkf_instance_res_id_wkf_id_index\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX wkf_instance_res_id_wkf_id_index ON wkf_instance (res_id, wkf_id)')
+        return res
 
 wkf_instance()
 
@@ -172,10 +173,11 @@
         'workitem_id': fields.many2one('workflow.workitem', 'Workitem', required=True, ondelete="cascade"),
     }
     def _auto_init(self, cr, context=None):
-        super(wkf_triggers, self)._auto_init(cr, context)
+        res = super(wkf_triggers, self)._auto_init(cr, context)
         cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = \'wkf_triggers_res_id_model_index\'')
         if not cr.fetchone():
             cr.execute('CREATE INDEX wkf_triggers_res_id_model_index ON wkf_triggers (res_id, model)')
+        return res
 wkf_triggers()
 
 

=== added file 'openerp/addons/base/models.py'
--- openerp/addons/base/models.py	1970-01-01 00:00:00 +0000
+++ openerp/addons/base/models.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,19 @@
+from openerp.osv.orm import BaseModel
+
+# Lovely: `base.model` inherits from `BaseModel`.
+#
+# `BaseModel` and `Model` are exactly the same, but with diamond inheritance of
+# `base.model`, if `Model` was used instead, `Model` would be higher in the MRO
+# than `AbstractModel`, e.g. with models inheriting from `mail.message` or
+# `mail.thread`. By using `BaseModel`, we keep `Model` below `AbstractModel`
+# and its `_auto=True` attribute "wins" over the `_auto=False` of
+# `AbstractModel`.
+class base_model(BaseModel):
+    _inherit = None
+    _name = 'base.model'
+
+    _auto = False # No table in database.
+    _transient = False
+
+    _columns = {
+    }

=== modified file 'openerp/addons/base/module/module.py'
--- openerp/addons/base/module/module.py	2013-06-28 10:04:07 +0000
+++ openerp/addons/base/module/module.py	2013-07-10 14:52:28 +0000
@@ -40,7 +40,7 @@
     from StringIO import StringIO   # NOQA
 
 import openerp
-from openerp import modules, tools, addons
+from openerp import modules, tools
 from openerp.modules.db import create_categories
 from openerp.tools.parse_version import parse_version
 from openerp.tools.translate import _
@@ -153,7 +153,7 @@
     def _get_desc(self, cr, uid, ids, field_name=None, arg=None, context=None):
         res = dict.fromkeys(ids, '')
         for module in self.browse(cr, uid, ids, context=context):
-            path = addons.get_module_resource(module.name, 'static/description/index.html')
+            path = openerp.modules.module.get_module_resource(module.name, 'static/description/index.html')
             if path:
                 with tools.file_open(path, 'rb') as desc_file:
                     doc = desc_file.read()
@@ -169,7 +169,7 @@
         return res
 
     def _get_latest_version(self, cr, uid, ids, field_name=None, arg=None, context=None):
-        default_version = modules.adapt_version('1.0')
+        default_version = modules.module.adapt_version('1.0')
         res = dict.fromkeys(ids, default_version)
         for m in self.browse(cr, uid, ids):
             res[m.id] = self.get_module_info(m.name).get('version', default_version)
@@ -243,7 +243,7 @@
     def _get_icon_image(self, cr, uid, ids, field_name=None, arg=None, context=None):
         res = dict.fromkeys(ids, '')
         for module in self.browse(cr, uid, ids, context=context):
-            path = addons.get_module_resource(module.name, 'static', 'description', 'icon.png')
+            path = openerp.modules.module.get_module_resource(module.name, 'static', 'description', 'icon.png')
             if path:
                 image_file = tools.file_open(path, 'rb')
                 try:
@@ -584,7 +584,7 @@
     def update_list(self, cr, uid, context=None):
         res = [0, 0]    # [update, add]
 
-        default_version = modules.adapt_version('1.0')
+        default_version = modules.module.adapt_version('1.0')
         known_mods = self.browse(cr, uid, self.search(cr, uid, []))
         known_mods_names = dict([(m.name, m) for m in known_mods])
 
@@ -631,7 +631,7 @@
 
     def download(self, cr, uid, ids, download=True, context=None):
         res = []
-        default_version = modules.adapt_version('1.0')
+        default_version = modules.module.adapt_version('1.0')
         for mod in self.browse(cr, uid, ids, context=context):
             if not mod.url:
                 continue

=== modified file 'openerp/conf/deprecation.py'
--- openerp/conf/deprecation.py	2013-03-27 16:40:45 +0000
+++ openerp/conf/deprecation.py	2013-07-10 14:52:28 +0000
@@ -58,4 +58,11 @@
 # but no warning was dispayed in the logs).
 openerp_pooler = True
 
+# If True, calling a model class after defining it is allowed.
+#   class my_model(Model):
+#       pass
+#   my_model()
+# Introduced around 2013.04.
+allow_explicit_model_call = True
+
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== modified file 'openerp/modules/__init__.py'
--- openerp/modules/__init__.py	2012-08-24 14:23:23 +0000
+++ openerp/modules/__init__.py	2013-07-10 14:52:28 +0000
@@ -28,14 +28,10 @@
 
 # TODO temporarily expose those things
 from openerp.modules.module import \
-    get_modules, get_modules_with_version, \
+    get_modules, \
     load_information_from_description_file, \
-    get_module_resource, zip_directory, \
-    get_module_path, initialize_sys_path, \
-    load_openerp_module, init_module_models, \
-    adapt_version
-
-from openerp.modules.loading import load_modules
+    get_module_resource, \
+    get_module_path
 
 
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== modified file 'openerp/modules/graph.py'
--- openerp/modules/graph.py	2013-03-27 17:06:39 +0000
+++ openerp/modules/graph.py	2013-07-10 14:52:28 +0000
@@ -98,7 +98,7 @@
             # done by db.initialize, so it is possible to not do it again here.
             info = openerp.modules.module.load_information_from_description_file(module)
             if info and info['installable']:
-                packages.append((module, info)) # TODO directly a dict, like in get_modules_with_version
+                packages.append((module, info)) # TODO directly a dict
             else:
                 _logger.warning('module %s: not installable, skipped', module)
 

=== modified file 'openerp/modules/loading.py'
--- openerp/modules/loading.py	2013-05-07 11:20:24 +0000
+++ openerp/modules/loading.py	2013-07-10 14:52:28 +0000
@@ -40,8 +40,7 @@
 from openerp import SUPERUSER_ID
 
 from openerp.tools.translate import _
-from openerp.modules.module import initialize_sys_path, \
-    load_openerp_module, init_module_models, adapt_version
+from openerp.modules.module import adapt_version
 
 _logger = logging.getLogger(__name__)
 _test_logger = logging.getLogger('openerp.tests')
@@ -149,9 +148,14 @@
 
         _logger.debug('module %s: loading objects', package.name)
         migrations.migrate_module(package, 'pre')
-        load_openerp_module(package.name)
-
-        models = registry.load(cr, package)
+        __import__('openerp.addons.' + package.name)
+        mod = sys.modules['openerp.addons.' + package.name]
+        post_load = mod.openerp_descriptor['post_load']
+        if post_load:
+            getattr(mod, post_load)()
+
+
+        models = registry.add_module(cr, mod)
 
         loaded_modules.append(package.name)
         if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):
@@ -223,6 +227,27 @@
 
     return loaded_modules, processed_modules
 
+def init_module_models(cr, module_name, models):
+    """ Initialize a list of models.
+
+    Call _auto_init and init on each model to create or update the
+    database tables supporting the models. Call _auto_end to create
+    foreign keys. Call _update_stored_functional_field to initialize
+    stored functional fields.
+    """
+    _logger.info('module %s: creating or updating database tables', module_name)
+    stored_fields = []
+    for model in models:
+        stored_fields += model._auto_init(cr, {'module': module_name})
+        model.init(cr)
+        cr.commit()
+    for model in models:
+        model._auto_end(cr, {'module': module_name})
+        cr.commit()
+    for order, model, field_name in sorted(stored_fields):
+        model._update_stored_functional_field(cr, field_name)
+    cr.commit()
+
 def _check_module_names(cr, module_names):
     mod_names = set(module_names)
     if 'base' in mod_names:
@@ -257,7 +282,6 @@
     # TODO status['progress'] reporting is broken: used twice (and reset each
     # time to zero) in load_module_graph, not fine-grained enough.
     # It should be a method exposed by the registry.
-    initialize_sys_path()
 
     force = []
     if force_demo:

=== modified file 'openerp/modules/module.py'
--- openerp/modules/module.py	2013-06-28 15:07:55 +0000
+++ openerp/modules/module.py	2013-07-10 14:52:28 +0000
@@ -26,7 +26,6 @@
 from os.path import join as opj
 import sys
 import types
-import zipimport
 
 import openerp.tools as tools
 import openerp.tools.osutil as osutil
@@ -36,9 +35,6 @@
 import openerp.release as release
 
 import re
-import base64
-from zipfile import PyZipFile, ZIP_DEFLATED
-from cStringIO import StringIO
 
 import logging
 
@@ -48,21 +44,177 @@
 _ad = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'addons') # default addons path (base)
 ad_paths = []
 
-# Modules already loaded
-loaded = []
-
-_logger = logging.getLogger(__name__)
+
+class Module(object):
+    modules = []
+    all_classes = []
+    dirty = False
+
+def derive_module_info():
+    rank_modules()
+    number_classes()
+    find_all_parents()
+    find_all_new_parents()
+    rank_classes()
+
+    Module.dirty = False
+
+def get_module(module_name):
+    return sys.modules['openerp.addons.' + module_name]
+
+def rank_modules():
+    for module in map(get_module, Module.modules):
+        module.rank = None
+    for module in map(get_module, Module.modules):
+        rank_module(module)
+    Module.modules = list(sorted(Module.modules, cmp=lambda x, y: cmp((get_module(x).openerp_rank, x), (get_module(y).openerp_rank, y))))
+
+def number_classes():
+    """rank_modules() must have been called."""
+    i = 0
+    Module.all_classes = []
+    for m in map(get_module, Module.modules):
+        for cls in m.openerp_classes:
+            Module.all_classes.append(cls)
+            cls._number = i
+            i += 1
+
+def rank_module(module):
+    if module.openerp_rank is None:
+        depends = module.openerp_descriptor['depends']
+        if depends:
+            module.openerp_rank = max(map(lambda d: rank_module(sys.modules['openerp.addons.' + d]), depends)) + 1
+        else:
+            module.openerp_rank = 0
+
+    return module.openerp_rank
+
+def rank_classes():
+    """find_all_new_parents() must have been called."""
+    for cls in Module.all_classes:
+        cls._rank = None
+    for cls in Module.all_classes:
+        rank_class(cls)
+
+    Module.ranked_classes = sorted(Module.all_classes, cmp=lambda x, y: cmp((x._rank, x._name), (y._rank, y._name)))
+
+def rank_class(cls):
+    if cls._rank is None:
+        if cls._parents:
+            cls._rank = max(map(lambda c: rank_class(c), cls._parents)) + 1
+            parent_modules = [p._original_module for p in cls._parents]
+            cls._original_module = [k for k in Module.modules if k in parent_modules][0]
+        else:
+            cls._rank = 0
+            cls._original_module = cls._module
+
+    return cls._rank
+
+def find_all_parents():
+    """number_classes() must have been called."""
+    for cls in Module.all_classes:
+        find_parents(cls)
+
+def find_parents(cls):
+    if isinstance(cls._inherit, list):
+        parents = cls._inherit
+    elif cls._inherit:
+        parents = [cls._inherit]
+    else:
+        parents = []
+    cls._parents = map(find_parent(cls), parents)
+    return cls._parents
+
+def find_parent(cls):
+    def f(name):
+        parent = None
+        for c in reversed(Module.all_classes[:cls._number]):
+            if c._name == name:
+                if not hasattr(c, '_children'):
+                    c._children = []
+                c._children.append(cls)
+                parent = c
+                break
+        assert parent, "Cannot find class for model `%s`, specified as a parent of `%s`." % (name, cls._name)
+        return c
+    return f
+
+def find_all_new_parents():
+    """find_all_parents() must have been called."""
+    for cls in Module.all_classes:
+        cls._parents = map(find_new_parent(cls), cls._parents)
+
+def find_new_parent(cls):
+    def f(parent):
+        assert cls._name
+        assert parent._name
+        if cls._name != parent._name:
+            # cls is a copy of parent
+            for c in reversed(Module.all_classes):
+                if c._name == parent._name:
+                    return c
+        return parent
+    return f
+
+def get_model_classes(name):
+    if Module.dirty:
+        derive_module_info()
+
+    last = None
+    for cls in reversed(Module.ranked_classes):
+        if cls._name == name:
+            last = cls
+            break
+    assert last, "No class found defining model `%s`.\n%s" % (name, map(lambda x: x._name, Module.ranked_classes))
+
+    return get_parents(cls, [])
+
+def get_parents(cls, accum):
+    if cls in accum:
+        accum.remove(cls) # Not accurate, we need to replicate Python MRO.
+    accum.append(cls)
+    for p in cls._parents:
+        get_parents(p, accum)
+    return accum
+
+def display_dot():
+    print 'digraph classes {'
+    print '  rankdir=BT;'
+    for cls in Module.all_classes:
+        print '  %s [label = "%s|%s"];' % (cls._number, cls._module, cls._name)
+
+    for cls in Module.all_classes:
+        for p in cls._parents:
+            if cls._name != p._name:
+                # cls is a copy of p
+                print '  %s -> %s [color="#1ED5FA"];' % (cls._number, p._number)
+            else:
+                print '  %s -> %s;' % (cls._number, p._number)
+
+    for m in map(get_module, Module.modules):
+        print '  subgraph %s {' % m.name
+        for cls in m.classes:
+            print '    %s;' % cls._number
+        print '  }'
+    print '}'
+
+# Temporary list for each OpenERP module all its model classes.
+# The list is available on the `openerp_classes` attribute
+# (on `sys.modules[module_name]`) but it doesn't exist yet
+# when the classes are registered.
+module_to_models = {}
 
 class AddonsImportHook(object):
     """
-    Import hook to load OpenERP addons from multiple paths.
+    Import hook to load OpenERP addons from multiple paths. The dependencies
+    (declared in the `__openerp__.py` file) are imported too. A few attributes
+    are set on the module.
 
     OpenERP implements its own import-hook to load its addons. OpenERP
-    addons are Python modules. Originally, they were each living in their
-    own top-level namespace, e.g. the sale module, or the hr module. For
-    backward compatibility, `import <module>` is still supported. Now they
-    are living in `openerp.addons`. The good way to import such modules is
-    thus `import openerp.addons.module`.
+    addons are Python modules. They must be imported from the `openerp.addons`
+    namespace. E.g. to import the `sale` module, use::
+
+        > import openerp.addons.sale
     """
 
     def find_module(self, module_name, package_path):
@@ -71,27 +223,38 @@
             return self # We act as a loader too.
 
     def load_module(self, module_name):
-
         module_parts = module_name.split('.')
         if len(module_parts) == 3 and module_name.startswith('openerp.addons.'):
             module_part = module_parts[2]
             if module_name in sys.modules:
                 return sys.modules[module_name]
 
+        # Import the dependencies.
+        info = load_information_from_description_file(module_part)
+        for d in info['depends']:
+            __import__('openerp.addons.' + d)
+
+        # Import the module.
         # Note: we don't support circular import.
         f, path, descr = imp.find_module(module_part, ad_paths)
         mod = imp.load_module('openerp.addons.' + module_part, f, path, descr)
+
+        # We also use the import-hook to do some bookkeeping directly on
+        # the module itself.
+        mod.openerp_name = module_part
+        mod.openerp_descriptor = info
+        mod.openerp_classes = module_to_models.get(module_part, [])
+        mod.openerp_rank = None
         sys.modules['openerp.addons.' + module_part] = mod
+        Module.modules.append(module_part)
+        Module.dirty = True
+
         return mod
 
 def initialize_sys_path():
     """
     Setup an import-hook to be able to import OpenERP addons from the different
     addons paths.
-
-    This ensures something like ``import crm`` (or even
-    ``import openerp.addons.crm``) works even if the addons are not in the
-    PYTHONPATH.
     """
     global ad_paths
     if ad_paths:
@@ -154,68 +317,6 @@
 
     return tree
 
-def zip_directory(directory, b64enc=True, src=True):
-    """Compress a directory
-
-    @param directory: The directory to compress
-    @param base64enc: if True the function will encode the zip file with base64
-    @param src: Integrate the source files
-
-    @return: a string containing the zip file
-    """
-
-    RE_exclude = re.compile('(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)
-
-    def _zippy(archive, path, src=True):
-        path = os.path.abspath(path)
-        base = os.path.basename(path)
-        for f in osutil.listdir(path, True):
-            bf = os.path.basename(f)
-            if not RE_exclude.search(bf) and (src or bf == '__openerp__.py' or not bf.endswith('.py')):
-                archive.write(os.path.join(path, f), os.path.join(base, f))
-
-    archname = StringIO()
-    archive = PyZipFile(archname, "w", ZIP_DEFLATED)
-
-    # for Python 2.5, ZipFile.write() still expects 8-bit strings (2.6 converts to utf-8)
-    directory = tools.ustr(directory).encode('utf-8')
-
-    archive.writepy(directory)
-    _zippy(archive, directory, src=src)
-    archive.close()
-    archive_data = archname.getvalue()
-    archname.close()
-
-    if b64enc:
-        return base64.encodestring(archive_data)
-
-    return archive_data
-
-def get_module_as_zip(modulename, b64enc=True, src=True):
-    """Generate a module as zip file with the source or not and can do a base64 encoding
-
-    @param modulename: The module name
-    @param b64enc: if True the function will encode the zip file with base64
-    @param src: Integrate the source files
-
-    @return: a stream to store in a file-like object
-    """
-
-    ap = get_module_path(str(modulename))
-    if not ap:
-        raise Exception('Unable to find path for module %s' % modulename)
-
-    ap = ap.encode('utf8')
-    if os.path.isfile(ap + '.zip'):
-        val = file(ap + '.zip', 'rb').read()
-        if b64enc:
-            val = base64.encodestring(val)
-    else:
-        val = zip_directory(ap, b64enc, src)
-
-    return val
-
-
 def get_module_resource(module, *args):
     """Return the full path of a resource of the given module.
 
@@ -295,76 +396,10 @@
             info['version'] = adapt_version(info['version'])
             return info
 
-    #TODO: refactor the logger in this file to follow the logging guidelines
-    #      for 6.0
     _logger.debug('module %s: no __openerp__.py file found.', module)
     return {}
 
 
-def init_module_models(cr, module_name, obj_list):
-    """ Initialize a list of models.
-
-    Call _auto_init and init on each model to create or update the
-    database tables supporting the models.
-
-    TODO better explanation of _auto_init and init.
-
-    """
-    _logger.info('module %s: creating or updating database tables', module_name)
-    todo = []
-    for obj in obj_list:
-        result = obj._auto_init(cr, {'module': module_name})
-        if result:
-            todo += result
-        if hasattr(obj, 'init'):
-            obj.init(cr)
-        cr.commit()
-    for obj in obj_list:
-        obj._auto_end(cr, {'module': module_name})
-        cr.commit()
-    todo.sort()
-    for t in todo:
-        t[1](cr, *t[2])
-    cr.commit()
-
-def load_openerp_module(module_name):
-    """ Load an OpenERP module, if not already loaded.
-
-    This loads the module and register all of its models, thanks to either
-    the MetaModel metaclass, or the explicit instantiation of the model.
-    This is also used to load server-wide module (i.e. it is also used
-    when there is no model to register).
-    """
-    global loaded
-    if module_name in loaded:
-        return
-
-    initialize_sys_path()
-    try:
-        mod_path = get_module_path(module_name)
-        zip_mod_path = '' if not mod_path else mod_path + '.zip'
-        if not os.path.isfile(zip_mod_path):
-            __import__('openerp.addons.' + module_name)
-        else:
-            zimp = zipimport.zipimporter(zip_mod_path)
-            zimp.load_module(module_name)
-
-        # Call the module's post-load hook. This can done before any model or
-        # data has been initialized. This is ok as the post-load hook is for
-        # server-wide (instead of registry-specific) functionalities.
-        info = load_information_from_description_file(module_name)
-        if info['post_load']:
-            getattr(sys.modules['openerp.addons.' + module_name], info['post_load'])()
-
-    except Exception, e:
-        mt = isinstance(e, zipimport.ZipImportError) and 'zip ' or ''
-        msg = "Couldn't load %smodule %s" % (mt, module_name)
-        _logger.critical(msg)
-        _logger.critical(e)
-        raise
-    else:
-        loaded.append(module_name)
-
 def get_modules():
     """Returns the list of module names
     """
@@ -388,17 +423,6 @@
     return list(set(plist))
 
 
-def get_modules_with_version():
-    modules = get_modules()
-    res = dict.fromkeys(modules, adapt_version('1.0'))
-    for module in modules:
-        try:
-            info = load_information_from_description_file(module)
-            res[module] = info['version']
-        except Exception:
-            continue
-    return res
-
 def adapt_version(version):
     serie = release.major_version
     if version == serie or not version.startswith(serie + '.'):

=== modified file 'openerp/modules/registry.py'
--- openerp/modules/registry.py	2013-06-19 10:53:35 +0000
+++ openerp/modules/registry.py	2013-07-10 14:52:28 +0000
@@ -24,13 +24,16 @@
 """
 from collections import Mapping
 from contextlib import contextmanager
+import itertools
 import logging
+import sys
 import threading
 
 import openerp.sql_db
 import openerp.osv.orm
 import openerp.tools
 import openerp.modules.db
+import openerp.modules.loading
 import openerp.tools.config
 from openerp.tools import assertion_report
 
@@ -53,6 +56,8 @@
         self._init_parent = {}
         self._assertion_report = assertion_report.assertion_report()
         self.fields_by_model = None
+        # Set of (set of classes) already consolidated and instanciated.
+        self.identities = set()
 
         # modules fully loaded (maintained during init phase by `loading` module)
         self._init_modules = set()
@@ -115,24 +120,32 @@
         """ Add or replace a model in the registry."""
         self.models[model_name] = model
 
-    def load(self, cr, module):
-        """ Load a given module in the registry.
-
-        At the Python level, the modules are already loaded, but not yet on a
-        per-registry level. This method populates a registry with the given
-        modules, i.e. it instanciates all the classes of a the given module
-        and registers them in the registry.
-
-        """
+    def add_module(self, cr, module):
+        module_names = [module.openerp_name] + list(self._init_modules)
         models_to_load = [] # need to preserve loading order
-        # Instantiate registered classes (via the MetaModel automatic discovery
-        # or via explicit constructor call), and add them to the pool.
-        for cls in openerp.osv.orm.MetaModel.module_to_models.get(module.name, []):
-            # models register themselves in self.models
-            model = cls.create_instance(self, cr)
-            if model._name not in models_to_load:
+        modules = [sys.modules['openerp.addons.' + m] for m in module_names]
+        # Re-consolidate all previously consolidated (and instanciated)
+        # models, instead of only the one from the current module.
+        # We end up re-creating more models than strictly necessary;
+        # normaly, only the parents (and their children) must be re-done.
+        for model in itertools.chain(*tuple(module.openerp_classes for module in modules)):
+            if model._name in models_to_load:
                 # avoid double-loading models whose declaration is split
-                models_to_load.append(model._name)
+                continue
+            classes = list(openerp.modules.module.get_model_classes(model._name))
+            classes = filter(lambda ext: ext._module in module_names, classes)
+            # Derive an 'identity' for this set of classes so we can avoid
+            # reloading the model if it has not been changed by this module.
+            # There would be nothing wrong doing it, it would just take
+            # additional time.
+            i = tuple([id(c) for c in classes])
+            if i in self.identities:
+                continue
+            self.identities.add(i)
+            models_to_load.append(model._name)
+            cls = openerp.osv.orm.consolidate(model._name, classes)
+            obj = object.__new__(cls)
+            obj.__init__(self, cr)
         return [self.models[m] for m in models_to_load]
 
     def clear_caches(self):
@@ -229,7 +242,7 @@
             cls.registries[db_name] = registry
             try:
                 # This should be a method on Registry
-                openerp.modules.load_modules(registry.db, force_demo, status, update_module)
+                openerp.modules.loading.load_modules(registry.db, force_demo, status, update_module)
             except Exception:
                 del cls.registries[db_name]
                 raise

=== modified file 'openerp/osv/orm.py'
--- openerp/osv/orm.py	2013-07-02 14:47:45 +0000
+++ openerp/osv/orm.py	2013-07-10 14:52:28 +0000
@@ -599,6 +599,53 @@
     return pg_type
 
 
+def consolidate(model_name, classes):
+    """ Create a consolidated model defined by the provided classes.
+    """
+    attributes = ['_columns', '_defaults', '_inherits', '_constraints',
+        '_sql_constraints']
+
+    assert classes, "Model `%s` consolidation cannot be done because there is no class to define it." % model_name
+    nattr = {'_register': False}
+    for s in attributes:
+        new = copy.copy(getattr(classes[-1], s))
+        for parent in list(reversed(classes))[1:]:
+            if s == '_columns':
+                # Duplicate float fields because they have a .digits
+                # cache (which must be per-registry, not server-wide).
+                for c in new.keys():
+                    if new[c]._type == 'float':
+                        new[c] = copy.copy(new[c])
+            if hasattr(new, 'update'):
+                new.update(parent.__dict__.get(s, {}))
+            elif s=='_constraints':
+                for c in parent.__dict__.get(s, []):
+                    exist = False
+                    for c2 in range(len(new)):
+                        #For _constraints, we should check field and methods as well
+                        if new[c2][2]==c[2] and (new[c2][0] == c[0] \
+                                or getattr(new[c2][0],'__name__', True) == \
+                                    getattr(c[0],'__name__', False)):
+                            # If new class defines a constraint with
+                            # same function name, we let it override
+                            # the old one.
+
+                            new[c2] = c
+                            exist = True
+                            break
+                    if not exist:
+                        new.append(c)
+            else:
+                new.extend(parent.__dict__.get(s, []))
+        nattr[s] = new
+
+    # Keep links to non-inherited constraints, e.g. useful when exporting translations
+    nattr['_local_constraints'] = classes[0].__dict__.get('_constraints', [])
+    nattr['_local_sql_constraints'] = classes[0].__dict__.get('_sql_constraints', [])
+    cls = type(model_name, tuple(classes), nattr)
+    return cls
+
+
 class MetaModel(type):
     """ Metaclass for the Model.
 
@@ -609,14 +656,23 @@
 
     """
 
-    module_to_models = {}
-
     def __init__(self, name, bases, attrs):
         if not self._register:
             self._register = True
             super(MetaModel, self).__init__(name, bases, attrs)
             return
 
+        # Derive the _name of the class.
+        if not self._name and isinstance(self._inherit, list) and len(self._inherit) == 1:
+            self._name = self._inherit[0]
+        elif not self._name and isinstance(self._inherit, list):
+            raise Exception, "_name must be provide when there are multiple _inherit parents."
+        elif not self._name:
+            self._name = self._inherit
+        assert self._name
+        # Sets the instance _inherit attribute (with the classs attribute).
+        self._inherit = self._inherit
+
         # The (OpenERP) module name can be in the `openerp.addons` namespace
         # or not. For instance module `sale` can be imported as
         # `openerp.addons.sale` (the good way) or `sale` (for backward
@@ -627,12 +683,15 @@
             module_name = self.__module__.split('.')[2]
         else:
             module_name = self.__module__.split('.')[0]
+            _logger.warning('OpenERP module `%s` is not in the `openerp.addons` namespace.', module_name)
+
         if not hasattr(self, '_module'):
             self._module = module_name
 
         # Remember which models to instanciate for this module.
         if not self._custom:
-            self.module_to_models.setdefault(self._module, []).append(self)
+            module_model_list = openerp.modules.module.module_to_models.setdefault(self._module, [])
+            module_model_list.append(self)
 
 
 # Definition of log access columns, automatically added to models if
@@ -688,6 +747,8 @@
     # Transience
     _transient = False # True in a TransientModel
 
+    _inherit = 'base.model'
+
     # structure:
     #  { 'parent_model': 'm2o_field', ... }
     _inherits = {}
@@ -835,119 +896,10 @@
                         break
         cr.commit()
 
-    #
-    # Goal: try to apply inheritance at the instanciation level and
-    #       put objects in the pool var
-    #
-    @classmethod
-    def create_instance(cls, pool, cr):
-        """ Instanciate a given model.
-
-        This class method instanciates the class of some model (i.e. a class
-        deriving from osv or osv_memory). The class might be the class passed
-        in argument or, if it inherits from another class, a class constructed
-        by combining the two classes.
-
-        The ``attributes`` argument specifies which parent class attributes
-        have to be combined.
-
-        TODO: the creation of the combined class is repeated at each call of
-        this method. This is probably unnecessary.
-
-        """
-        attributes = ['_columns', '_defaults', '_inherits', '_constraints',
-            '_sql_constraints']
-
-        parent_names = getattr(cls, '_inherit', None)
-        if parent_names:
-            if isinstance(parent_names, (str, unicode)):
-                name = cls._name or parent_names
-                parent_names = [parent_names]
-            else:
-                name = cls._name
-            if not name:
-                raise TypeError('_name is mandatory in case of multiple inheritance')
-
-            for parent_name in ((type(parent_names)==list) and parent_names or [parent_names]):
-                if parent_name not in pool:
-                    raise TypeError('The model "%s" specifies an unexisting parent class "%s"\n'
-                        'You may need to add a dependency on the parent class\' module.' % (name, parent_name))
-                parent_model = pool[parent_name]
-                if not getattr(cls, '_original_module', None) and name == parent_model._name:
-                    cls._original_module = parent_model._original_module
-                parent_class = parent_model.__class__
-                nattr = {}
-                for s in attributes:
-                    new = copy.copy(getattr(parent_model, s, {}))
-                    if s == '_columns':
-                        # Don't _inherit custom fields.
-                        for c in new.keys():
-                            if new[c].manual:
-                                del new[c]
-                        # Duplicate float fields because they have a .digits
-                        # cache (which must be per-registry, not server-wide).
-                        for c in new.keys():
-                            if new[c]._type == 'float':
-                                new[c] = copy.copy(new[c])
-                    if hasattr(new, 'update'):
-                        new.update(cls.__dict__.get(s, {}))
-                    elif s=='_constraints':
-                        for c in cls.__dict__.get(s, []):
-                            exist = False
-                            for c2 in range(len(new)):
-                                #For _constraints, we should check field and methods as well
-                                if new[c2][2]==c[2] and (new[c2][0] == c[0] \
-                                        or getattr(new[c2][0],'__name__', True) == \
-                                            getattr(c[0],'__name__', False)):
-                                    # If new class defines a constraint with
-                                    # same function name, we let it override
-                                    # the old one.
-
-                                    new[c2] = c
-                                    exist = True
-                                    break
-                            if not exist:
-                                new.append(c)
-                    else:
-                        new.extend(cls.__dict__.get(s, []))
-                    nattr[s] = new
-
-                # Keep links to non-inherited constraints, e.g. useful when exporting translations
-                nattr['_local_constraints'] = cls.__dict__.get('_constraints', [])
-                nattr['_local_sql_constraints'] = cls.__dict__.get('_sql_constraints', [])
-
-                cls = type(name, (cls, parent_class), dict(nattr, _register=False))
-        else:
-            cls._local_constraints = getattr(cls, '_constraints', [])
-            cls._local_sql_constraints = getattr(cls, '_sql_constraints', [])
-
-        if not getattr(cls, '_original_module', None):
-            cls._original_module = cls._module
-        obj = object.__new__(cls)
-        obj.__init__(pool, cr)
-        return obj
-
     def __new__(cls):
-        """Register this model.
-
-        This doesn't create an instance but simply register the model
-        as being part of the module where it is defined.
-
-        """
-
-
-        # Set the module name (e.g. base, sale, accounting, ...) on the class.
-        module = cls.__module__.split('.')[0]
-        if not hasattr(cls, '_module'):
-            cls._module = module
-
-        # Record this class in the list of models to instantiate for this module,
-        # managed by the metaclass.
-        module_model_list = MetaModel.module_to_models.setdefault(cls._module, [])
-        if cls not in module_model_list:
-            if not cls._custom:
-                module_model_list.append(cls)
-
+        assert openerp.conf.deprecation.allow_explicit_model_call
+        _logger.warning("Instanciating a model (here `%s`) after defining it"
+            " is deprecated.", cls._name or cls._inherit)
         # Since we don't return an instance here, the __init__
         # method won't be called.
         return None
@@ -1064,8 +1016,6 @@
         self._inherits_reload()
         if not self._sequence:
             self._sequence = self._table + '_id_seq'
-        for k in self._defaults:
-            assert (k in self._columns) or (k in self._inherit_fields), 'Default function defined in %s but field %s does not exist !' % (self._name, k,)
         for f in self._columns:
             self._columns[f].restart()
 
@@ -2776,9 +2726,10 @@
             pos = browse_rec(root, pos)
         return True
 
-    def _update_store(self, cr, f, k):
-        _logger.info("storing computed values of fields.function '%s'", k)
-        ss = self._columns[k]._symbol_set
+    def _update_stored_functional_field(self, cr, k):
+        _logger.info("Computing and storing functional field `%s`.", k)
+        f = self._columns[k]
+        ss = f._symbol_set
         update_query = 'UPDATE "%s" SET "%s"=%s WHERE id=%%s' % (self._table, k, ss[0])
         cr.execute('select id from '+self._table)
         ids_lst = map(lambda x: x[0], cr.fetchall())
@@ -2970,7 +2921,7 @@
         if context is None:
             context = {}
         store_compute = False
-        todo_end = []
+        stored_fields = []
         update_custom_fields = context.get('update_custom_fields', False)
         self._field_create(cr, context=context)
         create = not self._table_exist(cr)
@@ -3172,10 +3123,11 @@
 
                             # remember the functions to call for the stored fields
                             if isinstance(f, fields.function):
-                                order = 10
                                 if f.store is not True: # i.e. if f.store is a dict
                                     order = f.store[f.store.keys()[0]][2]
-                                todo_end.append((order, self._update_store, (f, k)))
+                                else:
+                                    order = 10
+                                stored_fields.append((order, self, k))
 
                             # and add constraints if needed
                             if isinstance(f, fields.many2one):
@@ -3202,23 +3154,19 @@
                                     _logger.warning(msg, k, self._table, self._table, k)
                             cr.commit()
 
-        else:
-            cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
-            create = not bool(cr.fetchone())
-
         cr.commit()     # start a new transaction
 
         if self._auto:
             self._add_sql_constraints(cr)
 
-        if create:
-            self._execute_sql(cr)
-
         if store_compute:
             self._parent_store_compute(cr)
             cr.commit()
 
-        return todo_end
+        return stored_fields
+
+    def init(self, cr):
+        pass
 
     def _auto_end(self, cr, context=None):
         """ Create the foreign keys recorded by _auto_init. """
@@ -3228,6 +3176,9 @@
         cr.commit()
         del self._foreign_keys
 
+        for k in self._defaults:
+            assert (k in self._columns) or (k in self._inherit_fields), 'Default function defined in %s but field %s does not exist !' % (self._name, k,)
+
 
     def _table_exist(self, cr):
         cr.execute("SELECT relname FROM pg_class WHERE relkind IN ('r','v') AND relname=%s", (self._table,))
@@ -3393,15 +3344,6 @@
                     cr.rollback()
 
 
-    def _execute_sql(self, cr):
-        """ Execute the SQL code from the _sql attribute (if any)."""
-        if hasattr(self, "_sql"):
-            for line in self._sql.split(';'):
-                line2 = line.replace('\n', '').strip()
-                if line2:
-                    cr.execute(line2)
-                    cr.commit()
-
     #
     # Update objects that uses this one to update their _inherits fields
     #

=== modified file 'openerp/service/__init__.py'
--- openerp/service/__init__.py	2013-06-12 15:28:26 +0000
+++ openerp/service/__init__.py	2013-07-10 14:52:28 +0000
@@ -60,7 +60,12 @@
 def load_server_wide_modules():
     for m in openerp.conf.server_wide_modules:
         try:
-            openerp.modules.module.load_openerp_module(m)
+            __import__('openerp.addons.' + m)
+            mod = sys.modules['openerp.addons.' + m]
+            post_load = mod.openerp_descriptor['post_load']
+            if post_load:
+                getattr(mod, post_load)()
+
         except Exception:
             msg = ''
             if m == 'web':

=== added directory 'openerp/tests/addons/test_base_model_a'
=== added file 'openerp/tests/addons/test_base_model_a/__init__.py'
--- openerp/tests/addons/test_base_model_a/__init__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_a/__init__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+import models
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_a/__openerp__.py'
--- openerp/tests/addons/test_base_model_a/__openerp__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_a/__openerp__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+{
+    'name': 'test-base-model-a',
+    'version': '0.1',
+    'category': 'Tests',
+    'description': """A module to test the BaseModel inheritance.""",
+    'author': 'OpenERP SA',
+    'maintainer': 'OpenERP SA',
+    'website': 'http://www.openerp.com',
+    'depends': ['base'],
+    'data': [],
+    'installable': True,
+    'auto_install': False,
+}
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_a/models.py'
--- openerp/tests/addons/test_base_model_a/models.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_a/models.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+import openerp
+
+class a(openerp.osv.orm.Model):
+    """ This model is just a copy of BaseModel.
+    In the context of the base.model tests, we will check if the _columns of
+    this model is indeed the consolidated _colmuns of base.model.
+
+    This test module will first add a column_n to base.model and thus we will
+    check in the unit tests if test.base.model.a contains it.
+
+    In the second test_base_model_b addons, we will add a column_o and again
+    check if test.base.model.a contains it in addition to column_n.
+    """
+    _name = 'test.base.model.a'
+
+class n(openerp.osv.orm.AbstractModel):
+    """ This model augments BaseModel.
+    """
+    _inherit = 'base.model'
+
+    _columns = {
+        'column_n': openerp.osv.fields.char(),
+    }
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added directory 'openerp/tests/addons/test_base_model_a/tests'
=== added file 'openerp/tests/addons/test_base_model_a/tests/__init__.py'
--- openerp/tests/addons/test_base_model_a/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_a/tests/__init__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from . import test_base_model
+
+fast_suite = [
+]
+
+checks = [
+  # This test assumes to be installed alone.
+  # test_base_model,
+]
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_a/tests/test_base_model.py'
--- openerp/tests/addons/test_base_model_a/tests/test_base_model.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_a/tests/test_base_model.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+import openerp.modules.registry
+import openerp
+
+from openerp.tests import common
+from openerp.tools.misc import mute_logger
+
+class test_base_model_a(common.TransactionCase):
+
+    def __init__(self, *args, **kwargs):
+        super(test_base_model_a, self).__init__(*args, **kwargs)
+        self.model = None
+
+    def setUp(self):
+        super(test_base_model_a, self).setUp()
+        self.model_a = self.registry('test.base.model.a')
+
+    def test_model_name(self):
+        self.assertEqual(
+            self.model_a._name,
+            'test.base.model.a')
+
+    def test_model_columns(self):
+        self.assertEqual(
+            self.model_a._columns.keys(),
+	    ['column_n'])
+
+    def test_model_inherit(self):
+        self.assertEqual(
+            self.model_a._inherit,
+            'base.model')
+
+    def test_model_table(self):
+        # Assert no table is backing base.model.
+        self.cr.execute("SELECT relname FROM pg_class WHERE relkind = 'r' AND relname=%s", ('base_model',))
+        self.assertTrue(not self.cr.dictfetchall())
+
+        # Make sure the previous assertion works.
+        self.cr.execute("SELECT relname FROM pg_class WHERE relkind = 'r' AND relname=%s", ('res_partner',))
+        self.assertTrue(self.cr.dictfetchall())

=== added directory 'openerp/tests/addons/test_base_model_b'
=== added file 'openerp/tests/addons/test_base_model_b/__init__.py'
--- openerp/tests/addons/test_base_model_b/__init__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_b/__init__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,3 @@
+# -*- coding: utf-8 -*-
+import models
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_b/__openerp__.py'
--- openerp/tests/addons/test_base_model_b/__openerp__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_b/__openerp__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+{
+    'name': 'test-base-model-b',
+    'version': '0.1',
+    'category': 'Tests',
+    'description': """A module to test the BaseModel inheritance.""",
+    'author': 'OpenERP SA',
+    'maintainer': 'OpenERP SA',
+    'website': 'http://www.openerp.com',
+    'depends': ['base', 'test_base_model_a'],
+    'data': [],
+    'installable': True,
+    'auto_install': False,
+}
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_b/models.py'
--- openerp/tests/addons/test_base_model_b/models.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_b/models.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+import openerp
+
+class b(openerp.osv.orm.Model):
+    """ This model is just a copy of BaseModel.
+    """
+    _name = 'test.base.model.b'
+
+class o(openerp.osv.orm.AbstractModel):
+    """ This model augments BaseModel.
+    """
+    _inherit = 'base.model'
+
+    _columns = {
+        'column_o': openerp.osv.fields.char(),
+    }
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added directory 'openerp/tests/addons/test_base_model_b/tests'
=== added file 'openerp/tests/addons/test_base_model_b/tests/__init__.py'
--- openerp/tests/addons/test_base_model_b/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_b/tests/__init__.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+from . import test_base_model
+
+fast_suite = [
+]
+
+checks = [
+  # This test assumes to be installed alone.
+  # test_base_model,
+]
+
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== added file 'openerp/tests/addons/test_base_model_b/tests/test_base_model.py'
--- openerp/tests/addons/test_base_model_b/tests/test_base_model.py	1970-01-01 00:00:00 +0000
+++ openerp/tests/addons/test_base_model_b/tests/test_base_model.py	2013-07-10 14:52:28 +0000
@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+import openerp.modules.registry
+import openerp
+
+from openerp.tests import common
+from openerp.tools.misc import mute_logger
+
+class test_base_model_b(common.TransactionCase):
+
+    def __init__(self, *args, **kwargs):
+        super(test_base_model_b, self).__init__(*args, **kwargs)
+        self.model = None
+
+    def setUp(self):
+        super(test_base_model_b, self).setUp()
+        self.model_a = self.registry('test.base.model.a')
+        self.model_b = self.registry('test.base.model.b')
+
+    def test_model_name(self):
+        self.assertEqual(
+            self.model_a._name,
+            'test.base.model.a')
+        self.assertEqual(
+            self.model_b._name,
+            'test.base.model.b')
+
+    def test_model_columns(self):
+        self.assertEqual(
+            sorted(self.model_a._columns.keys()),
+	    ['column_n', 'column_o'])
+        self.assertEqual(
+            sorted(self.model_b._columns.keys()),
+	    ['column_n', 'column_o'])
+
+    def test_model_inherit(self):
+        self.assertEqual(
+            self.model_a._inherit,
+            'base.model')
+        self.assertEqual(
+            self.model_b._inherit,
+            'base.model')
+
+    def test_model_table(self):
+        # Assert no table is backing base.model.
+        self.cr.execute("SELECT relname FROM pg_class WHERE relkind = 'r' AND relname=%s", ('base_model',))
+        self.assertTrue(not self.cr.dictfetchall())
+
+        # Make sure the previous assertion works.
+        self.cr.execute("SELECT relname FROM pg_class WHERE relkind = 'r' AND relname=%s", ('res_partner',))
+        self.assertTrue(self.cr.dictfetchall())