1

"""

     2

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

     3

"""

     4

     7

import subprocess

     8

     9

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

    10

    11

class InvokeError (Exception) :

    12

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

    13

        self.cmd = cmd

    14

        self.exit = exit

    15

        self.error = error

    16

    17

    def __str__ (self) :

    18

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

    19

    21

    """

    22

        Invoke a command directly.

    23

    24

        stdin:      

    25

            False   -> passthrough stdin/stdout

    26

            None    -> return lines of stdout

    27

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

    28

    29

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

    30

    """

    31

    32

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

    33

    34

    if stdin is False :

    35

        # keep process stdin/out

    36

        io = None

    37

        input = None

    38

    39

    elif stdin :

    40

        # return stdout, give stdin

    41

        io = subprocess.PIPE

    42

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

    43

    44

    else :

    45

        # return stdout

    46

        io = subprocess.PIPE

    47

        input = None

    48

    57

    58

    # get output

    59

    # returns None if not io

    60

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

    61

    62

    if p.returncode :

    63

        # failed

    64

        raise InvokeError(cmd, p.returncode, stderr)

    65

    66

    elif stderr :

    67

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

    68

    69

    if stdout :

    70

        return stdout.splitlines()

    71

    else :

    72

        return None

    73

    74

import collections

    75

    76

def process_opt (name, value) :

    77

    """

    78

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

    79

    80

        >>> process_opt('foo', True)

    81

        ('--foo',)

    82

        >>> process_opt('foo', 2)

    83

        ('--foo', '2')

    84

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

    85

        ('--foo', 'bar')

    86

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

    87

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

    88

    89

        # multi

    90

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

    91

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

    92

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

    93

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

    94

    95

        # empty

    96

        >>> process_opt('foo', False)

    97

        ()

    98

        >>> process_opt('foo', None)

    99

        ()

   100

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

   101

        ()

   102

   103

        Returns a tuple of argv items.

   104

    """

   105

   106

    # mangle opt

   107

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

   108

   109

    if value is True :

   110

        # flag opt

   111

        return (opt, )

   112

   113

    elif not value :

   114

        # flag opt / omit

   115

        return ( )

   116

   117

    elif isinstance(value, basestring) :

   118

        return (opt, value)

   119

   120

    elif isinstance(value, collections.Iterable) :

   121

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

   122

   123

        # flatten

   124

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

   125

   126

    else :

   127

        # as-is

   128

        return (opt, str(value))

   129

   130

def optargs (*args, **kwargs) :

   131

    """

   132

        Convert args/options into command-line format

   133

   134

        >>> optargs('foo')

   135

        ['foo']

   136

        >>> optargs(foo=True)

   137

        ['--foo']

   138

        >>> optargs(foo=False)

   139

        []

   140

        >>> optargs(foo='bar')

   141

        ['--foo', 'bar']

   142

    """

   143

   144

    ## opts

   145

    # process

   146

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

   147

   148

    # flatten

   149

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

   150

   151

    ## args

   152

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

   153

   154

    return opts + args

   155

   156

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

   157

def merge (*dicts, **kwargs) :

   158

    """

   159

        Merge given dicts together.

   160

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

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

   169

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

   170

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

   171

   172

    """

   173

   174

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

   175

   176

   177

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

   178

    """

   179

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

   180

   181

        Return stdout.

   182

    """

   183

   184

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

   185

   186

    # invoke

   187

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

   188

   189

if __name__ == '__main__':

   190

    import doctest

   191

    doctest.testmod()

   192