[FIX] odoo: rename imports and adapt import hooks

7 files changed, 90 insertions, 91 deletions

diff --git a/odoo/modules/__init__.py b/odoo/modules/__init__.py
index a6be26492af..530f81ff5e3 100644
--- a/odoo/modules/__init__.py
+++ b/odoo/modules/__init__.py
@@ -7,9 +7,9 @@
 
 from . import db, graph, loading, migration, module, registry
 
-from openerp.modules.loading import load_modules
+from odoo.modules.loading import load_modules
 
-from openerp.modules.module import (
+from odoo.modules.module import (
     adapt_version,
     get_module_path,
     get_module_resource,
diff --git a/odoo/modules/db.py b/odoo/modules/db.py
index 66051f8ca4d..f2592f947e2 100644
--- a/odoo/modules/db.py
+++ b/odoo/modules/db.py
@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
-import openerp.modules
+import odoo.modules
 import logging
 
 _logger = logging.getLogger(__name__)
@@ -23,25 +23,25 @@ def initialize(cr):
     and ir_model_data entries.
 
     """
-    f = openerp.modules.get_module_resource('base', 'base.sql')
+    f = odoo.modules.get_module_resource('base', 'base.sql')
     if not f:
         m = "File not found: 'base.sql' (provided by module 'base')."
         _logger.critical(m)
         raise IOError(m)
-    base_sql_file = openerp.tools.misc.file_open(f)
+    base_sql_file = odoo.tools.misc.file_open(f)
     try:
         cr.execute(base_sql_file.read())
         cr.commit()
     finally:
         base_sql_file.close()
 
-    for i in openerp.modules.get_modules():
-        mod_path = openerp.modules.get_module_path(i)
+    for i in odoo.modules.get_modules():
+        mod_path = odoo.modules.get_module_path(i)
         if not mod_path:
             continue
 
         # This will raise an exception if no/unreadable descriptor file.
-        info = openerp.modules.load_information_from_description_file(i)
+        info = odoo.modules.load_information_from_description_file(i)
 
         if not info:
             continue
diff --git a/odoo/modules/graph.py b/odoo/modules/graph.py
index f3e7e485031..aaf90ae8443 100644
--- a/odoo/modules/graph.py
+++ b/odoo/modules/graph.py
@@ -8,15 +8,15 @@ from os.path import join as opj
 import itertools
 import zipimport
 
-import openerp
+import odoo
 
-import openerp.osv as osv
-import openerp.tools as tools
-import openerp.tools.osutil as osutil
-from openerp.tools.translate import _
+import odoo.osv as osv
+import odoo.tools as tools
+import odoo.tools.osutil as osutil
+from odoo.tools.translate import _
 
 import zipfile
-import openerp.release as release
+import odoo.release as release
 
 import re
 import base64
@@ -77,7 +77,7 @@ class Graph(dict):
             # This will raise an exception if no/unreadable descriptor file.
             # NOTE The call to load_information_from_description_file is already
             # done by db.initialize, so it is possible to not do it again here.
-            info = openerp.modules.module.load_information_from_description_file(module)
+            info = odoo.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
             else:
diff --git a/odoo/modules/loading.py b/odoo/modules/loading.py
index 56066ecc2ad..f379f55d3c0 100644
--- a/odoo/modules/loading.py
+++ b/odoo/modules/loading.py
@@ -11,19 +11,19 @@ import sys
 import threading
 import time
 
-import openerp
-import openerp.modules.db
-import openerp.modules.graph
-import openerp.modules.migration
-import openerp.modules.registry
-import openerp.tools as tools
+import odoo
+import odoo.modules.db
+import odoo.modules.graph
+import odoo.modules.migration
+import odoo.modules.registry
+import odoo.tools as tools
 
-from openerp import api, SUPERUSER_ID
-from openerp.modules.module import adapt_version, initialize_sys_path, \
-                                   load_openerp_module, runs_post_install
+from odoo import api, SUPERUSER_ID
+from odoo.modules.module import adapt_version, initialize_sys_path, \
+                                load_openerp_module, runs_post_install
 
 _logger = logging.getLogger(__name__)
-_test_logger = logging.getLogger('openerp.tests')
+_test_logger = logging.getLogger('odoo.tests')
 
 
 def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=None, report=None):
@@ -50,7 +50,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
             else:
                 cr.rollback()
                 # avoid keeping stale xml_id, etc. in cache
-                openerp.registry(cr.dbname).clear_caches()
+                odoo.registry(cr.dbname).clear_caches()
 
 
     def _get_files_of_kind(kind):
@@ -99,8 +99,8 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
 
     processed_modules = []
     loaded_modules = []
-    registry = openerp.registry(cr.dbname)
-    migrations = openerp.modules.migration.MigrationManager(cr, graph)
+    registry = odoo.registry(cr.dbname)
+    migrations = odoo.modules.migration.MigrationManager(cr, graph)
     module_count = len(graph)
     _logger.info('loading %d modules...', module_count)
 
@@ -108,7 +108,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
 
     # register, instantiate and initialize models for each modules
     t0 = time.time()
-    t0_sql = openerp.sql_db.sql_counter
+    t0_sql = odoo.sql_db.sql_counter
 
     for index, package in enumerate(graph, 1):
         module_name = package.name
@@ -123,7 +123,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
 
         new_install = package.state == 'to install'
         if new_install:
-            py_module = sys.modules['openerp.addons.%s' % (module_name,)]
+            py_module = sys.modules['odoo.addons.%s' % (module_name,)]
             pre_init = package.info.get('pre_init_hook')
             if pre_init:
                 getattr(py_module, pre_init)(cr)
@@ -163,7 +163,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
             migrations.migrate_module(package, 'post')
 
             # Update translations for all installed languages
-            overwrite = openerp.tools.config["overwrite_existing_translations"]
+            overwrite = odoo.tools.config["overwrite_existing_translations"]
             module.with_context(overwrite=overwrite).update_translations()
 
             registry._init_modules.add(package.name)
@@ -183,7 +183,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
                     report.record_result(load_test(module_name, idref, mode))
                     # Python tests
                     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))
+                    report.record_result(odoo.modules.module.run_unit_tests(module_name, cr.dbname))
 
             processed_modules.append(package.name)
 
@@ -199,7 +199,7 @@ def load_module_graph(cr, graph, status=None, perform_checks=True, skip_modules=
         registry._init_modules.add(package.name)
         cr.commit()
 
-    _logger.log(25, "%s modules loaded in %.2fs, %s queries", len(graph), time.time() - t0, openerp.sql_db.sql_counter - t0_sql)
+    _logger.log(25, "%s modules loaded in %.2fs, %s queries", len(graph), time.time() - t0, odoo.sql_db.sql_counter - t0_sql)
 
     registry.clear_manual_fields()
 
@@ -248,9 +248,9 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
 
     cr = db.cursor()
     try:
-        if not openerp.modules.db.is_initialized(cr):
+        if not odoo.modules.db.is_initialized(cr):
             _logger.info("init db")
-            openerp.modules.db.initialize(cr)
+            odoo.modules.db.initialize(cr)
             update_module = True # process auto-installed modules
             tools.config["init"]["all"] = 1
             tools.config['update']['all'] = 1
@@ -258,15 +258,15 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
                 tools.config["demo"]['all'] = 1
 
         # This is a brand new registry, just created in
-        # openerp.modules.registry.Registry.new().
-        registry = openerp.registry(cr.dbname)
+        # odoo.modules.registry.Registry.new().
+        registry = odoo.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'))
 
         # STEP 1: LOAD BASE (must be done before module dependencies can be computed for later steps)
-        graph = openerp.modules.graph.Graph()
+        graph = odoo.modules.graph.Graph()
         graph.add_module(cr, 'base', force)
         if not graph:
             _logger.critical('module base cannot be loaded! (hint: verify addons-path)')
@@ -379,7 +379,7 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
                 for pkg in pkgs:
                     uninstall_hook = pkg.info.get('uninstall_hook')
                     if uninstall_hook:
-                        py_module = sys.modules['openerp.addons.%s' % (pkg.name,)]
+                        py_module = sys.modules['odoo.addons.%s' % (pkg.name,)]
                         getattr(py_module, uninstall_hook)(cr, registry)
 
                 Module = env['ir.module.module']
@@ -389,7 +389,7 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
                 cr.commit()
                 _logger.info('Reloading registry once more after uninstalling modules')
                 api.Environment.reset()
-                return openerp.modules.registry.Registry.new(cr.dbname, force_demo, status, update_module)
+                return odoo.modules.registry.Registry.new(cr.dbname, force_demo, status, update_module)
 
         # STEP 6: verify custom views on every model
         if update_module:
@@ -414,14 +414,14 @@ def load_modules(db, force_demo=False, status=None, update_module=False):
         cr.commit()
 
         t0 = time.time()
-        t0_sql = openerp.sql_db.sql_counter
-        if openerp.tools.config['test_enable']:
+        t0_sql = odoo.sql_db.sql_counter
+        if odoo.tools.config['test_enable']:
             if update_module:
                 cr.execute("SELECT name FROM ir_module_module WHERE state='installed' and name = ANY(%s)", (processed_modules,))
             else:
                 cr.execute("SELECT name FROM ir_module_module WHERE state='installed'")
             for module_name in cr.fetchall():
-                report.record_result(openerp.modules.module.run_unit_tests(module_name[0], cr.dbname, position=runs_post_install))
-            _logger.log(25, "All post-tested in %.2fs, %s queries", time.time() - t0, openerp.sql_db.sql_counter - t0_sql)
+                report.record_result(odoo.modules.module.run_unit_tests(module_name[0], cr.dbname, position=runs_post_install))
+            _logger.log(25, "All post-tested in %.2fs, %s queries", time.time() - t0, odoo.sql_db.sql_counter - t0_sql)
     finally:
         cr.close()
diff --git a/odoo/modules/migration.py b/odoo/modules/migration.py
index 9776a6816ad..67f1d4d5c89 100644
--- a/odoo/modules/migration.py
+++ b/odoo/modules/migration.py
@@ -8,10 +8,10 @@ import logging
 import os
 from os.path import join as opj
 
-import openerp
-import openerp.release as release
-import openerp.tools as tools
-from openerp.tools.parse_version import parse_version
+import odoo
+import odoo.release as release
+import odoo.tools as tools
+from odoo.tools.parse_version import parse_version
 
 
 _logger = logging.getLogger(__name__)
@@ -60,7 +60,7 @@ class MigrationManager(object):
             if not (hasattr(pkg, 'update') or pkg.state == 'to upgrade'):
                 continue
 
-            get_module_filetree = openerp.modules.module.get_module_filetree
+            get_module_filetree = odoo.modules.module.get_module_filetree
             self.migrations[pkg.name]['module'] = get_module_filetree(pkg.name, 'migrations') or {}
             self.migrations[pkg.name]['maintenance'] = get_module_filetree('base', 'maintenance/migrations/' + pkg.name) or {}
 
diff --git a/odoo/modules/module.py b/odoo/modules/module.py
index f1812d86350..bd850870e4d 100644
--- a/odoo/modules/module.py
+++ b/odoo/modules/module.py
@@ -18,11 +18,11 @@ 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, api
-from openerp.tools.safe_eval import safe_eval
+import odoo
+import odoo.tools as tools
+import odoo.release as release
+from odoo import SUPERUSER_ID, api
+from odoo.tools.safe_eval import safe_eval
 
 MANIFEST = '__openerp__.py'
 README = ['README.rst', 'README.md', 'README.txt']
@@ -37,8 +37,8 @@ hooked = False
 loaded = []
 
 class AddonsHook(object):
-    """ Makes modules accessible through openerp.addons.* and odoo.addons.*
-    """
+    """ Makes modules accessible through openerp.addons.* and odoo.addons.* """
+
     def find_module(self, name, path):
         if name.startswith(('odoo.addons.', 'openerp.addons.'))\
                 and name.count('.') == 2:
@@ -61,8 +61,8 @@ class AddonsHook(object):
         if f: f.close()
 
         # TODO: fetch existing module from sys.modules if reloads permitted
-        # create empty openerp.addons.* module, set name
-        new_mod = types.ModuleType(openerp_name)
+        # create empty odoo.addons.* module, set name
+        new_mod = types.ModuleType(odoo_name)
         new_mod.__loader__ = self
 
         # module top-level can only be a package
@@ -70,18 +70,18 @@ class AddonsHook(object):
         modfile = opj(path, '__init__.py')
         new_mod.__file__ = modfile
         new_mod.__path__ = [path]
-        new_mod.__package__ = openerp_name
+        new_mod.__package__ = odoo_name
 
         # both base and alias should be in sys.modules to handle recursive and
         # corecursive situations
-        sys.modules[openerp_name] = sys.modules[odoo_name] = new_mod
+        sys.modules[odoo_name] = sys.modules[openerp_name] = new_mod
 
         # execute source in context of module *after* putting everything in
         # sys.modules, so recursive import works
         execfile(modfile, new_mod.__dict__)
 
         # people import openerp.addons and expect openerp.addons.<module> to work
-        setattr(openerp.addons, addon_name, new_mod)
+        setattr(odoo.addons, addon_name, new_mod)
 
         return sys.modules[name]
 # need to register loader with setuptools as Jinja relies on it when using
@@ -89,19 +89,18 @@ class AddonsHook(object):
 pkg_resources.register_loader_type(AddonsHook, pkg_resources.DefaultProvider)
 
 class OdooHook(object):
-    """ Makes odoo package also available as openerp
-    """
+    """ Makes odoo package also available as openerp """
 
     def find_module(self, name, path=None):
         # openerp.addons.<identifier> should already be matched by AddonsHook,
         # only framework and subdirectories of modules should match
-        if re.match(r'^odoo\b', name):
+        if re.match(r'^openerp\b', name):
             return self
 
     def load_module(self, name):
         assert name not in sys.modules
 
-        canonical = re.sub(r'^odoo(.*)', r'openerp\g<1>', name)
+        canonical = re.sub(r'^openerp(.*)', r'odoo\g<1>', name)
 
         if canonical in sys.modules:
             mod = sys.modules[canonical]
@@ -122,7 +121,7 @@ def initialize_sys_path():
     addons paths.
 
     This ensures something like ``import crm`` (or even
-    ``import openerp.addons.crm``) works even if the addons are not in the
+    ``import odoo.addons.crm``) works even if the addons are not in the
     PYTHONPATH.
     """
     global ad_paths
@@ -177,7 +176,7 @@ def get_module_filetree(module, dir='.'):
     if dir.startswith('..') or (dir and dir[0] == '/'):
         raise Exception('Cannot access file outside the module')
 
-    files = openerp.tools.osutil.listdir(path, True)
+    files = odoo.tools.osutil.listdir(path, True)
 
     tree = {}
     for f in files:
@@ -355,14 +354,14 @@ def load_openerp_module(module_name):
     initialize_sys_path()
     try:
         mod_path = get_module_path(module_name)
-        __import__('openerp.addons.' + module_name)
+        __import__('odoo.addons.' + 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'])()
+            getattr(sys.modules['odoo.addons.' + module_name], info['post_load'])()
 
     except Exception, e:
         msg = "Couldn't load module %s" % (module_name)
@@ -415,7 +414,7 @@ def get_test_modules(module):
     """ Return a list of module for the addons potentially containing tests to
     feed unittest.TestLoader.loadTestsFromModule() """
     # Try to import the module
-    modpath = 'openerp.addons.' + module
+    modpath = 'odoo.addons.' + module
     try:
         mod = importlib.import_module('.tests', modpath)
     except Exception, e:
@@ -436,7 +435,7 @@ def get_test_modules(module):
 
 # Use a custom stream object to log the test executions.
 class TestStream(object):
-    def __init__(self, logger_name='openerp.tests'):
+    def __init__(self, logger_name='odoo.tests'):
         self.logger = logging.getLogger(logger_name)
         self.r = re.compile(r'^-*$|^ *... *$|^ok$')
     def flush(self):
@@ -487,11 +486,11 @@ def run_unit_tests(module_name, dbname, position=runs_at_install):
 
         if suite.countTestCases():
             t0 = time.time()
-            t0_sql = openerp.sql_db.sql_counter
+            t0_sql = odoo.sql_db.sql_counter
             _logger.info('%s running tests.', m.__name__)
             result = unittest.TextTestRunner(verbosity=2, stream=TestStream(m.__name__)).run(suite)
             if time.time() - t0 > 5:
-                _logger.log(25, "%s tested in %.2fs, %s queries", m.__name__, time.time() - t0, openerp.sql_db.sql_counter - t0_sql)
+                _logger.log(25, "%s tested in %.2fs, %s queries", m.__name__, time.time() - t0, odoo.sql_db.sql_counter - t0_sql)
             if not result.wasSuccessful():
                 r = False
                 _logger.error("Module %s: %d failures, %d errors", module_name, len(result.failures), len(result.errors))
diff --git a/odoo/modules/registry.py b/odoo/modules/registry.py
index 7c9772c3881..aba103ffcfd 100644
--- a/odoo/modules/registry.py
+++ b/odoo/modules/registry.py
@@ -10,11 +10,11 @@ import logging
 import os
 import threading
 
-import openerp
+import odoo
 from .. import SUPERUSER_ID
-from openerp.tools import assertion_report, lazy_classproperty, config, \
+from odoo.tools import assertion_report, lazy_classproperty, config, \
                           lazy_property, topological_sort, OrderedSet
-from openerp.tools.lru import LRU
+from odoo.tools.lru import LRU
 
 _logger = logging.getLogger(__name__)
 
@@ -54,14 +54,14 @@ class Registry(Mapping):
                 return cls.new(db_name)
             finally:
                 # set db tracker - cleaned up at the WSGI dispatching phase in
-                # openerp.service.wsgi_server.application
+                # odoo.service.wsgi_server.application
                 threading.current_thread().dbname = db_name
 
     @classmethod
     def new(cls, db_name, force_demo=False, status=None, update_module=False):
         """ Create and return a new registry for the given database name. """
         with cls._lock:
-            with openerp.api.Environment.manage():
+            with odoo.api.Environment.manage():
                 registry = object.__new__(cls)
                 registry.init(db_name)
 
@@ -74,7 +74,7 @@ class Registry(Mapping):
                 try:
                     registry.setup_signaling()
                     # This should be a method on Registry
-                    openerp.modules.load_modules(registry._db, force_demo, status, update_module)
+                    odoo.modules.load_modules(registry._db, force_demo, status, update_module)
                 except Exception:
                     _logger.exception('Failed to load registry')
                     del cls.registries[db_name]
@@ -110,7 +110,7 @@ class Registry(Mapping):
         self._init_modules = set()
 
         self.db_name = db_name
-        self._db = openerp.sql_db.db_connect(db_name)
+        self._db = odoo.sql_db.db_connect(db_name)
 
         # special cursor for test mode; None means "normal" mode
         self.test_cr = None
@@ -118,7 +118,7 @@ class Registry(Mapping):
         # Indicates that the registry is 
         self.ready = False
 
-        # Inter-process signaling (used only when openerp.multi_process is True):
+        # Inter-process signaling (used only when odoo.multi_process is True):
         # The `base_registry_signaling` sequence indicates the whole registry
         # must be reloaded.
         # The `base_cache_signaling sequence` indicates all caches must be
@@ -132,10 +132,10 @@ class Registry(Mapping):
         self.cache_cleared = False
 
         with closing(self.cursor()) as cr:
-            has_unaccent = openerp.modules.db.has_unaccent(cr)
-            if openerp.tools.config['unaccent'] and not has_unaccent:
+            has_unaccent = odoo.modules.db.has_unaccent(cr)
+            if odoo.tools.config['unaccent'] and not has_unaccent:
                 _logger.warning("The option --unaccent was given but no unaccent() function was found in database.")
-            self.has_unaccent = openerp.tools.config['unaccent'] and has_unaccent
+            self.has_unaccent = odoo.tools.config['unaccent'] and has_unaccent
 
     @classmethod
     def delete(cls, db_name):
@@ -216,7 +216,7 @@ class Registry(Mapping):
         return self._fields_by_model[model_name]
 
     def do_parent_store(self, cr):
-        env = openerp.api.Environment(cr, SUPERUSER_ID, {})
+        env = odoo.api.Environment(cr, SUPERUSER_ID, {})
         for model_name in self._init_parent:
             if model_name in env:
                 env[model_name]._parent_store_compute()
@@ -259,7 +259,7 @@ 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, {})
+        env = odoo.api.Environment(cr, SUPERUSER_ID, {})
 
         # load custom models
         ir_model = env['ir.model']
@@ -296,7 +296,7 @@ class Registry(Mapping):
             _logger.info('module %s: creating or updating database tables', context['module'])
 
         context = dict(context, todo=[])
-        env = openerp.api.Environment(cr, SUPERUSER_ID, context)
+        env = odoo.api.Environment(cr, SUPERUSER_ID, context)
         models = [env[model_name] for model_name in model_names]
 
         for model in models:
@@ -325,7 +325,7 @@ class Registry(Mapping):
 
     def setup_signaling(self):
         """ Setup the inter-process signaling on this registry. """
-        if not openerp.multi_process:
+        if not odoo.multi_process:
             return
 
         with self.cursor() as cr:
@@ -351,7 +351,7 @@ class Registry(Mapping):
         """ Check whether the registry has changed, and performs all necessary
         operations to update the registry. Return an up-to-date registry.
         """
-        if not openerp.multi_process:
+        if not odoo.multi_process:
             return self
 
         with closing(self.cursor()) as cr:
@@ -377,7 +377,7 @@ class Registry(Mapping):
 
     def signal_registry_change(self):
         """ Notifies other processes that the registry has changed. """
-        if openerp.multi_process:
+        if odoo.multi_process:
             _logger.info("Registry changed, signaling through the database")
             with closing(self.cursor()) as cr:
                 cr.execute("select nextval('base_registry_signaling')")
@@ -385,7 +385,7 @@ class Registry(Mapping):
 
     def signal_caches_change(self):
         """ Notifies other processes if caches have been invalidated. """
-        if openerp.multi_process and self.cache_cleared:
+        if odoo.multi_process and self.cache_cleared:
             # signal it through the database to other processes
             _logger.info("At least one model cache has been invalidated, signaling through the database.")
             with closing(self.cursor()) as cr: