Python subprocess example1

This article is based on the official document on the subprocess module.  you can find the article on subprocess module in this link: http://docs.python.org/library/subprocess.html#module-subprocess

 

a blurb on subprocess module.

 

 

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several other, older modules and functions, such as:

os.system
os.spawn*
os.popen*
popen2.*
commands.*

Information about how the subprocess module can be used to replace these modules and functions can be found in the following sections.

 

 

Below shows some code that utilize the subprocess module to start a number of process, it will close the subprocess on receiving input from the command line.

 

'''
File:
    start_command.py
description:
    This script is suppose to start some script/commands given the specified number of instance
    where you can also specify the location to the command to start.
argumnents;
    -n the # of instance of the command to start
    -p the location to the command
    -a the command argument
    
'''


# this will give us 
#     types.IntType
#     types.FloatTypes        
# more details, pls have a read 
#  http://docs.python.org/library/types.html
#  
from types import *

# this will give access to the symbols
#   sys.argv
#   sys...
# Joe - 
# we recommended that directly use fully qualified symbols
# 
# from sys import *


import sys


# os module
# which has the command 'os.pipe' ... 
# declared, 
# more details, pls find it here:
#   http://docs.python.org/library/os.html
import os


# apparently, the fork command is not well available on the Windows Platform
# you might give some consideration to the multiprocessing module, more details see
#    http://docs.python.org/library/multiprocessing.html
#
# 
import multiprocessing


# time module
# time module has methods such as 'time.sleep(secs)',
# time.strftime(format[,t]) and etc
import time

# subprocess module
# subprocess module allows you to spawn new processes, connect to their input/putput/error pipes
# and obtain their return values
# this module intends to replace several others, older module and functions, such as ...
# see more details 
#   http://docs.python.org/library/subprocess.html#module-subprocess
# 
import subprocess


# the doc string is mimic of the 
# doc string that is exemplified under this doc
#  http://stackoverflow.com/questions/256222/which-exception-should-i-raise-on-bad-illegal-argument-combinations-in-python
def check(n, p, a=None):
    """
    :param n: the # of instance to start
    :param p: the path to the Command/Script to start
    :param a: this is optional argument, default value of a is `None`
    :raise TypeError: if `type(n) is not int or type(p) is not str`
    :raise ValueError: if `n <= 0 or p == ""`
    :return None
    """


# about the parameter of the python argument
# there are 4 types of argument that a Python Fucntino that can accept
# they are
#   1. fixed argument (or called non-default argument) 
#   2. the positional arguments
#   3. the keyword arguments
#   4. the default arguments ( a special case of keyword argument)
#
# the syntax to define python function is as follow
#    func_name(a, b, ..., [*args | default=default_values]], **kwargs)
# 
#  so the general rule of defining python argument is as follow
#      def func_name(a, b, ..., *args, **kwargs)
# however, it is quite confusing when the default value for a argument comes into the play
# to declare a default argument, you normally do this 
#      def func_name(a, b, ..., *args, default=default_value)
# because the default value for an argument syntactically looks like the keyword argument
# which means
#    1. you cannot have default argument before the positional argument
#        def func_name(a, b, ..., default=default_value, *args) # raise TypeError
#    2. it is not allowed if to have default argument in the middle of fixed argument
#        def func_name(a, ..., default=default_value, b, ..., *args) # raise TypeError
#    3. you cannot have both positional argument and default argument together...
#        def func_name(a, b, *args, default="default_value") # raise TypeError
#        def func_name(a, b, default=default_value", *args, **kwargs) # raise TypeError
#    4. You can have an argument with default value after the positional argument and before the 
#       keyword argument (**kwargs) (you can think default valued argument is a special form of
#       keyword argument.  
#         def func_name(a, b, ..., default=default_value, **kwargs)
#    5. As said in 4, if you try to put the default argument after the keyword arguments, it fails
#         def func_name(a, b, ..., **kwargs, default=default_value);


    assert(n is not None and n > 0)
    assert(p is not None and p != "")
    assert(a is None or a != "")
    
    
    if (not isinstance(n, int)): raise TypeError("Argument 'n' expect integer")
    if (n is None or n <= 0): raise ValueError("Argument 'n' invalid");
    if (a is not None):
        if (type(a) != StringType): raise TypeError("Argument 'a': expect string")
        if (type(a) is not StringType): raise TypeError("Argument 'a': expect string")
        if (type(a) != str): raise TypeError("Argument 'a': expect string")
        if (type(a) is not str): raise TypeError("Argument 'a': expect string")
        # while this is wrong, because is is like identity equal operator
        # it is like 
        #     a is b
        #  is equivalent
        #     id(a) == id(b)
        # 
        # if (a is not str): raise TypeError("Argument 'a': expect string")
        if (not isinstance(a, str)): raise TypeError("Argument 'a': expect string")
        if (not (type(a) in [str, unicode])): raise TypeError("Argument 'a': expect string")
    pass





def initializeList(size, value=None):
#    l = [None] * size
    l = []
    for i in range(size):
        l.append(value)
    return l
    
def initializeList2(size, value=None):
    return [value] * size; 


def debugArgument(n, p, a):
    check(n, p, a)
    
    print "-n={0}".format(n)
    print "-p={0}".format(p)
    if (a is not None):
        print "-a={0}".format(a)

def parseArguments(args):
    assert(args is not None)
    
    if (args is None): raise ValueError("args: Invalid value!")
    
    # the first argument of args is the name of the program
    #    [0]: start_command.py
    # 
    # you can also skip the first argument of the sequence.
    
    a = dict({})
    print "len(args) = {0}".format(len(args))
    
    # let's drop the first element
    # it is the same as writting as 
    #   args[1::]
    #
    args = args[1:];

    for i in range(0, len(args), 2):
        if (args[i] == "-n"): a[args[i]] = int(args[i+1])
        elif (args[i] == "-p"): a[args[i]] = args[i+1]
        elif (args[i] == '-a'): a[args[i]] = args[i+1]
        else: raise ValueError("Invalid args: Unrecognized option {0}".format(args[i]))

    return a



def main():
    
    args = parseArguments(sys.argv);
 
    
    n = args["-n"] if args.has_key("-n") else None
    p = args["-p"] if args.has_key("-p") else None
    a = args["-a"] if args.has_key("-a") else None
    
     
    if (args is not None): 
        check(n, p, a);
    else:
        raise ValueError("Invalid Command Line: Unable to parse the CommandLine arguments")
    
    debugArgument(n, p, a)    
    
    v = list()

    for i in range(n):
        startProcess(v, p, a)
    
    time.sleep(n)
    
    # ask the user to input and ignore the input
    # there is an error to switch to use 
    #   input("Please enter any key to continue:")
    # but rather when you change to use 
    #   raw_input(Please enter any key to continue:")
    # then the problem goes away, 
    # need to find out the reason why
    # 
    raw_input("Please enter any key to continue:")
    
   
    
    for child in v:
        child.write("\n")
        # child.flush()
        child.close()
            
    print "Done!"


# see 
#   http://docs.python.org/library/multiprocessing.html
# this is a abstract layer over the Unix and Windows to do multiprocessing
# while you can use 
#   * queue
#   * pipe
# to communicate 
# 
#def startProcess(p, a):
#    parent_conn, child_conn = multiprocessing.Pipe()
#    p = multiprocessing.Process(target=childProcess, args=(child_conn,))
#    p.start()
#    print parent_conn.recv()
#    p.join()
#    
#def childProcess(conn):
#    conn.send([42, None, 'hello'])
#    conn.close()
    


def startProcess(v, p, a):
    """
    :param v: list of stdin PIPE to child 
    :param p: the child command's path
    :param a: the child command's argument
    :raise:
    :return: None
    :remark: `start_command | {child}`; the child read from PIPE and 
             and its stdin handler is stored in the list `v`;
             More details, please read 
                http://docs.python.org/library/subprocess.html#module-subprocess
             in section "17.1.4.2. Replacing shell pipeline"
    """
    commandline = [p]
    if (a is not None and a != ""):
        commandline.append(a)
    v.append(subprocess.Popen(commandline, shell=True, stdin=subprocess.PIPE).stdin)

if __name__ == '__main__':
    main()