1

"""

     2

    Invoke external commands, with python kwargs -> options mangling.

     3

"""

     4

     5

import subprocess

     6

import logging

     7

     8

log = logging.getLogger('pvl.invoke')

     9

    10

class InvokeError (Exception) :

    11

    def __init__ (self, cmd, exit, error) :

    12

        self.cmd = cmd

    13

        self.exit = exit

    14

        self.error = error

    15

    16

    def __str__ (self) :

    17

        return "{self.cmd} failed ({self.exit}): {self.error}".format(self=self)

    18

    19

def invoke (cmd, args, stdin=None) :

    20

    """

    21

        Invoke a command directly.

    22

    23

        stdin:      

    24

            False   -> passthrough stdin/stdout

    25

            None    -> return lines of stdout

    26

            [lines] -> write lines on stdin, return lines of stdout

    27

    28

        Raises InvokeError on nonzero exit, otherwise log.warn's any stderr.

    29

    """

    30

    31

    log.debug("{cmd} {args}".format(cmd=cmd, args=' '.join(args)))

    32

    33

    if stdin is False :

    34

        # keep process stdin/out

    35

        io = None

    36

        input = None

    37

    38

    elif stdin :

    39

        # return stdout, give stdin

    40

        io = subprocess.PIPE

    41

        input = '\n'.join(stdin) + '\n'

    42

    43

    else :

    44

        # return stdout

    45

        io = subprocess.PIPE

    46

        input = None

    47

    48

    p = subprocess.Popen([cmd] + args, stdin=io, stdout=io, stderr=io)

    49

    50

    # get output

    51

    # returns None if not io

    52

    stdout, stderr = p.communicate(input=input)

    53

    54

    if p.returncode :

    55

        # failed

    56

        raise InvokeError(cmd, p.returncode, stderr)

    57

    58

    elif stderr :

    59

        log.warning("%s: %s", cmd, stderr)

    60

    61

    if stdout :

    62

        return stdout.splitlines()

    63

    else :

    64

        return None

    65

    66

import collections

    67

    68

def process_opt (name, value) :

    69

    """

    70

        Mangle from python keyword-argument dict format to command-line option tuple format.

    71

    72

        >>> process_opt('foo', True)

    73

        ('--foo',)

    74

        >>> process_opt('foo', 2)

    75

        ('--foo', '2')

    76

        >>> process_opt('foo', 'bar')

    77

        ('--foo', 'bar')

    78

        >>> process_opt('foo_bar', 'asdf')

    79

        ('--foo-bar', 'asdf')

    80

    81

        # multi

    82

        >>> process_opt('foo', ['bar', 'quux'])

    83

        ('--foo', 'bar', '--foo', 'quux')

    84

        >>> process_opt('foo', [False, 'bar', True])

    85

        ('--foo', 'bar', '--foo')

    86

    87

        # empty

    88

        >>> process_opt('foo', False)

    89

        ()

    90

        >>> process_opt('foo', None)

    91

        ()

    92

        >>> process_opt('bar', '')

    93

        ()

    94

    95

        Returns a tuple of argv items.

    96

    """

    97

    98

    # mangle opt

    99

    opt = '--' + name.replace('_', '-')

   100

   101

    if value is True :

   102

        # flag opt

   103

        return (opt, )

   104

   105

    elif not value :

   106

        # flag opt / omit

   107

        return ( )

   108

   109

    elif isinstance(value, basestring) :

   110

        return (opt, value)

   111

   112

    elif isinstance(value, collections.Iterable) :

   113

        opts = (process_opt(name, subvalue) for subvalue in value)

   114

   115

        # flatten

   116

        return tuple(part for parts in opts for part in parts)

   117

   118

    else :

   119

        # as-is

   120

        return (opt, str(value))

   121

   122

def optargs (*args, **kwargs) :

   123

    """

   124

        Convert args/options into command-line format

   125

   126

        >>> optargs('foo')

   127

        ['foo']

   128

        >>> optargs(foo=True)

   129

        ['--foo']

   130

        >>> optargs(foo=False)

   131

        []

   132

        >>> optargs(foo='bar')

   133

        ['--foo', 'bar']

   134

    """

   135

   136

    ## opts

   137

    # process

   138

    opts = [process_opt(opt, value) for opt, value in kwargs.iteritems()]

   139

   140

    # flatten

   141

    opts = [str(part) for parts in opts for part in parts]

   142

   143

    ## args

   144

    args = [str(arg) for arg in args if arg]

   145

   146

    return opts + args

   147

   148

# XXX: move to pvl.utils or something random?

   149

def merge (*dicts, **kwargs) :

   150

    """

   151

        Merge given dicts together.

   152

   153

        >>> merge(foo=1, bar=2)

   154

        {'foo': 1, 'bar': 2}

   155

        >>> merge(dict(foo=1), bar=2)

   156

        {'foo': 1, 'bar': 2}

   157

        >>> merge(dict(foo=1), bar=2, foo=3)

   158

        {'foo': 3, 'bar': 2}

   159

        >>> merge(dict(foo=1), dict(bar=2), foo=3)

   160

        {'foo': 3, 'bar': 2}

   161

        >>> merge(dict(bar=2), dict(foo=1), foo=3)

   162

        {'foo': 3, 'bar': 2}

   163

   164

    """

   165

   166

    return dict((k, v) for d in (dicts + (kwargs, )) for k, v in d.iteritems())

   167

   168

   169

def command (cmd, *args, **opts) :

   170

    """

   171

        Invoke a command with options/arguments, given via Python arguments/keyword arguments.

   172

   173

        Return stdout.

   174

    """

   175

   176

    log.debug("{cmd} {opts} {args}".format(cmd=cmd, args=args, opts=opts))

   177

   178

    # invoke

   179

    return invoke(cmd, optargs(*args, **opts))

   180

   181

if __name__ == '__main__':

   182

    import doctest

   183

    doctest.testmod()

   184