[MIG] openerp.modules: convert code to the new API

Also, convert function `init_models` to a registry method.

6 files changed, 112 insertions, 100 deletions

diff --git a/openerp/addons/base/ir/ir_http.py b/openerp/addons/base/ir/ir_http.py
index 2de1441ab93..e52929ebc2d 100644
--- a/openerp/addons/base/ir/ir_http.py
+++ b/openerp/addons/base/ir/ir_http.py
@@ -210,9 +210,12 @@ class IrHttp(models.AbstractModel):
             # of the model, each instance will regenared its own routing map and thus
             # regenerate its EndPoint. The routing map should be static.
             type(self)._routing_map = http.routing_map(mods, False, converters=self._get_converters())
-
         return self._routing_map
 
+    def _clear_routing_map(self):
+        if hasattr(self, '_routing_map'):
+            del type(self)._routing_map
+
     def content_disposition(self, filename):
         filename = tools.ustr(filename)
         escaped = urllib2.quote(filename.encode('utf8'))
diff --git a/openerp/addons/base/ir/ir_model.py b/openerp/addons/base/ir/ir_model.py
index c4e6af26687..eb175a69583 100644
--- a/openerp/addons/base/ir/ir_model.py
+++ b/openerp/addons/base/ir/ir_model.py
@@ -5,7 +5,6 @@ from collections import defaultdict
 
 from odoo import api, fields, models, SUPERUSER_ID, tools,  _
 from odoo.exceptions import AccessError, UserError, ValidationError
-from odoo.modules import init_models
 from odoo.modules.registry import RegistryManager
 from odoo.tools.safe_eval import safe_eval
 
@@ -150,8 +149,7 @@ class IrModel(models.Model):
             # setup models; this automatically adds model in registry
             self.pool.setup_models(self._cr, partial=(not self.pool.ready))
             # update database schema
-            model = self.pool[vals['model']]
-            init_models([model], self._cr, dict(self._context, update_custom_fields=True))
+            self.pool.init_models(self._cr, [vals['model']], dict(self._context, update_custom_fields=True))
             RegistryManager.signal_registry_change(self._cr.dbname)
         return res
 
@@ -444,8 +442,7 @@ class IrModelFields(models.Model):
                 # setup models; this re-initializes model in registry
                 self.pool.setup_models(self._cr, partial=(not self.pool.ready))
                 # update database schema
-                model = self.pool[vals['model']]
-                init_models([model], self._cr, dict(self._context, update_custom_fields=True))
+                self.pool.init_models(self._cr, [vals['model']], dict(self._context, update_custom_fields=True))
                 RegistryManager.signal_registry_change(self._cr.dbname)
 
         return res
@@ -527,8 +524,7 @@ class IrModelFields(models.Model):
 
         if patched_models:
             # update the database schema of the models to patch
-            models = [self.pool[name] for name in patched_models]
-            init_models(models, self._cr, dict(self._context, update_custom_fields=True))
+            self.pool.init_models(self._cr, patched_models, dict(self._context, update_custom_fields=True))
 
         if column_rename or patched_models:
             RegistryManager.signal_registry_change(self._cr.dbname)
diff --git a/openerp/modules/__init__.py b/openerp/modules/__init__.py
index c3bc3a337bd..a6be26492af 100644
--- a/openerp/modules/__init__.py
+++ b/openerp/modules/__init__.py
@@ -9,7 +9,15 @@ from . import db, graph, loading, migration, module, registry
 
 from openerp.modules.loading import load_modules
 
-from openerp.modules.module import get_modules, get_modules_with_version, \
-    load_information_from_description_file, get_module_resource, get_module_path, \
-    initialize_sys_path, load_openerp_module, init_models, adapt_version, \
-    get_resource_path, get_resource_from_path
+from openerp.modules.module import (
+    adapt_version,
+    get_module_path,
+    get_module_resource,
+    get_modules,
+    get_modules_with_version,
+    get_resource_from_path,
+    get_resource_path,
+    initialize_sys_path,
+    load_information_from_description_file,
+    load_openerp_module,
+)
diff --git a/openerp/modules/loading.py b/openerp/modules/loading.py
index 05b68e9ef1d..3f20a37f723 100644
--- a/openerp/modules/loading.py
+++ b/openerp/modules/loading.py
@@ -7,7 +7,6 @@
 
 import itertools
 import logging
-import os
 import sys
 import threading
 import time
@@ -18,12 +17,10 @@ import openerp.modules.graph
 import openerp.modules.migration
 import openerp.modules.registry
 import openerp.tools as tools
-from openerp import SUPERUSER_ID
 
-from openerp.tools.translate import _
-from openerp.modules.module import initialize_sys_path, \
-    load_openerp_module, init_models, adapt_version
-from module import runs_post_install
+from openerp import api, SUPERUSER_ID
+from openerp.modules.module import adapt_version, initialize_sys_path, \
+                                   load_openerp_module, runs_post_install
 
 _logger = logging.getLogger(__name__)
 _test_logger = logging.getLogger('openerp.tests')
@@ -131,12 +128,12 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
             if pre_init:
                 getattr(py_module, pre_init)(cr)
 
-        models = registry.load(cr, package)
+        model_names = registry.load(cr, package)
 
         loaded_modules.append(package.name)
         if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):
             registry.setup_models(cr, partial=True)
-            init_models(models, cr, {'module': package.name})
+            registry.init_models(cr, model_names, {'module': package.name})
 
         idref = {}
 
@@ -145,27 +142,29 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
             mode = 'init'
 
         if hasattr(package, 'init') or hasattr(package, 'update') or package.state in ('to install', 'to upgrade'):
+            env = api.Environment(cr, SUPERUSER_ID, {})
             # Can't put this line out of the loop: ir.module.module will be
             # registered by init_models() above.
-            modobj = registry['ir.module.module']
+            module = env['ir.module.module'].browse(module_id)
 
             if perform_checks:
-                modobj.check(cr, SUPERUSER_ID, [module_id])
+                module.check()
 
             if package.state=='to upgrade':
                 # upgrading the module information
-                modobj.write(cr, SUPERUSER_ID, [module_id], modobj.get_values_from_terp(package.data))
+                module.write(module.get_values_from_terp(package.data))
             _load_data(cr, module_name, idref, mode, kind='data')
             has_demo = hasattr(package, 'demo') or (package.dbdemo and package.state != 'installed')
             if has_demo:
                 _load_data(cr, module_name, idref, mode, kind='demo')
                 cr.execute('update ir_module_module set demo=%s where id=%s', (True, module_id))
-                modobj.invalidate_cache(cr, SUPERUSER_ID, ['demo'], [module_id])
+                module.invalidate_cache(['demo'])
 
             migrations.migrate_module(package, 'post')
 
             # Update translations for all installed languages
-            modobj.update_translations(cr, SUPERUSER_ID, [module_id], None, {'overwrite': openerp.tools.config["overwrite_existing_translations"]})
+            overwrite = openerp.tools.config["overwrite_existing_translations"]
+            module.with_context(overwrite=overwrite).update_translations()
 
             registry._init_modules.add(package.name)
 
@@ -175,7 +174,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
                     getattr(py_module, post_init)(cr, registry)
 
             # validate all the views at a whole
-            registry['ir.ui.view']._validate_module_views(cr, SUPERUSER_ID, module_name)
+            env['ir.ui.view']._validate_module_views(module_name)
 
             if has_demo:
                 # launch tests only in demo mode, allowing tests to use demo data.
@@ -183,17 +182,14 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
                     # Yamel test
                     report.record_result(load_test(module_name, idref, mode))
                     # Python tests
-                    ir_http = registry['ir.http']
-                    if hasattr(ir_http, '_routing_map'):
-                        # Force routing map to be rebuilt between each module test suite
-                        del(type(ir_http)._routing_map)
+                    env['ir.http']._clear_routing_map()     # force routing map to be rebuilt
                     report.record_result(openerp.modules.module.run_unit_tests(module_name, cr.dbname))
 
             processed_modules.append(package.name)
 
             ver = adapt_version(package.data['version'])
             # Set new modules and dependencies
-            modobj.write(cr, SUPERUSER_ID, [module_id], {'state': 'installed', 'latest_version': ver})
+            module.write({'state': 'installed', 'latest_version': ver})
 
             package.state = 'installed'
             for kind in ('init', 'demo', 'update'):
@@ -264,6 +260,7 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
         # This is a brand new registry, just created in
         # openerp.modules.registry.RegistryManager.new().
         registry = openerp.registry(cr.dbname)
+        env = api.Environment(cr, SUPERUSER_ID, {})
 
         if 'base' in tools.config['update'] or 'all' in tools.config['update']:
             cr.execute("update ir_module_module set state=%s where name=%s and state=%s", ('to upgrade', 'base', 'installed'))
@@ -291,27 +288,27 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
 
         # STEP 2: Mark other modules to be loaded/updated
         if update_module:
-            modobj = registry['ir.module.module']
+            Module = env['ir.module.module']
             if ('base' in tools.config['init']) or ('base' in tools.config['update']):
                 _logger.info('updating modules list')
-                modobj.update_list(cr, SUPERUSER_ID)
+                Module.update_list()
 
             _check_module_names(cr, itertools.chain(tools.config['init'].keys(), tools.config['update'].keys()))
 
-            mods = [k for k in tools.config['init'] if tools.config['init'][k]]
-            if mods:
-                ids = modobj.search(cr, SUPERUSER_ID, ['&', ('state', '=', 'uninstalled'), ('name', 'in', mods)])
-                if ids:
-                    modobj.button_install(cr, SUPERUSER_ID, ids)
+            module_names = [k for k, v in tools.config['init'].items() if v]
+            if module_names:
+                modules = Module.search([('state', '=', 'uninstalled'), ('name', 'in', module_names)])
+                if modules:
+                    modules.button_install()
 
-            mods = [k for k in tools.config['update'] if tools.config['update'][k]]
-            if mods:
-                ids = modobj.search(cr, SUPERUSER_ID, ['&', ('state', '=', 'installed'), ('name', 'in', mods)])
-                if ids:
-                    modobj.button_upgrade(cr, SUPERUSER_ID, ids)
+            module_names = [k for k, v in tools.config['update'].items() if v]
+            if module_names:
+                modules = Module.search([('state', '=', 'installed'), ('name', 'in', module_names)])
+                if modules:
+                    modules.button_upgrade()
 
             cr.execute("update ir_module_module set state=%s where name=%s", ('installed', 'base'))
-            modobj.invalidate_cache(cr, SUPERUSER_ID, ['state'])
+            Module.invalidate_cache(['state'])
 
 
         # STEP 3: Load marked modules (skipping base which was done in STEP 1)
@@ -345,7 +342,7 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
         if processed_modules:
             cr.execute("""select model,name from ir_model where id NOT IN (select distinct model_id from ir_model_access)""")
             for (model, name) in cr.fetchall():
-                if model in registry and not registry[model].is_transient() and not isinstance(registry[model], openerp.osv.orm.AbstractModel):
+                if model in registry and not registry[model]._abstract and not registry[model]._transient:
                     _logger.warning('The model %s has no access rules, consider adding one. E.g. access_%s,access_%s,model_%s,,1,0,0,0',
                         model, model.replace('.', '_'), model.replace('.', '_'), model.replace('.', '_'))
 
@@ -353,18 +350,18 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
             # been replaced by owner-only access rights
             cr.execute("""select distinct mod.model, mod.name from ir_model_access acc, ir_model mod where acc.model_id = mod.id""")
             for (model, name) in cr.fetchall():
-                if model in registry and registry[model].is_transient():
+                if model in registry and registry[model]._transient:
                     _logger.warning('The transient model %s (%s) should not have explicit access rules!', model, name)
 
             cr.execute("SELECT model from ir_model")
             for (model,) in cr.fetchall():
                 if model in registry:
-                    registry[model]._check_removed_columns(cr, log=True)
+                    env[model]._check_removed_columns(log=True)
                 else:
                     _logger.warning("Model %s is declared but cannot be loaded! (Perhaps a module was partially removed or renamed)", model)
 
             # Cleanup orphan records
-            registry['ir.model.data']._process_end(cr, SUPERUSER_ID, processed_modules)
+            env['ir.model.data']._process_end(processed_modules)
 
         for kind in ('init', 'demo', 'update'):
             tools.config[kind] = {}
@@ -385,20 +382,21 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
                         py_module = sys.modules['openerp.addons.%s' % (pkg.name,)]
                         getattr(py_module, uninstall_hook)(cr, registry)
 
-                registry['ir.module.module'].module_uninstall(cr, SUPERUSER_ID, modules_to_remove.values())
+                Module = env['ir.module.module']
+                Module.browse(modules_to_remove.values()).module_uninstall()
                 # Recursive reload, should only happen once, because there should be no
                 # modules to remove next time
                 cr.commit()
                 _logger.info('Reloading registry once more after uninstalling modules')
-                openerp.api.Environment.reset()
+                api.Environment.reset()
                 return openerp.modules.registry.RegistryManager.new(cr.dbname, force_demo, status, update_module)
 
         # STEP 6: verify custom views on every model
         if update_module:
-            Views = registry['ir.ui.view']
+            View = env['ir.ui.view']
             custom_view_test = True
-            for model in registry.models.keys():
-                if not Views._validate_custom_views(cr, SUPERUSER_ID, model):
+            for model in registry:
+                if not View._validate_custom_views(model):
                     custom_view_test = False
                     _logger.error('invalid custom view(s) for model %s', model)
             report.record_result(custom_view_test)
@@ -409,8 +407,8 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
             _logger.info('Modules loaded.')
 
         # STEP 8: call _register_hook on every model
-        for model in registry.models.values():
-            model._register_hook(cr)
+        for model in env.values():
+            model._register_hook()
 
         # STEP 9: Run the post-install tests
         cr.commit()
diff --git a/openerp/modules/module.py b/openerp/modules/module.py
index abc14bfc841..f1812d86350 100644
--- a/openerp/modules/module.py
+++ b/openerp/modules/module.py
@@ -18,11 +18,10 @@ import threading
 from operator import itemgetter
 from os.path import join as opj
 
-
 import openerp
 import openerp.tools as tools
 import openerp.release as release
-from openerp import SUPERUSER_ID
+from openerp import SUPERUSER_ID, api
 from openerp.tools.safe_eval import safe_eval
 
 MANIFEST = '__openerp__.py'
@@ -341,34 +340,6 @@ def load_information_from_description_file(module, mod_path=None):
     _logger.debug('module %s: no %s file found.', module, MANIFEST)
     return {}
 
-def init_models(models, cr, context):
-    """ Initialize a list of models.
-
-    Call methods ``_auto_init``, ``init``, and ``_auto_end`` on each model to
-    create or update the database tables supporting the models.
-
-    The context may contain the following items:
-     - ``module``: the name of the module being installed/updated, if any;
-     - ``update_custom_fields``: whether custom fields should be updated.
-
-    """
-    if 'module' in context:
-        _logger.info('module %s: creating or updating database tables', context['module'])
-    context = dict(context, todo=[])
-    models = [model.browse(cr, SUPERUSER_ID, [], context) for model in models]
-    for model in models:
-        model._auto_init()
-        model.init()
-        cr.commit()
-    for model in models:
-        model._auto_end()
-        cr.commit()
-    for _, func, args in sorted(context['todo'], key=itemgetter(0)):
-        func(*args)
-    if models:
-        models[0].recompute()
-    cr.commit()
-
 def load_openerp_module(module_name):
     """ Load an OpenERP module, if not already loaded.
 
diff --git a/openerp/modules/registry.py b/openerp/modules/registry.py
index 1de9114d01a..97cb20866c6 100644
--- a/openerp/modules/registry.py
+++ b/openerp/modules/registry.py
@@ -136,9 +136,10 @@ class Registry(Mapping):
         return self._fields_by_model[model_name]
 
     def do_parent_store(self, cr):
-        for model in self._init_parent:
-            if model in self:
-                self[model]._parent_store_compute(cr)
+        env = openerp.api.Environment(cr, SUPERUSER_ID, {})
+        for model_name in self._init_parent:
+            if model_name in env:
+                env[model_name]._parent_store_compute()
         self._init = False
 
     def obj_list(self):
@@ -150,7 +151,8 @@ class Registry(Mapping):
         self.models[model_name] = model
 
     def load(self, cr, module):
-        """ Load a given module in the registry.
+        """ Load a given module in the registry, and return the names of the
+        modified models.
 
         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
@@ -176,7 +178,7 @@ class Registry(Mapping):
             model = cls._build_model(self, cr)
             mark_loaded(model)
 
-        return map(self, loaded_models)
+        return list(loaded_models)
 
     def setup_models(self, cr, partial=False):
         """ Complete the setup of models.
@@ -185,27 +187,61 @@ class Registry(Mapping):
             :param partial: ``True`` if all models have not been loaded yet.
         """
         lazy_property.reset_all(self)
+        env = openerp.api.Environment(cr, SUPERUSER_ID, {})
 
         # load custom models
-        ir_model = self['ir.model']
+        ir_model = env['ir.model']
         cr.execute('SELECT * FROM ir_model WHERE state=%s', ('manual',))
         for model_data in cr.dictfetchall():
-            ir_model._instanciate(cr, SUPERUSER_ID, model_data, {})
+            ir_model._instanciate(model_data)
 
         # prepare the setup on all models
-        for model in self.models.itervalues():
-            model._prepare_setup(cr, SUPERUSER_ID)
+        models = [env[model_name] for model_name in self.models]
+        for model in models:
+            model._prepare_setup()
 
         # do the actual setup from a clean state
         self._m2m = {}
-        for model in self.models.itervalues():
-            model._setup_base(cr, SUPERUSER_ID, partial)
+        for model in models:
+            model._setup_base(partial)
 
-        for model in self.models.itervalues():
-            model._setup_fields(cr, SUPERUSER_ID, partial)
+        for model in models:
+            model._setup_fields(partial)
 
-        for model in self.models.itervalues():
-            model._setup_complete(cr, SUPERUSER_ID)
+        for model in models:
+            model._setup_complete()
+
+    def init_models(self, cr, model_names, context):
+        """ Initialize a list of models (given by their name). Call methods
+            ``_auto_init``, ``init``, and ``_auto_end`` on each model to create
+            or update the database tables supporting the models.
+
+            The ``context`` may contain the following items:
+             - ``module``: the name of the module being installed/updated, if any;
+             - ``update_custom_fields``: whether custom fields should be updated.
+        """
+        if 'module' in context:
+            _logger.info('module %s: creating or updating database tables', context['module'])
+
+        context = dict(context, todo=[])
+        env = openerp.api.Environment(cr, SUPERUSER_ID, context)
+        models = [env[model_name] for model_name in model_names]
+
+        for model in models:
+            model._auto_init()
+            model.init()
+            cr.commit()
+
+        for model in models:
+            model._auto_end()
+            cr.commit()
+
+        for _, func, args in sorted(context['todo']):
+            func(*args)
+
+        if models:
+            models[0].recompute()
+        cr.commit()
 
     def clear_caches(self):
         """ Clear the caches