2

    Command-line based command implementation, handling option/argument parsing.

     5

import concurrent

     6

     7

import inspect, itertools, logging, traceback, optparse

     8

     9

def optify (symbol) :

    10

    """

    11

        Turns the given python symbol into the suitable version for use as a command-line argument.

    12

    13

        In other words, this replaces '_' with '-'.

    14

    """

    15

    16

    return symbol.replace('_', '-')

    17

    18

# wrapper around optparse.make_option

    19

Option = optparse.make_option

    20

    21

class Command (object) :

    22

    """

    23

        A Command is simply a function that can be executed from the command line with some options/arguments

    24

    """

    25

    26

    def __init__ (self, name, func, doc=None, options=None) :

    27

        """

    28

            Create a new Command

    29

    30

             name       - the name of the command

    31

             func       - the callable python function

    32

             doc        - descriptive help text

    33

             options    - named options as Option objects

    34

        """

    35

    36

        self.name = name

    37

        self.func = func

    38

        self.doc = doc

    39

        self.options = options

    40

    41

    def parse_args (self, args) :

    42

        """

    43

            Pre-parse the given arguments list.

    44

        """

    45

    46

        return args

    47

    48

    def apply (self, config, gallery, options, *args, **kwargs) :

    49

        """

    50

            Construct a CommandContext for execution of this command with the given environment.

    51

            the command with the given context.

    52

        """

    53

    54

        # apply extra options

    55

        for k, v in kwargs.iteritems() :

    56

            setattr(options, k, v)

    57

    58

        return Environment(self, config, gallery, options, args)

    59

    60

    def option_group (self, parser) :

    61

        """

    62

            Returns an optparse.OptionGroup for this command's options.

    63

        """

    64

    65

        group = optparse.OptionGroup(parser, "Command-specific options")

    66

    67

        for opt in self.options :

    68

            group.add_option(opt)

    69

    70

        return group

    71

    72

    def cmdopt_callback (self, option, opt_str, value, parser) :

    73

        """

    74

            Used as a optparse.Option callback-action, adds this command's options to the parser, and stores the

    75

            selected command.

    76

        """

    77

    78

        # check

    79

        if hasattr(parser.values, option.dest) :

    80

            raise ArgumentError("More than one command option given: %s + %s" % (getattr(parser.values, option.dest), self.name))

    81

    82

        if self.options :

    83

            # setup command-specific options

    84

            parser.add_option_group(self.build_options(parser))

    85

    86

        # store selected command

    87

        setattr(parser.values, option.dest, self)

    91

        A set of available Commands

   109

    def option_group (self, parser, default) :

   110

        """

   111

            Returns an optparse.OptionGroup for these commands, using the given parser.

   112

        """

   113

   114

        group = optparse.OptionGroup(parser, "Command Options", "Select what command to execute, may introduce other options")

   115

   116

        for command in self.list :

   117

            group.add_option('--%s' % optify(command.name), action='callback', callback=command.cmdopt_callback, dest='command', help=command.doc)

   118

   119

        # store default

   120

        parser.set_defaults(command=default)

   121

   122

        return group

   123

   124

class Environment (object) :

   126

        The environment that a Command will execute in.

   127

   128

        This is bound to a Configuration, a Gallery, options values, argument values and other miscellaneous things. An

   129

        environment also provides other services, such as status output, concurrent execution and error handling.

   132

    def __init__ (self, command, config, gallery, options, args) :

   140

        self.options = options

   141

        self.args = args

   146

    def execute (self) :

   151

        return self.command.func(self, *self.args)

   153

    def run (self) :

   160

            return self.execute()

   169

   170

    # XXX: split off to a .log object

   220

def command (options=None) :

   221

    def _decorator (func) :

   222

        """

   223

            A function decorator used to define Commands automatically

   224

        """

   225

   226

        # find help string

   227

        doc = inspect.getdoc(func)

   228

   229

        return Command(func.__name__, func, doc, options)

   230

   231

    return _decorator