Synnefo » ./kamaki

import inspect

import sys

from sys import exit, stdout, stderr

from colors import magenta, red, yellow, bold

from kamaki import clients

from .config import Config

_commands = OrderedDict()

GROUPS = {}

def command(group=None, name=None, syntax=None):

    """Class decorator that registers a class as a CLI command."""

        grp, sep, cmd = cls.__name__.partition('_')

        if not sep:

            grp, cmd = None, cls.__name__

        #cls.api = api

        cls.group = group or grp

        cls.name = name or cmd

        short_description, sep, long_description = cls.__doc__.partition('\n')

        cls.description = short_description

        cls.long_description = long_description or short_description

        cls.syntax = syntax

        if cls.syntax is None:

            # Generate a syntax string based on main's arguments

            spec = inspect.getargspec(cls.main.im_func)

            args = spec.args[1:]

            n = len(args) - len(spec.defaults or ())

            required = ' '.join('<%s>' % x.replace('____', '[:').replace('___', ':').replace('__',']').replace('_', ' ') for x in args[:n])

            optional = ' '.join('[%s]' % x.replace('____', '[:').replace('___', ':').replace('__', ']').replace('_', ' ') for x in args[n:])

            cls.syntax = ' '.join(x for x in [required, optional] if x)

            if spec.varargs:

                cls.syntax += ' <%s ...>' % spec.varargs

        if cls.group not in _commands:

            _commands[cls.group] = OrderedDict()

        _commands[cls.group][cls.name] = cls

def main():

    def print_groups():

        print('\nGroups:')

        for group in _commands:

            description = GROUPS.get(group, '')

            print(' ', group.ljust(12), description)

    def print_commands(group):

        description = GROUPS.get(group, '')

        if description:

            print('\n' + description)

        print('\nCommands:')

        for name, cls in _commands[group].items():

            print(' ', name.ljust(14), cls.description)

    def manage_logging_handlers(args):

        """This is mostly to handle logging for clients package"""

        def add_handler(name, level, prefix=''):

            h = logging.StreamHandler()

            fmt = logging.Formatter(prefix + '%(message)s')

            h.setFormatter(fmt)

            logger = logging.getLogger(name)

            logger.addHandler(h)

            logger.setLevel(level)

        if args.silent:

            add_handler('', logging.CRITICAL)

        elif args.debug:

            add_handler('requests', logging.INFO, prefix='* ')

            add_handler('clients.send', logging.DEBUG, prefix='> ')

            add_handler('clients.recv', logging.DEBUG, prefix='< ')

        elif args.verbose:

            add_handler('requests', logging.INFO, prefix='* ')

            add_handler('clients.send', logging.INFO, prefix='> ')

            add_handler('clients.recv', logging.INFO, prefix='< ')

        elif args.include:

            add_handler('clients.recv', logging.INFO)

        else:

            add_handler('', logging.WARNING)

    def load_groups(config):

        """load groups and import CLIs and Modules"""

        loaded_modules = {}

        for api in config.apis():

            api_cli = config.get(api, 'cli')

            if None == api_cli or len(api_cli)==0:

                print('Warnig: No Command Line Interface "%s" given for API "%s"'%(api_cli, api))

                print('\t(cli option in config file)')

                continue

            if not loaded_modules.has_key(api_cli):

                loaded_modules[api_cli] = False

                for location in CLI_LOCATIONS:

                    location += api_cli if location == '' else '.%s'%api_cli

                    try:

                        __import__(location)

                        loaded_modules[api_cli] = True

                        break

                    except ImportError:

                        pass

                if not loaded_modules[api_cli]:

                    print('Warning: failed to load Command Line Interface "%s" for API "%s"'%(api_cli, api))

                    print('\t(No suitable cli in known paths)')

                    continue

            if not GROUPS.has_key(api):

                GROUPS[api] = 'No description (interface: %s)'%api_cli

    def init_parser(exe):

        parser = ArgumentParser(add_help=False)

        parser.prog = '%s <group> <command>' % exe

        parser.add_argument('-h', '--help', dest='help', action='store_true',

                          default=False,

                          help="Show this help message and exit")

        parser.add_argument('--config', dest='config', metavar='PATH',

                          help="Specify the path to the configuration file")

        parser.add_argument('-d', '--debug', dest='debug', action='store_true',

                          default=False,

                          help="Include debug output")

        parser.add_argument('-i', '--include', dest='include', action='store_true',

                          default=False,

                          help="Include protocol headers in the output")

        parser.add_argument('-s', '--silent', dest='silent', action='store_true',

                          default=False,

                          help="Silent mode, don't output anything")

        parser.add_argument('-v', '--verbose', dest='verbose', action='store_true',

                          default=False,

                          help="Make the operation more talkative")

        parser.add_argument('-V', '--version', dest='version', action='store_true',

                          default=False,

                          help="Show version number and quit")

        parser.add_argument('-o', dest='options', action='append',

                          default=[], metavar="KEY=VAL",

                          help="Override a config value")

        return parser

    def find_term_in_args(arg_list, term_list):

        """find an arg_list term in term_list. All other terms up to found

        term are rearanged at the end of arg_list, preserving relative order

        """

        arg_tail = []

        while len(arg_list) > 0:

            group = arg_list.pop(0)

            if group not in term_list:

                arg_tail.append(group)

            else:

                arg_list += arg_tail

                return group

        return None

    """Main Code"""

    exe = basename(sys.argv[0])

    parser = init_parser(exe)

    args, argv = parser.parse_known_args()

    #print version

    if args.version:

        import kamaki

        print("kamaki %s" % kamaki.__version__)

        exit(0)

    config = Config(args.config) if args.config else Config()

    #load config options from command line

    for option in args.options:

        keypath, sep, val = option.partition('=')

        if not sep:

            print("Invalid option '%s'" % option)

            exit(1)

        section, sep, key = keypath.partition('.')

        if not sep:

            print("Invalid option '%s'" % option)

            exit(1)

        config.override(section.strip(), key.strip(), val.strip())

    load_groups(config)

    group = find_term_in_args(argv, _commands)

    if not group:

        parser.print_help()

        print_groups()

        exit(0)

    parser.prog = '%s %s <command>' % (exe, group)

    command = find_term_in_args(argv, _commands[group])

    if not command:

        parser.print_help()

        print_commands(group)

        exit(0)

    cmd = _commands[group][command]()

    parser.prog = '%s %s %s' % (exe, group, command)

    if cmd.syntax:

        parser.prog += '  %s' % cmd.syntax

    parser.description = cmd.description

    parser.epilog = ''

    if hasattr(cmd, 'update_parser'):

        cmd.update_parser(parser)

    #check other args

    args, argv = parser.parse_known_args()

    if group != argv[0]:

        errmsg = red('Invalid command group '+argv[0])

        print(errmsg, file=stderr)

        exit(1)

    if command != argv[1]:

        errmsg = red('Invalid command "%s" in group "%s"'%(argv[1], argv[0]))

        print(errmsg, file=stderr)

        exit(1)

    if args.help:

        parser.print_help()

        exit(0)

    manage_logging_handlers(args)

    cmd.args = args

    cmd.config = config

        ret = cmd.main(*argv[2:])

        exit(ret)

    except TypeError as e:

        if e.args and e.args[0].startswith('main()'):

            parser.print_help()

            exit(1)

        else:

            raise

        errmsg = 'CLI Error '

        errmsg += '(%s): '%err.status if err.status else ': '

        errmsg += unicode(err.message) if err.message else ''

        if err.importance == 1:

            errmsg = yellow(errmsg)

        elif err.importance == 2:

            errmsg = magenta(errmsg)

        elif err.importance > 2:

            errmsg = red(errmsg)

        print(errmsg, file=stderr)

if __name__ == '__main__':

    main()

from sys import argv, exit

from inspect import getargspec

from os.path import basename

from argparse import ArgumentParser

from .utils import CommandTree, Argument

from .errors import CLIError, CLISyntaxError

try:

	from colors import magenta, red, yellow, bold

except ImportError:

	#No colours? No worries, use dummy foo instead

	def bold(val):

		return val

	red = yellow = magenta = bold

_commands = CommandTree()

			self._exit(0)

	def _exit(self, num):

			pass

def command():

	"""Class decorator that registers a class as a CLI command"""

	def decorator(cls):

		"""Any class with name of the form cmd1_cmd2_cmd3_... is accepted"""

		cls.description, sep, cls.long_description = cls.__doc__.partition('\n')

		# Generate a syntax string based on main's arguments

		spec = getargspec(cls.main.im_func)

		args = spec.args[1:]

		n = len(args) - len(spec.defaults or ())

		required = ' '.join('<%s>' % x.replace('____', '[:').replace('___', ':').replace('__',']').\

			replace('_', ' ') for x in args[:n])

		optional = ' '.join('[%s]' % x.replace('____', '[:').replace('___', ':').replace('__', ']').\

			replace('_', ' ') for x in args[n:])

		cls.syntax = ' '.join(x for x in [required, optional] if x)

		if spec.varargs:

			cls.syntax += ' <%s ...>' % spec.varargs

		_commands.add(cls.__name__, cls)

		return cls

	return decorator

def _init_parser(exe):

	parser = ArgumentParser(add_help=True)

	parser.prog='%s <cmd_group> [<cmd_subbroup> ...] <cmd>'%exe

	for name, argument in _arguments.items():

		argument.update_parser(parser, name)

	return parser

def one_command():

	exe = basename(argv[0])

	parser = _init_parser(exe)

	parsed, unparsed = parse_known_args(parser)

def run_one_command():

	try:

		one_command()

	except CLIError as err:

		errmsg = '%s'%unicode(err) +' (%s)'%err.status if err.status else ' '

		font_color = yellow if err.importance <= 1 else magenta if err.importance <=2 else red

		from sys import stdout

		stdout.write(font_color(errmsg))

		if err.details is not None and len(err.details) > 0:

			print(': %s'%err.details)

		else:

			print

		exit(1)

from .errors import CLIUnknownCommand, CLISyntaxError, CLICmdSpecError

class Argument(object):

    """An argument that can be parsed from command line or otherwise"""

    def __init__(self, arity, help=None, parsed_name=None, default=None):

        self.arity = int(arity)

        if help is not None:

            self.help = help

        if parsed_name is not None:

            self.parsed_name = parsed_name

        if default is not None:

            self.default = default

    @property 

    def parsed_name(self):

        return getattr(self, '_parsed_name', None)

    @parsed_name.setter

    def parsed_name(self, newname):

        self._parsed_name = getattr(self, '_parsed_name', [])

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

            self._parsed_name += list(newname)

        else:

            self._parsed_name.append(unicode(newname))

    @property 

    def help(self):

        return getattr(self, '_help', None)

    @help.setter

    def help(self, newhelp):

        self._help = unicode(newhelp)

    @property 

    def arity(self):

        return getattr(self, '_arity', None)

    @arity.setter

    def arity(self, newarity):

        newarity = int(newarity)

        assert newarity >= 0

        self._arity = newarity

    @property 

    def default(self):

        if not hasattr(self, '_default'):

            self._default = False if self.arity == 0 else None

        return self._default

    @default.setter

    def default(self, newdefault):

        self._default = newdefault

    @property 

    def value(self):

        return getattr(self, '_value', self.default)

    @value.setter

    def value(self, newvalue):

        self._value = newvalue

    def update_parser(self, parser, name):

        """Update an argument parser with this argument info"""

        action = 'store_true' if self.arity==0 else 'store'

        parser.add_argument(*self.parsed_name, dest=name, action=action,

            default=self.default, help=self.help)

    def main(self):

        """Overide this method to give functionality to ur args"""

        raise NotImplementedError

    @classmethod

    def test(self):

        h = Argument(arity=0, help='Display a help massage', parsed_name=('--help', '-h'))

        b = Argument(arity=1, help='This is a bbb', parsed_name='--bbb')

        c = Argument(arity=2, help='This is a ccc', parsed_name='--ccc')

        from argparse import ArgumentParser

        parser = ArgumentParser(add_help=False)

        h.update_parser(parser, 'hee')

        b.update_parser(parser, 'bee')

        c.update_parser(parser, 'cee')

        args, argv = parser.parse_known_args()

        print('args: %s\nargv: %s'%(args, argv))

        'console_scripts': ['kamaki = kamaki.cli:main', 'newmaki = kamaki.cli.argument:run_one_command']