Synnefo » ./kamaki

def _required_syntax(arguments, required):

    if isinstance(required, tuple):

        return ' '.join([_required_syntax(arguments, k) for k in required])

    elif isinstance(required, list):

        return '(%s)' % ' | '.join([

            _required_syntax(arguments, k) for k in required])

    return '/'.join(arguments[required].parsed_name)

        cls.syntax = ' '.join([required, optional])

        required = getattr(cls, 'required', None)

        if required:

            arguments = getattr(cls, 'arguments', dict())

            cls.syntax += ' %s' % _required_syntax(arguments, required)

            #parser.parser.print_help()

            parser.print_help()

from sys import stderr

    def __init__(self, exe, arguments=None, required=None):

        :param required: (list or tuple) an iterable of argument keys, denoting

            which arguments are required. A tuple denoted an AND relation,

            while a list denotes an OR relation e.g., ['a', 'b'] means that

            either 'a' or 'b' is required, while ('a', 'b') means that both 'a'

            and 'b' ar required.

            Nesting is allowed e.g., ['a', ('b', 'c'), ['d', 'e']] means that

            this command required either 'a', or both 'b' and 'c', or one of

            'd', 'e'.

            Repeated arguments are also allowed e.g., [('a', 'b'), ('a', 'c'),

            ['b', 'c']] means that the command required either 'a' and 'b' or

            'a' and 'c' or at least one of 'b', 'c' and could be written as

            [('a', ['b', 'c']), ['b', 'c']]

        self._exe = exe

        self.required = required

    @staticmethod

    def required2list(required):

        if isinstance(required, list) or isinstance(required, tuple):

            terms = []

            for r in required:

                terms.append(ArgumentParseManager.required2list(r))

            return list(set(terms).union())

        return required

    @staticmethod

    def required2str(required, arguments, tab=''):

        if isinstance(required, list):

            return ' %sat least one:\n%s' % (tab, ''.join(

                [ArgumentParseManager.required2str(

                    r, arguments, tab + '  ') for r in required]))

        elif isinstance(required, tuple):

            return ' %sall:\n%s' % (tab, ''.join(

                [ArgumentParseManager.required2str(

                    r, arguments, tab + '  ') for r in required]))

        else:

            lt_pn, lt_all, arg = 23, 80, arguments[required]

            tab2 = ' ' * lt_pn

            ret = '%s%s' % (tab, ', '.join(arg.parsed_name))

            if arg.arity != 0:

                ret += ' %s' % required.upper()

            ret = ('{:<%s}' % lt_pn).format(ret)

            prefix = ('\n%s' % tab2) if len(ret) < lt_pn else ' '

            step, cur = (len(arg.help) / (lt_all - lt_pn)) or len(arg.help), 0

            while arg.help[cur:]:

                next = cur + step

                ret += prefix

                ret += ('{:<%s}' % (lt_all - lt_pn)).format(arg.help[cur:next])

                cur, finish = next, '\n%s' % tab2

            return ret + '\n'

    def print_help(self, out=stderr):

        if self.required:

            tmp_args = dict(self.arguments)

            for term in self.required2list(self.required):

                tmp_args.pop(term)

            tmp_parser = ArgumentParseManager(self._exe, tmp_args)

            tmp_parser.syntax = self.syntax

            tmp_parser.parser.description = '%s\n\nrequired arguments:\n%s' % (

                self.parser.description,

                self.required2str(self.required, self.arguments))

            tmp_parser.update_parser()

            tmp_parser.parser.print_help()

        else:

            self.parser.print_help()

            assert isinstance(new_arguments, dict), 'Arguments not in dict !!!'

            pdict = vars(self._parsed)

            diff = set(self.required or []).difference(

                [k for k in pdict if pdict[k] != None])

            if diff:

                self.print_help()

                miss = ['/'.join(self.arguments[k].parsed_name) for k in diff]

                raise CLISyntaxError(

                    'Missing required arguments (%s)' % ', '.join(miss))

from sys import stdout, stderr

    def _create_help_method(cmd_name, args, required, descr, syntax):

        help_parser = ArgumentParseManager(cmd_name, tmp_args, required)

        #return help_parser.parser.print_help

        return help_parser.print_help

                    cmd_parser.required = getattr(cls, 'required', None)

                        cmd.name, cmd_parser.arguments, cmd_parser.required,

    # self.arguments (dict) contains all non-positional arguments

    # self.required (list or tuple) contains required argument keys

    #     if it is a list, at least one of these arguments is required

    #     if it is a tuple, all arguments are required

    #     Lists and tuples can nest other lists and/or tuples

    required = None

    """Create a server (aka Virtual Machine)"""

        server_name=ValueArgument('The name of the new server', '--name'),

        flavor_id=IntArgument('The ID of the hardware flavor', '--flavor-id'),

        image_id=IntArgument('The ID of the hardware image', '--image-id'),

    required = ('server_name', 'flavor_id', 'image_id')

    def main(self):

        self._run(

            name=self['server_name'],

            flavor_id=self['flavor_id'],

            image_id=self['image_id'])

class server_modify(_init_cyclades, _optional_output_cmd):

    """Modify attributes of a virtual server"""

    arguments = dict(

        server_name=ValueArgument('The new name', '--name'),

        flavor_id=IntArgument('Set a different flavor', '--flavor-id'),

    )

    required = ['server_name', 'flavor_id']

    def _run(self, server_id):

        if self['server_name']:

            self.client.update_server_name((server_id), self['server_name'])

        if self['flavor_id']:

            self.client.resize_server(server_id, self['flavor_id'])

        if self['with_output']:

            self._optional_output(self.client.get_server_details(server_id))

    def main(self, server_id):

        self._run(server_id=server_id)

        if bool(self['subnet_id']) != bool(self['ip_address']):

                '--subnet-id and --ip-address should be used together'])

        fixed_ips = [dict(

            subnet_id=self['subnet_id'], ip_address=self['ip_address'])] if (

        #parser.parser.print_help()

        parser.print_help()

        #parser.parser.print_help()

        if cmd.cmd_class:

            parser.required = getattr(cmd.cmd_class, 'required', None)

        parser.print_help()

    parser.required = getattr(cls, 'required', None)

    #exec_cmd(executable, parser.unparsed, parser.parser.print_help)

    exec_cmd(executable, parser.unparsed, parser.print_help)

        for fixed_ip in fixed_ips:

            diff = set(['subnet_id', 'ip_address']).difference(fixed_ip)

        if fixed_ips: