golden hour

/usr/lib64/python2.7/distutils/command

File/Folder	Size	Actions
__init__.py	822 B
__init__.pyc	665 B
__init__.pyo	665 B
bdist.py	5.46 KB
bdist.pyc	5.1 KB
bdist.pyo	5.1 KB
bdist_dumb.py	5.07 KB
bdist_dumb.pyc	4.92 KB
bdist_dumb.pyo	4.92 KB
bdist_msi.py	34.37 KB
bdist_msi.pyc	23.45 KB
bdist_msi.pyo	23.35 KB
bdist_rpm.py	20.55 KB
bdist_rpm.pyc	17.32 KB
bdist_rpm.pyo	17.24 KB
bdist_wininst.py	14.65 KB
bdist_wininst.pyc	10.55 KB
bdist_wininst.pyo	10.47 KB
build.py	5.31 KB
build.pyc	5.03 KB
build.pyo	5.03 KB
build_clib.py	7.94 KB
build_clib.pyc	6.28 KB
build_clib.pyo	6.28 KB
build_ext.py	31.75 KB
build_ext.py.debug-build	31.53 KB
build_ext.pyc	19.09 KB
build_ext.pyo	19.09 KB
build_py.py	15.92 KB
build_py.pyc	11.24 KB
build_py.pyo	11.17 KB
build_scripts.py	4.49 KB
build_scripts.pyc	4.43 KB
build_scripts.pyo	4.43 KB
check.py	5.43 KB
check.pyc	6.08 KB
check.pyo	6.08 KB
clean.py	2.75 KB
clean.pyc	3.1 KB
clean.pyo	3.1 KB
command_template	719 B
config.py	12.82 KB
config.pyc	12.39 KB
config.pyo	12.39 KB
install.py	25.65 KB
install.pyc	16.5 KB
install.pyo	16.5 KB
install_data.py	2.78 KB
install_data.pyc	3.09 KB
install_data.pyo	3.09 KB
install_egg_info.py	2.53 KB
install_egg_info.pyc	3.68 KB
install_egg_info.pyo	3.68 KB
install_headers.py	1.31 KB
install_headers.pyc	2.24 KB
install_headers.pyo	2.24 KB
install_lib.py	8.14 KB
install_lib.pyc	6.63 KB
install_lib.pyo	6.63 KB
install_scripts.py	2.02 KB
install_scripts.pyc	2.93 KB
install_scripts.pyo	2.93 KB
register.py	11.56 KB
register.pyc	9.98 KB
register.pyo	9.98 KB
sdist.py	18.12 KB
sdist.pyc	16.31 KB
sdist.pyo	16.31 KB
upload.py	6.84 KB
upload.pyc	6.13 KB
upload.pyo	6.13 KB
wininst-6.0.exe	60 KB
wininst-7.1.exe	64 KB
wininst-8.0.exe	60 KB
wininst-9.0-amd64.exe	218.5 KB
wininst-9.0.exe	191.5 KB

Edit: build_clib.py

"""distutils.command.build_clib

Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module."""

__revision__ = "$Id$"

# XXX this module has *lots* of code ripped-off quite transparently from
# build_ext.py -- not surprisingly really, as the work required to build
# a static library from a collection of C source files is not really all
# that different from what's required to build a shared object file from
# a collection of C source files.  Nevertheless, I haven't done the
# necessary refactoring to account for the overlap in code between the
# two modules, mainly because a number of subtle details changed in the
# cut 'n paste.  Sigh.

import os
from distutils.core import Command
from distutils.errors import DistutilsSetupError
from distutils.sysconfig import customize_compiler
from distutils import log

def show_compilers():
    from distutils.ccompiler import show_compilers
    show_compilers()

class build_clib(Command):

description = "build C/C++ libraries used by Python extensions"

user_options = [
        ('build-clib=', 'b',
         "directory to build C/C++ libraries to"),
        ('build-temp=', 't',
         "directory to put temporary build by-products"),
        ('debug', 'g',
         "compile with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c',
         "specify the compiler type"),
        ]

boolean_options = ['debug', 'force']

help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

def initialize_options(self):
        self.build_clib = None
        self.build_temp = None

# List of libraries to build
        self.libraries = None

# Compilation options for all libraries
        self.include_dirs = None
        self.define = None
        self.undef = None
        self.debug = None
        self.force = 0
        self.compiler = None

def finalize_options(self):
        # This might be confusing: both build-clib and build-temp default
        # to build-temp as defined by the "build" command.  This is because
        # I think that C libraries are really just temporary build
        # by-products, at least from the point of view of building Python
        # extensions -- but I want to keep my options open.
        self.set_undefined_options('build',
                                   ('build_temp', 'build_clib'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'))

self.libraries = self.distribution.libraries
        if self.libraries:
            self.check_library_list(self.libraries)

if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

# XXX same as for build_ext -- what about 'self.define' and
        # 'self.undef' ?

def run(self):
        if not self.libraries:
            return

# Yech -- this is cut 'n pasted from build_ext.py!
        from distutils.ccompiler import new_compiler
        self.compiler = new_compiler(compiler=self.compiler,
                                     dry_run=self.dry_run,
                                     force=self.force)
        customize_compiler(self.compiler)

if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name,value) in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)

self.build_libraries(self.libraries)

def check_library_list(self, libraries):
        """Ensure that the list of libraries is valid.

`library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(libraries, list):
            raise DistutilsSetupError, \
                  "'libraries' option must be a list of tuples"

for lib in libraries:
            if not isinstance(lib, tuple) and len(lib) != 2:
                raise DistutilsSetupError, \
                      "each element of 'libraries' must a 2-tuple"

name, build_info = lib

if not isinstance(name, str):
                raise DistutilsSetupError, \
                      "first element of each tuple in 'libraries' " + \
                      "must be a string (the library name)"
            if '/' in name or (os.sep != '/' and os.sep in name):
                raise DistutilsSetupError, \
                      ("bad library name '%s': " +
                       "may not contain directory separators") % \
                      lib[0]

if not isinstance(build_info, dict):
                raise DistutilsSetupError, \
                      "second element of each tuple in 'libraries' " + \
                      "must be a dictionary (build info)"

def get_library_names(self):
        # Assume the library list is valid -- 'check_library_list()' is
        # called from 'finalize_options()', so it should be!
        if not self.libraries:
            return None

lib_names = []
        for (lib_name, build_info) in self.libraries:
            lib_names.append(lib_name)
        return lib_names

def get_source_files(self):
        self.check_library_list(self.libraries)
        filenames = []
        for (lib_name, build_info) in self.libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError, \
                      ("in 'libraries' option (library '%s'), "
                       "'sources' must be present and must be "
                       "a list of source filenames") % lib_name

filenames.extend(sources)
        return filenames

def build_libraries(self, libraries):
        for (lib_name, build_info) in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError, \
                      ("in 'libraries' option (library '%s'), " +
                       "'sources' must be present and must be " +
                       "a list of source filenames") % lib_name
            sources = list(sources)

log.info("building '%s' library", lib_name)

# First, compile the source code to object files in the library
            # directory.  (This should probably change to putting object
            # files in a temporary build directory.)
            macros = build_info.get('macros')
            include_dirs = build_info.get('include_dirs')
            objects = self.compiler.compile(sources,
                                            output_dir=self.build_temp,
                                            macros=macros,
                                            include_dirs=include_dirs,
                                            debug=self.debug)

# Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(objects, lib_name,
                                            output_dir=self.build_clib,
                                            debug=self.debug)