/ - Diff - ./kamaki - Greek Research and Technology Network's projects

         from ordereddict import OrderedDict
     #from kamaki import clients
     from .errors import CLIError
     from .errors import CLIError, CLISyntaxError, CLICmdIncompleteError
     from .config import Config #TO BE REMOVED
     from .utils import magenta, red, yellow, CommandTree
     from .utils import bold, magenta, red, yellow, CommandTree, print_list
     from argument import _arguments, parse_known_args
     _commands = CommandTree()
     GROUPS={}
     CLI_LOCATIONS = ['kamaki.cli.commands', 'kamaki.commands', 'kamaki.cli', 'kamaki', '']
     #basic command groups
     def command():
         """Class decorator that registers a class as a CLI command"""
-...
         else:
             print
     def _expand_cmd(cmd_prefix, unparsed):
         if len(unparsed) == 0:
             return None
         prefix = (cmd_prefix+'_') if len(cmd_prefix) > 0 else ''
         for term in _commands.list(cmd_prefix):
             try:
                 unparsed.remove(term)
             except ValueError:
                 continue
             return prefix+term
         return None
     def _retrieve_cmd(unparsed):
         cmd_str = None
         cur_cmd = _expand_cmd('', unparsed)
         while cur_cmd is not None:
             cmd_str = cur_cmd
             cur_cmd = _expand_cmd(cur_cmd, unparsed)
         if cmd_str is None:
             print(bold('Command groups:'))
             print_list(_commands.get_groups(), ident=14)
             print
             return None
         try:
             return _commands.get_class(cmd_str)
         except CLICmdIncompleteError:
             print(bold('%s:'%cmd_str))
             print_list(_commands.list(cmd_str))
         return None
     def one_command():
         try:
             exe = basename(argv[0])
-...
             parsed, unparsed = parse_known_args(parser)
             if _arguments['version'].value:
                 exit(0)
             _commands.set_groups(_arguments['config'].get_groups())
             cmd = _retrieve_cmd(unparsed)
             if cmd is None:
                 parser.print_help()
                 exit(0)
         except CLIError as err:
             _print_error_message(err)
             exit(1)

     	def value(self, config_file):
     		self._value = Config(config_file) if config_file is not None else Config()
     	def get_groups(self):
     		return self.value.apis()
     _config_arg = ConfigArgument(1, 'Path to configuration file', '--config')
     class CmdLineConfigArgument(Argument):
     	def __init__(self, config_arg, help='', parsed_name=None, default=None):
     		super(self.__class__, self).__init__(1, help, parsed_name, default)
-...
     				raise CLISyntaxError(details='Missing . between section and key: -o section.key=val')
     		self._config_arg.value.override(section.strip(), key.strip(), val.strip())
     _config_arg = ConfigArgument(1, 'Path to configuration file', '--config')
     _arguments = dict(config = _config_arg,
     	debug = Argument(0, 'Include debug output', ('-d', '--debug')),
     	include = Argument(0, 'Include protocol headers in the output', ('-i', '--include')),

     		super(CLIUnknownCommand, self).__init__(message, status, details, importance=0)
     class CLICmdSpecError(CLIError):
     	def __init__(self, message='Command Specification Error', status=13, details=''):
     	def __init__(self, message='Command Specification Error', status=13, details='', importance=1):
     		super(CLICmdSpecError, self).__init__(message, status, details, importance=0)
     class CLICmdIncompleteError(CLICmdSpecError):
         def __init__(self, message='Incomplete Command Error', status=14, details=''):
             super(CLICmdSpecError, self).__init__(message, status, details, importance=1)
     def raiseCLIError(err, importance = -1):
         if importance < 0:
             if err.status <= 0:

             return val
         red = yellow = magenta = bold
     from .errors import CLIUnknownCommand, CLICmdSpecError, CLIError
     from .errors import CLIUnknownCommand, CLICmdIncompleteError, CLICmdSpecError, CLIError
     """
     def magenta(val):
-...
         def __init__(self):
             self._commands = {}
         def set_groups(self, groups):
             for grp in groups:
                 self._commands[grp] = {}
         def get_groups(self):
             return self._commands.keys()
         def _get_commands_from_prefix(self, prefix):
             if len(prefix) == 0:
                 return self._commands
             path = get_pathlist_from_prefix(prefix)
             next_list = self._commands
             try:
-...
             except ValueError:
                 return ret
         def is_full_command(self, command):
         def get_class(self, command):
             """ Check if a command exists as a full/terminal command
             e.g. store_list is full, store is partial, stort is not existing
             @param command can either be a cmd1_cmd2_... str or a ['cmd1, cmd2, ...'] list
-...
             @raise CLIUnknownCommand if command is unknown to this tree
             """
             next_level = self._get_commands_from_prefix(command)
             if '_class' in next_level.keys():
                 return True
             return False
             try:
                 return next_level['_class']
             except KeyError:
                 raise CLICmdIncompleteError(details='Cmd %s is not a full cmd'%command)
         def add(self, command, cmd_class):
             """Add a command_path-->cmd_class relation to the path """
-...
                 try:
                     cmds = cmds[cmd]
                 except KeyError:
                     raise CLIUnknownCommand('set_description to cmd %s failed: cmd not found'%command)
                     raise CLIUnknownCommand(details='set_description to cmd %s failed: cmd not found'%command)
             cmds['_description'] = description
         def load_spec_package(self, spec_package):
             loaded = False
             for location in self.cmd_spec_locations:
-...
                 except ImportError:
                     pass
             if not loaded:
                 raise CLICmdSpecError('Cmd Spec Package %s load failed'%spec_package)
                 raise CLICmdSpecError(details='Cmd Spec Package %s load failed'%spec_package)
         def load_spec(self, spec_package, spec):
             """Load spec from a non nessecery loaded spec package"""
-...
                 raise CLICmdSpecError('Cmd Spec %s load failed'%spec)
     def get_pathlist_from_prefix(prefix):
         return prefix if isinstance(prefix,list) else unicode(prefix).split('_')
         if isinstance(prefix, list):
             return prefix
         if len(prefix) == 0:
             return []
         return unicode(prefix).split('_')
     def pretty_keys(d, delim='_', recurcive=False):
         """Transform keys of a dict from the form

Synnefo » ./kamaki

Revision 017d37ce