code.grnet.gr Git - kamaki/blob - kamaki/cli/argument/__init__.py

   1 # Copyright 2012-2013 GRNET S.A. All rights reserved.
   2 #
   3 # Redistribution and use in source and binary forms, with or
   4 # without modification, are permitted provided that the following
   5 # conditions are met:
   6 #
   7 #   1. Redistributions of source code must retain the above
   8 #     copyright notice, this list of conditions and the following
   9 #     disclaimer.
  10 #
  11 #   2. Redistributions in binary form must reproduce the above
  12 #     copyright notice, this list of conditions and the following
  13 #     disclaimer in the documentation and/or other materials
  14 #     provided with the distribution.
  15 #
  16 # THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
  17 # OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19 # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
  20 # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  23 # USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  24 # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  26 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 # POSSIBILITY OF SUCH DAMAGE.
  28 #
  29 # The views and conclusions contained in the software and
  30 # documentation are those of the authors and should not be
  31 # interpreted as representing official policies, either expressed
  32 # or implied, of GRNET S.A.
  33
  34 from kamaki.cli.config import Config
  35 from kamaki.cli.errors import CLISyntaxError, raiseCLIError
  36 from kamaki.cli.utils import split_input
  37
  38 from datetime import datetime as dtm
  39 from time import mktime
  40
  41 from logging import getLogger
  42 from argparse import ArgumentParser, ArgumentError
  43 from argparse import RawDescriptionHelpFormatter
  44 from progress.bar import ShadyBar as KamakiProgressBar
  45
  46 log = getLogger(__name__)
  47
  48
  49 class Argument(object):
  50     """An argument that can be parsed from command line or otherwise.
  51     This is the top-level Argument class. It is suggested to extent this
  52     class into more specific argument types.
  53     """
  54
  55     def __init__(self, arity, help=None, parsed_name=None, default=None):
  56         self.arity = int(arity)
  57         self.help = '%s' % help or ''
  58
  59         assert parsed_name, 'No parsed name for argument %s' % self
  60         self.parsed_name = list(parsed_name) if isinstance(
  61             parsed_name, list) or isinstance(parsed_name, tuple) else (
  62                 '%s' % parsed_name).split()
  63         for name in self.parsed_name:
  64             assert name.count(' ') == 0, '%s: Invalid parse name "%s"' % (
  65                 self, name)
  66             msg = '%s: Invalid parse name "%s" should start with a "-"' % (
  67                     self, name)
  68             assert name.startswith('-'), msg
  69
  70         self.default = default if (default or self.arity) else False
  71
  72     @property
  73     def value(self):
  74         return getattr(self, '_value', self.default)
  75
  76     @value.setter
  77     def value(self, newvalue):
  78         self._value = newvalue
  79
  80     def update_parser(self, parser, name):
  81         """Update argument parser with self info"""
  82         action = 'append' if self.arity < 0 else (
  83             'store' if self.arity else 'store_true')
  84         parser.add_argument(
  85             *self.parsed_name,
  86             dest=name, action=action, default=self.default, help=self.help)
  87
  88
  89 class ConfigArgument(Argument):
  90     """Manage a kamaki configuration (file)"""
  91
  92     def __init__(self, help, parsed_name=('-c', '--config')):
  93         super(ConfigArgument, self).__init__(1, help, parsed_name, None)
  94         self.file_path = None
  95
  96     @property
  97     def value(self):
  98         return super(ConfigArgument, self).value
  99
 100     @value.setter
 101     def value(self, config_file):
 102         if config_file:
 103             self._value = Config(config_file)
 104             self.file_path = config_file
 105         elif self.file_path:
 106             self._value = Config(self.file_path)
 107         else:
 108             self._value = Config()
 109
 110     def get(self, group, term):
 111         """Get a configuration setting from the Config object"""
 112         return self.value.get(group, term)
 113
 114     @property
 115     def groups(self):
 116         suffix = '_cli'
 117         slen = len(suffix)
 118         return [term[:-slen] for term in self.value.keys('global') if (
 119             term.endswith(suffix))]
 120
 121     @property
 122     def cli_specs(self):
 123         suffix = '_cli'
 124         slen = len(suffix)
 125         return [(k[:-slen], v) for k, v in self.value.items('global') if (
 126             k.endswith(suffix))]
 127
 128     def get_global(self, option):
 129         return self.value.get_global(option)
 130
 131     def get_cloud(self, cloud, option):
 132         return self.value.get_cloud(cloud, option)
 133
 134
 135 _config_arg = ConfigArgument('Path to config file')
 136
 137
 138 class RuntimeConfigArgument(Argument):
 139     """Set a run-time setting option (not persistent)"""
 140
 141     def __init__(self, config_arg, help='', parsed_name=None, default=None):
 142         super(self.__class__, self).__init__(1, help, parsed_name, default)
 143         self._config_arg = config_arg
 144
 145     @property
 146     def value(self):
 147         return super(RuntimeConfigArgument, self).value
 148
 149     @value.setter
 150     def value(self, options):
 151         if options == self.default:
 152             return
 153         if not isinstance(options, list):
 154             options = ['%s' % options]
 155         for option in options:
 156             keypath, sep, val = option.partition('=')
 157             if not sep:
 158                 raiseCLIError(
 159                     CLISyntaxError('Argument Syntax Error '),
 160                     details=[
 161                         '%s is missing a "="',
 162                         ' (usage: -o section.key=val)' % option])
 163             section, sep, key = keypath.partition('.')
 164         if not sep:
 165             key = section
 166             section = 'global'
 167         self._config_arg.value.override(
 168             section.strip(),
 169             key.strip(),
 170             val.strip())
 171
 172
 173 class FlagArgument(Argument):
 174     """
 175     :value: true if set, false otherwise
 176     """
 177
 178     def __init__(self, help='', parsed_name=None, default=False):
 179         super(FlagArgument, self).__init__(0, help, parsed_name, default)
 180
 181
 182 class ValueArgument(Argument):
 183     """
 184     :value type: string
 185     :value returns: given value or default
 186     """
 187
 188     def __init__(self, help='', parsed_name=None, default=None):
 189         super(ValueArgument, self).__init__(1, help, parsed_name, default)
 190
 191
 192 class CommaSeparatedListArgument(ValueArgument):
 193     """
 194     :value type: string
 195     :value returns: list of the comma separated values
 196     """
 197
 198     @property
 199     def value(self):
 200         return self._value or list()
 201
 202     @value.setter
 203     def value(self, newvalue):
 204         self._value = newvalue.split(',') if newvalue else list()
 205
 206
 207 class IntArgument(ValueArgument):
 208
 209     @property
 210     def value(self):
 211         """integer (type checking)"""
 212         return getattr(self, '_value', self.default)
 213
 214     @value.setter
 215     def value(self, newvalue):
 216         try:
 217             self._value = self.default if (
 218                 newvalue == self.default) else int(newvalue)
 219         except ValueError:
 220             raiseCLIError(CLISyntaxError(
 221                 'IntArgument Error',
 222                 details=['Value %s not an int' % newvalue]))
 223
 224
 225 class DateArgument(ValueArgument):
 226
 227     DATE_FORMAT = '%a %b %d %H:%M:%S %Y'
 228
 229     INPUT_FORMATS = [DATE_FORMAT, '%d-%m-%Y', '%H:%M:%S %d-%m-%Y']
 230
 231     @property
 232     def timestamp(self):
 233         v = getattr(self, '_value', self.default)
 234         return mktime(v.timetuple()) if v else None
 235
 236     @property
 237     def formated(self):
 238         v = getattr(self, '_value', self.default)
 239         return v.strftime(self.DATE_FORMAT) if v else None
 240
 241     @property
 242     def value(self):
 243         return self.timestamp
 244
 245     @value.setter
 246     def value(self, newvalue):
 247         self._value = self.format_date(newvalue) if newvalue else self.default
 248
 249     def format_date(self, datestr):
 250         for format in self.INPUT_FORMATS:
 251             try:
 252                 t = dtm.strptime(datestr, format)
 253             except ValueError:
 254                 continue
 255             return t  # .strftime(self.DATE_FORMAT)
 256         raiseCLIError(None, 'Date Argument Error', details=[
 257             '%s not a valid date' % datestr,
 258             'Correct formats:\n\t%s' % self.INPUT_FORMATS])
 259
 260
 261 class VersionArgument(FlagArgument):
 262     """A flag argument with that prints current version"""
 263
 264     @property
 265     def value(self):
 266         """bool"""
 267         return super(self.__class__, self).value
 268
 269     @value.setter
 270     def value(self, newvalue):
 271         self._value = newvalue
 272         if newvalue:
 273             import kamaki
 274             print('kamaki %s' % kamaki.__version__)
 275
 276
 277 class KeyValueArgument(Argument):
 278     """A Value Argument that can be repeated
 279
 280     :syntax: --<arg> key1=value1 --<arg> key2=value2 ...
 281     """
 282
 283     def __init__(self, help='', parsed_name=None, default={}):
 284         super(KeyValueArgument, self).__init__(-1, help, parsed_name, default)
 285
 286     @property
 287     def value(self):
 288         """
 289         :returns: (dict) {key1: val1, key2: val2, ...}
 290         """
 291         return super(KeyValueArgument, self).value
 292
 293     @value.setter
 294     def value(self, keyvalue_pairs):
 295         """
 296         :param keyvalue_pairs: (str) ['key1=val1', 'key2=val2', ...]
 297         """
 298         self._value = {}
 299         try:
 300             for pair in keyvalue_pairs:
 301                 key, sep, val = pair.partition('=')
 302                 assert sep, ' %s misses a "=" (usage: key1=val1 )\n' % (pair)
 303                 self._value[key] = val
 304         except Exception as e:
 305             raiseCLIError(e, 'KeyValueArgument Syntax Error')
 306
 307
 308 class ProgressBarArgument(FlagArgument):
 309     """Manage a progress bar"""
 310
 311     def __init__(self, help='', parsed_name='', default=True):
 312         self.suffix = '%(percent)d%%'
 313         super(ProgressBarArgument, self).__init__(help, parsed_name, default)
 314
 315     def clone(self):
 316         """Get a modifiable copy of this bar"""
 317         newarg = ProgressBarArgument(
 318             self.help, self.parsed_name, self.default)
 319         newarg._value = self._value
 320         return newarg
 321
 322     def get_generator(self, message, message_len=25):
 323         """Get a generator to handle progress of the bar (gen.next())"""
 324         if self.value:
 325             return None
 326         try:
 327             self.bar = KamakiProgressBar()
 328         except NameError:
 329             self.value = None
 330             return self.value
 331         self.bar.message = message.ljust(message_len)
 332         self.bar.suffix = '%(percent)d%% - %(eta)ds'
 333         self.bar.start()
 334
 335         def progress_gen(n):
 336             for i in self.bar.iter(range(int(n))):
 337                 yield
 338             yield
 339         return progress_gen
 340
 341     def finish(self):
 342         """Stop progress bar, return terminal cursor to user"""
 343         if self.value:
 344             return
 345         mybar = getattr(self, 'bar', None)
 346         if mybar:
 347             mybar.finish()
 348
 349
 350 _arguments = dict(
 351     config=_config_arg,
 352     cloud=ValueArgument('Chose a cloud to connect to', ('--cloud')),
 353     help=Argument(0, 'Show help message', ('-h', '--help')),
 354     debug=FlagArgument('Include debug output', ('-d', '--debug')),
 355     include=FlagArgument(
 356         'Include raw connection data in the output', ('-i', '--include')),
 357     silent=FlagArgument('Do not output anything', ('-s', '--silent')),
 358     verbose=FlagArgument('More info at response', ('-v', '--verbose')),
 359     version=VersionArgument('Print current version', ('-V', '--version')),
 360     options=RuntimeConfigArgument(
 361         _config_arg, 'Override a config value', ('-o', '--options'))
 362 )
 363
 364
 365 #  Initial command line interface arguments
 366
 367
 368 class ArgumentParseManager(object):
 369     """Manage (initialize and update) an ArgumentParser object"""
 370
 371     def __init__(self, exe, arguments=None):
 372         """
 373         :param exe: (str) the basic command (e.g. 'kamaki')
 374
 375         :param arguments: (dict) if given, overrides the global _argument as
 376             the parsers arguments specification
 377         """
 378         self.parser = ArgumentParser(
 379             add_help=False, formatter_class=RawDescriptionHelpFormatter)
 380         self.syntax = '%s <cmd_group> [<cmd_subbroup> ...] <cmd>' % exe
 381         if arguments:
 382             self.arguments = arguments
 383         else:
 384             global _arguments
 385             self.arguments = _arguments
 386         self._parser_modified, self._parsed, self._unparsed = False, None, None
 387         self.parse()
 388
 389     @property
 390     def syntax(self):
 391         """The command syntax (useful for help messages, descriptions, etc)"""
 392         return self.parser.prog
 393
 394     @syntax.setter
 395     def syntax(self, new_syntax):
 396         self.parser.prog = new_syntax
 397
 398     @property
 399     def arguments(self):
 400         """:returns: (dict) arguments the parser should be aware of"""
 401         return self._arguments
 402
 403     @arguments.setter
 404     def arguments(self, new_arguments):
 405         assert isinstance(new_arguments, dict), 'Arguments must be in a dict'
 406         self._arguments = new_arguments
 407         self.update_parser()
 408
 409     @property
 410     def parsed(self):
 411         """(Namespace) parser-matched terms"""
 412         if self._parser_modified:
 413             self.parse()
 414         return self._parsed
 415
 416     @property
 417     def unparsed(self):
 418         """(list) parser-unmatched terms"""
 419         if self._parser_modified:
 420             self.parse()
 421         return self._unparsed
 422
 423     def update_parser(self, arguments=None):
 424         """Load argument specifications to parser
 425
 426         :param arguments: if not given, update self.arguments instead
 427         """
 428         arguments = arguments or self._arguments
 429
 430         for name, arg in arguments.items():
 431             try:
 432                 arg.update_parser(self.parser, name)
 433                 self._parser_modified = True
 434             except ArgumentError:
 435                 pass
 436
 437     def update_arguments(self, new_arguments):
 438         """Add to / update existing arguments
 439
 440         :param new_arguments: (dict)
 441         """
 442         if new_arguments:
 443             assert isinstance(new_arguments, dict)
 444             self._arguments.update(new_arguments)
 445             self.update_parser()
 446
 447     def parse(self, new_args=None):
 448         """Parse user input"""
 449         try:
 450             pkargs = (new_args,) if new_args else ()
 451             self._parsed, unparsed = self.parser.parse_known_args(*pkargs)
 452         except SystemExit:
 453             raiseCLIError(CLISyntaxError('Argument Syntax Error'))
 454         for name, arg in self.arguments.items():
 455             arg.value = getattr(self._parsed, name, arg.default)
 456         self._unparsed = []
 457         for term in unparsed:
 458             self._unparsed += split_input(' \'%s\' ' % term)
 459         self._parser_modified = False