Merge lp:~openerp-dev/openerp-command/trunk-entry-points-cto into lp:openerp-command

[Samus CTO (OpenERP)]

[lp:~openerp-dev/openerp-command/trunk-entry-points-cto]

187. By Samus CTO (OpenERP) on 2012-11-27

[IMP] Missing calls to expand_path for addons paths

Unmerged revisions

187. By Samus CTO (OpenERP) on 2012-11-27

[IMP] Missing calls to expand_path for addons paths

186. By Samus CTO (OpenERP) on 2012-11-22

[IMP] Modules now use entry points and OE populate automatically

185. By Samus CTO (OpenERP) on 2012-11-06

[FIX] Agrolait's id has changed in default server demo data

184. By Samus CTO (OpenERP) on 2012-11-05

Updated TODO

=== modified file 'README'
--- README	2012-10-31 10:52:02 +0000
+++ README	2012-11-27 15:42:19 +0000
@@ -4,6 +4,6 @@
 ----
 
 - Make sure to have proper return code for success/failure.
-- `oe --help` is a mess (it seems argparse doesn't try to do something sensible).
 - Have a flag for `run-tests` to drop in the debugger (to be combined with
   unittest2 fail-fast mode?).
+- Make sure oe can do everything openerp-server can do

=== modified file 'openerpcommand/__init__.py'
--- openerpcommand/__init__.py	2012-11-05 11:27:01 +0000
+++ openerpcommand/__init__.py	2012-11-27 15:42:19 +0000
@@ -1,61 +1,104 @@
+"""
+OpenERP Command provides a set of command-line tools around the OpenERP
+framework: openobject-server. All the tools are sub-commands of a single
+oe executable.
+"""
+import pkg_resources
+import sys
+import os
 import argparse
-import textwrap
-
-from .call import Call
-from .client import Open, Show, ConsumeNothing, ConsumeMemory, LeakMemory, ConsumeCPU
-from .benchmarks import Bench, BenchRead, BenchFieldsViewGet, BenchDummy, BenchLogin
-from .bench_sale_mrp import BenchSaleMrp
-from . import common
-
-from . import conf # Not really server-side (in the `for` below).
-from . import drop
-from . import initialize
-from . import model
-from . import module
-from . import read
-from . import run_tests
-from . import scaffold
-from . import uninstall
-from . import update
-
-command_list_server = (conf, drop, initialize, model, module, read, run_tests,
-                       scaffold, uninstall, update, )
-
-command_list_client = (Call, Open, Show, ConsumeNothing, ConsumeMemory,
-                       LeakMemory, ConsumeCPU, Bench, BenchRead,
-                       BenchFieldsViewGet, BenchDummy, BenchLogin,
-                       BenchSaleMrp, )
+
+command_list = []
+base_group = '%s.subcommands' % __name__
+toplevel_mark = '==toplevel=='
+
+for group, entry_points in pkg_resources.get_entry_map(pkg_resources.get_distribution('openerp-command')).items():
+    if group.startswith(base_group):
+        container = group[len(base_group)+1:] or None
+        for name, entry_point in entry_points.items():
+            try:
+                init_parser = entry_point.load()
+                pkg = sys.modules[init_parser.__module__.rsplit('.', 1)[0]]
+                description = unicode(sys.modules[init_parser.__module__].__doc__).strip()
+                command_list.append( (name.replace('_', '-'), container, description, init_parser, pkg) )
+            except ImportError, e:
+                sys.stderr.write("Invalid entry point: %s" % e.message + os.linesep)
 
 def main_parser():
+
+    def format_command(name, description):
+        text = [name]
+        if description:
+            text.extend([
+                ":", os.linesep,
+                "  " + description.strip().replace("\n", "\n  "),
+            ])
+        return "".join(text)
+
     parser = argparse.ArgumentParser(
         usage=argparse.SUPPRESS,
-        description=textwrap.fill(textwrap.dedent("""\
-                    OpenERP Command provides a set of command-line tools around
-                    the OpenERP framework: openobject-server. All the tools are
-                    sub-commands of a single oe executable.""")),
+        description=__doc__,
         epilog="""Use <command> --help to get information about the command.""",
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
-    description = []
-    for x in command_list_server:
-        description.append(x.__name__[len(__package__)+1:])
-        if x.__doc__:
-            description.extend([
-                ":\n",
-                textwrap.fill(str(x.__doc__).strip(),
-                              subsequent_indent='  ',
-                              initial_indent='  '),
-            ])
-        description.append("\n\n")
-    subparsers = parser.add_subparsers(
-        title="Available commands",
-        help=argparse.SUPPRESS,
-        description="".join(description[:-1]),
-    )
-    # Server-side commands.
-    for x in command_list_server:
-        x.add_parser(subparsers)
-    # Client-side commands. TODO one per .py file.
-    for x in command_list_client:
-        x(subparsers)
+    command_list.sort(key=lambda x:(x[1], x[0]))
+    container_help = {}
+    for name, container, description, _, pkg in command_list:
+        # Update parent subparser help_text
+        container = container or toplevel_mark
+        if container in container_help or container is toplevel_mark:
+            help_text = container_help.setdefault(container, [])
+        else:
+            parent_container = container.rsplit('.', 1)[0] if '.' in container else toplevel_mark
+            container_name = container.rsplit('.', 1)[1] if '.' in container else container
+            parent_text = container_help.setdefault(parent_container, [])
+            parent_text.extend([format_command(container_name, pkg.__doc__), os.linesep * 2])
+        # Make subcommand help
+        help_text = container_help.setdefault(container or toplevel_mark, [])
+        help_text.extend([format_command(name, description), os.linesep * 2])
+    subparsers = {toplevel_mark : parser.add_subparsers(
+                                  title="Available commands",
+                                  help=argparse.SUPPRESS,
+                                  description="".join(container_help[toplevel_mark][:-1])),
+                 }
+    for _, container, _, _, pkg in command_list:
+        if container is not None and container not in subparsers:
+            path, name = container.rsplit('.', 1) if '.' in container else (toplevel_mark, container)
+            parent_subparser = subparsers[path]
+            parent_parser = parent_subparser.add_parser(name, description=pkg.__doc__,
+                                                        formatter_class=argparse.RawDescriptionHelpFormatter)
+            subparsers[container] = parent_parser.add_subparsers(
+                title="Available commands",
+                help=argparse.SUPPRESS,
+                description="".join(container_help[container][:-1]),
+            )
+    for name, container, description, init_parser, _ in command_list:
+        subparser = subparsers[container or toplevel_mark]
+        command_parser = subparser.add_parser(name, description=description)
+        init_parser(command_parser)
     return parser
+
+def make_entry_points(path='.'):
+    import pkgutil
+    import pprint
+    res = {}
+    for importer, fullname, is_pkg in pkgutil.walk_packages(path):
+        try:
+            module_path = fullname.split('.')
+            prefix, name = module_path[0], module_path[-1]
+            if not prefix == __name__:
+                continue
+            module_container = ".".join(['openerpcommand','subcommands']+module_path[1:-1])
+            if is_pkg:
+                # Needed to display importation errors
+                __import__(fullname, globals(), locals(), [], -1)
+            else:
+                module = __import__(fullname, globals(), locals(), [name.split('.')[-1]], -1)
+                entry_point_string = "%s = %s:init_parser" % (name, fullname)
+                if not hasattr(module, 'init_parser'):
+                    print "#", entry_point_string
+                else:
+                    res.setdefault(module_container, []).append( entry_point_string )
+        except ValueError:
+            pass
+    pprint.pprint(res, indent=4)

=== modified file 'openerpcommand/addons/bench_sale_mrp/data.yml'
--- openerpcommand/addons/bench_sale_mrp/data.yml	2012-02-06 14:54:54 +0000
+++ openerpcommand/addons/bench_sale_mrp/data.yml	2012-11-27 15:42:19 +0000
@@ -18,7 +18,7 @@
     seller_delay: '1'
     seller_ids:
       - delay: 1
-        name: base.res_partner_agrolait
+        name: base.res_partner_2
         min_qty: 2.0
         qty: 5.0
     standard_price: 189.0

=== added directory 'openerpcommand/benchmark'
=== added file 'openerpcommand/benchmark/__init__.py'
--- openerpcommand/benchmark/__init__.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/benchmark/__init__.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,111 @@
+"""
+Base class for benchmark
+"""
+import sys
+import hashlib
+import multiprocessing
+import time
+
+from openerpcommand.common import Client
+
+class Benchmark(Client):
+    """
+    Base class for concurrent benchmarks. The measure_once() method must be
+    overriden.
+
+    Each sub-benchmark will be run in its own process then a report is done
+    with all the results (shared with the main process using a
+    `multiprocessing.Array`).
+    """
+
+    def __init__(self, parser):
+        super(Benchmark, self).__init__(parser)
+        self.parser.add_argument('-n', '--samples', metavar='SAMPLES',
+            default=100, help='number of measurements to take.')
+            # TODO if -n <samples>s is given (instead of -n <samples>), run the
+            # benchmark for <samples> seconds and return the number of iterations.
+        self.parser.add_argument('-o', '--output', metavar='FILE',
+            required=True, help='path to save the generated report.')
+        self.parser.add_argument('--append', action='store_true',
+            default=False, help='append the report to an existing file.')
+        self.parser.add_argument('-j', '--jobs', metavar='JOBS',
+            default=1, help='number of concurrent workers')
+        self.parser.add_argument('--seed', metavar='SEED',
+            default=0, help='a value to ensure different runs can create unique data.')
+        self.worker = -1
+
+    def work(self, iarr=None):
+        if iarr:
+            # If an array is given, it means we are a worker process...
+            self.work_slave(iarr)
+        else:
+            # ... else we are the main process and we will spawn workers,
+            # passing them an array.
+            self.work_master()
+
+    def work_master(self):
+        N = int(self.args.samples)
+        self.arrs = [(i, multiprocessing.Array('f', range(N)))
+            for i in xrange(int(self.args.jobs))]
+        ps = [multiprocessing.Process(target=self.run, args=(arr,))
+            for arr in self.arrs]
+        [p.start() for p in ps]
+        [p.join() for p in ps]
+
+        self.report_html()
+
+    def work_slave(self, iarr):
+        j, arr = iarr
+        self.worker = j
+        N = int(self.args.samples)
+        total_t0 = time.time()
+        for i in xrange(N):
+            t0 = time.time()
+            self.measure_once(i)
+            t1 = time.time()
+            arr[i] = t1 - t0
+            print >> sys.stdout, '\r%s' % ('|' * (i * 60 / N)),
+            print >> sys.stdout, '%s %s%%' % \
+                (' ' * (60 - (i * 60 / N)), int(float(i+1)/N*100)),
+            sys.stdout.flush()
+        total_t1 = time.time()
+        print '\nDone in %ss.' % (total_t1 - total_t0)
+
+    def report_html(self):
+        series = []
+        for arr in self.arrs:
+            serie = """{
+                data: %s,
+                points: { show: true }
+            }""" % ([[x, i] for i, x in enumerate(arr)],)
+            series.append(serie)
+        chart_id = hashlib.md5(" ".join(sys.argv)).hexdigest()
+        HEADER = """<!doctype html>
+<title>Benchmarks</title>
+<meta charset=utf-8>
+<script type="text/javascript" src="js/jquery.min.js"></script>
+<script type="text/javascript" src="js/jquery.flot.js"></script>
+"""
+
+        CONTENT = """<h1>%s</h1>
+%s
+<div id='chart_%s' style='width:400px;height:300px;'>...</div>
+<script type="text/javascript">
+$.plot($("#chart_%s"), [%s],
+  {yaxis: { ticks: false }});
+</script>""" % (self.bench_name, ' '.join(sys.argv), chart_id, chart_id,
+        ','.join(series))
+        if self.args.append:
+            with open(self.args.output, 'a') as f:
+                f.write(CONTENT,)
+        else:
+            with open(self.args.output, 'w') as f:
+                f.write(HEADER + CONTENT,)
+
+    def measure_once(self, i):
+        """
+        The `measure_once` method is called --jobs times. A `i` argument is
+        supplied to allow to create unique values for each execution (e.g. to
+        supply fresh identifiers to a `create` method.
+        """
+        pass

=== added file 'openerpcommand/benchmark/dummy.py'
--- openerpcommand/benchmark/dummy.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/benchmark/dummy.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,18 @@
+"""
+Dummy (call test.limits.model.consume_nothing()).
+"""
+from openerpcommand.benchmark import Benchmark
+
+class Dummy(Benchmark):
+    bench_name = 'test.limits.model.consume_nothing()'
+
+    def __init__(self, parser):
+        super(Dummy, self).__init__(parser)
+        self.parser.add_argument('-a', '--args', metavar='ARGS',
+            default='', help='some arguments to serialize')
+
+    def measure_once(self, i):
+        self.execute('test.limits.model', 'consume_nothing')
+
+def init_parser(parser):
+    Dummy(parser)

=== added file 'openerpcommand/benchmark/fields_view_get.py'
--- openerpcommand/benchmark/fields_view_get.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/benchmark/fields_view_get.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,20 @@
+"""
+Read a record's fields and view architecture repeatedly.
+"""
+from openerpcommand.benchmark import Benchmark
+
+class FieldsViewGet(Benchmark):
+    bench_name = 'res.users.fields_view_get(1)'
+
+    def __init__(self, parser):
+        super(FieldsViewGet, self).__init__(parser)
+        self.parser.add_argument('-m', '--model', metavar='MODEL',
+            required=True, help='the model')
+        self.parser.add_argument('-i', '--id', metavar='RECORDID',
+            required=True, help='the record id')
+
+    def measure_once(self, i):
+        self.execute(self.args.model, 'fields_view_get', self.args.id)
+
+def init_parser(parser):
+    FieldsViewGet(parser)

=== added file 'openerpcommand/benchmark/login.py'
--- openerpcommand/benchmark/login.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/benchmark/login.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,13 @@
+"""
+Login (update res_users.date).
+"""
+from openerpcommand.benchmark import Benchmark
+
+class Login(Benchmark):
+    bench_name = 'res.users.login(1)'
+
+    def measure_once(self, i):
+        self.common_proxy.login(self.database, self.user, self.password)
+
+def init_parser(parser):
+    Login(parser)

=== added file 'openerpcommand/benchmark/read.py'
--- openerpcommand/benchmark/read.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/benchmark/read.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,20 @@
+"""
+Define a base class for client-side benchmarking.
+"""
+from openerpcommand.benchmark import Benchmark
+
+class Read(Benchmark):
+    bench_name = 'res.users.read(1)'
+
+    def __init__(self, parser):
+        super(Read, self).__init__(parser)
+        self.parser.add_argument('-m', '--model', metavar='MODEL',
+            required=True, help='the model')
+        self.parser.add_argument('-i', '--id', metavar='RECORDID',
+            required=True, help='the record id')
+
+    def measure_once(self, i):
+        self.execute(self.args.model, 'read', [self.args.id], [])
+
+def init_parser(parser):
+    Read(parser)

=== renamed file 'openerpcommand/bench_sale_mrp.py' => 'openerpcommand/benchmark/sale_mrp.py'
--- openerpcommand/bench_sale_mrp.py	2012-02-06 14:54:54 +0000
+++ openerpcommand/benchmark/sale_mrp.py	2012-11-27 15:42:19 +0000
@@ -1,23 +1,17 @@
-"""
-Benchmark based on the `sale_mrp` addons (in `sale_mrp/test/sale_mrp.yml`).
-"""
+"""\
+Similar to `sale_mrp/test/sale_mrp.yml`.
 
+This benchmarks the OpenERP server `sale_mrp` module by creating and
+confirming a sale order. As it creates data in the server, it is necessary
+to ensure unique names for the newly created data. You can use the --seed
+argument to give a lower bound to those names. (The number of generated
+names is JOBS * SAMPLES.)
+"""
 import time
 
-from .benchmarks import Bench
-
-class BenchSaleMrp(Bench):
-    """\
-    Similar to `sale_mrp/test/sale_mrp.yml`.
-
-    This benchmarks the OpenERP server `sale_mrp` module by creating and
-    confirming a sale order. As it creates data in the server, it is necessary
-    to ensure unique names for the newly created data. You can use the --seed
-    argument to give a lower bound to those names. (The number of generated
-    names is --jobs * --samples.)
-    """
-
-    command_name = 'bench-sale-mrp'
+from openerpcommand.benchmark import Benchmark
+
+class SaleMrp(Benchmark):
     bench_name = '`sale_mrp/test/sale_mrp.yml`'
 
     def measure_once(self, i):
@@ -33,7 +27,7 @@
         res_partner_4 = self.execute('ir.model.data', 'get_object_reference', 'base', 'res_partner_4')[1]
         res_partner_address_7 = self.execute('ir.model.data', 'get_object_reference', 'base', 'res_partner_address_7')[1]
         list0 = self.execute('ir.model.data', 'get_object_reference', 'product', 'list0')[1]
-        shop = self.execute('ir.model.data', 'get_object_reference', 'sale', 'shop')[1]
+        shop = self.execute('ir.model.data', 'get_object_reference', 'sale', 'sale_shop_1')[1]
 
         # Create a sale order for the product `Slider Mobile`.
         data = {
@@ -66,3 +60,5 @@
         # Confirm the sale order.
         self.object_proxy.exec_workflow(self.database, self.uid, self.password, 'sale.order', 'order_confirm', sale_order_id, {})
 
+def init_parser(parser):
+    SaleMrp(parser)

=== removed file 'openerpcommand/benchmarks.py'
--- openerpcommand/benchmarks.py	2012-07-23 09:51:09 +0000
+++ openerpcommand/benchmarks.py	1970-01-01 00:00:00 +0000
@@ -1,166 +0,0 @@
-"""
-Define a base class for client-side benchmarking.
-"""
-import hashlib
-import multiprocessing
-import sys
-import time
-
-from .client import Client
-
-class Bench(Client):
-    """
-    Base class for concurrent benchmarks. The measure_once() method must be
-    overriden.
-
-    Each sub-benchmark will be run in its own process then a report is done
-    with all the results (shared with the main process using a
-    `multiprocessing.Array`).
-    """
-
-    def __init__(self, subparsers=None):
-        super(Bench, self).__init__(subparsers)
-        self.parser.add_argument('-n', '--samples', metavar='INT',
-            default=100, help='number of measurements to take')
-            # TODO if -n <int>s is given (instead of -n <int>), run the
-            # benchmark for <int> seconds and return the number of iterations.
-        self.parser.add_argument('-o', '--output', metavar='PATH',
-            required=True, help='path to save the generated report')
-        self.parser.add_argument('--append', action='store_true',
-            default=False, help='append the report to an existing file')
-        self.parser.add_argument('-j', '--jobs', metavar='JOBS',
-            default=1, help='number of concurrent workers')
-        self.parser.add_argument('--seed', metavar='SEED',
-            default=0, help='a value to ensure different runs can create unique data')
-        self.worker = -1
-
-    def work(self, iarr=None):
-        if iarr:
-            # If an array is given, it means we are a worker process...
-            self.work_slave(iarr)
-        else:
-            # ... else we are the main process and we will spawn workers,
-            # passing them an array.
-            self.work_master()
-
-    def work_master(self):
-        N = int(self.args.samples)
-        self.arrs = [(i, multiprocessing.Array('f', range(N)))
-            for i in xrange(int(self.args.jobs))]
-        ps = [multiprocessing.Process(target=self.run, args=(arr,))
-            for arr in self.arrs]
-        [p.start() for p in ps]
-        [p.join() for p in ps]
-
-        self.report_html()
-
-    def work_slave(self, iarr):
-        j, arr = iarr
-        self.worker = j
-        N = int(self.args.samples)
-        total_t0 = time.time()
-        for i in xrange(N):
-            t0 = time.time()
-            self.measure_once(i)
-            t1 = time.time()
-            arr[i] = t1 - t0
-            print >> sys.stdout, '\r%s' % ('|' * (i * 60 / N)),
-            print >> sys.stdout, '%s %s%%' % \
-                (' ' * (60 - (i * 60 / N)), int(float(i+1)/N*100)),
-            sys.stdout.flush()
-        total_t1 = time.time()
-        print '\nDone in %ss.' % (total_t1 - total_t0)
-
-    def report_html(self):
-        series = []
-        for arr in self.arrs:
-            serie = """{
-                data: %s,
-                points: { show: true }
-            }""" % ([[x, i] for i, x in enumerate(arr)],)
-            series.append(serie)
-        chart_id = hashlib.md5(" ".join(sys.argv)).hexdigest()
-        HEADER = """<!doctype html>
-<title>Benchmarks</title>
-<meta charset=utf-8>
-<script type="text/javascript" src="js/jquery.min.js"></script>
-<script type="text/javascript" src="js/jquery.flot.js"></script>
-"""
-
-        CONTENT = """<h1>%s</h1>
-%s
-<div id='chart_%s' style='width:400px;height:300px;'>...</div>
-<script type="text/javascript">
-$.plot($("#chart_%s"), [%s],
-  {yaxis: { ticks: false }});
-</script>""" % (self.bench_name, ' '.join(sys.argv), chart_id, chart_id,
-        ','.join(series))
-        if self.args.append:
-            with open(self.args.output, 'a') as f:
-                f.write(CONTENT,)
-        else:
-            with open(self.args.output, 'w') as f:
-                f.write(HEADER + CONTENT,)
-
-    def measure_once(self, i):
-        """
-        The `measure_once` method is called --jobs times. A `i` argument is
-        supplied to allow to create unique values for each execution (e.g. to
-        supply fresh identifiers to a `create` method.
-        """
-        pass
-
-class BenchRead(Bench):
-    """Read a record repeatedly."""
-
-    command_name = 'bench-read'
-    bench_name = 'res.users.read(1)'
-
-    def __init__(self, subparsers=None):
-        super(BenchRead, self).__init__(subparsers)
-        self.parser.add_argument('-m', '--model', metavar='MODEL',
-            required=True, help='the model')
-        self.parser.add_argument('-i', '--id', metavar='RECORDID',
-            required=True, help='the record id')
-
-    def measure_once(self, i):
-        self.execute(self.args.model, 'read', [self.args.id], [])
-
-class BenchFieldsViewGet(Bench):
-    """Read a record's fields and view architecture repeatedly."""
-
-    command_name = 'bench-view'
-    bench_name = 'res.users.fields_view_get(1)'
-
-    def __init__(self, subparsers=None):
-        super(BenchFieldsViewGet, self).__init__(subparsers)
-        self.parser.add_argument('-m', '--model', metavar='MODEL',
-            required=True, help='the model')
-        self.parser.add_argument('-i', '--id', metavar='RECORDID',
-            required=True, help='the record id')
-
-    def measure_once(self, i):
-        self.execute(self.args.model, 'fields_view_get', self.args.id)
-
-class BenchDummy(Bench):
-    """Dummy (call test.limits.model.consume_nothing())."""
-
-    command_name = 'bench-dummy'
-    bench_name = 'test.limits.model.consume_nothing()'
-
-    def __init__(self, subparsers=None):
-        super(BenchDummy, self).__init__(subparsers)
-        self.parser.add_argument('-a', '--args', metavar='ARGS',
-            default='', help='some arguments to serialize')
-
-    def measure_once(self, i):
-        self.execute('test.limits.model', 'consume_nothing')
-
-class BenchLogin(Bench):
-    """Login (update res_users.date)."""
-
-    command_name = 'bench-login'
-    bench_name = 'res.users.login(1)'
-
-    def measure_once(self, i):
-        self.common_proxy.login(self.database, self.user, self.password)

=== modified file 'openerpcommand/call.py'
--- openerpcommand/call.py	2012-02-10 16:19:48 +0000
+++ openerpcommand/call.py	2012-11-27 15:42:19 +0000
@@ -1,29 +1,18 @@
 """
 Call an arbitrary model's method.
+
+Example:
+  > oe call res.users.read '[1, 3]' '[]' -u 1 -p admin
 """
 import ast
-import os
 import pprint
 import sys
-import time
-import xmlrpclib
-
-import client
-
-class Call(client.Client):
-    """\
-    Call an arbitrary model's method.
-
-    Example:
-      > oe call res.users.read '[1, 3]' '[]' -u 1 -p admin
-    """
-    # TODO The above docstring is completely borked in the
-    # --help message.
-
-    command_name = 'call'
-
-    def __init__(self, subparsers=None):
-        super(Call, self).__init__(subparsers)
+
+from openerpcommand.common import Client
+
+class Call(Client):
+    def __init__(self, parser):
+        super(Call, self).__init__(parser)
         self.parser.add_argument('call', metavar='MODEL.METHOD',
             help='the model and the method to call, using the '
             '<model>.<method> format.')
@@ -42,3 +31,5 @@
         x = self.execute(model, method, *args)
         pprint.pprint(x, indent=4)
 
+def init_parser(parser):
+    Call(parser)

=== removed file 'openerpcommand/client.py'
--- openerpcommand/client.py	2012-01-20 15:41:17 +0000
+++ openerpcommand/client.py	1970-01-01 00:00:00 +0000
@@ -1,137 +0,0 @@
-"""
-Define a few common arguments for client-side command-line tools.
-"""
-import os
-import sys
-import time
-import xmlrpclib
-
-import common
-
-class Client(common.Command):
-    """
-    Base class for XML-RPC command-line clients. It must be inherited and the
-    work() method overriden.
-    """
-
-    def __init__(self, subparsers=None):
-        super(Client, self).__init__(subparsers)
-        required_or_default = common.required_or_default
-        self.parser.add_argument('-H', '--host', metavar='HOST',
-            **required_or_default('HOST', 'the server host'))
-        self.parser.add_argument('-P', '--port', metavar='PORT',
-            **required_or_default('PORT', 'the server port'))
-
-    def execute(self, *args):
-        return self.object_proxy.execute(self.database, self.uid, self.password, *args)
-
-    def initialize(self):
-        self.host = self.args.host
-        self.port = int(self.args.port)
-        self.database = self.args.database
-        self.user = self.args.user
-        self.password = self.args.password
-
-        self.url = 'http://%s:%d/xmlrpc/' % (self.host, self.port)
-        self.common_proxy = xmlrpclib.ServerProxy(self.url + 'common')
-        self.object_proxy = xmlrpclib.ServerProxy(self.url + 'object')
-
-        try:
-            self.uid = int(self.user)
-        except ValueError, e:
-            self.uid = self.common_proxy.login(self.database, self.user, self.password)
-
-    def run(self, *args):
-        self.initialize()
-        self.work(*args)
-
-    def work(self, *args):
-        pass
-
-class Open(Client):
-    """Get the web client's URL to view a specific model."""
-
-    command_name = 'open'
-
-    def __init__(self, subparsers=None):
-        super(Open, self).__init__(subparsers)
-        self.parser.add_argument('-m', '--model', metavar='MODEL',
-            required=True, help='the view type')
-        self.parser.add_argument('-v', '--view-mode', metavar='VIEWMODE',
-            default='tree', help='the view mode')
-
-    def work(self):
-        ids = self.execute('ir.actions.act_window', 'search', [
-            ('res_model', '=', self.args.model),
-            ('view_mode', 'like', self.args.view_mode),
-            ])
-        xs = self.execute('ir.actions.act_window', 'read', ids, [])
-        for x in xs:
-            print x['id'], x['name']
-            d = {}
-            d['host'] = self.host
-            d['port'] = self.port
-            d['action_id'] = x['id']
-            print "  http://%(host)s:%(port)s/web/webclient/home#action_id=%(action_id)s" % d
-
-class Show(Client):
-    """Display a record."""
-
-    command_name = 'show'
-
-    def __init__(self, subparsers=None):
-        super(Show, self).__init__(subparsers)
-        self.parser.add_argument('-m', '--model', metavar='MODEL',
-            required=True, help='the model')
-        self.parser.add_argument('-i', '--id', metavar='RECORDID',
-            required=True, help='the record id')
-
-    def work(self):
-        xs = self.execute(self.args.model, 'read', [self.args.id], [])
-        if xs:
-            x = xs[0]
-            print x['name']
-        else:
-            print "Record not found."
-
-class ConsumeNothing(Client):
-    """Call test.limits.model.consume_nothing()."""
-
-    command_name = 'consume-nothing'
-
-    def work(self):
-        xs = self.execute('test.limits.model', 'consume_nothing')
-
-class ConsumeMemory(Client):
-    """Call test.limits.model.consume_memory()."""
-
-    command_name = 'consume-memory'
-
-    def __init__(self, subparsers=None):
-        super(ConsumeMemory, self).__init__(subparsers)
-        self.parser.add_argument('--size', metavar='SIZE',
-            required=True, help='size of the list to allocate')
-
-    def work(self):
-        xs = self.execute('test.limits.model', 'consume_memory', int(self.args.size))
-
-class LeakMemory(ConsumeMemory):
-    """Call test.limits.model.leak_memory()."""
-
-    command_name = 'leak-memory'
-
-    def work(self):
-        xs = self.execute('test.limits.model', 'leak_memory', int(self.args.size))
-
-class ConsumeCPU(Client):
-    """Call test.limits.model.consume_cpu_time()."""
-
-    command_name = 'consume-cpu'
-
-    def __init__(self, subparsers=None):
-        super(ConsumeCPU, self).__init__(subparsers)
-        self.parser.add_argument('--seconds', metavar='INT',
-            required=True, help='how much CPU time to consume')
-
-    def work(self):
-        xs = self.execute('test.limits.model', 'consume_cpu_time', int(self.args.seconds))

=== modified file 'openerpcommand/common.py'
--- openerpcommand/common.py	2012-10-30 15:11:48 +0000
+++ openerpcommand/common.py	2012-11-27 15:42:19 +0000
@@ -1,9 +1,9 @@
 """
-Define a few common arguments for server-side command-line tools.
+Define a few common arguments for server-side (Command) and client-side (Client) command-line tools.
 """
-import argparse
 import os
 import sys
+import xmlrpclib
 
 def add_addons_argument(parser):
     """
@@ -37,28 +37,24 @@
     a mandatory argument.
     """
     if os.environ.get('OPENERP_' + name.upper()):
-	d = {'default': os.environ['OPENERP_' + name.upper()]}
+        d = {'default': os.environ['OPENERP_' + name.upper()]}
     else:
-	d = {'required': True}
+        d = {'required': True}
     d['help'] = h + '. The environment variable OPENERP_' + \
-	name.upper() + ' can be used instead.'
+        name.upper() + ' can be used instead.'
     return d
 
+def expand_path(path):
+    return os.path.expanduser(os.path.expandvars(path))
+
 class Command(object):
     """
     Base class to create command-line tools. It must be inherited and the
     run() method overriden.
     """
 
-    command_name = 'stand-alone'
-
-    def __init__(self, subparsers=None):
-        if subparsers:
-            self.parser = parser = subparsers.add_parser(self.command_name,
-	        description=self.__class__.__doc__)
-        else:
-	    self.parser = parser = argparse.ArgumentParser(
-                description=self.__class__.__doc__)
+    def __init__(self, parser):
+        self.parser = parser
 
         parser.add_argument('-d', '--database', metavar='DATABASE',
             **required_or_default('DATABASE', 'the database to connect to'))
@@ -86,3 +82,42 @@
         command = cls()
         args = command.parser.parse_args()
         args.run(args)
+
+class Client(Command):
+    """
+    Base class for XML-RPC command-line clients. It must be inherited and the
+    work() method overriden.
+    """
+
+    def __init__(self, parser):
+        super(Client, self).__init__(parser)
+        self.parser.add_argument('-H', '--host', metavar='HOST',
+            **required_or_default('HOST', 'the server host'))
+        self.parser.add_argument('-P', '--port', metavar='PORT',
+            **required_or_default('PORT', 'the server port'))
+
+    def execute(self, *args):
+        return self.object_proxy.execute(self.database, self.uid, self.password, *args)
+
+    def initialize(self):
+        self.host = self.args.host
+        self.port = int(self.args.port)
+        self.database = self.args.database
+        self.user = self.args.user
+        self.password = self.args.password
+
+        self.url = 'http://%s:%d/xmlrpc/' % (self.host, self.port)
+        self.common_proxy = xmlrpclib.ServerProxy(self.url + 'common')
+        self.object_proxy = xmlrpclib.ServerProxy(self.url + 'object')
+
+        try:
+            self.uid = int(self.user)
+        except ValueError, e:
+            self.uid = self.common_proxy.login(self.database, self.user, self.password)
+
+    def run(self, *args):
+        self.initialize()
+        self.work(*args)
+
+    def work(self, *args):
+        pass

=== modified file 'openerpcommand/conf.py'
--- openerpcommand/conf.py	2012-10-31 11:26:36 +0000
+++ openerpcommand/conf.py	2012-11-27 15:42:19 +0000
@@ -1,13 +1,11 @@
 """
 Display the currently used configuration. The configuration for any
-sub-command is normally given by options. But some options can be specified
-using environment variables. This sub-command shows those variables.
-A `set` sub-command should be provided when the configuration is in a real
-configuration file instead of environment variables.
+sub-command is normally given by options. But some options can be
+specified using environment variables. This sub-command shows those
+variables.  A `set` sub-command should be provided when the configuration
+is in a real configuration file instead of environment variables.
 """
 import os
-import sys
-import textwrap
 
 def run(args):
     for x in ('database', 'addons', 'host', 'port'):
@@ -18,8 +16,5 @@
             print '%s: <not set>' % (x, )
     os.environ['OPENERP_DATABASE'] = 'yeah'
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('conf',
-        description='Display the currently used configuration.')
-
+def init_parser(parser):
     parser.set_defaults(run=run)

=== added file 'openerpcommand/consume_cpu.py'
--- openerpcommand/consume_cpu.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/consume_cpu.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,16 @@
+"""
+Call test.limits.model.consume_cpu_time().
+"""
+from openerpcommand.common import Client
+
+class ConsumeCPU(Client):
+    def __init__(self, parser):
+        super(ConsumeCPU, self).__init__(parser)
+        self.parser.add_argument('--seconds', metavar='INT',
+            required=True, help='how much CPU time to consume')
+
+    def work(self):
+        xs = self.execute('test.limits.model', 'consume_cpu_time', int(self.args.seconds))
+
+def init_parser(parser):
+    ConsumeCPU(parser)

=== added file 'openerpcommand/consume_memory.py'
--- openerpcommand/consume_memory.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/consume_memory.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,16 @@
+"""
+Call test.limits.model.consume_memory().
+"""
+from openerpcommand.common import Client
+
+class ConsumeMemory(Client):
+    def __init__(self, parser):
+        super(ConsumeMemory, self).__init__(parser)
+        self.parser.add_argument('--size', metavar='SIZE',
+            required=True, help='size of the list to allocate')
+
+    def work(self):
+        xs = self.execute('test.limits.model', 'consume_memory', int(self.args.size))
+
+def init_parser(parser):
+    ConsumeMemory(parser)

=== added file 'openerpcommand/consume_nothing.py'
--- openerpcommand/consume_nothing.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/consume_nothing.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,11 @@
+"""
+Call test.limits.model.consume_nothing().
+"""
+from openerpcommand.common import Client
+
+class ConsumeNothing(Client):
+    def work(self):
+        xs = self.execute('test.limits.model', 'consume_nothing')
+
+def init_parser(parser):
+    ConsumeNothing(parser)

=== modified file 'openerpcommand/drop.py'
--- openerpcommand/drop.py	2012-08-23 09:25:05 +0000
+++ openerpcommand/drop.py	2012-11-27 15:42:19 +0000
@@ -1,8 +1,7 @@
 """
 Drop a database.
 """
-
-import common
+from openerpcommand import common
 
 # TODO turn template1 in a parameter
 # This should be exposed from openerp (currently in
@@ -36,10 +35,7 @@
     assert args.database
     drop_database(args.database)
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('drop',
-        description='Drop a database.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE',
         **common.required_or_default('DATABASE', 'the database to create'))
-
     parser.set_defaults(run=run)

=== modified file 'openerpcommand/initialize.py'
--- openerpcommand/initialize.py	2012-11-05 17:34:39 +0000
+++ openerpcommand/initialize.py	2012-11-27 15:42:19 +0000
@@ -1,10 +1,9 @@
 """
 Install OpenERP on a new (by default) database.
+Create and initialize a new OpenERP database.
 """
-import os
 import sys
-
-import common
+from openerpcommand import common
 
 def install_openerp(database_name, create_database_flag, module_names):
     import openerp
@@ -47,6 +46,10 @@
 
     config = openerp.tools.config
 
+    if args.drop:
+        import drop
+        drop.drop_database(args.database)
+
     if args.tests:
         config['log_handler'] = [':TEST']
         config['test_enable'] = True
@@ -57,7 +60,7 @@
         config['without_demo'] = True
 
     if args.addons:
-        args.addons = args.addons.split(':')
+        args.addons = map(common.expand_path, args.addons.split(':'))
     else:
         args.addons = []
     config['addons_path'] = ','.join(args.addons)
@@ -77,11 +80,11 @@
     if hasattr(registry, '_assertion_report'):
         sys.exit(1 if registry._assertion_report.failures else 0)
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('initialize',
-        description='Create and initialize a new OpenERP database.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE',
         **common.required_or_default('DATABASE', 'the database to create'))
+    parser.add_argument('--drop', action='store_true',
+        default=False, help="Drop the database if exists")
     common.add_addons_argument(parser)
     parser.add_argument('--module', metavar='MODULE', action='append',
         help='specify a module to install'
@@ -98,5 +101,4 @@
         ' (use the `run-tests` command to choose specific'
         ' tests to run against an existing database).'
         ' Demo data are installed.')
-
     parser.set_defaults(run=run)

=== added file 'openerpcommand/leak_memory.py'
--- openerpcommand/leak_memory.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/leak_memory.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,11 @@
+"""
+Call test.limits.model.leak_memory().
+"""
+from .consume_memory import ConsumeMemory
+
+class LeakMemory(ConsumeMemory):
+    def work(self):
+        xs = self.execute('test.limits.model', 'leak_memory', int(self.args.size))
+
+def init_parser(parser):
+    LeakMemory(parser)

=== modified file 'openerpcommand/model.py'
--- openerpcommand/model.py	2012-02-14 15:05:03 +0000
+++ openerpcommand/model.py	2012-11-27 15:42:19 +0000
@@ -1,7 +1,6 @@
 """
-Display information about a given model.
+Display information about a given model for an existing database.
 """
-import os
 import sys
 import textwrap
 
@@ -46,9 +45,7 @@
         if args.verbose and v.help:
             print textwrap.fill(v.help, initial_indent='    ', subsequent_indent='    ')
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('model',
-        description='Display information about a given model for an existing database.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE', required=True,
         help='the database to connect to')
     parser.add_argument('-m', '--model', metavar='MODEL', required=True,

=== modified file 'openerpcommand/module.py'
--- openerpcommand/module.py	2012-08-23 09:25:05 +0000
+++ openerpcommand/module.py	2012-11-27 15:42:19 +0000
@@ -1,11 +1,12 @@
 """
 Show module information for a given database or from the file-system.
+Display modules known from a given database or on file-system.
 """
 import os
 import sys
 import textwrap
 
-from . import common
+from openerpcommand import common
 
 # TODO provide a --rpc flag to use XML-RPC (with a specific username) instead
 # of server-side library.
@@ -16,7 +17,7 @@
     config = openerp.tools.config
     config['log_handler'] = [':CRITICAL']
     if args.addons:
-        args.addons = args.addons.split(':')
+        args.addons = map(common.expand_path, args.addons.split(':'))
     else:
         args.addons = []
     config['addons_path'] = ','.join(args.addons)
@@ -50,9 +51,7 @@
         else:
             print "No module found (database `%s`)." % (args.database,)
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('module',
-        description='Display modules known from a given database or on file-system.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE',
         **common.required_or_default('DATABASE', 'the database to modify'))
     common.add_addons_argument(parser)

=== added file 'openerpcommand/open.py'
--- openerpcommand/open.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/open.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,29 @@
+"""
+Get the web client's URL to view a specific model.
+"""
+from openerpcommand.common import Client
+
+class Open(Client):
+    def __init__(self, parser):
+        super(Open, self).__init__(parser)
+        self.parser.add_argument('-m', '--model', metavar='MODEL',
+            required=True, help='the view type')
+        self.parser.add_argument('-v', '--view-mode', metavar='VIEWMODE',
+            default='tree', help='the view mode')
+
+    def work(self):
+        ids = self.execute('ir.actions.act_window', 'search', [
+            ('res_model', '=', self.args.model),
+            ('view_mode', 'like', self.args.view_mode),
+            ])
+        xs = self.execute('ir.actions.act_window', 'read', ids, [])
+        for x in xs:
+            print x['id'], x['name']
+            d = {}
+            d['host'] = self.host
+            d['port'] = self.port
+            d['action_id'] = x['id']
+            print "  http://%(host)s:%(port)s/web/webclient/home#action_id=%(action_id)s" % d
+
+def init_parser(parser):
+    Open(parser)

=== modified file 'openerpcommand/read.py'
--- openerpcommand/read.py	2012-11-05 17:34:39 +0000
+++ openerpcommand/read.py	2012-11-27 15:42:19 +0000
@@ -41,9 +41,7 @@
     else:
         print "Record not found."
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('read',
-        description='Display a record.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE', required=True,
         help='the database to connect to')
     parser.add_argument('-m', '--model', metavar='MODEL', required=True,
@@ -56,5 +54,4 @@
         help='display less information')
     parser.add_argument('-f', '--field', metavar='FIELD',
         help='display information only for this particular field')
-
     parser.set_defaults(run=run)

=== modified file 'openerpcommand/run_tests.py'
--- openerpcommand/run_tests.py	2012-11-19 13:23:37 +0000
+++ openerpcommand/run_tests.py	2012-11-27 15:42:19 +0000
@@ -1,12 +1,13 @@
 """
 Execute the unittest2 tests available in OpenERP addons.
+Run the OpenERP server and/or addons tests.
 """
 
 import os
 import sys
 import types
 
-import common
+from openerpcommand import common
 
 def get_test_modules(module, submodule, explode):
     """
@@ -102,7 +103,7 @@
     config['db_name'] = args.database
     config['addons_path'] = args.addons.replace(':',',')
     if args.addons:
-        args.addons = args.addons.split(':')
+        args.addons = map(common.expand_path, args.addons.split(':'))
     else:
         args.addons = []
     if args.sanity_checks and args.fast_suite:
@@ -169,9 +170,7 @@
         for test_module in test_modules:
             print ' ', test_module.__name__
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('run-tests',
-        description='Run the OpenERP server and/or addons tests.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE', required=True,
         help='the database to test. Depending on the test suites, the '
         'database must already exist or not.')
@@ -192,5 +191,4 @@
         help='run only the sanity check tests')
     parser.add_argument('--dry-run', action='store_true',
         help='do not run the tests')
-
     parser.set_defaults(run=run)

=== modified file 'openerpcommand/scaffold.py'
--- openerpcommand/scaffold.py	2012-02-01 22:38:52 +0000
+++ openerpcommand/scaffold.py	2012-11-27 15:42:19 +0000
@@ -1,7 +1,6 @@
 """
 Generate an OpenERP module skeleton.
 """
-
 import os
 import sys
 
@@ -22,12 +21,9 @@
     with open(os.path.join(module, 'models', '__init__.py'), 'w') as h:
         h.write(MODELS_PY % (module,))
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('scaffold',
-        description='Generate an OpenERP module skeleton.')
+def init_parser(parser):
     parser.add_argument('module', metavar='MODULE',
         help='the name of the generated module')
-
     parser.set_defaults(run=run)
 
 MANIFEST = """\

=== added file 'openerpcommand/show.py'
--- openerpcommand/show.py	1970-01-01 00:00:00 +0000
+++ openerpcommand/show.py	2012-11-27 15:42:19 +0000
@@ -0,0 +1,23 @@
+"""
+Display a record.
+"""
+from openerpcommand.common import Client
+
+class Show(Client):
+    def __init__(self, parser):
+        super(Show, self).__init__(parser)
+        self.parser.add_argument('-m', '--model', metavar='MODEL',
+            required=True, help='the model')
+        self.parser.add_argument('-i', '--id', metavar='RECORDID',
+            required=True, help='the record id')
+
+    def work(self):
+        xs = self.execute(self.args.model, 'read', [self.args.id], [])
+        if xs:
+            x = xs[0]
+            print x['name']
+        else:
+            print "Record not found."
+
+def init_parser(parser):
+    Show(parser)

=== modified file 'openerpcommand/uninstall.py'
--- openerpcommand/uninstall.py	2012-08-22 17:20:15 +0000
+++ openerpcommand/uninstall.py	2012-11-27 15:42:19 +0000
@@ -1,10 +1,10 @@
 """
-Install OpenERP on a new (by default) database.
+Uninstall some modules from an OpenERP database.
 """
 import os
 import sys
 
-import common
+from openerpcommand import common
 
 # TODO turn template1 in a parameter
 # This should be exposed from openerp (currently in
@@ -30,7 +30,7 @@
     config = openerp.tools.config
     config['log_handler'] = [':CRITICAL']
     if args.addons:
-        args.addons = args.addons.split(':')
+        args.addons = map(common.expand_path, args.addons.split(':'))
     else:
         args.addons = []
     config['addons_path'] = ','.join(args.addons)
@@ -54,14 +54,11 @@
     finally:
         cr.close()
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('uninstall',
-        description='Uninstall some modules from an OpenERP database.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE',
         **common.required_or_default('DATABASE', 'the database to modify'))
     common.add_addons_argument(parser)
     parser.add_argument('--module', metavar='MODULE', action='append',
         help='specify a module to uninstall'
         ' (this option can be repeated)')
-
     parser.set_defaults(run=run)

=== modified file 'openerpcommand/update.py'
--- openerpcommand/update.py	2012-02-14 15:05:03 +0000
+++ openerpcommand/update.py	2012-11-27 15:42:19 +0000
@@ -10,9 +10,7 @@
     openerp.modules.registry.RegistryManager.get(
         args.database, update_module=True, pooljobs=False)
 
-def add_parser(subparsers):
-    parser = subparsers.add_parser('update',
-        description='Update an existing OpenERP database.')
+def init_parser(parser):
     parser.add_argument('-d', '--database', metavar='DATABASE', required=True,
         help='the database to update')
 

=== modified file 'setup.py' (properties changed: -x to +x)
--- setup.py	2012-01-31 17:55:23 +0000
+++ setup.py	2012-11-27 15:42:19 +0000
@@ -31,8 +31,29 @@
     zip_safe = False,
     packages = find_packages(),
     include_package_data = True,
-    entry_points="""
-    [console_scripts]
-    oe=openerpcommand.main:run
-    """,
+    entry_points={
+        'console_scripts' : ['oe = openerpcommand.main:run'],
+        'openerpcommand.subcommands': [   'call = openerpcommand.call:init_parser',
+                                          'conf = openerpcommand.conf:init_parser',
+                                          'consume_cpu = openerpcommand.consume_cpu:init_parser',
+                                          'consume_memory = openerpcommand.consume_memory:init_parser',
+                                          'consume_nothing = openerpcommand.consume_nothing:init_parser',
+                                          'drop = openerpcommand.drop:init_parser',
+                                          'initialize = openerpcommand.initialize:init_parser',
+                                          'leak_memory = openerpcommand.leak_memory:init_parser',
+                                          'model = openerpcommand.model:init_parser',
+                                          'module = openerpcommand.module:init_parser',
+                                          'open = openerpcommand.open:init_parser',
+                                          'read = openerpcommand.read:init_parser',
+                                          'run_tests = openerpcommand.run_tests:init_parser',
+                                          'scaffold = openerpcommand.scaffold:init_parser',
+                                          'show = openerpcommand.show:init_parser',
+                                          'uninstall = openerpcommand.uninstall:init_parser',
+                                          'update = openerpcommand.update:init_parser'],
+        'openerpcommand.subcommands.benchmark': [   'dummy = openerpcommand.benchmark.dummy:init_parser',
+                                                    'fields_view_get = openerpcommand.benchmark.fields_view_get:init_parser',
+                                                    'login = openerpcommand.benchmark.login:init_parser',
+                                                    'read = openerpcommand.benchmark.read:init_parser',
+                                                    'sale_mrp = openerpcommand.benchmark.sale_mrp:init_parser'],
+    },
 )