def endpoint(self, *args):
        """endpoint: Decorates a function to make it a CLI endpoint
        
        The function must be called do_<some>_<action> and accept one 'args'
        parameter. It will be converted into a ./cli some action commandline
        endpoint.
        
        A set of Arguments can be passed to the decorator, the syntax is the
        same than the argparse add_argument function.
        """
        # Decorator function
        def decorator(func):
            func_name = func.__name__
            func_name = func_name.replace("do_", "")
            actions = func_name.split("_")
            cmd_parser = None
            sub = self.subparsers
            wcount = 0
            # For each word in the command we build the parsing tree
            for word in actions:
                parser_name = '_'.join(actions[:wcount+1])
                # If the parser exist, we use it, otherwise we create it
                if self.parsers.has_key(parser_name):
                    cmd_parser = self.parsers[parser_name]
                else:
                    cmd_parser = sub.add_parser(word)
                    self.parsers[parser_name] = cmd_parser
                # We don't want to add a subparser to the final endpoint,
                # since it would require a void positional argument and
                # fuck up the whole thing.
                if wcount != len(actions) - 1:
                    # Same that with the parsers, it it exist we use it
                    # otherwise we create it. It avoids overwrites
                    if self.parsers.has_key("sub_"+parser_name):
                        sub = self.parsers["sub_"+parser_name]
                    else:
                        sub = cmd_parser.add_subparsers()
                        self.parsers["sub_"+parser_name] = sub
                wcount += 1
            # Bind the endpoint to the function
            cmd_parser.set_defaults(func=func)
            # We add the arguments to the function
            for argument in args:
                if type(argument) == Argument:
                    cmd_parser.add_argument(*argument.args, **argument.kwargs)
                elif type(argument) == ExclusiveGroup:
                    group = cmd_parser.add_mutually_exclusive_group(required=argument.required)
                    for arg in argument.args:
                        group.add_argument(*arg.args, **arg.kwargs)
            
            # Standard inner function
            def inner(*args, **kwargs):
                return func(*args, **kwargs)
                
            return inner
        return decorator