Python windows.call_subprocess_Popen函数代码示例

 def set_version():
     p = call_subprocess_Popen([nvcc_path, '--version'],
                               stdout=subprocess.PIPE,
                               stderr=subprocess.PIPE)
     p.wait()
     s = p.stdout.readlines()[-1].split(',')[1].strip().split()
     assert s[0] == 'release'
     global nvcc_version
     nvcc_version = s[1]

    def set_version():
        p = call_subprocess_Popen([nvcc_path, '--version'],
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE)
        p.wait()

        ver_line = decode(p.stdout.readlines()[-1])
        build, version = ver_line.split(',')[1].strip().split()

        assert build == 'release'
        global nvcc_version
        nvcc_version = version

    def test_gxx_support():
        default_openmp = True
        try:
            code = """
            #include <omp.h>
    int main( int argc, const char* argv[] )
    {
            int res[10];

            for(int i=0; i < 10; i++){
                res[i] = i;
            }
    }
            """
            fd, path = tempfile.mkstemp(suffix='.c', prefix='test_omp_')
            dummy_stdin = open(os.devnull)
            try:
                os.write(fd, code)
                os.close(fd)
                fd = None
                proc = call_subprocess_Popen(['g++', '-fopenmp', path],
                                             stdout=subprocess.PIPE,
                                             stderr=subprocess.PIPE,
                                             stdin=dummy_stdin.fileno())
                proc.wait()
                if proc.returncode != 0:
                    default_openmp = False
            finally:
                del dummy_stdin
                # Ensure `fd` is closed before we remove the temporary file.
                try:
                    if fd is not None:
                        os.close(fd)
                finally:
                    os.remove(path)
        except OSError, e:
            return False

# The way to get FAST_RUN_NOGC is with the flag 'linker=c|py_nogc'.
# The old all capital letter way of working is deprecated as it is not
# scalable.
# Also, please be careful not to modify the first item in the enum when adding
# new modes, since it is the default mode.
AddConfigVar('mode',
        "Default compilation mode",
        EnumStr('Mode', 'ProfileMode', 'DebugMode', 'FAST_RUN',
                'FAST_COMPILE', 'PROFILE_MODE', 'DEBUG_MODE'),
        in_c_key=False)

enum = EnumStr("g++", "")

# Test whether or not g++ is present: disable C code if it is not.
try:
    rc = call_subprocess_Popen(['g++', '-v'])
except OSError:
    enum = EnumStr("")
    rc = 1
AddConfigVar('cxx',
             "The C++ compiler to use. Currently only g++ is"
             " supported, but supporting additional compilers should not be "
             "too difficult. "
             "If it is empty, no C++ code is compiled.",
             enum,
             in_c_key=False)
del enum

if rc == 0 and config.cxx != "":
    # Keep the default linker the same as the one for the mode FAST_RUN
    AddConfigVar('linker',

AddConfigVar('mode',
        "Default compilation mode",
        EnumStr('Mode', 'ProfileMode', 'DebugMode', 'FAST_RUN',
                'FAST_COMPILE', 'PROFILE_MODE', 'DEBUG_MODE'),
        in_c_key=False)

enum = EnumStr("g++", "")

# Test whether or not g++ is present: disable C code if it is not.
# Using the dummy file descriptor below is a workaround for a crash experienced
# in an unusual Python 2.4.4 Windows environment with the default stdin=None.
dummy_stdin = open(os.devnull)
try:
    try:
        rc = call_subprocess_Popen(['g++', '-v'], stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE,
                                   stdin=dummy_stdin).wait()
    except OSError:
        rc = 1
finally:
    dummy_stdin.close()
    del dummy_stdin
if rc == 0:
    # Keep the default linker the same as the one for the mode FAST_RUN
    AddConfigVar('linker',
                 ("Default linker used if the theano flags mode is Mode "
                  "or ProfileMode"),
                 EnumStr('cvm', 'c|py', 'py', 'c', 'c|py_nogc', 'c&py',
                     'vm', 'vm_nogc', 'cvm_nogc'),
                 in_c_key=False)
else:

import numpy

import theano
from theano.configparser import config, AddConfigVar, ConfigParam, StrParam
from theano.gof.utils import flatten
from theano.misc.windows import call_subprocess_Popen

# Using the dummy file descriptors below is a workaround for a crash
# experienced in an unusual Python 2.4.4 Windows environment with the default
# None values.
dummy_in = open(os.devnull)
dummy_err = open(os.devnull, 'w')
p = None
try:
    p = call_subprocess_Popen(['g++', '-dumpversion'],
                              stdout=subprocess.PIPE,
                              stdin=dummy_in.fileno(),
                              stderr=dummy_err.fileno())
    p.wait()
    gcc_version_str = p.stdout.readline().strip()
except OSError:
    # Typically means gcc cannot be found.
    gcc_version_str = 'GCC_NOT_FOUND'
del p
del dummy_in
del dummy_err

compiledir_format_dict = {"platform": platform.platform(),
                          "processor": platform.processor(),
                          "python_version": platform.python_version(),
                          "theano_version": theano.__version__,
                          "numpy_version": numpy.__version__,

    "mode",
    "Default compilation mode",
    EnumStr("Mode", "ProfileMode", "DebugMode", "FAST_RUN", "FAST_COMPILE", "PROFILE_MODE", "DEBUG_MODE"),
    in_c_key=False,
)

enum = EnumStr("g++", "")

# Test whether or not g++ is present: disable C code if it is not.
# Using the dummy file descriptor below is a workaround for a crash experienced
# in an unusual Python 2.4.4 Windows environment with the default stdin=None.
dummy_stdin = open(os.devnull)
try:
    try:
        rc = call_subprocess_Popen(
            ["g++", "-v"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=dummy_stdin
        ).wait()
    except OSError:
        rc = 1
finally:
    dummy_stdin.close()
    del dummy_stdin
if rc == 0:
    # Keep the default linker the same as the one for the mode FAST_RUN
    AddConfigVar(
        "linker",
        ("Default linker used if the theano flags mode is Mode " "or ProfileMode"),
        EnumStr("cvm", "c|py", "py", "c", "c|py_nogc", "c&py", "vm", "vm_nogc", "cvm_nogc"),
        in_c_key=False,
    )
else:

#.........这里部分代码省略.........
                if s in word:
                    return pos

        # finds last word of list l containing string s
        def getIndexOfLast(l, s):
            for pos, word in enumerate(reversed(l)):
                if s in word:
                    return len(l) - pos - 1

        # iterating through tests
        # initializing master profiling list and raw log
        prof_master_nosort = []
        prof_rawlog = []
        dummy_out = open(os.devnull, "w")
        path_rawlog = os.path.join(sav_dir, "timeprof_rawlog")
        stamp = str(datetime.datetime.now()) + "\n\n"
        f_rawlog = open(path_rawlog, "w")
        f_rawlog.write("TIME-PROFILING OF THEANO'S NOSETESTS" " (raw log)\n\n" + stamp)
        f_rawlog.flush()

        stamp = str(datetime.datetime.now()) + "\n\n"
        fields = "Fields: computation time; nosetests sequential id;" " test name; parent class (if any); outcome\n\n"
        path_nosort = os.path.join(sav_dir, "timeprof_nosort")
        f_nosort = open(path_nosort, "w")
        f_nosort.write("TIME-PROFILING OF THEANO'S NOSETESTS" " (by sequential id)\n\n" + stamp + fields)
        f_nosort.flush()
        for test_floor in xrange(1, n_tests + 1, batch_size):
            for test_id in xrange(test_floor, min(test_floor + batch_size, n_tests + 1)):
                # Print the test we will start in the raw log to help
                # debug tests that are too long.
                f_rawlog.write("\n%s Will run test #%d %s\n" % (time.ctime(), test_id, data["ids"][test_id]))
                f_rawlog.flush()

                proc = call_subprocess_Popen(
                    ([python, theano_nose, "-v", "--with-id"] + [str(test_id)] + argv + ["--disabdocstring"]),
                    # the previous option calls a custom Nosetests plugin
                    # precluding automatic sustitution of doc. string for
                    # test name in display
                    # (see class 'DisabDocString' in file theano-nose)
                    stderr=subprocess.PIPE,
                    stdout=dummy_out.fileno(),
                )

                # recovering and processing data from pipe
                err = proc.stderr.read()
                # print the raw log
                f_rawlog.write(err)
                f_rawlog.flush()

                # parsing the output
                l_err = err.split()
                try:
                    pos_id = getIndexOfFirst(l_err, "#")
                    prof_id = l_err[pos_id]
                    pos_dot = getIndexOfFirst(l_err, "...")
                    prof_test = ""
                    for s in l_err[pos_id + 1 : pos_dot]:
                        prof_test += s + " "
                    if "OK" in err:
                        pos_ok = getIndexOfLast(l_err, "OK")
                        if len(l_err) == pos_ok + 1:
                            prof_time = float(l_err[pos_ok - 1][0:-1])
                            prof_pass = "OK"
                        elif "SKIP" in l_err[pos_ok + 1]:
                            prof_time = 0.0
                            prof_pass = "SKIPPED TEST"

# new modes, since it is the default mode.
AddConfigVar(
    "mode",
    "Default compilation mode",
    EnumStr("Mode", "ProfileMode", "DebugMode", "FAST_RUN", "FAST_COMPILE", "PROFILE_MODE", "DEBUG_MODE"),
    in_c_key=False,
)

enum = EnumStr("g++", "")

# Test whether or not g++ is present: disable C code if it is not.
# Using the dummy file descriptor below is a workaround for a crash experienced
# in an unusual Python 2.4.4 Windows environment with the default stdin=None.
dummy_stdin = open(os.devnull)
try:
    call_subprocess_Popen("g++", stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=dummy_stdin.fileno())
    # Keep the default linker the same as the one for the mode FAST_RUN
    AddConfigVar(
        "linker",
        ("Default linker used if the theano flags mode is Mode " "or ProfileMode"),
        EnumStr("cvm", "c|py", "py", "c", "c|py_nogc", "c&py", "vm", "vm_nogc", "cvm_nogc"),
        in_c_key=False,
    )
except OSError:
    # g++ is not present, linker should default to python only
    AddConfigVar(
        "linker",
        ("Default linker used if the theano flags mode is Mode " "or ProfileMode"),
        EnumStr("py", "vm", "vm_nogc"),
        in_c_key=False,
    )