Python utils.run_process函数代码示例

 def build_extension(self, extension):
     log.info("Building module %s..." % extension)
     
     # Prepare folders
     os.chdir(self.build_dir)
     module_build_dir = os.path.join(self.build_dir,  extension)
     if os.path.exists(module_build_dir):
         log.info("Deleting module build folder %s..." % module_build_dir)
         rmtree(module_build_dir)
     log.info("Creating module build folder %s..." % module_build_dir)
     os.mkdir(module_build_dir)
     os.chdir(module_build_dir)
     
     module_src_dir = os.path.join(self.sources_dir, extension)
     
     # Build module
     cmake_cmd = [
         "cmake",
         "-G", self.make_generator,
         "-DQT_QMAKE_EXECUTABLE=%s" % self.qmake_path,
         "-DBUILD_TESTS=False",
         "-DDISABLE_DOCSTRINGS=True",
         "-DCMAKE_BUILD_TYPE=%s" % self.build_type,
         "-DCMAKE_INSTALL_PREFIX=%s" % self.install_dir,
         module_src_dir
     ]
     if sys.version_info[0] > 2:
         cmake_cmd.append("-DPYTHON3_EXECUTABLE=%s" % self.py_executable)
         cmake_cmd.append("-DPYTHON3_INCLUDE_DIR=%s" % self.py_include_dir)
         cmake_cmd.append("-DPYTHON3_LIBRARY=%s" % self.py_library)
         if self.build_type.lower() == 'debug':
             cmake_cmd.append("-DPYTHON3_DBG_EXECUTABLE=%s" % self.py_executable)
             cmake_cmd.append("-DPYTHON3_DEBUG_LIBRARY=%s" % self.py_library)
     else:
         cmake_cmd.append("-DPYTHON_EXECUTABLE=%s" % self.py_executable)
         cmake_cmd.append("-DPYTHON_INCLUDE_DIR=%s" % self.py_include_dir)
         cmake_cmd.append("-DPYTHON_LIBRARY=%s" % self.py_library)
         if self.build_type.lower() == 'debug':
             cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY=%s" % self.py_library)
     if extension.lower() == "shiboken":
         cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes")
         if sys.version_info[0] > 2:
             cmake_cmd.append("-DUSE_PYTHON3=ON")
     
     log.info("Configuring module %s (%s)..." % (extension,  module_src_dir))
     if run_process(cmake_cmd, log) != 0:
         raise DistutilsSetupError("Error configuring " + extension)
     
     log.info("Compiling module %s..." % extension)
     if run_process([self.make_path], log) != 0:
         raise DistutilsSetupError("Error compiling " + extension)
     
     log.info("Installing module %s..." % extension)
     if run_process([self.make_path, "install/fast"], log) != 0:
         raise DistutilsSetupError("Error pseudo installing " + extension)
     
     os.chdir(self.script_dir)

def write(file_path, tag_list, attr_name='kMDItemUserTags'):
    """Writes the list of tags to xattr field of ``file_path``

    :param file_path: full path to file
    :type file_path: ``unicode``
    :param tag_list: values to write to attributes
    :type tag_list: ``list``
    :param attr_name: full name of OS X file metadata attribute
    :type attr_name: ``unicode``

    """
    tag_data = ['<string>{}</string>'.format(tag) for tag in tag_list]
    tag_data.insert(0, ('<!DOCTYPE plist PUBLIC'
                        '"-//Apple//DTD PLIST 1.0//EN"'
                        '"http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
                        '<plist version="1.0"><array>'))
    tag_data.append('</array></plist>')
    tag_text = ''.join(tag_data)

    xattr = "com.apple.metadata:{}".format(attr_name)
    # Other attributes you might want to try:
    # ['kMDItemOMUserTags', 'kOMUserTags',
    #  'kMDItemkeywords', 'kMDItemFinderComment']
    cmd = ['xattr',
           '-w',
           xattr,
           tag_text.encode("utf8"),
           file_path]
    return utils.run_process(cmd)

 def build_patchelf(self):
     if not sys.platform.startswith("linux"):
         return
     log.info("Building patchelf...")
     module_src_dir = os.path.join(self.sources_dir, "patchelf")
     build_cmd = ["g++", "%s/patchelf.cc" % (module_src_dir), "-o", "patchelf"]
     if run_process(build_cmd) != 0:
         raise DistutilsSetupError("Error building patchelf")

 def run(self):
     _install.run(self)
     # Custom script we run at the end of installing
     # If self.root has a value, it means we are being "installed" into
     # some other directory than Python itself (eg, into a temp directory
     # for bdist_wininst to use) - in which case we must *not* run our
     # installer
     if not self.dry_run and not self.root:
         filename = os.path.join(self.install_scripts, "pyside_postinstall.py")
         if not os.path.isfile(filename):
             raise RuntimeError("Can't find '%s'" % (filename,))
         print("Executing post install script '%s'..." % filename)
         cmd = [
             os.path.abspath(sys.executable),
             filename,
         ]
         run_process(cmd)

    def info(self):
        """Dictionary of metadata attribute information.

        :returns: `description`, `aliases`, `id`, and `name` of instance.
        :rtype: ``dict``

        """
        keys = ('id', 'name', 'description', 'aliases')
        item_cmd = "mdimport -A | grep '{}'".format(self.name)
        item_data = utils.run_process(item_cmd)
        if item_data:
            item_data = [item.replace("'", "")
                         for item in item_data[0].split('\t\t')]
            return dict(zip(keys, item_data))
        else:
            return item_data

def attributes_generator():
    """Generate dictionaries with data for all OS X metadata attributes

    :returns: data on all OS X metadata attributes
    :rtype: ``generator`` of ``dict``s

    """
    # get all OS X metadata attributes
    attributes = utils.run_process(['mdimport', '-A'])
    # prepare key names for the four columns
    keys = ('id', 'name', 'description', 'aliases')
    # create dicts, mapping ``keys`` to an item's columns
    for attribute in attributes:
        attribute_data = [item.replace("'", "")
                          for item in attribute.split('\t\t')]
        keyed_data = itertools.izip(keys, attribute_data)
        yield dict(keyed_data)

def list(file_path):
    """Wrapper for OS X `mdls` command.

    :param file_path: full path to file
    :type file_path: ``unicode``
    :returns: dictionary of metadata attributes and values
    :rtype: ``dict``

    """
    output = utils.run_process(['mdls', file_path])
    # get metadata into list, allowing for nested attributes
    md = [[y.strip()
           for y in line.split('=')]
          for line in output]
    # iterate over list to deal with nested attributes
    # then build dictionary
    listed_item, md_dict = [], {}
    for item in md:
        # item is pair
        if len(item) == 2:
            k, v = item
            # if second item is parens, then first is key
            if v == '(':
                listed_key = utils.clean_attribute(k)
            # else, it's a simple `key: value` pair
            else:
                # attempt to convert to `int`
                try:
                    val = int(v)
                except (ValueError, TypeError):
                    val = v.replace('"', '')
                # convert shell nulls to Python `None`
                if val in ('""', '(null)'):
                    val = None
                key = utils.clean_attribute(k)
                md_dict[key] = val
        # single item is part of a nested attribute
        elif len(item) == 1 and item[0] != ')':
            value = item[0].replace('"', '')
            listed_item.append(value)
        # single item marks end of a nested attribute
        elif len(item) == 1 and item[0] == ')':
            md_dict[listed_key] = listed_item
            listed_item = []
    return md_dict

def find(query_expression, only_in=None):
    """Wrapper for OS X `mdfind` command.

    :param query_expression: file metadata query expression
    :type query_expression: :class:`MDExpression` object or
        :class:`MDComparison` object.
    :param only_in: limit search scope to directory tree path
    :type only_in: ``unicode``
    :returns: full paths to files of any results
    :rtype: ``list``

    """
    cmd = ['mdfind']
    # add option to limit search scoe
    if only_in:
        cmd.append('-onlyin')
        cmd.append(only_in)
    # convert `query_expression` into file metadata query expression syntax
    query = "'" + unicode(query_expression) + "'"
    cmd.append(query)
    # run `mdfind` command as shell string, since otherwise it breaks
    #print(' '.join(cmd))
    return utils.run_process(' '.join(cmd))

    def build_extension(self, extension):
        log.info("Building module %s..." % extension)
        
        # Prepare folders
        os.chdir(self.build_dir)
        module_build_dir = os.path.join(self.build_dir,  extension)
        if os.path.exists(module_build_dir):
            log.info("Deleting module build folder %s..." % module_build_dir)
            rmtree(module_build_dir)
        log.info("Creating module build folder %s..." % module_build_dir)
        os.mkdir(module_build_dir)
        os.chdir(module_build_dir)
        
        module_src_dir = os.path.join(self.sources_dir, extension)
        
        # Build module
        cmake_cmd = [
            OPTION_CMAKE,
            "-G", self.make_generator,
            "-DQT_QMAKE_EXECUTABLE=%s" % self.qmake_path,
            "-DBUILD_TESTS=False",
            "-DDISABLE_DOCSTRINGS=True",
            "-DCMAKE_BUILD_TYPE=%s" % self.build_type,
            "-DCMAKE_INSTALL_PREFIX=%s" % self.install_dir,
            module_src_dir
        ]
        if sys.version_info[0] > 2:
            cmake_cmd.append("-DPYTHON3_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON3_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON3_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON3_DBG_EXECUTABLE=%s" % self.py_executable)
                cmake_cmd.append("-DPYTHON3_DEBUG_LIBRARY=%s" % self.py_library)
        else:
            cmake_cmd.append("-DPYTHON_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY=%s" % self.py_library)
            if sys.platform == "win32" and self.build_type.lower() == 'debug':
                cmake_cmd.append("-DCMAKE_DEBUG_POSTFIX=_d")
                
        if extension.lower() == "shiboken":
            cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes")
            if sys.version_info[0] > 2:
                cmake_cmd.append("-DUSE_PYTHON3=ON")
        elif sys.platform == 'darwin':
            # Work round cmake include problem
            # http://neilweisenfeld.com/wp/120/building-pyside-on-the-mac
            # https://groups.google.com/forum/#!msg/pyside/xciZZ4Hm2j8/CUmqfJptOwoJ
            cmake_cmd.append('-DALTERNATIVE_QT_INCLUDE_DIR=/Library/Frameworks')

        log.info("Configuring module %s (%s)..." % (extension,  module_src_dir))
        if run_process(cmake_cmd, log) != 0:
            raise DistutilsSetupError("Error configuring " + extension)
        
        log.info("Compiling module %s..." % extension)
        if run_process([self.make_path], log) != 0:
            raise DistutilsSetupError("Error compiling " + extension)
        
        if extension.lower() == "shiboken":
            log.info("Generating Shiboken documentation %s..." % extension)
            if run_process([self.make_path, "doc"], log) != 0:
                raise DistutilsSetupError("Error generating documentation " + extension)
        
        log.info("Installing module %s..." % extension)
        if run_process([self.make_path, "install/fast"], log) != 0:
            raise DistutilsSetupError("Error pseudo installing " + extension)
        
        os.chdir(self.script_dir)

        print("Option --version can not be used together with option --ignore-git")
        sys.exit(1)
    if not os.path.isdir(".git"):
        print("Option --version is available only when pyside-setup was cloned from git repository")
        sys.exit(1)
    if not OPTION_VERSION in submodules:
        print("""Invalid version specified %s
Use --list-versions option to get list of available versions""" % OPTION_VERSION)
        sys.exit(1)
    __version__ = OPTION_VERSION

# Initialize, pull and checkout submodules
if os.path.isdir(".git") and not OPTION_IGNOREGIT and not OPTION_ONLYPACKAGE:
    print("Initializing submodules for PySide version %s" % __version__)
    git_update_cmd = ["git", "submodule", "update", "--init"]
    if run_process(git_update_cmd) != 0:
        raise DistutilsSetupError("Failed to initialize the git submodules")
    git_pull_cmd = ["git", "submodule", "foreach", "git", "fetch", "origin"]
    if run_process(git_pull_cmd) != 0:
        raise DistutilsSetupError("Failed to initialize the git submodules")
    git_pull_cmd = ["git", "submodule", "foreach", "git", "pull", "origin", "master"]
    if run_process(git_pull_cmd) != 0:
        raise DistutilsSetupError("Failed to initialize the git submodules")
    submodules_dir = os.path.join(script_dir, "sources")
    for m in submodules[__version__]:
        module_name = m[0]
        module_version = m[1]
        print("Checking out submodule %s to branch %s" % (module_name, module_version))
        module_dir = os.path.join(submodules_dir, module_name)
        os.chdir(module_dir)
        git_checkout_cmd = ["git", "checkout", module_version]

 def rpath_cmd(srcpath):
     cmd = [patchelf_path, '--set-rpath', '$ORIGIN/', srcpath]
     if run_process(cmd) != 0:
         raise RuntimeError("Error patching rpath in " + srcpath)

    def build_extension(self, extension):
        # calculate the subrepos folder name
        folder = get_extension_folder(extension)

        log.info("Building module %s..." % extension)

        # Prepare folders
        os.chdir(self.build_dir)
        module_build_dir = os.path.join(self.build_dir,  extension)
        skipflag_file = module_build_dir + '-skip'
        if os.path.exists(skipflag_file):
            log.info("Skipping %s because %s exists" % (extension, skipflag_file))
            return
        if os.path.exists(module_build_dir):
            log.info("Deleting module build folder %s..." % module_build_dir)
            try:
                rmtree(module_build_dir)
            except Exception as e:
                print('***** problem removing "{}"'.format(module_build_dir))
                print('ignored error: {}'.format(e))
        log.info("Creating module build folder %s..." % module_build_dir)
        if not os.path.exists(module_build_dir):
            os.makedirs(module_build_dir)
        os.chdir(module_build_dir)

        module_src_dir = os.path.join(self.sources_dir, folder)

        # Build module
        cmake_cmd = [
            OPTION_CMAKE,
            "-G", self.make_generator,
            "-DQT_QMAKE_EXECUTABLE=%s" % self.qmake_path,
            "-DBUILD_TESTS=%s" % self.build_tests,
            "-DDISABLE_DOCSTRINGS=True",
            "-DQt5Help_DIR=%s" % self.qtinfo.docs_dir,
            "-DCMAKE_BUILD_TYPE=%s" % self.build_type,
            "-DCMAKE_INSTALL_PREFIX=%s" % self.install_dir,
            module_src_dir
        ]
        cmake_cmd.append("-DPYTHON_EXECUTABLE=%s" % self.py_executable)
        cmake_cmd.append("-DPYTHON_INCLUDE_DIR=%s" % self.py_include_dir)
        cmake_cmd.append("-DPYTHON_LIBRARY=%s" % self.py_library)
        if self.build_type.lower() == 'debug':
            cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY=%s" % self.py_library)

        if extension.lower() == "shiboken2":
            cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes")
            if sys.version_info[0] > 2:
                cmake_cmd.append("-DUSE_PYTHON_VERSION=3.4")

        if sys.platform == 'darwin':
            cmake_cmd.append('-DALTERNATIVE_QT_INCLUDE_DIR=' + self.qtinfo.headers_dir)

            if OPTION_OSXARCH:
                # also tell cmake which architecture to use
                cmake_cmd.append("-DCMAKE_OSX_ARCHITECTURES:STRING={}".format(OPTION_OSXARCH))

        log.info("Configuring module %s (%s)..." % (extension,  module_src_dir))
        if run_process(cmake_cmd) != 0:
            raise DistutilsSetupError("Error configuring " + extension)

        log.info("Compiling module %s..." % extension)
        cmd_make = [self.make_path]
        if OPTION_JOBS:
            cmd_make.append(OPTION_JOBS)
        if run_process(cmd_make) != 0:
            raise DistutilsSetupError("Error compiling " + extension)

        if extension.lower() == "shiboken2":
            log.info("Generating Shiboken documentation %s..." % extension)
            if run_process([self.make_path, "doc"]) != 0:
                raise DistutilsSetupError("Error generating documentation " + extension)

        log.info("Installing module %s..." % extension)
        if run_process([self.make_path, "install/fast"]) != 0:
            raise DistutilsSetupError("Error pseudo installing " + extension)

        os.chdir(self.script_dir)

elif format == "sff":
    if frg == "":
       infile = f1
    else:
       infile = frg

readpaths = []
filtreadpaths = []
for lib in readlibs:
   for read in lib.reads:
      readpaths.append("%s/Preprocess/in/"%(settings.rundir)+read.fname)
      filtreadpaths.append("%s/Preprocess/out/"%(settings.rundir)+read.fname)

if "Preprocess" in forcesteps:
   for path in readpaths:
      utils.run_process(settings, "touch %s"%(path),"RunPipeline")
   os.system("rm %s%sLogs%s*.ok"%(settings.rundir,os.sep,os.sep))
utils.Settings.readpaths = readpaths

asmfiles = []

for lib in readlibs:
    if "Assemble" in forcesteps:
        utils.run_process(settings, \
           "touch %s/Preprocess/out/lib%d.seq"%(settings.rundir,lib.id),\
           "RunPipeline")
    asmfiles.append("%s/Preprocess/out/lib%d.seq"%(settings.rundir,lib.id))

if "MapReads" in forcesteps:
    utils.run_process(settings, "rm %s/Assemble/out/*.contig.cvg"%(settings.rundir), "RunPipeline")
    utils.run_process(settings, "rm %s/Logs/mapreads.ok"%(settings.rundir), "RunPipeline")

    def build_extension(self, extension):
        log.info("Building module %s..." % extension)
        
        # Prepare folders
        os.chdir(self.build_dir)
        module_build_dir = os.path.join(self.build_dir,  extension)
        if os.path.exists(module_build_dir):
            log.info("Deleting module build folder %s..." % module_build_dir)
            rmtree(module_build_dir)
        log.info("Creating module build folder %s..." % module_build_dir)
        os.makedirs(module_build_dir)
        os.chdir(module_build_dir)
        
        module_src_dir = os.path.join(self.sources_dir, extension)
        
        # Build module
        cmake_cmd = [
            OPTION_CMAKE,
            "-G", self.make_generator,
            "-DQT_QMAKE_EXECUTABLE=%s" % self.qmake_path,
            "-DBUILD_TESTS=%s" % self.build_tests,
            "-DDISABLE_DOCSTRINGS=True",
            "-DCMAKE_BUILD_TYPE=%s" % self.build_type,
            "-DCMAKE_INSTALL_PREFIX=%s" % self.install_dir,
            module_src_dir
        ]
        if sys.version_info[0] > 2:
            cmake_cmd.append("-DPYTHON3_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON3_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON3_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON3_DBG_EXECUTABLE=%s" % self.py_executable)
                cmake_cmd.append("-DPYTHON3_DEBUG_LIBRARY=%s" % self.py_library)
        else:
            cmake_cmd.append("-DPYTHON_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY=%s" % self.py_library)

        if sys.platform == 'win32':
            cmake_cmd.append("-DCMAKE_DEBUG_POSTFIX=_d")

        cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes")
        if sys.version_info[0] > 2:
            cmake_cmd.append("-DUSE_PYTHON3=ON")
        
        if sys.platform == 'darwin':
            cmake_cmd.append('-DALTERNATIVE_QT_INCLUDE_DIR=' + self.qtinfo.headers_dir)
            
            if OPTION_OSXARCH:
                # also tell cmake which architecture to use 
                cmake_cmd.append("-DCMAKE_OSX_ARCHITECTURES:STRING={}".format(OPTION_OSXARCH))

        log.info("Configuring module %s (%s)..." % (extension,  module_src_dir))
        if run_process(cmake_cmd) != 0:
            raise DistutilsSetupError("Error configuring " + extension)
        
        log.info("Compiling module %s..." % extension)
        cmd_make = [self.make_path]
        if OPTION_JOBS:
            cmd_make.append(OPTION_JOBS)
        if run_process(cmd_make) != 0:
            raise DistutilsSetupError("Error compiling " + extension)
        
        log.info("Generating Shiboken documentation %s..." % extension)
        if run_process([self.make_path, "doc"]) != 0:
            raise DistutilsSetupError("Error generating documentation " + extension)
        
        log.info("Installing module %s..." % extension)
        if run_process([self.make_path, "install/fast"]) != 0:
            raise DistutilsSetupError("Error pseudo installing " + extension)
        
        os.chdir(self.script_dir)

    def build_extension(self, extension):
        log.info("Building module %s..." % extension)
        
        # Prepare folders
        os.chdir(self.build_dir)
        module_build_dir = os.path.join(self.build_dir,  extension)
        if os.path.exists(module_build_dir):
            log.info("Deleting module build folder %s..." % module_build_dir)
            rmtree(module_build_dir)
        log.info("Creating module build folder %s..." % module_build_dir)
        os.makedirs(module_build_dir)
        os.chdir(module_build_dir)
        
        module_src_dir = os.path.join(self.sources_dir, extension)
        
        # Build module
        cmake_cmd = [
            OPTION_CMAKE,
            "-G", self.make_generator,
            "-DQT_QMAKE_EXECUTABLE=%s" % self.qmake_path,
            "-DBUILD_TESTS=%s" % self.build_tests,
            "-DDISABLE_DOCSTRINGS=True",
            "-DCMAKE_BUILD_TYPE=%s" % self.build_type,
            "-DCMAKE_INSTALL_PREFIX=%s" % self.install_dir,
            module_src_dir
        ]
        if sys.version_info[0] > 2:
            cmake_cmd.append("-DPYTHON3_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON3_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON3_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON3_DBG_EXECUTABLE=%s" % self.py_executable)
                cmake_cmd.append("-DPYTHON3_DEBUG_LIBRARY=%s" % self.py_library)
        else:
            cmake_cmd.append("-DPYTHON_EXECUTABLE=%s" % self.py_executable)
            cmake_cmd.append("-DPYTHON_INCLUDE_DIR=%s" % self.py_include_dir)
            cmake_cmd.append("-DPYTHON_LIBRARY=%s" % self.py_library)
            if self.build_type.lower() == 'debug':
                cmake_cmd.append("-DPYTHON_DEBUG_LIBRARY=%s" % self.py_library)
            if sys.platform == "win32" and self.build_type.lower() == 'debug':
                cmake_cmd.append("-DCMAKE_DEBUG_POSTFIX=_d")
                
        if extension.lower() == "shiboken":
            cmake_cmd.append("-DCMAKE_INSTALL_RPATH_USE_LINK_PATH=yes")
            if sys.version_info[0] > 2:
                cmake_cmd.append("-DUSE_PYTHON3=ON")
        
        if sys.platform == 'darwin':
            if 'QTDIR' in os.environ:
                # If the user has QTDIR set, then use it as a prefix for an extra include path
                cmake_cmd.append('-DALTERNATIVE_QT_INCLUDE_DIR={0}/include'.format(os.environ['QTDIR']))
                #:{0}/lib  I had problems specifying both dirs.  Is it needed? Is there some other way to do it? --Robin
            else:
                # Otherwise assume it is a standard install and add the
                # Frameworks folder as a workaround for a cmake include problem
                # http://neilweisenfeld.com/wp/120/building-pyside-on-the-mac
                # https://groups.google.com/forum/#!msg/pyside/xciZZ4Hm2j8/CUmqfJptOwoJ
                cmake_cmd.append('-DALTERNATIVE_QT_INCLUDE_DIR=/Library/Frameworks')
            
            if OPTION_OSXARCH:
                # also tell cmake which architecture to use 
                cmake_cmd.append("-DCMAKE_OSX_ARCHITECTURES:STRING={}".format(OPTION_OSXARCH))

        log.info("Configuring module %s (%s)..." % (extension,  module_src_dir))
        if run_process(cmake_cmd, log) != 0:
            raise DistutilsSetupError("Error configuring " + extension)
        
        log.info("Compiling module %s..." % extension)
        cmd_make = [self.make_path]
        if OPTION_JOBS:
            cmd_make.append(OPTION_JOBS)
        if run_process(cmd_make, log) != 0:
            raise DistutilsSetupError("Error compiling " + extension)
        
        if extension.lower() == "shiboken":
            log.info("Generating Shiboken documentation %s..." % extension)
            if run_process([self.make_path, "doc"], log) != 0:
                raise DistutilsSetupError("Error generating documentation " + extension)
        
        log.info("Installing module %s..." % extension)
        if run_process([self.make_path, "install/fast"], log) != 0:
            raise DistutilsSetupError("Error pseudo installing " + extension)
        
        os.chdir(self.script_dir)